atlan-application-sdk 0.1.1rc32__py3-none-any.whl → 0.1.1rc34__py3-none-any.whl

application_sdk/activities/metadata_extraction/base.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict, Optional, Type
+
+from temporalio import activity
+
+from application_sdk.activities import ActivitiesInterface, ActivitiesState
+from application_sdk.activities.common.utils import get_workflow_id
+from application_sdk.clients.base import BaseClient
+from application_sdk.common.credential_utils import get_credentials
+from application_sdk.constants import APP_TENANT_ID, APPLICATION_NAME
+from application_sdk.handlers.base import BaseHandler
+from application_sdk.observability.logger_adaptor import get_logger
+from application_sdk.transformers import TransformerInterface
+
+logger = get_logger(__name__)
+activity.logger = logger
+
+
+class BaseMetadataExtractionActivitiesState(ActivitiesState):
+    """State for base metadata extraction activities."""
+
+    client: Optional[BaseClient] = None
+    handler: Optional[BaseHandler] = None
+    transformer: Optional[TransformerInterface] = None
+
+
+class BaseMetadataExtractionActivities(ActivitiesInterface):
+    """Base activities for non-SQL metadata extraction workflows."""
+
+    _state: Dict[str, BaseMetadataExtractionActivitiesState] = {}
+
+    client_class: Type[BaseClient] = BaseClient
+    handler_class: Type[BaseHandler] = BaseHandler
+    transformer_class: Optional[Type[TransformerInterface]] = None
+
+    def __init__(
+        self,
+        client_class: Optional[Type[BaseClient]] = None,
+        handler_class: Optional[Type[BaseHandler]] = None,
+        transformer_class: Optional[Type[TransformerInterface]] = None,
+    ):
+        """Initialize the base metadata extraction activities.
+
+        Args:
+            client_class: Client class to use. Defaults to BaseClient.
+            handler_class: Handler class to use. Defaults to BaseHandler.
+            transformer_class: Transformer class to use. Users must provide their own transformer implementation.
+        """
+        if client_class:
+            self.client_class = client_class
+        if handler_class:
+            self.handler_class = handler_class
+        if transformer_class:
+            self.transformer_class = transformer_class
+
+        super().__init__()
+
+    async def _set_state(self, workflow_args: Dict[str, Any]):
+        """Set up the state for the current workflow.
+
+        Args:
+            workflow_args: Arguments for the workflow.
+        """
+        workflow_id = get_workflow_id()
+        if not self._state.get(workflow_id):
+            self._state[workflow_id] = BaseMetadataExtractionActivitiesState()
+
+        await super()._set_state(workflow_args)
+
+        state = self._state[workflow_id]
+
+        # Initialize client
+        client = self.client_class()
+        # Extract credentials from state store if credential_guid is available
+        if "credential_guid" in workflow_args:
+            logger.info(
+                f"Retrieving credentials for credential_guid: {workflow_args['credential_guid']}"
+            )
+            try:
+                credentials = await get_credentials(workflow_args["credential_guid"])
+                logger.info(
+                    f"Successfully retrieved credentials with keys: {list(credentials.keys())}"
+                )
+                # Load the client with credentials
+                await client.load(credentials=credentials)
+            except Exception as e:
+                logger.error(f"Failed to retrieve credentials: {e}")
+                raise
+
+        state.client = client
+
+        # Initialize handler
+        handler = self.handler_class(client=client)
+        state.handler = handler
+
+        # Initialize transformer if provided
+        if self.transformer_class:
+            transformer_params = {
+                "connector_name": APPLICATION_NAME,
+                "connector_type": APPLICATION_NAME,
+                "tenant_id": APP_TENANT_ID,
+            }
+            state.transformer = self.transformer_class(**transformer_params)

application_sdk/application/__init__.py

@@ -2,8 +2,10 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Dict, List, Optional, Tuple, Type
 
 from application_sdk.activities import ActivitiesInterface
