from __future__ import absolute_import, unicode_literals

import collections

import contextlib

import os

import pickle

import re

import subprocess

import sys

import abc

import types

from unittest import TestCase, main, SkipTest

from copy import copy, deepcopy

from typing import Any, NoReturn

from typing import TypeVar, AnyStr

from typing import T, KT, VT # Not in __all__.

from typing import Union, Optional

from typing import Tuple, List, MutableMapping

from typing import Callable

from typing import Generic, ClassVar, GenericMeta, Final, Literal

from typing import cast

from typing import Type, Protocol, runtime_checkable

from typing import NewType

from typing import NamedTuple, TypedDict

from typing import Pattern, Match

import typing

import weakref

import collections

class BaseTestCase(TestCase):

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

if not issubclass(cls, class_or_tuple):

message = '%r is not a subclass of %r' % (cls, class_or_tuple)

if msg is not None:

message += ' : %s' % msg

raise self.failureException(message)

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

if issubclass(cls, class_or_tuple):

message = '%r is a subclass of %r' % (cls, class_or_tuple)

if msg is not None:

message += ' : %s' % msg

raise self.failureException(message)

def clear_caches(self):

for f in typing._cleanups:

f()

class Employee(object):

pass

class Manager(Employee):

pass

class Founder(Employee):

pass

class ManagingFounder(Manager, Founder):

pass

class AnyTests(BaseTestCase):

def test_any_instance_type_error(self):

with self.assertRaises(TypeError):

isinstance(42, Any)

def test_any_subclass_type_error(self):

with self.assertRaises(TypeError):

issubclass(Employee, Any)

with self.assertRaises(TypeError):

issubclass(Any, Employee)

def test_repr(self):

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

def test_errors(self):

with self.assertRaises(TypeError):

issubclass(42, Any)

with self.assertRaises(TypeError):

Any[int] # Any is not a generic type.

def test_cannot_subclass(self):

with self.assertRaises(TypeError):

class A(Any):

pass

with self.assertRaises(TypeError):

class A(type(Any)):

pass

def test_cannot_instantiate(self):

with self.assertRaises(TypeError):

Any()

with self.assertRaises(TypeError):

type(Any)()

def test_any_is_subclass(self):

# These expressions must simply not fail.

typing.Match[Any]

typing.Pattern[Any]

typing.IO[Any]

class NoReturnTests(BaseTestCase):

def test_noreturn_instance_type_error(self):

with self.assertRaises(TypeError):

isinstance(42, NoReturn)

def test_noreturn_subclass_type_error(self):

with self.assertRaises(TypeError):

issubclass(Employee, NoReturn)

with self.assertRaises(TypeError):

issubclass(NoReturn, Employee)

def test_repr(self):

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

def test_not_generic(self):

with self.assertRaises(TypeError):

NoReturn[int]

def test_cannot_subclass(self):

with self.assertRaises(TypeError):

class A(NoReturn):

pass

with self.assertRaises(TypeError):

class A(type(NoReturn)):

pass

def test_cannot_instantiate(self):

with self.assertRaises(TypeError):

NoReturn()

with self.assertRaises(TypeError):

type(NoReturn)()

class TypeVarTests(BaseTestCase):

def test_basic_plain(self):

T = TypeVar('T')

# T equals itself.

self.assertEqual(T, T)

# T is an instance of TypeVar

self.assertIsInstance(T, TypeVar)

def test_typevar_instance_type_error(self):

T = TypeVar('T')

with self.assertRaises(TypeError):

isinstance(42, T)

def test_typevar_subclass_type_error(self):

T = TypeVar('T')

with self.assertRaises(TypeError):

issubclass(int, T)

with self.assertRaises(TypeError):

issubclass(T, int)

def test_constrained_error(self):

with self.assertRaises(TypeError):

X = TypeVar('X', int)

X

def test_union_unique(self):

X = TypeVar('X')

Y = TypeVar('Y')

self.assertNotEqual(X, Y)

self.assertEqual(Union[X], X)

self.assertNotEqual(Union[X], Union[X, Y])

self.assertEqual(Union[X, X], X)

