Fix lint (that was not run for looong time)

Author: Ivan Levkivskyi

.flake8-tests

@@ -8,7 +8,7 @@
 [flake8]
 # fake builtins for python2/*
 builtins = basestring, unicode
-max-line-length = 90
+max-line-length = 100
 ignore =
   # temporary ignores until we sort it out
   E306,
@@ -18,6 +18,8 @@ ignore =
   # irrelevant plugins
   B3,
   DW12
+  # consistency with mypy
+  W504
 exclude =
   # This config is NOT for the main module.
   setup.py

python2/test_typing.py

@@ -1827,7 +1827,6 @@ def __new__(cls, arg):
         self.assertEqual(c.from_c, 'c')
 
 
-
 class ClassVarTests(BaseTestCase):
 
     def test_basics(self):
@@ -2308,8 +2307,8 @@ def __len__(self):
         self.assertIsSubclass(MMB[str, str], typing.Mapping)
         self.assertIsSubclass(MMC, MMA)
 
-        class I(typing.Iterable): pass
-        self.assertNotIsSubclass(list, I)
+        class It(typing.Iterable): pass
+        self.assertNotIsSubclass(list, It)
 
         class G(typing.Generator[int, int, int]): pass
         def g(): yield 0
@@ -2366,8 +2365,8 @@ class S(collections.MutableSequence): pass
         self.assertIsSubclass(S, typing.MutableSequence)
         self.assertIsSubclass(S, typing.Iterable)
 
-        class I(collections.Iterable): pass
-        self.assertIsSubclass(I, typing.Iterable)
+        class It(collections.Iterable): pass
+        self.assertIsSubclass(It, typing.Iterable)
 
         class A(collections.Mapping): pass
         class B: pass
@@ -2659,7 +2658,7 @@ def test_respect_no_type_check(self):
         class NoTpCheck(object):
             class Inn(object):
                 def __init__(self, x):
-                    # type: (this is not actually a type) -> None
+                    # type: (this is not actually a type) -> None  # noqa
                     pass
         self.assertTrue(NoTpCheck.__no_type_check__)
         self.assertTrue(NoTpCheck.Inn.__init__.__no_type_check__)

python2/typing.py

