typing

xsdata.formats.dataclass.typing

Result

Bases: NamedTuple

Analyze Result Object.

Source code in xsdata/formats/dataclass/typing.py

class Result(NamedTuple):
    """Analyze Result Object."""

    types: tuple[type[Any], ...]
    factory: Callable | None = None
    tokens_factory: Callable | None = None
    optional: bool = False

evaluate(tp, globalns, localns=None)

Analyze/Validate the typing annotation.

Source code in xsdata/formats/dataclass/typing.py

def evaluate(tp: Any, globalns: Any, localns: Any = None) -> Any:
    """Analyze/Validate the typing annotation."""
    result = _eval_type(tp, globalns, localns)

    # Ugly hack for the Type["str"]
    # Let's switch to ForwardRef("str")
    if get_origin(result) is type:
        args = get_args(result)
        if len(args) != 1:
            raise TypeError

        return args[0]

    return result

analyze_token_args(origin, args)

Analyze token arguments.

Ensure it only has one argument, filter out ellipsis.

Parameters:

Name	Type	Description	Default
origin	Any	The annotation origin	required
args	tuple[Any, ...]	The annotation arguments	required

Returns:

Type	Description
tuple[Any]	A tuple that contains only one arg

Raises:

Type	Description
TypeError	If the origin is not list or tuple, and it has more than one argument

Source code in xsdata/formats/dataclass/typing.py

def analyze_token_args(origin: Any, args: tuple[Any, ...]) -> tuple[Any]:
    """Analyze token arguments.

    Ensure it only has one argument, filter out ellipsis.

    Args:
        origin: The annotation origin
        args: The annotation arguments

    Returns:
        A tuple that contains only one arg

    Raises:
        TypeError: If the origin is not list or tuple,
            and it has more than one argument

    """
    if origin in ITERABLE_TYPES:
        args = filter_ellipsis(args)
        if len(args) == 1:
            return args

    raise TypeError

analyze_optional_origin(origin, args, types)

Analyze optional type annotations.

Remove the NoneType, adjust and return the origin, args and types.

Parameters:

Name	Type	Description	Default
origin	Any	The annotation origin	required
args	tuple[Any, ...]	The annotation arguments	required
types	tuple[Any, ...]	The annotation types	required

Returns:

Type	Description
tuple[Any, ...]	The old or new origin args and types.

Source code in xsdata/formats/dataclass/typing.py

def analyze_optional_origin(
    origin: Any, args: tuple[Any, ...], types: tuple[Any, ...]
) -> tuple[Any, ...]:
    """Analyze optional type annotations.

    Remove the NoneType, adjust and return the origin, args and types.

    Args:
        origin: The annotation origin
        args: The annotation arguments
        types: The annotation types

    Returns:
        The old or new origin args and types.
    """
    if origin in UNION_TYPES:
        new_args = filter_none_type(args)
        if len(new_args) == 1:
            return get_origin(new_args[0]), get_args(new_args[0]), new_args

    return origin, args, types

filter_none_type(args)

Filter out none types from args.

Source code in xsdata/formats/dataclass/typing.py

def filter_none_type(args: tuple[Any, ...]) -> tuple[Any, ...]:
    """Filter out none types from args."""
    return tuple(arg for arg in args if arg is not NONE_TYPE)

filter_ellipsis(args)

Filter out ellipsis from args.

Source code in xsdata/formats/dataclass/typing.py

def filter_ellipsis(args: tuple[Any, ...]) -> tuple[Any]:
    """Filter out ellipsis from args."""
    return tuple(arg for arg in args if arg is not Ellipsis)

evaluate_text(annotation, tokens=False)

Run exactly the same validations with attribute.

Source code in xsdata/formats/dataclass/typing.py

def evaluate_text(annotation: Any, tokens: bool = False) -> Result:
    """Run exactly the same validations with attribute."""
    return evaluate_attribute(annotation, tokens)

evaluate_attribute(annotation, tokens=False)

Validate annotations for an XML attribute.

Source code in xsdata/formats/dataclass/typing.py

