airia 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

airia/client/async_client.py

@@ -14,6 +14,7 @@ from .base_client import AiriaBaseClient
 from .conversations import AsyncConversations
 from .data_vector_search import AsyncDataVectorSearch
 from .deployments import AsyncDeployments
+from .library import AsyncLibrary
 from .pipeline_execution import AsyncPipelineExecution
 from .pipelines_config import AsyncPipelinesConfig
 from .project import AsyncProject
@@ -68,6 +69,7 @@ class AiriaAsyncClient(AiriaBaseClient):
         self.store = AsyncStore(self._request_handler)
         self.deployments = AsyncDeployments(self._request_handler)
         self.data_vector_search = AsyncDataVectorSearch(self._request_handler)
+        self.library = AsyncLibrary(self._request_handler)
 
     @classmethod
     def with_openai_gateway(

airia/client/library/__init__.py

@@ -0,0 +1,5 @@
+from .async_library import AsyncLibrary
+from .base_library import BaseLibrary
+from .sync_library import Library
+
+__all__ = ["AsyncLibrary", "BaseLibrary", "Library"]

airia/client/library/async_library.py

@@ -0,0 +1,100 @@
+from typing import Optional
+
+from ...types.api.library import GetLibraryModelsResponse
+from .._request_handler import AsyncRequestHandler
+from .base_library import BaseLibrary
+
+
+class AsyncLibrary(BaseLibrary):
+    """Asynchronous library client for interacting with Airia Library endpoints."""
+
+    def __init__(self, request_handler: AsyncRequestHandler):
+        super().__init__(request_handler)
+
+    async def get_models(
+        self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[str] = None,
+        search: Optional[str] = None,
+        providers: Optional[str] = None,
+        categories: Optional[str] = None,
+        licenses: Optional[str] = None,
+        industries: Optional[str] = None,
+        authors: Optional[str] = None,
+        is_open_source: Optional[bool] = None,
+        chat_specialized: Optional[bool] = None,
+        industry: Optional[str] = None,
+        commercial_use: Optional[bool] = None,
+        certifications: Optional[str] = None,
+        has_tool_support: Optional[bool] = None,
+        has_stream_support: Optional[bool] = None,
+        correlation_id: Optional[str] = None,
+    ) -> GetLibraryModelsResponse:
+        """
+        Asynchronously retrieve models from the Airia Library with optional filtering and pagination.
+
+        Args:
+            page_number: The page number to be fetched
+            page_size: The number of items per page
+            sort_by: Property to sort by
+            sort_direction: Direction of the sort, either "ASC" for ascending or "DESC" for descending
+            search: An optional search string
+            providers: Library service provider type filter
+            categories: Library service model category filter
+            licenses: Library service model license filter
+            industries: Optional list of industries to filter by
+            authors: Optional list of authors to filter by
+            is_open_source: Optional flag to filter by open source status
+            chat_specialized: Optional flag to filter by chat specialized status
+            industry: Optional flag to filter by Industry
+            commercial_use: Optional flag to filter by Commercial Use
+            certifications: Optional list of certifications to filter by
+            has_tool_support: Optional flag to filter by the models support for tools
+            has_stream_support: Optional flag to filter by the models support for response streaming
+            correlation_id: Optional correlation ID for request tracing. If not provided,
+                          one will be generated automatically.
+
+        Returns:
+            GetLibraryModelsResponse: Response containing the list of models and total count
+
+        Raises:
+            AiriaAPIError: If the API request fails with details about the error.
+            aiohttp.ClientError: For other request-related errors.
+
+        Example:
+            ```python
+            async with AiriaAsyncClient(api_key="your_api_key") as client:
+                response = await client.library.get_models(
+                    search="gpt",
+                    providers="OpenAI",
+                    page_size=10
+                )
+                for model in response.models:
+                    print(f"Model: {model.name} (ID: {model.id})")
+            ```
+        """
+        request_data = self._prepare_get_models_request(
+            page_number=page_number,
+            page_size=page_size,
+            sort_by=sort_by,
+            sort_direction=sort_direction,
+            search=search,
+            providers=providers,
+            categories=categories,
+            licenses=licenses,
+            industries=industries,
+            authors=authors,
+            is_open_source=is_open_source,
+            chat_specialized=chat_specialized,
+            industry=industry,
+            commercial_use=commercial_use,
+            certifications=certifications,
+            has_tool_support=has_tool_support,
+            has_stream_support=has_stream_support,
+            correlation_id=correlation_id,
+        )
+
+        resp = await self._request_handler.make_request("GET", request_data)
+        return GetLibraryModelsResponse(**resp)

airia/client/library/base_library.py

@@ -0,0 +1,110 @@
+from typing import Optional, Union
+from urllib.parse import urljoin
+
+from ...types._api_version import ApiVersion
+from .._request_handler import AsyncRequestHandler, RequestHandler
+
+
+class BaseLibrary:
+    """Base library client with common functionality for sync and async implementations."""
+
+    def __init__(self, request_handler: Union[RequestHandler, AsyncRequestHandler]):
+        self._request_handler = request_handler
+
+    def _prepare_get_models_request(
+        self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[str] = None,
+        search: Optional[str] = None,
+        providers: Optional[str] = None,
+        categories: Optional[str] = None,
+        licenses: Optional[str] = None,
+        industries: Optional[str] = None,
+        authors: Optional[str] = None,
+        is_open_source: Optional[bool] = None,
+        chat_specialized: Optional[bool] = None,
+        industry: Optional[str] = None,
+        commercial_use: Optional[bool] = None,
+        certifications: Optional[str] = None,
+        has_tool_support: Optional[bool] = None,
+        has_stream_support: Optional[bool] = None,
+        correlation_id: Optional[str] = None,
+    ):
+        """
+        Prepare request data for the get_models endpoint.
+
+        This internal method constructs the URL and parameters for library models
+        requests, validating parameters and preparing all request components.
+
+        Args:
+            page_number: The page number to be fetched
+            page_size: The number of items per page
+            sort_by: Property to sort by
+            sort_direction: Direction of the sort, either "ASC" for ascending or "DESC" for descending
+            search: An optional search string
+            providers: Library service provider type filter
+            categories: Library service model category filter
+            licenses: Library service model license filter
+            industries: Optional list of industries to filter by
+            authors: Optional list of authors to filter by
+            is_open_source: Optional flag to filter by open source status
+            chat_specialized: Optional flag to filter by chat specialized status
+            industry: Optional flag to filter by Industry
+            commercial_use: Optional flag to filter by Commercial Use
+            certifications: Optional list of certifications to filter by
+            has_tool_support: Optional flag to filter by the models support for tools
+            has_stream_support: Optional flag to filter by the models support for response streaming
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            RequestData: Prepared request data for the library models endpoint
+        """
+        url = urljoin(
+            self._request_handler.base_url,
+            f"api/marketplace/{ApiVersion.V1.value}/Library/models",
+        )
+
+        # Build query parameters, excluding None values
+        params = {}
+        if page_number is not None:
+            params["PageNumber"] = page_number
+        if page_size is not None:
+            params["PageSize"] = page_size
+        if sort_by is not None:
+            params["SortBy"] = sort_by
+        if sort_direction is not None:
+            params["SortDirection"] = sort_direction
+        if search is not None:
+            params["search"] = search
+        if providers is not None:
+            params["Providers"] = providers
+        if categories is not None:
+            params["Categories"] = categories
+        if licenses is not None:
+            params["Licenses"] = licenses
+        if industries is not None:
+            params["Industries"] = industries
+        if authors is not None:
+            params["Authors"] = authors
+        if is_open_source is not None:
+            params["IsOpenSource"] = is_open_source
+        if chat_specialized is not None:
+            params["ChatSpecialized"] = chat_specialized
+        if industry is not None:
+            params["Industry"] = industry
+        if commercial_use is not None:
+            params["CommercialUse"] = commercial_use
+        if certifications is not None:
+            params["Certifications"] = certifications
+        if has_tool_support is not None:
+            params["HasToolSupport"] = has_tool_support
+        if has_stream_support is not None:
+            params["HasStreamSupport"] = has_stream_support
+
+        request_data = self._request_handler.prepare_request(
+            url=url, params=params, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/library/sync_library.py

@@ -0,0 +1,100 @@
+from typing import Optional
+
+from ...types.api.library import GetLibraryModelsResponse
+from .._request_handler import RequestHandler
+from .base_library import BaseLibrary
+
+
+class Library(BaseLibrary):
+    """Synchronous library client for interacting with Airia Library endpoints."""
+
+    def __init__(self, request_handler: RequestHandler):
+        super().__init__(request_handler)
+
+    def get_models(
+        self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[str] = None,
+        search: Optional[str] = None,
+        providers: Optional[str] = None,
+        categories: Optional[str] = None,
+        licenses: Optional[str] = None,
+        industries: Optional[str] = None,
+        authors: Optional[str] = None,
+        is_open_source: Optional[bool] = None,
+        chat_specialized: Optional[bool] = None,
+        industry: Optional[str] = None,
+        commercial_use: Optional[bool] = None,
+        certifications: Optional[str] = None,
+        has_tool_support: Optional[bool] = None,
+        has_stream_support: Optional[bool] = None,
+        correlation_id: Optional[str] = None,
+    ) -> GetLibraryModelsResponse:
+        """
+        Retrieve models from the Airia Library with optional filtering and pagination.
+
+        Args:
+            page_number: The page number to be fetched
+            page_size: The number of items per page
+            sort_by: Property to sort by
+            sort_direction: Direction of the sort, either "ASC" for ascending or "DESC" for descending
+            search: An optional search string
+            providers: Library service provider type filter
+            categories: Library service model category filter
+            licenses: Library service model license filter
+            industries: Optional list of industries to filter by
+            authors: Optional list of authors to filter by
+            is_open_source: Optional flag to filter by open source status
+            chat_specialized: Optional flag to filter by chat specialized status
+            industry: Optional flag to filter by Industry
+            commercial_use: Optional flag to filter by Commercial Use
+            certifications: Optional list of certifications to filter by
+            has_tool_support: Optional flag to filter by the models support for tools
+            has_stream_support: Optional flag to filter by the models support for response streaming
+            correlation_id: Optional correlation ID for request tracing. If not provided,
+                          one will be generated automatically.
+
+        Returns:
+            GetLibraryModelsResponse: Response containing the list of models and total count
+
+        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.library.get_models(
+                search="gpt",
+                providers="OpenAI",
+                page_size=10
+            )
+            for model in response.models:
+                print(f"Model: {model.name} (ID: {model.id})")
+            ```
+        """
+        request_data = self._prepare_get_models_request(
+            page_number=page_number,
+            page_size=page_size,
+            sort_by=sort_by,
+            sort_direction=sort_direction,
+            search=search,
+            providers=providers,
+            categories=categories,
+            licenses=licenses,
+            industries=industries,
+            authors=authors,
+            is_open_source=is_open_source,
+            chat_specialized=chat_specialized,
+            industry=industry,
+            commercial_use=commercial_use,
+            certifications=certifications,
+            has_tool_support=has_tool_support,
+            has_stream_support=has_stream_support,
+            correlation_id=correlation_id,
+        )
+
+        resp = self._request_handler.make_request("GET", request_data)
+        return GetLibraryModelsResponse(**resp)

airia/client/pipeline_execution/async_pipeline_execution.py

@@ -3,8 +3,9 @@ from typing import Any, Dict, List, Literal, Optional, Union, overload
 from ...types._api_version import ApiVersion
 from ...types.api.pipeline_execution import (
     PipelineExecutionAsyncStreamedResponse,
-    PipelineExecutionDebugResponse,
     PipelineExecutionResponse,
+    TemporaryAssistantAsyncStreamedResponse,
+    TemporaryAssistantResponse,
 )
 from .._request_handler import AsyncRequestHandler
 from .base_pipeline_execution import BasePipelineExecution
@@ -64,7 +65,7 @@ class AsyncPipelineExecution(BasePipelineExecution):
         self,
         pipeline_id: str,
         user_input: str,
-        debug: Literal[False] = False,
+        debug: bool = False,
         user_id: Optional[str] = None,
         conversation_id: Optional[str] = None,
         async_output: Literal[False] = False,
@@ -82,29 +83,6 @@ class AsyncPipelineExecution(BasePipelineExecution):
         correlation_id: Optional[str] = None,
     ) -> PipelineExecutionResponse: ...
 
-    @overload
-    async 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,
-        voice_enabled: bool = False,
-        correlation_id: Optional[str] = None,
-    ) -> PipelineExecutionDebugResponse: ...
-
     @overload
     async def execute_pipeline(
         self,
@@ -149,7 +127,6 @@ class AsyncPipelineExecution(BasePipelineExecution):
         voice_enabled: bool = False,
         correlation_id: Optional[str] = None,
     ) -> Union[
-        PipelineExecutionDebugResponse,
         PipelineExecutionResponse,
         PipelineExecutionAsyncStreamedResponse,
     ]:
@@ -233,8 +210,209 @@ class AsyncPipelineExecution(BasePipelineExecution):
         )
 
         if not async_output:
-            if not debug:
-                return PipelineExecutionResponse(**resp)
-            return PipelineExecutionDebugResponse(**resp)
+            return PipelineExecutionResponse(**resp)
 
         return PipelineExecutionAsyncStreamedResponse(stream=resp)
+
+    @overload
+    async def execute_temporary_assistant(
+        self,
+        model_parameters: Dict[str, Any],
+        user_input: str,
+        assistant_name: str = "",
+        prompt_parameters: Dict[str, Any] = {"prompt": ""},
+        async_output: Literal[False] = False,
+        include_tools_response: bool = False,
+        save_history: bool = True,
+        voice_enabled: bool = False,
+        debug: bool = False,
+        additional_info: Optional[List[Any]] = None,
+        conversation_id: Optional[str] = None,
+        current_date_time: Optional[str] = None,
+        data_source_files: Optional[Dict[str, List[str]]] = None,
+        data_source_folders: Optional[Dict[str, List[str]]] = None,
+        data_store_parameters: Optional[Dict[str, Any]] = None,
+        external_user_id: Optional[str] = None,
+        files: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        in_memory_messages: Optional[List[Dict[str, Any]]] = None,
+        output_configuration: Optional[Dict[str, Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        user_input_id: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> TemporaryAssistantResponse: ...
+
+    @overload
+    async def execute_temporary_assistant(
+        self,
+        model_parameters: Dict[str, Any],
+        user_input: str,
+        assistant_name: str = "",
+        prompt_parameters: Dict[str, Any] = {"prompt": ""},
+        async_output: Literal[True] = True,
+        include_tools_response: bool = False,
+        save_history: bool = True,
+        voice_enabled: bool = False,
+        debug: bool = False,
+        additional_info: Optional[List[Any]] = None,
+        conversation_id: Optional[str] = None,
+        current_date_time: Optional[str] = None,
+        data_source_files: Optional[Dict[str, List[str]]] = None,
+        data_source_folders: Optional[Dict[str, List[str]]] = None,
+        data_store_parameters: Optional[Dict[str, Any]] = None,
+        external_user_id: Optional[str] = None,
+        files: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        in_memory_messages: Optional[List[Dict[str, Any]]] = None,
+        output_configuration: Optional[Dict[str, Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        user_input_id: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> TemporaryAssistantAsyncStreamedResponse: ...
+
+    async def execute_temporary_assistant(
+        self,
+        model_parameters: Dict[str, Any],
+        user_input: str,
+        assistant_name: str = "",
+        prompt_parameters: Dict[str, Any] = {"prompt": ""},
+        async_output: bool = False,
+        include_tools_response: bool = False,
+        save_history: bool = True,
+        voice_enabled: bool = False,
+        debug: bool = False,
+        additional_info: Optional[List[Any]] = None,
+        conversation_id: Optional[str] = None,
+        current_date_time: Optional[str] = None,
+        data_source_files: Optional[Dict[str, List[str]]] = None,
+        data_source_folders: Optional[Dict[str, List[str]]] = None,
+        data_store_parameters: Optional[Dict[str, Any]] = None,
+        external_user_id: Optional[str] = None,
+        files: Optional[List[str]] = None,
+        images: Optional[List[str]] = None,
+        in_memory_messages: Optional[List[Dict[str, Any]]] = None,
+        output_configuration: Optional[Dict[str, Any]] = None,
+        prompt_variables: Optional[Dict[str, Any]] = None,
+        user_id: Optional[str] = None,
+        user_input_id: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+    ) -> Union[
+        TemporaryAssistantResponse,
+        TemporaryAssistantAsyncStreamedResponse,
+    ]:
+        """
+        Execute a temporary assistant with the provided parameters asynchronously.
+
+        This method creates and executes a temporary AI assistant with custom configuration,
+        allowing for flexible assistant behavior without creating a persistent pipeline.
+
+        Args:
+            model_parameters: Model parameters (required). Must include libraryModelId,
+                            projectModelId, modelIdentifierType, and modelIsAvailableinProject
+            user_input: User input text (required)
+            assistant_name: Name of the temporary assistant. Default is ""
+            prompt_parameters: Parameters for prompt configuration. Default is {"prompt": ""}
+            async_output: Whether to stream the response. Default is False
+            include_tools_response: Whether to return initial LLM tool result. Default is False
+            save_history: Whether to save input and output to conversation history. Default is True
+            voice_enabled: Whether voice output is enabled. Default is False
+            debug: Whether debug mode execution is enabled. Default is False
+            additional_info: Optional additional information array
+            conversation_id: Optional conversation identifier
+            current_date_time: Optional current date and time in ISO format
+            data_source_files: Optional dictionary mapping data source GUIDs to file GUID arrays
+            data_source_folders: Optional dictionary mapping data source GUIDs to folder GUID arrays
+            data_store_parameters: Optional DataStore parameters
+            external_user_id: Optional external user identifier
+            files: Optional list of file identifiers
+            images: Optional list of image identifiers
+            in_memory_messages: Optional list of in-memory messages
+            output_configuration: Optional output configuration
+            prompt_variables: Optional prompt variables dictionary
+            user_id: Optional user identifier
+            user_input_id: Optional unique identifier for user input
+            variables: Optional variables dictionary
+            correlation_id: Optional correlation ID for request tracing. If not provided,
+                          one will be generated automatically.
+
+        Returns:
+            Response containing the result of the temporary assistant execution.
+            Returns different response types based on the result type discriminator.
+
+        Raises:
+            AiriaAPIError: If the API request fails with details about the error.
+            aiohttp.ClientError: For other request-related errors.
+            ValueError: If required parameters are missing or invalid.
+
+        Example:
+            ```python
+            client = AiriaAsyncClient(api_key="your_api_key")
+            response = await client.pipeline_execution.execute_temporary_assistant(
+                model_parameters={
+                    "libraryModelId": "library-model-id",
+                    "projectModelId": None,
+                    "modelIdentifierType": "Library",
+                    "modelIsAvailableinProject": True,
+                },
+                user_input="say double bubble bath ten times fast",
+            )
+            print(response.result)
+            ```
+        """
+        # Validate required parameters
+        if not user_input:
+            raise ValueError("user_input cannot be empty")
+
+        if not model_parameters:
+            raise ValueError("model_parameters cannot be empty")
+
+        # Handle file and image uploads (local files are uploaded, URLs are passed through)
+        image_urls = None
+        file_urls = None
+
+        if images or files:
+            file_urls, image_urls = await self._upload_files(files or [], images or [])
+
+        request_data = self._pre_execute_temporary_assistant(
+            model_parameters=model_parameters,
+            user_input=user_input,
+            assistant_name=assistant_name,
+            prompt_parameters=prompt_parameters,
+            async_output=async_output,
+            include_tools_response=include_tools_response,
+            save_history=save_history,
+            voice_enabled=voice_enabled,
+            debug=debug,
+            additional_info=additional_info,
+            conversation_id=conversation_id,
+            current_date_time=current_date_time,
+            data_source_files=data_source_files,
+            data_source_folders=data_source_folders,
+            data_store_parameters=data_store_parameters,
+            external_user_id=external_user_id,
+            files=file_urls,
+            images=image_urls,
+            in_memory_messages=in_memory_messages,
+            output_configuration=output_configuration,
+            prompt_variables=prompt_variables,
+            user_id=user_id,
+            user_input_id=user_input_id,
+            variables=variables,
+            correlation_id=correlation_id,
+        )
+
+        resp = (
+            self._request_handler.make_request_stream("POST", request_data)
+            if async_output
+            else await self._request_handler.make_request("POST", request_data)
+        )
+
+        if async_output:
+            return TemporaryAssistantAsyncStreamedResponse(stream=resp)
+
+        return TemporaryAssistantResponse(**resp)