@@ -1780,7 +1780,8 @@ def __init__(cls, *args, **kwargs):
         if cls._is_protocol:
             for base in cls.__mro__[1:]:
                 if not (base in (object, Generic) or
-                        base.__module__ == '_abcoll' and base.__name__ in _PROTO_WHITELIST or
+                        base.__module__ == '_abcoll' and
+                        base.__name__ in _PROTO_WHITELIST or
                         isinstance(base, TypingMeta) and base._is_protocol or
                         isinstance(base, GenericMeta) and base.__origin__ is Generic):
                     raise TypeError('Protocols can only inherit from other protocols,'

src/mod_generics_cache.py

@@ -12,11 +12,9 @@
 
     T = TypeVar('T')
 
-
     class A(Generic[T]):
         some_b: 'B'
 
-
     class B(Generic[T]):
         class A(Generic[T]):
             pass
@@ -35,13 +33,11 @@ class A(Generic[T]):
 
     T = TypeVar('T')
 
-
     class A(Generic[T]):
         __annotations__ = dict(
             some_b='B'
         )
 
-
     class B(Generic[T]):
         class A(Generic[T]):
             pass

src/test_typing.py

@@ -12,7 +12,7 @@
 from typing import TypeVar, AnyStr
 from typing import T, KT, VT  # Not in __all__.
 from typing import Union, Optional
-from typing import Tuple, List, MutableMapping
+from typing import Tuple, List, MutableMapping, Iterator
 from typing import Callable
 from typing import Generic, ClassVar, GenericMeta
 from typing import cast
@@ -1539,7 +1539,7 @@ def test_syntax_error(self):
 
     def test_delayed_syntax_error(self):
 
-        def foo(a: 'Node[T'):
+        def foo(a: 'Node[T'):  # noqa
             pass
 
         with self.assertRaises(SyntaxError):
@@ -1555,7 +1555,7 @@ def foo(a: Tuple['42']):
 
     def test_name_error(self):
 
-        def foo(a: 'Noode[T]'):
+        def foo(a: 'Noode[T]'):  # noqa
             pass
 
         with self.assertRaises(NameError):
@@ -1564,7 +1564,7 @@ def foo(a: 'Noode[T]'):
     def test_no_type_check(self):
 
         @no_type_check
-        def foo(a: 'whatevers') -> {}:
+        def foo(a: 'int') -> {}:
             pass
 
         th = get_type_hints(foo)
@@ -1574,7 +1574,7 @@ def test_no_type_check_class(self):
 
         @no_type_check
         class C:
-            def foo(a: 'whatevers') -> {}:
+            def foo(a: 'int') -> {}:
                 pass
 
         cth = get_type_hints(C.foo)
@@ -1600,12 +1600,12 @@ def magic_decorator(deco):
         self.assertEqual(magic_decorator.__name__, 'magic_decorator')
 
         @magic_decorator
-        def foo(a: 'whatevers') -> {}:
+        def foo(a: 'int') -> {}:
             pass
 
         @magic_decorator
         class C:
-            def foo(a: 'whatevers') -> {}:
+            def foo(a: 'int') -> {}:
                 pass
 
         self.assertEqual(foo.__name__, 'foo')
@@ -1764,7 +1764,7 @@ async def g_with(am: AsyncContextManager[int]):
     # fake names for the sake of static analysis
     ann_module = ann_module2 = ann_module3 = None
     A = B = CSub = G = CoolEmployee = CoolEmployeeWithDefault = object
-    XMeth = XRepr = NoneAndForward = object
+    XMeth = XRepr = NoneAndForward = HasForeignBaseClass = object
 
 gth = get_type_hints
 
@@ -1826,7 +1826,7 @@ def test_respect_no_type_check(self):
         @no_type_check
         class NoTpCheck:
             class Inn:
-                def __init__(self, x: 'not a type'): ...
+                def __init__(self, x: 'not a type'): ...  # noqa
         self.assertTrue(NoTpCheck.__no_type_check__)
         self.assertTrue(NoTpCheck.Inn.__init__.__no_type_check__)
         self.assertEqual(gth(ann_module2.NTC.meth), {})
@@ -2233,8 +2233,8 @@ def __len__(self):
         self.assertIsSubclass(MMB[str, str], typing.Mapping)
         self.assertIsSubclass(MMC, MMA)
 
-        class I(typing.Iterable): ...
-        self.assertNotIsSubclass(list, I)
+        class It(typing.Iterable): ...
+        self.assertNotIsSubclass(list, It)
 
         class G(typing.Generator[int, int, int]): ...
         def g(): yield 0
@@ -2316,8 +2316,8 @@ class S(collections_abc.MutableSequence): ...
         self.assertIsSubclass(S, typing.MutableSequence)
         self.assertIsSubclass(S, typing.Iterable)
 
-        class I(collections_abc.Iterable): ...
-        self.assertIsSubclass(I, typing.Iterable)
+        class It(collections_abc.Iterable): ...
+        self.assertIsSubclass(It, typing.Iterable)
 
         class A(collections_abc.Mapping, metaclass=abc.ABCMeta): ...
         class B: ...

tox.ini

@@ -17,7 +17,9 @@ ignore =
   B3,
   DW12,
   # code is sometimes better without this
-  E129
+  E129,
+  # consistency with mypy
+  W504
 exclude =
   # tests have more relaxed formatting rules
   # and its own specific config in .flake8-tests

typing_extensions/src_py2/test_typing_extensions.py

@@ -5,7 +5,7 @@
 import subprocess
 from unittest import TestCase, main
 
-from typing_extensions import Annotated, NoReturn, ClassVar, Final, IntVar, Literal, TypedDict
+from typing_extensions import Annotated, NoReturn, ClassVar, IntVar
 from typing_extensions import ContextManager, Counter, Deque, DefaultDict
 from typing_extensions import NewType, overload
 from typing import Dict, List
@@ -118,15 +118,15 @@ def test_no_isinstance(self):
 
 class IntVarTests(BaseTestCase):
     def test_valid(self):
-        T_ints = IntVar("T_ints")
+        T_ints = IntVar("T_ints")  # noqa
 
     def test_invalid(self):
         with self.assertRaises(TypeError):
             T_ints = IntVar("T_ints", int)
         with self.assertRaises(TypeError):
             T_ints = IntVar("T_ints", bound=int)
         with self.assertRaises(TypeError):
-            T_ints = IntVar("T_ints", covariant=True)
+            T_ints = IntVar("T_ints", covariant=True)  # noqa
 
 
 class CollectionsAbcTests(BaseTestCase):
@@ -332,8 +332,8 @@ def test_hash_eq(self):
 
     def test_cannot_subclass(self):
         with self.assertRaises(TypeError):
-           class C(Annotated):
-               pass
+            class C(Annotated):
+                pass
 
     def test_cannot_check_instance(self):
         with self.assertRaises(TypeError):
@@ -364,9 +364,9 @@ def test_subst(self):
         with self.assertRaises(TypeError):
             D[int]
 
-        I = Annotated[int, dec]
+        It = Annotated[int, dec]
         with self.assertRaises(TypeError):
-            I[None]
+            It[None]
 
         LI = L[int]
         with self.assertRaises(TypeError):
@@ -376,6 +376,7 @@ 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):

typing_extensions/src_py2/typing_extensions.py

@@ -1,7 +1,7 @@
 import abc
-import sys
 import typing