def evaluate_attribute(annotation: Any, tokens: bool = False) -> Result:
    """Validate annotations for an XML attribute."""
    types = (annotation,)
    origin = get_origin(annotation)
    args = get_args(annotation)
    tokens_factory = None

    if origin in UNION_TYPES:
        optional = NONE_TYPE in args
    else:
        optional = False

    if tokens:
        origin, args, types = analyze_optional_origin(origin, args, types)

        args = analyze_token_args(origin, args)
        tokens_factory = origin
        if tokens_factory in LIST_CONTAINERS:
            tokens_factory = list

        origin = get_origin(args[0])

        if origin in UNION_TYPES:
            args = get_args(args[0])
        elif origin:
            raise TypeError

    if origin in UNION_TYPES:
        types = filter_none_type(args)
    elif origin is None:
        types = args or (annotation,)
    else:
        raise TypeError

    if any(get_origin(tp) for tp in types):
        raise TypeError

    return Result(types=types, tokens_factory=tokens_factory, optional=optional)

evaluate_attributes(annotation, **_)

Validate annotations for XML wildcard attributes.

Source code in xsdata/formats/dataclass/typing.py

def evaluate_attributes(annotation: Any, **_: Any) -> Result:
    """Validate annotations for XML wildcard attributes."""
    if annotation is dict:
        args = ()
    else:
        origin = get_origin(annotation)
        args = get_args(annotation)

        if origin is not dict and origin is not Mapping:
            raise TypeError

    if args and not all(arg is str for arg in args):
        raise TypeError

    # Attributes always have optional=False (nothing else is supported)
    return Result(types=(str,), factory=dict, optional=False)

evaluate_element(annotation, tokens=False)

Validate annotations for an XML element.

Source code in xsdata/formats/dataclass/typing.py

def evaluate_element(annotation: Any, tokens: bool = False) -> Result:
    """Validate annotations for an XML element."""
    # Only the derived element value field is allowed a typevar
    if isinstance(annotation, TypeVar) and annotation.__bound__ is object:
        annotation = object

    types = (annotation,)
    origin = get_origin(annotation)
    args = get_args(annotation)
    tokens_factory = factory = None

    # Compute optional status from original annotation before any processing
    if origin in UNION_TYPES:
        optional = NONE_TYPE in args
    else:
        optional = False

    origin, args, types = analyze_optional_origin(origin, args, types)

    if tokens:
        args = analyze_token_args(origin, args)

        tokens_factory = origin
        origin = get_origin(args[0])
        types = args
        args = get_args(args[0])

    if origin in ITERABLE_TYPES:
        args = tuple(arg for arg in args if arg is not Ellipsis)
        if len(args) != 1:
            raise TypeError

        if tokens_factory:
            factory = tokens_factory
            tokens_factory = origin
        else:
            factory = origin

        types = args
        origin = get_origin(args[0])
        args = get_args(args[0])

    if origin in UNION_TYPES:
        types = filter_none_type(args)
    elif origin:
        raise TypeError

    if factory in LIST_CONTAINERS:
        factory = list

    if tokens_factory in LIST_CONTAINERS:
        tokens_factory = list

    return Result(
        types=types,
        factory=factory,
        tokens_factory=tokens_factory,
        optional=optional,
    )

evaluate_elements(annotation, **_)

Validate annotations for an XML compound field.

Source code in xsdata/formats/dataclass/typing.py

def evaluate_elements(annotation: Any, **_: Any) -> Result:
    """Validate annotations for an XML compound field."""
    result = evaluate_element(annotation, tokens=False)

    for tp in result.types:
        evaluate_element(tp, tokens=False)

    return Result(types=(object,), factory=result.factory, optional=result.optional)

evaluate_wildcard(annotation, **_)

Validate annotations for an XML wildcard.

Source code in xsdata/formats/dataclass/typing.py

def evaluate_wildcard(annotation: Any, **_: Any) -> Result:
    """Validate annotations for an XML wildcard."""
    origin = get_origin(annotation)
    factory = None

    # Compute optional status from original annotation
    if origin in UNION_TYPES:
        args = get_args(annotation)
        optional = NONE_TYPE in args
    else:
        optional = False

    if origin in UNION_TYPES:
        types = filter_none_type(args)
    elif origin in ITERABLE_TYPES:
        factory = list if origin in LIST_CONTAINERS else origin
        types = filter_ellipsis(get_args(annotation))
    elif origin is None:
        types = (annotation,)
    else:
        raise TypeError

    if len(types) != 1 or object not in types:
        raise TypeError

    return Result(types=types, factory=factory, optional=optional)