Fix lint issues. Preexisting tests pass.

davidfstr · davidfstr · commit b470abafef5b · 2016-10-29T18:25:34.000-07:00
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -198,20 +198,20 @@ def check_typeddict_call(self, callee: TypedDictType,
             kwargs = args[0]
             item_name_exprs = [item[0] for item in kwargs.items]
             item_args = [item[1] for item in kwargs.items]
-            
+
             item_names = []  # List[str]
             for item_name_expr in item_name_exprs:
                 if not isinstance(item_name_expr, StrExpr):
                     self.chk.fail(messages.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL, item_name_expr)
                     return AnyType()
                 item_names.append(item_name_expr.value)
-            
+
             return self.check_typeddict_call_with_kwargs(
                 callee, OrderedDict(zip(item_names, item_args)), context)
         else:
             self.chk.fail(messages.INVALID_TYPEDDICT_ARGS, context)
             return AnyType()
-    
+
     def check_typeddict_call_with_kwargs(self, callee: TypedDictType,
                                          kwargs: 'OrderedDict[str, Expression]',
                                          context: Context) -> Type:
@@ -226,20 +226,21 @@ def check_typeddict_call_with_kwargs(self, callee: TypedDictType,
                     kwargs.keys() - callee.items.keys()),
                 context)
             return AnyType()
-        
+
         items = OrderedDict()  # type: OrderedDict[str, Type]
         for (item_name, item_expected_type) in callee.items.items():
             item_value = kwargs[item_name]
-            
+
             item_actual_type = self.chk.check_simple_assignment(
                 lvalue_type=item_expected_type, rvalue=item_value, context=item_value,
                 msg=messages.INCOMPATIBLE_TYPES,
                 lvalue_name='TypedDict item',
                 rvalue_name='expression')
             items[item_name] = item_actual_type
-        
+
         mapping_value_type = join.join_type_list(list(items.values()))
-        fallback = self.chk.named_generic_type('typing.Mapping', [self.chk.str_type(), mapping_value_type])
+        fallback = self.chk.named_generic_type('typing.Mapping',
+                                               [self.chk.str_type(), mapping_value_type])
         return TypedDictType(items, fallback)
 
     # Types and methods that can be used to infer partial types.
diff --git a/mypy/constraints.py b/mypy/constraints.py
@@ -341,7 +341,7 @@ def visit_tuple_type(self, template: TupleType) -> List[Constraint]:
             return self.infer_against_any(template.items)
         else:
             return []
-    
+
     def visit_typeddict_type(self, template: TypedDictType) -> List[Constraint]:
         actual = self.actual
         # TODO: Is it correct to require identical keys here?
diff --git a/mypy/erasetype.py b/mypy/erasetype.py
@@ -2,7 +2,7 @@
 
 from mypy.types import (
     Type, TypeVisitor, UnboundType, ErrorType, AnyType, Void, NoneTyp, TypeVarId,
-    Instance, TypeVarType, CallableType, TupleType, TypedDictType, UnionType, Overloaded, 
+    Instance, TypeVarType, CallableType, TupleType, TypedDictType, UnionType, Overloaded,
     ErasedType, PartialType, DeletedType, TypeTranslator, TypeList, UninhabitedType, TypeType
 )
 from mypy import experiments
@@ -77,7 +77,7 @@ def visit_overloaded(self, t: Overloaded) -> Type:
 
     def visit_tuple_type(self, t: TupleType) -> Type:
         return t.fallback.accept(self)
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         return t.fallback.accept(self)
 
diff --git a/mypy/expandtype.py b/mypy/expandtype.py
@@ -2,7 +2,7 @@
 
 from mypy.types import (
     Type, Instance, CallableType, TypeVisitor, UnboundType, ErrorType, AnyType,
-    Void, NoneTyp, TypeVarType, Overloaded, TupleType, TypedDictType, UnionType, 
+    Void, NoneTyp, TypeVarType, Overloaded, TupleType, TypedDictType, UnionType,
     ErasedType, TypeList, PartialType, DeletedType, UninhabitedType, TypeType, TypeVarId
 )
 
@@ -92,7 +92,7 @@ def visit_overloaded(self, t: Overloaded) -> Type:
 
     def visit_tuple_type(self, t: TupleType) -> Type:
         return t.copy_modified(items=self.expand_types(t.items))
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         return t.copy_modified(item_types=self.expand_types(t.items.values()))
 
diff --git a/mypy/fixup.py b/mypy/fixup.py
@@ -195,7 +195,7 @@ def visit_tuple_type(self, tt: TupleType) -> None:
                 it.accept(self)
         if tt.fallback is not None:
             tt.fallback.accept(self)
-    
+
     def visit_typeddict_type(self, tdt: TypedDictType) -> None:
         if tdt.items:
             for it in tdt.items.values():
diff --git a/mypy/indirection.py b/mypy/indirection.py
@@ -86,7 +86,7 @@ def visit_overloaded(self, t: types.Overloaded) -> Set[str]:
 
     def visit_tuple_type(self, t: types.TupleType) -> Set[str]:
         return self._visit(*t.items) | self._visit(t.fallback)
