Refactor Duration to store only seconds internally

- Store only seconds field instead of days/hours/minutes/seconds
- Accept int | float in all from_* constructors (from_seconds, from_minutes, from_hours, from_days)
- Convert to seconds using direct multiplication instead of timedelta
- Use ValidationError instead of ValueError for negative values
- Simplify validation to check only seconds < 0

Author: FullyTyped

src/aws_durable_execution_sdk_python/config.py

@@ -4,10 +4,11 @@
 
 import random
 from dataclasses import dataclass, field
-from datetime import timedelta
 from enum import Enum, StrEnum
 from typing import TYPE_CHECKING, Generic, TypeVar
 
+from aws_durable_execution_sdk_python.exceptions import ValidationError
+
 P = TypeVar("P")  # Payload type
 R = TypeVar("R")  # Result type
 T = TypeVar("T")
@@ -26,49 +27,40 @@
 Numeric = int | float  # deliberately leaving off complex
 
 
-@dataclass
+@dataclass(frozen=True)
 class Duration:
-    """Represents a duration with multiple time units."""
+    """Represents a duration stored as total seconds."""
 
-    days: int = 0
-    hours: int = 0
-    minutes: int = 0
     seconds: int = 0
 
     def __post_init__(self):
-        if any(v < 0 for v in [self.days, self.hours, self.minutes, self.seconds]):
-            msg = "All duration values must be positive"
-            raise ValueError(msg)
+        if self.seconds < 0:
+            msg = "Duration seconds must be positive"
+            raise ValidationError(msg)
 
     def to_seconds(self) -> int:
         """Convert the duration to total seconds."""
-        td = timedelta(
-            days=self.days,
-            hours=self.hours,
-            minutes=self.minutes,
-            seconds=self.seconds,
-        )
-        return int(td.total_seconds())
+        return self.seconds
 
     @classmethod
-    def from_seconds(cls, value: int) -> Duration:
+    def from_seconds(cls, value: float) -> Duration:
         """Create a Duration from total seconds."""
-        return cls(seconds=value)
+        return cls(seconds=int(value))
 
     @classmethod
-    def from_minutes(cls, value: int) -> Duration:
+    def from_minutes(cls, value: float) -> Duration:
         """Create a Duration from minutes."""
-        return cls(minutes=value)
+        return cls(seconds=int(value * 60))
 
     @classmethod
-    def from_hours(cls, value: int) -> Duration:
+    def from_hours(cls, value: float) -> Duration:
         """Create a Duration from hours."""
-        return cls(hours=value)
+        return cls(seconds=int(value * 3600))
 
     @classmethod
-    def from_days(cls, value: int) -> Duration:
+    def from_days(cls, value: float) -> Duration:
         """Create a Duration from days."""
-        return cls(days=value)
+        return cls(seconds=int(value * 86400))
 
 
 @dataclass(frozen=True)

tests/operation/callback_test.py

@@ -11,7 +11,7 @@
     StepConfig,
     WaitForCallbackConfig,
 )
-from aws_durable_execution_sdk_python.exceptions import CallbackError
+from aws_durable_execution_sdk_python.exceptions import CallbackError, ValidationError
 from aws_durable_execution_sdk_python.identifier import OperationIdentifier
 from aws_durable_execution_sdk_python.lambda_service import (
     CallbackDetails,
@@ -333,7 +333,7 @@ def test_create_callback_handler_with_none_operation_in_result():
 def test_create_callback_handler_with_negative_timeouts():
     """Test create_callback_handler with negative timeout values in config."""
     # Duration now validates that all values must be positive
-    with pytest.raises(ValueError, match="All duration values must be positive"):
+    with pytest.raises(ValidationError, match="Duration seconds must be positive"):
         CallbackConfig(
             timeout=Duration(seconds=-100), heartbeat_timeout=Duration(seconds=-50)
         )