typing

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

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

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

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

    if tokens:
        args = analyze_token_args(origin, args)
        tokens_factory = origin
        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)

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 annotation is not dict:
            raise TypeError

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

    return Result(types=(str,), factory=dict)

def evaluate_element(annotation: Any, tokens: bool = False) -> Result:
    """Validate annotations for a xml element."""
    types = (annotation,)
    origin = get_origin(annotation)
    args = get_args(annotation)
    tokens_factory = factory = None

    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

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

def evaluate_elements(annotation: Any, **_: Any) -> Result:
    """Validate annotations for a xml compound field."""
    (
        types,
        factory,
        __,
    ) = evaluate_element(annotation, tokens=False)

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

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

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

    if origin in UNION_TYPES:
        types = filter_none_type(get_args(annotation))
    elif origin in ITERABLE_TYPES:
        factory = 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)