durabletask.azuremanaged 1.4.0.dev34__tar.gz → 1.6.0__tar.gz

{durabletask_azuremanaged-1.4.0.dev34 → durabletask_azuremanaged-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask.azuremanaged
-Version: 1.4.0.dev34
+Version: 1.6.0
 Summary: Durable Task Python SDK provider implementation for the Azure Durable Task Scheduler
 Project-URL: repository, https://github.com/microsoft/durabletask-python
 Project-URL: changelog, https://github.com/microsoft/durabletask-python/blob/main/CHANGELOG.md
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: durabletask>=1.4.0
+Requires-Dist: durabletask>=1.6.0
 Requires-Dist: azure-identity>=1.19.0
 Provides-Extra: azure-blob-payloads
-Requires-Dist: durabletask[azure-blob-payloads]>=1.4.0; extra == "azure-blob-payloads"
+Requires-Dist: durabletask[azure-blob-payloads]>=1.6.0; extra == "azure-blob-payloads"

{durabletask_azuremanaged-1.4.0.dev34 → durabletask_azuremanaged-1.6.0}/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
@@ -15,7 +14,10 @@ from durabletask.azuremanaged.internal.durabletask_grpc_interceptor import (
     DTSDefaultClientInterceptorImpl,
 )
 from durabletask.client import AsyncTaskHubGrpcClient, TaskHubGrpcClient
-from durabletask.grpc_options import GrpcChannelOptions
+from durabletask.grpc_options import (
+    GrpcChannelOptions,
+    GrpcClientResiliencyOptions,
+)
 import durabletask.internal.shared as shared
 from durabletask.payload.store import PayloadStore
 
@@ -25,15 +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,
-                 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")
@@ -54,6 +57,7 @@ class DurableTaskSchedulerClient(TaskHubGrpcClient):
             log_formatter=log_formatter,
             interceptors=resolved_interceptors,
             channel_options=channel_options,
+            resiliency_options=resiliency_options,
             default_version=default_version,
             payload_store=payload_store)
 
@@ -70,15 +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.
-        default_version (Optional[str], optional): Default version string for orchestrations.
-        payload_store (Optional[PayloadStore], optional): A payload store for
+        resiliency_options (GrpcClientResiliencyOptions | None, optional): Client-side
+            gRPC resiliency settings forwarded to the base async client.
+        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.
@@ -99,15 +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,
-                 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")
@@ -128,5 +135,6 @@ class AsyncDurableTaskSchedulerClient(AsyncTaskHubGrpcClient):
             log_formatter=log_formatter,
             interceptors=resolved_interceptors,
             channel_options=channel_options,
+            resiliency_options=resiliency_options,
             default_version=default_version,
             payload_store=payload_store)

{durabletask_azuremanaged-1.4.0.dev34 → durabletask_azuremanaged-1.6.0}/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 @@ import durabletask.internal.shared as shared
 # 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 @@ class AccessTokenManager:
             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 @@ class AsyncAccessTokenManager:
         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-1.4.0.dev34 → durabletask_azuremanaged-1.6.0}/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
@@ -15,8 +14,6 @@ from durabletask.azuremanaged.internal.access_token_manager import (
 from durabletask.internal.grpc_interceptor import (
     DefaultAsyncClientInterceptorImpl,
     DefaultClientInterceptorImpl,
-    _AsyncClientCallDetails,
-    _ClientCallDetails,
 )
 
 
@@ -27,9 +24,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')
@@ -63,7 +60,7 @@ class DTSDefaultClientInterceptorImpl (DefaultClientInterceptorImpl):
             self._metadata.append(("authorization", f"Bearer {token}"))
 
     def _intercept_call(
-            self, client_call_details: _ClientCallDetails) -> grpc.ClientCallDetails:
+            self, client_call_details: grpc.ClientCallDetails) -> grpc.ClientCallDetails:
         """Internal intercept_call implementation which adds metadata to grpc metadata in the RPC
             call details."""
         # Refresh the auth token if a credential was provided. The call to
@@ -83,7 +80,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')
@@ -115,7 +112,7 @@ class DTSAsyncDefaultClientInterceptorImpl(DefaultAsyncClientInterceptorImpl):
             self._metadata.append(("authorization", f"Bearer {token}"))
 
     async def _intercept_call(
-            self, client_call_details: _AsyncClientCallDetails) -> grpc.aio.ClientCallDetails:
+            self, client_call_details: grpc.aio.ClientCallDetails) -> grpc.aio.ClientCallDetails:
         """Internal intercept_call implementation which adds metadata to grpc metadata in the RPC
             call details."""
         # Refresh the auth token if a credential was provided. The call to

