def add_2(value):
    return value + 2

def add_2(value):
    """Add 2 to value.

    Args:
        value: addable value

    Returns:
        Value with 2 added
    """
    return value + 2

def add_2(value: float) -> float:
    """Add 2 to value.

    Args:
        value: addable value

    Returns:
        Value with 2 added
    """
    return value + 2

from typing import NewType

UserId = NewType("UserId", int)
some_id = UserId(524313)

assert some_id == 524313
assert isinstance(some_id, int)


def get_user_name(user_id: UserId) -> str:
    ...

## passes type checking
user_a = get_user_name(UserId(42351))

## fails type checking; an int is not a UserId
user_b = get_user_name(-1)

from typing import Awaitable, Callable


def feeder(get_next_item: Callable[[], str]) -> None:
    ...


def async_query(
    on_success: Callable[[int], None], on_error: Callable[[int, Exception], None]
) -> None:
    ...


async def on_update(value: str) -> None:
    ...


callback: Callable[[str], Awaitable[None]] = on_update
func: Callable[..., None] = feeder
func2: Callable[..., None] = async_query

from collections.abc import Sequence
from typing import TypeVar

T = TypeVar("T")  ## Declare type variable


def first(values: Sequence[T]) -> T:  ## Generic function
    return values[0]


first([1, 2, 3, 4, 5])  ## int
first("abcde")  ## str

from typing import TypeVar, Generic
from logging import Logger, getLogger

T = TypeVar("T")
logger = getLogger()


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("%s: %s", self.name, message)


vlogger: LoggedVar[int] = LoggedVar(1, "test", logger)

from typing import TypeVar, ParamSpec, Callable, Tuple

ParamT = ParamSpec("ParamT")
ValueT = TypeVar("ValueT")


def echo_params(func: Callable[ParamT, ValueT]) -> Callable[ParamT, ValueT]:
    def inner(*args: ParamT.args, **kwargs: ParamT.kwargs) -> ValueT:
        print(args, kwargs)
        return func(*args, **kwargs)

    return inner


@echo_params
def get_value(x: int, y: str, z: float) -> Tuple[int, str, float]:
    return (x, y, z)

from typing import Any

a: Any = None
a = []  ## OK
a = 2  ## OK

s: str = ""
s = a  ## OK


def foo(item: Any) -> int:
    ## Passes type checking; 'item' could be any type,
    ## and that type might have a 'bar' method
    item.bar()
    ...

from typing_extensions import LiteralString

def run_query(sql: LiteralString) -> ...
    ...

def caller(arbitrary_string: str, literal_string: LiteralString) -> None:
    run_query("SELECT * FROM students")  ## ok
    run_query(literal_string)  ## ok
    run_query("SELECT * FROM " + literal_string)  ## ok
    run_query(arbitrary_string)  ## type checker error
    run_query(  ## type checker error
        f"SELECT * FROM students WHERE name = {arbitrary_string}"
    )

from typing_extensions import Never


def never_call_me(arg: Never) -> None:
    pass


def int_or_str(arg: int | str) -> None:
    never_call_me(arg)  ## type checker error
    match arg:
        case int():
            print("It's an int")
        case str():
            print("It's a str")
        case _:
            never_call_me(arg)  ## ok, arg is of type Never

from typing import NoReturn


def stop() -> NoReturn:
    raise RuntimeError("no way")

from typing_extensions import Self


class Foo:
    def return_self(self) -> Self:
        ...
        return self

from typing import TypeVar

Self = TypeVar("Self", bound="Foo")


class Foo:
    def return_self(self: Self) -> Self:
        ...
        return self

from typing import Tuple
from typing_extensions import TypeAlias, TypeVar

ValueT = TypeVar("ValueT")
ErrorT = TypeVar("ErrorT", bound=BaseException)
Result: TypeAlias = Tuple[ValueT] | Tuple[ErrorT]
MaybeResult = Tuple[ValueT] | Tuple[ErrorT]

