Use black autoformatting

Author: syrusakbary

graphene_sqlalchemy/__init__.py

@@ -1,20 +1,13 @@
-from .types import (
-    SQLAlchemyObjectType,
-)
-from .fields import (
-    SQLAlchemyConnectionField
-)
-from .utils import (
-    get_query,
-    get_session
-)
+from .types import SQLAlchemyObjectType
+from .fields import SQLAlchemyConnectionField
+from .utils import get_query, get_session
 
-__version__ = '2.0.0'
+__version__ = "2.0.0"
 
 __all__ = [
-    '__version__',
-    'SQLAlchemyObjectType',
-    'SQLAlchemyConnectionField',
-    'get_query',
-    'get_session'
+    "__version__",
+    "SQLAlchemyObjectType",
+    "SQLAlchemyConnectionField",
+    "get_query",
+    "get_session",
 ]

graphene_sqlalchemy/converter.py

@@ -3,25 +3,23 @@
 from sqlalchemy.dialects import postgresql
 from sqlalchemy.orm import interfaces
 
-from graphene import (ID, Boolean, Dynamic, Enum, Field, Float, Int, List,
-                      String)
+from graphene import ID, Boolean, Dynamic, Enum, Field, Float, Int, List, String
 from graphene.types.json import JSONString
 
 from .fields import createConnectionField
 
 try:
-    from sqlalchemy_utils import (
-        ChoiceType, JSONType, ScalarListType, TSVectorType)
+    from sqlalchemy_utils import ChoiceType, JSONType, ScalarListType, TSVectorType
 except ImportError:
     ChoiceType = JSONType = ScalarListType = TSVectorType = object
 
 
 def get_column_doc(column):
-    return getattr(column, 'doc', None)
+    return getattr(column, "doc", None)
 
 
 def is_column_nullable(column):
-    return bool(getattr(column, 'nullable', True))
+    return bool(getattr(column, "nullable", True))
 
 
 def convert_sqlalchemy_relationship(relationship, registry):
@@ -43,46 +41,51 @@ def dynamic_type():
 
 
 def convert_sqlalchemy_hybrid_method(hybrid_item):
-    return String(description=getattr(hybrid_item, '__doc__', None),
-                  required=False)
+    return String(description=getattr(hybrid_item, "__doc__", None), required=False)
 
 
 def convert_sqlalchemy_composite(composite, registry):
     converter = registry.get_converter_for_composite(composite.composite_class)
     if not converter:
         try:
             raise Exception(
-                "Don't know how to convert the composite field %s (%s)" %
-                (composite, composite.composite_class))
+                "Don't know how to convert the composite field %s (%s)"
+                % (composite, composite.composite_class)
+            )
         except AttributeError:
             # handle fields that are not attached to a class yet (don't have a parent)
             raise Exception(
-                "Don't know how to convert the composite field %r (%s)" %
-                (composite, composite.composite_class))
+                "Don't know how to convert the composite field %r (%s)"
+                % (composite, composite.composite_class)
+            )
     return converter(composite, registry)
 
 
 def _register_composite_class(cls, registry=None):
     if registry is None:
         from .registry import get_global_registry
+
         registry = get_global_registry()
 
     def inner(fn):
         registry.register_composite_converter(cls, fn)
+
     return inner
 
 
 convert_sqlalchemy_composite.register = _register_composite_class
 
 
 def convert_sqlalchemy_column(column, registry=None):
-    return convert_sqlalchemy_type(getattr(column, 'type', None), column, registry)
+    return convert_sqlalchemy_type(getattr(column, "type", None), column, registry)
 
 
 @singledispatch
 def convert_sqlalchemy_type(type, column, registry=None):
     raise Exception(
-        "Don't know how to convert the SQLAlchemy field %s (%s)" % (column, column.__class__))
+        "Don't know how to convert the SQLAlchemy field %s (%s)"
+        % (column, column.__class__)
+    )
 
 
 @convert_sqlalchemy_type.register(types.Date)
@@ -96,40 +99,49 @@ def convert_sqlalchemy_type(type, column, registry=None):
 @convert_sqlalchemy_type.register(postgresql.CIDR)
 @convert_sqlalchemy_type.register(TSVectorType)
 def convert_column_to_string(type, column, registry=None):
-    return String(description=get_column_doc(column),
-                  required=not(is_column_nullable(column)))
+    return String(
+        description=get_column_doc(column), required=not (is_column_nullable(column))
+    )
 
 
 @convert_sqlalchemy_type.register(types.DateTime)
 def convert_column_to_datetime(type, column, registry=None):
     from graphene.types.datetime import DateTime