self.assertNotEqual(Union[X, int], Union[X])

self.assertNotEqual(Union[X, int], Union[int])

self.assertEqual(Union[X, int].__args__, (X, int))

self.assertEqual(Union[X, int].__parameters__, (X,))

self.assertIs(Union[X, int].__origin__, Union)

def test_union_constrained(self):

A = TypeVar('A', str, bytes)

self.assertNotEqual(Union[A, str], Union[A])

def test_repr(self):

self.assertEqual(repr(T), '~T')

self.assertEqual(repr(KT), '~KT')

self.assertEqual(repr(VT), '~VT')

self.assertEqual(repr(AnyStr), '~AnyStr')

T_co = TypeVar('T_co', covariant=True)

self.assertEqual(repr(T_co), '+T_co')

T_contra = TypeVar('T_contra', contravariant=True)

self.assertEqual(repr(T_contra), '-T_contra')

def test_no_redefinition(self):

self.assertNotEqual(TypeVar('T'), TypeVar('T'))

self.assertNotEqual(TypeVar('T', int, str), TypeVar('T', int, str))

def test_cannot_subclass_vars(self):

with self.assertRaises(TypeError):

class V(TypeVar('T')):

pass

def test_cannot_subclass_var_itself(self):

with self.assertRaises(TypeError):

class V(TypeVar):

pass

def test_cannot_instantiate_vars(self):

with self.assertRaises(TypeError):

TypeVar('A')()

def test_bound_errors(self):

with self.assertRaises(TypeError):

TypeVar('X', bound=42)

with self.assertRaises(TypeError):

TypeVar('X', str, float, bound=Employee)

def test_no_bivariant(self):

with self.assertRaises(ValueError):

TypeVar('T', covariant=True, contravariant=True)

class UnionTests(BaseTestCase):

def test_basics(self):

u = Union[int, float]

self.assertNotEqual(u, Union)

def test_subclass_error(self):

with self.assertRaises(TypeError):

issubclass(int, Union)

with self.assertRaises(TypeError):

issubclass(Union, int)

with self.assertRaises(TypeError):

issubclass(int, Union[int, str])

with self.assertRaises(TypeError):

issubclass(Union[int, str], int)

def test_union_any(self):

u = Union[Any]

self.assertEqual(u, Any)

u1 = Union[int, Any]

u2 = Union[Any, int]

u3 = Union[Any, object]

self.assertEqual(u1, u2)

self.assertNotEqual(u1, Any)

self.assertNotEqual(u2, Any)

self.assertNotEqual(u3, Any)

def test_union_object(self):

u = Union[object]

self.assertEqual(u, object)

u = Union[int, object]

self.assertEqual(u, object)

u = Union[object, int]

self.assertEqual(u, object)

def test_unordered(self):

u1 = Union[int, float]

u2 = Union[float, int]

self.assertEqual(u1, u2)

def test_single_class_disappears(self):

t = Union[Employee]

self.assertIs(t, Employee)

def test_base_class_disappears(self):

u = Union[Employee, Manager, int]

self.assertEqual(u, Union[int, Employee])

u = Union[Manager, int, Employee]

self.assertEqual(u, Union[int, Employee])

u = Union[Employee, Manager]

self.assertIs(u, Employee)

def test_union_union(self):

u = Union[int, float]

v = Union[u, Employee]

self.assertEqual(v, Union[int, float, Employee])

def test_repr(self):

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

u = Union[Employee, int]

self.assertEqual(repr(u), 'typing.Union[%s.Employee, int]' % __name__)

u = Union[int, Employee]

self.assertEqual(repr(u), 'typing.Union[int, %s.Employee]' % __name__)

T = TypeVar('T')

u = Union[T, int][int]

self.assertEqual(repr(u), repr(int))

u = Union[List[int], int]

self.assertEqual(repr(u), 'typing.Union[typing.List[int], int]')

def test_cannot_subclass(self):

with self.assertRaises(TypeError):

class C(Union):

pass

with self.assertRaises(TypeError):

class C(type(Union)):

pass

with self.assertRaises(TypeError):

