Skip to content

xsData defxmlschema/chapter10

defxmlschema/chapter10¶

Example 10-1 Defining a union type¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:simpleType name="SizeType">
    <xs:union>
      <xs:simpleType>
        <xs:restriction base="xs:integer">
          <xs:minInclusive value="2" />
          <xs:maxInclusive value="18" />
        </xs:restriction>
      </xs:simpleType>
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="small" />
          <xs:enumeration value="medium" />
          <xs:enumeration value="large" />
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:element name="Size" type="SizeType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import Optional, Union


@dataclass
class Size:
    """
    :ivar value:
    """
    value: Optional[Union[int, str]] = field(
        default=None,
        metadata=dict(
            name="value",
            type="Union",
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import schemaLocation="../chapter08/example0810.xsd" />
  <xs:simpleType name="AvailableSizesType">
    <xs:restriction>
      <xs:simpleType>
        <xs:list itemType="SMLSizeType" />
      </xs:simpleType>
      <xs:maxLength value="3" />
    </xs:restriction>
  </xs:simpleType>
  <xs:element name="AvailableSizesType" type="AvailableSizesType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import Optional
from tests.fixtures.defxmlschema.chapter08.example0810 import (
    SmlsizeType,
)


@dataclass
class AvailableSizesType:
    """
    :ivar value:
    """
    value: Optional[SmlsizeType] = field(
        default=None,
        metadata=dict(
            name="value",
            type="Restriction",
            max_length=3.0
        )
    )

Example 10-13 Enumeration applied to the item type of a list¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:simpleType name="AvailableSizesType">
    <xs:list>
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="small" />
          <xs:enumeration value="medium" />
          <xs:enumeration value="large" />
        </xs:restriction>
      </xs:simpleType>
    </xs:list>
  </xs:simpleType>
  <xs:element name="AvailableSizesType" type="AvailableSizesType" />
</xs:schema>

from enum import Enum
from dataclasses import dataclass, field
from typing import List


@dataclass
class AvailableSizesType:
    """
    :ivar value:
    """
    value: List["AvailableSizesType.Value"] = field(
        default_factory=list,
        metadata=dict(
            name="value",
            type="List",
            min_occurs=0,
            max_occurs=9223372036854775807
        )
    )

    class Value(Enum):
        """
        :cvar SMALL:
        :cvar MEDIUM:
        :cvar LARGE:
        """
        SMALL = "small"
        MEDIUM = "medium"
        LARGE = "large"

Example 10-14 Enumeration correctly applied to a list type¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:include schemaLocation="example1002.xsd" />
  <xs:simpleType name="ApplicableSizesType">
    <xs:restriction>
      <xs:simpleType>
        <xs:list itemType="SizeType" />
      </xs:simpleType>
      <xs:enumeration value="small medium large" />
      <xs:enumeration value="2 4 6 8 10 12 14 16 18" />
    </xs:restriction>
  </xs:simpleType>
  <xs:element name="ApplicableSizesType" type="ApplicableSizesType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import List, Union
from tests.fixtures.defxmlschema.chapter08.example0810 import (
    SmlsizeType,
)


@dataclass
class ApplicableSizesType:
    """
    :ivar value:
    :ivar small_medium_large:
    :ivar value_2_4_6_8_10_12_14_16_18:
    """
    value: List[Union[int, SmlsizeType]] = field(
        default_factory=list,
        metadata=dict(
            name="value",
            type="List",
            min_occurs=0,
            max_occurs=9223372036854775807,
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )
    small_medium_large: str = field(
        default="small medium large",
        metadata=dict(
            name="small medium large",
            type="Enumeration"
        )
    )
    value_2_4_6_8_10_12_14_16_18: str = field(
        default="2 4 6 8 10 12 14 16 18",
        metadata=dict(
            name="2 4 6 8 10 12 14 16 18",
            type="Enumeration"
        )
    )

Example 10-15 Pattern applied to a list type¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:simpleType name="VectorType">
    <xs:restriction>
      <xs:simpleType>
        <xs:list itemType="xs:unsignedInt" />
      </xs:simpleType>
      <xs:pattern value="\d+\s+\d+\s+((\d+\s+){3})*\d+" />
    </xs:restriction>
  </xs:simpleType>
  <xs:element name="VectorType" type="VectorType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import Optional


@dataclass
class VectorType:
    """
    :ivar value:
    """
    value: Optional[int] = field(
        default=None,
        metadata=dict(
            name="value",
            type="Restriction",
            pattern=r"\d+\s+\d+\s+((\d+\s+){3})*\d+"
        )
    )

Example 10-16 Defining a list of a string-based type¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:simpleType name="AvailableSizesType">
    <xs:list itemType="SMLXSizeType" />
  </xs:simpleType>
  <xs:simpleType name="SMLXSizeType">
    <xs:restriction base="xs:token">
      <xs:enumeration value="small" />
      <xs:enumeration value="medium" />
      <xs:enumeration value="large" />
      <xs:enumeration value="extra large" />
    </xs:restriction>
  </xs:simpleType>
</xs:schema>

from enum import Enum


class SmlxsizeType(Enum):
    """
    :cvar SMALL:
    :cvar MEDIUM:
    :cvar LARGE:
    :cvar EXTRA_LARGE:
    """
    SMALL = "small"
    MEDIUM = "medium"
    LARGE = "large"
    EXTRA_LARGE = "extra large"

Example 10-18 Defining a list of a union¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import schemaLocation="../chapter08/example0801.xsd" />
  <xs:import schemaLocation="../chapter08/example0809.xsd" />
  <xs:simpleType name="SizeType">
    <xs:union memberTypes="DressSizeType SMLXSizeType" />
  </xs:simpleType>
  <xs:simpleType name="AvailableSizesType">
    <xs:list itemType="SizeType" />
  </xs:simpleType>
  <xs:element name="AvailableSizesType" type="AvailableSizesType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import List, Union
from tests.fixtures.defxmlschema.chapter08.example0809 import (
    SmlxsizeType,
)


@dataclass
class AvailableSizesType:
    """
    :ivar value:
    """
    value: List[Union[int, SmlxsizeType]] = field(
        default_factory=list,
        metadata=dict(
            name="value",
            type="List",
            min_occurs=0,
            max_occurs=9223372036854775807,
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )

Example 10-2 Using the memberTypes attribute¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import schemaLocation="../chapter08/example0801.xsd" />
  <xs:import schemaLocation="../chapter08/example0810.xsd" />
  <xs:simpleType name="SizeType">
    <xs:union memberTypes="DressSizeType SMLSizeType" />
  </xs:simpleType>
  <xs:element name="SizeType" type="SizeType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import Optional, Union
from tests.fixtures.defxmlschema.chapter08.example0810 import (
    SmlsizeType,
)


@dataclass
class SizeType:
    """
    :ivar value:
    """
    value: Optional[Union[int, SmlsizeType]] = field(
        default=None,
        metadata=dict(
            name="value",
            type="Union",
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )

Example 10-21 An array using markup¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:complexType name="VectorType">
    <xs:sequence maxOccurs="unbounded">
      <xs:element name="e" type="xs:integer" />
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="ArrayType">
    <xs:sequence maxOccurs="unbounded">
      <xs:element name="r" type="VectorType" />
    </xs:sequence>
  </xs:complexType>
  <xs:element name="array" type="ArrayType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import Optional


@dataclass
class VectorType:
    """
    :ivar e:
    """
    e: Optional[int] = field(
        default=None,
        metadata=dict(
            name="e",
            type="Element",
            required=True
        )
    )


@dataclass
class ArrayType:
    """
    :ivar r:
    """
    r: Optional[VectorType] = field(
        default=None,
        metadata=dict(
            name="r",
            type="Element",
            required=True
        )
    )


@dataclass
class Array(ArrayType):
    class Meta:
        name = "array"

Example 10-3 Combining memberTypes and simpleType¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import schemaLocation="example1001.xsd" />
  <xs:simpleType name="SizeType">
    <xs:union memberTypes="DressSizeType">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:enumeration value="small" />
          <xs:enumeration value="medium" />
          <xs:enumeration value="large" />
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:element name="Size" type="SizeType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import Optional


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

Example 10-4 Restricting a union¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import schemaLocation="example1001.xsd" />
  <xs:simpleType name="SmallSizeType">
    <xs:restriction base="SizeType">
      <xs:enumeration value="2" />
      <xs:enumeration value="4" />
      <xs:enumeration value="6" />
      <xs:enumeration value="small" />
    </xs:restriction>
  </xs:simpleType>
</xs:schema>

from enum import Enum


class SmallSizeType(Enum):
    """
    :cvar VALUE_2:
    :cvar VALUE_4:
    :cvar VALUE_6:
    :cvar SMALL:
    """
    VALUE_2 = "2"
    VALUE_4 = "4"
    VALUE_6 = "6"
    SMALL = "small"

Example 10-5 A union of a union¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import schemaLocation="example1001.xsd" />
  <xs:simpleType name="InternationalSizeType">
    <xs:union memberTypes="SizeType">
      <xs:simpleType>
        <xs:restriction base="xs:integer">
          <xs:minInclusive value="24" />
          <xs:maxInclusive value="54" />
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
  <xs:element name="InternationalSizeType" type="InternationalSizeType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import Optional


@dataclass
class InternationalSizeType:
    """
    :ivar value:
    """
    value: Optional[int] = field(
        default=None,
        metadata=dict(
            name="value",
            type="Union",
            min_inclusive=24.0,
            max_inclusive=54.0
        )
    )

Example 10-7 Defining a list type using an itemType attribute¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:import schemaLocation="../chapter08/example0808.xsd" />
  <xs:simpleType name="AvailableSizesType">
    <xs:list itemType="DressSizeType" />
  </xs:simpleType>
  <xs:element name="AvailableSizesType" type="AvailableSizesType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import List, Union


@dataclass
class AvailableSizesType:
    """
    :ivar value:
    """
    value: List[Union[int, str]] = field(
        default_factory=list,
        metadata=dict(
            name="value",
            type="List",
            min_occurs=0,
            max_occurs=9223372036854775807,
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )

Example 10-9 Defining a list type using a simpleType child¶

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:simpleType name="AvailableSizesType">
    <xs:list>
      <xs:simpleType>
        <xs:restriction base="xs:integer">
          <xs:minInclusive value="2" />
          <xs:maxInclusive value="18" />
        </xs:restriction>
      </xs:simpleType>
    </xs:list>
  </xs:simpleType>
  <xs:element name="AvailableSizesType" type="AvailableSizesType" />
</xs:schema>

from dataclasses import dataclass, field
from typing import List


@dataclass
class AvailableSizesType:
    """
    :ivar value:
    """
    value: List[int] = field(
        default_factory=list,
        metadata=dict(
            name="value",
            type="List",
            min_occurs=0,
            max_occurs=9223372036854775807,
            min_inclusive=2.0,
            max_inclusive=18.0
        )
    )

Samples Source

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