Silence pep8.

Guido van Rossum · Guido van Rossum · commit e20621b0760a · 2015-03-20T14:29:08.000-07:00
diff --git a/prototyping/test_typing.py b/prototyping/test_typing.py
@@ -625,6 +625,7 @@ class X(SimpleMapping[A, B]):
     def test_errors(self):
         with self.assertRaises(TypeError):
             B = SimpleMapping[XK, Any]
+
             class C(Generic[B]):
                 pass
 
diff --git a/prototyping/typing.py b/prototyping/typing.py
@@ -1333,10 +1333,10 @@ def __init__(self, name, type_var, impl_type, type_checker):
         assert isinstance(type_var, type), repr(type_var)
         assert isinstance(impl_type, type), repr(impl_type)
         assert not isinstance(impl_type, TypingMeta), repr(impl_type)
-        self.name = name  # The name, e.g. 'Pattern'
-        self.type_var = type_var  # The type parameter, e.g. 'AnyStr', or the specific type, e.g. 'str'
-        self.impl_type = impl_type  # The implementation type
-        self.type_checker = type_checker  # Function that takes an impl_type instance and returns a value that should be a type_var instance
+        self.name = name
+        self.type_var = type_var
+        self.impl_type = impl_type
+        self.type_checker = type_checker
 
     def __repr__(self):
         return "%s[%s]" % (self.name, _type_repr(self.type_var))
@@ -1346,22 +1346,28 @@ def __getitem__(self, parameter):
         if not isinstance(self.type_var, TypeVar):
             raise TypeError("%s cannot be further parameterized." % self)
         if not issubclass(parameter, self.type_var):
-            raise TypeError("%s is not a valid substitution for %s." % (parameter, self.type_var))
-        return self.__class__(self.name, parameter, self.impl_type, self.type_checker)
+            raise TypeError("%s is not a valid substitution for %s." %
+                            (parameter, self.type_var))
+        return self.__class__(self.name, parameter,
+                              self.impl_type, self.type_checker)
 
     def __instancecheck__(self, obj):
-        return isinstance(obj, self.impl_type) and isinstance(self.type_checker(obj), self.type_var)
+        return (isinstance(obj, self.impl_type) and
+                isinstance(self.type_checker(obj), self.type_var))
 
     def __subclasscheck__(self, cls):
         if isinstance(cls, _TypeAlias):
             # Covariance.  For now, we compare by name.
-            return (cls.name == self.name and issubclass(cls.type_var, self.type_var))
+            return (cls.name == self.name and
+                    issubclass(cls.type_var, self.type_var))
         else:
             # Note that this is too lenient, because the
             # implementation type doesn't carry information about
             # whether it is about bytes or str (for example).
             return issubclass(cls, self.impl_type)
 
 
-Pattern = _TypeAlias('Pattern', AnyStr, type(re.compile('')), lambda p: p.pattern)
-Match =  _TypeAlias('Match', AnyStr, type(re.match('', '')), lambda m: m.re.pattern)
+Pattern = _TypeAlias('Pattern', AnyStr, type(re.compile('')),
+                     lambda p: p.pattern)
+Match = _TypeAlias('Match', AnyStr, type(re.match('', '')),
+                   lambda m: m.re.pattern)
