🦉 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/_helpers.py

@@ -201,21 +201,22 @@ def _datetime_to_rfc3339_nanoseconds(value):
 @dataclass
 class Interval:
     """Represents a Spanner INTERVAL type.
-    
+
     An interval is a combination of months, days and nanoseconds.
     Internally, Spanner supports Interval value with the following range of individual fields:
     months: [-120000, 120000]
     days: [-3660000, 3660000]
     nanoseconds: [-316224000000000000000, 316224000000000000000]
     """
+
     months: int = 0
     days: int = 0
     nanos: int = 0
 
     def __str__(self) -> str:
         """Returns the ISO8601 duration format string representation."""
         result = ["P"]
-        
+
         # Handle years and months
         if self.months:
             is_negative = self.months < 0
@@ -225,43 +226,43 @@ def __str__(self) -> str:
                 result.append(f"{'-' if is_negative else ''}{years}Y")
             if months:
                 result.append(f"{'-' if is_negative else ''}{months}M")
-            
+
         # Handle days
         if self.days:
             result.append(f"{self.days}D")
-            
+
         # Handle time components
         if self.nanos:
             result.append("T")
             nanos = abs(self.nanos)
             is_negative = self.nanos < 0
-            
+
             # Convert to hours, minutes, seconds
             nanos_per_hour = 3600000000000
             hours, nanos = divmod(nanos, nanos_per_hour)
             if hours:
                 if is_negative:
                     result.append("-")
                 result.append(f"{hours}H")
-                
+
             nanos_per_minute = 60000000000
             minutes, nanos = divmod(nanos, nanos_per_minute)
             if minutes:
                 if is_negative:
                     result.append("-")
                 result.append(f"{minutes}M")
-                
+
             nanos_per_second = 1000000000
             seconds, nanos_fraction = divmod(nanos, nanos_per_second)
-            
+
             if seconds or nanos_fraction:
                 if is_negative:
                     result.append("-")
                 if seconds:
                     result.append(str(seconds))
                 elif nanos_fraction:
                     result.append("0")
-                    
+
                 if nanos_fraction:
                     nano_str = f"{nanos_fraction:09d}"
                     trimmed = nano_str.rstrip("0")
@@ -276,54 +277,58 @@ def __str__(self) -> str:
                             trimmed += "0"
                     result.append(f".{trimmed}")
                 result.append("S")
-                
+
         if len(result) == 1:
             result.append("0Y")  # Special case for zero interval
-            
+
         return "".join(result)
 
     @classmethod
-    def from_str(cls, s: str) -> 'Interval':
+    def from_str(cls, s: str) -> "Interval":
         """Parse an ISO8601 duration format string into an Interval."""
-        pattern = r'^P(-?\d+Y)?(-?\d+M)?(-?\d+D)?(T(-?\d+H)?(-?\d+M)?(-?((\d+([.,]\d{1,9})?)|([.,]\d{1,9}))S)?)?$'
+        pattern = r"^P(-?\d+Y)?(-?\d+M)?(-?\d+D)?(T(-?\d+H)?(-?\d+M)?(-?((\d+([.,]\d{1,9})?)|([.,]\d{1,9}))S)?)?$"
         match = re.match(pattern, s)
         if not match or len(s) == 1:
             raise ValueError(f"Invalid interval format: {s}")
-            
+
         parts = match.groups()
         if not any(parts[:3]) and not parts[3]:
-            raise ValueError(f"Invalid interval format: at least one component (Y/M/D/H/M/S) is required: {s}")
-            
+            raise ValueError(
+                f"Invalid interval format: at least one component (Y/M/D/H/M/S) is required: {s}"
+            )
+
         if parts[3] == "T" and not any(parts[4:7]):
-            raise ValueError(f"Invalid interval format: time designator 'T' present but no time components specified: {s}")
-            
+            raise ValueError(
+                f"Invalid interval format: time designator 'T' present but no time components specified: {s}"
+            )
+
         def parse_num(s: str, suffix: str) -> int:
             if not s:
                 return 0
             return int(s.rstrip(suffix))
