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

airia/client/pipeline_execution/sync_pipeline_execution.py

@@ -0,0 +1,178 @@
+from typing import Any, Dict, List, Literal, Optional, Union, overload
+
+from ...types._api_version import ApiVersion
+from ...types.api.pipeline_execution import (
+    PipelineExecutionDebugResponse,
+    PipelineExecutionResponse,
+    PipelineExecutionStreamedResponse,
+)
+from .._request_handler import RequestHandler
+from .base_pipeline_execution import BasePipelineExecution
+
+
+class PipelineExecution(BasePipelineExecution):
+    def __init__(self, request_handler: RequestHandler):
+        super().__init__(request_handler)
+
+    @overload
+    def execute_pipeline(
+        self,
+        pipeline_id: str,
+        user_input: str,
+        debug: Literal[False] = False,
+        user_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+        async_output: Literal[False] = False,
+        include_tools_response: bool = False,
+        images: Optional[List[str]] = None,
+        files: Optional[List[str]] = None,
+        data_source_folders: Optional[Dict[str, Any]] = None,
+        data_source_files: Optional[Dict[str, Any]] = None,
+        in_memory_messages: Optional[List[Dict[str, str]]] = None,
+        current_date_time: Optional[str] = None,
+        save_history: bool = True,
+        additional_info: Optional[List[Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> PipelineExecutionResponse: ...
+
+    @overload
+    def execute_pipeline(
+        self,
+        pipeline_id: str,
+        user_input: str,
+        debug: Literal[True] = True,
+        user_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+        async_output: Literal[False] = False,
+        include_tools_response: bool = False,
+        images: Optional[List[str]] = None,
+        files: Optional[List[str]] = None,
+        data_source_folders: Optional[Dict[str, Any]] = None,
+        data_source_files: Optional[Dict[str, Any]] = None,
+        in_memory_messages: Optional[List[Dict[str, str]]] = None,
+        current_date_time: Optional[str] = None,
+        save_history: bool = True,
+        additional_info: Optional[List[Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> PipelineExecutionDebugResponse: ...
+
+    @overload
+    def execute_pipeline(
+        self,
+        pipeline_id: str,
+        user_input: str,
+        debug: bool = False,
+        user_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+        async_output: Literal[True] = True,
+        include_tools_response: bool = False,
+        images: Optional[List[str]] = None,
+        files: Optional[List[str]] = None,
+        data_source_folders: Optional[Dict[str, Any]] = None,
+        data_source_files: Optional[Dict[str, Any]] = None,
+        in_memory_messages: Optional[List[Dict[str, str]]] = None,
+        current_date_time: Optional[str] = None,
+        save_history: bool = True,
+        additional_info: Optional[List[Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> PipelineExecutionStreamedResponse: ...
+
+    def execute_pipeline(
+        self,
+        pipeline_id: str,
+        user_input: str,
+        debug: bool = False,
+        user_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+        async_output: bool = False,
+        include_tools_response: bool = False,
+        images: Optional[List[str]] = None,
+        files: Optional[List[str]] = None,
+        data_source_folders: Optional[Dict[str, Any]] = None,
+        data_source_files: Optional[Dict[str, Any]] = None,
+        in_memory_messages: Optional[List[Dict[str, str]]] = None,
+        current_date_time: Optional[str] = None,
+        save_history: bool = True,
+        additional_info: Optional[List[Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> Union[
+        PipelineExecutionDebugResponse,
+        PipelineExecutionResponse,
+        PipelineExecutionStreamedResponse,
+    ]:
+        """
+        Execute a pipeline with the provided input.
+
+        Args:
+            pipeline_id: The ID of the pipeline to execute.
+            user_input: input text to process.
+            debug: Whether debug mode execution is enabled. Default is False.
+            user_id: Optional ID of the user making the request (guid).
+            conversation_id: Optional conversation ID (guid).
+            async_output: Whether to stream the response. Default is False.
+            include_tools_response: Whether to return the initial LLM tool result. Default is False.
+            images: Optional list of images formatted as base64 strings.
+            files: Optional list of files formatted as base64 strings.
+            data_source_folders: Optional data source folders information.
+            data_source_files: Optional data source files information.
+            in_memory_messages: Optional list of in-memory messages, each with a role and message.
+            current_date_time: Optional current date and time in ISO format.
+            save_history: Whether to save the userInput and output to conversation history. Default is True.
+            additional_info: Optional additional information.
+            prompt_variables: Optional variables to be used in the prompt.
+            correlation_id: Optional correlation ID for request tracing. If not provided,
+                        one will be generated automatically.
+
+        Returns:
+            Response containing the result of the execution.
+
+        Raises:
+            AiriaAPIError: If the API request fails with details about the error.
+            requests.RequestException: For other request-related errors.
+
+        Example:
+            ```python
+            client = AiriaClient(api_key="your_api_key")
+            response = client.pipeline_execution.execute_pipeline(
+                pipeline_id="pipeline_123",
+                user_input="Tell me about quantum computing"
+            )
+            print(response.result)
+            ```
+        """
+        request_data = self._pre_execute_pipeline(
+            pipeline_id=pipeline_id,
+            user_input=user_input,
+            debug=debug,
+            user_id=user_id,
+            conversation_id=conversation_id,
+            async_output=async_output,
+            include_tools_response=include_tools_response,
+            images=images,
+            files=files,
+            data_source_folders=data_source_folders,
+            data_source_files=data_source_files,
+            in_memory_messages=in_memory_messages,
+            current_date_time=current_date_time,
+            save_history=save_history,
+            additional_info=additional_info,
+            prompt_variables=prompt_variables,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V2.value,
+        )
+        resp = (
+            self._request_handler.make_request_stream("POST", request_data)
+            if async_output
+            else self._request_handler.make_request("POST", request_data)
+        )
+
+        if not async_output:
+            if not debug:
+                return PipelineExecutionResponse(**resp)
+            return PipelineExecutionDebugResponse(**resp)
+
+        return PipelineExecutionStreamedResponse(stream=resp)

airia/client/pipelines_config/__init__.py

@@ -0,0 +1,4 @@
+from .sync_pipelines_config import PipelinesConfig
+from .async_pipelines_config import AsyncPipelinesConfig
+
+__all__ = ["PipelinesConfig", "AsyncPipelinesConfig"]

airia/client/pipelines_config/async_pipelines_config.py

@@ -0,0 +1,127 @@
+from typing import List, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.pipelines_config import GetPipelineConfigResponse
+from .._request_handler import AsyncRequestHandler
+from .base_pipelines_config import BasePipelinesConfig
+
+
+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]:
+        """
+        Retrieve a list of active pipeline IDs.
+
+        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.
+
+        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.
+            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.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The project_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")
+
+            # 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"
+            )
+            print(f"Project has {len(project_pipelines)} active pipelines")
+            ```
+
+        Note:
+            Only pipelines with active versions are returned. Inactive or archived
+            pipelines are not included in the results.
+        """
+        request_data = self._pre_get_active_pipelines_ids(
+            project_id=project_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 pipeline_ids
+
+    async def get_pipeline_config(
+        self, pipeline_id: str, correlation_id: Optional[str] = None
+    ) -> GetPipelineConfigResponse:
+        """
+        Retrieve configuration details for a specific pipeline.
+
+        This method fetches comprehensive information about a pipeline including its
+        deployment details, execution statistics, version information, and metadata.
+
+        Args:
+            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:
+            GetPipelineConfigResponse: A response object containing the pipeline
+                configuration.
+
+        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")
+
+            # Get pipeline configuration
+            config = await client.pipelines_config.get_pipeline_config(
+                pipeline_id="your_pipeline_id"
+            )
+
+            print(f"Pipeline: {config.agent.name}")
+            print(f"Description: {config.agent.agent_description}")
+            ```
+
+        Note:
+            This method only retrieves configuration information and does not
+            execute the pipeline. Use execute_pipeline() to run the pipeline.
+        """
+        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)
+
+        return GetPipelineConfigResponse(**resp)

airia/client/pipelines_config/base_pipelines_config.py

@@ -0,0 +1,76 @@
+from typing import Optional, Union
+from urllib.parse import urljoin
+
+from ...types._api_version import ApiVersion
+from .._request_handler import AsyncRequestHandler, RequestHandler
+
+
+class BasePipelinesConfig:
+    def __init__(self, request_handler: Union[RequestHandler, AsyncRequestHandler]):
+        self._request_handler = request_handler
+
+    def _pre_get_active_pipelines_ids(
+        self,
+        project_id: Optional[str] = None,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for getting active pipelines IDs.
+
+        Args:
+            project_id: ID of the project to get configuration 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
+
+        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")
+        params = {"projectId": project_id} if project_id is not None else None
+        request_data = self._request_handler.prepare_request(
+            url, params=params, correlation_id=correlation_id
+        )
+
+        return request_data
+
+    def _pre_get_pipeline_config(
+        self,
+        pipeline_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for getting pipeline configuration endpoint.
+
+        Args:
+            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
+
+        Returns:
+            RequestData: Prepared request data for the pipeline config 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/export/{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

@@ -0,0 +1,127 @@
+from typing import List, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.pipelines_config import GetPipelineConfigResponse
+from .._request_handler import RequestHandler
+from .base_pipelines_config import BasePipelinesConfig
+
+
+class PipelinesConfig(BasePipelinesConfig):
+    def __init__(self, request_handler: RequestHandler):
+        super().__init__(request_handler)
+
+    def get_active_pipelines_ids(
+        self, project_id: Optional[str] = None, correlation_id: Optional[str] = None
+    ) -> List[str]:
+        """
+        Retrieve a list of active pipeline IDs.
+
+        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.
+
+        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.
+            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.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The project_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")
+
+            # Get all active pipeline IDs
+            pipeline_ids = 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 = client.pipelines_config.get_active_pipelines_ids(
+                project_id="your_project_id"
+            )
+            print(f"Project has {len(project_pipelines)} active pipelines")
+            ```
+
+        Note:
+            Only pipelines with active versions are returned. Inactive or archived
+            pipelines are not included in the results.
+        """
+        request_data = self._pre_get_active_pipelines_ids(
+            project_id=project_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = 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 pipeline_ids
+
+    def get_pipeline_config(
+        self, pipeline_id: str, correlation_id: Optional[str] = None
+    ) -> GetPipelineConfigResponse:
+        """
+        Retrieve configuration details for a specific pipeline.
+
+        This method fetches comprehensive information about a pipeline including its
+        deployment details, execution statistics, version information, and metadata.
+
+        Args:
+            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:
+            GetPipelineConfigResponse: A response object containing the pipeline
+                configuration.
+
+        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")
+
+            # Get pipeline configuration
+            config = client.pipelines_config.get_pipeline_config(
+                pipeline_id="your_pipeline_id"
+            )
+
+            print(f"Pipeline: {config.agent.name}")
+            print(f"Description: {config.agent.agent_description}")
+            ```
+
+        Note:
+            This method only retrieves configuration information and does not
+            execute the pipeline. Use execute_pipeline() to run the pipeline.
+        """
+        request_data = self._pre_get_pipeline_config(
+            pipeline_id=pipeline_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = self._request_handler.make_request("GET", request_data)
+
+        return GetPipelineConfigResponse(**resp)

airia/client/project/__init__.py

@@ -0,0 +1,4 @@
+from .sync_project import Project
+from .async_project import AsyncProject
+
+__all__ = ["Project", "AsyncProject"]

airia/client/project/async_project.py

@@ -0,0 +1,122 @@
+from typing import List, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.project import ProjectItem
+from .._request_handler import AsyncRequestHandler
+from .base_project import BaseProject
+
+
+class AsyncProject(BaseProject):
+    def __init__(self, request_handler: AsyncRequestHandler):
+        super().__init__(request_handler)
+
+    async def get_projects(
+        self, correlation_id: Optional[str] = None
+    ) -> List[ProjectItem]:
+        """
+        Retrieve a list of all projects accessible to the authenticated user.
+
+        This method fetches comprehensive information about all projects that the
+        current user has access to, including project metadata, creation details,
+        and status information.
+
+        Args:
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            List[ProjectItem]: A list of ProjectItem objects containing project
+                information. Returns an empty list if no projects are accessible
+                or found.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+
+            client = AiriaAsyncClient(api_key="your_api_key")
+
+            # Get all accessible projects
+            projects = await client.project.get_projects()
+
+            for project in projects:
+                print(f"Project: {project.name}")
+                print(f"ID: {project.id}")
+                print(f"Description: {project.description}")
+                print(f"Created: {project.created_at}")
+                print("---")
+            ```
+
+        Note:
+            The returned projects are filtered based on the authenticated user's
+            permissions. Users will only see projects they have been granted
+            access to.
+        """
+        request_data = self._pre_get_projects(
+            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 []
+
+        return [ProjectItem(**item) for item in resp["items"]]
+
+    async def get_project(
+        self, project_id: str, correlation_id: Optional[str] = None
+    ) -> ProjectItem:
+        """
+        Retrieve detailed information for a specific project.
+
+        This method fetches comprehensive information about a single project,
+        including all associated resources, metadata, and configuration details.
+
+        Args:
+            project_id (str): The unique identifier (GUID) of the project to retrieve.
+            correlation_id (str, optional): A unique identifier for request tracing
+                and logging. If not provided, one will be automatically generated.
+
+        Returns:
+            ProjectItem: A ProjectItem object containing complete project
+                information including pipelines, models, data sources, and metadata.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - Project not found (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+
+        Example:
+            ```python
+            from airia import AiriaAsyncClient
+
+            client = AiriaAsyncClient(api_key="your_api_key")
+
+            # Get a specific project by ID
+            project = await client.project.get_project("12345678-1234-1234-1234-123456789abc")
+
+            print(f"Project: {project.name}")
+            print(f"Description: {project.description}")
+            print(f"Pipelines: {len(project.pipelines)}")
+            print(f"Created: {project.created_at}")
+            ```
+
+        Note:
+            The project must be accessible to the authenticated user.
+            Users will only be able to retrieve projects they have been granted
+            access to.
+        """
+        request_data = self._pre_get_project(
+            project_id=project_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+        resp = await self._request_handler.make_request("GET", request_data)
+
+        return ProjectItem(**resp)