class C(Union[int, str]):

pass

def test_cannot_instantiate(self):

with self.assertRaises(TypeError):

Union()

u = Union[int, float]

with self.assertRaises(TypeError):

u()

with self.assertRaises(TypeError):

type(u)()

def test_union_generalization(self):

self.assertFalse(Union[str, typing.Iterable[int]] == str)

self.assertFalse(Union[str, typing.Iterable[int]] == typing.Iterable[int])

self.assertTrue(Union[str, typing.Iterable] == typing.Iterable)

def test_union_compare_other(self):

self.assertNotEqual(Union, object)

self.assertNotEqual(Union, Any)

self.assertNotEqual(ClassVar, Union)

self.assertNotEqual(Optional, Union)

self.assertNotEqual([None], Optional)

self.assertNotEqual(Optional, typing.Mapping)

self.assertNotEqual(Optional[typing.MutableMapping], Union)

def test_optional(self):

o = Optional[int]

u = Union[int, None]

self.assertEqual(o, u)

def test_empty(self):

with self.assertRaises(TypeError):

Union[()]

def test_union_instance_type_error(self):

with self.assertRaises(TypeError):

isinstance(42, Union[int, str])

def test_no_eval_union(self):

u = Union[int, str]

self.assertIs(u._eval_type({}, {}), u)

def test_function_repr_union(self):

def fun(): pass

self.assertEqual(repr(Union[fun, int]), 'typing.Union[fun, int]')

def test_union_str_pattern(self):

# Shouldn't crash; see http://bugs.python.org/issue25390

A = Union[str, Pattern]

A

def test_etree(self):

# See https://github.com/python/typing/issues/229

# (Only relevant for Python 2.)

try:

from xml.etree.cElementTree import Element

except ImportError:

raise SkipTest("cElementTree not found")

Union[Element, str] # Shouldn't crash

def Elem(*args):

return Element(*args)

Union[Elem, str] # Nor should this

class TupleTests(BaseTestCase):

def test_basics(self):

with self.assertRaises(TypeError):

issubclass(Tuple, Tuple[int, str])

with self.assertRaises(TypeError):

issubclass(tuple, Tuple[int, str])

class TP(tuple): pass

self.assertTrue(issubclass(tuple, Tuple))

self.assertTrue(issubclass(TP, Tuple))

def test_equality(self):

self.assertEqual(Tuple[int], Tuple[int])

self.assertEqual(Tuple[int, ...], Tuple[int, ...])

self.assertNotEqual(Tuple[int], Tuple[int, int])

self.assertNotEqual(Tuple[int], Tuple[int, ...])

def test_tuple_subclass(self):

class MyTuple(tuple):

pass

self.assertTrue(issubclass(MyTuple, Tuple))

def test_tuple_instance_type_error(self):

with self.assertRaises(TypeError):

isinstance((0, 0), Tuple[int, int])

isinstance((0, 0), Tuple)

def test_repr(self):

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

self.assertEqual(repr(Tuple[()]), 'typing.Tuple[()]')

self.assertEqual(repr(Tuple[int, float]), 'typing.Tuple[int, float]')

self.assertEqual(repr(Tuple[int, ...]), 'typing.Tuple[int, ...]')

def test_errors(self):

with self.assertRaises(TypeError):

issubclass(42, Tuple)

with self.assertRaises(TypeError):

issubclass(42, Tuple[int])

class CallableTests(BaseTestCase):

def test_self_subclass(self):

with self.assertRaises(TypeError):

self.assertTrue(issubclass(type(lambda x: x), Callable[[int], int]))

self.assertTrue(issubclass(type(lambda x: x), Callable))

def test_eq_hash(self):

self.assertEqual(Callable[[int], int], Callable[[int], int])

self.assertEqual(len({Callable[[int], int], Callable[[int], int]}), 1)

self.assertNotEqual(Callable[[int], int], Callable[[int], str])

self.assertNotEqual(Callable[[int], int], Callable[[str], int])

self.assertNotEqual(Callable[[int], int], Callable[[int, int], int])

self.assertNotEqual(Callable[[int], int], Callable[[], int])

