black code

Author: fantix

docs/conf.py

@@ -75,5 +75,5 @@
     "python": ("https://docs.python.org/3", None),
 }
 
-locale_dirs = ['locale/']   # path is example but recommended.
-gettext_compact = False     # optional.
+locale_dirs = ["locale/"]  # path is example but recommended.
+gettext_compact = False  # optional.

src/gino/__init__.py

@@ -7,8 +7,8 @@
 def create_engine(*args, **kwargs):
     from sqlalchemy import create_engine
 
-    kwargs.setdefault('strategy', 'gino')
+    kwargs.setdefault("strategy", "gino")
     return create_engine(*args, **kwargs)
 
 
-__version__ = '0.8.5'
+__version__ = "0.8.5"

src/gino/api.py

@@ -45,7 +45,8 @@ class GinoExecutor:
         :meth:`db.scalar() <.Gino.scalar>` in this case.
 
     """
-    __slots__ = ('_query',)
+
+    __slots__ = ("_query",)
 
     def __init__(self, query):
         self._query = query
@@ -133,8 +134,7 @@ async def first(self, *multiparams, **params):
         (:class:`Gino`) is bound, while metadata is found in this query.
 
         """
-        return await self._query.bind.first(self._query, *multiparams,
-                                            **params)
+        return await self._query.bind.first(self._query, *multiparams, **params)
 
     async def one_or_none(self, *multiparams, **params):
         """
@@ -145,8 +145,7 @@ async def one_or_none(self, *multiparams, **params):
         query.
 
         """
-        return await self._query.bind.one_or_none(self._query, *multiparams,
-                                                  **params)
+        return await self._query.bind.one_or_none(self._query, *multiparams, **params)
 
     async def one(self, *multiparams, **params):
         """
@@ -166,8 +165,7 @@ async def scalar(self, *multiparams, **params):
         (:class:`Gino`) is bound, while metadata is found in this query.
 
         """
-        return await self._query.bind.scalar(self._query, *multiparams,
-                                             **params)
+        return await self._query.bind.scalar(self._query, *multiparams, **params)
 
     async def status(self, *multiparams, **params):
         """
@@ -177,8 +175,7 @@ async def status(self, *multiparams, **params):
         (:class:`Gino`) is bound, while metadata is found in this query.
 
         """
-        return await self._query.bind.status(self._query, *multiparams,
-                                             **params)
+        return await self._query.bind.status(self._query, *multiparams, **params)
 
     def iterate(self, *multiparams, **params):
         """
@@ -190,8 +187,7 @@ def iterate(self, *multiparams, **params):
         """
         connection = self._query.bind.current_connection
         if connection is None:
-            raise ValueError(
-                'No Connection in context, please provide one')
+            raise ValueError("No Connection in context, please provide one")
         return connection.iterate(self._query, *multiparams, **params)
 
 
@@ -311,15 +307,22 @@ class Gino(sa.MetaData):
 
     """
 
-    no_delegate = {'create_engine', 'engine_from_config'}
+    no_delegate = {"create_engine", "engine_from_config"}
     """
     A set of symbols from :mod:`sqlalchemy` which is not delegated by
     :class:`Gino`.
 
     """
 
-    def __init__(self, bind=None, model_classes=None, query_ext=True,
-                 schema_ext=True, ext=True, **kwargs):
+    def __init__(
+        self,
+        bind=None,
+        model_classes=None,
+        query_ext=True,
+        schema_ext=True,
+        ext=True,
+        **kwargs
+    ):
         """
         :param bind: A :class:`~.engine.GinoEngine` instance to bind. Also
                      accepts string or :class:`~sqlalchemy.engine.url.URL`,
