format code using ruff

Author: ohmayr

packages/django-google-spanner/django_spanner/__init__.py

@@ -6,32 +6,32 @@
 
 import datetime
 import os
-import django
 
 # Monkey-patch AutoField to generate a random value since Cloud Spanner can't
 # do that.
 from uuid import uuid4
 
+import django
+
 RANDOM_ID_GENERATION_ENABLED_SETTING = "RANDOM_ID_GENERATION_ENABLED"
 
 from django.conf.global_settings import DATABASES
 from django.db import DEFAULT_DB_ALIAS
-from google.cloud.spanner_v1 import JsonObject
 from django.db.models.fields import (
     NOT_PROVIDED,
     AutoField,
     Field,
 )
 
-from .functions import register_functions
-from .lookups import register_lookups
-from .utils import check_django_compatability
-from .version import __version__
-
 # Monkey-patch google.DatetimeWithNanoseconds's __eq__ compare against
 # datetime.datetime.
 from google.api_core.datetime_helpers import DatetimeWithNanoseconds
+from google.cloud.spanner_v1 import JsonObject
 
+from .functions import register_functions
+from .lookups import register_lookups
+from .utils import check_django_compatability
+from .version import __version__
 
 USING_DJANGO_3 = False
 if django.VERSION[:2] == (3, 2):
@@ -41,11 +41,11 @@
 if django.VERSION[:2] == (4, 2):
     USING_DJANGO_4 = True
 
+from django.db.models import JSONField
 from django.db.models.fields import (
-    SmallAutoField,
     BigAutoField,
+    SmallAutoField,
 )
-from django.db.models import JSONField
 
 USE_EMULATOR = os.getenv("SPANNER_EMULATOR_HOST") is not None
 
@@ -109,9 +109,7 @@ def get_prep_value(self, value):
 
 JSONField.get_prep_value = get_prep_value
 
-old_datetimewithnanoseconds_eq = getattr(
-    DatetimeWithNanoseconds, "__eq__", None
-)
+old_datetimewithnanoseconds_eq = getattr(DatetimeWithNanoseconds, "__eq__", None)
 
 
 def datetimewithnanoseconds_eq(self, other):

packages/django-google-spanner/django_spanner/base.py

@@ -6,18 +6,17 @@
 
 import os
 
-from google.cloud import spanner
-
 from django.db.backends.base.base import BaseDatabaseWrapper
-from google.cloud import spanner_dbapi
+from google.cloud import spanner, spanner_dbapi
+
+from django_spanner import USING_DJANGO_3
 
 from .client import DatabaseClient
 from .creation import DatabaseCreation
 from .features import DatabaseFeatures
 from .introspection import DatabaseIntrospection
 from .operations import DatabaseOperations
 from .schema import DatabaseSchemaEditor
-from django_spanner import USING_DJANGO_3
 
 
 class DatabaseWrapper(BaseDatabaseWrapper):
@@ -86,7 +85,9 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     # expression or the result of a bilateral transformation). In those cases,
     # special characters for REGEXP_CONTAINS operators (e.g. \, *, _) must be
     # escaped on database side.
-    pattern_esc = r'REPLACE(REPLACE(REPLACE({}, "\\", "\\\\"), "%%", r"\%%"), "_", r"\_")'
+    pattern_esc = (
+        r'REPLACE(REPLACE(REPLACE({}, "\\", "\\\\"), "%%", r"\%%"), "_", r"\_")'
+    )
 
     # These are all no-ops in favor of using REGEXP_CONTAINS in the customized
     # lookups.
@@ -123,7 +124,9 @@ def instance(self):
         if "client" in self.settings_dict["OPTIONS"]:
             client = self.settings_dict["OPTIONS"]["client"]
         else:
-            client = spanner.Client(project=os.environ.get("GOOGLE_CLOUD_PROJECT", "test-project"))
+            client = spanner.Client(
+                project=os.environ.get("GOOGLE_CLOUD_PROJECT", "test-project")
+            )
         return client.instance(self.settings_dict["INSTANCE"])
 
     @property
@@ -137,9 +140,7 @@ def allow_transactions_in_auto_commit(self):
 
     @property
     def _nodb_connection(self):
