durabletask.azuremanaged 0.0.0.dev1__tar.gz

durabletask_azuremanaged-0.0.0.dev1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: durabletask.azuremanaged
+Version: 0.0.0.dev1
+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
+Keywords: durable,task,workflow,azure
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: durabletask>=1.1.0
+Requires-Dist: azure-identity>=1.19.0

durabletask_azuremanaged-0.0.0.dev1/durabletask/azuremanaged/client.py

@@ -0,0 +1,41 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import logging
+
+from typing import Optional
+
+from azure.core.credentials import TokenCredential
+
+from durabletask.azuremanaged.internal.durabletask_grpc_interceptor import (
+    DTSDefaultClientInterceptorImpl,
+)
+from durabletask.client import TaskHubGrpcClient
+
+
+# Client class used for Durable Task Scheduler (DTS)
+class DurableTaskSchedulerClient(TaskHubGrpcClient):
+    def __init__(self, *,
+                 host_address: str,
+                 taskhub: str,
+                 token_credential: Optional[TokenCredential],
+                 secure_channel: bool = True,
+                 default_version: Optional[str] = None,
+                 log_handler: Optional[logging.Handler] = None,
+                 log_formatter: Optional[logging.Formatter] = None):
+
+        if not taskhub:
+            raise ValueError("Taskhub value cannot be empty. Please provide a value for your taskhub")
+
+        interceptors = [DTSDefaultClientInterceptorImpl(token_credential, taskhub)]
+
+        # We pass in None for the metadata so we don't construct an additional interceptor in the parent class
+        # Since the parent class doesn't use anything metadata for anything else, we can set it as None
+        super().__init__(
+            host_address=host_address,
+            secure_channel=secure_channel,
+            metadata=None,
+            log_handler=log_handler,
+            log_formatter=log_formatter,
+            interceptors=interceptors,
+            default_version=default_version)

durabletask_azuremanaged-0.0.0.dev1/durabletask/azuremanaged/internal/access_token_manager.py