durabletask_azuremanaged-1.6.0/durabletask/azuremanaged/internal/sandbox_service_pb2.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: durabletask/azuremanaged/internal/sandbox_service.proto
+# Protobuf Python Version: 5.26.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n7durabletask/azuremanaged/internal/sandbox_service.proto\x12\x1fmicrosoft.durabletask.sandboxes\"\xcd\x01\n\x1cSandboxActivityWorkerMessage\x12L\n\x05start\x18\x01 \x01(\x0b\x32;.microsoft.durabletask.sandboxes.SandboxActivityWorkerStartH\x00\x12T\n\theartbeat\x18\x02 \x01(\x0b\x32?.microsoft.durabletask.sandboxes.SandboxActivityWorkerHeartbeatH\x00\x42\t\n\x07message\"\x9d\x02\n\x1aSandboxActivityWorkerStart\x12\x10\n\x08task_hub\x18\x01 \x01(\t\x12\x1c\n\x14max_activities_count\x18\x02 \x01(\x05\x12N\n\x10sandbox_provider\x18\x03 \x01(\x0e\x32\x34.microsoft.durabletask.sandboxes.SandboxProviderKind\x12\x1e\n\x16\x64ts_sandbox_identifier\x18\x04 \x01(\t\x12\x19\n\x11worker_profile_id\x18\x05 \x01(\t\x12\x44\n\nactivities\x18\x06 \x03(\x0b\x32\x30.microsoft.durabletask.sandboxes.SandboxActivity\"A\n\x1eSandboxActivityWorkerHeartbeat\x12\x1f\n\x17\x61\x63tive_activities_count\x18\x01 \x01(\x05\"5\n\"SandboxActivityWorkerSessionResult\x12\x0f\n\x07message\x18\x01 \x01(\t\"\x89\x04\n\x14SandboxWorkerProfile\x12\x19\n\x11worker_profile_id\x18\x01 \x01(\t\x12\x44\n\nactivities\x18\x02 \x03(\x0b\x32\x30.microsoft.durabletask.sandboxes.SandboxActivity\x12\x44\n\x05image\x18\x03 \x01(\x0b\x32\x35.microsoft.durabletask.sandboxes.SandboxActivityImage\x12n\n\x15\x65nvironment_variables\x18\x04 \x03(\x0b\x32O.microsoft.durabletask.sandboxes.SandboxWorkerProfile.EnvironmentVariablesEntry\x12!\n\x19max_concurrent_activities\x18\x05 \x01(\x05\x12L\n\tresources\x18\x06 \x01(\x0b\x32\x39.microsoft.durabletask.sandboxes.SandboxActivityResources\x12,\n$scheduler_managed_identity_client_id\x18\x07 \x01(\t\x1a;\n\x19\x45nvironmentVariablesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"0\n\x0fSandboxActivity\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0f\n\x07version\x18\x02 \x01(\t\"n\n\x14SandboxActivityImage\x12\x11\n\timage_ref\x18\x01 \x01(\t\x12\"\n\x1amanaged_identity_client_id\x18\x02 \x01(\t\x12\x12\n\nentrypoint\x18\x03 \x03(\t\x12\x0b\n\x03\x63md\x18\x04 \x03(\t\"7\n\x18SandboxActivityResources\x12\x0b\n\x03\x63pu\x18\x01 \x01(\t\x12\x0e\n\x06memory\x18\x02 \x01(\t\"#\n!DeclareSandboxWorkerProfileResult\">\n!RemoveSandboxWorkerProfileRequest\x12\x19\n\x11worker_profile_id\x18\x01 \x01(\t\"\"\n RemoveSandboxWorkerProfileResult*\x8b\x01\n\x13SandboxProviderKind\x12%\n!SANDBOX_PROVIDER_KIND_UNSPECIFIED\x10\x00\x12*\n&SANDBOX_PROVIDER_KIND_ACA_SESSION_POOL\x10\x01\x12!\n\x1dSANDBOX_PROVIDER_KIND_SANDBOX\x10\x02\x32\xfb\x03\n\x11SandboxActivities\x12\xa4\x01\n\x1c\x43onnectSandboxActivityWorker\x12=.microsoft.durabletask.sandboxes.SandboxActivityWorkerMessage\x1a\x43.microsoft.durabletask.sandboxes.SandboxActivityWorkerSessionResult(\x01\x12\x98\x01\n\x1b\x44\x65\x63lareSandboxWorkerProfile\x12\x35.microsoft.durabletask.sandboxes.SandboxWorkerProfile\x1a\x42.microsoft.durabletask.sandboxes.DeclareSandboxWorkerProfileResult\x12\xa3\x01\n\x1aRemoveSandboxWorkerProfile\x12\x42.microsoft.durabletask.sandboxes.RemoveSandboxWorkerProfileRequest\x1a\x41.microsoft.durabletask.sandboxes.RemoveSandboxWorkerProfileResultB+\xaa\x02(Microsoft.DurableTask.Protobuf.Sandboxesb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'durabletask.azuremanaged.internal.sandbox_service_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\252\002(Microsoft.DurableTask.Protobuf.Sandboxes'
+  _globals['_SANDBOXWORKERPROFILE_ENVIRONMENTVARIABLESENTRY']._loaded_options = None
+  _globals['_SANDBOXWORKERPROFILE_ENVIRONMENTVARIABLESENTRY']._serialized_options = b'8\001'
+  _globals['_SANDBOXPROVIDERKIND']._serialized_start=1591
+  _globals['_SANDBOXPROVIDERKIND']._serialized_end=1730
+  _globals['_SANDBOXACTIVITYWORKERMESSAGE']._serialized_start=93
+  _globals['_SANDBOXACTIVITYWORKERMESSAGE']._serialized_end=298
+  _globals['_SANDBOXACTIVITYWORKERSTART']._serialized_start=301
+  _globals['_SANDBOXACTIVITYWORKERSTART']._serialized_end=586
+  _globals['_SANDBOXACTIVITYWORKERHEARTBEAT']._serialized_start=588
+  _globals['_SANDBOXACTIVITYWORKERHEARTBEAT']._serialized_end=653
+  _globals['_SANDBOXACTIVITYWORKERSESSIONRESULT']._serialized_start=655
+  _globals['_SANDBOXACTIVITYWORKERSESSIONRESULT']._serialized_end=708
+  _globals['_SANDBOXWORKERPROFILE']._serialized_start=711
+  _globals['_SANDBOXWORKERPROFILE']._serialized_end=1232
+  _globals['_SANDBOXWORKERPROFILE_ENVIRONMENTVARIABLESENTRY']._serialized_start=1173
+  _globals['_SANDBOXWORKERPROFILE_ENVIRONMENTVARIABLESENTRY']._serialized_end=1232
+  _globals['_SANDBOXACTIVITY']._serialized_start=1234
+  _globals['_SANDBOXACTIVITY']._serialized_end=1282
+  _globals['_SANDBOXACTIVITYIMAGE']._serialized_start=1284
+  _globals['_SANDBOXACTIVITYIMAGE']._serialized_end=1394
+  _globals['_SANDBOXACTIVITYRESOURCES']._serialized_start=1396
+  _globals['_SANDBOXACTIVITYRESOURCES']._serialized_end=1451
+  _globals['_DECLARESANDBOXWORKERPROFILERESULT']._serialized_start=1453
+  _globals['_DECLARESANDBOXWORKERPROFILERESULT']._serialized_end=1488
+  _globals['_REMOVESANDBOXWORKERPROFILEREQUEST']._serialized_start=1490
+  _globals['_REMOVESANDBOXWORKERPROFILEREQUEST']._serialized_end=1552
+  _globals['_REMOVESANDBOXWORKERPROFILERESULT']._serialized_start=1554
+  _globals['_REMOVESANDBOXWORKERPROFILERESULT']._serialized_end=1588
+  _globals['_SANDBOXACTIVITIES']._serialized_start=1733
+  _globals['_SANDBOXACTIVITIES']._serialized_end=2240
+# @@protoc_insertion_point(module_scope)

