Chapter 13¶
Deriving 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 derived from other specified types.
</xsd:documentation>
</xsd:annotation>
<xsd:element name="items" type="ItemsType"/>
<xsd:complexType name="ItemsType">
<xsd:choice minOccurs="0" maxOccurs="unbounded">
<xsd:element name="hat" type="ProductType"/>
<xsd:element name="umbrella" type="RestrictedProductType"/>
<xsd:element name="shirt" type="ShirtType"/>
</xsd:choice>
</xsd:complexType>
<!--Empty Content Type-->
<xsd:complexType name="ItemType" abstract="true">
<xsd:attribute name="routingNum" type="xsd:integer"/>
</xsd:complexType>
<!--Empty Content Extension (with Attribute Extension)-->
<xsd:complexType name="ProductType">
<xsd:complexContent>
<xsd:extension base="ItemType">
<xsd:sequence>
<xsd:element name="number" type="xsd:integer"/>
<xsd:element name="name" type="xsd:string"/>
<xsd:element name="description" type="xsd:string" minOccurs="0"/>
</xsd:sequence>
<xsd:attribute name="effDate" type="xsd:date"/>
<xsd:attribute name="lang" type="xsd:language"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--Complex Content Restriction-->
<xsd:complexType name="RestrictedProductType">
<xsd:complexContent>
<xsd:restriction base="ProductType">
<xsd:sequence>
<xsd:element name="number" type="xsd:integer"/>
<xsd:element name="name" type="xsd:token"/>
</xsd:sequence>
<xsd:attribute name="routingNum" type="xsd:short" use="required"/>
<xsd:attribute name="effDate" type="xsd:date" default="1900-01-01"/>
<xsd:attribute name="lang" use="prohibited"/>
</xsd:restriction>
</xsd:complexContent>
</xsd:complexType>
<!--Complex Content Extension-->
<xsd:complexType name="ShirtType">
<xsd:complexContent>
<xsd:extension base="RestrictedProductType">
<xsd:choice maxOccurs="unbounded">
<xsd:element name="size" type="SmallSizeType"/>
<xsd:element name="color" type="ColorType"/>
</xsd:choice>
<xsd:attribute name="sleeve" type="xsd:integer"/>
</xsd:extension>
</xsd:complexContent>
</xsd:complexType>
<!--Simple Content Extension-->
<xsd:complexType name="SizeType">
<xsd:simpleContent>
<xsd:extension base="xsd:integer">
<xsd:attribute name="system" type="xsd:token"/>
</xsd:extension>
</xsd:simpleContent>
</xsd:complexType>
<!--Simple Content Restriction-->
<xsd:complexType name="SmallSizeType">
<xsd:simpleContent>
<xsd:restriction base="SizeType">
<xsd:minInclusive value="2"/>
<xsd:maxInclusive value="6"/>
<xsd:attribute name="system" type="xsd:token"
use="required"/>
</xsd:restriction>
</xsd:simpleContent>
</xsd:complexType>
<xsd:complexType name="ColorType">
<xsd:attribute name="value" type="xsd:string"/>
</xsd:complexType>
</xsd:schema>
XML Document
<items xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="chapter14.xsd">
<hat routingNum="123456" effDate="2002-04-02" lang="en-US">
<number>557</number>
<name>Ten-Gallon Hat</name>
<description>This is a great hat!</description>
</hat>
<umbrella routingNum="123" effDate="2002-04-02">
<number>557</number>
<name>Ten-Gallon Hat</name>
</umbrella>
<shirt routingNum="124" effDate="2002-04-02" sleeve="17">
<number>557</number>
<name>Short-Sleeved Linen Blouse</name>
<color value="blue"/>
<size system="US-DRESS">6</size>
</shirt>
</items>
xsData XML Document
<items>
<hat routingNum="123456" effDate="2002-04-02" lang="en-US">
<number>557</number>
<name>Ten-Gallon Hat</name>
<description>This is a great hat!</description>
</hat>
<umbrella routingNum="123" effDate="2002-04-02">
<number>557</number>
<name>Ten-Gallon Hat</name>
</umbrella>
<shirt routingNum="124" effDate="2002-04-02" sleeve="17">
<number>557</number>
<name>Short-Sleeved Linen Blouse</name>
<size system="US-DRESS">6</size>
<color value="blue"/>
</shirt>
</items>
xsData JSON
{
"hat": [
{
"routing_num": 123456,
"number": 557,
"name": "Ten-Gallon Hat",
"description": "This is a great hat!",
"eff_date": "2002-04-02",
"lang": "en-US"
}
],
"umbrella": [
{
"number": 557,
"name": "Ten-Gallon Hat",
"routing_num": 123,
"description": null,
"eff_date": "2002-04-02",
"lang": null
}
],
"shirt": [
{
"number": 557,
"name": "Short-Sleeved Linen Blouse",
"routing_num": 124,
"description": null,
"eff_date": "2002-04-02",
"lang": null,
"size": [
{
"value": 6,
"system": "US-DRESS"
}
],
"color": [
{
"value": "blue"
}
],
"sleeve": 17
}
]
}
Example 13-1 Simple content extension¶
<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 13-2 Complex content extension¶
<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:sequence>
</xs:complexType>
<xs:complexType name="ShirtType">
<xs:complexContent>
<xs:extension base="ProductType">
<xs:choice maxOccurs="unbounded">
<xs:element name="size" type="xs:integer" />
<xs:element name="color" type="xs:string" />
</xs:choice>
</xs:extension>
</xs:complexContent>
</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: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
@dataclass
class ShirtType(ProductType):
"""
:ivar size:
:ivar color:
"""
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 13-3 Effective content model of ShirtType¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ShirtType">
<xs:sequence>
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
<xs:choice maxOccurs="unbounded">
<xs:element name="size" type="xs:integer" />
<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 ShirtType:
"""
: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 13-4 choice group extension¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ItemsType">
<xs:choice maxOccurs="unbounded">
<xs:element ref="shirt" />
<xs:element ref="hat" />
<xs:element ref="umbrella" />
</xs:choice>
</xs:complexType>
<xs:complexType name="ExpandedItemsType">
<xs:complexContent>
<xs:extension base="ItemsType">
<xs:choice maxOccurs="unbounded">
<xs:element ref="sweater" />
<xs:element ref="suit" />
</xs:choice>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<xs:element name="product" type="ProductType" />
<xs:element name="shirt" type="ProductType" />
<xs:element name="hat" type="ProductType" />
<xs:element name="umbrella" type="ProductType" />
<xs:element name="sweater" type="ProductType" />
<xs:element name="suit" type="ProductType" />
<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:schema>
from dataclasses import dataclass, field
from typing import List, 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 Hat(ProductType):
class Meta:
name = "hat"
@dataclass
class Product(ProductType):
class Meta:
name = "product"
@dataclass
class Shirt(ProductType):
class Meta:
name = "shirt"
@dataclass
class Suit(ProductType):
class Meta:
name = "suit"
@dataclass
class Sweater(ProductType):
class Meta:
name = "sweater"
@dataclass
class Umbrella(ProductType):
class Meta:
name = "umbrella"
@dataclass
class ItemsType:
"""
:ivar shirt:
:ivar hat:
:ivar umbrella:
"""
shirt: List[Shirt] = field(
default_factory=list,
metadata=dict(
type="Element",
min_occurs=0,
max_occurs=9223372036854775807
)
)
hat: List[Hat] = field(
default_factory=list,
metadata=dict(
type="Element",
min_occurs=0,
max_occurs=9223372036854775807
)
)
umbrella: List[Umbrella] = field(
default_factory=list,
metadata=dict(
type="Element",
min_occurs=0,
max_occurs=9223372036854775807
)
)
@dataclass
class ExpandedItemsType(ItemsType):
"""
:ivar sweater:
:ivar suit:
"""
sweater: List[Sweater] = field(
default_factory=list,
metadata=dict(
type="Element",
min_occurs=0,
max_occurs=9223372036854775807
)
)
suit: List[Suit] = field(
default_factory=list,
metadata=dict(
type="Element",
min_occurs=0,
max_occurs=9223372036854775807
)
)
Example 13-5 all group extension¶
<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:all>
</xs:complexType>
<xs:complexType name="ShirtType">
<xs:complexContent>
<xs:extension base="ProductType">
<xs:all>
<xs:element name="size" type="xs:integer" />
<xs:element name="color" type="xs:string" />
</xs:all>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
"""
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 ShirtType(ProductType):
"""
:ivar size:
:ivar color:
"""
size: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
Example 13-6 Effective content model of ShirtType with all groups combined¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ShirtType">
<xs:all>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="size" type="xs:integer" />
<xs:element name="color" type="xs:string" />
</xs:all>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ShirtType:
"""
: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="",
required=True
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
Example 13-7 Extending open content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType">
<xs:openContent mode="suffix">
<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:complexType name="ShirtType">
<xs:complexContent>
<xs:extension base="ProductType">
<xs:openContent mode="suffix">
<xs:any namespace="##any" processContents="lax" />
</xs:openContent>
<xs:sequence>
<xs:element name="size" type="xs:integer" />
<xs:element name="color" type="xs:string" />
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar other_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
)
)
other_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##other",
required=True
)
)
@dataclass
class ShirtType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar color:
:ivar any_element:
:ivar other_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
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
any_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##any",
required=True
)
)
other_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##other",
required=True
)
)
Example 13-8 Mixed content extension¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="LetterType" mixed="true">
<xs:sequence>
<xs:element name="custName" type="xs:string" />
<xs:element name="prodName" type="xs:string" />
<xs:element name="prodSize" type="xs:integer" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="ExtendedLetterType" mixed="true">
<xs:complexContent>
<xs:extension base="LetterType">
<xs:sequence>
<xs:element name="prodNum" type="xs:string" />
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class LetterType:
"""
:ivar content:
:ivar cust_name:
:ivar prod_name:
:ivar prod_size:
"""
content: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##any"
)
)
cust_name: Optional[str] = field(
default=None,
metadata=dict(
name="custName",
type="Element",
namespace="",
required=True
)
)
prod_name: Optional[str] = field(
default=None,
metadata=dict(
name="prodName",
type="Element",
namespace="",
required=True
)
)
prod_size: Optional[int] = field(
default=None,
metadata=dict(
name="prodSize",
type="Element",
namespace="",
required=True
)
)
@dataclass
class ExtendedLetterType(LetterType):
"""
:ivar content:
:ivar prod_num:
"""
content: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##any"
)
)
prod_num: Optional[str] = field(
default=None,
metadata=dict(
name="prodNum",
type="Element",
namespace="",
required=True
)
)
Example 13-9 Empty content extension¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ItemType">
<xs:attribute name="routingNum" type="xs:integer" />
</xs:complexType>
<xs:complexType name="ProductType">
<xs:complexContent>
<xs:extension base="ItemType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ItemType:
"""
:ivar routing_num:
"""
routing_num: Optional[int] = field(
default=None,
metadata=dict(
name="routingNum",
type="Attribute"
)
)
@dataclass
class ProductType(ItemType):
"""
:ivar number:
:ivar name:
"""
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 13-10 Attribute extension¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ItemType">
<xs:attribute name="id" type="xs:ID" use="required" />
<xs:attribute ref="xml:lang" />
</xs:complexType>
<xs:complexType name="ProductType">
<xs:complexContent>
<xs:extension base="ItemType">
<xs:attribute name="effDate" type="xs:date" />
<xs:attribute name="lang" type="xs:language" />
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ItemType:
"""
:ivar id:
:ivar lang:
"""
id: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
required=True
)
)
lang: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
namespace="http://www.w3.org/XML/1998/namespace"
)
)
@dataclass
class ProductType(ItemType):
"""
:ivar eff_date:
:ivar lang:
"""
eff_date: Optional[str] = field(
default=None,
metadata=dict(
name="effDate",
type="Attribute"
)
)
lang: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
Example 13-11 Attribute wildcard extension¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="BaseType">
<xs:anyAttribute processContents="lax" namespace="##local http://datypic.com/prod" />
</xs:complexType>
<xs:complexType name="DerivedType">
<xs:complexContent>
<xs:extension base="BaseType">
<xs:anyAttribute processContents="strict" namespace="##targetNamespace http://www.w3.org/1999/xhtml" />
</xs:extension>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from lxml.etree import QName
from typing import Dict
@dataclass
class BaseType:
"""
:ivar datypic_com_prod_attributes:
"""
datypic_com_prod_attributes: Dict[QName, str] = field(
default_factory=dict,
metadata=dict(
type="Attributes",
namespace="##local http://datypic.com/prod"
)
)
@dataclass
class DerivedType(BaseType):
"""
:ivar www_w3_org_1999_xhtml_attributes:
"""
www_w3_org_1999_xhtml_attributes: Dict[QName, str] = field(
default_factory=dict,
metadata=dict(
type="Attributes",
namespace="##targetNamespace http://www.w3.org/1999/xhtml"
)
)
Example 13-12 Effective attribute wildcard¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="DerivedType">
<xs:anyAttribute processContents="strict" namespace="##local http://datypic.com/prod ##targetNamespace http://www.w3.org/1999/xhtml" />
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from lxml.etree import QName
from typing import Dict
@dataclass
class DerivedType:
"""
:ivar datypic_com_prod_target_namespace_http_www_w3_org_1999_xhtml_attributes:
"""
datypic_com_prod_target_namespace_http_www_w3_org_1999_xhtml_attributes: Dict[QName, str] = field(
default_factory=dict,
metadata=dict(
type="Attributes",
namespace="##local http://datypic.com/prod ##targetNamespace http://www.w3.org/1999/xhtml"
)
)
Example 13-13 Simple content restriction¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="SmallSizeType">
<xs:simpleContent>
<xs:restriction base="xs:integer">
<xs:minInclusive value="2" />
<xs:maxInclusive value="6" />
<xs:attribute name="system" type="xs:token" use="required" />
</xs:restriction>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class SmallSizeType:
"""
:ivar value:
:ivar system:
"""
value: Optional[int] = field(
default=None,
metadata=dict(
min_inclusive=2.0,
max_inclusive=6.0
)
)
system: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
required=True
)
)
Example 13-14 Complex content restriction¶
<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" minOccurs="0" />
<xs:element name="color" type="xs:string" minOccurs="0" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="RestrictedProductType">
<xs:complexContent>
<xs:restriction base="ProductType">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:restriction>
</xs:complexContent>
</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=""
)
)
@dataclass
class RestrictedProductType:
"""
: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 13-26 Restricting open content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="BaseType">
<xs:openContent mode="suffix">
<xs:any namespace="http://datypic.com/prod http://datypic.com/ord" />
</xs:openContent>
<xs:sequence>
<xs:element name="a" type="xs:string" minOccurs="0" />
</xs:sequence>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class BaseType:
"""
:ivar a:
:ivar datypic_com_prod_http_datypic_com_ord_element:
"""
a: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
datypic_com_prod_http_datypic_com_ord_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="http://datypic.com/prod http://datypic.com/ord",
required=True
)
)
Example 13-26 Restricting open content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:import schemaLocation="example13261.xsd" />
<xs:complexType name="LegalDerivedType">
<xs:complexContent>
<xs:restriction base="BaseType">
<xs:openContent mode="suffix">
<xs:any namespace="http://datypic.com/prod" />
</xs:openContent>
<xs:sequence>
<xs:element name="a" type="xs:string" minOccurs="0" />
</xs:sequence>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class LegalDerivedType:
"""
:ivar a:
:ivar datypic_com_prod_element:
:ivar datypic_com_prod_http_datypic_com_ord_element:
"""
a: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
datypic_com_prod_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="http://datypic.com/prod",
required=True
)
)
datypic_com_prod_http_datypic_com_ord_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="http://datypic.com/prod http://datypic.com/ord",
required=True
)
)
Example 13-26 Restricting open content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:import schemaLocation="example13261.xsd" />
<xs:complexType name="IlegalDerivedType">
<xs:complexContent>
<xs:restriction base="BaseType">
<xs:openContent mode="interleave">
<xs:any namespace="##any" />
</xs:openContent>
<xs:sequence>
<xs:element name="a" type="xs:string" minOccurs="0" />
</xs:sequence>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class IlegalDerivedType:
"""
:ivar any_element:
:ivar a:
:ivar datypic_com_prod_http_datypic_com_ord_element:
"""
any_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##any",
required=True
)
)
a: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace=""
)
)
datypic_com_prod_http_datypic_com_ord_element: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="http://datypic.com/prod http://datypic.com/ord",
required=True
)
)
Example 13-27 Mixed content restriction¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="LetterType" mixed="true">
<xs:sequence>
<xs:element name="custName" type="xs:string" />
<xs:element name="prodName" type="xs:string" />
<xs:element name="prodSize" type="xs:integer" minOccurs="0" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="RestrictedLetterType" mixed="true">
<xs:complexContent>
<xs:restriction base="LetterType">
<xs:sequence>
<xs:element name="custName" type="xs:string" />
<xs:element name="prodName" type="xs:string" />
</xs:sequence>
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class LetterType:
"""
:ivar content:
:ivar cust_name:
:ivar prod_name:
:ivar prod_size:
"""
content: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##any"
)
)
cust_name: Optional[str] = field(
default=None,
metadata=dict(
name="custName",
type="Element",
namespace="",
required=True
)
)
prod_name: Optional[str] = field(
default=None,
metadata=dict(
name="prodName",
type="Element",
namespace="",
required=True
)
)
prod_size: Optional[int] = field(
default=None,
metadata=dict(
name="prodSize",
type="Element",
namespace=""
)
)
@dataclass
class RestrictedLetterType:
"""
:ivar content:
:ivar cust_name:
:ivar prod_name:
:ivar prod_size:
"""
content: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##any"
)
)
cust_name: Optional[str] = field(
default=None,
metadata=dict(
name="custName",
type="Element",
namespace="",
required=True
)
)
prod_name: Optional[str] = field(
default=None,
metadata=dict(
name="prodName",
type="Element",
namespace="",
required=True
)
)
prod_size: Optional[int] = field(
default=None,
metadata=dict(
name="prodSize",
type="Element",
namespace=""
)
)
Example 13-28 Mixed content restricted to simple content¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="LetterType" mixed="true">
<xs:sequence minOccurs="0">
<xs:element name="custName" type="xs:string" />
<xs:element name="prodName" type="xs:string" />
<xs:element name="prodSize" type="xs:integer" />
</xs:sequence>
</xs:complexType>
<xs:complexType name="RestrictedLetterType">
<xs:simpleContent>
<xs:restriction base="LetterType">
<xs:simpleType>
<xs:restriction base="xs:string" />
</xs:simpleType>
</xs:restriction>
</xs:simpleContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class LetterType:
"""
:ivar content:
:ivar cust_name:
:ivar prod_name:
:ivar prod_size:
"""
content: Optional[object] = field(
default=None,
metadata=dict(
type="Wildcard",
namespace="##any"
)
)
cust_name: Optional[str] = field(
default=None,
metadata=dict(
name="custName",
type="Element",
namespace=""
)
)
prod_name: Optional[str] = field(
default=None,
metadata=dict(
name="prodName",
type="Element",
namespace=""
)
)
prod_size: Optional[int] = field(
default=None,
metadata=dict(
name="prodSize",
type="Element",
namespace=""
)
)
@dataclass
class RestrictedLetterType(LetterType):
"""
:ivar value:
"""
value: Optional[str] = field(
default=None,
)
Example 13-29 Empty content restriction¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ItemType">
<xs:attribute name="routingNum" type="xs:integer" />
</xs:complexType>
<xs:complexType name="RestrictedItemType">
<xs:complexContent>
<xs:restriction base="ItemType">
<xs:attribute name="routingNum" type="xs:short" />
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ItemType:
"""
:ivar routing_num:
"""
routing_num: Optional[int] = field(
default=None,
metadata=dict(
name="routingNum",
type="Attribute"
)
)
@dataclass
class RestrictedItemType:
"""
:ivar routing_num:
"""
routing_num: Optional[int] = field(
default=None,
metadata=dict(
name="routingNum",
type="Attribute"
)
)
Example 13-30 Legal restrictions of attributes¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="BaseType">
<xs:attribute name="a" type="xs:integer" />
<xs:attribute name="b" type="xs:string" />
<xs:attribute name="c" type="xs:string" default="c" />
<xs:attribute name="d" type="xs:string" />
<xs:attribute name="e" type="xs:string" fixed="e" />
<xs:attribute name="f" type="xs:string" />
<xs:attribute name="g" type="xs:string" />
<xs:attribute name="x" type="xs:string" />
</xs:complexType>
<xs:complexType name="DerivedType">
<xs:complexContent>
<xs:restriction base="BaseType">
<xs:attribute name="a" type="xs:positiveInteger" />
<xs:attribute name="b" type="xs:string" default="b" />
<xs:attribute name="c" type="xs:string" default="c2" />
<xs:attribute name="d" type="xs:string" fixed="d" />
<xs:attribute name="e" type="xs:string" fixed="e" />
<xs:attribute name="f" type="xs:string" use="required" />
<xs:attribute name="g" type="xs:string" use="prohibited" />
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class BaseType:
"""
:ivar a:
:ivar b:
:ivar c:
:ivar d:
:ivar e:
:ivar f:
:ivar g:
:ivar x:
"""
a: Optional[int] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
b: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
c: str = field(
default="c",
metadata=dict(
type="Attribute"
)
)
d: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
e: str = field(
init=False,
default="e",
metadata=dict(
type="Attribute"
)
)
f: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
g: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
x: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
@dataclass
class DerivedType:
"""
:ivar a:
:ivar b:
:ivar c:
:ivar d:
:ivar e:
:ivar f:
:ivar g:
:ivar x:
"""
a: Optional[int] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
b: str = field(
default="b",
metadata=dict(
type="Attribute"
)
)
c: str = field(
default="c2",
metadata=dict(
type="Attribute"
)
)
d: str = field(
init=False,
default="d",
metadata=dict(
type="Attribute"
)
)
e: str = field(
init=False,
default="e",
metadata=dict(
type="Attribute"
)
)
f: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
required=True
)
)
g: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
x: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
Example 13-32 Restricting an attribute wildcard¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="BaseType">
<xs:anyAttribute processContents="lax" namespace="##any" />
</xs:complexType>
<xs:complexType name="DerivedType">
<xs:complexContent>
<xs:restriction base="BaseType">
<xs:anyAttribute processContents="strict" namespace="##targetNamespace http://www.w3.org/1999/xhtml" />
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from lxml.etree import QName
from typing import Dict
@dataclass
class BaseType:
"""
:ivar any_attributes:
"""
any_attributes: Dict[QName, str] = field(
default_factory=dict,
metadata=dict(
type="Attributes",
namespace="##any"
)
)
@dataclass
class DerivedType(BaseType):
"""
:ivar www_w3_org_1999_xhtml_attributes:
"""
www_w3_org_1999_xhtml_attributes: Dict[QName, str] = field(
default_factory=dict,
metadata=dict(
type="Attributes",
namespace="##targetNamespace http://www.w3.org/1999/xhtml"
)
)
Example 13-33 Replacing an attribute wildcard with attributes¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="BaseType">
<xs:anyAttribute processContents="lax" namespace="##any" />
</xs:complexType>
<xs:complexType name="DerivedType">
<xs:complexContent>
<xs:restriction base="BaseType">
<xs:attribute name="id" type="xs:ID" use="required" />
<xs:attribute name="name" type="xs:string" />
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from lxml.etree import QName
from typing import Dict, Optional
@dataclass
class BaseType:
"""
:ivar any_attributes:
"""
any_attributes: Dict[QName, str] = field(
default_factory=dict,
metadata=dict(
type="Attributes",
namespace="##any"
)
)
@dataclass
class DerivedType(BaseType):
"""
:ivar id:
:ivar name:
"""
id: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute"
)
)
Example 13-34 Restricting a type from another namespace with global declarations¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://datypic.com/prod" xmlns:prod="http://datypic.com/prod" elementFormDefault="qualified" attributeFormDefault="qualified">
<xs:complexType name="ProductType">
<xs:sequence>
<xs:element ref="prod:number" />
<xs:element ref="prod:name" />
<xs:element ref="prod:size" minOccurs="0" />
</xs:sequence>
<xs:attribute ref="prod:dept" />
</xs:complexType>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
<xs:element name="size" type="xs:integer" />
<xs:attribute name="dept" type="xs:string" />
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
__NAMESPACE__ = "http://datypic.com/prod"
@dataclass
class Name:
"""
:ivar value:
"""
class Meta:
name = "name"
namespace = "http://datypic.com/prod"
value: Optional[str] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Number:
"""
:ivar value:
"""
class Meta:
name = "number"
namespace = "http://datypic.com/prod"
value: Optional[int] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class Size:
"""
:ivar value:
"""
class Meta:
name = "size"
namespace = "http://datypic.com/prod"
value: Optional[int] = field(
default=None,
metadata=dict(
required=True
)
)
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar dept:
"""
number: Optional[Number] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
name: Optional[Name] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
size: Optional[Size] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod"
)
)
dept: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
namespace="http://datypic.com/prod"
)
)
Example 13-34 Restricting a type from another namespace with global declarations¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://datypic.com/ord" xmlns:prod="http://datypic.com/prod">
<xs:import namespace="http://datypic.com/prod" schemaLocation="example13341.xsd" />
<xs:complexType name="RestrictedProductType">
<xs:complexContent>
<xs:restriction base="prod:ProductType">
<xs:sequence>
<xs:element ref="prod:number" />
<xs:element ref="prod:name" />
</xs:sequence>
<xs:attribute ref="prod:dept" use="required" />
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
from tests.fixtures.defxmlschema.chapter13.example13341 import (
Name,
Number,
Size,
)
__NAMESPACE__ = "http://datypic.com/ord"
@dataclass
class RestrictedProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar dept:
"""
number: Optional[Number] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
name: Optional[Name] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
size: Optional[Size] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod"
)
)
dept: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
namespace="http://datypic.com/prod",
required=True
)
)
Example 13-35 Using targetNamespace on element and attribute declarations¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://datypic.com/prod" elementFormDefault="qualified" attributeFormDefault="qualified">
<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" minOccurs="0" />
</xs:sequence>
<xs:attribute name="dept" type="xs:string" />
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
__NAMESPACE__ = "http://datypic.com/prod"
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar dept:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod"
)
)
dept: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
namespace="http://datypic.com/prod"
)
)
Example 13-35 Using targetNamespace on element and attribute declarations¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://datypic.com/ord" xmlns:prod="http://datypic.com/prod" elementFormDefault="qualified" attributeFormDefault="qualified">
<xs:import namespace="http://datypic.com/prod" schemaLocation="example13351.xsd" />
<xs:complexType name="RestrictedProductType">
<xs:complexContent>
<xs:restriction base="prod:ProductType">
<xs:sequence>
<xs:element name="number" type="xs:string" targetNamespace="http://datypic.com/prod" />
<xs:element name="name" type="xs:string" targetNamespace="http://datypic.com/prod" />
</xs:sequence>
<xs:attribute name="dept" type="xs:string" use="required" targetNamespace="http://datypic.com/prod" />
</xs:restriction>
</xs:complexContent>
</xs:complexType>
</xs:schema>
from dataclasses import dataclass, field
from typing import Optional
__NAMESPACE__ = "http://datypic.com/ord"
@dataclass
class RestrictedProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar dept:
"""
number: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
type="Element",
namespace="http://datypic.com/prod"
)
)
dept: Optional[str] = field(
default=None,
metadata=dict(
type="Attribute",
namespace="http://datypic.com/prod",
required=True
)
)
Example 13-36 A derived 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:sequence>
</xs:complexType>
<xs:element name="product" type="ProductType" />
<xs:complexType name="ShirtType">
<xs:complexContent>
<xs:extension base="ProductType">
<xs:choice maxOccurs="unbounded">
<xs:element name="size" type="xs:integer" />
<xs:element name="color" type="xs:string" />
</xs:choice>
</xs:extension>
</xs:complexContent>
</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: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
@dataclass
class ShirtType(ProductType):
"""
:ivar size:
:ivar color:
"""
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
)
)
@dataclass
class Product(ProductType):
class Meta:
name = "product"
Example 13-38 Preventing derivation¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType" final="#all">
<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 ProductType:
"""
:ivar number:
:ivar name:
"""
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 13-39 Preventing substitution of derived types¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType" block="extension">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:element name="product" type="ProductType" />
<xs:complexType name="ShirtType">
<xs:complexContent>
<xs:extension base="ProductType">
<xs:choice maxOccurs="unbounded">
<xs:element name="size" type="xs:integer" />
<xs:element name="color" type="xs:string" />
</xs:choice>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<xs:element name="shirt" type="ShirtType" />
</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: Optional[str] = field(
default=None,
metadata=dict(
type="Element",
namespace="",
required=True
)
)
@dataclass
class ShirtType(ProductType):
"""
:ivar size:
:ivar color:
"""
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
)
)
@dataclass
class Product(ProductType):
class Meta:
name = "product"
@dataclass
class Shirt(ShirtType):
class Meta:
name = "shirt"
Example 13-41 An abstract type¶
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name="ProductType" abstract="true">
<xs:sequence>
<xs:element name="number" type="xs:integer" />
<xs:element name="name" type="xs:string" />
</xs:sequence>
</xs:complexType>
<xs:element name="product" type="ProductType" />
<xs:complexType name="ShirtType">
<xs:complexContent>
<xs:extension base="ProductType">
<xs:choice maxOccurs="unbounded">
<xs:element name="size" type="xs:integer" />
<xs:element name="color" type="xs:string" />
</xs:choice>
</xs:extension>
</xs:complexContent>
</xs:complexType>
<xs:element name="shirt" type="ShirtType" />
</xs:schema>
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class ShirtType:
"""
: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
)
)
@dataclass
class Product:
"""
:ivar number:
:ivar name:
"""
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
)
)
@dataclass
class Shirt(ShirtType):
class Meta:
name = "shirt"
Samples Source
Definitive XML Schema by Priscilla Walmsley (c) 2012 Prentice Hall PTR