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:

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_works_with_alias(self):

# These expressions must simply not fail.

typing.Match[Any]

typing.Pattern[Any]

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):

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_or(self):

X = TypeVar('X')

# use a string because str doesn't implement

# __or__/__ror__ itself

self.assertEqual(X | "x", Union[X, "x"])

self.assertEqual("x" | X, Union["x", X])

# make sure the order is correct

self.assertEqual(get_args(X | "x"), (X, ForwardRef("x")))

self.assertEqual(get_args("x" | X), (ForwardRef("x"), X))

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_missing__name__(self):

# See bpo-39942

code = ("import typing\n"

"T = typing.TypeVar('T')\n"

)

exec(code, {})

def test_no_bivariant(self):

with self.assertRaises(ValueError):

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(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)

u1 = Union[int, object]

u2 = Union[object, int]

self.assertEqual(u1, u2)

self.assertNotEqual(u1, object)

self.assertNotEqual(u2, 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_kept(self):

u = Union[Employee, Manager]

self.assertNotEqual(u, Employee)

self.assertIn(Employee, u.__args__)

self.assertIn(Manager, u.__args__)

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]')

u = Union[list[int], dict[str, float]]

self.assertEqual(repr(u), 'typing.Union[list[int], dict[str, float]]')

u = Union[int | float]

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

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()

with self.assertRaises(TypeError):

type(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.assertIn(str, Union[str, typing.Iterable[int]].__args__)

self.assertIn(typing.Iterable[int], Union[str, typing.Iterable[int]].__args__)

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_no_eval_union(self):

u = Union[int, str]

def f(x: u): ...

self.assertIs(get_type_hints(f)['x'], u)

def test_function_repr_union(self):

def fun() -> int: ...

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.)

from xml.etree.ElementTree import Element

Union[Element, str] # Shouldn't crash

def Elem(*args):

return Element(*args)

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): ...

self.assertIsSubclass(tuple, Tuple)

self.assertIsSubclass(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.assertIsSubclass(MyTuple, Tuple)

def test_tuple_instance_type_error(self):

with self.assertRaises(TypeError):

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

self.assertIsInstance((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, ...]')

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

def test_errors(self):

with self.assertRaises(TypeError):

issubclass(42, Tuple)

with self.assertRaises(TypeError):

def test_self_subclass(self):

Callable = self.Callable

with self.assertRaises(TypeError):

issubclass(types.FunctionType, Callable[[int], int])

self.assertIsSubclass(types.FunctionType, Callable)

def test_eq_hash(self):

Callable = self.Callable

C = Callable[[int], int]

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

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

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

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

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

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

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

self.assertNotEqual(C, Callable)

def test_cannot_instantiate(self):

Callable = self.Callable

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):

Callable = self.Callable

with self.assertRaises(TypeError):

Callable[int]

def test_callable_instance_works(self):

Callable = self.Callable

def f():

pass

self.assertIsInstance(f, Callable)

self.assertNotIsInstance(None, Callable)

def test_callable_instance_type_error(self):

Callable = self.Callable

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):

Callable = self.Callable

fullname = f'{Callable.__module__}.Callable'

ct0 = Callable[[], bool]

self.assertEqual(repr(ct0), f'{fullname}[[], bool]')

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

self.assertEqual(repr(ct2), f'{fullname}[[str, float], int]')

ctv = Callable[..., str]

self.assertEqual(repr(ctv), f'{fullname}[..., str]')

ct3 = Callable[[str, float], list[int]]

self.assertEqual(repr(ct3), f'{fullname}[[str, float], list[int]]')

def test_callable_with_ellipsis(self):

Callable = self.Callable

def foo(a: Callable[..., T]):

pass

self.assertEqual(get_type_hints(foo, globals(), locals()),

{'a': Callable[..., T]})

def test_ellipsis_in_generic(self):

Callable = self.Callable

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

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

def test_basic(self):

Callable = self.Callable

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

if Callable is collections.abc.Callable:

self.assertIsInstance(alias, types.GenericAlias)

self.assertIs(alias.__origin__, collections.abc.Callable)

self.assertEqual(alias.__args__, (int, str, float))

self.assertEqual(alias.__parameters__, ())

def test_weakref(self):

Callable = self.Callable

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

self.assertEqual(weakref.ref(alias)(), alias)

def test_pickle(self):

Callable = self.Callable

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

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

