import abc

import asyncio

import collections

import collections.abc

import contextlib

import copy

import functools

import gc

import importlib

import inspect

import io

import itertools

import pickle

import re

import subprocess

import sys

import tempfile

import textwrap

import types

import typing

import warnings

from collections import defaultdict

from functools import lru_cache

from pathlib import Path

from unittest import TestCase, main, skipIf, skipUnless

from unittest.mock import patch

import typing_extensions

from _typed_dict_test_helper import Foo, FooGeneric, VeryAnnotated

from typing_extensions import (

_FORWARD_REF_HAS_CLASS,

Annotated,

Any,

AnyStr,

AsyncContextManager,

AsyncIterator,

Awaitable,

Buffer,

Callable,

ClassVar,

Concatenate,

Dict,

Doc,

Final,

Format,

Generic,

IntVar,

Iterable,

Iterator,

List,

Literal,

LiteralString,

NamedTuple,

Never,

NewType,

NoDefault,

NoExtraItems,

NoReturn,

NotRequired,

Optional,

ParamSpec,

ParamSpecArgs,

ParamSpecKwargs,

Protocol,

ReadOnly,

Required,

Self,

Sentinel,

Set,

Tuple,

Type,

TypeAlias,

TypeAliasType,

TypedDict,

TypeForm,

TypeGuard,

TypeIs,

TypeVar,

TypeVarTuple,

Union,

Unpack,

assert_never,

assert_type,

clear_overloads,

dataclass_transform,

deprecated,

disjoint_base,

evaluate_forward_ref,

final,

get_annotations,

get_args,

get_origin,

get_original_bases,

get_overloads,

get_protocol_members,

get_type_hints,

is_protocol,

is_typeddict,

no_type_check,

overload,

override,

reveal_type,

runtime,

runtime_checkable,

type_repr,

)

NoneType = type(None)

T = TypeVar("T")

KT = TypeVar("KT")

VT = TypeVar("VT")

# Flags used to mark tests that only apply after a specific

# version of the typing module.

TYPING_3_10_0 = sys.version_info[:3] >= (3, 10, 0)

# 3.11 makes runtime type checks (_type_check) more lenient.

TYPING_3_11_0 = sys.version_info[:3] >= (3, 11, 0)

# 3.12 changes the representation of Unpack[] (PEP 692)

# and adds PEP 695 to CPython's grammar

TYPING_3_12_0 = sys.version_info[:3] >= (3, 12, 0)

# @deprecated works differently in Python 3.12

TYPING_3_12_ONLY = (3, 12) <= sys.version_info < (3, 13)

# 3.13 drops support for the keyword argument syntax of TypedDict

TYPING_3_13_0 = sys.version_info[:3] >= (3, 13, 0)

# 3.13.0.rc1 fixes a problem with @deprecated

TYPING_3_13_0_RC = sys.version_info[:4] >= (3, 13, 0, "candidate")

TYPING_3_14_0 = sys.version_info[:3] >= (3, 14, 0)

# https://github.com/python/cpython/pull/27017 was backported into some 3.9 and 3.10

# versions, but not all

HAS_FORWARD_MODULE = "module" in inspect.signature(typing._type_check).parameters

skip_if_py313_beta_1 = skipIf(

sys.version_info[:5] == (3, 13, 0, 'beta', 1),

"Bugfixes will be released in 3.13.0b2"

)

ANN_MODULE_SOURCE = '''\

import sys

from typing import List, Optional

from functools import wraps

try:

__annotations__[1] = 2

except NameError:

assert sys.version_info >= (3, 14)

class C:

x = 5; y: Optional['C'] = None

from typing import Tuple

x: int = 5; y: str = x; f: Tuple[int, int]

class M(type):

try:

__annotations__['123'] = 123

except NameError:

assert sys.version_info >= (3, 14)

o: type = object

(pars): bool = True

class D(C):

j: str = 'hi'; k: str= 'bye'

from types import new_class

h_class = new_class('H', (C,))

j_class = new_class('J')

class F():

z: int = 5

def __init__(self, x):

pass

class Y(F):

def __init__(self):

super(F, self).__init__(123)

class Meta(type):

def __new__(meta, name, bases, namespace):

return super().__new__(meta, name, bases, namespace)

class S(metaclass = Meta):

x: str = 'something'

y: str = 'something else'

def foo(x: int = 10):

def bar(y: List[str]):

x: str = 'yes'

bar()

def dec(func):

@wraps(func)

def wrapper(*args, **kwargs):

return func(*args, **kwargs)

return wrapper

'''