-    
+
     def visit_typeddict_type(self, t: types.TypedDictType) -> Set[str]:
         return self._visit(*t.items.values()) | self._visit(t.fallback)
 
diff --git a/mypy/join.py b/mypy/join.py
@@ -240,7 +240,7 @@ def visit_tuple_type(self, t: TupleType) -> Type:
             return TupleType(items, fallback)
         else:
             return self.default(self.s)
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         if isinstance(self.s, TypedDictType):
             items = OrderedDict([
diff --git a/mypy/meet.py b/mypy/meet.py
@@ -246,7 +246,7 @@ def visit_tuple_type(self, t: TupleType) -> Type:
             return TupleType(items, t.fallback)
         else:
             return self.default(self.s)
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         if isinstance(self.s, TypedDictType):
             items = OrderedDict([
@@ -275,7 +275,7 @@ def visit_type_type(self, t: TypeType) -> Type:
 
     def meet(self, s: Type, t: Type) -> Type:
         return meet_types(s, t)
-    
+
     def meet_maybe_one(self, s: Optional[Type], t: Optional[Type]) -> Type:
         if s is None:
             assert t is not None
diff --git a/mypy/messages.py b/mypy/messages.py
@@ -71,8 +71,10 @@
 KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPE = \
     'Keyword argument only valid with "str" key type in call to "dict"'
 ALL_MUST_BE_SEQ_STR = 'Type of __all__ must be {}, not {}'
-INVALID_TYPEDDICT_ARGS = 'Expected keyword arguments or dictionary literal in TypedDict constructor'
-TYPEDDICT_KEY_MUST_BE_STRING_LITERAL = 'Expected key in TypedDict constructor to be string literal'
+INVALID_TYPEDDICT_ARGS = \
+    'Expected keyword arguments or dictionary literal in TypedDict constructor'
+TYPEDDICT_KEY_MUST_BE_STRING_LITERAL = \
+    'Expected key in TypedDict constructor to be string literal'
 
 
 class MessageBuilder:
diff --git a/mypy/nodes.py b/mypy/nodes.py
@@ -2036,7 +2036,8 @@ def serialize(self) -> JsonDict:
                 'bases': [b.serialize() for b in self.bases],
                 '_promote': None if self._promote is None else self._promote.serialize(),
                 'tuple_type': None if self.tuple_type is None else self.tuple_type.serialize(),
-                'typeddict_type': None if self.typeddict_type is None else self.typeddict_type.serialize(),
+                'typeddict_type':
+                    None if self.typeddict_type is None else self.typeddict_type.serialize(),
                 'flags': get_flags(self, TypeInfo.FLAGS),
                 }
         return data
diff --git a/mypy/sametypes.py b/mypy/sametypes.py
@@ -1,8 +1,8 @@
 from typing import Sequence
 
 from mypy.types import (
-    Type, UnboundType, ErrorType, AnyType, NoneTyp, Void, TupleType, TypedDictType, 
-    UnionType, CallableType, TypeVarType, Instance, TypeVisitor, ErasedType, 
+    Type, UnboundType, ErrorType, AnyType, NoneTyp, Void, TupleType, TypedDictType,
+    UnionType, CallableType, TypeVarType, Instance, TypeVisitor, ErasedType,
     TypeList, Overloaded, PartialType, DeletedType, UninhabitedType, TypeType
 )
 
@@ -110,7 +110,7 @@ def visit_tuple_type(self, left: TupleType) -> bool:
             return is_same_types(left.items, self.right.items)
         else:
             return False
-    
+
     def visit_typeddict_type(self, left: TypedDictType) -> bool:
         if isinstance(self.right, TypedDictType):
             if left.items.keys() != self.right.items.keys():
diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -914,7 +914,7 @@ def object_type(self) -> Instance:
 
     def str_type(self) -> Instance:
         return self.named_type('__builtins__.str')
-    
+
     def class_type(self, info: TypeInfo) -> Type:
         # Construct a function type whose fallback is cls.
         from mypy import checkmember  # To avoid import cycle.
@@ -1931,7 +1931,8 @@ def fail_typeddict_arg(self, message: str,
     def build_typeddict_typeinfo(self, name: str, items: List[str],
                                  types: List[Type]) -> TypeInfo:
         mapping_value_type = join.join_type_list(types)
-        fallback = (self.named_type_or_none('typing.Mapping', [self.str_type(), mapping_value_type])
+        fallback = (self.named_type_or_none('typing.Mapping',
+                                            [self.str_type(), mapping_value_type])
                     or self.object_type())
 
         info = self.basic_new_typeinfo(name, fallback)
diff --git a/mypy/subtypes.py b/mypy/subtypes.py
@@ -185,7 +185,7 @@ def visit_tuple_type(self, left: TupleType) -> bool:
             return True
         else:
             return False
-    
+
     def visit_typeddict_type(self, left: TypedDictType) -> bool:
         right = self.right
         if isinstance(right, Instance):
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
@@ -223,7 +223,7 @@ def visit_tuple_type(self, t: TupleType) -> Type:
             return AnyType()
         fallback = t.fallback if t.fallback else self.builtin_type('builtins.tuple', [AnyType()])
         return TupleType(self.anal_array(t.items), fallback, t.line)
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         items = OrderedDict([
             (item_name, item_type.accept(self))
@@ -391,7 +391,7 @@ def visit_callable_type(self, t: CallableType) -> None:
     def visit_tuple_type(self, t: TupleType) -> None:
         for item in t.items:
             item.accept(self)
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> None:
         for item_type in t.items.values():
             item_type.accept(self)
diff --git a/mypy/types.py b/mypy/types.py
@@ -812,10 +812,10 @@ def slice(self, begin: int, stride: int, end: int) -> 'TupleType':
 
 class TypedDictType(Type):
     """The type of a TypedDict instance. TypedDict(K1=VT1, ..., Kn=VTn)"""
-    
+
     items = None  # type: OrderedDict[str, Type]  # (item_name, item_type)
     fallback = None  # type: Instance
-    
+
     def __init__(self, items: 'OrderedDict[str, Type]', fallback: Instance,
                  line: int = -1, column: int = -1) -> None:
         assert fallback.type.fullname() == 'typing.Mapping'
@@ -824,10 +824,10 @@ def __init__(self, items: 'OrderedDict[str, Type]', fallback: Instance,
         self.can_be_true = len(self.items) > 0
         self.can_be_false = len(self.items) == 0
         super().__init__(line, column)
-    
+
     def accept(self, visitor: 'TypeVisitor[T]') -> T:
         return visitor.visit_typeddict_type(self)
-    
+
     def serialize(self) -> JsonDict:
         return {'.class': 'TypedDictType',
                 'items': [[n, t.serialize()] for (n, t) in self.items.items()],
@@ -839,7 +839,7 @@ def deserialize(cls, data: JsonDict) -> 'TypedDictType':
         assert data['.class'] == 'TypedDictType'
         return TypedDictType(OrderedDict([(n, Type.deserialize(t)) for (n, t) in data['items']]),
                              Instance.deserialize(data['fallback']))
-    
+
     def copy_modified(self, *, fallback: Instance = None,
                       item_types: List[Type] = None) -> 'TypedDictType':
         if fallback is None:
@@ -849,18 +849,19 @@ def copy_modified(self, *, fallback: Instance = None,
         else:
             items = OrderedDict(zip(self.items, item_types))
         return TypedDictType(items, fallback, self.line, self.column)
-    
+
     def names_are_wider_than(self, other: 'TypedDictType'):
         return len(other.items.keys() - self.items.keys()) == 0
-    
+
     def zip(self, right: 'TypedDictType') -> Iterable[Tuple[str, Type, Type]]:
         left = self
         for (item_name, left_item_type) in left.items.items():
             right_item_type = right.items.get(item_name)
             if right_item_type is not None:
                 yield (item_name, left_item_type, right_item_type)
-    
-    def zipall(self, right: 'TypedDictType') -> Iterable[Tuple[str, Optional[Type], Optional[Type]]]:
+
+    def zipall(self, right: 'TypedDictType') \
+            -> Iterable[Tuple[str, Optional[Type], Optional[Type]]]:
         left = self
         for (item_name, left_item_type) in left.items.items():
             right_item_type = right.items.get(item_name)
@@ -1139,7 +1140,7 @@ def visit_overloaded(self, t: Overloaded) -> T:
     @abstractmethod
     def visit_tuple_type(self, t: TupleType) -> T:
         pass
-    
+
     @abstractmethod
     def visit_typeddict_type(self, t: TypedDictType) -> T:
         pass
@@ -1216,7 +1217,7 @@ def visit_tuple_type(self, t: TupleType) -> Type:
                          # TODO: This appears to be unsafe.
                          cast(Any, t.fallback.accept(self)),
                          t.line, t.column)
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         items = OrderedDict([
             (item_name, item_type.accept(self))
@@ -1361,7 +1362,7 @@ def visit_tuple_type(self, t: TupleType) -> str:
             if fallback_name != 'builtins.tuple':
                 return 'Tuple[{}, fallback={}]'.format(s, t.fallback.accept(self))
         return 'Tuple[{}]'.format(s)
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> str:
         s = self.keywords_str(t.items.items())
         if t.fallback and t.fallback.type:
@@ -1400,7 +1401,7 @@ def list_str(self, a: List[Type]) -> str:
             else:
                 res.append(str(t))
         return ', '.join(res)
-    
+
     def keywords_str(self, a: Iterable[Tuple[str, Type]]) -> str:
         """Convert keywords to strings (pretty-print types)
         and join the results with commas.
@@ -1480,7 +1481,7 @@ def visit_callable_type(self, t: CallableType) -> bool:
 
     def visit_tuple_type(self, t: TupleType) -> bool:
         return self.query_types(t.items)
-    
+
     def visit_typeddict_type(self, t: TypedDictType) -> bool:
         return self.query_types(t.items.values())
 
