Allowing multiple signature in subclass

[Zi-Pou (Zi-Pou)]

I have a use-case where i want to allow multiple different signature for methods when subclassing.
I've spend some time trying to make it pyright compliant and have discover some kind of weirdness.

from collections.abc import Callable
from typing import Self

type FuncSimple[T] = Callable[[T], int]
type Func[T] = Callable[[T], int] | Callable[[T, int], tuple[int, int]]

class Model:
    f1: FuncSimple[Self]
    f2: Func[Self]

class Example(Model):
    def f1(self) -> int: return 1
    def f2(self) -> int: return 1

pyright is fine if their is only one signature allowed (f1) but flags f2.
Is this normal behavior ? If so could someone explain to me what's happening :).

I've find a way to make pyright happy using CRTP pattern :

class Model2[T]:
    f2:Func[T]
    
class Example2(Model2["Example2"]):
    def f2(self) -> int: return 1

but if someone has something nicer i'll be glad.

I know it is a bit of a weird use case, my Model is some kind of dataclass (where some data are callables) that then get's normalized at class creation time.

[Aymen Hmaidi (aymenhmaidiwastaken)]

It isn't really about multiple signatures — it's Self not surviving the union. The error message gives it away if you read the type it's comparing against:

Type "(self: Example) -> int" is not assignable to type "Func[Model]"
                                                             ^^^^^

Func[Self] was solved to Func[Model], not Func[Example]. Once Self has collapsed to the base class, the override can't match: a callable taking Model has to accept any Model, and your method only accepts an Example.

I narrowed down what triggers the collapse. Everything below is the same subclass method, only the declared type changes, on pyright 1.1.411:

class M1:
    f: Callable[[Self], int]           # ok
class M2:
    f: Callable[["M2"], int]           # ok  - concrete base type, still fine

type U1[T] = Callable[[T], int]
class M3:
    f: U1[Self]                        # ok  - alias with ONE member

type U2[T] = Callable[[T], int] | Callable[[T, int], tuple[int, int]]
class M4:
    f: U2[Self]                        # ERROR

line 44  Type "(self: E4) -> int" is not assignable to type "U2[M4]"

M3 and M4 differ only in whether the alias has one arm or two. So it's not the alias, not Self on its own, and not the override check being strict about self — a single callable through Self re-binds to the subclass correctly. Adding a second union member is what stops the re-binding.

Worth also knowing that implementing the other arm doesn't help:

class E5(M4):
    def f(self, n: int) -> tuple[int, int]: return (n, n)
# line 49  Type "(self: E5, n: int) -> tuple[int, int]" is not assignable to type "U2[M4]"

Both arms fail identically, which rules out "pyright picked the wrong member".

That's also exactly why your CRTP version works, and I'd keep it. Writing Model2["Example2"] binds T to the concrete subclass explicitly, so there's no Self left to re-bind and the union is evaluated at Example2 from the start:

class Model2[T]:
    f2: Func[T]

class Example2(Model2["Example2"]):
    def f2(self) -> int: return 1      # no error

It's more ceremony at the declaration site, but it's saying the thing you actually mean, and it doesn't depend on Self behaviour inside unions.

One alternative I tried that does not work, so you can skip it: replacing the callable union with an overloaded Protocol for __call__. Pyright rejects the override with "One or more overloads of __call__ is not assignable" — same underlying problem, more machinery.

Given M3 and M4 differ by nothing but a union member, I'd say the collapse to U2[M4] is worth raising with Eric Traut (@erictraut) separately as a narrow question about Self solving inside unions — your case is a clean minimal repro for it, and if it's intended there's presumably a reason the one-member form behaves differently.