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

application_sdk/outputs/objectstore.py

@@ -1,125 +0,0 @@
-"""Object store interface for the application."""
-
-import os
-import shutil
-
-from dapr.clients import DaprClient
-from temporalio import activity
-
-from application_sdk.constants import DEPLOYMENT_OBJECT_STORE_NAME
-from application_sdk.observability.logger_adaptor import get_logger
-
-logger = get_logger(__name__)
-activity.logger = logger
-
-
-class ObjectStoreOutput:
-    OBJECT_CREATE_OPERATION = "create"
-
-    @staticmethod
-    def _cleanup_local_path(path: str) -> None:
-        """Remove a file or directory (recursively). Ignores if doesn't exist.
-        Args:
-            path (str): The path to the file or directory to remove.
-        """
-        try:
-            if os.path.isfile(path) or os.path.islink(path):
-                os.remove(path)
-            elif os.path.isdir(path):
-                shutil.rmtree(path)
-        except FileNotFoundError:
-            pass  # ignore if the file or directory doesn't exist
-        except Exception as e:
-            logger.warning(f"Error cleaning up {path}: {str(e)}")
-
-    @classmethod
-    async def push_file_to_object_store(
-        cls,
-        output_prefix: str,
-        file_path: str,
-        object_store_name: str = DEPLOYMENT_OBJECT_STORE_NAME,
-    ) -> None:
-        """Pushes a single file to the object store.
-
-        Args:
-            output_prefix (str): The base path to calculate relative paths from.
-                example: /tmp/output
-            file_path (str): The full path to the file to be pushed.
-                example: /tmp/output/persistent-artifacts/apps/myapp/data/wf-123/state.json
-
-        Raises:
-            IOError: If there's an error reading the file.
-            Exception: If there's an error pushing the file to the object store.
-        """
-        with DaprClient() as client:
-            try:
-                with open(file_path, "rb") as f:
-                    file_content = f.read()
-            except IOError as e:
-                logger.error(f"Error reading file {file_path}: {str(e)}")
-                raise e
-
-            relative_path = os.path.relpath(file_path, output_prefix)
-            metadata = {
-                "key": relative_path,
-                "blobName": relative_path,
-                "fileName": relative_path,
-            }
-
-            try:
-                client.invoke_binding(
-                    binding_name=object_store_name,
-                    operation=cls.OBJECT_CREATE_OPERATION,
-                    data=file_content,
-                    binding_metadata=metadata,
-                )
-                logger.debug(f"Successfully pushed file: {relative_path}")
-            except Exception as e:
-                logger.error(
-                    f"Error pushing file {relative_path} to object store: {str(e)}"
-                )
-                raise e
-            cls._cleanup_local_path(file_path)
-
-    @classmethod
-    async def push_files_to_object_store(
-        cls,
-        output_prefix: str,
-        input_files_path: str,
-        object_store_name: str = DEPLOYMENT_OBJECT_STORE_NAME,
-    ) -> None:
-        """Pushes files from a directory to the object store.
-
-        Args:
-            output_prefix (str): The base path to calculate relative paths from.
-            input_files_path (str): The path to the directory containing files to push.
-
-        Raises:
-            ValueError: If the input_files_path doesn't exist or is not a directory.
-            IOError: If there's an error reading files.
-            Exception: If there's an error with the Dapr client operations.
-
-        Example:
-            >>> ObjectStoreOutput.push_files_to_object_store("logs", "/tmp/observability")
-        """
-        if not os.path.isdir(input_files_path):
-            raise ValueError(
-                f"The provided output_path '{input_files_path}' is not a valid directory."
-            )
-
-        try:
-            for root, _, files in os.walk(input_files_path):
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    await cls.push_file_to_object_store(
-                        output_prefix, file_path, object_store_name
-                    )
-
-            logger.info(
-                f"Completed pushing data from {input_files_path} to object store"
-            )
-        except Exception as e:
-            logger.error(
-                f"An unexpected error occurred while pushing files to object store: {str(e)}"
-            )
-            raise e

application_sdk/outputs/secretstore.py

