atlan-application-sdk 0.1.1rc62__py3-none-any.whl → 0.1.1rc64__py3-none-any.whl

application_sdk/clients/atlan_auth.py

@@ -1,17 +1,17 @@
 """OAuth2 token manager with automatic secret store discovery."""
 
 import time
-from typing import Any, Dict, Optional
+from typing import Dict, Optional
 
 import aiohttp
 
 from application_sdk.common.error_codes import ClientError
 from application_sdk.constants import (
     APPLICATION_NAME,
+    AUTH_ENABLED,
+    AUTH_URL,
     WORKFLOW_AUTH_CLIENT_ID_KEY,
     WORKFLOW_AUTH_CLIENT_SECRET_KEY,
-    WORKFLOW_AUTH_ENABLED,
-    WORKFLOW_AUTH_URL_KEY,
 )
 from application_sdk.observability.logger_adaptor import get_logger
 from application_sdk.services.secretstore import SecretStore
@@ -39,9 +39,8 @@ class AtlanAuthClient:
         (environment variables, AWS Secrets Manager, Azure Key Vault, etc.)
         """
         self.application_name = APPLICATION_NAME
-        self.auth_config: Dict[str, Any] = SecretStore.get_deployment_secret()
-        self.auth_enabled: bool = WORKFLOW_AUTH_ENABLED
-        self.auth_url: Optional[str] = None
+        self.auth_enabled: bool = AUTH_ENABLED
+        self.auth_url: Optional[str] = AUTH_URL
 
         # Secret store credentials (cached after first fetch)
         self.credentials: Optional[Dict[str, str]] = None
@@ -175,18 +174,17 @@ class AtlanAuthClient:
 
     async def _extract_auth_credentials(self) -> Optional[Dict[str, str]]:
         """Fetch app credentials from secret store - auth-specific logic"""
-        if (
-            WORKFLOW_AUTH_CLIENT_ID_KEY in self.auth_config
-            and WORKFLOW_AUTH_CLIENT_SECRET_KEY in self.auth_config
-        ):
+        client_id = SecretStore.get_deployment_secret(WORKFLOW_AUTH_CLIENT_ID_KEY)
+        client_secret = SecretStore.get_deployment_secret(
+            WORKFLOW_AUTH_CLIENT_SECRET_KEY
+        )
+
+        if client_id and client_secret:
             credentials = {
-                "client_id": self.auth_config[WORKFLOW_AUTH_CLIENT_ID_KEY],
-                "client_secret": self.auth_config[WORKFLOW_AUTH_CLIENT_SECRET_KEY],
+                "client_id": client_id,
+                "client_secret": client_secret,
             }
 
-            if WORKFLOW_AUTH_URL_KEY in self.auth_config:
-                self.auth_url = self.auth_config[WORKFLOW_AUTH_URL_KEY]
-
             return credentials
         return None
 
@@ -199,10 +197,8 @@ class AtlanAuthClient:
         """
         # we are doing this to force a fetch of the credentials from secret store
         self.credentials = None
-        self.auth_url = None
         self._access_token = None
         self._token_expiry = 0
-        self.auth_config = {}
 
     def calculate_refresh_interval(self) -> int:
         """Calculate the optimal token refresh interval based on token expiry.

application_sdk/clients/temporal.py

@@ -18,14 +18,13 @@ from application_sdk.clients.workflow import WorkflowClient
 from application_sdk.constants import (
     APPLICATION_NAME,
     DEPLOYMENT_NAME,
-    DEPLOYMENT_NAME_KEY,
     IS_LOCKING_DISABLED,
     MAX_CONCURRENT_ACTIVITIES,
     WORKFLOW_HOST,
     WORKFLOW_MAX_TIMEOUT_HOURS,
     WORKFLOW_NAMESPACE,
     WORKFLOW_PORT,
-    WORKFLOW_TLS_ENABLED_KEY,
+    WORKFLOW_TLS_ENABLED,
 )
 from application_sdk.events.models import (
     ApplicationEventNames,
@@ -97,7 +96,6 @@ class TemporalWorkflowClient(WorkflowClient):
         self.port = port if port else WORKFLOW_PORT
         self.namespace = namespace if namespace else WORKFLOW_NAMESPACE
 
-        self.deployment_config: Dict[str, Any] = SecretStore.get_deployment_secret()
         self.worker_task_queue = self.get_worker_task_queue()
         self.auth_manager = AtlanAuthClient()
 
@@ -118,12 +116,8 @@ class TemporalWorkflowClient(WorkflowClient):
         Returns:
             str: The task queue name in format "app_name-deployment_name".
         """
