defxmlschema/chapter12

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(
            name="value",
            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 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(
            name="value",
            type="Extension"
        )
    )


@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[Union[int, str]] = field(
        default=None,
        metadata=dict(
            name="value",
            type="Union",
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )


@dataclass
class ProductType:
    """
    :ivar number:
    :ivar name:
    :ivar size:
    :ivar color:
    """
    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
        )
    )
    size: Optional[Size] = field(
        default=None,
        metadata=dict(
            name="size",
            type="Element"
        )
    )
    color: Optional[Color] = field(
        default=None,
        metadata=dict(
            name="color",
            type="Element"
        )
    )

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 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(
            name="number",
            type="Element",
            required=True
        )
    )
    name: Optional[str] = field(
        default=None,
        metadata=dict(
            name="name",
            type="Element",
            required=True
        )
    )
    size: Optional[Union[int, str]] = field(
        default=None,
        metadata=dict(
            name="size",
            type="Element",
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )
    color: Optional[str] = field(
        default=None,
        metadata=dict(
            name="color",
            type="Element"
        )
    )

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(
            name="number",
            type="Element",
            required=True
        )
    )
    name: Optional[str] = field(
        default=None,
        metadata=dict(
            name="name",
            type="Element",
            required=True
        )
    )
    color: List[str] = field(
        default_factory=list,
        metadata=dict(
            name="color",
            type="Element",
            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(
            name="shirt",
            type="Element"
        )
    )
    hat: Optional[HatType] = field(
        default=None,
        metadata=dict(
            name="hat",
            type="Element"
        )
    )
    umbrella: Optional[UmbrellaType] = field(
        default=None,
        metadata=dict(
            name="umbrella",
            type="Element"
        )
    )

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(
            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 Product(ProductType):
    class Meta:
        name = "product"

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 Optional
from tests.fixtures.defxmlschema.chapter16.example1607 import (
    HatType,
    ShirtType,
    UmbrellaType,
)


@dataclass
class ItemsType:
    """
    :ivar shirt:
    :ivar umbrella:
    :ivar hat:
    """
    shirt: Optional[ShirtType] = field(
        default=None,
        metadata=dict(
            name="shirt",
            type="Element"
        )
    )
    umbrella: Optional[UmbrellaType] = field(
        default=None,
        metadata=dict(
            name="umbrella",
            type="Element"
        )
    )
    hat: Optional[HatType] = field(
        default=None,
        metadata=dict(
            name="hat",
            type="Element"
        )
    )

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

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(
            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 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(
            name="description",
            type="Element",
            required=True
        )
    )
    comment: Optional[str] = field(
        default=None,
        metadata=dict(
            name="comment",
            type="Element"
        )
    )
    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 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(
            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
        )
    )

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 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(
            name="id",
            type="Attribute",
            required=True
        )
    )
    version: Optional[float] = field(
        default=None,
        metadata=dict(
            name="version",
            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 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 Color:
    """
    :ivar value:
    """
    class Meta:
        name = "color"

    value: Optional[str] = field(
        default=None,
        metadata=dict(
            name="value",
            type="Extension"
        )
    )


@dataclass
class Desc:
    """
    :ivar value:
    """
    class Meta:
        name = "desc"

    value: Optional[str] = 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 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 Optional


@dataclass
class DescriptionType:
    """
    :ivar value:
    """
    value: Optional[str] = field(
        default=None,
        metadata=dict(
            name="value",
            type="Extension"
        )
    )

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 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 Color:
    """
    :ivar value:
    """
    class Meta:
        name = "color"

    value: Optional[str] = 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 Product(ProductType):
    class Meta:
        name = "product"

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,
        metadata=dict(
            name="value",
            type="Extension"
        )
    )
    system: Optional[str] = field(
        default=None,
        metadata=dict(
            name="system",
            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 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(
            name="number",
            type="Element",
            required=True
        )
    )
    name: Optional[str] = field(
        default=None,
        metadata=dict(
            name="name",
            type="Element",
            required=True
        )
    )
    size: Optional[Union[int, str]] = field(
        default=None,
        metadata=dict(
            name="size",
            type="Element",
            required=True,
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )
    color: Optional[str] = field(
        default=None,
        metadata=dict(
            name="color",
            type="Element",
            required=True
        )
    )

Samples Source

Definitive XML Schema by Priscilla Walmsley (c) 2012 Prentice Hall PTR