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

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)

airia/client/project/base_project.py

@@ -0,0 +1,74 @@
+from typing import Optional, Union
+from urllib.parse import urljoin
+
+from ...types._api_version import ApiVersion
+from .._request_handler import AsyncRequestHandler, RequestHandler
+
+
+class BaseProject:
+    def __init__(self, request_handler: Union[RequestHandler, AsyncRequestHandler]):
+        self._request_handler = request_handler
+
+    def _pre_get_projects(
+        self,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for getting projects endpoint.
+
+        Args:
+            correlation_id: Optional correlation ID for tracing
+            api_version: API version to use for the request
+
+        Returns:
+            RequestData: Prepared request data for the projects 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}/Project/paginated"
+        )
+        request_data = self._request_handler.prepare_request(
+            url, correlation_id=correlation_id
+        )
+
+        return request_data
+
+    def _pre_get_project(
+        self,
+        project_id: str,
+        correlation_id: Optional[str] = None,
+        api_version: str = ApiVersion.V1.value,
+    ):
+        """
+        Prepare request data for getting a single project endpoint.
+
+        Args:
+            project_id: The project identifier (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 project 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}/Project/{project_id}"
+        )
+        request_data = self._request_handler.prepare_request(
+            url, correlation_id=correlation_id
+        )
+
+        return request_data

airia/client/project/sync_project.py

@@ -0,0 +1,120 @@
+from typing import List, Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.project import ProjectItem
+from .._request_handler import RequestHandler
+from .base_project import BaseProject
+
+
+class Project(BaseProject):
+    def __init__(self, request_handler: RequestHandler):
+        super().__init__(request_handler)
+
+    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 AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # Get all accessible projects
+            projects = 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 = 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"]]
+
+    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 AiriaClient
+
+            client = AiriaClient(api_key="your_api_key")
+
+            # Get a specific project by ID
+            project = 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 = self._request_handler.make_request("GET", request_data)
+
+        return ProjectItem(**resp)

airia/client/store/__init__.py

@@ -0,0 +1,4 @@
+from .async_store import AsyncStore
+from .sync_store import Store
+
+__all__ = ["Store", "AsyncStore"]

airia/client/store/async_store.py

@@ -0,0 +1,377 @@
+from typing import Optional
+
+from ...types._api_version import ApiVersion
+from ...types.api.store import File, GetFileResponse, GetFilesResponse
+from .._request_handler import AsyncRequestHandler
+from .base_store import BaseStore
+
+
+class AsyncStore(BaseStore):
+    def __init__(self, request_handler: AsyncRequestHandler):
+        super().__init__(request_handler)
+
+    async def upload_file(
+        self,
+        store_connector_id: str,
+        project_id: str,
+        file_path: str,
+        folder_id: Optional[str] = None,
+        pending_ingestion: bool = True,
+        correlation_id: Optional[str] = None,
+    ) -> File:
+        """
+        Upload a file to the Airia store asynchronously.
+
+        This method uploads a file to the specified store connector and project,
+        with optional folder organization and ingestion settings.
+
+        Args:
+            store_connector_id: The unique identifier of the store connector (GUID format)
+            project_id: The unique identifier of the project (GUID format)
+            file_path: Path to the file on disk
+            folder_id: Optional folder identifier for organizing the file (GUID format)
+            pending_ingestion: Whether the file should be marked as pending ingestion. Default is True.
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            File: object containing details about the uploaded file.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The store_connector_id doesn't exist (404)
+                - The project_id doesn't exist (404)
+                - The folder_id is invalid (400)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+            ValueError: If required parameters are missing or invalid
+
+        Example:
+            ```python
+            import asyncio
+            from airia import AiriaAsyncClient
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # Upload file
+                uploaded_file = await client.store.upload_file(
+                    store_connector_id="your_store_connector_id",
+                    project_id="your_project_id",
+                    file_path="document.pdf"
+                )
+
+                # Upload with folder organization
+                uploaded_file = await client.store.upload_file(
+                    store_connector_id="your_store_connector_id",
+                    project_id="your_project_id",
+                    file_path="document.pdf",
+                    folder_id="your_folder_id"
+                )
+
+            asyncio.run(main())
+            ```
+        """
+        request_data = self._pre_upload_file(
+            store_connector_id=store_connector_id,
+            project_id=project_id,
+            file_path=file_path,
+            folder_id=folder_id,
+            pending_ingestion=pending_ingestion,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        try:
+            response = await self._request_handler.make_request_multipart(
+                "POST", request_data
+            )
+            return File(**response)
+        finally:
+            request_data.files["File"][1].close()
+
+    async def update_file(
+        self,
+        store_connector_id: str,
+        store_file_id: str,
+        project_id: str,
+        file_path: str,
+        pending_ingestion: bool = True,
+        correlation_id: Optional[str] = None,
+    ) -> str:
+        """
+        Update an existing file in the Airia store asynchronously.
+
+        This method updates an existing file in the specified store connector and project,
+        with optional ingestion settings.
+
+        Args:
+            store_connector_id: The unique identifier of the store connector (GUID format)
+            store_file_id: The unique identifier of the file to update (GUID format)
+            project_id: The unique identifier of the project (GUID format)
+            file_path: Path to the file on disk
+            pending_ingestion: Whether the file should be marked as pending ingestion. Default is True.
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            The File ID of the updated file.
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The store_connector_id doesn't exist (404)
+                - The store_file_id doesn't exist (404)
+                - The project_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+            ValueError: If required parameters are missing or invalid
+
+        Example:
+            ```python
+            import asyncio
+            from airia import AiriaAsyncClient
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # Update existing file
+                updated_file_id = await client.store.update_file(
+                    store_connector_id="your_store_connector_id",
+                    store_file_id="your_store_file_id",
+                    project_id="your_project_id",
+                    file_path="document.pdf"
+                )
+
+            asyncio.run(main())
+            ```
+        """
+        request_data = self._pre_update_file(
+            store_connector_id=store_connector_id,
+            store_file_id=store_file_id,
+            project_id=project_id,
+            file_path=file_path,
+            pending_ingestion=pending_ingestion,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        try:
+            response = await self._request_handler.make_request_multipart(
+                "PUT", request_data
+            )
+            return response["fileId"]
+        finally:
+            request_data.files["File"][1].close()
+
+    async def get_file(
+        self,
+        project_id: str,
+        file_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> GetFileResponse:
+        """
+        Retrieve a file from the Airia store asynchronously.
+
+        This method retrieves file information, download URL, and preview information
+        for a specific file in the given project.
+
+        Args:
+            project_id: The unique identifier of the project (GUID format)
+            file_id: The unique identifier of the file (GUID format)
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            GetFileResponse: File information including metadata, download info, and preview info
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The project_id doesn't exist (404)
+                - The file_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+            ValueError: If required parameters are missing or invalid
+
+        Example:
+            ```python
+            import asyncio
+            from airia import AiriaAsyncClient
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # Get file information
+                file_info = await client.store.get_file(
+                    project_id="your_project_id",
+                    file_id="your_file_id"
+                )
+
+                # Access file metadata
+                if file_info.file:
+                    print(f"File name: {file_info.file.name}")
+                    print(f"File size: {file_info.file.size}")
+                    print(f"Status: {file_info.file.status}")
+
+                # Access download URL
+                if file_info.downloadInfo:
+                    print(f"Download URL: {file_info.downloadInfo.url}")
+
+                # Access preview information
+                if file_info.previewInfo:
+                    print(f"Preview URL: {file_info.previewInfo.previewUrl}")
+
+            asyncio.run(main())
+            ```
+
+        Note:
+            The response includes three optional components:
+            - file: File metadata and processing status
+            - downloadInfo: Direct download URL for the file
+            - previewInfo: Preview URL and connector information
+        """
+        request_data = self._pre_get_file(
+            project_id=project_id,
+            file_id=file_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        response = await self._request_handler.make_request(
+            "GET", request_data, return_json=True
+        )
+
+        return GetFileResponse(**response)
+
+    async def get_files(
+        self,
+        project_id: str,
+        store_connector_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> GetFilesResponse:
+        """
+        Retrieve all files from a store connector in the Airia store asynchronously.
+
+        This method retrieves information about all files in the specified store connector
+        and project, including file metadata, download URLs, and processing status.
+
+        Args:
+            project_id: The unique identifier of the project (GUID format)
+            store_connector_id: The unique identifier of the store connector (GUID format)
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            GetFilesResponse: List of files with metadata, download info, and total count
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The project_id doesn't exist (404)
+                - The store_connector_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+            ValueError: If required parameters are missing or invalid
+
+        Example:
+            ```python
+            import asyncio
+            from airia import AiriaAsyncClient
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # Get all files from a store connector
+                files_response = await client.store.get_files(
+                    project_id="your_project_id",
+                    store_connector_id="your_store_connector_id"
+                )
+
+                # Access files list
+                if files_response.files:
+                    for file in files_response.files:
+                        print(f"File: {file.name}, Status: {file.status}, Size: {file.size}")
+
+                # Access download URLs
+                if files_response.downloadInfos:
+                    for download_info in files_response.downloadInfos:
+                        print(f"File ID: {download_info.fileId}, URL: {download_info.url}")
+
+                # Access total count
+                print(f"Total files: {files_response.totalCount}")
+
+            asyncio.run(main())
+            ```
+
+        Note:
+            The response includes:
+            - files: List of file metadata and processing status
+            - downloadInfos: List of direct download URLs for files
+            - totalCount: Total number of files in the store connector
+        """
+        request_data = self._pre_get_files(
+            project_id=project_id,
+            store_connector_id=store_connector_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        response = await self._request_handler.make_request(
+            "GET", request_data, return_json=True
+        )
+
+        return GetFilesResponse(**response)
+
+    async def delete_file(
+        self,
+        project_id: str,
+        file_id: str,
+        correlation_id: Optional[str] = None,
+    ) -> None:
+        """
+        Delete a file from the Airia store asynchronously.
+
+        This method deletes a specific file from the given project.
+
+        Args:
+            project_id: The unique identifier of the project (GUID format)
+            file_id: The unique identifier of the file to delete (GUID format)
+            correlation_id: Optional correlation ID for request tracing
+
+        Returns:
+            None
+
+        Raises:
+            AiriaAPIError: If the API request fails, including cases where:
+                - The project_id doesn't exist (404)
+                - The file_id doesn't exist (404)
+                - Authentication fails (401)
+                - Access is forbidden (403)
+                - Server errors (5xx)
+            ValueError: If required parameters are missing or invalid
+
+        Example:
+            ```python
+            import asyncio
+            from airia import AiriaAsyncClient
+
+            async def main():
+                client = AiriaAsyncClient(api_key="your_api_key")
+
+                # Delete a file
+                await client.store.delete_file(
+                    project_id="your_project_id",
+                    file_id="your_file_id"
+                )
+
+            asyncio.run(main())
+            ```
+        """
+        request_data = self._pre_delete_file(
+            project_id=project_id,
+            file_id=file_id,
+            correlation_id=correlation_id,
+            api_version=ApiVersion.V1.value,
+        )
+
+        await self._request_handler.make_request(
+            "DELETE", request_data, return_json=False
+        )