durabletask.azuremanaged 1.8.0__tar.gz → 1.9.0__tar.gz

{durabletask_azuremanaged-1.8.0 → durabletask_azuremanaged-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask.azuremanaged
-Version: 1.8.0
+Version: 1.9.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.8.0
+Requires-Dist: durabletask>=1.9.0
 Requires-Dist: azure-identity>=1.19.0
 Provides-Extra: azure-blob-payloads
-Requires-Dist: durabletask[azure-blob-payloads]>=1.8.0; extra == "azure-blob-payloads"
+Requires-Dist: durabletask[azure-blob-payloads]>=1.9.0; extra == "azure-blob-payloads"

{durabletask_azuremanaged-1.8.0 → durabletask_azuremanaged-1.9.0}/durabletask/azuremanaged/internal/access_token_manager.py

@@ -1,5 +1,6 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
+import asyncio
 from datetime import datetime, timedelta, timezone
 from threading import Lock
 
@@ -13,6 +14,7 @@ import durabletask.internal.shared as shared
 class AccessTokenManager:
 
     _token: AccessToken | None
+    expiry_time: datetime | None
 
     def __init__(self, token_credential: TokenCredential | None, refresh_interval_seconds: int = 600):
         self._scope = "https://durabletask.io/.default"
@@ -22,12 +24,12 @@ class AccessTokenManager:
         self._credential = token_credential
         self._refresh_lock = Lock()
 
-        if self._credential is not None:
-            self._token = self._credential.get_token(self._scope)
-            self.expiry_time = datetime.fromtimestamp(self._token.expires_on, tz=timezone.utc)
-        else:
-            self._token = None
-            self.expiry_time = None
+        # Token acquisition is deferred to the first get_access_token() call so that
+        # constructing a client or worker does not perform a blocking credential round
+        # trip. The deferred first acquisition still goes through the double-checked
+        # refresh lock below, so it remains single-flight across threads.
+        self._token = None
+        self.expiry_time = None
 
     def get_access_token(self) -> AccessToken | None:
         if self._token is None or self.is_token_expired():
@@ -70,9 +72,37 @@ class AsyncAccessTokenManager:
         self._token = None
         self.expiry_time = None
 
+        # An asyncio.Lock binds itself to the event loop it is first used on, and this
+        # manager may outlive a loop or be shared across loops. Locks are therefore
+        # created lazily per running loop, guarded by a plain threading lock because
+        # different loops may run on different threads.
+        self._refresh_locks: dict[asyncio.AbstractEventLoop, asyncio.Lock] = {}
+        self._refresh_locks_guard = Lock()
+
+    def _get_refresh_lock(self) -> asyncio.Lock:
+        loop = asyncio.get_running_loop()
+        with self._refresh_locks_guard:
+            lock = self._refresh_locks.get(loop)
+            if lock is None:
+                # Discard locks belonging to loops that are no longer usable so the
+                # mapping does not grow without bound.
+                stale_loops = [
+                    existing for existing in self._refresh_locks if existing.is_closed()
+                ]
+                for stale_loop in stale_loops:
+                    del self._refresh_locks[stale_loop]
+                lock = asyncio.Lock()
+                self._refresh_locks[loop] = lock
+            return lock
+
     async def get_access_token(self) -> AccessToken | None:
         if self._token is None or self.is_token_expired():
-            await self.refresh_token()
+            async with self._get_refresh_lock():
+                # Re-check under the lock: a concurrent caller may have already
+                # refreshed the token while this one was waiting, so only a single
+                # credential request is made per refresh window.
+                if self._token is None or self.is_token_expired():
+                    await self.refresh_token()
         return self._token
 
     def is_token_expired(self) -> bool:

{durabletask_azuremanaged-1.8.0 → durabletask_azuremanaged-1.9.0}/durabletask/azuremanaged/internal/durabletask_grpc_interceptor.py

@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
+from functools import lru_cache
 from importlib.metadata import version
 
 import grpc
@@ -17,6 +18,22 @@ from durabletask.internal.grpc_interceptor import (
 )
 
 
+@lru_cache(maxsize=1)
+def _get_sdk_version() -> str:
+    """Return the installed version of the azuremanaged package.
+
+    Resolving the version walks distribution metadata on disk, so the result is
+    cached and shared by every interceptor instance instead of being recomputed
+    on each client or worker construction. Falls back to ``"unknown"`` when the
+    version cannot be determined.
+    """
+    try:
+        return version('durabletask-azuremanaged')
+    except Exception:
+        # Fallback if version cannot be determined
+        return "unknown"
+
+
 class DTSDefaultClientInterceptorImpl (DefaultClientInterceptorImpl):
     """The class implements a UnaryUnaryClientInterceptor, UnaryStreamClientInterceptor,
     StreamUnaryClientInterceptor and StreamStreamClientInterceptor from grpc to add an
@@ -27,13 +44,7 @@ class DTSDefaultClientInterceptorImpl (DefaultClientInterceptorImpl):
             token_credential: TokenCredential | None,
             taskhub_name: str,
             worker_id: str | None = None):
-        try:
-            # Get the version of the azuremanaged package
-            sdk_version = version('durabletask-azuremanaged')
-        except Exception:
-            # Fallback if version cannot be determined
-            sdk_version = "unknown"
-        user_agent = f"durabletask-python/{sdk_version}"
+        user_agent = f"durabletask-python/{_get_sdk_version()}"
         self._metadata = [
             ("taskhub", taskhub_name),
             ("x-user-agent", user_agent)]  # 'user-agent' is a reserved header; use 'x-user-agent'
@@ -41,13 +52,13 @@ class DTSDefaultClientInterceptorImpl (DefaultClientInterceptorImpl):
             self._metadata.append(("workerid", worker_id))
         super().__init__(self._metadata)
 
+        # Token acquisition is deferred to the first _intercept_call invocation rather
+        # than happening in __init__, so that constructing a client or worker does not
+        # block on a credential round trip before any RPC is made.
         self._token_manager = None
         if token_credential is not None:
             self._token_credential = token_credential
             self._token_manager = AccessTokenManager(token_credential=self._token_credential)
-            access_token = self._token_manager.get_access_token()
-            if access_token is not None:
-                self._upsert_authorization_header(access_token.token)
 
     def _upsert_authorization_header(self, token: str) -> None:
         found = False
@@ -81,13 +92,7 @@ class DTSAsyncDefaultClientInterceptorImpl(DefaultAsyncClientInterceptorImpl):
     (task hub name, user agent, and authentication token) to all async calls."""
 
     def __init__(self, token_credential: AsyncTokenCredential | None, taskhub_name: str):
-        try:
-            # Get the version of the azuremanaged package
-            sdk_version = version('durabletask-azuremanaged')
-        except Exception:
-            # Fallback if version cannot be determined
-            sdk_version = "unknown"
-        user_agent = f"durabletask-python/{sdk_version}"
+        user_agent = f"durabletask-python/{_get_sdk_version()}"
         self._metadata = [
             ("taskhub", taskhub_name),
             ("x-user-agent", user_agent)]

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

@@ -0,0 +1,80 @@
+# 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,
+    )
+
+The exports below are resolved lazily on first attribute access, so importing
+this package does not load the sandbox worker runtime (and its Azure Identity
+and gRPC dependencies) unless those APIs are actually used.
+"""
+
+from importlib import import_module
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    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",
+]
+
+# Public export name -> submodule of this package that defines it.
+_LAZY_EXPORTS: dict[str, str] = {
+    "SandboxWorker": "worker",
+    "SandboxActivity": "helpers",
+    "SandboxWorkerProfile": "worker_profiles",
+    "SandboxWorkerProfileOptions": "worker_profiles",
+    "SandboxActivitiesClient": "client",
+    "sandbox_worker_profile": "worker_profiles",
+}
+
+# Submodules that eager imports previously bound as attributes of this package.
+# They remain reachable through attribute access without an explicit import.
+_LAZY_SUBMODULES: frozenset[str] = frozenset({
+    "client",
+    "helpers",
+    "profile_builder",
+    "transport",
+    "worker",
+    "worker_messages",
+    "worker_profiles",
+})
+
+
+def __getattr__(name: str) -> Any:
+    """Import public sandbox exports on first access (PEP 562)."""
+    submodule = _LAZY_EXPORTS.get(name)
+    if submodule is not None:
+        value = getattr(import_module(f".{submodule}", __name__), name)
+    elif name in _LAZY_SUBMODULES:
+        value = import_module(f".{name}", __name__)
+    else:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__) | _LAZY_SUBMODULES)

{durabletask_azuremanaged-1.8.0 → durabletask_azuremanaged-1.9.0}/durabletask/azuremanaged/preview/sandboxes/profile_builder.py

@@ -7,7 +7,6 @@ from typing import Iterable, Optional
 from durabletask.azuremanaged.internal import sandbox_service_pb2 as pb
 from durabletask.azuremanaged.preview.sandboxes.helpers import (
     SandboxActivity,
-    activities_overlap,
     format_activity,
     normalize_required,
     resolve_activities,
@@ -91,22 +90,109 @@ def _build_sandbox_worker_profile(
     return worker_profile
 
 
+class _ActivityOwnerSlot:
+    """Earliest worker profiles recorded for a single activity overlap bucket.
+
+    Only two owners ever need to be retained to answer "which worker profile
+    first claimed an activity in this bucket, ignoring `worker_profile_id`":
+    the very first owner, plus the first owner that differs from it.
+    """
+
+    __slots__ = ("_first", "_first_other")
+
+    def __init__(self) -> None:
+        self._first: Optional[tuple[int, str]] = None
+        self._first_other: Optional[tuple[int, str]] = None
+
+    def add(self, order: int, worker_profile_id: str) -> None:
+        if self._first is None:
+            self._first = (order, worker_profile_id)
+        elif self._first_other is None and worker_profile_id != self._first[1]:
+            self._first_other = (order, worker_profile_id)
+
+    def first_owner_other_than(self, worker_profile_id: str) -> Optional[tuple[int, str]]:
+        if self._first is not None and self._first[1] != worker_profile_id:
+            return self._first
+        return self._first_other
+
+
+class _ActivityOwnerIndex:
+    """Indexes activity ownership so overlap checks cost O(1) per activity.
+
+    Reproduces the semantics of
+    :func:`durabletask.azuremanaged.preview.sandboxes.helpers.activities_overlap`
+    exactly: activity names are compared case insensitively, an unversioned
+    activity overlaps every version of the same name, and two activities with
+    the same name overlap when their explicit versions are equal. Registration
+    order is tracked so the reported conflict matches the first overlapping
+    activity, exactly as a linear scan would report it.
+    """
+
+    def __init__(self) -> None:
+        self._registration_count = 0
+        self._by_name: dict[str, _ActivityOwnerSlot] = {}
+        self._by_name_and_version: dict[tuple[str, Optional[str]], _ActivityOwnerSlot] = {}
+
+    def find_conflicting_profile(
+            self,
+            activity: SandboxActivity,
+            worker_profile_id: str) -> Optional[str]:
+        """Return the profile that first claimed an overlapping activity, if any."""
+        name_key = activity.name.casefold()
+        if activity.version is None:
+            # An unversioned activity overlaps every version of the same name.
+            owner = _first_owner_other_than(self._by_name.get(name_key), worker_profile_id)
+        else:
+            # A versioned activity overlaps the same version plus any
+            # unversioned registration of the same name.
+            owner = _earlier_owner(
+                _first_owner_other_than(
+                    self._by_name_and_version.get((name_key, None)), worker_profile_id),
+                _first_owner_other_than(
+                    self._by_name_and_version.get((name_key, activity.version)), worker_profile_id))
+        return None if owner is None else owner[1]
+
+    def add(self, activity: SandboxActivity, worker_profile_id: str) -> None:
+        """Record `worker_profile_id` as an owner of `activity`."""
+        name_key = activity.name.casefold()
+        order = self._registration_count
+        self._registration_count += 1
+        self._by_name.setdefault(name_key, _ActivityOwnerSlot()).add(order, worker_profile_id)
+        self._by_name_and_version.setdefault(
+            (name_key, activity.version), _ActivityOwnerSlot()).add(order, worker_profile_id)
+
+
+def _first_owner_other_than(
+        slot: Optional[_ActivityOwnerSlot],
+        worker_profile_id: str) -> Optional[tuple[int, str]]:
+    return None if slot is None else slot.first_owner_other_than(worker_profile_id)
+
+
+def _earlier_owner(
+        left: Optional[tuple[int, str]],
+        right: Optional[tuple[int, str]]) -> Optional[tuple[int, str]]:
+    if left is None:
+        return right
+    if right is None:
+        return left
+    return left if left[0] <= right[0] else right
+
+
 def build_sandbox_worker_profiles() -> list[pb.SandboxWorkerProfile]:
     """Build sandbox worker_profiles from worker profile configuration."""
     worker_profiles: list[pb.SandboxWorkerProfile] = []
-    activity_owners: list[tuple[SandboxActivity, str]] = []
+    activity_owners = _ActivityOwnerIndex()
     for profile in registered_sandbox_worker_profiles():
         activities = resolve_activities(profile.activities)
 
         for activity in activities:
-            existing_profile = next((owner_profile for owner_activity, owner_profile in activity_owners
-                                     if activities_overlap(owner_activity, activity)
-                                     and owner_profile != profile.worker_profile_id), None)
+            existing_profile = activity_owners.find_conflicting_profile(
+                activity, profile.worker_profile_id)
             if existing_profile:
                 raise ValueError(
                     f"Sandbox activity '{format_activity(activity)}' is assigned to both worker profile "
                     f"'{existing_profile}' and '{profile.worker_profile_id}'.")
-            activity_owners.append((activity, profile.worker_profile_id))
+            activity_owners.add(activity, profile.worker_profile_id)
 
         worker_profiles.append(_build_sandbox_worker_profile(
             activities=activities,

{durabletask_azuremanaged-1.8.0 → durabletask_azuremanaged-1.9.0}/durabletask/azuremanaged/preview/sandboxes/worker.py

@@ -130,30 +130,50 @@ class SandboxWorker(DurableTaskSchedulerWorker):
 
     def _run_sandbox_registration_loop(self) -> None:
         retry_delay = 1.0
-        while not self._sandbox_registration_stop.is_set():
-            try:
-                client = SandboxActivitiesGrpcTransport(
-                    host_address=self._sandbox_host_address,
-                    taskhub=self._sandbox_taskhub,
-                    token_credential=self._sandbox_token_credential,
-                    secure_channel=self._sandbox_secure_channel)
+        client: Optional[SandboxActivitiesGrpcTransport] = None
+        try:
+            while not self._sandbox_registration_stop.is_set():
                 try:
+                    if client is None:
+                        client = SandboxActivitiesGrpcTransport(
+                            host_address=self._sandbox_host_address,
+                            taskhub=self._sandbox_taskhub,
+                            token_credential=self._sandbox_token_credential,
+                            secure_channel=self._sandbox_secure_channel)
                     client.connect_sandbox_activity_worker(self._registration_messages())
                     retry_delay = 1.0
-                finally:
-                    client.close()
-            except Exception as ex:
-                if self._sandbox_registration_stop.is_set():
-                    break
-                if not _is_retriable_registration_failure(ex):
-                    self._sandbox_logger.error(
-                        "Sandbox activity worker registration failed permanently: %s", ex)
-                    self._sandbox_registration_stop.set()
-                    break
-                self._sandbox_logger.warning("Sandbox activity worker registration failed: %s", ex)
-                delay = random.uniform(0, retry_delay)
-                self._sandbox_registration_stop.wait(delay)
-                retry_delay = min(retry_delay * 2, 30.0)
+                except Exception as ex:
+                    # gRPC channels reconnect on their own after transient stream
+                    # failures, so the transport (and its channel, stub, and cached
+                    # access token) is reused instead of being rebuilt per attempt.
+                    if _requires_new_registration_transport(ex):
+                        self._close_sandbox_registration_transport(client)
+                        client = None
+                    if self._sandbox_registration_stop.is_set():
+                        break
+                    if not _is_retriable_registration_failure(ex):
+                        self._sandbox_logger.error(
+                            "Sandbox activity worker registration failed permanently: %s", ex)
+                        self._sandbox_registration_stop.set()
+                        break
+                    self._sandbox_logger.warning(
+                        "Sandbox activity worker registration failed: %s", ex)
+                    delay = random.uniform(0, retry_delay)
+                    self._sandbox_registration_stop.wait(delay)
+                    retry_delay = min(retry_delay * 2, 30.0)
+        finally:
+            self._close_sandbox_registration_transport(client)
+
+    def _close_sandbox_registration_transport(
+            self,
+            client: Optional[SandboxActivitiesGrpcTransport]) -> None:
+        if client is None:
+            return
+        try:
+            client.close()
+        except Exception as ex:
+            self._sandbox_logger.debug(
+                "Sandbox activity worker registration transport failed to close: %s", ex)
 
     def _registration_messages(self) -> Iterator[pb.SandboxActivityWorkerMessage]:
         yield build_sandbox_worker_start(
@@ -264,6 +284,26 @@ def _is_retriable_registration_failure(ex: Exception) -> bool:
     return isinstance(ex, OSError)
 
 
+def _requires_new_registration_transport(ex: Exception) -> bool:
+    """Returns whether a failure leaves the registration transport unusable.
+
+    A gRPC channel transparently reconnects after a stream fails, so the same
+    transport can serve the next registration attempt. A channel that has been
+    shut down rejects every later RPC, and a failure raised outside of gRPC (for
+    example while the channel itself is being created) can leave the transport
+    only partially initialized, so both cases need a replacement transport.
+    """
+    if not isinstance(ex, grpc.RpcError):
+        return True
+
+    if ex.code() != grpc.StatusCode.CANCELLED:
+        return False
+
+    details = getattr(ex, "details", None)
+    resolved_details = details() if callable(details) else None
+    return isinstance(resolved_details, str) and "channel closed" in resolved_details.lower()
+
+
 def _resolve_max_concurrent_activities() -> int:
     value = os.getenv("DTS_SANDBOX_MAX_ACTIVITIES")
     if value is None:

{durabletask_azuremanaged-1.8.0 → durabletask_azuremanaged-1.9.0}/durabletask.azuremanaged.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durabletask.azuremanaged
-Version: 1.8.0
+Version: 1.9.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.8.0
+Requires-Dist: durabletask>=1.9.0
 Requires-Dist: azure-identity>=1.19.0
 Provides-Extra: azure-blob-payloads
-Requires-Dist: durabletask[azure-blob-payloads]>=1.8.0; extra == "azure-blob-payloads"
+Requires-Dist: durabletask[azure-blob-payloads]>=1.9.0; extra == "azure-blob-payloads"

durabletask_azuremanaged-1.9.0/durabletask.azuremanaged.egg-info/requires.txt

@@ -0,0 +1,5 @@
+durabletask>=1.9.0
+azure-identity>=1.19.0
+
+[azure-blob-payloads]
+durabletask[azure-blob-payloads]>=1.9.0

{durabletask_azuremanaged-1.8.0 → durabletask_azuremanaged-1.9.0}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durabletask.azuremanaged"
-version = "1.8.0"
+version = "1.9.0"
 description = "Durable Task Python SDK provider implementation for the Azure Durable Task Scheduler"
 keywords = [
     "durable",
@@ -26,13 +26,13 @@ requires-python = ">=3.10"
 license = {file = "LICENSE"}
 readme = "README.md"
 dependencies = [
-    "durabletask>=1.8.0",
+    "durabletask>=1.9.0",
     "azure-identity>=1.19.0"
 ]
 
 [project.optional-dependencies]
 azure-blob-payloads = [
-    "durabletask[azure-blob-payloads]>=1.8.0"
+    "durabletask[azure-blob-payloads]>=1.9.0"
 ]
 
 [project.urls]

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

@@ -1,32 +0,0 @@
-# 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",
-]

durabletask_azuremanaged-1.8.0/durabletask.azuremanaged.egg-info/requires.txt

@@ -1,5 +0,0 @@
-durabletask>=1.8.0
-azure-identity>=1.19.0
-
-[azure-blob-payloads]
-durabletask[azure-blob-payloads]>=1.8.0