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

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

@@ -58,3 +58,63 @@
 - **Metrics**: Key operations include appropriate metrics
 - **Error Context**: Error logs include sufficient context for debugging
 - **Trace Information**: Critical paths include trace information
+
+## 🚨 Automated Pattern Detection Rules
+
+### Unit Test Requirements
+
+- **Mandatory Test Coverage**: PRs with titles starting with "fix:" MUST include corresponding test file changes
+- **Test File Naming**: Test files must follow the pattern `test_*.py` and mirror source structure
+
+### File Naming Conventions
+
+- **Model/Dataclass Files**: Files named `base.py` containing dataclasses or pydantic models should be renamed to `models.py` or `model.py`
+- **Descriptive Naming**: File names should clearly indicate their purpose and contents
+- **Consistency**: Follow established naming patterns within the repository
+
+### Directory Structure
+
+- **Single File Directories**: Directories containing only one file should be reorganized (e.g., `events/` folder with only one file)
+- **Logical Grouping**: Related functionality should be grouped in appropriate subdirectories
+- **Module Organization**: Avoid creating unnecessary directory nesting for single files
+
+### Magic String Constants
+
+- **Operation Strings**: Hardcoded strings like `"create"`, `"update"`, `"delete"` in business logic should be extracted to constants or enums.
+- **Configuration Values**: String literals used across multiple files that are loaded from environment variables should be defined in `constants.py`.
+
+### Method Naming
+
+- **Verbose Names**: Method names longer than 25 characters with redundant context should be simplified
+- **Clear Intent**: Method names should be concise but descriptive of their primary purpose
+- **Context Redundancy**: Avoid repeating class or module context in method names
+
+### Dead Code Detection
+
+- **Conditional Blocks**: Flag `if False:` blocks and suggest removal
+- **Unused Boolean Flags**: Detect and remove unused boolean flags and conditional logic
+- **Commented Code**: Remove commented-out code blocks that are no longer needed
+- **Unreachable Code**: Identify and remove code that can never be executed
+
+### Code Duplication
+
+- **Utility Extraction**: Repeated logic should be extracted into shared utility methods
+- **Configuration Patterns**: Similar configuration setup code should be centralized
+
+### File Management
+
+- **Premature Creation**: Flag new empty files or files with minimal content that aren't referenced elsewhere
+- **Unused Files**: Detect files added then immediately marked for removal in the same PR
+- **File Purpose**: Ensure every new file serves a clear, documented purpose
+
+### Import Organization
+
+- **Stale Imports**: When code is moved between files, check if old imports still reference moved code
+- **Import Cleanup**: Remove unused imports after code reorganization
+- **Dependency Management**: Ensure imports reflect actual code dependencies
+
+### Async Pattern Consistency
+
+- **Workflow Context**: In workflow/temporal contexts, flag sync method calls that should be async
+- **Mixed Patterns**: Ensure consistent async/await usage within the same module
+- **Temporal Best Practices**: Follow Temporal SDK guidelines for async operations

atlan_application_sdk-0.1.1rc34/.github/release_notes.md

