annotations_typeexpr.py

← Back to index
True Positive
False Positive
False Negative
Optional (detected)
Warning or Info
TP: 15
FP: 0
FN: 0
Optional: 0 / 0
"""
Test for type expressions used in annotations.
"""

import abc
import abc
import types
import types
from typing import Any, Callable, Tuple, Union, assert_type

# https://typing.readthedocs.io/en/latest/spec/annotations.html#valid-type-expression-forms


def greeting(name: str) -> str:
    return "Hello " + name


assert_type(greeting("Monty"), str)


# > Expressions whose type is a subtype of a specific argument type are also accepted for that argument.
class StrSub(str):
    ...


assert_type(greeting(StrSub("Monty")), str)


# > Type hints may be built-in classes (including those defined in standard library or third-party
# > extension modules), abstract base classes, types available in the types module, and user-defined
# > classes (including those defined in the standard library or third-party modules).


class UserDefinedClass:
    ...


class AbstractBaseClass(abc.ABC):
    @abc.abstractmethod
    def abstract_method(self):
        ...


# The following parameter annotations should all be considered
# valid and not generate errors.
def valid_annotations(
    p1: int,
    p2: str,
    p3: bytes,
    p4: bytearray,
    p5: memoryview,
    p6: complex,
    p7: float,
    p8: bool,
    p9: object,
    p10: type,
    p11: types.ModuleType,
    p12: types.FunctionType,
    p13: types.BuiltinFunctionType,
    p14: UserDefinedClass,
    p15: AbstractBaseClass,
    p16: int,
    p17: Union[int, str],
    p18: None,
    p19: list,
    p20: list[int],
    p21: tuple,
    p22: Tuple[int, ...],
    p23: Tuple[int, int, str],
    p24: Callable[..., int],
    p25: Callable[[int, str], None],
    p26: Any,
):
    assert_type(p17, int | str)
    assert_type(p19, list[Any])
    assert_type(p20, list[int])
    assert_type(p21, tuple[Any, ...])


# > Annotations should be kept simple or static analysis tools may not be able to interpret the values.

var1 = 3


# The following parameter annotations should all be considered
# invalid and generate errors.
def invalid_annotations(
    p1: eval("".join(map(chr, [105, 110, 116]))),  # E
[invalid-type-form] Function calls are not allowed in type expressions
    p2: [int, str],  # E
[invalid-type-form] List literals are not allowed in this context in a type expression: Did you mean `tuple[int, str]`?
    p3: (int, str),  # E
[invalid-type-form] Tuple literals are not allowed in this context in a type expression: Did you mean `tuple[int, str]`?
    p4: [int for i in range(1)],  # E
[invalid-type-form] List comprehensions are not allowed in type expressions
    p5: {},  # E
[invalid-type-form] Dict literals are not allowed in type expressions
    p6: (lambda: int)(),  # E
[invalid-type-form] Function calls are not allowed in type expressions
    p7: [int][0],  # E
[invalid-type-form] Invalid subscript of object of type `list[Unknown | <class 'int'>]` in type expression
[invalid-type-form] Int literals are not allowed in this context in a type expression
    p8: int if 1 < 3 else str,  # E
[invalid-type-form] `if` expressions are not allowed in type expressions
    p9: var1,  # E
[invalid-type-form] Variable of type `Literal[3]` is not allowed in a type expression
    p10: True,  # E
[invalid-type-form] Boolean literals are not allowed in this context in a type expression
    p11: 1,  # E
[invalid-type-form] Int literals are not allowed in this context in a type expression
    p12: -1,  # E
[invalid-type-form] Unary operations are not allowed in type expressions
    p13: int or str,  # E
[invalid-type-form] Boolean operations are not allowed in type expressions
    p14: f"int",  # E
[fstring-type-annotation] Type expressions cannot use f-strings
    p15: types,  # E
[invalid-type-form] Module `types` is not valid in a type expression
):
    pass


# > When used in a type hint, the expression None is considered equivalent to type(None).


def takes_None(x: None) -> None:
    ...


assert_type(takes_None(None), None)