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 Choice(AnnotationBase): """ Model representation of a schema xs:choice element. :param min_occurs: nonNegativeInteger : 1 :param max_occurs: (nonNegativeInteger | unbounded) : 1 :param elements: :param groups: :param choices: :param sequences: :param any: """ min_occurs: int = attribute(default=1, name="minOccurs") max_occurs: UnionType[int, str] = attribute(default=1, name="maxOccurs") elements: Array["Element"] = array_element(name="element") groups: Array["Group"] = array_element(name="group") choices: Array["Choice"] = array_element(name="choice") sequences: Array[Sequence] = array_element(name="sequence") any: Array["Any"] = array_element() def get_restrictions(self) -> Dict[str, Anything]: min_occurs = self.min_occurs if self.min_occurs > 1 else 0 max_occurs = sys.maxsize if self.max_occurs == "unbounded" else self.max_occurs return { "choice": str(id(self)), "min_occurs": min_occurs, "max_occurs": max_occurs, }
class Annotation(ElementBase): """ Model representation of a schema xs:annotation element. :param appinfos: :param documentations: :param any_attribute: any attributes with non-schema namespace """ appinfos: Array[Appinfo] = array_element(name="appinfo") documentations: Array[Documentation] = array_element(name="documentation") any_attribute: Optional["AnyAttribute"] = element(name="anyAttribute")
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 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 Redefine(SchemaLocation): """ Model representation of a schema xs:redefine element. :param schema_location: anyURI :param simple_types: :param complex_types: :param groups: :param attribute_groups: """ schema_location: Optional[str] = attribute(name="schemaLocation") 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")
class Types: """ :param schemas: :param documentation: """ schemas: List[Schema] = array_element(name="schema", namespace=Namespace.XS.uri) documentation: Optional[Documentation] = element()
class PortType(ExtensibleElement): """ :param operations: """ operations: List[PortTypeOperation] = array_element(name="operation") def find_operation(self, name: str) -> PortTypeOperation: return find_or_die(self.operations, name, "PortTypeOperation")
class GeneratorAliases: """ 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()
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 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 AttributeGroup(AnnotationBase): """ Model representation of a schema xs:attributeGroup element. :param name: NCName :param ref: QName :param attributes: any attributes with non-schema namespace :param attribute_groups: """ ref: str = attribute(default="") name: Optional[str] = attribute() attributes: Array[Attribute] = array_element(name="attribute") attribute_groups: Array["AttributeGroup"] = array_element( name="attributeGroup") @property def is_attribute(self) -> bool: return True @property def real_type(self) -> str: return self.ref
class All(AnnotationBase): """ Model representation of a schema xs:all element. :param min_occurs: nonNegativeInteger : 1 :param max_occurs: (nonNegativeInteger | unbounded) : 1 :param any: :param elements: :param groups: """ min_occurs: int = attribute(default=1, name="minOccurs") max_occurs: UnionType[int, str] = attribute(default=1, name="maxOccurs") any: Array[Any] = array_element(name="any") elements: Array["Element"] = array_element(name="element") groups: Array["Group"] = array_element(name="group") 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 Binding(ExtensibleElement): """ :param type: :param operations: :param extended: """ type: str = attribute() operations: List[BindingOperation] = array_element(name="operation") def unique_operations(self) -> Iterator[BindingOperation]: name_attr = operator.attrgetter("name") grouped_operations = collections.group_by(self.operations, key=name_attr) for operations in grouped_operations.values(): yield operations[-1]
class Union(AnnotationBase): """ Model representation of a schema xs:union element. :param member_types: List of QName :param simple_types: """ member_types: Optional[str] = attribute(name="memberTypes") simple_types: Array[SimpleType] = array_element(name="simpleType") @property def extensions(self) -> Iterator[str]: if self.member_types: yield from self.member_types.split() @property def is_attribute(self) -> bool: return True @property def real_name(self) -> str: return "value" @property def real_type(self) -> str: types = [] if self.simple_types: types.extend([ simple_type.real_type for simple_type in self.simple_types if simple_type.real_type ]) if self.member_types: types.extend(self.member_types.split()) return " ".join(types) def get_restrictions(self) -> Dict[str, Anything]: restrictions = {} for simple_type in self.simple_types: restrictions.update(simple_type.get_restrictions()) return restrictions
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 Union(AnnotationBase): """ Model representation of a schema xs:union element. :param member_types: List of QName :param simple_types: """ member_types: Optional[str] = attribute(name="memberTypes") simple_types: Array[SimpleType] = array_element(name="simpleType") @property def bases(self) -> Iterator[str]: if self.member_types: yield from self.member_types.split() @property def is_attribute(self) -> bool: return True @property def real_name(self) -> str: return DEFAULT_ATTR_NAME @property def attr_types(self) -> Iterator[str]: for simple_type in self.simple_types: yield from simple_type.attr_types if self.member_types: yield from self.member_types.split() def get_restrictions(self) -> Dict[str, Anything]: restrictions = {} for simple_type in self.simple_types: restrictions.update(simple_type.get_restrictions()) return restrictions
class Override(SchemaLocation): """ Model representation of a schema xs:override element. :param schema_location: anyURI :param simple_types: :param complex_types: :param groups: :param attribute_groups: :param elements: :param attributes: :param notations: """ schema_location: Optional[str] = attribute(name="schemaLocation") 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")
class Message(WsdlElement): """ :param part: """ parts: List[Part] = array_element(name="part")
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 Service(WsdlElement): """ :param ports: """ ports: List[ServicePort] = array_element(name="port")
class Element(AnnotationBase): """ Model representation of a schema xs:element element. :param name: NCName :param ref: QName :param type: QName :param substitution_group: List of QName :param default: :param fixed: :param form: qualified | unqualified :param block: (#all | List of (extension | restriction | substitution)) :param final: (#all | List of (extension | restriction)) :param target_namespace: anyURI :param simple_type: :param complex_type: :param alternatives: :param uniques: :param keys: :param keyrefs: :param min_occurs: nonNegativeInteger : 1 :param max_occurs: (nonNegativeInteger | unbounded) : 1 :param nillable: :param abstract: """ name: Optional[str] = attribute() ref: Optional[str] = attribute() type: Optional[str] = attribute() substitution_group: Optional[str] = attribute(name="substitutionGroup") default: Optional[str] = attribute() fixed: Optional[str] = attribute() form: Optional[FormType] = attribute() block: Optional[str] = attribute() final: Optional[str] = attribute() target_namespace: Optional[str] = attribute(name="targetNamespace") simple_type: Optional[SimpleType] = element(name="simpleType") complex_type: Optional[ComplexType] = element(name="complexType") alternatives: Array[Alternative] = array_element(name="alternative") uniques: Array[Unique] = array_element(name="unique") keys: Array[Key] = array_element(name="key") keyrefs: Array[Keyref] = array_element(name="keyref") min_occurs: int = attribute(default=1, name="minOccurs") max_occurs: UnionType[int, str] = attribute(default=1, name="maxOccurs") nillable: bool = attribute(default=False) abstract: bool = attribute(default=False) @property def is_attribute(self) -> bool: return True @property def is_mixed(self) -> bool: return self.complex_type.is_mixed if self.complex_type else False @property def default_type(self) -> str: return self.data_type_ref(DataType.ANY_TYPE) @property def raw_type(self) -> Optional[str]: if self.type: return self.type if self.has_children: return None return self.data_type_ref(DataType.ANY_TYPE) @property def real_type(self) -> str: types = { alternative.type for alternative in self.alternatives if alternative.type } if self.type: types.add(self.type) elif self.ref: types.add(self.ref) elif self.simple_type and self.simple_type.real_type: types.add(self.simple_type.real_type) return " ".join(sorted(types)) @property def substitutions(self) -> Array[str]: return self.substitution_group.split( ) if self.substitution_group else [] def get_restrictions(self) -> Dict[str, Anything]: max_occurs = sys.maxsize if self.max_occurs == "unbounded" else self.max_occurs restrictions = { "min_occurs": self.min_occurs, "max_occurs": max_occurs, } if self.simple_type: restrictions.update(self.simple_type.get_restrictions()) if self.nillable: restrictions.update(nillable=True) if self.type and self.type in self.token_types: restrictions["tokens"] = True return restrictions
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