s = pickle.dumps(alias, proto)

loaded = pickle.loads(s)

self.assertEqual(alias.__origin__, loaded.__origin__)

self.assertEqual(alias.__args__, loaded.__args__)

self.assertEqual(alias.__parameters__, loaded.__parameters__)

def test_var_substitution(self):

Callable = self.Callable

fullname = f"{Callable.__module__}.Callable"

C1 = Callable[[int, T], T]

C2 = Callable[[KT, T], VT]

C3 = Callable[..., T]

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

self.assertEqual(C2[int, float, str], Callable[[int, float], str])

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

# multi chaining

C4 = C2[int, VT, str]

self.assertEqual(repr(C4), f"{fullname}[[int, ~VT], str]")

self.assertEqual(repr(C4[dict]), f"{fullname}[[int, dict], str]")

self.assertEqual(C4[dict], Callable[[int, dict], str])

# substitute a nested GenericAlias (both typing and the builtin

# version)

C5 = Callable[[typing.List[T], tuple[KT, T], VT], int]

self.assertEqual(C5[int, str, float],

Callable[[typing.List[int], tuple[str, int], float], int])

def test_type_erasure(self):

Callable = self.Callable

class C1(Callable):

def __call__(self):

return None

a = C1[[int], T]

self.assertIs(a().__class__, C1)

self.assertEqual(a().__orig_class__, C1[[int], T])

def test_paramspec(self):

Callable = self.Callable

fullname = f"{Callable.__module__}.Callable"

P = ParamSpec('P')

P2 = ParamSpec('P2')

C1 = Callable[P, T]

# substitution

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

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

self.assertEqual(C1[[], str], Callable[[], str])

self.assertEqual(C1[..., str], Callable[..., str])

self.assertEqual(C1[P2, str], Callable[P2, str])

self.assertEqual(C1[Concatenate[int, P2], str],

Callable[Concatenate[int, P2], str])

self.assertEqual(repr(C1), f"{fullname}[~P, ~T]")

self.assertEqual(repr(C1[[int, str], str]), f"{fullname}[[int, str], str]")

with self.assertRaises(TypeError):

C1[int, str]

C2 = Callable[P, int]

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

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

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

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

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

self.assertEqual(C2[Concatenate[int, P2]],

Callable[Concatenate[int, P2], int])

# special case in PEP 612 where

# X[int, str, float] == X[[int, str, float]]

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

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

self.assertEqual(repr(C2), f"{fullname}[~P, int]")

self.assertEqual(repr(C2[int, str]), f"{fullname}[[int, str], int]")

def test_concatenate(self):

Callable = self.Callable

fullname = f"{Callable.__module__}.Callable"

P = ParamSpec('P')

C1 = Callable[typing.Concatenate[int, P], int]

self.assertEqual(repr(C1),

f"{fullname}[typing.Concatenate[int, ~P], int]")

def test_errors(self):

Callable = self.Callable

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

with self.assertRaisesRegex(TypeError, "is not a generic class"):

alias[int]

P = ParamSpec('P')

C1 = Callable[P, T]

with self.assertRaisesRegex(TypeError, "many arguments for"):

C1[int, str, str]

with self.assertRaisesRegex(TypeError, "few arguments for"):

Callable = typing.Callable

def test_consistency(self):

# bpo-42195

# Testing collections.abc.Callable's consistency with typing.Callable

c1 = typing.Callable[[int, str], dict]

c2 = collections.abc.Callable[[int, str], dict]

self.assertEqual(c1.__args__, c2.__args__)

def test_basics(self):

# All of these are allowed.

Literal[1]

Literal[1, 2, 3]

Literal["x", "y", "z"]

Literal[None]

Literal[True]

Literal[1, "2", False]

Literal[Literal[1, 2], Literal[4, 5]]

Literal[b"foo", u"bar"]

def test_illegal_parameters_do_not_raise_runtime_errors(self):

# Type checkers should reject these types, but we do not

# raise errors at runtime to maintain maximum flexibility.

Literal[int]

Literal[3j + 2, ..., ()]

Literal[{"foo": 3, "bar": 4}]

Literal[T]

def test_literals_inside_other_types(self):

List[Literal[1, 2, 3]]

List[Literal[("foo", "bar", "baz")]]

def test_repr(self):

self.assertEqual(repr(Literal[1]), "typing.Literal[1]")

