Skip to content

# mixins

## `xsdata.models.mixins`

### `ElementBase` `dataclass`

Base xsd schema model representation.

Attributes:

Name | Type | Description
--- | --- | ---
`index` | `int` | The element position in the schema
`ns_map` | `dict[str, str]` | The element namespace prefix-URI map

Source code in `xsdata/models/mixins.py`

     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170

    @dataclass
    class ElementBase:
        """Base xsd schema model representation.

        Attributes:
            index: The element position in the schema
            ns_map: The element namespace prefix-URI map
        """

        index: int = field(
            default_factory=int,
            init=False,
            metadata={"type": "Ignore"},
        )
        ns_map: dict[str, str] = field(
            default_factory=dict,
            init=False,
            metadata={"type": "Ignore"},
        )

        @property
        def class_name(self) -> str:
            """Return the schema element class name."""
            return self.__class__.__name__

        @property
        def default_type(self) -> str:
            """The element's inferred default type qname."""
            return DataType.STRING.prefixed(self.xs_prefix)

        @property
        def default_value(self) -> Any:
            """Return the default or the fixed attribute value."""
            default = getattr(self, "default", None)
            if default is None and hasattr(self, "fixed"):
                default = getattr(self, "fixed", None)

            return default

        @property
        def display_help(self) -> str | None:
            """Return the display help for this element."""
            return None

        @property
        def bases(self) -> Iterator[str]:
            """Return an iterator of all the base types."""
            yield from ()

        @property
        def has_children(self) -> bool:
            """Return whether this element has any children."""
            return next(self.children(), None) is not None

        @property
        def has_form(self) -> bool:
            """Return whether this element has the form attribute."""
            return hasattr(self, "form")

        @property
        def is_abstract(self) -> bool:
            """Return whether this element is defined as abstract."""
            return getattr(self, "abstract", False)

        @property
        def is_property(self) -> bool:
            """Return whether this element is qualified to be a class property."""
            return False

        @property
        def is_fixed(self) -> bool:
            """Return whether this element has a fixed value."""
            return getattr(self, "fixed", None) is not None

        @property
        def is_mixed(self) -> bool:
            """Return whether this element accepts mixed content value."""
            return False

        @property
        def is_nillable(self) -> bool:
            """Return whether this element accepts nillable content."""
            return getattr(self, "nillable", False)

        @property
        def is_qualified(self) -> bool:
            """Return whether this element must be referenced with the target namespace."""
            if self.has_form:
                if getattr(self, "form", FormType.UNQUALIFIED) == FormType.QUALIFIED:
                    return True

                if self.is_ref:
                    return True

            return False

        @property
        def is_ref(self) -> bool:
            """Return whether this element is a reference to another element."""
            return getattr(self, "ref", None) is not None

        @property
        def is_wildcard(self) -> bool:
            """Return whether this element is a wildcard element/attribute."""
            return False

        @property
        def prefix(self) -> str | None:
            """Return the namespace prefix for this element's type."""
            ref = getattr(self, "ref", None)
            return None if ref is None else text.prefix(ref)

        @property
        def raw_namespace(self) -> str | None:
            """Return if present the target namespace attribute value."""
            return getattr(self, "target_namespace", None)

        @property
        def real_name(self) -> str:
            """Return the real name for this element."""
            name = getattr(self, "name", None) or getattr(self, "ref", None)
            if name:
                return text.suffix(name)

            raise CodegenError(
                "Schema type can't be used as a class/field", type=self.class_name
            )

        @property
        def attr_types(self) -> Iterator[str]:
            """Return the attr types for this element."""
            yield from ()

        @property
        def substitutions(self) -> list[str]:
            """Return the substitution groups of this element."""
            return []

        @property
        def xs_prefix(self) -> str | None:
            """Return the xml schema URI prefix."""
            for prefix, uri in self.ns_map.items():
                if uri == Namespace.XS.uri:
                    return prefix

            return None

        def get_restrictions(self) -> dict[str, Any]:
            """Return the restrictions dictionary of this element."""
            return {}

        def children(self, condition: Callable = return_true) -> Iterator["ElementBase"]:
            """Yield the children recursively that match the given condition."""
            for f in fields(self):
                value = getattr(self, f.name)
                if isinstance(value, list) and value and isinstance(value[0], ElementBase):
                    yield from (val for val in value if condition(val))
                elif isinstance(value, ElementBase) and condition(value):
                    yield value

#### `class_name` `property`

Return the schema element class name.

#### `default_type` `property`

The element's inferred default type qname.

#### `default_value` `property`

Return the default or the fixed attribute value.

#### `display_help` `property`

