atlan-application-sdk 2.1.0__tar.gz → 2.2.0__tar.gz

atlan_application_sdk-2.2.0/.github/release_notes.md

@@ -0,0 +1,8 @@
+## v2.2.0 (January 14, 2026)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v2.1.1...v2.2.0
+
+### Features
+
+- added Azure specific client authentication (#619) (by @rupali-atlan in [37b2e19](https://github.com/atlanhq/application-sdk/commit/37b2e19))
+- Using Pubsub for message processors (#898) (by @niteesh-atlan in [f87f583](https://github.com/atlanhq/application-sdk/commit/f87f583))

{atlan_application_sdk-2.1.0 → atlan_application_sdk-2.2.0}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## v2.2.0 (January 14, 2026)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v2.1.1...v2.2.0
+
+### Features
+
+- added Azure specific client authentication (#619) (by @rupali-atlan in [37b2e19](https://github.com/atlanhq/application-sdk/commit/37b2e19))
+- Using Pubsub for message processors (#898) (by @niteesh-atlan in [f87f583](https://github.com/atlanhq/application-sdk/commit/f87f583))
+
+
+## v2.1.1 (January 08, 2026)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v2.1.0...v2.1.1
+
+### Bug Fixes
+
+- daft struct error (#931) (by @OnkarVO7 in [d64e60b](https://github.com/atlanhq/application-sdk/commit/d64e60b))
+- time based state refresh for each activity (#796) (by @abhishekagrawal-atlan in [3563595](https://github.com/atlanhq/application-sdk/commit/3563595))
+
+
 ## v2.1.0 (January 08, 2026)
 
 Full Changelog: https://github.com/atlanhq/application-sdk/compare/v2.0.0...v2.1.0

{atlan_application_sdk-2.1.0 → atlan_application_sdk-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 2.1.0
+Version: 2.2.0
 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
@@ -30,8 +30,12 @@ Requires-Dist: pyatlan<8.5.0,>=8.0.2
 Requires-Dist: pydantic<2.13.0,>=2.10.6
 Requires-Dist: python-dotenv<1.3.0,>=1.1.0
 Requires-Dist: uvloop<0.23.0,>=0.21.0; sys_platform != 'win32'
+Provides-Extra: azure
+Requires-Dist: azure-identity>=1.15.0; extra == 'azure'
+Requires-Dist: azure-storage-blob>=12.19.0; extra == 'azure'
+Requires-Dist: azure-storage-file-datalake>=12.19.0; extra == 'azure'
 Provides-Extra: daft
-Requires-Dist: daft<0.8.0,>=0.4.12; extra == 'daft'
+Requires-Dist: daft<0.8.0,>=0.7.1; extra == 'daft'
 Provides-Extra: distributed-lock
 Requires-Dist: redis[hiredis]<7.2.0,>=5.2.0; extra == 'distributed-lock'
 Provides-Extra: iam-auth

{atlan_application_sdk-2.1.0 → atlan_application_sdk-2.2.0}/application_sdk/activities/__init__.py

@@ -15,6 +15,7 @@ Example:
 
 import os
 from abc import ABC
+from datetime import datetime, timedelta
 from typing import Any, Dict, Generic, Optional, TypeVar
 
 from pydantic import BaseModel
@@ -62,6 +63,7 @@ class ActivitiesState(BaseModel, Generic[HandlerType]):
     model_config = {"arbitrary_types_allowed": True}
     handler: Optional[HandlerType] = None
     workflow_args: Optional[Dict[str, Any]] = None
+    last_updated_timestamp: Optional[datetime] = None
 
 
 ActivitiesStateType = TypeVar("ActivitiesStateType", bound=ActivitiesState)
@@ -113,12 +115,15 @@ class ActivitiesInterface(ABC, Generic[ActivitiesStateType]):
         Note:
             The workflow ID is automatically retrieved from the current activity context.
             If no state exists for the current workflow, a new one will be created.
+            This method also updates the last_updated_timestamp to enable time-based
+            state refresh functionality.
         """
         workflow_id = get_workflow_id()
         if not self._state.get(workflow_id):
             self._state[workflow_id] = ActivitiesState()
 
         self._state[workflow_id].workflow_args = workflow_args
+        self._state[workflow_id].last_updated_timestamp = datetime.now()
 
     async def _get_state(self, workflow_args: Dict[str, Any]) -> ActivitiesStateType:
         """Retrieve the state for the current workflow.
@@ -142,6 +147,15 @@ class ActivitiesInterface(ABC, Generic[ActivitiesStateType]):
             workflow_id = get_workflow_id()
             if workflow_id not in self._state:
                 await self._set_state(workflow_args)
+
+            else:
+                current_timestamp = datetime.now()
+                # if difference of current_timestamp and last_updated_timestamp is greater than 15 minutes, then again _set_state
+                last_updated = self._state[workflow_id].last_updated_timestamp
+                if last_updated and current_timestamp - last_updated > timedelta(
+                    minutes=15
+                ):
+                    await self._set_state(workflow_args)
             return self._state[workflow_id]
         except OrchestratorError as e:
             logger.error(

{atlan_application_sdk-2.1.0 → atlan_application_sdk-2.2.0}/application_sdk/activities/metadata_extraction/sql.py

@@ -1,4 +1,5 @@
 import os
+from datetime import datetime
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -60,6 +61,7 @@ class BaseSQLMetadataExtractionActivitiesState(ActivitiesState):
     sql_client: Optional[BaseSQLClient] = None
     handler: Optional[BaseSQLHandler] = None
     transformer: Optional[TransformerInterface] = None
+    last_updated_timestamp: Optional[datetime] = None
 
 
 class BaseSQLMetadataExtractionActivities(ActivitiesInterface):
@@ -149,13 +151,30 @@ class BaseSQLMetadataExtractionActivities(ActivitiesInterface):
 
         Args:
             workflow_args (Dict[str, Any]): Arguments passed to the workflow.
+
+        Note:
+            This method creates and configures the new SQL client before closing
+            the old one to ensure state is never left with a closed client if
+            initialization fails. The timestamp is only updated after the new
+            client is successfully created and assigned.
         """
         workflow_id = get_workflow_id()
         if not self._state.get(workflow_id):
             self._state[workflow_id] = BaseSQLMetadataExtractionActivitiesState()
 
-        await super()._set_state(workflow_args)
+        existing_state = self._state[workflow_id]
+
+        # Update workflow_args early, but preserve old timestamp until new client is ready
+        # This ensures that if initialization fails, the state can still be refreshed
+        existing_state.workflow_args = workflow_args
+
+        # Store reference to old client for cleanup after new client is ready
+        old_sql_client = None
+        if existing_state and existing_state.sql_client is not None:
+            old_sql_client = existing_state.sql_client
 
+        # Create and configure new client BEFORE closing old one
+        # This ensures state is never left with a closed client if initialization fails
         sql_client = self.sql_client_class()
 
         # Load credentials BEFORE creating handler to avoid race condition
@@ -165,10 +184,29 @@ class BaseSQLMetadataExtractionActivities(ActivitiesInterface):
             )
             await sql_client.load(credentials)
 
-        # Assign sql_client and handler to state AFTER credentials are loaded
+        # Only after new client is successfully created and configured,
+        # close old client and assign new one to state
+        if old_sql_client is not None:
+            try:
+                await old_sql_client.close()
+                logger.debug(
+                    f"Closed existing SQL client for workflow {workflow_id} during state refresh"
+                )
+            except Exception as e:
+                logger.warning(
+                    f"Failed to close existing SQL client for workflow {workflow_id}: {e}",
+                    exc_info=True,
+                )
+                # Continue even if close fails - new client is already ready
+
+        # Assign sql_client and handler to state AFTER new client is ready
         self._state[workflow_id].sql_client = sql_client
         handler = self.handler_class(sql_client)
         self._state[workflow_id].handler = handler
+        # Update timestamp only after successful client creation and assignment
+        # This ensures that if initialization fails, the old timestamp remains
+        # and the state can be refreshed again immediately
+        self._state[workflow_id].last_updated_timestamp = datetime.now()
 
         # Create transformer with required parameters from ApplicationConstants
         transformer_params = {

atlan_application_sdk-2.2.0/application_sdk/clients/azure/__init__.py

@@ -0,0 +1,6 @@
+"""Azure client module for the application-sdk framework."""
+
+# Azure Management API endpoint for token acquisition
+AZURE_MANAGEMENT_API_ENDPOINT = "https://management.azure.com/.default"
+
+__all__ = ["AZURE_MANAGEMENT_API_ENDPOINT"]

atlan_application_sdk-2.2.0/application_sdk/clients/azure/auth.py

@@ -0,0 +1,288 @@
+"""
+Azure authentication provider for the application-sdk framework.
+
+This module provides the AzureAuthProvider class that handles Azure
+Service Principal authentication for the application-sdk framework.
+
+Example:
+    >>> from application_sdk.clients.azure.auth import AzureAuthProvider
+    >>> import asyncio
+    >>>
+    >>> # Create authentication provider
+    >>> auth_provider = AzureAuthProvider()
+    >>>
+    >>> # Authenticate with Service Principal credentials
+    >>> credentials = {
+    ...     "tenant_id": "your-tenant-id",
+    ...     "client_id": "your-client-id",
+    ...     "client_secret": "your-client-secret"
+    ... }
+    >>>
+    >>> # Create credential
+    >>> credential = await auth_provider.create_credential(
+    ...     auth_type="service_principal",
+    ...     credentials=credentials
+    ... )
+    >>>
+    >>> # Alternative credential key formats are also supported
+    >>> alt_credentials = {
+    ...     "tenantId": "your-tenant-id",      # camelCase
+    ...     "clientId": "your-client-id",      # camelCase
+    ...     "clientSecret": "your-client-secret"  # camelCase
+    ... }
+    >>>
+    >>> credential = await auth_provider.create_credential(
+    ...     auth_type="service_principal",
+    ...     credentials=alt_credentials
+    ... )
+    >>>
+    >>> # Error handling for missing credentials
+    >>> try:
+    ...     await auth_provider.create_credential(
+    ...         auth_type="service_principal",
+    ...         credentials={"tenant_id": "only-tenant"}  # Missing client_id and client_secret
+    ...     )
+    ... except CommonError as e:
+    ...     print(f"Authentication failed: {e}")
+    ...     # Output: Authentication failed: Missing required credential keys: client_id, client_secret
+    >>>
+    >>> # Unsupported authentication type
+    >>> try:
+    ...     await auth_provider.create_credential(
+    ...         auth_type="unsupported_type",
+    ...         credentials=credentials
+    ...     )
+    ... except CommonError as e:
+    ...     print(f"Authentication failed: {e}")
+    ...     # Output: Authentication failed: Only 'service_principal' authentication is supported. Received: unsupported_type
+"""
+
+from typing import Any, Dict, Optional
+
+from azure.core.credentials import TokenCredential
+from azure.core.exceptions import ClientAuthenticationError
+from azure.identity import ClientSecretCredential
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+
+from application_sdk.clients.azure import AZURE_MANAGEMENT_API_ENDPOINT
+from application_sdk.common.error_codes import CommonError
+from application_sdk.common.utils import run_sync
+from application_sdk.observability.logger_adaptor import get_logger
+
+logger = get_logger(__name__)
+
+
+class ServicePrincipalCredentials(BaseModel):
+    """
+    Pydantic model for Azure Service Principal credentials.
+
+    Supports both snake_case and camelCase field names through field aliases.
+    All fields are required for service principal authentication.
+
+    Attributes:
+        tenant_id: Azure tenant ID (also accepts 'tenantId').
+        client_id: Azure client ID (also accepts 'clientId').
+        client_secret: Azure client secret (also accepts 'clientSecret').
+    """
+
+    tenant_id: str = Field(
+        ...,
+        alias="tenantId",
+        description="Azure tenant ID for service principal authentication",
+    )
+    client_id: str = Field(
+        ...,
+        alias="clientId",
+        description="Azure client ID for service principal authentication",
+    )
+    client_secret: str = Field(
+        ...,
+        alias="clientSecret",
+        description="Azure client secret for service principal authentication",
+    )
+
+    model_config = ConfigDict(
+        populate_by_name=True,  # Allow both field name and alias
+        extra="ignore",  # Ignore additional fields (Azure client may need extra fields like storage_account_name, network_config, etc.)
+        validate_assignment=True,  # Validate on assignment
+    )
+
+
+class AzureAuthProvider:
+    """
+    Azure authentication provider for handling Service Principal authentication.
+
+    This class provides a unified interface for creating Azure credentials
+    using Service Principal authentication with Azure SDK.
+
+    Supported authentication method:
+    - service_principal: Using client ID, client secret, and tenant ID
+    """
+
+    def __init__(self):
+        """Initialize the Azure authentication provider."""
+        pass
+
+    async def create_credential(
+        self,
+        auth_type: str = "service_principal",
+        credentials: Optional[Dict[str, Any]] = None,
+    ) -> TokenCredential:
+        """
+        Create Azure credential using Service Principal authentication.
+
+        Args:
+            auth_type (str): Type of authentication to use.
+                Currently only supports 'service_principal'.
+            credentials (Optional[Dict[str, Any]]): Service Principal credentials.
+                Required fields: tenant_id, client_id, client_secret.
+
+        Returns:
+            TokenCredential: Azure credential instance.
+
+        Raises:
+            CommonError: If authentication type is not supported or credentials are invalid.
+            ClientAuthenticationError: If credential creation fails.
+        """
+        try:
+            logger.debug(f"Creating Azure credential with auth type: {auth_type}")
+
+            if auth_type.lower() != "service_principal":
+                raise CommonError(
+                    f"{CommonError.CREDENTIALS_PARSE_ERROR}: "
+                    f"Only 'service_principal' authentication is supported. "
+                    f"Received: {auth_type}"
+                )
+
+            if not credentials:
+                raise CommonError(
+                    f"{CommonError.CREDENTIALS_PARSE_ERROR}: "
+                    "Credentials required for service principal authentication"
+                )
+
+            return await self._create_service_principal_credential(credentials)
+
+        except ClientAuthenticationError as e:
+            logger.error(f"Azure authentication failed: {str(e)}")
+            raise CommonError(f"{CommonError.AZURE_CREDENTIAL_ERROR}: {str(e)}")
+        except ValueError as e:
+            logger.error(f"Invalid Azure credential parameters: {str(e)}")
+            raise CommonError(
+                f"{CommonError.CREDENTIALS_PARSE_ERROR}: Invalid credential parameters - {str(e)}"
+            )
+        except TypeError as e:
+            logger.error(f"Wrong Azure credential parameter types: {str(e)}")
+            raise CommonError(
+                f"{CommonError.CREDENTIALS_PARSE_ERROR}: Invalid credential parameter types - {str(e)}"
+            )
+        except Exception as e:
+            logger.error(f"Unexpected error creating Azure credential: {str(e)}")
+            raise CommonError(
+                f"{CommonError.CREDENTIALS_PARSE_ERROR}: Unexpected error - {str(e)}"
+            )
+
+    async def _create_service_principal_credential(
+        self, credentials: Dict[str, Any]
+    ) -> ClientSecretCredential:
+        """
+        Create service principal credential.
+
+        Args:
+            credentials (Dict[str, Any]): Service principal credentials.
+                Must include tenant_id, client_id, and client_secret.
+
+        Returns:
+            ClientSecretCredential: Service principal credential.
+
+        Raises:
+            CommonError: If required credentials are missing or invalid.
+        """
+        if not credentials:
+            raise CommonError(
+                f"{CommonError.CREDENTIALS_PARSE_ERROR}: "
+                "Credentials required for service principal authentication"
+            )
+
+        try:
+            # Validate credentials using Pydantic model
+            validated_credentials = ServicePrincipalCredentials(**credentials)
+        except ValidationError as e:
+            # Pydantic provides detailed error messages for all validation errors
+            # Format errors into a user-friendly message
+            error_details = "; ".join(
+                [
+                    f"{'.'.join(str(loc) for loc in err['loc'])}: {err['msg']}"
+                    for err in e.errors()
+                ]
+            )
+            error_message = f"Invalid credential parameters: {error_details}"
+            logger.error(f"Azure credential validation failed: {error_message}")
+            raise CommonError(f"{CommonError.CREDENTIALS_PARSE_ERROR}: {error_message}")
+
+        logger.debug(
+            f"Creating service principal credential for tenant: {validated_credentials.tenant_id}"
+        )
+
+        try:
+            return await run_sync(ClientSecretCredential)(
+                validated_credentials.tenant_id,
+                validated_credentials.client_id,
+                validated_credentials.client_secret,
+            )
+        except ValueError as e:
+            logger.error(f"Invalid Azure credential parameters: {str(e)}")
+            raise CommonError(
+                f"{CommonError.CREDENTIALS_PARSE_ERROR}: Invalid credential parameters - {str(e)}"
+            )
+        except TypeError as e:
+            logger.error(f"Wrong Azure credential parameter types: {str(e)}")
+            raise CommonError(
+                f"{CommonError.CREDENTIALS_PARSE_ERROR}: Invalid credential parameter types - {str(e)}"
+            )
+        except ClientAuthenticationError as e:
+            logger.error(f"Azure authentication failed: {str(e)}")
+            raise CommonError(f"{CommonError.AZURE_CREDENTIAL_ERROR}: {str(e)}")
+        except Exception as e:
+            logger.error(f"Unexpected error creating Azure credential: {str(e)}")
+            raise CommonError(
+                f"{CommonError.CREDENTIALS_PARSE_ERROR}: Unexpected error - {str(e)}"
+            )
+
+    async def validate_credential(self, credential: TokenCredential) -> bool:
+        """
+        Validate Azure credential by attempting to get a token.
+
+        Args:
+            credential (TokenCredential): Azure credential to validate.
+
+        Returns:
+            bool: True if credential is valid, False otherwise.
+        """
+        try:
+            logger.debug("Validating Azure credential")
+
+            # Try to get a token for Azure Management API
+            token = await run_sync(credential.get_token)(AZURE_MANAGEMENT_API_ENDPOINT)
+
+            if token and hasattr(token, "token"):
+                logger.debug("Azure credential validation successful")
+                return True
+            else:
+                logger.warning("Azure credential validation failed: No token received")
+                return False
+
+        except ClientAuthenticationError as e:
+            logger.error(
+                f"Azure credential validation failed - authentication error: {str(e)}"
+            )
+            return False
+        except ValueError as e:
+            logger.error(
+                f"Azure credential validation failed - invalid parameters: {str(e)}"
+            )
+            return False
+        except Exception as e:
+            logger.error(
+                f"Azure credential validation failed - unexpected error: {str(e)}"
+            )
+            return False