python-durable 0.1.0__tar.gz → 0.1.1__tar.gz

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

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

python_durable-0.1.1/examples/approval.py

@@ -0,0 +1,95 @@
+"""
+approval.py — Human-in-the-loop approval workflow using durable signals.
+
+Demonstrates how a workflow can durably wait for external input (e.g. a
+human approval via a web endpoint), survive crashes, and resume cleanly.
+
+Run with:
+    uvicorn examples.approval:app --reload
+
+Then:
+    1. POST /orders/ord-100        → starts the workflow, blocks at approval
+    2. POST /approve/process-order-ord-100/manager-approval
+       body: {"approved": true, "approver": "alice@example.com"}
+                                    → delivers the signal, workflow continues
+    3. POST /orders/ord-100        → re-run: everything replays from cache
+"""
+
+import asyncio
+import logging
+
+from fastapi import FastAPI
+
+from durable import Workflow
+
+logging.basicConfig(level=logging.INFO)
+
+app = FastAPI(title="Durable Approval Example")
+wf = Workflow("approvals", db="sqlite:///approval.db")
+
+
+# ---------------------------------------------------------------------------
+# Tasks
+# ---------------------------------------------------------------------------
+
+
+@wf.task
+async def validate_order(order_id: str) -> dict:
+    print(f"  [validate_order] validating {order_id}...")
+    await asyncio.sleep(0.1)
+    return {"order_id": order_id, "total": 12_500.00, "items": 3}
+
+
+@wf.task
+async def fulfill_order(order: dict, approval: dict) -> dict:
+    print(
+        f"  [fulfill_order] fulfilling {order['order_id']}, approved by {approval.get('approver')}"
+    )
+    await asyncio.sleep(0.1)
+    return {"status": "fulfilled", "order_id": order["order_id"]}
+
+
+# ---------------------------------------------------------------------------
+# Workflow — blocks at wf.signal() until a human approves
+# ---------------------------------------------------------------------------
+
+
+@wf.workflow(id="process-order-{order_id}")
+async def process_order(order_id: str) -> dict:
+    order = await validate_order(order_id)
+    print("  [process_order] order validated, waiting for manager approval...")
+
+    # This durably blocks until someone calls wf.complete()
+    approval = await wf.signal("manager-approval")
+
+    if not approval.get("approved"):
+        return {"status": "rejected", "order_id": order_id}
+
+    return await fulfill_order(order, approval)
+
+
+# ---------------------------------------------------------------------------
+# HTTP endpoints
+# ---------------------------------------------------------------------------
+
+
+@app.post("/orders/{order_id}")
+async def start_order(order_id: str):
+    """Start (or re-run) the order workflow. Blocks until approval signal arrives."""
+    result = await process_order(order_id=order_id)
+    return result
+
+
+@app.post("/approve/{run_id}/{signal_name}")
+async def approve(run_id: str, signal_name: str, payload: dict):
+    """
+    Deliver a signal to a waiting workflow.
+
+    Example:
+        POST /approve/process-order-ord-100/manager-approval
+        {"approved": true, "approver": "alice@example.com"}
+    """
+    ok = await wf.complete(run_id, signal_name, payload)
+    if not ok:
+        return {"status": "already_completed", "run_id": run_id, "signal": signal_name}
+    return {"status": "delivered", "run_id": run_id, "signal": signal_name}

python_durable-0.1.1/examples/redis_example.py

