Treat invalid-state errors as non-retryable

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

Author: cursoragent

hyperbrowser/client/polling.py

@@ -1,6 +1,7 @@
 import asyncio
-from concurrent.futures import CancelledError as ConcurrentCancelledError
 from concurrent.futures import BrokenExecutor as ConcurrentBrokenExecutor
+from concurrent.futures import CancelledError as ConcurrentCancelledError
+from concurrent.futures import InvalidStateError as ConcurrentInvalidStateError
 import inspect
 import math
 from numbers import Real
@@ -206,6 +207,8 @@ def _normalize_status_code_for_retry(status_code: object) -> Optional[int]:
 def _is_retryable_exception(exc: Exception) -> bool:
     if isinstance(exc, ConcurrentBrokenExecutor):
         return False
+    if isinstance(exc, (asyncio.InvalidStateError, ConcurrentInvalidStateError)):
+        return False
     if isinstance(exc, (StopIteration, StopAsyncIteration)):
         return False
     if _is_generator_reentrancy_error(exc):

tests/test_polling.py

@@ -1,6 +1,7 @@
 import asyncio
-from concurrent.futures import CancelledError as ConcurrentCancelledError
 from concurrent.futures import BrokenExecutor as ConcurrentBrokenExecutor
+from concurrent.futures import CancelledError as ConcurrentCancelledError
+from concurrent.futures import InvalidStateError as ConcurrentInvalidStateError
 import math
 from fractions import Fraction
 
@@ -287,6 +288,26 @@ def get_status() -> str:
     assert attempts["count"] == 1
 
 
+def test_poll_until_terminal_status_does_not_retry_invalid_state_errors():
+    attempts = {"count": 0}
+
+    def get_status() -> str:
+        attempts["count"] += 1
+        raise asyncio.InvalidStateError("invalid async state")
+
+    with pytest.raises(asyncio.InvalidStateError, match="invalid async state"):
+        poll_until_terminal_status(
+            operation_name="sync poll invalid-state passthrough",
+            get_status=get_status,
+            is_terminal_status=lambda value: value == "completed",
+            poll_interval_seconds=0.0001,
+            max_wait_seconds=1.0,
+            max_status_failures=5,
+        )
+
+    assert attempts["count"] == 1
+
+
 def test_poll_until_terminal_status_does_not_retry_executor_shutdown_runtime_errors():
     attempts = {"count": 0}
 
@@ -754,6 +775,24 @@ def operation() -> str:
     assert attempts["count"] == 1
 
 
+def test_retry_operation_does_not_retry_invalid_state_errors():
+    attempts = {"count": 0}
+
+    def operation() -> str:
+        attempts["count"] += 1
+        raise ConcurrentInvalidStateError("invalid executor state")
+
+    with pytest.raises(ConcurrentInvalidStateError, match="invalid executor state"):
+        retry_operation(
+            operation_name="sync retry invalid-state passthrough",
+            operation=operation,
+            max_attempts=5,
+            retry_delay_seconds=0.0001,
+        )
+
+    assert attempts["count"] == 1
+
+
 def test_retry_operation_retries_server_errors():
     attempts = {"count": 0}
 
@@ -1158,6 +1197,29 @@ async def get_status() -> str:
     asyncio.run(run())
 
 
+def test_poll_until_terminal_status_async_does_not_retry_invalid_state_errors():
+    async def run() -> None:
+        attempts = {"count": 0}
+
+        async def get_status() -> str:
+            attempts["count"] += 1
+            raise asyncio.InvalidStateError("invalid async state")
+
+        with pytest.raises(asyncio.InvalidStateError, match="invalid async state"):
+            await poll_until_terminal_status_async(
+                operation_name="async poll invalid-state passthrough",
+                get_status=get_status,
+                is_terminal_status=lambda value: value == "completed",
+                poll_interval_seconds=0.0001,
+                max_wait_seconds=1.0,
+                max_status_failures=5,
+            )
+
+        assert attempts["count"] == 1
+
+    asyncio.run(run())
+
+
 def test_poll_until_terminal_status_async_retries_server_errors():
     async def run() -> None:
         attempts = {"count": 0}
