Use the async client (match old behavior)

Author: andystaples

azure-functions-durable/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+### Changed
+
+- `DurableFunctionsClient` is now an async client. Its orchestration and entity
+  management methods (e.g. `schedule_new_orchestration`, `get_orchestration_state`,
+  `wait_for_orchestration_completion`) are now coroutines and must be awaited.
+  This aligns the client with the async API surface of the V1
+  `DurableOrchestrationClient`.
+
 ## v0.1.0
 
 - Initial implementation

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

@@ -7,17 +7,17 @@
 import azure.functions as func
 from urllib.parse import urlparse, quote
 
-from durabletask.client import TaskHubGrpcClient
-from .internal.azurefunctions_grpc_interceptor import AzureFunctionsDefaultClientInterceptorImpl
+from durabletask.client import AsyncTaskHubGrpcClient
+from .internal.azurefunctions_grpc_interceptor import AzureFunctionsAsyncDefaultClientInterceptorImpl
 from .internal.serialization import DEFAULT_FUNCTIONS_DATA_CONVERTER
 from .http import HttpManagementPayload
 
 
 # Client class used for Durable Functions
-class DurableFunctionsClient(TaskHubGrpcClient):
+class DurableFunctionsClient(AsyncTaskHubGrpcClient):
     """A gRPC client passed to Durable Functions durable client bindings.
 
-    Connects to the Durable Functions runtime using gRPC and provides methods
+    Connects to the Durable Functions runtime using async gRPC and provides methods
     for creating and managing Durable orchestrations, interacting with Durable entities,
     and creating HTTP management payloads and check status responses for use with Durable Functions invocations.
     """
@@ -45,7 +45,7 @@ def __init__(self, client_as_string: str):
         """
         self._parse_client_configuration(client_as_string)
 
-        interceptors = [AzureFunctionsDefaultClientInterceptorImpl(self.taskHubName, self.requiredQueryStringParameters)]
+        interceptors = [AzureFunctionsAsyncDefaultClientInterceptorImpl(self.taskHubName, self.requiredQueryStringParameters)]
 
         # We pass in None for the metadata so we don't construct an additional interceptor in the parent class
         # Since the parent class doesn't use anything metadata for anything else, we can set it as None

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

@@ -3,7 +3,24 @@
 
 from importlib.metadata import version
 
-from durabletask.internal.grpc_interceptor import DefaultClientInterceptorImpl
+from durabletask.internal.grpc_interceptor import (
+    DefaultAsyncClientInterceptorImpl,
+    DefaultClientInterceptorImpl,
+)
+
+
+def _build_metadata(taskhub_name: str) -> list[tuple[str, str]]:
+    """Build the gRPC metadata headers sent on every Durable Functions call."""
+    try:
+        # Get the version of the azurefunctions package
+        sdk_version = version('durabletask-azurefunctions')
+    except Exception:
+        # Fallback if version cannot be determined
+        sdk_version = "unknown"
+    user_agent = f"durabletask-python/{sdk_version}"
+    return [
+        ("taskhub", taskhub_name),
+        ("x-user-agent", user_agent)]  # 'user-agent' is a reserved header in grpc, so we use 'x-user-agent' instead
 
 
 class AzureFunctionsDefaultClientInterceptorImpl(DefaultClientInterceptorImpl):
@@ -14,14 +31,18 @@ class AzureFunctionsDefaultClientInterceptorImpl(DefaultClientInterceptorImpl):
 
     def __init__(self, taskhub_name: str, required_query_string_parameters: str):
         self.required_query_string_parameters = required_query_string_parameters
-        try:
-            # Get the version of the azurefunctions package
-            sdk_version = version('durabletask-azurefunctions')
-        except Exception:
-            # Fallback if version cannot be determined
-            sdk_version = "unknown"
-        user_agent = f"durabletask-python/{sdk_version}"
-        self._metadata = [
-            ("taskhub", taskhub_name),
-            ("x-user-agent", user_agent)]  # 'user-agent' is a reserved header in grpc, so we use 'x-user-agent' instead
+        self._metadata = _build_metadata(taskhub_name)
+        super().__init__(self._metadata)
+
+
+class AzureFunctionsAsyncDefaultClientInterceptorImpl(DefaultAsyncClientInterceptorImpl):
+    """Async version of AzureFunctionsDefaultClientInterceptorImpl for use with grpc.aio channels.
+
+    This class implements async gRPC interceptors to add Durable Functions headers
+    (task hub name and user agent) to all async calls."""
+    required_query_string_parameters: str
+
+    def __init__(self, taskhub_name: str, required_query_string_parameters: str):
+        self.required_query_string_parameters = required_query_string_parameters
+        self._metadata = _build_metadata(taskhub_name)
         super().__init__(self._metadata)