`mypy` recognises `[1]` also as `SequenceNotStr[str]`.

[cmp0xff]

Describe the bug

mypy thinks [1] also fits SequenceNotStr[str].

Since SequenceNotStr is our own definition, I think it worths to discuss here first, before sending the report to mypy.

To Reproduce

Minimal example

from collections.abc import Iterator, Sequence
from typing import Any, Protocol, SupportsIndex, overload
from typing_extensions import reveal_type, TypeVar


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


class SequenceNotStr(Protocol[_T_co]):
    @overload
    def __getitem__(self, index: SupportsIndex, /) -> _T_co: ...
    @overload
    def __getitem__(self, index: slice, /) -> Sequence[_T_co]: ...
    def __contains__(self, value: object, /) -> bool: ...
    def __len__(self) -> int: ...
    def __iter__(self) -> Iterator[_T_co]: ...
    def index(self, value: Any, start: int = ..., stop: int = ..., /) -> int: ...
    def count(self, value: Any, /) -> int: ...
    def __reversed__(self) -> Iterator[_T_co]: ...


def foo(a: SequenceNotStr[str]) -> None:
    reveal_type(a[0])  # mypy and pyright gives str


reveal_type(foo([1]))  # mypy gives None, pyright gives error

Indicate which type checker you are using

both

Please complete the following information:

• OS: Debian
• OS Version: 12
• python version: 3.12
• version of type checker: mypy 1.19.1
• version of installed pandas-stubs: None

Additional context
Add any other context about the problem here.

[Dr-Irv]

Can you report this at https://github.com/hauntsaninja/useful_types/ because that is where we got the idea for SequenceNotStr from?

[cmp0xff]

I think it has been reported in hauntsaninja/useful_types#25. The repo does not seem active, either.

[cmp0xff]

Maybe we can try tuple[T, ...] | MutableSequence[T]

from collections.abc import MutableSequence
from typing import TypeAlias, cast

from typing_extensions import TypeVar

T_co = TypeVar("T_co")

MutableOrTuple: TypeAlias = tuple[T_co, ...] | MutableSequence[T_co]

def foo(p: MutableOrTuple[str]) -> None: ...

foo([1])  # type checkers give error
foo("1")  # type checkers give error
foo(cast(str, "1"))  # type checkers give error

[cmp0xff]

Unfortunately both mypy and pyright have problems inferring types here:

from collections.abc import MutableSequence
from typing import TypeAlias

from typing_extensions import TypeVar

T_co = TypeVar("T_co")

MutableOrTuple: TypeAlias = tuple[T_co, ...] | MutableSequence[T_co]

def foo(p: MutableOrTuple[str | float]) -> None: ...

seq = ["1 day"]
foo(seq)  # both mypy and pyright complain
foo(["1 day"])  # neither mypy nor pyright complains

[randolf-scholz]

MutableSequence is invariant, not covariant, so foo(seq) fails.

foo(["1 day"]) succeeds because they convert the list literal into a function call [T](arg: T) -> list[T] and then T=str | float is a valid solution for the argument "1 day".

[cmp0xff]

It is surprising that Sequence is covariant but MutableSequence is not 😕

[randolf-scholz]

Not really, that's the price for mutability. Otherwise, stuff like this would be problematic:

def add_zero(arg: MutableSequence[int]) -> None:
    arg.append(0)

class MyInteger(int):
    def special_method(self): ...

l: list[MyInteger] = []
l.add_zero()
l[-1].special_method()  # kaboom