durable-workflow 0.4.98__tar.gz → 0.4.99__tar.gz

{durable_workflow-0.4.98/src/durable_workflow.egg-info → durable_workflow-0.4.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 0.4.98
+Version: 0.4.99
 Summary: Python SDK for the Durable Workflow server (language-neutral HTTP protocol)
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -95,6 +95,36 @@ For a fuller deployable example, see
 [`examples/order_processing`](examples/order_processing), which runs a
 multi-activity order workflow against a local server with Docker Compose.
 
+## Schedule visibility and paging
+
+`list_schedules()` returns one typed `ScheduleList` page. Status and workflow
+type are exact server-side filters; the visibility query uses the server's
+documented equality-predicate grammar. All filters combine with AND semantics.
+
+```python
+page = await client.list_schedules(
+    status="active",
+    workflow_type="orders.rollup",
+    query='Region = "eu" AND Priority = 2',
+    page_size=25,
+)
+
+while page.next_page_token is not None:
+    page = await client.list_schedules(
+        status="active",
+        workflow_type="orders.rollup",
+        query='Region = "eu" AND Priority = 2',
+        page_size=25,
+        next_page_token=page.next_page_token,
+    )
+```
+
+Continuation tokens are opaque. Reuse them unchanged with the same namespace,
+status, workflow type, and query; `None` terminates traversal. Invalid filters
+and malformed, mismatched, cross-namespace, or stale tokens raise
+`ScheduleListError`, which retains `status`, `reason()`, `field`, `errors`,
+`last_safe_cursor`, and the complete server response in `body`.
+
 ## Retry policy scopes
 
 Retry and timeout settings are scoped to the layer where you configure them:

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/README.md

@@ -59,6 +59,36 @@ For a fuller deployable example, see
 [`examples/order_processing`](examples/order_processing), which runs a
 multi-activity order workflow against a local server with Docker Compose.
 
+## Schedule visibility and paging
+
+`list_schedules()` returns one typed `ScheduleList` page. Status and workflow
+type are exact server-side filters; the visibility query uses the server's
+documented equality-predicate grammar. All filters combine with AND semantics.
+
+```python
+page = await client.list_schedules(
+    status="active",
+    workflow_type="orders.rollup",
+    query='Region = "eu" AND Priority = 2',
+    page_size=25,
+)
+
+while page.next_page_token is not None:
+    page = await client.list_schedules(
+        status="active",
+        workflow_type="orders.rollup",
+        query='Region = "eu" AND Priority = 2',
+        page_size=25,
+        next_page_token=page.next_page_token,
+    )
+```
+
+Continuation tokens are opaque. Reuse them unchanged with the same namespace,
+status, workflow type, and query; `None` terminates traversal. Invalid filters
+and malformed, mismatched, cross-namespace, or stale tokens raise
+`ScheduleListError`, which retains `status`, `reason()`, `field`, `errors`,
+`last_safe_cursor`, and the complete server response in `body`.
+
 ## Retry policy scopes
 
 Retry and timeout settings are scoped to the layer where you configure them:

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "0.4.98"
+version = "0.4.99"
 description = "Python SDK for the Durable Workflow server (language-neutral HTTP protocol)"
 readme = "README.md"
 requires-python = ">=3.10"

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/src/durable_workflow/__init__.py

@@ -65,6 +65,7 @@ from .errors import (
     NonRetryableError,
     QueryFailed,
     ScheduleAlreadyExists,
+    ScheduleListError,
     ScheduleNotFound,
     ServerError,
     SignalFailed,
@@ -224,6 +225,7 @@ __all__ = [
     "ScheduleHistoryEvent",
     "ScheduleHistoryPage",
     "ScheduleList",
+    "ScheduleListError",
     "ScheduleNotFound",
     "ScheduleSpec",
     "ScheduleTriggerResult",

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/src/durable_workflow/client.py

@@ -2973,9 +2973,37 @@ class Client:
         sid = data.get("schedule_id", schedule_id or "")
         return ScheduleHandle(self, schedule_id=sid)
 
-    async def list_schedules(self) -> ScheduleList:
-        """Return all schedules in the current namespace."""
-        data = await self._request("GET", "/schedules")
+    async def list_schedules(
+        self,
+        *,
+        status: str | None = None,
+        workflow_type: str | None = None,
+        query: str | None = None,
+        page_size: int | None = None,
+        next_page_token: str | None = None,
+    ) -> ScheduleList:
+        """Return one server-filtered schedule visibility page.
+
+        Status, workflow type, and visibility-query filters combine with AND
+        semantics. Continuation tokens are opaque: pass a non-null token back
+        unchanged with the same namespace and filters. ``None`` terminates the
+        traversal. The server validates page sizes, predicates, and cursors.
+        """
+        params: dict[str, str] = {}
+        if status is not None:
+            params["status"] = status
+        if workflow_type is not None:
+            params["workflow_type"] = workflow_type
+        if query is not None:
+            params["query"] = query
+        if page_size is not None:
+            params["page_size"] = str(page_size)
+        if next_page_token is not None:
+            params["next_page_token"] = next_page_token
+
+        qs = urlencode(params)
+        path = f"/schedules?{qs}" if qs else "/schedules"
+        data = await self._request("GET", path, context="schedule.list")
         items = data.get("schedules", [])
         schedules = [
             ScheduleDescription(
@@ -2985,9 +3013,24 @@ class Client:
                 action=item.get("action"),
                 overlap_policy=item.get("overlap_policy"),
                 note=item.get("note"),
+                memo=item.get("memo") if isinstance(item.get("memo"), dict) else None,
+                search_attributes=(
+                    item.get("search_attributes")
+                    if isinstance(item.get("search_attributes"), dict)
+                    else None
+                ),
+                jitter_seconds=item.get("jitter_seconds"),
+                max_runs=item.get("max_runs"),
+                remaining_actions=item.get("remaining_actions"),
                 fires_count=item.get("fires_count", 0),
+                failures_count=item.get("failures_count", 0),
                 next_fire_at=item.get("next_fire_at"),
                 last_fired_at=item.get("last_fired_at"),
+                latest_workflow_instance_id=item.get("latest_workflow_instance_id"),
+                paused_at=item.get("paused_at"),
+                created_at=item.get("created_at"),
+                updated_at=item.get("updated_at"),
+                info=item.get("info") if isinstance(item.get("info"), dict) else None,
             )
             for item in items
         ]

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/src/durable_workflow/errors.py

@@ -152,6 +152,26 @@ class ScheduleAlreadyExists(DurableWorkflowError):
         self.schedule_id = schedule_id
 
 
+class ScheduleListError(ServerError):
+    """A schedule visibility filter or continuation cursor was refused.
+
+    The complete parsed response remains available on :attr:`body`. Convenience
+    attributes expose the rejected field, structured field errors, and the
+    server's last safe keyset cursor without discarding status or reason.
+    """
+
+    def __init__(self, status: int, body: object) -> None:
+        super().__init__(status, body)
+        self.field = body.get("field") if isinstance(body, dict) else None
+        errors = None
+        last_safe_cursor = None
+        if isinstance(body, dict):
+            errors = body.get("validation_errors") or body.get("errors")
+            last_safe_cursor = body.get("last_safe_cursor")
+        self.errors = errors if isinstance(errors, dict) else None
+        self.last_safe_cursor = last_safe_cursor if isinstance(last_safe_cursor, dict) else None
+
+
 class QueryFailed(DurableWorkflowError):
     """A workflow query was rejected or the workflow raised while handling it."""
 
@@ -447,6 +467,9 @@ def _raise_for_status(status: int, body: object, *, context: str = "") -> None:
     if status == 401:
         raise Unauthorized(message or "unauthorized")
 
+    if context == "schedule.list" and status in (400, 403, 409, 422):
+        raise ScheduleListError(status, body)
+
     def query_failed(default: str) -> QueryFailed:
         return QueryFailed(
             message or default,

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/src/durable_workflow/replay_verify.py

@@ -954,7 +954,12 @@ def _cli(argv: Sequence[str] | None = None) -> int:
         parser.error("--workflows is required unless --simulate-bundles is set")
 
     workflows = _resolve_workflow_loader(args.workflows)
-    report = verify_golden_history(args.fixture_dir, workflows)
+    required_families = REQUIRED_FAMILIES if args.strict_missing_families else ()
+    report = verify_golden_history(
+        args.fixture_dir,
+        workflows,
+        required_families=required_families,
+    )
 
     payload = report.to_dict()
     text = json.dumps(payload, indent=2, sort_keys=True)

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/src/durable_workflow/sync.py

@@ -629,8 +629,24 @@ class Client:
         )
         return SyncScheduleHandle(handle)
 
-    def list_schedules(self) -> ScheduleList:
-        result: ScheduleList = _run(self._async.list_schedules())
+    def list_schedules(
+        self,
+        *,
+        status: str | None = None,
+        workflow_type: str | None = None,
+        query: str | None = None,
+        page_size: int | None = None,
+        next_page_token: str | None = None,
+    ) -> ScheduleList:
+        result: ScheduleList = _run(
+            self._async.list_schedules(
+                status=status,
+                workflow_type=workflow_type,
+                query=query,
+                page_size=page_size,
+                next_page_token=next_page_token,
+            )
+        )
         return result
 
     def describe_schedule(self, schedule_id: str) -> ScheduleDescription:

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/src/durable_workflow/worker.py

@@ -1823,8 +1823,11 @@ class Worker:
             self._act_semaphore.release()
 
     async def _poll_query_tasks(self, *, client: Client | None = None, track_tasks: bool = True) -> None:
+        query_thread_stop = self._query_thread_stop if client is not None else None
         client = client or self.client
-        while not self._stop.is_set() and not self._query_thread_stop.is_set():
+        while not self._stop.is_set() and (
+            query_thread_stop is None or not query_thread_stop.is_set()
+        ):
             try:
                 poll_start = time.perf_counter()
                 task = await client.poll_query_task(

{durable_workflow-0.4.98 → durable_workflow-0.4.99/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 0.4.98
+Version: 0.4.99
 Summary: Python SDK for the Durable Workflow server (language-neutral HTTP protocol)
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -95,6 +95,36 @@ For a fuller deployable example, see
 [`examples/order_processing`](examples/order_processing), which runs a
 multi-activity order workflow against a local server with Docker Compose.
 
+## Schedule visibility and paging
+
+`list_schedules()` returns one typed `ScheduleList` page. Status and workflow
+type are exact server-side filters; the visibility query uses the server's
+documented equality-predicate grammar. All filters combine with AND semantics.
+
+```python
+page = await client.list_schedules(
+    status="active",
+    workflow_type="orders.rollup",
+    query='Region = "eu" AND Priority = 2',
+    page_size=25,
+)
+
+while page.next_page_token is not None:
+    page = await client.list_schedules(
+        status="active",
+        workflow_type="orders.rollup",
+        query='Region = "eu" AND Priority = 2',
+        page_size=25,
+        next_page_token=page.next_page_token,
+    )
+```
+
+Continuation tokens are opaque. Reuse them unchanged with the same namespace,
+status, workflow type, and query; `None` terminates traversal. Invalid filters
+and malformed, mismatched, cross-namespace, or stale tokens raise
+`ScheduleListError`, which retains `status`, `reason()`, `field`, `errors`,
+`last_safe_cursor`, and the complete server response in `body`.
+
 ## Retry policy scopes
 
 Retry and timeout settings are scoped to the layer where you configure them:

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/tests/test_replay_verify.py

@@ -17,6 +17,7 @@ from durable_workflow.replay_verify import (
     REASON_BUNDLE_INVALID,
     REASON_EXPECTATION_MISMATCH,
     REASON_NONE,
+    REASON_SHAPE_MISMATCH,
     REPORT_SCHEMA,
     REPORT_SCHEMA_VERSION,
     SIMULATION_REPORT_SCHEMA,

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/tests/test_schedules.py

@@ -23,6 +23,7 @@ from durable_workflow.client import (
 from durable_workflow.errors import (
     InvalidArgument,
     ScheduleAlreadyExists,
+    ScheduleListError,
     ScheduleNotFound,
 )
 
@@ -240,6 +241,93 @@ class TestListSchedules:
             result = await client.list_schedules()
             assert result.schedules == []
 
+    @pytest.mark.asyncio
+    async def test_filters_and_continuation_token_are_forwarded_and_mapped(self, client: Client) -> None:
+        resp = _mock_response(200, {
+            "schedules": [{
+                "schedule_id": "reports-eu",
+                "status": "paused",
+                "search_attributes": {"Region": "eu west"},
+                "created_at": "2026-07-14T12:00:00Z",
+                "updated_at": "2026-07-14T12:01:00Z",
+            }],
+            "next_page_token": "opaque+/= token",
+        })
+        with patch.object(client._http, "request", new_callable=AsyncMock, return_value=resp) as mock:
+            result = await client.list_schedules(
+                status="paused",
+                workflow_type="reports.rollup",
+                query='Region = "eu west"',
+                page_size=1,
+                next_page_token="page+/= one",
+            )
+
+        assert mock.call_args.args[:2] == (
+            "GET",
+            "/api/schedules?status=paused&workflow_type=reports.rollup"
+            "&query=Region+%3D+%22eu+west%22&page_size=1"
+            "&next_page_token=page%2B%2F%3D+one",
+        )
+        assert result.next_page_token == "opaque+/= token"
+        assert result.schedules[0].search_attributes == {"Region": "eu west"}
+        assert result.schedules[0].created_at == "2026-07-14T12:00:00Z"
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        ("status", "body", "expected_cursor"),
+        [
+            (422, {
+                "message": "Unsupported predicate.",
+                "reason": "unsupported_schedule_visibility_predicate",
+                "field": "query",
+                "errors": {"query": ["Only equality predicates are supported."]},
+                "last_safe_cursor": None,
+            }, None),
+            (400, {
+                "message": "Malformed token.",
+                "reason": "malformed_schedule_page_token",
+                "field": "next_page_token",
+                "errors": {"next_page_token": ["Malformed token."]},
+                "last_safe_cursor": None,
+            }, None),
+            (403, {
+                "message": "Wrong namespace.",
+                "reason": "schedule_page_token_namespace_mismatch",
+                "field": "next_page_token",
+                "errors": {"next_page_token": ["Wrong namespace."]},
+                "last_safe_cursor": {"created_at": "2026-07-14T12:00:00Z", "schedule_id": "s1"},
+            }, {"created_at": "2026-07-14T12:00:00Z", "schedule_id": "s1"}),
+            (409, {
+                "message": "Stale token.",
+                "reason": "stale_schedule_page_token",
+                "field": "next_page_token",
+                "errors": {"next_page_token": ["Stale token."]},
+                "last_safe_cursor": {"created_at": "2026-07-14T12:00:00Z", "schedule_id": "s1"},
+            }, {"created_at": "2026-07-14T12:00:00Z", "schedule_id": "s1"}),
+        ],
+    )
+    async def test_typed_filter_and_cursor_errors_preserve_server_evidence(
+        self,
+        client: Client,
+        status: int,
+        body: dict,
+        expected_cursor: dict | None,
+    ) -> None:
+        resp = _mock_response(status, body)
+        with (
+            patch.object(client._http, "request", new_callable=AsyncMock, return_value=resp),
+            pytest.raises(ScheduleListError) as exc_info,
+        ):
+            await client.list_schedules(query='Region STARTS_WITH "e"')
+
+        error = exc_info.value
+        assert error.status == status
+        assert error.reason() == body["reason"]
+        assert error.field == body["field"]
+        assert error.errors == body["errors"]
+        assert error.last_safe_cursor == expected_cursor
+        assert error.body == body
+
 
 class TestDescribeSchedule:
     @pytest.mark.asyncio

{durable_workflow-0.4.98 → durable_workflow-0.4.99}/tests/test_sync.py

@@ -727,6 +727,28 @@ class TestSyncClientContextManager:
             assert client is not None
 
 
+class TestSyncScheduleList:
+    def test_schedule_filters_and_cursor_are_forwarded(self) -> None:
+        client = Client("http://localhost:8080")
+        resp = _mock_response(200, {"schedules": [], "next_page_token": "next"})
+
+        with patch.object(client._async._http, "request", new_callable=AsyncMock, return_value=resp) as mock:
+            page = client.list_schedules(
+                status="active",
+                workflow_type="orders.process",
+                query='Region = "eu"',
+                page_size=25,
+                next_page_token="cursor",
+            )
+
+        assert page.next_page_token == "next"
+        assert mock.call_args.args[:2] == (
+            "GET",
+            "/api/schedules?status=active&workflow_type=orders.process"
+            "&query=Region+%3D+%22eu%22&page_size=25&next_page_token=cursor",
+        )
+
+
 class TestSyncRunInsideLoop:
     @pytest.mark.asyncio
     async def test_raises_inside_loop(self) -> None: