durable-workflow 2.5.13__tar.gz → 2.5.15__tar.gz

{durable_workflow-2.5.13/src/durable_workflow.egg-info → durable_workflow-2.5.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.13
+Version: 2.5.15
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.5.13 → durable_workflow-2.5.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.5.13"
+version = "2.5.15"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,9 +71,9 @@ durable-workflow-replay-conformance = "durable_workflow.replay_conformance:main"
 durable-workflow-workflow-updates-conformance = "durable_workflow.workflow_updates_conformance:main"
 
 [tool.durable-workflow]
-product-train = "2.5.13"
-registry-version = "2.5.13"
-supported-server-versions = "2.5.16"
+product-train = "2.5.15"
+registry-version = "2.5.15"
+supported-server-versions = "2.8.0"
 worker-protocol-version = "1.20"
 control-plane-version = "2"
 durable-selection = true

{durable_workflow-2.5.13 → durable_workflow-2.5.15}/src/durable_workflow/__init__.py

@@ -88,6 +88,7 @@ from .errors import (
     NonDeterministicReplayError,
     NonRetryableError,
     QueryFailed,
+    QueryTaskAuthorityLost,
     RuntimeCapabilityUnsupported,
     RuntimeDiscoveryUnavailable,
     SagaCompensationFailed,
@@ -375,6 +376,7 @@ __all__ = [
     "InvalidWorkflowDefinition",
     "NoopMetrics",
     "QueryFailed",
+    "QueryTaskAuthorityLost",
     "RuntimeCapabilityUnsupported",
     "RuntimeDiscoveryUnavailable",
     "RuntimeExternalPayloadReference",

durable_workflow-2.5.15/src/durable_workflow/_query_task_authority.py

@@ -0,0 +1,153 @@
+"""A query delivery's original, non-renewing execution budget."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+import time
+from collections.abc import Awaitable, Callable, Mapping
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, TypeVar
+
+from .errors import QueryTaskAuthorityLost
+
+_T = TypeVar("_T")
+_UTC6 = re.compile(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z\Z")
+_OBSERVATION_INTERVAL_SECONDS = 5.0
+
+
+def _timestamp(value: Any, *, canonical: bool) -> datetime:
+    if not isinstance(value, str) or (canonical and _UTC6.fullmatch(value) is None):
+        raise ValueError("missing or malformed query timing")
+    parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    if parsed.tzinfo is None:
+        raise ValueError("query timing must include a timezone")
+    return parsed
+
+
+@dataclass
+class QueryTaskAuthority:
+    client: object
+    namespace: str
+    task_id: str
+    attempt: int
+    owner: str
+    observed: bool
+    timing: dict[str, str]
+    until: float
+    identity: dict[str, Any]
+    observer: Callable[[], Awaitable[Mapping[str, Any]]] | None = field(default=None, repr=False)
+
+    @classmethod
+    def delivery(cls, client: object, namespace: str, task: Mapping[str, Any], *,
+                 owner: str, task_queue: str, observed: bool) -> QueryTaskAuthority:
+        task_id, attempt = task.get("query_task_id"), task.get("query_task_attempt")
+        if (not isinstance(owner, str) or not owner or not isinstance(task_queue, str) or not task_queue
+                or not isinstance(task_id, str) or not task_id or type(attempt) is not int or attempt < 1
+                or task.get("lease_owner") != owner or task.get("task_queue") != task_queue
+                or task.get("namespace", namespace) != namespace):
+            raise QueryTaskAuthorityLost(str(task_id or ""), "invalid_query_claim")
+        try:
+            lease = _timestamp(task.get("lease_expires_at"), canonical=observed)
+            timing = {"lease_expires_at": task["lease_expires_at"]}
+            bounds = [lease]
+            if observed or "query_admitted_at" in task or "query_deadline_at" in task:
+                admitted = _timestamp(task.get("query_admitted_at"), canonical=True)
+                deadline = _timestamp(task.get("query_deadline_at"), canonical=True)
+                if deadline < admitted or (observed and lease > deadline):
+                    raise ValueError("inconsistent original query timing")
+                timing.update({"query_admitted_at": task["query_admitted_at"],
+                               "query_deadline_at": task["query_deadline_at"]})
+                bounds.append(deadline)
+            # Legacy compatibility has no non-renewing observation. Its local
+            # clock check cannot establish an undisclosed caller deadline.
+            reference = (_timestamp(task.get("server_time"), canonical=True) if observed
+                         else datetime.now(timezone.utc))
+            until = time.monotonic() + (min(bounds) - reference).total_seconds()
+        except (ValueError, TypeError, OverflowError) as error:
+            raise QueryTaskAuthorityLost(task_id, "invalid_query_timing") from error
+        result = cls(client, namespace, task_id, attempt, owner, observed, timing, until,
+                     {key: task.get(key) for key in ("workflow_id", "run_id", "task_queue")})
+        result.remaining()
+        return result
+
+    def matches(self, client: object, namespace: str, task: Mapping[str, Any], owner: str) -> bool:
+        return (self.client is client and self.namespace == namespace and self.owner == owner
+                and task.get("query_task_id") == self.task_id
+                and type(task.get("query_task_attempt")) is int and task.get("query_task_attempt") == self.attempt
+                and task.get("lease_owner") == owner
+                and all(task.get(key) == value for key, value in self.identity.items())
+                and all(task.get(key) == value for key, value in self.timing.items()))
+
+    def remaining(self) -> float:
+        remaining = self.until - time.monotonic()
+        if remaining <= 0:
+            raise QueryTaskAuthorityLost(self.task_id, "query_execution_budget_expired")
+        return remaining
+
+    async def confirm(self) -> None:
+        remaining = self.remaining()
+        if not self.observed:
+            return
+        started = time.monotonic()
+        try:
+            if self.observer is None:
+                raise ValueError("query authority observer is unavailable")
+            reply = await asyncio.wait_for(self.observer(), timeout=min(5.0, remaining))
+            if (not isinstance(reply, Mapping) or reply.get("query_task_id") != self.task_id
+                    or type(reply.get("query_task_attempt")) is not int
+                    or reply.get("query_task_attempt") != self.attempt or reply.get("lease_owner") != self.owner
+                    or any(reply.get(key) != value for key, value in self.timing.items())):
+                raise ValueError("query authority observation changed its original claim")
+            if (reply.get("can_continue") is not True or reply.get("query_task_status") != "leased"
+                    or reply.get("reason") is not None):
+                raise QueryTaskAuthorityLost(self.task_id, str(reply.get("reason") or "query_claim_unavailable"))
+            server_time = _timestamp(reply.get("server_time"), canonical=True)
+            bound = min(_timestamp(value, canonical=True) for key, value in self.timing.items()
+                        if key != "query_admitted_at")
+            # Charging the entire observation round trip is conservative. A
+            # later observation may shorten this bound but can never reset it.
+            self.until = min(self.until, started + (bound - server_time).total_seconds())
+        except QueryTaskAuthorityLost:
+            raise
+        except Exception as error:
+            raise QueryTaskAuthorityLost(self.task_id, "query_authority_unavailable") from error
+        self.remaining()
+
+    async def run(self, operation: Callable[[], Awaitable[_T]], *, observe: bool = True,
+                  confirm_after: bool = True) -> _T:
+        await self.confirm()
+        execution = asyncio.ensure_future(operation())
+
+        async def watch() -> None:
+            while True:
+                await asyncio.sleep(min(_OBSERVATION_INTERVAL_SECONDS, self.remaining()))
+                await self.confirm()
+
+        observation = asyncio.create_task(watch()) if observe and self.observed else None
+        pending: set[asyncio.Future[Any]] = {execution}
+        if observation is not None:
+            pending.add(observation)
+        try:
+            done, _ = await asyncio.wait(pending, timeout=self.remaining(), return_when=asyncio.FIRST_COMPLETED)
+            if not done:
+                raise QueryTaskAuthorityLost(self.task_id, "query_execution_budget_expired")
+            if observation is not None and observation in done:
+                await observation
+                raise QueryTaskAuthorityLost(self.task_id, "query_authority_unavailable")
+            result = await execution
+            if confirm_after:
+                await self.confirm()
+            return result
+        finally:
+            for future in pending:
+                future.cancel()
+            await asyncio.gather(*pending, return_exceptions=True)
+
+
+# Async task creation copies this context. Each dispatched query keeps the
+# loading budget without adding private fields to the public wire dictionary
+# or retaining an unbounded task-ID registry on Client/Worker.
+current_query_authority: ContextVar[QueryTaskAuthority | None] = ContextVar("query_task_authority", default=None)

{durable_workflow-2.5.13 → durable_workflow-2.5.15}/src/durable_workflow/client.py

@@ -45,6 +45,7 @@ from ._cancellation_scope_history import (
     scope_timestamp,
 )
 from ._cooperative_cancellation import CancellationDelivery, CancellationRequest
+from ._query_task_authority import QueryTaskAuthority, current_query_authority
 from .errors import (
     ExternalPayloadIntegrityMismatch,
     ExternalPayloadOversized,
@@ -1809,6 +1810,9 @@ class Client:
         if discovery and path != "/cluster/info":
             raise ValueError("cluster discovery credentials can only authorize /cluster/info")
 
+        query_poll = worker and path == "/worker/query-tasks/poll"
+        if query_poll:
+            current_query_authority.set(None)
         request_json = json
         if (
             not discovery
@@ -1872,21 +1876,29 @@ class Client:
                 outcome = "ok"
                 return None
             result = resp.json()
+            query_authority = None
+            if query_poll and isinstance(result, dict) and isinstance(result.get("task"), dict):
+                query_authority = await self._query_delivery_authority(result["task"], request_json)
+                current_query_authority.set(query_authority)
             if not discovery and _contains_runtime_payload_envelope(result):
-                transport = await self._runtime_external_payload_transport()
+                transport = (await query_authority.run(self._runtime_external_payload_transport)
+                             if query_authority is not None else await self._runtime_external_payload_transport())
                 if transport is None:
                     raise ExternalPayloadUnsupported(
                         "runtime returned an external payload reference without advertising "
                         "the authenticated namespace transport"
                     )
-                result = await self._resolve_workflow_claim_payloads(
-                    result,
-                    worker=worker,
-                    transport=transport,
-                    path=path,
-                    request_json=request_json,
-                )
+                if query_authority is not None:
+                    result = await query_authority.run(lambda: self._resolve_runtime_payloads(
+                        result, worker=worker, transport=transport, resolved={},
+                    ))
+                else:
+                    result = await self._resolve_workflow_claim_payloads(
+                        result, worker=worker, transport=transport, path=path, request_json=request_json,
+                    )
             result = self._hydrate_result_envelopes(result)
+            if query_authority is not None:
+                await query_authority.confirm()
             outcome = "ok"
             return result
         except Exception as exc:
@@ -2332,6 +2344,7 @@ class Client:
         *,
         worker: bool,
         transport: _RuntimeExternalPayloadTransport,
+        resolved: dict[tuple[str, str, int, str], str] | None = None,
     ) -> Any:
         if isinstance(value, dict):
             if "external_payload" in value:
@@ -2347,6 +2360,9 @@ class Client:
                         "runtime external payload envelope codec does not match its reference",
                         reference_id=reference.reference_id,
                     )
+                identity = (reference.reference_id, reference.codec, reference.size_bytes, reference.sha256)
+                if resolved is not None and identity in resolved:
+                    return {"codec": reference.codec, "blob": resolved[identity]}
                 data = await self._fetch_runtime_payload(
                     reference,
                     worker=worker,
@@ -2359,12 +2375,15 @@ class Client:
                         "runtime external payload bytes are not a UTF-8 payload blob",
                         reference_id=reference.reference_id,
                     ) from exc
+                if resolved is not None:
+                    resolved[identity] = blob
                 return {"codec": reference.codec, "blob": blob}
             return {
                 key: await self._resolve_runtime_payloads(
                     item,
                     worker=worker,
                     transport=transport,
+                    resolved=resolved,
                 )
                 for key, item in value.items()
             }
@@ -2374,6 +2393,7 @@ class Client:
                     item,
                     worker=worker,
                     transport=transport,
+                    resolved=resolved,
                 )
                 for item in value
             ]
@@ -4825,8 +4845,10 @@ class Client:
         end_time: str,
         overlap_policy: str | None = None,
     ) -> ScheduleBackfillResult:
-        """Fire a schedule for every would-have-been moment in ``[start_time, end_time]``.
+        """Fire a schedule for every would-have-been moment in ``[start_time, end_time)``.
 
+        The start is inclusive and the end is exclusive. An occurrence equal
+        to ``end_time`` is excluded and belongs to the next adjacent window.
         Times are ISO-8601 strings. Useful to replay a period the schedule
         was paused or to seed historical runs. The returned
         :class:`ScheduleBackfillResult` reports how many fires were attempted
@@ -5625,6 +5647,48 @@ class Client:
             "POST", f"/worker/workflow-tasks/{task_id}/history", worker=True, json=body
         )
 
+    async def _query_delivery_authority(self, task: dict[str, Any], request: Any) -> QueryTaskAuthority:
+        # Worker registration establishes discovery before it polls. Advanced
+        # callers without discovery retain only the exposed local lease checks.
+        info = self._cluster_info or {}
+        protocol = info.get("worker_protocol")
+        capabilities = protocol.get("server_capabilities") if isinstance(protocol, dict) else None
+        observed = (isinstance(capabilities, dict) and capabilities.get("query_task_authority") is True
+                    and _supports_cooperative_cancellation_protocol(_protocol_version_from_env(
+                        "DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", PROTOCOL_VERSION)))
+        request = request if isinstance(request, dict) else {}
+        authority = QueryTaskAuthority.delivery(self, self.namespace, task, owner=request.get("worker_id", ""),
+                                               task_queue=request.get("task_queue", ""), observed=observed)
+        if observed:
+            authority.observer = lambda: self.query_task_status(query_task_id=authority.task_id,
+                lease_owner=authority.owner, query_task_attempt=authority.attempt)
+        await authority.confirm()
+        return authority
+
+    async def query_task_status(self, *, query_task_id: str, lease_owner: str,
+                                query_task_attempt: int) -> Any:
+        """Observe a protocol 1.20 query claim without renewing it.
+
+        Requires ``query_task_authority=true`` discovery. A positive observation
+        does not reserve authority for later execution or completion.
+        """
+        if not _supports_cooperative_cancellation_protocol(_protocol_version_from_env(
+            "DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", PROTOCOL_VERSION,
+        )):
+            raise ValueError("query task observation requires worker protocol 1.20")
+        capability_path = "worker_protocol.server_capabilities.query_task_authority"
+        info = await self._runtime_discovery(operation="Client.query_task_status", required_path=capability_path)
+        protocol = info.get("worker_protocol")
+        capabilities = protocol.get("server_capabilities") if isinstance(protocol, dict) else None
+        supported = capabilities.get("query_task_authority") if isinstance(capabilities, dict) else None
+        if supported is not True:
+            error_type = RuntimeCapabilityUnsupported if supported is False else RuntimeDiscoveryUnavailable
+            raise error_type("Client.query_task_status", capability_path,
+                             "Query task observation requires Server query_task_authority=true discovery.")
+        query = urlencode({"lease_owner": lease_owner, "query_task_attempt": query_task_attempt})
+        return await self._request("GET", f"/worker/query-tasks/{quote(query_task_id, safe='')}/status?{query}",
+                                   worker=True, timeout=5.0)
+
     async def poll_query_task(
         self,
         *,
@@ -5640,6 +5704,10 @@ class Client:
         must route a control-plane query to a non-PHP workflow runtime.
         ``timeout`` controls the server long-poll window; the HTTP request
         uses a small grace margin.
+
+        Worker registration establishes capability discovery. Custom workers
+        should call ``get_cluster_info()`` first to enable advertised query
+        status checks; without discovery only supplied local lease bounds apply.
         """
         body: dict[str, Any] = {
             "worker_id": worker_id,

{durable_workflow-2.5.13 → durable_workflow-2.5.15}/src/durable_workflow/errors.py

@@ -27,6 +27,15 @@ class DurableWorkflowError(Exception):
     """Base class for every exception raised by the SDK."""
 
 
+class QueryTaskAuthorityLost(DurableWorkflowError):
+    """A query delivery cannot safely load or invoke its handler."""
+
+    def __init__(self, query_task_id: str, reason: str) -> None:
+        super().__init__(f"query task {query_task_id!r} cannot continue: {reason}")
+        self.query_task_id = query_task_id
+        self.reason = reason
+
+
 class InvalidWorkflowDefinition(DurableWorkflowError, ValueError):
     """Workflow authoring uses an unsupported entry point or result."""
 

{durable_workflow-2.5.13 → durable_workflow-2.5.15}/src/durable_workflow/worker.py

@@ -41,6 +41,7 @@ from ._activity_process import CallbackFailure, CallbackInvocation, CallbackProc
 from ._cancellation_scope_history import CancellationScopeBudget, CancellationScopeDeliveryReceipt
 from ._cooperative_cancellation import CancellationRequest, read_cancellation_history
 from ._prepared_local_activity import PreparedAttempt, PreparedCancellationObserved, PreparedLocalRunner
+from ._query_task_authority import QueryTaskAuthority, current_query_authority
 from ._sticky_workflow_cache import CacheKey, StickyWorkflowCache, complete_history
 from .activity import ActivityContext, ActivityInfo, _set_context
 from .auth_composition import (
@@ -74,6 +75,7 @@ from .errors import (
     NonDeterministicReplayError,
     NonRetryableError,
     QueryFailed,
+    QueryTaskAuthorityLost,
     ServerError,
     UpdateRejected,
     UpdateValidationFailed,
@@ -107,11 +109,11 @@ from .workflow import (
     ScheduleActivity,
     StartChildWorkflow,
     UpsertMemo,
+    _prepare_query_state,
     _validate_workflow_entrypoint,
     _workflow_handler_registries,
     apply_update,
     commands_to_server_commands,
-    query_state,
     replay,
     validate_update,
 )
@@ -1035,8 +1037,11 @@ class Worker:
         external_storage: ExternalStorageDriver | None = None,
         external_storage_threshold_bytes: int | None = None,
         external_storage_cache: ExternalPayloadCache | None = None,
+        require_query_task_authority: bool = False,
     ) -> None:
         self.client = client
+        self.require_query_task_authority = require_query_task_authority
+        self._query_authority_supported = False
         self.task_queue = task_queue
         self.workflows: dict[str, type] = {}
         for definition in workflows:
@@ -1300,6 +1305,14 @@ class Worker:
             )
         self._validate_cooperative_activity_handlers()
         self._query_tasks_supported = _server_supports_query_tasks(info)
+        self._query_authority_supported = (
+            isinstance(server_capabilities, Mapping) and server_capabilities.get("query_task_authority") is True
+            and _supports_cooperative_cancellation_protocol(_protocol_version_from_env(
+                "DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", PROTOCOL_VERSION))
+        )
+        if self.require_query_task_authority and not self._query_authority_supported:
+            raise RuntimeError("query_task_authority_unavailable: require worker protocol 1.20 and "
+                               "Server query_task_authority=true before registration")
         self._workflow_memo_updates_supported = _server_supports_workflow_memo_updates(info)
         has_update_validators = any(
             contract["update_validators"] for contract in self.workflow_command_contracts.values()
@@ -3298,6 +3311,30 @@ class Worker:
         return await handler(context)
 
     async def _run_query_task(self, task: dict[str, Any], *, client: Client | None = None) -> str:
+        client = client or self.client
+        token = None
+        try:
+            namespace = getattr(client, "namespace", "default")
+            authority = current_query_authority.get()
+            if authority is None:
+                authority = QueryTaskAuthority.delivery(client, namespace, task, owner=self.worker_id,
+                    task_queue=self.task_queue, observed=self._query_authority_supported)
+                if authority.observed:
+                    authority.observer = lambda: client.query_task_status(query_task_id=authority.task_id,
+                        lease_owner=authority.owner, query_task_attempt=authority.attempt)
+                token = current_query_authority.set(authority)
+            if not authority.matches(client, namespace, task, self.worker_id):
+                raise QueryTaskAuthorityLost(str(task.get("query_task_id", "")), "invalid_query_claim")
+            await authority.confirm()
+            return await self._run_authorized_query_task(task, client=client)
+        except QueryTaskAuthorityLost as error:
+            log.info("query delivery suppressed: %s", error)
+            return "expired"
+        finally:
+            if token is not None:
+                current_query_authority.reset(token)
+
+    async def _run_authorized_query_task(self, task: dict[str, Any], *, client: Client) -> str:
         client = client or self.client
         codec = task.get("payload_codec")
         try:
@@ -3341,6 +3378,11 @@ class Worker:
 
     async def _run_query_task_core(self, task: dict[str, Any], *, client: Client | None = None) -> str:
         client = client or self.client
+        authority = current_query_authority.get()
+        if authority is None or not authority.matches(client, getattr(client, "namespace", "default"),
+                                                     task, self.worker_id):
+            raise QueryTaskAuthorityLost(str(task.get("query_task_id", "")), "invalid_query_claim")
+        await authority.confirm()
         query_task_id: str = task["query_task_id"]
         attempt: int = task.get("query_task_attempt", 1)
         wf_type: str = task.get("workflow_type", "")
@@ -3390,7 +3432,7 @@ class Worker:
                 codec=codec,
                 context="workflow query arguments",
             )
-            result = query_state(
+            invoke = _prepare_query_state(
                 cls,
                 history,
                 start_input,
@@ -3405,8 +3447,14 @@ class Worker:
                 prepare_local_activity_groups=self._prepared_local_activity_groups_supported,
                 local_activity_cancellation_policies=self._local_activity_cancellation_policies,
             )
-            if inspect.isawaitable(result):
-                result = await result
+            await authority.confirm()
+            async def execute() -> Any:
+                value = invoke()
+                return await value if inspect.isawaitable(value) else value
+
+            result = await authority.run(execute)
+        except QueryTaskAuthorityLost:
+            raise
         except AvroNotInstalledError as e:
             await self._fail_query_task(
                 query_task_id,
@@ -3452,7 +3500,7 @@ class Worker:
             return "failed"
 
         try:
-            await client.complete_query_task(
+            await authority.run(lambda: client.complete_query_task(
                 query_task_id=query_task_id,
                 lease_owner=self.worker_id,
                 query_task_attempt=attempt,
@@ -3462,7 +3510,9 @@ class Worker:
                 run_id=task.get("run_id"),
                 query_name=query_name,
                 **self._external_storage_completion_kwargs(),
-            )
+            ), observe=False, confirm_after=False)
+        except QueryTaskAuthorityLost:
+            raise
         except ServerError as e:
             if _is_storage_admission_error(e):
                 log.warning("query task %s acknowledgement paused: %s", query_task_id, e)
@@ -3552,6 +3602,12 @@ class Worker:
         client: Client | None = None,
     ) -> None:
         client = client or self.client
+        authority = current_query_authority.get()
+        if authority is not None:
+            if (authority.client is not client or authority.task_id != query_task_id or authority.attempt != attempt
+                    or authority.owner != self.worker_id):
+                raise QueryTaskAuthorityLost(query_task_id, "invalid_query_claim")
+            await authority.confirm()
         try:
             await client.fail_query_task(
                 query_task_id=query_task_id,
@@ -4013,7 +4069,7 @@ class Worker:
     def _clone_client_for_query_tasks(self) -> Client:
         warning_config = self._payload_size_warning_config()
 
-        return Client(
+        client = Client(
             self.client.base_url,
             token=self.client.token,
             control_token=self.client.control_token,
@@ -4035,6 +4091,8 @@ class Worker:
             external_storage_threshold_bytes=self.external_storage_threshold_bytes,
             external_storage_cache=self.external_storage_cache,
         )
+        client._cluster_info = self.client._cluster_info
+        return client
 
     def _can_clone_client_for_query_tasks(self) -> bool:
         return type(self.client) is Client

{durable_workflow-2.5.13 → durable_workflow-2.5.15}/src/durable_workflow/workflow.py

@@ -2991,7 +2991,7 @@ def replay(
     ).outcome
 
 
-def query_state(
+def _prepare_query_state(
     workflow_cls: type,
     history_events: Iterable[dict[str, Any]],
     start_input: list[Any],
@@ -3006,17 +3006,8 @@ def query_state(
     prepare_local_activities: bool = False,
     prepare_local_activity_groups: bool = False,
     local_activity_cancellation_policies: tuple[str, ...] = (),
-) -> Any:
-    """Replay a workflow to current state and invoke a registered query.
-
-    This is the replay and invocation core used by the current server-routed
-    worker query path after it fetches durable history. That path is negotiated
-    through ``worker_protocol.server_capabilities.query_tasks``: workers
-    advertise ``query_tasks`` only after discovery reports it as available,
-    and clients fail with typed capability or discovery errors when it is not.
-    Unknown query names and handler exceptions are normalized to
-    :class:`~durable_workflow.errors.QueryFailed`.
-    """
+) -> Callable[[], Any]:
+    """Prepare the query so a worker can recheck authority after replay."""
     try:
         state = _replay_state(
             workflow_cls,
@@ -3047,12 +3038,46 @@ def query_state(
     if handler is None:
         raise QueryFailed(f"query handler {query_name!r} is not available")
 
-    try:
-        return handler(*(list(args) if args is not None else []))
-    except QueryFailed:
-        raise
-    except Exception as exc:
-        raise QueryFailed(str(exc) or f"query {query_name!r} failed") from exc
+    def invoke() -> Any:
+        try:
+            return handler(*(list(args) if args is not None else []))
+        except QueryFailed:
+            raise
+        except Exception as exc:
+            raise QueryFailed(str(exc) or f"query {query_name!r} failed") from exc
+
+    return invoke
+
+
+def query_state(
+    workflow_cls: type,
+    history_events: Iterable[dict[str, Any]],
+    start_input: list[Any],
+    query_name: str,
+    args: list[Any] | None = None,
+    *,
+    workflow_id: str | None = None,
+    run_id: str = "",
+    payload_codec: str | None = None,
+    external_storage: ExternalStorageDriver | None = None,
+    external_storage_cache: ExternalPayloadCache | None = None,
+    prepare_local_activities: bool = False,
+    prepare_local_activity_groups: bool = False,
+    local_activity_cancellation_policies: tuple[str, ...] = (),
+) -> Any:
+    """Replay workflow state and invoke a query, normalizing handler failures.
+
+    Server-routed Worker execution separately checks its original query claim
+    between replay and handler invocation. Direct local use has no Server lease.
+    """
+    return _prepare_query_state(
+        workflow_cls, history_events, start_input, query_name, args,
+        workflow_id=workflow_id, run_id=run_id, payload_codec=payload_codec,
+        external_storage=external_storage, external_storage_cache=external_storage_cache,
+        prepare_local_activities=prepare_local_activities,
+        prepare_local_activity_groups=prepare_local_activity_groups,
+        local_activity_cancellation_policies=local_activity_cancellation_policies,
+    )()
 
 
 def apply_update(

{durable_workflow-2.5.13 → durable_workflow-2.5.15/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.13
+Version: 2.5.15
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.5.13 → durable_workflow-2.5.15}/src/durable_workflow.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/durable_workflow/_cancellation_scope.py
 src/durable_workflow/_cancellation_scope_history.py
 src/durable_workflow/_cooperative_cancellation.py
 src/durable_workflow/_prepared_local_activity.py
+src/durable_workflow/_query_task_authority.py
 src/durable_workflow/_sticky_workflow_cache.py
 src/durable_workflow/activity.py
 src/durable_workflow/auth_composition.py
@@ -95,6 +96,7 @@ tests/test_public_boundary_scanner.py
 tests/test_pypi_project_surface.py
 tests/test_python_conformance.py
 tests/test_queries.py
+tests/test_query_task_authority.py
 tests/test_query_timeout_retry.py
 tests/test_readme_quickstart.py
 tests/test_redrive_replay.py