Recursive sequence type of Sequence[NotAString] should not accept str

[jorenham]

This is a (p)repost from python#18184, which also applies here:

The false negative can be reproduced with:

from collections.abc import Sequence
from typing import TypeAlias

class Scalar: ...

Vector: TypeAlias = Sequence[Scalar]
Tensor: TypeAlias = Vector | Sequence["Tensor"]

accepted_vector: Vector = [Scalar()]     # true negative
rejected_vector: Vector = "duck"         # true positive: ducks aren't vectors

accepted_tensor: Tensor = [[[Scalar()]]] # true negative
rejected_tensor1: Tensor = object()      # true positive: objects aren't tensors
rejected_tensor2: Tensor = "duck"        # false negative: ducks are tensors...?

mypy-play

---

alternative example:

class Increment[T]:  # covariant
    def current(self, /) -> T: ...  # type: ignore[empty-body]

type Infinity = Increment[Infinity]

type Zero = Increment[None]
type Integer = Zero | Increment[Integer]


def int2inf(integer: Integer, /) -> Infinity:
    return integer  # rejected => ok

def inf2int(infinity: Infinity, /) -> Integer:
    return infinity  # accepted => wut

• mypy-play
• bpr-play (also wrong)

[jorenham]

oh woops, this should be labeled as bug

[KotlinIsland]

oh woops, this should be labeled as bug

feel free to update it 😁

[KotlinIsland]

is this the same thing?

class C[T]: ...
type A = C[A] | int
type B = C[B]

b: B
a: A = b

[KotlinIsland]

• related Warn against iterating strings #651

[jorenham]

class C[T]: ...
type A = C[A] | int
type B = C[B]

b: B
a: A = b

If T is covariant, and mypy treats str like a recursive type, then it might indeed be a more general example.

---

edit
it's actually a different, but similar, issue. Because this Sequence issue actually works in as expected pyright, but your A, B example is accepted in both mypy and pyright:

• https://basedpyright.com/?pyrightVersion=1.22.0&typeCheckingMode=all&code=MYGwhgzhAEDCDaAVAugLmgOiwWAFB4BcBPABwFNoBBaAXjnkuUNIoCFb7Wn9cATMgGbQBACgBG6VgBpoAegCU0ALQA%2BKqjzQt0AE5kCAVx0A7aGLxA

• https://basedpyright.com/?pyrightVersion=1.22.0&typeCheckingMode=all&code=GYJw9gtgBAxmA28CmMAuBLMA7AzgOgEMAjGKdCABzBFSgGUkBHAVySxiQFgAoUSKVAE8K6LAHMylarQAqwpAEF46Ajh48Y8VTnowCWkAC4oeU%2Bu4A1FKmrG5FRctVQAvPSat2SANp09BgF0eGTYcWyh7RxUdNys0aigAH3cWNg5vACIQ3GoMoO4eAhgOClQkABMAfQA3a3C4mxBXKF9-AhAACgBKAKg%2BvoBiARBWKCwkMQIMWp4QJAArawqauqMoBoS3DPLmGABrDP6jweHRqhx0aaRjHf2ddrYAclpa%2BJA1Au4ikrKqspy1tkwk03N4wX59O1ugEYVAhqgRkgxhMpugZtw5os0Mt-sCAIx2UKbKBgIhY1DdY5w05I86XNHXElk6z3OZYZ4CInvWYLJZ-LkAJkJAOa212BypJ2A%2BhwSPGkyuN3FrKRuOo%2BFMAH4gA

[jorenham]

is this the same thing?

class C[T]: ...
type A = C[A] | int
type B = C[B]

b: B
a: A = b

What's the | int for btw 🤔 ?

[KotlinIsland]

What's the | int for btw 🤔 ?

just for being closer to the original egg

[jorenham]

this seems relevant

basedmypy/mypy/subtypes.py

Lines 170 to 189 in 0935784

	if mypy.typeops.is_recursive_pair(left, right):
	# This case requires special care because it may cause infinite recursion.
	# Our view on recursive types is known under a fancy name of iso-recursive mu-types.
	# Roughly this means that a recursive type is defined as an alias where right hand side
	# can refer to the type as a whole, for example:
	# A = Union[int, Tuple[A, ...]]
	# and an alias unrolled once represents the *same type*, in our case all these represent
	# the same type:
	# A
	# Union[int, Tuple[A, ...]]
	# Union[int, Tuple[Union[int, Tuple[A, ...]], ...]]
	# The algorithm for subtyping is then essentially under the assumption that left <: right,
	# check that get_proper_type(left) <: get_proper_type(right). On the example above,
	# If we start with:
	# A = Union[int, Tuple[A, ...]]
	# B = Union[int, Tuple[B, ...]]
	# When checking if A <: B we push pair (A, B) onto 'assuming' stack, then when after few
	# steps we come back to initial call is_subtype(A, B) and immediately return True.
	with pop_on_exit(type_state.get_assumptions(is_proper=False), left, right):
	return _is_subtype(left, right, subtype_context, proper_subtype=False)

[KotlinIsland]

i really don't understand this. if you could put together an egg, that would be good

[jorenham]

how about the egg in the issue itself?

[KotlinIsland]

how about the egg in the issue itself?

i don't get that one 😅

probably an egg where it's not using any stdlib, and there is a positive and a negative

[jorenham]

class Increment[T]:  # covariant
    def current(self, /) -> T: ...  # type: ignore[empty-body]

type Infinity = Increment[Infinity]

type Zero = Increment[None]
type Integer = Zero | Increment[Integer]


def int2inf(integer: Integer, /) -> Infinity:
    return integer  # rejected => ok

def inf2int(infinity: Infinity, /) -> Integer:
    return infinity  # accepted => wut

• mypy-play
• bpr-play

[KotlinIsland]

does the covariance impact the situation?

is this the same thing?

class Thing: ...
class Box[T]: ...

type CouldEnd = Box[CouldEnd] | Thing
type Recursive = Box[Recursive]

b: Recursive = Box()
a: CouldEnd = b # this should be an error

c: CouldEnd = Box[Box[Box[Thing]]]() # this is just for fun

[jorenham]

does the covariance impact the situation?

is this the same thing?

class Thing: ...
class Box[T]: ...

type CouldEnd = Box[CouldEnd] | Thing
type Recursive = Box[Recursive]

b: Recursive = Box()
a: CouldEnd = b # this should be an error

c: CouldEnd = Box[Box[Box[Thing]]]() # this is just for fun

I thought that both mypy and pyright (incorrectly) inferred T@Box as covariant in such cases 🤔