@@ -0,0 +1,49 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from azure.core.credentials import AccessToken, TokenCredential
+
+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]
+
+    def __init__(self, token_credential: Optional[TokenCredential], 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")
+
+        self._credential = token_credential
+
+        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
+
+    def get_access_token(self) -> Optional[AccessToken]:
+        if self._token is None or self.is_token_expired():
+            self.refresh_token()
+        return self._token
+
+    # Checks if the token is expired, or if it will expire in the next "refresh_interval_seconds" seconds.
+    # For example, if the token is created to have a lifespan of 2 hours, and the refresh buffer is set to 30 minutes,
+    # We will grab a new token when there're 30minutes left on the lifespan of the token
+    def is_token_expired(self) -> bool:
+        if self.expiry_time is None:
+            return True
+        return datetime.now(timezone.utc) >= (self.expiry_time - timedelta(seconds=self._refresh_interval_seconds))
+
+    def refresh_token(self):
+        if self._credential is not None:
+            self._token = self._credential.get_token(self._scope)
+
+            # Convert UNIX timestamp to timezone-aware datetime
+            self.expiry_time = datetime.fromtimestamp(self._token.expires_on, tz=timezone.utc)
+            self._logger.debug(f"Token refreshed. Expires at: {self.expiry_time}")

durabletask_azuremanaged-0.0.0.dev1/durabletask/azuremanaged/internal/durabletask_grpc_interceptor.py

@@ -0,0 +1,54 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+from importlib.metadata import version
+from typing import Optional
+
+import grpc
+from azure.core.credentials import TokenCredential
+
+from durabletask.azuremanaged.internal.access_token_manager import AccessTokenManager
+from durabletask.internal.grpc_interceptor import (
+    DefaultClientInterceptorImpl,
+    _ClientCallDetails,
+)
+
+
+class DTSDefaultClientInterceptorImpl (DefaultClientInterceptorImpl):
+    """The class implements a UnaryUnaryClientInterceptor, UnaryStreamClientInterceptor,
+    StreamUnaryClientInterceptor and StreamStreamClientInterceptor from grpc to add an
+    interceptor to add additional headers to all calls as needed."""
+
+    def __init__(self, token_credential: Optional[TokenCredential], 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}"
+        self._metadata = [
+            ("taskhub", taskhub_name),
+            ("x-user-agent", user_agent)]  # 'user-agent' is a reserved header in grpc, so we use 'x-user-agent' instead
+        super().__init__(self._metadata)
+
+        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._metadata.append(("authorization", f"Bearer {access_token.token}"))
+
+    def _intercept_call(
+            self, client_call_details: _ClientCallDetails) -> grpc.ClientCallDetails:
+        """Internal intercept_call implementation which adds metadata to grpc metadata in the RPC
+            call details."""
+        # Refresh the auth token if it is present and needed
+        if self._metadata is not None:
+            for i, (key, _) in enumerate(self._metadata):
+                if key.lower() == "authorization":  # Ensure case-insensitive comparison
+                    new_token = self._token_manager.get_access_token()  # Get the new token
+                    if new_token is not None:
+                        self._metadata[i] = ("authorization", f"Bearer {new_token.token}")  # Update the token
+
+        return super()._intercept_call(client_call_details)

durabletask_azuremanaged-0.0.0.dev1/durabletask/azuremanaged/worker.py

@@ -0,0 +1,83 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+import logging
+
+from typing import Optional
+
+from azure.core.credentials import TokenCredential
+
+from durabletask.azuremanaged.internal.durabletask_grpc_interceptor import \
+    DTSDefaultClientInterceptorImpl
+from durabletask.worker import ConcurrencyOptions, TaskHubGrpcWorker
+
+
+# Worker class used for Durable Task Scheduler (DTS)
+class DurableTaskSchedulerWorker(TaskHubGrpcWorker):
+    """A worker implementation for Azure Durable Task Scheduler (DTS).
+
+    This class extends TaskHubGrpcWorker to provide integration with Azure's
+    Durable Task Scheduler service. It handles authentication via Azure credentials
+    and configures the necessary gRPC interceptors for DTS communication.
+
+    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.
+            If None, anonymous authentication will be used.
+        secure_channel (bool, optional): Whether to use a secure gRPC channel (TLS).
+            Defaults to True.
+        concurrency_options (Optional[ConcurrencyOptions], optional): Configuration
+            for controlling worker concurrency limits. If None, default concurrency
+            settings will be used.
+        log_handler (Optional[logging.Handler], optional): Custom logging handler for worker logs.
+        log_formatter (Optional[logging.Formatter], optional): Custom log formatter for worker logs.
+
+    Raises:
+        ValueError: If taskhub is empty or None.
+
+    Example:
+        >>> from azure.identity import DefaultAzureCredential
+        >>> from durabletask.azuremanaged import DurableTaskSchedulerWorker
+        >>> from durabletask.worker import ConcurrencyOptions
+        >>>
+        >>> credential = DefaultAzureCredential()
+        >>> concurrency = ConcurrencyOptions(max_concurrent_activities=10)
+        >>> worker = DurableTaskSchedulerWorker(
+        ...     host_address="my-dts-service.azure.com:443",
+        ...     taskhub="my-task-hub",
+        ...     token_credential=credential,
+        ...     concurrency_options=concurrency
+        ... )
+
+    Note:
+        This worker automatically configures DTS-specific gRPC interceptors
+        for authentication and task hub routing. The parent class metadata
+        parameter is set to None since authentication is handled by the
+        DTS interceptor.
+    """
+
+    def __init__(self, *,
+                 host_address: str,
+                 taskhub: str,
+                 token_credential: Optional[TokenCredential],
+                 secure_channel: bool = True,
+                 concurrency_options: Optional[ConcurrencyOptions] = None,
+                 log_handler: Optional[logging.Handler] = None,
+                 log_formatter: Optional[logging.Formatter] = None):
+
+        if not taskhub:
+            raise ValueError("The taskhub value cannot be empty.")
+
+        interceptors = [DTSDefaultClientInterceptorImpl(token_credential, taskhub)]
+
+        # We pass in None for the metadata so we don't construct an additional interceptor in the parent class
+        # Since the parent class doesn't use anything metadata for anything else, we can set it as None
+        super().__init__(
+            host_address=host_address,
+            secure_channel=secure_channel,
+            metadata=None,
+            log_handler=log_handler,
+            log_formatter=log_formatter,
+            interceptors=interceptors,
+            concurrency_options=concurrency_options)

durabletask_azuremanaged-0.0.0.dev1/durabletask.azuremanaged.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: durabletask.azuremanaged
+Version: 0.0.0.dev1
+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
+Keywords: durable,task,workflow,azure
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: durabletask>=1.1.0
+Requires-Dist: azure-identity>=1.19.0

durabletask_azuremanaged-0.0.0.dev1/durabletask.azuremanaged.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+pyproject.toml
+durabletask.azuremanaged.egg-info/PKG-INFO
+durabletask.azuremanaged.egg-info/SOURCES.txt
+durabletask.azuremanaged.egg-info/dependency_links.txt
+durabletask.azuremanaged.egg-info/requires.txt
+durabletask.azuremanaged.egg-info/top_level.txt
+durabletask/azuremanaged/__init__.py
+durabletask/azuremanaged/client.py
+durabletask/azuremanaged/py.typed
+durabletask/azuremanaged/worker.py
+durabletask/azuremanaged/internal/access_token_manager.py
+durabletask/azuremanaged/internal/durabletask_grpc_interceptor.py
+durabletask/azuremanaged/internal/py.typed

durabletask_azuremanaged-0.0.0.dev1/durabletask.azuremanaged.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

durabletask_azuremanaged-0.0.0.dev1/durabletask.azuremanaged.egg-info/requires.txt

@@ -0,0 +1,2 @@
+durabletask>=1.1.0
+azure-identity>=1.19.0

durabletask_azuremanaged-0.0.0.dev1/durabletask.azuremanaged.egg-info/top_level.txt

@@ -0,0 +1 @@
+durabletask

durabletask_azuremanaged-0.0.0.dev1/pyproject.toml

@@ -0,0 +1,41 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+# For more information on pyproject.toml, see https://peps.python.org/pep-0621/
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "durabletask.azuremanaged"
+version = "0.0.0.dev1"
+description = "Durable Task Python SDK provider implementation for the Azure Durable Task Scheduler"
+keywords = [
+    "durable",
+    "task",
+    "workflow",
+    "azure"
+]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+]
+requires-python = ">=3.10"
+license = {file = "LICENSE"}
+readme = "README.md"
+dependencies = [
+    "durabletask>=1.1.0",
+    "azure-identity>=1.19.0"
+]
+
+[project.urls]
+repository = "https://github.com/microsoft/durabletask-python"
+changelog = "https://github.com/microsoft/durabletask-python/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+include = ["durabletask.azuremanaged", "durabletask.azuremanaged.*"]
+
+[tool.pytest.ini_options]
+minversion = "6.0"

durabletask_azuremanaged-0.0.0.dev1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+