airia 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

airia/client/pipeline_import/async_pipeline_import.py

@@ -0,0 +1,147 @@
+from typing import Any, Dict, Literal, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.pipeline_import import CreateAgentFromPipelineDefinitionResponse
+from .._request_handler import AsyncRequestHandler
+from .base_pipeline_import import BasePipelineImport
+
+
+class AsyncPipelineImport(BasePipelineImport):
+    def __init__(self, request_handler: AsyncRequestHandler):
+        super().__init__(request_handler)
+
+    async def create_agent_from_pipeline_definition(
+        self,
+        pipeline_definition: Dict[str, Any],
+        agent_import_source: Optional[
+            Literal[
+                "PlatformApi",
+                "ChatCommunity",
+                "PlatformCommunity",
+                "PlatformJson",
+                "Marketplace",
+            ]
+        ] = None,
+        conflict_resolution_strategy: Literal[
+            "SkipConflictingEntities",
+            "RecreateExistingEntities",
+            "SeededAgent",
+        ] = "SkipConflictingEntities",
+        credential_mappings: Optional[Dict[str, str]] = None,
+        default_project_behavior: Optional[
+            Literal["Library", "BrainFreezeThenDefault", "DefaultProject"]
+        ] = None,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+    ) -> CreateAgentFromPipelineDefinitionResponse:
+        """
+        Create an agent from a pipeline definition (async).
+
+        This method imports a complete pipeline from a definition dictionary,
+        creating all necessary components including data sources, prompts, tools,
+        models, and pipeline steps. The definition structure should match the
+        format returned by export_pipeline_definition(), but use JSON-compatible
+        types (no enums or Pydantic classes).
+
+        Args:
+            pipeline_definition (dict): The pipeline definition to import. This should
+                be a dictionary with the same structure as the response from
+                pipelines_config.export_pipeline_definition(), but using only
+                JSON-compatible types (strings, numbers, dicts, lists).
+            agent_import_source (str, optional): The source of the agent import.
+                Valid values: "PlatformApi", "ChatCommunity", "PlatformCommunity",
+                "PlatformJson", "Marketplace". If not provided, the import source
+                will not be specified.
+            conflict_resolution_strategy (str): Strategy for handling conflicting entities.
+                Valid values:
+                - "SkipConflictingEntities" (default): Skip entities that already exist
+                - "RecreateExistingEntities": Recreate entities that already exist
+                - "SeededAgent": Use seeded agent strategy
+            credential_mappings (dict, optional): Mapping of exported credential IDs
+                to existing credential GUIDs in the database. Key: Exported credential
+                ID from agent definition. Value: Existing credential GUID in database
+                (must belong to tenant/project).
+            default_project_behavior (str, optional): The default project behavior
+                if project_id is null. Valid values: "Library", "BrainFreezeThenDefault",
+                "DefaultProject".
+            project_id (str, optional): The project ID where the pipeline should be
+                imported. If null, the provision will happen in a library project
+                according to default_project_behavior.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            CreateAgentFromPipelineDefinitionResponse: A response object containing the
+                import result, including pipeline ID, department ID, pipeline name,
+                deployment ID (if deployed), and lists of created, updated, and
+                skipped entities. If the import failed, error_message and error_details
+                will contain information about what went wrong.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The pipeline definition is invalid (400)
+                - A referenced project_id doesn't exist (404)
+                - Credential mappings are invalid (400)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+            import asyncio
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # First, export a pipeline definition
+                exported = await client.pipelines_config.export_pipeline_definition(
+                    pipeline_id="source_pipeline_id"
+                )
+
+                # Convert the exported definition to a JSON-compatible dictionary
+                # (Pydantic models have a .model_dump() method for this)
+                pipeline_def = exported.model_dump(by_alias=True, exclude_none=True)
+
+                # Import the pipeline into a new project
+                result = await client.pipeline_import.create_agent_from_pipeline_definition(
+                    pipeline_definition=pipeline_def,
+                    project_id="target_project_id",
+                    conflict_resolution_strategy="SkipConflictingEntities"
+                )
+
+                if result.error_message:
+                    print(f"Import failed: {result.error_message}")
+                    if result.error_details:
+                        for detail in result.error_details:
+                            print(f"  - {detail}")
+                else:
+                    print(f"Pipeline imported successfully!")
+                    print(f"Pipeline ID: {result.pipeline_id}")
+                    print(f"Pipeline Name: {result.pipeline_name}")
+                    print(f"Created {len(result.created_entities or [])} entities")
+                    print(f"Updated {len(result.updated_entities or [])} entities")
+                    print(f"Skipped {len(result.skipped_entities or [])} entities")
+
+            asyncio.run(main())
+            ```
+
+        Note:
+            - The pipeline_definition must use JSON-compatible types only
+            - Use model_dump(by_alias=True) on Pydantic models to get the correct format
+            - Credential mappings must reference existing credentials in the target system
+            - The import process will create new GUIDs for most entities
+        """
+        request_data = self._pre_create_agent_from_pipeline_definition(
+            pipeline_definition=pipeline_definition,
+            agent_import_source=agent_import_source,
+            conflict_resolution_strategy=conflict_resolution_strategy,
+            credential_mappings=credential_mappings,
+            default_project_behavior=default_project_behavior,
+            project_id=project_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = await self._request_handler.make_request("POST", request_data)
+
+        return CreateAgentFromPipelineDefinitionResponse(**resp)

airia/client/pipeline_import/base_pipeline_import.py

@@ -0,0 +1,95 @@
+from typing import Any, Dict, Literal, Optional, Union
+from urllib.parse import urljoin
+
+from ...types._api_version import ApiVersion
+from .._request_handler import AsyncRequestHandler, RequestHandler
+
+
+class BasePipelineImport:
+    def __init__(self, request_handler: Union[RequestHandler, AsyncRequestHandler]):
+        self._request_handler = request_handler
+
+    def _pre_create_agent_from_pipeline_definition(
+        self,
+        pipeline_definition: Dict[str, Any],
+        agent_import_source: Optional[
+            Literal[
+                "PlatformApi",
+                "ChatCommunity",
+                "PlatformCommunity",
+                "PlatformJson",
+                "Marketplace",
+            ]
+        ] = None,
+        conflict_resolution_strategy: Literal[
+            "SkipConflictingEntities",
+            "RecreateExistingEntities",
+            "SeededAgent",
+        ] = "SkipConflictingEntities",
+        credential_mappings: Optional[Dict[str, str]] = None,
+        default_project_behavior: Optional[
+            Literal["Library", "BrainFreezeThenDefault", "DefaultProject"]
+        ] = None,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for creating an agent from a pipeline definition.
+
+        This internal method constructs the URL and payload for importing
+        a pipeline from a definition.
+
+        Args:
+            pipeline_definition: The pipeline definition to import (dictionary structure
+                matching ExportPipelineDefinitionResponse format, but using JSON-compatible types)
+            agent_import_source: The source of the agent import (PlatformApi, ChatCommunity,
+                PlatformCommunity, PlatformJson, or Marketplace)
+            conflict_resolution_strategy: Strategy for handling conflicting entities
+                (SkipConflictingEntities, RecreateExistingEntities, or SeededAgent)
+            credential_mappings: Optional mapping of exported credential IDs to existing
+                credential GUIDs in the database
+            default_project_behavior: The default project behavior if project_id is null
+                (Library, BrainFreezeThenDefault, or DefaultProject)
+            project_id: Optional project ID. If null, provision happens in a library project
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the pipeline import 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}/PipelineImport/definition",
+        )
+
+        payload = {
+            "pipelineDefinition": pipeline_definition,
+            "conflictResolutionStrategy": conflict_resolution_strategy,
+        }
+
+        # Add optional fields only if they are not None
+        if agent_import_source is not None:
+            payload["agentImportSource"] = agent_import_source
+
+        if credential_mappings is not None:
+            payload["credentialMappings"] = credential_mappings
+
+        if default_project_behavior is not None:
+            payload["defaultProjectBehavior"] = default_project_behavior
+
+        if project_id is not None:
+            payload["projectId"] = project_id
+
+        request_data = self._request_handler.prepare_request(
+            url=url, payload=payload, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/pipeline_import/sync_pipeline_import.py

@@ -0,0 +1,143 @@
+from typing import Any, Dict, Literal, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.pipeline_import import CreateAgentFromPipelineDefinitionResponse
+from .._request_handler import RequestHandler
+from .base_pipeline_import import BasePipelineImport
+
+
+class PipelineImport(BasePipelineImport):
+    def __init__(self, request_handler: RequestHandler):
+        super().__init__(request_handler)
+
+    def create_agent_from_pipeline_definition(
+        self,
+        pipeline_definition: Dict[str, Any],
+        agent_import_source: Optional[
+            Literal[
+                "PlatformApi",
+                "ChatCommunity",
+                "PlatformCommunity",
+                "PlatformJson",
+                "Marketplace",
+            ]
+        ] = None,
+        conflict_resolution_strategy: Literal[
+            "SkipConflictingEntities",
+            "RecreateExistingEntities",
+            "SeededAgent",
+        ] = "SkipConflictingEntities",
+        credential_mappings: Optional[Dict[str, str]] = None,
+        default_project_behavior: Optional[
+            Literal["Library", "BrainFreezeThenDefault", "DefaultProject"]
+        ] = None,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+    ) -> CreateAgentFromPipelineDefinitionResponse:
+        """
+        Create an agent from a pipeline definition.
+
+        This method imports a complete pipeline from a definition dictionary,
+        creating all necessary components including data sources, prompts, tools,
+        models, and pipeline steps. The definition structure should match the
+        format returned by export_pipeline_definition(), but use JSON-compatible
+        types (no enums or Pydantic classes).
+
+        Args:
+            pipeline_definition (dict): The pipeline definition to import. This should
+                be a dictionary with the same structure as the response from
+                pipelines_config.export_pipeline_definition(), but using only
+                JSON-compatible types (strings, numbers, dicts, lists).
+            agent_import_source (str, optional): The source of the agent import.
+                Valid values: "PlatformApi", "ChatCommunity", "PlatformCommunity",
+                "PlatformJson", "Marketplace". If not provided, the import source
+                will not be specified.
+            conflict_resolution_strategy (str): Strategy for handling conflicting entities.
+                Valid values:
+                - "SkipConflictingEntities" (default): Skip entities that already exist
+                - "RecreateExistingEntities": Recreate entities that already exist
+                - "SeededAgent": Use seeded agent strategy
+            credential_mappings (dict, optional): Mapping of exported credential IDs
+                to existing credential GUIDs in the database. Key: Exported credential
+                ID from agent definition. Value: Existing credential GUID in database
+                (must belong to tenant/project).
+            default_project_behavior (str, optional): The default project behavior
+                if project_id is null. Valid values: "Library", "BrainFreezeThenDefault",
+                "DefaultProject".
+            project_id (str, optional): The project ID where the pipeline should be
+                imported. If null, the provision will happen in a library project
+                according to default_project_behavior.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            CreateAgentFromPipelineDefinitionResponse: A response object containing the
+                import result, including pipeline ID, department ID, pipeline name,
+                deployment ID (if deployed), and lists of created, updated, and
+                skipped entities. If the import failed, error_message and error_details
+                will contain information about what went wrong.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The pipeline definition is invalid (400)
+                - A referenced project_id doesn't exist (404)
+                - Credential mappings are invalid (400)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # First, export a pipeline definition
+            exported = client.pipelines_config.export_pipeline_definition(
+                pipeline_id="source_pipeline_id"
+            )
+
+            # Convert the exported definition to a JSON-compatible dictionary
+            # (Pydantic models have a .model_dump() method for this)
+            pipeline_def = exported.model_dump(by_alias=True, exclude_none=True)
+
+            # Import the pipeline into a new project
+            result = client.pipeline_import.create_agent_from_pipeline_definition(
+                pipeline_definition=pipeline_def,
+                project_id="target_project_id",
+                conflict_resolution_strategy="SkipConflictingEntities"
+            )
+
+            if result.error_message:
+                print(f"Import failed: {result.error_message}")
+                if result.error_details:
+                    for detail in result.error_details:
+                        print(f"  - {detail}")
+            else:
+                print(f"Pipeline imported successfully!")
+                print(f"Pipeline ID: {result.pipeline_id}")
+                print(f"Pipeline Name: {result.pipeline_name}")
+                print(f"Created {len(result.created_entities or [])} entities")
+                print(f"Updated {len(result.updated_entities or [])} entities")
+                print(f"Skipped {len(result.skipped_entities or [])} entities")
+            ```
+
+        Note:
+            - The pipeline_definition must use JSON-compatible types only
+            - Use model_dump(by_alias=True) on Pydantic models to get the correct format
+            - Credential mappings must reference existing credentials in the target system
+            - The import process will create new GUIDs for most entities
+        """
+        request_data = self._pre_create_agent_from_pipeline_definition(
+            pipeline_definition=pipeline_definition,
+            agent_import_source=agent_import_source,
+            conflict_resolution_strategy=conflict_resolution_strategy,
+            credential_mappings=credential_mappings,
+            default_project_behavior=default_project_behavior,
+            project_id=project_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = self._request_handler.make_request("POST", request_data)
+
+        return CreateAgentFromPipelineDefinitionResponse(**resp)

airia/client/pipelines_config/async_pipelines_config.py

@@ -188,3 +188,53 @@ class AsyncPipelinesConfig(BasePipelinesConfig):
         resp = await self._request_handler.make_request("GET", request_data)
 
         return GetPipelinesConfigResponse(**resp)
+
+    async def delete_pipeline(
+        self,
+        pipeline_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a pipeline by its ID.
+
+        This method permanently removes a pipeline and all its configuration
+        from the Airia platform. This action cannot be undone.
+
+        Args:
+            pipeline_id (str): The unique identifier of the pipeline to delete.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            None: This method returns nothing upon successful deletion (204 No Content).
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The pipeline_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+
+            client = AiriaAsyncClient(api_key="your_api_key")
+
+            # Delete a pipeline
+            await client.pipelines_config.delete_pipeline(
+                pipeline_id="your_pipeline_id"
+            )
+            print("Pipeline deleted successfully")
+            ```
+
+        Warning:
+            This operation is permanent and cannot be reversed. Ensure you have
+            the correct pipeline_id before calling this method.
+        """
+        request_data = self._pre_delete_pipeline(
+            pipeline_id=pipeline_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        await self._request_handler.make_request("DELETE", request_data, return_json=False)

airia/client/pipelines_config/base_pipelines_config.py

@@ -114,3 +114,40 @@ class BasePipelinesConfig:
         )
 
         return request_data
+
+    def _pre_delete_pipeline(
+        self,
+        pipeline_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for deleting a pipeline by ID.
+
+        This internal method constructs the URL for pipeline deletion
+        requests using the provided pipeline identifier.
+
+        Args:
+            pipeline_id: ID of the pipeline to delete
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the pipeline deletion 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}/PipelinesConfig/{pipeline_id}",
+        )
+        request_data = self._request_handler.prepare_request(
+            url, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/pipelines_config/sync_pipelines_config.py

@@ -188,3 +188,53 @@ class PipelinesConfig(BasePipelinesConfig):
         resp = self._request_handler.make_request("GET", request_data)
 
         return GetPipelinesConfigResponse(**resp)
+
+    def delete_pipeline(
+        self,
+        pipeline_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a pipeline by its ID.
+
+        This method permanently removes a pipeline and all its configuration
+        from the Airia platform. This action cannot be undone.
+
+        Args:
+            pipeline_id (str): The unique identifier of the pipeline to delete.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            None: This method returns nothing upon successful deletion (204 No Content).
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The pipeline_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # Delete a pipeline
+            client.pipelines_config.delete_pipeline(
+                pipeline_id="your_pipeline_id"
+            )
+            print("Pipeline deleted successfully")
+            ```
+
+        Warning:
+            This operation is permanent and cannot be reversed. Ensure you have
+            the correct pipeline_id before calling this method.
+        """
+        request_data = self._pre_delete_pipeline(
+            pipeline_id=pipeline_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        self._request_handler.make_request("DELETE", request_data, return_json=False)

airia/client/sync_client.py

@@ -15,10 +15,13 @@ from .conversations import Conversations
 from .data_vector_search import DataVectorSearch
 from .deployments import Deployments
 from .library import Library
+from .models import Models
 from .pipeline_execution import PipelineExecution
+from .pipeline_import import PipelineImport
 from .pipelines_config import PipelinesConfig
 from .project import Project
 from .store import Store
+from .tools import Tools
 
 
 class AiriaClient(AiriaBaseClient):
@@ -63,6 +66,7 @@ class AiriaClient(AiriaBaseClient):
         )
         self.attachments = Attachments(self._request_handler)
         self.pipeline_execution = PipelineExecution(self._request_handler)
+        self.pipeline_import = PipelineImport(self._request_handler)
         self.pipelines_config = PipelinesConfig(self._request_handler)
         self.project = Project(self._request_handler)
         self.conversations = Conversations(self._request_handler)
@@ -70,6 +74,8 @@ class AiriaClient(AiriaBaseClient):
         self.deployments = Deployments(self._request_handler)
         self.data_vector_search = DataVectorSearch(self._request_handler)
         self.library = Library(self._request_handler)
+        self.models = Models(self._request_handler)
+        self.tools = Tools(self._request_handler)
 
     @classmethod
     def with_openai_gateway(

airia/client/tools/__init__.py

@@ -0,0 +1,4 @@
+from .async_tools import AsyncTools
+from .sync_tools import Tools
+
+__all__ = ["Tools", "AsyncTools"]