ANN_MODULE_2_SOURCE = '''\

from typing import no_type_check, ClassVar

i: int = 1

j: int

x: float = i/10

def f():

class C: ...

return C()

f().new_attr: object = object()

class C:

def __init__(self, x: int) -> None:

self.x = x

c = C(5)

c.new_attr: int = 10

__annotations__ = {}

@no_type_check

class NTC:

def meth(self, param: complex) -> None:

...

class CV:

var: ClassVar['CV']

CV.var = CV()

'''

ANN_MODULE_3_SOURCE = '''\

def f_bad_ann():

__annotations__[1] = 2

class C_OK:

def __init__(self, x: int) -> None:

self.x: no_such_name = x # This one is OK as proposed by Guido

class D_bad_ann:

def __init__(self, x: int) -> None:

sfel.y: int = 0

def g_bad_ann():

no_such_name.attr: int = 0

'''

STOCK_ANNOTATIONS = """

a:int=3

b:str="foo"

class MyClass:

a:int=4

b:str="bar"

def __init__(self, a, b):

self.a = a

self.b = b

def __eq__(self, other):

return isinstance(other, MyClass) and self.a == other.a and self.b == other.b

def function(a:int, b:str) -> MyClass:

return MyClass(a, b)

def function2(a:int, b:"str", c:MyClass) -> MyClass:

pass

def function3(a:"int", b:"str", c:"MyClass"):

pass

class UnannotatedClass:

pass

def unannotated_function(a, b, c): pass

"""

STRINGIZED_ANNOTATIONS = """

from __future__ import annotations

a:int=3

b:str="foo"

class MyClass:

a:int=4

b:str="bar"

def __init__(self, a, b):

self.a = a

self.b = b

def __eq__(self, other):

return isinstance(other, MyClass) and self.a == other.a and self.b == other.b

def function(a:int, b:str) -> MyClass:

return MyClass(a, b)

def function2(a:int, b:"str", c:MyClass) -> MyClass:

pass

def function3(a:"int", b:"str", c:"MyClass"):

pass

class UnannotatedClass:

pass

def unannotated_function(a, b, c): pass

class MyClassWithLocalAnnotations:

mytype = int

x: mytype

"""

STRINGIZED_ANNOTATIONS_2 = """

from __future__ import annotations

def foo(a, b, c): pass

"""

if TYPING_3_12_0:

STRINGIZED_ANNOTATIONS_PEP_695 = textwrap.dedent(

"""

from __future__ import annotations

from typing import Callable, Unpack

class A[T, *Ts, **P]:

x: T

y: tuple[*Ts]

z: Callable[P, str]

class B[T, *Ts, **P]:

T = int

Ts = str

P = bytes

x: T

y: Ts

z: P

Eggs = int

Spam = str

class C[Eggs, **Spam]:

x: Eggs

y: Spam

def generic_function[T, *Ts, **P](

x: T, *y: Unpack[Ts], z: P.args, zz: P.kwargs

) -> None: ...

def generic_function_2[Eggs, **Spam](x: Eggs, y: Spam): pass

class D:

Foo = int

Bar = str

def generic_method[Foo, **Bar](

self, x: Foo, y: Bar

) -> None: ...

def generic_method_2[Eggs, **Spam](self, x: Eggs, y: Spam): pass

# Eggs is `int` in globals, a TypeVar in type_params, and `str` in locals:

class E[Eggs]:

Eggs = str

x: Eggs

def nested():

from types import SimpleNamespace

from typing_extensions import get_annotations

Eggs = bytes

Spam = memoryview

class F[Eggs, **Spam]:

x: Eggs

y: Spam

def generic_method[Eggs, **Spam](self, x: Eggs, y: Spam): pass

def generic_function[Eggs, **Spam](x: Eggs, y: Spam): pass

# Eggs is `int` in globals, `bytes` in the function scope,

# a TypeVar in the type_params, and `str` in locals:

class G[Eggs]:

Eggs = str

x: Eggs

return SimpleNamespace(

F=F,

F_annotations=get_annotations(F, eval_str=True),

F_meth_annotations=get_annotations(F.generic_method, eval_str=True),

G_annotations=get_annotations(G, eval_str=True),

generic_func=generic_function,

generic_func_annotations=get_annotations(generic_function, eval_str=True)

)

"""

)

