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