self.assertNotEqual(Callable[[int], int], Callable)

def test_cannot_instantiate(self):

with self.assertRaises(TypeError):

Callable()

with self.assertRaises(TypeError):

type(Callable)()

c = Callable[[int], str]

with self.assertRaises(TypeError):

c()

with self.assertRaises(TypeError):

type(c)()

def test_callable_wrong_forms(self):

with self.assertRaises(TypeError):

Callable[(), int]

with self.assertRaises(TypeError):

Callable[[()], int]

with self.assertRaises(TypeError):

Callable[[int, 1], 2]

with self.assertRaises(TypeError):

Callable[int]

def test_callable_instance_works(self):

def f():

pass

self.assertIsInstance(f, Callable)

self.assertNotIsInstance(None, Callable)

def test_callable_instance_type_error(self):

def f():

pass

with self.assertRaises(TypeError):

self.assertIsInstance(f, Callable[[], None])

with self.assertRaises(TypeError):

self.assertIsInstance(f, Callable[[], Any])

with self.assertRaises(TypeError):

self.assertNotIsInstance(None, Callable[[], None])

with self.assertRaises(TypeError):

self.assertNotIsInstance(None, Callable[[], Any])

def test_repr(self):

ct0 = Callable[[], bool]

self.assertEqual(repr(ct0), 'typing.Callable[[], bool]')

ct2 = Callable[[str, float], int]

self.assertEqual(repr(ct2), 'typing.Callable[[str, float], int]')

ctv = Callable[..., str]

self.assertEqual(repr(ctv), 'typing.Callable[..., str]')

def test_ellipsis_in_generic(self):

# Shouldn't crash; see https://github.com/python/typing/issues/259

typing.List[Callable[..., str]]

XK = TypeVar('XK', unicode, bytes)

XV = TypeVar('XV')

class SimpleMapping(Generic[XK, XV]):

def __getitem__(self, key):

pass

def __setitem__(self, key, value):

pass

def get(self, key, default=None):

pass

class MySimpleMapping(SimpleMapping[XK, XV]):

def __init__(self):

self.store = {}

def __getitem__(self, key):

return self.store[key]

def __setitem__(self, key, value):

self.store[key] = value

def get(self, key, default=None):

try:

return self.store[key]

except KeyError:

return default

class ProtocolTests(BaseTestCase):

def test_basic_protocol(self):

@runtime_checkable

class P(Protocol):

def meth(self):

pass

class C(object): pass

class D(object):

def meth(self):

pass

def f():

pass

self.assertIsSubclass(D, P)

self.assertIsInstance(D(), P)

self.assertNotIsSubclass(C, P)

self.assertNotIsInstance(C(), P)

self.assertNotIsSubclass(types.FunctionType, P)

self.assertNotIsInstance(f, P)

def test_everything_implements_empty_protocol(self):

@runtime_checkable

class Empty(Protocol): pass

class C(object): pass

def f():

pass

for thing in (object, type, tuple, C, types.FunctionType):

self.assertIsSubclass(thing, Empty)

for thing in (object(), 1, (), typing, f):

self.assertIsInstance(thing, Empty)

def test_function_implements_protocol(self):

@runtime_checkable

class Function(Protocol):

def __call__(self, *args, **kwargs):

pass

def f():

pass

self.assertIsInstance(f, Function)

def test_no_inheritance_from_nominal(self):

class C(object): pass

class BP(Protocol): pass

with self.assertRaises(TypeError):

class P(C, Protocol):

pass

with self.assertRaises(TypeError):

class P(Protocol, C):

pass

with self.assertRaises(TypeError):

class P(BP, C, Protocol):

pass

class D(BP, C): pass

class E(C, BP): pass

self.assertNotIsInstance(D(), E)

self.assertNotIsInstance(E(), D)

def test_no_instantiation(self):

class P(Protocol): pass

with self.assertRaises(TypeError):

P()

class C(P): pass

self.assertIsInstance(C(), C)

T = typing.TypeVar('T')

class PG(Protocol[T]): pass

with self.assertRaises(TypeError):

PG()

