atlan-application-sdk 0.1.1rc45__tar.gz → 0.1.1rc47__tar.gz

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/.github/actions/trivy-container/action.yaml

@@ -23,7 +23,7 @@ runs:
       uses: docker/build-push-action@v6
       with:
         context: .
-        file: ./install/Dockerfile
+        file: ./Dockerfile
         push: false
         secrets: |
           "PRIVATE_REPO_ACCESS_TOKEN=${{ inputs.github-token }}"

atlan_application_sdk-0.1.1rc47/.github/release_notes.md

@@ -0,0 +1,9 @@
+## v0.1.1rc47 (September 24, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc46...v0.1.1rc47
+
+### Bug Fixes
+
+- partition columns defaults for daft write_parquet (#728) (by @Nishchith Shetty in [7ed4949](https://github.com/atlanhq/application-sdk/commit/7ed4949))
+- Update ParquetOutput to handle file uploads correctly (#732) (by @Mustafa in [b4b2953](https://github.com/atlanhq/application-sdk/commit/b4b2953))
+- CI build path (#733) (by @Nishchith Shetty in [6d04006](https://github.com/atlanhq/application-sdk/commit/6d04006))

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/.github/workflow-templates/trivy-container.yaml

@@ -47,7 +47,7 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           context: .
-          file: ./install/Dockerfile
+          file: ./Dockerfile
           push: false
           secrets: |
             "PRIVATE_REPO_ACCESS_TOKEN=${{ secrets.PRIVATE_REPO_ACCESS_TOKEN }}"

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/.github/workflows/scale-tests.yaml

@@ -69,7 +69,7 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           context: .
-          file: ./install/Dockerfile
+          file: ./Dockerfile
           tags: test-sample:latest
           secrets: |
             PRIVATE_REPO_ACCESS_TOKEN=${{ secrets.ORG_PAT_GITHUB }}

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## v0.1.1rc47 (September 24, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc46...v0.1.1rc47
+
+### Bug Fixes
+
+- partition columns defaults for daft write_parquet (#728) (by @Nishchith Shetty in [7ed4949](https://github.com/atlanhq/application-sdk/commit/7ed4949))
+- Update ParquetOutput to handle file uploads correctly (#732) (by @Mustafa in [b4b2953](https://github.com/atlanhq/application-sdk/commit/b4b2953))
+- CI build path (#733) (by @Nishchith Shetty in [6d04006](https://github.com/atlanhq/application-sdk/commit/6d04006))
+
+
+
+## v0.1.1rc46 (September 18, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc45...v0.1.1rc46
+
+### Bug Fixes
+
+- Fix semaphore implementation to allow multiple batching without getting into max_concurrent_activities issue (#725) (by @Mustafa in [2a66f13](https://github.com/atlanhq/application-sdk/commit/2a66f13))
+
 ## v0.1.1rc45 (September 18, 2025)
 
 Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc44...v0.1.1rc45

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/PKG-INFO

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

@@ -5,15 +5,15 @@ allowing the workflow to orchestrate locking without hitting Temporal's
 deadlock timeout.
 """
 
-import asyncio
 import random
 from typing import Any, Dict
 
 from temporalio import activity
+from temporalio.exceptions import ApplicationError
 
 from application_sdk.clients.redis import RedisClientAsync
 from application_sdk.common.error_codes import ActivityError
-from application_sdk.constants import APPLICATION_NAME, LOCK_RETRY_INTERVAL
+from application_sdk.constants import APPLICATION_NAME
 from application_sdk.observability.logger_adaptor import get_logger
 
 logger = get_logger(__name__)
@@ -45,40 +45,41 @@ async def acquire_distributed_lock(
     """
     # Input validation
     if max_locks <= 0:
-        raise ActivityError(
-            f"{ActivityError.LOCK_ACQUISITION_ERROR}: max_locks must be greater than 0, got {max_locks}"
+        raise ApplicationError(
+            f"{ActivityError.LOCK_ACQUISITION_ERROR}: max_locks must be greater than 0, got {max_locks}",
+            non_retryable=True,
+        )
+    slot = random.randint(0, max_locks - 1)
+    resource_id = f"{APPLICATION_NAME}:{lock_name}:{slot}"
+
+    try:
+        async with RedisClientAsync() as redis_client:
+            # Acquire lock - connection will stay open until context exits
+            acquired = await redis_client._acquire_lock(
+                resource_id, owner_id, ttl_seconds
+            )
+            if acquired:
+                logger.info(f"Lock acquired for slot {slot}, resource: {resource_id}")
+                return {
+                    "status": True,
+                    "slot_id": slot,
+                    "resource_id": resource_id,
+                    "owner_id": owner_id,
+                }
+
+            raise ActivityError(
+                f"{ActivityError.LOCK_ACQUISITION_ERROR}: Lock not acquired for {resource_id}, will retry after some time"
+            )
+    except Exception as e:
+        # Redis connection or operation failed - propagate as activity error
+        if isinstance(e, (ActivityError)):
+            raise e
+        logger.error(f"Redis error during lock acquisition: {e}")
+        raise ApplicationError(
+            f"Redis error during lock acquisition for {resource_id}, error: {e}",
+            non_retryable=True,
+            type=type(e).__name__,
         )
-
-    async with RedisClientAsync() as redis_client:
-        while True:
-            slot = random.randint(0, max_locks - 1)
-            resource_id = f"{APPLICATION_NAME}:{lock_name}:{slot}"
-
-            try:
-                # Acquire lock - connection will stay open until context exits
-                acquired = await redis_client._acquire_lock(
-                    resource_id, owner_id, ttl_seconds
-                )
-                if acquired:
-                    logger.info(
-                        f"Lock acquired for slot {slot}, resource: {resource_id}"
-                    )
-                    return {
-                        "slot_id": slot,
-                        "resource_id": resource_id,
-                        "owner_id": owner_id,
-                    }
-                # If not acquired, continue retrying (lock held by another owner)
-
-            except Exception as e:
-                # Redis connection or operation failed - propagate as activity error
-                logger.error(f"Redis error during lock acquisition: {e}")
-                raise ActivityError(
-                    f"{ActivityError.LOCK_ACQUISITION_ERROR}: Redis error during lock acquisition for {resource_id}"
-                )
-
-            # Wait before retrying
-            await asyncio.sleep(LOCK_RETRY_INTERVAL)
 
 
 @activity.defn
@@ -94,8 +95,8 @@ async def release_distributed_lock(
     Returns:
         True if lock was released successfully, False otherwise
     """
-    async with RedisClientAsync() as redis_client:
-        try:
+    try:
+        async with RedisClientAsync() as redis_client:
             released, result = await redis_client._release_lock(resource_id, owner_id)
             if released:
                 logger.info(
@@ -103,8 +104,8 @@ async def release_distributed_lock(
                 )
             return released
 
-        except Exception as e:
-            logger.error(f"Redis error during lock release for {resource_id}: {e}")
-            # Don't raise exception for lock release failures - log and return False
-            # Lock release is best-effort and shouldn't fail the workflow
-            return False
+    except Exception as e:
+        logger.error(f"Redis error during lock release for {resource_id}: {e}")
+        # Don't raise exception for lock release failures - log and return False
+        # Lock release is best-effort and shouldn't fail the workflow
+        return False

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/application_sdk/interceptors/lock.py

@@ -22,6 +22,7 @@ from application_sdk.constants import (
     APPLICATION_NAME,
     IS_LOCKING_DISABLED,
     LOCK_METADATA_KEY,
+    LOCK_RETRY_INTERVAL,
 )
 from application_sdk.observability.logger_adaptor import get_logger
 
@@ -106,13 +107,17 @@ class RedisLockOutboundInterceptor(WorkflowOutboundInterceptor):
         lock_result = None
 
         try:
-            # Step 1: Acquire lock via dedicated activity (can take >2s safely)
-            start_to_close_timeout = workflow.info().execution_timeout
-            lock_result = await workflow.execute_activity(
+            # Step 1: Acquire lock via dedicated activity with Temporal retry policy
+            schedule_to_close_timeout = workflow.info().execution_timeout
+            lock_result = await workflow.execute_local_activity(
                 "acquire_distributed_lock",
                 args=[lock_name, max_locks, ttl_seconds, owner_id],
-                start_to_close_timeout=start_to_close_timeout,
-                retry_policy=RetryPolicy(maximum_attempts=1),
+                start_to_close_timeout=timedelta(seconds=30),
+                retry_policy=RetryPolicy(
+                    initial_interval=timedelta(seconds=int(LOCK_RETRY_INTERVAL)),
+                    backoff_coefficient=1.0,
+                ),
+                schedule_to_close_timeout=schedule_to_close_timeout,
             )
 
             logger.debug(f"Lock acquired: {lock_result}, executing {input.activity}")

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/application_sdk/outputs/parquet.py

@@ -221,17 +221,19 @@ class ParquetOutput(Output):
             if row_count == 0:
                 return
 
+            file_paths = []
             # Use Daft's execution context for temporary configuration
             with daft.execution_config_ctx(
                 parquet_target_filesize=self.max_file_size_bytes,
                 default_morsel_size=morsel_size,
             ):
                 # Daft automatically handles file splitting and naming
-                dataframe.write_parquet(
+                result = dataframe.write_parquet(
                     root_dir=self.output_path,
                     write_mode=write_mode.value,
-                    partition_cols=partition_cols if partition_cols else [],
+                    partition_cols=partition_cols,
                 )
+                file_paths = result.to_pydict().get("path", [])
 
             # Update counters
             self.chunk_count += 1
@@ -266,12 +268,12 @@ class ParquetOutput(Output):
                     logger.info(
                         f"No files found under prefix {get_object_store_prefix(self.output_path)}: {str(e)}"
                     )
-
-            await ObjectStore.upload_prefix(
-                source=self.output_path,
-                destination=get_object_store_prefix(self.output_path),
-                retain_local_copy=self.retain_local_copy,
-            )
+            for path in file_paths:
+                await ObjectStore.upload_file(
+                    source=path,
+                    destination=get_object_store_prefix(path),
+                    retain_local_copy=self.retain_local_copy,
+                )
 
         except Exception as e:
             # Record metrics for failed write

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/application_sdk/version.py

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

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atlan-application-sdk"
-version = "0.1.1rc45"
+version = "0.1.1rc47"
 description = "Atlan Application SDK is a Python library for developing applications on the Atlan Platform"
 license = "Apache-2.0"
 authors = [

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/tests/unit/activities/test_lock_management.py

@@ -3,6 +3,7 @@
 from unittest.mock import AsyncMock, patch
 
 import pytest
+from temporalio.exceptions import ApplicationError
 
 from application_sdk.activities.lock_management import (
     acquire_distributed_lock,
@@ -27,6 +28,7 @@ class TestAcquireDistributedLock:
         result = await acquire_distributed_lock("test_resource", 5, 100, "owner1")
 
         # Verify
+        assert result["status"] is True
         assert "slot_id" in result
         assert "resource_id" in result
         assert "owner_id" in result
@@ -36,7 +38,7 @@ class TestAcquireDistributedLock:
     @patch("application_sdk.activities.lock_management.RedisClientAsync")
     async def test_acquire_lock_invalid_max_locks(self, mock_redis_client_class):
         """Test lock acquisition with invalid max_locks."""
-        with pytest.raises(ActivityError) as exc_info:
+        with pytest.raises(ApplicationError) as exc_info:
             await acquire_distributed_lock("test_resource", 0, 100, "owner1")
 
         assert "ATLAN-ACTIVITY-503-01" in str(exc_info.value)
@@ -50,12 +52,27 @@ class TestAcquireDistributedLock:
         mock_client._acquire_lock.side_effect = Exception("Redis connection failed")
         mock_redis_client_class.return_value.__aenter__.return_value = mock_client
 
+        # Execute and verify
+        with pytest.raises(ApplicationError) as exc_info:
+            await acquire_distributed_lock("test_resource", 5, 100, "owner1")
+
+        assert "Redis error during lock acquisition" in str(exc_info.value)
+        assert "Redis connection failed" in str(exc_info.value)
+
+    @patch("application_sdk.activities.lock_management.RedisClientAsync")
+    async def test_acquire_lock_not_available(self, mock_redis_client_class):
+        """Test lock acquisition when lock is not available."""
+        # Setup mock to return False (lock not acquired)
+        mock_client = AsyncMock()
+        mock_client._acquire_lock.return_value = False
+        mock_redis_client_class.return_value.__aenter__.return_value = mock_client
+
         # Execute and verify
         with pytest.raises(ActivityError) as exc_info:
             await acquire_distributed_lock("test_resource", 5, 100, "owner1")
 
         assert "ATLAN-ACTIVITY-503-01" in str(exc_info.value)
-        assert "Redis error during lock acquisition" in str(exc_info.value)
+        assert "Lock not acquired" in str(exc_info.value)
 
 
 class TestReleaseDistributedLock:

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/tests/unit/outputs/test_parquet_output.py

@@ -300,7 +300,7 @@ class TestParquetOutputWriteDaftDataframe:
     async def test_write_daft_dataframe_success(self, base_output_path: str):
         """Test successful daft DataFrame writing."""
         with patch("daft.execution_config_ctx") as mock_ctx, patch(
-            "application_sdk.services.objectstore.ObjectStore.upload_prefix"
+            "application_sdk.services.objectstore.ObjectStore.upload_file"
         ) as mock_upload, patch(
             "application_sdk.outputs.parquet.get_object_store_prefix"
         ) as mock_prefix:
@@ -312,7 +312,9 @@ class TestParquetOutputWriteDaftDataframe:
             # Mock daft DataFrame
             mock_df = MagicMock()
             mock_df.count_rows.return_value = 1000
-            mock_df.write_parquet = MagicMock()
+            mock_result = MagicMock()
+            mock_result.to_pydict.return_value = {"path": ["test.parquet"]}
+            mock_df.write_parquet.return_value = mock_result
 
             parquet_output = ParquetOutput(
                 output_path=base_output_path,
@@ -327,7 +329,7 @@ class TestParquetOutputWriteDaftDataframe:
             mock_df.write_parquet.assert_called_once_with(
                 root_dir=parquet_output.output_path,
                 write_mode="append",  # Uses method default value "append"
-                partition_cols=[],  # Default empty list
+                partition_cols=None,
             )
 
             # Check that upload_prefix was called
@@ -339,7 +341,7 @@ class TestParquetOutputWriteDaftDataframe:
     ):
         """Test daft DataFrame writing with parameter overrides."""
         with patch("daft.execution_config_ctx") as mock_ctx, patch(
-            "application_sdk.services.objectstore.ObjectStore.upload_prefix"
+            "application_sdk.services.objectstore.ObjectStore.upload_file"
         ) as mock_upload, patch(
             "application_sdk.services.objectstore.ObjectStore.delete_prefix"
         ) as mock_delete, patch(
@@ -354,7 +356,9 @@ class TestParquetOutputWriteDaftDataframe:
             # Mock daft DataFrame
             mock_df = MagicMock()
             mock_df.count_rows.return_value = 500
-            mock_df.write_parquet = MagicMock()
+            mock_result = MagicMock()
+            mock_result.to_pydict.return_value = {"path": ["test.parquet"]}
+            mock_df.write_parquet.return_value = mock_result
 
             parquet_output = ParquetOutput(
                 output_path=base_output_path,
@@ -381,7 +385,7 @@ class TestParquetOutputWriteDaftDataframe:
     ):
         """Test daft DataFrame writing with default parameters (uses method default write_mode='append')."""
         with patch("daft.execution_config_ctx") as mock_ctx, patch(
-            "application_sdk.services.objectstore.ObjectStore.upload_prefix"
+            "application_sdk.services.objectstore.ObjectStore.upload_file"
         ) as mock_upload, patch(
             "application_sdk.outputs.parquet.get_object_store_prefix"
         ) as mock_prefix:
@@ -393,7 +397,9 @@ class TestParquetOutputWriteDaftDataframe:
             # Mock daft DataFrame
             mock_df = MagicMock()
             mock_df.count_rows.return_value = 500
-            mock_df.write_parquet = MagicMock()
+            mock_result = MagicMock()
+            mock_result.to_pydict.return_value = {"path": ["test.parquet"]}
+            mock_df.write_parquet.return_value = mock_result
 
             parquet_output = ParquetOutput(
                 output_path=base_output_path,
@@ -406,7 +412,7 @@ class TestParquetOutputWriteDaftDataframe:
             mock_df.write_parquet.assert_called_once_with(
                 root_dir=parquet_output.output_path,
                 write_mode="append",  # Uses method default value "append"
-                partition_cols=[],  # None converted to empty list
+                partition_cols=None,
             )
 
     @pytest.mark.asyncio
@@ -415,7 +421,7 @@ class TestParquetOutputWriteDaftDataframe:
     ):
         """Test that DAPR limit is properly configured."""
         with patch("daft.execution_config_ctx") as mock_ctx, patch(
-            "application_sdk.services.objectstore.ObjectStore.upload_prefix"
+            "application_sdk.services.objectstore.ObjectStore.upload_file"
         ) as mock_upload, patch(
             "application_sdk.outputs.parquet.get_object_store_prefix"
         ) as mock_prefix:
@@ -427,7 +433,9 @@ class TestParquetOutputWriteDaftDataframe:
             # Mock daft DataFrame
             mock_df = MagicMock()
             mock_df.count_rows.return_value = 1000
-            mock_df.write_parquet = MagicMock()
+            mock_result = MagicMock()
+            mock_result.to_pydict.return_value = {"path": ["test.parquet"]}
+            mock_df.write_parquet.return_value = mock_result
 
             parquet_output = ParquetOutput(output_path=base_output_path)
 
@@ -488,7 +496,7 @@ class TestParquetOutputMetrics:
     async def test_daft_write_metrics(self, base_output_path: str):
         """Test that metrics are recorded for daft DataFrame writes."""
         with patch("daft.execution_config_ctx") as mock_ctx, patch(
-            "application_sdk.services.objectstore.ObjectStore.upload_prefix"
+            "application_sdk.services.objectstore.ObjectStore.upload_file"
         ) as mock_upload, patch(
             "application_sdk.outputs.parquet.get_metrics"
         ) as mock_get_metrics, patch(
@@ -504,7 +512,9 @@ class TestParquetOutputMetrics:
             # Mock daft DataFrame
             mock_df = MagicMock()
             mock_df.count_rows.return_value = 1000
-            mock_df.write_parquet = MagicMock()
+            mock_result = MagicMock()
+            mock_result.to_pydict.return_value = {"path": ["test.parquet"]}
+            mock_df.write_parquet.return_value = mock_result
 
             parquet_output = ParquetOutput(output_path=base_output_path)
 

{atlan_application_sdk-0.1.1rc45 → atlan_application_sdk-0.1.1rc47}/uv.lock

@@ -140,7 +140,7 @@ wheels = [
 
 [[package]]
 name = "atlan-application-sdk"
-version = "0.1.1rc45"
+version = "0.1.1rc47"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

atlan_application_sdk-0.1.1rc45/.github/release_notes.md

@@ -1,9 +0,0 @@
-## v0.1.1rc45 (September 18, 2025)
-
-Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc44...v0.1.1rc45
-
-### Features
-
-- add MCP (Model Context Protocol) integration to application-sdk (#698) (by @AdvitXAtlan in [a5d496e](https://github.com/atlanhq/application-sdk/commit/a5d496e))
-- fix credentials and extra field information in docs (#724) (by @Nishchith Shetty in [a0808db](https://github.com/atlanhq/application-sdk/commit/a0808db))
-- add minimal API docs for endpoints exposed (#721) (by @Nishchith Shetty in [3301b61](https://github.com/atlanhq/application-sdk/commit/3301b61))