More compat layer stuff

Author: andystaples

azure-functions-durable/CHANGELOG.md

@@ -23,6 +23,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   (`output`, `input`, `customStatus`) as their raw JSON representation instead
   of reconstructed Python objects, so the result is always JSON-serializable
   even when payloads are custom types.
+- Restored v1 members that were missing on the compatibility types, avoiding
+  `AttributeError`/`TypeError` for existing code that used them:
+  - `create_http_management_payload(...)` now returns a `dict`-based
+    `HttpManagementPayload`, so `json.dumps(payload)` works directly again.
+  - `RetryOptions.to_json()` returns the v1
+    `firstRetryIntervalInMilliseconds`/`maxNumberOfAttempts` dictionary, and the
+    `first_retry_interval_in_milliseconds` / `max_number_of_attempts` getters
+    remain available.
+  - `DurableOrchestrationStatus.from_json(...)` reconstructs a status from its
+    `to_json()` representation (or the equivalent v1 JSON schema).
+  - `PurgeHistoryResult.from_json(...)` reconstructs a result from its v1 JSON
+    representation.
+  - `DurableOrchestrationContext.version` returns the orchestration instance
+    version (or `None`).
 
 ### Added
 
@@ -103,11 +117,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `create_http_management_payload` now accepts either the durabletask
   `(request, instance_id)` signature or the v1 `(instance_id)` signature for
   backwards compatibility.
-- `HttpManagementPayload` now supports mapping-style access
+- `HttpManagementPayload` now subclasses `dict`, so it is directly
+  JSON-serializable via `json.dumps(payload)` and supports mapping-style access
   (`payload["statusQueryGetUri"]`, iteration, `in`, `keys()`/`items()`/`values()`)
   so v1 code that treated the payload as a `dict` keeps working.
 
-
 ## v0.1.0
 
 - Initial implementation

azure-functions-durable/azure/durable_functions/http/http_management_payload.py

@@ -2,18 +2,20 @@
 # Licensed under the MIT License.
 
 import json
-from collections.abc import Iterator
+from typing import Any
 
 
-class HttpManagementPayload:
+class HttpManagementPayload(dict[str, str]):
     """A class representing the HTTP management payload for a Durable Function orchestration instance.
 
     Contains URLs for managing the instance, such as querying status,
     sending events, terminating, restarting, etc.
 
-    Supports mapping-style access (``payload["statusQueryGetUri"]``, iteration,
-    ``in``, ``.keys()``/``.items()``/``.values()``) for backwards compatibility
-    with the v1 API, which returned a plain ``dict``.
+    Subclasses ``dict`` for backwards compatibility with the v1 API, which
+    returned a plain ``dict``. As a result the payload supports mapping-style
+    access (``payload["statusQueryGetUri"]``, iteration, ``in``,
+    ``.keys()``/``.items()``/``.values()``) and is directly JSON-serializable
+    via ``json.dumps(payload)``.
     """
 
     def __init__(self, instance_id: str, instance_status_url: str, required_query_string_parameters: str):
