def constraint_type(tvar: TypeVar):
ts = get_constraints(tvar)
if ts:
return Union[ts]
else:
bound = get_bound(tvar)
return object if bound is None else bound
def _repr(val: t.Any) -> str:
assert val is not None
if types.is_none_type(val):
return 'NoneType'
elif ti.is_literal_type(val):
return str(val)
elif ti.is_new_type(val):
nested_type = val.__supertype__
return f'{_qualified_name(val)}[{get_repr(nested_type)}]'
elif ti.is_typevar(val):
tv_constraints = ti.get_constraints(val)
tv_bound = ti.get_bound(val)
if tv_constraints:
constraints_repr = (get_repr(tt) for tt in tv_constraints)
return f'typing.TypeVar(?, {", ".join(constraints_repr)})'
elif tv_bound:
return get_repr(tv_bound)
else:
return 'typing.Any'
elif ti.is_optional_type(val):
optional_args = ti.get_args(val, True)[:-1]
nested_union = len(optional_args) > 1
optional_reprs = (get_repr(tt) for tt in optional_args)
if nested_union:
return f'typing.Optional[typing.Union[{", ".join(optional_reprs)}]]'
else:
return f'typing.Optional[{", ".join(optional_reprs)}]'
elif ti.is_union_type(val):
union_reprs = (get_repr(tt) for tt in ti.get_args(val, True))
return f'typing.Union[{", ".join(union_reprs)}]'
elif ti.is_generic_type(val):
attr_name = val._name
generic_reprs = (get_repr(tt) for tt in ti.get_args(val, evaluate=True))
return f'typing.{attr_name}[{", ".join(generic_reprs)}]'
else:
val_name = _qualified_name(val)
maybe_td_entries = getattr(val, '__annotations__', {}).copy()
if maybe_td_entries:
# we are dealing with typed dict
# that's quite lovely
td_keys = sorted(maybe_td_entries.keys())
internal_members_repr = ', '.join(
'{key}: {type}'.format(key=k, type=get_repr(maybe_td_entries.get(k)))
for k in td_keys
)
return f'{val_name}{{{internal_members_repr}}}'
elif 'TypedDict' == getattr(val, '__name__', ''):
return 'typing_extensions.TypedDict'
else:
return val_name
def normalize_pytype(typ: Type) -> Type:
if typing_inspect.is_typevar(typ):
# we treat type vars in the most general way possible (the bound, or as 'object')
bound = typing_inspect.get_bound(typ)
if bound is not None:
return normalize_pytype(bound)
constraints = typing_inspect.get_constraints(typ)
if constraints:
raise CrosshairUnsupported
# TODO: not easy; interpreting as a Union allows the type to be
# instantiated differently in different places. So, this doesn't work:
# return Union.__getitem__(tuple(map(normalize_pytype, constraints)))
return object
if typ is Any:
# The distinction between any and object is for type checking, crosshair treats them the same
return object
if typ is Type:
return type
return typ
def get(cls, type_or_hint, *, is_argument: bool = False) -> "TypeChecker":
# This ensures the validity of the type passed (see typing documentation for info)
type_or_hint = is_valid_type(type_or_hint, "Invalid type.",
is_argument)
if type_or_hint is Any:
return AnyTypeChecker()
if is_type(type_or_hint):
return TypeTypeChecker.make(type_or_hint, is_argument)
if is_literal_type(type_or_hint):
return LiteralTypeChecker.make(type_or_hint, is_argument)
if is_generic_type(type_or_hint):
origin = get_origin(type_or_hint)
if issubclass(origin, MappingCol):
return MappingTypeChecker.make(type_or_hint, is_argument)
if issubclass(origin, Collection):
return CollectionTypeChecker.make(type_or_hint, is_argument)
# CONSIDER: how to cater for exhaustible generators?
if issubclass(origin, Iterable):
raise NotImplementedError(
"No type-checker is setup for iterables that exhaust.")
return GenericTypeChecker.make(type_or_hint, is_argument)
if is_tuple_type(type_or_hint):
return TupleTypeChecker.make(type_or_hint, is_argument)
if is_callable_type(type_or_hint):
return CallableTypeChecker.make(type_or_hint, is_argument)
if isclass(type_or_hint):
if is_typed_dict(type_or_hint):
return TypedDictChecker.make(type_or_hint, is_argument)
return ConcreteTypeChecker.make(type_or_hint, is_argument)
if is_union_type(type_or_hint):
return UnionTypeChecker.make(type_or_hint, is_argument)
if is_typevar(type_or_hint):
bound_type = get_bound(type_or_hint)
if bound_type:
return cls.get(bound_type)
constraints = get_constraints(type_or_hint)
if constraints:
union_type_checkers = tuple(
cls.get(type_) for type_ in constraints)
return UnionTypeChecker(Union.__getitem__(constraints),
union_type_checkers)
else:
return AnyTypeChecker()
if is_new_type(type_or_hint):
super_type = getattr(type_or_hint, "__supertype__", None)
if super_type is None:
raise TypeError(
f"No supertype for NewType: {type_or_hint}. This is not allowed."
)
return cls.get(super_type)
if is_forward_ref(type_or_hint):
return ForwardTypeChecker.make(type_or_hint,
is_argument=is_argument)
if is_classvar(type_or_hint):
var_type = get_args(type_or_hint, evaluate=True)[0]
return cls.get(var_type)
raise NotImplementedError(
f"No {TypeChecker.__qualname__} is available for type or hint: '{type_or_hint}'"
)
def test_constraints(self):
T = TypeVar('T')
TC = TypeVar('TC', int, str)
self.assertEqual(get_constraints(T), ())
self.assertEqual(get_constraints(TC), (int, str))