Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Issue #28556: various style fixes for typing.py (3.5->3.6)

This commit is contained in:
Guido van Rossum 2017-01-22 17:43:56 -08:00
parent 78034c81fb d7adfe129c
commit 0c5f47fbf4
2 changed files with 68 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
Lib/test/test_typing.py
View File

@ -701,7 +701,7 @@ class GenericTests(BaseTestCase):
self.assertFalse(naive_generic_check(Node[str](), Node[int]))
self.assertFalse(naive_generic_check(Node[str](), List))
with self.assertRaises(NotImplementedError):
naive_generic_check([1,2,3], Node[int])
naive_generic_check([1, 2, 3], Node[int])
def naive_list_base_check(obj, tp):
# Check if list conforms to a List subclass
@ -773,7 +773,10 @@ class GenericTests(BaseTestCase):
def test_generic_forward_ref(self):
def foobar(x: List[List['CC']]): ...
class CC: ...
self.assertEqual(get_type_hints(foobar, globals(), locals()), {'x': List[List[CC]]})
self.assertEqual(
get_type_hints(foobar, globals(), locals()),
{'x': List[List[CC]]}
)
T = TypeVar('T')
AT = Tuple[T, ...]
def barfoo(x: AT): ...
@ -1094,6 +1097,7 @@ class GenericTests(BaseTestCase):
with self.assertRaises(Exception):
D[T]
class ClassVarTests(BaseTestCase):
def test_basics(self):
@ -1316,9 +1320,6 @@ class ForwardRefTests(BaseTestCase):
class OverloadTests(BaseTestCase):
def test_overload_exists(self):
from typing import overload
def test_overload_fails(self):
from typing import overload
@ -1381,6 +1382,10 @@ if ASYNCIO:
exec(ASYNCIO_TESTS)
except ImportError:
ASYNCIO = False
else:
# fake names for the sake of static analysis
asyncio = None
AwaitableWrapper = AsyncIteratorWrapper = object
PY36 = sys.version_info[:2] >= (3, 6)
@ -1408,9 +1413,14 @@ class CoolEmployeeWithDefault(NamedTuple):
if PY36:
exec(PY36_TESTS)
else:
# fake names for the sake of static analysis
ann_module = ann_module2 = ann_module3 = None
A = B = CSub = G = CoolEmployee = CoolEmployeeWithDefault = object
gth = get_type_hints
class GetTypeHintTests(BaseTestCase):
def test_get_type_hints_from_various_objects(self):
# For invalid objects should fail with TypeError (not AttributeError etc).
@ -1423,7 +1433,8 @@ class GetTypeHintTests(BaseTestCase):
@skipUnless(PY36, 'Python 3.6 required')
def test_get_type_hints_modules(self):
self.assertEqual(gth(ann_module), {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str})
ann_module_type_hints = {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str}
self.assertEqual(gth(ann_module), ann_module_type_hints)
self.assertEqual(gth(ann_module2), {})
self.assertEqual(gth(ann_module3), {})
@ -1926,7 +1937,7 @@ class TypeTests(BaseTestCase):
def new_user(user_class: Type[User]) -> User:
return user_class()
joe = new_user(BasicUser)
new_user(BasicUser)
def test_type_typevar(self):
@ -1939,7 +1950,7 @@ class TypeTests(BaseTestCase):
def new_user(user_class: Type[U]) -> U:
return user_class()
joe = new_user(BasicUser)
new_user(BasicUser)
def test_type_optional(self):
A = Optional[Type[BaseException]]
@ -2102,8 +2113,8 @@ class RETests(BaseTestCase):
self.assertIsInstance(mat, Match)
# these should just work
p = Pattern[Union[str, bytes]]
m = Match[Union[bytes, str]]
Pattern[Union[str, bytes]]
Match[Union[bytes, str]]
def test_errors(self):
with self.assertRaises(TypeError):

73
Lib/typing.py
View File

