Identifying Generic Types at Runtime

[hmc-cs-mdrissi]

Is there a recommended public/stableish api way of identifying if a type is generic at runtime? Here I'm thinking of a type being generic if it accepts type parameters. I've included some example test cases describing behavior I'm aiming for.

def is_generic(tp: object) -> bool:
  ...

def test_is_generic() -> None:
   # Primitives are not generic
    assert not is_generic(int)
    assert not is_generic(bool)

    # List is generic, but List[int] is not generic because it already has a type argument.
    assert not is_generic(List[int])
    assert is_generic(List)

    # Similar for pep 585 style list
    assert not is_generic(list[int])
    assert is_generic(list)

    # Similar for Union/Optional/Container. If you pass type arguments I would view it as concrete and not generic.
    assert not is_generic(Union[int, str])
    assert is_generic(Union)

    assert not is_generic(Optional[int])
    assert is_generic(Optional)

    assert not is_generic(Container[int])
    assert is_generic(Container)

    # Weirder case generic aliases. Here type arguments are present, but typevar makes me view it still as generic.
    T = TypeVar('T')
    assert is_generic(list[T])
    assert is_generic(dict[str, T])
    assert is_generic(list[dict[str, T]])

    # Special Forms are also generic.
    assert is_generic(Final)
    assert is_generic(Literal)

The intended use case is for non-generic types I "fully" know type and use that information for serialization/deserialization. For generic types I instead need a function that takes as argument all types needed to fill in unknown type parameters and uses that to make a serializer/deserializer. So I'm roughly looking for objects, t, where t[int] makes sense as a type annotation.

[hmc-cs-mdrissi]

I'll leave my current solution here. It works for the test cases I have listed, although I'd be happily surprised if there aren't harder edge cases I'm missing.

def _type_var_present(tp: object) -> bool:
  # Add TypeVarTuple eventually
  if isinstance(tp, (TypeVar, Paramspec)):
    return True

  args = get_args(tp)
  if args is None:
    return False

  return any(_type_var_present(arg) for arg in args)

def is_generic(cls: object) -> bool:
    if hasattr(cls, "__parameters__") and len(cls.__parameters__) > 0:  # type: ignore
        return True

    if isinstance(cls, _SpecialForm):
        return cls._name in ("Union", "Optional", "Literal")  # type: ignore

    if get_origin(cls) is None:
        return False

    args = get_args(cls)
    # Only at top level is no args parametrizable. list is parametrizable, but list[list] is not.
    if len(args) == 0:
        return True

    return _type_var_present(cls)

[JelleZijlstra]

Have you tried the typing-inspect library?

[hmc-cs-mdrissi]

I took a look at it and is_generic_type helper in it is defined as has generic in the mro, not as accepts type arguments. The approach I have here is similar to the idea described in the issue + more special cases.

Maybe some notion of accepts_type_parameters could live in typing-inspect. Not sure how many other runtime type users need this check.