xsdata.resolver module

class xsdata.resolver.DependenciesResolver(packages=<factory>, aliases=<factory>, imports=<factory>)

Bases: object

Parameters

• packages (Dict[QName, str]) –

• aliases (Dict[QName, str]) –

• imports (List[Package]) –

packages: Dict[QName, str] = None

aliases: Dict[QName, str] = None

imports: List[Package] = None

class_list: List[QName] = None

class_map: Dict[QName, Class] = None

package: str = None

process(classes)

Resolve the dependencies for the given list of classes and the target package.

Reset aliases and imports from any previous runs keep the record of the processed class names

Parameters

classes (List[Class]) –

sorted_imports()

Return a new sorted by name list of import packages.

Return type

List[Package]

sorted_classes()

Return an iterator of classes property sorted for generation and apply import aliases.

Return type

List[Class]

apply_aliases(obj)

Walk the attributes tree and set the type aliases.

Parameters

obj (Class) –

resolve_imports()

Walk the import qualified names, check for naming collisions and add the necessary code generator import instance.

add_import(qname, package, exists=False)

Append an import package to the list of imports with any if necessary aliases if the import name exists in the local module.

Parameters

• qname (QName) –

• package (str) –

• exists (bool) –

find_package(qname)

Return the package name for the given qualified class name.

Raises

ResolverValueError – if name doesn’t exist.

Parameters

qname (QName) –

Return type

str

import_classes()

Return a list of class that need to be imported.

Return type

List[QName]

static create_class_list(classes)

Use topology sort to return a flat list for all the dependencies.

Parameters

classes (List[Class]) –

Return type

List[Class]

static create_class_map(classes)

Index the list of classes by name.

Parameters

classes (List[Class]) –

Return type

Dict[QName, Class]