xsdata.models.elements module

xsdata.models.elements.attribute(default=None, init=True, **kwargs)[source]
Parameters
Return type

Any

xsdata.models.elements.element(init=True, **kwargs)[source]
Parameters
Return type

Any

xsdata.models.elements.array_element(init=True, **kwargs)[source]
Parameters
Return type

Any

xsdata.models.elements.array_any_element(init=True, **kwargs)[source]
Parameters
Return type

Any

xsdata.models.elements.occurrences(min_value, max_value)[source]
Parameters
Return type

Dict[str, int]

class xsdata.models.elements.XmlString(elements=<factory>)[source]

Bases: object

Parameters

elements (List[object]) –

elements: Array[object] = None
render()[source]
Return type

str

class xsdata.models.elements.Documentation(index=<factory>, ns_map=<factory>, lang=None, source=None, elements=<factory>, attributes=None)[source]

Bases: xsdata.models.mixins.ElementBase

<documentation

source = anyURI xml:lang = language {any attributes with non-schema namespace …}> Content: ({any})*

</documentation>

Parameters
class Meta[source]

Bases: object

mixed = True
lang: Optional[str] = None
source: Optional[str] = None
elements: Array[object] = None
attributes: Optional[AnyAttribute] = None
tostring()[source]
Return type

Optional[str]

class xsdata.models.elements.Appinfo(index=<factory>, ns_map=<factory>, source=None, elements=<factory>, any_attribute=None)[source]

Bases: xsdata.models.mixins.ElementBase

<appinfo

source = anyURI {any attributes with non-schema namespace …}> Content: ({any})*

</appinfo>

Parameters
class Meta[source]

Bases: object

mixed = True
source: Optional[str] = None
elements: Array[object] = None
any_attribute: Optional[AnyAttribute] = None
class xsdata.models.elements.Annotation(index=<factory>, ns_map=<factory>, appinfo=None, documentations=<factory>, any_attribute=None)[source]

Bases: xsdata.models.mixins.ElementBase

<annotation

id = ID {any attributes with non-schema namespace …}> Content: (appinfo | documentation)*

</annotation>

Parameters
appinfo: Optional[xsdata.models.elements.Appinfo] = None
documentations: Array[Documentation] = None
any_attribute: Optional[AnyAttribute] = None
class xsdata.models.elements.AnnotationBase(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None)[source]

Bases: xsdata.models.mixins.ElementBase

Base Class for elements that can contain annotations.

Parameters
id: Optional[str] = None
annotation: Optional[xsdata.models.elements.Annotation] = None
any_attribute: Optional[AnyAttribute] = None
property display_help
Return type

Optional[str]

