Inferring parameter types and return type of a type[T]

[InSyncWithFoo]

Is the following supposed to work?

(playground)

@dataclass(kw_only = True)
class User:
    id: int
    name: str

class HasCls[**P, T](Protocol):
    cls: Callable[P, T]

class Repository[T]:
    cls: type[T]

    def __init__(self, cls: type[T]) -> None: ...
    def create[**P](self: HasCls[P, T], *args: P.args, **kwargs: P.kwargs) -> T: ...

class UserDatabase(Repository[User]):
    def __init__(self) -> None: ...

Expected:

user = UserDatabase().create(id = 1, name = 'foo')  # fine

reveal_type(UserDatabase().create)  # (*, id: int, name: str) -> User
reveal_type(user)                   # User

Actual:

user = UserDatabase().create(id = 1, name = 'foo')
#                            ~~      ~~~~ No parameter named 'id'/'name' (reportCallIssue)

reveal_type(UserDatabase().create)  # (**P@HasCls) -> User
reveal_type(user)                   # Unknown

This seems to be a rare pattern, so I don't actually expect it to be supported. Given that Repository cannot be made generic over P (Repository[**P, T]) since UserDatabase cannot specify P directly (User only accepts keyword arguments), are there any alternatives?

[erictraut]

It took me a while to convince myself that this should work, but I agree it should. It's a clever pattern — one that pushes the boundaries of the type system and veers into territory that is not well defined currently in the typing spec.

The reason it's not currently working in is because of the way that pyright determines protocol compatibility when callable attributes are present in the protocol. A callable attribute is generally assumed to be called with a self argument, so it must be bindable to the concrete class. The type Callable[P, T] isn't bindable because it has no dedicated parameter corresponding to self. If you change your code to cls: Callable[Concatenate[Any, P], T], pyright works as you expect.

Thinking about this more, cls is an instance variable in the protocol definition, and instance variables that contain callables should not be bound when accessed through a class instance. I've updated pyright's protocol verification method to skip the binding step in the case of an instance variable, and that produces the behavior that you are expecting. This change will be included in the next release.

I'll note that mypy doesn't handle this pattern either, so if you want it to work with mypy, you'll need to work with the mypy maintainers to get that fixed.