Dynamic method signature, depending on init args

[Redoubts]

I'd like to know if there's a way to type a class, where an init arg determines the signature of another method on the class. For example:

class X[T]:
    def __init__(self, grouped: Literal[False]):
        ....

    def x(self, takes: T) -> None
        pass

class X[T]:
    def __init__(self, grouped: Literal[True]):
        ....
    def x(self, takes: list[T]) -> None
        pass

[erictraut]

Here's a solution that works with pyright. It doesn't work with mypy because of various bugs and limitations in how it handles __new__.

from typing import Literal, overload

class X[T]:
    @overload
    def __new__(cls, grouped: Literal[True]) -> X[list[T]]:
        ...
    @overload
    def __new__(cls, grouped: Literal[False]) -> X[T]:
        ...
    def __new__(cls, grouped: bool) -> X[list[T]] | X[T]:
        ...

    def x(self, takes: T) -> None:
        pass

x1 = X[int](True)
reveal_type(x1) # X[list[int]]

x2 = X[int](False)
reveal_type(x2) # X[int]

[henribru]

For an alternative that works in Mypy, it's doable by introducing another generic parameter:

from typing import Literal, overload, TypeVar, Generic

T = TypeVar("T")
Grouped = TypeVar("Grouped", bound=bool)

class X(Generic[T, Grouped]):
    def __init__(self, grouped: Grouped) -> None: pass
    @overload
    def x(self: X[T, Literal[True]], takes: list[T]) -> None:
        pass
    @overload
    def x(self: X[T, Literal[False]], takes: T) -> None:
        pass
    def x(self, takes: T | list[T]) -> None:
        pass

x1 = X[int, Literal[True]](True)
reveal_type(x1.x) # def (takes: builtins.list[builtins.int])

x2 = X[int, Literal[False]](False)
reveal_type(x2.x) # def (takes: builtins.int)

X[int, Literal[True]](True) looks kinda dumb but you can't specify one generic and let the other one be inferred, so 🤷

[henribru]

[...] let the other one be inferred, so 🤷

Actually it seems Mypy doesn't infer a literal generic in that way anyway:

from typing import Literal, overload, TypeVar, Generic

Grouped = TypeVar("Grouped", bound=bool)

class X(Generic[Grouped]):
    def __init__(self, grouped: Grouped) -> None: pass

x1 = X(True)
reveal_type(x1) # __main__.X[builtins.bool]

x2 = X(False)
reveal_type(x2) # __main__.X[builtins.bool]

[henribru]

Oh yes, actually it does, but the bound needs to be Literal[True, False]

from typing import Literal, overload, TypeVar, Generic

Grouped = TypeVar("Grouped", bound=Literal[True, False])

class X(Generic[Grouped]):
    def __init__(self, grouped: Grouped) -> None: pass

x1 = X(True)
reveal_type(x1) # __main__.X[Literal[True]]

x2 = X(False)
reveal_type(x2) # __main__.X[Literal[False]]

[Redoubts]

very interesting idea, ty