durabletask 1.4.0.dev31__py3-none-any.whl → 1.4.0.dev32__py3-none-any.whl

durabletask/__init__.py

@@ -3,6 +3,7 @@
 
 """Durable Task SDK for Python"""
 
+from durabletask.grpc_options import GrpcChannelOptions, GrpcRetryPolicyOptions
 from durabletask.payload.store import LargePayloadStorageOptions, PayloadStore
 from durabletask.worker import (
     ActivityWorkItemFilter,
@@ -17,6 +18,8 @@ __all__ = [
     "ActivityWorkItemFilter",
     "ConcurrencyOptions",
     "EntityWorkItemFilter",
+    "GrpcChannelOptions",
+    "GrpcRetryPolicyOptions",
     "LargePayloadStorageOptions",
     "OrchestrationWorkItemFilter",
     "PayloadStore",

durabletask/client.py

@@ -14,6 +14,7 @@ import grpc.aio
 import durabletask.history as history
 from durabletask.entities import EntityInstanceId
 from durabletask.entities.entity_metadata import EntityMetadata
+from durabletask.grpc_options import GrpcChannelOptions
 import durabletask.internal.helpers as helpers
 import durabletask.internal.history_helpers as history_helpers
 import durabletask.internal.orchestrator_service_pb2 as pb
@@ -161,18 +162,22 @@ class TaskHubGrpcClient:
                  metadata: Optional[list[tuple[str, str]]] = None,
                  log_handler: Optional[logging.Handler] = None,
                  log_formatter: Optional[logging.Formatter] = None,
+                 channel: Optional[grpc.Channel] = None,
                  secure_channel: bool = False,
                  interceptors: Optional[Sequence[shared.ClientInterceptor]] = None,
+                 channel_options: Optional[GrpcChannelOptions] = None,
                  default_version: Optional[str] = None,
                  payload_store: Optional[PayloadStore] = None):
 
-        interceptors = prepare_sync_interceptors(metadata, interceptors)
-
-        channel = shared.get_grpc_channel(
-            host_address=host_address,
-            secure_channel=secure_channel,
-            interceptors=interceptors
-        )
+        self._owns_channel = channel is None
+        if channel is None:
+            interceptors = prepare_sync_interceptors(metadata, interceptors)
+            channel = shared.get_grpc_channel(
+                host_address=host_address,
+                secure_channel=secure_channel,
+                interceptors=interceptors,
+                channel_options=channel_options,
+            )
         self._channel = channel
         self._stub = stubs.TaskHubSidecarServiceStub(channel)
         self._logger = shared.get_logger("client", log_handler, log_formatter)
@@ -180,8 +185,15 @@ class TaskHubGrpcClient:
         self._payload_store = payload_store
 
     def close(self) -> None:
-        """Closes the underlying gRPC channel."""
-        self._channel.close()
+        """Closes the underlying gRPC channel.
+
+        Only closes channels created internally. If a pre-configured channel
+        was passed via the ``channel`` constructor parameter, this method is
+        a no-op — the caller retains ownership and is responsible for closing
+        it.
+        """
+        if self._owns_channel:
+            self._channel.close()
 
     def schedule_new_orchestration(self, orchestrator: Union[task.Orchestrator[TInput, TOutput], str], *,
                                    input: Optional[TInput] = None,
@@ -480,18 +492,22 @@ class AsyncTaskHubGrpcClient:
                  metadata: Optional[list[tuple[str, str]]] = None,
                  log_handler: Optional[logging.Handler] = None,
                  log_formatter: Optional[logging.Formatter] = None,
+                 channel: Optional[grpc.aio.Channel] = None,
                  secure_channel: bool = False,
                  interceptors: Optional[Sequence[shared.AsyncClientInterceptor]] = None,
+                 channel_options: Optional[GrpcChannelOptions] = None,
                  default_version: Optional[str] = None,
                  payload_store: Optional[PayloadStore] = None):
 
-        interceptors = prepare_async_interceptors(metadata, interceptors)
-
-        channel = shared.get_async_grpc_channel(
-            host_address=host_address,
-            secure_channel=secure_channel,
-            interceptors=interceptors
-        )
+        self._owns_channel = channel is None
+        if channel is None:
+            interceptors = prepare_async_interceptors(metadata, interceptors)
+            channel = shared.get_async_grpc_channel(
+                host_address=host_address,
+                secure_channel=secure_channel,
+                interceptors=interceptors,
+                channel_options=channel_options,
+            )
         self._channel = channel
         self._stub = stubs.TaskHubSidecarServiceStub(channel)
         self._logger = shared.get_logger("async_client", log_handler, log_formatter)
@@ -499,8 +515,15 @@ class AsyncTaskHubGrpcClient:
         self._payload_store = payload_store
 
     async def close(self) -> None:
-        """Closes the underlying gRPC channel."""
-        await self._channel.close()
+        """Closes the underlying gRPC channel.
+
+        Only closes channels created internally. If a pre-configured channel
+        was passed via the ``channel`` constructor parameter, this method is
+        a no-op — the caller retains ownership and is responsible for closing
+        it.
+        """
+        if self._owns_channel:
+            await self._channel.close()
 
     async def __aenter__(self):
         return self

durabletask/grpc_options.py

@@ -0,0 +1,102 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import json
+from typing import Any, Optional
+
+
+@dataclass
+class GrpcRetryPolicyOptions:
+    """Configuration for transport-level gRPC retries."""
+
+    max_attempts: int = 4
+    initial_backoff_seconds: float = 0.05
+    max_backoff_seconds: float = 0.25
+    backoff_multiplier: float = 2.0
+    retryable_status_codes: list[str] = field(default_factory=lambda: ["UNAVAILABLE"])
+
+    def __post_init__(self) -> None:
+        if self.max_attempts < 2:
+            raise ValueError("max_attempts must be >= 2")
+        if self.initial_backoff_seconds <= 0:
+            raise ValueError("initial_backoff_seconds must be > 0")
+        if self.max_backoff_seconds <= 0:
+            raise ValueError("max_backoff_seconds must be > 0")
+        if self.backoff_multiplier <= 0:
+            raise ValueError("backoff_multiplier must be > 0")
+        if self.max_backoff_seconds < self.initial_backoff_seconds:
+            raise ValueError("max_backoff_seconds must be >= initial_backoff_seconds")
+        if len(self.retryable_status_codes) == 0:
+            raise ValueError("retryable_status_codes cannot be empty")
+        # Validate that backoff values are representable as non-zero gRPC duration strings.
+        self._format_duration(self.initial_backoff_seconds)
+        self._format_duration(self.max_backoff_seconds)
+
+    @staticmethod
+    def _format_duration(seconds: float) -> str:
+        formatted = f"{seconds:.9f}".rstrip('0')
+        if formatted.endswith('.'):
+            formatted += '0'
+        if float(formatted) == 0:
+            raise ValueError(
+                f"Duration {seconds!r} rounds to zero; use a value large enough to "
+                "produce a non-zero gRPC duration string."
+            )
+        return f"{formatted}s"
+
+    def to_service_config(self) -> dict[str, Any]:
+        return {
+            "methodConfig": [
+                {
+                    "name": [{}],
+                    "retryPolicy": {
+                        "maxAttempts": self.max_attempts,
+                        "initialBackoff": self._format_duration(self.initial_backoff_seconds),
+                        "maxBackoff": self._format_duration(self.max_backoff_seconds),
+                        "backoffMultiplier": self.backoff_multiplier,
+                        "retryableStatusCodes": self.retryable_status_codes,
+                    },
+                }
+            ]
+        }
+
+
+@dataclass
+class GrpcChannelOptions:
+    """Configuration for transport-level gRPC channel behavior."""
+
+    max_receive_message_length: Optional[int] = None
+    max_send_message_length: Optional[int] = None
+    keepalive_time_ms: Optional[int] = None
+    keepalive_timeout_ms: Optional[int] = None
+    keepalive_permit_without_calls: Optional[bool] = None
+    retry_policy: Optional[GrpcRetryPolicyOptions] = None
+    raw_options: list[tuple[str, Any]] = field(default_factory=list)
+
+    def to_grpc_options(self) -> list[tuple[str, Any]]:
+        options = list(self.raw_options)
+
+        if self.max_receive_message_length is not None:
+            options.append(("grpc.max_receive_message_length", self.max_receive_message_length))
+        if self.max_send_message_length is not None:
+            options.append(("grpc.max_send_message_length", self.max_send_message_length))
+        if self.keepalive_time_ms is not None:
+            options.append(("grpc.keepalive_time_ms", self.keepalive_time_ms))
+        if self.keepalive_timeout_ms is not None:
+            options.append(("grpc.keepalive_timeout_ms", self.keepalive_timeout_ms))
+        if self.keepalive_permit_without_calls is not None:
+            options.append(
+                (
+                    "grpc.keepalive_permit_without_calls",
+                    1 if self.keepalive_permit_without_calls else 0,
+                )
+            )
+
+        if self.retry_policy is not None:
+            options.append(("grpc.enable_retries", 1))
+            options.append(("grpc.service_config", json.dumps(self.retry_policy.to_service_config())))
+
+        return options

durabletask/internal/shared.py

@@ -9,6 +9,7 @@ from typing import Any, Optional, Sequence, Union
 
 import grpc
 import grpc.aio
+from durabletask.grpc_options import GrpcChannelOptions
 
 ClientInterceptor = Union[
     grpc.UnaryUnaryClientInterceptor,
@@ -39,7 +40,8 @@ def get_default_host_address() -> str:
 def get_grpc_channel(
         host_address: Optional[str],
         secure_channel: bool = False,
-        interceptors: Optional[Sequence[ClientInterceptor]] = None) -> grpc.Channel:
+        interceptors: Optional[Sequence[ClientInterceptor]] = None,
+        channel_options: Optional[GrpcChannelOptions] = None) -> grpc.Channel:
 
     if host_address is None:
         host_address = get_default_host_address()
@@ -59,10 +61,21 @@ def get_grpc_channel(
             break
 
     # Create the base channel
+    options = channel_options.to_grpc_options() if channel_options is not None else None
     if secure_channel:
-        channel = grpc.secure_channel(host_address, grpc.ssl_channel_credentials())
+        if options is None:
+            channel = grpc.secure_channel(host_address, grpc.ssl_channel_credentials())
+        else:
+            channel = grpc.secure_channel(
+                host_address,
+                grpc.ssl_channel_credentials(),
+                options=options,
+            )
     else:
-        channel = grpc.insecure_channel(host_address)
+        if options is None:
+            channel = grpc.insecure_channel(host_address)
+        else:
+            channel = grpc.insecure_channel(host_address, options=options)
 
     # Apply interceptors ONLY if they exist
     if interceptors:
@@ -73,7 +86,8 @@ def get_grpc_channel(
 def get_async_grpc_channel(
         host_address: Optional[str],
         secure_channel: bool = False,
-        interceptors: Optional[Sequence[AsyncClientInterceptor]] = None) -> grpc.aio.Channel:
+        interceptors: Optional[Sequence[AsyncClientInterceptor]] = None,
+        channel_options: Optional[GrpcChannelOptions] = None) -> grpc.aio.Channel:
 
     if host_address is None:
         host_address = get_default_host_address()
@@ -90,14 +104,34 @@ def get_async_grpc_channel(
             host_address = host_address[len(protocol):]
             break
 
+    options = channel_options.to_grpc_options() if channel_options is not None else None
+
     if secure_channel:
-        channel = grpc.aio.secure_channel(
-            host_address, grpc.ssl_channel_credentials(),
-            interceptors=interceptors)
+        if options is None:
+            channel = grpc.aio.secure_channel(
+                host_address,
+                grpc.ssl_channel_credentials(),
+                interceptors=interceptors,
+            )
+        else:
+            channel = grpc.aio.secure_channel(
+                host_address,
+                grpc.ssl_channel_credentials(),
+                interceptors=interceptors,
+                options=options,
+            )
     else:
-        channel = grpc.aio.insecure_channel(
-            host_address,
-            interceptors=interceptors)
+        if options is None:
+            channel = grpc.aio.insecure_channel(
+                host_address,
+                interceptors=interceptors,
+            )
+        else:
+            channel = grpc.aio.insecure_channel(
+                host_address,
+                interceptors=interceptors,
+                options=options,
+            )
 
     return channel
 

durabletask/worker.py

@@ -21,6 +21,7 @@ from packaging.version import InvalidVersion, parse
 import grpc
 from google.protobuf import empty_pb2
 
+from durabletask.grpc_options import GrpcChannelOptions
 from durabletask.entities.entity_operation_failed_exception import EntityOperationFailedException
 from durabletask.internal import helpers
 from durabletask.internal.entity_state_shim import StateShim
@@ -361,8 +362,13 @@ class TaskHubGrpcWorker:
             Defaults to None.
         secure_channel (bool, optional): Whether to use a secure gRPC channel (TLS).
             Defaults to False.
+        channel (Optional[grpc.Channel], optional): Pre-configured gRPC channel to use.
+            If set, host address, secure_channel, interceptors, and channel_options
+            are ignored when creating connections.
         interceptors (Optional[Sequence[shared.ClientInterceptor]], optional): Custom gRPC
             interceptors to apply to the channel. Defaults to None.
+        channel_options (Optional[GrpcChannelOptions], optional): Extra low-level gRPC
+            channel configuration including retry/service config options.
         concurrency_options (Optional[ConcurrencyOptions], optional): Configuration for
             controlling worker concurrency limits. If None, default settings are used.
 
@@ -426,8 +432,10 @@ class TaskHubGrpcWorker:
             metadata: Optional[list[tuple[str, str]]] = None,
             log_handler: Optional[logging.Handler] = None,
             log_formatter: Optional[logging.Formatter] = None,
+            channel: Optional[grpc.Channel] = None,
             secure_channel: bool = False,
             interceptors: Optional[Sequence[shared.ClientInterceptor]] = None,
+            channel_options: Optional[GrpcChannelOptions] = None,
             concurrency_options: Optional[ConcurrencyOptions] = None,
             maximum_timer_interval: Optional[timedelta] = DEFAULT_MAXIMUM_TIMER_INTERVAL,
             payload_store: Optional[PayloadStore] = None,
@@ -439,8 +447,10 @@ class TaskHubGrpcWorker:
         self._logger = shared.get_logger("worker", log_handler, log_formatter)
         self._shutdown = Event()
         self._is_running = False
+        self._channel = channel
         self._secure_channel = secure_channel
         self._payload_store = payload_store
+        self._channel_options = channel_options
 
         # Use provided concurrency options or create default ones
         self._concurrency_options = (
@@ -590,7 +600,7 @@ class TaskHubGrpcWorker:
 
         def create_fresh_connection():
             nonlocal current_channel, current_stub, conn_retry_count
-            if current_channel:
+            if current_channel and self._channel is None:
                 try:
                     current_channel.close()
                 except Exception:
@@ -598,16 +608,22 @@ class TaskHubGrpcWorker:
             current_channel = None
             current_stub = None
             try:
-                current_channel = shared.get_grpc_channel(
-                    self._host_address, self._secure_channel, self._interceptors
-                )
+                if self._channel is not None:
+                    current_channel = self._channel
+                else:
+                    current_channel = shared.get_grpc_channel(
+                        self._host_address,
+                        self._secure_channel,
+                        self._interceptors,
+                        channel_options=self._channel_options,
+                    )
                 current_stub = stubs.TaskHubSidecarServiceStub(current_channel)
                 current_stub.Hello(empty_pb2.Empty())
                 conn_retry_count = 0
                 self._logger.info(f"Created fresh connection to {self._host_address}")
             except Exception as e:
                 self._logger.warning(f"Failed to create connection: {e}")
-                current_channel = None
+                current_channel = self._channel if self._channel is not None else None
                 current_stub = None
                 raise
 
@@ -632,12 +648,12 @@ class TaskHubGrpcWorker:
                 current_reader_thread = None
 
             # Close the channel
-            if current_channel:
+            if current_channel and self._channel is None:
                 try:
                     current_channel.close()
                 except Exception:
                     pass
-            current_channel = None
+            current_channel = self._channel if self._channel is not None else None
             current_stub = None
 
         def should_invalidate_connection(rpc_error):

{durabletask-1.4.0.dev31.dist-info → durabletask-1.4.0.dev32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask
-Version: 1.4.0.dev31
+Version: 1.4.0.dev32
 Summary: A Durable Task Client SDK for Python
 License:     MIT License
         

{durabletask-1.4.0.dev31.dist-info → durabletask-1.4.0.dev32.dist-info}/RECORD

@@ -1,9 +1,10 @@
-durabletask/__init__.py,sha256=OdfKCNlS_NJawRfLWsFNj7YIHeGSQkh2VH3OzG0Oric,644
-durabletask/client.py,sha256=OfVkCn6x4PE-8_8Yn1agjKzRuLzJD_fPidVy4tVUblY,38896
+durabletask/__init__.py,sha256=GhLZFOSOVlP7Jomi6f-nNYiUxDf5a2wNylkBAcshEBA,780
+durabletask/client.py,sha256=PUOTYi0Kw7JoREbz-W8Gw5tjN_VCZxBLMqLq0T97unQ,40086
+durabletask/grpc_options.py,sha256=k1xXnKzK5b_86wibuh7Ype396A-Gs6P4nbHBaUSpE9U,4174
 durabletask/history.py,sha256=VhrWb5eFr9TZSaazpotdMzKt2quwLuJVRk9j39WbTPs,18680
 durabletask/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 durabletask/task.py,sha256=QS7RPUaWhb4Xq5hi7nnueooJqQSDO6ipEoiAiSVkAIs,24009
-durabletask/worker.py,sha256=B8aYoOguNuYccmmtGF9GFr3YEEdfTGJqcOoox0kByQM,133661
+durabletask/worker.py,sha256=ZNx_85fGjgUkjJK_dEI2AZRB4qM3XMV6hgPlc3PPdFk,134691
 durabletask/entities/__init__.py,sha256=DbNd5riqWZaj3tG6gN82O8Q6wTmFpe6QaH0pQgDSPHs,721
 durabletask/entities/durable_entity.py,sha256=LQPWnUlRsHiFVRoTdpeSK--eXtjf2UGbVQwEEKf7QwI,3318
 durabletask/entities/entity_context.py,sha256=U-B3i9QP34N-6Fikx_tMp8zo0YLdmwhwpdxwjHd7z-M,5346
@@ -27,15 +28,15 @@ durabletask/internal/orchestrator_service_pb2.py,sha256=K5iG8oguyGhTGt0YmkDsK9ZQ
 durabletask/internal/orchestrator_service_pb2.pyi,sha256=TFa752MEoXPdK1fP2fDIIaqpGQJ0sbyXRoNg51hlegE,78590
 durabletask/internal/orchestrator_service_pb2_grpc.py,sha256=Rk0QpGOc8fTeIGULB6xww9CtX6GiLGlZ3JMoZyW9Wuo,60845
 durabletask/internal/proto_task_hub_sidecar_service_stub.py,sha256=pFlOCj1LhuhU5OKU4CZIuQCCsf9jilC9GXDqlEQYQ0U,1503
-durabletask/internal/shared.py,sha256=3GMYHWCFX9esgzlRwNr3J2AOeufAIypTZJQ9n2xI6g4,5589
+durabletask/internal/shared.py,sha256=00NrfM7dmdBQznLt0S9rfWoYWBTOXHWnmg3nemhyWco,6819
 durabletask/internal/tracing.py,sha256=3cSanl0UcmGekItHcQ6tSl7wqSkS7_wOKzsDvJyS_ag,28821
 durabletask/payload/__init__.py,sha256=1h68pQvgk8JUp5LBJuBq9W4GUPYkdlhqmCCQEg6YBYI,784
 durabletask/payload/helpers.py,sha256=RYG5MEVAqHjm4zfFHs3Td91FVQHUoCcb5hbEJ4sYj5s,12350
 durabletask/payload/store.py,sha256=3qJMvKxRUkr6ScWUzxpKAVgzuhFLywRW8a2_5OOmNk4,3000
 durabletask/testing/__init__.py,sha256=rXbcSFtzuaRAbDNX-HmdgbxLTegvKJ1FRjZfSOIAMgA,323
 durabletask/testing/in_memory_backend.py,sha256=mF0zCA3GMLUd0vqa7CvkgBhYXH4VCsqHReIWuw72wvA,82530
-durabletask-1.4.0.dev31.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
-durabletask-1.4.0.dev31.dist-info/METADATA,sha256=aeUengR81uLV9mY6zeEvw5d4S8KCoM2uYLPP2rF0q04,4404
-durabletask-1.4.0.dev31.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-durabletask-1.4.0.dev31.dist-info/top_level.txt,sha256=EBVyuKWnjOwq8bJI1Uvb9U3c4fzQxACWj9p83he6fik,12
-durabletask-1.4.0.dev31.dist-info/RECORD,,
+durabletask-1.4.0.dev32.dist-info/licenses/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+durabletask-1.4.0.dev32.dist-info/METADATA,sha256=6jrrQkmgSTCTRRdoeoFUUKpP0OUVNjB4inn5V4Ua9-M,4404
+durabletask-1.4.0.dev32.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+durabletask-1.4.0.dev32.dist-info/top_level.txt,sha256=EBVyuKWnjOwq8bJI1Uvb9U3c4fzQxACWj9p83he6fik,12
+durabletask-1.4.0.dev32.dist-info/RECORD,,