else:

STRINGIZED_ANNOTATIONS_PEP_695 = None

class BaseTestCase(TestCase):

def assertIsSubclass(self, cls, class_or_tuple, msg=None):

if not issubclass(cls, class_or_tuple):

message = f'{cls!r} is not a subclass of {class_or_tuple!r}'

if msg is not None:

message += f' : {msg}'

raise self.failureException(message)

def assertNotIsSubclass(self, cls, class_or_tuple, msg=None):

if issubclass(cls, class_or_tuple):

message = f'{cls!r} is a subclass of {class_or_tuple!r}'

if msg is not None:

message += f' : {msg}'

raise self.failureException(message)

class EqualToForwardRef:

"""Helper to ease use of annotationlib.ForwardRef in tests.

This checks only attributes that can be set using the constructor.

"""

def __init__(

self,

arg,

*,

module=None,

owner=None,

is_class=False,

):

self.__forward_arg__ = arg

self.__forward_is_class__ = is_class

self.__forward_module__ = module

self.__owner__ = owner

def __eq__(self, other):

if not isinstance(other, (EqualToForwardRef, typing.ForwardRef)):

return NotImplemented

if sys.version_info >= (3, 14) and self.__owner__ != other.__owner__:

return False

return (

self.__forward_arg__ == other.__forward_arg__

and self.__forward_module__ == other.__forward_module__

and self.__forward_is_class__ == other.__forward_is_class__

)

def __repr__(self):

extra = []

if self.__forward_module__ is not None:

extra.append(f", module={self.__forward_module__!r}")

if self.__forward_is_class__:

extra.append(", is_class=True")

if sys.version_info >= (3, 14) and self.__owner__ is not None:

extra.append(f", owner={self.__owner__!r}")

return f"EqualToForwardRef({self.__forward_arg__!r}{''.join(extra)})"

class Employee:

pass

class BottomTypeTestsMixin:

bottom_type: ClassVar[Any]

def test_equality(self):

self.assertEqual(self.bottom_type, self.bottom_type)

self.assertIs(self.bottom_type, self.bottom_type)

self.assertNotEqual(self.bottom_type, None)

def test_get_origin(self):

self.assertIs(get_origin(self.bottom_type), None)

def test_instance_type_error(self):

with self.assertRaises(TypeError):

isinstance(42, self.bottom_type)

def test_subclass_type_error(self):

with self.assertRaises(TypeError):

issubclass(Employee, self.bottom_type)

with self.assertRaises(TypeError):

issubclass(NoReturn, self.bottom_type)

def test_not_generic(self):

with self.assertRaises(TypeError):

self.bottom_type[int]

def test_cannot_subclass(self):

with self.assertRaises(TypeError):

class A(self.bottom_type):

pass

with self.assertRaises(TypeError):

class B(type(self.bottom_type)):

pass

def test_cannot_instantiate(self):

with self.assertRaises(TypeError):

self.bottom_type()

with self.assertRaises(TypeError):

type(self.bottom_type)()

def test_pickle(self):

for proto in range(pickle.HIGHEST_PROTOCOL + 1):

pickled = pickle.dumps(self.bottom_type, protocol=proto)

self.assertIs(self.bottom_type, pickle.loads(pickled))

@skipUnless(TYPING_3_10_0, "PEP 604 has yet to be")

def test_or(self):

self.assertEqual(self.bottom_type | int, Union[self.bottom_type, int])

self.assertEqual(int | self.bottom_type, Union[int, self.bottom_type])