self.assertEqual(repr(Literal[1, True, "foo"]), "typing.Literal[1, True, 'foo']")

self.assertEqual(repr(Literal[int]), "typing.Literal[int]")

self.assertEqual(repr(Literal), "typing.Literal")

self.assertEqual(repr(Literal[None]), "typing.Literal[None]")

self.assertEqual(repr(Literal[1, 2, 3, 3]), "typing.Literal[1, 2, 3]")

def test_cannot_init(self):

with self.assertRaises(TypeError):

Literal()

with self.assertRaises(TypeError):

Literal[1]()

with self.assertRaises(TypeError):

type(Literal)()

with self.assertRaises(TypeError):

type(Literal[1])()

def test_no_isinstance_or_issubclass(self):

with self.assertRaises(TypeError):

isinstance(1, Literal[1])

with self.assertRaises(TypeError):

isinstance(int, Literal[1])

with self.assertRaises(TypeError):

issubclass(1, Literal[1])

with self.assertRaises(TypeError):

issubclass(int, Literal[1])

def test_no_subclassing(self):

with self.assertRaises(TypeError):

class Foo(Literal[1]): pass

with self.assertRaises(TypeError):

class Bar(Literal): pass

def test_no_multiple_subscripts(self):

with self.assertRaises(TypeError):

Literal[1][1]

def test_equal(self):

self.assertNotEqual(Literal[0], Literal[False])

self.assertNotEqual(Literal[True], Literal[1])

self.assertNotEqual(Literal[1], Literal[2])

self.assertNotEqual(Literal[1, True], Literal[1])

self.assertNotEqual(Literal[1, True], Literal[1, 1])

self.assertNotEqual(Literal[1, 2], Literal[True, 2])

self.assertEqual(Literal[1], Literal[1])

self.assertEqual(Literal[1, 2], Literal[2, 1])

self.assertEqual(Literal[1, 2, 3], Literal[1, 2, 3, 3])

def test_hash(self):

self.assertEqual(hash(Literal[1]), hash(Literal[1]))

self.assertEqual(hash(Literal[1, 2]), hash(Literal[2, 1]))

self.assertEqual(hash(Literal[1, 2, 3]), hash(Literal[1, 2, 3, 3]))

def test_args(self):

self.assertEqual(Literal[1, 2, 3].__args__, (1, 2, 3))

self.assertEqual(Literal[1, 2, 3, 3].__args__, (1, 2, 3))

self.assertEqual(Literal[1, Literal[2], Literal[3, 4]].__args__, (1, 2, 3, 4))

# Mutable arguments will not be deduplicated

self.assertEqual(Literal[[], []].__args__, ([], []))

def test_flatten(self):

l1 = Literal[Literal[1], Literal[2], Literal[3]]

l2 = Literal[Literal[1, 2], 3]

l3 = Literal[Literal[1, 2, 3]]

for l in l1, l2, l3:

self.assertEqual(l, Literal[1, 2, 3])

def __getitem__(self, key: XK) -> XV:

...

def __setitem__(self, key: XK, value: XV):

...

def get(self, key: XK, default: XV = None) -> XV:

def __init__(self):

self.store = {}

def __getitem__(self, key: str):

return self.store[key]

def __setitem__(self, key: str, value):

self.store[key] = value

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

try:

return self.store[key]

except KeyError:

attr: int = 1

def meth(self, arg: str) -> int:

if arg == 'this':

return 1

def test_basic_protocol(self):

@runtime_checkable

class P(Protocol):

def meth(self):

pass

class C: pass

class D:

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:

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):

def f():

pass

self.assertIsInstance(f, HasCallProtocol)

def test_no_inheritance_from_nominal(self):

class C: 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)

with self.assertRaises(TypeError):

C(42)

T = 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)

with self.assertRaises(TypeError):

CG[int](42)

def test_cannot_instantiate_abstract(self):

@runtime_checkable

class P(Protocol):

@abc.abstractmethod

def ameth(self) -> int:

raise NotImplementedError

class B(P):

pass

class C(B):

def ameth(self) -> int:

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:

def meth1(self):

pass

def meth2(self):

pass

class C1:

def meth1(self):

pass

class C2:

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:

def meth1(self):

pass

def meth2(self):

pass

class C1:

def meth1(self):

pass

class C2:

def meth2(self):

pass

self.assertNotIsInstance(C1(), P)