Infer Functions durable client type

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

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

Author: andystaples

azure-functions-durable/CHANGELOG.md

@@ -9,10 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ADDED
 
-- Added `SyncDurableFunctionsClient` and
-`DFApp.durable_client_input_sync()` for synchronous durable-client functions.
-Both synchronous and asynchronous Functions durable clients can now use the
-scheduled-tasks and history-export client APIs without an async-to-sync bridge.
+- Added `SyncDurableFunctionsClient`. `DFApp.durable_client_input()` now injects
+the synchronous client into synchronous functions and the asynchronous client
+into coroutine functions. Both clients support scheduled-task and history-export
+APIs without an async-to-sync bridge.
 
 ## 2.0.0b1
 

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

@@ -152,12 +152,12 @@ def configure_history_export(self, writer: Any) -> None:
         # whatever worker runs them). ``durable_client_input`` is applied as the
         # outer decorator over ``activity_trigger`` so the built function carries
         # both bindings.
-        self.durable_client_input(client_name="client", sync=True)(
+        self.durable_client_input(client_name="client")(
             self.activity_trigger(
                 input_name="input",
                 activity=LIST_TERMINAL_INSTANCES_ACTIVITY)(
                     list_terminal_instances_client_bound))
-        self.durable_client_input(client_name="client", sync=True)(
+        self.durable_client_input(client_name="client")(
             self.activity_trigger(
                 input_name="input",
                 activity=EXPORT_INSTANCE_HISTORY_ACTIVITY)(
@@ -359,11 +359,13 @@ def durable_client_input(self,
                              client_name: str,
                              task_hub: Optional[str] = None,
                              connection_name: Optional[str] = None,
-                             *,
-                             sync: bool = False,
                              ) -> Callable[[Callable[..., Any]], FunctionBuilder]:
         """Register a Durable-client Function.
 
+        Coroutine functions receive an asynchronous
+        :class:`DurableFunctionsClient`; synchronous functions receive a cached
+        :class:`SyncDurableFunctionsClient`.
+
         Parameters
         ----------
         client_name: str
@@ -378,17 +380,14 @@ def durable_client_input(self,
             The storage account represented by this connection string must be the same one
             used by the target orchestrator functions. If not specified, the default storage
             account connection string for the function app is used.
-        sync: bool
-            When ``True``, inject a :class:`SyncDurableFunctionsClient`. The
-            default injects the asynchronous :class:`DurableFunctionsClient`.
         """
 
         @self._build_function
         def wrap(fb: FunctionBuilder) -> FunctionBuilder:
             def decorator() -> FunctionBuilder:
                 # The converter returns the host configuration string. The
-                # function wrapper below constructs and closes the requested
-                # synchronous or asynchronous rich client per invocation.
+                # function wrapper below constructs the rich client matching
+                # the decorated function's synchronous or asynchronous type.
                 fb.add_binding(
                     binding=DurableClient(name=client_name,
                                           task_hub=task_hub,
@@ -407,6 +406,7 @@ def attach_client_function(user_fn: Callable[..., Any]) -> FunctionBuilder:
             function = (user_fn._function._func  # pyright: ignore[reportPrivateUsage]
                         if isinstance(user_fn, FunctionBuilder) else user_fn)
             signature = inspect.signature(function)
+            is_async_function = inspect.iscoroutinefunction(function)
 
             def bind_client(
                     args: tuple[Any, ...],
@@ -421,8 +421,8 @@ def bind_client(
                 if not isinstance(raw_client, str):
                     raise TypeError(
                         f"durable client binding '{client_name}' did not provide its configuration")
-                client = (SyncDurableFunctionsClient.get_cached(raw_client) if sync
-                          else DurableFunctionsClient(raw_client))
+                client = (DurableFunctionsClient(raw_client) if is_async_function
+                          else SyncDurableFunctionsClient.get_cached(raw_client))
                 bound.arguments[client_name] = client
                 return bound, client
 
@@ -439,7 +439,7 @@ def set_client_metadata(client_bound: Callable[..., Any]) -> None:
                 client_bound.__annotations__ = annotations
                 setattr(client_bound, "client_function", function)
 
-            if inspect.iscoroutinefunction(function):
+            if is_async_function:
                 @wraps(function)
                 async def async_client_bound(*args: Any, **kwargs: Any) -> Any:
                     bound, client = bind_client(args, kwargs)
@@ -469,16 +469,6 @@ def sync_client_bound(*args: Any, **kwargs: Any) -> Any:
 
         return attach_client_function
 
-    def durable_client_input_sync(
-            self,
-            client_name: str,
-            task_hub: Optional[str] = None,
-            connection_name: Optional[str] = None,
-    ) -> Callable[[Callable[..., Any]], FunctionBuilder]:
-        """Register a durable-client binding that injects a synchronous client."""
-        return self.durable_client_input(
-            client_name, task_hub, connection_name, sync=True)
-
 
 class DFApp(Blueprint, FunctionRegister):
     """Durable Functions (DF) app.

durabletask/scheduled/client.py

@@ -269,7 +269,10 @@ async def list_schedules(
         results: list[ScheduleDescription] = []
         for metadata in await self._client.get_all_entities(query):
             state = metadata.get_typed_state(ScheduleState)
-            if state is not None and state.schedule_configuration is not None and \
-                    ScheduledTaskClient.matches_filter(state, schedule_query):
+            if (
+                    state is not None
+                    and state.schedule_configuration is not None
+                    and ScheduledTaskClient.matches_filter(state, schedule_query)
+            ):
                 results.append(state.to_description())
         return results

tests/azure-functions-durable/test_decorator_compat.py

@@ -135,15 +135,15 @@ async def starter(client):
     assert await fb._function._func(client="{}") == "DurableFunctionsClient"
 
 
-def test_durable_client_input_sync_injects_sync_client():
+def test_durable_client_input_injects_sync_client_for_sync_function():
     app = df.DFApp()
     clients = []
 
     def starter(client):
         clients.append(client)
         return type(client).__name__
 
-    fb = app.durable_client_input_sync(client_name="client")(starter)
+    fb = app.durable_client_input(client_name="client")(starter)
     assert not inspect.iscoroutinefunction(fb._function._func)
     assert fb._function._func(client="{}") == "SyncDurableFunctionsClient"
     assert fb._function._func(client="{}") == "SyncDurableFunctionsClient"