How to create an isinstance function that is aware of type aliases and unions?

[JoanPuig]

I tried to create an isinstance that can return true if the value is of the target type while the target type can be an alias or a union as well as the standard classes and tuples of classes.

I got the code to work correctly at runtime, but I am unable to get pyright to understand the intend when typechecking.

I originally reported it as a bug: #11168, but it seems the issue is related to my implementation.

I was wondering, has anyone implemented something like this before? Any libraries that would do it in a way that type checkers understand? Any suggestions on how to improve the code below?

Thanks,
Joan

import types
from dataclasses import dataclass
from typing import (
    Annotated,
    Any,
    TypeAliasType,
    TypeIs,
    cast,
    get_args,
    get_origin,
    overload,
)


def resolve_alias(t: Any) -> Any:
    """
    Unwraps:
    - PEP 695 type aliases to their underlying type
    - Annotated[T, ...] to T
    """

    if isinstance(t, TypeAliasType):
        return t.__value__

    origin = get_origin(t)

    if origin is Annotated:
        args = get_args(t)
        if args:
            return resolve_alias(args[0])

    return t


@overload
def is_instance_union_aware[T](
    value: Any, target_type: type[T] | tuple[type[T], ...]
) -> TypeIs[T]: ...


@overload
def is_instance_union_aware(value: Any, target_type: Any) -> bool: ...


def is_instance_union_aware(value: Any, target_type: Any):
    """
    Return True if value is an instance of target_type, where target_type can be:
    - Concrete classes
    - PEP 604 unions (A | B | ...)
    - typing.Union[A, B, ...]
    - PEP 695 type alias (type U = ...)
    - Annotated[T, ...] where T is any of the above
    - Tuple of the above
    """

    if isinstance(target_type, tuple):
        if not target_type:
            return False
        return any(is_instance_union_aware(value, t) for t in target_type)

    t = resolve_alias(value)
    origin = get_origin(t)

    if origin is types.UnionType:
        return any(
            is_instance_union_aware(value, resolve_alias(arg)) for arg in get_args(t)
        )

    if t is Any:
        return True

    try:
        return isinstance(value, cast("type[Any]", t))
    except TypeError:
        return False
    ```
    

[erictraut]

Refer to draft PEP 747 for an overview of the TypeForm[T] special form. It is designed for cases like this. Pyright has support for TypeForm, but since the PEP is not yet approved, that support is considered experimental. You need to set enableExperimentalFeatures to true in your pyright configuration. I don't recommend using this support in production code at this time because it's subject to change or removal based on the final status of the PEP.