@@ -1,38 +0,0 @@
-"""Secret store for the application."""
-
-import uuid
-from typing import Any, Dict
-
-from application_sdk.constants import DEPLOYMENT_NAME, LOCAL_ENVIRONMENT
-from application_sdk.inputs.statestore import StateType
-from application_sdk.outputs.statestore import StateStoreOutput
-
-
-class SecretStoreOutput:
-    @classmethod
-    async def save_secret(cls, config: Dict[str, Any]) -> str:
-        """Store credentials in the state store.
-
-        Args:
-            config: The credentials to store.
-
-        Returns:
-            str: The generated credential GUID.
-
-        Raises:
-            Exception: If there's an error with the Dapr client operations.
-
-        Examples:
-            >>> SecretStoreOutput.save_secret({"username": "admin", "password": "password"})
-            "1234567890"
-        """
-        if DEPLOYMENT_NAME == LOCAL_ENVIRONMENT:
-            # NOTE: (development) temporary solution to store the credentials in the state store.
-            # In production, dapr doesn't support creating secrets.
-            credential_guid = str(uuid.uuid4())
-            await StateStoreOutput.save_state_object(
-                id=credential_guid, value=config, type=StateType.CREDENTIALS
-            )
-            return credential_guid
-        else:
-            raise ValueError("Storing credentials is not supported in production.")

application_sdk/outputs/statestore.py

@@ -1,113 +0,0 @@
-"""State store for the application."""
-
-import json
-import os
-from typing import Any, Dict
-
-from temporalio import activity
-
-from application_sdk.constants import TEMPORARY_PATH, UPSTREAM_OBJECT_STORE_NAME
-from application_sdk.inputs.statestore import (
-    StateStoreInput,
-    StateType,
-    build_state_store_path,
-)
-from application_sdk.observability.logger_adaptor import get_logger
-from application_sdk.outputs.objectstore import ObjectStoreOutput
-
-logger = get_logger(__name__)
-activity.logger = logger
-
-
-class StateStoreOutput:
-    @classmethod
-    async def save_state(cls, key: str, value: Any, id: str, type: StateType) -> None:
-        """Save state to the store.
-
-        Args:
-            key: The key to store the state under.
-            value: The dictionary value to store.
-
-        Raises:
-            Exception: If there's an error with the Dapr client operations.
-
-        Example:
-            >>> from application_sdk.outputs.statestore import StateStoreOutput
-
-            >>> await StateStoreOutput.save_state("test", {"test": "test"}, "wf-123")
-        """
-        try:
-            # get the current state from object store
-            current_state = StateStoreInput.get_state(id, type)
-            state_file_path = build_state_store_path(id, type)
-
-            # update the state with the new value
-            current_state[key] = value
-
-            local_state_file_path = os.path.join(TEMPORARY_PATH, state_file_path)
-            os.makedirs(os.path.dirname(local_state_file_path), exist_ok=True)
-
-            # save the state to a local file
-            with open(local_state_file_path, "w") as file:
-                json.dump(current_state, file)
-
-            # save the state to the object store
-            await ObjectStoreOutput.push_file_to_object_store(
-                output_prefix=TEMPORARY_PATH,
-                file_path=local_state_file_path,
-                object_store_name=UPSTREAM_OBJECT_STORE_NAME,
-            )
-
-        except Exception as e:
-            logger.error(f"Failed to store state: {str(e)}")
-            raise e
-
-    @classmethod
-    async def save_state_object(
-        cls, id: str, value: Dict[str, Any], type: StateType
-    ) -> Dict[str, Any]:
-        """Save the entire state object to the object store.
-
-        Args:
-            id: The id of the state.
-            value: The value of the state.
-            type: The type of the state.
-
-        Returns:
-            Dict[str, Any]: The updated state.
-
-        Raises:
-            ValueError: If the type is invalid.
-            Exception: If there's an error with the Dapr client operations.
-
-        Example:
-            >>> from application_sdk.outputs.statestore import StateStoreOutput
-            >>> await StateStoreOutput.save_state_object("wf-123", {"test": "test"}, "workflow")
-        """
-        try:
-            logger.info(f"Saving state object for {id} with type {type}")
-            # get the current state from object store
-            current_state = StateStoreInput.get_state(id, type)
-            state_file_path = build_state_store_path(id, type)
-
-            # update the state with the new value
-            current_state.update(value)
-
-            local_state_file_path = os.path.join(TEMPORARY_PATH, state_file_path)
-            os.makedirs(os.path.dirname(local_state_file_path), exist_ok=True)
-
-            # save the state to a local file
-            with open(local_state_file_path, "w") as file:
-                json.dump(current_state, file)
-
-            # save the state to the object store
-            await ObjectStoreOutput.push_file_to_object_store(
-                output_prefix=TEMPORARY_PATH,
-                file_path=local_state_file_path,
-                object_store_name=UPSTREAM_OBJECT_STORE_NAME,
-            )
-            logger.info(f"State object saved for {id} with type {type}")
-            return current_state
-        except Exception as e:
-            logger.error(f"Failed to store state: {str(e)}")
-            raise e