with self.assertRaises(TypeError):

PG[int]()

with self.assertRaises(TypeError):

PG[T]()

class CG(PG[T]): pass

self.assertIsInstance(CG[int](), CG)

def test_cannot_instantiate_abstract(self):

@runtime_checkable

class P(Protocol):

@abc.abstractmethod

def ameth(self):

raise NotImplementedError

class B(P):

pass

class C(B):

def ameth(self):

return 26

with self.assertRaises(TypeError):

B()

self.assertIsInstance(C(), P)

def test_subprotocols_extending(self):

class P1(Protocol):

def meth1(self):

pass

@runtime_checkable

class P2(P1, Protocol):

def meth2(self):

pass

class C(object):

def meth1(self):

pass

def meth2(self):

pass

class C1(object):

def meth1(self):

pass

class C2(object):

def meth2(self):

pass

self.assertNotIsInstance(C1(), P2)

self.assertNotIsInstance(C2(), P2)

self.assertNotIsSubclass(C1, P2)

self.assertNotIsSubclass(C2, P2)

self.assertIsInstance(C(), P2)

self.assertIsSubclass(C, P2)

def test_subprotocols_merging(self):

class P1(Protocol):

def meth1(self):

pass

class P2(Protocol):

def meth2(self):

pass

@runtime_checkable

class P(P1, P2, Protocol):

pass

class C(object):

def meth1(self):

pass

def meth2(self):

pass

class C1(object):

def meth1(self):

pass

class C2(object):

def meth2(self):

pass

self.assertNotIsInstance(C1(), P)

self.assertNotIsInstance(C2(), P)

self.assertNotIsSubclass(C1, P)

self.assertNotIsSubclass(C2, P)

self.assertIsInstance(C(), P)

self.assertIsSubclass(C, P)

def test_protocols_issubclass(self):

T = typing.TypeVar('T')

@runtime_checkable

class P(Protocol):

def x(self): pass

@runtime_checkable

class PG(Protocol[T]):

def x(self): pass

class BadP(Protocol):

def x(self): pass

class BadPG(Protocol[T]):

def x(self): pass

class C(object):

def x(self): pass

self.assertIsSubclass(C, P)

self.assertIsSubclass(C, PG)

self.assertIsSubclass(BadP, PG)

self.assertIsSubclass(PG[int], PG)

self.assertIsSubclass(BadPG[int], P)

self.assertIsSubclass(BadPG[T], PG)

with self.assertRaises(TypeError):

issubclass(C, PG[T])

with self.assertRaises(TypeError):

issubclass(C, PG[C])

with self.assertRaises(TypeError):

issubclass(C, BadP)

with self.assertRaises(TypeError):

issubclass(C, BadPG)

with self.assertRaises(TypeError):

issubclass(P, PG[T])

with self.assertRaises(TypeError):

issubclass(PG, PG[int])

def test_protocols_issubclass_non_callable(self):

class C(object):

x = 1

@runtime_checkable

class PNonCall(Protocol):

x = 1

with self.assertRaises(TypeError):

issubclass(C, PNonCall)

self.assertIsInstance(C(), PNonCall)

PNonCall.register(C)

with self.assertRaises(TypeError):

issubclass(C, PNonCall)

self.assertIsInstance(C(), PNonCall)

# check that non-protocol subclasses are not affected

class D(PNonCall): pass

self.assertNotIsSubclass(C, D)

self.assertNotIsInstance(C(), D)

D.register(C)

self.assertIsSubclass(C, D)

self.assertIsInstance(C(), D)

with self.assertRaises(TypeError):

issubclass(D, PNonCall)

def test_protocols_isinstance(self):

T = typing.TypeVar('T')

@runtime_checkable

class P(Protocol):

def meth(x): pass

@runtime_checkable

class PG(Protocol[T]):

def meth(x): pass

class BadP(Protocol):

def meth(x): pass

class BadPG(Protocol[T]):

def meth(x): pass

class C(object):

def meth(x): pass

self.assertIsInstance(C(), P)

self.assertIsInstance(C(), PG)

with self.assertRaises(TypeError):

isinstance(C(), PG[T])

