Serialization compat, fix typing, working again

Author: andystaples

azure-functions-durable/azure/durable_functions/__init__.py

@@ -1,15 +1,10 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
-from .internal.functions_json import install_custom_serialization
 from .decorators.durable_app import Blueprint, DFApp
 from .client import DurableFunctionsClient
 from .orchestrator import Orchestrator
 
-# Ensure the durabletask JSON encoder/decoder is replaced as soon as the
-# durable_functions package is imported.
-install_custom_serialization()
-
 # IMPORTANT: DO NOT REMOVE. `azure-functions` relies on the presence and value of this variable
 # for version detection
 version = "2.x"

azure-functions-durable/azure/durable_functions/client.py

@@ -9,6 +9,7 @@
 
 from durabletask.client import TaskHubGrpcClient
 from .internal.azurefunctions_grpc_interceptor import AzureFunctionsDefaultClientInterceptorImpl
+from .internal.serialization import DEFAULT_FUNCTIONS_DATA_CONVERTER
 from .http import HttpManagementPayload
 
 
@@ -52,7 +53,8 @@ def __init__(self, client_as_string: str):
             host_address=self.rpcBaseUrl,
             secure_channel=False,
             metadata=None,
-            interceptors=interceptors)
+            interceptors=interceptors,
+            data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER)
 
     def _parse_client_configuration(self, client_as_string: str) -> None:
         """Parses the client configuration JSON string and sets instance variables.

azure-functions-durable/azure/durable_functions/decorators/durable_app.py

@@ -4,6 +4,7 @@
 from functools import wraps
 from typing import Any, Callable, Optional, Union
 
+import azure.functions as func
 from azure.functions import FunctionRegister, TriggerApi, BindingApi, AuthLevel
 from azure.functions.decorators.function_app import FunctionBuilder
 
@@ -95,7 +96,12 @@ def decorator(entity_func: task.Entity[Any, Any]) -> FunctionBuilder:
             # TODO: Because this handle method is the one actually exposed to the Functions SDK decorator,
             #       the parameter name will always be "context" here, even if the user specified a different name.
             #       We need to find a way to allow custom context names (like "ctx").
-            def handle(context: Any) -> str:
+            # The generated handle is what the Azure Functions host registers,
+            # so its ``context`` parameter must be annotated with
+            # ``azure.functions.EntityContext`` for the host's entityTrigger
+            # binding converter to accept it; at runtime the host passes that
+            # transport context (exposing ``.body``).
+            def handle(context: func.EntityContext) -> str:
                 return DurableFunctionsWorker().execute_entity_batch_request(entity_func, context)
 
             handle.entity_function = entity_func  # pyright: ignore[reportFunctionMemberAccess]

azure-functions-durable/azure/durable_functions/internal/functions_json.py

@@ -0,0 +1,118 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Azure Functions payload serialization for Durable Task.
+
+Bridges durabletask's pluggable :class:`~durabletask.serialization.DataConverter`
+to the azure-functions SDK's centralized ``df_dumps`` / ``df_loads`` serializers
+so that payloads round-trip through the **exact** wire format the Durable
+Functions host extension (and the SDK's ``ActivityTriggerConverter``) expect:
+builtins as plain JSON, custom objects wrapped in the
+``{"__class__", "__module__", "__data__"}`` envelope via their ``to_json`` /
+``from_json`` hooks.
+
+When the installed ``azure-functions`` package exposes ``df_dumps`` / ``df_loads``
+(centralized serializers with optional type validation and strict-typing
+support), they are used directly. On older releases that lack them we fall back
+to the legacy ``_serialize_custom_object`` / ``_deserialize_custom_object`` hooks
+-- the same behavior the SDK converter uses in those versions -- keeping both
+sides symmetric. The wire format is unchanged either way.
+"""
+
+from __future__ import annotations
+
+import importlib
+import json
+import logging
+from typing import Any, Callable, Optional, cast
+
+from durabletask.serialization import JsonDataConverter
+
+logger = logging.getLogger("azure.functions.DurableFunctions")
+
+# ``azure.functions`` only exposes its Durable serialization helpers from a
+# private, untyped module. Resolve it dynamically and bind the symbols we need
+# to locally-typed callables so the rest of the module stays type-checked.
+_df_internal = importlib.import_module("azure.functions._durable_functions")
+_serialize_custom_object: Callable[[Any], Any] = getattr(
+    _df_internal, "_serialize_custom_object")
+_deserialize_custom_object: Callable[[dict[str, Any]], Any] = getattr(
+    _df_internal, "_deserialize_custom_object")
+
+_FALLBACK_MESSAGE = (
+    "The installed 'azure-functions' package does not provide the centralized "
+    "'df_dumps' / 'df_loads' serializers. Durable Functions is falling back to "
+    "the legacy serialization pipeline; the wire format is unchanged, but "
+    "payload type validation (the 'expected_type' argument and strict typing "
+    "mode) is unavailable. Upgrade to azure-functions>=1.26.0b4 to enable "
+    "type-validated serialization."
+)
+
+_warned = False
+
+
+def _warn_fallback_once() -> None:
+    # Deferred to first use (debug level) rather than emitted at import time, so
+    # users who never exercise the fallback path are not spammed.
+    global _warned
+    if not _warned:
+        _warned = True
+        logger.debug(_FALLBACK_MESSAGE)
+
+
+def _fallback_df_dumps(value: Any) -> str:
+    """Serialize ``value`` via the legacy custom-object hook."""
+    _warn_fallback_once()
+    return json.dumps(value, default=_serialize_custom_object)
+
+
+def _fallback_df_loads(s: str, expected_type: Optional[type] = None) -> Any:
+    """Deserialize ``s`` via the legacy custom-object hook.
+
+    ``expected_type`` is accepted for call-site compatibility but ignored on
+    this fallback path; type validation is only performed by the SDK's
+    ``df_loads`` when it is available.
+    """
+    _warn_fallback_once()
+    return json.loads(s, object_hook=_deserialize_custom_object)
+
+
+# Prefer the SDK's centralized serializers; fall back to the legacy hooks when
+# they are unavailable (older azure-functions releases).
+_sdk_df_dumps = getattr(_df_internal, "df_dumps", None)
+_sdk_df_loads = getattr(_df_internal, "df_loads", None)
+
+df_dumps: Callable[[Any], str] = (
+    cast("Callable[[Any], str]", _sdk_df_dumps)
+    if callable(_sdk_df_dumps) else _fallback_df_dumps)
+df_loads: Callable[..., Any] = (
+    cast("Callable[..., Any]", _sdk_df_loads)
+    if callable(_sdk_df_loads) else _fallback_df_loads)
+
+
+class FunctionsDataConverter(JsonDataConverter):
+    """:class:`DataConverter` that serializes via azure-functions' codec.
+
+    Overrides only the string boundary (:meth:`serialize` / :meth:`deserialize`)
+    to route through ``df_dumps`` / ``df_loads`` -- producing the
+    ``{"__class__", "__module__", "__data__"}`` envelope that the Durable
+    Functions host expects -- while inheriting :class:`JsonDataConverter`'s
+    value-level :meth:`coerce` and reconstruction policy
+    (:meth:`can_reconstruct`), which operate on already-parsed values and are
+    wire-format agnostic.
+    """
+
+    def serialize(self, value: Any) -> str | None:
+        if value is None:
+            return None
+        return df_dumps(value)
+
+    def deserialize(self, data: str | None, target_type: type | None = None) -> Any:
+        if data is None or data == "":
+            return None
+        return df_loads(data, target_type)
+
+
+# Shared instance: the converter is stateless, so a single instance is reused
+# across the per-invocation worker/client objects.
+DEFAULT_FUNCTIONS_DATA_CONVERTER: FunctionsDataConverter = FunctionsDataConverter()

