Cleanup pyright errors

Author: andystaples

.github/workflows/typecheck.yml

@@ -7,6 +7,7 @@ on:
     tags:
       - "v*"
       - "azuremanaged-v*"
+      - "azurefunctions-v*"
   pull_request:
     branches:
       - "main"
@@ -36,3 +37,25 @@ jobs:
 
       - name: Run pyright (strict, Python 3.10)
         run: pyright
+
+  pyright-azurefunctions:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python 3.13 (lowest supported by azure-functions-durable)
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install packages and dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install -e ".[azure-blob-payloads,opentelemetry]"
+          pip install -e ./azure-functions-durable
+          pip install pyright
+
+      - name: Run pyright (strict, Python 3.13)
+        run: pyright -p azure-functions-durable/pyrightconfig.json

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

@@ -1,14 +1,15 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
-# This import ensures that the replacement of the global JSON encoder/decoder
-# happens as soon as the durabletask.azurefunctions package is imported.
-from .internal import functions_json as _
-
+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

@@ -18,7 +18,7 @@ class DurableFunctionsClient(TaskHubGrpcClient):
     """A gRPC client passed to Durable Functions durable client bindings.
 
     Connects to the Durable Functions runtime using gRPC and provides methods
-    for creating and managing Durable orchestrations, interacting with Durable entities, 
+    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.
     """
     taskHubName: str
@@ -44,7 +44,7 @@ def __init__(self, client_as_string: str):
             json.JSONDecodeError: If the provided string is not valid JSON.
         """
         self._parse_client_configuration(client_as_string)
-        if self.httpBaseUrl is None:
+        if not self.httpBaseUrl:
             # This happens when the extension has not been configured for gRPC yet. For some reason, instead of
             # the client returning with null rpcBaseUrl and httpBaseUrl, it returns rpcBaseUrl with the http url.
             self.configure_extension_for_grpc()
@@ -87,7 +87,7 @@ def configure_extension_for_grpc(self) -> None:
 
         Makes an HTTP request to the extension's management endpoint to enable gRPC.
         """
-        
+
         # Make an HTTP request to the extension to configure gRPC
         configure_base_url = self.httpBaseUrl
         if not configure_base_url:
@@ -103,7 +103,7 @@ def configure_extension_for_grpc(self) -> None:
         response = requests.get(url, params=params)
         if response.status_code != 200:
             raise Exception(f"Failed to configure gRPC for Durable Functions extension. Status code: {response.status_code}, Response: {response.text}")
-        
+
         # Parse the response to update client configuration - it's double-encoded so we need to load it twice
         self._parse_client_configuration(json.loads(response.text))
 

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

@@ -2,12 +2,12 @@
 #  Licensed under the MIT License.
 
 from functools import wraps
+from typing import Any, Callable, Optional, Union
 
-from durabletask import task
-
-from typing import Callable, Optional
-from typing import Union
 from azure.functions import FunctionRegister, TriggerApi, BindingApi, AuthLevel
+from azure.functions.decorators.function_app import FunctionBuilder
+
+from durabletask import task
 
 from .metadata import OrchestrationTrigger, ActivityTrigger, EntityTrigger, \
     DurableClient
