airia 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

airia/client/async_client.py

@@ -11,6 +11,7 @@ from ..constants import (
 from ._request_handler import AsyncRequestHandler
 from .base_client import AiriaBaseClient
 from .conversations import AsyncConversations
+from .deployments import AsyncDeployments
 from .pipeline_execution import AsyncPipelineExecution
 from .pipelines_config import AsyncPipelinesConfig
 from .project import AsyncProject
@@ -62,6 +63,7 @@ class AiriaAsyncClient(AiriaBaseClient):
         self.project = AsyncProject(self._request_handler)
         self.conversations = AsyncConversations(self._request_handler)
         self.store = AsyncStore(self._request_handler)
+        self.deployments = AsyncDeployments(self._request_handler)
 
     @classmethod
     def with_openai_gateway(

airia/client/deployments/__init__.py

@@ -0,0 +1,11 @@
+"""
+Deployment management client modules.
+
+This module provides synchronous and asynchronous client interfaces for
+deployment-related operations in the Airia platform.
+"""
+
+from .async_deployments import AsyncDeployments
+from .sync_deployments import Deployments
+
+__all__ = ["AsyncDeployments", "Deployments"]

airia/client/deployments/async_deployments.py

@@ -0,0 +1,112 @@
+from typing import List, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.deployments import GetDeploymentResponse, GetDeploymentsResponse
+from .._request_handler import AsyncRequestHandler
+from .base_deployments import BaseDeployments
+
+
+class AsyncDeployments(BaseDeployments):
+    def __init__(self, request_handler: AsyncRequestHandler):
+        super().__init__(request_handler)
+
+    async def get_deployments(
+        self,
+        tags: Optional[List[str]] = None,
+        is_recommended: Optional[bool] = None,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V2.value,
+    ) -> GetDeploymentsResponse:
+        """
+        Retrieve a paged list of deployments asynchronously.
+
+        This method fetches deployments from the Airia platform with optional filtering
+        by tags and recommendation status. The response includes detailed information
+        about each deployment including associated pipelines, data sources, and user prompts.
+
+        Args:
+            tags: Optional list of tags to filter deployments by
+            is_recommended: Optional filter by recommended status
+            project_id: Optional filter by project id
+            correlation_id: Optional correlation ID for request tracing
+            api_version: API version to use (defaults to V2)
+
+        Returns:
+            GetDeploymentsResponse: Paged response containing deployment items and total count
+
+        Raises:
+            AiriaAPIError: If the API request fails
+            ValueError: If an invalid API version is provided
+
+        Example:
+            ```python
+            client = AiriaAsyncClient(api_key="your-api-key")
+            deployments = await client.deployments.get_deployments(
+                tags=["production", "nlp"],
+                is_recommended=True
+            )
+            print(f"Found {deployments.total_count} deployments")
+            for deployment in deployments.items:
+                print(f"- {deployment.deployment_name}")
+            ```
+        """
+        request_data = self._pre_get_deployments(
+            tags=tags,
+            is_recommended=is_recommended,
+            correlation_id=correlation_id,
+            api_version=api_version,
+        )
+
+        response = await self._request_handler.make_request("GET", request_data)
+
+        if project_id is not None:
+            response["items"] = [
+                item for item in response["items"] if item["projectId"] == project_id
+            ]
+
+        return GetDeploymentsResponse(**response)
+
+    async def get_deployment(
+        self,
+        deployment_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ) -> GetDeploymentResponse:
+        """
+        Retrieve a single deployment by ID asynchronously.
+
+        This method fetches a specific deployment from the Airia platform using its
+        unique identifier. The response includes complete information about the deployment
+        including associated pipelines, data sources, user prompts, and configuration settings.
+
+        Args:
+            deployment_id: The unique identifier of the deployment to retrieve
+            correlation_id: Optional correlation ID for request tracing
+            api_version: API version to use (defaults to V1)
+
+        Returns:
+            GetDeploymentResponse: Complete deployment information
+
+        Raises:
+            AiriaAPIError: If the API request fails or deployment is not found
+            ValueError: If an invalid API version is provided
+
+        Example:
+            ```python
+            client = AiriaAsyncClient(api_key="your-api-key")
+            deployment = await client.deployments.get_deployment("deployment-id-123")
+            print(f"Deployment: {deployment.deployment_name}")
+            print(f"Description: {deployment.description}")
+            print(f"Project: {deployment.project_id}")
+            ```
+        """
+        request_data = self._pre_get_deployment(
+            deployment_id=deployment_id,
+            correlation_id=correlation_id,
+            api_version=api_version,
+        )
+
+        response = await self._request_handler.make_request("GET", request_data)
+
+        return GetDeploymentResponse(**response)

airia/client/deployments/base_deployments.py

@@ -0,0 +1,95 @@
+from typing import List, Optional, Union
+from urllib.parse import urljoin
+
+from ...types._api_version import ApiVersion
+from .._request_handler import AsyncRequestHandler, RequestHandler
+
+
+class BaseDeployments:
+    def __init__(self, request_handler: Union[RequestHandler, AsyncRequestHandler]):
+        self._request_handler = request_handler
+
+    def _pre_get_deployments(
+        self,
+        tags: Optional[List[str]] = None,
+        is_recommended: Optional[bool] = None,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V2.value,
+    ):
+        """
+        Prepare request data for retrieving deployments.
+
+        This internal method constructs the URL and query parameters for deployment
+        retrieval requests, including optional filtering by tags and recommendation status.
+
+        Args:
+            tags: Optional list of tags to filter deployments by
+            is_recommended: Optional filter by recommended status
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the deployments endpoint
+
+        Raises:
+            ValueError: If an invalid API version is provided
+        """
+        if api_version not in ApiVersion.as_list():
+            raise ValueError(
+                f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
+            )
+
+        url = urljoin(
+            self._request_handler.base_url, f"{api_version}/Deployments/paged"
+        )
+
+        # Build query parameters
+        params = {}
+        if tags is not None:
+            params["tags"] = tags
+        if is_recommended is not None:
+            params["isRecommended"] = is_recommended
+
+        request_data = self._request_handler.prepare_request(
+            url=url, params=params, correlation_id=correlation_id
+        )
+
+        return request_data
+
+    def _pre_get_deployment(
+        self,
+        deployment_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for retrieving a single deployment.
+
+        This internal method constructs the URL for deployment retrieval
+        by ID using the specified API version.
+
+        Args:
+            deployment_id: The unique identifier of the deployment to retrieve
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the deployment endpoint
+
+        Raises:
+            ValueError: If an invalid API version is provided
+        """
+        if api_version not in ApiVersion.as_list():
+            raise ValueError(
+                f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
+            )
+
+        url = urljoin(
+            self._request_handler.base_url, f"{api_version}/Deployments/{deployment_id}"
+        )
+
+        request_data = self._request_handler.prepare_request(
+            url=url, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/deployments/sync_deployments.py

@@ -0,0 +1,112 @@
+from typing import List, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.deployments import GetDeploymentResponse, GetDeploymentsResponse
+from .._request_handler import RequestHandler
+from .base_deployments import BaseDeployments
+
+
+class Deployments(BaseDeployments):
+    def __init__(self, request_handler: RequestHandler):
+        super().__init__(request_handler)
+
+    def get_deployments(
+        self,
+        tags: Optional[List[str]] = None,
+        is_recommended: Optional[bool] = None,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V2.value,
+    ) -> GetDeploymentsResponse:
+        """
+        Retrieve a paged list of deployments.
+
+        This method fetches deployments from the Airia platform with optional filtering
+        by tags and recommendation status. The response includes detailed information
+        about each deployment including associated pipelines, data sources, and user prompts.
+
+        Args:
+            tags: Optional list of tags to filter deployments by
+            is_recommended: Optional filter by recommended status
+            project_id: Optional filter by project id
+            correlation_id: Optional correlation ID for request tracing
+            api_version: API version to use (defaults to V2)
+
+        Returns:
+            GetDeploymentsResponse: Paged response containing deployment items and total count
+
+        Raises:
+            AiriaAPIError: If the API request fails
+            ValueError: If an invalid API version is provided
+
+        Example:
+            ```python
+            client = AiriaClient(api_key="your-api-key")
+            deployments = client.deployments.get_deployments(
+                tags=["production", "nlp"],
+                is_recommended=True
+            )
+            print(f"Found {deployments.total_count} deployments")
+            for deployment in deployments.items:
+                print(f"- {deployment.deployment_name}")
+            ```
+        """
+        request_data = self._pre_get_deployments(
+            tags=tags,
+            is_recommended=is_recommended,
+            correlation_id=correlation_id,
+            api_version=api_version,
+        )
+
+        response = self._request_handler.make_request("GET", request_data)
+
+        if project_id is not None:
+            response["items"] = [
+                item for item in response["items"] if item["projectId"] == project_id
+            ]
+
+        return GetDeploymentsResponse(**response)
+
+    def get_deployment(
+        self,
+        deployment_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ) -> GetDeploymentResponse:
+        """
+        Retrieve a single deployment by ID.
+
+        This method fetches a specific deployment from the Airia platform using its
+        unique identifier. The response includes complete information about the deployment
+        including associated pipelines, data sources, user prompts, and configuration settings.
+
+        Args:
+            deployment_id: The unique identifier of the deployment to retrieve
+            correlation_id: Optional correlation ID for request tracing
+            api_version: API version to use (defaults to V1)
+
+        Returns:
+            GetDeploymentResponse: Complete deployment information
+
+        Raises:
+            AiriaAPIError: If the API request fails or deployment is not found
+            ValueError: If an invalid API version is provided
+
+        Example:
+            ```python
+            client = AiriaClient(api_key="your-api-key")
+            deployment = client.deployments.get_deployment("deployment-id-123")
+            print(f"Deployment: {deployment.deployment_name}")
+            print(f"Description: {deployment.description}")
+            print(f"Project: {deployment.project_id}")
+            ```
+        """
+        request_data = self._pre_get_deployment(
+            deployment_id=deployment_id,
+            correlation_id=correlation_id,
+            api_version=api_version,
+        )
+
+        response = self._request_handler.make_request("GET", request_data)
+
+        return GetDeploymentResponse(**response)

airia/client/pipelines_config/async_pipelines_config.py

@@ -1,7 +1,10 @@
-from typing import List, Optional
+from typing import Optional
 
 from ...types._api_version import ApiVersion
-from ...types.api.pipelines_config import GetPipelineConfigResponse
+from ...types.api.pipelines_config import (
+    PipelineConfigResponse,
+    ExportPipelineDefinitionResponse,
+)
 from .._request_handler import AsyncRequestHandler
 from .base_pipelines_config import BasePipelinesConfig
 
@@ -10,29 +13,28 @@ class AsyncPipelinesConfig(BasePipelinesConfig):
     def __init__(self, request_handler: AsyncRequestHandler):
         super().__init__(request_handler)
 
-    async def get_active_pipelines_ids(
-        self, project_id: Optional[str] = None, correlation_id: Optional[str] = None
-    ) -> List[str]:
+    async def get_pipeline_config(
+        self, pipeline_id: str, correlation_id: Optional[str] = None
+    ) -> PipelineConfigResponse:
         """
-        Retrieve a list of active pipeline IDs.
+        Retrieve configuration details for a specific pipeline.
 
-        This method fetches the IDs of all active pipelines, optionally filtered by project.
-        Active pipelines are those that are currently deployed and available for execution.
+        This method fetches comprehensive information about a pipeline including its
+        deployment details, execution statistics, version information, and metadata.
 
         Args:
-            project_id (str, optional): The unique identifier of the project to filter
-                pipelines by. If not provided, returns active pipelines from all projects
-                accessible to the authenticated user.
+            pipeline_id (str): The unique identifier of the pipeline to retrieve
+                configuration for.
             correlation_id (str, optional): A unique identifier for request tracing
                 and logging. If not provided, one will be automatically generated.
 
         Returns:
-            List[str]: A list of pipeline IDs that are currently active. Returns an
-                empty list if no active pipelines are found.
+            PipelineConfigResponse: A response object containing the pipeline
+                configuration.
 
         Raises:
             AiriaAPIError: If the API request fails, including cases where:
-                - The project_id doesn't exist (404)
+                - The pipeline_id doesn't exist (404)
                 - Authentication fails (401)
                 - Access is forbidden (403)
                 - Server errors (5xx)
@@ -43,53 +45,47 @@ class AsyncPipelinesConfig(BasePipelinesConfig):
 
             client = AiriaAsyncClient(api_key="your_api_key")
 
-            # Get all active pipeline IDs
-            pipeline_ids = await client.pipelines_config.get_active_pipelines_ids()
-            print(f"Found {len(pipeline_ids)} active pipelines")
-
-            # Get active pipeline IDs for a specific project
-            project_pipelines = await client.pipelines_config.get_active_pipelines_ids(
-                project_id="your_project_id"
+            # Get pipeline configuration
+            config = await client.pipelines_config.get_pipeline_config(
+                pipeline_id="your_pipeline_id"
             )
-            print(f"Project has {len(project_pipelines)} active pipelines")
+
+            print(f"Pipeline: {config.agent.name}")
+            print(f"Description: {config.agent.agent_description}")
             ```
 
         Note:
-            Only pipelines with active versions are returned. Inactive or archived
-            pipelines are not included in the results.
+            This method only retrieves configuration information and does not
+            execute the pipeline. Use execute_pipeline() to run the pipeline.
         """
-        request_data = self._pre_get_active_pipelines_ids(
-            project_id=project_id,
+        request_data = self._pre_get_pipeline_config(
+            pipeline_id=pipeline_id,
             correlation_id=correlation_id,
             api_version=ApiVersion.V1.value,
         )
         resp = await self._request_handler.make_request("GET", request_data)
 
-        if "items" not in resp or len(resp["items"]) == 0:
-            return []
-
-        pipeline_ids = [r["activeVersion"]["pipelineId"] for r in resp["items"]]
+        return PipelineConfigResponse(**resp)
 
-        return pipeline_ids
-
-    async def get_pipeline_config(
+    async def export_pipeline_definition(
         self, pipeline_id: str, correlation_id: Optional[str] = None
-    ) -> GetPipelineConfigResponse:
+    ) -> ExportPipelineDefinitionResponse:
         """
-        Retrieve configuration details for a specific pipeline.
+        Export the complete definition of a pipeline including all its components.
 
-        This method fetches comprehensive information about a pipeline including its
-        deployment details, execution statistics, version information, and metadata.
+        This method retrieves a comprehensive export of a pipeline definition including
+        metadata, agent configuration, data sources, prompts, tools, models, memories,
+        Python code blocks, routers, and deployment information.
 
         Args:
-            pipeline_id (str): The unique identifier of the pipeline to retrieve
-                configuration for.
+            pipeline_id (str): The unique identifier of the pipeline to export
+                definition for.
             correlation_id (str, optional): A unique identifier for request tracing
                 and logging. If not provided, one will be automatically generated.
 
         Returns:
-            GetPipelineConfigResponse: A response object containing the pipeline
-                configuration.
+            ExportPipelineDefinitionResponse: A response object containing the complete
+                pipeline definition export.
 
         Raises:
             AiriaAPIError: If the API request fails, including cases where:
@@ -104,24 +100,26 @@ class AsyncPipelinesConfig(BasePipelinesConfig):
 
             client = AiriaAsyncClient(api_key="your_api_key")
 
-            # Get pipeline configuration
-            config = await client.pipelines_config.get_pipeline_config(
+            # Export pipeline definition
+            export = await client.pipelines_config.export_pipeline_definition(
                 pipeline_id="your_pipeline_id"
             )
 
-            print(f"Pipeline: {config.agent.name}")
-            print(f"Description: {config.agent.agent_description}")
+            print(f"Pipeline: {export.agent.name}")
+            print(f"Export version: {export.metadata.export_version}")
+            print(f"Data sources: {len(export.data_sources or [])}")
+            print(f"Tools: {len(export.tools or [])}")
             ```
 
         Note:
-            This method only retrieves configuration information and does not
-            execute the pipeline. Use execute_pipeline() to run the pipeline.
+            This method exports the complete pipeline definition which can be used
+            for backup, version control, or importing into other environments.
         """
-        request_data = self._pre_get_pipeline_config(
+        request_data = self._pre_export_pipeline_definition(
             pipeline_id=pipeline_id,
             correlation_id=correlation_id,
             api_version=ApiVersion.V1.value,
         )
         resp = await self._request_handler.make_request("GET", request_data)
 
-        return GetPipelineConfigResponse(**resp)
+        return ExportPipelineDefinitionResponse(**resp)

airia/client/pipelines_config/base_pipelines_config.py

@@ -9,17 +9,17 @@ class BasePipelinesConfig:
     def __init__(self, request_handler: Union[RequestHandler, AsyncRequestHandler]):
         self._request_handler = request_handler
 
-    def _pre_get_active_pipelines_ids(
+    def _pre_get_pipeline_config(
         self,
-        project_id: Optional[str] = None,
+        pipeline_id: str,
         correlation_id: Optional[str] = None,
         api_version: str = ApiVersion.V1.value,
     ):
         """
-        Prepare request data for getting active pipelines IDs.
+        Prepare request data for getting pipeline configuration endpoint.
 
         Args:
-            project_id: ID of the project to get configuration for
+            pipeline_id: ID of the pipeline to get configuration for
             correlation_id: Optional correlation ID for tracing
             api_version: API version to use for the request
 
@@ -33,30 +33,32 @@ class BasePipelinesConfig:
             raise ValueError(
                 f"Invalid API version: {api_version}. Valid versions are: {', '.join(ApiVersion.as_list())}"
             )
-        url = urljoin(self._request_handler.base_url, f"{api_version}/PipelinesConfig")
-        params = {"projectId": project_id} if project_id is not None else None
+        url = urljoin(
+            self._request_handler.base_url,
+            f"{api_version}/PipelinesConfig/{pipeline_id}",
+        )
         request_data = self._request_handler.prepare_request(
-            url, params=params, correlation_id=correlation_id
+            url, correlation_id=correlation_id
         )
 
         return request_data
 
-    def _pre_get_pipeline_config(
+    def _pre_export_pipeline_definition(
         self,
         pipeline_id: str,
         correlation_id: Optional[str] = None,
         api_version: str = ApiVersion.V1.value,
     ):
         """
-        Prepare request data for getting pipeline configuration endpoint.
+        Prepare request data for exporting pipeline definition endpoint.
 
         Args:
-            pipeline_id: ID of the pipeline to get configuration for
+            pipeline_id: ID of the pipeline to export definition for
             correlation_id: Optional correlation ID for tracing
             api_version: API version to use for the request
 
         Returns:
-            RequestData: Prepared request data for the pipeline config endpoint
+            RequestData: Prepared request data for the export pipeline definition endpoint
 
         Raises:
             ValueError: If an invalid API version is provided