🦉 Updates from OwlBot post-processor

See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md

Author: gcf-owl-bot[bot]

google/cloud/spanner_v1/database.py

@@ -199,7 +199,6 @@ def __init__(
         pool.bind(self)
         self._session_manager = DatabaseSessionsManager(database=self, pool=pool)
 
-
     @classmethod
     def from_pb(cls, database_pb, instance, pool=None):
         """Creates an instance of this class from a protobuf.
@@ -785,8 +784,8 @@ def execute_pdml():
                     # re-raising the error.
                     except NotImplementedError as exc:
                         if (
-                                "Transaction type partitioned_dml not supported with multiplexed sessions"
-                                in str(exc)
+                            "Transaction type partitioned_dml not supported with multiplexed sessions"
+                            in str(exc)
                         ):
                             self.session_options.disable_multiplexed(
                                 self.logger, TransactionType.PARTITIONED
@@ -1261,6 +1260,7 @@ def __init__(
     ):
         # Move import here to avoid circular import
         from google.cloud.spanner_v1.database import Database
+
         if not isinstance(database, Database):
             raise TypeError(
                 "{class_name} must receive an instance of {expected_class_name}. Received: {actual_class_name}".format(
@@ -1290,6 +1290,7 @@ def __enter__(self):
     def __exit__(self, *ignored):
         self._database._session_manager.put_session(self._session)
 
+
 class BatchCheckout(object):
     """Context manager for using a batch from a database.
 
@@ -1978,4 +1979,3 @@ def _retry_on_aborted(func, retry_config):
     """
     retry = retry_config.with_predicate(if_exception_type(Aborted))
     return retry(func)
-

google/cloud/spanner_v1/database_sessions_manager.py

@@ -256,4 +256,4 @@ def _maintain_multiplexed_session(session_manager_ref) -> None:
                     session_manager._disable_multiplexed_sessions()
                     return
 
-            session_created_time = time.time()
+            session_created_time = time.time()

google/cloud/spanner_v1/pool.py

@@ -787,7 +787,3 @@ def begin_pending_transactions(self):
         while not self._pending_sessions.empty():
             session = self._pending_sessions.get()
             super(TransactionPingingPool, self).put(session)
-
-
-
-

google/cloud/spanner_v1/session_options.py

@@ -66,9 +66,8 @@ def use_multiplexed(self, transaction_type: TransactionType) -> bool:
         """
 
         if transaction_type is TransactionType.READ_ONLY:
-            return (
-                self._is_multiplexed_enabled[transaction_type]
-                and self._getenv(self.ENV_VAR_ENABLE_MULTIPLEXED)
+            return self._is_multiplexed_enabled[transaction_type] and self._getenv(
+                self.ENV_VAR_ENABLE_MULTIPLEXED
             )
 
         elif transaction_type is TransactionType.PARTITIONED:
@@ -80,7 +79,7 @@ def use_multiplexed(self, transaction_type: TransactionType) -> bool:
 
         elif transaction_type is TransactionType.READ_WRITE:
             return False
- 
+
         raise ValueError(f"Transaction type {transaction_type} is not supported.")
 
     def disable_multiplexed(
@@ -104,11 +103,15 @@ def disable_multiplexed(
         if transaction_type is None:
             if logger:
                 logger.warning(
-                    disable_multiplexed_log_msg_fstring.format(transaction_type_value="all")
+                    disable_multiplexed_log_msg_fstring.format(
+                        transaction_type_value="all"
+                    )
                 )
             else:
                 print(
-                    disable_multiplexed_log_msg_fstring.format(transaction_type_value="all")
+                    disable_multiplexed_log_msg_fstring.format(
+                        transaction_type_value="all"
+                    )
                 )
             for transaction_type in TransactionType:
                 self._is_multiplexed_enabled[transaction_type] = False
@@ -123,7 +126,9 @@ def disable_multiplexed(
                 )
             else:
                 print(
-                    disable_multiplexed_log_msg_fstring.format(transaction_type_value=transaction_type.value)
+                    disable_multiplexed_log_msg_fstring.format(
+                        transaction_type_value=transaction_type.value
+                    )
                 )
             self._is_multiplexed_enabled[transaction_type] = False
             return
@@ -137,4 +142,4 @@ def _getenv(name: str) -> bool:
         considered false.
         """
         env_var = os.getenv(name, "").lower().strip()
-        return env_var in ["1", "true"]
+        return env_var in ["1", "true"]

google/cloud/spanner_v1/snapshot.py

@@ -196,6 +196,7 @@ def _restart_on_unavailable(
 
         del item_buffer[:]
 
+
 def _handle_not_implemented_error(exception, database) -> None:
     """Handles NotImplementedError for the database. If the error is due to unsupported
     partitioned operations with multiplexed sessions, disables multiplexed sessions for
@@ -212,10 +213,13 @@ def _handle_not_implemented_error(exception, database) -> None:
         exception
     ):
         session_options = database.session_options
-        session_options.disable_multiplexed(database.logger, TransactionType.PARTITIONED)
+        session_options.disable_multiplexed(
+            database.logger, TransactionType.PARTITIONED
+        )
 
     raise exception
 
+
 class _SnapshotBase(_SessionWrapper):
     """Base class for Snapshot.
 
@@ -614,7 +618,6 @@ def wrapped_restart(*args, **kwargs):
                 return self._get_streamed_result_set(**get_streamed_result_set_args)
         return self._get_streamed_result_set(**get_streamed_result_set_args)
 
-
     def partition_read(
         self,
         table,
@@ -856,14 +859,14 @@ def attempt_tracking_method():
         return [partition.partition_token for partition in response.partitions]
 
     def _get_streamed_result_set(
-            self,
-            method,
-            request,
-            metadata,
-            trace_attributes,
-            column_info,
-            observability_options,
-            lazy_decode,
+        self,
+        method,
+        request,
+        metadata,
+        trace_attributes,
+        column_info,
+        observability_options,
+        lazy_decode,
     ):
         """Returns the streamed result set for a read or execute SQL request with the given arguments."""
 
@@ -901,6 +904,7 @@ def _get_streamed_result_set(
 
         return StreamedResultSet(**streamed_result_set_args)
 
+
 class Snapshot(_SnapshotBase):
     """Allow a set of reads / SQL statements with shared staleness.