🦉 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

@@ -201,7 +201,7 @@ def __init__(
 
         self._pool = pool
         pool.bind(self)
-        
+
         # Initialize session options and sessions manager for multiplexed session support
         self.session_options = SessionOptions()
         self._sessions_manager = DatabaseSessionsManager(self, pool)
@@ -766,9 +766,11 @@ def execute_pdml():
                 observability_options=self.observability_options,
             ) as span, MetricsCapture():
                 from google.cloud.spanner_v1.session_options import TransactionType
-                
+
                 # Use sessions manager for partitioned DML operations
-                session = self._sessions_manager.get_session(TransactionType.PARTITIONED)
+                session = self._sessions_manager.get_session(
+                    TransactionType.PARTITIONED
+                )
                 try:
                     add_span_event(span, "Starting BeginTransaction")
                     txn = api.begin_transaction(
@@ -1255,7 +1257,7 @@ def observability_options(self):
     @property
     def sessions_manager(self):
         """Returns the database sessions manager.
-        
+
         :rtype: :class:`~google.cloud.spanner_v1.database_sessions_manager.DatabaseSessionsManager`
         :returns: The sessions manager for this database.
         """
@@ -1312,7 +1314,7 @@ def __init__(
     def __enter__(self):
         """Begin ``with`` block."""
         from google.cloud.spanner_v1.session_options import TransactionType
-        
+
         current_span = get_current_span()
         session = self._session = self._database.sessions_manager.get_session(
             TransactionType.READ_WRITE
@@ -1370,7 +1372,7 @@ def __init__(self, database):
     def __enter__(self):
         """Begin ``with`` block."""
         from google.cloud.spanner_v1.session_options import TransactionType
-        
+
         session = self._session = self._database.sessions_manager.get_session(
             TransactionType.READ_WRITE
         )
@@ -1413,7 +1415,7 @@ def __init__(self, database, **kw):
     def __enter__(self):
         """Begin ``with`` block."""
         from google.cloud.spanner_v1.session_options import TransactionType
-        
+
         session = self._session = self._database.sessions_manager.get_session(
             TransactionType.READ_ONLY
         )
@@ -1508,7 +1510,7 @@ def _get_session(self):
         """
         if self._session is None:
             from google.cloud.spanner_v1.session_options import TransactionType
-            
+
             # Use sessions manager for partition operations
             session = self._session = self._database.sessions_manager.get_session(
                 TransactionType.PARTITIONED

google/cloud/spanner_v1/session_options.py

@@ -69,9 +69,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:
@@ -130,4 +129,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"]

tests/unit/test_database.py

@@ -1263,25 +1263,32 @@ def _execute_partitioned_dml_helper(
         session = _Session()
         pool.put(session)
         database = self._make_one(self.DATABASE_ID, instance, pool=pool)
-        
+
         # Check if multiplexed sessions are enabled for partitioned operations
-        multiplexed_partitioned_enabled = os.environ.get(
-            "GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS_PARTITIONED_OPS", "false"
-        ).lower() == "true"
-        
+        multiplexed_partitioned_enabled = (
+            os.environ.get(
+                "GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS_PARTITIONED_OPS", "false"
+            ).lower()
+            == "true"
+        )
+
         if multiplexed_partitioned_enabled:
             # When multiplexed sessions are enabled, create a mock multiplexed session
             # that the sessions manager will return
             multiplexed_session = _Session()
-            multiplexed_session.name = self.SESSION_NAME  # Use the expected session name
+            multiplexed_session.name = (
+                self.SESSION_NAME
+            )  # Use the expected session name
             multiplexed_session.is_multiplexed = True
             # Configure the sessions manager to return the multiplexed session
-            database._sessions_manager.get_session = mock.Mock(return_value=multiplexed_session)
+            database._sessions_manager.get_session = mock.Mock(
+                return_value=multiplexed_session
+            )
             expected_session = multiplexed_session
         else:
             # When multiplexed sessions are disabled, use the regular pool session
             expected_session = session
-        
+
         api = database._spanner_api = self._make_spanner_api()
         api._method_configs = {"ExecuteStreamingSql": MethodConfig(retry=Retry())}
         if retried:
@@ -1446,12 +1453,15 @@ def _execute_partitioned_dml_helper(
                 ],
             )
             self.assertEqual(api.execute_streaming_sql.call_count, 1)
-            
+
         # Verify that the correct session type was used based on environment
         if multiplexed_partitioned_enabled:
             # Verify that sessions_manager.get_session was called with PARTITIONED transaction type
             from google.cloud.spanner_v1.session_options import TransactionType
-            database._sessions_manager.get_session.assert_called_with(TransactionType.PARTITIONED)
+
+            database._sessions_manager.get_session.assert_called_with(
+                TransactionType.PARTITIONED
+            )
         # If multiplexed sessions are not enabled, the regular pool session should be used
 
     def test_execute_partitioned_dml_wo_params(self):
@@ -1542,16 +1552,20 @@ def test_snapshot_defaults(self):
         database = self._make_one(self.DATABASE_ID, instance, pool=pool)
 
         # Check if multiplexed sessions are enabled for read operations
-        multiplexed_enabled = os.getenv("GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS") == "true"
-        
+        multiplexed_enabled = (
+            os.getenv("GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS") == "true"
+        )
+
         if multiplexed_enabled:
             # When multiplexed sessions are enabled, configure the sessions manager
             # to return a multiplexed session for read operations
             multiplexed_session = _Session()
             multiplexed_session.name = self.SESSION_NAME
             multiplexed_session.is_multiplexed = True
             # Override the side_effect to return the multiplexed session
-            database._sessions_manager.get_session = mock.Mock(return_value=multiplexed_session)
+            database._sessions_manager.get_session = mock.Mock(
+                return_value=multiplexed_session
+            )
             expected_session = multiplexed_session
         else:
             expected_session = session
@@ -1588,16 +1602,20 @@ def test_snapshot_w_read_timestamp_and_multi_use(self):
         database = self._make_one(self.DATABASE_ID, instance, pool=pool)
 
         # Check if multiplexed sessions are enabled for read operations
-        multiplexed_enabled = os.getenv("GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS") == "true"
-        
+        multiplexed_enabled = (
+            os.getenv("GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS") == "true"
+        )
+
         if multiplexed_enabled:
             # When multiplexed sessions are enabled, configure the sessions manager
             # to return a multiplexed session for read operations
             multiplexed_session = _Session()
             multiplexed_session.name = self.SESSION_NAME
             multiplexed_session.is_multiplexed = True
             # Override the side_effect to return the multiplexed session
-            database._sessions_manager.get_session = mock.Mock(return_value=multiplexed_session)
+            database._sessions_manager.get_session = mock.Mock(
+                return_value=multiplexed_session
+            )
             expected_session = multiplexed_session
         else:
             expected_session = session
@@ -2557,7 +2575,10 @@ def test__get_session_new(self):
         self.assertIs(batch_txn._get_session(), session)
         # Verify that sessions_manager.get_session was called with PARTITIONED transaction type
         from google.cloud.spanner_v1.session_options import TransactionType
-        database.sessions_manager.get_session.assert_called_once_with(TransactionType.PARTITIONED)
+
+        database.sessions_manager.get_session.assert_called_once_with(
+            TransactionType.PARTITIONED
+        )
 
     def test__get_snapshot_already(self):
         database = self._make_database()
@@ -3518,17 +3539,25 @@ def __init__(self, name, instance=None):
         self.default_transaction_options = DefaultTransactionOptions()
         self._nth_request = AtomicCounter()
         self._nth_client_id = _Database.NTH_CLIENT_ID.increment()
-        
+
         # Mock sessions manager for multiplexed sessions support
         self._sessions_manager = mock.Mock()
-        # Configure get_session to return sessions from the pool  
-        self._sessions_manager.get_session = mock.Mock(side_effect=lambda tx_type: self._pool.get() if hasattr(self, '_pool') and self._pool else None)
-        self._sessions_manager.put_session = mock.Mock(side_effect=lambda session: self._pool.put(session) if hasattr(self, '_pool') and self._pool else None)
+        # Configure get_session to return sessions from the pool
+        self._sessions_manager.get_session = mock.Mock(
+            side_effect=lambda tx_type: self._pool.get()
+            if hasattr(self, "_pool") and self._pool
+            else None
+        )
+        self._sessions_manager.put_session = mock.Mock(
+            side_effect=lambda session: self._pool.put(session)
+            if hasattr(self, "_pool") and self._pool
+            else None
+        )
 
     @property
     def sessions_manager(self):
         """Returns the database sessions manager.
-        
+
         :rtype: Mock
         :returns: The mock sessions manager for this database.
         """