-            
+
         years = parse_num(parts[0], "Y")
         months = parse_num(parts[1], "M")
         total_months = years * 12 + months
-        
+
         days = parse_num(parts[2], "D")
-        
+
         nanos = 0
         if parts[3]:  # Has time component
             # Convert hours to nanoseconds
             hours = parse_num(parts[4], "H")
             nanos += hours * 3600000000000
-            
+
             # Convert minutes to nanoseconds
             minutes = parse_num(parts[5], "M")
             nanos += minutes * 60000000000
-            
+
             # Handle seconds and fractional seconds
             if parts[6]:
                 seconds = parts[6].rstrip("S")
                 if "," in seconds:
                     seconds = seconds.replace(",", ".")
-                    
+
                 if "." in seconds:
                     sec_parts = seconds.split(".")
                     whole_seconds = sec_parts[0] if sec_parts[0] else "0"
@@ -335,19 +340,20 @@ def parse_num(s: str, suffix: str) -> int:
                     nanos += frac_nanos
                 else:
                     nanos += int(seconds) * 1000000000
-                    
+
         return cls(months=total_months, days=days, nanos=nanos)
 
 
 @dataclass
 class NullInterval:
     """Represents a Spanner INTERVAL that may be NULL."""
+
     interval: Interval
     valid: bool = True
-    
+
     def is_null(self) -> bool:
         return not self.valid
-        
+
     def __str__(self) -> str:
         if not self.valid:
             return "NULL"
@@ -641,7 +647,7 @@ def _parse_nullable(value_pb, decoder):
 
 def _parse_interval(value_pb):
     """Parse a Value protobuf containing an interval."""
-    if hasattr(value_pb, 'string_value'):
+    if hasattr(value_pb, "string_value"):
         return Interval.from_str(value_pb.string_value)
     return Interval.from_str(value_pb)
 

tests/system/test_session_api.py

@@ -2923,8 +2923,9 @@ def test_interval(sessions_database, database_dialect, not_emulator):
 
     def setup_table():
         if database_dialect == DatabaseDialect.POSTGRESQL:
-            sessions_database.update_ddl([
-                """
+            sessions_database.update_ddl(
+                [
+                    """
                 CREATE TABLE IntervalTable (
                     key text primary key,
                     create_time timestamptz,
@@ -2933,10 +2934,12 @@ def setup_table():
                     interval_array_len bigint GENERATED ALWAYS AS (ARRAY_LENGTH(ARRAY[INTERVAL '1-2 3 4:5:6'], 1)) STORED
                 )
                 """
-            ]).result()
+                ]
+            ).result()
         else:
-            sessions_database.update_ddl([
-                """
+            sessions_database.update_ddl(
+                [
+                    """
                 CREATE TABLE IntervalTable (
                     key STRING(MAX),
                     create_time TIMESTAMP,
@@ -2945,10 +2948,13 @@ def setup_table():
                     interval_array_len INT64 AS (ARRAY_LENGTH(ARRAY<INTERVAL>[INTERVAL '1-2 3 4:5:6' YEAR TO SECOND]))
                 ) PRIMARY KEY (key)
                 """
-            ]).result()
+                ]
+            ).result()
 
     def insert_test1(transaction):