@@ -1402,6 +1464,27 @@ async def operation() -> str:
     asyncio.run(run())
 
 
+def test_retry_operation_async_does_not_retry_invalid_state_errors():
+    async def run() -> None:
+        attempts = {"count": 0}
+
+        async def operation() -> str:
+            attempts["count"] += 1
+            raise ConcurrentInvalidStateError("invalid executor state")
+
+        with pytest.raises(ConcurrentInvalidStateError, match="invalid executor state"):
+            await retry_operation_async(
+                operation_name="async retry invalid-state passthrough",
+                operation=operation,
+                max_attempts=5,
+                retry_delay_seconds=0.0001,
+            )
+
+        assert attempts["count"] == 1
+
+    asyncio.run(run())
+
+
 def test_retry_operation_async_does_not_retry_executor_shutdown_runtime_errors():
     async def run() -> None:
         attempts = {"count": 0}
@@ -2519,6 +2602,28 @@ def get_next_page(page: int) -> dict:
     assert attempts["count"] == 1
 
 
+def test_collect_paginated_results_does_not_retry_invalid_state_errors():
+    attempts = {"count": 0}
+
+    def get_next_page(page: int) -> dict:
+        attempts["count"] += 1
+        raise asyncio.InvalidStateError("invalid async state")
+
+    with pytest.raises(asyncio.InvalidStateError, match="invalid async state"):
+        collect_paginated_results(
+            operation_name="sync paginated invalid-state passthrough",
+            get_next_page=get_next_page,
+            get_current_page_batch=lambda response: response["current"],
+            get_total_page_batches=lambda response: response["total"],
+            on_page_success=lambda response: None,
+            max_wait_seconds=1.0,
+            max_attempts=5,
+            retry_delay_seconds=0.0001,
+        )
+
+    assert attempts["count"] == 1
+
+
 def test_collect_paginated_results_does_not_retry_executor_shutdown_runtime_errors():
     attempts = {"count": 0}
 
@@ -2934,6 +3039,31 @@ async def get_next_page(page: int) -> dict:
     asyncio.run(run())
 
 
+def test_collect_paginated_results_async_does_not_retry_invalid_state_errors():
+    async def run() -> None:
+        attempts = {"count": 0}
+
+        async def get_next_page(page: int) -> dict:
+            attempts["count"] += 1
+            raise ConcurrentInvalidStateError("invalid executor state")
+
+        with pytest.raises(ConcurrentInvalidStateError, match="invalid executor state"):
+            await collect_paginated_results_async(
+                operation_name="async paginated invalid-state passthrough",
+                get_next_page=get_next_page,
+                get_current_page_batch=lambda response: response["current"],
+                get_total_page_batches=lambda response: response["total"],
+                on_page_success=lambda response: None,
+                max_wait_seconds=1.0,
+                max_attempts=5,
+                retry_delay_seconds=0.0001,
+            )
+
+        assert attempts["count"] == 1
+
+    asyncio.run(run())
+
+
 def test_collect_paginated_results_async_does_not_retry_executor_shutdown_runtime_errors():
     async def run() -> None:
         attempts = {"count": 0}
@@ -3209,6 +3339,35 @@ def fetch_result() -> dict:
     assert fetch_attempts["count"] == 0
 
 
+def test_wait_for_job_result_does_not_retry_invalid_state_status_errors():
+    status_attempts = {"count": 0}
+    fetch_attempts = {"count": 0}
+
+    def get_status() -> str:
+        status_attempts["count"] += 1
+        raise asyncio.InvalidStateError("invalid async state")
+
+    def fetch_result() -> dict:
+        fetch_attempts["count"] += 1
+        return {"ok": True}
+
+    with pytest.raises(asyncio.InvalidStateError, match="invalid async state"):
+        wait_for_job_result(
+            operation_name="sync wait helper status invalid-state",
+            get_status=get_status,
+            is_terminal_status=lambda value: value == "completed",
+            fetch_result=fetch_result,
+            poll_interval_seconds=0.0001,
+            max_wait_seconds=1.0,
+            max_status_failures=5,
+            fetch_max_attempts=5,
+            fetch_retry_delay_seconds=0.0001,
+        )
+
+    assert status_attempts["count"] == 1
+    assert fetch_attempts["count"] == 0
+
+
 def test_wait_for_job_result_does_not_retry_executor_shutdown_status_errors():
     status_attempts = {"count": 0}
     fetch_attempts = {"count": 0}
