get_args

Is it possible to use typing_inspect to achieve the following?

from typing import Any, List, TypeVar

import typing_inspect


class C:
    x: int

    def __init__(self, x: int) -> None:
        self.x = x


T = TypeVar("T")


class L(List[T]):
    def append_new(self, *args: Any, **kw: Any) -> T:
        item_class = ???(T)
        self.append(item_class(*args, **kw))
        return self[-1]


l = L[C]()
print(l.append_new(42).x)

[Peilonrayz]

This is as the arguments are on the base class. Using get_generic_bases works fine.

from typing import List, TypeVar

import typing_inspect

T = TypeVar("T")


class L(List[T]):
    def f(self) -> None:
        types = typing_inspect.get_args(typing_inspect.get_generic_type(self))
        if not types:
            types = typing_inspect.get_args(typing_inspect.get_generic_bases(self)[0])
        print(types)


class L2(L[int]):
    pass


L().f()
L[int]().f()
L2().f()

It should be noted that this is hacky solution, and may give unexpected results if the class is class C(Mapping[int, T], Sequence[str]). The behavior can be seen in one of typing_inspect_lib.get_mro_orig tests. This function isn’t available until #31 has been completed.

Using this should be fairly simple when it does come out: (Note: untested and subject to change)

for type_info in get_mro_orig(L2()):
    if type_info.typing is L:
        print(get_args(type_info.orig))

It should be noted that this won’t return (int, T, str) if used on C, in an equivalent way. It however is rather simple to change it to return this, return a combination of Mapping and Sequence.

[Peilonrayz]

It doesn’t look like this is at all possible to do in the constructor, in Python 3.7.2 at least.

This is as typing_inspect.get_generic_type(self) returns <class '__main__.L'> not __main__.L[int, str].

Otherwise it looks rather simple:

from typing import List, Tuple, TypeVar

import typing_inspect

U = TypeVar("U")
V = TypeVar("V")
W = TypeVar("W")
Z = 1


def get_type_argument(instance, type_var):
    generic = typing_inspect.get_generic_type(instance)
    origin = typing_inspect.get_origin(generic)
    params = typing_inspect.get_parameters(origin)
    index = params.index(type_var)
    return typing_inspect.get_args(generic)[index]


class L(List[Tuple[U, V]]):
    pass


l = L[int, str]()
print(get_type_argument(l, U))
print(get_type_argument(l, V))
try:
    print(get_type_argument(l, W))
except ValueError as e:
    print(e)
try:
    print(get_type_argument(l, Z))
except ValueError as e:
    print(e)