Modernize typing to Python 3.10+ idioms

The repository declares `requires-python = ">=3.10"` but its
hand-written modules still relied on pre-3.10 typing constructs. Apply
PEP 604, PEP 585, PEP 613, and PEP 634 throughout, leaving generated
proto/grpc files and their hand-written stub mirror untouched.

- Replace `Optional[X]` with `X | None` and `Union[X, Y]` with
  `X | Y` (PEP 604).
- Replace `List[...]` / `Dict[...]` / `Tuple[...]` / `Type[...]`
  with the built-in generic forms `list[...]`, `dict[...]`,
  `tuple[...]`, `type[...]` (PEP 585).
- Annotate module-level type aliases in `durabletask/task.py` and
  `durabletask/internal/shared.py` with `TypeAlias` (PEP 613).
- Convert the `action_type` dispatch in
  `_get_method_name_for_action` to `match`/`case` (PEP 634).
- Drop now-unused `typing` imports.

No public API or behavior changes.

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

Author: Bernd Verst

durabletask-azuremanaged/durabletask/azuremanaged/client.py

@@ -2,8 +2,7 @@
 # Licensed under the MIT License.
 
 import logging
-
-from typing import Optional, Sequence
+from collections.abc import Sequence
 
 import grpc
 import grpc.aio
@@ -28,16 +27,16 @@ class DurableTaskSchedulerClient(TaskHubGrpcClient):
     def __init__(self, *,
                  host_address: str,
                  taskhub: str,
-                 token_credential: Optional[TokenCredential],
-                 channel: Optional[grpc.Channel] = None,
+                 token_credential: TokenCredential | None,
+                 channel: grpc.Channel | None = None,
                  secure_channel: bool = True,
-                 interceptors: Optional[Sequence[shared.ClientInterceptor]] = None,
-                 channel_options: Optional[GrpcChannelOptions] = None,
-                 resiliency_options: Optional[GrpcClientResiliencyOptions] = None,
-                 default_version: Optional[str] = None,
-                 payload_store: Optional[PayloadStore] = None,
-                 log_handler: Optional[logging.Handler] = None,
-                 log_formatter: Optional[logging.Formatter] = None):
+                 interceptors: Sequence[shared.ClientInterceptor] | None = None,
+                 channel_options: GrpcChannelOptions | None = None,
+                 resiliency_options: GrpcClientResiliencyOptions | None = None,
+                 default_version: str | None = None,
+                 payload_store: PayloadStore | None = None,
+                 log_handler: logging.Handler | None = None,
+                 log_formatter: logging.Formatter | None = None):
 
         if not taskhub:
             raise ValueError("Taskhub value cannot be empty. Please provide a value for your taskhub")
@@ -75,17 +74,17 @@ class AsyncDurableTaskSchedulerClient(AsyncTaskHubGrpcClient):
     Args:
         host_address (str): The gRPC endpoint address of the DTS service.
         taskhub (str): The name of the task hub. Cannot be empty.
-        token_credential (Optional[TokenCredential]): Azure credential for authentication.
+        token_credential (TokenCredential | None): Azure credential for authentication.
             If None, anonymous authentication will be used.
         secure_channel (bool, optional): Whether to use a secure gRPC channel (TLS).
             Defaults to True.
-        resiliency_options (Optional[GrpcClientResiliencyOptions], optional): Client-side
+        resiliency_options (GrpcClientResiliencyOptions | None, optional): Client-side
             gRPC resiliency settings forwarded to the base async client.
-        default_version (Optional[str], optional): Default version string for orchestrations.
-        payload_store (Optional[PayloadStore], optional): A payload store for
+        default_version (str | None, optional): Default version string for orchestrations.
+        payload_store (PayloadStore | None, optional): A payload store for
             externalizing large payloads. If None, payloads are sent inline.
-        log_handler (Optional[logging.Handler], optional): Custom logging handler for client logs.
-        log_formatter (Optional[logging.Formatter], optional): Custom log formatter for client logs.
+        log_handler (logging.Handler | None, optional): Custom logging handler for client logs.
+        log_formatter (logging.Formatter | None, optional): Custom log formatter for client logs.
 
     Raises:
         ValueError: If taskhub is empty or None.