result: Result[int, Exception] = (1,)
error: Result[int, Exception] = (Exception("test"),)

result2: MaybeResult[int, Exception] = (1,)
error2: MaybeResult[int, Exception] = (Exception("test"),)

from typing import Tuple

a: Tuple[int, str] = (1, "a")  ## correct
b: Tuple[int] = a  ## incorrect
c: Tuple[int, ...] = a  ## incorrect
d: Tuple[int, ...] = (1, 1, 1)  ## correct

from typing import Union

Union[Union[int, str], float] == Union[int, str, float]
Union[int] == int  ## 문법상 에러가 발생하지만, 의미상 동일하다.
Union[int, str, int] == Union[int, str] == int | str  ## 3.10부터 |를 사용할 수 있다.
Union[int, str] == Union[str, int]

a: Union[int, str] = 1  ## correct
a = "asd"  ## correct
a = 0.3  ## incorrect

from typing import Optional


def foo(arg: Optional[int] = None) -> None:
    ...

from collections.abc import Callable
from threading import Lock
from typing import Concatenate, ParamSpec, TypeVar

P = ParamSpec("P")
R = TypeVar("R")

## Use this lock to ensure that only one thread is executing a function
## at any time.
my_lock = Lock()


def with_lock(f: Callable[Concatenate[Lock, P], R]) -> Callable[P, R]:
    """A type-safe decorator which provides a lock."""

    def inner(*args: P.args, **kwargs: P.kwargs) -> R:
        ## Provide the lock as the first argument.
        return f(my_lock, *args, **kwargs)

    return inner


@with_lock
def sum_threadsafe(lock: Lock, numbers: list[float]) -> float:
    """Add a list of numbers together in a thread-safe manner."""
    with lock:
        return sum(numbers)


## We don't need to pass in the lock ourselves thanks to the decorator.
sum_threadsafe([1.1, 2.2, 3.3])

from typing import Type


class User:
    ...


class BasicUser(User):
    ...


class ProUser(User):
    ...


class TeamUser(User):
    ...


## Accepts User, BasicUser, ProUser, TeamUser, ...
def make_new_user(user_class: Type[User]) -> User:
    ## ...
    return user_class()

from typing import Literal, Any


def validate_simple(data: Any) -> Literal[True]:  ## always returns True
    ...


MODE = Literal["r", "rb", "w", "wb"]


def open_helper(file: str, mode: MODE) -> str:
    ...


open_helper("/some/path", "r")  ## Passes type check
open_helper("/other/path", "typo")  ## Error in type checker

from typing import ClassVar


class Starship:
    stats: ClassVar[dict[str, int]] = {}  ## class variable
    damage: int = 10  ## instance variable

    def __init__(self, value: int) -> None:
        self.damage = value


enterprise_d = Starship(3000)
enterprise_d.stats = {}  ## Error, setting class variable on instance
Starship.stats = {}  ## This is OK

from typing import Final

MAX_SIZE: Final[int] = 9000
MAX_SIZE += 1  ## Error reported by type checker


class Connection:
    TIMEOUT: Final[int] = 10


class FastConnector(Connection):
    TIMEOUT = 1  ## Error reported by type checker

from typing import TypedDict
from typing_extensions import Required, NotRequired


class SomeDict(TypedDict):
    a: Required[int]
    b: NotRequired[int]


a: SomeDict = {}  ## incorrect
b: SomeDict = {"a": 1}  ## correct
c: SomeDict = {"a": 1, "b": 2}  ## correct
d: SomeDict = {"b": 2}  ## incorrect

from typing import TypeGuard


def is_str_list(val: list[object]) -> TypeGuard[list[str]]:
    """Determines whether all objects in the list are strings"""
    return all(isinstance(x, str) for x in val)