self.assertEqual(get_args(self.bottom_type | int), (self.bottom_type, int))

self.assertEqual(get_args(int | self.bottom_type), (int, self.bottom_type))

class NoReturnTests(BottomTypeTestsMixin, BaseTestCase):

bottom_type = NoReturn

def test_repr(self):

if hasattr(typing, 'NoReturn'):

self.assertEqual(repr(NoReturn), 'typing.NoReturn')

else:

self.assertEqual(repr(NoReturn), 'typing_extensions.NoReturn')

def test_get_type_hints(self):

def some(arg: NoReturn) -> NoReturn: ...

def some_str(arg: 'NoReturn') -> 'typing.NoReturn': ...

expected = {'arg': NoReturn, 'return': NoReturn}

for target in some, some_str:

with self.subTest(target=target):

self.assertEqual(gth(target), expected)

def test_not_equality(self):

self.assertNotEqual(NoReturn, Never)

self.assertNotEqual(Never, NoReturn)

class NeverTests(BottomTypeTestsMixin, BaseTestCase):

bottom_type = Never

def test_repr(self):

if hasattr(typing, 'Never'):

self.assertEqual(repr(Never), 'typing.Never')

else:

self.assertEqual(repr(Never), 'typing_extensions.Never')

def test_get_type_hints(self):

def some(arg: Never) -> Never: ...

def some_str(arg: 'Never') -> 'typing_extensions.Never': ...

expected = {'arg': Never, 'return': Never}

for target in [some, some_str]:

with self.subTest(target=target):

self.assertEqual(gth(target), expected)

class AssertNeverTests(BaseTestCase):

def test_exception(self):

with self.assertRaises(AssertionError):

assert_never(None)

value = "some value"

with self.assertRaisesRegex(AssertionError, value):

assert_never(value)

# Make sure a huge value doesn't get printed in its entirety

huge_value = "a" * 10000

with self.assertRaises(AssertionError) as cm:

assert_never(huge_value)

self.assertLess(

len(cm.exception.args[0]),

typing_extensions._ASSERT_NEVER_REPR_MAX_LENGTH * 2,

)

class OverrideTests(BaseTestCase):

def test_override(self):

class Base:

def normal_method(self): ...

@staticmethod

def static_method_good_order(): ...

@staticmethod

def static_method_bad_order(): ...

@staticmethod

def decorator_with_slots(): ...

class Derived(Base):

@override

def normal_method(self):

return 42

@staticmethod

@override

def static_method_good_order():

return 42

@override

@staticmethod

def static_method_bad_order():

return 42

self.assertIsSubclass(Derived, Base)

instance = Derived()

self.assertEqual(instance.normal_method(), 42)

self.assertIs(True, instance.normal_method.__override__)

self.assertEqual(Derived.static_method_good_order(), 42)

self.assertIs(True, Derived.static_method_good_order.__override__)

self.assertEqual(Derived.static_method_bad_order(), 42)

self.assertIs(False, hasattr(Derived.static_method_bad_order, "__override__"))

class DeprecatedTests(BaseTestCase):

def test_dunder_deprecated(self):

@deprecated("A will go away soon")

class A:

pass

self.assertEqual(A.__deprecated__, "A will go away soon")

self.assertIsInstance(A, type)

@deprecated("b will go away soon")

def b():

pass

self.assertEqual(b.__deprecated__, "b will go away soon")

self.assertIsInstance(b, types.FunctionType)

@overload

@deprecated("no more ints")

def h(x: int) -> int: ...

@overload

def h(x: str) -> str: ...

def h(x):

return x # pragma: no cover

overloads = get_overloads(h)

self.assertEqual(len(overloads), 2)

self.assertEqual(overloads[0].__deprecated__, "no more ints")

def test_class(self):

@deprecated("A will go away soon")

class A:

pass

with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):

A()

with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):

with self.assertRaises(TypeError):

A(42)

def test_class_with_init(self):

@deprecated("HasInit will go away soon")

class HasInit:

def __init__(self, x):

self.x = x

with self.assertWarnsRegex(DeprecationWarning, "HasInit will go away soon"):

