apply black

Author: wwwjfy

src/gino/crud.py

@@ -152,8 +152,8 @@ async def apply(self, bind=None, timeout=DEFAULT):
                     )
             elif isinstance(prop.type, mysql_JSON):
                 values[prop_name] = sa.func.json_merge_patch(
-                    prop,
-                    sa.func.json_object(*itertools.chain(*updates.items())))
+                    prop, sa.func.json_object(*itertools.chain(*updates.items()))
+                )
             else:
                 raise TypeError(
                     "{} is not supported to update json "
@@ -171,8 +171,8 @@ async def apply(self, bind=None, timeout=DEFAULT):
             .execution_options(**opts)
         )
         await _query_and_update(
-            bind, self._instance, clause,
-            [getattr(cls, key) for key in values], opts)
+            bind, self._instance, clause, [getattr(cls, key) for key in values], opts
+        )
         for prop in self._props:
             prop.reload(self._instance)
         return self
@@ -806,7 +806,8 @@ async def _query_and_update(bind, item, query, cols, execution_opts):
             conn = bind
         try:
             lastrowid, affected_rows = await conn.all(
-                query.execution_options(return_affected_rows=True))
+                query.execution_options(return_affected_rows=True)
+            )
             if not lastrowid and not affected_rows:
                 raise NoSuchRowError()
             # It's insertion and primary key is AUTO_INCREMENT
@@ -815,13 +816,15 @@ async def _query_and_update(bind, item, query, cols, execution_opts):
                 query = (
                     sa.select(cols)
                     .where(pkey.columns.values()[0] == lastrowid)
-                    .execution_options(**execution_opts))
+                    .execution_options(**execution_opts)
+                )
             else:
                 try:
                     query = (
                         sa.select(cols)
                         .where(item.lookup())
-                        .execution_options(**execution_opts))
+                        .execution_options(**execution_opts)
+                    )
                 except LookupError:  # no primary key
                     return None
             row = await conn.first(query)

src/gino/dialects/aiomysql.py

@@ -7,7 +7,7 @@
 
 import aiomysql
 from sqlalchemy import util, exc
-from sqlalchemy.dialects.mysql import (JSON, ENUM)
+from sqlalchemy.dialects.mysql import JSON, ENUM
 from sqlalchemy.dialects.mysql.base import (
     MySQLCompiler,
     MySQLDialect,
@@ -27,10 +27,11 @@
 #: executemany only suports simple bulk insert.
 #: You can use it to load large dataset.
 _RE_INSERT_VALUES = re.compile(
-    r"\s*((?:INSERT|REPLACE)\s.+\sVALUES?\s+)" +
-    r"(\(\s*(?:%s|%\(.+\)s)\s*(?:,\s*(?:%s|%\(.+\)s)\s*)*\))" +
-    r"(\s*(?:ON DUPLICATE.*)?);?\s*\Z",
-    re.IGNORECASE | re.DOTALL)
+    r"\s*((?:INSERT|REPLACE)\s.+\sVALUES?\s+)"
+    + r"(\(\s*(?:%s|%\(.+\)s)\s*(?:,\s*(?:%s|%\(.+\)s)\s*)*\))"
+    + r"(\s*(?:ON DUPLICATE.*)?);?\s*\Z",
+    re.IGNORECASE | re.DOTALL,
+)
 
 #: Max statement size which :meth:`executemany` generates.
 #:
@@ -45,8 +46,7 @@ class AiomysqlDBAPI(base.BaseDBAPI):
 
 
 # noinspection PyAbstractClass
