python-durable 0.2.0__tar.gz → 0.2.3__tar.gz

{python_durable-0.2.0 → python_durable-0.2.3}/.github/workflows/publish.yml

@@ -4,6 +4,9 @@ on:
   release:
     types: [published]
 
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
 jobs:
   publish:
     runs-on: ubuntu-latest

{python_durable-0.2.0 → python_durable-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-durable
-Version: 0.2.0
+Version: 0.2.3
 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

{python_durable-0.2.0 → python_durable-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-durable"
-version = "0.2.0"
+version = "0.2.3"
 description = "Lightweight workflow durability for Python — make any async workflow resumable after crashes with just a decorator."
 readme = "README.md"
 license = "MIT"

{python_durable-0.2.0 → python_durable-0.2.3}/src/durable/pydantic_ai.py

@@ -69,6 +69,20 @@ def _deserialize_messages(data: list[dict]) -> list[Any]:
     return result
 
 
+def _serialize_run_result(result: Any) -> dict:
+    """Convert an agent RunResult to a JSON-serializable dict."""
+    output = result.output
+    # If output is a pydantic model, convert to dict
+    if hasattr(output, "model_dump"):
+        output = output.model_dump(mode="json")
+    data: dict[str, Any] = {"output": output}
+    try:
+        data["all_messages"] = _serialize_messages(result.all_messages())
+    except Exception:
+        data["all_messages"] = []
+    return data
+
+
 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:
@@ -207,7 +221,8 @@ class DurableAgent(Generic[AgentDepsT, OutputT]):
             step_id="agent-run",
             **kwargs,
         )
-        return result
+        output_type = getattr(self.agent, "_output_type", None)
+        return _AgentRunResult(result, output_type=output_type)
 
     async def _do_model_request(
         self,
@@ -225,7 +240,7 @@ class DurableAgent(Generic[AgentDepsT, OutputT]):
         run_kwargs.update(kwargs)
 
         result = await self.agent.run(prompt, **run_kwargs)
-        return _AgentRunResult(result)
+        return _serialize_run_result(result)
 
     async def _do_tool_call(
         self,
@@ -268,15 +283,19 @@ class _AgentRunResult:
     """Wrapper that holds an agent RunResult and handles both live and
     deserialized (dict) results transparently."""
 
-    def __init__(self, result: Any) -> None:
+    def __init__(self, result: Any, output_type: type | None = None) -> None:
         self._result = result
+        self._output_type = output_type
 
     @property
     def output(self) -> Any:
         if hasattr(self._result, "output"):
             return self._result.output
         if isinstance(self._result, dict):
-            return self._result.get("output")
+            raw = self._result.get("output")
+            if isinstance(raw, dict) and self._output_type and hasattr(self._output_type, "model_validate"):
+                return self._output_type.model_validate(raw)
+            return raw
         return self._result
 
     @property

{python_durable-0.2.0 → python_durable-0.2.3}/src/durable/redis_store.py

@@ -18,6 +18,8 @@ _WRAP_KEY = "v"
 
 
 def _wrap(value: Any) -> str:
+    if hasattr(value, "model_dump"):
+        value = value.model_dump(mode="json")
     return json.dumps({_WRAP_KEY: value})
 
 
@@ -71,6 +73,8 @@ class RedisStore(Store):
     async def set_step(
         self, run_id: str, step_id: str, result: Any, attempt: int = 1
     ) -> None:
+        if hasattr(result, "model_dump"):
+            result = result.model_dump(mode="json")
         payload = json.dumps({"v": result, "attempt": attempt})
         key = _step_key(self._prefix, run_id, step_id)
         client = self._client()

{python_durable-0.2.0 → python_durable-0.2.3}/src/durable/store.py

@@ -23,6 +23,8 @@ _WRAP_KEY = "v"
 
 
 def _wrap(value: Any) -> str:
+    if hasattr(value, "model_dump"):
+        value = value.model_dump(mode="json")
     return json.dumps({_WRAP_KEY: value})
 
 

{python_durable-0.2.0 → python_durable-0.2.3}/src/durable/workflow.py

@@ -26,7 +26,7 @@ import functools
 import inspect
 import logging
 import re
-from typing import Any, Callable, ParamSpec, TypeVar, overload
+from typing import Any, Callable, ParamSpec, TypeVar, get_type_hints, overload
 
 from .backoff import BackoffStrategy, exponential
 from .context import RunContext, _active_run
@@ -74,6 +74,12 @@ class _TaskWrapper:
         self._step_name = step_name
         self._retries = retries
         self._backoff = backoff
+        # Extract return type hint for Pydantic model rehydration on replay
+        try:
+            hints = get_type_hints(fn)
+        except Exception:
+            hints = {}
+        self._return_type = hints.get("return")
         # Preserve the original function's metadata for IDE / tooling support
         functools.update_wrapper(self, fn)
 
@@ -97,7 +103,7 @@ class _TaskWrapper:
             log.debug(
                 "[durable] ↩  %s (step=%s) — replayed from store", self._step_name, sid
             )
-            return cached
+            return self._rehydrate(cached)
 
         return await self._execute_with_retry(ctx, sid, args, kwargs)
 
@@ -137,6 +143,17 @@ class _TaskWrapper:
 
         raise last_exc  # type: ignore[misc]
 
+    def _rehydrate(self, value: Any) -> Any:
+        """Re-inflate a cached dict into a Pydantic model if the return type hint says so."""
+        if (
+            isinstance(value, dict)
+            and self._return_type is not None
+            and isinstance(self._return_type, type)
+            and hasattr(self._return_type, "model_validate")
+        ):
+            return self._return_type.model_validate(value)
+        return value
+
     def __repr__(self) -> str:
         return f"<DurableTask '{self._step_name}' retries={self._retries}>"
 

{python_durable-0.2.0 → python_durable-0.2.3}/tests/test_durable.py

@@ -240,3 +240,128 @@ async def test_task_reuse_across_workflows():
         assert call_log == []
 
     print("  ✓ Shared tasks are isolated per workflow run")
+
+
+# ---------------------------------------------------------------------------
+# 7. Pydantic model serialization/deserialization in @wf.task
+# ---------------------------------------------------------------------------
+
+from pydantic import BaseModel
+
+
+class UserModel(BaseModel):
+    id: int
+    name: str
+    email: str
+
+
+async def test_pydantic_model_serializes_from_task():
+    """Pydantic model returned from @wf.task serializes without error on first run."""
+    with tempfile.TemporaryDirectory() as tmp:
+        wf = make_wf(tmp)
+
+        @wf.task
+        async def fetch_user() -> UserModel:
+            return UserModel(id=1, name="Alice", email="alice@example.com")
+
+        @wf.workflow(id="test-pydantic-serialize")
+        async def my_workflow() -> UserModel:
+            return await fetch_user()
+
+        result = await my_workflow()
+        assert isinstance(result, UserModel)
+        assert result.id == 1
+        assert result.name == "Alice"
+
+
+async def test_pydantic_model_rehydrated_on_replay():
+    """Pydantic model is correctly rehydrated on replay (not returned as dict)."""
+    with tempfile.TemporaryDirectory() as tmp:
+        wf = make_wf(tmp)
+        call_log = []
+
+        @wf.task
+        async def fetch_user() -> UserModel:
+            call_log.append("fetch")
+            return UserModel(id=2, name="Bob", email="bob@example.com")
+
+        @wf.workflow(id="test-pydantic-replay")
+        async def my_workflow() -> UserModel:
+            return await fetch_user()
+
+        # First run
+        result = await my_workflow()
+        assert isinstance(result, UserModel)
+        assert call_log == ["fetch"]
+
+        # Second run — replayed from store
+        call_log.clear()
+        result = await my_workflow()
+        assert call_log == [], "Task was re-executed but should have been replayed!"
+        assert isinstance(result, UserModel), f"Expected UserModel, got {type(result)}"
+        assert result.id == 2
+        assert result.name == "Bob"
+
+
+async def test_plain_types_still_work():
+    """Plain dict/string/int returns still work (no regression)."""
+    with tempfile.TemporaryDirectory() as tmp:
+        wf = make_wf(tmp)
+
+        @wf.task
+        async def return_dict() -> dict:
+            return {"key": "value"}
+
+        @wf.task
+        async def return_str() -> str:
+            return "hello"
+
+        @wf.task
+        async def return_int() -> int:
+            return 42
+
+        @wf.workflow(id="test-plain-types")
+        async def my_workflow():
+            d = await return_dict()
+            s = await return_str()
+            i = await return_int()
+            return d, s, i
+
+        d, s, i = await my_workflow()
+        assert d == {"key": "value"}
+        assert s == "hello"
+        assert i == 42
+
+        # Replay
+        d, s, i = await my_workflow()
+        assert d == {"key": "value"}
+        assert s == "hello"
+        assert i == 42
+
+
+async def test_pydantic_without_return_type_hint():
+    """Task without return type hint still serializes Pydantic models (but no rehydration)."""
+    with tempfile.TemporaryDirectory() as tmp:
+        wf = make_wf(tmp)
+        call_log = []
+
+        @wf.task
+        async def fetch_user():
+            call_log.append("fetch")
+            return UserModel(id=3, name="Charlie", email="charlie@example.com")
+
+        @wf.workflow(id="test-pydantic-no-hint")
+        async def my_workflow():
+            return await fetch_user()
+
+        # First run — should serialize without error
+        result = await my_workflow()
+        assert result.id == 3
+        assert call_log == ["fetch"]
+
+        # Replay — no type hint, so it comes back as dict (no rehydration)
+        call_log.clear()
+        result = await my_workflow()
+        assert call_log == []
+        assert isinstance(result, dict), f"Expected dict without type hint, got {type(result)}"
+        assert result["id"] == 3

{python_durable-0.2.0 → python_durable-0.2.3}/tests/test_pydantic_ai.py

@@ -326,3 +326,89 @@ class TestIntegration:
         r2 = await durable.run("What is 6*7?", run_id="calc-1")
         assert r2.output == "42"
         assert agent.run.call_count == 1
+
+    async def test_durable_agent_with_sqlite_store(self, tmp_path):
+        """Ensure agent results are JSON-serializable for SQLiteStore."""
+        db_path = str(tmp_path / "test.db")
+        wf = Workflow("test-sqlite", db=db_path)
+
+        agent, _ = _mock_agent(output="serialized ok")
+        durable = DurableAgent(agent, wf, name="sqlite-agent")
+
+        r1 = await durable.run("Test prompt", run_id="sqlite-1")
+        assert r1.output == "serialized ok"
+        assert agent.run.call_count == 1
+
+        r2 = await durable.run("Test prompt", run_id="sqlite-1")
+        assert r2.output == "serialized ok"
+        assert agent.run.call_count == 1
+
+    async def test_pydantic_model_output_preserved_on_replay(self, wf):
+        """Pydantic model output should be re-hydrated on replay, not returned as dict."""
+        from pydantic import BaseModel
+
+        class CityInfo(BaseModel):
+            name: str
+            population: int
+
+        city = CityInfo(name="Paris", population=2_161_000)
+
+        agent, run_result = _mock_agent()
+        run_result.output = city
+        agent._output_type = CityInfo
+
+        durable = DurableAgent(agent, wf, name="city-agent")
+
+        r1 = await durable.run("Tell me about Paris", run_id="pydantic-1")
+        assert isinstance(r1.output, CityInfo)
+        assert r1.output.name == "Paris"
+        assert agent.run.call_count == 1
+
+        # Replay — should still return a CityInfo, not a dict
+        r2 = await durable.run("Tell me about Paris", run_id="pydantic-1")
+        assert isinstance(r2.output, CityInfo)
+        assert r2.output.name == "Paris"
+        assert r2.output.population == 2_161_000
+        assert agent.run.call_count == 1
+
+    async def test_plain_string_output_no_regression(self, wf):
+        """Plain string outputs should still work after the output_type change."""
+        agent, _ = _mock_agent(output="just a string")
+        agent._output_type = None
+
+        durable = DurableAgent(agent, wf, name="string-agent")
+
+        r1 = await durable.run("Say hello", run_id="string-1")
+        assert r1.output == "just a string"
+
+        r2 = await durable.run("Say hello", run_id="string-1")
+        assert r2.output == "just a string"
+
+
+class TestAgentRunResultRehydration:
+    def test_rehydrate_dict_with_output_type(self):
+        from pydantic import BaseModel
+
+        class Item(BaseModel):
+            id: int
+            label: str
+
+        wrapper = _AgentRunResult({"output": {"id": 1, "label": "test"}}, output_type=Item)
+        result = wrapper.output
+        assert isinstance(result, Item)
+        assert result.id == 1
+        assert result.label == "test"
+
+    def test_no_rehydrate_without_output_type(self):
+        wrapper = _AgentRunResult({"output": {"id": 1, "label": "test"}})
+        result = wrapper.output
+        assert isinstance(result, dict)
+
+    def test_no_rehydrate_non_dict_output(self):
+        from pydantic import BaseModel
+
+        class Item(BaseModel):
+            id: int
+
+        wrapper = _AgentRunResult({"output": "plain string"}, output_type=Item)
+        assert wrapper.output == "plain string"