generics_basic.py

← Back to index
True Positive
False Positive
False Negative
Optional (detected)
Warning or Info
TP: 9
FP: 0
FN: 4
Optional: 0 / 0
"""
Tests for basic usage of generics.
"""

# Specification: https://typing.readthedocs.io/en/latest/spec/generics.html#introduction

from __future__ import annotations

from collections.abc import Sequence
from typing import Any, Generic, Protocol, TypeVar, assert_type

T = TypeVar("T")

# > Generics can be parameterized by using a factory available in
# > ``typing`` called ``TypeVar``.

def first(l: Sequence[T]) -> T:
    return l[0]

def test_first(seq_int: Sequence[int], seq_str: Sequence[str]) -> None:
    assert_type(first(seq_int), int)
    assert_type(first(seq_str), str)

# > ``TypeVar`` supports constraining parametric types to a fixed set of
# > possible types

AnyStr = TypeVar("AnyStr", str, bytes)

def concat(x: AnyStr, y: AnyStr) -> AnyStr:
    return x + y

def test_concat(s: str, b: bytes, a: Any) -> None:
    concat(s, s)  # OK
    concat(b, b)  # OK
    concat(s, b)  # E
Expected a ty diagnostic for this line
    concat(b, s)  # E
Expected a ty diagnostic for this line

    concat(s, a)  # OK
    concat(a, b)  # OK

# > Specifying a single constraint is disallowed.

BadConstraint1 = TypeVar("BadConstraint1", str)  # E
[invalid-legacy-type-variable] A `TypeVar` cannot have exactly one constraint

# > Note: those types cannot be parameterized by type variables

class Test(Generic[T]):
    BadConstraint2 = TypeVar("BadConstraint2", str, list[T])  # E
[invalid-type-variable-constraints] TypeVar constraint cannot be generic

# > Subtypes of types constrained by a type variable should be treated
# > as their respective explicitly listed base types in the context of the
# > type variable.

class MyStr(str): ...

def test_concat_subtype(s: str, b: bytes, a: Any, m: MyStr) -> None:
    assert_type(concat(m, m), str)
    assert_type(concat(m, s), str)
    concat(m, b)  # E
Expected a ty diagnostic for this line

    # TODO: should these be str or Any?
    # reveal_type(concat(m, a))
    # reveal_type(concat(a, m))

# Specification: https://typing.readthedocs.io/en/latest/spec/generics.html#user-defined-generic-classes

# > You can include a ``Generic`` base class to define a user-defined class
# > as generic.

from logging import Logger
from collections.abc import Iterable

class LoggedVar(Generic[T]):
    def __init__(self, value: T, name: str, logger: Logger) -> None:
        self.name = name
        self.logger = logger
        self.value = value

    def set(self, new: T) -> None:
        self.log("Set " + repr(self.value))
        self.value = new

    def get(self) -> T:
        self.log("Get " + repr(self.value))
        return self.value

    def log(self, message: str) -> None:
        self.logger.info("{}: {}".format(self.name, message))

def zero_all_vars(vars: Iterable[LoggedVar[int]]) -> None:
    for var in vars:
        var.set(0)
        assert_type(var.get(), int)

# > A generic type can have any number of type variables, and type variables
# > may be constrained.

S = TypeVar("S")

class Pair1(Generic[T, S]): ...

# > Each type variable argument to ``Generic`` must be distinct.

class Pair2(Generic[T, T]):  # E
[invalid-generic-class] Type parameter `T` cannot appear multiple times in `Generic` subscription
    ...

# > The ``Generic[T]`` base class is redundant in simple cases where you
# > subclass some other generic class and specify type variables for its
# > parameters.

from collections.abc import Iterator, Mapping

class MyIter1(Iterator[T]): ...

class MyIter2(Iterator[T], Generic[T]): ...

def test_my_iter(m1: MyIter1[int], m2: MyIter2[int]):
    assert_type(next(m1), int)
    assert_type(next(m2), int)

K = TypeVar("K")
V = TypeVar("V")

class MyMap1(Mapping[K, V], Generic[K, V]): ...

class MyMap2(Mapping[K, V], Generic[V, K]): ...

def test_my_map(m1: MyMap1[str, int], m2: MyMap2[int, str]):
    assert_type(m1["key"], int)
    assert_type(m2["key"], int)

    m1[0]  # E
[invalid-argument-type] Method `__getitem__` of type `bound method MyMap1[str, int].__getitem__(key: str, /) -> int` cannot be called with key of type `Literal[0]` on object of type `MyMap1[str, int]`
    m2[0]  # E
[invalid-argument-type] Method `__getitem__` of type `bound method MyMap2[int, str].__getitem__(key: str, /) -> int` cannot be called with key of type `Literal[0]` on object of type `MyMap2[int, str]`

# > All arguments to ``Generic`` or ``Protocol`` must be type variables.

class Bad1(Generic[int]): ...  # E
[invalid-argument-type] `<class 'int'>` is not a valid argument to `Generic`
class Bad2(Protocol[int]): ...  # E
[invalid-argument-type] `<class 'int'>` is not a valid argument to `Protocol`

# > All type parameters for the class must appear within the ``Generic`` or
# > ``Protocol`` type argument list.

T_co = TypeVar("T_co", covariant=True)
S_co = TypeVar("S_co", covariant=True)

class Bad3(Iterable[T_co], Generic[S_co]): ...  # E
[invalid-generic-class] `Generic` base class must include all type variables used in other base classes
class Bad4(Iterable[T_co], Protocol[S_co]): ...  # E
[invalid-generic-class] `Generic` base class must include all type variables used in other base classes

# > The above rule does not apply to a bare ``Protocol`` base class.

class MyIterator(Iterator[T_co], Protocol): ...  # OK

# > You can use multiple inheritance with ``Generic``

from collections.abc import Sized, Container

class LinkedList(Sized, Generic[T]): ...

class MyMapping(Iterable[tuple[K, V]], Container[tuple[K, V]], Generic[K, V]): ...

# > Subclassing a generic class without specifying type parameters assumes
# > ``Any`` for each position.  In the following example, ``MyIterable``
# > is not generic but implicitly inherits from ``Iterable[Any]``::

class MyIterableAny(Iterable):  # Same as Iterable[Any]
    ...

def test_my_iterable_any(m: MyIterableAny):
    assert_type(iter(m), Iterator[Any])

# > Generic metaclasses are not supported

class GenericMeta(type, Generic[T]): ...

class GenericMetaInstance(metaclass=GenericMeta[T]):  # E
Expected a ty diagnostic for this line
    ...