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()
