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

application_sdk/activities/__init__.py

@@ -29,7 +29,6 @@ from application_sdk.activities.common.utils import (
 from application_sdk.common.error_codes import OrchestratorError
 from application_sdk.constants import TEMPORARY_PATH
 from application_sdk.handlers import HandlerInterface
-from application_sdk.inputs.statestore import StateStoreInput, StateType
 from application_sdk.observability.logger_adaptor import get_logger
 
 logger = get_logger(__name__)
@@ -190,7 +189,9 @@ class ActivitiesInterface(ABC, Generic[ActivitiesStateType]):
 
         try:
             # This already handles the Dapr call internally
-            workflow_args = StateStoreInput.get_state(workflow_id, StateType.WORKFLOWS)
+            from application_sdk.services.statestore import StateStore, StateType
+
+            workflow_args = await StateStore.get_state(workflow_id, StateType.WORKFLOWS)
             workflow_args["output_prefix"] = workflow_args.get(
                 "output_prefix", TEMPORARY_PATH
             )

application_sdk/activities/common/utils.py

@@ -5,13 +5,18 @@ including workflow ID retrieval, automatic heartbeating, and periodic heartbeat
 """
 
 import asyncio
+import os
 from datetime import timedelta
 from functools import wraps
 from typing import Any, Awaitable, Callable, Optional, TypeVar, cast
 
 from temporalio import activity
 
-from application_sdk.constants import APPLICATION_NAME, WORKFLOW_OUTPUT_PATH_TEMPLATE
+from application_sdk.constants import (
+    APPLICATION_NAME,
+    TEMPORARY_PATH,
+    WORKFLOW_OUTPUT_PATH_TEMPLATE,
+)
 from application_sdk.observability.logger_adaptor import get_logger
 
 logger = get_logger(__name__)
@@ -72,6 +77,21 @@ def build_output_path() -> str:
     )
 
 
+def get_object_store_prefix(path: str) -> str:
+    """Get the object store prefix for the path.
+    Args:
+        path: The path to the output directory.
+
+    Returns:
+        The object store prefix for the path.
+
+    Example:
+        >>> get_object_store_prefix("./local/tmp/artifacts/apps/appName/workflows/wf-123/run-456")
+        "artifacts/apps/appName/workflows/wf-123/run-456"
+    """
+    return os.path.relpath(path, TEMPORARY_PATH)
+
+
 def auto_heartbeater(fn: F) -> F:
     """Decorator that automatically sends heartbeats during activity execution.
 

application_sdk/activities/metadata_extraction/base.py

@@ -0,0 +1,104 @@
+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.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.services.secretstore import SecretStore
+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 SecretStore.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)

application_sdk/activities/metadata_extraction/sql.py

@@ -5,25 +5,24 @@ from temporalio import activity
 
 from application_sdk.activities import ActivitiesInterface, ActivitiesState
 from application_sdk.activities.common.models import ActivityStatistics
-from application_sdk.activities.common.utils import auto_heartbeater, get_workflow_id
+from application_sdk.activities.common.utils import (
+    auto_heartbeater,
+    get_object_store_prefix,
+    get_workflow_id,
+)
 from application_sdk.clients.sql import BaseSQLClient
-from application_sdk.common.credential_utils import get_credentials
 from application_sdk.common.dataframe_utils import is_empty_dataframe
 from application_sdk.common.error_codes import ActivityError
 from application_sdk.common.utils import prepare_query, read_sql_files
-from application_sdk.constants import (
-    APP_TENANT_ID,
-    APPLICATION_NAME,
-    SQL_QUERIES_PATH,
-    TEMPORARY_PATH,
-)
+from application_sdk.constants import APP_TENANT_ID, APPLICATION_NAME, SQL_QUERIES_PATH
 from application_sdk.handlers.sql import BaseSQLHandler
 from application_sdk.inputs.parquet import ParquetInput
 from application_sdk.inputs.sql_query import SQLQueryInput
 from application_sdk.observability.logger_adaptor import get_logger
-from application_sdk.outputs.atlan_storage import AtlanStorageOutput
 from application_sdk.outputs.json import JsonOutput
 from application_sdk.outputs.parquet import ParquetOutput
+from application_sdk.services.atlan_storage import AtlanStorage
+from application_sdk.services.secretstore import SecretStore
 from application_sdk.transformers import TransformerInterface
 from application_sdk.transformers.query import QueryBasedTransformer
 
@@ -144,7 +143,9 @@ class BaseSQLMetadataExtractionActivities(ActivitiesInterface):
         self._state[workflow_id].handler = handler
 
         if "credential_guid" in workflow_args:
-            credentials = await get_credentials(workflow_args["credential_guid"])
+            credentials = await SecretStore.get_credentials(
+                workflow_args["credential_guid"]
+            )
             await sql_client.load(credentials)
 
         self._state[workflow_id].sql_client = sql_client
@@ -536,11 +537,11 @@ class BaseSQLMetadataExtractionActivities(ActivitiesInterface):
 
         # Upload data from object store to Atlan storage
         # Use workflow_id/workflow_run_id as the prefix to migrate specific data
-        migration_prefix = os.path.relpath(workflow_args["output_path"], TEMPORARY_PATH)
+        migration_prefix = get_object_store_prefix(workflow_args["output_path"])
         logger.info(
             f"Starting migration from object store with prefix: {migration_prefix}"
         )
