offwork 0.2.0__tar.gz → 0.2.1__tar.gz

{offwork-0.2.0 → offwork-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: offwork
-Version: 0.2.0
+Version: 0.2.1
 Summary: Distributed Python task execution via automatic function serialization
 License: AGPL-3.0-only
 License-File: LICENSE

{offwork-0.2.0 → offwork-0.2.1}/offwork/worker/backends/redis.py

@@ -1,12 +1,15 @@
 """Redis-backed transport using ``RPUSH``/``BLPOP`` for tasks and results."""
 
+import math
 import time
 import asyncio
 from typing import Any
+from urllib.parse import parse_qs, urlparse
 from collections.abc import AsyncIterator
 
 try:
     import redis.asyncio as _redis
+    from redis.exceptions import TimeoutError as RedisTimeoutError
 except ImportError:
     raise ImportError(
         "redis package is required for RedisBackend. "
@@ -50,7 +53,11 @@ class RedisBackend(Backend):
         queue_key: str | None = None,
         result_ttl: int | None = None,
     ) -> None:
-        self._redis: Any = _redis.Redis.from_url(url)
+        query = parse_qs(urlparse(url).query)
+        connect_kwargs: dict[str, Any] = {}
+        if "socket_timeout" not in query:
+            connect_kwargs["socket_timeout"] = None
+        self._redis: Any = _redis.Redis.from_url(url, **connect_kwargs)
         self._queue_key = queue_key or self.DEFAULT_QUEUE_KEY
         self._result_ttl = result_ttl or self.DEFAULT_RESULT_TTL
 
@@ -60,7 +67,13 @@ class RedisBackend(Backend):
     async def listen(self) -> AsyncIterator[str]:
         """Block on ``BLPOP`` and yield task JSON strings as they arrive."""
         while True:
-            result = await self._redis.blpop(self._queue_key)
+            try:
+                result = await self._redis.blpop(self._queue_key)
+            except RedisTimeoutError:
+                task = asyncio.current_task()
+                if task is not None and task.cancelling():
+                    raise asyncio.CancelledError() from None
+                continue
             if result is None:
                 continue
             _, raw = result
@@ -73,14 +86,34 @@ class RedisBackend(Backend):
 
     async def get_result(self, task_id: str, timeout: float | None = None) -> str:
         key = f"{self.RESULT_PREFIX}{task_id}"
-        t = int(timeout) if timeout else 0
-        result = await self._redis.blpop(key, timeout=t)
-        if result is None:
-            raise TimeoutError(
-                f"Timed out waiting for result of task {task_id}"
-            )
-        _, raw = result
-        return raw.decode() if isinstance(raw, bytes) else raw
+        deadline = None if timeout is None else time.monotonic() + max(0.0, timeout)
+        while True:
+            if deadline is None:
+                block_seconds = 0
+            else:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise TimeoutError(
+                        f"Timed out waiting for result of task {task_id}"
+                    )
+                block_seconds = max(1, math.ceil(remaining))
+            try:
+                result = await self._redis.blpop(key, timeout=block_seconds)
+            except RedisTimeoutError:
+                task = asyncio.current_task()
+                if task is not None and task.cancelling():
+                    raise asyncio.CancelledError() from None
+                if deadline is not None and time.monotonic() >= deadline:
+                    raise TimeoutError(
+                        f"Timed out waiting for result of task {task_id}"
+                    ) from None
+                continue
+            if result is None:
+                raise TimeoutError(
+                    f"Timed out waiting for result of task {task_id}"
+                )
+            _, raw = result
+            return raw.decode() if isinstance(raw, bytes) else raw
 
     async def try_get_result(self, task_id: str) -> str | None:
         """Non-blocking ``LPOP``; returns ``None`` if not yet available."""

{offwork-0.2.0 → offwork-0.2.1}/offwork/worker/backends/ws.py

@@ -31,6 +31,14 @@ from collections.abc import AsyncIterator
 from typing import Any
 from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
 
+try:
+    import websockets
+except ImportError:
+    raise ImportError(
+        "websockets package is required for RabbitMQBackend. "
+        "Install it with: pip install websockets"
+    ) from None
+
 from offwork.core.version import _VERSION
 from offwork.worker.backends.base import Backend
 
@@ -86,13 +94,6 @@ class WebSocketBackend(Backend):
     # ------------------------------------------------------------------ #
 
     async def _connect(self) -> Any:
-        try:
-            import websockets
-        except ImportError as exc:
-            raise RuntimeError(
-                "WebSocketBackend requires the 'websockets' package. "
-                "Install with: pip install offwork[ws]"
-            ) from exc
         ws = await websockets.connect(
             self._url,
             max_size=None,  # broker payloads (graph_json) can be large

{offwork-0.2.0 → offwork-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "offwork"
-version = "0.2.0"
+version = "0.2.1"
 description = "Distributed Python task execution via automatic function serialization"
 readme = "README.md"
 authors = [