airia 0.1.31__py3-none-any.whl → 0.1.32__py3-none-any.whl

airia/client/data_vector_search/async_data_vector_search.py

@@ -11,7 +11,12 @@ class AsyncDataVectorSearch(BaseDataVectorSearch):
         super().__init__(request_handler)
 
     async def get_file_chunks(
-        self, data_store_id: str, file_id: str, correlation_id: Optional[str] = None
+        self,
+        data_store_id: str,
+        file_id: str,
+        page_number: int = 1,
+        page_size: int = 50,
+        correlation_id: Optional[str] = None,
     ) -> GetFileChunksResponse:
         """
         Retrieve chunks from a specific file in a data store.
@@ -21,6 +26,8 @@ class AsyncDataVectorSearch(BaseDataVectorSearch):
         Args:
             data_store_id: The unique identifier of the data store (GUID format)
             file_id: The unique identifier of the file (GUID format)
+            page_number: The page number (1-based). Default is 1.
+            page_size: The page size. Maximum supported value is 100. Default is 50.
             correlation_id: Optional correlation ID for request tracing
 
         Returns:
@@ -49,6 +56,14 @@ class AsyncDataVectorSearch(BaseDataVectorSearch):
                     file_id="your_file_id"
                 )
 
+                # Get file chunks with custom pagination
+                chunks_response = await client.data_vector_search.get_file_chunks(
+                    data_store_id="your_data_store_id",
+                    file_id="your_file_id",
+                    page_number=2,
+                    page_size=100
+                )
+
                 # Access the chunks
                 for chunk in chunks_response.chunks:
                     print(f"Chunk: {chunk.chunk}")
@@ -64,6 +79,8 @@ class AsyncDataVectorSearch(BaseDataVectorSearch):
         request_data = self._pre_get_file_chunks(
             data_store_id=data_store_id,
             file_id=file_id,
+            page_number=page_number,
+            page_size=page_size,
             correlation_id=correlation_id,
             api_version=ApiVersion.V1.value,
         )

airia/client/data_vector_search/base_data_vector_search.py

@@ -13,6 +13,8 @@ class BaseDataVectorSearch:
         self,
         data_store_id: str,
         file_id: str,
+        page_number: int = 1,
+        page_size: int = 50,
         correlation_id: Optional[str] = None,
         api_version: str = ApiVersion.V1.value,
     ):
@@ -24,6 +26,8 @@ class BaseDataVectorSearch:
         Args:
             data_store_id: ID of the data store
             file_id: ID of the file
+            page_number: The page number (1-based). Default is 1.
+            page_size: The page size. Maximum supported value is 100. Default is 50.
             correlation_id: Optional correlation ID for tracing
             api_version: API version to use for the request
 
@@ -44,7 +48,7 @@ class BaseDataVectorSearch:
         )
 
         request_data = self._request_handler.prepare_request(
-            url, correlation_id=correlation_id, params={"pageNumber": 1, "pageSize": 50}
+            url, correlation_id=correlation_id, params={"pageNumber": page_number, "pageSize": page_size}
         )
 
         return request_data

airia/client/data_vector_search/sync_data_vector_search.py

@@ -11,7 +11,12 @@ class DataVectorSearch(BaseDataVectorSearch):
         super().__init__(request_handler)
 
     def get_file_chunks(
-        self, data_store_id: str, file_id: str, correlation_id: Optional[str] = None
+        self,
+        data_store_id: str,
+        file_id: str,
+        page_number: int = 1,
+        page_size: int = 50,
+        correlation_id: Optional[str] = None,
     ) -> GetFileChunksResponse:
         """
         Retrieve chunks from a specific file in a data store.
@@ -21,6 +26,8 @@ class DataVectorSearch(BaseDataVectorSearch):
         Args:
             data_store_id: The unique identifier of the data store (GUID format)
             file_id: The unique identifier of the file (GUID format)
+            page_number: The page number (1-based). Default is 1.
+            page_size: The page size. Maximum supported value is 100. Default is 50.
             correlation_id: Optional correlation ID for request tracing
 
         Returns:
@@ -47,6 +54,14 @@ class DataVectorSearch(BaseDataVectorSearch):
                 file_id="your_file_id"
             )
 
+            # Get file chunks with custom pagination
+            chunks_response = client.data_vector_search.get_file_chunks(
+                data_store_id="your_data_store_id",
+                file_id="your_file_id",
+                page_number=2,
+                page_size=100
+            )
+
             # Access the chunks
             for chunk in chunks_response.chunks:
                 print(f"Chunk: {chunk.chunk}")