Return the display help for this element.

#### `bases` `property`

Return an iterator of all the base types.

#### `has_children` `property`

Return whether this element has any children.

#### `has_form` `property`

Return whether this element has the form attribute.

#### `is_abstract` `property`

Return whether this element is defined as abstract.

#### `is_property` `property`

Return whether this element is qualified to be a class property.

#### `is_fixed` `property`

Return whether this element has a fixed value.

#### `is_mixed` `property`

Return whether this element accepts mixed content value.

#### `is_nillable` `property`

Return whether this element accepts nillable content.

#### `is_qualified` `property`

Return whether this element must be referenced with the target namespace.

#### `is_ref` `property`

Return whether this element is a reference to another element.

#### `is_wildcard` `property`

Return whether this element is a wildcard element/attribute.

#### `prefix` `property`

Return the namespace prefix for this element's type.

#### `raw_namespace` `property`

Return if present the target namespace attribute value.

#### `real_name` `property`

Return the real name for this element.

#### `attr_types` `property`

Return the attr types for this element.

#### `substitutions` `property`

Return the substitution groups of this element.

#### `xs_prefix` `property`

Return the xml schema URI prefix.

#### `get_restrictions()`

Return the restrictions dictionary of this element.

Source code in `xsdata/models/mixins.py`

    159
    160
    161

    def get_restrictions(self) -> dict[str, Any]:
        """Return the restrictions dictionary of this element."""
        return {}

#### `children(condition=return_true)`

Yield the children recursively that match the given condition.

Source code in `xsdata/models/mixins.py`

    163
    164
    165
    166
    167
    168
    169
    170

    def children(self, condition: Callable = return_true) -> Iterator["ElementBase"]:
        """Yield the children recursively that match the given condition."""
        for f in fields(self):
            value = getattr(self, f.name)
            if isinstance(value, list) and value and isinstance(value[0], ElementBase):
                yield from (val for val in value if condition(val))
            elif isinstance(value, ElementBase) and condition(value):
                yield value

### `attribute(optional=True, **kwargs)`

Shortcut method for attribute fields.

Source code in `xsdata/models/mixins.py`

    173
    174
    175
    176
    177
    178

    def attribute(optional: bool = True, **kwargs: Any) -> Any:
        """Shortcut method for attribute fields."""
        metadata = extract_metadata(kwargs, type=XmlType.ATTRIBUTE)
        add_default_value(kwargs, optional=optional)

        return field(metadata=metadata, **kwargs)

### `element(optional=True, **kwargs)`

Shortcut method for element fields.

Source code in `xsdata/models/mixins.py`

    181
    182
    183
    184
    185
    186

    def element(optional: bool = True, **kwargs: Any) -> Any:
        """Shortcut method for element fields."""
        metadata = extract_metadata(kwargs, type=XmlType.ELEMENT)
        add_default_value(kwargs, optional=optional)

        return field(metadata=metadata, **kwargs)

### `add_default_value(params, optional)`

Add the default value if it's missing and the optional flag is true.

Source code in `xsdata/models/mixins.py`

    189
    190
    191
    192

    def add_default_value(params: dict, optional: bool) -> None:
        """Add the default value if it's missing and the optional flag is true."""
        if optional and not ("default" in params or "default_factory" in params):
            params["default"] = None

### `array_element(**kwargs)`

Shortcut method for list element fields.

Source code in `xsdata/models/mixins.py`

    195
    196
    197
    198

    def array_element(**kwargs: Any) -> Any:
        """Shortcut method for list element fields."""
        metadata = extract_metadata(kwargs, type=XmlType.ELEMENT)
        return field(metadata=metadata, default_factory=list, **kwargs)

### `array_any_element(**kwargs)`

Shortcut method for list wildcard fields.

Source code in `xsdata/models/mixins.py`

    201
    202
    203
    204
    205
    206

    def array_any_element(**kwargs: Any) -> Any:
        """Shortcut method for list wildcard fields."""
        metadata = extract_metadata(
            kwargs, type=XmlType.WILDCARD, namespace=NamespaceType.ANY_NS
        )
        return field(metadata=metadata, default_factory=list, **kwargs)

### `extract_metadata(params, **kwargs)`

Remove dataclasses standard field properties and merge any additional.

Source code in `xsdata/models/mixins.py`

    209
    210
    211
    212
    213
    214
    215

    def extract_metadata(params: dict, **kwargs: Any) -> dict:
        """Remove dataclasses standard field properties and merge any additional."""
        metadata = {
            key: params.pop(key) for key in list(params.keys()) if key not in FIELD_PARAMS
        }
        metadata.update(kwargs)
        return metadata