def func1(val: list[object]):
    if is_str_list(val):
        ## Type of ``val`` is narrowed to ``list[str]``.
        print(" ".join(val))
    else:
        ## Type of ``val`` remains as ``list[object]``.
        print("Not a list of strings!")

from typing import TypeVar, Generic
from typing_extensions import TypeVarTuple


T = TypeVar('T')
Ts = TypeVarTuple('Ts')

def move_first_element_to_last(tup: tuple[T, *Ts]) -> tuple[*Ts, T]:
    return (*tup[1:], tup[0])

## T is bound to int, Ts is bound to ()
## Return value is (1,), which has type tuple[int]
move_first_element_to_last(tup=(1,))

## T is bound to int, Ts is bound to (str,)
## Return value is ('spam', 1), which has type tuple[str, int]
move_first_element_to_last(tup=(1, 'spam'))

## T is bound to int, Ts is bound to (str, float)
## Return value is ('spam', 3.0, 1), which has type tuple[str, float, int]
move_first_element_to_last(tup=(1, 'spam', 3.0))

## This fails to type check (and fails at runtime)
## because tuple[()] is not compatible with tuple[T, *Ts]
## (at least one element is required)
move_first_element_to_last(tup=())

Shape = TypeVarTuple('Shape')
class Array(Generic[*Shape]):
    def __getitem__(self, key: tuple[*Shape]) -> float: ...
    def __abs__(self) -> "Array[*Shape]": ...
    def get_shape(self) -> tuple[*Shape]: ...

## In older versions of Python, TypeVarTuple and Unpack
## are located in the `typing_extensions` backports package.
from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple("Ts")
tup: tuple[*Ts]         ## Syntax error on Python <= 3.10!
tup: tuple[Unpack[Ts]]  ## Semantically equivalent, and backwards-compatible

from typing import AnyStr


def concat(a: AnyStr, b: AnyStr) -> AnyStr:
    return a + b


concat("foo", "bar")  ## Ok, output has type 'unicode'
concat(b"foo", b"bar")  ## Ok, output has type 'bytes'
concat("foo", b"bar")  ## Error, cannot mix unicode and bytes

from typing import Protocol


class Test(Protocol):
    def __call__(self, x: int, *, y: str, z: int) -> tuple[int, str, int]:
        ...

from typing import NamedTuple


class Employee(NamedTuple):
    name: str
    id: int = 3


employee = Employee("Guido")
assert employee.id == 3
assert employee[0] == "Guido"
assert isinstance(employee, tuple)

from typing import TypedDict


class Point2D(TypedDict):
    x: int
    y: int
    label: str


a: Point2D = {"x": 1, "y": 2, "label": "good"}  ## OK
b: Point2D = {"z": 3, "label": "bad"}  ## Fails type check

assert Point2D(x=1, y=2, label="first") == dict(x=1, y=2, label="first")

Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})

from typing import Dict

def count_words(text: str) -> Dict[str, int]:
    ...

from typing import List, TypeVar, Sequence

T = TypeVar("T", int, float)


def vec2(x: T, y: T) -> List[T]:
    return [x, y]


def keep_positives(vector: Sequence[T]) -> List[T]:
    return [item for item in vector if item > 0]

from typing import Mapping

def get_position_in_index(word_list: Mapping[str, int], word: str) -> int:
    return word_list[word]

from typing import Generator

def echo_round() -> Generator[int, float, str]:
    sent = yield 0
    while sent >= 0:
        sent = yield round(sent)
    return 'Done'

from collections.abc import Coroutine

c: Coroutine[list[str], str, int]  ## Some coroutine defined elsewhere
x = c.send('hi')                   ## Inferred type of 'x' is list[str]

async def bar() -> None:
    y = await c                    ## Inferred type of 'y' is int

from typing import AsyncGenerator


async def echo_round() -> AsyncGenerator[int, float]:
    sent = yield 0
    while sent >= 0.0:
        rounded = await round(sent)
        sent = yield rounded