@@ -24,7 +26,7 @@ def __init__(self, instance_id: str, instance_status_url: str, required_query_st
             instance_status_url (str): The base URL for the instance status.
             required_query_string_parameters (str): The required URL parameters provided by the Durable extension.
         """
-        self.urls = {
+        super().__init__({
             'id': instance_id,
             'purgeHistoryDeleteUri': instance_status_url + "?" + required_query_string_parameters,
             'restartPostUri': instance_status_url + "/restart?" + required_query_string_parameters,
@@ -33,31 +35,16 @@ def __init__(self, instance_id: str, instance_status_url: str, required_query_st
             'terminatePostUri': instance_status_url + "/terminate?reason={text}&" + required_query_string_parameters,
             'resumePostUri': instance_status_url + "/resume?reason={text}&" + required_query_string_parameters,
             'suspendPostUri': instance_status_url + "/suspend?reason={text}&" + required_query_string_parameters
-        }
+        })
 
-    def __str__(self):
-        return json.dumps(self.urls)
+    def __str__(self) -> str:
+        return json.dumps(self)
 
-    def __getitem__(self, key: str) -> str:
-        return self.urls[key]
+    @property
+    def urls(self) -> dict[str, Any]:
+        """Return the management URLs as a plain ``dict`` (v1 compatibility)."""
+        return dict(self)
 
-    def __iter__(self) -> Iterator[str]:
-        return iter(self.urls)
-
-    def __len__(self) -> int:
-        return len(self.urls)
-
-    def __contains__(self, key: object) -> bool:
-        return key in self.urls
-
-    def keys(self):
-        """Return the management URL keys."""
-        return self.urls.keys()
-
-    def items(self):
-        """Return the management URL (key, value) pairs."""
-        return self.urls.items()
-
-    def values(self):
-        """Return the management URL values."""
-        return self.urls.values()
+    def to_json(self) -> dict[str, Any]:
+        """Return the management URLs as a plain ``dict``."""
+        return dict(self)

azure-functions-durable/azure/durable_functions/internal/compat/durable_orchestration_status.py

@@ -3,13 +3,14 @@
 
 import json
 from datetime import datetime
-from typing import Any, Optional
+from typing import Any, Optional, cast
 
-from durabletask.client import OrchestrationState
+from durabletask.client import OrchestrationState, OrchestrationStatus
 
 from .orchestration_runtime_status import (
     OrchestrationRuntimeStatus,
     from_durabletask_status,
+    to_durabletask_status,
 )
 
 
@@ -35,6 +36,43 @@ def from_orchestration_state(
         """Wrap a durabletask ``OrchestrationState`` (or ``None``)."""
         return cls(state)
 
+    @classmethod
+    def from_json(cls, json_obj: Any) -> "DurableOrchestrationStatus":
+        """Reconstruct a status from its v1 JSON representation.
+
+        Accepts the dictionary produced by :meth:`to_json` (or the equivalent v1
+        schema); a JSON string is parsed first. The wrapped
+        ``OrchestrationState`` is rebuilt so the resulting object exposes the
+        same attribute surface as one returned by the client.
+        """
+        if isinstance(json_obj, str):
+            json_obj = json.loads(json_obj)
+        data = dict(json_obj)
+
+        runtime_status = data.get("runtimeStatus")
+        dt_status = (
+            to_durabletask_status(OrchestrationRuntimeStatus(runtime_status))
+            if runtime_status is not None else None)
+
+        def _parse_datetime(value: Any) -> Any:
+            return datetime.fromisoformat(value) if isinstance(value, str) else value
+
+        def _reserialize(value: Any) -> Optional[str]:
+            return None if value is None else json.dumps(value)
+
+        state = OrchestrationState(
+            instance_id=cast(str, data.get("instanceId")),
+            name=cast(str, data.get("name")),
+            runtime_status=cast(OrchestrationStatus, dt_status),
+            created_at=cast(datetime, _parse_datetime(data.get("createdTime"))),
+            last_updated_at=cast(datetime, _parse_datetime(data.get("lastUpdatedTime"))),
+            serialized_input=_reserialize(data.get("input")),
+            serialized_output=_reserialize(data.get("output")),
+            serialized_custom_status=_reserialize(data.get("customStatus")),
+            failure_details=None,
+        )
+        return cls(state)
+
     def __bool__(self) -> bool:
         return self._state is not None
 

azure-functions-durable/azure/durable_functions/internal/compat/orchestration_context.py

@@ -81,6 +81,11 @@ def will_continue_as_new(self) -> bool:
         """Whether :meth:`continue_as_new` has been called in this execution."""
         return self._will_continue_as_new
 
+    @property
+    def version(self) -> Optional[str]:
+        """Get the version assigned to the orchestration instance (or ``None``)."""
+        return self._ctx.version
+
     @property
     def parent_instance_id(self) -> str:
         """Get the ID of the parent orchestration.

azure-functions-durable/azure/durable_functions/internal/compat/purge_history_result.py

@@ -1,6 +1,8 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
+from typing import Any
+
 from durabletask.client import PurgeInstancesResult
 
 
@@ -21,6 +23,11 @@ def from_purge_result(cls, result: PurgeInstancesResult) -> "PurgeHistoryResult"
         """Wrap a durabletask ``PurgeInstancesResult``."""
         return cls(result.deleted_instance_count)
 
+    @classmethod
+    def from_json(cls, json_obj: "dict[str, Any]") -> "PurgeHistoryResult":
+        """Reconstruct a result from its v1 JSON representation."""
+        return cls(instances_deleted=json_obj["instancesDeleted"])
+
     @property
     def instances_deleted(self) -> int:
         """Get the number of deleted instances."""

azure-functions-durable/azure/durable_functions/internal/compat/retry_options.py

@@ -44,3 +44,10 @@ def __init__(
     def first_retry_interval_in_milliseconds(self) -> int:
         """Get the first retry interval, in milliseconds."""
         return int(self.first_retry_interval / timedelta(milliseconds=1))
+
+    def to_json(self) -> dict[str, int]:
+        """Return the v1 JSON representation of these retry options."""
+        return {
+            "firstRetryIntervalInMilliseconds": self.first_retry_interval_in_milliseconds,
+            "maxNumberOfAttempts": self.max_number_of_attempts,
+        }