+from application_sdk.clients.base import BaseClient
 from application_sdk.clients.utils import get_workflow_client
 from application_sdk.events.models import EventRegistration
+from application_sdk.handlers.base import BaseHandler
 from application_sdk.observability.logger_adaptor import get_logger
 from application_sdk.server import ServerInterface
 from application_sdk.server.fastapi import APIServer, HttpWorkflowTrigger
@@ -28,6 +30,8 @@ class BaseApplication:
         name: str,
         server: Optional[ServerInterface] = None,
         application_manifest: Optional[dict] = None,
+        client_class: Optional[Type[BaseClient]] = None,
+        handler_class: Optional[Type[BaseHandler]] = None,
     ):
         """
         Initialize the application.
@@ -48,6 +52,9 @@ class BaseApplication:
         self.application_manifest: Dict[str, Any] = application_manifest
         self.bootstrap_event_registration()
 
+        self.client_class = client_class or BaseClient
+        self.handler_class = handler_class or BaseHandler
+
     def bootstrap_event_registration(self):
         self.event_subscriptions = {}
         if self.application_manifest is None:
@@ -168,6 +175,7 @@ class BaseApplication:
         self.server = APIServer(
             workflow_client=self.workflow_client,
             ui_enabled=ui_enabled,
+            handler=self.handler_class(client=self.client_class()),
         )
 
         if self.event_subscriptions:

application_sdk/clients/async_atlan.py

@@ -0,0 +1,70 @@
+from typing import Optional
+
+from pyatlan.client.aio.client import AsyncAtlanClient
+
+from application_sdk.common.error_codes import ClientError
+from application_sdk.constants import (
+    ATLAN_API_KEY,
+    ATLAN_API_TOKEN_GUID,
+    ATLAN_BASE_URL,
+    ATLAN_CLIENT_ID,
+    ATLAN_CLIENT_SECRET,
+)
+from application_sdk.observability.logger_adaptor import get_logger
+
+logger = get_logger(__name__)
+
+
+async def get_client(
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_token_guid: Optional[str] = None,
+) -> AsyncAtlanClient:
+    """
+    Returns an authenticated AsyncAtlanClient instance using provided parameters or environment variables.
+
+    Selects authentication method based on the presence of parameters or environment variables and validates the required configuration.
+    In general, the use of environment variables is recommended. Any parameters specified will override the environment variables.
+
+    Args:
+    base_url: Atlan base URL (overrides ATLAN_BASE_URL)
+    api_key: Atlan API key (overrides ATLAN_API_KEY)
+    api_token_guid: API token GUID (overrides API_TOKEN_GUID)
+    """
+    # Resolve final values (parameters override env vars)
+    final_token_guid = api_token_guid or ATLAN_API_TOKEN_GUID
+    final_base_url = base_url or ATLAN_BASE_URL
+    final_api_key = api_key or ATLAN_API_KEY
+
+    # Priority 1: Token-based auth (recommended for production)
+    if final_token_guid:
+        if final_base_url or final_api_key:
+            logger.warning(
+                "Token auth takes precedence - ignoring base_url/api_key parameters as well as ATLAN_BASE_URL and ATLAN_API_KEY environment variables."
+            )
+        return await _get_client_from_token(final_token_guid)
+
+    # Priority 2: API key + base URL auth
+    if not final_base_url:
+        raise ClientError(
+            "ATLAN_BASE_URL is required (via parameter or environment variable)"
+        )
+    if not final_api_key:
+        raise ClientError(
+            "ATLAN_API_KEY is required (via parameter or environment variable)"
+        )
+
+    logger.info("Using API key-based authentication")
+    return AsyncAtlanClient(base_url=final_base_url, api_key=final_api_key)
+
+
+async def _get_client_from_token(api_token_guid: str):
+    if not ATLAN_CLIENT_ID:
+        raise ClientError(
+            f"{ClientError.AUTH_CONFIG_ERROR}: Environment variable CLIENT_ID is required when API_TOKEN_GUID is set."
+        )
+    if not ATLAN_CLIENT_SECRET:
+        raise ClientError(
+            f"{ClientError.AUTH_CONFIG_ERROR}: Environment variable CLIENT_SECRET is required when API_TOKEN_GUID is set."
+        )
+    return await AsyncAtlanClient.from_token_guid(guid=api_token_guid)

application_sdk/clients/base.py

@@ -0,0 +1,293 @@
+from typing import Any, Dict, Optional
+
+import httpx
+from httpx import Headers
+from httpx._types import (
+    AuthTypes,
+    HeaderTypes,
+    QueryParamTypes,
+    RequestData,
+    RequestFiles,
+)
+
+from application_sdk.clients import ClientInterface
+from application_sdk.observability.logger_adaptor import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseClient(ClientInterface):
+    """
+    Base client for non-SQL based applications.
+
+    This class provides a base implementation for clients that need to connect
+    to non-SQL data sources. It implements the ClientInterface and provides
+    basic functionality that can be extended by subclasses.
+
+    Attributes:
+        credentials (Dict[str, Any]): Client credentials for authentication.
+        http_headers (HeaderTypes): HTTP headers for all http requests made by this client. Supports dict, Headers object, or list of tuples.
+        http_retry_transporter (httpx.AsyncBaseTransport): HTTP transport for requests. Uses httpx default transport by default.
+            Can be overridden in load() method for custom retry behavior.
+
+    Extending the Client:
+        To customize retry behavior, subclasses can override the http_retry_transporter
+        in the load() method, similar to how http_headers is set:
+
+        Example:
+            >>> class MyClient(BaseClient):
+            ...     async def load(self, **kwargs):
+            ...         # Set up HTTP headers in load method for better modularity
+            ...         credentials = kwargs.get("credentials", {})
+            ...         # Can use dict, Headers object, or list of tuples
+            ...         self.http_headers = {
+            ...             "Authorization": f"Bearer {credentials.get('token')}",
+            ...             "User-Agent": "MyApp/1.0"
+            ...         }
+            ...         # Optionally override retry transport with custom configuration
+            ...         # For advanced retry logic with status code handling, use httpx-retries:
+            ...         # from httpx_retries import Retry, RetryTransport
+            ...         # retry = Retry(total=5, backoff_factor=20)
+            ...         # self.http_retry_transporter = RetryTransport(retry=retry) #replace transport with custom transport if needed
+
+        Advanced Retry Configuration:
+            For applications requiring advanced retry logic (e.g., status code-based retries,
+            rate limiting, custom backoff strategies), consider using httpx-retries library:
+
+            >>> class MyClient(BaseClient):
+            ...     async def load(self, **kwargs):
+            ...         # Set up headers
+            ...         self.http_headers = {"Authorization": f"Bearer {kwargs.get('token')}"}
+            ...
+            ...         # Install httpx-retries: pip install httpx-retries
+            ...         from httpx_retries import Retry, RetryTransport
+            ...
+            ...         # Configure retry for status codes and network errors
+            ...         retry = Retry(
+            ...             total=5,
+            ...             backoff_factor=10,
+            ...             status_forcelist=[429, 500, 502, 503, 504]
+            ...         )
+            ...         self.http_retry_transporter = RetryTransport(retry=retry)
+
+        Header Management:
+            The client supports a two-level header system using httpx Headers for merging headers:
+            - Client-level headers: Set in the load() method and used for all requests
+            - Method-level headers: Passed to individual methods and override/add to client headers
+
+            Example:
+                >>> client = MyClient()
+                >>> await client.load(credentials={"token": "initial_token"})
+                >>> # This request will use: {"Authorization": "Bearer initial_token", "User-Agent": "MyApp/1.0", "Content-Type": "application/json"}
+                >>> response = await client.execute_http_post_request(
+                ...     url="https://api.example.com/data",
+                ...     headers={"Content-Type": "application/json"}
+                ... )
+    """
+
+    def __init__(
+        self,
+        credentials: Dict[str, Any] = {},
+        http_headers: HeaderTypes = {},
+    ):
+        """
+        Initialize the base client.
+
+        Args:
+            credentials (Dict[str, Any], optional): Client credentials for authentication. Defaults to {}.
+            http_headers (HeaderTypes, optional): HTTP headers for all requests. Defaults to {}.
+        """
+        self.credentials = credentials
+        self.http_headers = http_headers
+
+        # Use httpx default transport (no retries on status codes)
+        self.http_retry_transport: httpx.AsyncBaseTransport = httpx.AsyncHTTPTransport()
+
+    async def load(self, **kwargs: Any) -> None:
+        """
+        Initialize the client with credentials and necessary attributes for the client to work.
+
+        This method should be implemented by subclasses to:
+        - Set up authentication headers in self.http_headers in case of http requestss
+        - Initialize any required client state
+        - Handle credential processing
+        - Optionally override self.http_retry_transport for custom retry behavior
+
+        For advanced retry logic (status code-based retries, rate limiting, custom backoff),
+        consider using httpx-retries library and overriding http_retry_transport:
+
+        Example:
+            >>> async def load(self, **kwargs):
+            ...     # Set up headers
+            ...     self.http_headers = {"Authorization": f"Bearer {kwargs.get('token')}"}
+            ...
+            ...     # For advanced retry logic, install httpx-retries: pip install httpx-retries
+            ...     from httpx_retries import Retry, RetryTransport
+            ...     retry = Retry(total=5, backoff_factor=10, status_forcelist=[429, 500, 502, 503, 504])
+            ...     self.http_retry_transport = RetryTransport(retry=retry)
+
+        Args:
+            **kwargs: Additional keyword arguments, typically including credentials.
+                May also include retry configuration parameters that can be used to
+                create a custom http_retry_transport.
+
+        Raises:
+            NotImplementedError: If the subclass does not implement this method.
+        """
+        raise NotImplementedError("load method is not implemented")
+
+    async def execute_http_get_request(
+        self,
+        url: str,
+        headers: Optional[HeaderTypes] = None,
+        params: Optional[QueryParamTypes] = None,
+        auth: Optional[AuthTypes] = None,
+        timeout: int = 10,
+    ) -> Optional[httpx.Response]:
+        """
+        Perform an HTTP GET request using the configured transport.
+
+        This method uses httpx default transport which only retries on network-level errors
+        (connection failures, timeouts). For status code-based retries (429, 500, etc.),
+        consider overriding http_retry_transport in the load() method using httpx-retries library.
+
+        Args:
+            url (str): The URL to make the GET request to
+            headers (Optional[HeaderTypes]): HTTP headers to include in the request. Supports dict, Headers object, or list of tuples. These headers will override/add to any client-level headers set in the load() method.
+            params (Optional[QueryParamTypes]): Query parameters to include in the request. Supports dict, list of tuples, or string.
+            auth (Optional[AuthTypes]): Authentication to use for the request. Supports BasicAuth, DigestAuth, custom auth classes, or tuples for basic auth.
+            timeout (int): Request timeout in seconds. Defaults to 10.
+
+        Returns:
+            Optional[httpx.Response]: The HTTP response if successful, None if failed
+
+        Example:
+            >>> # Using Basic Authentication
+            >>> from httpx import BasicAuth
+            >>> response = await client.execute_http_get_request(
+            ...     url="https://api.example.com/data",
+            ...     auth=BasicAuth("username", "password"),
+            ...     params={"limit": 100}
+            ... )
+            >>>
+            >>> # Using tuple for basic auth (username, password)
+            >>> response = await client.execute_http_get_request(
+            ...     url="https://api.example.com/data",
+            ...     auth=("username", "password"),
+            ...     params={"limit": 100}
+            ... )
+            >>>
+            >>> # Using custom headers for Bearer token
+            >>> response = await client.execute_http_get_request(
+            ...     url="https://api.example.com/data",
+            ...     headers={"Authorization": "Bearer token"},
+            ...     params={"limit": 100}
+            ... )
+        """
+        async with httpx.AsyncClient(
+            timeout=timeout, transport=self.http_retry_transport
+        ) as client:
+            merged_headers = Headers(self.http_headers)
+            if headers:
+                merged_headers.update(headers)
+
+            try:
+                response = await client.get(
+                    url,
+                    headers=merged_headers,
+                    params=params,
+                    auth=auth if auth is not None else httpx.USE_CLIENT_DEFAULT,
+                )
+                return response
+            except httpx.HTTPStatusError as e:
+                logger.error(f"HTTP error for {url}: {e.response.status_code}")
+                return None
+            except Exception as e:
+                logger.error(f"Request failed for {url}: {e}")
+                return None
+
+    async def execute_http_post_request(
+        self,
+        url: str,
+        data: Optional[RequestData] = None,
+        json_data: Optional[Any] = None,
+        content: Optional[bytes] = None,
+        files: Optional[RequestFiles] = None,
+        headers: Optional[HeaderTypes] = None,
+        params: Optional[QueryParamTypes] = None,
+        cookies: Optional[Dict[str, str]] = None,
+        auth: Optional[AuthTypes] = None,
+        follow_redirects: bool = True,
+        verify: bool = True,
+        timeout: int = 30,
+    ) -> Optional[httpx.Response]:
+        """
+        Perform an HTTP POST request using the configured transport.
+
+        This method uses httpx default transport which only retries on network-level errors
+        (connection failures, timeouts). For status code-based retries (429, 500, etc.),
+        consider overriding http_retry_transport in the load() method using httpx-retries library.
+
+        Args:
+            url (str): The URL to make the POST request to
+            data (Optional[RequestData]): Form data to send in the request body. Supports dict, list of tuples, or other httpx-compatible formats.
+            json_data (Optional[Any]): JSON data to send in the request body. Any JSON-serializable object.
+            content (Optional[bytes]): Raw binary content to send in the request body
+            files (Optional[RequestFiles]): Files to upload in the request body. Supports various file formats and tuples.
+            headers (Optional[HeaderTypes]): HTTP headers to include in the request. Supports dict, Headers object, or list of tuples. These headers will override/add to any client-level headers set in the load() method.
+            params (Optional[QueryParamTypes]): Query parameters to include in the request. Supports dict, list of tuples, or string.
+            cookies (Optional[Dict[str, str]]): Cookies to include in the request
+            auth (Optional[AuthTypes]): Authentication to use for the request. Supports BasicAuth, DigestAuth, custom auth classes, or tuples for basic auth.
+            follow_redirects (bool): Whether to follow HTTP redirects. Defaults to True.
+            verify (bool): Whether to verify SSL certificates. Defaults to True.
+            timeout (int): Request timeout in seconds. Defaults to 30.
+
+        Returns:
+            Optional[httpx.Response]: The HTTP response if successful, None if failed
+
+        Example:
+            >>> # Basic JSON POST request with authentication
+            >>> from httpx import BasicAuth
+            >>> response = await client.execute_http_post_request(
+            ...     url="https://api.example.com/data",
+            ...     json_data={"name": "test", "value": 123},
+            ...     headers={"Content-Type": "application/json"},
+            ...     auth=BasicAuth("username", "password")
+            ... )
+            >>>
+            >>> # File upload with basic auth tuple
+            >>> with open("file.txt", "rb") as f:
+            ...     response = await client.execute_http_post_request(
+            ...         url="https://api.example.com/upload",
+            ...         data={"description": "My file"},
+            ...         files={"file": ("file.txt", f.read(), "text/plain")},
+            ...         auth=("username", "password")
+            ... )
+        """
+        async with httpx.AsyncClient(
+            timeout=timeout, transport=self.http_retry_transport, verify=verify
+        ) as client:
+            merged_headers = Headers(self.http_headers)
+            if headers:
+                merged_headers.update(headers)
+
+            try:
+                response = await client.post(
+                    url,
+                    data=data,
+                    json=json_data,
+                    content=content,
+                    files=files,
+                    headers=merged_headers,
+                    params=params,
+                    cookies=cookies,
+                    auth=auth if auth is not None else httpx.USE_CLIENT_DEFAULT,
+                    follow_redirects=follow_redirects,
+                )
+                return response
+            except httpx.HTTPStatusError as e:
+                logger.error(f"HTTP error for {url}: {e.response.status_code}")
+                return None
+            except Exception as e:
+                logger.error(f"Request failed for {url}: {e}")
+                return None

application_sdk/handlers/base.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, Optional
+
+from application_sdk.clients.base import BaseClient
+from application_sdk.handlers import HandlerInterface
+from application_sdk.observability.logger_adaptor import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseHandler(HandlerInterface):
+    """
+    Base handler for non-SQL based applications.
+
+    This class provides a base implementation for handlers that need to interact with non-SQL data sources. It implements the HandlerInterface and provides basic functionality that can be extended by subclasses.
+
+    Attributes:
+        client (BaseClient): The client instance for connecting to the target system.
+    """
+
+    def __init__(self, client: Optional[BaseClient] = None):
+        """
+        Initialize the base handler.
+
+        Args:
+            client (BaseClient, optional): The client instance to use for connections. Defaults to BaseClient().
+        """
+        self.client = client or BaseClient()
+
+    async def load(self, credentials: Dict[str, Any]) -> None:
+        """
+        Load and initialize the handler.
+
+        This method initializes the handler and loads the client with the provided credentials.
+
+        Args:
+            credentials (Dict[str, Any]): Credentials for the client.
+        """
+        logger.info("Loading base handler")
+
+        # Load the client with credentials
+        await self.client.load(credentials=credentials)
+
+        logger.info("Base handler loaded successfully")
+
+    # The following methods are inherited from HandlerInterface and should be implemented
+    # by subclasses to handle calls from their respective FastAPI endpoints:
+    #
+    # - test_auth(**kwargs) -> bool: Called by /workflow/v1/auth endpoint
+    # - preflight_check(**kwargs) -> Any: Called by /workflow/v1/check endpoint
+    # - fetch_metadata(**kwargs) -> Any: Called by /workflow/v1/metadata endpoint

application_sdk/server/fastapi/models.py

@@ -34,7 +34,7 @@ class FetchMetadataRequest(RootModel[Dict[str, Any]]):
 
 class FetchMetadataResponse(BaseModel):
     success: bool
-    data: List[Dict[str, str]]
+    data: Any
 
 
 class PreflightCheckRequest(BaseModel):

application_sdk/version.py

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

{atlan_application_sdk-0.1.1rc32.dist-info → atlan_application_sdk-0.1.1rc34.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc32
+Version: 0.1.1rc34
 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
@@ -26,12 +26,12 @@ Requires-Dist: fastapi[standard]>=0.115.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: opentelemetry-exporter-otlp>=1.27.0
 Requires-Dist: psutil>=7.0.0
-Requires-Dist: pyatlan>=7.1.6
+Requires-Dist: pyatlan>=8.0.0
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: uvloop>=0.21.0; sys_platform != 'win32'
 Provides-Extra: daft
-Requires-Dist: daft[sql]>=0.4.12; extra == 'daft'
+Requires-Dist: daft>=0.4.12; extra == 'daft'
 Provides-Extra: iam-auth
 Requires-Dist: boto3>=1.38.6; extra == 'iam-auth'
 Provides-Extra: iceberg

{atlan_application_sdk-0.1.1rc32.dist-info → atlan_application_sdk-0.1.1rc34.dist-info}/RECORD

@@ -1,21 +1,24 @@
 application_sdk/__init__.py,sha256=2e2mvmLJ5dxmJGPELtb33xwP-j6JMdoIuqKycEn7hjg,151
 application_sdk/constants.py,sha256=_Fmk9PgpM68chPDHHkgrs4Zg2KK4UCqqg7Oj9_u3WVo,9486
-application_sdk/version.py,sha256=ifHNi-zFUduvn5OEE1VTXtr426-rLzTEQ6lB9WnnQbk,88
+application_sdk/version.py,sha256=_RjK_lRaDoDHAbAg-jVq77m5SMKSytbbLBp_Mg4q_Hw,88
 application_sdk/worker.py,sha256=dZLxPkAieCSw7XEWxzL-FRk0QAZm7vXQBICjZODy3B4,7488
 application_sdk/activities/__init__.py,sha256=EH5VTHcfGykIX7V1HsG0J1Z-1FbJEXTQOET0HdzFDjU,9519
 application_sdk/activities/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 application_sdk/activities/common/models.py,sha256=305WdrZB7EAtCOAU_q9hMw81XowUdCeuFs9zfzb-MHQ,1196
 application_sdk/activities/common/utils.py,sha256=CWAj_tQUSQirSs5wwy-9eS8yI_4HoDfXsj2U_Xkb4Bc,6480
 application_sdk/activities/metadata_extraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+application_sdk/activities/metadata_extraction/base.py,sha256=t6dpJWq-syhlyLjjmA-TkXU9SnpJ_3yMu5uI9t6-joo,3877
 application_sdk/activities/metadata_extraction/rest.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 application_sdk/activities/metadata_extraction/sql.py,sha256=3G9_KGKyS0kTBN-nOKdvNSpTqwFv0nUectsqhMewpnU,22594
 application_sdk/activities/query_extraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 application_sdk/activities/query_extraction/sql.py,sha256=xC-dC_so3D9yY88lSL2W8Q8CfDRjiIrF-OHKbITFgd0,21271
-application_sdk/application/__init__.py,sha256=sUmng7msiUCPmQu1YY9gRvzXWviVKABVjKT3diPC6GM,7553
+application_sdk/application/__init__.py,sha256=WDWDWP-IQ-ny7okqsrdTwH60cXKgXBRcnlJ1XVYfiNU,7957
 application_sdk/application/metadata_extraction/sql.py,sha256=ohpV4qZ92uKRlH7I_8G67ocnWkZJAZCU_7XdvqYPiN4,7966
 application_sdk/clients/__init__.py,sha256=C9T84J7V6ZumcoWJPAxdd3tqSmbyciaGBJn-CaCCny0,1341
+application_sdk/clients/async_atlan.py,sha256=RTgRbMw6zJWcv1C-7cU4ccaSW5XZsB5dcA1Tlkj32p8,2699
 application_sdk/clients/atlan.py,sha256=f2-Uk5KiPIDJEhGkfYctA_f3CwoVB_mWNBMVvxeLuY4,2684
 application_sdk/clients/atlan_auth.py,sha256=MQznmvVKrlOT_Tp232W4UrOupRrx9Dx9zQm3n1R7kD8,8938
+application_sdk/clients/base.py,sha256=TIn3pG89eXUc1XSYf4jk66m1vajWp0WxcCQOOltdazA,14021
 application_sdk/clients/sql.py,sha256=tW89SHuuWdU5jv8lDUP5AUCEpR2CF_5TyUvYDCBHses,17880
 application_sdk/clients/temporal.py,sha256=jyU2MYGZXkTn0Gqy_qvYg0iSc2bKz4snflsU_XcDsfk,23662
 application_sdk/clients/utils.py,sha256=zLFOJbTr_6TOqnjfVFGY85OtIXZ4FQy_rquzjaydkbY,779
@@ -45,6 +48,7 @@ application_sdk/docgen/parsers/manifest.py,sha256=3NP-dBTpHAUQa477usMIDaKSb_9xfL
 application_sdk/events/__init__.py,sha256=OcbVWDF4ZKRTJXK9UaFVtYEwu-3DHE77S-Sn6jNafUs,204
 application_sdk/events/models.py,sha256=7Esqp3WlbriT2EqT4kNiY_sHtRXRPLj27b8SbeC5Sb0,5121
 application_sdk/handlers/__init__.py,sha256=U7kKwVWK0FZz1uIJ2ANN0C5tD83k_9Nyz0ns6ttr92g,1152
+application_sdk/handlers/base.py,sha256=6GF0a4p9mbdVoBltkzXwt6i0vzOvOKUHcB6fBiqi7v0,1883
 application_sdk/handlers/sql.py,sha256=oeB-sgWwPYo31xaD87TyMc0h51Sary1F-CmhExt9_Pk,16100
 application_sdk/inputs/__init__.py,sha256=_d-cUhcDyoJTJR3PdQkC831go6VDw9AM6Bg7-qm3NHI,1900
 application_sdk/inputs/iceberg.py,sha256=xiv1kNtVx1k0h3ZJbJeXjZwdfBGSy9j9orYP_AyCYlI,2756
@@ -72,7 +76,7 @@ application_sdk/outputs/secretstore.py,sha256=JS9vUzb11leDpcMQSCnLJuE9Ww-9G3wMvC
 application_sdk/outputs/statestore.py,sha256=XiEag2e9WW3_D3xbWQGoNrHiFJz9916qcIvhrROX8_8,3999
 application_sdk/server/__init__.py,sha256=KTqE1YPw_3WDVMWatJUuf9OOiobLM2K5SMaBrI62sCo,1568
 application_sdk/server/fastapi/__init__.py,sha256=1RNP3170Es_GcxVSweqkl_iz4Sd0Evi8bs6fuVuVTiA,27770
-application_sdk/server/fastapi/models.py,sha256=QarZthIq-ileNua-SCh6AldRuEjRCZk-C7QQZ5K6STE,6682
+application_sdk/server/fastapi/models.py,sha256=K6eNl3XXiTXKUvRTpq3oqdGH3jY1-ApobXma04J86fE,6665
 application_sdk/server/fastapi/utils.py,sha256=2XI4DylhRQsukhX67lpAzRNCHeFCSpbuNd7TlE2IBJA,1164
 application_sdk/server/fastapi/middleware/logmiddleware.py,sha256=CxcPtDmCbSfSZ8RyI09nIshVIbCokyyA9bByQJ2G_ns,2545
 application_sdk/server/fastapi/middleware/metrics.py,sha256=5ddHAIg5sT-u9tB_HHMGL3Cfu2g1rm9z7ksienIr9ks,1563
@@ -134,8 +138,8 @@ application_sdk/workflows/metadata_extraction/__init__.py,sha256=jHUe_ZBQ66jx8bg
 application_sdk/workflows/metadata_extraction/sql.py,sha256=_NhszxIgmcQI6lVpjJoyJRFLwPYvJw1Dyqox_m9K2RA,11947
 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.1rc32.dist-info/METADATA,sha256=bN4buUiRRKto73NmQ8JsMnKQrWS3CqJMr5m1huc-4u8,5473
-atlan_application_sdk-0.1.1rc32.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-atlan_application_sdk-0.1.1rc32.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-atlan_application_sdk-0.1.1rc32.dist-info/licenses/NOTICE,sha256=A-XVVGt3KOYuuMmvSMIFkg534F1vHiCggEBp4Ez3wGk,1041
-atlan_application_sdk-0.1.1rc32.dist-info/RECORD,,
+atlan_application_sdk-0.1.1rc34.dist-info/METADATA,sha256=XScCLyFgrofFYSusKm-kLSlICduUMNytPqAnNWEqs7Q,5468
+atlan_application_sdk-0.1.1rc34.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+atlan_application_sdk-0.1.1rc34.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+atlan_application_sdk-0.1.1rc34.dist-info/licenses/NOTICE,sha256=A-XVVGt3KOYuuMmvSMIFkg534F1vHiCggEBp4Ez3wGk,1041
+atlan_application_sdk-0.1.1rc34.dist-info/RECORD,,