Merge pull request #1 from ambv/master

Update with master

Author: ilevkivskyi

pep-0484.txt

@@ -9,6 +9,7 @@ Status: Accepted
 Type: Standards Track
 Content-Type: text/x-rst
 Created: 29-Sep-2014
+Python-Version: 3.5
 Post-History: 16-Jan-2015,20-Mar-2015,17-Apr-2015,20-May-2015,22-May-2015
 Resolution: https://mail.python.org/pipermail/python-dev/2015-May/140104.html
 
@@ -85,7 +86,7 @@ Non-goals
 ---------
 
 While the proposed typing module will contain some building blocks for
-runtime type checking -- in particular the `get_type_hints()`
+runtime type checking -- in particular the ``get_type_hints()``
 function -- third party packages would have to be developed to
 implement specific runtime type checking functionality, for example
 using decorators or metaclasses.  Using type hints for performance
@@ -262,10 +263,10 @@ arguments with ``Callable``.  Similarly, there is no support for
 specifying callback signatures with a variable number of argument of a
 specific type.
 
-Because `typing.Callable` does double-duty as a replacement for
-`collections.abc.Callable`, `isinstance(x, typing.Callable)` is
-implemented by deferring to `isinstance(x, collections.abc.Callable)`.
-However, `isinstance(x, typing.Callable[...])` is not supported.
+Because ``typing.Callable`` does double-duty as a replacement for
+``collections.abc.Callable``, ``isinstance(x, typing.Callable)`` is
+implemented by deferring to ```isinstance(x, collections.abc.Callable)``.
+However, ``isinstance(x, typing.Callable[...])`` is not supported.
 
 
 Generics
@@ -413,7 +414,7 @@ You can use multiple inheritance with ``Generic``::
 
 Subclassing a generic class without specifying type parameters assumes
 ``Any`` for each position.  In the following example, ``MyIterable``
-is not generic but implicitly inherits from ``Iterable[Any]``:
+is not generic but implicitly inherits from ``Iterable[Any]``::
 
   from typing import Iterable
 
@@ -441,20 +442,20 @@ Now there are two ways we can instantiate this class; the type
 inferred by a type checker may be different depending on the form we
 use.  The first way is to give the value of the type parameter
 explicitly -- this overrides whatever type inference the type
-checker would otherwise perform:
+checker would otherwise perform::
 
   x = Node[T]()  # The type inferred for x is Node[T].
 
   y = Node[int]()  # The type inferred for y is Node[int].
 
 If no explicit types are given, the type checker is given some
-freedom. Consider this code:
+freedom. Consider this code::
 
   x = Node()
 
 The inferred type could be ``Node[Any]``, as there isn't enough
 context to infer a more precise type.  Alternatively, a type checker
-may reject the line and require an explicit annotation, like this:
+may reject the line and require an explicit annotation, like this::
 
   x = Node()  # type: Node[int]  # Inferred type is Node[int].
 
@@ -943,7 +944,7 @@ ellipsis::
 
   stream = ...  # type: IO[str]
 
-In non-stub code, there is a similar special case:
+In non-stub code, there is a similar special case::
 
   from typing import IO
 
@@ -986,7 +987,7 @@ than a type checker may be able to infer.  For example::
       return cast(str, a[index])
 
 Some type checkers may not be able to infer that the type of
-``a[index]`` is ``str`` and only infer ``object`` or ``Any``", but we
+``a[index]`` is ``str`` and only infer ``object`` or ``Any``, but we
 know that (if the code gets to that point) it must be a string.  The
 ``cast(t, x)`` call tells the type checker that we are confident that
 the type of ``x`` is ``t``.  At runtime a cast always returns the
@@ -1110,7 +1111,7 @@ calling ``overload()`` directly raises ``RuntimeError``.
 
 A constrained ``TypeVar`` type can often be used instead of using the
 ``@overload`` decorator.  For example, the definitions of ``concat1``
-and ``concat2`` in this stub file are equivalent:
+and ``concat2`` in this stub file are equivalent::
 
   from typing import TypeVar
 
@@ -1133,7 +1134,7 @@ Another important difference between type variables such as ``AnyStr``
 and using ``@overload`` is that the prior can also be used to define
 constraints for generic class type parameters.  For example, the type
 parameter of the generic class ``typing.IO`` is constrained (only
-``IO[str]``, ``IO[bytes]`` and ``IO[Any]`` are valid):
+``IO[str]``, ``IO[bytes]`` and ``IO[Any]`` are valid)::
 
   class IO(Generic[AnyStr]): ...
 
@@ -1645,7 +1646,7 @@ References
    http://en.wikipedia.org/wiki/Covariance_and_contravariance_%28computer_science%29
 
 .. [typeshed]
-   https://github.com/JukkaL/typeshed/
+   https://github.com/python/typeshed/
 
 .. [pyflakes]
    https://github.com/pyflakes/pyflakes/

prototyping/test_typing.py

@@ -459,6 +459,14 @@ def test_repr(self):
         ctv = Callable[..., str]
         self.assertEqual(repr(ctv), 'typing.Callable[..., str]')
 
+    def test_callable_with_ellipsis(self):
+
+        def foo(a: Callable[..., T]):
+            pass
+
+        self.assertEqual(get_type_hints(foo, globals(), locals()),
+                         {'a': Callable[..., T]})
+
 
 XK = TypeVar('XK', str, bytes)
 XV = TypeVar('XV')
@@ -809,6 +817,14 @@ def foo(a: Callable[['T'], 'T']):
         self.assertEqual(get_type_hints(foo, globals(), locals()),
                          {'a': Callable[[T], T]})
 
+    def test_callable_with_ellipsis_forward(self):
+
+        def foo(a: 'Callable[..., T]'):
+            pass
+
+        self.assertEqual(get_type_hints(foo, globals(), locals()),
+                         {'a': Callable[..., T]})
+
     def test_syntax_error(self):
 
         with self.assertRaises(SyntaxError):

prototyping/typing.py

@@ -128,6 +128,8 @@ def __repr__(self):
 class Final:
     """Mix-in class to prevent instantiation."""
 
+    __slots__ = ()
+
     def __new__(self, *args, **kwds):
         raise TypeError("Cannot instantiate %r" % self.__class__)
 
@@ -204,6 +206,8 @@ class _TypeAlias:
     False.
     """
 
+    __slots__ = ('name', 'type_var', 'impl_type', 'type_checker')
+
     def __new__(cls, *args, **kwds):
         """Constructor.
 
@@ -341,6 +345,8 @@ class Any(Final, metaclass=AnyMeta, _root=True):
     - As a special case, Any and object are subclasses of each other.
     """
 
+    __slots__ = ()
+
 
 class TypeVar(TypingMeta, metaclass=TypingMeta, _root=True):
     """Type variable.
@@ -635,6 +641,8 @@ class Optional(Final, metaclass=OptionalMeta, _root=True):
     Optional[X] is equivalent to Union[X, type(None)].
     """
 
+    __slots__ = ()
+
 
 class TupleMeta(TypingMeta):
     """Metaclass for Tuple."""
@@ -734,6 +742,8 @@ class Tuple(Final, metaclass=TupleMeta, _root=True):
     To specify a variable-length tuple of homogeneous type, use Sequence[T].
     """
 
+    __slots__ = ()
+
 
 class CallableMeta(TypingMeta):
     """Metaclass for Callable."""
@@ -767,7 +777,10 @@ def _has_type_var(self):
     def _eval_type(self, globalns, localns):
         if self.__args__ is None and self.__result__ is None:
             return self
-        args = [_eval_type(t, globalns, localns) for t in self.__args__]
+        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
@@ -837,6 +850,8 @@ class Callable(Final, metaclass=CallableMeta, _root=True):
     such function types are rarely used as callback types.
     """
 
+    __slots__ = ()
+
 
 def _gorg(a):
     """Return the farthest origin of a generic class."""
@@ -1041,6 +1056,8 @@ def lookup_name(mapping: Mapping[X, Y], key: X, default: Y) -> Y:
           # Same body as above.
     """
 
+    __slots__ = ()
+
     def __new__(cls, *args, **kwds):
         next_in_mro = object
         # Look for the last occurrence of Generic or Generic[...].
@@ -1207,6 +1224,7 @@ def _get_protocol_attrs(self):
                         attr != '__abstractmethods__' and
                         attr != '_is_protocol' and
                         attr != '__dict__' and
+                        attr != '__slots__' and
                         attr != '_get_protocol_attrs' and
                         attr != '__parameters__' and
                         attr != '__origin__' and
@@ -1224,6 +1242,8 @@ class _Protocol(metaclass=_ProtocolMeta):
     such as Hashable).
     """
 
+    __slots__ = ()
+
     _is_protocol = True
 
 
@@ -1234,56 +1254,63 @@ class _Protocol(metaclass=_ProtocolMeta):
 
 
 class Iterable(Generic[T_co], extra=collections_abc.Iterable):
-    pass
+    __slots__ = ()
 
 
 class Iterator(Iterable[T_co], extra=collections_abc.Iterator):
-    pass
+    __slots__ = ()
 
 
 class SupportsInt(_Protocol):
+    __slots__ = ()
 
     @abstractmethod
     def __int__(self) -> int:
         pass
 
 
 class SupportsFloat(_Protocol):
+    __slots__ = ()
 
     @abstractmethod
     def __float__(self) -> float:
         pass
 
 
 class SupportsComplex(_Protocol):
+    __slots__ = ()
 
     @abstractmethod
     def __complex__(self) -> complex:
         pass
 
 
 class SupportsBytes(_Protocol):
+    __slots__ = ()
 
     @abstractmethod
     def __bytes__(self) -> bytes:
         pass
 
 
 class SupportsAbs(_Protocol[T]):
+    __slots__ = ()
 
     @abstractmethod
     def __abs__(self) -> T:
         pass
 
 
 class SupportsRound(_Protocol[T]):
+    __slots__ = ()
 
     @abstractmethod
     def __round__(self, ndigits: int = 0) -> T:
         pass
 
 
 class Reversible(_Protocol[T]):
+    __slots__ = ()
 
     @abstractmethod
     def __reversed__(self) -> 'Iterator[T]':
@@ -1294,7 +1321,7 @@ def __reversed__(self) -> 'Iterator[T]':
 
 
 class Container(Generic[T_co], extra=collections_abc.Container):
-    pass
+    __slots__ = ()
 
 
 # Callable was defined earlier.
@@ -1368,6 +1395,7 @@ def __subclasscheck__(self, cls):
 
 
 class FrozenSet(frozenset, AbstractSet[T_co], metaclass=_FrozenSetMeta):
+    __slots__ = ()
 
     def __new__(cls, *args, **kwds):
         if _geqv(cls, FrozenSet):
@@ -1415,6 +1443,7 @@ def __new__(cls, *args, **kwds):
 
 class Generator(Iterator[T_co], Generic[T_co, T_contra, V_co],
                 extra=_G_base):
+    __slots__ = ()
 
     def __new__(cls, *args, **kwds):
         if _geqv(cls, Generator):
@@ -1458,6 +1487,8 @@ class IO(Generic[AnyStr]):
     way to track the other distinctions in the type system.
     """
 
+    __slots__ = ()
+
     @abstractproperty
     def mode(self) -> str:
         pass
@@ -1542,6 +1573,8 @@ def __exit__(self, type, value, traceback) -> None:
 class BinaryIO(IO[bytes]):
     """Typed version of the return of open() in binary mode."""
 
+    __slots__ = ()
+
     @abstractmethod
     def write(self, s: Union[bytes, bytearray]) -> int:
         pass
@@ -1554,6 +1587,8 @@ def __enter__(self) -> 'BinaryIO':
 class TextIO(IO[str]):
     """Typed version of the return of open() in text mode."""
 
+    __slots__ = ()
+
     @abstractproperty
     def buffer(self) -> BinaryIO:
         pass