Add Annotated in python2 (python#640)

till-varoquaux · ilevkivskyi · commit a15d7866329c · 2019-06-06T11:13:42.000+01:00
The Python 2 version is very close to the Python 3.6 code.
diff --git a/src_py2/test_typing_extensions.py b/src_py2/test_typing_extensions.py
@@ -8,9 +8,10 @@
 import types
 from unittest import TestCase, main, skipUnless
 
-from typing_extensions import NoReturn, ClassVar, Final, IntVar, Literal, TypedDict
+from typing_extensions import Annotated, NoReturn, ClassVar, Final, IntVar, Literal, TypedDict
 from typing_extensions import ContextManager, Counter, Deque, DefaultDict
 from typing_extensions import NewType, overload, Protocol, runtime
+from typing import Dict, List
 import typing
 import typing_extensions
 
@@ -926,6 +927,147 @@ def test_total(self):
         self.assertEqual(D.__total__, False)
 
 
+class AnnotatedTests(BaseTestCase):
+
+    def test_repr(self):
+        self.assertEqual(
+            repr(Annotated[int, 4, 5]),
+            "typing_extensions.Annotated[int, 4, 5]"
+        )
+        self.assertEqual(
+            repr(Annotated[List[int], 4, 5]),
+            "typing_extensions.Annotated[typing.List[int], 4, 5]"
+        )
+        self.assertEqual(repr(Annotated), "typing_extensions.Annotated")
+
+    def test_flatten(self):
+        A = Annotated[Annotated[int, 4], 5]
+        self.assertEqual(A, Annotated[int, 4, 5])
+        self.assertEqual(A.__metadata__, (4, 5))
+
+    def test_specialize(self):
+        L = Annotated[List[T], "my decoration"]
+        LI = Annotated[List[int], "my decoration"]
+        self.assertEqual(L[int], Annotated[List[int], "my decoration"])
+        self.assertEqual(L[int].__metadata__, ("my decoration",))
+        with self.assertRaises(TypeError):
+            LI[int]
+        with self.assertRaises(TypeError):
+            L[int, float]
+
+    def test_hash_eq(self):
+        self.assertEqual(len({Annotated[int, 4, 5], Annotated[int, 4, 5]}), 1)
+        self.assertNotEqual(Annotated[int, 4, 5], Annotated[int, 5, 4])
+        self.assertNotEqual(Annotated[int, 4, 5], Annotated[str, 4, 5])
+        self.assertNotEqual(Annotated[int, 4], Annotated[int, 4, 4])
+        self.assertEqual(
+            {Annotated[int, 4, 5], Annotated[int, 4, 5], Annotated[T, 4, 5]},
+            {Annotated[int, 4, 5], Annotated[T, 4, 5]}
+        )
+
+    def test_instantiate(self):
+        class C:
+            classvar = 4
+
+            def __init__(self, x):
+                self.x = x
+
+            def __eq__(self, other):
+                if not isinstance(other, C):
+                    return NotImplemented
+                return other.x == self.x
+
+        A = Annotated[C, "a decoration"]
+        a = A(5)
+        c = C(5)
+        self.assertEqual(a, c)
+        self.assertEqual(a.x, c.x)
+        self.assertEqual(a.classvar, c.classvar)
+
+    def test_instantiate_generic(self):
+        MyCount = Annotated[typing_extensions.Counter[T], "my decoration"]
+        self.assertEqual(MyCount([4, 4, 5]), {4: 2, 5: 1})
+        self.assertEqual(MyCount[int]([4, 4, 5]), {4: 2, 5: 1})
+
+    def test_cannot_instantiate_forward(self):
+        A = Annotated["int", (5, 6)]
+        with self.assertRaises(TypeError):
+            A(5)
+
+    def test_cannot_instantiate_type_var(self):
+        A = Annotated[T, (5, 6)]
+        with self.assertRaises(TypeError):
+            A(5)
+
+    def test_cannot_getattr_typevar(self):
+        with self.assertRaises(AttributeError):
+            Annotated[T, (5, 7)].x
+
+    def test_attr_passthrough(self):
+        class C:
+            classvar = 4
+
+        A = Annotated[C, "a decoration"]
+        self.assertEqual(A.classvar, 4)
+        A.x = 5
+        self.assertEqual(C.x, 5)
+
+    def test_hash_eq(self):
+        self.assertEqual(len({Annotated[int, 4, 5], Annotated[int, 4, 5]}), 1)
+        self.assertNotEqual(Annotated[int, 4, 5], Annotated[int, 5, 4])
+        self.assertNotEqual(Annotated[int, 4, 5], Annotated[str, 4, 5])
+        self.assertNotEqual(Annotated[int, 4], Annotated[int, 4, 4])
+        self.assertEqual(
+            {Annotated[int, 4, 5], Annotated[int, 4, 5], Annotated[T, 4, 5]},
+            {Annotated[int, 4, 5], Annotated[T, 4, 5]}
+        )
+
+    def test_cannot_subclass(self):
+        with self.assertRaises(TypeError):
+           class C(Annotated):
+               pass
+
+    def test_cannot_check_instance(self):
+        with self.assertRaises(TypeError):
+            isinstance(5, Annotated[int, "positive"])
+
+    def test_cannot_check_subclass(self):
+        with self.assertRaises(TypeError):
+            issubclass(int, Annotated[int, "positive"])
+
+    def test_subst(self):
+        dec = "a decoration"
+        dec2 = "another decoration"
+
+        S = Annotated[T, dec2]
+        self.assertEqual(S[int], Annotated[int, dec2])
+
+        self.assertEqual(S[Annotated[int, dec]], Annotated[int, dec, dec2])
+        L = Annotated[List[T], dec]
+
+        self.assertEqual(L[int], Annotated[List[int], dec])
+        with self.assertRaises(TypeError):
+            L[int, int]
+
+        self.assertEqual(S[L[int]], Annotated[List[int], dec, dec2])
+
+        D = Annotated[Dict[KT, VT], dec]
+        self.assertEqual(D[str, int], Annotated[Dict[str, int], dec])
+        with self.assertRaises(TypeError):
+            D[int]
+
+        I = Annotated[int, dec]
+        with self.assertRaises(TypeError):
+            I[None]
+
+        LI = L[int]
+        with self.assertRaises(TypeError):
+            LI[None]
+
+    def test_annotated_in_other_types(self):
+        X = List[Annotated[T, 5]]
+        self.assertEqual(X[int], List[Annotated[int, 5]])
+
 class AllTests(BaseTestCase):
 
     def test_typing_extensions_includes_standard(self):
diff --git a/src_py2/typing_extensions.py b/src_py2/typing_extensions.py
@@ -605,3 +605,134 @@ def __new__(cls, name, bases, ns, total=True):
 
         Point2D = TypedDict('Point2D', x=int, y=int, label=str)
     """
+
+def _is_dunder(name):
+    """Returns True if name is a __dunder_variable_name__."""
+    return len(name) > 4 and name.startswith('__') and name.endswith('__')
+
+class AnnotatedMeta(GenericMeta):
+    """Metaclass for Annotated"""
+
+    def __new__(cls, name, bases, namespace, **kwargs):
+        if any(b is not object for b in bases):
+            raise TypeError("Cannot subclass %s" % Annotated)
+        return super(AnnotatedMeta, cls).__new__(cls, name, bases, namespace, **kwargs)
+
+    @property
+    def __metadata__(self):
+        return self._subs_tree()[2]
+
+    def _tree_repr(self, tree):
+        assert len(tree) == 3
+        cls, origin, metadata = tree
+        if not isinstance(origin, tuple):
+            tp_repr = typing._type_repr(origin)
+        else:
+            tp_repr = origin[0]._tree_repr(origin)
+        metadata_reprs = ", ".join(repr(arg) for arg in metadata)
+        return '%s[%s, %s]' % (cls, tp_repr, metadata_reprs)
+
+    def _subs_tree(self, tvars=None, args=None):
+        if self is Annotated:
+            return Annotated
+        res = super(AnnotatedMeta, self)._subs_tree(tvars=tvars, args=args)
+        # Flatten nested Annotated
+        if isinstance(res[1], tuple) and res[1][0] is Annotated:
+            sub_tp = res[1][1]
+            sub_annot = res[1][2]
+            return (Annotated, sub_tp, sub_annot + res[2])
+        return res
+
+    def _get_cons(self):
+        """Return the class used to create instance of this type."""
+        if self.__origin__ is None:
+            raise TypeError("Cannot get the underlying type of a non-specialized "
+                            "Annotated type.")
+        tree = self._subs_tree()
+        while isinstance(tree, tuple) and tree[0] is Annotated:
+            tree = tree[1]
+        if isinstance(tree, tuple):
+            return tree[0]
+        else:
+            return tree
+
+    @_tp_cache
+    def __getitem__(self, params):
+        if not isinstance(params, tuple):
+            params = (params,)
+        if self.__origin__ is not None:  # specializing an instantiated type
+            return super(AnnotatedMeta, self).__getitem__(params)
+        elif not isinstance(params, tuple) or len(params) < 2:
+            raise TypeError("Annotated[...] should be instantiated with at "
+                            "least two arguments (a type and an annotation).")
+        else:
+            msg = "Annotated[t, ...]: t must be a type."
+            tp = typing._type_check(params[0], msg)
+            metadata = tuple(params[1:])
+        return self.__class__(
+            self.__name__,
+            self.__bases__,
+            dict(self.__dict__),
+            tvars=_type_vars((tp,)),
+            # Metadata is a tuple so it won't be touched by _replace_args et al.
+            args=(tp, metadata),
+            origin=self,
+        )
+
+    def __call__(self, *args, **kwargs):
+        cons = self._get_cons()
+        result = cons(*args, **kwargs)
+        try:
+            result.__orig_class__ = self
+        except AttributeError:
+            pass
+        return result
+
+    def __getattr__(self, attr):
+        # For simplicity we just don't relay all dunder names
+        if self.__origin__ is not None and not _is_dunder(attr):
+            return getattr(self._get_cons(), attr)
+        raise AttributeError(attr)
+
+    def __setattr__(self, attr, value):
+        if _is_dunder(attr) or attr.startswith('_abc_'):
+            super(AnnotatedMeta, self).__setattr__(attr, value)
+        elif self.__origin__ is None:
+            raise AttributeError(attr)
+        else:
+            setattr(self._get_cons(), attr, value)
+
+
+class Annotated(object):
+    """Add context specific metadata to a type.
+
+    Example: Annotated[int, runtime_check.Unsigned] indicates to the
+    hypothetical runtime_check module that this type is an unsigned int.
+    Every other consumer of this type can ignore this metadata and treat
+    this type as int.
+
+    The first argument to Annotated must be a valid type, the remaining
+    arguments are kept as a tuple in the __metadata__ field.
+
+    Details:
+
+    - It's an error to call `Annotated` with less than two arguments.
+    - Nested Annotated are flattened::
+
+        Annotated[Annotated[int, Ann1, Ann2], Ann3] == Annotated[int, Ann1, Ann2, Ann3]
+
+    - Instantiating an annotated type is equivalent to instantiating the
+    underlying type::
+
+        Annotated[C, Ann1](5) == C(5)
+
+    - Annotated can be used as a generic type alias::
+
+        Optimized = Annotated[T, runtime.Optimize()]
+        Optimized[int] == Annotated[int, runtime.Optimize()]
+
+        OptimizedList = Annotated[List[T], runtime.Optimize()]
+        OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
+    """
+    __metaclass__ = AnnotatedMeta
+    __slots__ = ()