@@ -0,0 +1,7 @@
+## v0.1.1rc34 (August 27, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc33...v0.1.1rc34
+
+### Features
+
+- Generic Client and Handlers for non-SQL connectors with http request methods (allows custom retry transport) (#660) (by @Prateek Rai in [b077a90](https://github.com/atlanhq/application-sdk/commit/b077a90))

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

@@ -1,5 +1,14 @@
 # Changelog
 
+
+## v0.1.1rc34 (August 27, 2025)
+
+Full Changelog: https://github.com/atlanhq/application-sdk/compare/v0.1.1rc33...v0.1.1rc34
+
+### Features
+
+- Generic Client and Handlers for non-SQL connectors with http request methods (allows custom retry transport) (#660) (by @Prateek Rai in [b077a90](https://github.com/atlanhq/application-sdk/commit/b077a90))
+
 ## 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.1rc33 → atlan_application_sdk-0.1.1rc34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlan-application-sdk
-Version: 0.1.1rc33
+Version: 0.1.1rc34
 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.1rc34/application_sdk/activities/metadata_extraction/base.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict, Optional, Type
+
+from temporalio import activity
+
+from application_sdk.activities import ActivitiesInterface, ActivitiesState
+from application_sdk.activities.common.utils import get_workflow_id
+from application_sdk.clients.base import BaseClient
+from application_sdk.common.credential_utils import get_credentials
+from application_sdk.constants import APP_TENANT_ID, APPLICATION_NAME
+from application_sdk.handlers.base import BaseHandler
+from application_sdk.observability.logger_adaptor import get_logger
+from application_sdk.transformers import TransformerInterface
+
+logger = get_logger(__name__)
+activity.logger = logger
+
+
+class BaseMetadataExtractionActivitiesState(ActivitiesState):
+    """State for base metadata extraction activities."""
+
+    client: Optional[BaseClient] = None
+    handler: Optional[BaseHandler] = None
+    transformer: Optional[TransformerInterface] = None
+
+
+class BaseMetadataExtractionActivities(ActivitiesInterface):
+    """Base activities for non-SQL metadata extraction workflows."""
+
+    _state: Dict[str, BaseMetadataExtractionActivitiesState] = {}
+
+    client_class: Type[BaseClient] = BaseClient
+    handler_class: Type[BaseHandler] = BaseHandler
+    transformer_class: Optional[Type[TransformerInterface]] = None
+
+    def __init__(
+        self,
+        client_class: Optional[Type[BaseClient]] = None,
+        handler_class: Optional[Type[BaseHandler]] = None,
+        transformer_class: Optional[Type[TransformerInterface]] = None,
+    ):
+        """Initialize the base metadata extraction activities.
+
+        Args:
+            client_class: Client class to use. Defaults to BaseClient.
+            handler_class: Handler class to use. Defaults to BaseHandler.
+            transformer_class: Transformer class to use. Users must provide their own transformer implementation.
+        """
+        if client_class:
+            self.client_class = client_class
+        if handler_class:
+            self.handler_class = handler_class
+        if transformer_class:
+            self.transformer_class = transformer_class
+
+        super().__init__()
+
+    async def _set_state(self, workflow_args: Dict[str, Any]):
+        """Set up the state for the current workflow.
+
+        Args:
+            workflow_args: Arguments for the workflow.
+        """
+        workflow_id = get_workflow_id()
+        if not self._state.get(workflow_id):
+            self._state[workflow_id] = BaseMetadataExtractionActivitiesState()
+
+        await super()._set_state(workflow_args)
+
+        state = self._state[workflow_id]
+
+        # Initialize client
+        client = self.client_class()
+        # Extract credentials from state store if credential_guid is available
+        if "credential_guid" in workflow_args:
+            logger.info(
+                f"Retrieving credentials for credential_guid: {workflow_args['credential_guid']}"
+            )
+            try:
+                credentials = await get_credentials(workflow_args["credential_guid"])
+                logger.info(
+                    f"Successfully retrieved credentials with keys: {list(credentials.keys())}"
+                )
+                # Load the client with credentials
+                await client.load(credentials=credentials)
+            except Exception as e:
+                logger.error(f"Failed to retrieve credentials: {e}")
+                raise
+
+        state.client = client
+
+        # Initialize handler
+        handler = self.handler_class(client=client)
+        state.handler = handler
+
+        # Initialize transformer if provided
+        if self.transformer_class:
+            transformer_params = {
+                "connector_name": APPLICATION_NAME,
+                "connector_type": APPLICATION_NAME,
+                "tenant_id": APP_TENANT_ID,
+            }
+            state.transformer = self.transformer_class(**transformer_params)

{atlan_application_sdk-0.1.1rc33 → atlan_application_sdk-0.1.1rc34}/application_sdk/application/__init__.py

@@ -2,8 +2,10 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Dict, List, Optional, Tuple, Type
 
 from application_sdk.activities import ActivitiesInterface
+from application_sdk.clients.base import BaseClient
 from application_sdk.clients.utils import get_workflow_client
 from application_sdk.events.models import EventRegistration
+from application_sdk.handlers.base import BaseHandler
 from application_sdk.observability.logger_adaptor import get_logger
 from application_sdk.server import ServerInterface
 from application_sdk.server.fastapi import APIServer, HttpWorkflowTrigger
@@ -28,6 +30,8 @@ class BaseApplication:
         name: str,
         server: Optional[ServerInterface] = None,
         application_manifest: Optional[dict] = None,
+        client_class: Optional[Type[BaseClient]] = None,
+        handler_class: Optional[Type[BaseHandler]] = None,
     ):
         """
         Initialize the application.
@@ -48,6 +52,9 @@ class BaseApplication:
         self.application_manifest: Dict[str, Any] = application_manifest
         self.bootstrap_event_registration()
 
+        self.client_class = client_class or BaseClient
+        self.handler_class = handler_class or BaseHandler
+
     def bootstrap_event_registration(self):
         self.event_subscriptions = {}
         if self.application_manifest is None:
@@ -168,6 +175,7 @@ class BaseApplication:
         self.server = APIServer(
             workflow_client=self.workflow_client,
             ui_enabled=ui_enabled,
+            handler=self.handler_class(client=self.client_class()),
         )
 
         if self.event_subscriptions:

atlan_application_sdk-0.1.1rc34/application_sdk/clients/base.py

@@ -0,0 +1,293 @@
+from typing import Any, Dict, Optional
+
+import httpx
+from httpx import Headers
+from httpx._types import (
+    AuthTypes,
+    HeaderTypes,
+    QueryParamTypes,
+    RequestData,
+    RequestFiles,
+)
+
+from application_sdk.clients import ClientInterface
+from application_sdk.observability.logger_adaptor import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseClient(ClientInterface):
+    """
+    Base client for non-SQL based applications.
+
+    This class provides a base implementation for clients that need to connect
+    to non-SQL data sources. It implements the ClientInterface and provides
+    basic functionality that can be extended by subclasses.
+
+    Attributes:
+        credentials (Dict[str, Any]): Client credentials for authentication.
+        http_headers (HeaderTypes): HTTP headers for all http requests made by this client. Supports dict, Headers object, or list of tuples.
+        http_retry_transporter (httpx.AsyncBaseTransport): HTTP transport for requests. Uses httpx default transport by default.
+            Can be overridden in load() method for custom retry behavior.
+
+    Extending the Client:
+        To customize retry behavior, subclasses can override the http_retry_transporter
+        in the load() method, similar to how http_headers is set:
+
+        Example:
+            >>> class MyClient(BaseClient):
+            ...     async def load(self, **kwargs):
+            ...         # Set up HTTP headers in load method for better modularity
+            ...         credentials = kwargs.get("credentials", {})
+            ...         # Can use dict, Headers object, or list of tuples
+            ...         self.http_headers = {
+            ...             "Authorization": f"Bearer {credentials.get('token')}",
+            ...             "User-Agent": "MyApp/1.0"
+            ...         }
+            ...         # Optionally override retry transport with custom configuration
+            ...         # For advanced retry logic with status code handling, use httpx-retries:
+            ...         # from httpx_retries import Retry, RetryTransport
+            ...         # retry = Retry(total=5, backoff_factor=20)
+            ...         # self.http_retry_transporter = RetryTransport(retry=retry) #replace transport with custom transport if needed
+
+        Advanced Retry Configuration:
+            For applications requiring advanced retry logic (e.g., status code-based retries,
+            rate limiting, custom backoff strategies), consider using httpx-retries library:
+
+            >>> class MyClient(BaseClient):
+            ...     async def load(self, **kwargs):
+            ...         # Set up headers
+            ...         self.http_headers = {"Authorization": f"Bearer {kwargs.get('token')}"}
+            ...
+            ...         # Install httpx-retries: pip install httpx-retries
+            ...         from httpx_retries import Retry, RetryTransport
+            ...
+            ...         # Configure retry for status codes and network errors
+            ...         retry = Retry(
+            ...             total=5,
+            ...             backoff_factor=10,
+            ...             status_forcelist=[429, 500, 502, 503, 504]
+            ...         )
+            ...         self.http_retry_transporter = RetryTransport(retry=retry)
+
+        Header Management:
+            The client supports a two-level header system using httpx Headers for merging headers:
+            - Client-level headers: Set in the load() method and used for all requests
+            - Method-level headers: Passed to individual methods and override/add to client headers
+
+            Example:
+                >>> client = MyClient()
+                >>> await client.load(credentials={"token": "initial_token"})
+                >>> # This request will use: {"Authorization": "Bearer initial_token", "User-Agent": "MyApp/1.0", "Content-Type": "application/json"}
+                >>> response = await client.execute_http_post_request(
+                ...     url="https://api.example.com/data",
+                ...     headers={"Content-Type": "application/json"}
+                ... )
+    """
+
+    def __init__(
+        self,
+        credentials: Dict[str, Any] = {},
+        http_headers: HeaderTypes = {},
+    ):
+        """
+        Initialize the base client.
+
+        Args:
+            credentials (Dict[str, Any], optional): Client credentials for authentication. Defaults to {}.
+            http_headers (HeaderTypes, optional): HTTP headers for all requests. Defaults to {}.
+        """
+        self.credentials = credentials
+        self.http_headers = http_headers
+
+        # Use httpx default transport (no retries on status codes)
+        self.http_retry_transport: httpx.AsyncBaseTransport = httpx.AsyncHTTPTransport()
+
+    async def load(self, **kwargs: Any) -> None:
+        """
+        Initialize the client with credentials and necessary attributes for the client to work.
+
+        This method should be implemented by subclasses to:
+        - Set up authentication headers in self.http_headers in case of http requestss
+        - Initialize any required client state
+        - Handle credential processing
+        - Optionally override self.http_retry_transport for custom retry behavior
+
+        For advanced retry logic (status code-based retries, rate limiting, custom backoff),
+        consider using httpx-retries library and overriding http_retry_transport:
+
+        Example:
+            >>> async def load(self, **kwargs):
+            ...     # Set up headers
+            ...     self.http_headers = {"Authorization": f"Bearer {kwargs.get('token')}"}
+            ...
+            ...     # For advanced retry logic, install httpx-retries: pip install httpx-retries
+            ...     from httpx_retries import Retry, RetryTransport
+            ...     retry = Retry(total=5, backoff_factor=10, status_forcelist=[429, 500, 502, 503, 504])
+            ...     self.http_retry_transport = RetryTransport(retry=retry)
+
+        Args:
+            **kwargs: Additional keyword arguments, typically including credentials.
+                May also include retry configuration parameters that can be used to
+                create a custom http_retry_transport.
+
+        Raises:
+            NotImplementedError: If the subclass does not implement this method.
+        """
+        raise NotImplementedError("load method is not implemented")
+
+    async def execute_http_get_request(
+        self,
+        url: str,
+        headers: Optional[HeaderTypes] = None,
+        params: Optional[QueryParamTypes] = None,
+        auth: Optional[AuthTypes] = None,
+        timeout: int = 10,
+    ) -> Optional[httpx.Response]:
+        """
+        Perform an HTTP GET request using the configured transport.
+
+        This method uses httpx default transport which only retries on network-level errors
+        (connection failures, timeouts). For status code-based retries (429, 500, etc.),
+        consider overriding http_retry_transport in the load() method using httpx-retries library.
+
+        Args:
+            url (str): The URL to make the GET request to
+            headers (Optional[HeaderTypes]): HTTP headers to include in the request. Supports dict, Headers object, or list of tuples. These headers will override/add to any client-level headers set in the load() method.
+            params (Optional[QueryParamTypes]): Query parameters to include in the request. Supports dict, list of tuples, or string.
+            auth (Optional[AuthTypes]): Authentication to use for the request. Supports BasicAuth, DigestAuth, custom auth classes, or tuples for basic auth.
+            timeout (int): Request timeout in seconds. Defaults to 10.
+
+        Returns:
+            Optional[httpx.Response]: The HTTP response if successful, None if failed
+
+        Example:
+            >>> # Using Basic Authentication
+            >>> from httpx import BasicAuth
+            >>> response = await client.execute_http_get_request(
+            ...     url="https://api.example.com/data",
+            ...     auth=BasicAuth("username", "password"),
+            ...     params={"limit": 100}
+            ... )
+            >>>
+            >>> # Using tuple for basic auth (username, password)
+            >>> response = await client.execute_http_get_request(
+            ...     url="https://api.example.com/data",
+            ...     auth=("username", "password"),
+            ...     params={"limit": 100}
+            ... )
+            >>>
+            >>> # Using custom headers for Bearer token
+            >>> response = await client.execute_http_get_request(
+            ...     url="https://api.example.com/data",
+            ...     headers={"Authorization": "Bearer token"},
+            ...     params={"limit": 100}
+            ... )
+        """
+        async with httpx.AsyncClient(
+            timeout=timeout, transport=self.http_retry_transport
+        ) as client:
+            merged_headers = Headers(self.http_headers)
+            if headers:
+                merged_headers.update(headers)
+
+            try:
+                response = await client.get(
+                    url,
+                    headers=merged_headers,
+                    params=params,
+                    auth=auth if auth is not None else httpx.USE_CLIENT_DEFAULT,
+                )
+                return response
+            except httpx.HTTPStatusError as e:
+                logger.error(f"HTTP error for {url}: {e.response.status_code}")
+                return None
+            except Exception as e:
+                logger.error(f"Request failed for {url}: {e}")
+                return None
+
+    async def execute_http_post_request(
+        self,
+        url: str,
+        data: Optional[RequestData] = None,
+        json_data: Optional[Any] = None,
+        content: Optional[bytes] = None,
+        files: Optional[RequestFiles] = None,
+        headers: Optional[HeaderTypes] = None,
+        params: Optional[QueryParamTypes] = None,
+        cookies: Optional[Dict[str, str]] = None,
+        auth: Optional[AuthTypes] = None,
+        follow_redirects: bool = True,
+        verify: bool = True,
+        timeout: int = 30,
+    ) -> Optional[httpx.Response]:
+        """
+        Perform an HTTP POST request using the configured transport.
+
+        This method uses httpx default transport which only retries on network-level errors
+        (connection failures, timeouts). For status code-based retries (429, 500, etc.),
+        consider overriding http_retry_transport in the load() method using httpx-retries library.
+
+        Args:
+            url (str): The URL to make the POST request to
+            data (Optional[RequestData]): Form data to send in the request body. Supports dict, list of tuples, or other httpx-compatible formats.
+            json_data (Optional[Any]): JSON data to send in the request body. Any JSON-serializable object.
+            content (Optional[bytes]): Raw binary content to send in the request body
+            files (Optional[RequestFiles]): Files to upload in the request body. Supports various file formats and tuples.
+            headers (Optional[HeaderTypes]): HTTP headers to include in the request. Supports dict, Headers object, or list of tuples. These headers will override/add to any client-level headers set in the load() method.
+            params (Optional[QueryParamTypes]): Query parameters to include in the request. Supports dict, list of tuples, or string.
+            cookies (Optional[Dict[str, str]]): Cookies to include in the request
+            auth (Optional[AuthTypes]): Authentication to use for the request. Supports BasicAuth, DigestAuth, custom auth classes, or tuples for basic auth.
+            follow_redirects (bool): Whether to follow HTTP redirects. Defaults to True.
+            verify (bool): Whether to verify SSL certificates. Defaults to True.
+            timeout (int): Request timeout in seconds. Defaults to 30.
+
+        Returns:
+            Optional[httpx.Response]: The HTTP response if successful, None if failed
+
+        Example:
+            >>> # Basic JSON POST request with authentication
+            >>> from httpx import BasicAuth
+            >>> response = await client.execute_http_post_request(
+            ...     url="https://api.example.com/data",
+            ...     json_data={"name": "test", "value": 123},
+            ...     headers={"Content-Type": "application/json"},
+            ...     auth=BasicAuth("username", "password")
+            ... )
+            >>>
+            >>> # File upload with basic auth tuple
+            >>> with open("file.txt", "rb") as f:
+            ...     response = await client.execute_http_post_request(
+            ...         url="https://api.example.com/upload",
+            ...         data={"description": "My file"},
+            ...         files={"file": ("file.txt", f.read(), "text/plain")},
+            ...         auth=("username", "password")
+            ... )
+        """
+        async with httpx.AsyncClient(
+            timeout=timeout, transport=self.http_retry_transport, verify=verify
+        ) as client:
+            merged_headers = Headers(self.http_headers)
+            if headers:
+                merged_headers.update(headers)
+
+            try:
+                response = await client.post(
+                    url,
+                    data=data,
+                    json=json_data,
+                    content=content,
+                    files=files,
+                    headers=merged_headers,
+                    params=params,
+                    cookies=cookies,
+                    auth=auth if auth is not None else httpx.USE_CLIENT_DEFAULT,
+                    follow_redirects=follow_redirects,
+                )
+                return response
+            except httpx.HTTPStatusError as e:
+                logger.error(f"HTTP error for {url}: {e.response.status_code}")
+                return None
+            except Exception as e:
+                logger.error(f"Request failed for {url}: {e}")
+                return None

atlan_application_sdk-0.1.1rc34/application_sdk/handlers/base.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, Optional
+
+from application_sdk.clients.base import BaseClient
+from application_sdk.handlers import HandlerInterface
+from application_sdk.observability.logger_adaptor import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseHandler(HandlerInterface):
+    """
+    Base handler for non-SQL based applications.
+
+    This class provides a base implementation for handlers that need to interact with non-SQL data sources. It implements the HandlerInterface and provides basic functionality that can be extended by subclasses.
+
+    Attributes:
+        client (BaseClient): The client instance for connecting to the target system.
+    """
+
+    def __init__(self, client: Optional[BaseClient] = None):
+        """
+        Initialize the base handler.
+
+        Args:
+            client (BaseClient, optional): The client instance to use for connections. Defaults to BaseClient().
+        """
+        self.client = client or BaseClient()
+
+    async def load(self, credentials: Dict[str, Any]) -> None:
+        """
+        Load and initialize the handler.
+
+        This method initializes the handler and loads the client with the provided credentials.
+
+        Args:
+            credentials (Dict[str, Any]): Credentials for the client.
+        """
+        logger.info("Loading base handler")
+
+        # Load the client with credentials
+        await self.client.load(credentials=credentials)
+
+        logger.info("Base handler loaded successfully")
+
+    # The following methods are inherited from HandlerInterface and should be implemented
+    # by subclasses to handle calls from their respective FastAPI endpoints:
+    #
+    # - test_auth(**kwargs) -> bool: Called by /workflow/v1/auth endpoint
+    # - preflight_check(**kwargs) -> Any: Called by /workflow/v1/check endpoint
+    # - fetch_metadata(**kwargs) -> Any: Called by /workflow/v1/metadata endpoint

{atlan_application_sdk-0.1.1rc33 → atlan_application_sdk-0.1.1rc34}/application_sdk/server/fastapi/models.py

@@ -34,7 +34,7 @@ class FetchMetadataRequest(RootModel[Dict[str, Any]]):
 
 class FetchMetadataResponse(BaseModel):
     success: bool
-    data: List[Dict[str, str]]
+    data: Any
 
 
 class PreflightCheckRequest(BaseModel):

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

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

{atlan_application_sdk-0.1.1rc33 → atlan_application_sdk-0.1.1rc34}/docs/docs/concepts/activities.md

@@ -34,6 +34,11 @@ The SDK provides pre-built base activity classes for common tasks, primarily foc
     *   **Activities:** Includes `preflight_check`, `fetch_queries`, `transform_data`.
     *   **Extensibility:** Defines `fetch_queries_sql` as a class attribute for customization.
 
+*   **`BaseMetadataExtractionActivities`** (in `application_sdk.activities.metadata_extraction.base`):
+    *   **Purpose:** Provides a standard set of activities for extracting metadata from non-SQL data sources (e.g., REST APIs, file systems).
+    *   **Activities:** Includes `preflight_check`, `fetch_metadata`, and `transform_data` from the parent class `ActivitiesInterface`. Adds credential handling in the set_state method along with the `handler` instances.
+    *   **Extensibility:** Designed to be subclassed for specific non-SQL data sources with custom client, handler, and transformer implementations.
+
 ## Usage Patterns
 
 ### 1. Reusing Base Activities (No Customization)