durable-workflow 2.4.3__tar.gz → 2.5.1__tar.gz

{durable_workflow-2.4.3/src/durable_workflow.egg-info → durable_workflow-2.5.1}/PKG-INFO

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

{durable_workflow-2.4.3 → durable_workflow-2.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.4.3"
+version = "2.5.1"
 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.4.3"
-registry-version = "2.4.3"
-supported-server-versions = "2.5.0"
+product-train = "2.5.1"
+registry-version = "2.5.1"
+supported-server-versions = "2.5.16"
 worker-protocol-version = "1.19"
 control-plane-version = "2"
 durable-selection = true

durable_workflow-2.5.1/src/durable_workflow/_sticky_workflow_cache.py

@@ -0,0 +1,103 @@
+"""Bounded snapshots of durable wire history, never live workflow instances."""
+
+from __future__ import annotations
+
+import json
+import time
+from collections import OrderedDict
+from dataclasses import dataclass
+from typing import Any
+
+CacheKey = tuple[str, str, str]
+
+
+def complete_history(history: list[dict[str, Any]]) -> bool:
+    if not history or any(not isinstance(event, dict) for event in history):
+        return False
+    types = [event.get("event_type") for event in history[:2]]
+    if types[0] != "WorkflowStarted" and types != ["StartAccepted", "WorkflowStarted"]:
+        return False
+    return all(type(event.get("sequence")) is int and event["sequence"] == index
+               for index, event in enumerate(history, 1))
+
+
+@dataclass(frozen=True)
+class _Entry:
+    encoded: bytes
+    expires_at: float
+    resume_token: str | None
+    resume_offset: int
+
+
+class StickyWorkflowCache:
+    def __init__(self, capacity: int, max_bytes: int, ttl_seconds: int) -> None:
+        for name, value, minimum in (("capacity", capacity, 0), ("max_bytes", max_bytes, 1),
+                                     ("ttl_seconds", ttl_seconds, 1)):
+            if type(value) is not int or value < minimum:
+                raise ValueError(f"sticky_cache_{name} must be an integer of at least {minimum}")
+        if ttl_seconds > 3600:
+            raise ValueError("sticky_cache_ttl_seconds must be at most 3600")
+        self.capacity = capacity
+        self.max_bytes = max_bytes
+        self.ttl_seconds = ttl_seconds
+        self._entries: OrderedDict[CacheKey, _Entry] = OrderedDict()
+        self._bytes = 0
+        self._metrics = {"hit": 0, "miss": 0, "eviction": 0, "forced_cold_replay": 0}
+
+    @property
+    def enabled(self) -> bool:
+        return self.capacity > 0
+
+    def _expire(self) -> None:
+        now = time.monotonic()
+        for key, entry in list(self._entries.items()):
+            if entry.expires_at <= now:
+                self.discard(key)
+
+    def discard(self, key: CacheKey) -> None:
+        entry = self._entries.pop(key, None)
+        if entry is not None:
+            self._bytes -= len(entry.encoded)
+
+    def lookup(self, key: CacheKey) -> tuple[list[dict[str, Any]], str | None, int] | None:
+        self._expire()
+        entry = self._entries.get(key)
+        if entry is None:
+            return None
+        self._entries.move_to_end(key)
+        # Decoding isolates the retained snapshot from replay and handler mutation.
+        history: list[dict[str, Any]] = json.loads(entry.encoded)
+        return history, entry.resume_token, entry.resume_offset
+
+    def remember(self, key: CacheKey, history: list[dict[str, Any]], *,
+                 resume_token: str | None = None, resume_offset: int = 0) -> bool:
+        self._expire()
+        self.discard(key)
+        if not self.enabled or not complete_history(history):
+            return False
+        try:
+            encoded = json.dumps(history, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8")
+        except (TypeError, ValueError):
+            return False
+        if len(encoded) > self.max_bytes:
+            return False
+        while self._entries and (len(self._entries) >= self.capacity or self._bytes + len(encoded) > self.max_bytes):
+            oldest = next(iter(self._entries))
+            self.discard(oldest)
+            self._metrics["eviction"] += 1
+        self._entries[key] = _Entry(encoded, time.monotonic() + self.ttl_seconds, resume_token, resume_offset)
+        self._bytes += len(encoded)
+        return True
+
+    def record_replay(self, *, hit: bool, forced: bool = False) -> None:
+        self._metrics["hit" if hit else "miss"] += 1
+        if forced:
+            self._metrics["forced_cold_replay"] += 1
+
+    def metrics(self) -> dict[str, int]:
+        self._expire()
+        return {**self._metrics, "entries": len(self._entries), "history_bytes": self._bytes}
+
+    def clear(self) -> None:
+        self._entries.clear()
+        self._bytes = 0

{durable_workflow-2.4.3 → durable_workflow-2.5.1}/src/durable_workflow/client.py

@@ -87,7 +87,7 @@ PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST: dict[str, dict[str, str | bool]] =
     "sticky_execution": {
         "supported": False,
         "minimum_protocol_version": "1.18",
-        "reason": "python_worker_uses_complete_durable_history_replay",
+        "reason": "sticky_cache_disabled",
     },
 }
 _MESSAGE_STREAMS_CAPABILITY = "message_streams"
@@ -5112,6 +5112,7 @@ class Client:
         commands: list[dict[str, Any]],
         message_stream_cursors: list[dict[str, Any]] | None = None,
         message_stream_waits: list[dict[str, Any]] | None = None,
+        sticky_cache: dict[str, Any] | None = None,
     ) -> Any:
         """Report successful execution of a workflow task with its emitted commands.
 
@@ -5143,6 +5144,8 @@ class Client:
             body["message_stream_cursors"] = message_stream_cursors
         if message_stream_waits:
             body["message_stream_waits"] = message_stream_waits
+        if sticky_cache is not None:
+            body["sticky_cache"] = sticky_cache
         return await self._request(
             "POST", f"/worker/workflow-tasks/{task_id}/complete", worker=True, json=body
         )

{durable_workflow-2.4.3 → durable_workflow-2.5.1}/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 ._sticky_workflow_cache import CacheKey, StickyWorkflowCache, complete_history
 from .activity import ActivityContext, ActivityInfo, _set_context
 from .auth_composition import (
     AUTH_COMPOSITION_CONTRACT_SCHEMA,
@@ -53,6 +54,7 @@ from .client import (
     CONTROL_PLANE_REQUEST_CONTRACT_SCHEMA,
     CONTROL_PLANE_REQUEST_CONTRACT_VERSION,
     CONTROL_PLANE_VERSION,
+    DEFAULT_SDK_VERSION,
     PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST,
     PROTOCOL_VERSION,
     Client,
@@ -1008,6 +1010,9 @@ class Worker:
         max_concurrent_workflow_tasks: int = 10,
         max_concurrent_activity_tasks: int = 10,
         max_concurrent_worker_sessions: int = 10,
+        sticky_cache_capacity: int = 0,
+        sticky_cache_max_bytes: int = 16 * 1024 * 1024,
+        sticky_cache_ttl_seconds: int = 300,
         shutdown_timeout: float = 30.0,
         heartbeat_interval: float = 60.0,
         metrics: MetricsRecorder | None = None,
@@ -1029,6 +1034,11 @@ class Worker:
         }
         self.activities = {_activity_name(a): a for a in activities}
         self.capabilities = tuple(dict.fromkeys(capability.strip() for capability in capabilities))
+        self._sticky_cache = StickyWorkflowCache(
+            sticky_cache_capacity, sticky_cache_max_bytes, sticky_cache_ttl_seconds,
+        )
+        if "sticky_execution" in self.capabilities and not self._sticky_cache.enabled:
+            raise ValueError("sticky_execution requires a positive sticky_cache_capacity")
         self._cooperative_cancellation_supported = False
         self._prepared_local_activities_supported = False
         self._prepared_local_activity_groups_supported = False
@@ -1211,6 +1221,13 @@ class Worker:
         _validate_server_compatibility(info)
         protocol = info.get("worker_protocol")
         server_capabilities = protocol.get("server_capabilities") if isinstance(protocol, Mapping) else None
+        sticky_support = (
+            server_capabilities.get("sticky_execution") if isinstance(server_capabilities, Mapping) else None
+        )
+        if self._sticky_cache.enabled and (
+            not isinstance(sticky_support, Mapping) or sticky_support.get("supported") is not True
+        ):
+            raise RuntimeError("sticky execution requires Server's advertised sticky_execution support")
         self._cooperative_cancellation_supported = (
             "cooperative_cancellation" in self.capabilities
             and isinstance(protocol, Mapping)
@@ -1292,6 +1309,15 @@ class Worker:
             capabilities.append("prepared_local_activity_cancellation_policies")
         if PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST["worker_sessions"]["supported"]:
             capabilities.append("worker_sessions")
+        affinity_manifest = {name: dict(entry) for name, entry in PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST.items()}
+        if self._sticky_cache.enabled:
+            if "sticky_execution" not in capabilities:
+                capabilities.append("sticky_execution")
+            affinity_manifest["sticky_execution"] = {
+                "supported": True,
+                "minimum_protocol_version": "1.18",
+                "implementation": "bounded_durable_history_cache",
+            }
 
         ack = await self.client.register_worker(
             worker_id=self.worker_id,
@@ -1306,7 +1332,7 @@ class Worker:
             build_id=self.build_id,
             capabilities=capabilities,
             capability_manifest={
-                **PORTABLE_WORKER_AFFINITY_CAPABILITY_MANIFEST,
+                **affinity_manifest,
                 **({"prepared_local_activities": {
                     "supported": True, "minimum_protocol_version": "1.20",
                     "implementation": "durable_sequential_admission",
@@ -1514,8 +1540,65 @@ class Worker:
     async def _load_workflow_claim_history(
         self, task: dict[str, Any], *, first_page_token: str | None = None,
     ) -> list[dict[str, Any]]:
-        history = [] if first_page_token is not None else list(task.get("history_events", []))
-        token = first_page_token if first_page_token is not None else task.get("next_history_page_token")
+        if first_page_token is not None:
+            return await self._fetch_workflow_claim_history_pages(task, [], first_page_token)
+        inline = list(task.get("history_events", []))
+        key = self._sticky_cache_key(task)
+        mode = task.get("sticky_replay_mode")
+        cached = self._sticky_cache.lookup(key) if key is not None and mode == "sticky_hit_expected" else None
+        if cached is not None and key is not None:
+            prefix, resume_token, resume_offset = cached
+            overlap = min(len(inline), len(prefix))
+            # Published Server responses also express the boundary as an event count.
+            # Retained histories are contiguous from sequence 1, so the two agree.
+            raw_last_sequence = task.get("last_history_sequence", task.get("total_history_events"))
+            last_sequence = raw_last_sequence if isinstance(raw_last_sequence, int) else -1
+            anchored = (
+                complete_history(inline) and inline[:overlap] == prefix[:overlap]
+                and type(raw_last_sequence) is int and last_sequence >= len(prefix)
+            )
+            if anchored:
+                if resume_token is not None and resume_offset >= len(inline) and len(inline) < len(prefix):
+                    try:
+                        tail = await self._fetch_workflow_claim_history_pages(task, [], resume_token)
+                    except (InvalidArgument, LocalActivityExecutionAborted):
+                        tail = []
+                    except ServerError as error:
+                        if error.status != 400 or error.reason() != "invalid_page_token":
+                            raise
+                        tail = []
+                    if tail[:len(prefix) - resume_offset] == prefix[resume_offset:]:
+                        history = prefix[:resume_offset] + tail
+                        if complete_history(history) and len(history) >= last_sequence:
+                            # Paging measured the offset within the tail; retain its absolute boundary.
+                            task["_sticky_resume_offset"] += resume_offset
+                            self._sticky_cache.record_replay(hit=True)
+                            return history
+                else:
+                    history = await self._fetch_workflow_claim_history_pages(
+                        task, inline, task.get("next_history_page_token"),
+                    )
+                    if complete_history(history) and history[:len(prefix)] == prefix and len(history) >= last_sequence:
+                        self._sticky_cache.record_replay(hit=True)
+                        return history
+            # A cached prefix must never replace an inconsistent authoritative page.
+            self._sticky_cache.discard(key)
+        if key is not None:
+            self._sticky_cache.record_replay(
+                hit=False, forced=mode in {"sticky_hit_expected", "forced_cold_replay"},
+            )
+        if mode in {"sticky_hit_expected", "forced_cold_replay"} and not complete_history(inline):
+            history = await self._fetch_workflow_claim_history_pages(task, [], "MA==")
+            if not complete_history(history):
+                raise LocalActivityExecutionAborted("cold replay lacks a complete canonical history prefix")
+            return history
+        return await self._fetch_workflow_claim_history_pages(task, inline, task.get("next_history_page_token"))
+
+    async def _fetch_workflow_claim_history_pages(
+        self, task: dict[str, Any], history: list[dict[str, Any]], token: Any,
+    ) -> list[dict[str, Any]]:
+        task["_sticky_resume_token"] = None
+        task["_sticky_resume_offset"] = 0
         seen: set[str] = set()
         while token is not None:
             if not isinstance(token, str) or not token or token in seen:
@@ -1529,10 +1612,46 @@ class Worker:
                 raise LocalActivityExecutionAborted("workflow history page was not acknowledged")
             if any(not isinstance(event, dict) for event in page["history_events"]):
                 raise LocalActivityExecutionAborted("workflow history page contains a malformed event")
+            task["_sticky_resume_token"] = token
+            task["_sticky_resume_offset"] = len(history)
             history.extend(page["history_events"])
             token = page.get("next_history_page_token")
         return history
 
+    def _sticky_cache_key(self, task: dict[str, Any]) -> CacheKey | None:
+        if not self._sticky_cache.enabled:
+            return None
+        workflow_id, run_id = task.get("workflow_id"), task.get("run_id")
+        if not isinstance(workflow_id, str) or not workflow_id or not isinstance(run_id, str) or not run_id:
+            return None
+        return workflow_id, run_id, self.build_id.strip() if self.build_id is not None else DEFAULT_SDK_VERSION
+
+    def _sticky_cache_claim(
+        self, task: dict[str, Any], history: list[dict[str, Any]], commands: list[dict[str, Any]],
+    ) -> dict[str, Any] | None:
+        key = self._sticky_cache_key(task)
+        if key is None:
+            return None
+        if any(command.get("type") in {"complete_workflow", "fail_workflow", "continue_as_new"}
+               for command in commands):
+            self._sticky_cache.discard(key)
+            return None
+        if not self._sticky_cache.remember(
+            key, history, resume_token=task.get("_sticky_resume_token"),
+            resume_offset=task.get("_sticky_resume_offset", 0),
+        ):
+            return None
+        return {
+            "worker_id": self.worker_id, "workflow_id": key[0], "run_id": key[1], "build_id": key[2],
+            "ttl_seconds": self._sticky_cache.ttl_seconds,
+            "metrics": {name: self._sticky_cache.metrics()[name]
+                        for name in ("hit", "miss", "eviction", "forced_cold_replay")},
+        }
+
+    def sticky_cache_metrics(self) -> dict[str, int]:
+        """Return replay counters, retained entries and encoded history bytes."""
+        return self._sticky_cache.metrics()
+
     async def _refresh_cancellation_history(
         self, task: dict[str, Any], observed: CancellationRequest,
     ) -> list[dict[str, Any]]:
@@ -2416,6 +2535,7 @@ class Worker:
                     task_id=task_id,
                     attempt=attempt,
                     commands=[command],
+                    sticky_cache=self._sticky_cache_claim(task, history, [command]),
                 )
             except Exception as e:
                 log.warning("failed to complete workflow update task %s: %s", task_id, e)
@@ -2622,6 +2742,7 @@ class Worker:
                 commands=commands,
                 message_stream_cursors=outcome.message_stream_cursors,
                 message_stream_waits=outcome.message_stream_waits,
+                sticky_cache=self._sticky_cache_claim(task, history, commands),
             )
         except Exception as e:
             log.warning("failed to complete workflow task %s: %s", task_id, e)
@@ -2640,9 +2761,11 @@ class Worker:
         commands: list[dict[str, Any]],
         message_stream_cursors: list[dict[str, Any]] | None = None,
         message_stream_waits: list[dict[str, Any]] | None = None,
+        sticky_cache: dict[str, Any] | None = None,
     ) -> None:
         for completion_attempt in range(1, _WORKFLOW_TASK_COMPLETION_MAX_ATTEMPTS + 1):
             try:
+                completion_kwargs = {"sticky_cache": sticky_cache} if sticky_cache is not None else {}
                 await self.client.complete_workflow_task(
                     task_id=task_id,
                     lease_owner=self.worker_id,
@@ -2650,6 +2773,7 @@ class Worker:
                     commands=commands,
                     message_stream_cursors=message_stream_cursors,
                     message_stream_waits=message_stream_waits,
+                    **completion_kwargs,
                 )
                 return
             except Exception as error:
@@ -4353,6 +4477,7 @@ class Worker:
             await self.client.deregister_worker_registration(self.worker_id)
             self._registered = False
             log.info("worker %s deregistered", self.worker_id)
+        self._sticky_cache.clear()
 
     @staticmethod
     def _remaining_shutdown_time(deadline: float) -> float:

{durable_workflow-2.4.3 → durable_workflow-2.5.1}/src/durable_workflow/workflow.py

@@ -5185,6 +5185,96 @@ def _replay_state(
     pending: list[Command] = []
     advanced_cmd: Any = None
     terminal_condition_reopen_cmd: WaitCondition | None = None
+    version_decisions: dict[str, tuple[int, str]] = {}
+
+    def _version_error(detail: str, step: _RecordedStep | None = None) -> NonDeterministicReplayError:
+        return NonDeterministicReplayError(
+            step.workflow_sequence if step is not None else authored_sequence,
+            "compatible version marker",
+            step.event_types if step is not None else [],
+            detail=detail,
+        )
+
+    def _recorded_version(step: _RecordedStep) -> int:
+        if step.history_index is None:
+            raise _version_error("Version marker is missing its history position.", step)
+        payload = events[step.history_index].get("payload") or {}
+        version = payload.get("version")
+        if type(version) is not int:
+            raise _version_error("Version marker must contain an integer version.", step)
+        change_id = payload.get("change_id")
+        if "change_id" in payload and (not isinstance(change_id, str) or not change_id.strip()):
+            raise _version_error("Version marker must retain a non-empty change ID.", step)
+        if "min_supported" in payload or "max_supported" in payload:
+            minimum, maximum = payload.get("min_supported"), payload.get("max_supported")
+            if (type(minimum) is not int or type(maximum) is not int
+                    or not minimum <= version <= maximum):
+                raise _version_error("Recorded version marker has an invalid supported range.", step)
+        return version
+
+    def _consume_duplicate_version_markers() -> None:
+        nonlocal result_cursor, authored_sequence
+        if not version_decisions:
+            return
+        while result_cursor < len(recorded_steps):
+            step = recorded_steps[result_cursor]
+            change_id = step.details.get("change_id")
+            if step.shape != "version marker" or change_id not in version_decisions:
+                return
+            if _next_unconsumed_recorded_step() is not step:
+                return
+            version = _recorded_version(step)
+            if version != version_decisions[change_id][0]:
+                raise _version_error(f"Conflicting recorded decisions for change ID {change_id!r}.", step)
+            # Earlier SDKs emitted a marker for every invocation. Consume these
+            # aliases while retaining their physical positions for cancellation
+            # and prepared operations. The stored history itself is unchanged.
+            result_cursor += 1
+            authored_sequence = max(authored_sequence, step.workflow_sequence + 1)
+
+    def _resolve_version(command: RecordVersionMarker) -> Any:
+        nonlocal result_cursor, authored_sequence
+        change_id = command.change_id
+        if not isinstance(change_id, str) or not change_id.strip():
+            raise _version_error("Version markers require a stable non-empty change ID.")
+        if (type(command.min_supported) is not int or type(command.max_supported) is not int
+                or command.min_supported > command.max_supported):
+            raise _version_error(f"Invalid supported range for change ID {change_id!r}.")
+        family = "version" if command.result_kind == "version" else "patch"
+        decision = version_decisions.get(change_id)
+        step = _next_unconsumed_recorded_step()
+        if decision is not None:
+            version, original_family = decision
+            if original_family != family:
+                raise _version_error(f"Change ID {change_id!r} cannot switch between version and patch helpers.", step)
+        elif step is not None and step.shape == "version marker":
+            _assert_step_matches(command, step)
+            version = _recorded_version(step)
+            result_cursor += 1
+            authored_sequence = max(authored_sequence, step.workflow_sequence + 1)
+        elif step is not None or (cancellation.delivery is not None and not cancellation_consumed) or any(
+            sequence not in consumed_scope_deliveries for sequence in committed_scopes.deliveries
+        ) or any(_history_event_type(event) in {
+            "WorkflowCompleted", "WorkflowFailed", "WorkflowCancelled", "WorkflowTerminated",
+            "WorkflowContinuedAsNew", "WorkflowTimedOut",
+        } for event in events):
+            # An unmarked recorded command proves this history passed the new
+            # patch site. Leave that command available for its original call.
+            version = -1
+        else:
+            version = command.version
+            if type(version) is not int:
+                raise _version_error(f"Invalid version for change ID {change_id!r}.")
+            ctx.logger._set_replaying(False)
+            pending.append(command)
+            authored_sequence += 1
+        if not command.min_supported <= version <= command.max_supported:
+            raise _version_error(
+                f"Recorded version {version} for change ID {change_id!r} is outside "
+                f"the supported range {command.min_supported}..{command.max_supported}.", step,
+            )
+        version_decisions.setdefault(change_id, (version, family))
+        return _version_marker_result(command, version)
 
     def _parallel_leaf_kind(command: Any) -> str:
         if isinstance(command, ScheduleActivity | RecordLocalActivity):
@@ -6064,6 +6154,7 @@ def _replay_state(
     replay_token = _ACTIVE_WORKFLOW_REPLAY.set(ctx)
     try:
         while True:
+            _consume_duplicate_version_markers()
             # Cursor-0 receivers are start-boundary events. Enter run() once
             # before applying them so workflow initialization observes the
             # same WorkflowStarted-before-Signal/Update ordering the server
@@ -6081,6 +6172,9 @@ def _replay_state(
                 first = False
             _apply_due_receivers()
             _validate_local_activity_policies(cmd)
+            if isinstance(cmd, RecordVersionMarker):
+                next_value = _resolve_version(cmd)
+                continue
             if prepare_local_activities and isinstance(cmd, list | SelectGroup) and _contains_local_activity(cmd) and (
                 not prepare_local_activity_groups or isinstance(cmd, SelectGroup)
             ):
@@ -6497,18 +6591,6 @@ def _replay_state(
                 pending.append(cmd)
                 next_value = None
                 continue
-            if isinstance(cmd, RecordVersionMarker):
-                if result_cursor < len(resolved_results):
-                    _assert_next_step_matches(cmd)
-                    val = resolved_results[result_cursor]
-                    result_cursor += 1
-                    next_value = _version_marker_result(cmd, val)
-                    continue
-                ctx.logger._set_replaying(False)
-                _assert_pending_step_matches(cmd)
-                pending.append(cmd)
-                next_value = _version_marker_result(cmd, cmd.version)
-                continue
             if isinstance(cmd, WaitCondition):
                 # A condition that is already true is not persisted. Apply
                 # receivers at the yield boundary before deciding whether the

{durable_workflow-2.4.3 → durable_workflow-2.5.1/src/durable_workflow.egg-info}/PKG-INFO

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

{durable_workflow-2.4.3 → durable_workflow-2.5.1}/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/_sticky_workflow_cache.py
 src/durable_workflow/activity.py
 src/durable_workflow/auth_composition.py
 src/durable_workflow/cancellation.py
@@ -81,6 +82,7 @@ tests/test_metrics.py
 tests/test_order_processing_example.py
 tests/test_parallel_completion_order_replay.py
 tests/test_parallel_saga_authoring.py
+tests/test_patch_history.py
 tests/test_pending_operation_replay.py
 tests/test_prepared_local_activity_client.py
 tests/test_prepared_local_activity_groups.py
@@ -106,6 +108,7 @@ tests/test_serializer.py
 tests/test_signals.py
 tests/test_sleep.py
 tests/test_standalone_activity_client.py
+tests/test_sticky_execution.py
 tests/test_storage_admission.py
 tests/test_sync.py
 tests/test_testing_harness.py

{durable_workflow-2.4.3 → durable_workflow-2.5.1}/tests/test_cooperative_remote_worker.py

@@ -47,22 +47,29 @@ def stop_receipt() -> dict[str, Any]:
             "heartbeat_recorded": False, "history_event_id": "receipt-event"}
 
 
+def write_pid_marker(marker: str) -> None:
+    target = Path(marker)
+    pending = target.with_name(target.name + ".pending")
+    pending.write_text(str(os.getpid()))
+    pending.replace(target)
+
+
 async def blocked_async(marker: str, heartbeat: bool = False) -> None:
     if heartbeat:
         await activity.context().heartbeat({"authored": True})
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     await asyncio.Event().wait()
 
 
 def blocked_sync(marker: str, heartbeat: bool = False) -> None:
     if heartbeat:
         asyncio.run(activity.context().heartbeat({"authored": True}))
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     time.sleep(60)
 
 
 def released_sync(marker: str) -> bytes:
-    Path(marker).write_text(str(os.getpid()))
+    write_pid_marker(marker)
     while not Path(marker + ".release").exists():
         time.sleep(0.02)
     return b"late result"