@@ -58,6 +73,8 @@ class DataVectorSearch(BaseDataVectorSearch):
         request_data = self._pre_get_file_chunks(
             data_store_id=data_store_id,
             file_id=file_id,
+            page_number=page_number,
+            page_size=page_size,
             correlation_id=correlation_id,
             api_version=ApiVersion.V1.value,
         )

airia/client/deployments/async_deployments.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from ...types._api_version import ApiVersion
 from ...types.api.deployments import GetDeploymentResponse, GetDeploymentsResponse
@@ -12,6 +12,11 @@ class AsyncDeployments(BaseDeployments):
 
     async def get_deployments(
         self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[Literal["ASC", "DESC"]] = None,
+        filter: Optional[str] = None,
         tags: Optional[List[str]] = None,
         is_recommended: Optional[bool] = None,
         project_id: Optional[str] = None,
@@ -26,6 +31,11 @@ class AsyncDeployments(BaseDeployments):
         about each deployment including associated pipelines, data sources, and user prompts.
 
         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: The direction of the sort, either "ASC" for ascending or "DESC" for descending
+            filter: The search filter
             tags: Optional list of tags to filter deployments by
             is_recommended: Optional filter by recommended status
             project_id: Optional filter by project id
@@ -42,16 +52,33 @@ class AsyncDeployments(BaseDeployments):
         Example:
             ```python
             client = AiriaAsyncClient(api_key="your-api-key")
+
+            # Basic usage with filtering
             deployments = await client.deployments.get_deployments(
                 tags=["production", "nlp"],
                 is_recommended=True
             )
+
+            # With pagination and sorting
+            deployments = await client.deployments.get_deployments(
+                page_number=1,
+                page_size=20,
+                sort_by="deploymentName",
+                sort_direction="ASC",
+                filter="text-analysis"
+            )
+
             print(f"Found {deployments.total_count} deployments")
             for deployment in deployments.items:
                 print(f"- {deployment.deployment_name}")
             ```
         """
         request_data = self._pre_get_deployments(
+            page_number=page_number,
+            page_size=page_size,
+            sort_by=sort_by,
+            sort_direction=sort_direction,
+            filter=filter,
             tags=tags,
             is_recommended=is_recommended,
             correlation_id=correlation_id,

airia/client/deployments/base_deployments.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union
+from typing import List, Literal, Optional, Union
 from urllib.parse import urljoin
 
 from ...types._api_version import ApiVersion
@@ -11,6 +11,11 @@ class BaseDeployments:
 
     def _pre_get_deployments(
         self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[Literal["ASC", "DESC"]] = None,
+        filter: Optional[str] = None,
         tags: Optional[List[str]] = None,
         is_recommended: Optional[bool] = None,
         correlation_id: Optional[str] = None,
@@ -23,6 +28,11 @@ class BaseDeployments:
         retrieval requests, including optional filtering by tags and recommendation status.
 
         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: The direction of the sort, either "ASC" for ascending or "DESC" for descending
+            filter: The search filter
             tags: Optional list of tags to filter deployments by
             is_recommended: Optional filter by recommended status
             correlation_id: Optional correlation ID for tracing
@@ -45,6 +55,16 @@ class BaseDeployments:
 
         # Build query parameters
         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 filter is not None:
+            params["Filter"] = filter
         if tags is not None:
             params["tags"] = tags
         if is_recommended is not None:

airia/client/deployments/sync_deployments.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from ...types._api_version import ApiVersion
 from ...types.api.deployments import GetDeploymentResponse, GetDeploymentsResponse
@@ -12,6 +12,11 @@ class Deployments(BaseDeployments):
 
     def get_deployments(
         self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[Literal["ASC", "DESC"]] = None,
+        filter: Optional[str] = None,
         tags: Optional[List[str]] = None,
         is_recommended: Optional[bool] = None,
         project_id: Optional[str] = None,
@@ -26,6 +31,11 @@ class Deployments(BaseDeployments):
         about each deployment including associated pipelines, data sources, and user prompts.
 
         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: The direction of the sort, either "ASC" for ascending or "DESC" for descending
+            filter: The search filter
             tags: Optional list of tags to filter deployments by
             is_recommended: Optional filter by recommended status
             project_id: Optional filter by project id
@@ -42,16 +52,33 @@ class Deployments(BaseDeployments):
         Example:
             ```python
             client = AiriaClient(api_key="your-api-key")
+
+            # Basic usage with filtering
             deployments = client.deployments.get_deployments(
                 tags=["production", "nlp"],
                 is_recommended=True
             )
+
+            # With pagination and sorting
+            deployments = client.deployments.get_deployments(
+                page_number=1,
+                page_size=20,
+                sort_by="deploymentName",
+                sort_direction="ASC",
+                filter="text-analysis"
+            )
+
             print(f"Found {deployments.total_count} deployments")
             for deployment in deployments.items:
                 print(f"- {deployment.deployment_name}")
             ```
         """
         request_data = self._pre_get_deployments(
+            page_number=page_number,
+            page_size=page_size,
+            sort_by=sort_by,
+            sort_direction=sort_direction,
+            filter=filter,
             tags=tags,
             is_recommended=is_recommended,
             correlation_id=correlation_id,

airia/client/pipeline_execution/async_pipeline_execution.py

@@ -3,8 +3,12 @@ from typing import Any, Dict, List, Literal, Optional, Type, Union, overload
 from pydantic import BaseModel
 
 from ...types._api_version import ApiVersion
-from ...types._structured_output import create_schema_system_message, parse_response_to_model
+from ...types._structured_output import (
+    create_schema_system_message,
+    parse_response_to_model,
+)
 from ...types.api.pipeline_execution import (
+    GetPipelineExecutionResponse,
     PipelineExecutionAsyncStreamedResponse,
     PipelineExecutionResponse,
     TemporaryAssistantAsyncStreamedResponse,
@@ -209,7 +213,9 @@ class AsyncPipelineExecution(BasePipelineExecution):
         modified_in_memory_messages = in_memory_messages
         if output_schema is not None:
             # Create a copy of in_memory_messages if it exists, otherwise create new list
-            modified_in_memory_messages = list(in_memory_messages) if in_memory_messages else []
+            modified_in_memory_messages = (
+                list(in_memory_messages) if in_memory_messages else []
+            )
             # Insert schema instruction as first system message
             schema_message = create_schema_system_message(output_schema)
             modified_in_memory_messages.insert(0, schema_message)
@@ -246,7 +252,9 @@ class AsyncPipelineExecution(BasePipelineExecution):
             response = PipelineExecutionResponse(**resp)
             # Parse response to Pydantic model if output_schema was provided
             if output_schema is not None and response.result:
-                response.result = parse_response_to_model(response.result, output_schema)
+                response.result = parse_response_to_model(
+                    response.result, output_schema
+                )
             return response
 
         return PipelineExecutionAsyncStreamedResponse(stream=resp)
@@ -440,7 +448,9 @@ class AsyncPipelineExecution(BasePipelineExecution):
         modified_in_memory_messages = in_memory_messages
         if output_schema is not None:
             # Create a copy of in_memory_messages if it exists, otherwise create new list
-            modified_in_memory_messages = list(in_memory_messages) if in_memory_messages else []
+            modified_in_memory_messages = (
+                list(in_memory_messages) if in_memory_messages else []
+            )
             # Insert schema instruction as first system message
             schema_message = create_schema_system_message(output_schema)
             modified_in_memory_messages.insert(0, schema_message)
@@ -487,5 +497,52 @@ class AsyncPipelineExecution(BasePipelineExecution):
         response = TemporaryAssistantResponse(**resp)
         # Parse response to Pydantic model if output_schema was provided
         if output_schema is not None and response.result:
-            response.result = parse_response_to_model(str(response.result), output_schema)
+            response.result = parse_response_to_model(
+                str(response.result), output_schema
+            )
         return response
+
+    async def get_pipeline_execution(
+        self, execution_id: str, correlation_id: Optional[str] = None
+    ) -> GetPipelineExecutionResponse:
+        """
+        Retrieve a pipeline execution result by execution ID asynchronously.
+
+        This method fetches the details of a specific pipeline execution using its
+        unique identifier. The response includes execution logs, step execution records,
+        timing information, and any errors that occurred during execution.
+
+        Args:
+            execution_id: The execution id (GUID format)
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            GetPipelineExecutionResponse: Pipeline execution details including logs and step records
+
+        Raises:
+            AiriaAPIError: If the API request fails or execution is not found
+            ValueError: If an invalid API version is provided
+
+        Example:
+            ```python
+            client = AiriaAsyncClient(api_key="your-api-key")
+            execution = await client.pipeline_execution.get_pipeline_execution("execution-id-123")
+            print(f"Execution ID: {execution.execution_id}")
+            print(f"Success: {execution.log_record_details.success}")
+            print(f"Duration: {execution.log_record_details.duration}")
+
+            # Iterate through step execution logs
+            if execution.step_execution_log_records:
+                for step in execution.step_execution_log_records:
+                    print(f"Step: {step.step_title} - Success: {step.success}")
+            ```
+        """
+        request_data = self._pre_get_pipeline_execution(
+            execution_id=execution_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        response = await self._request_handler.make_request("GET", request_data)
+
+        return GetPipelineExecutionResponse(**response)

airia/client/pipeline_execution/base_pipeline_execution.py

@@ -224,3 +224,42 @@ class BasePipelineExecution:
         )
 
         return request_data
+
+    def _pre_get_pipeline_execution(
+        self,
+        execution_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for retrieving a pipeline execution.
+
+        This internal method constructs the URL for pipeline execution retrieval
+        by ID using the specified API version.
+
+        Args:
+            execution_id: The execution id (GUID format)
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the pipeline execution 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}/PipelineExecution/{execution_id}",
+        )
+
+        request_data = self._request_handler.prepare_request(
+            url=url, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/pipeline_execution/sync_pipeline_execution.py

@@ -3,8 +3,12 @@ from typing import Any, Dict, List, Literal, Optional, Type, Union, overload
 from pydantic import BaseModel
 
 from ...types._api_version import ApiVersion
-from ...types._structured_output import create_schema_system_message, parse_response_to_model
+from ...types._structured_output import (
+    create_schema_system_message,
+    parse_response_to_model,
+)
 from ...types.api.pipeline_execution import (
+    GetPipelineExecutionResponse,
     PipelineExecutionResponse,
     PipelineExecutionStreamedResponse,
     TemporaryAssistantResponse,
@@ -208,7 +212,9 @@ class PipelineExecution(BasePipelineExecution):
         modified_in_memory_messages = in_memory_messages
         if output_schema is not None:
             # Create a copy of in_memory_messages if it exists, otherwise create new list
-            modified_in_memory_messages = list(in_memory_messages) if in_memory_messages else []
+            modified_in_memory_messages = (
+                list(in_memory_messages) if in_memory_messages else []
+            )
             # Insert schema instruction as first system message
             schema_message = create_schema_system_message(output_schema)
             modified_in_memory_messages.insert(0, schema_message)
@@ -245,7 +251,9 @@ class PipelineExecution(BasePipelineExecution):
             response = PipelineExecutionResponse(**resp)
             # Parse response to Pydantic model if output_schema was provided
             if output_schema is not None and response.result:
-                response.result = parse_response_to_model(response.result, output_schema)
+                response.result = parse_response_to_model(
+                    response.result, output_schema
+                )
             return response
 
         return PipelineExecutionStreamedResponse(stream=resp)
@@ -440,7 +448,9 @@ class PipelineExecution(BasePipelineExecution):
         modified_in_memory_messages = in_memory_messages
         if output_schema is not None:
             # Create a copy of in_memory_messages if it exists, otherwise create new list
-            modified_in_memory_messages = list(in_memory_messages) if in_memory_messages else []
+            modified_in_memory_messages = (
+                list(in_memory_messages) if in_memory_messages else []
+            )
             # Insert schema instruction as first system message
             schema_message = create_schema_system_message(output_schema)
             modified_in_memory_messages.insert(0, schema_message)
@@ -448,7 +458,9 @@ class PipelineExecution(BasePipelineExecution):
             output_configuration = None
 
         # Convert UUID objects to strings for API compatibility
-        conversation_id_str = str(conversation_id) if conversation_id else conversation_id
+        conversation_id_str = (
+            str(conversation_id) if conversation_id else conversation_id
+        )
         user_id_str = str(user_id) if user_id else user_id
         user_input_id_str = str(user_input_id) if user_input_id else user_input_id
 
@@ -492,5 +504,52 @@ class PipelineExecution(BasePipelineExecution):
         response = TemporaryAssistantResponse(**resp)
         # Parse response to Pydantic model if output_schema was provided
         if output_schema is not None and response.result:
-            response.result = parse_response_to_model(str(response.result), output_schema)
+            response.result = parse_response_to_model(
+                str(response.result), output_schema
+            )
         return response
+
+    def get_pipeline_execution(
+        self, execution_id: str, correlation_id: Optional[str] = None
+    ) -> GetPipelineExecutionResponse:
+        """
+        Retrieve a pipeline execution result by execution ID.
+
+        This method fetches the details of a specific pipeline execution using its
+        unique identifier. The response includes execution logs, step execution records,
+        timing information, and any errors that occurred during execution.
+
+        Args:
+            execution_id: The execution id (GUID format)
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            GetPipelineExecutionResponse: Pipeline execution details including logs and step records
+
+        Raises:
+            AiriaAPIError: If the API request fails or execution is not found
+            ValueError: If an invalid API version is provided
+
+        Example:
+            ```python
+            client = AiriaClient(api_key="your-api-key")
+            execution = client.pipeline_execution.get_pipeline_execution("execution-id-123")
+            print(f"Execution ID: {execution.execution_id}")
+            print(f"Success: {execution.log_record_details.success}")
+            print(f"Duration: {execution.log_record_details.duration}")
+
+            # Iterate through step execution logs
+            if execution.step_execution_log_records:
+                for step in execution.step_execution_log_records:
+                    print(f"Step: {step.step_title} - Success: {step.success}")
+            ```
+        """
+        request_data = self._pre_get_pipeline_execution(
+            execution_id=execution_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        response = self._request_handler.make_request("GET", request_data)
+
+        return GetPipelineExecutionResponse(**response)

airia/client/pipelines_config/async_pipelines_config.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Literal, Optional
 
 from ...types._api_version import ApiVersion
 from ...types.api.pipelines_config import (
@@ -126,20 +126,34 @@ class AsyncPipelinesConfig(BasePipelinesConfig):
         return ExportPipelineDefinitionResponse(**resp)
 
     async def get_pipelines_config(
-        self, project_id: Optional[str] = None, correlation_id: Optional[str] = None
+        self,
+        page_number: Optional[int] = None,
+        page_size: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_direction: Optional[Literal["ASC", "DESC"]] = None,
+        filter: Optional[str] = None,
+        project_id: Optional[str] = None,
+        model_credential_source_type: Optional[Literal["UserProvided", "Library"]] = None,
+        correlation_id: Optional[str] = None,
     ) -> GetPipelinesConfigResponse:
         """
-        Retrieve a list of pipeline configurations, optionally filtered by project ID.
+        Retrieve a list of pipeline configurations with optional filtering, pagination, and sorting.
 
         This method fetches a list of pipeline configurations including their
         deployment details, execution statistics, version information, and metadata.
-        The results can be filtered by project ID to retrieve only pipelines
-        belonging to a specific project.
+        The results can be filtered, paginated, and sorted using various parameters.
 
         Args:
+            page_number (int, optional): The page number to be fetched.
+            page_size (int, optional): The number of items per page.
+            sort_by (str, optional): Property to sort by.
+            sort_direction (str, optional): The direction of the sort, either "ASC" for ascending or "DESC" for descending.
+            filter (str, optional): The search filter.
             project_id (str, optional): The unique identifier of the project to filter
                 pipelines by. If not provided, pipelines from all accessible projects
                 will be returned.
+            model_credential_source_type (str, optional): Optional filter to return only pipelines
+                using models with specified source type ("UserProvided" or "Library").
             correlation_id (str, optional): A unique identifier for request tracing
                 and logging. If not provided, one will be automatically generated.
 
@@ -168,9 +182,19 @@ class AsyncPipelinesConfig(BasePipelinesConfig):
                 if pipeline.execution_stats:
                     print(f"Success count: {pipeline.execution_stats.success_count}")
 
-            # Get pipelines for a specific project
+            # Get pipelines with pagination and sorting
+            pipelines = await client.pipelines_config.get_pipelines_config(
+                page_number=1,
+                page_size=20,
+                sort_by="name",
+                sort_direction="ASC",
+                filter="classification"
+            )
+
+            # Get pipelines for a specific project with model source type filter
             project_pipelines = await client.pipelines_config.get_pipelines_config(
-                project_id="your_project_id"
+                project_id="your_project_id",
+                model_credential_source_type="UserProvided"
             )
             print(f"Project pipelines: {project_pipelines.total_count}")
             ```
@@ -181,7 +205,13 @@ class AsyncPipelinesConfig(BasePipelinesConfig):
             pipeline identifier.
         """
         request_data = self._pre_get_pipelines_config(
+            page_number=page_number,
+            page_size=page_size,
+            sort_by=sort_by,
+            sort_direction=sort_direction,
+            filter=filter,
             project_id=project_id,
+            model_credential_source_type=model_credential_source_type,
             correlation_id=correlation_id,
             api_version=ApiVersion.V1.value,
         )