Typehinting function to accept numpy arrays

I'm having trouble understanding why mypy throws an error with the following example.

import numpy as np
from typing import Sequence


def compute(x: Sequence[float]) -> bool:
    # some computation that does not modify x
    ...


compute(np.linspace(0, 1, 10))

Mypy Error:

Argument 1 to "compute" has incompatible type "ndarray[Any, dtype[floating[Any]]]"; expected "Sequence[float]"  [arg-type]

In particular, since typing.Sequence requires iterability, reversability, and indexing, I'd think a numpy array should also be a Sequence. Is it related to the fact that numpy arrays are mutable, and Sequence types are intended to be immutable? I notice when I change Sequence to Iterable, the problem is fixed. But I need to be able to index x in compute.

So, what is the best way to typehint the compute function so that it can accept objects with iterability and indexing?

np.ndarray is not a Sequence (incompatible with corresponding protocol), because np.ndarray does not implement .count and .index methods, which are required for collections.abc.Sequence, see the table of methods in link.

Here's a relevant question.

To make something sequence-like compatible with np.ndarray, I'd suggest to define your protocol:

from __future__ import annotations

from collections.abc import Collection, Reversible, Iterator
from typing import Protocol, TypeVar, overload

_T_co = TypeVar('_T_co', covariant=True)

class WeakSequence(Collection[_T_co], Reversible[_T_co], Protocol[_T_co]):
    @overload
    def __getitem__(self, index: int) -> _T_co: ...
    @overload
    def __getitem__(self, index: slice) -> WeakSequence[_T_co]: ...
    def __contains__(self, value: object) -> bool: ...
    def __iter__(self) -> Iterator[_T_co]: ...
    def __reversed__(self) -> Iterator[_T_co]: ...

This is basically the same as Sequence definition in typeshed except that I'm using Protocol instead of Generic (to avoid adding implementation - stubs don't have to, plus this makes structural subtyping more obvious) and omit .index and .count methods.

Now np.ndarray should be compatible with WeakSequence as well as a list or tuple, and you can use WeakSequence instead of collections.abc.Sequence in your annotations.

Try using np.ndarray as the type hint for x. I checked type(np.linspace(0, 1, 10)) and it returned np.ndarray