@@ -0,0 +1,74 @@
+"""
+redis_example.py — Using RedisStore for distributed, TTL-backed workflows.
+
+Checkpoints are stored in Redis with automatic expiration (default: 24 hours).
+This is ideal for production deployments where multiple workers share state
+or you want old runs to expire automatically.
+
+Prerequisites:
+    pip install python-durable[redis]
+    # or: uv sync --all-extras
+
+    # Redis must be running locally (default: localhost:6379)
+    docker run -d --name redis -p 6379:6379 redis:latest
+
+Run with:
+    uv run python examples/redis_example.py
+"""
+
+import asyncio
+
+from durable import RedisStore, Workflow
+from durable.backoff import constant
+
+store = RedisStore(
+    url="redis://localhost:6379/0",
+    ttl=3600,  # checkpoints expire after 1 hour
+    prefix="example",
+)
+wf = Workflow("redis-demo", db=store)
+
+call_count = 0
+
+
+@wf.task(retries=3, backoff=constant(0))
+async def flaky_fetch(url: str) -> dict:
+    """Fails twice, then succeeds — retries are handled automatically."""
+    global call_count
+    call_count += 1
+    if call_count < 3:
+        raise ConnectionError(f"attempt {call_count}: connection refused")
+    print(f"  [flaky_fetch] succeeded on attempt {call_count}")
+    return {"url": url, "status": "ok"}
+
+
+@wf.task
+async def transform(data: dict) -> str:
+    print(f"  [transform] processing {data['url']}")
+    return f"transformed-{data['status']}"
+
+
+@wf.workflow(id="pipeline-{job_id}")
+async def pipeline(job_id: str) -> str:
+    data = await flaky_fetch("https://api.example.com/data")
+    return await transform(data)
+
+
+async def main():
+    await store.setup()
+    try:
+        print("── First run: flaky_fetch retries, then both steps execute ──")
+        result = await pipeline(job_id="job-1")
+        print(f"  result: {result}")
+
+        print("\n── Second run (same id): both steps replayed from Redis ──")
+        result = await pipeline(job_id="job-1")
+        print(f"  result: {result}")
+
+        print("\n✓ Done. Checkpoints stored in Redis (TTL: 1 hour).")
+    finally:
+        await store.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-durable"
-version = "0.1.0"
+version = "0.1.1"
 description = "Lightweight workflow durability for Python — make any async workflow resumable after crashes with just a decorator."
 readme = "README.md"
 license = "MIT"