@@ -3472,6 +3631,29 @@ def fetch_result() -> dict:
     assert fetch_attempts["count"] == 1
 
 
+def test_wait_for_job_result_does_not_retry_invalid_state_fetch_errors():
+    fetch_attempts = {"count": 0}
+
+    def fetch_result() -> dict:
+        fetch_attempts["count"] += 1
+        raise ConcurrentInvalidStateError("invalid executor state")
+
+    with pytest.raises(ConcurrentInvalidStateError, match="invalid executor state"):
+        wait_for_job_result(
+            operation_name="sync wait helper fetch invalid-state",
+            get_status=lambda: "completed",
+            is_terminal_status=lambda value: value == "completed",
+            fetch_result=fetch_result,
+            poll_interval_seconds=0.0001,
+            max_wait_seconds=1.0,
+            max_status_failures=5,
+            fetch_max_attempts=5,
+            fetch_retry_delay_seconds=0.0001,
+        )
+
+    assert fetch_attempts["count"] == 1
+
+
 def test_wait_for_job_result_does_not_retry_executor_shutdown_fetch_errors():
     fetch_attempts = {"count": 0}
 
@@ -3819,6 +4001,38 @@ async def fetch_result() -> dict:
     asyncio.run(run())
 
 
+def test_wait_for_job_result_async_does_not_retry_invalid_state_status_errors():
+    async def run() -> None:
+        status_attempts = {"count": 0}
+        fetch_attempts = {"count": 0}
+
+        async def get_status() -> str:
+            status_attempts["count"] += 1
+            raise ConcurrentInvalidStateError("invalid executor state")
+
+        async def fetch_result() -> dict:
+            fetch_attempts["count"] += 1
+            return {"ok": True}
+
+        with pytest.raises(ConcurrentInvalidStateError, match="invalid executor state"):
+            await wait_for_job_result_async(
+                operation_name="async wait helper status invalid-state",
+                get_status=get_status,
+                is_terminal_status=lambda value: value == "completed",
+                fetch_result=fetch_result,
+                poll_interval_seconds=0.0001,
+                max_wait_seconds=1.0,
+                max_status_failures=5,
+                fetch_max_attempts=5,
+                fetch_retry_delay_seconds=0.0001,
+            )
+
+        assert status_attempts["count"] == 1
+        assert fetch_attempts["count"] == 0
+
+    asyncio.run(run())
+
+
 def test_wait_for_job_result_async_does_not_retry_executor_shutdown_status_errors():
     async def run() -> None:
         status_attempts = {"count": 0}
@@ -4106,6 +4320,32 @@ async def fetch_result() -> dict:
     asyncio.run(run())
 
 
+def test_wait_for_job_result_async_does_not_retry_invalid_state_fetch_errors():
+    async def run() -> None:
+        fetch_attempts = {"count": 0}
+
+        async def fetch_result() -> dict:
+            fetch_attempts["count"] += 1
+            raise asyncio.InvalidStateError("invalid async state")
+
+        with pytest.raises(asyncio.InvalidStateError, match="invalid async state"):
+            await wait_for_job_result_async(
+                operation_name="async wait helper fetch invalid-state",
+                get_status=lambda: asyncio.sleep(0, result="completed"),
+                is_terminal_status=lambda value: value == "completed",
+                fetch_result=fetch_result,
+                poll_interval_seconds=0.0001,
+                max_wait_seconds=1.0,
+                max_status_failures=5,
+                fetch_max_attempts=5,
+                fetch_retry_delay_seconds=0.0001,
+            )
+
+        assert fetch_attempts["count"] == 1
+
+    asyncio.run(run())
+
+
 def test_wait_for_job_result_async_does_not_retry_executor_shutdown_fetch_errors():
     async def run() -> None:
         fetch_attempts = {"count": 0}