Inherit/subclass from `tuple` with correct indexing and slicing

i am trying to sublass tuple and make mypy happy in the process. i would like to make slicing and indexing work.

here is what i have tried:

from functools import singledispatchmethod
from typing import Iterable


class MyIntTuple(tuple[int, ...]):
    def __new__(cls, iterable: Iterable[int]) -> "MyIntTuple":
        return super().__new__(cls, iterable)  # type: ignore

    @singledispatchmethod
    def __getitem__(self, value: slice, /) -> "MyIntTuple":
        return MyIntTuple(super().__getitem__(value))

    @__getitem__.register
    def __getitem__(self, value: int, /) -> int:
        return super().__getitem__(value)

this almost works except for slicing:

a = MyIntTuple(range(12))
print(a)        # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
print(a[3])     # 3 
print(a[3:6])   # (3, 4, 5)
b = a[5:8]
print(type(a))  # <class '__main__.MyIntTuple'>
print(type(b))  # <class 'tuple'>

the problem here is that slicing should return an instance of MyIntTuple. i seem to have gotten that wrong.

also mypy is not happy about this:

error: Name "__getitem__" already defined on line 488  [no-redef]

the subs in tuple are

Superclass:
    @overload
    def __getitem__(self, SupportsIndex, /) -> int
    @overload
    def __getitem__(self, slice, /) -> Tuple[int, ...]

how do i correctly overload those? is functools.singledispatchmethod the wrong way to go? or am i using it incorrectly?

overload in the signature mypy presents to you as expected is not some abstract thing, but a reference to decorator from typing.

Here's what you can do to match supertype definition:

from typing import Iterable, SupportsIndex, overload
from typing_extensions import reveal_type

class MyIntTuple(tuple[int, ...]):
    # Your main problem was here: `int` is much stricter than `SupportsIndex`
    @overload
    def __getitem__(self, value: SupportsIndex, /) -> int: ...
    @overload
    def __getitem__(self, value: slice, /) -> "MyIntTuple": ...
    
    def __getitem__(self, value: SupportsIndex | slice, /) -> "MyIntTuple | int":
        if isinstance(value, slice):
            return MyIntTuple(super().__getitem__(value))

        return super().__getitem__(value)


t = MyIntTuple((1,2,3))
reveal_type(t)  # N: Revealed type is "__main__.MyIntTuple"
reveal_type(t[0])  # N: Revealed type is "builtins.int"
reveal_type(t[1:])  # N: Revealed type is "__main__.MyIntTuple"

# And here's why "SupportsIndex"
class MySomething:
    def __index__(self) -> int:
        return 1

reveal_type(t[MySomething()])  # N: Revealed type is "builtins.int"

The snippet above shows a problem with using int: this restriction should be weakened, because narrower argument types are violating LSP. Actual tuple can use a slice or anything with __index__ dunder method defined, not just int in __getitem__.

With overload and SupportsIndex in place, you are almost ready. The only change you need is to swap overloads order: same overloads order is enforced by mypy, and Sequence puts SupportsIndex signature first (try to swap them back and watch the error). In this case it is not critical, but in general different overloads order may change the type resolution. Overloads are tried in the definition order, the topmost wins. If signatures overlap, usually you'll see an extra mypy error - but better keep overloads in order anyway. Here's what inverse order would generate:

main.py:6: error: Signature of "__getitem__" incompatible with supertype "tuple"  [override]
main.py:6: note: Overload variants must be defined in the same order as they are in "tuple"

The code above typechecks with --strict.

You need to give the individual implementations a different name from the "main" function:

@__getitem__.register
def _(self, value: int, /) -> int:
    return super().__getitem__(value)

Also, the implementation for slices should be separate from the "main" function (which is used as the fallback for unrecognized argument types), and the int implementation should really take anything that supports __index__.

Since MyIntTuple isn't defined yet, you'll have to pass a type to register explicitly for the slice implementation, so it doesn't have to look at the annotations. Also, you can remove your __new__ implementation - the inherited implementation will work fine:

from functools import singledispatchmethod
from typing import SupportsIndex

class MyIntTuple(tuple[int, ...]):
    @singledispatchmethod
    def __getitem__(self, arg, /):
        raise TypeError("Can't index MyIntTuple with argument of type {!r}".format(type(arg)))

    @__getitem__.register(slice)
    def _(self, value: slice, /) -> "MyIntTuple":
        return MyIntTuple(super().__getitem__(value))

    @__getitem__.register
    def _(self, value: SupportsIndex, /) -> int:
        return super().__getitem__(value)

There is a problem with singledispatchmethod.

from __future__ import annotations
from functools import singledispatchmethod
from typing import Iterable, Sequence

class MyIntTuple(tuple[int, ...]):
    def __new__(cls, iterable: Iterable[int]) -> MyIntTuple:
        return super().__new__(cls, iterable)  # type: ignore

    @singledispatchmethod
    def __getitem__(self) -> None:
        raise NotImplementedError

    @__getitem__.register
    def _(self, value: slice, /) -> MyIntTuple:
        return MyIntTuple(super().__getitem__(value))

    @__getitem__.register
    def _(self, value: int, /) -> int:
        return super().__getitem__(value)

a = MyIntTuple(range(12))
print(a)        # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
print(a[3])     # 3 
print(a[3:6])   # (3, 4, 5)
b = a[5:8]
print(type(a))  # <class '__main__.MyIntTuple'>
print(type(b))  # <class '__main__.MyIntTuple'>