atlan-application-sdk 1.0.2__tar.gz → 1.0.4__tar.gz

atlan_application_sdk-1.0.4/.github/release_notes.md

@@ -0,0 +1,7 @@
+## v1.0.4 (December 11, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v1.0.3...v1.0.4
+
+### Bug Fixes
+
+- add automatic gRPC message size limit handling for large file uploads (#878) (by @SanilK2108 in [4d76838](https://github.com/atlanhq/application-sdk/commit/4d76838))

{atlan_application_sdk-1.0.2 → atlan_application_sdk-1.0.4}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## v1.0.4 (December 11, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v1.0.3...v1.0.4
+
+### Bug Fixes
+
+- add automatic gRPC message size limit handling for large file uploads (#878) (by @SanilK2108 in [4d76838](https://github.com/atlanhq/application-sdk/commit/4d76838))
+
+
+## v1.0.3 (December 09, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v1.0.2...v1.0.3
+
+### Bug Fixes
+
+- handle Azure Blob and GCP response formats in list_files method in objectstore service (#875) (by @hamza-atlan in [19d26a3](https://github.com/atlanhq/application-sdk/commit/19d26a3))
+- error handling on connection failures (#877) (by @sachi-atlan in [8108186](https://github.com/atlanhq/application-sdk/commit/8108186))
+
+
 ## v1.0.2 (December 09, 2025)
 
 Full Changelog: https://github.com/atlanhq/application-sdk/compare/v1.0.1...v1.0.2

{atlan_application_sdk-1.0.2 → atlan_application_sdk-1.0.4}/PKG-INFO

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

@@ -151,6 +151,10 @@ class ActivitiesInterface(ABC, Generic[ActivitiesStateType]):
             )
             await self._clean_state()
             raise
+        except Exception as err:
+            logger.error(f"Error getting state: {str(err)}", exc_info=err)
+            await self._clean_state()
+            raise
 
     async def _clean_state(self):
         """Remove the state data for the current workflow.

{atlan_application_sdk-1.0.2 → atlan_application_sdk-1.0.4}/application_sdk/services/objectstore.py

@@ -85,7 +85,15 @@ class ObjectStore:
 
             # Extract paths based on response type
             if isinstance(file_list, list):
-                paths = file_list
+                # Handle list format: strings OR Azure Blob/GCP dicts with "Name" field
+                paths = []
+                for item in file_list:
+                    if isinstance(item, str):
+                        paths.append(item)
+                    elif isinstance(item, dict) and isinstance(item.get("Name"), str):
+                        paths.append(item["Name"])
+                    else:
+                        logger.warning(f"Skipping invalid path entry: {item}")
             elif isinstance(file_list, dict) and "Contents" in file_list:
                 paths = [item["Key"] for item in file_list["Contents"] if "Key" in item]
             elif isinstance(file_list, dict):
@@ -98,6 +106,7 @@ class ObjectStore:
                 if not isinstance(path, str):
                     logger.warning(f"Skipping non-string path: {path}")
                     continue
+
                 valid_list.append(
                     path[path.find(prefix) :]
                     if prefix and prefix in path
@@ -460,9 +469,35 @@ class ObjectStore:
             Exception: If there's an error with the Dapr binding operation.
         """
         try:
-            with DaprClient(
-                max_grpc_message_length=DAPR_MAX_GRPC_MESSAGE_LENGTH
-            ) as client:
+            # Calculate data size (handle both bytes and str)
+            if isinstance(data, bytes):
+                data_size = len(data)
+            elif isinstance(data, str):
+                data_size = len(data.encode("utf-8"))
+            else:
+                data_size = 0
+
+            # Check if data size exceeds DAPR limit and log warning
+            if data_size > DAPR_MAX_GRPC_MESSAGE_LENGTH:
+                # gRPC adds overhead (headers, metadata, etc.) to messages
+                # Add a buffer of 5% or at least 1KB to account for this overhead
+                grpc_overhead_buffer = max(int(data_size * 0.05), 1024)
+                required_max_length = data_size + grpc_overhead_buffer
+                logger.warning(
+                    f"Data size ({data_size:,} bytes / {data_size / (1024 * 1024):.2f}MB) "
+                    f"exceeds DAPR_MAX_GRPC_MESSAGE_LENGTH ({DAPR_MAX_GRPC_MESSAGE_LENGTH:,} bytes / "
+                    f"{DAPR_MAX_GRPC_MESSAGE_LENGTH / (1024 * 1024):.2f}MB). "
+                    f"Increasing max_grpc_message_length to {required_max_length:,} bytes "
+                    f"(data size + {grpc_overhead_buffer:,} bytes overhead buffer). "
+                    f"This may cause issues with Dapr gRPC communication."
+                )
+                # Set max_grpc_message_length to accommodate the data size plus gRPC overhead
+                max_message_length = required_max_length
+            else:
+                # Data is within limit, use default DAPR limit
+                max_message_length = DAPR_MAX_GRPC_MESSAGE_LENGTH
+
+            with DaprClient(max_grpc_message_length=max_message_length) as client:
                 response = client.invoke_binding(
                     binding_name=store_name,
                     operation=operation,

{atlan_application_sdk-1.0.2 → atlan_application_sdk-1.0.4}/application_sdk/version.py

@@ -2,4 +2,4 @@
 Version information for the application_sdk package.
 """
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"

{atlan_application_sdk-1.0.2 → atlan_application_sdk-1.0.4}/pyproject.toml

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

{atlan_application_sdk-1.0.2 → atlan_application_sdk-1.0.4}/tests/unit/activities/test_activities.py

@@ -299,3 +299,68 @@ class TestMockActivities:
         state = await mock_activities._get_state(workflow_args)
         assert state.handler is not None
         assert isinstance(state.handler, MockHandler)
+
+
+class MockActivitiesImplementation(ActivitiesInterface):
+    """Minimal concrete implementation for testing base methods."""
+
+    pass
+
+
+class TestActivitiesInterfaceErrorHandling:
+    """Test error handling in ActivitiesInterface."""
+
+    @pytest.fixture
+    def activities(self):
+        return MockActivitiesImplementation()
+
+    @patch("application_sdk.activities.get_workflow_id")
+    async def test_get_state_cleans_up_on_general_exception(
+        self, mock_get_workflow_id, activities
+    ):
+        """Test that _get_state cleans up state if _set_state raises a general Exception."""
+        workflow_id = "wf-1"
+        mock_get_workflow_id.return_value = workflow_id
+
+        # Simulate the state being "dirty" (entry created) before _set_state fails.
+        async def set_state_side_effect(workflow_args):
+            activities._state[workflow_id] = ActivitiesState()
+            raise Exception("DB Connection Failed")
+
+        with patch.object(
+            activities, "_set_state", side_effect=set_state_side_effect
+        ) as mock_set_state:
+            # Ensure state is empty initially
+            assert workflow_id not in activities._state
+
+            # Call _get_state, expect exception re-raised
+            with pytest.raises(Exception, match="DB Connection Failed"):
+                await activities._get_state({})
+
+            # Verify state was cleaned up (entry removed)
+            assert workflow_id not in activities._state
+            mock_set_state.assert_called_once()
+
+    @patch("application_sdk.activities.get_workflow_id")
+    async def test_get_state_cleans_up_on_orchestrator_error(
+        self, mock_get_workflow_id, activities
+    ):
+        """Test that _get_state cleans up state if _set_state raises OrchestratorError."""
+        workflow_id = "wf-2"
+        mock_get_workflow_id.return_value = workflow_id
+
+        from application_sdk.common.error_codes import OrchestratorError
+
+        async def set_state_side_effect(workflow_args):
+            activities._state[workflow_id] = ActivitiesState()
+            raise OrchestratorError(
+                OrchestratorError.ORCHESTRATOR_CLIENT_ACTIVITY_ERROR.code,
+                "Orchestrator Fail",
+            )
+
+        with patch.object(activities, "_set_state", side_effect=set_state_side_effect):
+            with pytest.raises(Exception) as excinfo:
+                await activities._get_state({})
+
+            assert isinstance(excinfo.value, OrchestratorError)
+            assert workflow_id not in activities._state

{atlan_application_sdk-1.0.2 → atlan_application_sdk-1.0.4}/tests/unit/services/test_objectstore.py

@@ -4,6 +4,7 @@ from unittest.mock import AsyncMock, MagicMock, mock_open, patch
 
 import pytest
 
+from application_sdk.constants import DAPR_MAX_GRPC_MESSAGE_LENGTH
 from application_sdk.services.objectstore import ObjectStore
 
 
@@ -301,6 +302,123 @@ class TestObjectStore:
 
         assert result is None
 
+    @patch("application_sdk.services.objectstore.DaprClient")
+    @patch("application_sdk.services.objectstore.logger")
+    async def test_invoke_dapr_binding_with_large_data_warning(
+        self, mock_logger: MagicMock, mock_dapr_client: MagicMock
+    ) -> None:
+        """Test that a warning is logged when data size exceeds DAPR_MAX_GRPC_MESSAGE_LENGTH."""
+
+        mock_client = MagicMock()
+        mock_response = MagicMock()
+        mock_response.data = b"response data"
+        mock_client.invoke_binding.return_value = mock_response
+        mock_dapr_client.return_value.__enter__.return_value = mock_client
+
+        # Create data that exceeds the DAPR limit
+        large_data = b"x" * (DAPR_MAX_GRPC_MESSAGE_LENGTH + 1)
+
+        result = await ObjectStore._invoke_dapr_binding(
+            operation="create",
+            metadata={"key": "test"},
+            data=large_data,
+        )
+
+        # Verify warning was logged
+        mock_logger.warning.assert_called_once()
+        warning_call = mock_logger.warning.call_args[0][0]
+        assert "exceeds DAPR_MAX_GRPC_MESSAGE_LENGTH" in warning_call
+        assert f"{DAPR_MAX_GRPC_MESSAGE_LENGTH + 1:,}" in warning_call
+
+        # Verify DaprClient was called with increased max_grpc_message_length
+        # With 5% buffer: (DAPR_MAX_GRPC_MESSAGE_LENGTH + 1) + 5% of (DAPR_MAX_GRPC_MESSAGE_LENGTH + 1)
+        mock_dapr_client.assert_called_once()
+        call_kwargs = mock_dapr_client.call_args[1]
+        expected_data_size = DAPR_MAX_GRPC_MESSAGE_LENGTH + 1
+        expected_buffer = max(
+            int(expected_data_size * 0.05), 1024
+        )  # 5% buffer, min 1KB
+        expected_max_length = expected_data_size + expected_buffer
+        assert call_kwargs["max_grpc_message_length"] == expected_max_length
+
+        # Verify the binding was invoked
+        mock_client.invoke_binding.assert_called_once()
+        assert result == b"response data"
+
+    @patch("application_sdk.services.objectstore.DaprClient")
+    @patch("application_sdk.services.objectstore.logger")
+    async def test_invoke_dapr_binding_with_small_data_no_warning(
+        self, mock_logger: MagicMock, mock_dapr_client: MagicMock
+    ) -> None:
+        """Test that no warning is logged when data size is within DAPR_MAX_GRPC_MESSAGE_LENGTH."""
+        from application_sdk.constants import DAPR_MAX_GRPC_MESSAGE_LENGTH
+
+        mock_client = MagicMock()
+        mock_response = MagicMock()
+        mock_response.data = b"response data"
+        mock_client.invoke_binding.return_value = mock_response
+        mock_dapr_client.return_value.__enter__.return_value = mock_client
+
+        # Create data that is within the DAPR limit
+        small_data = b"x" * (DAPR_MAX_GRPC_MESSAGE_LENGTH - 1000)
+
+        result = await ObjectStore._invoke_dapr_binding(
+            operation="create",
+            metadata={"key": "test"},
+            data=small_data,
+        )
+
+        # Verify no warning was logged
+        mock_logger.warning.assert_not_called()
+
+        # Verify DaprClient was called with default max_grpc_message_length
+        mock_dapr_client.assert_called_once()
+        call_kwargs = mock_dapr_client.call_args[1]
+        assert call_kwargs["max_grpc_message_length"] == DAPR_MAX_GRPC_MESSAGE_LENGTH
+
+        # Verify the binding was invoked
+        mock_client.invoke_binding.assert_called_once()
+        assert result == b"response data"
+
+    @patch("application_sdk.services.objectstore.DaprClient")
+    @patch("application_sdk.services.objectstore.logger")
+    async def test_invoke_dapr_binding_with_string_data(
+        self, mock_logger: MagicMock, mock_dapr_client: MagicMock
+    ) -> None:
+        """Test that string data is properly handled and size is calculated correctly."""
+        from application_sdk.constants import DAPR_MAX_GRPC_MESSAGE_LENGTH
+
+        mock_client = MagicMock()
+        mock_response = MagicMock()
+        mock_response.data = b"response data"
+        mock_client.invoke_binding.return_value = mock_response
+        mock_dapr_client.return_value.__enter__.return_value = mock_client
+
+        # Create a string that when encoded exceeds the DAPR limit
+        # Each character in UTF-8 is typically 1 byte, but we'll use a large string
+        large_string = "x" * (DAPR_MAX_GRPC_MESSAGE_LENGTH + 1)
+
+        result = await ObjectStore._invoke_dapr_binding(
+            operation="create",
+            metadata={"key": "test"},
+            data=large_string,
+        )
+
+        # Verify warning was logged
+        mock_logger.warning.assert_called_once()
+
+        # Verify DaprClient was called with increased max_grpc_message_length
+        mock_dapr_client.assert_called_once()
+        call_kwargs = mock_dapr_client.call_args[1]
+        # The encoded string size should be accounted for
+        assert (
+            call_kwargs["max_grpc_message_length"] >= DAPR_MAX_GRPC_MESSAGE_LENGTH + 1
+        )
+
+        # Verify the binding was invoked
+        mock_client.invoke_binding.assert_called_once()
+        assert result == b"response data"
+
     # @patch("application_sdk.services.objectstore.ObjectStore.list_files", new_callable=AsyncMock)
     # @patch("application_sdk.services.objectstore.ObjectStore._download_file", new_callable=AsyncMock)
     # async def test_download_directory_success(
@@ -312,3 +430,140 @@ class TestObjectStore:
     #         destination="/tmp",
     #     )
     #     assert mock_download_file.await_count == 2
+
+    @pytest.mark.parametrize(
+        "response_json, prefix, expected_paths",
+        [
+            # 1: Standard List of Strings
+            (["file1.txt", "sub/file2.txt"], "", ["file1.txt", "sub/file2.txt"]),
+            # 2: AWS S3 Format (Dict with Contents)
+            (
+                {"Contents": [{"Key": "s3-file.txt"}, {"Key": "folder/s3-file2.txt"}]},
+                "",
+                ["s3-file.txt", "folder/s3-file2.txt"],
+            ),
+            # 3: Azure/GCP Format (List of Dicts with "Name")
+            (
+                [
+                    {"Name": "az-blob.txt", "etag": "123"},
+                    {"Name": "folder/az-blob2.txt"},
+                    {"Name": "folder/gcs.parquet"},
+                ],
+                "",
+                ["az-blob.txt", "folder/az-blob2.txt", "folder/gcs.parquet"],
+            ),
+            # 4: Generic Wrapper "files"
+            ({"files": ["generic1.txt"]}, "", ["generic1.txt"]),
+            # 5: Generic Wrapper "keys"
+            ({"keys": ["key1.txt"]}, "", ["key1.txt"]),
+            # 6: Mixed Invalid Types (Integers, None, Boolean)
+            (
+                ["valid.txt", 123, None, True, "valid2.txt"],
+                "",
+                ["valid.txt", "valid2.txt"],
+            ),
+            # 7: Malformed Dictionaries (Missing "Name")
+            (
+                [{"Name": "valid.txt"}, {"etag": "no-name"}, {"size": 500}],
+                "",
+                ["valid.txt"],
+            ),
+            # 8: Dict with non-string "Name" value (None, int, nested dict)
+            (
+                [
+                    {"Name": "valid.txt"},
+                    {"Name": None},
+                    {"Name": 123},
+                    {"Name": {"nested": "dict"}},
+                    {},
+                ],
+                "",
+                ["valid.txt"],
+            ),
+            # 9: S3 Items Missing "Key" (Filtered by list comprehension)
+            (
+                {"Contents": [{"Key": "good.txt"}, {"Size": 500}]},
+                "",
+                ["good.txt"],
+            ),
+            # 10: Unknown Structure (Empty Fallback)
+            ({"random": "data"}, "", []),
+            # 11: Prefix Slicing (Prefix Exists in Path)
+            # Logic: Returns substring starting from prefix
+            (
+                ["root/my-folder/image.png"],
+                "my-folder",
+                ["my-folder/image.png"],
+            ),
+            # 12: Prefix Fallback (Prefix NOT in Path)
+            # Logic: Returns os.path.basename if prefix is provided but not found
+            (
+                ["other-location/image.png"],
+                "my-folder/",
+                ["image.png"],
+            ),
+            # 13: No Prefix Provided
+            # Logic: Returns full original path
+            (
+                ["/full/path/to/file.txt"],
+                "",
+                ["/full/path/to/file.txt"],
+            ),
+        ],
+    )
+    @patch("application_sdk.services.objectstore.ObjectStore._invoke_dapr_binding")
+    async def test_list_files_parsing_and_logic(
+        self,
+        mock_invoke: AsyncMock,
+        response_json,
+        prefix,
+        expected_paths,
+    ) -> None:
+        """
+        1. JSON Structure parsing (List vs Dict vs S3 vs Azure)
+        2. Item validation (Skipping invalid types)
+        3. Prefix path transformation logic
+        """
+        # Arrange
+        import orjson
+
+        mock_invoke.return_value = orjson.dumps(response_json)
+
+        # Act
+        result = await ObjectStore.list_files(prefix=prefix)
+
+        # Assert
+        assert result == expected_paths
+        mock_invoke.assert_called_once()
+
+    @patch("application_sdk.services.objectstore.ObjectStore._invoke_dapr_binding")
+    async def test_list_files_empty_response(self, mock_invoke: AsyncMock) -> None:
+        """14: Test handling of empty/None response from Dapr."""
+        # Arrange: simulate empty byte response
+        mock_invoke.return_value = b""
+
+        # Act
+        result = await ObjectStore.list_files(prefix="test")
+
+        # Assert
+        assert result == []
+
+    @patch("application_sdk.services.objectstore.ObjectStore._invoke_dapr_binding")
+    async def test_list_files_malformed_json(self, mock_invoke: AsyncMock) -> None:
+        """15: Test handling of corrupt JSON response."""
+        # Arrange: simulate invalid JSON
+        mock_invoke.return_value = b"{invalid-json..."
+
+        # Act & Assert
+        with pytest.raises(Exception):  # Expecting JSONDecodeError wrapped or raised
+            await ObjectStore.list_files(prefix="test")
+
+    @patch("application_sdk.services.objectstore.ObjectStore._invoke_dapr_binding")
+    async def test_list_files_binding_failure(self, mock_invoke: AsyncMock) -> None:
+        """16: Test handling of Dapr binding exception."""
+        # Arrange
+        mock_invoke.side_effect = Exception("Network Error")
+
+        # Act & Assert
+        with pytest.raises(Exception, match="Network Error"):
+            await ObjectStore.list_files(prefix="test")

{atlan_application_sdk-1.0.2 → atlan_application_sdk-1.0.4}/uv.lock

@@ -182,7 +182,7 @@ wheels = [
 
 [[package]]
 name = "atlan-application-sdk"
-version = "1.0.2"
+version = "1.0.4"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

atlan_application_sdk-1.0.2/.github/release_notes.md

@@ -1,7 +0,0 @@
-## v1.0.2 (December 09, 2025)
-
-Full Changelog: https://github.com/atlanhq/application-sdk/compare/v1.0.1...v1.0.2
-
-### Bug Fixes
-
-- release version bump (#871) (by @inishchith in [0cf4305](https://github.com/atlanhq/application-sdk/commit/0cf4305))