Initial formatting of astroid

1 files changed, 31 insertions, 23 deletions

diff --git a/astroid/helpers.py b/astroid/helpers.py
index d7a72338..e58d1919 100644
--- a/astroid/helpers.py
+++ b/astroid/helpers.py
@@ -34,13 +34,13 @@ def _build_proxy_class(cls_name, builtins):
 def _function_type(function, builtins):
     if isinstance(function, scoped_nodes.Lambda):
         if function.root().name == BUILTINS:
-            cls_name = 'builtin_function_or_method'
+            cls_name = "builtin_function_or_method"
         else:
-            cls_name = 'function'
+            cls_name = "function"
     elif isinstance(function, bases.BoundMethod):
-        cls_name = 'method'
+        cls_name = "method"
     elif isinstance(function, bases.UnboundMethod):
-        cls_name = 'function'
+        cls_name = "function"
     return _build_proxy_class(cls_name, builtins)
 
 
@@ -56,11 +56,11 @@ def _object_type(node, context=None):
                 if metaclass:
                     yield metaclass
                     continue
-            yield builtins.getattr('type')[0]
+            yield builtins.getattr("type")[0]
         elif isinstance(inferred, (scoped_nodes.Lambda, bases.UnboundMethod)):
             yield _function_type(inferred, builtins)
         elif isinstance(inferred, scoped_nodes.Module):
-            yield _build_proxy_class('module', builtins)
+            yield _build_proxy_class("module", builtins)
         else:
             yield inferred._proxied
 
@@ -94,8 +94,10 @@ def _object_type_is_subclass(obj_type, class_or_seq, context=None):
         return util.Uninferable
 
     # Instances are not types
-    class_seq = [item if not isinstance(item, bases.Instance)
-                 else util.Uninferable for item in class_seq]
+    class_seq = [
+        item if not isinstance(item, bases.Instance) else util.Uninferable
+        for item in class_seq
+    ]
     # strict compatibility with issubclass
     # issubclass(type, (object, 1)) evaluates to true
     # issubclass(object, (1, type)) raises TypeError
@@ -153,9 +155,9 @@ def safe_infer(node, context=None):
         return None
     try:
         next(inferit)
-        return None # None if there is ambiguity on the inferred node
+        return None  # None if there is ambiguity on the inferred node
     except exceptions.InferenceError:
-        return None# there is some kind of ambiguity
+        return None  # there is some kind of ambiguity
     except StopIteration:
         return value
 
@@ -169,9 +171,11 @@ def has_known_bases(klass, context=None):
     for base in klass.bases:
         result = safe_infer(base, context=context)
         # TODO: check for A->B->A->B pattern in class structure too?
-        if (not isinstance(result, scoped_nodes.ClassDef) or
-                result is klass or
-                not has_known_bases(result, context=context)):
+        if (
+            not isinstance(result, scoped_nodes.ClassDef)
+            or result is klass
+            or not has_known_bases(result, context=context)
+        ):
             klass._all_bases_known = False
             return False
     klass._all_bases_known = True
@@ -212,13 +216,12 @@ def class_instance_as_index(node):
     context.callcontext = contextmod.CallContext(args=[node])
 
     try:
-        for inferred in node.igetattr('__index__', context=context):
+        for inferred in node.igetattr("__index__", context=context):
             if not isinstance(inferred, bases.BoundMethod):
                 continue
 
             for result in inferred.infer_call_result(node, context=context):
-                if (isinstance(result, nodes.Const)
-                        and isinstance(result.value, int)):
+                if isinstance(result, nodes.Const) and isinstance(result.value, int):
                     return result
     except exceptions.InferenceError:
         pass
@@ -238,11 +241,13 @@ def object_len(node, context=None):
     :rtype int: Integer length of node
     """
     from astroid.objects import FrozenSet
+
     inferred_node = safe_infer(node, context=context)
     if inferred_node is None or inferred_node is util.Uninferable:
         raise exceptions.InferenceError(node=node)
-    if (isinstance(inferred_node, nodes.Const) and
-            isinstance(inferred_node.value, (bytes, str))):
+    if isinstance(inferred_node, nodes.Const) and isinstance(
+        inferred_node.value, (bytes, str)
+    ):
         return len(inferred_node.value)
     if isinstance(inferred_node, (nodes.List, nodes.Set, nodes.Tuple, FrozenSet)):
         return len(inferred_node.elts)
@@ -253,12 +258,15 @@ def object_len(node, context=None):
         len_call = next(node_type.igetattr("__len__", context=context))
     except exceptions.AttributeInferenceError:
         raise exceptions.AstroidTypeError(
-            "object of type '{}' has no len()"
-            .format(len_call.pytype()))
+            "object of type '{}' has no len()".format(len_call.pytype())
+        )
 
     result_of_len = next(len_call.infer_call_result(node, context))
-    if isinstance(result_of_len, nodes.Const) and result_of_len.pytype() == "builtins.int":
+    if (
+        isinstance(result_of_len, nodes.Const)
+        and result_of_len.pytype() == "builtins.int"
+    ):
         return result_of_len.value
     raise exceptions.AstroidTypeError(
-        "'{}' object cannot be interpreted as an integer"
-        .format(result_of_len))
+        "'{}' object cannot be interpreted as an integer".format(result_of_len)
+    )