Assign Python method generic argument to class generic argument by default

Say I want a method to return a generic type and I would like it to default to the a argument of the class by default but to still be overridable at function call, like this:

T = TypeVar('T', bound=str)
U = TypeVar('U')

class Foo(Generic[T]):
    def bar(self, response_type: Type[U] = T) -> U:
        pass

So you could have:

x: Foo[int] = ...
x.bar() # Returns int
x.bar(response_type=str) # Returns str

Does any Python type checker type system support this?

Additionally, I would also like Foo to default to str, so that:

x = Foo(...)
x.bar() # Returns str by default even if unspecified when constructing Foo

Does the bound parameter enable this?

Purely from a typing perspective, it is possible to express what you want using overloads like this:

from typing import Generic, Optional, TypeVar, overload


T = TypeVar("T")
U = TypeVar("U")


class Foo(Generic[T]):
    @overload
    def bar(self, response_type: type[U]) -> U: ...

    @overload
    def bar(self, response_type: None = None) -> T: ...

    def bar(self, response_type: Optional[type] = None) -> object:
        ...  # implementation


x: Foo[int]
reveal_type(x.bar())                   # note: Revealed type is "builtins.int"
reveal_type(x.bar(response_type=str))  # note: Revealed type is "builtins.str"

Using reveal_type with Mypy shows that the type checker correctly infers the return types this way.

The real challenge here could be the actual implementation because without some serious overhead you will not be able to get that type argument passed to Foo, unless you pass it in explicitly via the constructor for example.

It would be easy of course, if you had it as a mandatory __init__ argument. Then you could do something like the following:

from typing import Generic, Optional, TypeVar, overload


T = TypeVar("T")
U = TypeVar("U")


class Foo(Generic[T]):
    def __init__(self, type_arg: type[T]) -> None:
        self.type_arg = type_arg

    @overload
    def bar(self, response_type: type[U]) -> U: ...

    @overload
    def bar(self, response_type: None = None) -> T: ...

    def bar(self, response_type: Optional[type] = None) -> object:
        if response_type is None:
            ...
            return self.type_arg()
        ...
        return response_type()


x = Foo(int)
i = x.bar()
s = x.bar(response_type=str)

print(repr(i))  # 0
print(repr(s))  # ''

Obviously the details depend on your actual use case, but you can see the concept.

But if you want to rely on passing the type argument via __class_getitem__ only, you will need to get creative. There is no built-in way to have the default for a method parameter automatically be the type argument passed to __class_getitem__.

The way generic alias types are constructed, the type argument is completely lost during initialization, meaning when you initialize Foo[int] it looks the same as if you were initializing any other Foo[T] or just Foo for that matter. From the docs:

> parameterized generics erase type parameters during object creation

Now after initialization, the __orig_class__ attribute is added, which points to the generic alias type that was used, but this does not help you in the __init__ method.

I guess you could defer checking for __orig_class__ until you call that specific bar method in question. So one possible way around this issue could look something like this:

from typing import Generic, Optional, TypeVar, get_args, overload


T = TypeVar("T")
U = TypeVar("U")


class Foo(Generic[T]):
    @overload
    def bar(self, response_type: type[U]) -> U: ...

    @overload
    def bar(self, response_type: None = None) -> T: ...

    def bar(self, response_type: Optional[type] = None) -> object:
        if response_type is not None:
            ...
            return response_type()
        orig_class = getattr(self, "__orig_class__", None)
        if orig_class is None:
            raise TypeError("No type parameter available!")
        type_arg = get_args(orig_class)[0]
        ...
        return type_arg()


x = Foo[int]()
i = x.bar()
s = x.bar(response_type=str)

print(repr(i))  # 0
print(repr(s))  # ''

But as pointed out in the comments by @user2357112, this is not a very robust way of doing it. It does not address subclassing, i.e. class Bar(Foo[int]): ... will not retain __orig_class__. You could again work around that and grab the __orig_bases__ for example in __init_subclass__, but this will get more and more hacky.

In general, you should remember that many typing constructs have minimal or no runtime implications by design. So trying to work from typing to runtime is always going to be an uphill battle.