-from typing import (
+from typing import (  # noqa
+    # These are imported for re-export.
     ClassVar, Type, Generic, Callable, GenericMeta, TypingMeta,
     Counter, DefaultDict, Deque, TypeVar, Tuple, Final, final,
     NewType, overload, Text, TYPE_CHECKING, Literal, TypedDict, Protocol,

typing_extensions/src_py3/test_typing_extensions.py

@@ -9,7 +9,7 @@
 from unittest import TestCase, main, skipUnless
 from typing import TypeVar, Optional
 from typing import T, KT, VT  # Not in __all__.
-from typing import Tuple, List, Dict
+from typing import Tuple, List, Dict, Iterator
 from typing import Generic
 from typing import no_type_check
 from typing_extensions import NoReturn, ClassVar, Final, IntVar, Literal, Type, NewType, TypedDict
@@ -34,13 +34,13 @@
 
 OLD_GENERICS = False
 try:
-    from typing import _type_vars, _next_in_mro, _type_check
+    from typing import _type_vars, _next_in_mro, _type_check  # noqa
 except ImportError:
     OLD_GENERICS = True
 
 # We assume Python versions *below* 3.5.0 will have the most
 # up-to-date version of the typing module installed. Since
-# the typing module isn't a part of the standard library in older 
+# the typing module isn't a part of the standard library in older
 # versions of Python, those users are likely to have a reasonably
 # modern version of `typing` installed from PyPi.
 TYPING_LATEST = sys.version_info[:3] < (3, 5, 0)
@@ -73,6 +73,7 @@
 # Protocols are hard to backport to the original version of typing 3.5.0
 HAVE_PROTOCOLS = sys.version_info[:3] != (3, 5, 0)
 
+
 class BaseTestCase(TestCase):
     def assertIsSubclass(self, cls, class_or_tuple, msg=None):
         if not issubclass(cls, class_or_tuple):
@@ -226,15 +227,15 @@ def test_no_isinstance(self):
 
 class IntVarTests(BaseTestCase):
     def test_valid(self):
-        T_ints = IntVar("T_ints")
+        T_ints = IntVar("T_ints")  # noqa
 
     def test_invalid(self):
         with self.assertRaises(TypeError):
             T_ints = IntVar("T_ints", int)
         with self.assertRaises(TypeError):
             T_ints = IntVar("T_ints", bound=int)
         with self.assertRaises(TypeError):
-            T_ints = IntVar("T_ints", covariant=True)
+            T_ints = IntVar("T_ints", covariant=True)  # noqa
 
 
 class LiteralTests(BaseTestCase):
@@ -475,7 +476,7 @@ def test_respect_no_type_check(self):
         @no_type_check
         class NoTpCheck:
             class Inn:
-                def __init__(self, x: 'not a type'): ...
+                def __init__(self, x: 'not a type'): ...  # noqa
         self.assertTrue(NoTpCheck.__no_type_check__)
         self.assertTrue(NoTpCheck.Inn.__init__.__no_type_check__)
         self.assertEqual(gth(ann_module2.NTC.meth), {})
@@ -502,6 +503,7 @@ def test_final_forward_ref(self):
         self.assertNotEqual(gth(Loop, globals())['attr'], Final[int])
         self.assertNotEqual(gth(Loop, globals())['attr'], Final)
 
+
 class CollectionsAbcTests(BaseTestCase):
 
     def test_isinstance_collections(self):
@@ -1609,8 +1611,8 @@ def test_hash_eq(self):
 
     def test_cannot_subclass(self):
         with self.assertRaisesRegex(TypeError, "Cannot subclass .*Annotated"):
-           class C(Annotated):
-               pass
+            class C(Annotated):
+                pass
 
     def test_cannot_check_instance(self):
         with self.assertRaises(TypeError):
@@ -1620,7 +1622,6 @@ def test_cannot_check_subclass(self):
         with self.assertRaises(TypeError):
             issubclass(int, Annotated[int, "positive"])
 
-
     @skipUnless(PEP_560, "pickle support was added with PEP 560")
     def test_pickle(self):
         samples = [typing.Any, typing.Union[int, str],
@@ -1673,9 +1674,9 @@ def test_subst(self):
         with self.assertRaises(TypeError):
             D[int]
 
-        I = Annotated[int, dec]
+        It = Annotated[int, dec]
         with self.assertRaises(TypeError):
-            I[None]
+            It[None]
 
         LI = L[int]
         with self.assertRaises(TypeError):
@@ -1747,7 +1748,6 @@ def __iand__(self, other: Const["MySet[T]"]) -> "MySet[T]":
         )
 
 
-
 class AllTests(BaseTestCase):
 
     def test_typing_extensions_includes_standard(self):
@@ -1782,7 +1782,6 @@ def test_typing_extensions_includes_standard(self):
             self.assertIn('Protocol', a)
             self.assertIn('runtime', a)
 
-
     def test_typing_extensions_defers_when_possible(self):
         exclude = {'overload', 'Text', 'TYPE_CHECKING', 'Final', 'get_type_hints'}
         for item in typing_extensions.__all__:
@@ -1804,4 +1803,4 @@ def test_typing_extensions_compiles_with_opt(self):
 
 
 if __name__ == '__main__':
-   main()
+    main()