-        raise NotImplementedError(
-            'Spanner does not have a "no db" connection.'
-        )
+        raise NotImplementedError('Spanner does not have a "no db" connection.')
 
     def get_connection_params(self):
         """Retrieve the connection parameters.

packages/django-google-spanner/django_spanner/compiler.py

@@ -7,12 +7,21 @@
 from django.core.exceptions import EmptyResultSet
 from django.db.models.sql.compiler import (
     SQLAggregateCompiler as BaseSQLAggregateCompiler,
+)
+from django.db.models.sql.compiler import (
     SQLCompiler as BaseSQLCompiler,
+)
+from django.db.models.sql.compiler import (
     SQLDeleteCompiler as BaseSQLDeleteCompiler,
+)
+from django.db.models.sql.compiler import (
     SQLInsertCompiler as BaseSQLInsertCompiler,
+)
+from django.db.models.sql.compiler import (
     SQLUpdateCompiler as BaseSQLUpdateCompiler,
 )
 from django.db.utils import DatabaseError
+
 from django_spanner import USING_DJANGO_3
 
 
@@ -49,29 +58,23 @@ def get_combinator_sql(self, combinator, all):
                 if not query.is_empty()
             ]
             if not features.supports_slicing_ordering_in_compound:
-                for query, compiler in zip(
-                    self.query.combined_queries, compilers
-                ):
+                for query, compiler in zip(self.query.combined_queries, compilers):
                     if query.low_mark or query.high_mark:
                         raise DatabaseError(
                             "LIMIT/OFFSET not allowed in subqueries of compound "
                             "statements."
                         )
                     if compiler.get_order_by():
                         raise DatabaseError(
-                            "ORDER BY not allowed in subqueries of compound "
-                            "statements."
+                            "ORDER BY not allowed in subqueries of compound statements."
                         )
             parts = ()
             for compiler in compilers:
                 try:
                     # If the columns list is limited, then all combined queries
                     # must have the same columns list. Set the selects defined on
                     # the query on all combined queries, if not already set.
-                    if (
-                        not compiler.query.values_select
-                        and self.query.values_select
-                    ):
+                    if not compiler.query.values_select and self.query.values_select:
                         compiler.query.set_values(
                             (
                                 *self.query.extra_select,
@@ -87,17 +90,13 @@ def get_combinator_sql(self, combinator, all):
                             part_sql = "SELECT * FROM ({})".format(part_sql)
                         # Add parentheses when combining with compound query if not
                         # already added for all compound queries.
-                        elif (
-                            not features.supports_slicing_ordering_in_compound
-                        ):
+                        elif not features.supports_slicing_ordering_in_compound:
                             part_sql = "({})".format(part_sql)
                     parts += ((part_sql, part_args),)
                 except EmptyResultSet:
                     # Omit the empty queryset with UNION and with DIFFERENCE if the
                     # first queryset is nonempty.
-                    if combinator == "union" or (
-                        combinator == "difference" and parts
-                    ):
+                    if combinator == "union" or (combinator == "difference" and parts):
                         continue
                     raise
             if not parts:
@@ -106,11 +105,7 @@ def get_combinator_sql(self, combinator, all):
             # This is the only line that is changed from the Django core
             # implementation of this method
             combinator_sql += " ALL" if all else " DISTINCT"
-            braces = (
-                "({})"
-                if features.supports_slicing_ordering_in_compound
-                else "{}"
-            )
+            braces = "({})" if features.supports_slicing_ordering_in_compound else "{}"
             sql_parts, args_parts = zip(
                 *((braces.format(sql), args) for sql, args in parts)
             )
@@ -126,9 +121,7 @@ def get_combinator_sql(self, combinator, all):
         else:
             features = self.connection.features
             compilers = [
-                query.get_compiler(
-                    self.using, self.connection, self.elide_empty
-                )
+                query.get_compiler(self.using, self.connection, self.elide_empty)
                 for query in self.query.combined_queries
             ]
             if not features.supports_slicing_ordering_in_compound:
@@ -154,10 +147,7 @@ def get_combinator_sql(self, combinator, all):
                     # If the columns list is limited, then all combined queries
                     # must have the same columns list. Set the selects defined on
                     # the query on all combined queries, if not already set.
-                    if (
-                        not compiler.query.values_select
-                        and self.query.values_select
-                    ):
+                    if not compiler.query.values_select and self.query.values_select:
                         compiler.query = compiler.query.clone()
                         compiler.query.set_values(
                             (
@@ -166,9 +156,7 @@ def get_combinator_sql(self, combinator, all):
                                 *self.query.annotation_select,
                             )
                         )
-                    part_sql, part_args = compiler.as_sql(
-                        with_col_aliases=True
-                    )
+                    part_sql, part_args = compiler.as_sql(with_col_aliases=True)
                     if compiler.query.combinator:
                         # Wrap in a subquery if wrapping in parentheses isn't
                         # supported.
@@ -190,9 +178,7 @@ def get_combinator_sql(self, combinator, all):
                 except EmptyResultSet:
                     # Omit the empty queryset with UNION and with DIFFERENCE if the
                     # first queryset is nonempty.
-                    if combinator == "union" or (
-                        combinator == "difference" and parts
-                    ):
+                    if combinator == "union" or (combinator == "difference" and parts):
                         continue
                     raise
             if not parts:

packages/django-google-spanner/django_spanner/creation.py

@@ -86,9 +86,7 @@ def _create_test_db(self, verbosity, autoclobber, keepdb=False):
                     self._destroy_test_db(test_database_name, verbosity)
                     self._execute_create_test_db(None, test_db_params, keepdb)
                 except Exception as e:
-                    self.log(
-                        "Got an error recreating the test database: %s" % e
-                    )
+                    self.log("Got an error recreating the test database: %s" % e)
                     sys.exit(2)
             else:
                 self.log("Tests cancelled.")

packages/django-google-spanner/django_spanner/features.py

@@ -8,6 +8,7 @@
 
 from django.db.backends.base.features import BaseDatabaseFeatures
 from django.db.utils import InterfaceError
+
 from django_spanner import USE_EMULATOR, USING_DJANGO_3, USING_DJANGO_4
 
 

packages/django-google-spanner/django_spanner/functions.py

@@ -61,9 +61,7 @@ def cast(self, compiler, connection, **extra_context):
         template = "SUBSTR(" + self.template + ", 0, %s)" % max_length
     else:
         template = self.template
-    return self.as_sql(
-        compiler, connection, template=template, **extra_context
-    )
+    return self.as_sql(compiler, connection, template=template, **extra_context)
 
 
 def chr_(self, compiler, connection, **extra_context):
@@ -92,7 +90,7 @@ def chr_(self, compiler, connection, **extra_context):
         compiler,
         connection,
         template="CODE_POINTS_TO_STRING([%(expressions)s])",
-        **extra_context
+        **extra_context,
     )
 
 
@@ -150,10 +148,7 @@ def cot(self, compiler, connection, **extra_context):
               to be replaced with the elements of the `list`.
     """
     return self.as_sql(
-        compiler,
-        connection,
-        template="(1 / TAN(%(expressions)s))",
-        **extra_context
+        compiler, connection, template="(1 / TAN(%(expressions)s))", **extra_context
     )
 
 
