offwork 0.1.0__tar.gz → 0.1.1__tar.gz

{offwork-0.1.0 → offwork-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: offwork
-Version: 0.1.0
+Version: 0.1.1
 Summary: Distributed Python task execution via automatic function serialization
 License: AGPL-3.0-only
 License-File: LICENSE
@@ -29,14 +29,13 @@ Description-Content-Type: text/markdown
 
 **Run any Python function on a remote worker — zero setup, zero deployment.**
 
-[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/downloads/)
+[![PyPI](https://img.shields.io/pypi/v/offwork)](https://pypi.org/project/offwork/)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
 [![License: AGPL-3.0](https://img.shields.io/badge/license-AGPL--3.0-green)](LICENSE)
 [![Typed](https://img.shields.io/badge/typing-strict%20mypy-blue)](https://mypy-lang.org/)
 [![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)]()
 
-Add `@trace` to a function. offwork captures its source, dependencies, and imports automatically.
-Workers reconstruct and execute everything from scratch — no shared filesystem, no deployment pipeline.
-Missing packages are installed on the fly.
+Add `@offwork.task` to a function. offwork captures its source, all dependencies, and all imports automatically. Workers reconstruct and execute everything from scratch — no shared filesystem, no deployment pipeline. Missing packages are installed on the fly.
 
 ## Quick start
 
@@ -46,14 +45,14 @@ pip install offwork
 
 ```python
 import asyncio, math, offwork
-from offwork import trace
+import offwork
 
 offwork.connect("local://localhost:9748")
 
 def add(a, b):
     return a + b
 
-@trace
+@offwork.task
 def hypotenuse(a: float, b: float) -> float:
     return math.sqrt(add(a**2, b**2))
 
@@ -63,14 +62,32 @@ async def main():
 asyncio.run(main())
 ```
 
-Only the entry point needs `@trace` — everything it calls is captured automatically.
+Only the entry point needs `@offwork.task` — everything it calls is captured automatically.
 
 ```bash
 offwork worker --backend local://localhost:9748 --tmp   # start a worker
 python my_script.py                                    # → 5.0
 ```
 
-For multi-machine, swap `local://` for `redis://` or an `https://` managed broker URL. That's it.
+For multi-machine, swap `local://` for `redis://` or an `https://` managed broker URL.
+
+## Features
+
+| | |
+|-|-|
+| **Auto dependency capture** | Functions, classes, constants, closures — recursive AST analysis |
+| **Package auto-install** | Workers `pip install` missing packages before execution |
+| **Async-native** | `.run()`, `.start()`, `.map()`, `asyncio.gather` |
+| **Retry & timeout** | `@offwork.task(timeout=30, retries=3)` with exponential backoff |
+| **Scheduling** | `.run_in(delay)`, `.run_at(datetime)`, `.run_every(freq)` with cancellation |
+| **Throttling** | `@offwork.task(throttle=timedelta(hours=24)/50)` — rate-limit executions |
+| **Progress & cancellation** | `offwork.progress(3, 10)` inside tasks; `await future.cancel()` on client |
+| **Heartbeat & stall detection** | Workers heartbeat; clients raise `TaskStalled` on silence |
+| **Content-hash caching** | Same code = cache hit, regardless of client |
+| **Pluggable backends** | `local://` (TCP), `redis://`, `amqp://` (RabbitMQ), `https://` (hosted) |
+| **Docker sandbox** | Container isolation, transparent to clients |
+| **Signed execution** | Pre-shared token or PIN pairing + HMAC-SHA256 task authentication |
+| **Graceful shutdown** | Ctrl+C drains in-flight tasks; second Ctrl+C force-quits |
 
 ## Sandbox
 
@@ -81,7 +98,7 @@ offwork sandbox setup                                      # build image (once)
 offwork worker --backend redis://localhost:6379 --sandbox  # run with isolation
 ```
 
-See [Sandbox](docs/SANDBOX.md) for configuration and management.
+See [Sandbox](docs/SANDBOX.md) for configuration.
 
 ## Signing
 
@@ -89,7 +106,7 @@ Pre-shared token or PIN-based pairing + HMAC-SHA256 — workers reject untrusted
 
 ```bash
 # Token-based (recommended for CI/CD)
-offwork token generate                                       # generate once
+offwork token generate
 export OFFWORK_SIGNING_TOKEN=<token>                         # set on client & worker
 offwork worker --backend redis://localhost:6379 --require-signing
 
@@ -98,25 +115,7 @@ offwork worker --backend redis://localhost:6379 --pair       # displays a 6-digi
 offwork pair --backend redis://localhost:6379                # on client: enter the PIN
 ```
 
-After setup, tasks are signed automatically. No client-side code changes. See [Signing & Pairing](docs/SIGNING.md) for details.
-
-## Features
-
-| | |
-|-|-|
-| **Auto dependency capture** | Functions, classes, constants, closures — recursive AST analysis |
-| **Package auto-install** | Workers `pip install` missing packages before execution |
-| **Async-native** | `.run()`, `.start()`, `.map()`, `asyncio.gather` |
-| **Retry & timeout** | `@trace(timeout=30, retries=3)` with exponential backoff |
-| **Scheduling** | `.run_in(delay)`, `.run_at(datetime)`, `.run_every(freq)` with cancellation |
-| **Throttling** | `@trace(throttle=timedelta(hours=24)/50)` — rate-limit executions |
-| **Progress & cancellation** | `offwork.progress(3, 10)` inside tasks; `await future.cancel()` on client |
-| **Heartbeat & stall detection** | Workers heartbeat; clients raise `TaskStalled` on silence |
-| **Content-hash caching** | Same code = cache hit, regardless of client |
-| **Pluggable backends** | `local://` (same-machine TCP), `redis://`, `amqp://` (RabbitMQ), `http://`/`https://` (hosted broker API) |
-| **Docker sandbox** | Container isolation, transparent to clients |
-| **Signed execution** | Pre-shared token or PIN pairing + HMAC-SHA256 task authentication |
-| **Graceful shutdown** | Ctrl+C drains in-flight tasks; second Ctrl+C force-quits |
+After setup, tasks are signed automatically. No client-side code changes. See [Signing & Pairing](docs/SIGNING.md).
 
 ## Documentation
 
@@ -126,7 +125,6 @@ After setup, tasks are signed automatically. No client-side code changes. See [S
 | **[Technical Overview](docs/TECHNICAL_OVERVIEW.md)** | Architecture, serialization format, internals |
 | **[Signing & Pairing](docs/SIGNING.md)** | Cryptographic task signing protocol |
 | **[Sandbox](docs/SANDBOX.md)** | Docker container isolation |
-| **[Cloud POC](docs/CLOUD_POC.md)** | Local FastAPI + MongoDB + Kubernetes + React prototype for managed hosting |
 
 ## Examples
 

{offwork-0.1.0 → offwork-0.1.1}/README.md

@@ -2,14 +2,13 @@
 
 **Run any Python function on a remote worker — zero setup, zero deployment.**
 
-[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/downloads/)
+[![PyPI](https://img.shields.io/pypi/v/offwork)](https://pypi.org/project/offwork/)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org/downloads/)
 [![License: AGPL-3.0](https://img.shields.io/badge/license-AGPL--3.0-green)](LICENSE)
 [![Typed](https://img.shields.io/badge/typing-strict%20mypy-blue)](https://mypy-lang.org/)
 [![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)]()
 
-Add `@trace` to a function. offwork captures its source, dependencies, and imports automatically.
-Workers reconstruct and execute everything from scratch — no shared filesystem, no deployment pipeline.
-Missing packages are installed on the fly.
+Add `@offwork.task` to a function. offwork captures its source, all dependencies, and all imports automatically. Workers reconstruct and execute everything from scratch — no shared filesystem, no deployment pipeline. Missing packages are installed on the fly.
 
 ## Quick start
 
@@ -19,14 +18,14 @@ pip install offwork
 
 ```python
 import asyncio, math, offwork
-from offwork import trace
+import offwork
 
 offwork.connect("local://localhost:9748")
 
 def add(a, b):
     return a + b
 
-@trace
+@offwork.task
 def hypotenuse(a: float, b: float) -> float:
     return math.sqrt(add(a**2, b**2))
 
@@ -36,14 +35,32 @@ async def main():
 asyncio.run(main())
 ```
 
-Only the entry point needs `@trace` — everything it calls is captured automatically.
+Only the entry point needs `@offwork.task` — everything it calls is captured automatically.
 
 ```bash
 offwork worker --backend local://localhost:9748 --tmp   # start a worker
 python my_script.py                                    # → 5.0
 ```
 
-For multi-machine, swap `local://` for `redis://` or an `https://` managed broker URL. That's it.
+For multi-machine, swap `local://` for `redis://` or an `https://` managed broker URL.
+
+## Features
+
+| | |
+|-|-|
+| **Auto dependency capture** | Functions, classes, constants, closures — recursive AST analysis |
+| **Package auto-install** | Workers `pip install` missing packages before execution |
+| **Async-native** | `.run()`, `.start()`, `.map()`, `asyncio.gather` |
+| **Retry & timeout** | `@offwork.task(timeout=30, retries=3)` with exponential backoff |
+| **Scheduling** | `.run_in(delay)`, `.run_at(datetime)`, `.run_every(freq)` with cancellation |
+| **Throttling** | `@offwork.task(throttle=timedelta(hours=24)/50)` — rate-limit executions |
+| **Progress & cancellation** | `offwork.progress(3, 10)` inside tasks; `await future.cancel()` on client |
+| **Heartbeat & stall detection** | Workers heartbeat; clients raise `TaskStalled` on silence |
+| **Content-hash caching** | Same code = cache hit, regardless of client |
+| **Pluggable backends** | `local://` (TCP), `redis://`, `amqp://` (RabbitMQ), `https://` (hosted) |
+| **Docker sandbox** | Container isolation, transparent to clients |
+| **Signed execution** | Pre-shared token or PIN pairing + HMAC-SHA256 task authentication |
+| **Graceful shutdown** | Ctrl+C drains in-flight tasks; second Ctrl+C force-quits |
 
 ## Sandbox
 
@@ -54,7 +71,7 @@ offwork sandbox setup                                      # build image (once)
 offwork worker --backend redis://localhost:6379 --sandbox  # run with isolation
 ```
 
-See [Sandbox](docs/SANDBOX.md) for configuration and management.
+See [Sandbox](docs/SANDBOX.md) for configuration.
 
 ## Signing
 
@@ -62,7 +79,7 @@ Pre-shared token or PIN-based pairing + HMAC-SHA256 — workers reject untrusted
 
 ```bash
 # Token-based (recommended for CI/CD)
-offwork token generate                                       # generate once
+offwork token generate
 export OFFWORK_SIGNING_TOKEN=<token>                         # set on client & worker
 offwork worker --backend redis://localhost:6379 --require-signing
 
@@ -71,25 +88,7 @@ offwork worker --backend redis://localhost:6379 --pair       # displays a 6-digi
 offwork pair --backend redis://localhost:6379                # on client: enter the PIN
 ```
 
-After setup, tasks are signed automatically. No client-side code changes. See [Signing & Pairing](docs/SIGNING.md) for details.
-
-## Features
-
-| | |
-|-|-|
-| **Auto dependency capture** | Functions, classes, constants, closures — recursive AST analysis |
-| **Package auto-install** | Workers `pip install` missing packages before execution |
-| **Async-native** | `.run()`, `.start()`, `.map()`, `asyncio.gather` |
-| **Retry & timeout** | `@trace(timeout=30, retries=3)` with exponential backoff |
-| **Scheduling** | `.run_in(delay)`, `.run_at(datetime)`, `.run_every(freq)` with cancellation |
-| **Throttling** | `@trace(throttle=timedelta(hours=24)/50)` — rate-limit executions |
-| **Progress & cancellation** | `offwork.progress(3, 10)` inside tasks; `await future.cancel()` on client |
-| **Heartbeat & stall detection** | Workers heartbeat; clients raise `TaskStalled` on silence |
-| **Content-hash caching** | Same code = cache hit, regardless of client |
-| **Pluggable backends** | `local://` (same-machine TCP), `redis://`, `amqp://` (RabbitMQ), `http://`/`https://` (hosted broker API) |
-| **Docker sandbox** | Container isolation, transparent to clients |
-| **Signed execution** | Pre-shared token or PIN pairing + HMAC-SHA256 task authentication |
-| **Graceful shutdown** | Ctrl+C drains in-flight tasks; second Ctrl+C force-quits |
+After setup, tasks are signed automatically. No client-side code changes. See [Signing & Pairing](docs/SIGNING.md).
 
 ## Documentation
 
@@ -99,7 +98,6 @@ After setup, tasks are signed automatically. No client-side code changes. See [S
 | **[Technical Overview](docs/TECHNICAL_OVERVIEW.md)** | Architecture, serialization format, internals |
 | **[Signing & Pairing](docs/SIGNING.md)** | Cryptographic task signing protocol |
 | **[Sandbox](docs/SANDBOX.md)** | Docker container isolation |
-| **[Cloud POC](docs/CLOUD_POC.md)** | Local FastAPI + MongoDB + Kubernetes + React prototype for managed hosting |
 
 ## Examples
 

{offwork-0.1.0 → offwork-0.1.1}/offwork/__init__.py

@@ -53,7 +53,7 @@ from offwork.worker.worker import Worker
 from offwork.worker.worker import execute as execute
 from offwork.worker.sandbox import DockerSandbox
 from offwork.worker.schedule import ScheduleHandle
-from offwork.graph.decorator import trace
+from offwork.graph.decorator import task
 from offwork.worker.backends.base import Backend
 
 
@@ -107,7 +107,7 @@ __version__: str = _VERSION
 __all__ = [
     "__version__",
     # Primary API
-    "trace",
+    "task",
     "connect",
     "disconnect",
     "serve",

{offwork-0.1.0 → offwork-0.1.1}/offwork/__main__.py

@@ -54,6 +54,8 @@ async def _run_in_tmp_venv(args: argparse.Namespace) -> None:
     extras: list[str] = []
     if args.backend and args.backend.startswith(("redis://", "rediss://")):
         extras.append("redis")
+    if args.backend and args.backend.startswith(("amqp://", "amqps://")):
+        extras.append("rabbitmq")
 
     async with temp_venv(install_offwork=True, extras=extras) as venv:
         cmd = _build_worker_cmd(str(venv.python), args)
@@ -315,6 +317,8 @@ def _collect_extras(args: argparse.Namespace, script: Path) -> list[str]:
     backend = os.environ.get("OFFWORK_BACKEND", "")
     if backend.startswith(("redis://", "rediss://")) and "redis" not in extras:
         extras.append("redis")
+    if backend.startswith(("amqp://", "amqps://")) and "rabbitmq" not in extras:
+        extras.append("rabbitmq")
     for extra in _detect_offwork_extras(str(script)):
         if extra not in extras:
             extras.append(extra)

{offwork-0.1.0 → offwork-0.1.1}/offwork/core/progress.py

@@ -67,7 +67,7 @@ def progress(
 ) -> None:
     """Report task progress from within a running function.
 
-    Call this inside a ``@trace``-decorated function to report progress
+    Call this inside a ``@offwork.task``-decorated function to report progress
     to the client.  When called outside a worker, this is a silent no-op.
 
     Accepts either a percentage or a current/total pair::

{offwork-0.1.0 → offwork-0.1.1}/offwork/core/version.py

@@ -1,7 +1,7 @@
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version as _pkg_version
 
-_FALLBACK_VERSION = "0.4.0"
+_FALLBACK_VERSION = "0.1.0"
 
 try:
     _VERSION: str = _pkg_version("offwork")

offwork-0.1.1/offwork/graph/__init__.py

@@ -0,0 +1,5 @@
+from offwork.graph.graph import Graph
+from offwork.graph.store import Store, MergeResult
+from offwork.graph.decorator import task
+
+__all__ = ["Graph", "Store", "MergeResult", "task"]

{offwork-0.1.0 → offwork-0.1.1}/offwork/graph/analyzer.py

@@ -15,20 +15,22 @@ logger = logging.getLogger(__name__)
 
 
 def _is_trace_decorator(node: ast.expr) -> bool:
-    """Return True if *node* is a ``@trace`` or ``@trace(...)`` decorator."""
-    if isinstance(node, ast.Name) and node.id == "trace":
+    """Return True if *node* is a ``@task``, ``@task(...)``, ``@offwork.task``, or ``@offwork.task(...)`` decorator."""
+    # @task or @task(...)
+    if isinstance(node, ast.Name) and node.id == "task":
         return True
-    if (
-        isinstance(node, ast.Call)
-        and isinstance(node.func, ast.Name)
-        and node.func.id == "trace"
-    ):
+    if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "task":
+        return True
+    # @offwork.task or @offwork.task(...)
+    if isinstance(node, ast.Attribute) and node.attr == "task" and isinstance(node.value, ast.Name) and node.value.id == "offwork":
+        return True
+    if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == "task" and isinstance(node.func.value, ast.Name) and node.func.value.id == "offwork":
         return True
     return False
 
 
 def get_function_source(func: Callable[..., object]) -> str:
-    """Get dedented source of func with @trace decorator lines stripped."""
+    """Get dedented source of func with @task decorator lines stripped."""
     source = textwrap.dedent(inspect.getsource(func))
     tree = ast.parse(source)
     func_def = tree.body[0]

{offwork-0.1.0 → offwork-0.1.1}/offwork/graph/decorator.py

@@ -1,4 +1,4 @@
-"""The ``@trace`` decorator for marking functions for remote execution."""
+"""The ``@offwork.task`` decorator for marking functions for remote execution."""
 
 import logging
 from datetime import timedelta
@@ -15,12 +15,12 @@ _P = ParamSpec("_P")
 
 
 @overload
-def trace(func: Callable[_P, _R]) -> TracedFunction[_P, _R]: ...
+def task(func: Callable[_P, _R]) -> TracedFunction[_P, _R]: ...
 @overload
-def trace(*, timeout: float | None = ..., retries: int = ..., retry_delay: float = ..., throttle: timedelta | float | None = ...) -> TraceDecorator: ...
+def task(*, timeout: float | None = ..., retries: int = ..., retry_delay: float = ..., throttle: timedelta | float | None = ...) -> TraceDecorator: ...
 
 
-def trace(
+def task(
     func: Callable[..., object] | None = None,
     *,
     timeout: float | None = None,
@@ -35,10 +35,10 @@ def trace(
 
     Can be used with or without arguments::
 
-        @trace
+        @offwork.task
         def fast(x): ...
 
-        @trace(timeout=30, retries=3)
+        @offwork.task(timeout=30, retries=3)
         def flaky(x): ...
     """
     if func is not None:
@@ -74,7 +74,7 @@ def _apply_trace(
         if throttle_seconds <= 0:
             raise ValueError(f"throttle must be positive, got {throttle}")
 
-    logger.debug("@trace applied to %s", func.__qualname__)
+    logger.debug("@offwork.task applied to %s", func.__qualname__)
     graph = Graph.default()
     graph.register(func)
     wrapper = graph.create_wrapper(func)

{offwork-0.1.0 → offwork-0.1.1}/offwork/graph/graph.py

@@ -296,7 +296,7 @@ class Graph(TracingMixin):
 
     @classmethod
     def default(cls) -> "Graph":
-        """Return the singleton default graph used by ``@trace``."""
+        """Return the singleton default graph used by ``@offwork.task``."""
         if cls._default is None:
             cls._default = Graph()
         return cls._default

{offwork-0.1.0 → offwork-0.1.1}/offwork/graph/store.py

@@ -429,7 +429,7 @@ class Store:
     # -- Serialization -------------------------------------------------------
 
     def to_dict(self) -> dict[str, Any]:
-        """Export as a dict in v0.4.0 format."""
+        """Export as a dict in v0.1.0 format."""
         qname_to_hash = self._refs
 
         # Build objects with closure_func_refs converted to hashes

{offwork-0.1.0 → offwork-0.1.1}/offwork/typing.py

@@ -1,4 +1,4 @@
-"""Protocol types for ``@trace``-decorated functions."""
+"""Protocol types for ``@offwork.task``-decorated functions."""
 
 from datetime import datetime, timedelta
 from typing import Any, TypeVar, Protocol, ParamSpec
@@ -12,7 +12,7 @@ R = TypeVar("R")
 
 
 class TracedFunction(Protocol[P, R]):
-    """A function decorated with ``@trace``, with remote execution methods."""
+    """A function decorated with ``@offwork.task``, with remote execution methods."""
 
     __offwork_traced__: bool
     __wrapped__: Callable[P, R]
@@ -43,6 +43,6 @@ class TracedFunction(Protocol[P, R]):
 
 
 class TraceDecorator(Protocol):
-    """The ``@trace`` decorator when called with keyword arguments."""
+    """The ``@offwork.task`` decorator when called with keyword arguments."""
 
     def __call__(self, func: Callable[P, R]) -> TracedFunction[P, R]: ...

{offwork-0.1.0 → offwork-0.1.1}/offwork/worker/backends/http.py

@@ -22,8 +22,8 @@ class HttpBackend(Backend):
     The base URL can point either at the broker root or at the service root;
     when no path is provided, ``/api/v1/broker`` is assumed.
 
-    Authentication is intentionally simple for the proof-of-concept:
-    include ``?api_key=...`` in the URL and the backend will move it into the
+    Authentication is currently supported via an API key, which can be provided by
+    including ``?api_key=...`` in the URL and the backend will move it into the
     ``X-Offwork-API-Key`` request header.
     """
 

{offwork-0.1.0 → offwork-0.1.1}/offwork/worker/backends/rabbitmq.py

@@ -67,6 +67,7 @@ class RabbitMQBackend(Backend):
         *,
         task_queue: str | None = None,
         result_ttl: int | None = None,
+        queue_namespace: str | None = None,
     ) -> None:
         self._url = url
         self._task_queue_name = task_queue or self.TASK_QUEUE
@@ -74,6 +75,14 @@ class RabbitMQBackend(Backend):
         self._connection: Any = None
         self._channel: Any = None
         self._lock = asyncio.Lock()
+        ns = f"{queue_namespace}." if queue_namespace else ""
+        self._result_prefix = f"{ns}{self.RESULT_PREFIX}"
+        self._heartbeat_prefix = f"{ns}{self.HEARTBEAT_PREFIX}"
+        self._cancel_prefix = f"{ns}{self.CANCEL_PREFIX}"
+        self._progress_prefix = f"{ns}{self.PROGRESS_PREFIX}"
+        self._schedule_prefix = f"{ns}{self.SCHEDULE_PREFIX}"
+        self._throttle_prefix = f"{ns}{self.THROTTLE_PREFIX}"
+        self._notify_exchange = f"{ns}{self.NOTIFY_EXCHANGE}"
 
     # -- connection management --------------------------------------------------
 
@@ -146,7 +155,7 @@ class RabbitMQBackend(Backend):
         redeclares it with the new arguments.
         """
         try:
-            return await channel.declare_queue(name, arguments=arguments)
+            return await channel.declare_queue(name, durable=True, arguments=arguments)
         except Exception:
             # Channel is closed by RabbitMQ after PRECONDITION_FAILED.
             # Reopen a fresh channel, purge the stale queue, and retry.
@@ -157,7 +166,7 @@ class RabbitMQBackend(Backend):
             except Exception:
                 self._channel = None
                 channel = await self._ensure_channel()
-            return await channel.declare_queue(name, arguments=arguments)
+            return await channel.declare_queue(name, durable=True, arguments=arguments)
 
     async def _kv_put(
         self, prefix: str, task_id: str, value: str, ttl_s: int,
@@ -229,8 +238,8 @@ class RabbitMQBackend(Backend):
     async def send_result(self, task_id: str, result_json: str) -> None:
         async with self._lock:
             channel = await self._ensure_channel()
-            name = f"{self.RESULT_PREFIX}{task_id}"
-            await channel.declare_queue(name, arguments=self._result_args())
+            name = f"{self._result_prefix}{task_id}"
+            await channel.declare_queue(name, durable=True, arguments=self._result_args())
             await channel.default_exchange.publish(
                 aio_pika.Message(result_json.encode()),
                 routing_key=name,
@@ -239,9 +248,9 @@ class RabbitMQBackend(Backend):
     async def get_result(self, task_id: str, timeout: float | None = None) -> str:
         channel = await self._new_channel()
         try:
-            name = f"{self.RESULT_PREFIX}{task_id}"
+            name = f"{self._result_prefix}{task_id}"
             queue = await channel.declare_queue(
-                name, arguments=self._result_args(),
+                name, durable=True, arguments=self._result_args(),
             )
             future: asyncio.Future[str] = asyncio.get_running_loop().create_future()
 
@@ -270,9 +279,9 @@ class RabbitMQBackend(Backend):
     async def try_get_result(self, task_id: str) -> str | None:
         async with self._lock:
             channel = await self._ensure_channel()
-            name = f"{self.RESULT_PREFIX}{task_id}"
+            name = f"{self._result_prefix}{task_id}"
             queue = await channel.declare_queue(
-                name, arguments=self._result_args(),
+                name, durable=True, arguments=self._result_args(),
             )
             msg = await queue.get(fail=False)
             if msg is None:
@@ -285,17 +294,13 @@ class RabbitMQBackend(Backend):
 
     async def send_heartbeat(self, task_id: str) -> None:
         await self._kv_put(
-            self.HEARTBEAT_PREFIX, task_id,
+            self._heartbeat_prefix, task_id,
             str(time.time()), self.HEARTBEAT_TTL,
         )
 
     async def get_heartbeat(self, task_id: str) -> float | None:
-        # Consume (ack) the heartbeat rather than peeking. This avoids a
-        # RabbitMQ race where nack+requeue bypasses x-max-length=1 and causes
-        # the stale heartbeat to be returned on every subsequent poll, making
-        # stall detection fire spuriously.
         raw = await self._kv_get(
-            self.HEARTBEAT_PREFIX, task_id, self.HEARTBEAT_TTL, peek=False,
+            self._heartbeat_prefix, task_id, self.HEARTBEAT_TTL, peek=True,
         )
         return float(raw) if raw is not None else None
 
@@ -303,12 +308,12 @@ class RabbitMQBackend(Backend):
 
     async def cancel_task(self, task_id: str) -> None:
         await self._kv_put(
-            self.CANCEL_PREFIX, task_id, "1", self.CANCEL_TTL,
+            self._cancel_prefix, task_id, "1", self.CANCEL_TTL,
         )
 
     async def is_cancelled(self, task_id: str) -> bool:
         raw = await self._kv_get(
-            self.CANCEL_PREFIX, task_id, self.CANCEL_TTL, peek=True,
+            self._cancel_prefix, task_id, self.CANCEL_TTL, peek=True,
         )
         return raw is not None
 
@@ -316,24 +321,24 @@ class RabbitMQBackend(Backend):
 
     async def send_progress(self, task_id: str, progress_json: str) -> None:
         await self._kv_put(
-            self.PROGRESS_PREFIX, task_id, progress_json, self.PROGRESS_TTL,
+            self._progress_prefix, task_id, progress_json, self.PROGRESS_TTL,
         )
 
     async def get_progress(self, task_id: str) -> str | None:
         return await self._kv_get(
-            self.PROGRESS_PREFIX, task_id, self.PROGRESS_TTL, peek=True,
+            self._progress_prefix, task_id, self.PROGRESS_TTL, peek=True,
         )
 
     # -- Schedule cancellation -------------------------------------------------
 
     async def cancel_schedule(self, schedule_id: str) -> None:
         await self._kv_put(
-            self.SCHEDULE_PREFIX, schedule_id, "1", self.SCHEDULE_TTL,
+            self._schedule_prefix, schedule_id, "1", self.SCHEDULE_TTL,
         )
 
     async def is_schedule_cancelled(self, schedule_id: str) -> bool:
         raw = await self._kv_get(
-            self.SCHEDULE_PREFIX, schedule_id, self.SCHEDULE_TTL, peek=True,
+            self._schedule_prefix, schedule_id, self.SCHEDULE_TTL, peek=True,
         )
         return raw is not None
 
@@ -352,7 +357,7 @@ class RabbitMQBackend(Backend):
         # message body.  Function names can contain characters rejected by
         # the AMQP queue-name grammar (e.g. ``<locals>``), so we hash them.
         raw = await self._kv_get(
-            self.THROTTLE_PREFIX, self._safe_suffix(function_name),
+            self._throttle_prefix, self._safe_suffix(function_name),
             self.THROTTLE_QUEUE_TTL, peek=True,
         )
         if raw is None:
@@ -364,7 +369,7 @@ class RabbitMQBackend(Backend):
     ) -> None:
         expiry = time.time() + throttle_seconds
         await self._kv_put(
-            self.THROTTLE_PREFIX, self._safe_suffix(function_name),
+            self._throttle_prefix, self._safe_suffix(function_name),
             str(expiry), self.THROTTLE_QUEUE_TTL,
         )
 
@@ -374,7 +379,7 @@ class RabbitMQBackend(Backend):
         async with self._lock:
             channel = await self._ensure_channel()
             exchange = await channel.declare_exchange(
-                self.NOTIFY_EXCHANGE, aio_pika.ExchangeType.FANOUT,
+                self._notify_exchange, aio_pika.ExchangeType.FANOUT,
             )
             await exchange.publish(
                 aio_pika.Message(task_id.encode()),
@@ -385,7 +390,7 @@ class RabbitMQBackend(Backend):
         channel = await self._new_channel()
         try:
             exchange = await channel.declare_exchange(
-                self.NOTIFY_EXCHANGE, aio_pika.ExchangeType.FANOUT,
+                self._notify_exchange, aio_pika.ExchangeType.FANOUT,
             )
             queue = await channel.declare_queue(exclusive=True)
             await queue.bind(exchange)

{offwork-0.1.0 → offwork-0.1.1}/offwork/worker/deps.py

@@ -39,7 +39,7 @@ def install_package_as(package: str) -> Iterator[None]:
     """Declare the pip package name for imports inside this block.
 
     At runtime this is a no-op -- the import executes normally.  The
-    ``@trace`` analyzer detects the ``with`` block in the AST and records
+    ``@offwork.task`` analyzer detects the ``with`` block in the AST and records
     the *package* name on every :class:`ImportInfo` inside it, so the
     worker knows which pip package to install.
 
@@ -64,7 +64,7 @@ class _WorkerOnlyStub(types.ModuleType):
     def _err(self) -> WorkerOnlyError:
         return WorkerOnlyError(
             f"'{self.__name__}' was imported with worker_only_import; "
-            "it must only be used inside a @trace function executed on a worker"
+            "it must only be used inside a @offwork.task function executed on a worker"
         )
 
     def __getattr__(self, name: str) -> Any:
@@ -86,7 +86,7 @@ class _StubAttr:
     def _err(self) -> WorkerOnlyError:
         return WorkerOnlyError(
             f"'{self._qualname}' was imported with worker_only_import; "
-            "it must only be used inside a @trace function executed on a worker"
+            "it must only be used inside a @offwork.task function executed on a worker"
         )
 
     def __call__(self, *args: Any, **kwargs: Any) -> Any:
@@ -183,7 +183,7 @@ def worker_only_import(package: str | None = None) -> Iterator[None]:
     """Skip installing packages locally; the worker installs them on demand.
 
     Imports inside this block resolve to lightweight stubs on the client.
-    The ``@trace`` analyzer records the imports as worker-only, and the
+    The ``@offwork.task`` analyzer records the imports as worker-only, and the
     worker installs them via pip before reconstructing the function.
 
     The optional *package* argument overrides the pip package name (same

{offwork-0.1.0 → offwork-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "offwork"
-version = "0.1.0"
+version = "0.1.1"
 description = "Distributed Python task execution via automatic function serialization"
 readme = "README.md"
 authors = [
@@ -40,6 +40,7 @@ dev = [
     "mypy (>=1.19.1,<2.0.0)",
     "ipython (>=9.11.0,<10.0.0)",
     "isort (>=8.0.1,<9.0.0)",
+    "twine (>=6.2.0,<7.0.0)",
 ]
 
 [tool.pytest.ini_options]

offwork-0.1.0/offwork/graph/__init__.py

@@ -1,5 +0,0 @@
-from offwork.graph.graph import Graph
-from offwork.graph.store import Store, MergeResult
-from offwork.graph.decorator import trace
-
-__all__ = ["Graph", "Store", "MergeResult", "trace"]