Refactor Union, Tuple, and Callable (#308)
Fixes #301 now ``List[Tuple[T, T]][int] == List[Tuple[int, int]]``
Fixes #298 now ``Table = Tuple[T, List[T]]`` can be used as generic type alias (as in PEP 484 example)
Fixes #299 now ``class MyTup(Tuple[int, ...]): ...`` is allowed
Fixes #156 (well, it does not substitute the annotations, but makes this task simple even in complex cases, see example in tests)
Also this PR fixes some minor things that I have found while working on this:
* ``List[Union]`` (with bare ``Union``, i.e. without arguments), ``List[Optional]``, ``List[Generic[T]]``, and ``List[ClassVar[int]]`` are not valid and are prohibited now.
* ``Generic`` did not evaluate forward references when asked, now it does.
* ``__qualname__`` was not copied on generic class subscription.
* Type was not erased on instantiation of subclasses of concrete containers (``List``, ``Set``, etc).
* There was an obscure bug in Python 2: sometimes ``_abc_registry`` was erased on instantiation.
The main idea of this PR is to fix the issues mentioned at the top by reusing the existing code. Namely, I pulled flattening and removing duplicates code from ``_Union`` and the tree calculation function ``_subs_tree`` from ``GenericMeta``. As well I moved ``Tuple`` and ``Callable`` _after_ ``GenericMeta`` and made them inherit the latter. So that now all types that could be generic store their info in common way using ``__origin__``, ``__parameters__``, ``__args__``.
I tried to polish this, to be sure that nothing was broken in the process of "refactoring" (also to improve speed). There is no recursion, the substitution tree is recalculated only when necessary. Also I added a lot of tests and many comments/docstrings (also for things added in my recent PRs).
diff --git a/python2/test_typing.py b/python2/test_typing.py
index 4b0da3a..07a0e1f 100644
--- a/python2/test_typing.py
+++ b/python2/test_typing.py
@@ -141,8 +141,9 @@
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].__union_params__, (X, int))
- self.assertEqual(Union[X, int].__union_set_params__, {X, 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)
@@ -309,8 +310,6 @@
def test_basics(self):
with self.assertRaises(TypeError):
- issubclass(Tuple[int, str], Tuple)
- with self.assertRaises(TypeError):
issubclass(Tuple, Tuple[int, str])
with self.assertRaises(TypeError):
issubclass(tuple, Tuple[int, str])
@@ -364,22 +363,6 @@
self.assertNotEqual(Callable[[int], int], Callable[[], int])
self.assertNotEqual(Callable[[int], int], Callable)
- def test_cannot_subclass(self):
- with self.assertRaises(TypeError):
-
- class C(Callable):
- pass
-
- with self.assertRaises(TypeError):
-
- class C(type(Callable)):
- pass
-
- with self.assertRaises(TypeError):
-
- class C(Callable[[int], int]):
- pass
-
def test_cannot_instantiate(self):
with self.assertRaises(TypeError):
Callable()
@@ -683,6 +666,124 @@
self.assertEqual(C.__orig_bases__, (List[T][U][V],))
self.assertEqual(D.__orig_bases__, (C, List[T][U][V]))
+ def test_extended_generic_rules_eq(self):
+ T = TypeVar('T')
+ U = TypeVar('U')
+ self.assertEqual(Tuple[T, T][int], Tuple[int, int])
+ self.assertEqual(typing.Iterable[Tuple[T, T]][T], typing.Iterable[Tuple[T, T]])
+ with self.assertRaises(TypeError):
+ Tuple[T, int][()]
+ with self.assertRaises(TypeError):
+ Tuple[T, U][T, ...]
+
+ self.assertEqual(Union[T, int][int], int)
+ self.assertEqual(Union[T, U][int, Union[int, str]], Union[int, str])
+ class Base(object): pass
+ class Derived(Base): pass
+ self.assertEqual(Union[T, Base][Derived], Base)
+ with self.assertRaises(TypeError):
+ Union[T, int][1]
+
+ self.assertEqual(Callable[[T], T][KT], Callable[[KT], KT])
+ self.assertEqual(Callable[..., List[T]][int], Callable[..., List[int]])
+ with self.assertRaises(TypeError):
+ Callable[[T], U][..., int]
+ with self.assertRaises(TypeError):
+ Callable[[T], U][[], int]
+
+ def test_extended_generic_rules_repr(self):
+ T = TypeVar('T')
+ self.assertEqual(repr(Union[Tuple, Callable]).replace('typing.', ''),
+ 'Union[Tuple, Callable]')
+ self.assertEqual(repr(Union[Tuple, Tuple[int]]).replace('typing.', ''),
+ 'Tuple')
+ self.assertEqual(repr(Callable[..., Optional[T]][int]).replace('typing.', ''),
+ 'Callable[..., Union[int, NoneType]]')
+ self.assertEqual(repr(Callable[[], List[T]][int]).replace('typing.', ''),
+ 'Callable[[], List[int]]')
+
+ def test_generic_forvard_ref(self):
+ LLT = List[List['T']]
+ T = TypeVar('T')
+ self.assertEqual(typing._eval_type(LLT, globals(), locals()), List[List[T]])
+ TTE = Tuple[T, ...]
+ self.assertIs(typing._eval_type(TTE, globals(), locals()), Tuple[T, ...])
+
+ def test_extended_generic_rules_subclassing(self):
+ class T1(Tuple[T, KT]): pass
+ class T2(Tuple[T, ...]): pass
+ class C1(Callable[[T], T]): pass
+ class C2(Callable[..., int]):
+ def __call__(self):
+ return None
+
+ self.assertEqual(T1.__parameters__, (T, KT))
+ self.assertEqual(T1[int, str].__args__, (int, str))
+ self.assertEqual(T1[int, T].__origin__, T1)
+
+ self.assertEqual(T2.__parameters__, (T,))
+ with self.assertRaises(TypeError):
+ T1[int]
+ with self.assertRaises(TypeError):
+ T2[int, str]
+
+ self.assertEqual(repr(C1[int]).split('.')[-1], 'C1[int]')
+ self.assertEqual(C2.__parameters__, ())
+ self.assertIsInstance(C2(), collections_abc.Callable)
+ self.assertIsSubclass(C2, collections_abc.Callable)
+ self.assertIsSubclass(C1, collections_abc.Callable)
+ self.assertIsInstance(T1(), tuple)
+ self.assertIsSubclass(T2, tuple)
+ self.assertIsSubclass(Tuple[int, ...], typing.Sequence)
+ self.assertIsSubclass(Tuple[int, ...], typing.Iterable)
+
+ def test_fail_with_bare_union(self):
+ with self.assertRaises(TypeError):
+ List[Union]
+ with self.assertRaises(TypeError):
+ Tuple[Optional]
+ with self.assertRaises(TypeError):
+ ClassVar[ClassVar]
+ with self.assertRaises(TypeError):
+ List[ClassVar[int]]
+
+ def test_fail_with_bare_generic(self):
+ T = TypeVar('T')
+ with self.assertRaises(TypeError):
+ List[Generic]
+ with self.assertRaises(TypeError):
+ Tuple[Generic[T]]
+ with self.assertRaises(TypeError):
+ List[typing._Protocol]
+
+ def test_type_erasure_special(self):
+ T = TypeVar('T')
+ class MyTup(Tuple[T, T]): pass
+ self.assertIs(MyTup[int]().__class__, MyTup)
+ self.assertIs(MyTup[int]().__orig_class__, MyTup[int])
+ class MyCall(Callable[..., T]):
+ def __call__(self): return None
+ self.assertIs(MyCall[T]().__class__, MyCall)
+ self.assertIs(MyCall[T]().__orig_class__, MyCall[T])
+ class MyDict(typing.Dict[T, T]): pass
+ self.assertIs(MyDict[int]().__class__, MyDict)
+ self.assertIs(MyDict[int]().__orig_class__, MyDict[int])
+ class MyDef(typing.DefaultDict[str, T]): pass
+ self.assertIs(MyDef[int]().__class__, MyDef)
+ self.assertIs(MyDef[int]().__orig_class__, MyDef[int])
+
+ def test_all_repr_eq_any(self):
+ objs = (getattr(typing, el) for el in typing.__all__)
+ for obj in objs:
+ self.assertNotEqual(repr(obj), '')
+ self.assertEqual(obj, obj)
+ if getattr(obj, '__parameters__', None) and len(obj.__parameters__) == 1:
+ self.assertEqual(obj[Any].__args__, (Any,))
+ if isinstance(obj, type):
+ for base in obj.__mro__:
+ self.assertNotEqual(repr(base), '')
+ self.assertEqual(base, base)
+
def test_pickle(self):
global C # pickle wants to reference the class by name
T = TypeVar('T')
@@ -724,7 +825,7 @@
X = C[int]
self.assertEqual(X.__module__, __name__)
if not PY32:
- self.assertEqual(X.__qualname__, 'C')
+ self.assertTrue(X.__qualname__.endswith('.<locals>.C'))
self.assertEqual(repr(X).split('.')[-1], 'C[int]')
class Y(C[int]):
diff --git a/python2/typing.py b/python2/typing.py
index f19b8c7..ff635df 100644
--- a/python2/typing.py
+++ b/python2/typing.py
@@ -309,8 +309,7 @@
def _eval_type(t, globalns, localns):
if isinstance(t, TypingMeta) or isinstance(t, _TypingBase):
return t._eval_type(globalns, localns)
- else:
- return t
+ return t
def _type_check(arg, msg):
@@ -329,8 +328,14 @@
return type(None)
if isinstance(arg, basestring):
arg = _ForwardRef(arg)
- if not isinstance(arg, (type, _TypingBase)) and not callable(arg):
+ if (isinstance(arg, _TypingBase) and type(arg).__name__ == '_ClassVar' or
+ not isinstance(arg, (type, _TypingBase)) and not callable(arg)):
raise TypeError(msg + " Got %.100r." % (arg,))
+ # Bare Union etc. are not valid as type arguments
+ if (type(arg).__name__ in ('_Union', '_Optional')
+ and not getattr(arg, '__origin__', None)
+ or isinstance(arg, TypingMeta) and _gorg(arg) in (Generic, _Protocol)):
+ raise TypeError("Plain %s is not valid as type argument" % arg)
return arg
@@ -345,10 +350,12 @@
if isinstance(obj, type) and not isinstance(obj, TypingMeta):
if obj.__module__ == '__builtin__':
return _qualname(obj)
- else:
- return '%s.%s' % (obj.__module__, _qualname(obj))
- else:
- return repr(obj)
+ return '%s.%s' % (obj.__module__, _qualname(obj))
+ if obj is Ellipsis:
+ return('...')
+ if isinstance(obj, types.FunctionType):
+ return obj.__name__
+ return repr(obj)
class ClassVarMeta(TypingMeta):
@@ -396,17 +403,10 @@
return type(self)(_eval_type(self.__type__, globalns, localns),
_root=True)
- def _get_type_vars(self, tvars):
- if self.__type__:
- _get_type_vars([self.__type__], tvars)
-
def __repr__(self):
- return self._subs_repr([], [])
-
- def _subs_repr(self, tvars, args):
r = super(_ClassVar, self).__repr__()
if self.__type__ is not None:
- r += '[{}]'.format(_replace_arg(self.__type__, tvars, args))
+ r += '[{}]'.format(_type_repr(self.__type__))
return r
def __hash__(self):
@@ -566,6 +566,102 @@
AnyStr = TypeVar('AnyStr', bytes, unicode)
+def _replace_arg(arg, tvars, args):
+ """ A helper fuunction: replace arg if it is a type variable
+ found in tvars with corresponding substitution from args or
+ with corresponding substitution sub-tree if arg is a generic type.
+ """
+
+ if tvars is None:
+ tvars = []
+ if hasattr(arg, '_subs_tree'):
+ return arg._subs_tree(tvars, args)
+ if isinstance(arg, TypeVar):
+ for i, tvar in enumerate(tvars):
+ if arg == tvar:
+ return args[i]
+ return arg
+
+
+def _subs_tree(cls, tvars=None, args=None):
+ """ Calculate substitution tree for generic cls after
+ replacing its type parameters with substitutions in tvars -> args (if any).
+ Repeat the same cyclicaly following __origin__'s.
+ """
+
+ if cls.__origin__ is None:
+ return cls
+ # Make of chain of origins (i.e. cls -> cls.__origin__)
+ current = cls.__origin__
+ orig_chain = []
+ while current.__origin__ is not None:
+ orig_chain.append(current)
+ current = current.__origin__
+ # Replace type variables in __args__ if asked ...
+ tree_args = []
+ for arg in cls.__args__:
+ tree_args.append(_replace_arg(arg, tvars, args))
+ # ... then continue replacing down the origin chain.
+ for ocls in orig_chain:
+ new_tree_args = []
+ for i, arg in enumerate(ocls.__args__):
+ new_tree_args.append(_replace_arg(arg, ocls.__parameters__, tree_args))
+ tree_args = new_tree_args
+ return tree_args
+
+
+def _remove_dups_flatten(parameters):
+ """ A helper for Union creation and substitution: flatten Union's
+ among parameters, then remove duplicates and strict subclasses.
+ """
+
+ # Flatten out Union[Union[...], ...].
+ params = []
+ for p in parameters:
+ if isinstance(p, _Union) and p.__origin__ is Union:
+ params.extend(p.__args__)
+ elif isinstance(p, tuple) and len(p) > 0 and p[0] is Union:
+ params.extend(p[1:])
+ else:
+ params.append(p)
+ # Weed out strict duplicates, preserving the first of each occurrence.
+ all_params = set(params)
+ if len(all_params) < len(params):
+ new_params = []
+ for t in params:
+ if t in all_params:
+ new_params.append(t)
+ all_params.remove(t)
+ params = new_params
+ assert not all_params, all_params
+ # Weed out subclasses.
+ # E.g. Union[int, Employee, Manager] == Union[int, Employee].
+ # If object is present it will be sole survivor among proper classes.
+ # Never discard type variables.
+ # (In particular, Union[str, AnyStr] != AnyStr.)
+ all_params = set(params)
+ for t1 in params:
+ if not isinstance(t1, type):
+ continue
+ if any(isinstance(t2, type) and issubclass(t1, t2)
+ for t2 in all_params - {t1}
+ if not (isinstance(t2, GenericMeta) and
+ t2.__origin__ is not None)):
+ all_params.remove(t1)
+ return tuple(t for t in params if t in all_params)
+
+
+def _check_generic(cls, parameters):
+ # Check correct count for parameters of a generic cls.
+ if not cls.__parameters__:
+ raise TypeError("%s is not a generic class" % repr(cls))
+ alen = len(parameters)
+ elen = len(cls.__parameters__)
+ if alen != elen:
+ raise TypeError("Too %s parameters for %s; actual %s, expected %s" %
+ ("many" if alen > elen else "few", repr(cls), alen, elen))
+
+
def _tp_cache(func):
maxsize = 128
cache = {}
@@ -638,101 +734,101 @@
- You cannot subclass or instantiate a union.
- - You cannot write Union[X][Y] (what would it mean?).
-
- You can use Optional[X] as a shorthand for Union[X, None].
"""
__metaclass__ = UnionMeta
- __slots__ = ('__union_params__', '__union_set_params__')
+ __slots__ = ('__parameters__', '__args__', '__origin__', '__tree_hash__')
- def __new__(cls, parameters=None, *args, **kwds):
- self = super(_Union, cls).__new__(cls, parameters, *args, **kwds)
- if parameters is None:
- self.__union_params__ = None
- self.__union_set_params__ = None
+ def __new__(cls, parameters=None, origin=None, *args, **kwds):
+ self = super(_Union, cls).__new__(cls, parameters, origin, *args, **kwds)
+ if origin is None:
+ self.__parameters__ = None
+ self.__args__ = None
+ self.__origin__ = None
+ self.__tree_hash__ = hash(frozenset(('Union',)))
return self
if not isinstance(parameters, tuple):
raise TypeError("Expected parameters=<tuple>")
- # Flatten out Union[Union[...], ...] and type-check non-Union args.
- params = []
- msg = "Union[arg, ...]: each arg must be a type."
- for p in parameters:
- if isinstance(p, _Union):
- params.extend(p.__union_params__)
- else:
- params.append(_type_check(p, msg))
- # Weed out strict duplicates, preserving the first of each occurrence.
- all_params = set(params)
- if len(all_params) < len(params):
- new_params = []
- for t in params:
- if t in all_params:
- new_params.append(t)
- all_params.remove(t)
- params = new_params
- assert not all_params, all_params
- # Weed out subclasses.
- # E.g. Union[int, Employee, Manager] == Union[int, Employee].
- # If object is present it will be sole survivor among proper classes.
- # Never discard type variables.
- # (In particular, Union[str, AnyStr] != AnyStr.)
- all_params = set(params)
- for t1 in params:
- if not isinstance(t1, type):
- continue
- if any(isinstance(t2, type) and issubclass(t1, t2)
- for t2 in all_params - {t1}
- if not (isinstance(t2, GenericMeta) and
- t2.__origin__ is not None)):
- all_params.remove(t1)
- # It's not a union if there's only one type left.
- if len(all_params) == 1:
- return all_params.pop()
- self.__union_params__ = tuple(t for t in params if t in all_params)
- self.__union_set_params__ = frozenset(self.__union_params__)
+ if origin is Union:
+ parameters = _remove_dups_flatten(parameters)
+ # It's not a union if there's only one type left.
+ if len(parameters) == 1:
+ return parameters[0]
+ self.__parameters__ = _type_vars(parameters)
+ self.__args__ = parameters
+ self.__origin__ = origin
+ # Pre-calculate the __hash__ on instantiation.
+ # This improves speed for complex substitutions.
+ subs_tree = self._subs_tree()
+ if isinstance(subs_tree, tuple):
+ self.__tree_hash__ = hash(frozenset(subs_tree))
+ else:
+ self.__tree_hash__ = hash(subs_tree)
return self
def _eval_type(self, globalns, localns):
- p = tuple(_eval_type(t, globalns, localns)
- for t in self.__union_params__)
- if p == self.__union_params__:
+ if self.__args__ is None:
return self
- else:
- return self.__class__(p, _root=True)
+ ev_args = tuple(_eval_type(t, globalns, localns) for t in self.__args__)
+ ev_origin = _eval_type(self.__origin__, globalns, localns)
+ if ev_args == self.__args__ and ev_origin == self.__origin__:
+ # Everything is already evaluated.
+ return self
+ return self.__class__(ev_args, ev_origin, _root=True)
def _get_type_vars(self, tvars):
- if self.__union_params__:
- _get_type_vars(self.__union_params__, tvars)
+ if self.__origin__ and self.__parameters__:
+ _get_type_vars(self.__parameters__, tvars)
def __repr__(self):
- return self._subs_repr([], [])
+ if self.__origin__ is None:
+ return super(_Union, self).__repr__()
+ tree = self._subs_tree()
+ if not isinstance(tree, tuple):
+ return repr(tree)
+ return tree[0]._tree_repr(tree)
- def _subs_repr(self, tvars, args):
- r = super(_Union, self).__repr__()
- if self.__union_params__:
- r += '[%s]' % (', '.join(_replace_arg(t, tvars, args)
- for t in self.__union_params__))
- return r
+ def _tree_repr(self, tree):
+ arg_list = []
+ for arg in tree[1:]:
+ if not isinstance(arg, tuple):
+ arg_list.append(_type_repr(arg))
+ else:
+ arg_list.append(arg[0]._tree_repr(arg))
+ return super(_Union, self).__repr__() + '[%s]' % ', '.join(arg_list)
@_tp_cache
def __getitem__(self, parameters):
- if self.__union_params__ is not None:
- raise TypeError(
- "Cannot subscript an existing Union. Use Union[u, t] instead.")
if parameters == ():
raise TypeError("Cannot take a Union of no types.")
if not isinstance(parameters, tuple):
parameters = (parameters,)
- return self.__class__(parameters, _root=True)
+ if self.__origin__ is None:
+ msg = "Union[arg, ...]: each arg must be a type."
+ else:
+ msg = "Parameters to generic types must be types."
+ parameters = tuple(_type_check(p, msg) for p in parameters)
+ if self is not Union:
+ _check_generic(self, parameters)
+ return self.__class__(parameters, origin=self, _root=True)
+
+ def _subs_tree(self, tvars=None, args=None):
+ if self is Union:
+ return Union # Nothing to substitute
+ tree_args = _subs_tree(self, tvars, args)
+ tree_args = _remove_dups_flatten(tree_args)
+ if len(tree_args) == 1:
+ return tree_args[0] # Union of a single type is that type
+ return (Union,) + tree_args
def __eq__(self, other):
if not isinstance(other, _Union):
- return NotImplemented
- return self.__union_set_params__ == other.__union_set_params__
+ return self._subs_tree() == other
+ return self.__tree_hash__ == other.__tree_hash__
def __hash__(self):
- return hash(self.__union_set_params__)
+ return self.__tree_hash__
def __instancecheck__(self, obj):
raise TypeError("Unions cannot be used with isinstance().")
@@ -770,212 +866,6 @@
Optional = _Optional(_root=True)
-class TupleMeta(TypingMeta):
- """Metaclass for Tuple."""
-
- def __new__(cls, name, bases, namespace):
- cls.assert_no_subclassing(bases)
- return super(TupleMeta, cls).__new__(cls, name, bases, namespace)
-
-
-class _Tuple(_FinalTypingBase):
- """Tuple type; Tuple[X, Y] is the cross-product type of X and Y.
-
- Example: Tuple[T1, T2] is a tuple of two elements corresponding
- to type variables T1 and T2. Tuple[int, float, str] is a tuple
- of an int, a float and a string.
-
- To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
- """
-
- __metaclass__ = TupleMeta
- __slots__ = ('__tuple_params__', '__tuple_use_ellipsis__')
-
- def __init__(self, parameters=None,
- use_ellipsis=False, _root=False):
- self.__tuple_params__ = parameters
- self.__tuple_use_ellipsis__ = use_ellipsis
-
- def _get_type_vars(self, tvars):
- if self.__tuple_params__:
- _get_type_vars(self.__tuple_params__, tvars)
-
- def _eval_type(self, globalns, localns):
- tp = self.__tuple_params__
- if tp is None:
- return self
- p = tuple(_eval_type(t, globalns, localns) for t in tp)
- if p == self.__tuple_params__:
- return self
- else:
- return self.__class__(p, _root=True)
-
- def __repr__(self):
- return self._subs_repr([], [])
-
- def _subs_repr(self, tvars, args):
- r = super(_Tuple, self).__repr__()
- if self.__tuple_params__ is not None:
- params = [_replace_arg(p, tvars, args) for p in self.__tuple_params__]
- if self.__tuple_use_ellipsis__:
- params.append('...')
- if not params:
- params.append('()')
- r += '[%s]' % (
- ', '.join(params))
- return r
-
- @_tp_cache
- def __getitem__(self, parameters):
- if self.__tuple_params__ is not None:
- raise TypeError("Cannot re-parameterize %r" % (self,))
- if not isinstance(parameters, tuple):
- parameters = (parameters,)
- if len(parameters) == 2 and parameters[1] == Ellipsis:
- parameters = parameters[:1]
- use_ellipsis = True
- msg = "Tuple[t, ...]: t must be a type."
- else:
- use_ellipsis = False
- msg = "Tuple[t0, t1, ...]: each t must be a type."
- parameters = tuple(_type_check(p, msg) for p in parameters)
- return self.__class__(parameters, use_ellipsis=use_ellipsis, _root=True)
-
- def __eq__(self, other):
- if not isinstance(other, _Tuple):
- return NotImplemented
- return (self.__tuple_params__ == other.__tuple_params__ and
- self.__tuple_use_ellipsis__ == other.__tuple_use_ellipsis__)
-
- def __hash__(self):
- return hash(self.__tuple_params__)
-
- def __instancecheck__(self, obj):
- if self.__tuple_params__ == None:
- return isinstance(obj, tuple)
- raise TypeError("Parameterized Tuple cannot be used "
- "with isinstance().")
-
- def __subclasscheck__(self, cls):
- if self.__tuple_params__ == None:
- return issubclass(cls, tuple)
- raise TypeError("Parameterized Tuple cannot be used "
- "with issubclass().")
-
-
-Tuple = _Tuple(_root=True)
-
-
-class CallableMeta(TypingMeta):
- """Metaclass for Callable."""
-
- def __new__(cls, name, bases, namespace):
- cls.assert_no_subclassing(bases)
- return super(CallableMeta, cls).__new__(cls, name, bases, namespace)
-
-
-class _Callable(_FinalTypingBase):
- """Callable type; Callable[[int], str] is a function of (int) -> str.
-
- The subscription syntax must always be used with exactly two
- values: the argument list and the return type. The argument list
- must be a list of types; the return type must be a single type.
-
- There is no syntax to indicate optional or keyword arguments,
- such function types are rarely used as callback types.
- """
-
- __metaclass__ = CallableMeta
- __slots__ = ('__args__', '__result__')
-
- def __init__(self, args=None, result=None, _root=False):
- if args is None and result is None:
- pass # Must be 'class Callable'.
- else:
- if args is not Ellipsis:
- if not isinstance(args, list):
- raise TypeError("Callable[args, result]: "
- "args must be a list."
- " Got %.100r." % (args,))
- msg = "Callable[[arg, ...], result]: each arg must be a type."
- args = tuple(_type_check(arg, msg) for arg in args)
- msg = "Callable[args, result]: result must be a type."
- result = _type_check(result, msg)
- self.__args__ = args
- self.__result__ = result
-
- def _get_type_vars(self, tvars):
- if self.__args__ and self.__args__ is not Ellipsis:
- _get_type_vars(self.__args__, tvars)
- if self.__result__:
- _get_type_vars([self.__result__], tvars)
-
- def _eval_type(self, globalns, localns):
- if self.__args__ is None and self.__result__ is None:
- return self
- if self.__args__ is Ellipsis:
- args = self.__args__
- else:
- args = [_eval_type(t, globalns, localns) for t in self.__args__]
- result = _eval_type(self.__result__, globalns, localns)
- if args == self.__args__ and result == self.__result__:
- return self
- else:
- return self.__class__(args=args, result=result, _root=True)
-
- def __repr__(self):
- return self._subs_repr([], [])
-
- def _subs_repr(self, tvars, args):
- r = super(_Callable, self).__repr__()
- if self.__args__ is not None or self.__result__ is not None:
- if self.__args__ is Ellipsis:
- args_r = '...'
- else:
- args_r = '[%s]' % ', '.join(_replace_arg(t, tvars, args)
- for t in self.__args__)
- r += '[%s, %s]' % (args_r, _replace_arg(self.__result__, tvars, args))
- return r
-
- def __getitem__(self, parameters):
- if self.__args__ is not None or self.__result__ is not None:
- raise TypeError("This Callable type is already parameterized.")
- if not isinstance(parameters, tuple) or len(parameters) != 2:
- raise TypeError(
- "Callable must be used as Callable[[arg, ...], result].")
- args, result = parameters
- return self.__class__(args=args, result=result, _root=True)
-
- def __eq__(self, other):
- if not isinstance(other, _Callable):
- return NotImplemented
- return (self.__args__ == other.__args__ and
- self.__result__ == other.__result__)
-
- def __hash__(self):
- return hash(self.__args__) ^ hash(self.__result__)
-
- def __instancecheck__(self, obj):
- # For unparametrized Callable we allow this, because
- # typing.Callable should be equivalent to
- # collections.abc.Callable.
- if self.__args__ is None and self.__result__ is None:
- return isinstance(obj, collections_abc.Callable)
- else:
- raise TypeError("Parameterized Callable cannot be used "
- "with isinstance().")
-
- def __subclasscheck__(self, cls):
- if self.__args__ is None and self.__result__ is None:
- return issubclass(cls, collections_abc.Callable)
- else:
- raise TypeError("Parameterized Callable cannot be used "
- "with issubclass().")
-
-
-Callable = _Callable(_root=True)
-
-
def _gorg(a):
"""Return the farthest origin of a generic class."""
assert isinstance(a, GenericMeta)
@@ -999,16 +889,6 @@
return _gorg(a) is _gorg(b)
-def _replace_arg(arg, tvars, args):
- if hasattr(arg, '_subs_repr'):
- return arg._subs_repr(tvars, args)
- if isinstance(arg, TypeVar):
- for i, tvar in enumerate(tvars):
- if arg == tvar:
- return args[i]
- return _type_repr(arg)
-
-
def _next_in_mro(cls):
"""Helper for Generic.__new__.
@@ -1123,7 +1003,11 @@
self = super(GenericMeta, cls).__new__(cls, name, bases, namespace)
self.__parameters__ = tvars
- self.__args__ = args
+ # Be prepared that GenericMeta will be subclassed by TupleMeta
+ # and CallableMeta, those two allow ..., (), or [] in __args___.
+ self.__args__ = tuple(Ellipsis if a is _TypingEllipsis else
+ () if a is _TypingEmpty else
+ a for a in args) if args else None
self.__origin__ = origin
self.__extra__ = extra
# Speed hack (https://github.com/python/typing/issues/196).
@@ -1139,57 +1023,74 @@
or hasattr(self.__subclasshook__, '__name__') and
self.__subclasshook__.__name__ == '__extrahook__'):
self.__subclasshook__ = _make_subclasshook(self)
- if isinstance(extra, abc.ABCMeta):
- self._abc_registry = extra._abc_registry
+
+ if origin and hasattr(origin, '__qualname__'): # Fix for Python 3.2.
+ self.__qualname__ = origin.__qualname__
+ self.__tree_hash__ = hash(self._subs_tree()) if origin else hash((self.__name__,))
return self
+ def __init__(self, *args, **kwargs):
+ super(GenericMeta, self).__init__(*args, **kwargs)
+ if isinstance(self.__extra__, abc.ABCMeta):
+ self._abc_registry = self.__extra__._abc_registry
+
def _get_type_vars(self, tvars):
if self.__origin__ and self.__parameters__:
_get_type_vars(self.__parameters__, tvars)
+ def _eval_type(self, globalns, localns):
+ ev_origin = (self.__origin__._eval_type(globalns, localns)
+ if self.__origin__ else None)
+ ev_args = tuple(_eval_type(a, globalns, localns) for a
+ in self.__args__) if self.__args__ else None
+ if ev_origin == self.__origin__ and ev_args == self.__args__:
+ return self
+ return self.__class__(self.__name__,
+ self.__bases__,
+ dict(self.__dict__),
+ tvars=_type_vars(ev_args) if ev_args else None,
+ args=ev_args,
+ origin=ev_origin,
+ extra=self.__extra__,
+ orig_bases=self.__orig_bases__)
+
def __repr__(self):
if self.__origin__ is None:
return super(GenericMeta, self).__repr__()
- return self._subs_repr([], [])
+ return self._tree_repr(self._subs_tree())
- def _subs_repr(self, tvars, args):
- assert len(tvars) == len(args)
- # Construct the chain of __origin__'s.
- current = self.__origin__
- orig_chain = []
- while current.__origin__ is not None:
- orig_chain.append(current)
- current = current.__origin__
- # Replace type variables in __args__ if asked ...
- str_args = []
- for arg in self.__args__:
- str_args.append(_replace_arg(arg, tvars, args))
- # ... then continue replacing down the origin chain.
- for cls in orig_chain:
- new_str_args = []
- for i, arg in enumerate(cls.__args__):
- new_str_args.append(_replace_arg(arg, cls.__parameters__, str_args))
- str_args = new_str_args
- return super(GenericMeta, self).__repr__() + '[%s]' % ', '.join(str_args)
+ def _tree_repr(self, tree):
+ arg_list = []
+ for arg in tree[1:]:
+ if arg == ():
+ arg_list.append('()')
+ elif not isinstance(arg, tuple):
+ arg_list.append(_type_repr(arg))
+ else:
+ arg_list.append(arg[0]._tree_repr(arg))
+ return super(GenericMeta, self).__repr__() + '[%s]' % ', '.join(arg_list)
+
+ def _subs_tree(self, tvars=None, args=None):
+ if self.__origin__ is None:
+ return self
+ tree_args = _subs_tree(self, tvars, args)
+ return (_gorg(self),) + tuple(tree_args)
def __eq__(self, other):
if not isinstance(other, GenericMeta):
return NotImplemented
- if self.__origin__ is not None:
- return (self.__origin__ is other.__origin__ and
- self.__args__ == other.__args__ and
- self.__parameters__ == other.__parameters__)
- else:
+ if self.__origin__ is None or other.__origin__ is None:
return self is other
+ return self.__tree_hash__ == other.__tree_hash__
def __hash__(self):
- return hash((self.__name__, self.__parameters__))
+ return self.__tree_hash__
@_tp_cache
def __getitem__(self, params):
if not isinstance(params, tuple):
params = (params,)
- if not params:
+ if not params and not _gorg(self) is Tuple:
raise TypeError(
"Parameter list to %s[...] cannot be empty" % _qualname(self))
msg = "Parameters to generic types must be types."
@@ -1204,6 +1105,9 @@
"Parameters to Generic[...] must all be unique")
tvars = params
args = params
+ elif self in (Tuple, Callable):
+ tvars = _type_vars(params)
+ args = params
elif self is _Protocol:
# _Protocol is internal, don't check anything.
tvars = params
@@ -1214,14 +1118,7 @@
repr(self))
else:
# Subscripting a regular Generic subclass.
- if not self.__parameters__:
- raise TypeError("%s is not a generic class" % repr(self))
- alen = len(params)
- elen = len(self.__parameters__)
- if alen != elen:
- raise TypeError(
- "Too %s parameters for %s; actual %s, expected %s" %
- ("many" if alen > elen else "few", repr(self), alen, elen))
+ _check_generic(self, params)
tvars = _type_vars(params)
args = params
return self.__class__(self.__name__,
@@ -1248,6 +1145,22 @@
Generic = None
+def _generic_new(base_cls, cls, *args, **kwds):
+ # Assure type is erased on instantiation,
+ # but attempt to store it in __orig_class__
+ if cls.__origin__ is None:
+ return base_cls.__new__(cls)
+ else:
+ origin = _gorg(cls)
+ obj = base_cls.__new__(origin)
+ try:
+ obj.__orig_class__ = cls
+ except AttributeError:
+ pass
+ obj.__init__(*args, **kwds)
+ return obj
+
+
class Generic(object):
"""Abstract base class for generic types.
@@ -1273,17 +1186,159 @@
__slots__ = ()
def __new__(cls, *args, **kwds):
- if cls.__origin__ is None:
- return cls.__next_in_mro__.__new__(cls)
+ return _generic_new(cls.__next_in_mro__, cls, *args, **kwds)
+
+
+class _TypingEmpty(object):
+ """Placeholder for () or []. Used by TupleMeta and CallableMeta
+ to allow empy list/tuple in specific places, without allowing them
+ to sneak in where prohibited.
+ """
+
+
+class _TypingEllipsis(object):
+ """Ditto for ..."""
+
+
+class TupleMeta(GenericMeta):
+ """Metaclass for Tuple"""
+
+ @_tp_cache
+ def __getitem__(self, parameters):
+ if self.__origin__ is not None or not _geqv(self, Tuple):
+ # Normal generic rules apply if this is not the first subscription
+ # or a subscription of a subclass.
+ return super(TupleMeta, self).__getitem__(parameters)
+ if parameters == ():
+ return super(TupleMeta, self).__getitem__((_TypingEmpty,))
+ if not isinstance(parameters, tuple):
+ parameters = (parameters,)
+ if len(parameters) == 2 and parameters[1] is Ellipsis:
+ msg = "Tuple[t, ...]: t must be a type."
+ p = _type_check(parameters[0], msg)
+ return super(TupleMeta, self).__getitem__((p, _TypingEllipsis))
+ msg = "Tuple[t0, t1, ...]: each t must be a type."
+ parameters = tuple(_type_check(p, msg) for p in parameters)
+ return super(TupleMeta, self).__getitem__(parameters)
+
+ def __instancecheck__(self, obj):
+ if self.__args__ == None:
+ return isinstance(obj, tuple)
+ raise TypeError("Parameterized Tuple cannot be used "
+ "with isinstance().")
+
+ def __subclasscheck__(self, cls):
+ if self.__args__ == None:
+ return issubclass(cls, tuple)
+ raise TypeError("Parameterized Tuple cannot be used "
+ "with issubclass().")
+
+
+class Tuple(tuple):
+ """Tuple type; Tuple[X, Y] is the cross-product type of X and Y.
+
+ Example: Tuple[T1, T2] is a tuple of two elements corresponding
+ to type variables T1 and T2. Tuple[int, float, str] is a tuple
+ of an int, a float and a string.
+
+ To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
+ """
+
+ __metaclass__ = TupleMeta
+ __extra__ = tuple
+ __slots__ = ()
+
+ def __new__(cls, *args, **kwds):
+ if _geqv(cls, Tuple):
+ raise TypeError("Type Tuple cannot be instantiated; "
+ "use tuple() instead")
+ return _generic_new(tuple, cls, *args, **kwds)
+
+
+class CallableMeta(GenericMeta):
+ """ Metaclass for Callable."""
+
+ def __repr__(self):
+ if self.__origin__ is None:
+ return super(CallableMeta, self).__repr__()
+ return self._tree_repr(self._subs_tree())
+
+ def _tree_repr(self, tree):
+ if _gorg(self) is not Callable:
+ return super(CallableMeta, self)._tree_repr(tree)
+ # For actual Callable (not its subclass) we override
+ # super(CallableMeta, self)._tree_repr() for nice formatting.
+ arg_list = []
+ for arg in tree[1:]:
+ if arg == ():
+ arg_list.append('[]')
+ elif not isinstance(arg, tuple):
+ arg_list.append(_type_repr(arg))
+ else:
+ arg_list.append(arg[0]._tree_repr(arg))
+ if len(arg_list) == 2:
+ return repr(tree[0]) + '[%s]' % ', '.join(arg_list)
+ return (repr(tree[0]) +
+ '[[%s], %s]' % (', '.join(arg_list[:-1]), arg_list[-1]))
+
+ def __getitem__(self, parameters):
+ """ A thin wrapper around __getitem_inner__ to provide the latter
+ with hashable arguments to improve speed.
+ """
+
+ if self.__origin__ is not None or not _geqv(self, Callable):
+ return super(CallableMeta, self).__getitem__(parameters)
+ if not isinstance(parameters, tuple) or len(parameters) != 2:
+ raise TypeError("Callable must be used as "
+ "Callable[[arg, ...], result].")
+ args, result = parameters
+ if args is Ellipsis:
+ parameters = (Ellipsis, result)
+ elif args == []:
+ parameters = ((), result)
else:
- origin = _gorg(cls)
- obj = cls.__next_in_mro__.__new__(origin)
- try:
- obj.__orig_class__ = cls
- except AttributeError:
- pass
- obj.__init__(*args, **kwds)
- return obj
+ if not isinstance(args, list):
+ raise TypeError("Callable[args, result]: args must be a list."
+ " Got %.100r." % (args,))
+ parameters = tuple(args) + (result,)
+ return self.__getitem_inner__(parameters)
+
+ @_tp_cache
+ def __getitem_inner__(self, parameters):
+ args = parameters[:-1]
+ result = parameters[-1]
+ msg = "Callable[args, result]: result must be a type."
+ result = _type_check(result, msg)
+ if args == (Ellipsis,):
+ return super(CallableMeta, self).__getitem__((_TypingEllipsis, result))
+ if args == ((),):
+ return super(CallableMeta, self).__getitem__((_TypingEmpty, result))
+ msg = "Callable[[arg, ...], result]: each arg must be a type."
+ args = tuple(_type_check(arg, msg) for arg in args)
+ parameters = args + (result,)
+ return super(CallableMeta, self).__getitem__(parameters)
+
+
+class Callable(object):
+ """Callable type; Callable[[int], str] is a function of (int) -> str.
+
+ The subscription syntax must always be used with exactly two
+ values: the argument list and the return type. The argument list
+ must be a list of types; the return type must be a single type.
+
+ There is no syntax to indicate optional or keyword arguments,
+ such function types are rarely used as callback types.
+ """
+
+ __metaclass__ = CallableMeta
+ __extra__ = collections_abc.Callable
+ __slots__ = ()
+
+ def __new__(cls, *args, **kwds):
+ if _geqv(cls, Callable):
+ raise TypeError("Type Callable cannot be instantiated; "
+ "use a non-abstract subclass instead")
+ return _generic_new(cls.__next_in_mro__, cls, *args, **kwds)
def cast(typ, val):
@@ -1454,6 +1509,7 @@
attr != '__origin__' and
attr != '__orig_bases__' and
attr != '__extra__' and
+ attr != '__tree_hash__' and
attr != '__module__'):
attrs.add(attr)
@@ -1598,7 +1654,7 @@
if _geqv(cls, List):
raise TypeError("Type List cannot be instantiated; "
"use list() instead")
- return list.__new__(cls, *args, **kwds)
+ return _generic_new(list, cls, *args, **kwds)
class Set(set, MutableSet[T]):
@@ -1609,7 +1665,7 @@
if _geqv(cls, Set):
raise TypeError("Type Set cannot be instantiated; "
"use set() instead")
- return set.__new__(cls, *args, **kwds)
+ return _generic_new(set, cls, *args, **kwds)
class FrozenSet(frozenset, AbstractSet[T_co]):
@@ -1620,7 +1676,7 @@
if _geqv(cls, FrozenSet):
raise TypeError("Type FrozenSet cannot be instantiated; "
"use frozenset() instead")
- return frozenset.__new__(cls, *args, **kwds)
+ return _generic_new(frozenset, cls, *args, **kwds)
class MappingView(Sized, Iterable[T_co]):
@@ -1653,7 +1709,7 @@
if _geqv(cls, Dict):
raise TypeError("Type Dict cannot be instantiated; "
"use dict() instead")
- return dict.__new__(cls, *args, **kwds)
+ return _generic_new(dict, cls, *args, **kwds)
class DefaultDict(collections.defaultdict, MutableMapping[KT, VT]):
@@ -1664,7 +1720,7 @@
if _geqv(cls, DefaultDict):
raise TypeError("Type DefaultDict cannot be instantiated; "
"use collections.defaultdict() instead")
- return collections.defaultdict.__new__(cls, *args, **kwds)
+ return _generic_new(collections.defaultdict, cls, *args, **kwds)
# Determine what base class to use for Generator.
@@ -1684,7 +1740,7 @@
if _geqv(cls, Generator):
raise TypeError("Type Generator cannot be instantiated; "
"create a subclass instead")
- return super(Generator, cls).__new__(cls, *args, **kwds)
+ return _generic_new(_G_base, cls, *args, **kwds)
# Internal type variable used for Type[].
diff --git a/src/test_typing.py b/src/test_typing.py
index 0d8532e..8e0a8c5 100644
--- a/src/test_typing.py
+++ b/src/test_typing.py
@@ -142,8 +142,9 @@
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].__union_params__, (X, int))
- self.assertEqual(Union[X, int].__union_set_params__, {X, 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)
@@ -312,8 +313,6 @@
def test_basics(self):
with self.assertRaises(TypeError):
- issubclass(Tuple[int, str], Tuple)
- with self.assertRaises(TypeError):
issubclass(Tuple, Tuple[int, str])
with self.assertRaises(TypeError):
issubclass(tuple, Tuple[int, str])
@@ -367,22 +366,6 @@
self.assertNotEqual(Callable[[int], int], Callable[[], int])
self.assertNotEqual(Callable[[int], int], Callable)
- def test_cannot_subclass(self):
- with self.assertRaises(TypeError):
-
- class C(Callable):
- pass
-
- with self.assertRaises(TypeError):
-
- class C(type(Callable)):
- pass
-
- with self.assertRaises(TypeError):
-
- class C(Callable[[int], int]):
- pass
-
def test_cannot_instantiate(self):
with self.assertRaises(TypeError):
Callable()
@@ -710,6 +693,138 @@
self.assertEqual(C.__orig_bases__, (List[T][U][V],))
self.assertEqual(D.__orig_bases__, (C, List[T][U][V]))
+ def test_extended_generic_rules_eq(self):
+ T = TypeVar('T')
+ U = TypeVar('U')
+ self.assertEqual(Tuple[T, T][int], Tuple[int, int])
+ self.assertEqual(typing.Iterable[Tuple[T, T]][T], typing.Iterable[Tuple[T, T]])
+ with self.assertRaises(TypeError):
+ Tuple[T, int][()]
+ with self.assertRaises(TypeError):
+ Tuple[T, U][T, ...]
+
+ self.assertEqual(Union[T, int][int], int)
+ self.assertEqual(Union[T, U][int, Union[int, str]], Union[int, str])
+ class Base: ...
+ class Derived(Base): ...
+ self.assertEqual(Union[T, Base][Derived], Base)
+ with self.assertRaises(TypeError):
+ Union[T, int][1]
+
+ self.assertEqual(Callable[[T], T][KT], Callable[[KT], KT])
+ self.assertEqual(Callable[..., List[T]][int], Callable[..., List[int]])
+ with self.assertRaises(TypeError):
+ Callable[[T], U][..., int]
+ with self.assertRaises(TypeError):
+ Callable[[T], U][[], int]
+
+ def test_extended_generic_rules_repr(self):
+ T = TypeVar('T')
+ self.assertEqual(repr(Union[Tuple, Callable]).replace('typing.', ''),
+ 'Union[Tuple, Callable]')
+ self.assertEqual(repr(Union[Tuple, Tuple[int]]).replace('typing.', ''),
+ 'Tuple')
+ self.assertEqual(repr(Callable[..., Optional[T]][int]).replace('typing.', ''),
+ 'Callable[..., Union[int, NoneType]]')
+ self.assertEqual(repr(Callable[[], List[T]][int]).replace('typing.', ''),
+ 'Callable[[], List[int]]')
+
+ def test_generic_forvard_ref(self):
+ def foobar(x: List[List['T']]): ...
+ T = TypeVar('T')
+ self.assertEqual(get_type_hints(foobar, globals(), locals()), {'x': List[List[T]]})
+ def barfoo(x: Tuple[T, ...]): ...
+ self.assertIs(get_type_hints(barfoo, globals(), locals())['x'], Tuple[T, ...])
+
+ def test_extended_generic_rules_subclassing(self):
+ class T1(Tuple[T, KT]): ...
+ class T2(Tuple[T, ...]): ...
+ class C1(Callable[[T], T]): ...
+ class C2(Callable[..., int]):
+ def __call__(self):
+ return None
+
+ self.assertEqual(T1.__parameters__, (T, KT))
+ self.assertEqual(T1[int, str].__args__, (int, str))
+ self.assertEqual(T1[int, T].__origin__, T1)
+
+ self.assertEqual(T2.__parameters__, (T,))
+ with self.assertRaises(TypeError):
+ T1[int]
+ with self.assertRaises(TypeError):
+ T2[int, str]
+
+ self.assertEqual(repr(C1[int]).split('.')[-1], 'C1[int]')
+ self.assertEqual(C2.__parameters__, ())
+ self.assertIsInstance(C2(), collections_abc.Callable)
+ self.assertIsSubclass(C2, collections_abc.Callable)
+ self.assertIsSubclass(C1, collections_abc.Callable)
+ self.assertIsInstance(T1(), tuple)
+ self.assertIsSubclass(T2, tuple)
+ self.assertIsSubclass(Tuple[int, ...], typing.Sequence)
+ self.assertIsSubclass(Tuple[int, ...], typing.Iterable)
+
+ def test_fail_with_bare_union(self):
+ with self.assertRaises(TypeError):
+ List[Union]
+ with self.assertRaises(TypeError):
+ Tuple[Optional]
+ with self.assertRaises(TypeError):
+ ClassVar[ClassVar]
+ with self.assertRaises(TypeError):
+ List[ClassVar[int]]
+
+ def test_fail_with_bare_generic(self):
+ T = TypeVar('T')
+ with self.assertRaises(TypeError):
+ List[Generic]
+ with self.assertRaises(TypeError):
+ Tuple[Generic[T]]
+ with self.assertRaises(TypeError):
+ List[typing._Protocol]
+
+ def test_type_erasure_special(self):
+ T = TypeVar('T')
+ class MyTup(Tuple[T, T]): ...
+ self.assertIs(MyTup[int]().__class__, MyTup)
+ self.assertIs(MyTup[int]().__orig_class__, MyTup[int])
+ class MyCall(Callable[..., T]):
+ def __call__(self): return None
+ self.assertIs(MyCall[T]().__class__, MyCall)
+ self.assertIs(MyCall[T]().__orig_class__, MyCall[T])
+ class MyDict(typing.Dict[T, T]): ...
+ self.assertIs(MyDict[int]().__class__, MyDict)
+ self.assertIs(MyDict[int]().__orig_class__, MyDict[int])
+ class MyDef(typing.DefaultDict[str, T]): ...
+ self.assertIs(MyDef[int]().__class__, MyDef)
+ self.assertIs(MyDef[int]().__orig_class__, MyDef[int])
+
+ def test_all_repr_eq_any(self):
+ objs = (getattr(typing, el) for el in typing.__all__)
+ for obj in objs:
+ self.assertNotEqual(repr(obj), '')
+ self.assertEqual(obj, obj)
+ if getattr(obj, '__parameters__', None) and len(obj.__parameters__) == 1:
+ self.assertEqual(obj[Any].__args__, (Any,))
+ if isinstance(obj, type):
+ for base in obj.__mro__:
+ self.assertNotEqual(repr(base), '')
+ self.assertEqual(base, base)
+
+ def test_substitution_helper(self):
+ T = TypeVar('T')
+ KT = TypeVar('KT')
+ VT = TypeVar('VT')
+ class Map(Generic[KT, VT]):
+ def meth(self, k: KT, v: VT): ...
+ StrMap = Map[str, T]
+ obj = StrMap[int]()
+
+ new_args = typing._subs_tree(obj.__orig_class__)
+ new_annots = {k: typing._replace_arg(v, type(obj).__parameters__, new_args)
+ for k, v in obj.meth.__annotations__.items()}
+
+ self.assertEqual(new_annots, {'k': str, 'v': int})
def test_pickle(self):
global C # pickle wants to reference the class by name
@@ -752,7 +867,7 @@
X = C[int]
self.assertEqual(X.__module__, __name__)
if not PY32:
- self.assertEqual(X.__qualname__, 'C')
+ self.assertTrue(X.__qualname__.endswith('.<locals>.C'))
self.assertEqual(repr(X).split('.')[-1], 'C[int]')
class Y(C[int]):
diff --git a/src/typing.py b/src/typing.py
index 261da5d..bda4ea5 100644
--- a/src/typing.py
+++ b/src/typing.py
@@ -333,8 +333,7 @@
def _eval_type(t, globalns, localns):
if isinstance(t, TypingMeta) or isinstance(t, _TypingBase):
return t._eval_type(globalns, localns)
- else:
- return t
+ return t
def _type_check(arg, msg):
@@ -353,8 +352,14 @@
return type(None)
if isinstance(arg, str):
arg = _ForwardRef(arg)
- if not isinstance(arg, (type, _TypingBase)) and not callable(arg):
+ if (isinstance(arg, _TypingBase) and type(arg).__name__ == '_ClassVar' or
+ not isinstance(arg, (type, _TypingBase)) and not callable(arg)):
raise TypeError(msg + " Got %.100r." % (arg,))
+ # Bare Union etc. are not valid as type arguments
+ if (type(arg).__name__ in ('_Union', '_Optional')
+ and not getattr(arg, '__origin__', None)
+ or isinstance(arg, TypingMeta) and _gorg(arg) in (Generic, _Protocol)):
+ raise TypeError("Plain %s is not valid as type argument" % arg)
return arg
@@ -369,10 +374,12 @@
if isinstance(obj, type) and not isinstance(obj, TypingMeta):
if obj.__module__ == 'builtins':
return _qualname(obj)
- else:
- return '%s.%s' % (obj.__module__, _qualname(obj))
- else:
- return repr(obj)
+ return '%s.%s' % (obj.__module__, _qualname(obj))
+ if obj is ...:
+ return('...')
+ if isinstance(obj, types.FunctionType):
+ return obj.__name__
+ return repr(obj)
class _Any(_FinalTypingBase, _root=True):
@@ -502,7 +509,107 @@
AnyStr = TypeVar('AnyStr', bytes, str)
+def _replace_arg(arg, tvars, args):
+ """ A helper fuunction: replace arg if it is a type variable
+ found in tvars with corresponding substitution from args or
+ with corresponding substitution sub-tree if arg is a generic type.
+ """
+
+ if tvars is None:
+ tvars = []
+ if hasattr(arg, '_subs_tree'):
+ return arg._subs_tree(tvars, args)
+ if isinstance(arg, TypeVar):
+ for i, tvar in enumerate(tvars):
+ if arg == tvar:
+ return args[i]
+ return arg
+
+
+def _subs_tree(cls, tvars=None, args=None):
+ """ Calculate substitution tree for generic cls after
+ replacing its type parameters with substitutions in tvars -> args (if any).
+ Repeat the same cyclicaly following __origin__'s.
+ """
+
+ if cls.__origin__ is None:
+ return cls
+ # Make of chain of origins (i.e. cls -> cls.__origin__)
+ current = cls.__origin__
+ orig_chain = []
+ while current.__origin__ is not None:
+ orig_chain.append(current)
+ current = current.__origin__
+ # Replace type variables in __args__ if asked ...
+ tree_args = []
+ for arg in cls.__args__:
+ tree_args.append(_replace_arg(arg, tvars, args))
+ # ... then continue replacing down the origin chain.
+ for ocls in orig_chain:
+ new_tree_args = []
+ for i, arg in enumerate(ocls.__args__):
+ new_tree_args.append(_replace_arg(arg, ocls.__parameters__, tree_args))
+ tree_args = new_tree_args
+ return tree_args
+
+
+def _remove_dups_flatten(parameters):
+ """ A helper for Union creation and substitution: flatten Union's
+ among parameters, then remove duplicates and strict subclasses.
+ """
+
+ # Flatten out Union[Union[...], ...].
+ params = []
+ for p in parameters:
+ if isinstance(p, _Union) and p.__origin__ is Union:
+ params.extend(p.__args__)
+ elif isinstance(p, tuple) and len(p) > 0 and p[0] is Union:
+ params.extend(p[1:])
+ else:
+ params.append(p)
+ # Weed out strict duplicates, preserving the first of each occurrence.
+ all_params = set(params)
+ if len(all_params) < len(params):
+ new_params = []
+ for t in params:
+ if t in all_params:
+ new_params.append(t)
+ all_params.remove(t)
+ params = new_params
+ assert not all_params, all_params
+ # Weed out subclasses.
+ # E.g. Union[int, Employee, Manager] == Union[int, Employee].
+ # If object is present it will be sole survivor among proper classes.
+ # Never discard type variables.
+ # (In particular, Union[str, AnyStr] != AnyStr.)
+ all_params = set(params)
+ for t1 in params:
+ if not isinstance(t1, type):
+ continue
+ if any(isinstance(t2, type) and issubclass(t1, t2)
+ for t2 in all_params - {t1}
+ if not (isinstance(t2, GenericMeta) and
+ t2.__origin__ is not None)):
+ all_params.remove(t1)
+ return tuple(t for t in params if t in all_params)
+
+
+def _check_generic(cls, parameters):
+ # Check correct count for parameters of a generic cls.
+ if not cls.__parameters__:
+ raise TypeError("%s is not a generic class" % repr(cls))
+ alen = len(parameters)
+ elen = len(cls.__parameters__)
+ if alen != elen:
+ raise TypeError("Too %s parameters for %s; actual %s, expected %s" %
+ ("many" if alen > elen else "few", repr(cls), alen, elen))
+
+
def _tp_cache(func):
+ """ Caching for __getitem__ of generic types with a fallback to
+ original function for non-hashable arguments.
+ """
+
cached = functools.lru_cache()(func)
@functools.wraps(func)
def inner(*args, **kwds):
@@ -555,100 +662,100 @@
- You cannot subclass or instantiate a union.
- - You cannot write Union[X][Y] (what would it mean?).
-
- You can use Optional[X] as a shorthand for Union[X, None].
"""
- __slots__ = ('__union_params__', '__union_set_params__')
+ __slots__ = ('__parameters__', '__args__', '__origin__', '__tree_hash__')
- def __new__(cls, parameters=None, *args, _root=False):
- self = super().__new__(cls, parameters, *args, _root=_root)
- if parameters is None:
- self.__union_params__ = None
- self.__union_set_params__ = None
+ def __new__(cls, parameters=None, origin=None, *args, _root=False):
+ self = super().__new__(cls, parameters, origin, *args, _root=_root)
+ if origin is None:
+ self.__parameters__ = None
+ self.__args__ = None
+ self.__origin__ = None
+ self.__tree_hash__ = hash(frozenset(('Union',)))
return self
if not isinstance(parameters, tuple):
raise TypeError("Expected parameters=<tuple>")
- # Flatten out Union[Union[...], ...] and type-check non-Union args.
- params = []
- msg = "Union[arg, ...]: each arg must be a type."
- for p in parameters:
- if isinstance(p, _Union):
- params.extend(p.__union_params__)
- else:
- params.append(_type_check(p, msg))
- # Weed out strict duplicates, preserving the first of each occurrence.
- all_params = set(params)
- if len(all_params) < len(params):
- new_params = []
- for t in params:
- if t in all_params:
- new_params.append(t)
- all_params.remove(t)
- params = new_params
- assert not all_params, all_params
- # Weed out subclasses.
- # E.g. Union[int, Employee, Manager] == Union[int, Employee].
- # If object is present it will be sole survivor among proper classes.
- # Never discard type variables.
- # (In particular, Union[str, AnyStr] != AnyStr.)
- all_params = set(params)
- for t1 in params:
- if not isinstance(t1, type):
- continue
- if any(isinstance(t2, type) and issubclass(t1, t2)
- for t2 in all_params - {t1}
- if not (isinstance(t2, GenericMeta) and
- t2.__origin__ is not None)):
- all_params.remove(t1)
- # It's not a union if there's only one type left.
- if len(all_params) == 1:
- return all_params.pop()
- self.__union_params__ = tuple(t for t in params if t in all_params)
- self.__union_set_params__ = frozenset(self.__union_params__)
+ if origin is Union:
+ parameters = _remove_dups_flatten(parameters)
+ # It's not a union if there's only one type left.
+ if len(parameters) == 1:
+ return parameters[0]
+ self.__parameters__ = _type_vars(parameters)
+ self.__args__ = parameters
+ self.__origin__ = origin
+ # Pre-calculate the __hash__ on instantiation.
+ # This improves speed for complex substitutions.
+ subs_tree = self._subs_tree()
+ if isinstance(subs_tree, tuple):
+ self.__tree_hash__ = hash(frozenset(subs_tree))
+ else:
+ self.__tree_hash__ = hash(subs_tree)
return self
def _eval_type(self, globalns, localns):
- p = tuple(_eval_type(t, globalns, localns)
- for t in self.__union_params__)
- if p == self.__union_params__:
+ if self.__args__ is None:
return self
- else:
- return self.__class__(p, _root=True)
+ ev_args = tuple(_eval_type(t, globalns, localns) for t in self.__args__)
+ ev_origin = _eval_type(self.__origin__, globalns, localns)
+ if ev_args == self.__args__ and ev_origin == self.__origin__:
+ # Everything is already evaluated.
+ return self
+ return self.__class__(ev_args, ev_origin, _root=True)
def _get_type_vars(self, tvars):
- if self.__union_params__:
- _get_type_vars(self.__union_params__, tvars)
+ if self.__origin__ and self.__parameters__:
+ _get_type_vars(self.__parameters__, tvars)
def __repr__(self):
- return self._subs_repr([], [])
+ if self.__origin__ is None:
+ return super().__repr__()
+ tree = self._subs_tree()
+ if not isinstance(tree, tuple):
+ return repr(tree)
+ return tree[0]._tree_repr(tree)
- def _subs_repr(self, tvars, args):
- r = super().__repr__()
- if self.__union_params__:
- r += '[%s]' % (', '.join(_replace_arg(t, tvars, args)
- for t in self.__union_params__))
- return r
+ def _tree_repr(self, tree):
+ arg_list = []
+ for arg in tree[1:]:
+ if not isinstance(arg, tuple):
+ arg_list.append(_type_repr(arg))
+ else:
+ arg_list.append(arg[0]._tree_repr(arg))
+ return super().__repr__() + '[%s]' % ', '.join(arg_list)
@_tp_cache
def __getitem__(self, parameters):
- if self.__union_params__ is not None:
- raise TypeError(
- "Cannot subscript an existing Union. Use Union[u, t] instead.")
if parameters == ():
raise TypeError("Cannot take a Union of no types.")
if not isinstance(parameters, tuple):
parameters = (parameters,)
- return self.__class__(parameters, _root=True)
+ if self.__origin__ is None:
+ msg = "Union[arg, ...]: each arg must be a type."
+ else:
+ msg = "Parameters to generic types must be types."
+ parameters = tuple(_type_check(p, msg) for p in parameters)
+ if self is not Union:
+ _check_generic(self, parameters)
+ return self.__class__(parameters, origin=self, _root=True)
+
+ def _subs_tree(self, tvars=None, args=None):
+ if self is Union:
+ return Union # Nothing to substitute
+ tree_args = _subs_tree(self, tvars, args)
+ tree_args = _remove_dups_flatten(tree_args)
+ if len(tree_args) == 1:
+ return tree_args[0] # Union of a single type is that type
+ return (Union,) + tree_args
def __eq__(self, other):
if not isinstance(other, _Union):
- return NotImplemented
- return self.__union_set_params__ == other.__union_set_params__
+ return self._subs_tree() == other
+ return self.__tree_hash__ == other.__tree_hash__
def __hash__(self):
- return hash(self.__union_set_params__)
+ return self.__tree_hash__
def __instancecheck__(self, obj):
raise TypeError("Unions cannot be used with isinstance().")
@@ -677,195 +784,6 @@
Optional = _Optional(_root=True)
-class _Tuple(_FinalTypingBase, _root=True):
- """Tuple type; Tuple[X, Y] is the cross-product type of X and Y.
-
- Example: Tuple[T1, T2] is a tuple of two elements corresponding
- to type variables T1 and T2. Tuple[int, float, str] is a tuple
- of an int, a float and a string.
-
- To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
- """
-
- __slots__ = ('__tuple_params__', '__tuple_use_ellipsis__')
-
- def __init__(self, parameters=None,
- use_ellipsis=False, _root=False):
- self.__tuple_params__ = parameters
- self.__tuple_use_ellipsis__ = use_ellipsis
-
- def _get_type_vars(self, tvars):
- if self.__tuple_params__:
- _get_type_vars(self.__tuple_params__, tvars)
-
- def _eval_type(self, globalns, localns):
- tp = self.__tuple_params__
- if tp is None:
- return self
- p = tuple(_eval_type(t, globalns, localns) for t in tp)
- if p == self.__tuple_params__:
- return self
- else:
- return self.__class__(p, _root=True)
-
- def __repr__(self):
- return self._subs_repr([], [])
-
- def _subs_repr(self, tvars, args):
- r = super().__repr__()
- if self.__tuple_params__ is not None:
- params = [_replace_arg(p, tvars, args) for p in self.__tuple_params__]
- if self.__tuple_use_ellipsis__:
- params.append('...')
- if not params:
- params.append('()')
- r += '[%s]' % (
- ', '.join(params))
- return r
-
- @_tp_cache
- def __getitem__(self, parameters):
- if self.__tuple_params__ is not None:
- raise TypeError("Cannot re-parameterize %r" % (self,))
- if not isinstance(parameters, tuple):
- parameters = (parameters,)
- if len(parameters) == 2 and parameters[1] == Ellipsis:
- parameters = parameters[:1]
- use_ellipsis = True
- msg = "Tuple[t, ...]: t must be a type."
- else:
- use_ellipsis = False
- msg = "Tuple[t0, t1, ...]: each t must be a type."
- parameters = tuple(_type_check(p, msg) for p in parameters)
- return self.__class__(parameters,
- use_ellipsis=use_ellipsis, _root=True)
-
- def __eq__(self, other):
- if not isinstance(other, _Tuple):
- return NotImplemented
- return (self.__tuple_params__ == other.__tuple_params__ and
- self.__tuple_use_ellipsis__ == other.__tuple_use_ellipsis__)
-
- def __hash__(self):
- return hash((self.__tuple_params__, self.__tuple_use_ellipsis__))
-
- def __instancecheck__(self, obj):
- if self.__tuple_params__ == None:
- return isinstance(obj, tuple)
- raise TypeError("Parameterized Tuple cannot be used "
- "with isinstance().")
-
- def __subclasscheck__(self, cls):
- if self.__tuple_params__ == None:
- return issubclass(cls, tuple)
- raise TypeError("Parameterized Tuple cannot be used "
- "with issubclass().")
-
-
-Tuple = _Tuple(_root=True)
-
-
-class _Callable(_FinalTypingBase, _root=True):
- """Callable type; Callable[[int], str] is a function of (int) -> str.
-
- The subscription syntax must always be used with exactly two
- values: the argument list and the return type. The argument list
- must be a list of types; the return type must be a single type.
-
- There is no syntax to indicate optional or keyword arguments,
- such function types are rarely used as callback types.
- """
-
- __slots__ = ('__args__', '__result__')
-
- def __init__(self, args=None, result=None, _root=False):
- if args is None and result is None:
- pass
- else:
- if args is not Ellipsis:
- if not isinstance(args, list):
- raise TypeError("Callable[args, result]: "
- "args must be a list."
- " Got %.100r." % (args,))
- msg = "Callable[[arg, ...], result]: each arg must be a type."
- args = tuple(_type_check(arg, msg) for arg in args)
- msg = "Callable[args, result]: result must be a type."
- result = _type_check(result, msg)
- self.__args__ = args
- self.__result__ = result
-
- def _get_type_vars(self, tvars):
- if self.__args__ and self.__args__ is not Ellipsis:
- _get_type_vars(self.__args__, tvars)
- if self.__result__:
- _get_type_vars([self.__result__], tvars)
-
- def _eval_type(self, globalns, localns):
- if self.__args__ is None and self.__result__ is None:
- return self
- if self.__args__ is Ellipsis:
- args = self.__args__
- else:
- args = [_eval_type(t, globalns, localns) for t in self.__args__]
- result = _eval_type(self.__result__, globalns, localns)
- if args == self.__args__ and result == self.__result__:
- return self
- else:
- return self.__class__(args, result, _root=True)
-
- def __repr__(self):
- return self._subs_repr([], [])
-
- def _subs_repr(self, tvars, args):
- r = super().__repr__()
- if self.__args__ is not None or self.__result__ is not None:
- if self.__args__ is Ellipsis:
- args_r = '...'
- else:
- args_r = '[%s]' % ', '.join(_replace_arg(t, tvars, args)
- for t in self.__args__)
- r += '[%s, %s]' % (args_r, _replace_arg(self.__result__, tvars, args))
- return r
-
- def __getitem__(self, parameters):
- if self.__args__ is not None or self.__result__ is not None:
- raise TypeError("This Callable type is already parameterized.")
- if not isinstance(parameters, tuple) or len(parameters) != 2:
- raise TypeError(
- "Callable must be used as Callable[[arg, ...], result].")
- args, result = parameters
- return self.__class__(args, result, _root=True)
-
- def __eq__(self, other):
- if not isinstance(other, _Callable):
- return NotImplemented
- return (self.__args__ == other.__args__ and
- self.__result__ == other.__result__)
-
- def __hash__(self):
- return hash(self.__args__) ^ hash(self.__result__)
-
- def __instancecheck__(self, obj):
- # For unparametrized Callable we allow this, because
- # typing.Callable should be equivalent to
- # collections.abc.Callable.
- if self.__args__ is None and self.__result__ is None:
- return isinstance(obj, collections_abc.Callable)
- else:
- raise TypeError("Parameterized Callable cannot be used "
- "with isinstance().")
-
- def __subclasscheck__(self, cls):
- if self.__args__ is None and self.__result__ is None:
- return issubclass(cls, collections_abc.Callable)
- else:
- raise TypeError("Parameterized Callable cannot be used "
- "with issubclass().")
-
-
-Callable = _Callable(_root=True)
-
-
def _gorg(a):
"""Return the farthest origin of a generic class."""
assert isinstance(a, GenericMeta)
@@ -889,16 +807,6 @@
return _gorg(a) is _gorg(b)
-def _replace_arg(arg, tvars, args):
- if hasattr(arg, '_subs_repr'):
- return arg._subs_repr(tvars, args)
- if isinstance(arg, TypeVar):
- for i, tvar in enumerate(tvars):
- if arg == tvar:
- return args[i]
- return _type_repr(arg)
-
-
def _next_in_mro(cls):
"""Helper for Generic.__new__.
@@ -1011,7 +919,11 @@
self = super().__new__(cls, name, bases, namespace, _root=True)
self.__parameters__ = tvars
- self.__args__ = args
+ # Be prepared that GenericMeta will be subclassed by TupleMeta
+ # and CallableMeta, those two allow ..., (), or [] in __args___.
+ self.__args__ = tuple(... if a is _TypingEllipsis else
+ () if a is _TypingEmpty else
+ a for a in args) if args else None
self.__origin__ = origin
self.__extra__ = extra
# Speed hack (https://github.com/python/typing/issues/196).
@@ -1029,55 +941,69 @@
self.__subclasshook__ = _make_subclasshook(self)
if isinstance(extra, abc.ABCMeta):
self._abc_registry = extra._abc_registry
+
+ if origin and hasattr(origin, '__qualname__'): # Fix for Python 3.2.
+ self.__qualname__ = origin.__qualname__
+ self.__tree_hash__ = hash(self._subs_tree()) if origin else hash((self.__name__,))
return self
def _get_type_vars(self, tvars):
if self.__origin__ and self.__parameters__:
_get_type_vars(self.__parameters__, tvars)
+ def _eval_type(self, globalns, localns):
+ ev_origin = (self.__origin__._eval_type(globalns, localns)
+ if self.__origin__ else None)
+ ev_args = tuple(_eval_type(a, globalns, localns) for a
+ in self.__args__) if self.__args__ else None
+ if ev_origin == self.__origin__ and ev_args == self.__args__:
+ return self
+ return self.__class__(self.__name__,
+ self.__bases__,
+ dict(self.__dict__),
+ tvars=_type_vars(ev_args) if ev_args else None,
+ args=ev_args,
+ origin=ev_origin,
+ extra=self.__extra__,
+ orig_bases=self.__orig_bases__)
+
def __repr__(self):
if self.__origin__ is None:
return super().__repr__()
- return self._subs_repr([], [])
+ return self._tree_repr(self._subs_tree())
- def _subs_repr(self, tvars, args):
- assert len(tvars) == len(args)
- # Construct the chain of __origin__'s.
- current = self.__origin__
- orig_chain = []
- while current.__origin__ is not None:
- orig_chain.append(current)
- current = current.__origin__
- # Replace type variables in __args__ if asked ...
- str_args = []
- for arg in self.__args__:
- str_args.append(_replace_arg(arg, tvars, args))
- # ... then continue replacing down the origin chain.
- for cls in orig_chain:
- new_str_args = []
- for i, arg in enumerate(cls.__args__):
- new_str_args.append(_replace_arg(arg, cls.__parameters__, str_args))
- str_args = new_str_args
- return super().__repr__() + '[%s]' % ', '.join(str_args)
+ def _tree_repr(self, tree):
+ arg_list = []
+ for arg in tree[1:]:
+ if arg == ():
+ arg_list.append('()')
+ elif not isinstance(arg, tuple):
+ arg_list.append(_type_repr(arg))
+ else:
+ arg_list.append(arg[0]._tree_repr(arg))
+ return super().__repr__() + '[%s]' % ', '.join(arg_list)
+
+ def _subs_tree(self, tvars=None, args=None):
+ if self.__origin__ is None:
+ return self
+ tree_args = _subs_tree(self, tvars, args)
+ return (_gorg(self),) + tuple(tree_args)
def __eq__(self, other):
if not isinstance(other, GenericMeta):
return NotImplemented
- if self.__origin__ is not None:
- return (self.__origin__ is other.__origin__ and
- self.__args__ == other.__args__ and
- self.__parameters__ == other.__parameters__)
- else:
+ if self.__origin__ is None or other.__origin__ is None:
return self is other
+ return self.__tree_hash__ == other.__tree_hash__
def __hash__(self):
- return hash((self.__name__, self.__parameters__))
+ return self.__tree_hash__
@_tp_cache
def __getitem__(self, params):
if not isinstance(params, tuple):
params = (params,)
- if not params:
+ if not params and not _gorg(self) is Tuple:
raise TypeError(
"Parameter list to %s[...] cannot be empty" % _qualname(self))
msg = "Parameters to generic types must be types."
@@ -1092,6 +1018,9 @@
"Parameters to Generic[...] must all be unique")
tvars = params
args = params
+ elif self in (Tuple, Callable):
+ tvars = _type_vars(params)
+ args = params
elif self is _Protocol:
# _Protocol is internal, don't check anything.
tvars = params
@@ -1102,14 +1031,7 @@
repr(self))
else:
# Subscripting a regular Generic subclass.
- if not self.__parameters__:
- raise TypeError("%s is not a generic class" % repr(self))
- alen = len(params)
- elen = len(self.__parameters__)
- if alen != elen:
- raise TypeError(
- "Too %s parameters for %s; actual %s, expected %s" %
- ("many" if alen > elen else "few", repr(self), alen, elen))
+ _check_generic(self, params)
tvars = _type_vars(params)
args = params
return self.__class__(self.__name__,
@@ -1134,6 +1056,22 @@
Generic = None
+def _generic_new(base_cls, cls, *args, **kwds):
+ # Assure type is erased on instantiation,
+ # but attempt to store it in __orig_class__
+ if cls.__origin__ is None:
+ return base_cls.__new__(cls)
+ else:
+ origin = _gorg(cls)
+ obj = base_cls.__new__(origin)
+ try:
+ obj.__orig_class__ = cls
+ except AttributeError:
+ pass
+ obj.__init__(*args, **kwds)
+ return obj
+
+
class Generic(metaclass=GenericMeta):
"""Abstract base class for generic types.
@@ -1158,17 +1096,154 @@
__slots__ = ()
def __new__(cls, *args, **kwds):
- if cls.__origin__ is None:
- return cls.__next_in_mro__.__new__(cls)
+ return _generic_new(cls.__next_in_mro__, cls, *args, **kwds)
+
+
+class _TypingEmpty:
+ """Placeholder for () or []. Used by TupleMeta and CallableMeta
+ to allow empy list/tuple in specific places, without allowing them
+ to sneak in where prohibited.
+ """
+
+
+class _TypingEllipsis:
+ """Ditto for ..."""
+
+
+class TupleMeta(GenericMeta):
+ """Metaclass for Tuple"""
+
+ @_tp_cache
+ def __getitem__(self, parameters):
+ if self.__origin__ is not None or not _geqv(self, Tuple):
+ # Normal generic rules apply if this is not the first subscription
+ # or a subscription of a subclass.
+ return super().__getitem__(parameters)
+ if parameters == ():
+ return super().__getitem__((_TypingEmpty,))
+ if not isinstance(parameters, tuple):
+ parameters = (parameters,)
+ if len(parameters) == 2 and parameters[1] is ...:
+ msg = "Tuple[t, ...]: t must be a type."
+ p = _type_check(parameters[0], msg)
+ return super().__getitem__((p, _TypingEllipsis))
+ msg = "Tuple[t0, t1, ...]: each t must be a type."
+ parameters = tuple(_type_check(p, msg) for p in parameters)
+ return super().__getitem__(parameters)
+
+ def __instancecheck__(self, obj):
+ if self.__args__ == None:
+ return isinstance(obj, tuple)
+ raise TypeError("Parameterized Tuple cannot be used "
+ "with isinstance().")
+
+ def __subclasscheck__(self, cls):
+ if self.__args__ == None:
+ return issubclass(cls, tuple)
+ raise TypeError("Parameterized Tuple cannot be used "
+ "with issubclass().")
+
+
+class Tuple(tuple, extra=tuple, metaclass=TupleMeta):
+ """Tuple type; Tuple[X, Y] is the cross-product type of X and Y.
+
+ Example: Tuple[T1, T2] is a tuple of two elements corresponding
+ to type variables T1 and T2. Tuple[int, float, str] is a tuple
+ of an int, a float and a string.
+
+ To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
+ """
+
+ __slots__ = ()
+
+ def __new__(cls, *args, **kwds):
+ if _geqv(cls, Tuple):
+ raise TypeError("Type Tuple cannot be instantiated; "
+ "use tuple() instead")
+ return _generic_new(tuple, cls, *args, **kwds)
+
+
+class CallableMeta(GenericMeta):
+ """ Metaclass for Callable."""
+
+ def __repr__(self):
+ if self.__origin__ is None:
+ return super().__repr__()
+ return self._tree_repr(self._subs_tree())
+
+ def _tree_repr(self, tree):
+ if _gorg(self) is not Callable:
+ return super()._tree_repr(tree)
+ # For actual Callable (not its subclass) we override
+ # super()._tree_repr() for nice formatting.
+ arg_list = []
+ for arg in tree[1:]:
+ if arg == ():
+ arg_list.append('[]')
+ elif not isinstance(arg, tuple):
+ arg_list.append(_type_repr(arg))
+ else:
+ arg_list.append(arg[0]._tree_repr(arg))
+ if len(arg_list) == 2:
+ return repr(tree[0]) + '[%s]' % ', '.join(arg_list)
+ return (repr(tree[0]) +
+ '[[%s], %s]' % (', '.join(arg_list[:-1]), arg_list[-1]))
+
+ def __getitem__(self, parameters):
+ """ A thin wrapper around __getitem_inner__ to provide the latter
+ with hashable arguments to improve speed.
+ """
+
+ if self.__origin__ is not None or not _geqv(self, Callable):
+ return super().__getitem__(parameters)
+ if not isinstance(parameters, tuple) or len(parameters) != 2:
+ raise TypeError("Callable must be used as "
+ "Callable[[arg, ...], result].")
+ args, result = parameters
+ if args is ...:
+ parameters = (..., result)
+ elif args == []:
+ parameters = ((), result)
else:
- origin = _gorg(cls)
- obj = cls.__next_in_mro__.__new__(origin)
- try:
- obj.__orig_class__ = cls
- except AttributeError:
- pass
- obj.__init__(*args, **kwds)
- return obj
+ if not isinstance(args, list):
+ raise TypeError("Callable[args, result]: args must be a list."
+ " Got %.100r." % (args,))
+ parameters = tuple(args) + (result,)
+ return self.__getitem_inner__(parameters)
+
+ @_tp_cache
+ def __getitem_inner__(self, parameters):
+ *args, result = parameters
+ msg = "Callable[args, result]: result must be a type."
+ result = _type_check(result, msg)
+ if args == [...,]:
+ return super().__getitem__((_TypingEllipsis, result))
+ if args == [(),]:
+ return super().__getitem__((_TypingEmpty, result))
+ msg = "Callable[[arg, ...], result]: each arg must be a type."
+ args = tuple(_type_check(arg, msg) for arg in args)
+ parameters = args + (result,)
+ return super().__getitem__(parameters)
+
+
+class Callable(extra=collections_abc.Callable, metaclass = CallableMeta):
+ """Callable type; Callable[[int], str] is a function of (int) -> str.
+
+ The subscription syntax must always be used with exactly two
+ values: the argument list and the return type. The argument list
+ must be a list of types; the return type must be a single type.
+
+ There is no syntax to indicate optional or keyword arguments,
+ such function types are rarely used as callback types.
+ """
+
+ __slots__ = ()
+
+ def __new__(cls, *args, **kwds):
+ if _geqv(cls, Callable):
+ raise TypeError("Type Callable cannot be instantiated; "
+ "use a non-abstract subclass instead")
+ return _generic_new(cls.__next_in_mro__, cls, *args, **kwds)
class _ClassVar(_FinalTypingBase, _root=True):
@@ -1208,17 +1283,10 @@
return self
return type(self)(new_tp, _root=True)
- def _get_type_vars(self, tvars):
- if self.__type__:
- _get_type_vars([self.__type__], tvars)
-
def __repr__(self):
- return self._subs_repr([], [])
-
- def _subs_repr(self, tvars, args):
r = super().__repr__()
if self.__type__ is not None:
- r += '[{}]'.format(_replace_arg(self.__type__, tvars, args))
+ r += '[{}]'.format(_type_repr(self.__type__))
return r
def __hash__(self):
@@ -1231,6 +1299,7 @@
return self.__type__ == other.__type__
return self is other
+
ClassVar = _ClassVar(_root=True)
@@ -1533,6 +1602,7 @@
attr != '__origin__' and
attr != '__orig_bases__' and
attr != '__extra__' and
+ attr != '__tree_hash__' and
attr != '__module__'):
attrs.add(attr)
@@ -1723,7 +1793,7 @@
if _geqv(cls, List):
raise TypeError("Type List cannot be instantiated; "
"use list() instead")
- return list.__new__(cls, *args, **kwds)
+ return _generic_new(list, cls, *args, **kwds)
class Set(set, MutableSet[T], extra=set):
@@ -1734,7 +1804,7 @@
if _geqv(cls, Set):
raise TypeError("Type Set cannot be instantiated; "
"use set() instead")
- return set.__new__(cls, *args, **kwds)
+ return _generic_new(set, cls, *args, **kwds)
class FrozenSet(frozenset, AbstractSet[T_co], extra=frozenset):
@@ -1744,7 +1814,7 @@
if _geqv(cls, FrozenSet):
raise TypeError("Type FrozenSet cannot be instantiated; "
"use frozenset() instead")
- return frozenset.__new__(cls, *args, **kwds)
+ return _generic_new(frozenset, cls, *args, **kwds)
class MappingView(Sized, Iterable[T_co], extra=collections_abc.MappingView):
@@ -1781,7 +1851,7 @@
if _geqv(cls, Dict):
raise TypeError("Type Dict cannot be instantiated; "
"use dict() instead")
- return dict.__new__(cls, *args, **kwds)
+ return _generic_new(dict, cls, *args, **kwds)
class DefaultDict(collections.defaultdict, MutableMapping[KT, VT],
extra=collections.defaultdict):
@@ -1792,7 +1862,7 @@
if _geqv(cls, DefaultDict):
raise TypeError("Type DefaultDict cannot be instantiated; "
"use collections.defaultdict() instead")
- return collections.defaultdict.__new__(cls, *args, **kwds)
+ return _generic_new(collections.defaultdict, cls, *args, **kwds)
# Determine what base class to use for Generator.
if hasattr(collections_abc, 'Generator'):
@@ -1811,7 +1881,7 @@
if _geqv(cls, Generator):
raise TypeError("Type Generator cannot be instantiated; "
"create a subclass instead")
- return super().__new__(cls, *args, **kwds)
+ return _generic_new(_G_base, cls, *args, **kwds)
# Internal type variable used for Type[].
