Fix Functions client typing

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 76f2163a-0773-4889-b627-1bd4e5c7bea0

Author: andystaples

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

@@ -499,6 +499,17 @@ def _create_http_response(status_code: int, body: Union[str, Any]) -> func.HttpR
 class SyncDurableFunctionsClient(TaskHubGrpcClient):
     """Synchronous durable client supplied by a Functions durable-client binding."""
 
+    taskHubName: str
+    connectionName: str
+    creationUrls: dict[str, str]
+    managementUrls: dict[str, str]
+    baseUrl: str
+    requiredQueryStringParameters: str
+    rpcBaseUrl: str
+    httpBaseUrl: str
+    maxGrpcMessageSizeInBytes: int
+    grpcHttpClientTimeout: timedelta | str
+
     def __init__(self, client_as_string: str):
         self._parse_client_configuration(client_as_string)
         interceptors = [AzureFunctionsDefaultClientInterceptorImpl(
@@ -516,8 +527,61 @@ def __init__(self, client_as_string: str):
             channel_options=channel_options,
             data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER)
 
-    _parse_client_configuration = DurableFunctionsClient._parse_client_configuration
-    create_check_status_response = DurableFunctionsClient.create_check_status_response
-    create_http_management_payload = DurableFunctionsClient.create_http_management_payload
-    _get_client_response_links = DurableFunctionsClient._get_client_response_links
-    _get_instance_status_url = DurableFunctionsClient._get_instance_status_url
+    def _parse_client_configuration(self, client_as_string: str) -> None:
+        client = json.loads(client_as_string)
+        self.taskHubName = client.get("taskHubName") or ""
+        self.connectionName = client.get("connectionName") or ""
+        self.creationUrls = client.get("creationUrls") or {}
+        self.managementUrls = client.get("managementUrls") or {}
+        self.baseUrl = client.get("baseUrl") or ""
+        self.requiredQueryStringParameters = client.get(
+            "requiredQueryStringParameters") or ""
+        self.rpcBaseUrl = client.get("rpcBaseUrl") or ""
+        self.httpBaseUrl = client.get("httpBaseUrl") or ""
+        self.maxGrpcMessageSizeInBytes = client.get(
+            "maxGrpcMessageSizeInBytes") or 0
+        self.grpcHttpClientTimeout = client.get(
+            "grpcHttpClientTimeout") or timedelta(seconds=30)
+
+    def create_check_status_response(
+            self, request: func.HttpRequest, instance_id: str) -> func.HttpResponse:
+        payload = self._get_client_response_links(request, instance_id)
+        return func.HttpResponse(
+            body=str(payload),
+            status_code=202,
+            headers={
+                "content-type": "application/json",
+                "Location": payload["statusQueryGetUri"],
+            },
+        )
+
+    def create_http_management_payload(
+            self,
+            request: func.HttpRequest | str | None = None,
+            instance_id: str | None = None) -> HttpManagementPayload:
+        if instance_id is None and isinstance(request, str):
+            instance_id = request
+            request = None
+        if instance_id is None:
+            raise TypeError("instance_id is required")
+        resolved_request = request if isinstance(request, func.HttpRequest) else None
+        return self._get_client_response_links(resolved_request, instance_id)
+
+    def _get_client_response_links(
+            self, request: func.HttpRequest | None,
+            instance_id: str) -> HttpManagementPayload:
+        return HttpManagementPayload(
+            instance_id,
+            self._get_instance_status_url(request, instance_id),
+            self.requiredQueryStringParameters)
+
+    def _get_instance_status_url(
+            self, request: func.HttpRequest | None, instance_id: str) -> str:
+        encoded_instance_id = quote(instance_id)
+        if request is not None:
+            request_url = urlparse(request.url)
+            return (
+                f"{request_url.scheme}://{request_url.netloc}"
+                f"/runtime/webhooks/durabletask/instances/{encoded_instance_id}")
+        base_url = self.baseUrl.rstrip("/") if self.baseUrl else ""
+        return f"{base_url}/instances/{encoded_instance_id}"

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

@@ -409,8 +409,8 @@ def attach_client_function(user_fn: Callable[..., Any]) -> FunctionBuilder:
             # ``FunctionBuilder`` (e.g. history export), which is left untouched.
             from ..client import DurableFunctionsClient, SyncDurableFunctionsClient
 
-            function = (user_fn._function._func if isinstance(user_fn, FunctionBuilder)
-                        else user_fn)
+            function = (user_fn._function._func  # pyright: ignore[reportPrivateUsage]
+                        if isinstance(user_fn, FunctionBuilder) else user_fn)
             signature = inspect.signature(function)
 
             @wraps(function)
@@ -427,15 +427,15 @@ async def client_bound(*args: Any, **kwargs: Any) -> Any:
                     result = function(*bound.args, **bound.kwargs)
                     return await result if inspect.isawaitable(result) else result
                 finally:
-                    if sync:
-                        client.close()
-                    else:
+                    if isinstance(client, DurableFunctionsClient):
                         client.schedule_close()
+                    else:
+                        client.close()
 
             client_bound.__annotations__[client_name] = str
-            client_bound.client_function = function  # pyright: ignore[reportFunctionMemberAccess]
+            setattr(client_bound, "client_function", function)
             if isinstance(user_fn, FunctionBuilder):
-                user_fn._function._func = client_bound
+                user_fn._function._func = client_bound  # pyright: ignore[reportPrivateUsage]
                 return wrap(user_fn)
             return wrap(client_bound)
 

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

@@ -20,7 +20,6 @@
 
 from __future__ import annotations
 
-import threading
 from collections.abc import Mapping
 from datetime import datetime, timezone
 from typing import Any, Optional, cast
@@ -48,10 +47,6 @@
 from durabletask.extensions.history_export.transitions import assert_valid_transition
 from durabletask.extensions.history_export.writer import HistoryWriter
 
-from .azurefunctions_grpc_interceptor import (
-    AzureFunctionsDefaultClientInterceptorImpl,
-)
-from .serialization import DEFAULT_FUNCTIONS_DATA_CONVERTER
 
 # The activity registers under the same name the export orchestrator calls, so
 # it transparently replaces the core activity.
@@ -156,11 +151,6 @@ def list_terminal_instances(
 # ---------------------------------------------------------------------------
 
 _export_writer: Optional[HistoryWriter] = None
-# The per-process export context (sync client + writer), built lazily from the
-# first injected durable client and reused across every export activity. Guarded
-# by ``_context_lock`` for the first-build race; its client is closed at exit.
-_export_context: Optional[HistoryExportContext] = None
-_context_lock = threading.Lock()
 
 
 def set_export_writer(writer: HistoryWriter) -> None:
@@ -174,48 +164,6 @@ def set_export_writer(writer: HistoryWriter) -> None:
     _export_writer = writer
 
 
-def _build_sync_client(client: Any) -> TaskHubGrpcClient:
-    """Build a synchronous ``TaskHubGrpcClient`` from an injected durable client.
-
-    The ``durable_client_input`` binding yields an async ``DurableFunctionsClient``
-    carrying the host's RPC endpoint and auth; the export activities use the
-    synchronous client, so this bridges to one aimed at the same endpoint.
-
-    > [!NOTE]
-    > This async->sync adapter is temporary. Once a first-class synchronous
-    > durable-client binding exists
-    > (https://github.com/microsoft/durabletask-python/issues/181), the export
-    > activities can be injected with a sync client directly and this bridge --
-    > along with the separate channel it opens -- can be removed.
-    """
-    interceptors = [AzureFunctionsDefaultClientInterceptorImpl(
-        client.taskHubName, client.requiredQueryStringParameters)]
-    return TaskHubGrpcClient(
-        host_address=client.rpcBaseUrl,
-        secure_channel=False,
-        interceptors=interceptors,
-        data_converter=DEFAULT_FUNCTIONS_DATA_CONVERTER)
-
-
-def _close_sync_export_client() -> None:
-    """Close the process-wide sync export client (registered via ``atexit``).
-
-    The client is built once per worker process and reused across every export
-    activity, so it lives for the app's lifetime; closing it at interpreter
-    exit releases its gRPC channel on graceful shutdown. Idempotent and
-    exception-safe -- shutdown must never surface an error from cleanup.
-    """
-    global _export_context
-    with _context_lock:
-        context = _export_context
-        _export_context = None
-    if context is not None:
-        try:
-            context.client.close()
-        except Exception:
-            pass
-
-
 def _context_for(client: TaskHubGrpcClient) -> HistoryExportContext:
     """Resolve an export context for the invocation's native sync client."""
     if _export_writer is None:

tests/azure-functions-durable/test_history_export_compat.py

@@ -203,20 +203,7 @@ def test_context_for_uses_invocation_sync_client(monkeypatch):
 
 
 def test_context_for_requires_configured_writer(monkeypatch):
-    monkeypatch.setattr(hec, "_build_sync_client", lambda _c: MagicMock())
     monkeypatch.setattr(hec, "_export_writer", None)
-    monkeypatch.setattr(hec, "_export_context", None)
 
     with pytest.raises(RuntimeError, match="writer is not configured"):
         hec._context_for(object())
-
-
-def test_close_sync_export_client_swallows_errors(monkeypatch):
-    fake_client = MagicMock()
-    fake_client.close.side_effect = RuntimeError("boom")
-    context = hec.HistoryExportContext(client=fake_client, writer=MagicMock())
-    monkeypatch.setattr(hec, "_export_context", context)
-
-    # Cleanup at shutdown must never raise.
-    hec._close_sync_export_client()
-    assert hec._export_context is None