@ -97,8 +97,8 @@ def _qualname(x):
def _trim_name(nm):
if nm.startswith('_') and nm not in ('_TypeAlias',
'_ForwardRef', '_TypingBase', '_FinalTypingBase'):
whitelist = ('_TypeAlias', '_ForwardRef', '_TypingBase', '_FinalTypingBase')
if nm.startswith('_') and nm not in whitelist:
nm = nm[1:]
return nm
@ -355,13 +355,17 @@ def _type_check(arg, msg):
return type(None)
if isinstance(arg, str):
arg = _ForwardRef(arg)
if (isinstance(arg, _TypingBase) and type(arg).__name__ == '_ClassVar' or
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)):
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
@ -455,7 +459,7 @@ class TypeVar(_TypingBase, _root=True):
'__covariant__', '__contravariant__')
def __init__(self, name, *constraints, bound=None,
covariant=False, contravariant=False):
covariant=False, contravariant=False):
super().__init__(name, *constraints, bound=bound,
covariant=covariant, contravariant=contravariant)
self.__name__ = name
@ -563,7 +567,7 @@ def _subs_tree(cls, tvars=None, args=None):
# ... then continue replacing down the origin chain.
for ocls in orig_chain:
new_tree_args = []
for i, arg in enumerate(ocls.__args__):
for arg in ocls.__args__:
new_tree_args.append(_replace_arg(arg, ocls.__parameters__, tree_args))
tree_args = new_tree_args
return tree_args
@ -631,6 +635,7 @@ def _tp_cache(func):
cached = functools.lru_cache()(func)
_cleanups.append(cached.cache_clear)
@functools.wraps(func)
def inner(*args, **kwds):
try:
@ -840,7 +845,7 @@ def _next_in_mro(cls):
# Look for the last occurrence of Generic or Generic[...].
for i, c in enumerate(cls.__mro__[:-1]):
if isinstance(c, GenericMeta) and _gorg(c) is Generic:
next_in_mro = cls.__mro__[i+1]
next_in_mro = cls.__mro__[i + 1]
return next_in_mro
@ -849,8 +854,10 @@ def _valid_for_check(cls):
if cls is Generic:
raise TypeError("Class %r cannot be used with class "
"or instance checks" % cls)
if (cls.__origin__ is not None and
sys._getframe(3).f_globals['__name__'] not in ['abc', 'functools']):
if (
cls.__origin__ is not None and
sys._getframe(3).f_globals['__name__'] not in ['abc', 'functools']
):
raise TypeError("Parameterized generics cannot be used with class "
"or instance checks")
@ -986,9 +993,12 @@ class GenericMeta(TypingMeta, abc.ABCMeta):
# This allows unparameterized generic collections to be used
# with issubclass() and isinstance() in the same way as their
# collections.abc counterparts (e.g., isinstance([], Iterable)).
if ('__subclasshook__' not in namespace and extra # allow overriding
or hasattr(self.__subclasshook__, '__name__') and
self.__subclasshook__.__name__ == '__extrahook__'):
if (
# allow overriding
'__subclasshook__' not in namespace and extra 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
@ -1192,13 +1202,13 @@ class TupleMeta(GenericMeta):
return super().__getitem__(parameters)
def __instancecheck__(self, obj):
if self.__args__ == None:
if self.__args__ is None:
return isinstance(obj, tuple)
raise TypeError("Parameterized Tuple cannot be used "
"with isinstance().")
def __subclasscheck__(self, cls):
if self.__args__ == None:
if self.__args__ is None:
return issubclass(cls, tuple)
raise TypeError("Parameterized Tuple cannot be used "
"with issubclass().")
@ -1252,7 +1262,7 @@ class CallableMeta(GenericMeta):
with hashable arguments to improve speed.
"""
if self.__origin__ is not None or not _geqv(self, Callable):
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 "
@ -1280,7 +1290,7 @@ class CallableMeta(GenericMeta):
return super().__getitem__(parameters)
class Callable(extra=collections_abc.Callable, metaclass = CallableMeta):
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
@ -1442,10 +1452,12 @@ def get_type_hints(obj, globalns=None, localns=None):
hints = getattr(obj, '__annotations__', None)
if hints is None:
# Return empty annotations for something that _could_ have them.
if (isinstance(obj, types.FunctionType) or
if (
isinstance(obj, types.FunctionType) or
isinstance(obj, types.BuiltinFunctionType) or
isinstance(obj, types.MethodType) or
isinstance(obj, types.ModuleType)):
isinstance(obj, types.ModuleType)
):
return {}
else:
raise TypeError('{!r} is not a module, class, method, '
@ -1485,7 +1497,7 @@ def no_type_check(arg):
no_type_check(obj)
try:
arg.__no_type_check__ = True
except TypeError: # built-in classes
except TypeError: # built-in classes
pass
return arg
@ -1771,14 +1783,15 @@ else:
class MutableMapping(Mapping[KT, VT], extra=collections_abc.MutableMapping):
__slots__ = ()
if hasattr(collections_abc, 'Reversible'):
if hasattr(collections_abc, 'Collection'):
class Sequence(Reversible[T_co], Collection[T_co],
extra=collections_abc.Sequence):
extra=collections_abc.Sequence):
__slots__ = ()
else:
class Sequence(Sized, Reversible[T_co], Container[T_co],
extra=collections_abc.Sequence):
extra=collections_abc.Sequence):
__slots__ = ()
else:
class Sequence(Sized, Iterable[T_co], Container[T_co],
@ -1804,6 +1817,7 @@ class List(list, MutableSequence[T], extra=list):
"use list() instead")
return _generic_new(list, cls, *args, **kwds)
class Deque(collections.deque, MutableSequence[T], extra=collections.deque):
__slots__ = ()
@ -1814,6 +1828,7 @@ class Deque(collections.deque, MutableSequence[T], extra=collections.deque):
"use deque() instead")
return _generic_new(collections.deque, cls, *args, **kwds)
class Set(set, MutableSet[T], extra=set):
__slots__ = ()
@ -1871,6 +1886,7 @@ class Dict(dict, MutableMapping[KT, VT], extra=dict):
"use dict() instead")
return _generic_new(dict, cls, *args, **kwds)
class DefaultDict(collections.defaultdict, MutableMapping[KT, VT],
extra=collections.defaultdict):
@ -1882,6 +1898,7 @@ class DefaultDict(collections.defaultdict, MutableMapping[KT, VT],
"use collections.defaultdict() instead")
return _generic_new(collections.defaultdict, cls, *args, **kwds)
# Determine what base class to use for Generator.
if hasattr(collections_abc, 'Generator'):
# Sufficiently recent versions of 3.5 have a Generator ABC.
@ -1901,6 +1918,7 @@ class Generator(Iterator[T_co], Generic[T_co, T_contra, V_co],
"create a subclass instead")
return _generic_new(_G_base, cls, *args, **kwds)
if hasattr(collections_abc, 'AsyncGenerator'):
class AsyncGenerator(AsyncIterator[T_co], Generic[T_co, T_contra],
extra=collections_abc.AsyncGenerator):
@ -1976,14 +1994,15 @@ class NamedTupleMeta(type):
defaults.append(default_value)
defaults_dict[field_name] = default_value
elif defaults:
raise TypeError("Non-default namedtuple field {field_name} cannot follow default"
" field(s) {default_names}"
raise TypeError("Non-default namedtuple field {field_name} cannot "
"follow default field(s) {default_names}"
.format(field_name=field_name,
default_names=', '.join(defaults_dict.keys())))
nm_tpl.__new__.__defaults__ = tuple(defaults)
nm_tpl._field_defaults = defaults_dict
return nm_tpl
class NamedTuple(metaclass=NamedTupleMeta):
"""Typed version of namedtuple.
@ -2207,6 +2226,7 @@ class io:
TextIO = TextIO
BinaryIO = BinaryIO
io.__name__ = __name__ + '.io'
sys.modules[io.__name__] = io
@ -2224,5 +2244,6 @@ class re:
Pattern = Pattern
Match = Match
re.__name__ = __name__ + '.re'
sys.modules[re.__name__] = re