Fixed lint errors

syrusakbary · syrusakbary · commit a2ab008ead0f · 2015-11-11T21:54:45.000-08:00
diff --git a/bin/autolinter b/bin/autolinter
@@ -1,5 +1,5 @@
 #!/bin/bash
 
 autoflake ./ -r --remove-unused-variables --remove-all-unused-imports --in-place
-autopep8 ./ -r --in-place
+autopep8 ./ -r --in-place --experimental --aggressive --max-line-length 120
 isort -rc .
diff --git a/graphene/__init__.py b/graphene/__init__.py
@@ -40,7 +40,30 @@
     resolve_only_args
 )
 
-__all__ = ['Enum', 'Argument', 'String', 'Int', 'Boolean', 'Float', 'ID', 'List', 'NonNull', 'signals', 'Schema',
-           'BaseType', 'LazyType', 'ObjectType', 'Interface', 'Mutation', 'Field', 'InputField', 'StringField',
-           'IntField', 'BooleanField', 'IDField', 'ListField', 'NonNullField',
-           'FloatField', 'resolve_only_args']
+__all__ = [
+    'Enum',
+    'Argument',
+    'String',
+    'Int',
+    'Boolean',
+    'Float',
+    'ID',
+    'List',
+    'NonNull',
+    'signals',
+    'Schema',
+    'BaseType',
+    'LazyType',
+    'ObjectType',
+    'Interface',
+    'Mutation',
+    'Field',
+    'InputField',
+    'StringField',
+    'IntField',
+    'BooleanField',
+    'IDField',
+    'ListField',
+    'NonNullField',
+    'FloatField',
+    'resolve_only_args']
diff --git a/graphene/contrib/django/converter.py b/graphene/contrib/django/converter.py
@@ -16,7 +16,8 @@ class UUIDField(object):
 @singledispatch
 def convert_django_field(field):
     raise Exception(
-        "Don't know how to convert the Django field %s (%s)" % (field, field.__class__))
+        "Don't know how to convert the Django field %s (%s)" %
+        (field, field.__class__))
 
 
 @convert_django_field.register(models.DateField)
diff --git a/graphene/contrib/django/options.py b/graphene/contrib/django/options.py
@@ -32,6 +32,7 @@ def contribute_to_class(self, cls, name):
             return
         if not self.model:
             raise Exception(
-                'Django ObjectType %s must have a model in the Meta class attr' % cls)
+                'Django ObjectType %s must have a model in the Meta class attr' %
+                cls)
         elif not inspect.isclass(self.model) or not issubclass(self.model, models.Model):
             raise Exception('Provided model in %s is not a Django model' % cls)
diff --git a/graphene/contrib/django/tests/test_query.py b/graphene/contrib/django/tests/test_query.py
@@ -87,7 +87,8 @@ class Query(graphene.ObjectType):
         article = graphene.Field(ArticleNode)
 
         def resolve_reporter(self, *args, **kwargs):