@@ -106,16 +105,16 @@ class AsyncDurableTaskSchedulerClient(AsyncTaskHubGrpcClient):
     def __init__(self, *,
                  host_address: str,
                  taskhub: str,
-                 token_credential: Optional[AsyncTokenCredential],
-                 channel: Optional[grpc.aio.Channel] = None,
+                 token_credential: AsyncTokenCredential | None,
+                 channel: grpc.aio.Channel | None = None,
                  secure_channel: bool = True,
-                 interceptors: Optional[Sequence[shared.AsyncClientInterceptor]] = None,
-                 channel_options: Optional[GrpcChannelOptions] = None,
-                 resiliency_options: Optional[GrpcClientResiliencyOptions] = None,
-                 default_version: Optional[str] = None,
-                 payload_store: Optional[PayloadStore] = None,
-                 log_handler: Optional[logging.Handler] = None,
-                 log_formatter: Optional[logging.Formatter] = None):
+                 interceptors: Sequence[shared.AsyncClientInterceptor] | None = None,
+                 channel_options: GrpcChannelOptions | None = None,
+                 resiliency_options: GrpcClientResiliencyOptions | None = None,
+                 default_version: str | None = None,
+                 payload_store: PayloadStore | None = None,
+                 log_handler: logging.Handler | None = None,
+                 log_formatter: logging.Formatter | None = None):
 
         if not taskhub:
             raise ValueError("Taskhub value cannot be empty. Please provide a value for your taskhub")

durabletask-azuremanaged/durabletask/azuremanaged/internal/access_token_manager.py

@@ -2,7 +2,6 @@
 # Licensed under the MIT License.
 from datetime import datetime, timedelta, timezone
 from threading import Lock
-from typing import Optional
 
 from azure.core.credentials import AccessToken, TokenCredential
 from azure.core.credentials_async import AsyncTokenCredential
@@ -13,9 +12,9 @@
 # By default, when there's 10minutes left before the token expires, refresh the token
 class AccessTokenManager:
 
-    _token: Optional[AccessToken]
+    _token: AccessToken | None
 
-    def __init__(self, token_credential: Optional[TokenCredential], refresh_interval_seconds: int = 600):
+    def __init__(self, token_credential: TokenCredential | None, refresh_interval_seconds: int = 600):
         self._scope = "https://durabletask.io/.default"
         self._refresh_interval_seconds = refresh_interval_seconds
         self._logger = shared.get_logger("token_manager")
