class GeneratorOutput: """ Main generator output options. :param max_line_length: Maximum line length :param package: Package name eg foo.bar.models :param format: Code generator output format name :param structure: Select an output structure :param docstring_style: Select a docstring style :param compound_fields: Use compound fields for repeating choices. Enable if elements ordering matters for your case. """ max_line_length: int = attribute(default=79) package: str = element(default="generated") format: str = element(default="dataclasses") structure: OutputStructure = element(default=OutputStructure.FILENAMES) docstring_style: DocstringStyle = element(default=DocstringStyle.RST) compound_fields: bool = element(default=False) def __post_init__(self): if self.format == "pydata": warnings.warn( "Output format 'pydata' renamed to 'dataclasses'", DeprecationWarning, ) self.format = "dataclasses"
class Alternative(AnnotationBase): """ Model representation of a schema xs:alternative element. :param type: QName :param test: an XPath expression :param simple_type: :param complex_type: """ type: Optional[str] = attribute() test: Optional[str] = attribute() simple_type: Optional[SimpleType] = element(name="simpleType") complex_type: Optional[ComplexType] = element(name="complexType") @property def real_name(self) -> str: if self.test: return text.snake_case(self.test) if self.id: return self.id return DEFAULT_ATTR_NAME @property def bases(self) -> Iterator[str]: if self.type: yield self.type
class GeneratorConfig: """ 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 """ class Meta: name = "Config" namespace = "http://pypi.org/project/xsdata" version: str = attribute(init=False, default=get_distribution("xsdata").version) output: GeneratorOutput = element(default_factory=GeneratorOutput) conventions: GeneratorConventions = element( default_factory=GeneratorConventions) aliases: GeneratorAliases = element(default_factory=GeneratorAliases) @classmethod def create(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")) return obj @classmethod def read(cls, path: Path) -> "GeneratorConfig": ctx = XmlContext( element_name_generator=text.pascal_case, attribute_name_generator=text.camel_case, ) config = ParserConfig(fail_on_unknown_properties=False) parser = XmlParser(context=ctx, config=config) return parser.from_path(path, cls) @classmethod def write(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"})
class SimpleContent(AnnotationBase): """ Model representation of a schema xs:simpleContent element. :param restriction: :param extension: """ restriction: Optional[Restriction] = element() extension: Optional[Extension] = element()
class PortTypeOperation(WsdlElement): """ :param input: :param output: :param faults: """ input: PortTypeMessage = element() output: PortTypeMessage = element() faults: List[PortTypeMessage] = array_element(name="fault")
class BindingOperation(ExtensibleElement): """ :param input: :param output: :param faults: """ input: BindingMessage = element() output: BindingMessage = element() faults: List[BindingMessage] = array_element(name="fault")
class Annotation(ElementBase): """ Model representation of a schema xs:annotation element. :param appinfo: :param documentations: :param any_attribute: any attributes with non-schema namespace """ appinfo: Optional[Appinfo] = element() documentations: Array[Documentation] = array_element(name="documentation") any_attribute: Optional["AnyAttribute"] = element(name="anyAttribute")
class List(AnnotationBase): """ Model representation of a schema xs:list element. :param simple_type: :param item_type: QName """ simple_type: Optional[SimpleType] = element(name="simpleType") item_type: str = attribute(name="itemType", default="") @property def is_attribute(self) -> bool: return True @property def real_name(self) -> str: return "value" @property def real_type(self) -> str: return self.item_type def get_restrictions(self) -> Dict[str, Anything]: return {"tokens": True}
class SimpleType(AnnotationBase): """ Model representation of a schema xs:simpleType element. :param name: NCName :param restriction: :param list: :param union: """ name: Optional[str] = attribute() restriction: Optional["Restriction"] = element() list: Optional["List"] = element() union: Optional["Union"] = element() @property def is_attribute(self) -> bool: return True @property def is_enumeration(self) -> bool: return self.restriction is not None and len( self.restriction.enumerations) > 0 @property def real_name(self) -> str: if self.name: return self.name return "value" @property def real_type(self) -> str: if not self.is_enumeration and self.restriction: return self.restriction.real_type if self.list: return self.list.real_type if self.union and self.union.member_types: return self.union.member_types return "" def get_restrictions(self) -> Dict[str, Anything]: if self.restriction: return self.restriction.get_restrictions() if self.list: return self.list.get_restrictions() return {}
class Attribute(AnnotationBase): """ Model representation of a schema xs:attribute element. :param default: string :param fixed: string :param form: qualified | unqualified :param name: NCName :param ref: QName :param type: QName :param target_namespace: anyURI :param simple_type: :param use: (optional | prohibited | required) : optional """ default: Optional[str] = attribute() fixed: Optional[str] = attribute() form: Optional[FormType] = attribute() name: Optional[str] = attribute() ref: Optional[str] = attribute() type: Optional[str] = attribute() target_namespace: Optional[str] = attribute(name="targetNamespace") simple_type: Optional[SimpleType] = element(name="simpleType") use: Optional[UseType] = attribute(default=UseType.OPTIONAL) @property def is_attribute(self) -> bool: return True @property def real_type(self) -> str: if self.simple_type: return self.simple_type.real_type if self.type: return self.type if self.ref: return self.ref return "" def get_restrictions(self) -> Dict[str, Anything]: restrictions = {} if self.use == UseType.REQUIRED: restrictions.update({ "min_occurs": 1, "max_occurs": 1, "required": True }) elif self.use == UseType.PROHIBITED: restrictions.update({"prohibited": True}) if self.simple_type: restrictions.update(self.simple_type.get_restrictions()) if self.type and self.type in self.token_types: restrictions["tokens"] = True return restrictions
class WsdlElement: """ :param name: :param documentation: """ name: str = attribute() documentation: Optional[Documentation] = element() ns_map: Dict = field(default_factory=dict, init=False)
class Types: """ :param schemas: :param documentation: """ schemas: List[Schema] = array_element(name="schema", namespace=Namespace.XS.uri) documentation: Optional[Documentation] = element()
class SimpleType(AnnotationBase): """ Model representation of a schema xs:simpleType element. :param name: NCName :param restriction: :param list: :param union: """ name: Optional[str] = attribute() restriction: Optional["Restriction"] = element() list: Optional["List"] = element() union: Optional["Union"] = element() @property def is_attribute(self) -> bool: return True @property def is_enumeration(self) -> bool: return self.restriction is not None and len(self.restriction.enumerations) > 0 @property def real_name(self) -> str: if self.name: return self.name return DEFAULT_ATTR_NAME @property def attr_types(self) -> Iterator[str]: if not self.is_enumeration and self.restriction: yield from self.restriction.attr_types elif self.list: yield from self.list.attr_types elif self.union: yield from self.union.bases def get_restrictions(self) -> Dict[str, Anything]: if self.restriction: return self.restriction.get_restrictions() if self.list: return self.list.get_restrictions() return {}
class ComplexType(AnnotationBase): """ Model representation of a schema xs:complexType element. :param name: NCName :param block: (#all | List of (extension | restriction)) :param final: (#all | List of (extension | restriction)) :param simple_content: :param complex_content: :param group: :param all: :param choice: :param sequence: :param any_attribute: :param open_content: :param attributes: :param attribute_groups: :param assertion: :param abstract: :param mixed: :param default_attributes_apply: """ name: Optional[str] = attribute() block: Optional[str] = attribute() final: Optional[str] = attribute() simple_content: Optional[SimpleContent] = element(name="simpleContent") complex_content: Optional[ComplexContent] = element(name="complexContent") group: Optional[Group] = element() all: Optional[All] = element() choice: Optional[Choice] = element() sequence: Optional[Sequence] = element() any_attribute: Optional[AnyAttribute] = element(name="anyAttribute") open_content: Optional[OpenContent] = element(name="openContent") attributes: Array[Attribute] = array_element(name="attribute") attribute_groups: Array[AttributeGroup] = array_element( name="attributeGroup") assertion: Array[Assertion] = array_element(name="assert") abstract: bool = attribute(default=False) mixed: bool = attribute(default=False) default_attributes_apply: bool = attribute(default=True, name="defaultAttributesApply") @property def is_mixed(self) -> bool: if self.mixed: return True if self.complex_content: return self.complex_content.mixed return False
class Attribute(AnnotationBase): """ Model representation of a schema xs:attribute element. :param default: string :param fixed: string :param form: qualified | unqualified :param name: NCName :param ref: QName :param type: QName :param target_namespace: anyURI :param simple_type: :param use: (optional | prohibited | required) : optional """ default: Optional[str] = attribute() fixed: Optional[str] = attribute() form: Optional[FormType] = attribute() name: Optional[str] = attribute() ref: Optional[str] = attribute() type: Optional[str] = attribute() target_namespace: Optional[str] = attribute(name="targetNamespace") simple_type: Optional[SimpleType] = element(name="simpleType") use: Optional[UseType] = attribute(default=UseType.OPTIONAL) @property def bases(self) -> Iterator[str]: if self.type: yield self.type @property def is_attribute(self) -> bool: return True @property def attr_types(self) -> Iterator[str]: if self.simple_type: yield from self.simple_type.attr_types elif self.type: yield self.type elif self.ref: yield self.ref def get_restrictions(self) -> Dict[str, Anything]: restrictions = {} if self.use == UseType.REQUIRED: restrictions.update({"required": True}) elif self.use == UseType.PROHIBITED: restrictions.update({"prohibited": True}) if self.simple_type: restrictions.update(self.simple_type.get_restrictions()) return restrictions
class OpenContent(AnnotationBase): """ Model representation of a schema xs:openContent element. :param applies_to_empty: default false :param mode: (none | interleave | suffix) : interleave :param any: """ applies_to_empty: bool = attribute(default=False, name="appliesToEmpty") mode: Mode = attribute(default=Mode.INTERLEAVE) any: Any = element()
class GeneratorConventions: """ 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"))
class GeneratorOutput: """ Main generator output options. :param wsdl: Enable wsdl mode :param max_line_length: Maximum line length :param package: Package name eg foo.bar.models :param format: Select an output format :param structure: Select an output structure :param docstring_style: Select a docstring style :param compound_fields: Use compound fields for repeating choices. Enable if elements ordering matters for your case. """ wsdl: bool = attribute(default=False) max_line_length: int = attribute(default=79) package: str = element(default="generated") format: OutputFormat = element(default=OutputFormat.DATACLASS) structure: OutputStructure = element(default=OutputStructure.FILENAMES) docstring_style: DocstringStyle = element(default=DocstringStyle.RST) compound_fields: bool = element(default=False)
class Extension(AnnotationBase): """ Model representation of a schema xs:extension element. :param base: QName :param group: :param all: :param choice: :param sequence: :param any_attribute: any attributes with non-schema namespace :param open_content: :param attributes: :param attribute_groups: :param assertions: """ base: Optional[str] = attribute() group: Optional[Group] = element() all: Optional[All] = element() choice: Optional[Choice] = element() sequence: Optional[Sequence] = element() any_attribute: Optional[AnyAttribute] = element(name="anyAttribute") open_content: Optional[OpenContent] = element(name="openContent") attributes: Array[Attribute] = array_element(name="attribute") attribute_groups: Array[AttributeGroup] = array_element( name="attributeGroup") assertions: Array[Assertion] = array_element(name="assert") @property def extensions(self) -> Iterator[str]: if self.base: yield self.base
class Definitions(ExtensibleElement, ModuleMixin): """ :param types: :param imports: :param messages: :param port_types: :param bindings: :param services: :param extended: """ class Meta: name = "definitions" namespace = "http://schemas.xmlsoap.org/wsdl/" target_namespace: Optional[str] = attribute(name="targetNamespace") types: Optional[Types] = element() imports: List[Import] = array_element(name="import") messages: List[Message] = array_element(name="message") port_types: List[PortType] = array_element(name="portType") bindings: List[Binding] = array_element(name="binding") services: List[Service] = array_element(name="service") location: Optional[str] = field(default=None) @property def schemas(self): if self.types: yield from self.types.schemas def find_binding(self, name: str) -> Binding: return find_or_die(self.bindings, name, "Binding") def find_message(self, name: str) -> Message: return find_or_die(self.messages, name, "Message") def find_port_type(self, name: str) -> PortType: return find_or_die(self.port_types, name, "PortType") def merge(self, source: "Definitions"): if not self.types: self.types = source.types elif source.types: self.types.schemas.extend(source.types.schemas) self.messages.extend(source.messages) self.port_types.extend(source.port_types) self.bindings.extend(source.bindings) self.services.extend(source.services) self.extended.extend(source.extended) def included(self) -> Iterator[Import]: yield from self.imports
class Key(AnnotationBase): """ Model representation of a schema xs:key element. :param name: NCName :param ref: QName :param selector: :param fields: """ name: Optional[str] = attribute() ref: Optional[str] = attribute() selector: Optional[Selector] = element() fields: Array[Selector] = array_element(name="field")
class Appinfo(ElementBase): """ Model representation of a schema xs:appinfo element. :param lang: language :param source: anyURI :param attributes: any attributes with non-schema namespace """ class Meta: mixed = True source: Optional[str] = attribute() elements: Array[object] = array_any_element() any_attribute: Optional["AnyAttribute"] = element(name="anyAttribute")
class Group(AnnotationBase): """ Model representation of a schema xs:group element. :param name: NCName :param ref: QName :param min_occurs: nonNegativeInteger : 1 :param max_occurs: (nonNegativeInteger | unbounded) : 1 :param all: :param choice: :param sequence: """ name: Optional[str] = attribute() ref: str = attribute(default="") min_occurs: int = attribute(default=1, name="minOccurs") max_occurs: UnionType[int, str] = attribute(default=1, name="maxOccurs") all: Optional[All] = element() choice: Optional[Choice] = element() sequence: Optional[Sequence] = element() @property def is_attribute(self) -> bool: return True @property def attr_types(self) -> Iterator[str]: if self.ref: yield self.ref def get_restrictions(self) -> Dict[str, Anything]: max_occurs = sys.maxsize if self.max_occurs == "unbounded" else self.max_occurs return { "min_occurs": self.min_occurs, "max_occurs": max_occurs, }
class Documentation(ElementBase): """ Model representation of a schema xs:documentation element. :param lang: language :param source: anyURI :param elements: ({any})* :param attributes: any attributes with non-schema namespace """ lang: Optional[str] = attribute() source: Optional[str] = attribute() elements: Array[object] = array_any_element(mixed=True) attributes: Optional["AnyAttribute"] = element() def tostring(self) -> Optional[str]: xml = docstring_serializer.render(Docstring(self.elements)).split( "\n", 1) return textwrap.dedent(clean_html(xml[1])[5:-7]).strip()
class AnnotationBase(ElementBase): """ Base Class for elements that can contain annotations. :param id: ID :param annotations: :param any_attribute: any attributes with non-schema namespace """ id: Optional[str] = attribute() annotations: Array[Annotation] = array_element(name="annotation") any_attribute: Optional["AnyAttribute"] = element(name="anyAttribute") @property def display_help(self) -> Optional[str]: help_str = "\n".join( documentation.tostring() or "" for annotation in self.annotations for documentation in annotation.documentations).strip() return help_str or None
class Documentation(ElementBase): """ Model representation of a schema xs:documentation element. :param lang: language :param source: anyURI :param elements: ({any})* :param attributes: any attributes with non-schema namespace """ lang: Optional[str] = attribute() source: Optional[str] = attribute() elements: Array[object] = array_any_element(mixed=True) attributes: Optional["AnyAttribute"] = element() def tostring(self) -> Optional[str]: obj = Docstring(self.elements) ns_map = {None: "http://www.w3.org/1999/xhtml"} xml = docstring_serializer.render(obj, ns_map=ns_map) start = xml.find(">") + 1 end = xml.rfind("<") return textwrap.dedent(xml[start:end]).strip()
class Restriction(AnnotationBase): """ Model representation of a schema xs:restriction element. :param base: QName :param group: :param all: :param choice: :param sequence: :param open_content: :param attributes: :param attribute_groups: :param enumerations: :param asserts: :param assertions: :param any_element: :param min_exclusive: :param min_inclusive: :param min_length: :param max_exclusive: :param max_inclusive: :param max_length: :param total_digits: :param fraction_digits: :param length: :param white_space: :param patterns: :param explicit_timezone: :param simple_type: """ base: Optional[str] = attribute() group: Optional[Group] = element() all: Optional[All] = element() choice: Optional[Choice] = element() sequence: Optional[Sequence] = element() open_content: Optional[OpenContent] = element(name="openContent") attributes: Array[Attribute] = array_element(name="attribute") attribute_groups: Array[AttributeGroup] = array_element( name="attributeGroup") enumerations: Array[Enumeration] = array_element(name="enumeration") asserts: Array[Assertion] = array_element(name="assert") assertions: Array[Assertion] = array_element(name="assertion") any_element: Array[object] = array_any_element() min_exclusive: Optional[MinExclusive] = element(name="minExclusive") min_inclusive: Optional[MinInclusive] = element(name="minInclusive") min_length: Optional[MinLength] = element(name="minLength") max_exclusive: Optional[MaxExclusive] = element(name="maxExclusive") max_inclusive: Optional[MaxInclusive] = element(name="maxInclusive") max_length: Optional[MaxLength] = element(name="maxLength") total_digits: Optional[TotalDigits] = element(name="totalDigits") fraction_digits: Optional[FractionDigits] = element(name="fractionDigits") length: Optional[Length] = element() white_space: Optional[WhiteSpace] = element(name="whiteSpace") patterns: Array[Pattern] = array_element(name="pattern") explicit_timezone: Optional[ExplicitTimezone] = element( name="explicitTimezone") simple_type: Optional[SimpleType] = element(name="simpleType") @property def real_type(self) -> str: if self.simple_type: return self.simple_type.real_type if self.enumerations: return "" if self.base: return self.base return "" @property def real_name(self) -> str: return "value" @property def extensions(self) -> Iterator[str]: if self.base: yield self.base def get_restrictions(self) -> Dict[str, Anything]: restrictions = {} if self.simple_type: restrictions.update(self.simple_type.get_restrictions()) keys = ( "min_exclusive", "min_inclusive", "min_length", "max_exclusive", "max_inclusive", "max_length", "total_digits", "fraction_digits", "length", "white_space", "explicit_timezone", ) restrictions.update({ key: getattr(self, key).value for key in keys if getattr(self, key) is not None }) if self.patterns: restrictions["pattern"] = "|".join( [pattern.value for pattern in self.patterns]) if self.base and self.base in self.token_types: restrictions["tokens"] = True return restrictions
class Schema(SchemaLocation, ModuleMixin): """ Model representation of a schema xs:schema element. :param target: :param block_default: (#all | List of (extension | restriction | substitution)) :param default_attributes: QName :param final_default: (#all | List of extension | restriction | list | union) : '' :param target_namespace: anyURI :param version: token :param xmlns: :param element_form_default: (qualified | unqualified) : unqualified :param attribute_form_default: (qualified | unqualified) : unqualified :param default_open_content: :param imports: :param redefines: :param overrides: :param annotations: :param simple_types: :param complex_types: :param groups: :param attribute_groups: :param elements: :param attributes: :param notations: """ class Meta: name = "schema" namespace = Namespace.XS.uri target: Optional[str] = attribute() block_default: Optional[str] = attribute(name="blockDefault") default_attributes: Optional[str] = attribute(name="defaultAttributes") final_default: Optional[str] = attribute(name="finalDefault") target_namespace: Optional[str] = attribute(name="targetNamespace") version: Optional[str] = attribute() xmlns: Optional[str] = attribute() element_form_default: FormType = attribute(default=FormType.UNQUALIFIED, name="elementFormDefault") attribute_form_default: FormType = attribute(default=FormType.UNQUALIFIED, name="attributeFormDefault") default_open_content: Optional[DefaultOpenContent] = element( name="defaultOpenContent") includes: Array[Include] = array_element(name="include") imports: Array[Import] = array_element(name="import") redefines: Array[Redefine] = array_element(name="redefine") overrides: Array[Override] = array_element(name="override") annotations: Array[Annotation] = array_element(name="annotation") simple_types: Array[SimpleType] = array_element(name="simpleType") complex_types: Array[ComplexType] = array_element(name="complexType") groups: Array[Group] = array_element(name="group") attribute_groups: Array[AttributeGroup] = array_element( name="attributeGroup") elements: Array[Element] = array_element(name="element") attributes: Array[Attribute] = array_element(name="attribute") notations: Array[Notation] = array_element(name="notation") def included( self) -> Iterator[UnionType[Import, Include, Redefine, Override]]: yield from self.imports yield from self.includes yield from self.redefines yield from self.overrides
class Root: item: Union[int, Item] = element()
class Root: item: Union[str, int, Item2, Item] = element()