Strange error when implementing a protocol, bug?

[dsedivec]

Minimal-ish example that demonstrates behavior I can't explain:

from __future__ import annotations

from typing import Generic, Protocol, Self, TypeVar, final


class P(Protocol):
    @classmethod
    def factory_method(cls) -> Self: ...

    def f(self, a_num: int, arg: C1[Self]) -> object: ...


T = TypeVar("T", bound=P)


class C1(Generic[T]):
    attr: C2[T]

    def __init__(self, c2: C2[T]):
        self.attr = c2


@final
class C2(Generic[T]):
    ts: list[T]

    def __init__(self, t_cls: type[T], c1_cls: type[C1[T]]):
        self.c1_cls = c1_cls
        self.ts = [t_cls.factory_method() for _ in range(10)]


class ConcreteP:
    @classmethod
    def factory_method(cls):
        return ConcreteP()

    def f(self, a_num: int, arg: C1[ConcreteP]) -> str:
        return f"{a_num=} {arg=}"


class SpecificC1(C1[ConcreteP]):
    pass


c2_instance = C2(ConcreteP, SpecificC1)

I'm just... sorry, this code is a mess, but it's the result of me trying to narrow down my actual code to reproduce the problem. Basically C1 and C2 want to work together to do things with an object that satisfies protocol P.

When I run Pyright 1.1.407 on this file (Python 3.13.11) I get this error:

/tmp/mwe.py:37:37 - error: Type "ConcreteP" cannot be assigned to type variable "T@C1"
    Type "ConcreteP" is not assignable to upper bound "P" for type variable "T@C1"
      "ConcreteP" is incompatible with protocol "P"
        "f" is an incompatible type
          Type "(a_num: int) -> Unknown" is not assignable to type "(a_num: int, arg: C1[ConcreteP]) -> object"
            Function accepts too many positional parameters; expected 1 but received 2 (reportInvalidTypeArguments)
1 error, 0 warnings, 0 informations

Note that Mypy (1.19.0) does not give me any errors on this code.

If I make ConcreteP explicitly implement P (class ConcreteP(P)), the error goes away.

My questions are:

1. Why do I have to explicitly implement P?
2. Why does the error message say the signature is "(a_num: int) -> Unknown"? Is this something like the Pyright recursing too deep and halting while trying to process this type?

Thanks for any help! This is stumping me.

[erictraut]

I'd have to investigate in more detail to confirm, but I suspect the problem is because your definition of P is circular — that is, it depends on itself in a way that pyright is not able to handle. The definition of P depends on the definition of C1 which depends on T which has an upper bound of P.

When you explicitly implement P, pyright (and mypy) perform a shortcut where they don't verify protocol compatibility during assignability checks. They rely on subclass compatibility (if ConcreteP is a subclass of P, then it must be assignable to P).

[dsedivec]

Thank you for helping me untangle the problem! I think this is a more minimal example:

from __future__ import annotations

from typing import Any, Generic, Protocol, Self, TypeVar


class P(Protocol):
    def f(self, a_num: int, arg: C1[Self]) -> Any: ...


T = TypeVar("T", bound=P)


class C1(Generic[T]):
    def __init__(self, t: T):
        self.t = t


class ConcreteP:
    def f(self, a_num: int, arg: C1[Self]) -> Any:
        return a_num, arg

And indeed it yields the same error:

/tmp/mwe2.py:19:37 - error: Type "Self@ConcreteP" cannot be assigned to type variable "T@C1"
    Type "ConcreteP*" is not assignable to upper bound "P" for type variable "T@C1"
      "ConcreteP*" is incompatible with protocol "P"
        "f" is an incompatible type
          Type "(a_num: int) -> Unknown" is not assignable to type "(a_num: int, arg: C1[Self@ConcreteP]) -> Any"
            Function accepts too many positional parameters; expected 1 but received 2 (reportInvalidTypeArguments)
1 error, 0 warnings, 0 informations

I think I just need to rewrite the code that I'm working on so this thing isn't so convoluted. Failing that, I did manage to make it check by explicitly implementing the protocol, so I guess I'm good. I was mostly wondering if I was doing something wrong. Do let me know if you think I should open a bug or feature request, though.

Thanks again for all your work on this project!

[dsedivec]

Oh, I forgot one more strange behavior I found: If I make a TypeAlias, but don't use it, the types check.

from __future__ import annotations

from typing import Any, Generic, Protocol, Self, TypeAlias, TypeVar


class P(Protocol):
    def f(self, a_num: int, arg: C1[Self]) -> Any: ...


T = TypeVar("T", bound=P)


class C1(Generic[T]):
    def __init__(self, t: T):
        self.t = t


_: TypeAlias = "C1[ConcreteP]"


class ConcreteP:
    def f(self, a_num: int, arg: C1[ConcreteP]) -> Any:
        return a_num, arg

(I had to change Self to ConcreteP because AFAIK you can't use Self in a TypeAlias.) If I comment out the _: TypeAlias = ..., I get the same error.