instance = HasInit(42)

self.assertEqual(instance.x, 42)

def test_class_with_new(self):

has_new_called = False

@deprecated("HasNew will go away soon")

class HasNew:

def __new__(cls, x):

nonlocal has_new_called

has_new_called = True

return super().__new__(cls)

def __init__(self, x) -> None:

self.x = x

with self.assertWarnsRegex(DeprecationWarning, "HasNew will go away soon"):

instance = HasNew(42)

self.assertEqual(instance.x, 42)

self.assertTrue(has_new_called)

def test_class_with_inherited_new(self):

new_base_called = False

class NewBase:

def __new__(cls, x):

nonlocal new_base_called

new_base_called = True

return super().__new__(cls)

def __init__(self, x) -> None:

self.x = x

@deprecated("HasInheritedNew will go away soon")

class HasInheritedNew(NewBase):

pass

with self.assertWarnsRegex(DeprecationWarning, "HasInheritedNew will go away soon"):

instance = HasInheritedNew(42)

self.assertEqual(instance.x, 42)

self.assertTrue(new_base_called)

def test_class_with_new_but_no_init(self):

new_called = False

@deprecated("HasNewNoInit will go away soon")

class HasNewNoInit:

def __new__(cls, x):

nonlocal new_called

new_called = True

obj = super().__new__(cls)

obj.x = x

return obj

with self.assertWarnsRegex(DeprecationWarning, "HasNewNoInit will go away soon"):

instance = HasNewNoInit(42)

self.assertEqual(instance.x, 42)

self.assertTrue(new_called)

def test_mixin_class(self):

@deprecated("Mixin will go away soon")

class Mixin:

pass

class Base:

def __init__(self, a) -> None:

self.a = a

with self.assertWarnsRegex(DeprecationWarning, "Mixin will go away soon"):

class Child(Base, Mixin):

pass

instance = Child(42)

self.assertEqual(instance.a, 42)

def test_do_not_shadow_user_arguments(self):

new_called = False

new_called_cls = None

@deprecated("MyMeta will go away soon")

class MyMeta(type):

def __new__(mcs, name, bases, attrs, cls=None):

nonlocal new_called, new_called_cls

new_called = True

new_called_cls = cls

return super().__new__(mcs, name, bases, attrs)

with self.assertWarnsRegex(DeprecationWarning, "MyMeta will go away soon"):

class Foo(metaclass=MyMeta, cls='haha'):

pass

self.assertTrue(new_called)

self.assertEqual(new_called_cls, 'haha')

def test_existing_init_subclass(self):

@deprecated("C will go away soon")

class C:

def __init_subclass__(cls) -> None:

cls.inited = True

with self.assertWarnsRegex(DeprecationWarning, "C will go away soon"):

C()

with self.assertWarnsRegex(DeprecationWarning, "C will go away soon"):

class D(C):

pass

self.assertTrue(D.inited)

self.assertIsInstance(D(), D) # no deprecation

def test_existing_init_subclass_in_base(self):

class Base:

def __init_subclass__(cls, x) -> None:

cls.inited = x

@deprecated("C will go away soon")

class C(Base, x=42):

pass

self.assertEqual(C.inited, 42)

with self.assertWarnsRegex(DeprecationWarning, "C will go away soon"):

C()

with self.assertWarnsRegex(DeprecationWarning, "C will go away soon"):

class D(C, x=3):

pass

self.assertEqual(D.inited, 3)

def test_existing_init_subclass_in_sibling_base(self):

@deprecated("A will go away soon")

class A:

pass

class B:

def __init_subclass__(cls, x):

super().__init_subclass__()

cls.inited = x

with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):

class C(A, B, x=42):

pass

self.assertEqual(C.inited, 42)

with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):

class D(B, A, x=42):

pass

self.assertEqual(D.inited, 42)

def test_init_subclass_has_correct_cls(self):

init_subclass_saw = None

@deprecated("Base will go away soon")

class Base:

def __init_subclass__(cls) -> None:

nonlocal init_subclass_saw

init_subclass_saw = cls

self.assertIsNone(init_subclass_saw)