-    return DateTime(description=get_column_doc(column),
-                    required=not(is_column_nullable(column)))
+
+    return DateTime(
+        description=get_column_doc(column), required=not (is_column_nullable(column))
+    )
 
 
 @convert_sqlalchemy_type.register(types.SmallInteger)
 @convert_sqlalchemy_type.register(types.Integer)
 def convert_column_to_int_or_id(type, column, registry=None):
     if column.primary_key:
-        return ID(description=get_column_doc(column),
-                  required=not (is_column_nullable(column)))
+        return ID(
+            description=get_column_doc(column),
+            required=not (is_column_nullable(column)),
+        )
     else:
-        return Int(description=get_column_doc(column),
-                   required=not (is_column_nullable(column)))
+        return Int(
+            description=get_column_doc(column),
+            required=not (is_column_nullable(column)),
+        )
 
 
 @convert_sqlalchemy_type.register(types.Boolean)
 def convert_column_to_boolean(type, column, registry=None):
-    return Boolean(description=get_column_doc(column),
-                   required=not(is_column_nullable(column)))
+    return Boolean(
+        description=get_column_doc(column), required=not (is_column_nullable(column))
+    )
 
 
 @convert_sqlalchemy_type.register(types.Float)
 @convert_sqlalchemy_type.register(types.Numeric)
 @convert_sqlalchemy_type.register(types.BigInteger)
 def convert_column_to_float(type, column, registry=None):
-    return Float(description=get_column_doc(column),
-                 required=not(is_column_nullable(column)))
+    return Float(
+        description=get_column_doc(column), required=not (is_column_nullable(column))
+    )
 
 
 @convert_sqlalchemy_type.register(types.Enum)
@@ -138,14 +150,16 @@ def convert_enum_to_enum(type, column, registry=None):
         items = type.enum_class.__members__.items()
     except AttributeError:
         items = zip(type.enums, type.enums)
-    return Field(Enum(type.name, items),
-                 description=get_column_doc(column),
-                 required=not(is_column_nullable(column)))
+    return Field(
+        Enum(type.name, items),
+        description=get_column_doc(column),
+        required=not (is_column_nullable(column)),
+    )
 
 
 @convert_sqlalchemy_type.register(ChoiceType)
 def convert_column_to_enum(type, column, registry=None):
-    name = '{}_{}'.format(column.table.name, column.name).upper()
+    name = "{}_{}".format(column.table.name, column.name).upper()
     return Enum(name, type.choices, description=get_column_doc(column))
 
 
@@ -158,19 +172,24 @@ def convert_scalar_list_to_list(type, column, registry=None):
 def convert_postgres_array_to_list(_type, column, registry=None):
     graphene_type = convert_sqlalchemy_type(column.type.item_type, column)
     inner_type = type(graphene_type)
-    return List(inner_type, description=get_column_doc(column),
-                required=not(is_column_nullable(column)))
+    return List(
+        inner_type,
+        description=get_column_doc(column),
+        required=not (is_column_nullable(column)),
+    )
 
 
 @convert_sqlalchemy_type.register(postgresql.HSTORE)
 @convert_sqlalchemy_type.register(postgresql.JSON)
 @convert_sqlalchemy_type.register(postgresql.JSONB)
 def convert_json_to_string(type, column, registry=None):
-    return JSONString(description=get_column_doc(column),
-                      required=not(is_column_nullable(column)))
+    return JSONString(
+        description=get_column_doc(column), required=not (is_column_nullable(column))
+    )
 
 
 @convert_sqlalchemy_type.register(JSONType)
 def convert_json_type_to_string(type, column, registry=None):
-    return JSONString(description=get_column_doc(column),
-                      required=not(is_column_nullable(column)))
+    return JSONString(
+        description=get_column_doc(column), required=not (is_column_nullable(column))
+    )

graphene_sqlalchemy/fields.py

@@ -10,17 +10,19 @@
 
 
 class UnsortedSQLAlchemyConnectionField(ConnectionField):
-
     @property
     def type(self):
         from .types import SQLAlchemyObjectType
+
         _type = super(ConnectionField, self).type
         if issubclass(_type, Connection):
             return _type
         assert issubclass(_type, SQLAlchemyObjectType), (
             "SQLALchemyConnectionField only accepts SQLAlchemyObjectType types, not {}"
         ).format(_type.__name__)
-        assert _type._meta.connection, "The type {} doesn't have a connection".format(_type.__name__)
+        assert _type._meta.connection, "The type {} doesn't have a connection".format(
+            _type.__name__
+        )
         return _type._meta.connection
 
     @property
