defxmlschema/chapter13¶
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,
metadata=dict(
name="value",
type="Extension"
)
)
system: Optional[str] = field(
default=None,
metadata=dict(
name="system",
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 typing import Optional
@dataclass
class BaseType:
"""
:ivar value:
"""
value: Optional[str] = field(
default=None,
metadata=dict(
name="value",
type="Extension"
)
)
@dataclass
class DerivedType(BaseType):
pass
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 typing import Optional
@dataclass
class DerivedType:
"""
:ivar value:
"""
value: Optional[str] = field(
default=None,
metadata=dict(
name="value",
type="Extension"
)
)
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(
name="value",
type="Extension"
)
)
system: Optional[str] = field(
default=None,
metadata=dict(
name="system",
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(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element"
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
name="color",
type="Element"
)
)
@dataclass
class RestrictedProductType(ProductType):
"""
:ivar number:
:ivar name:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
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 Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
@dataclass
class ShirtType(ProductType):
"""
:ivar size:
:ivar color:
"""
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element"
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
name="color",
type="Element"
)
)
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 cust_name:
:ivar prod_name:
:ivar prod_size:
"""
cust_name: Optional[str] = field(
default=None,
metadata=dict(
name="custName",
type="Element",
required=True
)
)
prod_name: Optional[str] = field(
default=None,
metadata=dict(
name="prodName",
type="Element",
required=True
)
)
prod_size: Optional[int] = field(
default=None,
metadata=dict(
name="prodSize",
type="Element"
)
)
@dataclass
class RestrictedLetterType(LetterType):
"""
:ivar cust_name:
:ivar prod_name:
"""
cust_name: Optional[str] = field(
default=None,
metadata=dict(
name="custName",
type="Element",
required=True
)
)
prod_name: Optional[str] = field(
default=None,
metadata=dict(
name="prodName",
type="Element",
required=True
)
)
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 cust_name:
:ivar prod_name:
:ivar prod_size:
"""
cust_name: Optional[str] = field(
default=None,
metadata=dict(
name="custName",
type="Element",
required=True
)
)
prod_name: Optional[str] = field(
default=None,
metadata=dict(
name="prodName",
type="Element",
required=True
)
)
prod_size: Optional[int] = field(
default=None,
metadata=dict(
name="prodSize",
type="Element",
required=True
)
)
@dataclass
class RestrictedLetterType:
"""
:ivar value:
"""
value: Optional[str] = field(
default=None,
metadata=dict(
name="value",
type="Restriction"
)
)
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(ItemType):
"""
:ivar routing_num:
"""
routing_num: Optional[int] = field(
default=None,
metadata=dict(
name="routingNum",
type="Attribute"
)
)
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 Optional
@dataclass
class ShirtType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar color:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element"
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
name="color",
type="Element"
)
)
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(
name="a",
type="Attribute"
)
)
b: Optional[str] = field(
default=None,
metadata=dict(
name="b",
type="Attribute"
)
)
c: str = field(
default="c",
metadata=dict(
name="c",
type="Attribute"
)
)
d: Optional[str] = field(
default=None,
metadata=dict(
name="d",
type="Attribute"
)
)
e: Optional[str] = field(
default=None,
metadata=dict(
name="e",
type="Attribute"
)
)
f: Optional[str] = field(
default=None,
metadata=dict(
name="f",
type="Attribute"
)
)
g: Optional[str] = field(
default=None,
metadata=dict(
name="g",
type="Attribute"
)
)
x: Optional[str] = field(
default=None,
metadata=dict(
name="x",
type="Attribute"
)
)
@dataclass
class DerivedType(BaseType):
"""
:ivar a:
:ivar b:
:ivar c:
:ivar d:
:ivar e:
:ivar f:
:ivar g:
"""
a: Optional[int] = field(
default=None,
metadata=dict(
name="a",
type="Attribute"
)
)
b: str = field(
default="b",
metadata=dict(
name="b",
type="Attribute"
)
)
c: str = field(
default="c2",
metadata=dict(
name="c",
type="Attribute"
)
)
d: Optional[str] = field(
default=None,
metadata=dict(
name="d",
type="Attribute"
)
)
e: Optional[str] = field(
default=None,
metadata=dict(
name="e",
type="Attribute"
)
)
f: Optional[str] = field(
default=None,
metadata=dict(
name="f",
type="Attribute",
required=True
)
)
g: Optional[str] = field(
default=None,
metadata=dict(
name="g",
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 typing import Optional
@dataclass
class BaseType:
"""
:ivar value:
"""
value: Optional[str] = field(
default=None,
metadata=dict(
name="value",
type="Extension"
)
)
@dataclass
class DerivedType(BaseType):
pass
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 typing import Optional
@dataclass
class BaseType:
"""
:ivar value:
"""
value: Optional[str] = field(
default=None,
metadata=dict(
name="value",
type="Extension"
)
)
@dataclass
class DerivedType(BaseType):
"""
:ivar id:
:ivar name:
"""
id: Optional[str] = field(
default=None,
metadata=dict(
name="id",
type="Attribute",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
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
@dataclass
class Name:
"""
:ivar value:
"""
class Meta:
name = "name"
value: Optional[str] = field(
default=None,
metadata=dict(
name="value",
type="Extension"
)
)
@dataclass
class Number:
"""
:ivar value:
"""
class Meta:
name = "number"
value: Optional[int] = field(
default=None,
metadata=dict(
name="value",
type="Extension"
)
)
@dataclass
class Size:
"""
:ivar value:
"""
class Meta:
name = "size"
value: Optional[int] = field(
default=None,
metadata=dict(
name="value",
type="Extension"
)
)
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar dept:
"""
number: Optional[Number] = field(
default=None,
metadata=dict(
name="number",
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
name: Optional[Name] = field(
default=None,
metadata=dict(
name="name",
type="Element",
namespace="http://datypic.com/prod",
required=True
)
)
size: Optional[Size] = field(
default=None,
metadata=dict(
name="size",
type="Element",
namespace="http://datypic.com/prod"
)
)
dept: Optional[str] = field(
default=None,
metadata=dict(
name="dept",
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 (
ProductType,
Name,
Number,
)
@dataclass
class RestrictedProductType(ProductType):
"""
:ivar number:
:ivar name:
:ivar dept:
"""
number: Optional[Number] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[Name] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
dept: Optional[str] = field(
default=None,
metadata=dict(
name="dept",
type="Attribute",
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
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar dept:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element"
)
)
dept: Optional[str] = field(
default=None,
metadata=dict(
name="dept",
type="Attribute"
)
)
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
from tests.fixtures.defxmlschema.chapter13.example13351 import (
ProductType,
)
@dataclass
class RestrictedProductType(ProductType):
"""
:ivar number:
:ivar name:
:ivar dept:
"""
number: Optional[str] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
dept: Optional[str] = field(
default=None,
metadata=dict(
name="dept",
type="Attribute",
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 Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
@dataclass
class ShirtType(ProductType):
"""
:ivar size:
:ivar color:
"""
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element"
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
name="color",
type="Element"
)
)
@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(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
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 Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
@dataclass
class ShirtType(ProductType):
"""
:ivar size:
:ivar color:
"""
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element"
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
name="color",
type="Element"
)
)
@dataclass
class Product(ProductType):
class Meta:
name = "product"
@dataclass
class Shirt(ShirtType):
class Meta:
name = "shirt"
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 Optional
@dataclass
class ProductType:
"""
:ivar number:
:ivar name:
:ivar size:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element",
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: Optional[Shirt] = field(
default=None,
metadata=dict(
name="shirt",
type="Element"
)
)
hat: Optional[Hat] = field(
default=None,
metadata=dict(
name="hat",
type="Element"
)
)
umbrella: Optional[Umbrella] = field(
default=None,
metadata=dict(
name="umbrella",
type="Element"
)
)
@dataclass
class ExpandedItemsType(ItemsType):
"""
:ivar sweater:
:ivar suit:
"""
sweater: Optional[Sweater] = field(
default=None,
metadata=dict(
name="sweater",
type="Element"
)
)
suit: Optional[Suit] = field(
default=None,
metadata=dict(
name="suit",
type="Element"
)
)
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 Optional
@dataclass
class ShirtType:
"""
:ivar number:
:ivar name:
:ivar size:
:ivar color:
"""
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element"
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
name="color",
type="Element"
)
)
@dataclass
class Product:
"""
:ivar number:
:ivar name:
"""
class Meta:
name = "product"
number: Optional[int] = field(
default=None,
metadata=dict(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
@dataclass
class Shirt(ShirtType):
class Meta:
name = "shirt"
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(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
@dataclass
class ShirtType(ProductType):
"""
:ivar size:
:ivar color:
"""
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element",
required=True
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
name="color",
type="Element",
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(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
size: Optional[int] = field(
default=None,
metadata=dict(
name="size",
type="Element",
required=True
)
)
color: Optional[str] = field(
default=None,
metadata=dict(
name="color",
type="Element",
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 cust_name:
:ivar prod_name:
:ivar prod_size:
"""
cust_name: Optional[str] = field(
default=None,
metadata=dict(
name="custName",
type="Element",
required=True
)
)
prod_name: Optional[str] = field(
default=None,
metadata=dict(
name="prodName",
type="Element",
required=True
)
)
prod_size: Optional[int] = field(
default=None,
metadata=dict(
name="prodSize",
type="Element",
required=True
)
)
@dataclass
class ExtendedLetterType(LetterType):
"""
:ivar prod_num:
"""
prod_num: Optional[str] = field(
default=None,
metadata=dict(
name="prodNum",
type="Element",
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(
name="number",
type="Element",
required=True
)
)
name: Optional[str] = field(
default=None,
metadata=dict(
name="name",
type="Element",
required=True
)
)
Samples Source
Definitive XML Schema by Priscilla Walmsley (c) 2012 Prentice Hall PTR