How to satisfy Typing.Sequence using Structural typing

[omar-abdelgawad]

I was reading the docs when I tried to implement the methods mentioned to remove Pylance errors in vscode. I don't want to inherit from typing.Sequence but still want to use its interaface. Almost all abstract typing classes work as I expected except Sequence.
The following snippet has only one error in the last line

# testing Sequence class

from typing import Collection, Container, Iterable, Reversible, Sequence, Sized


class ImplementsSequence:
    def __getitem__(self, index: int) -> int:
        return 0

    def __len__(self) -> int:
        return 0

    def __contains__(self, item) -> bool:
        return False

    def __iter__(self):
        return (1, 2, 3).__iter__()

    def __reversed__(self):
        return reversed([1, 2, 3])

    def index(self, item):
        return 0

    def count(self, item):
        return 0


Sequence.register(ImplementsSequence) # doesn't change anything with Pylance unfortunately


def accept_Sized(obj: Sized) -> None:
    print(len(obj))


def accept_iterable(obj: Iterable[int]) -> None:
    for x in obj:
        print(x)


def accept_Contains(obj: Container[int]) -> None:
    print(1 in obj)
    print(4 in obj)


def accepts_Reversible(obj: Reversible[int]) -> None:
    for x in reversed(obj):
        print(x)


def accepts_Collection(obj: Collection[int]) -> None:
    for x in obj:
        print(x)


def accepts_sequence(obj: Sequence) -> None:
    for x in obj:
        print(x)
    print(obj[2])


accept_Sized(ImplementsSequence())  # OK
accept_iterable(ImplementsSequence())  # OK
accept_Contains(ImplementsSequence())  # OK
accepts_Reversible(ImplementsSequence())  # OK
accepts_Collection(ImplementsSequence())  # OK
accepts_sequence(ImplementsSequence())  # Error????

The problem is that also unlike other abstract class the error message doesn't tell what method(s) are wrong/missing from the interface.

Argument of type "ImplementsSequence" cannot be assigned to parameter "obj" of type "Sequence[Unknown]" in function "accepts_sequence"
  "ImplementsSequence" is incompatible with "Sequence[Unknown]"Pylance[reportArgumentType](https://github.com/microsoft/pyright/blob/main/docs/configuration.md#reportArgumentType)

Is this behavior correct? If so what am I doing incorrectly?

[erictraut]

Pyright is a standards-compliant type checker for Python, which means it follows the rules spelled out in the Python type specification.

Sequence is a nominal type, not a structural type. In the Python type system, type compatibility rules for nominal types is based on static class hierarchies. Class B is a subtype of class A only if B derives from A. Dynamic registration of ABCs is not (and never will be) supported in the static type system.

In the Python type system, structural types are referred to as “protocols”. You can read about them in the Python type specification here and here. Examples of protocols includes Sized, Iterable, Container, and Reversible. You could create a protocol that defines the methods for Sequence, but you'd need to do that yourself because there is no such protocol defined in the stdlib.

[omar-abdelgawad]

Thanks I didn't know that!

I guess then I need advice on the best way to type hint the following function:

def _calculate_distance(self, p1, p2) -> float:
        return ((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2) ** 0.5

both p1 and p2 implement __getitem__ and have float values. I thought that the best way was to use Sequence[float] but that seems to be hard since the Point class used is from a third party package and doesn't inherit from Sequence. How should I add type hints to the signature in this situtation?

[erictraut]

You could write a SupportsGetItem protocol. Both Sequence and Point would satisfy that protocol.

You might be interested in the useful_types library, which defines a number of useful protocol classes. If you don't want to take a dependency on this library, you can copy the protocol definitions from it directly.

[erictraut]

Code sample in pyright playground

from typing import NamedTuple, Protocol, Sequence

class SupportsGetItem[T](Protocol):
    def __getitem__(self, key: int, /) -> T: ...

def calculate_distance(p1: SupportsGetItem[float], p2: SupportsGetItem[float]) -> float:
    return ((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2) ** 0.5

def func1(a: Sequence[float], b: Sequence[float]):
    return calculate_distance(a, b)

class Point(NamedTuple):
    x: float
    y: float

def func2(a: Point, b: Point):
    return calculate_distance(a, b)