def check_default_invariant_behaviour(
self, type_a, type_b, local_variables=None, global_variables=None
):
"""
Template for performing certain type checks which use default covariant/contravariant settings
The default is invariant
"""
self.assertFalse(
is_type_of_type(
type_a,
type_b,
local_variables=local_variables,
global_variables=global_variables,
)
)
self.assertFalse(
is_type_of_type(
type_b,
type_a,
local_variables=local_variables,
global_variables=global_variables,
)
)
self.assertTrue(
is_type_of_type(
type_a,
type_a,
local_variables=local_variables,
global_variables=global_variables,
)
)
def test_in_built_types(self):
"""
Tests an unusual result found while testing tuples
"""
a = (1, 1) # Tuple
b = 1 # Int
c = 1.1 # Float
d = 1 + 1j # Complex
e = None # NoneType
f = True # Boolean
g = {} # Dictionary
h = [] # List
i = '' # String
k = b'' # Bytes
self.assertTrue(is_type_of_type(type(a), Tuple))
self.assertTrue(is_type_of_type(type(b), Integer))
self.assertTrue(is_type_of_type(type(c), numbers.Real))
self.assertTrue(is_type_of_type(type(d), numbers.Complex))
self.assertTrue(is_type_of_type(type(e), type(None)))
self.assertTrue(is_type_of_type(type(f), Boolean))
self.assertTrue(is_type_of_type(type(g), Dict))
self.assertTrue(is_type_of_type(type(h), List))
self.assertTrue(is_type_of_type(type(i), str))
self.assertTrue(is_type_of_type(type(k), bytes))
def test_in_built_types(self):
"""
Tests an unusual result found while testing tuples
"""
a = (1, 1) # Tuple
b = 1 # Int
c = 1.1 # Float
d = 1 + 1j # Complex
e = None # NoneType
f = True # Boolean
g = {} # Dictionary
h = [] # List
i = '' # String
k = b'' # Bytes
self.assertTrue(is_type_of_type(type(a), Tuple))
self.assertTrue(is_type_of_type(type(b), Integer))
self.assertTrue(is_type_of_type(type(c), numbers.Real))
self.assertTrue(is_type_of_type(type(d), numbers.Complex))
self.assertTrue(is_type_of_type(type(e), type(None)))
self.assertTrue(is_type_of_type(type(f), Boolean))
self.assertTrue(is_type_of_type(type(g), Dict))
self.assertTrue(is_type_of_type(type(h), List))
self.assertTrue(is_type_of_type(type(i), str))
self.assertTrue(is_type_of_type(type(k), bytes))
def check_invariant(self,
type_a,
type_b,
local_variables=None,
global_variables=None):
"""
Template for performing certain invariant type checks
"""
self.assertFalse(
is_type_of_type(type_a,
type_b,
covariant=False,
contravariant=False,
local_variables=local_variables,
global_variables=global_variables))
self.assertFalse(
is_type_of_type(type_b,
type_a,
covariant=False,
contravariant=False,
local_variables=local_variables,
global_variables=global_variables))
self.assertTrue(
is_type_of_type(type_a,
type_a,
covariant=False,
contravariant=False,
local_variables=local_variables,
global_variables=global_variables))
def test_type_var_default(self):
"""
Verifies that type checking works as expected with parameterless TypeVar
and it works invariantly
"""
T = TypeVar('T')
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(None, T))
def test_type_var_constrained(self):
"""
Verifies that type checking respects the TypeVar constraints
"""
T = TypeVar('T', Animal, int)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
def test_type_var_constrained(self):
"""
Verifies that type checking respects the TypeVar constraints
"""
T = TypeVar('T', Animal, int)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
def test_type_var_default(self):
"""
Verifies that type checking works as expected with parameterless TypeVar
and it works invariantly
"""
T = TypeVar('T')
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(None, T))
def test_any(self):
"""
Verifies that type checking works with Any construct
"""
self.assertTrue(is_type_of_type(Animal, Any))
self.assertTrue(is_type_of_type(None, Any))
self.assertTrue(is_type_of_type(12, Any))
self.assertTrue(is_type_of_type([1, 3, 'str'], Any))
self.assertTrue(type, Any)
def test_none(self):
"""
Verifies that type checking automatically replaces None with NoneType
"""
self.assertTrue(is_type_of_type(None, None))
self.assertTrue(is_type_of_type(type(None), None))
self.assertTrue(is_type_of_type(None, None, covariant=True))
self.assertTrue(is_type_of_type(None, None, contravariant=True))
self.assertTrue(is_type_of_type(None, None, covariant=True, contravariant=True))
def test_none(self):
"""
Verifies that type checking automatically replaces None with NoneType
"""
self.assertTrue(is_type_of_type(None, None))
self.assertTrue(is_type_of_type(type(None), None))
self.assertTrue(is_type_of_type(None, None, covariant=True))
self.assertTrue(is_type_of_type(None, None, contravariant=True))
self.assertTrue(is_type_of_type(None, None, covariant=True, contravariant=True))
def test_type_var_contravariant(self):
"""
Verifies that type checking works with contravariant TypeVars
"""
T = TypeVar('T', Pet, int, contravariant=True)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertFalse(is_type_of_type(Chihuahua, T))
self.assertTrue(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
def test_type_var_contravariant(self):
"""
Verifies that type checking works with contravariant TypeVars
"""
T = TypeVar('T', Pet, int, contravariant=True)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertFalse(is_type_of_type(Chihuahua, T))
self.assertTrue(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
def test_enhanced_type_var(self):
"""
Verifies that type checking behaves exactly the same with an Enhanced TypeVar
as it would with a default TypeVar
"""
T = EnhancedTypeVar('T', str, int, Animal)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(int, T))
self.assertTrue(is_type_of_type(str, T))
self.assertFalse(is_type_of_type(Pet, T))
self.assertFalse(is_type_of_type(None, T))
def test_enhanced_type_var_bivariant(self):
"""
Default TypeVars cannot be bivariant
This test verifies if an Enhanced version of it will properly checked
"""
T = EnhancedTypeVar('T', Pet, int, covariant=True, contravariant=True)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertTrue(is_type_of_type(Chihuahua, T))
self.assertTrue(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
def test_enhanced_type_var_bivariant(self):
"""
Default TypeVars cannot be bivariant
This test verifies if an Enhanced version of it will properly checked
"""
T = EnhancedTypeVar('T', Pet, int, covariant=True, contravariant=True)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertTrue(is_type_of_type(Chihuahua, T))
self.assertTrue(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
def test_enhanced_type_var(self):
"""
Verifies that type checking behaves exactly the same with an Enhanced TypeVar
as it would with a default TypeVar
"""
T = EnhancedTypeVar('T', str, int, Animal)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(int, T))
self.assertTrue(is_type_of_type(str, T))
self.assertFalse(is_type_of_type(Pet, T))
self.assertFalse(is_type_of_type(None, T))
def test_abc_protocols(self):
"""
Verifies that ABC protocols are respected and working as expected
"""
some_list = [1]
list_type = type(some_list)
self.assertTrue(is_type_of_type(list_type, Sized, covariant=True))
def test_abc_protocols(self):
"""
Verifies that ABC protocols are respected and working as expected
"""
some_list = [1]
list_type = type(some_list)
self.assertTrue(is_type_of_type(list_type, Sized, covariant=True))
def check_default_invariant_behaviour(self, type_a, type_b, local_variables=None, global_variables=None):
"""
Template for performing certain type checks which use default covariant/contravariant settings
The default is invariant
"""
self.assertFalse(is_type_of_type(type_a,
type_b,
local_variables=local_variables,
global_variables=global_variables))
self.assertFalse(is_type_of_type(type_b,
type_a,
local_variables=local_variables,
global_variables=global_variables))
self.assertTrue(is_type_of_type(type_a,
type_a,
local_variables=local_variables,
global_variables=global_variables))
def check_invariant(self, type_a, type_b, local_variables=None, global_variables=None):
"""
Template for performing certain invariant type checks
"""
self.assertFalse(is_type_of_type(type_a,
type_b,
covariant=False,
contravariant=False,
local_variables=local_variables,
global_variables=global_variables))
self.assertFalse(is_type_of_type(type_b,
type_a,
covariant=False,
contravariant=False,
local_variables=local_variables,
global_variables=global_variables))
self.assertTrue(is_type_of_type(type_a,
type_a,
covariant=False,
contravariant=False,
local_variables=local_variables,
global_variables=global_variables))
def test_complex_type_var(self):
"""
Verifies that nested types, such as Unions, can be compared
"""
T = TypeVar('T', Union[int, str], bytes)
K = TypeVar('K', Optional[int], str)
self.assertTrue(is_type_of_type(Union[str, int], T))
self.assertTrue(is_type_of_type(bytes, T))
self.assertFalse(is_type_of_type(Union[int, str, bytes], T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(bytearray, T))
self.assertTrue(is_type_of_type(Optional[int], K))
self.assertTrue(is_type_of_type(Union[None, int], K))
self.assertTrue(is_type_of_type(str, K))
self.assertFalse(is_type_of_type(int, K))
def test_complex_type_var(self):
"""
Verifies that nested types, such as Unions, can be compared
"""
T = TypeVar('T', Union[int, str], bytes)
K = TypeVar('K', Optional[int], str)
self.assertTrue(is_type_of_type(Union[str, int], T))
self.assertTrue(is_type_of_type(bytes, T))
self.assertFalse(is_type_of_type(Union[int, str, bytes], T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(bytearray, T))
self.assertTrue(is_type_of_type(Optional[int], K))
self.assertTrue(is_type_of_type(Union[None, int], K))
self.assertTrue(is_type_of_type(str, K))
self.assertFalse(is_type_of_type(int, K))
def test_subbclasscheck(self):
"""
Verifies that subclasscheck is always respected if present
"""
class A:
@classmethod
def __subclasscheck__(cls, C):
try:
if cls is C.subclass_of:
return True
else:
return False
except AttributeError:
return NotImplemented
class B(A):
pass
class C:
subclass_of = A
class D(A):
subclass_of = None
class E:
subclass_of = None
self.assertTrue(is_type_of_type(A, A))
self.assertFalse(is_type_of_type(B, A))
self.assertFalse(is_type_of_type(A, B))
self.assertFalse(is_type_of_type(C, A))
self.assertFalse(is_type_of_type(A, C))
self.assertFalse(is_type_of_type(D, A))
self.assertFalse(is_type_of_type(A, D))
self.assertFalse(is_type_of_type(E, A))
self.assertFalse(is_type_of_type(A, E))
self.assertTrue(is_type_of_type(A, A, covariant=True))
self.assertTrue(is_type_of_type(A, A, contravariant=True))
self.assertTrue(is_type_of_type(A, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True))
self.assertFalse(is_type_of_type(A, B, covariant=True))
self.assertFalse(is_type_of_type(B, A, contravariant=True))
self.assertTrue(is_type_of_type(A, B, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True))
self.assertFalse(is_type_of_type(A, C, covariant=True))
self.assertFalse(is_type_of_type(C, A, contravariant=True))
self.assertTrue(is_type_of_type(A, C, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(D, A, covariant=True))
self.assertFalse(is_type_of_type(A, D, covariant=True))
self.assertFalse(is_type_of_type(D, A, contravariant=True))
self.assertFalse(is_type_of_type(A, D, contravariant=True))
self.assertFalse(is_type_of_type(D, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(A, D, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True))
self.assertFalse(is_type_of_type(E, A, contravariant=True))
self.assertFalse(is_type_of_type(A, E, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True, contravariant=True))
def test_subbclasshook(self):
"""
Verifies that a subclasshook in ABC is respected and it takes precedence over ABC registry
"""
class A(ABC):
@classmethod
def __subclasshook__(cls, C):
try:
if cls is C.subclass_of:
return True
else:
return False
except AttributeError:
return NotImplemented
class B(A):
pass
class C:
subclass_of = A
class D(A):
subclass_of = None
class E:
subclass_of = None
A.register(E)
self.assertTrue(is_type_of_type(A, A))
self.assertFalse(is_type_of_type(B, A))
self.assertFalse(is_type_of_type(A, B))
self.assertFalse(is_type_of_type(C, A))
self.assertFalse(is_type_of_type(A, C))
self.assertFalse(is_type_of_type(D, A))
self.assertFalse(is_type_of_type(A, D))
self.assertFalse(is_type_of_type(E, A))
self.assertFalse(is_type_of_type(A, E))
self.assertTrue(is_type_of_type(A, A, covariant=True))
self.assertTrue(is_type_of_type(A, A, contravariant=True))
self.assertTrue(is_type_of_type(A, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True))
self.assertFalse(is_type_of_type(A, B, covariant=True))
self.assertFalse(is_type_of_type(B, A, contravariant=True))
self.assertTrue(is_type_of_type(A, B, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True))
self.assertFalse(is_type_of_type(A, C, covariant=True))
self.assertFalse(is_type_of_type(C, A, contravariant=True))
self.assertTrue(is_type_of_type(A, C, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(D, A, covariant=True))
self.assertFalse(is_type_of_type(A, D, covariant=True))
self.assertFalse(is_type_of_type(D, A, contravariant=True))
self.assertFalse(is_type_of_type(A, D, contravariant=True))
self.assertFalse(is_type_of_type(D, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(A, D, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True))
self.assertFalse(is_type_of_type(E, A, contravariant=True))
self.assertFalse(is_type_of_type(A, E, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True, contravariant=True))
def test_abc_registry(self):
"""
Verifies that when a class is registered with ABC,
unless a type check is invariant or subclasshook is defined on ABC,
it would be a subclass of that ABC.
This check must be done recursively.
"""
# NOTE: Subclass test is a covariant check
class A(ABC):
pass
class B(A):
pass
class C(ABC):
pass
class D(A):
pass
class E:
pass
class F:
pass
class G:
pass
A.register(C)
A.register(D)
A.register(G)
A.register(tuple)
C.register(F)
self.assertTrue(is_type_of_type(A, A))
self.assertFalse(is_type_of_type(B, A))
self.assertFalse(is_type_of_type(A, B))
self.assertFalse(is_type_of_type(C, A))
self.assertFalse(is_type_of_type(A, C))
self.assertFalse(is_type_of_type(D, A))
self.assertFalse(is_type_of_type(A, D))
self.assertFalse(is_type_of_type(E, A))
self.assertFalse(is_type_of_type(A, E))
self.assertFalse(is_type_of_type(F, A))
self.assertFalse(is_type_of_type(A, F))
self.assertFalse(is_type_of_type(G, A))
self.assertFalse(is_type_of_type(A, G))
self.assertFalse(is_type_of_type(tuple, A))
self.assertFalse(is_type_of_type(A, tuple))
self.assertTrue(is_type_of_type(A, A, covariant=True))
self.assertTrue(is_type_of_type(A, A, contravariant=True))
self.assertTrue(is_type_of_type(A, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True))
self.assertFalse(is_type_of_type(A, B, covariant=True))
self.assertFalse(is_type_of_type(B, A, contravariant=True))
self.assertTrue(is_type_of_type(A, B, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(A, B, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True))
self.assertFalse(is_type_of_type(A, C, covariant=True))
self.assertFalse(is_type_of_type(C, A, contravariant=True))
self.assertTrue(is_type_of_type(A, C, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(A, C, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(D, A, covariant=True))
self.assertFalse(is_type_of_type(A, D, covariant=True))
self.assertFalse(is_type_of_type(D, A, contravariant=True))
self.assertTrue(is_type_of_type(A, D, contravariant=True))
self.assertTrue(is_type_of_type(D, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(A, D, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True))
self.assertFalse(is_type_of_type(E, A, contravariant=True))
self.assertFalse(is_type_of_type(A, E, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(F, A, covariant=True))
self.assertFalse(is_type_of_type(A, F, covariant=True))
self.assertFalse(is_type_of_type(F, A, contravariant=True))
self.assertTrue(is_type_of_type(A, F, contravariant=True))
self.assertTrue(is_type_of_type(F, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(A, F, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(G, A, covariant=True))
self.assertFalse(is_type_of_type(A, G, covariant=True))
self.assertFalse(is_type_of_type(G, A, contravariant=True))
self.assertTrue(is_type_of_type(A, G, contravariant=True))
self.assertTrue(is_type_of_type(G, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(A, G, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(tuple, A, covariant=True))
self.assertFalse(is_type_of_type(A, tuple, covariant=True))
self.assertFalse(is_type_of_type(tuple, A, contravariant=True))
self.assertTrue(is_type_of_type(A, tuple, contravariant=True))
self.assertTrue(is_type_of_type(tuple, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(A, tuple, covariant=True, contravariant=True))
def test_generic_type(self):
"""
Verifies that it can correctly compare generic types
"""
from enforce.enforcers import GenericProxy
T = TypeVar('T')
class A(Generic[T]):
pass
class B(A):
pass
C = GenericProxy(A)
self.assertFalse(is_type_of_type(A, Generic))
self.assertFalse(is_type_of_type(Generic, A))
self.assertTrue(is_type_of_type(A, Generic, covariant=True))
self.assertFalse(is_type_of_type(Generic, A, covariant=True))
self.assertFalse(is_type_of_type(A, Generic, contravariant=True))
self.assertTrue(is_type_of_type(Generic, A, contravariant=True))
self.assertTrue(is_type_of_type(A, Generic, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(Generic, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(B, Generic))
self.assertFalse(is_type_of_type(Generic, B))
self.assertTrue(is_type_of_type(B, Generic, covariant=True))
self.assertFalse(is_type_of_type(Generic, B, covariant=True))
self.assertFalse(is_type_of_type(B, Generic, contravariant=True))
self.assertTrue(is_type_of_type(Generic, B, contravariant=True))
self.assertTrue(is_type_of_type(B, Generic, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(Generic, B, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(C, Generic))
self.assertFalse(is_type_of_type(Generic, C))
self.assertTrue(is_type_of_type(C, Generic, covariant=True))
self.assertFalse(is_type_of_type(Generic, C, covariant=True))
self.assertFalse(is_type_of_type(C, Generic, contravariant=True))
self.assertTrue(is_type_of_type(Generic, C, contravariant=True))
self.assertTrue(is_type_of_type(C, Generic, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(Generic, C, covariant=True, contravariant=True))
def test_generic_type(self):
"""
Verifies that it can correctly compare generic types
"""
from enforce.enforcers import GenericProxy
T = TypeVar('T')
class A(Generic[T]):
pass
class B(A):
pass
C = GenericProxy(A)
self.assertFalse(is_type_of_type(A, Generic))
self.assertFalse(is_type_of_type(Generic, A))
self.assertTrue(is_type_of_type(A, Generic, covariant=True))
self.assertFalse(is_type_of_type(Generic, A, covariant=True))
self.assertFalse(is_type_of_type(A, Generic, contravariant=True))
self.assertTrue(is_type_of_type(Generic, A, contravariant=True))
self.assertTrue(
is_type_of_type(A, Generic, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(Generic, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(B, Generic))
self.assertFalse(is_type_of_type(Generic, B))
self.assertTrue(is_type_of_type(B, Generic, covariant=True))
self.assertFalse(is_type_of_type(Generic, B, covariant=True))
self.assertFalse(is_type_of_type(B, Generic, contravariant=True))
self.assertTrue(is_type_of_type(Generic, B, contravariant=True))
self.assertTrue(
is_type_of_type(B, Generic, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(Generic, B, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(C, Generic))
self.assertFalse(is_type_of_type(Generic, C))
self.assertTrue(is_type_of_type(C, Generic, covariant=True))
self.assertFalse(is_type_of_type(Generic, C, covariant=True))
self.assertFalse(is_type_of_type(C, Generic, contravariant=True))
self.assertTrue(is_type_of_type(Generic, C, contravariant=True))
self.assertTrue(
is_type_of_type(C, Generic, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(Generic, C, covariant=True, contravariant=True))
def test_type_var_bounded(self):
"""
Verifies that type checking works with bounded TypeVars
It uses Enhanced TypeVars for bivariant tests as default TypeVars cannot be bivariant
"""
T = TypeVar('T', bound=Animal)
self.assertTrue(is_type_of_type(Animal, T))
self.assertFalse(is_type_of_type(Pet, T))
self.assertFalse(is_type_of_type(Chihuahua, T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
T = TypeVar('T', covariant=True, bound=Animal)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertTrue(is_type_of_type(Chihuahua, T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
T = TypeVar('T', contravariant=True, bound=Pet)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertFalse(is_type_of_type(Chihuahua, T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
# Bivariant TypeVars are not supported by default
# Therefore, testing it with an Enhanced version of TypeVar
T = EnhancedTypeVar('T', covariant=True, contravariant=True, bound=Pet)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertTrue(is_type_of_type(Chihuahua, T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
def test_any_from_str(self):
"""
Verifies that type checking works with Any construct if it is provided as a string with the type name
"""
self.assertTrue(is_type_of_type(Animal, 'Any'))
def test_type_var_bounded(self):
"""
Verifies that type checking works with bounded TypeVars
It uses Enhanced TypeVars for bivariant tests as default TypeVars cannot be bivariant
"""
T = TypeVar('T', bound=Animal)
self.assertTrue(is_type_of_type(Animal, T))
self.assertFalse(is_type_of_type(Pet, T))
self.assertFalse(is_type_of_type(Chihuahua, T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
T = TypeVar('T', covariant=True, bound=Animal)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertTrue(is_type_of_type(Chihuahua, T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
T = TypeVar('T', contravariant=True, bound=Pet)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertFalse(is_type_of_type(Chihuahua, T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
# Bivariant TypeVars are not supported by default
# Therefore, testing it with an Enhanced version of TypeVar
T = EnhancedTypeVar('T', covariant=True, contravariant=True, bound=Pet)
self.assertTrue(is_type_of_type(Animal, T))
self.assertTrue(is_type_of_type(Pet, T))
self.assertTrue(is_type_of_type(Chihuahua, T))
self.assertFalse(is_type_of_type(int, T))
self.assertFalse(is_type_of_type(None, T))
def test_abc_registry(self):
"""
Verifies that when a class is registered with ABC,
unless a type check is invariant or subclasshook is defined on ABC,
it would be a subclass of that ABC.
This check must be done recursively.
"""
# NOTE: Subclass test is a covariant check
class A(ABC):
pass
class B(A):
pass
class C(ABC):
pass
class D(A):
pass
class E:
pass
class F:
pass
class G:
pass
A.register(C)
A.register(D)
A.register(G)
A.register(tuple)
C.register(F)
self.assertTrue(is_type_of_type(A, A))
self.assertFalse(is_type_of_type(B, A))
self.assertFalse(is_type_of_type(A, B))
self.assertFalse(is_type_of_type(C, A))
self.assertFalse(is_type_of_type(A, C))
self.assertFalse(is_type_of_type(D, A))
self.assertFalse(is_type_of_type(A, D))
self.assertFalse(is_type_of_type(E, A))
self.assertFalse(is_type_of_type(A, E))
self.assertFalse(is_type_of_type(F, A))
self.assertFalse(is_type_of_type(A, F))
self.assertFalse(is_type_of_type(G, A))
self.assertFalse(is_type_of_type(A, G))
self.assertFalse(is_type_of_type(tuple, A))
self.assertFalse(is_type_of_type(A, tuple))
self.assertTrue(is_type_of_type(A, A, covariant=True))
self.assertTrue(is_type_of_type(A, A, contravariant=True))
self.assertTrue(
is_type_of_type(A, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True))
self.assertFalse(is_type_of_type(A, B, covariant=True))
self.assertFalse(is_type_of_type(B, A, contravariant=True))
self.assertTrue(is_type_of_type(A, B, contravariant=True))
self.assertTrue(
is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(A, B, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True))
self.assertFalse(is_type_of_type(A, C, covariant=True))
self.assertFalse(is_type_of_type(C, A, contravariant=True))
self.assertTrue(is_type_of_type(A, C, contravariant=True))
self.assertTrue(
is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(A, C, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(D, A, covariant=True))
self.assertFalse(is_type_of_type(A, D, covariant=True))
self.assertFalse(is_type_of_type(D, A, contravariant=True))
self.assertTrue(is_type_of_type(A, D, contravariant=True))
self.assertTrue(
is_type_of_type(D, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(A, D, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True))
self.assertFalse(is_type_of_type(E, A, contravariant=True))
self.assertFalse(is_type_of_type(A, E, contravariant=True))
self.assertFalse(
is_type_of_type(E, A, covariant=True, contravariant=True))
self.assertFalse(
is_type_of_type(A, E, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(F, A, covariant=True))
self.assertFalse(is_type_of_type(A, F, covariant=True))
self.assertFalse(is_type_of_type(F, A, contravariant=True))
self.assertTrue(is_type_of_type(A, F, contravariant=True))
self.assertTrue(
is_type_of_type(F, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(A, F, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(G, A, covariant=True))
self.assertFalse(is_type_of_type(A, G, covariant=True))
self.assertFalse(is_type_of_type(G, A, contravariant=True))
self.assertTrue(is_type_of_type(A, G, contravariant=True))
self.assertTrue(
is_type_of_type(G, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(A, G, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(tuple, A, covariant=True))
self.assertFalse(is_type_of_type(A, tuple, covariant=True))
self.assertFalse(is_type_of_type(tuple, A, contravariant=True))
self.assertTrue(is_type_of_type(A, tuple, contravariant=True))
self.assertTrue(
is_type_of_type(tuple, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(A, tuple, covariant=True, contravariant=True))
def test_subbclasshook(self):
"""
Verifies that a subclasshook in ABC is respected and it takes precedence over ABC registry
"""
class A(ABC):
@classmethod
def __subclasshook__(cls, C):
try:
if cls is C.subclass_of:
return True
else:
return False
except AttributeError:
return NotImplemented
class B(A):
pass
class C:
subclass_of = A
class D(A):
subclass_of = None
class E:
subclass_of = None
A.register(E)
self.assertTrue(is_type_of_type(A, A))
self.assertFalse(is_type_of_type(B, A))
self.assertFalse(is_type_of_type(A, B))
self.assertFalse(is_type_of_type(C, A))
self.assertFalse(is_type_of_type(A, C))
self.assertFalse(is_type_of_type(D, A))
self.assertFalse(is_type_of_type(A, D))
self.assertFalse(is_type_of_type(E, A))
self.assertFalse(is_type_of_type(A, E))
self.assertTrue(is_type_of_type(A, A, covariant=True))
self.assertTrue(is_type_of_type(A, A, contravariant=True))
self.assertTrue(
is_type_of_type(A, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True))
self.assertFalse(is_type_of_type(A, B, covariant=True))
self.assertFalse(is_type_of_type(B, A, contravariant=True))
self.assertTrue(is_type_of_type(A, B, contravariant=True))
self.assertTrue(
is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True))
self.assertFalse(is_type_of_type(A, C, covariant=True))
self.assertFalse(is_type_of_type(C, A, contravariant=True))
self.assertTrue(is_type_of_type(A, C, contravariant=True))
self.assertTrue(
is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(D, A, covariant=True))
self.assertFalse(is_type_of_type(A, D, covariant=True))
self.assertFalse(is_type_of_type(D, A, contravariant=True))
self.assertFalse(is_type_of_type(A, D, contravariant=True))
self.assertFalse(
is_type_of_type(D, A, covariant=True, contravariant=True))
self.assertFalse(
is_type_of_type(A, D, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True))
self.assertFalse(is_type_of_type(E, A, contravariant=True))
self.assertFalse(is_type_of_type(A, E, contravariant=True))
self.assertFalse(
is_type_of_type(E, A, covariant=True, contravariant=True))
self.assertFalse(
is_type_of_type(A, E, covariant=True, contravariant=True))
def test_any_from_str(self):
"""
Verifies that type checking works with Any construct if it is provided as a string with the type name
"""
self.assertTrue(is_type_of_type(Animal, 'Any'))
def test_subbclasscheck(self):
"""
Verifies that subclasscheck is always respected if present
"""
class A:
@classmethod
def __subclasscheck__(cls, C):
try:
if cls is C.subclass_of:
return True
else:
return False
except AttributeError:
return NotImplemented
class B(A):
pass
class C:
subclass_of = A
class D(A):
subclass_of = None
class E:
subclass_of = None
self.assertTrue(is_type_of_type(A, A))
self.assertFalse(is_type_of_type(B, A))
self.assertFalse(is_type_of_type(A, B))
self.assertFalse(is_type_of_type(C, A))
self.assertFalse(is_type_of_type(A, C))
self.assertFalse(is_type_of_type(D, A))
self.assertFalse(is_type_of_type(A, D))
self.assertFalse(is_type_of_type(E, A))
self.assertFalse(is_type_of_type(A, E))
self.assertTrue(is_type_of_type(A, A, covariant=True))
self.assertTrue(is_type_of_type(A, A, contravariant=True))
self.assertTrue(
is_type_of_type(A, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(B, A, covariant=True))
self.assertFalse(is_type_of_type(A, B, covariant=True))
self.assertFalse(is_type_of_type(B, A, contravariant=True))
self.assertTrue(is_type_of_type(A, B, contravariant=True))
self.assertTrue(
is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(B, A, covariant=True, contravariant=True))
self.assertTrue(is_type_of_type(C, A, covariant=True))
self.assertFalse(is_type_of_type(A, C, covariant=True))
self.assertFalse(is_type_of_type(C, A, contravariant=True))
self.assertTrue(is_type_of_type(A, C, contravariant=True))
self.assertTrue(
is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertTrue(
is_type_of_type(C, A, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(D, A, covariant=True))
self.assertFalse(is_type_of_type(A, D, covariant=True))
self.assertFalse(is_type_of_type(D, A, contravariant=True))
self.assertFalse(is_type_of_type(A, D, contravariant=True))
self.assertFalse(
is_type_of_type(D, A, covariant=True, contravariant=True))
self.assertFalse(
is_type_of_type(A, D, covariant=True, contravariant=True))
self.assertFalse(is_type_of_type(E, A, covariant=True))
self.assertFalse(is_type_of_type(A, E, covariant=True))
self.assertFalse(is_type_of_type(E, A, contravariant=True))
self.assertFalse(is_type_of_type(A, E, contravariant=True))
self.assertFalse(
is_type_of_type(E, A, covariant=True, contravariant=True))
self.assertFalse(
is_type_of_type(A, E, covariant=True, contravariant=True))
def test_none_from_str(self):
"""
Verifies that type checking works with None if it is provided as a string with the type name
"""
self.assertTrue(is_type_of_type(None, 'None'))
def test_none_from_str(self):
"""
Verifies that type checking works with None if it is provided as a string with the type name
"""
self.assertTrue(is_type_of_type(None, 'None'))
def test_any(self):
"""
Verifies that type checking works with Any construct
"""
self.assertTrue(is_type_of_type(Animal, Any))
self.assertTrue(is_type_of_type(None, Any))