class xsdata.models.elements.AnyAttribute(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, namespace='##any', process_contents=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<anyAttribute

id = ID namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local))) notNamespace = List of (anyURI | (##targetNamespace | ##local)) notQName = List of (QName | ##defined) processContents = (lax | skip | strict) : strict {any attributes with non-schema namespace …}> Content: (annotation?)

</anyAttribute>

Parameters
namespace: Optional[str] = '##any'
process_contents: Optional[xsdata.models.enums.ProcessType] = None
property is_attribute
Return type

bool

property raw_namespace
Return type

Optional[str]

property real_name
Return type

str

property real_type
Return type

Optional[str]

class xsdata.models.elements.Assertion(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, test=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<assertion

id = ID test = an XPath expression xpathDefaultNamespace =

(anyURI | (##defaultNamespace | ##targetNamespace | ##local))

{any attributes with non-schema namespace …}> Content: (annotation?)

</assertion>

Parameters
test: Optional[str] = None
class xsdata.models.elements.SimpleType(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, restriction=None, list=None, union=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<simpleType

final = (#all | List of (list | union | restriction | extension)) id = ID name = NCName {any attributes with non-schema namespace …}> Content: (annotation?, (restriction | list | union))

</simpleType>

Parameters
name: Optional[str] = None
restriction: Optional[Restriction] = None
list: Optional[List] = None
union: Optional[Union] = None
property is_attribute
Return type

bool

property is_enumeration
Return type

bool

property real_name
Return type

str

property real_type
Return type

Optional[str]

get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.List(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, simple_type=None, item_type=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<list

id = ID itemType = QName {any attributes with non-schema namespace …}> Content: (annotation?, simpleType?)

</list>

Parameters
simple_type: Optional[xsdata.models.elements.SimpleType] = None
item_type: Optional[str] = None
property is_attribute
Return type

bool

property real_name
Return type

str

property real_type
Return type

Optional[str]

get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.Union(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, member_types=None, simple_types=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<union

id = ID memberTypes = List of QName {any attributes with non-schema namespace …}> Content: (annotation?, simpleType*)

</union>

Parameters
member_types: Optional[str] = None
simple_types: Array[SimpleType] = None
property extends
Return type

Optional[str]

property is_attribute
Return type

bool

property real_name
Return type

str

property real_type
Return type

Optional[str]

get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.Attribute(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, default=None, fixed=None, form=None, name=None, ref=None, type=None, target_namespace=None, simple_type=None, use=<UseType.OPTIONAL: 'optional'>)[source]

Bases: xsdata.models.elements.AnnotationBase

<attribute

default = string fixed = string form = (qualified | unqualified) id = ID name = NCName ref = QName targetNamespace = anyURI type = QName use = (optional | prohibited | required) : optional inheritable = boolean {any attributes with non-schema namespace …}> Content: (annotation?, simpleType?)

</attribute>

Parameters
default: Optional[str] = None
fixed: Optional[str] = None
form: Optional[xsdata.models.enums.FormType] = None
name: Optional[str] = None
ref: Optional[str] = None
type: Optional[str] = None
target_namespace: Optional[str] = None
simple_type: Optional[xsdata.models.elements.SimpleType] = None
use: Optional[xsdata.models.enums.UseType] = 'optional'
property is_attribute
Return type

bool

property real_type
Return type

Optional[str]

get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.AttributeGroup(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, ref=None, attributes=<factory>, attribute_groups=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<attributeGroup

id = ID ref = QName {any attributes with non-schema namespace …}> Content: (annotation?)

</attributeGroup>

Parameters
name: Optional[str] = None
ref: Optional[str] = None
attributes: Array[Attribute] = None
attribute_groups: Array['AttributeGroup'] = None
property is_attribute
Return type

bool

property real_type
Return type

Optional[str]

class xsdata.models.elements.Any(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, min_occurs=1, max_occurs=1, namespace='##any', process_contents=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<any

id = ID maxOccurs = (nonNegativeInteger | unbounded) : 1 minOccurs = nonNegativeInteger : 1 namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local))) notNamespace = List of (anyURI | (##targetNamespace | ##local)) notQName = List of (QName | (##defined | ##definedSibling)) processContents = (lax | skip | strict) : strict {any attributes with non-schema namespace …}> Content: (annotation?)

</any>

Parameters
min_occurs: int = 1
max_occurs: Union[int, str] = 1
namespace: Optional[str] = '##any'
process_contents: Optional[xsdata.models.enums.ProcessType] = None
property is_attribute
Return type

bool

property real_name
Return type

str

property raw_namespace
Return type

Optional[str]

property real_type
Return type

Optional[str]

get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.All(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, min_occurs=1, max_occurs=1, any=<factory>, elements=<factory>, groups=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<all

id = ID maxOccurs = (0 | 1) : 1 minOccurs = (0 | 1) : 1 {any attributes with non-schema namespace …}> Content: (annotation?, (element | any | group)*)

</all>

Parameters
min_occurs: int = 1
max_occurs: Union[int, str] = 1
any: Array[Any] = None
elements: Array['Element'] = None
groups: Array['Group'] = None
get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.Sequence(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, min_occurs=1, max_occurs=1, elements=<factory>, groups=<factory>, choices=<factory>, sequences=<factory>, any=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<sequence

id = ID maxOccurs = (nonNegativeInteger | unbounded) : 1 minOccurs = nonNegativeInteger : 1 {any attributes with non-schema namespace …}> Content: (annotation?, (element | group | choice | sequence | any)*)

</sequence>

Parameters
min_occurs: int = 1
max_occurs: Union[int, str] = 1
elements: Array['Element'] = None
groups: Array['Group'] = None
choices: Array['Choice'] = None
sequences: Array['Sequence'] = None
any: Array['Any'] = None
get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.Choice(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, min_occurs=1, max_occurs=1, elements=<factory>, groups=<factory>, choices=<factory>, sequences=<factory>, any=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<choice

id = ID maxOccurs = (nonNegativeInteger | unbounded) : 1 minOccurs = nonNegativeInteger : 1 {any attributes with non-schema namespace …}> Content: (annotation?, (element | group | choice | sequence | any)*)

</choice>

Parameters
min_occurs: int = 1
max_occurs: Union[int, str] = 1
elements: Array['Element'] = None
groups: Array['Group'] = None
choices: Array['Choice'] = None
sequences: Array[Sequence] = None
any: Array['Any'] = None
get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.Group(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, ref=None, min_occurs=1, max_occurs=1, all=None, choice=None, sequence=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<group

id = ID maxOccurs = (nonNegativeInteger | unbounded) : 1 minOccurs = nonNegativeInteger : 1 name = NCName ref = QName {any attributes with non-schema namespace …}> Content: (annotation?, (all | choice | sequence)?)

</group>

Parameters
name: Optional[str] = None
ref: Optional[str] = None
min_occurs: int = 1
max_occurs: Union[int, str] = 1
all: Optional[xsdata.models.elements.All] = None
choice: Optional[xsdata.models.elements.Choice] = None
sequence: Optional[xsdata.models.elements.Sequence] = None
property is_attribute
Return type

bool

property real_type
Return type

Optional[str]

get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.OpenContent(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, applies_to_empty=False, mode=<Mode.INTERLEAVE: 'interleave'>, any=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<openContent

id = ID mode = (none | interleave | suffix) : interleave {any attributes with non-schema namespace …}> Content: (annotation?, any?)

</openContent>

Parameters
applies_to_empty: bool = False
mode: xsdata.models.enums.Mode = 'interleave'
any: xsdata.models.elements.Any = None
class xsdata.models.elements.DefaultOpenContent(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, applies_to_empty=False, mode=<Mode.INTERLEAVE: 'interleave'>, any=None)[source]

Bases: xsdata.models.elements.OpenContent

<defaultOpenContent

appliesToEmpty = boolean : false id = ID mode = (interleave | suffix) : interleave {any attributes with non-schema namespace …}> Content: (annotation?, any)

</defaultOpenContent>

Parameters
class xsdata.models.elements.Extension(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, base=None, group=None, all=None, choice=None, sequence=None, open_content=None, attributes=<factory>, attribute_groups=<factory>, assertions=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<extension

base = QName id = ID {any attributes with non-schema namespace …}> Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?), assert*)

</extension>

Parameters
base: Optional[str] = None
group: Optional[xsdata.models.elements.Group] = None
all: Optional[xsdata.models.elements.All] = None
choice: Optional[xsdata.models.elements.Choice] = None
sequence: Optional[xsdata.models.elements.Sequence] = None
any_attribute: Optional[xsdata.models.elements.AnyAttribute] = None
open_content: Optional[xsdata.models.elements.OpenContent] = None
attributes: Array[Attribute] = None
attribute_groups: Array[AttributeGroup] = None
assertions: Array[Assertion] = None
property extends
Return type

Optional[str]

class xsdata.models.elements.Enumeration(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<enumeration

id = ID value = anySimpleType {any attributes with non-schema namespace …}> Content: (annotation?)

</enumeration>

Parameters
value: str = None
property is_attribute
Return type

bool

property real_type
Return type

None

property real_name
Return type

str

property default
Return type

str

class xsdata.models.elements.FractionDigits(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<fractionDigits

fixed = boolean : false id = ID value = nonNegativeInteger {any attributes with non-schema namespace …}> Content: (annotation?)

</fractionDigits>

Parameters
value: int = None
class xsdata.models.elements.Length(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<length

fixed = boolean : false id = ID value = nonNegativeInteger {any attributes with non-schema namespace …}> Content: (annotation?)

</length>

Parameters
value: int = None
class xsdata.models.elements.MaxExclusive(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<maxExclusive

fixed = boolean : false id = ID value = anySimpleType {any attributes with non-schema namespace …}> Content: (annotation?)

</maxExclusive>

Parameters
value: float = None
class xsdata.models.elements.MaxInclusive(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<maxInclusive

fixed = boolean : false id = ID value = anySimpleType {any attributes with non-schema namespace …}> Content: (annotation?)

</maxInclusive>

Parameters
value: float = None
class xsdata.models.elements.MaxLength(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<maxLength

fixed = boolean : false id = ID value = nonNegativeInteger {any attributes with non-schema namespace …}> Content: (annotation?)

</maxLength>

Parameters
value: float = None
class xsdata.models.elements.MinExclusive(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<minExclusive

fixed = boolean : false id = ID value = anySimpleType {any attributes with non-schema namespace …}> Content: (annotation?)

</minExclusive>

Parameters
value: float = None
class xsdata.models.elements.MinInclusive(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<minInclusive

fixed = boolean : false id = ID value = anySimpleType {any attributes with non-schema namespace …}> Content: (annotation?)

</minInclusive>

Parameters
value: float = None
class xsdata.models.elements.MinLength(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<minLength

fixed = boolean : false id = ID value = nonNegativeInteger {any attributes with non-schema namespace …}> Content: (annotation?)

</minLength>

Parameters
value: float = None
class xsdata.models.elements.Pattern(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<pattern

id = ID value = string {any attributes with non-schema namespace …}> Content: (annotation?)

</pattern>

Parameters
value: str = None
class xsdata.models.elements.TotalDigits(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<totalDigits

fixed = boolean : false id = ID value = positiveInteger {any attributes with non-schema namespace …}> Content: (annotation?)

</totalDigits>

Parameters
value: int = None
class xsdata.models.elements.WhiteSpace(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<whiteSpace

fixed = boolean : false id = ID value = (collapse | preserve | replace) {any attributes with non-schema namespace …}> Content: (annotation?)

</whiteSpace>

Parameters
value: str = None
class xsdata.models.elements.ExplicitTimezone(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, value=None, fixed=False)[source]

Bases: xsdata.models.elements.AnnotationBase

<explicitTimezone

fixed = boolean : false id = ID value = NCName {any attributes with non-schema namespace …}> Content: (annotation?)

</explicitTimezone>

Parameters
value: str = None
fixed: bool = False
class xsdata.models.elements.Restriction(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, base=None, group=None, all=None, choice=None, sequence=None, open_content=None, attributes=<factory>, attribute_groups=<factory>, enumerations=<factory>, asserts=<factory>, assertions=<factory>, any_element=<factory>, min_exclusive=None, min_inclusive=None, min_length=None, max_exclusive=None, max_inclusive=None, max_length=None, total_digits=None, fraction_digits=None, length=None, white_space=None, patterns=<factory>, explicit_timezone=None, simple_type=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<restriction

base = QName id = ID {any attributes with non-schema namespace …}> Content: (annotation?, (simpleType?, (

minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern | assertion | explicitTimezone | {any with namespace: ##other})*)

)

</restriction>

Parameters
base: Optional[str] = None
group: Optional[xsdata.models.elements.Group] = None
all: Optional[xsdata.models.elements.All] = None
choice: Optional[xsdata.models.elements.Choice] = None
sequence: Optional[xsdata.models.elements.Sequence] = None
open_content: Optional[xsdata.models.elements.OpenContent] = None
attributes: Array[Attribute] = None
attribute_groups: Array[AttributeGroup] = None
enumerations: Array[Enumeration] = None
asserts: Array[Assertion] = None
assertions: Array[Assertion] = None
any_element: Array[object] = None
min_exclusive: Optional[xsdata.models.elements.MinExclusive] = None
min_inclusive: Optional[xsdata.models.elements.MinInclusive] = None
min_length: Optional[xsdata.models.elements.MinLength] = None
max_exclusive: Optional[xsdata.models.elements.MaxExclusive] = None
max_inclusive: Optional[xsdata.models.elements.MaxInclusive] = None
max_length: Optional[xsdata.models.elements.MaxLength] = None
total_digits: Optional[xsdata.models.elements.TotalDigits] = None
fraction_digits: Optional[xsdata.models.elements.FractionDigits] = None
length: Optional[xsdata.models.elements.Length] = None
white_space: Optional[xsdata.models.elements.WhiteSpace] = None
patterns: Array[Pattern] = None
explicit_timezone: Optional[xsdata.models.elements.ExplicitTimezone] = None
simple_type: Optional[xsdata.models.elements.SimpleType] = None
property real_type
Return type

Optional[str]

property real_name
Return type

str

property extends
Return type

Optional[str]

get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.SimpleContent(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, restriction=None, extension=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<simpleContent

id = ID {any attributes with non-schema namespace …}> Content: (annotation?, (restriction | extension))

</simpleContent>

Parameters
restriction: Optional[xsdata.models.elements.Restriction] = None
extension: Optional[xsdata.models.elements.Extension] = None
class xsdata.models.elements.ComplexContent(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, restriction=None, extension=None, mixed=False)[source]

Bases: xsdata.models.elements.SimpleContent

<complexContent

id = ID mixed = boolean {any attributes with non-schema namespace …}> Content: (annotation?, (restriction | extension))

</complexContent>

Parameters
mixed: bool = False
class xsdata.models.elements.ComplexType(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, block=None, final=None, simple_content=None, complex_content=None, group=None, all=None, choice=None, sequence=None, open_content=None, attributes=<factory>, attribute_groups=<factory>, assertion=<factory>, abstract=False, mixed=False, default_attributes_apply=True)[source]

Bases: xsdata.models.elements.AnnotationBase

<complexType

abstract = boolean : false block = (#all | List of (extension | restriction)) final = (#all | List of (extension | restriction)) id = ID mixed = boolean name = NCName defaultAttributesApply = boolean : true {any attributes with non-schema namespace …}> Content: (annotation?, (

simpleContent | complexContent | (openContent?, (group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?), assert*))

)

</complexType>

Parameters
name: Optional[str] = None
block: Optional[str] = None
final: Optional[str] = None
simple_content: Optional[xsdata.models.elements.SimpleContent] = None
complex_content: Optional[xsdata.models.elements.ComplexContent] = None
group: Optional[xsdata.models.elements.Group] = None
all: Optional[xsdata.models.elements.All] = None
choice: Optional[xsdata.models.elements.Choice] = None
sequence: Optional[xsdata.models.elements.Sequence] = None
any_attribute: Optional[xsdata.models.elements.AnyAttribute] = None
open_content: Optional[xsdata.models.elements.OpenContent] = None
attributes: Array[Attribute] = None
attribute_groups: Array[AttributeGroup] = None
assertion: Array[Assertion] = None
abstract: bool = False
mixed: bool = False
default_attributes_apply: bool = True
property is_mixed
Return type

bool

class xsdata.models.elements.Field(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, xpath=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<field

id = ID xpath = a subset of XPath expression, see below xpathDefaultNamespace =

(anyURI | (##defaultNamespace | ##targetNamespace | ##local))

{any attributes with non-schema namespace …}> Content: (annotation?)

</field>

Parameters
xpath: Optional[str] = None
class xsdata.models.elements.Selector(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, xpath=None)[source]

Bases: xsdata.models.elements.Field

<selector

id = ID xpath = a subset of XPath expression, see below xpathDefaultNamespace =

(anyURI | (##defaultNamespace | ##targetNamespace | ##local))

{any attributes with non-schema namespace …}> Content: (annotation?)

</selector>

Parameters
class xsdata.models.elements.Unique(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, selector=None, fields=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<unique

id = ID name = NCName ref = QName {any attributes with non-schema namespace …}> Content: (annotation?, (selector, field+)?)

</unique>

Parameters
name: Optional[str] = None
selector: Optional[xsdata.models.elements.Selector] = None
fields: Array[Field] = None
class xsdata.models.elements.Key(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, selector=None, fields=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<key

id = ID name = NCName ref = QName {any attributes with non-schema namespace …}> Content: (annotation?, (selector, field+)?)

</key>

Parameters
name: Optional[str] = None
selector: Optional[xsdata.models.elements.Selector] = None
fields: Array[Selector] = None
class xsdata.models.elements.Keyref(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, refer=None, selector=None, fields=<factory>)[source]

Bases: xsdata.models.elements.AnnotationBase

<keyref

id = ID name = NCName ref = QName refer = QName {any attributes with non-schema namespace …}> Content: (annotation?, (selector, field+)?)

</keyref>

Parameters
name: Optional[str] = None
refer: Optional[str] = None
selector: Optional[xsdata.models.elements.Selector] = None
fields: Array[Selector] = None
class xsdata.models.elements.Alternative(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, type=None, test=None, simple_type=None, complex_type=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<alternative

id = ID test = an XPath expression type = QName xpathDefaultNamespace =

(anyURI | (##defaultNamespace | ##targetNamespace | ##local))

{any attributes with non-schema namespace …}> Content: (annotation?, (simpleType | complexType)?)

</alternative>

Parameters
type: Optional[str] = None
test: Optional[str] = None
simple_type: Optional[xsdata.models.elements.SimpleType] = None
complex_type: Optional[xsdata.models.elements.ComplexType] = None
property real_name
Return type

str

class xsdata.models.elements.Element(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, ref=None, type=None, substitution_group=None, default=None, fixed=None, form=None, block=None, final=None, target_namespace=None, simple_type=None, complex_type=None, alternatives=<factory>, uniques=<factory>, keys=<factory>, keyrefs=<factory>, min_occurs=1, max_occurs=1, nillable=False, abstract=False)[source]

Bases: xsdata.models.elements.AnnotationBase

<element

abstract = boolean : false block = (#all | List of (extension | restriction | substitution)) default = string final = (#all | List of (extension | restriction)) fixed = string form = (qualified | unqualified) id = ID maxOccurs = (nonNegativeInteger | unbounded) : 1 minOccurs = nonNegativeInteger : 1 name = NCName nillable = boolean : false ref = QName substitutionGroup = List of QName targetNamespace = anyURI type = QName {any attributes with non-schema namespace …}> Content: (annotation?,

((simpleType | complexType)?, alternative*, (unique | key | keyref)*))

</element>

Parameters
name: Optional[str] = None
ref: Optional[str] = None
type: Optional[str] = None
substitution_group: Optional[str] = None
default: Optional[str] = None
fixed: Optional[str] = None
form: Optional[xsdata.models.enums.FormType] = None
block: Optional[str] = None
final: Optional[str] = None
target_namespace: Optional[str] = None
simple_type: Optional[xsdata.models.elements.SimpleType] = None
complex_type: Optional[xsdata.models.elements.ComplexType] = None
alternatives: Array[Alternative] = None
uniques: Array[Unique] = None
keys: Array[Key] = None
keyrefs: Array[Keyref] = None
min_occurs: int = 1
max_occurs: Union[int, str] = 1
nillable: bool = False
abstract: bool = False
property is_attribute
Return type

bool

property is_mixed
Return type

bool

property default_type
Return type

DataType

property raw_type
Return type

Optional[str]

property real_type
Return type

Optional[str]

property substitutions
Return type

List[str]

get_restrictions()[source]
Return type

Dict[str, Any]

class xsdata.models.elements.Notation(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, name=None, public=None, system=None)[source]

Bases: xsdata.models.elements.AnnotationBase

<notation

id = ID name = NCName public = token system = anyURI {any attributes with non-schema namespace …}> Content: (annotation?)

</notation>

Parameters
name: Optional[str] = None
public: Optional[str] = None
system: Optional[str] = None
class xsdata.models.elements.SchemaLocation(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, location=None)[source]

Bases: xsdata.models.elements.AnnotationBase

Parameters
location: Optional[pathlib.Path] = None
class xsdata.models.elements.Import(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, location=None, namespace=None, schema_location=None)[source]

Bases: xsdata.models.elements.SchemaLocation

<import

id = ID namespace = anyURI schemaLocation = anyURI {any attributes with non-schema namespace …}> Content: (annotation?)

</import>

Parameters
namespace: Optional[str] = None
schema_location: Optional[str] = None
class xsdata.models.elements.Include(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, location=None, schema_location=None)[source]

Bases: xsdata.models.elements.SchemaLocation

<include

id = ID schemaLocation = anyURI {any attributes with non-schema namespace …}> Content: (annotation?)

</include>

Parameters
schema_location: Optional[str] = None
class xsdata.models.elements.Redefine(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, location=None, schema_location=None, simple_types=<factory>, complex_types=<factory>, groups=<factory>, attribute_groups=<factory>)[source]

Bases: xsdata.models.elements.SchemaLocation

<redefine

id = ID schemaLocation = anyURI {any attributes with non-schema namespace …}> Content: (annotation | (simpleType | complexType | group | attributeGroup))*

</redefine>

Parameters
schema_location: Optional[str] = None
simple_types: Array[SimpleType] = None
complex_types: Array[ComplexType] = None
groups: Array[Group] = None
attribute_groups: Array[AttributeGroup] = None
class xsdata.models.elements.Override(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, location=None, schema_location=None, simple_types=<factory>, complex_types=<factory>, groups=<factory>, attribute_groups=<factory>, elements=<factory>, attributes=<factory>, notations=<factory>)[source]

Bases: xsdata.models.elements.SchemaLocation

<override

id = ID schemaLocation = anyURI {any attributes with non-schema namespace …}> Content: (

annotation | (simpleType | complexType | group | attributeGroup | element | attribute | notation)

)*

</override>

Parameters
schema_location: Optional[str] = None
simple_types: Array[SimpleType] = None
complex_types: Array[ComplexType] = None
groups: Array[Group] = None
attribute_groups: Array[AttributeGroup] = None
elements: Array[Element] = None
attributes: Array[Attribute] = None
notations: Array[Notation] = None
class xsdata.models.elements.Schema(index=<factory>, ns_map=<factory>, id=None, annotation=None, any_attribute=None, location=None, target=None, block_default=None, default_attributes=None, final_default=None, target_namespace=None, version=None, xmlns=None, element_form_default=<FormType.UNQUALIFIED: 'unqualified'>, attribute_form_default=<FormType.UNQUALIFIED: 'unqualified'>, default_open_content=None, includes=<factory>, imports=<factory>, redefines=<factory>, overrides=<factory>, annotations=<factory>, simple_types=<factory>, complex_types=<factory>, groups=<factory>, attribute_groups=<factory>, elements=<factory>, attributes=<factory>, notations=<factory>)[source]

Bases: xsdata.models.elements.SchemaLocation

<schema

attributeFormDefault = (qualified | unqualified) : unqualified blockDefault = (#all | List of (extension | restriction | substitution)) : ‘’ defaultAttributes = QName xpathDefaultNamespace = (anyURI | (##defaultNamespace | ##targetNamespace | ##local)) : ##local elementFormDefault = (qualified | unqualified) : unqualified finalDefault = (#all | List of (extension | restriction | list | union)) : ‘’ id = ID targetNamespace = anyURI version = token xml:lang = language {any attributes with non-schema namespace …}> Content: (

(include | import | redefine | override | annotation)*, (defaultOpenContent, annotation*)?, ((simpleType | complexType | group | attributeGroup |

element | attribute | notation), annotation*)*)

</schema>

Parameters
class Meta[source]

Bases: object

namespace = 'http://www.w3.org/2001/XMLSchema'
target: Optional[str] = None
block_default: Optional[str] = None
default_attributes: Optional[str] = None
final_default: Optional[str] = None
target_namespace: Optional[str] = None
version: Optional[str] = None
xmlns: Optional[str] = None
element_form_default: xsdata.models.enums.FormType = 'unqualified'
attribute_form_default: xsdata.models.enums.FormType = 'unqualified'
default_open_content: Optional[xsdata.models.elements.DefaultOpenContent] = None
includes: Array[Include] = None
imports: Array[Import] = None
redefines: Array[Redefine] = None
overrides: Array[Override] = None
annotations: Array[Annotation] = None
simple_types: Array[SimpleType] = None
complex_types: Array[ComplexType] = None
groups: Array[Group] = None
attribute_groups: Array[AttributeGroup] = None
elements: Array[Element] = None
attributes: Array[Attribute] = None
notations: Array[Notation] = None
included()[source]
Return type

Iterator[Union[Import, Include, Redefine, Override]]

property module
Return type

str