list[list[T]] and Sequence[Sequence[T]] are incompatible as base classes

[InSyncWithFoo]

Minimal reproducible example (playground):

class C[T](list[list[T]], Sequence[Sequence[T]]): ...
#     ^ Base classes of C are mutually incompatible
#
# Base class "Sequence[Sequence[T@C]]" derives from "Sequence[Sequence[T@C]]"
# which is incompatible with type "Sequence[list[T@C]]" 

It seems that Pyright tried to assign Sequence[Sequence[T]] to Sequence[list[T]], the parametrized version of one of list[list[T]]'s base class, and failed. Shouldn't it be the other way around instead?

[erictraut]

I think pyright is correct here. You should pick one or the other as a base class, not both.

[InSyncWithFoo]

The original hierarchy is a bit more complex (from this Stack Overflow question; playground):

class Grid[T](Sequence[Sequence[T]], ABC): ...

class MutableGrid[T](list[list[T]], Grid[T]): ...
#     ^^^^^^^^^^^
# Base class "Grid[T@MutableGrid]" derives from "Sequence[Sequence[T@MutableGrid]]"
# which is incompatible with type "Sequence[list[T@MutableGrid]]"

Also consider the immutable counterpart:

class Grid[T](Sequence[Sequence[T]], ABC): ...

class ImmutableGrid[T](tuple[tuple[T, ...], ...], Grid[T]): ...
#     ^^^^^^^^^^^^^
# Base class "Grid[T@ImmutableGrid]" derives from "Sequence[Sequence[T@ImmutableGrid]]"
# which is incompatible with type "Sequence[tuple[T@ImmutableGrid, ...]]"

This is a bad example of inheritance, yes, but what specifically makes it unsound? I'm interested in a detailed, theoretical explanation.

[erictraut]

If you swap the two base classes in your MutableGrid and ImmutableGrid examples, they becomes sound. That's because list[list[T] and tuple[tuple[T, ...]] are both subtypes of Sequence[Sequence[T]]. Ordering matters here because later base classes override earlier ones.

There are also some special circumstances with Sequence and list because the typeshed definitions for these two classes violate the Liskov Substitution Principle (LSP). For example, the index method in Sequence accepts keyword arguments but the same method in list accepts only positional arguments. The stubs are correctly reflecting the runtime behavior, but it's unsound from a type standpoint. In most cases, this doesn't matter, but when you try to inherit from both classes directly, a type checker like pyright will detect these inconsistencies as part of its analysis.

[FrozenBob]

Ordering matters here because later base classes override earlier ones.

You've got that backward - earlier base classes override later ones. Is Pyright coded to think later base classes override earlier ones?

It's easy enough to demonstrate that earlier base classes override later ones. For example, if you run this:

class A:
    def foo(self):
        print('A')

class B:
    def foo(self):
        print('B')

class C(A, B):
    pass

C().foo()

it prints A instead of B.

[erictraut]

You've got that backward

Yes, you're right. I stated it backward above. Pyright's logic is actually correct. My point stands, however, that ordering matters here.