-            return ReporterNode(Reporter(id=1, first_name='ABA', last_name='X'))
+            return ReporterNode(
+                Reporter(id=1, first_name='ABA', last_name='X'))
 
     query = '''
         query ReporterQuery {
diff --git a/graphene/contrib/django/types.py b/graphene/contrib/django/types.py
@@ -46,11 +46,13 @@ def __getattr__(self, attr):
         return getattr(self.instance, attr)
 
 
-class DjangoObjectType(six.with_metaclass(DjangoObjectTypeMeta, InstanceObjectType)):
+class DjangoObjectType(six.with_metaclass(
+        DjangoObjectTypeMeta, InstanceObjectType)):
     pass
 
 
-class DjangoInterface(six.with_metaclass(DjangoObjectTypeMeta, InstanceObjectType)):
+class DjangoInterface(six.with_metaclass(
+        DjangoObjectTypeMeta, InstanceObjectType)):
     pass
 
 
diff --git a/graphene/contrib/django/views.py b/graphene/contrib/django/views.py
@@ -28,11 +28,14 @@ def response_errors(self, *errors):
         errors = [{
             "message": str(e)
         } for e in errors]
-        return HttpResponse(json.dumps({'errors': errors}), content_type='application/json')
+        return HttpResponse(
+            json.dumps({'errors': errors}),
+            content_type='application/json')
 
     def execute_query(self, request, query, *args, **kwargs):
         if not query:
-            return self.response_errors(Exception("Must provide query string."))
+            return self.response_errors(
+                Exception("Must provide query string."))
         else:
             try:
                 result = self.schema.execute(query, *args, **kwargs)
@@ -59,7 +62,8 @@ def post(self, request, *args, **kwargs):
                 received_json_data = json.loads(request.body.decode())
                 query = received_json_data.get('query')
             except ValueError:
-                return self.response_errors(ValueError("Malformed json body in the post data"))
+                return self.response_errors(ValueError(
+                    "Malformed json body in the post data"))
         else:
             query = request.POST.get('query') or request.GET.get('query')
         return self.execute_query(request, query or '')
diff --git a/graphene/core/options.py b/graphene/core/options.py
@@ -52,7 +52,9 @@ def contribute_to_class(self, cls, name):
             # Any leftover attributes must be invalid.
             if meta_attrs != {}:
                 raise TypeError(
-                    "'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys()))
+                    "'class Meta' got invalid attribute(s): %s" %
+                    ','.join(
+                        meta_attrs.keys()))
         else:
             self.proxy = False
 
diff --git a/graphene/core/schema.py b/graphene/core/schema.py
@@ -21,7 +21,8 @@ def __init__(self, schema, *args, **kwargs):
 class Schema(object):
     _executor = None
 
-    def __init__(self, query=None, mutation=None, name='Schema', executor=None):
+    def __init__(self, query=None, mutation=None,
+                 name='Schema', executor=None):
         self._types_names = {}
         self._types = {}
         self.mutation = mutation
@@ -36,7 +37,9 @@ def __repr__(self):
     def T(self, object_type):
         if not object_type:
             return
-        if inspect.isclass(object_type) and issubclass(object_type, BaseType) or isinstance(object_type, BaseType):
+        if inspect.isclass(object_type) and issubclass(
+                object_type, BaseType) or isinstance(
+                object_type, BaseType):
             if object_type not in self._types:
                 internal_type = object_type.internal_type(self)
                 self._types[object_type] = internal_type
@@ -63,7 +66,9 @@ def executor(self, value):
     def schema(self):
         if not self.query:
             raise Exception('You have to define a base query type')
-        return GraphQLSchema(self, query=self.T(self.query), mutation=self.T(self.mutation))
+        return GraphQLSchema(
+            self, query=self.T(self.query),
+            mutation=self.T(self.mutation))
 
     def register(self, object_type):
         type_name = object_type._meta.type_name
@@ -78,7 +83,8 @@ def objecttype(self, type):
         name = getattr(type, 'name', None)
         if name:
             objecttype = self._types_names.get(name, None)
-            if objecttype and inspect.isclass(objecttype) and issubclass(objecttype, BaseObjectType):
+            if objecttype and inspect.isclass(
+                    objecttype) and issubclass(objecttype, BaseObjectType):
                 return objecttype
 
     def setup(self):
@@ -95,7 +101,8 @@ def get_type(self, type_name):
     def types(self):
         return self._types_names
 
-    def execute(self, request='', root=None, vars=None, operation_name=None, **kwargs):
+    def execute(self, request='', root=None, vars=None,
+                operation_name=None, **kwargs):
         root = root or object()
         return self.executor.execute(
             self.schema,
diff --git a/graphene/core/tests/test_schema.py b/graphene/core/tests/test_schema.py
@@ -92,9 +92,9 @@ def test_query_schema_execute():
 def test_schema_get_type_map():
     assert_equal_lists(
         schema.schema.get_type_map().keys(),
-        ['__Field', 'String', 'Pet', 'Character', '__InputValue', '__Directive',
-            '__TypeKind', '__Schema', '__Type', 'Human', '__EnumValue', 'Boolean']
-    )
+        ['__Field', 'String', 'Pet', 'Character', '__InputValue',
+         '__Directive', '__TypeKind', '__Schema', '__Type', 'Human',
+         '__EnumValue', 'Boolean'])
 
 
 def test_schema_no_query():
diff --git a/graphene/core/types/__init__.py b/graphene/core/types/__init__.py
@@ -5,5 +5,26 @@
 from .scalars import String, ID, Boolean, Int, Float, Scalar
 from .field import Field, InputField
 
-__all__ = ['BaseType', 'LazyType', 'OrderedType', 'Argument', 'ArgumentsGroup', 'to_arguments', 'List', 'NonNull', 'Field', 'InputField',
-           'Interface', 'BaseObjectType', 'ObjectTypeMeta', 'ObjectType', 'Mutation', 'InputObjectType', 'String', 'ID', 'Boolean', 'Int', 'Float', 'Scalar']
+__all__ = [
+    'BaseType',
+    'LazyType',
+    'OrderedType',
+    'Argument',
+    'ArgumentsGroup',
+    'to_arguments',
+    'List',
+    'NonNull',
+    'Field',
+    'InputField',
+    'Interface',
+    'BaseObjectType',
+    'ObjectTypeMeta',
+    'ObjectType',
+    'Mutation',
+    'InputObjectType',
+    'String',
+    'ID',
+    'Boolean',
+    'Int',
+    'Float',
+    'Scalar']
diff --git a/graphene/core/types/argument.py b/graphene/core/types/argument.py
@@ -9,15 +9,18 @@
 
 class Argument(OrderedType):
 
-    def __init__(self, type, description=None, default=None, name=None, _creation_counter=None):
+    def __init__(self, type, description=None, default=None,
+                 name=None, _creation_counter=None):
         super(Argument, self).__init__(_creation_counter=_creation_counter)
         self.name = name
         self.type = type
         self.description = description
         self.default = default
 
     def internal_type(self, schema):
-        return GraphQLArgument(schema.T(self.type), self.default, self.description)
+        return GraphQLArgument(
+            schema.T(self.type),
+            self.default, self.description)
 
     def __repr__(self):
         return self.name
@@ -30,7 +33,8 @@ def __init__(self, *args, **kwargs):
         self.arguments = OrderedDict([(arg.name, arg) for arg in arguments])
 
     def internal_type(self, schema):
-        return OrderedDict([(arg.name, schema.T(arg)) for arg in self.arguments.values()])
+        return OrderedDict([(arg.name, schema.T(arg))
+                            for arg in self.arguments.values()])
 
     def __len__(self):
         return len(self.arguments)
diff --git a/graphene/core/types/base.py b/graphene/core/types/base.py
@@ -54,7 +54,7 @@ def gen_counter():
 
     def __eq__(self, other):
         # Needed for @total_ordering
-        if type(self) == type(other):
+        if isinstance(self, type(other)):
             return self.creation_counter == other.creation_counter
         return NotImplemented
 
@@ -87,7 +87,8 @@ class ArgumentType(MirroredType):
 
     def as_argument(self):
         from .argument import Argument
-        return Argument(self, _creation_counter=self.creation_counter, *self.args, **self.kwargs)
+        return Argument(
+            self, _creation_counter=self.creation_counter, *self.args, **self.kwargs)
 
 
 class FieldType(MirroredType):
@@ -103,11 +104,13 @@ def contribute_to_class(self, cls, name):
 
     def as_field(self):
         from .field import Field
-        return Field(self, _creation_counter=self.creation_counter, *self.args, **self.kwargs)
+        return Field(self, _creation_counter=self.creation_counter,
+                     *self.args, **self.kwargs)
 
     def as_inputfield(self):
         from .field import InputField
-        return InputField(self, _creation_counter=self.creation_counter, *self.args, **self.kwargs)
+        return InputField(
+            self, _creation_counter=self.creation_counter, *self.args, **self.kwargs)
 
 
 class MountedType(FieldType, ArgumentType):
diff --git a/graphene/core/types/field.py b/graphene/core/types/field.py
@@ -26,7 +26,9 @@ class Empty(object):
 
 class Field(OrderedType):
 
-    def __init__(self, type, description=None, args=None, name=None, resolver=None, required=False, default=None, *args_list, **kwargs):
+    def __init__(
+            self, type, description=None, args=None, name=None, resolver=None,
+            required=False, default=None, *args_list, **kwargs):
         _creation_counter = kwargs.pop('_creation_counter', None)
         super(Field, self).__init__(_creation_counter=_creation_counter)
         self.name = name
@@ -43,7 +45,8 @@ def __init__(self, type, description=None, args=None, name=None, resolver=None,
 
     def contribute_to_class(self, cls, attname):
         assert issubclass(
-            cls, BaseObjectType), 'Field {} cannot be mounted in {}'.format(self, cls)
+            cls, BaseObjectType), 'Field {} cannot be mounted in {}'.format(
+            self, cls)
         if not self.name:
             self.name = to_camel_case(attname)
         self.attname = attname
@@ -109,7 +112,7 @@ def __str__(self):
 
     def __eq__(self, other):
         eq = super(Field, self).__eq__(other)
-        if type(self) == type(other):
+        if isinstance(self, type(other)):
             return eq and self.object_type == other.object_type
         return NotImplemented
 
@@ -119,7 +122,8 @@ def __hash__(self):
 
 class InputField(OrderedType):
 
-    def __init__(self, type, description=None, default=None, name=None, _creation_counter=None, required=False):
+    def __init__(self, type, description=None, default=None,
+                 name=None, _creation_counter=None, required=False):
         super(InputField, self).__init__(_creation_counter=_creation_counter)
         self.name = name
         if required:
@@ -130,7 +134,8 @@ def __init__(self, type, description=None, default=None, name=None, _creation_co
 
     def contribute_to_class(self, cls, attname):
         assert issubclass(
-            cls, InputObjectType), 'InputField {} cannot be mounted in {}'.format(self, cls)
+            cls, InputObjectType), 'InputField {} cannot be mounted in {}'.format(
+            self, cls)
         if not self.name:
             self.name = to_camel_case(attname)
         self.attname = attname
@@ -141,5 +146,6 @@ def contribute_to_class(self, cls, attname):
         cls._meta.add_field(self)
 
     def internal_type(self, schema):
-        return GraphQLInputObjectField(schema.T(self.type), default_value=self.default,
-                                       description=self.description)
+        return GraphQLInputObjectField(
+            schema.T(self.type),
+            default_value=self.default, description=self.description)
diff --git a/graphene/core/types/objecttype.py b/graphene/core/types/objecttype.py
@@ -79,7 +79,8 @@ def __new__(cls, name, bases, attrs):
             # on the base classes (we cannot handle shadowed fields at the
             # moment).
             for field in parent_fields:
-                if field.name in field_names and field.type.__class__ != field_names[field.name].type.__class__:
+                if field.name in field_names and field.type.__class__ != field_names[
+                        field.name].type.__class__:
                     raise Exception(
                         'Local field %r in class %r (%r) clashes '
                         'with field with similar name from '
@@ -111,7 +112,8 @@ def _prepare(cls):
 
     def add_to_class(cls, name, value):
         # We should call the contribute_to_class method only if it's bound
-        if not inspect.isclass(value) and hasattr(value, 'contribute_to_class'):
+        if not inspect.isclass(value) and hasattr(
+                value, 'contribute_to_class'):
             value.contribute_to_class(cls, name)
         else:
             setattr(cls, name, value)
@@ -157,14 +159,16 @@ def __init__(self, *args, **kwargs):
                     pass
             if kwargs:
                 raise TypeError(
-                    "'%s' is an invalid keyword argument for this function" % list(kwargs)[0])
+                    "'%s' is an invalid keyword argument for this function" %
+                    list(kwargs)[0])
 
         signals.post_init.send(self.__class__, instance=self)
 
     @classmethod
     def fields_as_arguments(cls, schema):
-        return OrderedDict([(f.attname, GraphQLArgument(f.internal_type(schema)))
-                            for f in cls._meta.fields])
+        return OrderedDict(
+            [(f.attname, GraphQLArgument(f.internal_type(schema)))
+             for f in cls._meta.fields])
 
     @classmethod
     def resolve_objecttype(cls, schema, instance, *args):
diff --git a/graphene/core/types/tests/test_base.py b/graphene/core/types/tests/test_base.py
@@ -28,7 +28,11 @@ def test_type_as_field_called(Field):
     a = MountedType(2, description='A', resolver=resolver)
     a.as_field()
     Field.assert_called_with(
-        a, 2, _creation_counter=a.creation_counter, description='A', resolver=resolver)
+        a,
+        2,
+        _creation_counter=a.creation_counter,
+        description='A',
+        resolver=resolver)
 
 
 @patch('graphene.core.types.argument.Argument')
diff --git a/graphene/core/types/tests/test_scalars.py b/graphene/core/types/tests/test_scalars.py
diff --git a/graphene/relay/fields.py b/graphene/relay/fields.py
diff --git a/graphene/relay/types.py b/graphene/relay/types.py
diff --git a/graphene/relay/utils.py b/graphene/relay/utils.py
diff --git a/graphene/utils/tests/test_proxy_snake_dict.py b/graphene/utils/tests/test_proxy_snake_dict.py
diff --git a/setup.cfg b/setup.cfg
