Chapter 12¶
Complex types¶
Binding Test¶
Schema
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:annotation>
<xsd:documentation>
This example illustrates complex types that are not derived from other specified types.
It includes an example of each content type: element-only, simple, empty and mixed.
</xsd:documentation>
</xsd:annotation>
<xsd:element name="items" type="ItemsType"/>
<xsd:complexType name="ItemsType">
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element name="shirt" type="ProductType"/>
<xsd:element name="hat" type="ProductType"/>
<xsd:element name="umbrella" type="ProductType"/>
</xsd:choice>
</xsd:complexType>
<!-- Element-only content -->
<xsd:complexType name="ProductType">
<xsd:sequence>
<xsd:element name="number" type="xsd:integer"/>
<xsd:element name="name" type="xsd:string"/>
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element name="size" type="SizeType"/>
<xsd:element name="color" type="ColorType"/>
<xsd:element name="description" type="DescriptionType"/>
</xsd:choice>
</xsd:sequence>
<xsd:attribute name="effDate" type="xsd:date"
default="1900-01-01"/>
<xsd:anyAttribute namespace="##other" processContents="lax"/>
</xsd:complexType>
<!-- Simple content -->
<xsd:complexType name="SizeType">
<xsd:simpleContent>
<xsd:extension base="xsd:integer">
<xsd:attribute name="system" type="xsd:token"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<!-- Empty content -->
<xsd:complexType name="ColorType">
<xsd:attribute name="value" type="xsd:string"/>
</xsd:complexType>
<!-- Mixed content -->
<xsd:complexType name="DescriptionType" mixed="true">
<xsd:sequence>
<xsd:any namespace="http://www.w3.org/1999/xhtml"
minOccurs="0" maxOccurs="unbounded"
processContents="skip"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
XML Document
<items xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../../../../../xsdata-samples/dxsfullexamples/chapter13.xsd"
xmlns:xhtml="http://www.w3.org/1999/xhtml"
xmlns:oth="http://example.org/oth">
<shirt effDate="2002-04-02">
<number>557</number>
<name>Short-Sleeved Linen Blouse</name>
<size system="US-DRESS">10</size>
<color value="blue"/>
<description>
This shirt is the <xhtml:b>best-selling</xhtml:b> shirt in
our catalog! <xhtml:br/> Note: runs large.
</description>
</shirt>
<hat oth:custom="12">
<number>557</number>
<name>Ten-Gallon Hat</name>
<color value="red"/>
</hat>
</items>
xsData XML Document
<items xmlns:oth="http://example.org/oth" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<shirt effDate="2002-04-02">
<number>557</number>
<name>Short-Sleeved Linen Blouse</name>
<size system="US-DRESS">10</size>
<color value="blue"/>
<description>This shirt is the<xhtml:b>best-selling</xhtml:b>shirt in
our catalog!<xhtml:br/>Note: runs large.</description>
</shirt>
<hat effDate="1900-01-01" oth:custom="12">
<number>557</number>
<name>Ten-Gallon Hat</name>
<color value="red"/>
</hat>
</items>
xsData JSON
{
"shirt": [
{
"number": 557,
"name": "Short-Sleeved Linen Blouse",
"size": [
{
"value": 10,
"system": "US-DRESS"
}
],
"color": [
{
"value": "blue"
}
],
"description": [
{
"www_w3_org_1999_xhtml_element": [
"This shirt is the",
{
"qname": "{http://www.w3.org/1999/xhtml}b",
"text": "best-selling",
"tail": "shirt in\n our catalog!",
"ns_map": {
"xsi": "http://www.w3.org/2001/XMLSchema-instance",
"xhtml": "http://www.w3.org/1999/xhtml",
"oth": "http://example.org/oth"
},
"children": [],
"attributes": {}
},
{
"qname": "{http://www.w3.org/1999/xhtml}br",
"text": null,
"tail": "Note: runs large.",
"ns_map": {
"xsi": "http://www.w3.org/2001/XMLSchema-instance",
"xhtml": "http://www.w3.org/1999/xhtml",
"oth": "http://example.org/oth"
},
"children": [],
"attributes": {}
}
]
}
],
"eff_date": "2002-04-02",
"other_attributes": {}
}
],
"hat": [
{
"number": 557,
"name": "Ten-Gallon Hat",
"size": [],
"color": [
{
"value": "red"
}
],
"description": [],
"eff_date": "1900-01-01",
"other_attributes": {
"{http://example.org/oth}custom": "12"
}
}
],
"umbrella": []
}
Example 12-2 Named complex type¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="size" type="xs:integer" />
</xs:sequence>
</xs:complexType>
<xs:element name="product" type="ProductType" />
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
@dataclass
class Product(ProductType):
class Meta:
name = "product"
Example 12-3 Anonymous complex type¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="product">
<xs:complexType>
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="size" type="xs:int" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class Product:
"""
:ivar number:
:ivar name:
:ivar size:
"""
class Meta:
name = "product"
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
Example 12-5 Complex type with simple content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="SizeType">
<xs:simpleContent>
<xs:extension base="xs:integer">
<xs:attribute name="system" type="xs:token" />
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class SizeType:
"""
:ivar value:
:ivar system:
"""
value: Optional[int] = field(
default=None,
)
system: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
Example 12-7 Complex type with element-only content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:import schemaLocation="../chapter10/example1001.xsd" />
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="size" type="SizeType" />
<xs:element name="color" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:schema>
from enum import Enum
from dataclasses import dataclass, field
from typing import Optional, Union
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar color:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
size: Optional[Union[int, "ProductType.Value"]] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True,
min_inclusive=2.0,
max_inclusive=18.0
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
class Value(Enum):
"""
:cvar SMALL:
:cvar MEDIUM:
:cvar LARGE:
"""
SMALL = "small"
MEDIUM = "medium"
LARGE = "large"
Example 12-9 Complex type with mixed content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="desc" type="DescType" />
<xs:complexType name="DescType" mixed="true">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="i" type="xs:string" />
<xs:element name="b" type="xs:string" />
<xs:element name="u" type="xs:string" />
</xs:choice>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class DescType:
"""
:ivar content:
:ivar i:
:ivar b:
:ivar u:
"""
content: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##any"
)
)
i: List[str] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=9223372036854775807
)
)
b: List[str] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=9223372036854775807
)
)
u: List[str] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=9223372036854775807
)
)
@dataclass
class Desc(DescType):
class Meta:
name = "desc"
Example 12-11 Complex type with empty content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ColorType">
<xs:attribute name="value" type="xs:string" />
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ColorType:
"""
:ivar value:
"""
value: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
Example 12-12 Element references¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:import schemaLocation="../chapter10/example1001.xsd" />
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="size" type="SizeType" />
<xs:element name="color" type="xs:string" />
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element ref="number" />
<xs:element ref="name" />
<xs:element ref="size" minOccurs="0" />
<xs:element ref="color" minOccurs="0" />
</xs:sequence>
</xs:complexType>
</xs:schema>
from enum import Enum
from dataclasses import dataclass, field
from typing import Optional, Union
@dataclass
class Color:
"""
:ivar value:
"""
class Meta:
name = "color"
value: Optional[str] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Name:
"""
:ivar value:
"""
class Meta:
name = "name"
value: Optional[str] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Number:
"""
:ivar value:
"""
class Meta:
name = "number"
value: Optional[int] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Size:
"""
:ivar value:
"""
class Meta:
name = "size"
value: Optional[Union[int, "Size.Value"]] = field(
default=None,
metadata=dict(
required=True,
min_inclusive=2.0,
max_inclusive=18.0
)
)
class Value(Enum):
"""
:cvar SMALL:
:cvar MEDIUM:
:cvar LARGE:
"""
SMALL = "small"
MEDIUM = "medium"
LARGE = "large"
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar color:
"""
number: Optional[Number] = field(
default=None,
metadata=dict(
type="Element",
required=True
)
)
name: Optional[Name] = field(
default=None,
metadata=dict(
type="Element",
required=True
)
)
size: Optional[Size] = field(
default=None,
metadata=dict(
type="Element"
)
)
color: Optional[Color] = field(
default=None,
metadata=dict(
type="Element"
)
)
Example 12-13 Legal duplication of element names¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:choice>
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" minOccurs="0" />
</xs:sequence>
<xs:element name="name" type="xs:string" />
</xs:choice>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: List[str] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=2
)
)
Example 12-15 A sequence group¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:import schemaLocation="../chapter10/example1001.xsd" />
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="size" type="SizeType" minOccurs="0" />
<xs:element name="color" type="xs:string" minOccurs="0" />
</xs:sequence>
</xs:complexType>
</xs:schema>
from enum import Enum
from dataclasses import dataclass, field
from typing import Optional, Union
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar color:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
size: Optional[Union[int, "ProductType.Value"]] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
min_inclusive=2.0,
max_inclusive=18.0
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
class Value(Enum):
"""
:cvar SMALL:
:cvar MEDIUM:
:cvar LARGE:
"""
SMALL = "small"
MEDIUM = "medium"
LARGE = "large"
Example 12-18 Enforcing order for better constraints¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="color" type="xs:string" maxOccurs="3" />
</xs:sequence>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar color:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
color: List[str] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=1,
max_occurs=3
)
)
Example 12-19 A choice group¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:include schemaLocation="../chapter16/example1607.xsd" />
<xs:complexType name="ItemsType">
<xs:choice>
<xs:element name="shirt" type="ShirtType" />
<xs:element name="hat" type="HatType" />
<xs:element name="umbrella" type="UmbrellaType" />
</xs:choice>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
from tests.fixtures.defxmlschema.chapter16.example1607 import (
HatType,
ShirtType,
UmbrellaType,
)
@dataclass
class ItemsType:
"""
:ivar shirt:
:ivar hat:
:ivar umbrella:
"""
shirt: Optional[ShirtType] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
hat: Optional[HatType] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
umbrella: Optional[UmbrellaType] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
Example 12-21 A repeating choice group¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:include schemaLocation="../chapter16/example1607.xsd" />
<xs:complexType name="ItemsType">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="shirt" type="ShirtType" />
<xs:element name="umbrella" type="UmbrellaType" />
<xs:element name="hat" type="HatType" />
</xs:choice>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import List
from tests.fixtures.defxmlschema.chapter16.example1607 import (
HatType,
ShirtType,
UmbrellaType,
)
@dataclass
class ItemsType:
"""
:ivar shirt:
:ivar umbrella:
:ivar hat:
"""
shirt: List[ShirtType] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=9223372036854775807
)
)
umbrella: List[UmbrellaType] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=9223372036854775807
)
)
hat: List[HatType] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=9223372036854775807
)
)
Example 12-23 Multiple nested groups¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="size" type="xs:int" />
<xs:element name="color" type="xs:string" />
</xs:choice>
</xs:sequence>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar color:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
size: List[int] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=9223372036854775807
)
)
color: List[str] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=9223372036854775807
)
)
Example 12-24 An all group¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:all>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="size" type="xs:integer" minOccurs="0" />
<xs:element name="color" type="xs:string" minOccurs="0" />
</xs:all>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar color:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
Example 12-27 Complex type with a named model group reference¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:sequence>
<xs:group ref="DescriptionGroup" />
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:group name="DescriptionGroup">
<xs:sequence>
<xs:element name="description" type="xs:string" />
<xs:element name="comment" type="xs:string" minOccurs="0" />
</xs:sequence>
</xs:group>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ProductType:
"""
:ivar description:
:ivar comment:
:ivar number:
:ivar name:
"""
description: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
comment: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
Example 12-29 Deterministic content model¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="AOrBOrBothType">
<xs:choice>
<xs:sequence>
<xs:element name="a" type="xs:string" />
<xs:element name="b" type="xs:string" minOccurs="0" />
</xs:sequence>
<xs:element name="b" type="xs:string" />
</xs:choice>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class AorBorBothType:
"""
:ivar a:
:ivar b:
"""
class Meta:
name = "AOrBOrBothType"
a: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
b: List[str] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=0,
max_occurs=2
)
)
Example 12-30 Local attribute declaration¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:attribute name="effDate" type="xs:date" default="1900-01-01" />
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
@dataclass
class ProductType:
"""
:ivar eff_date:
"""
eff_date: str = field(
default="1900-01-01",
metadata=dict(
name="effDate",
type="Attribute"
)
)
Example 12-31 Attribute reference¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:attribute name="effDate" type="xs:date" default="1900-01-01" />
<xs:complexType name="ProductType">
<xs:attribute ref="effDate" default="2000-12-31" />
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
@dataclass
class ProductType:
"""
:ivar eff_date:
"""
eff_date: str = field(
default="2000-12-31",
metadata=dict(
name="effDate",
type="Attribute"
)
)
Example 12-32 Complex type with attribute group reference¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:attributeGroup ref="IdentifierGroup" />
<xs:attribute name="effDate" type="xs:date" />
</xs:complexType>
<xs:attributeGroup name="IdentifierGroup">
<xs:attribute name="id" type="xs:ID" use="required" />
<xs:attribute name="version" type="xs:decimal" />
</xs:attributeGroup>
</xs:schema>
from decimal import Decimal
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ProductType:
"""
:ivar id:
:ivar version:
:ivar eff_date:
"""
id: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
required=True
)
)
version: Optional[Decimal] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
eff_date: Optional[str] = field(
default=None,
metadata=dict(
name="effDate",
type="Attribute"
)
)
Example 12-33 Using an element wildcard¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="product" type="ProductType" />
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:any minOccurs="0" maxOccurs="unbounded" />
</xs:sequence>
</xs:complexType>
<xs:element name="color" type="xs:string" />
<xs:element name="desc" type="xs:string" />
<xs:element name="size" type="xs:integer" />
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar any_element:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
any_element: List[object] = field(
default_factory=list,
metadata=dict(
type="Wildcard",
namespace="##any",
min_occurs=0,
max_occurs=9223372036854775807
)
)
@dataclass
class Color:
"""
:ivar value:
"""
class Meta:
name = "color"
value: Optional[str] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Desc:
"""
:ivar value:
"""
class Meta:
name = "desc"
value: Optional[str] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Size:
"""
:ivar value:
"""
class Meta:
name = "size"
value: Optional[int] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Product(ProductType):
class Meta:
name = "product"
Example 12-35 Complex type with element wildcard¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="DescriptionType" mixed="true">
<xs:sequence>
<xs:any namespace="http://www.w3.org/1999/xhtml" minOccurs="0" maxOccurs="unbounded" processContents="skip" />
</xs:sequence>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import List
@dataclass
class DescriptionType:
"""
:ivar www_w3_org_1999_xhtml_element:
"""
www_w3_org_1999_xhtml_element: List[object] = field(
default_factory=list,
metadata=dict(
type="Wildcard",
namespace="http://www.w3.org/1999/xhtml",
min_occurs=0,
max_occurs=9223372036854775807
)
)
Example 12-37 Negative wildcards¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="product" type="ProductType" />
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:any minOccurs="0" maxOccurs="unbounded" notNamespace="http://www.w3.org/1999/xhtml" notQName="##definedSibling desc size" processContents="lax" />
</xs:sequence>
</xs:complexType>
<xs:element name="color" type="xs:string" />
<xs:element name="size" type="xs:integer" />
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar any_element:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
any_element: List[object] = field(
default_factory=list,
metadata=dict(
type="Wildcard",
namespace="##any",
min_occurs=0,
max_occurs=9223372036854775807
)
)
@dataclass
class Color:
"""
:ivar value:
"""
class Meta:
name = "color"
value: Optional[str] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Size:
"""
:ivar value:
"""
class Meta:
name = "size"
value: Optional[int] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Product(ProductType):
class Meta:
name = "product"
Example 12-40 Defining an interleaved open content model¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="product" type="OpenProductType" />
<xs:complexType name="OpenProductType">
<xs:openContent>
<xs:any namespace="##other" processContents="lax" />
</xs:openContent>
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class OpenProductType:
"""
:ivar other_element:
:ivar number:
:ivar name:
"""
other_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##other",
required=True
)
)
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
@dataclass
class Product(OpenProductType):
class Meta:
name = "product"
Example 12-42 Defining a suffix open content model¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="product" type="OpenProductType" />
<xs:complexType name="OpenProductType">
<xs:openContent mode="suffix">
<xs:any namespace="##local" processContents="strict" />
</xs:openContent>
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:element name="something" type="xs:string" />
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class OpenProductType:
"""
:ivar number:
:ivar name:
:ivar local_element:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
local_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##local",
required=True
)
)
@dataclass
class Something:
"""
:ivar value:
"""
class Meta:
name = "something"
value: Optional[str] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Product(OpenProductType):
class Meta:
name = "product"
Example 12-44 Defining a default open content model¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:defaultOpenContent mode="suffix">
<xs:any namespace="##local" />
</xs:defaultOpenContent>
<xs:element name="catalog" type="CatalogType" />
<xs:complexType name="CatalogType">
<xs:sequence>
<xs:element name="product" type="ProductType" maxOccurs="unbounded" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:element name="something" type="xs:string" />
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar local_element:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
local_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##local",
required=True
)
)
@dataclass
class Something:
"""
:ivar value:
"""
class Meta:
name = "something"
value: Optional[str] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class CatalogType:
"""
:ivar product:
:ivar local_element:
"""
product: List[ProductType] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=1,
max_occurs=9223372036854775807
)
)
local_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##local",
required=True
)
)
@dataclass
class Catalog(CatalogType):
class Meta:
name = "catalog"
Example 12-46 Overriding a default open content model¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:defaultOpenContent mode="suffix">
<xs:any namespace="##local" />
</xs:defaultOpenContent>
<xs:element name="catalog" type="CatalogType" />
<xs:complexType name="CatalogType">
<xs:openContent mode="none" />
<xs:sequence>
<xs:element name="product" type="ProductType" maxOccurs="unbounded" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar local_element:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
local_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##local",
required=True
)
)
@dataclass
class CatalogType:
"""
:ivar product:
"""
product: List[ProductType] = field(
default_factory=list,
metadata=dict(
type="Element",
namespace="",
min_occurs=1,
max_occurs=9223372036854775807
)
)
@dataclass
class Catalog(CatalogType):
class Meta:
name = "catalog"
Example 12-47 Complex type with attribute wildcard¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:sequence />
<xs:anyAttribute namespace="##other" processContents="lax" />
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from lxml.etree import QName
from typing import Dict
@dataclass
class ProductType:
"""
:ivar other_attributes:
"""
other_attributes: Dict[QName, str] = field(
default_factory=dict,
metadata=dict(
type="Attributes",
namespace="##other"
)
)
Samples Source
Definitive XML Schema by Priscilla Walmsley (c) 2012 Prentice Hall PTR