@@ -24,11 +24,16 @@ dependencies = [
 Repository = "https://github.com/WillemDeGroef/python-durable"
 
 [project.optional-dependencies]
+redis = [
+    "redis>=5.0",
+]
 dev = [
     "pytest>=8.0",
     "pytest-asyncio>=0.24",
     "ruff>=0.9",
     "ty>=0.0.1a7",
+    "fakeredis>=2.26",
+    "redis>=5.0",
 ]
 examples = [
     "pydantic>=2.0",

{python_durable-0.1.0 → python_durable-0.1.1}/src/durable/__init__.py

@@ -33,6 +33,7 @@ Quick start:
 
 from .backoff import BackoffStrategy, constant, exponential, linear
 from .context import RunContext
+from .redis_store import RedisStore
 from .store import InMemoryStore, SQLiteStore, Store
 from .workflow import Workflow
 
@@ -41,6 +42,7 @@ __all__ = [
     "Store",
     "SQLiteStore",
     "InMemoryStore",
+    "RedisStore",
     "RunContext",
     "BackoffStrategy",
     "exponential",

python_durable-0.1.1/src/durable/redis_store.py

@@ -0,0 +1,116 @@
+"""
+Redis-backed store with automatic key expiration.
+
+Requires the ``redis`` extra: ``pip install python-durable[redis]``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+from redis.asyncio import Redis
+
+from .store import Store
+
+_WRAP_KEY = "v"
+
+
+def _wrap(value: Any) -> str:
+    return json.dumps({_WRAP_KEY: value})
+
+
+def _unwrap(raw: str | bytes) -> Any:
+    return json.loads(raw)[_WRAP_KEY]
+
+
+def _step_key(prefix: str, run_id: str, step_id: str) -> str:
+    tag = hashlib.sha256(f"{run_id}:{step_id}".encode()).hexdigest()[:16]
+    return f"{prefix}:step:{tag}"
+
+
+def _run_key(prefix: str, run_id: str) -> str:
+    return f"{prefix}:run:{run_id}"
+
+
+def _sig_key(prefix: str, run_id: str, name: str) -> str:
+    tag = hashlib.sha256(f"{run_id}:{name}".encode()).hexdigest()[:16]
+    return f"{prefix}:sig:{tag}"
+
+
+class RedisStore(Store):
+    """Async Redis store with TTL-based auto-expiration."""
+
+    def __init__(
+        self,
+        url: str = "redis://localhost:6379/0",
+        ttl: int = 86_400,
+        prefix: str = "durable",
+    ) -> None:
+        self._url = url
+        self._ttl = ttl
+        self._prefix = prefix
+        self._redis: Redis | None = None
+
+    async def setup(self) -> None:
+        if self._redis is None:
+            self._redis = Redis.from_url(self._url, decode_responses=True)
+
+    def _client(self) -> Redis:
+        if self._redis is None:
+            raise RuntimeError("RedisStore.setup() must be called before use")
+        return self._redis
+
+    async def get_step(self, run_id: str, step_id: str) -> tuple[bool, Any]:
+        raw = await self._client().get(_step_key(self._prefix, run_id, step_id))
+        if raw is None:
+            return False, None
+        return True, _unwrap(raw)
+
+    async def set_step(
+        self, run_id: str, step_id: str, result: Any, attempt: int = 1
+    ) -> None:
+        payload = json.dumps({"v": result, "attempt": attempt})
+        key = _step_key(self._prefix, run_id, step_id)
+        client = self._client()
+        if self._ttl > 0:
+            await client.setex(key, self._ttl, payload)
+        else:
+            await client.set(key, payload)
+
+    async def mark_run_done(self, run_id: str) -> None:
+        key = _run_key(self._prefix, run_id)
+        client = self._client()
+        if self._ttl > 0:
+            await client.setex(key, self._ttl, "done")
+        else:
+            await client.set(key, "done")
+
+    async def mark_run_failed(self, run_id: str, error: str) -> None:
+        key = _run_key(self._prefix, run_id)
+        payload = json.dumps({"status": "failed", "error": error})
+        client = self._client()
+        if self._ttl > 0:
+            await client.setex(key, self._ttl, payload)
+        else:
+            await client.set(key, payload)
+
+    async def get_signal(self, run_id: str, name: str) -> tuple[bool, Any]:
+        raw = await self._client().get(_sig_key(self._prefix, run_id, name))
+        if raw is None:
+            return False, None
+        return True, json.loads(raw)
+
+    async def set_signal(self, run_id: str, name: str, payload: Any) -> bool:
+        key = _sig_key(self._prefix, run_id, name)
+        client = self._client()
+        created = await client.set(key, json.dumps(payload), nx=True)
+        if created and self._ttl > 0:
+            await client.expire(key, self._ttl)
+        return bool(created)
+
+    async def close(self) -> None:
+        if self._redis is not None:
+            await self._redis.aclose()
+            self._redis = None

{python_durable-0.1.0 → python_durable-0.1.1}/src/durable/store.py

@@ -55,6 +55,14 @@ class Store(ABC):
     async def mark_run_failed(self, run_id: str, error: str) -> None:
         """Mark the run as failed with an error message."""
 
+    @abstractmethod
+    async def get_signal(self, run_id: str, name: str) -> tuple[bool, Any]:
+        """Return (found, payload). found=False means the signal hasn't been delivered yet."""
+
+    @abstractmethod
+    async def set_signal(self, run_id: str, name: str, payload: Any) -> bool:
+        """Write payload. Returns False if already set (idempotent, first-write-wins)."""
+
 
 _SENTINEL = object()
 
@@ -70,6 +78,7 @@ class InMemoryStore(Store):
     def __init__(self) -> None:
         self._steps: dict[tuple[str, str], Any] = {}
         self._runs: dict[str, str] = {}
+        self._signals: dict[tuple[str, str], Any] = {}
 
     async def setup(self) -> None:
         pass
@@ -91,6 +100,19 @@ class InMemoryStore(Store):
     async def mark_run_failed(self, run_id: str, error: str) -> None:
         self._runs[run_id] = "failed"
 
+    async def get_signal(self, run_id: str, name: str) -> tuple[bool, Any]:
+        key = (run_id, name)
+        if key in self._signals:
+            return True, self._signals[key]
+        return False, None
+
+    async def set_signal(self, run_id: str, name: str, payload: Any) -> bool:
+        key = (run_id, name)
+        if key in self._signals:
+            return False
+        self._signals[key] = payload
+        return True
+
 
 class SQLiteStore(Store):
     """
@@ -126,6 +148,13 @@ class SQLiteStore(Store):
                     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                     PRIMARY KEY (run_id, step_id)
                 );
+
+                CREATE TABLE IF NOT EXISTS signals (
+                    run_id  TEXT NOT NULL,
+                    name    TEXT NOT NULL,
+                    payload TEXT NOT NULL,
+                    PRIMARY KEY (run_id, name)
+                );
             """)
             await db.commit()
         self._ready = True
@@ -189,6 +218,26 @@ class SQLiteStore(Store):
             )
             await db.commit()
 
+    async def get_signal(self, run_id: str, name: str) -> tuple[bool, Any]:
+        async with aiosqlite.connect(self.path) as db:
+            async with db.execute(
+                "SELECT payload FROM signals WHERE run_id = ? AND name = ?",
+                (run_id, name),
+            ) as cursor:
+                row = await cursor.fetchone()
+                if row is None:
+                    return False, None
+                return True, json.loads(row[0])
+
+    async def set_signal(self, run_id: str, name: str, payload: Any) -> bool:
+        async with aiosqlite.connect(self.path) as db:
+            cursor = await db.execute(
+                "INSERT OR IGNORE INTO signals (run_id, name, payload) VALUES (?, ?, ?)",
+                (run_id, name, json.dumps(payload)),
+            )
+            await db.commit()
+            return cursor.rowcount > 0
+
     async def ensure_run(self, run_id: str, workflow_id: str) -> None:
         async with aiosqlite.connect(self.path) as db:
             await db.execute(

{python_durable-0.1.0 → python_durable-0.1.1}/src/durable/workflow.py

@@ -164,6 +164,8 @@ class Workflow:
         self._default_backoff = default_backoff
         self._store = self._build_store(db)
         self._initialized = False
+        self._sig_events: dict[str, asyncio.Event] = {}
+        self._sig_data: dict[str, Any] = {}
 
     # ------------------------------------------------------------------
     # @wf.task — can be used bare or with arguments
@@ -320,6 +322,52 @@ class Workflow:
             return decorator(fn)
         return decorator
 
+    # ------------------------------------------------------------------
+    # Signals — durable wait for external input
+    # ------------------------------------------------------------------
+
+    @property
+    def _current_run_id(self) -> str:
+        ctx = _active_run.get()
+        if ctx is None:
+            raise RuntimeError("signal() must be called inside an active workflow")
+        return ctx.run_id
+
+    async def signal(self, name: str, *, poll: float = 2.0) -> Any:
+        """Durably wait for an external signal inside a workflow."""
+        run_id = self._current_run_id
+        sk = f"{run_id}:{name}"
+
+        # Replay: already delivered?
+        found, payload = await self._store.get_signal(run_id, name)
+        if found:
+            return payload
+
+        # Wait: in-process event + store poll fallback
+        event = self._sig_events[sk] = asyncio.Event()
+        try:
+            while True:
+                try:
+                    await asyncio.wait_for(event.wait(), timeout=poll)
+                    return self._sig_data.pop(sk)
+                except asyncio.TimeoutError:
+                    found, payload = await self._store.get_signal(run_id, name)
+                    if found:
+                        return payload
+        finally:
+            self._sig_events.pop(sk, None)
+            self._sig_data.pop(sk, None)
+
+    async def complete(self, run_id: str, name: str, payload: Any = None) -> bool:
+        """Deliver a signal from the outside world (e.g. a web handler)."""
+        ok = await self._store.set_signal(run_id, name, payload or {})
+        if ok:
+            sk = f"{run_id}:{name}"
+            self._sig_data[sk] = payload or {}
+            if sk in self._sig_events:
+                self._sig_events[sk].set()
+        return ok
+
     # ------------------------------------------------------------------
     # Internal helpers
     # ------------------------------------------------------------------

python_durable-0.1.1/tests/test_redis_store.py

@@ -0,0 +1,171 @@
+import json
+
+import pytest
+from fakeredis.aioredis import FakeRedis
+
+from durable import RedisStore, Workflow
+
+
+def _make_store(ttl: int = 86_400) -> RedisStore:
+    store = RedisStore(ttl=ttl)
+    store._redis = FakeRedis(decode_responses=True)
+    return store
+
+
+def _make_wf(store: RedisStore) -> Workflow:
+    return Workflow("test-redis", db=store, default_retries=0)
+
+
+async def test_get_missing_step_returns_not_found():
+    store = _make_store()
+    await store.setup()
+    found, value = await store.get_step("run-1", "step-1")
+    assert found is False
+    assert value is None
+
+
+async def test_set_and_get_step():
+    store = _make_store()
+    await store.setup()
+
+    await store.set_step("run-1", "step-1", {"count": 42})
+    found, value = await store.get_step("run-1", "step-1")
+    assert found is True
+    assert value == {"count": 42}
+
+
+async def test_step_returns_none_value():
+    store = _make_store()
+    await store.setup()
+
+    await store.set_step("run-1", "step-1", None)
+    found, value = await store.get_step("run-1", "step-1")
+    assert found is True
+    assert value is None
+
+
+async def test_ttl_is_applied():
+    store = _make_store(ttl=60)
+    await store.setup()
+
+    await store.set_step("run-1", "step-1", "hello")
+    key = next(k for k in await store._client().keys("*") if "step" in k)
+    ttl = await store._client().ttl(key)
+    assert 0 < ttl <= 60
+
+
+async def test_no_ttl_when_zero():
+    store = _make_store(ttl=0)
+    await store.setup()
+
+    await store.set_step("run-1", "step-1", "hello")
+    key = next(k for k in await store._client().keys("*") if "step" in k)
+    ttl = await store._client().ttl(key)
+    assert ttl == -1
+
+
+async def test_mark_run_done():
+    store = _make_store()
+    await store.setup()
+
+    await store.mark_run_done("run-1")
+    key = next(k for k in await store._client().keys("*") if "run" in k)
+    assert await store._client().get(key) == "done"
+
+
+async def test_mark_run_failed():
+    store = _make_store()
+    await store.setup()
+
+    await store.mark_run_failed("run-1", "kaboom")
+    key = next(k for k in await store._client().keys("*") if "run" in k)
+    raw = await store._client().get(key)
+    data = json.loads(raw)
+    assert data["status"] == "failed"
+    assert data["error"] == "kaboom"
+
+
+async def test_overwrite_step():
+    store = _make_store()
+    await store.setup()
+
+    await store.set_step("run-1", "step-1", "first")
+    await store.set_step("run-1", "step-1", "second")
+    found, value = await store.get_step("run-1", "step-1")
+    assert found is True
+    assert value == "second"
+
+
+async def test_close():
+    store = _make_store()
+    await store.setup()
+    await store.close()
+    assert store._redis is None
+
+
+async def test_workflow_checkpoints_with_redis():
+    store = _make_store()
+    wf = _make_wf(store)
+    call_log: list[str] = []
+
+    @wf.task
+    async def step_a() -> str:
+        call_log.append("a")
+        return "result-a"
+
+    @wf.task
+    async def step_b(x: str) -> str:
+        call_log.append("b")
+        return f"{x}+b"
+
+    @wf.workflow(id="ckpt-test")
+    async def pipeline() -> str:
+        a = await step_a()
+        return await step_b(a)
+
+    result = await pipeline()
+    assert result == "result-a+b"
+    assert call_log == ["a", "b"]
+
+    call_log.clear()
+    result = await pipeline()
+    assert result == "result-a+b"
+    assert call_log == []
+
+
+async def test_workflow_resumes_after_failure():
+    store = _make_store()
+    wf = _make_wf(store)
+    call_count = 0
+
+    @wf.task
+    async def good_step() -> str:
+        nonlocal call_count
+        call_count += 1
+        return "ok"
+
+    fail_once = True
+
+    @wf.task
+    async def flaky_step(x: str) -> str:
+        nonlocal fail_once, call_count
+        call_count += 1
+        if fail_once:
+            fail_once = False
+            raise RuntimeError("boom")
+        return f"{x}!"
+
+    @wf.workflow(id="resume-test")
+    async def pipeline() -> str:
+        a = await good_step()
+        return await flaky_step(a)
+
+    with pytest.raises(RuntimeError, match="boom"):
+        await pipeline()
+
+    assert call_count == 2
+
+    call_count = 0
+    result = await pipeline()
+    assert result == "ok!"
+    assert call_count == 1

python_durable-0.1.1/tests/test_signals.py

@@ -0,0 +1,243 @@
+"""
+Tests for durable signals (human-in-the-loop / external input).
+
+Covers:
+  1. Basic flow: workflow waits, external completes, workflow receives payload
+  2. Replay: re-running after delivery returns cached payload instantly
+  3. Idempotent complete: second complete() returns False
+  4. Signal before wait: complete() before workflow reaches signal()
+  5. Multiple signals: workflow waits for two independent signals
+"""
+
+import asyncio
+
+from fakeredis.aioredis import FakeRedis
+
+from durable import InMemoryStore, RedisStore, Workflow
+
+
+# ---------------------------------------------------------------------------
+# InMemoryStore tests
+# ---------------------------------------------------------------------------
+
+
+def _mem_wf() -> Workflow:
+    return Workflow("test-sig", db=InMemoryStore(), default_retries=0)
+
+
+async def test_basic_signal_flow():
+    wf = _mem_wf()
+    received = []
+
+    @wf.workflow(id="basic-sig")
+    async def my_workflow() -> dict:
+        result = await wf.signal("approval")
+        received.append(result)
+        return result
+
+    async def deliver():
+        await asyncio.sleep(0.05)
+        await wf.complete("basic-sig", "approval", {"approved": True})
+
+    asyncio.create_task(deliver())
+    result = await my_workflow()
+    assert result == {"approved": True}
+    assert received == [{"approved": True}]
+
+
+async def test_signal_replay():
+    wf = _mem_wf()
+    call_count = 0
+
+    @wf.task
+    async def before_signal() -> str:
+        nonlocal call_count
+        call_count += 1
+        return "step-done"
+
+    @wf.workflow(id="replay-sig")
+    async def my_workflow() -> dict:
+        await before_signal()
+        return await wf.signal("approval")
+
+    # Deliver signal, run workflow
+    async def deliver():
+        await asyncio.sleep(0.05)
+        await wf.complete("replay-sig", "approval", {"ok": True})
+
+    asyncio.create_task(deliver())
+    result = await my_workflow()
+    assert result == {"ok": True}
+    assert call_count == 1
+
+    # Re-run: signal is already in the store, no waiting
+    call_count = 0
+    result = await my_workflow()
+    assert result == {"ok": True}
+    assert call_count == 0  # task replayed from checkpoint
+
+
+async def test_idempotent_complete():
+    wf = _mem_wf()
+
+    @wf.workflow(id="idem-sig")
+    async def my_workflow() -> dict:
+        return await wf.signal("approval")
+
+    # Complete before workflow runs
+    ok1 = await wf.complete("idem-sig", "approval", {"first": True})
+    ok2 = await wf.complete("idem-sig", "approval", {"second": True})
+    assert ok1 is True
+    assert ok2 is False
+
+    # Workflow gets the first payload
+    result = await my_workflow()
+    assert result == {"first": True}
+
+
+async def test_signal_before_wait():
+    wf = _mem_wf()
+
+    @wf.workflow(id="pre-sig")
+    async def my_workflow() -> dict:
+        return await wf.signal("approval")
+
+    # Deliver before workflow starts
+    await wf.complete("pre-sig", "approval", {"early": True})
+
+    # Workflow should pick it up immediately (no waiting)
+    result = await my_workflow()
+    assert result == {"early": True}
+
+
+async def test_multiple_signals():
+    wf = _mem_wf()
+
+    @wf.workflow(id="multi-sig")
+    async def my_workflow() -> list:
+        a = await wf.signal("step-a")
+        b = await wf.signal("step-b")
+        return [a, b]
+
+    async def deliver():
+        await asyncio.sleep(0.05)
+        await wf.complete("multi-sig", "step-a", {"val": "A"})
+        await asyncio.sleep(0.05)
+        await wf.complete("multi-sig", "step-b", {"val": "B"})
+
+    asyncio.create_task(deliver())
+    result = await my_workflow()
+    assert result == [{"val": "A"}, {"val": "B"}]
+
+
+# ---------------------------------------------------------------------------
+# RedisStore tests
+# ---------------------------------------------------------------------------
+
+
+def _redis_store(ttl: int = 86_400) -> RedisStore:
+    store = RedisStore(ttl=ttl)
+    store._redis = FakeRedis(decode_responses=True)
+    return store
+
+
+def _redis_wf(store: RedisStore) -> Workflow:
+    return Workflow("test-redis-sig", db=store, default_retries=0)
+
+
+async def test_redis_basic_signal_flow():
+    store = _redis_store()
+    wf = _redis_wf(store)
+
+    @wf.workflow(id="redis-basic-sig")
+    async def my_workflow() -> dict:
+        return await wf.signal("approval")
+
+    async def deliver():
+        await asyncio.sleep(0.05)
+        await wf.complete("redis-basic-sig", "approval", {"approved": True})
+
+    asyncio.create_task(deliver())
+    result = await my_workflow()
+    assert result == {"approved": True}
+
+
+async def test_redis_signal_replay():
+    store = _redis_store()
+    wf = _redis_wf(store)
+
+    @wf.workflow(id="redis-replay-sig")
+    async def my_workflow() -> dict:
+        return await wf.signal("approval")
+
+    async def deliver():
+        await asyncio.sleep(0.05)
+        await wf.complete("redis-replay-sig", "approval", {"ok": True})
+
+    asyncio.create_task(deliver())
+    result = await my_workflow()
+    assert result == {"ok": True}
+
+    # Re-run: replayed from store
+    result = await my_workflow()
+    assert result == {"ok": True}
+
+
+async def test_redis_idempotent_complete():
+    store = _redis_store()
+    wf = _redis_wf(store)
+
+    ok1 = await wf.complete("redis-idem", "approval", {"first": True})
+    ok2 = await wf.complete("redis-idem", "approval", {"second": True})
+    assert ok1 is True
+    assert ok2 is False
+
+    # Verify first payload persisted
+    found, payload = await store.get_signal("redis-idem", "approval")
+    assert found is True
+    assert payload == {"first": True}
+
+
+async def test_redis_signal_before_wait():
+    store = _redis_store()
+    wf = _redis_wf(store)
+
+    @wf.workflow(id="redis-pre-sig")
+    async def my_workflow() -> dict:
+        return await wf.signal("approval")
+
+    await wf.complete("redis-pre-sig", "approval", {"early": True})
+    result = await my_workflow()
+    assert result == {"early": True}
+
+
+async def test_redis_signal_ttl():
+    store = _redis_store(ttl=120)
+    wf = _redis_wf(store)
+
+    await wf.complete("ttl-test", "approval", {"data": 1})
+    keys = [k for k in await store._client().keys("*") if "sig" in k]
+    assert len(keys) == 1
+    ttl = await store._client().ttl(keys[0])
+    assert 0 < ttl <= 120
+
+
+async def test_redis_multiple_signals():
+    store = _redis_store()
+    wf = _redis_wf(store)
+
+    @wf.workflow(id="redis-multi-sig")
+    async def my_workflow() -> list:
+        a = await wf.signal("step-a")
+        b = await wf.signal("step-b")
+        return [a, b]
+
+    async def deliver():
+        await asyncio.sleep(0.05)
+        await wf.complete("redis-multi-sig", "step-a", {"val": "A"})
+        await asyncio.sleep(0.05)
+        await wf.complete("redis-multi-sig", "step-b", {"val": "B"})
+
+    asyncio.create_task(deliver())
+    result = await my_workflow()
+    assert result == [{"val": "A"}, {"val": "B"}]