Use _PosArgs instead of tuple

1. allow equality between typing._PosArgs and collections.abc._PosArgs 2. allow equality checks between genericalias subclasses 3. add support to genericalias subclasses for union type expressions
python · gvanrossum · Dec 13, 2020 · Oct 31, 2020 · Oct 31, 2020 · Oct 31, 2020
commit 327e1a5bb75e4320c41ef0d3aabff2c1c407fac4
diff --git a/Lib/_collections_abc.py b/Lib/_collections_abc.py
@@ -24,8 +24,11 @@ def _f(): pass
            "MappingView", "KeysView", "ItemsView", "ValuesView",
            "Sequence", "MutableSequence",
            "ByteString",
-           # To allow for pickling, not actually meant to be imported.
+           # The following classse are to allow pickling, not actually
+           # meant to be imported.
            "_CallableGenericAlias",
+           "_PosArgs",
+           "_PosArgsGenericAlias"
            ]
 
 # This module has been renamed from collections.abc to _collections_abc to
@@ -415,6 +418,35 @@ def __subclasshook__(cls, C):
         return NotImplemented
 
 
+class _PosArgsGenericAlias(GenericAlias):
+    """ Internal class specifically to represent positional arguments in
+    ``_CallableGenericAlias``.
+    """
+    def __repr__(self):
+        return f"{__name__}._PosArgsGenericAlias" \
+               f"[{', '.join(_type_repr(t) for t in self.__args__)}]"
+
+    def __eq__(self, other):
+        o_cls = other.__class__
+        if not (o_cls.__module__ == "typing" and o_cls.__name__
+                == "_GenericAlias" or isinstance(other, GenericAlias)):
+            return NotImplemented
+        return (self.__origin__ == other.__origin__
+                and self.__args__ == other.__args__)
+
+    def __hash__(self):
+        return hash((self.__origin__, self.__args__))
+
+# Only used for _CallableGenericAlias
+class _PosArgs:
+    """ Internal class specifically to represent positional arguments in
+    ``_CallableGenericAlias``.
+    """
+    def __class_getitem__(cls, item):
+        return _PosArgsGenericAlias(tuple, item)
+
+# _PosArgs = type("_PosArgs", (tuple, ), {})
+
 class _CallableGenericAlias(GenericAlias):
     """ Internal class specifically for consistency between the ``__args__`` of
     ``collections.abc.Callable``'s and ``typing.Callable``'s ``GenericAlias``.
@@ -432,21 +464,10 @@ def __new__(cls, *args, **kwargs):
                             f"or Ellipsis. Got {_type_repr(t_args)}")
 
         ga_args = (_args if t_args is Ellipsis
-                   else (tuple[tuple(t_args)], t_result))
+                   else (_PosArgs[tuple(t_args)], t_result))
 
         return super().__new__(cls, origin, ga_args)
 
-    def __init__(self, *args, **kwargs):
-        pass
-
-    def __eq__(self, other):
-        if not isinstance(other, GenericAlias):
-            return NotImplemented
-        return (self.__origin__ == other.__origin__
-                and self.__args__ == other.__args__)
-
-    def __hash__(self):
-        return super().__hash__()
 
     def __repr__(self):
         t_args = self.__args__[0]
@@ -459,6 +480,12 @@ def __repr__(self):
 
         return f"{origin}[{t_args_repr}, {_type_repr(self.__args__[-1])}]"
 
+    def __reduce__(self):
+        args = self.__args__
+        if not (len(args) == 2 and args[0] is ...):
+            args = list(t for t in args[0].__args__), args[-1]
+        return _CallableGenericAlias, (Callable, args)
+
 
 def _type_repr(obj):
     """Return the repr() of an object, special-casing types (internal helper).

diff --git a/Lib/test/test_genericalias.py b/Lib/test/test_genericalias.py
@@ -303,30 +303,38 @@ def test_weakref(self):
 
     def test_abc_callable(self):
         alias = Callable[[int, str], float]
-        with self.subTest("Testing collections.abc.Callable's subscription"):
+        with self.subTest("Testing subscription"):
             self.assertIs(alias.__origin__, Callable)
-            self.assertEqual(alias.__args__, (tuple[int, str], float))
+            self.assertEqual(alias.__args__, (_PosArgs[int, str], float))
             self.assertEqual(alias.__parameters__, ())
 
-        with self.subTest("Testing collections.abc.Callable's instance checks"):
+        with self.subTest("Testing nstance checks"):
             self.assertIsInstance(alias, GenericAlias)
 
         invalid_params = ('Callable[int]', 'Callable[int, str]')
