Type inference when unpacking tuple

[mehdigmira]

Hello,

When unpacking a tuple such as

def f(t: tuple[str, int]):
  x, y = t

Pyright (and mypy) seem to be able to infer that x is of type str and y is of type int. How is that achieved ? Since tuple.iter doesn't have a special signature that would allow this inference, is there some special casing in the type checker's code ?

Moreover, the definition of tuple in typeshed stubs seems to only be generic of _T_co which seems a bit weird ? How wome this doesn't cause any problem ? Maybe tuple implementation is hardcoded in each typechecker's logic ? If so can you point out to code lines that implement this ?

[erictraut]

Yes, the tuple class requires very significant special casing within a type checker, and this logic affects hundreds of places within the type checker. There's no single place I can point you to. Most of the special-case logic involves the field named tupleTypeArguments, so you can search for that in the source code.

[mehdigmira]

Thanks, I eventually stumbled upon assignTypeToTupleOrListNode and tupleTypeArguments.
I guess there is no way to make a custom class benefit from this inference when unpacking ?

I'm asking this because SQLAlchemy has a Row class, which isn't a tuple per say, but allows unpacking. But then types that are inferred are often Any when you do so.
The current workaround seems to use Row.tuple() which returns a tuple, and hence benefits from this inference. But it's a bit verbose and error prone. Isn't there an other way ?

[erictraut]

Can you model it using a TypeVarTuple (PEP 646)? That construct was designed to enable customized tuple-like behavior.

[mehdigmira]

how would you support unpacking with TypeVarTuple ?

[mehdigmira]

tried smth such as

from __future__ import annotations

from typing import *

T = TypeVarTuple("T")


class Model(Generic[*T]):
    def __iter__(self) -> tuple[*T]:
        ...


x, y, z = Model[str, int]()

but it doesn't work well, typing wise

[erictraut]

Yeah, I think you'd need to derive from tuple, which is probably not the solution you're looking for.

from typing import TypeVarTuple

T = TypeVarTuple("T")

class Model(tuple[*T]):
    ...

x, y, z = Model[str, int, str]()