@@ -30,7 +29,7 @@ def __init__(self, token_credential: Optional[TokenCredential], refresh_interval
             self._token = None
             self.expiry_time = None
 
-    def get_access_token(self) -> Optional[AccessToken]:
+    def get_access_token(self) -> AccessToken | None:
         if self._token is None or self.is_token_expired():
             with self._refresh_lock:
                 if self._token is None or self.is_token_expired():
@@ -59,9 +58,9 @@ class AsyncAccessTokenManager:
 
     This avoids blocking the event loop when acquiring or refreshing tokens."""
 
-    _token: Optional[AccessToken]
+    _token: AccessToken | None
 
-    def __init__(self, token_credential: Optional[AsyncTokenCredential],
+    def __init__(self, token_credential: AsyncTokenCredential | None,
                  refresh_interval_seconds: int = 600):
         self._scope = "https://durabletask.io/.default"
         self._refresh_interval_seconds = refresh_interval_seconds
@@ -71,7 +70,7 @@ def __init__(self, token_credential: Optional[AsyncTokenCredential],
         self._token = None
         self.expiry_time = None
 
-    async def get_access_token(self) -> Optional[AccessToken]:
+    async def get_access_token(self) -> AccessToken | None:
         if self._token is None or self.is_token_expired():
             await self.refresh_token()
         return self._token

durabletask-azuremanaged/durabletask/azuremanaged/internal/durabletask_grpc_interceptor.py

@@ -2,7 +2,6 @@
 # Licensed under the MIT License.
 
 from importlib.metadata import version
-from typing import Optional
 
 import grpc
 from azure.core.credentials import TokenCredential
@@ -27,9 +26,9 @@ class DTSDefaultClientInterceptorImpl (DefaultClientInterceptorImpl):
 
     def __init__(
             self,
-            token_credential: Optional[TokenCredential],
+            token_credential: TokenCredential | None,
             taskhub_name: str,
-            worker_id: Optional[str] = None):
+            worker_id: str | None = None):
         try:
             # Get the version of the azuremanaged package
             sdk_version = version('durabletask-azuremanaged')
@@ -83,7 +82,7 @@ class DTSAsyncDefaultClientInterceptorImpl(DefaultAsyncClientInterceptorImpl):
     This class implements async gRPC interceptors to add DTS-specific headers
     (task hub name, user agent, and authentication token) to all async calls."""
 
-    def __init__(self, token_credential: Optional[AsyncTokenCredential], taskhub_name: str):
+    def __init__(self, token_credential: AsyncTokenCredential | None, taskhub_name: str):
         try:
             # Get the version of the azuremanaged package
             sdk_version = version('durabletask-azuremanaged')

durabletask-azuremanaged/durabletask/azuremanaged/worker.py

@@ -5,8 +5,7 @@
 import os
 import socket
 import uuid
-
-from typing import Optional, Sequence
+from collections.abc import Sequence
 
 import grpc
 from azure.core.credentials import TokenCredential
@@ -33,19 +32,19 @@ class DurableTaskSchedulerWorker(TaskHubGrpcWorker):
     Args:
         host_address (str): The gRPC endpoint address of the DTS service.
         taskhub (str): The name of the task hub. Cannot be empty.
-        token_credential (Optional[TokenCredential]): Azure credential for authentication.
+        token_credential (TokenCredential | None): Azure credential for authentication.
             If None, anonymous authentication will be used.
         secure_channel (bool, optional): Whether to use a secure gRPC channel (TLS).
             Defaults to True.
-        resiliency_options (Optional[GrpcWorkerResiliencyOptions], optional): Worker-side
+        resiliency_options (GrpcWorkerResiliencyOptions | None, optional): Worker-side
             gRPC resiliency settings forwarded to the base worker.
-        concurrency_options (Optional[ConcurrencyOptions], optional): Configuration
+        concurrency_options (ConcurrencyOptions | None, optional): Configuration
             for controlling worker concurrency limits. If None, default concurrency
             settings will be used.
-        payload_store (Optional[PayloadStore], optional): A payload store for
+        payload_store (PayloadStore | None, optional): A payload store for
             externalizing large payloads. If None, payloads are sent inline.
-        log_handler (Optional[logging.Handler], optional): Custom logging handler for worker logs.
-        log_formatter (Optional[logging.Formatter], optional): Custom log formatter for worker logs.
+        log_handler (logging.Handler | None, optional): Custom logging handler for worker logs.
+        log_formatter (logging.Formatter | None, optional): Custom log formatter for worker logs.
 
     Raises:
         ValueError: If taskhub is empty or None.
@@ -74,16 +73,16 @@ class DurableTaskSchedulerWorker(TaskHubGrpcWorker):
     def __init__(self, *,
                  host_address: str,
                  taskhub: str,
-                 token_credential: Optional[TokenCredential],
-                 channel: Optional[grpc.Channel] = None,
+                 token_credential: TokenCredential | None,
+                 channel: grpc.Channel | None = None,
                  secure_channel: bool = True,
-                 interceptors: Optional[Sequence[shared.ClientInterceptor]] = None,
-                 channel_options: Optional[GrpcChannelOptions] = None,
-                 resiliency_options: Optional[GrpcWorkerResiliencyOptions] = None,
-                 concurrency_options: Optional[ConcurrencyOptions] = None,
-                 payload_store: Optional[PayloadStore] = None,
-                 log_handler: Optional[logging.Handler] = None,
-                 log_formatter: Optional[logging.Formatter] = None):
+                 interceptors: Sequence[shared.ClientInterceptor] | None = None,
+                 channel_options: GrpcChannelOptions | None = None,
+                 resiliency_options: GrpcWorkerResiliencyOptions | None = None,
+                 concurrency_options: ConcurrencyOptions | None = None,
+                 payload_store: PayloadStore | None = None,
+                 log_handler: logging.Handler | None = None,
+                 log_formatter: logging.Formatter | None = None):
 
         if not taskhub:
             raise ValueError("The taskhub value cannot be empty.")