-        keys, placeholders = get_param_info(["key", "create_time", "expiry_time"], database_dialect)
+        keys, placeholders = get_param_info(
+            ["key", "create_time", "expiry_time"], database_dialect
+        )
         transaction.execute_sql(
             f"""
             INSERT INTO IntervalTable (key, create_time, expiry_time)
@@ -2998,7 +3004,9 @@ def test_interval_arithmetic(transaction):
         assert interval.nanos == 0
 
     def insert_test2(transaction):
-        keys, placeholders = get_param_info(["key", "create_time", "expiry_time"], database_dialect)
+        keys, placeholders = get_param_info(
+            ["key", "create_time", "expiry_time"], database_dialect
+        )
         transaction.execute_sql(
             f"""
             INSERT INTO IntervalTable (key, create_time, expiry_time)
@@ -3043,7 +3051,8 @@ def test_interval_array_param(transaction, database_dialect):
         ]
         keys, placeholders = get_param_info(["intervals"], database_dialect)
         array_type = spanner_v1.Type(
-            code=spanner_v1.TypeCode.ARRAY, array_element_type=spanner_v1.param_types.INTERVAL
+            code=spanner_v1.TypeCode.ARRAY,
+            array_element_type=spanner_v1.param_types.INTERVAL,
         )
         results = list(
             transaction.execute_sql(
@@ -3056,23 +3065,23 @@ def test_interval_array_param(transaction, database_dialect):
         row = results[0]
         intervals = row[0]
         assert len(intervals) == 4
-        
+
         # Check first interval
         assert intervals[0].valid is True
         assert intervals[0].interval.months == 14
         assert intervals[0].interval.days == 3
         assert intervals[0].interval.nanos == 14706000000000
-        
+
         assert intervals[1].valid is True
         assert intervals[1].interval.months == 0
         assert intervals[1].interval.days == 0
         assert intervals[1].interval.nanos == 0
-        
+
         assert intervals[2].valid is True
         assert intervals[2].interval.months == -14
         assert intervals[2].interval.days == -3
         assert intervals[2].interval.nanos == -14706000000000
-        
+
         assert intervals[3].valid is True
         assert intervals[3].interval.months == 0
         assert intervals[3].interval.days == 0
@@ -3094,14 +3103,14 @@ def test_interval_array_cast(transaction):
         row = results[0]
         intervals = row[0]
         assert len(intervals) == 3
-        
+
         assert intervals[0].valid is True
         assert intervals[0].interval.months == 14  # 1 year + 2 months
         assert intervals[0].interval.days == 3
         assert intervals[0].interval.nanos == 14706789123000  # 4h5m6.789123s in nanos
-        
+
         assert intervals[1].valid is False
-        
+
         assert intervals[2].valid is True
         assert intervals[2].interval.months == -14
         assert intervals[2].interval.days == -3

tests/unit/test__helpers.py

@@ -1221,6 +1221,7 @@ def _callFUT(self, *args, **kw):
 
     def test_full_interval_with_all_components(self):
         from google.protobuf.struct_pb2 import Value
+
         input_str = "P1Y2M3DT12H12M6.789000123S"
         expected_months = 14
         expected_days = 3
@@ -1647,6 +1648,7 @@ def test_both_dot_and_comma_decimals(self):
 
     def test_interval_with_years_months(self):
         from google.protobuf.struct_pb2 import Value
+
         input_str = "P1Y2M"
         expected_months = 14
         expected_days = 0
@@ -1659,6 +1661,7 @@ def test_interval_with_years_months(self):
 
     def test_interval_with_days(self):
         from google.protobuf.struct_pb2 import Value
+
         input_str = "P3D"
         expected_months = 0
         expected_days = 3
@@ -1671,6 +1674,7 @@ def test_interval_with_days(self):
 
     def test_interval_with_time(self):
         from google.protobuf.struct_pb2 import Value
+
         input_str = "PT12H12M6.789000123S"
         expected_months = 0
         expected_days = 0
@@ -1683,6 +1687,7 @@ def test_interval_with_time(self):
 
     def test_interval_with_negative_components(self):
         from google.protobuf.struct_pb2 import Value
+
         input_str = "P-1Y-2M-3DT-12H-12M-6.789000123S"
         expected_months = -14
         expected_days = -3
@@ -1695,6 +1700,7 @@ def test_interval_with_negative_components(self):
 
     def test_interval_with_zero_components(self):
         from google.protobuf.struct_pb2 import Value
+
         input_str = "P0Y0M0DT0H0M0S"
         expected_months = 0
         expected_days = 0