durable-workflow 2.14.0__tar.gz → 2.14.1__tar.gz

{durable_workflow-2.14.0/src/durable_workflow.egg-info → durable_workflow-2.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.14.0
+Version: 2.14.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.14.0 → durable_workflow-2.14.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.14.0"
+version = "2.14.1"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -79,8 +79,8 @@ 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.14.0"
-registry-version = "2.14.0"
+product-train = "2.14.1"
+registry-version = "2.14.1"
 supported-server-versions = "2.8.0"
 supported-server-release-baselines = { "2" = "2.8.0", "3" = "3.0.0" }
 worker-protocol-version = "1.20"

durable_workflow-2.14.1/src/durable_workflow/_condition_fingerprint.py

@@ -0,0 +1,229 @@
+"""Stable identity for ``wait_condition`` predicates (#258).
+
+The Server records the fingerprint a worker sends with ``open_condition_wait``
+and replay compares it, so the value must be the same on every Python version
+and in every process. Version 2 hashes the predicate's module, qualified name
+and a canonical form of its source AST. It never hashes bytecode, constant
+reprs, memory addresses, file paths or line numbers.
+
+Version 1 (every release through 2.14.0) hashed bytecode and ``repr`` of code
+constants, which change across Python versions and, for nested functions,
+across processes. Recorded v1 values cannot be recomputed portably, so replay
+treats a v1 value that differs from this process's v1 as unverifiable rather
+than as a changed predicate (see :func:`fingerprint_verdict`).
+"""
+
+from __future__ import annotations
+
+import ast
+import hashlib
+import inspect
+import linecache
+import re
+from collections.abc import Callable
+from typing import Any, Literal
+
+V2_PREFIX = "dwpy2:sha256:"
+_LEGACY = re.compile(r"sha256:[0-9a-f]{64}\Z")
+# Fields that carry no predicate meaning or differ between Python versions.
+_SKIPPED_FIELDS = frozenset({"ctx", "kind", "type_comment", "type_params", "decorator_list", "returns"})
+_parsed: dict[tuple[str, int], ast.Module | None] = {}
+_nodes: dict[Any, str | None] = {}
+# Python 3.12 inlines list, dict and set comprehensions (PEP 709), which drops
+# their segment from a nested function's __qualname__.
+_INLINED_COMPREHENSION = re.compile(r"\.<(?:listcomp|dictcomp|setcomp)>")
+
+Verdict = Literal["match", "mismatch", "unverifiable"]
+
+
+def legacy_fingerprint(predicate: Callable[[], bool]) -> str:
+    """The v1 fingerprint, kept only to recognise histories recorded by 2.14.0 and earlier."""
+    h = hashlib.sha256()
+    h.update(b"durable-workflow-python.wait-condition.v1\0")
+    h.update(f"{getattr(predicate, '__module__', '')}\0".encode())
+    h.update(f"{getattr(predicate, '__qualname__', '')}\0".encode())
+    original = getattr(predicate, "__typed_workflow_method__", None)
+    code = getattr(original if original is not None else predicate, "__code__", None)
+    if code is None:
+        h.update(repr(predicate).encode())
+    else:
+        h.update(repr((
+            code.co_argcount, code.co_posonlyargcount, code.co_kwonlyargcount, code.co_code,
+            code.co_consts, code.co_names, code.co_varnames, code.co_freevars,
+        )).encode())
+    return f"sha256:{h.hexdigest()}"
+
+
+def is_legacy(value: Any) -> bool:
+    return isinstance(value, str) and _LEGACY.match(value) is not None
+
+
+def fingerprint(predicate: Callable[[], bool]) -> str | None:
+    """Return the v2 fingerprint, or None when the predicate's source is unavailable.
+
+    Without a fingerprint the wait is identified by its key and call order,
+    as in sdk-php.
+    """
+    function = _authored_function(predicate)
+    if function is None:
+        return None
+    code = function.__code__
+    if code not in _nodes:
+        _nodes[code] = _predicate_node(function)
+    node = _nodes[code]
+    if node is None:
+        return None
+    qualname = _INLINED_COMPREHENSION.sub("", getattr(function, "__qualname__", ""))
+    h = hashlib.sha256()
+    h.update(b"durable-workflow-python.wait-condition.v2\0")
+    h.update(f"{getattr(function, '__module__', '')}\0".encode())
+    h.update(f"{qualname}\0".encode())
+    h.update(node.encode())
+    return f"{V2_PREFIX}{h.hexdigest()}"
+
+
+def fingerprint_verdict(recorded: Any, authored: str | None, predicate: Callable[[], bool]) -> Verdict:
+    """Compare a recorded fingerprint with the authored predicate.
+
+    - No recorded value: nothing to compare.
+    - An identity supplied explicitly in another format (not v2, not None)
+      is compared exactly, as before.
+    - A v2 value is compared exactly; without source it cannot be checked.
+    - A v1 value equal to this process's v1 matches. Any other v1 value is
+      unverifiable, because v1 differs across Python versions and processes.
+    - Any other string is compared exactly, as before.
+    """
+    if not isinstance(recorded, str):
+        return "match"
+    if authored is not None and not authored.startswith(V2_PREFIX):
+        return "match" if recorded == authored else "mismatch"
+    if recorded.startswith(V2_PREFIX):
+        if authored is None:
+            return "unverifiable"
+        return "match" if recorded == authored else "mismatch"
+    if is_legacy(recorded):
+        return "match" if recorded == legacy_fingerprint(predicate) else "unverifiable"
+    return "match" if recorded == authored else "mismatch"
+
+
+def _authored_function(predicate: Any) -> Any:
+    target = getattr(predicate, "__typed_workflow_method__", None) or predicate
+    if inspect.ismethod(target):
+        target = target.__func__
+    target = getattr(target, "__typed_workflow_method__", None) or target
+    return target if inspect.isfunction(target) else None
+
+
+def _module_tree(function: Any) -> ast.Module | None:
+    try:
+        filename = inspect.getsourcefile(function) or inspect.getfile(function)
+    except (OSError, TypeError):
+        return None
+    lines = linecache.getlines(filename, function.__globals__)
+    if not lines:
+        return None
+    source = "".join(lines)
+    key = (filename, hash(source))
+    if key not in _parsed:
+        try:
+            _parsed[key] = ast.parse(source)
+        except (SyntaxError, ValueError):
+            _parsed[key] = None
+    return _parsed[key]
+
+
+def _predicate_node(function: Any) -> str | None:
+    tree = _module_tree(function)
+    if tree is None:
+        return None
+    code = function.__code__
+    first_line = code.co_firstlineno
+    if function.__name__ == "<lambda>":
+        lambdas = [node for node in ast.walk(tree) if isinstance(node, ast.Lambda) and node.lineno == first_line]
+        lambdas.sort(key=lambda node: node.col_offset)
+        # PEP 709 moves comprehension instructions into the enclosing lambda.
+        # Candidates indistinguishable before 3.12 can become distinct after
+        # inlining, so keep the combined AST on every version in this case.
+        has_inlined_comprehension = any(
+            isinstance(child, ast.ListComp | ast.DictComp | ast.SetComp)
+            for node in lambdas for child in ast.walk(node)
+        )
+        if len(lambdas) > 1 and not has_inlined_comprehension:
+            # Names and constants are stable across versions; bytecode only
+            # breaks a tie, and is compared within this interpreter.
+            matching = [node for node in lambdas if _compiles_to(node, code, compare_bytecode=False)]
+            if len(matching) > 1:
+                matching = [node for node in matching if _compiles_to(node, code, compare_bytecode=True)]
+            if len(matching) == 1:
+                lambdas = matching
+        if not lambdas:
+            return None
+        # Lambdas that start on the same line and compile identically share
+        # one fingerprint covering all of them.
+        return "|".join(_canonical(node) for node in lambdas)
+    definitions = [
+        node for node in ast.walk(tree)
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef) and node.name == function.__name__
+        and min([node.lineno, *(decorator.lineno for decorator in node.decorator_list)]) == first_line
+    ]
+    if len(definitions) != 1:
+        return None
+    return _canonical(definitions[0])
+
+
+def _compiles_to(node: ast.Lambda, code: Any, *, compare_bytecode: bool) -> bool:
+    """Whether *node* compiles to *code* on this interpreter.
+
+    The candidate is compiled inside a function that binds the live code's
+    free variables, so names resolve the same way. Only the choice of node
+    uses bytecode, which is valid within one interpreter; the fingerprint
+    hashes the node's AST, so it stays portable.
+    """
+    free = list(code.co_freevars)
+    lines = ["def __dw_outer__():"]
+    if free:
+        lines.append(f"    {' = '.join(free)} = None")
+    lines.append(f"    return ({ast.unparse(node)})")
+    try:
+        outer = compile("\n".join(lines), "<condition-fingerprint>", "exec")
+    except SyntaxError:
+        return False
+    function = next((const for const in outer.co_consts if hasattr(const, "co_code")), None)
+    candidate = next(
+        (const for const in getattr(function, "co_consts", ()) if getattr(const, "co_name", None) == "<lambda>"),
+        None,
+    )
+    return candidate is not None and (
+        (not compare_bytecode or candidate.co_code == code.co_code)
+        and candidate.co_argcount == code.co_argcount
+        and candidate.co_names == code.co_names
+        and candidate.co_varnames == code.co_varnames
+        and candidate.co_freevars == code.co_freevars
+        and _plain_constants(candidate) == _plain_constants(code)
+    )
+
+
+def _plain_constants(code: Any) -> list[Any]:
+    """Constants other than nested code and the qualnames Python 3.10 stores for them."""
+    return [
+        const for const in code.co_consts
+        if not hasattr(const, "co_code") and not (isinstance(const, str) and "<locals>" in const)
+    ]
+
+
+def _canonical(value: Any) -> str:
+    if isinstance(value, ast.AST):
+        parts = [type(value).__name__]
+        for name in value._fields:
+            if name in _SKIPPED_FIELDS:
+                continue
+            item = getattr(value, name, None)
+            if item is None or item == []:
+                continue
+            parts.append(f"{name}={_canonical(item)}")
+        return "(" + " ".join(parts) + ")"
+    if isinstance(value, list):
+        return "[" + ",".join(_canonical(item) for item in value) + "]"
+    if value is None or value is Ellipsis or isinstance(value, str | bytes | int | float | complex | bool):
+        return f"{type(value).__name__}:{value!r}"
+    return type(value).__name__

