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

{atlan_application_sdk-0.1.1rc31 → atlan_application_sdk-0.1.1rc33}/.cursor/BUGBOT.md

@@ -14,7 +14,7 @@
 - **Cognitive Load**: Can a new developer understand this change with less cognitive load?
 - **Magic Numbers/Strings**: All constants properly defined and named in @application_sdk/constants.py
 - **Spell Check**: No typos in code, comments, docstrings, or documentation
-- **Exception Handling Standards**: All exception handling must follow these principles. See detailed guidelines in [exception-handling.mdc](mdc:.cursor/rules/exception-handling.mdc).
+- **Exception Handling Standards**: All exception handling must follow these principles. See detailed guidelines in [exception-handling.mdc](@.cursor/rules/exception-handling.mdc).
 
 ### 🏗️ Architecture & Design
 
@@ -32,7 +32,7 @@
 
 ### 🧪 Testing
 
-- **Testing Standards**: Testing standards are defined in [testing.mdc](mdc:.cursor/rules/testing.mdc)
+- **Testing Standards**: Testing standards are defined in [testing.mdc](@.cursor/rules/testing.mdc)
 - **Test Coverage**: New code has corresponding tests (unit/integration/e2e as appropriate)
 - **Edge Cases**: Error conditions and boundary cases are tested
 - **Mock Strategy**: External dependencies properly mocked/isolated
@@ -43,7 +43,7 @@
 - **Input Validation**: All external inputs validated and sanitized
 - **Secrets Management**: No secrets in code; proper credential handling
 - **SQL Injection**: Parameterized queries used for all SQL operations
-- **Performance Standards**: All performance considerations must follow these principles. See detailed guidelines in [performance.mdc](mdc:.cursor/rules/performance.mdc).
+- **Performance Standards**: All performance considerations must follow these principles. See detailed guidelines in [performance.mdc](@.cursor/rules/performance.mdc).
 - **Memory Management**: Resources properly closed, large datasets processed in chunks
 - **DataFrame Optimization**: Appropriate dtypes, avoid unnecessary copies, use chunked processing
 - **SQL Query Efficiency**: Use LIMIT, specific columns, proper WHERE clauses, connection pooling
@@ -54,7 +54,7 @@
 
 ### 📊 Observability & Logging
 
-- **Logging Standards**: logging standards are defined in [logging.mdc](mdc:.cursor/rules/logging.mdc)
+- **Logging Standards**: logging standards are defined in [logging.mdc](@.cursor/rules/logging.mdc)
 - **Metrics**: Key operations include appropriate metrics
 - **Error Context**: Error logs include sufficient context for debugging
 - **Trace Information**: Critical paths include trace information

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.1rc31 → atlan_application_sdk-0.1.1rc33}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # 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)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc31...v0.1.1rc32
+
+### Bug Fixes
+
+- update app host (#664) (by @Onkar Ravgan in [24d23cb](https://github.com/atlanhq/application-sdk/commit/24d23cb))
+- file references in cursor rules (#662) (by @Nishchith Shetty in [2395ce3](https://github.com/atlanhq/application-sdk/commit/2395ce3))
+- Parquet file output path with None file names (#659) (by @Onkar Ravgan in [8841660](https://github.com/atlanhq/application-sdk/commit/8841660))
+
 ## v0.1.1rc31 (August 14, 2025)
 
 Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc30...v0.1.1rc31

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc31
+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.1rc31 → atlan_application_sdk-0.1.1rc33}/application_sdk/constants.py

@@ -36,7 +36,7 @@ APPLICATION_NAME = os.getenv("ATLAN_APPLICATION_NAME", "default")
 #: Name of the deployment, used to distinguish between different deployments of the same application
 DEPLOYMENT_NAME = os.getenv("ATLAN_DEPLOYMENT_NAME", LOCAL_ENVIRONMENT)
 #: Host address for the application's HTTP server
-APP_HOST = str(os.getenv("ATLAN_APP_HTTP_HOST", "localhost"))
+APP_HOST = str(os.getenv("ATLAN_APP_HTTP_HOST", "0.0.0.0"))
 #: Port number for the application's HTTP server
 APP_PORT = int(os.getenv("ATLAN_APP_HTTP_PORT", "8000"))
 #: Tenant ID for multi-tenant applications

{atlan_application_sdk-0.1.1rc31 → atlan_application_sdk-0.1.1rc33}/application_sdk/inputs/parquet.py

@@ -51,7 +51,12 @@ class ParquetInput(Input):
         Returns:
             Optional[str]: Path to the downloaded local file.
         """
-        parquet_files = glob.glob(local_file_path)
+        # if the path is a directory, then check if the directory has any parquet files
+        parquet_files = []
+        if os.path.isdir(local_file_path):
+            parquet_files = glob.glob(os.path.join(local_file_path, "*.parquet"))
+        else:
+            parquet_files = glob.glob(local_file_path)
         if not parquet_files:
             if self.input_prefix:
                 logger.info(
@@ -162,10 +167,9 @@ class ParquetInput(Input):
                         await self.download_files(path)
                         yield daft.read_parquet(path)
             else:
-                path = f"{self.path}/*.parquet"
-                if self.input_prefix and path:
-                    await self.download_files(path)
-                yield daft.read_parquet(path)
+                if self.path and self.input_prefix:
+                    await self.download_files(self.path)
+                    yield daft.read_parquet(f"{self.path}/*.parquet")
 
         except Exception as error:
             logger.error(

atlan_application_sdk-0.1.1rc33/application_sdk/test_utils/hypothesis/strategies/inputs/parquet_input.py

@@ -0,0 +1,28 @@
+from hypothesis import strategies as st
+
+# Strategy for generating safe file path components
+safe_path_strategy = st.text(
+    alphabet=st.characters(),
+)
+
+# Strategy for generating file names
+file_name_strategy = st.builds(lambda name: f"{name}.parquet", name=safe_path_strategy)
+
+# Strategy for generating lists of file names
+file_names_strategy = st.lists(file_name_strategy, unique=True)
+
+# Strategy for generating input prefixes
+input_prefix_strategy = safe_path_strategy
+
+# Strategy for generating chunk sizes
+chunk_size_strategy = st.one_of(st.none(), st.integers(min_value=1, max_value=1000000))
+
+# Strategy for generating complete ParquetInput configurations
+parquet_input_config_strategy = st.fixed_dictionaries(
+    {
+        "path": safe_path_strategy,
+        "chunk_size": chunk_size_strategy,
+        "input_prefix": st.one_of(st.none(), input_prefix_strategy),
+        "file_names": st.one_of(st.none(), file_names_strategy),
+    }
+)

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "atlan-application-sdk"
-version = "0.1.1rc31"
+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()