atlan-application-sdk 0.1.1rc32__tar.gz → 0.1.1rc33__tar.gz

atlan_application_sdk-0.1.1rc33/.github/release_notes.md

@@ -0,0 +1,3 @@
+## v0.1.1rc33 (August 26, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc32...v0.1.1rc33

{atlan_application_sdk-0.1.1rc32 → atlan_application_sdk-0.1.1rc33}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## v0.1.1rc33 (August 26, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc32...v0.1.1rc33
+
+
 
 ## v0.1.1rc32 (August 20, 2025)
 

{atlan_application_sdk-0.1.1rc32 → atlan_application_sdk-0.1.1rc33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc32
+Version: 0.1.1rc33
 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.1rc33/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)

{atlan_application_sdk-0.1.1rc32 → atlan_application_sdk-0.1.1rc33}/application_sdk/version.py

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

{atlan_application_sdk-0.1.1rc32 → atlan_application_sdk-0.1.1rc33}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atlan-application-sdk"
-version = "0.1.1rc32"
+version = "0.1.1rc33"
 description = "Atlan Application SDK is a Python library for developing applications on the Atlan Platform"
 license = "Apache-2.0"
 authors = [
@@ -24,7 +24,7 @@ dependencies = [
     "opentelemetry-exporter-otlp>=1.27.0",
     "psutil>=7.0.0",
     "fastapi[standard]>=0.115.0",
-    "pyatlan>=7.1.6",
+    "pyatlan>=8.0.0",
     "pydantic>=2.10.6",
     "loguru>=0.7.3",
     "uvloop>=0.21.0; sys_platform != 'win32'",
@@ -49,7 +49,7 @@ pandas = [
     "pandas>=2.2.3"
 ]
 daft = [
-    "daft[sql]>=0.4.12",
+    "daft>=0.4.12",
 ]
 iceberg = [
     "pyiceberg>=0.8.1",

atlan_application_sdk-0.1.1rc33/tests/unit/clients/test_async_atlan.py

@@ -0,0 +1,309 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from application_sdk.clients.async_atlan import get_client
+from application_sdk.common.error_codes import ClientError
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "params,constants,msg",
+    [
+        # Error: missing base_url
+        (
+            {"base_url": None, "api_key": "api_key_789", "api_token_guid": None},
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": None,
+                "ATLAN_CLIENT_SECRET": None,
+            },
+            "ATLAN_BASE_URL is required",
+        ),
+        # Error: missing api_key
+        (
+            {"base_url": "https://atlan.com", "api_key": None, "api_token_guid": None},
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": None,
+                "ATLAN_CLIENT_SECRET": None,
+            },
+            "ATLAN_API_KEY is required",
+        ),
+        # Error: missing both base_url and api_key
+        (
+            {"base_url": None, "api_key": None, "api_token_guid": None},
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": None,
+                "ATLAN_CLIENT_SECRET": None,
+            },
+            "ATLAN_BASE_URL is required",
+        ),
+        # Error: missing client_id
+        (
+            {"base_url": None, "api_key": None, "api_token_guid": "guid_param"},
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": None,
+                "ATLAN_CLIENT_SECRET": None,
+            },
+            "Environment variable CLIENT_ID is required when API_TOKEN_GUID is set",
+        ),
+        # Error: missing client_secret
+        (
+            {"base_url": None, "api_key": None, "api_token_guid": "guid_param"},
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": "CLIENT_ID_789",
+                "ATLAN_CLIENT_SECRET": None,
+            },
+            "Environment variable CLIENT_SECRET is required when API_TOKEN_GUID is set",
+        ),
+    ],
+    ids=[
+        "missing_base_url",
+        "missing_api_key",
+        "missing_both_base_url_and_api_key",
+        "missing_client_id",
+        "missing_client_secret",
+    ],
+)
+async def test_get_client_bad_params(params, constants, msg):
+    # Arrange
+    with patch(
+        "application_sdk.clients.async_atlan.ATLAN_API_TOKEN_GUID",
+        constants["ATLAN_API_TOKEN_GUID"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_BASE_URL",
+        constants["ATLAN_BASE_URL"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_API_KEY",
+        constants["ATLAN_API_KEY"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_CLIENT_ID",
+        constants["ATLAN_CLIENT_ID"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_CLIENT_SECRET",
+        constants["ATLAN_CLIENT_SECRET"],
+    ):
+        # Act / Assert
+        with pytest.raises(ClientError) as excinfo:
+            await get_client(**params)
+        # Assert
+        assert msg in str(excinfo.value)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "params,constants,expected_call,expected_args,expected_log,raises",
+    [
+        # Happy path: token auth via param
+        (
+            {"base_url": None, "api_key": None, "api_token_guid": "guid_param"},
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": "cid",
+                "ATLAN_CLIENT_SECRET": "csecret",
+            },
+            "_get_client_from_token",
+            ("guid_param",),
+            None,
+            None,
+        ),
+        # Happy path: token auth via env
+        (
+            {"base_url": None, "api_key": None, "api_token_guid": None},
+            {
+                "ATLAN_API_TOKEN_GUID": "guid_const",
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": "cid",
+                "ATLAN_CLIENT_SECRET": "csecret",
+            },
+            "_get_client_from_token",
+            ("guid_const",),
+            None,
+            None,
+        ),
+        # Happy path: token auth, base_url/api_key params present (should log warning)
+        (
+            {
+                "base_url": "https://atlan.com",
+                "api_key": "api_key_123",
+                "api_token_guid": "guid_param",
+            },
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": "cid",
+                "ATLAN_CLIENT_SECRET": "csecret",
+            },
+            "_get_client_from_token",
+            ("guid_param",),
+            "warning",
+            None,
+        ),
+    ],
+    ids=[
+        "param_token_guid",
+        "env_token_guid",
+        "token_guid_with_base_url_api_key",
+    ],
+)
+async def test_get_client_with_token_guid(
+    params, constants, expected_call, expected_args, expected_log, raises
+):
+    # Arrange
+
+    with patch(
+        "application_sdk.clients.async_atlan.ATLAN_API_TOKEN_GUID",
+        constants["ATLAN_API_TOKEN_GUID"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_BASE_URL",
+        constants["ATLAN_BASE_URL"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_API_KEY",
+        constants["ATLAN_API_KEY"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_CLIENT_ID",
+        constants["ATLAN_CLIENT_ID"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_CLIENT_SECRET",
+        constants["ATLAN_CLIENT_SECRET"],
+    ), patch(
+        "application_sdk.clients.async_atlan._get_client_from_token"
+    ) as mock_get_client_from_token, patch(
+        "application_sdk.clients.async_atlan.AsyncAtlanClient"
+    ) as mock_atlan_client, patch(
+        "application_sdk.clients.async_atlan.logger"
+    ) as mock_logger:
+        mock_client_instance = MagicMock()
+        mock_get_client_from_token.return_value = mock_client_instance
+        mock_atlan_client.return_value = mock_client_instance
+
+        # Act & Assert
+        # Act
+        result = await get_client(**params)
+        # Assert
+        mock_get_client_from_token.assert_awaited_once_with(*expected_args)
+        assert result == mock_client_instance
+        if expected_log == "warning":
+            mock_logger.warning.assert_called_once()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "params,constants,expected_call,expected_args,expected_log,raises",
+    [
+        # Happy path: API key auth via params
+        (
+            {
+                "base_url": "https://atlan.com",
+                "api_key": "api_key_123",
+                "api_token_guid": None,
+            },
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": None,
+                "ATLAN_API_KEY": None,
+                "ATLAN_CLIENT_ID": "cid",
+                "ATLAN_CLIENT_SECRET": "csecret",
+            },
+            "AsyncAtlanClient",
+            {"base_url": "https://atlan.com", "api_key": "api_key_123"},
+            "info",
+            None,
+        ),
+        # Happy path: API key auth via constants
+        (
+            {"base_url": None, "api_key": None, "api_token_guid": None},
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": "https://const.atlan.com",
+                "ATLAN_API_KEY": "const_api_key",
+                "ATLAN_CLIENT_ID": None,
+                "ATLAN_CLIENT_SECRET": None,
+            },
+            "AsyncAtlanClient",
+            {"base_url": "https://const.atlan.com", "api_key": "const_api_key"},
+            "info",
+            None,
+        ),
+        # Edge case: param overrides env
+        (
+            {
+                "base_url": "https://param.atlan.com",
+                "api_key": "param_api_key",
+                "api_token_guid": None,
+            },
+            {
+                "ATLAN_API_TOKEN_GUID": None,
+                "ATLAN_BASE_URL": "https://const.atlan.com",
+                "ATLAN_API_KEY": "const_api_key",
+                "ATLAN_CLIENT_ID": None,
+                "ATLAN_CLIENT_SECRET": None,
+            },
+            "AsyncAtlanClient",
+            {"base_url": "https://param.atlan.com", "api_key": "param_api_key"},
+            "info",
+            None,
+        ),
+    ],
+    ids=[
+        "param_base_url_and_api_key",
+        "env_base_url_and_api_key",
+        "param_precedence_over_env",
+    ],
+)
+async def test_get_client_with_api_key(
+    params, constants, expected_call, expected_args, expected_log, raises
+):
+    # Arrange
+    with patch(
+        "application_sdk.clients.async_atlan.ATLAN_API_TOKEN_GUID",
+        constants["ATLAN_API_TOKEN_GUID"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_BASE_URL",
+        constants["ATLAN_BASE_URL"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_API_KEY",
+        constants["ATLAN_API_KEY"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_CLIENT_ID",
+        constants["ATLAN_CLIENT_ID"],
+    ), patch(
+        "application_sdk.clients.async_atlan.ATLAN_CLIENT_SECRET",
+        constants["ATLAN_CLIENT_SECRET"],
+    ), patch(
+        "application_sdk.clients.async_atlan._get_client_from_token"
+    ) as mock_get_client_from_token, patch(
+        "application_sdk.clients.async_atlan.AsyncAtlanClient"
+    ) as mock_atlan_client, patch(
+        "application_sdk.clients.async_atlan.logger"
+    ) as mock_logger:
+        mock_client_instance = MagicMock()
+        mock_get_client_from_token.return_value = mock_client_instance
+        mock_atlan_client.return_value = mock_client_instance
+
+        # Act & Assert
+        # Act
+        result = await get_client(**params)
+        # Assert
+        mock_atlan_client.assert_called_once_with(**expected_args)
+        assert result == mock_client_instance
+        if expected_log == "info":
+            mock_logger.info.assert_called_once()