@@ -74,20 +76,21 @@ def get_resolver(self, parent_resolver):
 
 
 class SQLAlchemyConnectionField(UnsortedSQLAlchemyConnectionField):
-
     def __init__(self, type, *args, **kwargs):
-        if 'sort' not in kwargs and issubclass(type, Connection):
+        if "sort" not in kwargs and issubclass(type, Connection):
             # Let super class raise if type is not a Connection
             try:
                 model = type.Edge.node._type._meta.model
-                kwargs.setdefault('sort', sort_argument_for_model(model))
+                kwargs.setdefault("sort", sort_argument_for_model(model))
             except Exception:
                 raise Exception(
                     'Cannot create sort argument for {}. A model is required. Set the "sort" argument'
-                    ' to None to disabling the creation of the sort query argument'.format(type.__name__)
+                    " to None to disabling the creation of the sort query argument".format(
+                        type.__name__
+                    )
                 )
-        elif 'sort' in kwargs and kwargs['sort'] is None:
-            del kwargs['sort']
+        elif "sort" in kwargs and kwargs["sort"] is None:
+            del kwargs["sort"]
         super(SQLAlchemyConnectionField, self).__init__(type, *args, **kwargs)
 
 

graphene_sqlalchemy/registry.py

@@ -1,17 +1,17 @@
 class Registry(object):
-
     def __init__(self):
         self._registry = {}
         self._registry_models = {}
         self._registry_composites = {}
 
     def register(self, cls):
         from .types import SQLAlchemyObjectType
+
         assert issubclass(cls, SQLAlchemyObjectType), (
-            'Only classes of type SQLAlchemyObjectType can be registered, '
+            "Only classes of type SQLAlchemyObjectType can be registered, "
             'received "{}"'
         ).format(cls.__name__)
-        assert cls._meta.registry == self, 'Registry for a Model have to match.'
+        assert cls._meta.registry == self, "Registry for a Model have to match."
         # assert self.get_type_for_model(cls._meta.model) in [None, cls], (
         #     'SQLAlchemy model "{}" already associated with '
         #     'another type "{}".'

graphene_sqlalchemy/tests/models.py

@@ -8,33 +8,36 @@
 
 Base = declarative_base()
 
-association_table = Table('association', Base.metadata,
-                          Column('pet_id', Integer, ForeignKey('pets.id')),
-                          Column('reporter_id', Integer, ForeignKey('reporters.id')))
+association_table = Table(
+    "association",
+    Base.metadata,
+    Column("pet_id", Integer, ForeignKey("pets.id")),
+    Column("reporter_id", Integer, ForeignKey("reporters.id")),
+)
 
 
 class Editor(Base):
-    __tablename__ = 'editors'
+    __tablename__ = "editors"
     editor_id = Column(Integer(), primary_key=True)
     name = Column(String(100))
 
 
 class Pet(Base):
-    __tablename__ = 'pets'
+    __tablename__ = "pets"
     id = Column(Integer(), primary_key=True)
     name = Column(String(30))
-    pet_kind = Column(Enum('cat', 'dog', name='pet_kind'), nullable=False)
-    reporter_id = Column(Integer(), ForeignKey('reporters.id'))
+    pet_kind = Column(Enum("cat", "dog", name="pet_kind"), nullable=False)
+    reporter_id = Column(Integer(), ForeignKey("reporters.id"))
 
 
 class Reporter(Base):
-    __tablename__ = 'reporters'
+    __tablename__ = "reporters"
     id = Column(Integer(), primary_key=True)
     first_name = Column(String(30))
     last_name = Column(String(30))
     email = Column(String())
-    pets = relationship('Pet', secondary=association_table, backref='reporters')
-    articles = relationship('Article', backref='reporter')
+    pets = relationship("Pet", secondary=association_table, backref="reporters")
+    articles = relationship("Article", backref="reporter")
     favorite_article = relationship("Article", uselist=False)
 
     # total = column_property(
@@ -45,19 +48,21 @@ class Reporter(Base):
 
 
 class Article(Base):
-    __tablename__ = 'articles'
+    __tablename__ = "articles"
     id = Column(Integer(), primary_key=True)
     headline = Column(String(100))
     pub_date = Column(Date())
-    reporter_id = Column(Integer(), ForeignKey('reporters.id'))
+    reporter_id = Column(Integer(), ForeignKey("reporters.id"))
 
 
 class ReflectedEditor(type):
     """Same as Editor, but using reflected table."""
+
     @classmethod
     def __subclasses__(cls):
         return []
 
-editor_table = Table('editors', Base.metadata, autoload=True)
+
+editor_table = Table("editors", Base.metadata, autoload=True)
 
 mapper(ReflectedEditor, editor_table)