durabletask 1.7.0__tar.gz → 1.7.1__tar.gz

{durabletask-1.7.0 → durabletask-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask
-Version: 1.7.0
+Version: 1.7.1
 Summary: A Durable Task Client SDK for Python
 License:     MIT License
         

{durabletask-1.7.0 → durabletask-1.7.1}/durabletask/internal/helpers.py

@@ -3,6 +3,7 @@
 
 import traceback
 from datetime import datetime, timezone
+from typing import Any, cast
 
 from google.protobuf import timestamp_pb2, wrappers_pb2
 
@@ -136,6 +137,59 @@ def new_failure_details(ex: Exception, _visited: set[int] | None = None) -> pb.T
     )
 
 
+def _failure_details_from_core_dict(fd: dict[str, Any]) -> pb.TaskFailureDetails:
+    """Convert a serialized DurableTask.Core ``FailureDetails`` dict to protobuf."""
+    inner = fd.get("InnerFailure")
+    stack_trace = fd.get("StackTrace")
+    return pb.TaskFailureDetails(
+        errorType=str(fd.get("ErrorType") or ""),
+        errorMessage=str(fd.get("ErrorMessage") or ""),
+        stackTrace=get_string_value(str(stack_trace) if stack_trace is not None else None),
+        innerFailure=_failure_details_from_core_dict(cast(dict[str, Any], inner)) if isinstance(inner, dict) else None,
+        isNonRetriable=bool(fd.get("IsNonRetriable", False)),
+    )
+
+
+def entity_response_failure_details(
+        response: dict[str, Any],
+        error_content: Any = None) -> pb.TaskFailureDetails:
+    """Build failure details from a failed legacy-protocol entity ``ResponseMessage``.
+
+    Call this only for responses that :func:`is_entity_error_response` reports as
+    failures. In the WebJobs "old protocol" ``ResponseMessage`` (see
+    ``EntityScheduler/ResponseMessage.cs``), a failed operation serializes the
+    human-readable content into ``result`` while ``exceptionType`` carries only
+    the exception's type name (a presence marker) -- it is *not* the message.
+    This mirrors ``azure-functions-durable-python`` / ``-js``, which read the
+    message from ``result`` and ignore ``exceptionType``'s value.
+
+    Parameters
+    ----------
+    response:
+        The deserialized ``ResponseMessage`` dict.
+    error_content:
+        The already-deserialized ``result`` payload, used as the failure
+        message. A structured ``failureDetails`` object, if present, takes
+        precedence (current-protocol shape).
+    """
+    failure_details = response.get("failureDetails")
+    if isinstance(failure_details, dict):
+        return _failure_details_from_core_dict(cast(dict[str, Any], failure_details))
+    error_type = str(response.get("exceptionType") or "")
+    error_message = "" if error_content is None else str(error_content)
+    return pb.TaskFailureDetails(errorType=error_type, errorMessage=error_message)
+
+
+def is_entity_error_response(response: dict[str, Any]) -> bool:
+    """Return ``True`` if a legacy-protocol entity ``ResponseMessage`` is a failure.
+
+    In the WebJobs "old protocol" a failed operation is marked by the presence of
+    an ``exceptionType`` field (successful responses omit it). Current-protocol
+    payloads may instead carry a structured ``failureDetails`` object.
+    """
+    return "exceptionType" in response or isinstance(response.get("failureDetails"), dict)
+
+
 def new_event_sent_event(event_id: int, instance_id: str, input: str):
     return pb.HistoryEvent(
         eventId=event_id,

{durabletask-1.7.0 → durabletask-1.7.1}/durabletask/payload/store.py

@@ -21,15 +21,15 @@ class LargePayloadStorageOptions:
 
     Attributes:
         threshold_bytes: Payloads larger than this value (in bytes) will
-            be externalized to the payload store.  Defaults to 900,000
-            (900 KB), matching the .NET SDK default.
+            be externalized to the payload store.  Defaults to 262,144
+            (256 KiB), matching the .NET SDK default.
         max_stored_payload_bytes: Maximum payload size (in bytes) that
             can be stored externally.  Payloads exceeding this limit
             will cause an error.  Defaults to 10,485,760 (10 MB).
         enable_compression: When ``True`` (the default), payloads are
             GZip-compressed before uploading.
     """
-    threshold_bytes: int = 900_000
+    threshold_bytes: int = 262_144
     max_stored_payload_bytes: int = 10 * 1024 * 1024  # 10 MB
     enable_compression: bool = True
 

{durabletask-1.7.0 → durabletask-1.7.1}/durabletask/scheduled/models.py

@@ -8,9 +8,15 @@ from typing import Any
 
 from durabletask.internal.helpers import ensure_aware
 from durabletask.scheduled.schedule_status import ScheduleStatus
+from durabletask.serialization import JsonDataConverter
 
 MINIMUM_INTERVAL = timedelta(seconds=1)
 
+# Serializer used to (de)serialize the orchestration input to/from a JSON string
+# for persistence. Matches the .NET SDK, which stores ``OrchestrationInput`` as a
+# string so the Durable Task Scheduler dashboard can read the raw entity state.
+_INPUT_CONVERTER = JsonDataConverter()
+
 
 def _validate_interval(interval: timedelta) -> timedelta:
     if interval <= timedelta(0):
@@ -25,7 +31,15 @@ def _to_iso(value: datetime | None) -> str | None:
 
 
 def _from_iso(value: str | None) -> datetime | None:
-    return datetime.fromisoformat(value) if value else None
+    if not value:
+        return None
+    # .NET serializes ``DateTimeOffset`` with a numeric offset, but tolerate a
+    # trailing ``Z`` so states written by other producers still parse on the
+    # Python versions that predate ``fromisoformat`` accepting ``Z``. Only the
+    # trailing designator is normalized so an interior ``Z`` is left untouched.
+    if value.endswith("Z"):
+        value = value[:-1] + "+00:00"
+    return datetime.fromisoformat(value)
 
 
 def _interval_to_seconds(value: timedelta | None) -> float | None:
@@ -36,6 +50,119 @@ def _interval_from_seconds(value: float | None) -> timedelta | None:
     return timedelta(seconds=value) if value is not None else None
 
 
+# Number of 100-nanosecond ticks per second, matching the .NET ``TimeSpan``
+# resolution used when formatting the fractional component.
+_TICKS_PER_SECOND = 10_000_000
+
+
+def _interval_to_timespan(value: timedelta | None) -> str | None:
+    """Format a ``timedelta`` as a .NET ``TimeSpan`` (``[-][d.]hh:mm:ss[.fffffff]``).
+
+    The Durable Task Scheduler dashboard deserializes the schedule interval into
+    a .NET ``TimeSpan``, whose JSON converter only accepts this constant format.
+    """
+    if value is None:
+        return None
+    negative = value < timedelta(0)
+    value = abs(value)
+    days = value.days
+    hours, remainder = divmod(value.seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    if days:
+        formatted = f"{days}.{hours:02d}:{minutes:02d}:{seconds:02d}"
+    else:
+        formatted = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+    if value.microseconds:
+        ticks = value.microseconds * 10  # microseconds -> 100-ns ticks
+        formatted += f".{ticks:07d}"
+    return f"-{formatted}" if negative else formatted
+
+
+def _interval_from_timespan(value: str) -> timedelta:
+    """Parse a .NET ``TimeSpan`` string (``[-][d.]hh:mm:ss[.fffffff]``)."""
+    text = value.strip()
+    negative = text.startswith("-")
+    if negative:
+        text = text[1:]
+
+    fraction = 0.0
+    if "." in text:
+        head, _, tail = text.rpartition(".")
+        # A dot before the first ``:`` is the day separator, not a fraction.
+        if ":" in tail:
+            # e.g. ``1.02:03:04`` -- the ``.`` separates days from the clock.
+            days_part, _, clock = text.partition(".")
+            days = int(days_part)
+            hours, minutes, seconds = (int(p) for p in clock.split(":"))
+        else:
+            # ``head`` holds ``[d.]hh:mm:ss`` and ``tail`` the ticks fraction.
+            fraction = int(tail.ljust(7, "0")[:7]) / _TICKS_PER_SECOND
+            days, hours, minutes, seconds = _split_clock(head)
+    else:
+        days, hours, minutes, seconds = _split_clock(text)
+
+    result = timedelta(days=days, hours=hours, minutes=minutes,
+                       seconds=seconds) + timedelta(seconds=fraction)
+    return -result if negative else result
+
+
+def _split_clock(text: str) -> tuple[int, int, int, int]:
+    """Split ``[d.]hh:mm:ss`` into ``(days, hours, minutes, seconds)``."""
+    days = 0
+    if "." in text:
+        days_part, _, text = text.partition(".")
+        days = int(days_part)
+    hours, minutes, seconds = (int(part) for part in text.split(":"))
+    return days, hours, minutes, seconds
+
+
+def _get(data: dict[str, Any], *keys: str, default: Any = None) -> Any:
+    """Return the first present key from ``data``.
+
+    Reads tolerate both the .NET-compatible PascalCase keys and the legacy
+    snake_case keys written by earlier Python workers.
+    """
+    for key in keys:
+        if key in data:
+            return data[key]
+    return default
+
+
+def _parse_interval(data: dict[str, Any]) -> timedelta:
+    """Read the interval from either the .NET ``Interval`` or legacy field."""
+    timespan = _get(data, "Interval", "interval")
+    if isinstance(timespan, str):
+        return _interval_from_timespan(timespan)
+    seconds = _get(data, "interval_seconds")
+    if seconds is not None:
+        return timedelta(seconds=seconds)
+    raise KeyError("interval")
+
+
+def _encode_orchestration_input(value: Any) -> str | None:
+    """Serialize the orchestration input to a JSON string for persistence.
+
+    The Durable Task Scheduler dashboard (and the .NET SDK) model the persisted
+    ``OrchestrationInput`` as a string, so the raw input object is serialized to
+    a JSON string here and parsed back by :func:`_decode_orchestration_input`.
+    """
+    if value is None:
+        return None
+    return _INPUT_CONVERTER.serialize(value)
+
+
+def _decode_orchestration_input(value: Any) -> Any:
+    """Reconstruct the raw orchestration input from its persisted JSON string."""
+    if value is None or not isinstance(value, str):
+        return value
+    try:
+        return _INPUT_CONVERTER.deserialize(value)
+    except (ValueError, TypeError):
+        # Not a JSON document (an unexpected shape); return it unchanged rather
+        # than failing to load the schedule.
+        return value
+
+
 @dataclass
 class ScheduleCreationOptions:
     """Options for creating a new schedule."""
@@ -230,29 +357,39 @@ class ScheduleConfiguration:
             raise ValueError("start_at cannot be later than end_at.")
 
     def to_json(self) -> dict[str, Any]:
+        # Serialized with .NET-compatible property names and value shapes so the
+        # Durable Task Scheduler dashboard can deserialize the raw entity state:
+        # PascalCase keys and the interval as a .NET ``TimeSpan`` string.
         return {
-            "schedule_id": self.schedule_id,
-            "orchestration_name": self.orchestration_name,
-            "interval_seconds": self.interval.total_seconds(),
-            "orchestration_input": self.orchestration_input,
-            "orchestration_instance_id": self.orchestration_instance_id,
-            "start_at": _to_iso(self.start_at),
-            "end_at": _to_iso(self.end_at),
-            "start_immediately_if_late": self.start_immediately_if_late,
+            "ScheduleId": self.schedule_id,
+            "OrchestrationName": self.orchestration_name,
+            "Interval": _interval_to_timespan(self.interval),
+            "OrchestrationInput": _encode_orchestration_input(self.orchestration_input),
+            "OrchestrationInstanceId": self.orchestration_instance_id,
+            "StartAt": _to_iso(self.start_at),
+            "EndAt": _to_iso(self.end_at),
+            "StartImmediatelyIfLate": self.start_immediately_if_late,
         }
 
     @classmethod
     def from_json(cls, data: dict[str, Any]) -> "ScheduleConfiguration":
         config = cls(
-            data["schedule_id"],
-            data["orchestration_name"],
-            timedelta(seconds=data["interval_seconds"]),
+            _get(data, "ScheduleId", "schedule_id"),
+            _get(data, "OrchestrationName", "orchestration_name"),
+            _parse_interval(data),
         )
-        config.orchestration_input = data.get("orchestration_input")
-        config.orchestration_instance_id = data.get("orchestration_instance_id")
-        config.start_at = _from_iso(data.get("start_at"))
-        config.end_at = _from_iso(data.get("end_at"))
-        config.start_immediately_if_late = bool(data.get("start_immediately_if_late", False))
+        if "OrchestrationInput" in data:
+            # New .NET-compatible states store the input as a JSON string.
+            config.orchestration_input = _decode_orchestration_input(data["OrchestrationInput"])
+        else:
+            # Legacy states stored the raw (already-parsed) input object.
+            config.orchestration_input = data.get("orchestration_input")
+        config.orchestration_instance_id = _get(
+            data, "OrchestrationInstanceId", "orchestration_instance_id")
+        config.start_at = _from_iso(_get(data, "StartAt", "start_at"))
+        config.end_at = _from_iso(_get(data, "EndAt", "end_at"))
+        config.start_immediately_if_late = bool(
+            _get(data, "StartImmediatelyIfLate", "start_immediately_if_late", default=False))
         return config
 
 
@@ -273,16 +410,18 @@ class ScheduleState:
 
     def to_json(self) -> dict[str, Any]:
         # ``schedule_configuration`` is returned as the object itself; the
-        # serializer recurses into it and fires its own ``to_json`` hook. Only
-        # this type's non-JSON-native leaves (datetimes) are converted here.
+        # serializer recurses into it and fires its own ``to_json`` hook. Keys
+        # and value shapes mirror the .NET ``ScheduleState`` so the Durable Task
+        # Scheduler dashboard can deserialize the raw entity state: PascalCase
+        # names, the status as its numeric ordinal, and datetimes as ISO strings.
         return {
-            "status": self.status.value,
-            "execution_token": self.execution_token,
-            "last_run_at": _to_iso(self.last_run_at),
-            "next_run_at": _to_iso(self.next_run_at),
-            "schedule_created_at": _to_iso(self.schedule_created_at),
-            "schedule_last_modified_at": _to_iso(self.schedule_last_modified_at),
-            "schedule_configuration": self.schedule_configuration,
+            "Status": self.status.to_dotnet_ordinal(),
+            "ExecutionToken": self.execution_token,
+            "LastRunAt": _to_iso(self.last_run_at),
+            "NextRunAt": _to_iso(self.next_run_at),
+            "ScheduleCreatedAt": _to_iso(self.schedule_created_at),
+            "ScheduleLastModifiedAt": _to_iso(self.schedule_last_modified_at),
+            "ScheduleConfiguration": self.schedule_configuration,
         }
 
     @classmethod
@@ -291,15 +430,22 @@ class ScheduleState:
         # ``from_json`` hook directly. ``ScheduleConfiguration`` is an internal
         # type, so there is no need to route it through a (possibly custom)
         # converter -- keeping this hook converter-free means it round-trips
-        # under any code path, not only the worker's threaded converter.
+        # under any code path, not only the worker's threaded converter. Reads
+        # accept both the .NET-compatible and legacy snake_case shapes.
         state = cls()
-        state.status = ScheduleStatus(data["status"])
-        state.execution_token = data["execution_token"]
-        state.last_run_at = _from_iso(data.get("last_run_at"))
-        state.next_run_at = _from_iso(data.get("next_run_at"))
-        state.schedule_created_at = _from_iso(data.get("schedule_created_at"))
-        state.schedule_last_modified_at = _from_iso(data.get("schedule_last_modified_at"))
-        config_data = data.get("schedule_configuration")
+        state.status = ScheduleStatus.from_dotnet(_get(data, "Status", "status"))
+        # Preserve the token generated by ``__init__`` when the field is absent;
+        # overwriting it with ``None`` would make every ``run_schedule`` signal
+        # look stale and silently stop the schedule.
+        token = _get(data, "ExecutionToken", "execution_token")
+        if token is not None:
+            state.execution_token = token
+        state.last_run_at = _from_iso(_get(data, "LastRunAt", "last_run_at"))
+        state.next_run_at = _from_iso(_get(data, "NextRunAt", "next_run_at"))
+        state.schedule_created_at = _from_iso(_get(data, "ScheduleCreatedAt", "schedule_created_at"))
+        state.schedule_last_modified_at = _from_iso(
+            _get(data, "ScheduleLastModifiedAt", "schedule_last_modified_at"))
+        config_data = _get(data, "ScheduleConfiguration", "schedule_configuration")
         state.schedule_configuration = (
             ScheduleConfiguration.from_json(config_data) if config_data is not None else None)
         return state

durabletask-1.7.1/durabletask/scheduled/schedule_status.py

@@ -0,0 +1,66 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from enum import Enum
+
+
+class ScheduleStatus(str, Enum):
+    """Represents the current status of a schedule."""
+
+    UNINITIALIZED = "Uninitialized"
+    """Schedule has not been created."""
+
+    ACTIVE = "Active"
+    """Schedule is active and running."""
+
+    PAUSED = "Paused"
+    """Schedule is paused."""
+
+    def to_dotnet_ordinal(self) -> int:
+        """Return the numeric value used by the .NET ``ScheduleStatus`` enum.
+
+        The Durable Task Scheduler dashboard reads the persisted entity state
+        with ``System.Text.Json`` (Web defaults, no string-enum converter), so
+        the status must be serialized as the enum's ordinal rather than its
+        name. The ordinals match the .NET SDK order (``Uninitialized`` = 0,
+        ``Active`` = 1, ``Paused`` = 2).
+        """
+        return _STATUS_TO_ORDINAL[self]
+
+    @classmethod
+    def from_dotnet(cls, value: "int | str | None") -> "ScheduleStatus":
+        """Reconstruct a status from a persisted value.
+
+        Accepts the numeric ordinal written by the .NET-compatible serializer
+        as well as the legacy string name (e.g. ``"Active"``) so that states
+        persisted by older Python workers still round-trip.
+        """
+        if isinstance(value, bool):
+            # ``bool`` is a subclass of ``int``; reject it explicitly so a
+            # stray boolean cannot be misread as an ordinal.
+            return cls.UNINITIALIZED
+        if isinstance(value, int):
+            return _ORDINAL_TO_STATUS.get(value, cls.UNINITIALIZED)
+        if isinstance(value, str):
+            text = value.strip()
+            if text.isdigit():
+                return _ORDINAL_TO_STATUS.get(int(text), cls.UNINITIALIZED)
+            for member in cls:
+                if member.value.lower() == text.lower():
+                    return member
+            # The .NET Scheduler client names the zero value "Unknown"; treat
+            # it as the equivalent uninitialized state.
+            if text.lower() == "unknown":
+                return cls.UNINITIALIZED
+        return cls.UNINITIALIZED
+
+
+_STATUS_TO_ORDINAL: dict["ScheduleStatus", int] = {
+    ScheduleStatus.UNINITIALIZED: 0,
+    ScheduleStatus.ACTIVE: 1,
+    ScheduleStatus.PAUSED: 2,
+}
+
+_ORDINAL_TO_STATUS: dict[int, "ScheduleStatus"] = {
+    ordinal: status for status, ordinal in _STATUS_TO_ORDINAL.items()
+}

{durabletask-1.7.0 → durabletask-1.7.1}/durabletask/task.py

@@ -38,6 +38,22 @@ class OrchestrationContext(ABC):
         """
         pass
 
+    @property
+    @abstractmethod
+    def parent_instance_id(self) -> str | None:
+        """Get the ID of the parent orchestration instance.
+
+        For a sub-orchestration, this is the instance ID of the orchestration
+        that scheduled it. For a top-level orchestration, this is ``None``.
+
+        Returns
+        -------
+        str | None
+            The parent orchestration instance ID, or ``None`` if this
+            orchestration was not scheduled by a parent orchestration.
+        """
+        pass
+
     @property
     @abstractmethod
     def version(self) -> str | None:

{durabletask-1.7.0 → durabletask-1.7.1}/durabletask/worker.py

@@ -1483,6 +1483,7 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
         self._registry = registry
         self._entity_context = OrchestrationEntityContext(instance_id)
         self._version: str | None = None
+        self._parent_instance_id: str | None = None
         self._completion_status: pb.OrchestrationStatus | None = None
         self._received_events: dict[str, list[str | None]] = {}
         self._pending_events: dict[str, list[task.CancellableTask[Any]]] = {}
@@ -1638,6 +1639,10 @@ class _RuntimeOrchestrationContext(task.OrchestrationContext):
     def version(self) -> str | None:
         return self._version
 
+    @property
+    def parent_instance_id(self) -> str | None:
+        return self._parent_instance_id
+
     @property
     def current_utc_datetime(self) -> datetime:
         return self._current_utc_datetime
@@ -2222,6 +2227,16 @@ class _OrchestrationExecutor:
                 if event.executionStarted.version:
                     ctx._version = event.executionStarted.version.value  # pyright: ignore[reportPrivateUsage]
 
+                # Store the parent orchestration instance ID (set for
+                # sub-orchestrations; absent for top-level orchestrations)
+                if (
+                        event.executionStarted.HasField("parentInstance")
+                        and event.executionStarted.parentInstance.HasField("orchestrationInstance")
+                ):
+                    ctx._parent_instance_id = (  # pyright: ignore[reportPrivateUsage]
+                        event.executionStarted.parentInstance.orchestrationInstance.instanceId
+                    )
+
                 # Store the parent trace context for propagation to child tasks
                 if event.executionStarted.HasField("parentTraceContext"):
                     ctx._parent_trace_context = event.executionStarted.parentTraceContext  # pyright: ignore[reportPrivateUsage]
@@ -2573,10 +2588,10 @@ class _OrchestrationExecutor:
                     raise TypeError("Unexpected sub-orchestration task type")
             elif event.HasField("eventRaised"):
                 if event.eventRaised.name in ctx._entity_task_id_map:  # pyright: ignore[reportPrivateUsage]
-                    entity_id, operation, task_id = ctx._entity_task_id_map.get(event.eventRaised.name, (None, None, None))  # pyright: ignore[reportPrivateUsage]
-                    self._handle_entity_event_raised(ctx, event, entity_id, task_id, False)
+                    entity_id, operation, task_id = ctx._entity_task_id_map.pop(event.eventRaised.name, (None, None, None))  # pyright: ignore[reportPrivateUsage]
+                    self._handle_entity_event_raised(ctx, event, entity_id, task_id, False, operation)
                 elif event.eventRaised.name in ctx._entity_lock_task_id_map:  # pyright: ignore[reportPrivateUsage]
-                    entity_id, task_id = ctx._entity_lock_task_id_map.get(event.eventRaised.name, (None, None))  # pyright: ignore[reportPrivateUsage]
+                    entity_id, task_id = ctx._entity_lock_task_id_map.pop(event.eventRaised.name, (None, None))  # pyright: ignore[reportPrivateUsage]
                     self._handle_entity_event_raised(ctx, event, entity_id, task_id, True)
                 else:
                     # event names are case-insensitive
@@ -2803,7 +2818,8 @@ class _OrchestrationExecutor:
                                     event: pb.HistoryEvent,
                                     entity_id: EntityInstanceId | None,
                                     task_id: int | None,
-                                    is_lock_event: bool):
+                                    is_lock_event: bool,
+                                    operation: str | None = None):
         # This eventRaised represents the result of an entity operation after being translated to the old
         # entity protocol by the Durable WebJobs extension
         if entity_id is None:
@@ -2813,16 +2829,38 @@ class _OrchestrationExecutor:
         entity_task = ctx._pending_tasks.pop(task_id, None)  # pyright: ignore[reportPrivateUsage]
         if not entity_task:
             raise RuntimeError(f"Could not retrieve entity task for entity-related eventRaised with ID '{event.eventId}'")
-        result = None
+        response: dict[str, Any] | None = None
         if not ph.is_empty(event.eventRaised.input):
-            # TODO: Investigate why the event result is wrapped in a dict with "result" key
-            # The expected type applies to the unwrapped result value, not the
-            # transport wrapper. Unwrap first, then coerce the already-parsed
-            # inner value to the expected type via the converter (no redundant
-            # re-serialization round-trip).
-            unwrapped = self._data_converter.deserialize(event.eventRaised.input.value)["result"]
-            result = self._data_converter.coerce(
-                unwrapped,
+            response = self._data_converter.deserialize(event.eventRaised.input.value)
+
+        # For entity operation calls (lock acquisitions never fail this way), the legacy WebJobs
+        # "old protocol" ResponseMessage signals a failed operation via the presence of an
+        # "exceptionType" marker (or a structured "failureDetails" object). The human-readable
+        # message lives in the *serialized* "result" field -- "exceptionType" is only the exception
+        # type name, not the message -- so deserialize "result" to recover it, matching
+        # azure-functions-durable-python / -js. Propagate as a task failure so an awaiting
+        # call_entity raises, like the current entity protocol and the .NET SDK.
+        if not is_lock_event and isinstance(response, dict) and ph.is_entity_error_response(response):
+            raw_result = response.get("result")
+            error_content = (
+                self._data_converter.deserialize(raw_result) if isinstance(raw_result, str) else raw_result
+            )
+            failure_details = ph.entity_response_failure_details(response, error_content)
+            failure = EntityOperationFailedException(entity_id, operation or "", failure_details)
+            ctx._entity_context.recover_lock_after_call(entity_id)  # pyright: ignore[reportPrivateUsage]
+            entity_task.fail(str(failure), failure)
+            ctx.resume()
+            return
+
+        result = None
+        if response is not None:
+            # The legacy protocol wraps the result as {"result": <serialized>},
+            # where the value is a serialized JSON string (like the new protocol's
+            # entityOperationCompleted.output). Deserialize it -- not coerce -- so
+            # the value is fully parsed and the expected type applied; coercing
+            # would skip JSON parsing and leave it double-encoded (e.g. '"done"').
+            result = self._data_converter.deserialize(
+                response["result"],
                 entity_task._expected_type,  # pyright: ignore[reportPrivateUsage]
             )
         if is_lock_event:

{durabletask-1.7.0 → durabletask-1.7.1}/durabletask.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask
-Version: 1.7.0
+Version: 1.7.1
 Summary: A Durable Task Client SDK for Python
 License:     MIT License
         

{durabletask-1.7.0 → durabletask-1.7.1}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durabletask"
-version = "1.7.0"
+version = "1.7.1"
 description = "A Durable Task Client SDK for Python"
 keywords = [
     "durable",

durabletask-1.7.0/durabletask/scheduled/schedule_status.py

@@ -1,17 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-
-from enum import Enum
-
-
-class ScheduleStatus(str, Enum):
-    """Represents the current status of a schedule."""
-
-    UNINITIALIZED = "Uninitialized"
-    """Schedule has not been created."""
-
-    ACTIVE = "Active"
-    """Schedule is active and running."""
-
-    PAUSED = "Paused"
-    """Schedule is paused."""