@@ -387,8 +390,7 @@ def bind(self):
 
         """
         if self._bind is None:
-            return _PlaceHolder(
-                UninitializedError('Gino engine is not initialized.'))
+            return _PlaceHolder(UninitializedError("Gino engine is not initialized."))
         return self._bind
 
     # noinspection PyMethodOverriding,PyAttributeOutsideInit
@@ -411,6 +413,7 @@ async def set_bind(self, bind, loop=None, **kwargs):
             bind = make_url(bind)
         if isinstance(bind, URL):
             from . import create_engine
+
             bind = await create_engine(bind, loop=loop, **kwargs)
         self.bind = bind
         return bind
@@ -450,6 +453,7 @@ def __await__(self):
         async def init():
             await self.set_bind(self.bind)
             return self
+
         return init().__await__()
 
     def compile(self, elem, *multiparams, **params):
@@ -529,17 +533,17 @@ def transaction(self, *args, **kwargs):
 
 
 class _PlaceHolder:
-    __slots__ = '_exception'
+    __slots__ = "_exception"
 
     def __init__(self, exception):
         self._exception = exception
 
     def __getattribute__(self, item):
-        if item == '_exception':
+        if item == "_exception":
             return super().__getattribute__(item)
         raise self._exception
 
     def __setattr__(self, key, value):
-        if key == '_exception':
+        if key == "_exception":
             return super().__setattr__(key, value)
         raise self._exception

src/gino/crud.py

@@ -39,8 +39,8 @@ def select(*args):
             q = sa.select([getattr(owner, x) for x in args])
             if instance is not None:
                 q = q.where(instance.lookup())
-            return q.execution_options(model=weakref.ref(owner),
-                                       return_model=False)
+            return q.execution_options(model=weakref.ref(owner), return_model=False)
+
         return select
 
 
@@ -79,7 +79,8 @@ class UpdateRequest:
     specific model instance and its database row.
 
     """
-    def __init__(self, instance: 'CRUDModel'):
+
+    def __init__(self, instance: "CRUDModel"):
         self._instance = instance
         self._values = {}
         self._props = {}
@@ -116,8 +117,10 @@ async def apply(self, bind=None, timeout=DEFAULT):
         """
         if self._locator is None:
             raise TypeError(
-                'Model {} has no table, primary key or custom lookup()'.format(
-                    self._instance.__class__.__name__))
+                "Model {} has no table, primary key or custom lookup()".format(
+                    self._instance.__class__.__name__
+                )
+            )
         cls = type(self._instance)
         values = self._values.copy()
 
@@ -137,36 +140,38 @@ async def apply(self, bind=None, timeout=DEFAULT):
         for prop_name, updates in json_updates.items():
             prop = getattr(cls, prop_name)
             from .dialects.asyncpg import JSONB
+
             if isinstance(prop.type, JSONB):
                 if self._literal:
                     values[prop_name] = prop.concat(updates)
                 else:
                     values[prop_name] = prop.concat(
-                        sa.func.jsonb_build_object(
-                            *itertools.chain(*updates.items())))
+                        sa.func.jsonb_build_object(*itertools.chain(*updates.items()))
+                    )
             else:
-                raise TypeError('{} is not supported to update json '
-                                'properties in Gino. Please consider using '
-                                'JSONB.'.format(prop.type))
+                raise TypeError(
+                    "{} is not supported to update json "
+                    "properties in Gino. Please consider using "
+                    "JSONB.".format(prop.type)
+                )
 
         opts = dict(return_model=False)
         if timeout is not DEFAULT:
-            opts['timeout'] = timeout
-        clause = type(self._instance).update.where(
-            self._locator,
-        ).values(
-            **self._instance._get_sa_values(values),
-        ).returning(
-            *[getattr(cls, key) for key in values],
-        ).execution_options(**opts)
+            opts["timeout"] = timeout
+        clause = (
+            type(self._instance)
+            .update.where(self._locator,)
+            .values(**self._instance._get_sa_values(values),)
+            .returning(*[getattr(cls, key) for key in values],)
+            .execution_options(**opts)
+        )
         if bind is None:
             bind = cls.__metadata__.bind
         row = await bind.first(clause)
         if not row:
             raise NoSuchRowError()
         for k, v in row.items():
-            self._instance.__values__[
-                self._instance._column_name_map.invert_get(k)] = v
+            self._instance.__values__[self._instance._column_name_map.invert_get(k)] = v
         for prop in self._props:
             prop.reload(self._instance)
         return self
@@ -208,11 +213,11 @@ def update(self, **values):
         for key, value in values.items():
             prop = cls.__dict__.get(key)
             if isinstance(prop, json_support.JSONProperty):
-                value_from = '__profile__'
+                value_from = "__profile__"
                 method = self._set_prop
                 k = prop
             else:
-                value_from = '__values__'
+                value_from = "__values__"
                 method = self._set
                 k = key
             if not isinstance(value, ClauseElement):
@@ -227,16 +232,19 @@ class Alias:
     Experimental proxy for table alias on model.
 
     """