@@ -183,7 +178,7 @@ def degrees(self, compiler, connection, **extra_context):
         compiler,
         connection,
         template="((%%(expressions)s) * 180 / %s)" % math.pi,
-        **extra_context
+        **extra_context,
     )
 
 
@@ -266,7 +261,7 @@ def ord_(self, compiler, connection, **extra_context):
         compiler,
         connection,
         template="TO_CODE_POINTS(%(expressions)s)[OFFSET(0)]",
-        **extra_context
+        **extra_context,
     )
 
 
@@ -292,9 +287,7 @@ def pi(self, compiler, connection, **extra_context):
     :returns: A tuple where `str` is a string containing ordered SQL parameters
               to be replaced with the elements of the `list`.
     """
-    return self.as_sql(
-        compiler, connection, template=str(math.pi), **extra_context
-    )
+    return self.as_sql(compiler, connection, template=str(math.pi), **extra_context)
 
 
 def radians(self, compiler, connection, **extra_context):
@@ -323,7 +316,7 @@ def radians(self, compiler, connection, **extra_context):
         compiler,
         connection,
         template="((%%(expressions)s) * %s / 180)" % math.pi,
-        **extra_context
+        **extra_context,
     )
 
 
@@ -349,9 +342,7 @@ def strindex(self, compiler, connection, **extra_context):
     :returns: A tuple where `str` is a string containing ordered SQL parameters
               to be replaced with the elements of the `list`.
     """
-    return self.as_sql(
-        compiler, connection, function="STRPOS", **extra_context
-    )
+    return self.as_sql(compiler, connection, function="STRPOS", **extra_context)
 
 
 def substr(self, compiler, connection, **extra_context):
@@ -376,9 +367,7 @@ def substr(self, compiler, connection, **extra_context):
     :returns: A tuple where `str` is a string containing ordered SQL parameters
               to be replaced with the elements of the `list`.
     """
-    return self.as_sql(
-        compiler, connection, function="SUBSTR", **extra_context
-    )
+    return self.as_sql(compiler, connection, function="SUBSTR", **extra_context)
 
 
 def register_functions():

packages/django-google-spanner/django_spanner/introspection.py

@@ -11,6 +11,7 @@
 )
 from django.db.models import Index
 from google.cloud.spanner_v1 import TypeCode
+
 from django_spanner import USE_EMULATOR
 
 
@@ -91,8 +92,7 @@ def get_table_description(self, cursor, table_name):
                   cursor.description interface.
         """
         cursor.execute(
-            "SELECT * FROM %s LIMIT 1"
-            % self.connection.ops.quote_name(table_name)
+            "SELECT * FROM %s LIMIT 1" % self.connection.ops.quote_name(table_name)
         )
         column_details = cursor.get_table_column_schema(table_name)
         descriptions = []

packages/django-google-spanner/django_spanner/lookups.py

@@ -211,8 +211,7 @@ def startswith_endswith(self, compiler, connection):
             sql += ", '$'"
         sql += ")"
         return (
-            "REGEXP_CONTAINS(%s, %s)"
-            % (lhs_sql, connection.pattern_esc.format(sql)),
+            "REGEXP_CONTAINS(%s, %s)" % (lhs_sql, connection.pattern_esc.format(sql)),
             params,
         )