Accept decimal timing values via float normalization

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

hyperbrowser/client/polling.py

@@ -2,6 +2,7 @@
 from concurrent.futures import BrokenExecutor as ConcurrentBrokenExecutor
 from concurrent.futures import CancelledError as ConcurrentCancelledError
 from concurrent.futures import InvalidStateError as ConcurrentInvalidStateError
+from decimal import Decimal
 import inspect
 import math
 from numbers import Real
@@ -27,7 +28,8 @@ class _NonRetryablePollingError(HyperbrowserError):
 
 
 def _normalize_non_negative_real(value: float, *, field_name: str) -> float:
-    if isinstance(value, bool) or not isinstance(value, Real):
+    is_supported_numeric_type = isinstance(value, Real) or isinstance(value, Decimal)
+    if isinstance(value, bool) or not is_supported_numeric_type:
         raise HyperbrowserError(f"{field_name} must be a number")
     try:
         normalized_value = float(value)

hyperbrowser/client/timeout_utils.py

@@ -1,3 +1,4 @@
+from decimal import Decimal
 import math
 from numbers import Real
 from typing import Optional
@@ -8,7 +9,10 @@
 def validate_timeout_seconds(timeout: Optional[float]) -> Optional[float]:
     if timeout is None:
         return None
-    if isinstance(timeout, bool) or not isinstance(timeout, Real):
+    is_supported_numeric_type = isinstance(timeout, Real) or isinstance(
+        timeout, Decimal
+    )
+    if isinstance(timeout, bool) or not is_supported_numeric_type:
         raise HyperbrowserError("timeout must be a number")
     try:
         normalized_timeout = float(timeout)

tests/test_client_timeout.py

@@ -1,4 +1,5 @@
 import asyncio
+from decimal import Decimal
 import math
 from fractions import Fraction
 
@@ -58,6 +59,33 @@ async def run() -> None:
     asyncio.run(run())
 
 
+def test_sync_client_normalizes_decimal_timeout_to_float():
+    client = Hyperbrowser(
+        api_key="test-key",
+        timeout=Decimal("0.5"),  # type: ignore[arg-type]
+    )
+    try:
+        assert isinstance(client.transport.client.timeout.connect, float)
+        assert client.transport.client.timeout.connect == 0.5
+    finally:
+        client.close()
+
+
+def test_async_client_normalizes_decimal_timeout_to_float():
+    async def run() -> None:
+        client = AsyncHyperbrowser(
+            api_key="test-key",
+            timeout=Decimal("0.5"),  # type: ignore[arg-type]
+        )
+        try:
+            assert isinstance(client.transport.client.timeout.connect, float)
+            assert client.transport.client.timeout.connect == 0.5
+        finally:
+            await client.close()
+
+    asyncio.run(run())
+
+
 def test_sync_client_rejects_non_numeric_timeout():
     with pytest.raises(HyperbrowserError, match="timeout must be a number"):
         Hyperbrowser(api_key="test-key", timeout="30")  # type: ignore[arg-type]

tests/test_polling.py

@@ -3,6 +3,7 @@
 from concurrent.futures import BrokenExecutor as ConcurrentBrokenExecutor
 from concurrent.futures import CancelledError as ConcurrentCancelledError
 from concurrent.futures import InvalidStateError as ConcurrentInvalidStateError
+from decimal import Decimal
 import math
 from fractions import Fraction
 
@@ -120,6 +121,20 @@ def test_poll_until_terminal_status_accepts_fraction_timing_values():
     assert status == "completed"
 
 
+def test_poll_until_terminal_status_accepts_decimal_timing_values():
+    status_values = iter(["running", "completed"])
+
+    status = poll_until_terminal_status(
+        operation_name="sync poll decimal timings",
+        get_status=lambda: next(status_values),
+        is_terminal_status=lambda value: value == "completed",
+        poll_interval_seconds=Decimal("0.0001"),  # type: ignore[arg-type]
+        max_wait_seconds=Decimal("1"),  # type: ignore[arg-type]
+    )
+
+    assert status == "completed"
+
+
 def test_poll_until_terminal_status_does_not_retry_non_retryable_client_errors():
     attempts = {"count": 0}
 
@@ -838,6 +853,26 @@ def operation() -> str:
     assert attempts["count"] == 3
 
 
+def test_retry_operation_accepts_decimal_retry_delay():
+    attempts = {"count": 0}
+
+    def operation() -> str:
+        attempts["count"] += 1
+        if attempts["count"] < 3:
+            raise ValueError("transient")
+        return "ok"
+
+    result = retry_operation(
+        operation_name="sync retry decimal delay",
+        operation=operation,
+        max_attempts=3,
+        retry_delay_seconds=Decimal("0.0001"),  # type: ignore[arg-type]
+    )
+
+    assert result == "ok"
+    assert attempts["count"] == 3
+
+
 def test_retry_operation_raises_after_max_attempts():
     with pytest.raises(HyperbrowserError, match="sync retry failure"):
         retry_operation(
@@ -1464,6 +1499,38 @@ async def get_next_page(page_batch: int) -> dict:
     asyncio.run(run())
 
 
+def test_async_helpers_accept_decimal_timing_values():
+    async def run() -> None:
+        status_values = iter(["pending", "completed"])
+        status = await poll_until_terminal_status_async(
+            operation_name="async poll decimal timings",
+            get_status=lambda: asyncio.sleep(0, result=next(status_values)),
+            is_terminal_status=lambda value: value == "completed",
+            poll_interval_seconds=Decimal("0.0001"),  # type: ignore[arg-type]
+            max_wait_seconds=Decimal("1"),  # type: ignore[arg-type]
+        )
+        assert status == "completed"
+
+        attempts = {"count": 0}
+
+        async def operation() -> str:
+            attempts["count"] += 1
+            if attempts["count"] < 2:
+                raise ValueError("temporary")
+            return "ok"
+
+        result = await retry_operation_async(
+            operation_name="async retry decimal delay",
+            operation=operation,
+            max_attempts=2,
+            retry_delay_seconds=Decimal("0.0001"),  # type: ignore[arg-type]
+        )
+        assert result == "ok"
+        assert attempts["count"] == 2
+
+    asyncio.run(run())
+
+
 def test_retry_operation_async_rejects_non_awaitable_operation_result() -> None:
     async def run() -> None:
         with pytest.raises(