@@ -40,9 +40,14 @@ def __init__(self,
         DFApp
             New instance of a Durable Functions app
         """
-        super().__init__(auth_level=http_auth_level)
-
-    def _configure_orchestrator_callable(self, wrap) -> Callable:
+        # The next-in-MRO base (``DecoratorApi.__init__``) is declared with
+        # untyped ``*args``/``**kwargs``, so pyright cannot see this call's type.
+        super().__init__(auth_level=http_auth_level)  # pyright: ignore[reportUnknownMemberType]
+
+    def _configure_orchestrator_callable(
+            self,
+            wrap: Callable[[Callable[..., Any]], FunctionBuilder]
+    ) -> Callable[[task.Orchestrator[Any, Any]], FunctionBuilder]:
         """Obtain decorator to construct an Orchestrator class from a user-defined Function.
 
         Parameters
@@ -56,7 +61,7 @@ def _configure_orchestrator_callable(self, wrap) -> Callable:
             The function to construct an Orchestrator class from the user-defined Function,
             wrapped by the next decorator in the sequence.
         """
-        def decorator(orchestrator_func: task.Orchestrator):
+        def decorator(orchestrator_func: task.Orchestrator[Any, Any]) -> FunctionBuilder:
             # Construct an orchestrator based on the end-user code
 
             handle = Orchestrator.create(orchestrator_func)
@@ -67,7 +72,10 @@ def decorator(orchestrator_func: task.Orchestrator):
 
         return decorator
 
-    def _configure_entity_callable(self, wrap) -> Callable:
+    def _configure_entity_callable(
+            self,
+            wrap: Callable[[Callable[..., Any]], FunctionBuilder]
+    ) -> Callable[[task.Entity[Any, Any]], FunctionBuilder]:
         """Obtain decorator to construct an Entity class from a user-defined Function.
 
         Parameters
@@ -81,34 +89,44 @@ def _configure_entity_callable(self, wrap) -> Callable:
             The function to construct an Entity class from the user-defined Function,
             wrapped by the next decorator in the sequence.
         """
-        def decorator(entity_func: task.Entity):
+        def decorator(entity_func: task.Entity[Any, Any]) -> FunctionBuilder:
             # Construct an orchestrator based on the end-user code
 
             # 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) -> str:
-                return DurableFunctionsWorker()._execute_entity_batch(entity_func, context)
+            def handle(context: Any) -> str:
+                return DurableFunctionsWorker().execute_entity_batch_request(entity_func, context)
 
-            handle.entity_function = entity_func  # type: ignore
+            handle.entity_function = entity_func  # pyright: ignore[reportFunctionMemberAccess]
 
             # invoke next decorator, with the Entity as input
             handle.__name__ = entity_func.__name__
             return wrap(handle)
 
         return decorator
 
-    def _add_rich_client(self, fb, parameter_name, client_constructor):
+    def _add_rich_client(
+            self,
+            fb: FunctionBuilder,
+            parameter_name: str,
+            client_constructor: Callable[[Any], Any]
+    ) -> None:
         # Obtain user-code and force type annotation on the client-binding parameter to be `str`.
         # This ensures a passing type-check of that specific parameter,
         # circumventing a limitation of the worker in type-checking rich DF Client objects.
         # TODO: Once rich-binding type checking is possible, remove the annotation change.
-        user_code = fb._function._func
+        # ``FunctionBuilder._function`` and ``Function._func`` are private to
+        # azure-functions with no public accessor for mutating the wrapped
+        # user function. Holding it as ``Any`` keeps the single private-access
+        # waiver here rather than spreading it across each ``._func`` use.
+        function_obj: Any = fb._function  # pyright: ignore[reportPrivateUsage]
+        user_code = function_obj._func
         user_code.__annotations__[parameter_name] = str
 
         # `wraps` This ensures we re-export the same method-signature as the decorated method
         @wraps(user_code)
-        async def df_client_middleware(*args, **kwargs):
+        async def df_client_middleware(*args: Any, **kwargs: Any) -> Any:
 
             # Obtain JSON-string currently passed as DF Client,
             # construct rich object from it,
@@ -121,13 +139,30 @@ async def df_client_middleware(*args, **kwargs):
             return await user_code(*args, **kwargs)
 
         # TODO: Is there a better way to support retrieving the unwrapped user code?
-        df_client_middleware.client_function = fb._function._func  # type: ignore
+        df_client_middleware.client_function = function_obj._func  # pyright: ignore[reportAttributeAccessIssue]
 
-        user_code_with_rich_client = df_client_middleware
-        fb._function._func = user_code_with_rich_client
+        function_obj._func = df_client_middleware
+
+    def _build_function(
+            self,
+            wrap: Callable[[FunctionBuilder], FunctionBuilder]
+    ) -> Callable[[Callable[..., Any]], FunctionBuilder]:
+        """Typed equivalent of the base ``_configure_function_builder``.
+
+        The inherited method is untyped, which would otherwise propagate
+        ``Unknown`` types through every decorator below. This mirrors its
+        behaviour exactly using the typed protected members it relies on.
+        """
+        def decorator(func: Callable[..., Any]) -> FunctionBuilder:
+            fb = self._validate_type(func)
+            self._function_builders.append(fb)
+            return wrap(fb)
+
+        return decorator
 
     def orchestration_trigger(self, context_name: str,
-                              orchestration: Optional[str] = None):
+                              orchestration: Optional[str] = None
+                              ) -> Callable[[task.Orchestrator[Any, Any]], FunctionBuilder]:
         """Register an Orchestrator Function.
 
         Parameters
@@ -139,10 +174,10 @@ def orchestration_trigger(self, context_name: str,
             The value is None by default, in which case the name of the method is used.
         """
         @self._configure_orchestrator_callable
-        @self._configure_function_builder
-        def wrap(fb):
+        @self._build_function
+        def wrap(fb: FunctionBuilder) -> FunctionBuilder:
 
-            def decorator():
+            def decorator() -> FunctionBuilder:
                 fb.add_trigger(
                     trigger=OrchestrationTrigger(name=context_name,
                                                  orchestration=orchestration))
@@ -153,7 +188,8 @@ def decorator():
         return wrap
 
     def activity_trigger(self, input_name: str,
-                         activity: Optional[str] = None):
+                         activity: Optional[str] = None
+                         ) -> Callable[[Callable[..., Any]], FunctionBuilder]:
         """Register an Activity Function.
 
         Parameters
@@ -164,9 +200,9 @@ def activity_trigger(self, input_name: str,
             Name of Activity Function.
             The value is None by default, in which case the name of the method is used.
         """
-        @self._configure_function_builder
-        def wrap(fb):
-            def decorator():
+        @self._build_function
+        def wrap(fb: FunctionBuilder) -> FunctionBuilder:
+            def decorator() -> FunctionBuilder:
                 fb.add_trigger(
                     trigger=ActivityTrigger(name=input_name,
                                             activity=activity))
@@ -178,7 +214,8 @@ def decorator():
 
     def entity_trigger(self,
                        context_name: str,
-                       entity_name: Optional[str] = None):
+                       entity_name: Optional[str] = None
+                       ) -> Callable[[task.Entity[Any, Any]], FunctionBuilder]:
         """Register an Entity Function.
 
         Parameters
@@ -190,9 +227,9 @@ def entity_trigger(self,
             The value is None by default, in which case the name of the method is used.
         """
         @self._configure_entity_callable
-        @self._configure_function_builder
-        def wrap(fb):
-            def decorator():
+        @self._build_function
+        def wrap(fb: FunctionBuilder) -> FunctionBuilder:
+            def decorator() -> FunctionBuilder:
                 fb.add_trigger(
                     trigger=EntityTrigger(name=context_name,
                                           entity_name=entity_name))
@@ -206,7 +243,7 @@ def durable_client_input(self,
                              client_name: str,
                              task_hub: Optional[str] = None,
                              connection_name: Optional[str] = None
-                             ):
+                             ) -> Callable[[Callable[..., Any]], FunctionBuilder]:
         """Register a Durable-client Function.
 
         Parameters
@@ -225,9 +262,9 @@ def durable_client_input(self,
             account connection string for the function app is used.
         """
 
-        @self._configure_function_builder
-        def wrap(fb):
-            def decorator():
+        @self._build_function
+        def wrap(fb: FunctionBuilder) -> FunctionBuilder:
+            def decorator() -> FunctionBuilder:
                 fb.add_binding(
                     binding=DurableClient(name=client_name,
                                           task_hub=task_hub,

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

@@ -28,7 +28,7 @@ def get_binding_name() -> str:
     def __init__(self,
                  name: str,
                  orchestration: Optional[str] = None,
-                 durable_requires_grpc=True,
+                 durable_requires_grpc: bool = True,
                  ) -> None:
         self.orchestration = orchestration
         self.durable_requires_grpc = durable_requires_grpc
@@ -55,7 +55,7 @@ def get_binding_name() -> str:
     def __init__(self,
                  name: str,
                  activity: Optional[str] = None,
-                 durable_requires_grpc=True,
+                 durable_requires_grpc: bool = True,
                  ) -> None:
         self.activity = activity
         self.durable_requires_grpc = durable_requires_grpc
@@ -82,7 +82,7 @@ def get_binding_name() -> str:
     def __init__(self,
                  name: str,
                  entity_name: Optional[str] = None,
-                 durable_requires_grpc=True,
+                 durable_requires_grpc: bool = True,
                  ) -> None:
         self.entity_name = entity_name
         self.durable_requires_grpc = durable_requires_grpc
@@ -110,7 +110,7 @@ def __init__(self,
                  name: str,
                  task_hub: Optional[str] = None,
                  connection_name: Optional[str] = None,
-                 durable_requires_grpc=True,
+                 durable_requires_grpc: bool = True,
                  ) -> None:
         self.task_hub = task_hub
         self.connection_name = connection_name