-class AiomysqlExecutionContext(base.ExecutionContextOverride,
-                               MySQLExecutionContext):
+class AiomysqlExecutionContext(base.ExecutionContextOverride, MySQLExecutionContext):
     async def _execute_scalar(self, stmt, type_):
         conn = self.root_connection
         if (
@@ -104,8 +104,7 @@ async def _init(self):
 
     async def __anext__(self):
         await self._init()
-        row = await asyncio.wait_for(
-            self._cursor.fetchone(), self._context.timeout)
+        row = await asyncio.wait_for(self._cursor.fetchone(), self._context.timeout)
         if row is None:
             raise StopAsyncIteration
         return self._context.process_rows([row])[0]
@@ -129,7 +128,7 @@ async def forward(self, n, *, timeout=base.DEFAULT):
         await self._init()
         if timeout is base.DEFAULT:
             timeout = self._context.timeout
-        await asyncio.wait_for(self._cursor.scroll(n, mode='relative'), timeout)
+        await asyncio.wait_for(self._cursor.scroll(n, mode="relative"), timeout)
 
 
 class DBAPICursor(base.DBAPICursor):
@@ -156,7 +155,8 @@ async def async_execute(self, query, timeout, args, limit=0, many=False):
             return await self._async_execute(conn, query, timeout, args)
 
         return await asyncio.wait_for(
-            self._async_executemany(conn, query, args), timeout=timeout)
+            self._async_executemany(conn, query, args), timeout=timeout
+        )
 
     async def _async_execute(self, conn, query, timeout, args):
         if args is not None:
@@ -175,9 +175,10 @@ async def _async_executemany(self, conn, query, args):
         if m:
             q_prefix = m.group(1)
             q_values = m.group(2).rstrip()
-            q_postfix = m.group(3) or ''
-            return (await self._do_execute_many(
-                conn, q_prefix, q_values, q_postfix, args))
+            q_postfix = m.group(3) or ""
+            return await self._do_execute_many(
+                conn, q_prefix, q_values, q_postfix, args
+            )
         else:
             rows = 0
             for arg in args:
@@ -196,19 +197,19 @@ async def _do_execute_many(self, conn, prefix, values, postfix, args):
         args = iter(args)
         v = values % escape(next(args), conn)
         if isinstance(v, str):
-            v = v.encode(conn.encoding, 'surrogateescape')
+            v = v.encode(conn.encoding, "surrogateescape")
         stmt += v
         rows = 0
         for arg in args:
             v = values % escape(arg, conn)
             if isinstance(v, str):
-                v = v.encode(conn.encoding, 'surrogateescape')
+                v = v.encode(conn.encoding, "surrogateescape")
             if len(stmt) + len(v) + len(postfix) + 1 > _MAX_STMT_LENGTH:
                 await self._async_execute(conn, stmt + postfix, None, None)
                 rows += self.affected_rows
                 stmt = bytearray(prefix)
             else:
-                stmt += b','
+                stmt += b","
             stmt += v
         await self._async_execute(conn, stmt + postfix, None, None)
         rows += self.affected_rows
@@ -224,8 +225,7 @@ def get_statusmsg(self):
 
     def iterate(self, context):
         # use SSCursor to get server side cursor
-        return AiomysqlIterator(
-            context, aiomysql.SSCursor(self._conn.raw_connection))
+        return AiomysqlIterator(context, aiomysql.SSCursor(self._conn.raw_connection))
 
 
 class Pool(base.Pool):
@@ -288,7 +288,7 @@ def repr(self, color):
                     + "."
                     + self._pool.__class__.__name__,
                     fg="green",
-                    ),
+                ),
                 max=click.style(repr(self._pool.maxsize), fg="cyan"),
                 min=click.style(repr(self._pool._minsize), fg="cyan"),
                 cur=click.style(repr(self._pool.size), fg="cyan"),
@@ -298,8 +298,8 @@ def repr(self, color):
             # noinspection PyProtectedMember
             return "<{classname} max={max} min={min} cur={cur} use={use}>".format(
                 classname=self._pool.__class__.__module__
-                          + "."
-                          + self._pool.__class__.__name__,
+                + "."
+                + self._pool.__class__.__name__,
                 max=self._pool.maxsize,
                 min=self._pool._minsize,
                 cur=self._pool.size,
@@ -371,14 +371,12 @@ class AiomysqlDialect(MySQLDialect, base.AsyncDialectMixin):
                 for f in [aiomysql.create_pool, aiomysql.connect]
             ]
         )