with self.assertRaises(TypeError):

isinstance(C(), PG[C])

with self.assertRaises(TypeError):

isinstance(C(), BadP)

with self.assertRaises(TypeError):

isinstance(C(), BadPG)

def test_protocols_isinstance_init(self):

T = typing.TypeVar('T')

@runtime_checkable

class P(Protocol):

x = 1

@runtime_checkable

class PG(Protocol[T]):

x = 1

class C(object):

def __init__(self, x):

self.x = x

self.assertIsInstance(C(1), P)

self.assertIsInstance(C(1), PG)

def test_protocol_checks_after_subscript(self):

class P(Protocol[T]): pass

class C(P[T]): pass

class Old1: pass

class New1(object): pass

class Old2: pass

class New2(object): pass

CA = C[Any] # noqa

self.assertNotIsInstance(Old1(), C)

self.assertNotIsInstance(New1(), C)

self.assertNotIsSubclass(Old2, C)

self.assertNotIsSubclass(New2, C)

class D1(C[Any]): pass

class D2(C[Any]): pass

CI = C[int] # noqa

self.assertIsInstance(D1(), C)

self.assertIsSubclass(D2, C)

def test_protocols_support_register(self):

@runtime_checkable

class P(Protocol):

x = 1

class PM(Protocol):

def meth(self): pass

class D(PM): pass

class C(object): pass

D.register(C)

P.register(C)

self.assertIsInstance(C(), P)

self.assertIsInstance(C(), D)

def test_none_on_non_callable_doesnt_block_implementation(self):

@runtime_checkable

class P(Protocol):

x = 1

class A(object):

x = 1

class B(A):

x = None

class C(object):

def __init__(self):

self.x = None

self.assertIsInstance(B(), P)

self.assertIsInstance(C(), P)

def test_none_on_callable_blocks_implementation(self):

@runtime_checkable

class P(Protocol):

def x(self): pass

class A(object):

def x(self): pass

class B(A):

x = None

class C(object):

def __init__(self):

self.x = None

self.assertNotIsInstance(B(), P)

self.assertNotIsInstance(C(), P)

def test_non_protocol_subclasses(self):

class P(Protocol):

x = 1

@runtime_checkable

class PR(Protocol):

def meth(self): pass

class NonP(P):

x = 1

class NonPR(PR): pass

class C(object):

x = 1

class D(object):

def meth(self): pass

self.assertNotIsInstance(C(), NonP)

self.assertNotIsInstance(D(), NonPR)

self.assertNotIsSubclass(C, NonP)

self.assertNotIsSubclass(D, NonPR)

self.assertIsInstance(NonPR(), PR)

self.assertIsSubclass(NonPR, PR)

def test_custom_subclasshook(self):

class P(Protocol):

x = 1

class OKClass(object): pass

class BadClass(object):

x = 1

class C(P):

@classmethod

def __subclasshook__(cls, other):

return other.__name__.startswith("OK")

self.assertIsInstance(OKClass(), C)

self.assertNotIsInstance(BadClass(), C)

self.assertIsSubclass(OKClass, C)

self.assertNotIsSubclass(BadClass, C)

def test_issubclass_fails_correctly(self):

@runtime_checkable

class P(Protocol):

x = 1

class C: pass

with self.assertRaises(TypeError):

issubclass(C(), P)

def test_defining_generic_protocols(self):

T = typing.TypeVar('T')

S = typing.TypeVar('S')

@runtime_checkable

class PR(Protocol[T, S]):

def meth(self): pass

class P(PR[int, T], Protocol[T]):

y = 1

self.assertIsSubclass(PR[int, T], PR)

self.assertIsSubclass(P[str], PR)

with self.assertRaises(TypeError):

PR[int]

with self.assertRaises(TypeError):

P[int, str]

with self.assertRaises(TypeError):

PR[int, 1]

with self.assertRaises(TypeError):

PR[int, ClassVar]

class C(PR[int, T]): pass

self.assertIsInstance(C[str](), C)

def test_defining_generic_protocols_old_style(self):

T = typing.TypeVar('T')

