Reformatted files using black

Author: syrusakbary

graphene_django/__init__.py

@@ -1,14 +1,6 @@
-from .types import (
-    DjangoObjectType,
-)
-from .fields import (
-    DjangoConnectionField,
-)
+from .types import DjangoObjectType
+from .fields import DjangoConnectionField
 
-__version__ = '2.1rc1'
+__version__ = "2.1rc1"
 
-__all__ = [
-    '__version__',
-    'DjangoObjectType',
-    'DjangoConnectionField'
-]
+__all__ = ["__version__", "DjangoObjectType", "DjangoConnectionField"]

graphene_django/compat.py

@@ -7,7 +7,7 @@ class MissingType(object):
     # and we cannot have psycopg2 on PyPy
     from django.contrib.postgres.fields import ArrayField, HStoreField, RangeField
 except ImportError:
-    ArrayField, HStoreField, JSONField, RangeField = (MissingType, ) * 4
+    ArrayField, HStoreField, JSONField, RangeField = (MissingType,) * 4
 
 
 try:

graphene_django/converter.py

@@ -1,8 +1,22 @@
 from django.db import models
 from django.utils.encoding import force_text
 
-from graphene import (ID, Boolean, Dynamic, Enum, Field, Float, Int, List,
-                      NonNull, String, UUID, DateTime, Date, Time)
+from graphene import (
+    ID,
+    Boolean,
+    Dynamic,
+    Enum,
+    Field,
+    Float,
+    Int,
+    List,
+    NonNull,
+    String,
+    UUID,
+    DateTime,
+    Date,
+    Time,
+)
 from graphene.types.json import JSONString
 from graphene.utils.str_converters import to_camel_case, to_const
 from graphql import assert_valid_name
@@ -32,7 +46,7 @@ def get_choices(choices):
         else:
             name = convert_choice_name(value)
             while name in converted_names:
-                name += '_' + str(len(converted_names))
+                name += "_" + str(len(converted_names))
             converted_names.append(name)
             description = help_text
             yield name, value, description
@@ -43,16 +57,15 @@ def convert_django_field_with_choices(field, registry=None):
         converted = registry.get_converted_field(field)
         if converted:
             return converted
-    choices = getattr(field, 'choices', None)
+    choices = getattr(field, "choices", None)
     if choices:
         meta = field.model._meta
-        name = to_camel_case('{}_{}'.format(meta.object_name, field.name))
+        name = to_camel_case("{}_{}".format(meta.object_name, field.name))
         choices = list(get_choices(choices))
         named_choices = [(c[0], c[1]) for c in choices]
         named_choices_descriptions = {c[0]: c[2] for c in choices}
 
         class EnumWithDescriptionsType(object):
-
             @property
             def description(self):
                 return named_choices_descriptions[self.name]
@@ -69,8 +82,8 @@ def description(self):
 @singledispatch
 def convert_django_field(field, registry=None):
     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.CharField)
@@ -147,7 +160,7 @@ def dynamic_type():
 
         # We do this for a bug in Django 1.8, where null attr
         # is not available in the OneToOneRel instance
-        null = getattr(field, 'null', True)
+        null = getattr(field, "null", True)
         return Field(_type, required=not null)
 
     return Dynamic(dynamic_type)
@@ -171,6 +184,7 @@ def dynamic_type():
             # defined filter_fields in the DjangoObjectType Meta
             if _type._meta.filter_fields:
                 from .filter.fields import DjangoFilterConnectionField
+
                 return DjangoFilterConnectionField(_type)
 
             return DjangoConnectionField(_type)

graphene_django/debug/__init__.py

@@ -1,4 +1,4 @@
 from .middleware import DjangoDebugMiddleware
 from .types import DjangoDebug
 
-__all__ = ['DjangoDebugMiddleware', 'DjangoDebug']
+__all__ = ["DjangoDebugMiddleware", "DjangoDebug"]

graphene_django/debug/middleware.py

@@ -7,7 +7,6 @@
 
 
 class DjangoDebugContext(object):
-
     def __init__(self):
         self.debug_promise = None
         self.promises = []
@@ -38,20 +37,21 @@ def disable_instrumentation(self):
 
 
 class DjangoDebugMiddleware(object):
-
     def resolve(self, next, root, info, **args):
         context = info.context
-        django_debug = getattr(context, 'django_debug', None)
+        django_debug = getattr(context, "django_debug", None)
         if not django_debug:
             if context is None:
-                raise Exception('DjangoDebug cannot be executed in None contexts')
+                raise Exception("DjangoDebug cannot be executed in None contexts")
             try:
                 context.django_debug = DjangoDebugContext()
             except Exception:
-                raise Exception('DjangoDebug need the context to be writable, context received: {}.'.format(
-                    context.__class__.__name__
-                ))
-        if info.schema.get_type('DjangoDebug') == info.return_type:
+                raise Exception(
+                    "DjangoDebug need the context to be writable, context received: {}.".format(
+                        context.__class__.__name__
+                    )
+                )
+        if info.schema.get_type("DjangoDebug") == info.return_type:
             return context.django_debug.get_debug_promise()
         promise = next(root, info, **args)
         context.django_debug.add_promise(promise)

graphene_django/debug/sql/tracking.py

@@ -16,7 +16,6 @@ class SQLQueryTriggered(Exception):
 
 
 class ThreadLocalState(local):
-
     def __init__(self):
         self.enabled = True
 
@@ -35,7 +34,7 @@ def recording(self, v):
 
 
 def wrap_cursor(connection, panel):
-    if not hasattr(connection, '_graphene_cursor'):
+    if not hasattr(connection, "_graphene_cursor"):
         connection._graphene_cursor = connection.cursor
 
         def cursor():
@@ -46,7 +45,7 @@ def cursor():
 
 
 def unwrap_cursor(connection):
-    if hasattr(connection, '_graphene_cursor'):
+    if hasattr(connection, "_graphene_cursor"):
         previous_cursor = connection._graphene_cursor
         connection.cursor = previous_cursor
         del connection._graphene_cursor
@@ -87,61 +86,63 @@ def _quote_params(self, params):
         if not params:
             return params
         if isinstance(params, dict):
-            return dict((key, self._quote_expr(value))
-                        for key, value in params.items())
+            return dict((key, self._quote_expr(value)) for key, value in params.items())
         return list(map(self._quote_expr, params))
 
     def _decode(self, param):
         try:
             return force_text(param, strings_only=True)
         except UnicodeDecodeError:
-            return '(encoded string)'
+            return "(encoded string)"
 
     def _record(self, method, sql, params):
         start_time = time()
         try:
             return method(sql, params)
         finally:
             stop_time = time()
-            duration = (stop_time - start_time)
-            _params = ''
+            duration = stop_time - start_time
+            _params = ""
             try:
                 _params = json.dumps(list(map(self._decode, params)))
             except Exception:
                 pass  # object not JSON serializable
 
-            alias = getattr(self.db, 'alias', 'default')
+            alias = getattr(self.db, "alias", "default")
             conn = self.db.connection
-            vendor = getattr(conn, 'vendor', 'unknown')
+            vendor = getattr(conn, "vendor", "unknown")
 
             params = {
-                'vendor': vendor,
-                'alias': alias,
-                'sql': self.db.ops.last_executed_query(
-                    self.cursor, sql, self._quote_params(params)),
-                'duration': duration,
-                'raw_sql': sql,
-                'params': _params,
-                'start_time': start_time,
-                'stop_time': stop_time,
-                'is_slow': duration > 10,
-                'is_select': sql.lower().strip().startswith('select'),
+                "vendor": vendor,
+                "alias": alias,
+                "sql": self.db.ops.last_executed_query(
+                    self.cursor, sql, self._quote_params(params)
+                ),
+                "duration": duration,
+                "raw_sql": sql,
+                "params": _params,
+                "start_time": start_time,
+                "stop_time": stop_time,
+                "is_slow": duration > 10,
+                "is_select": sql.lower().strip().startswith("select"),
             }
 
-            if vendor == 'postgresql':
+            if vendor == "postgresql":
                 # If an erroneous query was ran on the connection, it might
                 # be in a state where checking isolation_level raises an
                 # exception.
                 try:
                     iso_level = conn.isolation_level
                 except conn.InternalError:
-                    iso_level = 'unknown'
-                params.update({
-                    'trans_id': self.logger.get_transaction_id(alias),
-                    'trans_status': conn.get_transaction_status(),
-                    'iso_level': iso_level,
-                    'encoding': conn.encoding,
-                })
+                    iso_level = "unknown"
+                params.update(
+                    {
+                        "trans_id": self.logger.get_transaction_id(alias),
+                        "trans_status": conn.get_transaction_status(),
+                        "iso_level": iso_level,
+                        "encoding": conn.encoding,
+                    }
+                )
 
             _sql = DjangoDebugSQL(**params)
             # We keep `sql` to maintain backwards compatibility