[docs]classStructureStyle(Enum):""" Code writer output structure strategies. :cvar FILENAMES: filenames: groups classes by the schema location :cvar NAMESPACES: namespaces: group classes by the target namespace :cvar CLUSTERS: clusters: group by strong connected dependencies :cvar SINGLE_PACKAGE: single-package: group all classes together :cvar NAMESPACE_CLUSTERS: namespace-clusters: group by strong connected dependencies and namespaces """FILENAMES="filenames"NAMESPACES="namespaces"CLUSTERS="clusters"SINGLE_PACKAGE="single-package"NAMESPACE_CLUSTERS="namespace-clusters"
[docs]@dataclassclassOutputFormat:""" Output format options. :param value: Output format name, default: dataclasses :param repr: Generate __repr__ method, default: true :param eq: Generate __eq__ method, default: true :param order: Generate __lt__, __le__, __gt__, and __ge__ methods, default: false :param unsafe_hash: Generate __hash__ method if not frozen, default: false :param frozen: Enable read only properties, default false :param slots: Enable __slots__, default: false, python>=3.10 Only :param kw_only: Enable keyword only arguments, default: false, python>=3.10 Only """value:str=field(default="dataclasses")repr:bool=attribute(default=True)eq:bool=attribute(default=True)order:bool=attribute(default=False)unsafe_hash:bool=attribute(default=False)frozen:bool=attribute(default=False)slots:bool=attribute(default=False)kw_only:bool=attribute(default=False)def__post_init__(self):self.validate()defvalidate(self):ifself.orderandnotself.eq:raiseGeneratorConfigError("eq must be true if order is true")ifself.value=="dataclasses"andsys.version_info<(3,10):ifself.slots:self.slots=Falsewarnings.warn("slots requires python >= 3.10, reverting...",CodeGenerationWarning,)ifself.kw_only:self.kw_only=Falsewarnings.warn("kw_only requires python >= 3.10, reverting...",CodeGenerationWarning,)
[docs]@dataclassclassGeneratorOutput:""" Main generator output options. :param package: Target package, default: generated :param format: Output format :param structure_style: Output structure style, default: filenames :param docstring_style: Docstring style, default: reStructuredText :param relative_imports: Use relative imports, default: false :param compound_fields: Use compound fields for repeatable elements, default: false :param max_line_length: Adjust the maximum line length, default: 79 """package:str=element(default="generated")format:OutputFormat=element(default_factory=OutputFormat)structure_style:StructureStyle=element(default=StructureStyle.FILENAMES,name="Structure")docstring_style:DocstringStyle=element(default=DocstringStyle.RST)relative_imports:bool=element(default=False)compound_fields:bool=element(default=False)max_line_length:int=attribute(default=79)defupdate(self,**kwargs:Any):objects.update(self,**kwargs)self.format.validate()
[docs]@dataclassclassNameConvention:""" Name convention model. :param case: Naming scheme, eg camelCase, snakeCase :param safe_prefix: A prefix to be prepended into names that match one of the reserved words: and, except, lambda, with, as, finally, nonlocal, while, assert, false, none, yield, break, for, not, class, from, or, continue, global, pass, def, if, raise, del, import, return, elif, in, true, else, is, try, str, int, bool, float, list, optional, dict, field """case:NameCase=attribute(optional=False)safe_prefix:str=attribute(optional=False)
[docs]@dataclassclassGeneratorConventions:""" Generator global naming conventions. :param class_name: Class naming conventions. :param field_name: Field naming conventions. :param module_name: Module naming conventions. :param package_name: Package naming conventions. """class_name:NameConvention=element(default_factory=lambda:NameConvention(NameCase.PASCAL,"type"))field_name:NameConvention=element(default_factory=lambda:NameConvention(NameCase.SNAKE,"value"))constant_name:NameConvention=element(default_factory=lambda:NameConvention(NameCase.SCREAMING_SNAKE,"value"))module_name:NameConvention=element(default_factory=lambda:NameConvention(NameCase.SNAKE,"mod"))package_name:NameConvention=element(default_factory=lambda:NameConvention(NameCase.SNAKE,"pkg"))
[docs]@dataclassclassGeneratorAlias:""" Define an alias for a module, package, class and field Alias definition model. Each alias has a source attribute that refers to the original name in the schema definition and the target attribute for output name. For package and module aliases the source refers to the schema filename or target namespace depending the selected output structure. :param source: The source name from schema definition :param target: The target name of the object. """source:str=attribute(required=True)target:str=attribute(required=True)
[docs]@dataclassclassGeneratorAliases:""" Generator aliases for classes, fields, packages and modules that bypass the global naming conventions. .. warning:: The generator doesn't validate aliases. :param class_name: list of class name aliases :param field_name: list of field name aliases :param package_name: list of package name aliases :param module_name: list of module name aliases """class_name:List[GeneratorAlias]=array_element()field_name:List[GeneratorAlias]=array_element()package_name:List[GeneratorAlias]=array_element()module_name:List[GeneratorAlias]=array_element()
[docs]@dataclassclassGeneratorConfig:""" Generator configuration binding model. :cvar version: xsdata version number the config was created/updated :param output: output options :param conventions: generator conventions :param aliases: generator aliases """classMeta:name="Config"namespace="http://pypi.org/project/xsdata"version:str=attribute(init=False,default=__version__)output:GeneratorOutput=element(default_factory=GeneratorOutput)conventions:GeneratorConventions=element(default_factory=GeneratorConventions)aliases:GeneratorAliases=element(default_factory=GeneratorAliases)@classmethoddefcreate(cls)->"GeneratorConfig":obj=cls()obj.aliases.class_name.append(GeneratorAlias("fooType","Foo"))obj.aliases.class_name.append(GeneratorAlias("ABCSomething","ABCSomething"))obj.aliases.field_name.append(GeneratorAlias("ChangeofGauge","change_of_gauge"))obj.aliases.package_name.append(GeneratorAlias("http://www.w3.org/1999/xhtml","xtml"))obj.aliases.module_name.append(GeneratorAlias("2010.1","2020a"))returnobj@classmethoddefread(cls,path:Path)->"GeneratorConfig":ifnotpath.exists():returncls()ctx=XmlContext(element_name_generator=text.pascal_case,attribute_name_generator=text.camel_case,)config=ParserConfig(fail_on_unknown_properties=False,fail_on_converter_warnings=True,)parser=XmlParser(context=ctx,config=config)returnparser.from_path(path,cls)@classmethoddefwrite(cls,output:TextIO,obj:"GeneratorConfig"):ctx=XmlContext(element_name_generator=text.pascal_case,attribute_name_generator=text.camel_case,)config=SerializerConfig(pretty_print=True)serializer=XmlSerializer(context=ctx,config=config,writer=XmlEventWriter)serializer.write(output,obj,ns_map={None:"http://pypi.org/project/xsdata"})