-        upload_stats = await AtlanStorageOutput.migrate_from_objectstore_to_atlan(
+        upload_stats = await AtlanStorage.migrate_from_objectstore_to_atlan(
             prefix=migration_prefix
         )
 

application_sdk/activities/query_extraction/sql.py

@@ -7,17 +7,20 @@ from pydantic import BaseModel, Field
 from temporalio import activity
 
 from application_sdk.activities import ActivitiesInterface, ActivitiesState
-from application_sdk.activities.common.utils import auto_heartbeater, get_workflow_id
+from application_sdk.activities.common.utils import (
+    auto_heartbeater,
+    get_object_store_prefix,
+    get_workflow_id,
+)
 from application_sdk.clients.sql import BaseSQLClient
-from application_sdk.common.credential_utils import get_credentials
 from application_sdk.constants import UPSTREAM_OBJECT_STORE_NAME
 from application_sdk.handlers import HandlerInterface
 from application_sdk.handlers.sql import BaseSQLHandler
-from application_sdk.inputs.objectstore import ObjectStoreInput
 from application_sdk.inputs.sql_query import SQLQueryInput
 from application_sdk.observability.logger_adaptor import get_logger
-from application_sdk.outputs.objectstore import ObjectStoreOutput
 from application_sdk.outputs.parquet import ParquetOutput
+from application_sdk.services.objectstore import ObjectStore
+from application_sdk.services.secretstore import SecretStore
 from application_sdk.transformers import TransformerInterface
 from application_sdk.transformers.atlas import AtlasTransformer
 
@@ -129,7 +132,9 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
         workflow_id = get_workflow_id()
         sql_client = self.sql_client_class()
         if "credential_guid" in workflow_args:
-            credentials = await get_credentials(workflow_args["credential_guid"])
+            credentials = await SecretStore.get_credentials(
+                workflow_args["credential_guid"]
+            )
             await sql_client.load(credentials)
 
         handler = self.handler_class(sql_client)
@@ -412,14 +417,14 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
             f.write(last_marker)
 
         logger.info(f"Last marker: {last_marker}")
-        await ObjectStoreOutput.push_file_to_object_store(
-            workflow_args["output_prefix"],
-            marker_file_path,
-            object_store_name=UPSTREAM_OBJECT_STORE_NAME,
+        await ObjectStore.upload_file(
+            source=marker_file_path,
+            destination=get_object_store_prefix(marker_file_path),
+            store_name=UPSTREAM_OBJECT_STORE_NAME,
         )
         logger.info(f"Marker file written to {marker_file_path}")
 
-    def read_marker(self, workflow_args: Dict[str, Any]) -> Optional[int]:
+    async def read_marker(self, workflow_args: Dict[str, Any]) -> Optional[int]:
         """Read the marker from the output path.
 
         This method reads the current marker value from a marker file to determine the
@@ -442,15 +447,12 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
             marker_file_path = os.path.join(output_path, "markerfile")
             logger.info(f"Downloading marker file from {marker_file_path}")
 
-            os.makedirs(workflow_args["output_prefix"], exist_ok=True)
-
-            ObjectStoreInput.download_file_from_object_store(
-                workflow_args["output_prefix"],
-                marker_file_path,
-                object_store_name=UPSTREAM_OBJECT_STORE_NAME,
+            await ObjectStore.download_file(
+                source=get_object_store_prefix(marker_file_path),
+                destination=marker_file_path,
+                store_name=UPSTREAM_OBJECT_STORE_NAME,
             )
 
-            logger.info(f"Output prefix: {workflow_args['output_prefix']}")
             logger.info(f"Marker file downloaded to {marker_file_path}")
             if not os.path.exists(marker_file_path):
                 logger.warning(f"Marker file does not exist at {marker_file_path}")
@@ -487,7 +489,7 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
 
         miner_args = MinerArgs(**workflow_args.get("miner_args", {}))
 
-        current_marker = self.read_marker(workflow_args)
+        current_marker = await self.read_marker(workflow_args)
         if current_marker:
             miner_args.current_marker = current_marker
 
@@ -522,8 +524,10 @@ class SQLQueryExtractionActivities(ActivitiesInterface):
         with open(metadata_file_path, "w") as f:
             f.write(json.dumps(parallel_markers))
 
-        await ObjectStoreOutput.push_file_to_object_store(
-            workflow_args["output_prefix"], metadata_file_path
+        await ObjectStore.upload_file(
+            source=metadata_file_path,
+            destination=get_object_store_prefix(metadata_file_path),
+            store_name=UPSTREAM_OBJECT_STORE_NAME,
         )
 
         try:

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:

application_sdk/clients/atlan_auth.py

@@ -13,8 +13,8 @@ from application_sdk.constants import (
     WORKFLOW_AUTH_ENABLED,
     WORKFLOW_AUTH_URL_KEY,
 )
-from application_sdk.inputs.secretstore import SecretStoreInput
 from application_sdk.observability.logger_adaptor import get_logger
+from application_sdk.services.secretstore import SecretStore
 
 logger = get_logger(__name__)
 
@@ -39,7 +39,7 @@ class AtlanAuthClient:
         (environment variables, AWS Secrets Manager, Azure Key Vault, etc.)
         """
         self.application_name = APPLICATION_NAME
-        self.auth_config: Dict[str, Any] = SecretStoreInput.get_deployment_secret()
+        self.auth_config: Dict[str, Any] = SecretStore.get_deployment_secret()
         self.auth_enabled: bool = WORKFLOW_AUTH_ENABLED
         self.auth_url: Optional[str] = None
 

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