{durable_workflow-2.14.0 → durable_workflow-2.14.1}/src/durable_workflow/workflow.py

@@ -42,6 +42,8 @@ from ._cancellation_scope_history import (
     CommittedCancellationScopeHistory,
     ScopeBoundary,
 )
+from ._condition_fingerprint import fingerprint as _stable_condition_fingerprint
+from ._condition_fingerprint import fingerprint_verdict, is_legacy
 from ._cooperative_cancellation import CancellationDelivery, read_cancellation_history
 from ._failure_reporting import exception_message
 from ._typed_values import decode_payload_value, to_payload_values, validate_annotation
@@ -1720,28 +1722,9 @@ class CancelDurableOperation:
         }
 
 
-def _condition_predicate_fingerprint(predicate: Callable[[], bool]) -> str:
-    h = hashlib.sha256()
-    h.update(b"durable-workflow-python.wait-condition.v1\0")
-    h.update(f"{getattr(predicate, '__module__', '')}\0".encode())
-    h.update(f"{getattr(predicate, '__qualname__', '')}\0".encode())
-
-    code = getattr(predicate, "__code__", None)
-    if code is None:
-        h.update(repr(predicate).encode())
-    else:
-        h.update(repr((
-            code.co_argcount,
-            code.co_posonlyargcount,
-            code.co_kwonlyargcount,
-            code.co_code,
-            code.co_consts,
-            code.co_names,
-            code.co_varnames,
-            code.co_freevars,
-        )).encode())
-
-    return f"sha256:{h.hexdigest()}"
+def _condition_predicate_fingerprint(predicate: Callable[[], bool]) -> str | None:
+    """The stable v2 predicate fingerprint, or None without source (#258)."""
+    return _stable_condition_fingerprint(predicate)
 
 
 Command = (
@@ -6017,10 +6000,7 @@ def _replay_state(
             )
 
         opened_fingerprint = opened.get("condition_definition_fingerprint")
-        if (
-            isinstance(opened_fingerprint, str)
-            and cmd.condition_definition_fingerprint != opened_fingerprint
-        ):
+        if _fingerprint_verdict(opened, cmd) == "mismatch":
             return NonDeterministicReplayError(
                 step.workflow_sequence, "condition wait", step.event_types,
                 detail=(
@@ -6033,7 +6013,19 @@ def _replay_state(
 
         return None
 
-    def _same_logical_condition_wait(opened: Mapping[str, Any], cmd: WaitCondition) -> bool:
+    def _fingerprint_verdict(opened: Mapping[str, Any], cmd: WaitCondition) -> str:
+        return fingerprint_verdict(
+            opened.get("condition_definition_fingerprint"), cmd.condition_definition_fingerprint, cmd.predicate,
+        )
+
+    def _same_logical_condition_wait(
+        opened: Mapping[str, Any],
+        cmd: WaitCondition,
+        *,
+        chain_first: Mapping[str, Any] | None = None,
+        chain_current: Mapping[str, Any] | None = None,
+        next_index: int | None = None,
+    ) -> bool:
         if _condition_wait_mismatch(opened, cmd) is not None:
             return False
 
@@ -6042,10 +6034,33 @@ def _replay_state(
             return True
 
         opened_fingerprint = opened.get("condition_definition_fingerprint")
+        if not isinstance(opened_fingerprint, str) or not opened_fingerprint:
+            # A keyless wait without source has no identity beyond call order.
+            # Within its own chain (both opens recorded without a fingerprint)
+            # it is the same wait, as 2.14.0 linked it by its process-local v1.
+            first_fingerprint = (
+                chain_first.get("condition_definition_fingerprint") if chain_first is not None else "absent"
+            )
+            return (
+                cmd.condition_definition_fingerprint is None and not cmd.condition_key
+                and chain_first is not None and not first_fingerprint
+            )
+        verdict = _fingerprint_verdict(opened, cmd)
+        if verdict == "match":
+            return True
+        if verdict != "unverifiable":
+            return False
+        # A keyless wait whose fingerprint cannot be checked (a v1 value from
+        # another Python version or process, #258) links only within its own
+        # chain: the same recorded v1 value as the chain's first open, or a
+        # duplicate opened while the current wait was still open (#253). It
+        # never binds a recorded wait to another call.
+        first_fingerprint = chain_first.get("condition_definition_fingerprint") if chain_first is not None else None
+        if is_legacy(opened_fingerprint) and opened_fingerprint == first_fingerprint:
+            return True
         return (
-            isinstance(opened_fingerprint, str)
-            and bool(opened_fingerprint)
-            and opened_fingerprint == cmd.condition_definition_fingerprint
+            chain_current is not None and next_index is not None
+            and _opened_before_terminal(next_index, chain_current)
         )
 
     result_cursor = 0
@@ -6111,6 +6126,10 @@ def _replay_state(
     pending: list[Command] = []
     advanced_cmd: Any = None
     terminal_condition_reopen_cmd: WaitCondition | None = None
+    # The first open of the chain a terminal reopen cleanup belongs to (#258).
+    terminal_condition_chain_first: Mapping[str, Any] | None = None
+    # Its terminal position proves whether a different-process duplicate belongs.
+    terminal_condition_chain_current: Mapping[str, Any] | None = None
     version_decisions: dict[str, int] = {}
 
     def _version_error(detail: str, step: _RecordedStep | None = None) -> NonDeterministicReplayError:
@@ -6686,7 +6705,10 @@ def _replay_state(
             return
         while wait_yield_count < len(wait_opened):
             opened = wait_opened[wait_yield_count]
-            if not _same_logical_condition_wait(opened, terminal_condition_reopen_cmd):
+            if not _same_logical_condition_wait(
+                opened, terminal_condition_reopen_cmd, chain_first=terminal_condition_chain_first,
+                chain_current=terminal_condition_chain_current, next_index=wait_yield_count,
+            ):
                 break
             opened_id = opened.get("condition_wait_id")
             if not isinstance(opened_id, str):
@@ -6928,9 +6950,14 @@ def _replay_state(
                     expected = ({"delay_seconds": leaf.delay_seconds} if isinstance(leaf, StartTimer) else {
                         "condition_key": leaf.condition_key,
                         "timeout_seconds": leaf.timeout_seconds,
-                        "condition_definition_fingerprint": leaf.condition_definition_fingerprint,
                     })
-                    if any(field in payload and payload[field] != actual for field, actual in expected.items()):
+                    fingerprint_changed = isinstance(leaf, WaitCondition) and fingerprint_verdict(
+                        payload.get("condition_definition_fingerprint"), leaf.condition_definition_fingerprint,
+                        leaf.predicate,
+                    ) == "mismatch"
+                    if fingerprint_changed or any(
+                        field in payload and payload[field] != actual for field, actual in expected.items()
+                    ):
                         raise NonDeterministicReplayError(
                             sequence, "original group member", [event_type],
                             detail="scoped group changed its original timer or condition definition",
@@ -7054,7 +7081,7 @@ def _replay_state(
         return terminal is not None and wait_opened_event_indexes[next_index] < terminal
 
     def _reopened_with_remaining_timeout(command: WaitCondition, first_index: int) -> WaitCondition:
-        """Reopen a logical wait with the time left before its first deadline.
+        """Reopen a logical wait with its first fingerprint and remaining time.
 
         The deadline is fixed when the wait first opens, as in embedded
         Workflow: the first ConditionWaitOpened time plus the authored
@@ -7063,14 +7090,20 @@ def _replay_state(
         history time, rounded up and clamped to 0..authored (the sdk-php#269
         rule). Without recorded times the authored timeout is kept.
         """
-        authored = command.timeout_seconds
-        if authored is None or first_index >= len(wait_opened):
+        if first_index >= len(wait_opened):
             return command
+        reopened = copy(command)
+        # A reopen sends the fingerprint its first open recorded, so a wait
+        # first opened under v1 (2.14.0 and earlier) keeps v1 across the
+        # upgrade and links v1 to v1, never v1 to v2 (#258).
+        recorded = wait_opened[first_index].get("condition_definition_fingerprint")
+        if isinstance(recorded, str) and recorded:
+            reopened.condition_definition_fingerprint = recorded
+        authored = command.timeout_seconds
         opened_at = wait_opened_times[first_index]
-        if opened_at is None or history_time is None:
-            return command
+        if authored is None or opened_at is None or history_time is None:
+            return reopened
         remaining = math.ceil(authored - (history_time - opened_at).total_seconds())
-        reopened = copy(command)
         reopened.timeout_seconds = min(authored, max(0, remaining))
         return reopened
 
@@ -7730,7 +7763,10 @@ def _replay_state(
                     has_reopened_same_wait = (
                         opened is not None
                         and next_wait_index < len(wait_opened)
-                        and _same_logical_condition_wait(wait_opened[next_wait_index], cmd)
+                        and _same_logical_condition_wait(
+                            wait_opened[next_wait_index], cmd, chain_first=wait_opened[first_open_index],
+                            chain_current=opened, next_index=next_wait_index,
+                        )
                     )
                     if resolution == "timed_out":
                         if has_reopened_same_wait and _opened_before_terminal(next_wait_index, opened):
@@ -7769,6 +7805,8 @@ def _replay_state(
                             if has_reopened_same_wait and consumed_reopen_for_current_wait
                             else None
                         )
+                        terminal_condition_chain_first = wait_opened[first_open_index]
+                        terminal_condition_chain_current = opened
                         next_value = True
                         wait_yield_count += 1
                         break
@@ -7778,6 +7816,8 @@ def _replay_state(
                             if has_reopened_same_wait and consumed_reopen_for_current_wait
                             else None
                         )
+                        terminal_condition_chain_first = wait_opened[first_open_index]
+                        terminal_condition_chain_current = opened
                         next_value = True
                         wait_yield_count += 1
                         break

{durable_workflow-2.14.0 → durable_workflow-2.14.1/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.14.0
+Version: 2.14.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.14.0 → durable_workflow-2.14.1}/src/durable_workflow.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/durable_workflow/_activity_process.py
 src/durable_workflow/_avro.py
 src/durable_workflow/_cancellation_scope.py
 src/durable_workflow/_cancellation_scope_history.py
+src/durable_workflow/_condition_fingerprint.py
 src/durable_workflow/_cooperative_cancellation.py
 src/durable_workflow/_failure_reporting.py
 src/durable_workflow/_metric_routes.py
@@ -78,6 +79,7 @@ tests/test_committed_cancellation_scope_descendants.py
 tests/test_committed_cancellation_scope_groups.py
 tests/test_committed_cancellation_scope_history.py
 tests/test_committed_cancellation_scope_replay.py
+tests/test_condition_fingerprint.py
 tests/test_condition_replay_drift.py
 tests/test_control_plane_parity_fixtures.py
 tests/test_cooperative_cancellation.py

{durable_workflow-2.14.0 → durable_workflow-2.14.1}/tests/test_client_timeouts.py

@@ -60,10 +60,15 @@ async def response_server(*, delay: float | None) -> AsyncIterator[str]:
 @pytest.mark.asyncio
 @pytest.mark.parametrize("operation", ["control", "discovery", "worker"])
 async def test_configured_timeout_bounds_a_stalled_response(operation: str) -> None:
+    async def allow_connection_setup(request: httpx.Request) -> None:
+        # Exercise the configured read budget even when cold TCP setup is slow.
+        request.extensions["timeout"]["connect"] = 1.0
+
     async with (
         response_server(delay=None) as endpoint,
         Client(endpoint, timeout=0.05, retry_policy=TransportRetryPolicy(max_attempts=1)) as client,
     ):
+        client._http.event_hooks["request"].append(allow_connection_setup)
         if operation == "control":
             request = client.health()
         elif operation == "discovery":