Chaining parametrization on generic class

[Viicos]

Code sample in pyright playground

from typing import Generic, TypeVar

T = TypeVar("T")


class Model(Generic[T]):
    t: T

Sub = Model[T][int]

Although this is fine at runtime, pyright emits a "Type "Model[T@Sub]" is already specialized" error when defining Sub.

This doesn't happen when doing it in two steps:

Sub = Model[T]
Sub2 = Sub[int]

Is this expected behavior? Thanks in advance!

[erictraut]

This is expected behavior. You cannot specialize a class twice. I'm not even sure what this would mean. The fact that this does not crash at runtime does not make it valid.

Perhaps your intent is to define a generic type alias?

type Sub[T] = Model[T]
Sub2 = Sub[int]

[Viicos]

In this case, should:

Sub = Model[T]
Sub2 = Sub[int]

be marked with the same error as well? It is doing the same thing. Unless I'm mistaken and Model[T][int] has a different meaning (at least from a type checker perspective).

---

One real use case that we support in Pydantic is something like:

class A(BaseModel, Generic[T, S]):
    a: T
    b: S

IntListA = A[int, list[S]]  # partial parametrization, which can be reused for different secondary parametrizations
IntListStrA = IntListA[str]  # `IntListStrA = A[int, list[str]]`

If the above is valid according to the spec (if not, I'm wondering if it should be specified, or if it is already the case but I couldn't find anything related to this), should:

IntListStrA = A[int, list[S]][str]

be valid as well?

[Viicos]

I guess in all cases the "inlined" form can be simplified (IntListStrA = A[int, list[str]]). So no real need to dive deeper into this.

[erictraut]

The statement Sub = Model[T] is the old-style (PEP 484) way to define a generic type alias. It's equivalent to the less-old-style Sub: TypeAlias = Model[T] or the modern type Sub[T] = Model[T].

Once a generic type alias is defined, you can specialize it using subscripts.

In your first code snippet, you're not defining a type alias, and Model[T][int] has no valid meaning to a type checker. For the same reason, A[int, list[S]][str] is invalid.