-        deployment_name = self.deployment_config.get(
-            DEPLOYMENT_NAME_KEY, DEPLOYMENT_NAME
-        )
-
-        if deployment_name:
-            return f"atlan-{self.application_name}-{deployment_name}"
+        if DEPLOYMENT_NAME:
+            return f"atlan-{self.application_name}-{DEPLOYMENT_NAME}"
         else:
             return self.application_name
 
@@ -228,12 +222,9 @@ class TemporalWorkflowClient(WorkflowClient):
         connection_options: Dict[str, Any] = {
             "target_host": self.get_connection_string(),
             "namespace": self.namespace,
-            "tls": False,
+            "tls": WORKFLOW_TLS_ENABLED,
         }
 
-        connection_options["tls"] = self.deployment_config.get(
-            WORKFLOW_TLS_ENABLED_KEY, False
-        )
         self.worker_task_queue = self.get_worker_task_queue()
 
         if self.auth_manager.auth_enabled:

application_sdk/constants.py

@@ -105,16 +105,23 @@ MAX_CONCURRENT_ACTIVITIES = int(os.getenv("ATLAN_MAX_CONCURRENT_ACTIVITIES", "5"
 DEPLOYMENT_SECRET_PATH = os.getenv(
     "ATLAN_DEPLOYMENT_SECRET_PATH", "ATLAN_DEPLOYMENT_SECRETS"
 )
-WORKFLOW_AUTH_ENABLED = (
-    os.getenv("ATLAN_WORKFLOW_AUTH_ENABLED", "false").lower() == "true"
+AUTH_ENABLED = os.getenv("ATLAN_AUTH_ENABLED", "false").lower() == "true"
+#: OAuth2 authentication URL for workflow services
+AUTH_URL = os.getenv("ATLAN_AUTH_URL")
+#: Whether to enable TLS for Temporal workflow connections
+WORKFLOW_TLS_ENABLED = (
+    os.getenv("ATLAN_WORKFLOW_TLS_ENABLED", "false").lower() == "true"
 )
 
 # Deployment Secret Store Key Names
-WORKFLOW_AUTH_CLIENT_ID_KEY = f"{APPLICATION_NAME}_app_client_id"
-WORKFLOW_AUTH_CLIENT_SECRET_KEY = f"{APPLICATION_NAME}_app_client_secret"
-WORKFLOW_AUTH_URL_KEY = "atlan_auth_url"
-WORKFLOW_TLS_ENABLED_KEY = "workflow_tls_enabled"
-DEPLOYMENT_NAME_KEY = "deployment_name"
+#: Key name for OAuth2 client ID in deployment secrets (can be overridden via ATLAN_AUTH_CLIENT_ID_KEY)
+WORKFLOW_AUTH_CLIENT_ID_KEY = os.getenv(
+    "ATLAN_AUTH_CLIENT_ID_KEY", "ATLAN_AUTH_CLIENT_ID"
+)
+#: Key name for OAuth2 client secret in deployment secrets (can be overridden via ATLAN_AUTH_CLIENT_SECRET_KEY)
+WORKFLOW_AUTH_CLIENT_SECRET_KEY = os.getenv(
+    "ATLAN_AUTH_CLIENT_SECRET_KEY", "ATLAN_AUTH_CLIENT_SECRET"
+)
 
 # Workflow Constants
 #: Timeout duration for activity heartbeats
@@ -270,3 +277,9 @@ LOCK_RETRY_INTERVAL_SECONDS = int(os.getenv("LOCK_RETRY_INTERVAL_SECONDS", "60")
 #: with the application.
 ENABLE_MCP = os.getenv("ENABLE_MCP", "false").lower() == "true"
 MCP_METADATA_KEY = "__atlan_application_sdk_mcp_metadata"
+
+
+# Disable Analytics Configuration for DAFT
+os.environ["DO_NOT_TRACK"] = "true"
+os.environ["SCARF_NO_ANALYTICS"] = "true"
+os.environ["DAFT_ANALYTICS_ENABLED"] = "0"

application_sdk/events/models.py

@@ -155,6 +155,7 @@ class WorkerStartEventData(BaseModel):
 
     Attributes:
         application_name: Name of the application the worker belongs to.
+        deployment_name: Name of the deployment the worker belongs to.
         task_queue: Task queue name for the worker.
         namespace: Temporal namespace for the worker.
         host: Host address of the Temporal server.
@@ -167,6 +168,7 @@ class WorkerStartEventData(BaseModel):
 
     version: str = WORKER_START_EVENT_VERSION
     application_name: str
+    deployment_name: str
     task_queue: str
     namespace: str
     host: str

application_sdk/services/secretstore.py

@@ -1,9 +1,21 @@
-"""Unified secret store service for the application."""
+"""Unified secret store service for the application.
+
+Logic summary:
+
+    1. Fetch credential config from state store.
+
+    2. Determine mode: Multi-key if (credentialSource == 'direct' OR secret-path is defined), Single-key otherwise.
+
+    3. Fetch secrets accordingly: Multi-key uses secret_path if credentialSource == "agent" else credential_guid, Single-key fetches each field individually.
+
+    4. Merge & resolve secrets.
+"""
 
 import collections.abc
 import copy
 import json
 import uuid
+from enum import Enum
 from typing import Any, Dict
 
 from dapr.clients import DaprClient
@@ -23,8 +35,22 @@ from application_sdk.services.statestore import StateStore, StateType
 logger = get_logger(__name__)
 
 
+class CredentialSource(Enum):
+    """Enumeration of credential source types."""
+
+    DIRECT = "direct"
+    AGENT = "agent"
+
+
+class SecretMode(Enum):
+    """Enumeration of secret retrieval modes."""
+
+    MULTI_KEY = "multi-key"
+    SINGLE_KEY = "single-key"
+
+
 class SecretStore:
-    """Unified secret store service for handling secret management."""
+    """Unified secret store service for handling secret management across providers."""
 
     @classmethod
     async def get_credentials(cls, credential_guid: str) -> Dict[str, Any]:
@@ -33,6 +59,8 @@ class SecretStore:
         This method retrieves credential configuration from the state store and resolves
         any secret references by fetching actual values from the secret store.
 
+        Supports Multi-key mode (direct / has secret-path) and Single-key mode (no secret-path, non-direct).
+
         Args:
             credential_guid (str): The unique GUID of the credential configuration to resolve.
 
@@ -48,7 +76,6 @@ class SecretStore:
             >>> creds = await SecretStore.get_credentials("db-cred-abc123")
             >>> print(f"Connecting to {creds['host']}:{creds['port']}")
             >>> # Password is automatically resolved from secret store
-
             >>> # Handle resolution errors
             >>> try:
             ...     creds = await SecretStore.get_credentials("invalid-guid")
@@ -62,13 +89,44 @@ class SecretStore:
                 credential_guid, StateType.CREDENTIALS
             )
 
-            # Fetch secret data from secret store
-            secret_key = credential_config.get("secret-path", credential_guid)
-            secret_data = SecretStore.get_secret(secret_key=secret_key)
+            credential_source_str = credential_config.get(
+                "credentialSource", CredentialSource.DIRECT.value
+            )
+            try:
+                credential_source = CredentialSource(credential_source_str)
+            except ValueError:
+                credential_source = CredentialSource.DIRECT
+            secret_path = credential_config.get("secret-path")
+
+            secret_data: Dict[str, Any] = {}
 
-            # Resolve credentials
-            credential_source = credential_config.get("credentialSource", "direct")
-            if credential_source == "direct":
+            # Decide mode
+            if credential_source == CredentialSource.DIRECT or secret_path:
+                mode = SecretMode.MULTI_KEY
+            else:
+                mode = SecretMode.SINGLE_KEY
+
+            # Multi-key secret fetch (direct or has secret-path)
+            if mode == SecretMode.MULTI_KEY:
+                key_to_fetch = (
+                    secret_path
+                    if credential_source == CredentialSource.AGENT
+                    else credential_guid
+                )
+                try:
+                    logger.debug(f"Fetching multi-key secret from '{key_to_fetch}'")
+                    secret_data = cls.get_secret(secret_key=key_to_fetch)
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to fetch secret bundle '{key_to_fetch}': {e}"
+                    )
+
+            # Single-key mode → per-field secret lookup
+            else:
+                secret_data = cls._fetch_single_key_secrets(credential_config)
+
+            # Merge or resolve references
+            if credential_source == CredentialSource.DIRECT:
                 credential_config.update(secret_data)
                 return credential_config
             else:
@@ -78,12 +136,59 @@ class SecretStore:
             # Run async operations directly
             return await _get_credentials_async(credential_guid)
         except Exception as e:
-            logger.error(f"Error resolving credentials: {str(e)}")
+            logger.error(f"Error resolving credentials for {credential_guid}: {str(e)}")
             raise CommonError(
                 CommonError.CREDENTIALS_RESOLUTION_ERROR,
                 f"Failed to resolve credentials: {str(e)}",
             )
 
+    # Secret resolution helpers
+
+    @classmethod
+    def _fetch_single_key_secrets(
+        cls, credential_config: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Fetch secrets in single-key mode by looking up each field individually.
+
+        Args:
+            credential_config: The credential configuration dictionary
+
+        Returns:
+            Dictionary containing collected secret values
+        """
+        logger.debug("Single-key mode: fetching secrets per field")
+        collected = {}
+        for field, value in credential_config.items():
+            if isinstance(value, str):
+                try:
+                    single_secret = cls.get_secret(value)
+                    if single_secret:
+                        for k, v in single_secret.items():
+                            # Only filter out None and empty strings, not all falsy values.
+                            # This preserves valid secret values like False, 0, 0.0 which are
+                            # legitimate secret values that should not be excluded.
+                            if v is None or v == "":
+                                continue
+                            collected[k] = v
+                except Exception as e:
+                    logger.debug(f"Skipping '{field}' → '{value}' ({e})")
+            elif field == "extra" and isinstance(value, dict):
+                # Recursively process string values in the extra dictionary
+                for extra_key, extra_value in value.items():
+                    if isinstance(extra_value, str):
+                        try:
+                            single_secret = cls.get_secret(extra_value)
+                            if single_secret:
+                                for k, v in single_secret.items():
+                                    if v is None or v == "":
+                                        continue
+                                    collected[k] = v
+                        except Exception as e:
+                            logger.debug(
+                                f"Skipping 'extra.{extra_key}' → '{extra_value}' ({e})"
+                            )
+        return collected
+
     @classmethod
     def resolve_credentials(
         cls, credential_config: Dict[str, Any], secret_data: Dict[str, Any]
@@ -106,7 +211,6 @@ class SecretStore:
             >>> secrets = {"db_password_key": "actual_secret_password"}
             >>> resolved = SecretStore.resolve_credentials(config, secrets)
             >>> print(resolved)  # {"host": "db.example.com", "password": "actual_secret_password"}
-
             >>> # Resolution with nested 'extra' fields
             >>> config = {
             ...     "host": "db.example.com",
@@ -125,51 +229,65 @@ class SecretStore:
         # Apply the same substitution to the 'extra' dictionary if it exists
         if "extra" in credentials and isinstance(credentials["extra"], dict):
             for key, value in list(credentials["extra"].items()):
-                if isinstance(value, str):
-                    if value in secret_data:
-                        credentials["extra"][key] = secret_data[value]
-                    elif value in secret_data.get("extra", {}):
-                        credentials["extra"][key] = secret_data["extra"][value]
+                if isinstance(value, str) and value in secret_data:
+                    credentials["extra"][key] = secret_data[value]
 
         return credentials
 
     @classmethod
-    def get_deployment_secret(cls) -> Dict[str, Any]:
-        """Get deployment configuration from the deployment secret store.
+    def get_deployment_secret(cls, key: str) -> Any:
+        """Get a specific key from deployment configuration in the deployment secret store.
 
         Validates that the deployment secret store component is registered
         before attempting to fetch secrets to prevent errors. This method
-        is commonly used to retrieve environment-specific configuration.
+        fetches only the specified key from the deployment secret, rather than
+        the entire secret dictionary.
+
+        Args:
+            key (str): The key to fetch from the deployment secret.
 
         Returns:
-            Dict[str, Any]: Deployment configuration data, or empty dict if
-                          component is unavailable or fetch fails.
+            Any: The value for the specified key, or None if the key is not found
+            or the component is unavailable.
 
         Examples:
-            >>> # Get deployment configuration
-            >>> config = SecretStore.get_deployment_secret()
-            >>> if config:
-            ...     print(f"Environment: {config.get('environment')}")
-            ...     print(f"Region: {config.get('region')}")
-            >>> else:
-            ...     print("No deployment configuration available")
-
-            >>> # Use in application initialization
-            >>> deployment_config = SecretStore.get_deployment_secret()
-            >>> if deployment_config.get('debug_mode'):
-            ...     logging.getLogger().setLevel(logging.DEBUG)
+            >>> # Get a specific deployment configuration value
+            >>> auth_url = SecretStore.get_deployment_secret("ATLAN_AUTH_CLIENT_ID")
+            >>> if auth_url:
+            ...     print(f"Auth URL: {auth_url}")
+            >>> # Get deployment name
+            >>> deployment_name = SecretStore.get_deployment_secret("deployment_name")
+            >>> if deployment_name:
+            ...     print(f"Deployment: {deployment_name}")
         """
         if not is_component_registered(DEPLOYMENT_SECRET_STORE_NAME):
             logger.warning(
-                f"Deployment secret store component '{DEPLOYMENT_SECRET_STORE_NAME}' is not registered"
+                f"Deployment secret store component '{DEPLOYMENT_SECRET_STORE_NAME}' not registered."
             )
-            return {}
+            return None
 
         try:
-            return cls.get_secret(DEPLOYMENT_SECRET_PATH, DEPLOYMENT_SECRET_STORE_NAME)
+            secret_data = cls.get_secret(
+                DEPLOYMENT_SECRET_PATH, DEPLOYMENT_SECRET_STORE_NAME
+            )
+            if isinstance(secret_data, dict) and key in secret_data:
+                return secret_data[key]
+
+            logger.debug(f"Multi-key not found, checking single-key secret for '{key}'")
+            single_secret_data = cls.get_secret(key, DEPLOYMENT_SECRET_STORE_NAME)
+            if isinstance(single_secret_data, dict):
+                # Handle both {key:value} and {"value": "..."} cases
+                if key in single_secret_data:
+                    return single_secret_data[key]
+                elif len(single_secret_data) == 1:
+                    # extract single value
+                    return list(single_secret_data.values())[0]
+
+            return None
+
         except Exception as e:
-            logger.error(f"Failed to fetch deployment config: {e}")
-            return {}
+            logger.error(f"Failed to fetch deployment config key '{key}': {e}")
+            return None
 
     @classmethod
     def get_secret(
@@ -182,7 +300,7 @@ class SecretStore:
 
         Args:
             secret_key (str): Key of the secret to fetch from the secret store.
-            component_name (str, optional): Name of the Dapr component to fetch from.
+            component_name (str): Name of the Dapr component to fetch from.
                 Defaults to SECRET_STORE_NAME.
 
         Returns:
@@ -199,7 +317,6 @@ class SecretStore:
             >>> # Get database credentials
             >>> db_secret = SecretStore.get_secret("database-credentials")
             >>> print(f"Host: {db_secret.get('host')}")
-
             >>> # Get from specific component
             >>> api_secret = SecretStore.get_secret(
             ...     "api-keys",
@@ -217,7 +334,7 @@ class SecretStore:
                 return cls._process_secret_data(dapr_secret_object.secret)
         except Exception as e:
             logger.error(
-                f"Failed to fetch secret using component {component_name}: {str(e)}"
+                f"Failed to fetch secret using component '{component_name}': {str(e)}"
             )
             raise
 
@@ -235,17 +352,34 @@ class SecretStore:
         if isinstance(secret_data, collections.abc.Mapping):
             secret_data = dict(secret_data)
 
-        # If the dict has a single key and its value is a JSON string, parse it
-        if len(secret_data) == 1 and isinstance(next(iter(secret_data.values())), str):
+        # Handle single-key secrets gracefully
+        if len(secret_data) == 1:
+            k, v = next(iter(secret_data.items()))
+            return cls._handle_single_key_secret(k, v)
+
+        return secret_data
+
+    # Utility helpers
+
+    @classmethod
+    def _handle_single_key_secret(cls, key: str, value: Any) -> Dict[str, Any]:
+        """Handle single-key secret by attempting to parse JSON value.
+
+        Args:
+            key: The secret key.
+            value: The secret value (may be a JSON string).
+
+        Returns:
+            Dictionary with parsed JSON if value is valid JSON dict, otherwise {key: value}.
+        """
+        if isinstance(value, str):
             try:
-                parsed = json.loads(next(iter(secret_data.values())))
+                parsed = json.loads(value)
                 if isinstance(parsed, dict):
-                    secret_data = parsed
-            except Exception as e:
-                logger.error(f"Failed to parse secret data: {e}")
+                    return parsed
+            except Exception:
                 pass
-
-        return secret_data
+        return {key: value}
 
     @classmethod
     def apply_secret_values(
@@ -275,7 +409,6 @@ class SecretStore:
             ...     "db_password": "secure_db_password"
             ... }
             >>> resolved = SecretStore.apply_secret_values(source, secrets)
-
             >>> # With nested extra fields
             >>> source = {
             ...     "host": "api.example.com",
@@ -328,7 +461,6 @@ class SecretStore:
             ... }
             >>> guid = await SecretStore.save_secret(config)
             >>> print(f"Stored credentials with GUID: {guid}")
-
             >>> # Later retrieve these credentials
             >>> retrieved = await SecretStore.get_credentials(guid)
         """

application_sdk/version.py

@@ -2,4 +2,4 @@
 Version information for the application_sdk package.
 """
 
-__version__ = "0.1.1rc62"
+__version__ = "0.1.1rc64"

application_sdk/worker.py

@@ -14,7 +14,7 @@ from temporalio.types import CallableType, ClassType
 from temporalio.worker import Worker as TemporalWorker
 
 from application_sdk.clients.workflow import WorkflowClient
-from application_sdk.constants import MAX_CONCURRENT_ACTIVITIES
+from application_sdk.constants import DEPLOYMENT_NAME, MAX_CONCURRENT_ACTIVITIES
 from application_sdk.events.models import (
     ApplicationEventNames,
     Event,
@@ -122,6 +122,7 @@ class Worker:
         if self.workflow_client:
             self._worker_creation_event_data = WorkerStartEventData(
                 application_name=self.workflow_client.application_name,
+                deployment_name=DEPLOYMENT_NAME,
                 task_queue=self.workflow_client.worker_task_queue,
                 namespace=self.workflow_client.namespace,
                 host=self.workflow_client.host,

{atlan_application_sdk-0.1.1rc62.dist-info → atlan_application_sdk-0.1.1rc64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc62
+Version: 0.1.1rc64
 Summary: Atlan Application SDK is a Python library for developing applications on the Atlan Platform
 Project-URL: Repository, https://github.com/atlanhq/application-sdk
 Project-URL: Documentation, https://github.com/atlanhq/application-sdk/README.md

{atlan_application_sdk-0.1.1rc62.dist-info → atlan_application_sdk-0.1.1rc64.dist-info}/RECORD

@@ -1,7 +1,7 @@
 application_sdk/__init__.py,sha256=2e2mvmLJ5dxmJGPELtb33xwP-j6JMdoIuqKycEn7hjg,151
-application_sdk/constants.py,sha256=XCRJRiug2GXgeeVZu3Mp1QavRw54bWtzxIZ2l1bIkkA,11028
-application_sdk/version.py,sha256=MFOV2tNUAo7go0hrgOky6QW0SxSDPfPaY9aTrIZC3wg,88
-application_sdk/worker.py,sha256=i5f0AeKI39IfsLO05QkwC6uMz0zDPSJqP7B2byri1VI,7489
+application_sdk/constants.py,sha256=S3I_WUGFbmAPH5GTtoTKD5rxILGevkZ219zhctLQles,11568
+application_sdk/version.py,sha256=Q9wvKTw8AbBOhwCGADxsnpaSLWW9daKc9sh6yO50mMo,88
+application_sdk/worker.py,sha256=D3-wtfGv1DLFKi1YSaE3jTcX66eC00N6RwtBu9RkgNc,7555
 application_sdk/activities/__init__.py,sha256=L5WXkTwOwGtjWAlXrUJRCKGwyIyp3z8fBv8BZVCRFQI,11175
 application_sdk/activities/lock_management.py,sha256=6Wdf3jMKitoarHQP91PIJOoGFz4aaOLS_40c7n1yAOA,3902
 application_sdk/activities/.cursor/BUGBOT.md,sha256=FNykX5aMkdOhzgpiGqstOnSp9JN63iR2XP3onU4AGh8,15843
@@ -18,12 +18,12 @@ application_sdk/application/__init__.py,sha256=hb5zBc4zi-10av8Ivbovhb0CEAwNgr3eF
 application_sdk/application/metadata_extraction/sql.py,sha256=rOd06Wodr4GyzupCYxVSCsNcuNar1rJM66ej9vocNHw,8138
 application_sdk/clients/__init__.py,sha256=C9T84J7V6ZumcoWJPAxdd3tqSmbyciaGBJn-CaCCny0,1341
 application_sdk/clients/atlan.py,sha256=l6yV39fr1006SJFwkOTNDQlbSFlHCZQaUPfdUlzdVEg,5053
-application_sdk/clients/atlan_auth.py,sha256=D7FuNqv81ohNXLJtdx1AFw_jU6a3g0Pw6149ia4ucFY,8930
+application_sdk/clients/atlan_auth.py,sha256=_MykgutI-Ill1t8ERgc1a7QrfaxnrtZjD48FAT-ER9M,8642
 application_sdk/clients/base.py,sha256=TIn3pG89eXUc1XSYf4jk66m1vajWp0WxcCQOOltdazA,14021
 application_sdk/clients/models.py,sha256=iZOTyH6LO64kozdiUPCFCN0NgLhd_Gtv0lH7ZIPdo8w,1800
 application_sdk/clients/redis.py,sha256=IfAD32vLp88BCvsDTaQtxFHxzHlEx4V7TK7h1HwDDBg,15917
 application_sdk/clients/sql.py,sha256=lXeVu_dute30IaWWK5gHBhjEs2dXp_e0XkOMsbOsq64,19589
-application_sdk/clients/temporal.py,sha256=eSbBOmbRmYU-MLiQ1D8hHTU3-VIJssTYAzC2twLwf38,20200
+application_sdk/clients/temporal.py,sha256=ekmgQhOOfPTz7Mi9n85H_p2jS6DF5inxbMGLljTXQyA,19869
 application_sdk/clients/utils.py,sha256=zLFOJbTr_6TOqnjfVFGY85OtIXZ4FQy_rquzjaydkbY,779
 application_sdk/clients/workflow.py,sha256=6bSqmA3sNCk9oY68dOjBUDZ9DhNKQxPD75qqE0cfldc,6104
 application_sdk/clients/.cursor/BUGBOT.md,sha256=7nEDUqWBEMI_uU6eK1jCSZGeXoQtLQcKwOrDn8AIDWo,10595
@@ -55,7 +55,7 @@ application_sdk/docgen/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 application_sdk/docgen/parsers/directory.py,sha256=8Kk2sjb-0l2wLO_njdlcuHjv5akoNgmf-FmaDSaE4WM,7751
 application_sdk/docgen/parsers/manifest.py,sha256=3NP-dBTpHAUQa477usMIDaKSb_9xfLE8G3RX0T1Bq2s,3318
 application_sdk/events/__init__.py,sha256=OcbVWDF4ZKRTJXK9UaFVtYEwu-3DHE77S-Sn6jNafUs,204
-application_sdk/events/models.py,sha256=Q8qt1lW0XimtNI2GFd9o6kO3xOuPt9c8yFqzZJVKCv8,6019
+application_sdk/events/models.py,sha256=kEzJKvb-G1M7aKrLPgAmsukJXLXeh8hIJKwEkOiaY28,6115
 application_sdk/handlers/__init__.py,sha256=3Wf7jCVFR2nYOyHZEc9jj8BQUnHCylFqoezp70J2Df0,1329
 application_sdk/handlers/base.py,sha256=ieWFbv8Gm7vfrrpS-mdMSm-mHGuQY02qiAVX2qPdj3w,2467
 application_sdk/handlers/sql.py,sha256=6A_9xCtkXyNY5gPhImbftzrdPIEWIeTTqjyIewVESHA,17815
@@ -98,7 +98,7 @@ application_sdk/services/__init__.py,sha256=H-5HZEPdr53MUfAggyHqHhRXDRLZFZsxvJgW
 application_sdk/services/atlan_storage.py,sha256=TKzXxu0yXeUcmZehwp8PcnQTC4A9w9RlZ0Fl-Xp1bLE,8509
 application_sdk/services/eventstore.py,sha256=X03JzodKByXh8w8nOl658rnnZfMFTj0IkmiLVbd6IN8,6729
 application_sdk/services/objectstore.py,sha256=7TZSQAoba1-2Eb-C8v9ULhba6-Ss9ym4ICjrISr8CAs,17203
-application_sdk/services/secretstore.py,sha256=UpyLLcdMia1tqFCpRrn-lE9AnERAt2iGVzET6QqkmqI,13976
+application_sdk/services/secretstore.py,sha256=Jd2gYyBcF31x8Hs8d5J93SWBXBdt6ULGvSk-Gfxb8Dw,19072
 application_sdk/services/statestore.py,sha256=3-afiM3Vsoe1XDYRokdGTB5I5CwOKyieuX5RwIZf77o,9413
 application_sdk/test_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 application_sdk/test_utils/workflow_monitoring.py,sha256=gqq6CsT62GrMt2GqtNSb1iD_-t4MBffQvpO0BXboZek,3490
@@ -157,8 +157,8 @@ application_sdk/workflows/metadata_extraction/__init__.py,sha256=jHUe_ZBQ66jx8bg
 application_sdk/workflows/metadata_extraction/sql.py,sha256=6ZaVt84n-8U2ZvR9GR7uIJKv5v8CuyQjhlnoRJvDszc,12435
 application_sdk/workflows/query_extraction/__init__.py,sha256=n066_CX5RpJz6DIxGMkKS3eGSRg03ilaCtsqfJWQb7Q,117
 application_sdk/workflows/query_extraction/sql.py,sha256=kT_JQkLCRZ44ZpaC4QvPL6DxnRIIVh8gYHLqRbMI-hA,4826
-atlan_application_sdk-0.1.1rc62.dist-info/METADATA,sha256=8ApEAfPm6ZpGgjwZtDJ2F_rqLkNCM5L-3ZKTKkdkwJg,5730
-atlan_application_sdk-0.1.1rc62.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-atlan_application_sdk-0.1.1rc62.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-atlan_application_sdk-0.1.1rc62.dist-info/licenses/NOTICE,sha256=A-XVVGt3KOYuuMmvSMIFkg534F1vHiCggEBp4Ez3wGk,1041
-atlan_application_sdk-0.1.1rc62.dist-info/RECORD,,
+atlan_application_sdk-0.1.1rc64.dist-info/METADATA,sha256=EwFzqHyE-Kr85w44hkHi_91zSJBFrSq3GV9BMnJJ_VM,5730
+atlan_application_sdk-0.1.1rc64.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+atlan_application_sdk-0.1.1rc64.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+atlan_application_sdk-0.1.1rc64.dist-info/licenses/NOTICE,sha256=A-XVVGt3KOYuuMmvSMIFkg534F1vHiCggEBp4Ez3wGk,1041
+atlan_application_sdk-0.1.1rc64.dist-info/RECORD,,