with self.assertWarnsRegex(DeprecationWarning, "Base will go away soon"):

class C(Base):

pass

self.assertIs(init_subclass_saw, C)

def test_init_subclass_with_explicit_classmethod(self):

init_subclass_saw = None

@deprecated("Base will go away soon")

class Base:

@classmethod

def __init_subclass__(cls) -> None:

nonlocal init_subclass_saw

init_subclass_saw = cls

self.assertIsNone(init_subclass_saw)

with self.assertWarnsRegex(DeprecationWarning, "Base will go away soon"):

class C(Base):

pass

self.assertIs(init_subclass_saw, C)

def test_function(self):

@deprecated("b will go away soon")

def b():

pass

with self.assertWarnsRegex(DeprecationWarning, "b will go away soon"):

b()

def test_method(self):

class Capybara:

@deprecated("x will go away soon")

def x(self):

pass

instance = Capybara()

with self.assertWarnsRegex(DeprecationWarning, "x will go away soon"):

instance.x()

def test_property(self):

class Capybara:

@property

@deprecated("x will go away soon")

def x(self):

pass

@property

def no_more_setting(self):

return 42

@no_more_setting.setter

@deprecated("no more setting")

def no_more_setting(self, value):

pass

instance = Capybara()

with self.assertWarnsRegex(DeprecationWarning, "x will go away soon"):

instance.x

with warnings.catch_warnings():

warnings.simplefilter("error")

self.assertEqual(instance.no_more_setting, 42)

with self.assertWarnsRegex(DeprecationWarning, "no more setting"):

instance.no_more_setting = 42

def test_category(self):

@deprecated("c will go away soon", category=RuntimeWarning)

def c():

pass

with self.assertWarnsRegex(RuntimeWarning, "c will go away soon"):

c()

def test_turn_off_warnings(self):

@deprecated("d will go away soon", category=None)

def d():

pass

with warnings.catch_warnings():

warnings.simplefilter("error")

d()

def test_only_strings_allowed(self):

with self.assertRaisesRegex(

TypeError,

"Expected an object of type str for 'message', not 'type'"

):

@deprecated

class Foo: ...

with self.assertRaisesRegex(

TypeError,

"Expected an object of type str for 'message', not 'function'"

):

@deprecated

def foo(): ...

def test_no_retained_references_to_wrapper_instance(self):

@deprecated('depr')

def d(): pass

self.assertFalse(any(

isinstance(cell.cell_contents, deprecated) for cell in d.__closure__

))

@deprecated("depr")

def func():

pass

@deprecated("depr")

async def coro():

pass

class Cls:

@deprecated("depr")

def func(self):

pass

@deprecated("depr")

async def coro(self):

pass

class DeprecatedCoroTests(BaseTestCase):

def test_asyncio_iscoroutinefunction(self):

with warnings.catch_warnings():

warnings.simplefilter("ignore", DeprecationWarning)

self.assertFalse(asyncio.coroutines.iscoroutinefunction(func))

self.assertFalse(asyncio.coroutines.iscoroutinefunction(Cls.func))

self.assertTrue(asyncio.coroutines.iscoroutinefunction(coro))

self.assertTrue(asyncio.coroutines.iscoroutinefunction(Cls.coro))

@skipUnless(TYPING_3_12_ONLY or TYPING_3_13_0_RC, "inspect.iscoroutinefunction works differently on Python < 3.12")

def test_inspect_iscoroutinefunction(self):

self.assertFalse(inspect.iscoroutinefunction(func))

self.assertFalse(inspect.iscoroutinefunction(Cls.func))

self.assertTrue(inspect.iscoroutinefunction(coro))

self.assertTrue(inspect.iscoroutinefunction(Cls.coro))

class AnyTests(BaseTestCase):

def test_can_subclass(self):

class Mock(Any): pass

self.assertTrue(issubclass(Mock, Any))

self.assertIsInstance(Mock(), Mock)

class Something: pass

self.assertFalse(issubclass(Something, Any))

self.assertNotIsInstance(Something(), Mock)

class MockSomething(Something, Mock): pass

self.assertTrue(issubclass(MockSomething, Any))