S = typing.TypeVar('S')

@runtime_checkable

class PR(Protocol, typing.Generic[T, S]):

def meth(self): pass

class P(PR[int, str], Protocol):

y = 1

self.assertIsSubclass(PR[int, str], PR)

self.assertIsSubclass(P, PR)

with self.assertRaises(TypeError):

PR[int]

with self.assertRaises(TypeError):

PR[int, 1]

class P1(Protocol, typing.Generic[T]):

def bar(self, x): pass

class P2(typing.Generic[T], Protocol):

def bar(self, x): pass

@runtime_checkable

class PSub(P1[str], Protocol):

x = 1

class Test(object):

x = 1

def bar(self, x):

return x

self.assertIsInstance(Test(), PSub)

with self.assertRaises(TypeError):

PR[int, ClassVar]

def test_init_called(self):

T = typing.TypeVar('T')

class P(Protocol[T]): pass

class C(P[T]):

def __init__(self):

self.test = 'OK'

self.assertEqual(C[int]().test, 'OK')

def test_protocols_bad_subscripts(self):

T = typing.TypeVar('T')

S = typing.TypeVar('S')

with self.assertRaises(TypeError):

class P(Protocol[T, T]): pass

with self.assertRaises(TypeError):

class P(Protocol[int]): pass

with self.assertRaises(TypeError):

class P(Protocol[T], Protocol[S]): pass

with self.assertRaises(TypeError):

class P(Protocol[T], typing.Mapping[T, S]): pass

def test_generic_protocols_repr(self):

T = typing.TypeVar('T')

S = typing.TypeVar('S')

class P(Protocol[T, S]): pass

self.assertTrue(repr(P).endswith('P'))

self.assertTrue(repr(P[T, S]).endswith('P[~T, ~S]'))

self.assertTrue(repr(P[int, str]).endswith('P[int, str]'))

def test_generic_protocols_eq(self):

T = typing.TypeVar('T')

S = typing.TypeVar('S')

class P(Protocol[T, S]): pass

self.assertEqual(P, P)

self.assertEqual(P[int, T], P[int, T])

self.assertEqual(P[T, T][typing.Tuple[T, S]][int, str],

P[typing.Tuple[int, str], typing.Tuple[int, str]])

def test_generic_protocols_special_from_generic(self):

T = typing.TypeVar('T')

class P(Protocol[T]): pass

self.assertEqual(P.__parameters__, (T,))

self.assertIs(P.__args__, None)

self.assertIs(P.__origin__, None)

self.assertEqual(P[int].__parameters__, ())

self.assertEqual(P[int].__args__, (int,))

self.assertIs(P[int].__origin__, P)

def test_generic_protocols_special_from_protocol(self):

@runtime_checkable

class PR(Protocol):

x = 1

class P(Protocol):

def meth(self):

pass

T = typing.TypeVar('T')

class PG(Protocol[T]):

x = 1

def meth(self):

pass

self.assertTrue(P._is_protocol)

self.assertTrue(PR._is_protocol)

self.assertTrue(PG._is_protocol)

with self.assertRaises(AttributeError):

self.assertFalse(P._is_runtime_protocol)

self.assertTrue(PR._is_runtime_protocol)

self.assertTrue(PG[int]._is_protocol)

self.assertEqual(P._get_protocol_attrs(), {'meth'})

self.assertEqual(PR._get_protocol_attrs(), {'x'})

self.assertEqual(frozenset(PG._get_protocol_attrs()),

frozenset({'x', 'meth'}))

self.assertEqual(frozenset(PG[int]._get_protocol_attrs()),

frozenset({'x', 'meth'}))

def test_no_runtime_deco_on_nominal(self):

with self.assertRaises(TypeError):

@runtime_checkable

class C(object): pass

class Proto(Protocol):

x = 1

with self.assertRaises(TypeError):

@runtime_checkable

class Concrete(Proto):

pass

def test_none_treated_correctly(self):

@runtime_checkable

class P(Protocol):

x = None # type: int

class B(object): pass

self.assertNotIsInstance(B(), P)

class C(object):

x = 1

class D(object):

x = None