python-durable 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

durable/__init__.py

@@ -37,6 +37,27 @@ from .redis_store import RedisStore
 from .store import InMemoryStore, SQLiteStore, Store
 from .workflow import Workflow
 
+_PYDANTIC_AI_NAMES = {"DurableAgent", "TaskConfig", "durable_tool", "durable_pipeline"}
+
+
+def __getattr__(name: str):
+    if name in _PYDANTIC_AI_NAMES:
+        from .pydantic_ai import (
+            DurableAgent,
+            TaskConfig,
+            durable_pipeline,
+            durable_tool,
+        )
+
+        return {
+            "DurableAgent": DurableAgent,
+            "TaskConfig": TaskConfig,
+            "durable_tool": durable_tool,
+            "durable_pipeline": durable_pipeline,
+        }[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 __all__ = [
     "Workflow",
     "Store",
@@ -48,6 +69,11 @@ __all__ = [
     "exponential",
     "constant",
     "linear",
+    # pydantic-ai integration (optional)
+    "DurableAgent",
+    "TaskConfig",
+    "durable_tool",
+    "durable_pipeline",
 ]
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

durable/pydantic_ai.py

@@ -0,0 +1,328 @@
+"""Pydantic AI integration for python-durable.
+
+Provides DurableAgent — a wrapper that makes any pydantic-ai Agent durable,
+automatically checkpointing model requests and tool calls to the store.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Any, Generic, TypeVar
+
+from .backoff import BackoffStrategy, exponential
+from .workflow import Workflow
+
+log = logging.getLogger("durable.pydantic_ai")
+
+AgentDepsT = TypeVar("AgentDepsT")
+OutputT = TypeVar("OutputT")
+
+
+def _serialize_messages(messages: list[Any]) -> list[dict]:
+    """Convert pydantic-ai message objects to JSON-serializable dicts."""
+    result = []
+    for msg in messages:
+        if hasattr(msg, "model_dump"):
+            d = msg.model_dump(mode="json")
+            d["__type__"] = type(msg).__name__
+            result.append(d)
+        elif isinstance(msg, dict):
+            result.append(msg)
+        else:
+            result.append({"__repr__": repr(msg)})
+    return result
+
+
+def _deserialize_messages(data: list[dict]) -> list[Any]:
+    """Reconstruct pydantic-ai message objects from serialized dicts.
+
+    Falls back to returning raw dicts if the classes aren't available.
+    """
+    try:
+        from pydantic_ai.messages import (
+            ModelRequest,
+            ModelResponse,
+        )
+
+        _type_map: dict[str, type[Any]] = {
+            "ModelRequest": ModelRequest,
+            "ModelResponse": ModelResponse,
+        }
+    except ImportError:
+        _type_map = {}
+
+    result = []
+    for item in data:
+        type_name = item.pop("__type__", None) if isinstance(item, dict) else None
+        if type_name and type_name in _type_map:
+            try:
+                cls = _type_map[type_name]
+                result.append(cls(**item))
+            except Exception:
+                item["__type__"] = type_name
+                result.append(item)
+        else:
+            if type_name:
+                item["__type__"] = type_name
+            result.append(item)
+    return result
+
+
+def _run_id_for_agent(agent_name: str, prompt: str, run_id: str | None) -> str:
+    """Generate a deterministic run ID from the agent name and prompt."""
+    if run_id:
+        return run_id
+    prompt_hash = hashlib.sha256(prompt.encode()).hexdigest()[:12]
+    return f"agent-{agent_name}-{prompt_hash}"
+
+
+class TaskConfig:
+    """Retry/backoff configuration for model requests or tool calls."""
+
+    def __init__(
+        self,
+        retries: int | None = None,
+        backoff: BackoffStrategy | None = None,
+    ) -> None:
+        self.retries = retries
+        self.backoff = backoff
+
+
+class DurableAgent(Generic[AgentDepsT, OutputT]):
+    """Wrap a pydantic-ai Agent for durable execution with python-durable.
+
+    Wraps each ``agent.run()`` call as a ``@wf.workflow`` and checkpoints
+    model requests and tool calls as ``@wf.task`` steps.
+    """
+
+    def __init__(
+        self,
+        agent: Any,  # pydantic_ai.Agent[AgentDepsT, OutputT]
+        wf: Workflow,
+        *,
+        name: str | None = None,
+        model_task_config: TaskConfig | None = None,
+        tool_task_config: TaskConfig | None = None,
+    ) -> None:
+        self.agent = agent
+        self.wf = wf
+        self.name = name or getattr(agent, "name", None) or "agent"
+
+        self._model_retries = (
+            model_task_config.retries
+            if model_task_config and model_task_config.retries is not None
+            else 3
+        )
+        self._model_backoff = (
+            model_task_config.backoff
+            if model_task_config and model_task_config.backoff
+            else exponential(base=2, max=60)
+        )
+        self._tool_retries = (
+            tool_task_config.retries
+            if tool_task_config and tool_task_config.retries is not None
+            else 2
+        )
+        self._tool_backoff = (
+            tool_task_config.backoff
+            if tool_task_config and tool_task_config.backoff
+            else exponential(base=2, max=30)
+        )
+
+        self._model_request_task = wf.task(
+            name=f"{self.name}.model_request",
+            retries=self._model_retries,
+            backoff=self._model_backoff,
+        )(self._do_model_request)
+
+        self._tool_call_task = wf.task(
+            name=f"{self.name}.tool_call",
+            retries=self._tool_retries,
+            backoff=self._tool_backoff,
+        )(self._do_tool_call)
+
+    async def run(
+        self,
+        prompt: str,
+        *,
+        deps: Any = None,
+        message_history: list[Any] | None = None,
+        run_id: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Run the agent durably.
+
+        Works like ``Agent.run()`` but the result is checkpointed. If the
+        process crashes and you call ``run()`` again with the same ``run_id``
+        (or same prompt), the cached result is returned without re-executing.
+        """
+        rid = _run_id_for_agent(self.name, prompt, run_id)
+
+        @self.wf.workflow(id=rid)
+        async def _durable_run() -> Any:
+            return await self._execute_agent_loop(
+                prompt=prompt,
+                deps=deps,
+                message_history=message_history,
+                **kwargs,
+            )
+
+        return await _durable_run.run(rid)
+
+    def run_sync(
+        self,
+        prompt: str,
+        *,
+        deps: Any = None,
+        message_history: list[Any] | None = None,
+        run_id: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Synchronous version of :meth:`run`."""
+        import asyncio
+
+        return asyncio.run(
+            self.run(
+                prompt,
+                deps=deps,
+                message_history=message_history,
+                run_id=run_id,
+                **kwargs,
+            )
+        )
+
+    async def _execute_agent_loop(
+        self,
+        prompt: str,
+        deps: Any = None,
+        message_history: list[Any] | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Wrap the full agent.run() as a single checkpointed task."""
+        result = await self._model_request_task(
+            prompt,
+            deps=deps,
+            message_history=message_history,
+            step_id="agent-run",
+            **kwargs,
+        )
+        return result
+
+    async def _do_model_request(
+        self,
+        prompt: str,
+        deps: Any = None,
+        message_history: list[Any] | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Execute the actual agent.run() call."""
+        run_kwargs: dict[str, Any] = {}
+        if deps is not None:
+            run_kwargs["deps"] = deps
+        if message_history is not None:
+            run_kwargs["message_history"] = message_history
+        run_kwargs.update(kwargs)
+
+        result = await self.agent.run(prompt, **run_kwargs)
+        return _AgentRunResult(result)
+
+    async def _do_tool_call(
+        self,
+        tool_name: str,
+        tool_args: dict[str, Any],
+    ) -> Any:
+        """Execute a single tool call."""
+        tools = getattr(self.agent, "_function_tools", {})
+        if tool_name not in tools:
+            raise ValueError(
+                f"Tool {tool_name!r} not found on agent {self.name!r}. "
+                f"Available: {list(tools.keys())}"
+            )
+        tool = tools[tool_name]
+        return await tool.run(tool_args)
+
+    async def tool(
+        self,
+        tool_name: str,
+        tool_args: dict[str, Any],
+        *,
+        step_id: str | None = None,
+    ) -> Any:
+        """Durably execute a tool call with checkpointing."""
+        return await self._tool_call_task(tool_name, tool_args, step_id=step_id)
+
+    async def signal(self, name: str, *, poll: float = 2.0) -> Any:
+        """Durably wait for an external signal (e.g., human approval)."""
+        return await self.wf.signal(name, poll=poll)
+
+    def __repr__(self) -> str:
+        return (
+            f"<DurableAgent name={self.name!r} "
+            f"model_retries={self._model_retries} "
+            f"tool_retries={self._tool_retries}>"
+        )
+
+
+class _AgentRunResult:
+    """Wrapper that holds an agent RunResult and handles both live and
+    deserialized (dict) results transparently."""
+
+    def __init__(self, result: Any) -> None:
+        self._result = result
+
+    @property
+    def output(self) -> Any:
+        if hasattr(self._result, "output"):
+            return self._result.output
+        if isinstance(self._result, dict):
+            return self._result.get("output")
+        return self._result
+
+    @property
+    def all_messages(self) -> list[Any]:
+        if hasattr(self._result, "all_messages"):
+            return self._result.all_messages()
+        if isinstance(self._result, dict):
+            return self._result.get("all_messages", [])
+        return []
+
+    @property
+    def usage(self) -> Any:
+        if hasattr(self._result, "usage"):
+            return self._result.usage()
+        if isinstance(self._result, dict):
+            return self._result.get("usage")
+        return None
+
+    def __repr__(self) -> str:
+        return f"<DurableRunResult output={self.output!r}>"
+
+
+def durable_tool(
+    wf: Workflow,
+    *,
+    name: str | None = None,
+    retries: int = 2,
+    backoff: BackoffStrategy | None = None,
+):
+    """Decorator to make a tool function durable (checkpointed as a @wf.task)."""
+    _backoff = backoff or exponential(base=2, max=30)
+
+    def decorator(fn):
+        return wf.task(
+            name=name or getattr(fn, "__name__", "tool"),
+            retries=retries,
+            backoff=_backoff,
+        )(fn)
+
+    return decorator
+
+
+def durable_pipeline(
+    wf: Workflow,
+    *,
+    id: str,  # noqa: A002
+):
+    """Syntactic sugar for ``@wf.workflow`` in multi-agent pipelines."""
+    return wf.workflow(id=id)

durable/redis_store.py

@@ -1,7 +1,7 @@
 """
 Redis-backed store with automatic key expiration.
 
-Requires the ``redis`` extra: ``pip install python-durable[redis]``.
+Requires the ``redis`` extra: ``uv sync --extra redis``.
 """
 
 from __future__ import annotations

python_durable-0.2.0.dist-info/METADATA

@@ -0,0 +1,290 @@
+Metadata-Version: 2.4
+Name: python-durable
+Version: 0.2.0
+Summary: Lightweight workflow durability for Python — make any async workflow resumable after crashes with just a decorator.
+Project-URL: Repository, https://github.com/WillemDeGroef/python-durable
+Author: Willem
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: aiosqlite>=0.20
+Provides-Extra: dev
+Requires-Dist: fakeredis>=2.26; extra == 'dev'
+Requires-Dist: pydantic-ai>=0.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: redis>=5.0; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Requires-Dist: ty>=0.0.1a7; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: pydantic-ai>=0.1; extra == 'examples'
+Requires-Dist: pydantic>=2.0; extra == 'examples'
+Provides-Extra: pydantic-ai
+Requires-Dist: pydantic-ai>=0.1; extra == 'pydantic-ai'
+Provides-Extra: redis
+Requires-Dist: redis>=5.0; extra == 'redis'
+Description-Content-Type: text/markdown
+
+# durable
+
+Lightweight workflow durability for Python. Make any async workflow resumable after crashes with just a decorator.
+
+Backed by SQLite out of the box; swap in Redis or any `Store` subclass for production.
+
+## Install
+
+```bash
+pip install python-durable
+
+# With Redis support
+pip install python-durable[redis]
+
+# With Pydantic AI integration
+pip install python-durable[pydantic-ai]
+```
+
+## Quick start
+
+```python
+from durable import Workflow
+from durable.backoff import exponential
+
+wf = Workflow("my-app")
+
+@wf.task(retries=3, backoff=exponential(base=2, max=60))
+async def fetch_data(url: str) -> dict:
+    async with httpx.AsyncClient() as client:
+        return (await client.get(url)).json()
+
+@wf.task
+async def save_result(data: dict) -> None:
+    await db.insert(data)
+
+@wf.workflow(id="pipeline-{source}")
+async def run_pipeline(source: str) -> None:
+    data = await fetch_data(f"https://api.example.com/{source}")
+    await save_result(data)
+
+# First call: runs all steps and checkpoints each one.
+# If it crashes and you call it again with the same args,
+# completed steps are replayed from SQLite instantly.
+await run_pipeline(source="users")
+```
+
+## How it works
+
+1. **`@wf.task`** wraps an async function with checkpoint + retry logic. When called inside a workflow, results are persisted to the store. On re-run, completed steps return their cached result without re-executing.
+
+2. **`@wf.workflow`** marks the entry point of a durable run. It manages a `RunContext` (via `ContextVar`) so tasks automatically know which run they belong to. The `id` parameter is a template string resolved from function arguments at call time.
+
+3. **`Store`** is the persistence backend. `SQLiteStore` is the default (zero config, backed by aiosqlite). `RedisStore` is available for distributed setups. Subclass `Store` to use Postgres or anything else.
+
+## Features
+
+- **Crash recovery** — completed steps are never re-executed after a restart
+- **Automatic retries** — configurable per-task with `exponential`, `linear`, or `constant` backoff
+- **Signals** — durably wait for external input (approvals, webhooks, human-in-the-loop)
+- **Loop support** — use `step_id` to checkpoint each iteration independently
+- **Zero magic outside workflows** — tasks work as plain async functions when called without a workflow context
+- **Pluggable storage** — SQLite by default, Redis built-in, or bring your own `Store`
+
+## Signals
+
+Workflows can pause and wait for external input using signals:
+
+```python
+@wf.workflow(id="order-{order_id}")
+async def process_order(order_id: str) -> None:
+    await prepare_order(order_id)
+    approval = await wf.signal("manager-approval")  # pauses here
+    if approval["approved"]:
+        await ship_order(order_id)
+
+# From the outside (e.g. a web handler):
+await wf.complete("order-42", "manager-approval", {"approved": True})
+```
+
+Signals are durable — if the workflow crashes and restarts, a previously delivered signal replays instantly.
+
+## Redis store
+
+For distributed or multi-process setups, use `RedisStore` instead of the default SQLite:
+
+```python
+from durable import Workflow, RedisStore
+
+store = RedisStore(url="redis://localhost:6379/0", ttl=86400)
+wf = Workflow("my-app", db=store)
+```
+
+Keys auto-expire based on `ttl` (default: 24 hours).
+
+## Backoff strategies
+
+```python
+from durable.backoff import exponential, linear, constant
+
+@wf.task(retries=5, backoff=exponential(base=2, max=60))  # 2s, 4s, 8s, 16s, 32s
+async def exp_task(): ...
+
+@wf.task(retries=3, backoff=linear(start=2, step=3))      # 2s, 5s, 8s
+async def linear_task(): ...
+
+@wf.task(retries=3, backoff=constant(5))                   # 5s, 5s, 5s
+async def const_task(): ...
+```
+
+## Loops with step_id
+
+When calling the same task in a loop, pass `step_id` so each iteration is checkpointed independently:
+
+```python
+@wf.workflow(id="batch-{batch_id}")
+async def process_batch(batch_id: str) -> None:
+    for i, item in enumerate(items):
+        await process_item(item, step_id=f"item-{i}")
+```
+
+If the workflow crashes mid-loop, only the remaining items are processed on restart.
+
+## Pydantic AI integration
+
+Make any [pydantic-ai](https://ai.pydantic.dev) agent durable with **zero infrastructure** — no Temporal server, no Prefect cloud, no Postgres. Just decorators and a SQLite file.
+
+Pydantic AI natively supports three durable execution backends: **Temporal**, **DBOS**, and **Prefect**. All three require external infrastructure. `python-durable` is a fourth option that trades scale for simplicity:
+
+| Feature | Temporal | DBOS | Prefect | **python-durable** |
+|---------|----------|------|---------|-------------------|
+| Infrastructure | Server + Worker | Postgres | Cloud/Server | **SQLite file** |
+| Setup | Complex | Moderate | Moderate | **`pip install`** |
+| Lines to wrap an agent | ~20 | ~10 | ~10 | **1** |
+| Crash recovery | Yes | Yes | Yes | Yes |
+| Retries + backoff | Yes | Yes | Yes | Yes |
+| Human-in-the-loop signals | Yes | No | No | Yes |
+| Multi-process / distributed | Yes | Yes | Yes | No (single process) |
+| Production scale | Enterprise | Production | Production | **Dev / SME / CLI** |
+
+**Best for:** prototyping, CLI tools, single-process services, SME deployments, and any situation where you want durable agents without ops overhead.
+
+### DurableAgent
+
+```python
+from pydantic_ai import Agent
+from durable import Workflow
+from durable.pydantic_ai import DurableAgent, TaskConfig
+from durable.backoff import exponential
+
+wf = Workflow("my-app")
+agent = Agent("openai:gpt-5.2", instructions="Be helpful.", name="assistant")
+
+durable_agent = DurableAgent(agent, wf)
+
+result = await durable_agent.run("What is the capital of France?")
+print(result.output)  # Paris
+
+# Same run_id after crash → replayed from SQLite, no LLM call
+result = await durable_agent.run("What is the capital of France?", run_id="same-id")
+```
+
+With custom retry config:
+
+```python
+durable_agent = DurableAgent(
+    agent,
+    wf,
+    model_task_config=TaskConfig(retries=5, backoff=exponential(base=2, max=120)),
+    tool_task_config=TaskConfig(retries=3),
+)
+```
+
+### @durable_tool
+
+Make individual tool functions durable:
+
+```python
+from durable.pydantic_ai import durable_tool
+
+@durable_tool(wf, retries=3, backoff=exponential(base=2, max=60))
+async def web_search(query: str) -> str:
+    async with httpx.AsyncClient() as client:
+        return (await client.get(f"https://api.search.com?q={query}")).text
+```
+
+### @durable_pipeline
+
+Multi-agent workflows with per-step checkpointing. On crash, completed steps replay from the store and only remaining work executes:
+
+```python
+from durable.pydantic_ai import durable_pipeline
+
+@durable_pipeline(wf, id="research-{topic_id}")
+async def research(topic_id: str, topic: str) -> str:
+    plan = await plan_research(topic)
+    findings = []
+    for i, query in enumerate(plan["queries"]):
+        r = await search(query, step_id=f"q-{i}")
+        findings.append(r)
+    return await summarize(findings)
+```
+
+### Comparison with Temporal
+
+```python
+# Temporal — requires server + worker + plugin
+from temporalio import workflow
+from pydantic_ai.durable_exec.temporal import TemporalAgent
+
+temporal_agent = TemporalAgent(agent)
+
+@workflow.defn
+class MyWorkflow:
+    @workflow.run
+    async def run(self, prompt: str):
+        return await temporal_agent.run(prompt)
+
+# python-durable
+from durable import Workflow
+from durable.pydantic_ai import DurableAgent
+
+wf = Workflow("my-app")
+durable_agent = DurableAgent(agent, wf)
+result = await durable_agent.run("Hello")
+```
+
+### Caveats
+
+- **Tool functions** registered on the pydantic-ai agent are NOT automatically wrapped. If they perform I/O, decorate them with `@durable_tool(wf)` or `@wf.task`.
+- **Streaming** (`agent.run_stream()`) is not supported in durable mode (same limitation as DBOS). Use `agent.run()`.
+- **Single process** — unlike Temporal/DBOS, python-durable runs in-process. For distributed workloads, use the Redis store.
+
+See [`examples/pydantic_ai_example.py`](examples/pydantic_ai_example.py) for five complete patterns.
+
+## Important: JSON serialization
+
+Task return values must be JSON-serializable (dicts, lists, strings, numbers, booleans, `None`). The store uses `json.dumps` internally.
+
+For Pydantic models, return `.model_dump()` from tasks and reconstruct with `.model_validate()` downstream:
+
+```python
+@wf.task
+async def validate_invoice(draft: InvoiceDraft) -> dict:
+    validated = ValidatedInvoice(...)
+    return validated.model_dump()
+
+@wf.task
+async def book_invoice(data: dict) -> dict:
+    invoice = ValidatedInvoice.model_validate(data)
+    ...
+```
+
+## License
+
+MIT

python_durable-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+durable/__init__.py,sha256=CMNNJpWOyJHDKK9H2UidatvyDAb76UR4sbhEKIpBOCQ,2187
+durable/backoff.py,sha256=o5p3hXfJ1YMwmEzjzukqW6inYezYGYnEi3_1YwnmDcU,1056
+durable/context.py,sha256=greEK4jRz9RmVc5kHlmBjU3fisrsl2RCDDtGUPEiQM4,1324
+durable/pydantic_ai.py,sha256=3g4mmxJ0X_Kw8LsRZxeZiwho9G7kZR7QTrCD4LgZtUU,9761
+durable/redis_store.py,sha256=ShzNblDOoxTm5rEonbcwotEZmfZ8DYrCfx-7fMTUxAE,3536
+durable/store.py,sha256=YvrVNFzYQGSlLR-TKnXS0b1tJzpY5zr_tkkKDH5sR1k,8769
+durable/workflow.py,sha256=Q0boxwnquNJMueE8LeRlWg8yLxFr6m1I6RzOO3kmdB8,13192
+python_durable-0.2.0.dist-info/METADATA,sha256=N_ygSggefBkxcAutcvZumKfkBFMYVdyXeDyrZ6Q0iwA,10029
+python_durable-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_durable-0.2.0.dist-info/licenses/LICENSE,sha256=S5JKY7biEEYA0tC7Qr2hO-ppopDVnD8muKbaviRFqLk,1084
+python_durable-0.2.0.dist-info/RECORD,,

python_durable-0.1.1.dist-info/METADATA

@@ -1,137 +0,0 @@
-Metadata-Version: 2.4
-Name: python-durable
-Version: 0.1.1
-Summary: Lightweight workflow durability for Python — make any async workflow resumable after crashes with just a decorator.
-Project-URL: Repository, https://github.com/WillemDeGroef/python-durable
-Author: Willem
-License-Expression: MIT
-License-File: LICENSE
-Classifier: Development Status :: 3 - Alpha
-Classifier: Framework :: AsyncIO
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Typing :: Typed
-Requires-Python: >=3.12
-Requires-Dist: aiosqlite>=0.20
-Provides-Extra: dev
-Requires-Dist: fakeredis>=2.26; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
-Requires-Dist: pytest>=8.0; extra == 'dev'
-Requires-Dist: redis>=5.0; extra == 'dev'
-Requires-Dist: ruff>=0.9; extra == 'dev'
-Requires-Dist: ty>=0.0.1a7; extra == 'dev'
-Provides-Extra: examples
-Requires-Dist: pydantic-ai>=0.1; extra == 'examples'
-Requires-Dist: pydantic>=2.0; extra == 'examples'
-Provides-Extra: redis
-Requires-Dist: redis>=5.0; extra == 'redis'
-Description-Content-Type: text/markdown
-
-# durable
-
-Lightweight workflow durability for Python. Make any async workflow resumable after crashes with just a decorator.
-
-Backed by SQLite out of the box; swap in any `Store` subclass for production.
-
-## Install
-
-```bash
-pip install python-durable
-```
-
-## Quick start
-
-```python
-from durable import Workflow
-from durable.backoff import exponential
-
-wf = Workflow("my-app")
-
-@wf.task(retries=3, backoff=exponential(base=2, max=60))
-async def fetch_data(url: str) -> dict:
-    async with httpx.AsyncClient() as client:
-        return (await client.get(url)).json()
-
-@wf.task
-async def save_result(data: dict) -> None:
-    await db.insert(data)
-
-@wf.workflow(id="pipeline-{source}")
-async def run_pipeline(source: str) -> None:
-    data = await fetch_data(f"https://api.example.com/{source}")
-    await save_result(data)
-
-# First call: runs all steps and checkpoints each one.
-# If it crashes and you call it again with the same args,
-# completed steps are replayed from SQLite instantly.
-await run_pipeline(source="users")
-```
-
-## How it works
-
-1. **`@wf.task`** wraps an async function with checkpoint + retry logic. When called inside a workflow, results are persisted to the store. On re-run, completed steps return their cached result without re-executing.
-
-2. **`@wf.workflow`** marks the entry point of a durable run. It manages a `RunContext` (via `ContextVar`) so tasks automatically know which run they belong to. The `id` parameter is a template string resolved from function arguments at call time.
-
-3. **`Store`** is the persistence backend. `SQLiteStore` is the default (zero config, backed by aiosqlite). Subclass `Store` to use Postgres, Redis, or anything else.
-
-## Features
-
-- **Crash recovery** — completed steps are never re-executed after a restart
-- **Automatic retries** — configurable per-task with `exponential`, `linear`, or `constant` backoff
-- **Loop support** — use `step_id` to checkpoint each iteration independently
-- **Zero magic outside workflows** — tasks work as plain async functions when called without a workflow context
-- **Pluggable storage** — SQLite by default, bring your own `Store` for production
-
-## Backoff strategies
-
-```python
-from durable.backoff import exponential, linear, constant
-
-@wf.task(retries=5, backoff=exponential(base=2, max=60))  # 2s, 4s, 8s, 16s, 32s
-async def exp_task(): ...
-
-@wf.task(retries=3, backoff=linear(start=2, step=3))      # 2s, 5s, 8s
-async def linear_task(): ...
-
-@wf.task(retries=3, backoff=constant(5))                   # 5s, 5s, 5s
-async def const_task(): ...
-```
-
-## Loops with step_id
-
-When calling the same task in a loop, pass `step_id` so each iteration is checkpointed independently:
-
-```python
-@wf.workflow(id="batch-{batch_id}")
-async def process_batch(batch_id: str) -> None:
-    for i, item in enumerate(items):
-        await process_item(item, step_id=f"item-{i}")
-```
-
-If the workflow crashes mid-loop, only the remaining items are processed on restart.
-
-## Important: JSON serialization
-
-Task return values must be JSON-serializable (dicts, lists, strings, numbers, booleans, `None`). The store uses `json.dumps` internally.
-
-For Pydantic models, return `.model_dump()` from tasks and reconstruct with `.model_validate()` downstream:
-
-```python
-@wf.task
-async def validate_invoice(draft: InvoiceDraft) -> dict:
-    validated = ValidatedInvoice(...)
-    return validated.model_dump()
-
-@wf.task
-async def book_invoice(data: dict) -> dict:
-    invoice = ValidatedInvoice.model_validate(data)
-    ...
-```
-
-## License
-
-MIT

python_durable-0.1.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-durable/__init__.py,sha256=IPi-f0B49fps6zZ5Hik1AP5Dp-thp3MoQXCEVikes44,1477
-durable/backoff.py,sha256=o5p3hXfJ1YMwmEzjzukqW6inYezYGYnEi3_1YwnmDcU,1056
-durable/context.py,sha256=greEK4jRz9RmVc5kHlmBjU3fisrsl2RCDDtGUPEiQM4,1324
-durable/redis_store.py,sha256=gYMRqgEzLh5K4EC3dWry515l4eJ8OfZqRGaY-1eRrDA,3548
-durable/store.py,sha256=YvrVNFzYQGSlLR-TKnXS0b1tJzpY5zr_tkkKDH5sR1k,8769
-durable/workflow.py,sha256=Q0boxwnquNJMueE8LeRlWg8yLxFr6m1I6RzOO3kmdB8,13192
-python_durable-0.1.1.dist-info/METADATA,sha256=-ig6huL8l_xGmrNqfQolT_uvcMStHFUbeoKqDmEbx9s,4775
-python_durable-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-python_durable-0.1.1.dist-info/licenses/LICENSE,sha256=S5JKY7biEEYA0tC7Qr2hO-ppopDVnD8muKbaviRFqLk,1084
-python_durable-0.1.1.dist-info/RECORD,,