fmt

Author: hectorcast-db

databricks/sdk/common.py

@@ -64,7 +64,7 @@ def from_timedelta(cls, td: timedelta) -> "Duration":
         # Get the fractional part and convert to nanoseconds
         # This preserves more precision than using microsecond * 1000
         fractional = total_seconds - seconds
-        nanoseconds = int(fractional * Decimal('1000000000'))
+        nanoseconds = int(fractional * Decimal("1000000000"))
         return cls(seconds=seconds, nanoseconds=nanoseconds)
 
     def to_timedelta(self) -> timedelta:
@@ -150,9 +150,9 @@ def to_string(self) -> str:
             return f"{self.seconds}s"
 
         # Use Decimal for precise decimal arithmetic
-        total = Decimal(self.seconds) + (Decimal(self.nanoseconds) / Decimal('1000000000'))
+        total = Decimal(self.seconds) + (Decimal(self.nanoseconds) / Decimal("1000000000"))
         # Format with up to 9 decimal places, removing trailing zeros
-        return f"{total:.9f}".rstrip('0').rstrip('.') + 's'
+        return f"{total:.9f}".rstrip("0").rstrip(".") + "s"
 
 
 class Timestamp:
@@ -213,16 +213,16 @@ def from_datetime(cls, dt: datetime) -> "Timestamp":
             dt = dt.replace(tzinfo=timezone.utc)
         # Convert to UTC
         utc_dt = dt.astimezone(timezone.utc)
-        
+
         # Get seconds since epoch using Decimal for precise calculation
         # datetime.timestamp() returns float, so we need to handle it carefully
         ts = Decimal(str(utc_dt.timestamp()))
         seconds = int(ts)
         # Get the fractional part and convert to nanoseconds
         # This preserves more precision than using microsecond * 1000
         fractional = ts - seconds
-        nanos = int(fractional * Decimal('1000000000'))
-        
+        nanos = int(fractional * Decimal("1000000000"))
+
         return cls(seconds=seconds, nanos=nanos)
 
     def to_datetime(self) -> datetime:
@@ -267,7 +267,7 @@ def parse(cls, timestamp_str: str) -> "Timestamp":
 
         # Build the datetime string with a standardized offset format
         dt_str = f"{year}-{month}-{day}T{hour}:{minute}:{second}"
-        
+
         # Handle fractional seconds, truncating to microseconds for fromisoformat
         nanos = 0
         if frac:
@@ -343,6 +343,6 @@ def replace(self, **kwargs) -> "Timestamp":
         Returns:
             A new Timestamp instance with the specified fields replaced
         """
-        seconds = kwargs.get('seconds', self.seconds)
-        nanos = kwargs.get('nanos', self.nanos)
+        seconds = kwargs.get("seconds", self.seconds)
+        nanos = kwargs.get("nanos", self.nanos)
         return Timestamp(seconds=seconds, nanos=nanos)

tests/test_common.py

@@ -141,7 +141,15 @@ def test_timestamp_from_datetime(dt, expected_seconds, expected_nanos):
     ],
 )
 def test_timestamp_to_datetime(
-    seconds, nanos, expected_year, expected_month, expected_day, expected_hour, expected_minute, expected_second, expected_microsecond
+    seconds,
+    nanos,
+    expected_year,
+    expected_month,
+    expected_day,
+    expected_hour,
+    expected_minute,
+    expected_second,
+    expected_microsecond,
 ):
     """Test conversion from Timestamp to datetime."""
     ts = Timestamp(seconds=seconds, nanos=nanos)
@@ -225,7 +233,7 @@ def test_timestamp_equality(ts1, ts2, expected_equal):
 )
 def test_duration_float_precision(seconds, nanoseconds, expected_microseconds):
     """Test Duration float precision handling with various nanosecond values.
-    
+
     Note: timedelta only supports microsecond precision (6 decimal places),
     so nanosecond values are rounded to the nearest microsecond.
     """
@@ -254,7 +262,7 @@ def test_duration_float_precision(seconds, nanoseconds, expected_microseconds):
 )
 def test_duration_parse_precision(duration_str, expected_microseconds):
     """Test Duration parsing precision with various decimal values.
-    
+
     Note: timedelta only supports microsecond precision (6 decimal places),
     so nanosecond values are rounded to the nearest microsecond.
     """