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

@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

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

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

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

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

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

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

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

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