durabletask_azuremanaged-1.6.0/durabletask/azuremanaged/internal/sandbox_service_pb2.pyi

@@ -0,0 +1,119 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class SandboxProviderKind(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    SANDBOX_PROVIDER_KIND_UNSPECIFIED: _ClassVar[SandboxProviderKind]
+    SANDBOX_PROVIDER_KIND_ACA_SESSION_POOL: _ClassVar[SandboxProviderKind]
+    SANDBOX_PROVIDER_KIND_SANDBOX: _ClassVar[SandboxProviderKind]
+SANDBOX_PROVIDER_KIND_UNSPECIFIED: SandboxProviderKind
+SANDBOX_PROVIDER_KIND_ACA_SESSION_POOL: SandboxProviderKind
+SANDBOX_PROVIDER_KIND_SANDBOX: SandboxProviderKind
+
+class SandboxActivityWorkerMessage(_message.Message):
+    __slots__ = ("start", "heartbeat")
+    START_FIELD_NUMBER: _ClassVar[int]
+    HEARTBEAT_FIELD_NUMBER: _ClassVar[int]
+    start: SandboxActivityWorkerStart
+    heartbeat: SandboxActivityWorkerHeartbeat
+    def __init__(self, start: _Optional[_Union[SandboxActivityWorkerStart, _Mapping]] = ..., heartbeat: _Optional[_Union[SandboxActivityWorkerHeartbeat, _Mapping]] = ...) -> None: ...
+
+class SandboxActivityWorkerStart(_message.Message):
+    __slots__ = ("task_hub", "max_activities_count", "sandbox_provider", "dts_sandbox_identifier", "worker_profile_id", "activities")
+    TASK_HUB_FIELD_NUMBER: _ClassVar[int]
+    MAX_ACTIVITIES_COUNT_FIELD_NUMBER: _ClassVar[int]
+    SANDBOX_PROVIDER_FIELD_NUMBER: _ClassVar[int]
+    DTS_SANDBOX_IDENTIFIER_FIELD_NUMBER: _ClassVar[int]
+    WORKER_PROFILE_ID_FIELD_NUMBER: _ClassVar[int]
+    ACTIVITIES_FIELD_NUMBER: _ClassVar[int]
+    task_hub: str
+    max_activities_count: int
+    sandbox_provider: SandboxProviderKind
+    dts_sandbox_identifier: str
+    worker_profile_id: str
+    activities: _containers.RepeatedCompositeFieldContainer[SandboxActivity]
+    def __init__(self, task_hub: _Optional[str] = ..., max_activities_count: _Optional[int] = ..., sandbox_provider: _Optional[_Union[SandboxProviderKind, str]] = ..., dts_sandbox_identifier: _Optional[str] = ..., worker_profile_id: _Optional[str] = ..., activities: _Optional[_Iterable[_Union[SandboxActivity, _Mapping]]] = ...) -> None: ...
+
+class SandboxActivityWorkerHeartbeat(_message.Message):
+    __slots__ = ("active_activities_count",)
+    ACTIVE_ACTIVITIES_COUNT_FIELD_NUMBER: _ClassVar[int]
+    active_activities_count: int
+    def __init__(self, active_activities_count: _Optional[int] = ...) -> None: ...
+
+class SandboxActivityWorkerSessionResult(_message.Message):
+    __slots__ = ("message",)
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    message: str
+    def __init__(self, message: _Optional[str] = ...) -> None: ...
+
+class SandboxWorkerProfile(_message.Message):
+    __slots__ = ("worker_profile_id", "activities", "image", "environment_variables", "max_concurrent_activities", "resources", "scheduler_managed_identity_client_id")
+    class EnvironmentVariablesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    WORKER_PROFILE_ID_FIELD_NUMBER: _ClassVar[int]
+    ACTIVITIES_FIELD_NUMBER: _ClassVar[int]
+    IMAGE_FIELD_NUMBER: _ClassVar[int]
+    ENVIRONMENT_VARIABLES_FIELD_NUMBER: _ClassVar[int]
+    MAX_CONCURRENT_ACTIVITIES_FIELD_NUMBER: _ClassVar[int]
+    RESOURCES_FIELD_NUMBER: _ClassVar[int]
+    SCHEDULER_MANAGED_IDENTITY_CLIENT_ID_FIELD_NUMBER: _ClassVar[int]
+    worker_profile_id: str
+    activities: _containers.RepeatedCompositeFieldContainer[SandboxActivity]
+    image: SandboxActivityImage
+    environment_variables: _containers.ScalarMap[str, str]
+    max_concurrent_activities: int
+    resources: SandboxActivityResources
+    scheduler_managed_identity_client_id: str
+    def __init__(self, worker_profile_id: _Optional[str] = ..., activities: _Optional[_Iterable[_Union[SandboxActivity, _Mapping]]] = ..., image: _Optional[_Union[SandboxActivityImage, _Mapping]] = ..., environment_variables: _Optional[_Mapping[str, str]] = ..., max_concurrent_activities: _Optional[int] = ..., resources: _Optional[_Union[SandboxActivityResources, _Mapping]] = ..., scheduler_managed_identity_client_id: _Optional[str] = ...) -> None: ...
+
+class SandboxActivity(_message.Message):
+    __slots__ = ("name", "version")
+    NAME_FIELD_NUMBER: _ClassVar[int]
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    name: str
+    version: str
+    def __init__(self, name: _Optional[str] = ..., version: _Optional[str] = ...) -> None: ...
+
+class SandboxActivityImage(_message.Message):
+    __slots__ = ("image_ref", "managed_identity_client_id", "entrypoint", "cmd")
+    IMAGE_REF_FIELD_NUMBER: _ClassVar[int]
+    MANAGED_IDENTITY_CLIENT_ID_FIELD_NUMBER: _ClassVar[int]
+    ENTRYPOINT_FIELD_NUMBER: _ClassVar[int]
+    CMD_FIELD_NUMBER: _ClassVar[int]
+    image_ref: str
+    managed_identity_client_id: str
+    entrypoint: _containers.RepeatedScalarFieldContainer[str]
+    cmd: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, image_ref: _Optional[str] = ..., managed_identity_client_id: _Optional[str] = ..., entrypoint: _Optional[_Iterable[str]] = ..., cmd: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class SandboxActivityResources(_message.Message):
+    __slots__ = ("cpu", "memory")
+    CPU_FIELD_NUMBER: _ClassVar[int]
+    MEMORY_FIELD_NUMBER: _ClassVar[int]
+    cpu: str
+    memory: str
+    def __init__(self, cpu: _Optional[str] = ..., memory: _Optional[str] = ...) -> None: ...
+
+class DeclareSandboxWorkerProfileResult(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class RemoveSandboxWorkerProfileRequest(_message.Message):
+    __slots__ = ("worker_profile_id",)
+    WORKER_PROFILE_ID_FIELD_NUMBER: _ClassVar[int]
+    worker_profile_id: str
+    def __init__(self, worker_profile_id: _Optional[str] = ...) -> None: ...
+
+class RemoveSandboxWorkerProfileResult(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...

durabletask_azuremanaged-1.6.0/durabletask/azuremanaged/internal/sandbox_service_pb2_grpc.py

@@ -0,0 +1,197 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from durabletask.azuremanaged.internal import sandbox_service_pb2 as durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2
+
+GRPC_GENERATED_VERSION = '1.65.4'
+GRPC_VERSION = grpc.__version__
+EXPECTED_ERROR_RELEASE = '1.66.0'
+SCHEDULED_RELEASE_DATE = 'August 6, 2024'
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    warnings.warn(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in durabletask/azuremanaged/internal/sandbox_service_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+        + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},'
+        + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.',
+        RuntimeWarning
+    )
+
+
+class SandboxActivitiesStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.ConnectSandboxActivityWorker = channel.stream_unary(
+                '/microsoft.durabletask.sandboxes.SandboxActivities/ConnectSandboxActivityWorker',
+                request_serializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxActivityWorkerMessage.SerializeToString,
+                response_deserializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxActivityWorkerSessionResult.FromString,
+                _registered_method=True)
+        self.DeclareSandboxWorkerProfile = channel.unary_unary(
+                '/microsoft.durabletask.sandboxes.SandboxActivities/DeclareSandboxWorkerProfile',
+                request_serializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxWorkerProfile.SerializeToString,
+                response_deserializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.DeclareSandboxWorkerProfileResult.FromString,
+                _registered_method=True)
+        self.RemoveSandboxWorkerProfile = channel.unary_unary(
+                '/microsoft.durabletask.sandboxes.SandboxActivities/RemoveSandboxWorkerProfile',
+                request_serializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.RemoveSandboxWorkerProfileRequest.SerializeToString,
+                response_deserializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.RemoveSandboxWorkerProfileResult.FromString,
+                _registered_method=True)
+
+
+class SandboxActivitiesServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def ConnectSandboxActivityWorker(self, request_iterator, context):
+        """Opens a live sandbox activity worker session. The first message
+        must be a start message with static worker metadata. Heartbeats carry
+        dynamic state only. Closing the stream deregisters the worker.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def DeclareSandboxWorkerProfile(self, request, context):
+        """Creates or updates a sandbox worker profile before any live worker stream exists.
+        This is a configuration contract and does not advertise active worker
+        capacity.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def RemoveSandboxWorkerProfile(self, request, context):
+        """Removes a sandbox worker profile so the backend stops
+        waking new sandbox workers for the specified worker profile. Existing
+        workers are not terminated by this RPC.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_SandboxActivitiesServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'ConnectSandboxActivityWorker': grpc.stream_unary_rpc_method_handler(
+                    servicer.ConnectSandboxActivityWorker,
+                    request_deserializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxActivityWorkerMessage.FromString,
+                    response_serializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxActivityWorkerSessionResult.SerializeToString,
+            ),
+            'DeclareSandboxWorkerProfile': grpc.unary_unary_rpc_method_handler(
+                    servicer.DeclareSandboxWorkerProfile,
+                    request_deserializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxWorkerProfile.FromString,
+                    response_serializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.DeclareSandboxWorkerProfileResult.SerializeToString,
+            ),
+            'RemoveSandboxWorkerProfile': grpc.unary_unary_rpc_method_handler(
+                    servicer.RemoveSandboxWorkerProfile,
+                    request_deserializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.RemoveSandboxWorkerProfileRequest.FromString,
+                    response_serializer=durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.RemoveSandboxWorkerProfileResult.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'microsoft.durabletask.sandboxes.SandboxActivities', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('microsoft.durabletask.sandboxes.SandboxActivities', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class SandboxActivities(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def ConnectSandboxActivityWorker(request_iterator,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.stream_unary(
+            request_iterator,
+            target,
+            '/microsoft.durabletask.sandboxes.SandboxActivities/ConnectSandboxActivityWorker',
+            durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxActivityWorkerMessage.SerializeToString,
+            durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxActivityWorkerSessionResult.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def DeclareSandboxWorkerProfile(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/microsoft.durabletask.sandboxes.SandboxActivities/DeclareSandboxWorkerProfile',
+            durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.SandboxWorkerProfile.SerializeToString,
+            durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.DeclareSandboxWorkerProfileResult.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def RemoveSandboxWorkerProfile(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/microsoft.durabletask.sandboxes.SandboxActivities/RemoveSandboxWorkerProfile',
+            durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.RemoveSandboxWorkerProfileRequest.SerializeToString,
+            durabletask_dot_azuremanaged_dot_internal_dot_sandbox__service__pb2.RemoveSandboxWorkerProfileResult.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

durabletask_azuremanaged-1.6.0/durabletask/azuremanaged/preview/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Preview Azure Managed Durable Task Scheduler APIs."""

durabletask_azuremanaged-1.6.0/durabletask/azuremanaged/preview/sandboxes/__init__.py

@@ -0,0 +1,32 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Sandbox preview APIs for Durable Task Scheduler.
+
+This extension provides preview APIs for declaring sandbox activity
+worker images and running a Python activity worker inside a Durable Task
+Scheduler-launched sandbox.
+
+Usage::
+
+    from durabletask.azuremanaged.preview.sandboxes import (
+        SandboxWorker,
+        SandboxActivitiesClient,
+    )
+"""
+
+from durabletask.azuremanaged.preview.sandboxes.client import SandboxActivitiesClient
+from durabletask.azuremanaged.preview.sandboxes.helpers import SandboxActivity
+from durabletask.azuremanaged.preview.sandboxes.worker_profiles import SandboxWorkerProfile
+from durabletask.azuremanaged.preview.sandboxes.worker_profiles import SandboxWorkerProfileOptions
+from durabletask.azuremanaged.preview.sandboxes.worker_profiles import sandbox_worker_profile
+from durabletask.azuremanaged.preview.sandboxes.worker import SandboxWorker
+
+__all__ = [
+    "SandboxWorker",
+    "SandboxActivity",
+    "SandboxWorkerProfile",
+    "SandboxWorkerProfileOptions",
+    "SandboxActivitiesClient",
+    "sandbox_worker_profile",
+]