azure-functions-durable/azure/durable_functions/internal/serialization.py

@@ -5,6 +5,8 @@
 """
 from typing import Any, Callable, Generator
 
+import azure.functions as func
+
 from durabletask.task import OrchestrationContext
 
 from .worker import DurableFunctionsWorker
@@ -27,13 +29,16 @@ def __init__(self,
         """
         self.fn: Callable[[OrchestrationContext, Any], Generator[Any, Any, Any]] = activity_func
 
-    def handle(self, context: OrchestrationContext) -> str:
+    def handle(self, context: func.OrchestrationContext) -> str:
         """Handle the orchestration of the user defined generator function.
 
         Parameters
         ----------
-        context : DurableOrchestrationContext
-            The DF orchestration context
+        context : azure.functions.OrchestrationContext
+            The Durable Functions orchestration trigger context. This is the
+            transport wrapper supplied by the host (it exposes ``.body``); the
+            user's orchestrator function receives a durabletask
+            ``OrchestrationContext`` during execution inside the worker.
 
         Returns
         -------
@@ -60,7 +65,12 @@ def create(cls, fn: Callable[[OrchestrationContext, Any], Generator[Any, Any, An
             Handle function of the newly created orchestration client
         """
 
-        def handle(context: Any) -> str:
+        # The generated handle is the function registered with the Azure
+        # Functions host. Its ``context`` parameter must be annotated with
+        # ``azure.functions.OrchestrationContext`` so the host's
+        # orchestrationTrigger binding converter accepts it; at runtime the
+        # host passes that transport context (exposing ``.body``).
+        def handle(context: func.OrchestrationContext) -> str:
             return Orchestrator(fn).handle(context)
 
         handle.orchestrator_function = fn  # pyright: ignore[reportFunctionMemberAccess]

azure-functions-durable/azure/durable_functions/orchestrator.py

@@ -14,6 +14,7 @@
 )
 from durabletask.worker import TaskHubGrpcWorker
 from .internal.azurefunctions_null_stub import AzureFunctionsNullStub
+from .internal.serialization import DEFAULT_FUNCTIONS_DATA_CONVERTER
 
 
 # Worker class used for Durable Task Scheduler (DTS)
@@ -30,7 +31,11 @@ def __init__(self) -> None:
         # concurrency options, payload store, etc.) that the inherited
         # ``_execute_*`` methods rely on; work items are delivered directly by
         # the methods below rather than streamed from a sidecar.
-        super().__init__()
+        #
+        # The Functions converter routes payload serialization through the
+        # azure-functions codec (df_dumps/df_loads) so user types round-trip in
+        # the wire format the Durable Functions host extension expects.
+        super().__init__(data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER)
 
     def add_named_orchestrator(self, name: str, func: task.Orchestrator[Any, Any]) -> None:
         self._registry.add_named_orchestrator(name, func)

azure-functions-durable/azure/durable_functions/worker.py

@@ -29,7 +29,7 @@ readme = "README.md"
 dependencies = [
     "durabletask>=1.2.0dev0",
     "azure-identity>=1.19.0",
-    "azure-functions>=1.25.0b3.dev1"
+    "azure-functions>=2.2.0b6"
 ]
 
 [project.urls]