-    ) - {'echo'}  # use SQLAlchemy's echo instead
+    ) - {
+        "echo"
+    }  # use SQLAlchemy's echo instead
     colspecs = util.update_copy(
         MySQLDialect.colspecs,
-        {
-            ENUM: AsyncEnum,
-            sqltypes.Enum: AsyncEnum,
-            sqltypes.NullType: GinoNullType,
-        },
+        {ENUM: AsyncEnum, sqltypes.Enum: AsyncEnum, sqltypes.NullType: GinoNullType,},
     )
     postfetch_lastrowid = False
     support_returning = False
@@ -395,15 +393,16 @@ def __init__(self, *args, **kwargs):
     async def init_pool(self, url, loop, pool_class=None):
         if pool_class is None:
             pool_class = Pool
-        return await pool_class(
-            url, loop, init=self.on_connect(), **self._pool_kwargs)
+        return await pool_class(url, loop, init=self.on_connect(), **self._pool_kwargs)
 
     # noinspection PyMethodMayBeStatic
     def transaction(self, raw_conn, args, kwargs):
         _set_isolation = None
-        if 'isolation' in kwargs:
+        if "isolation" in kwargs:
+
             async def _set_isolation(conn):
-                await self.set_isolation_level(conn, kwargs['isolation'])
+                await self.set_isolation_level(conn, kwargs["isolation"])
+
         return Transaction(raw_conn, _set_isolation)
 
     def on_connect(self):
@@ -428,15 +427,13 @@ async def _set_isolation_level(self, connection, level):
                 % (level, self.name, ", ".join(self._isolation_lookup))
             )
         cursor = await connection.cursor()
-        await cursor.execute(
-            "SET SESSION TRANSACTION ISOLATION LEVEL %s" % level)
+        await cursor.execute("SET SESSION TRANSACTION ISOLATION LEVEL %s" % level)
         await cursor.execute("COMMIT")
         await cursor.close()
 
     async def get_isolation_level(self, connection):
         if self.server_version_info is None:
-            self.server_version_info = await self._get_server_version_info(
-                connection)
+            self.server_version_info = await self._get_server_version_info(connection)
         cursor = await connection.cursor()
         if self._is_mysql and self.server_version_info >= (5, 7, 20):
             await cursor.execute("SELECT @@transaction_isolation")
@@ -484,9 +481,7 @@ def _parse_server_version(self, val):
 
     async def has_table(self, connection, table_name, schema=None):
         full_name = ".".join(
-            self.identifier_preparer._quote_free_identifiers(
-                schema, table_name
-            )
+            self.identifier_preparer._quote_free_identifiers(schema, table_name)
         )
 
         st = "DESCRIBE %s" % full_name
@@ -502,6 +497,7 @@ def _extract_error_code(self, exception):
             exception = exception.args[0]
         return exception.args[0]
 
+
 def _escape_args(args, conn):
     if isinstance(args, (tuple, list)):
         return tuple(conn.escape(arg) for arg in args)

src/gino/dialects/base.py

@@ -93,9 +93,7 @@ async def _do_execute(
             self.clause, *multiparams, **params
         ).context
         if ctx.executemany:
-            raise ValueError(
-                "PreparedStatement does not support multiple parameters."
-            )
+            raise ValueError("PreparedStatement does not support multiple parameters.")
         if ctx.statement != self.context.statement:
             raise AssertionError(
                 "Prepared statement generated different SQL with parameters"
@@ -225,11 +223,10 @@ async def execute(self, one=False, return_model=True, status=False):
                 rows = await cursor.async_execute(
                     context.statement, context.timeout, args, 1 if one else 0
                 )
-            if (not self.context.dialect.support_returning and
-                    (self.context.isinsert or self.context.isupdate)):
-                if self.context.execution_options.get(
-                    'return_affected_rows', False
-                ):
+            if not self.context.dialect.support_returning and (
+                self.context.isinsert or self.context.isupdate
+            ):
+                if self.context.execution_options.get("return_affected_rows", False):
                     return context.get_lastrowid(), context.get_affected_rows()
                 return context.get_lastrowid()
             item = context.process_rows(rows, return_model=return_model)