+
     def __init__(self, model, *args, **kwargs):
         # noinspection PyProtectedMember
         model._check_abstract()
         self.model = model
         self.alias = model.__table__.alias(*args, **kwargs)
 
     def __getattr__(self, item):
-        rv = getattr(self.alias.columns, item,
-                     getattr(self.alias, item,
-                             getattr(self.model, item, DEFAULT)))
+        rv = getattr(
+            self.alias.columns,
+            item,
+            getattr(self.alias, item, getattr(self.model, item, DEFAULT)),
+        )
         if rv is DEFAULT:
             raise AttributeError
         return rv
@@ -429,16 +437,15 @@ def _init_table(cls, sub_cls):
                 if isinstance(v, json_support.JSONProperty):
                     if not hasattr(sub_cls, v.prop_name):
                         raise AttributeError(
-                            'Requires "{}" JSON[B] column.'.format(
-                                v.prop_name))
+                            'Requires "{}" JSON[B] column.'.format(v.prop_name)
+                        )
                     v.name = k
         if rv is not None:
             rv.__model__ = weakref.ref(sub_cls)
         return rv
 
     @classmethod
-    async def _create_without_instance(cls, bind=None, timeout=DEFAULT,
-                                       **values):
+    async def _create_without_instance(cls, bind=None, timeout=DEFAULT, **values):
         return await cls(**values)._create(bind=bind, timeout=timeout)
 
     async def _create(self, bind=None, timeout=DEFAULT):
@@ -462,13 +469,14 @@ async def _create(self, bind=None, timeout=DEFAULT):
         # insert into database
         opts = dict(return_model=False, model=cls)
         if timeout is not DEFAULT:
-            opts['timeout'] = timeout
+            opts["timeout"] = timeout
         # noinspection PyArgumentList
-        q = cls.__table__.insert().values(
-            **self._get_sa_values(self.__values__)
-        ).returning(
-            *cls
-        ).execution_options(**opts)
+        q = (
+            cls.__table__.insert()
+            .values(**self._get_sa_values(self.__values__))
+            .returning(*cls)
+            .execution_options(**opts)
+        )
         if bind is None:
             bind = cls.__metadata__.bind
         row = await bind.first(q)
@@ -517,9 +525,9 @@ async def get(cls, ident, bind=None, timeout=DEFAULT):
         columns = cls.__table__.primary_key.columns
         if len(ident_) != len(columns):
             raise ValueError(
-                'Incorrect number of values as primary key: '
-                'expected {}, got {}.'.format(
-                    len(columns), len(ident_)))
+                "Incorrect number of values as primary key: "
+                "expected {}, got {}.".format(len(columns), len(ident_))
+            )
         clause = cls.query
         for i, c in enumerate(columns):
             try:
@@ -575,9 +583,11 @@ def lookup(self):
         if exps:
             return sa.and_(*exps)
         else:
-            raise LookupError('Instance-level CRUD operations not allowed on '
-                              'models without primary keys or lookup(), please'
-                              ' use model-level CRUD operations instead.')
+            raise LookupError(
+                "Instance-level CRUD operations not allowed on "
+                "models without primary keys or lookup(), please"
+                " use model-level CRUD operations instead."
+            )
 
     def _update(self, **values):
         return self._update_request_cls(self).update(**values)
@@ -758,10 +768,15 @@ class QueryModel(type):
     Metaclass of Model classes used for subqueries.
 
     """
+
     def __getattr__(self, item):
-        rv = getattr(self._query.columns, item,
-                     getattr(self._model.__table__.columns, item,
-                             getattr(self._model, item, DEFAULT)))
+        rv = getattr(
+            self._query.columns,
+            item,
+            getattr(
+                self._model.__table__.columns, item, getattr(self._model, item, DEFAULT)
+            ),
+        )
         # replace `cls` in classmethod in models to `self`
         if inspect.ismethod(rv) and inspect.isclass(rv.__self__):
             return lambda *args, **kwargs: rv.__func__(self, *args, **kwargs)