-        with self.subTest("Testing collections.abc.Callable's parameter "
-                          "validation"):
+        with self.subTest("Testing parameter validation"):
             for bad in invalid_params:
                 with self.subTest(f'Testing expression {bad}'):
                     with self.assertRaises(TypeError):
                         eval(bad)
 
-        with self.subTest("Testing collections.abc.Callable's weakref"):
+        with self.subTest("Testing weakref"):
             self.assertEqual(ref(alias)(), alias)
 
+        with self.subTest("Testing picling"):
+            s = pickle.dumps(alias)
+            loaded = pickle.loads(s)
+            self.assertEqual(alias.__origin__, loaded.__origin__)
+            self.assertEqual(alias.__args__, loaded.__args__)
+            self.assertEqual(alias.__parameters__, loaded.__parameters__)
+
         # bpo-42195
         with self.subTest("Testing collections.abc.Callable's consistency "
                           "with typing.Callable"):
-            self.assertEqual(typing.Callable[[int, str], dict].__args__,
-                              Callable[[int, str], dict].__args__)
+            c1 = typing.Callable[[int, str], dict]
+            c2 = Callable[[int, str], dict]
+            self.assertEqual(c1.__args__, c2.__args__)
+            self.assertEqual(hash(c1.__args__), hash(c2.__args__))
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
@@ -3058,7 +3058,7 @@ class C(Generic[T]): pass
                          (int, Tuple[str, int]))
         self.assertEqual(get_args(typing.Dict[int, Tuple[T, T]][Optional[int]]),
                          (int, Tuple[Optional[int], Optional[int]]))
-        self.assertEqual(get_args(Callable[[], T][int]), (tuple[()], int))
+        self.assertEqual(get_args(Callable[[], T][int]), (typing._PosArgs[()], int))
         self.assertEqual(get_args(Callable[..., int]), (..., int))
         self.assertEqual(get_args(Union[int, Callable[[Tuple[T, ...]], str]]),
                          (int, Callable[[Tuple[T, ...]], str]))

diff --git a/Lib/typing.py b/Lib/typing.py
@@ -114,6 +114,7 @@
     'Text',
     'TYPE_CHECKING',
     'TypeAlias',
+    '_PosArgs',  # Not meant to be imported, just for pickling.
 ]
 
 # The pseudo-submodules 're' and 'io' are part of the public
@@ -921,7 +922,7 @@ def __getitem_inner__(self, params):
             return self.copy_with((_TypingEllipsis, result))
         msg = "Callable[[arg, ...], result]: each arg must be a type."
         args = tuple(_type_check(arg, msg) for arg in args)
-        params = (tuple[args], result)
+        params = (_PosArgs[args], result)
         return self.copy_with(params)
 
 
@@ -1711,6 +1712,8 @@ class Other(Leaf):  # Error reported by type checker
 Sized = _alias(collections.abc.Sized, 0)  # Not generic.
 Container = _alias(collections.abc.Container, 1)
 Collection = _alias(collections.abc.Collection, 1)
+# Only used for Callable
+_PosArgs = _TupleType(tuple, -1, inst=False, name='_PosArgs')
 Callable = _CallableType(collections.abc.Callable, 2)
 Callable.__doc__ = \
     """Callable type; Callable[[int], str] is a function of (int) -> str.

diff --git a/Objects/genericaliasobject.c b/Objects/genericaliasobject.c
@@ -429,8 +429,8 @@ ga_getattro(PyObject *self, PyObject *name)
 static PyObject *
 ga_richcompare(PyObject *a, PyObject *b, int op)
 {
-    if (!Py_IS_TYPE(a, &Py_GenericAliasType) ||
-        !Py_IS_TYPE(b, &Py_GenericAliasType) ||
+    if (!PyObject_TypeCheck(a, &Py_GenericAliasType) ||
+        !PyObject_TypeCheck(b, &Py_GenericAliasType) ||
         (op != Py_EQ && op != Py_NE))
     {
         Py_RETURN_NOTIMPLEMENTED;

diff --git a/Objects/unionobject.c b/Objects/unionobject.c
@@ -296,7 +296,7 @@ is_unionable(PyObject *obj)
         is_new_type(obj) ||
         is_special_form(obj) ||
         PyType_Check(obj) ||
-        type == &Py_GenericAliasType ||
+        PyObject_TypeCheck(obj, &Py_GenericAliasType) ||
         type == &_Py_UnionType);
 }