pygeai 0.1.6__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/core/files/managers.py

@@ -0,0 +1,224 @@
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from pygeai import logger
+from pygeai.admin.clients import AdminClient
+from pygeai.core.base.mappers import ErrorMapper, ResponseMapper
+from pygeai.core.base.responses import EmptyResponse
+from pygeai.core.files.clients import FileClient
+from pygeai.core.files.models import UploadFile, File, FileList
+from pygeai.core.files.mappers import FileResponseMapper
+from pygeai.core.files.responses import UploadFileResponse
+from pygeai.core.handlers import ErrorHandler
+from pygeai.core.common.exceptions import APIError
+
+
+class FileManager:
+    """
+    Manages file-related operations such as uploading, retrieving, and deleting files
+    within an organization and project.
+    """
+
+    def __init__(
+            self,
+            api_key: str = None,
+            base_url: str = None,
+            alias: str = None,
+            organization_id: str = None,
+            project_id: str = None
+    ):
+        self.__client = FileClient(
+            api_key,
+            base_url,
+            alias
+        )
+        self.organization_id = self.__get_organization_id() if not organization_id else organization_id
+        self.project_id = self.__get_project_id() if not project_id else project_id
+
+    def __get_organization_id(self):
+        response = None
+        try:
+            response = AdminClient().validate_api_token()
+            return response.get("organizationId")
+        except Exception as e:
+            logger.error(f"Error retrieving organization_id from GEAI. Response: {response}: {e}")
+            raise APIError(f"Error retrieving organization_id from GEAI: {e}")
+
+    def __get_project_id(self):
+        response = None
+        try:
+            response = AdminClient().validate_api_token()
+            return response.get("projectId")
+        except Exception as e:
+            logger.error(f"Error retrieving project_id from GEAI. Response: {response}: {e}")
+            raise APIError(f"Error retrieving project_id from GEAI: {e}")
+
+    def upload_file(
+            self,
+            file: UploadFile
+    ) -> UploadFileResponse:
+        """
+        Uploads a file to the specified organization and project.
+
+        This method sends a request to the file client to upload a file based on the provided
+        `UploadFile` object.
+
+        :param file: UploadFile - The file object containing file path, name, and folder details.
+        :return: UploadFileResponse - The response object containing the uploaded file details.
+        :raises APIError: If the API returns errors.
+        """
+        response_data = self.__client.upload_file(
+            file_path=file.path,
+            organization_id=self.organization_id,
+            project_id=self.project_id,
+            folder=file.folder,
+            file_name=file.name,
+        )
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while uploading file: {error}")
+            raise APIError(f"Error received while uploading file: {error}")
+
+        result = FileResponseMapper.map_to_upload_file_response(response_data)
+        return result
+
+    def get_file_data(
+            self,
+            file_id: str
+    ) -> File:
+        """
+        Retrieves metadata of a specific file by its ID.
+
+        This method sends a request to the file client to retrieve metadata for a file
+        identified by `file_id`.
+
+        :param file_id: str - The unique identifier of the file.
+        :return: File - A file object containing metadata about the requested file.
+        :raises APIError: If the API returns errors.
+        """
+        response_data = self.__client.get_file(
+            organization=self.organization_id,
+            project=self.project_id,
+            file_id=file_id
+        )
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving file data: {error}")
+            raise APIError(f"Error received while retrieving file data: {error}")
+
+        result = FileResponseMapper.map_to_file(response_data)
+        return result
+
+    def delete_file(
+            self,
+            file_id: str
+    ) -> EmptyResponse:
+        """
+        Deletes a file from the specified organization and project.
+
+        This method sends a request to the file client to delete a file identified by `file_id`.
+
+        :param file_id: str - The unique identifier of the file to be deleted.
+        :return: EmptyResponse - Response indicating the success of the operation.
+        :raises APIError: If the API returns errors.
+        """
+        response_data = self.__client.delete_file(
+            organization=self.organization_id,
+            project=self.project_id,
+            file_id=file_id
+        )
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while deleting file: {error}")
+            raise APIError(f"Error received while deleting file: {error}")
+
+        result = ResponseMapper.map_to_empty_response(response_data or "File deleted successfully")
+        return result
+
+    def get_file_content(
+            self,
+            file_id: str
+    ) -> bytes:
+        """
+        Retrieves the raw content of a specific file.
+
+        This method sends a request to the file client to retrieve the binary content of a file
+        identified by `file_id`.
+
+        :param file_id: str - The unique identifier of the file.
+        :return: bytes - The binary content of the file.
+        :raises APIError: If the API returns errors.
+        """
+        response_data = self.__client.get_file_content(
+            organization=self.organization_id,
+            project=self.project_id,
+            file_id=file_id
+        )
+        if isinstance(response_data, dict) and "errors" in response_data:
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving file content: {error}")
+            raise APIError(f"Error received while retrieving file content: {error}")
+
+        result = response_data
+        return result
+
+    def get_file_list(self) -> FileList:
+        """
+        Retrieves a list of all files associated with a given organization and project.
+
+        This method queries the file client to fetch a list of files for the specified
+        organization and project.
+
+        :return: FileList - A list of file objects associated with the organization and project.
+        :raises APIError: If the API returns errors.
+        """
+        response_data = self.__client.get_file_list(
+            organization=self.organization_id,
+            project=self.project_id
+        )
+        if ErrorHandler.has_errors(response_data):
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while retrieving file list: {error}")
+            raise APIError(f"Error received while retrieving file list: {error}")
+
+        result = FileResponseMapper.map_to_file_list_response(response_data)
+        return result
+
+    def upload_file_from_content(
+            self,
+            file_name: str,
+            content: bytes,
+            folder: Optional[str] = None
+    ) -> UploadFileResponse:
+        """
+        Uploads a file from binary content to the specified organization and project.
+
+        This method creates a temporary file from the provided content, uploads it,
+        and then cleans up the temporary file.
+
+        :param file_name: str - The name for the uploaded file.
+        :param content: bytes - The binary content of the file.
+        :param folder: str, optional - Destination folder (default is None, which means temporary storage).
+        :return: UploadFileResponse - The response object containing the uploaded file details.
+        :raises APIError: If the API returns errors.
+        """
+        temp_file = None
+        try:
+            suffix = Path(file_name).suffix or ""
+            with tempfile.NamedTemporaryFile(mode='wb', suffix=suffix, delete=False) as temp_file:
+                temp_file.write(content)
+                temp_file_path = temp_file.name
+
+            upload_file = UploadFile(
+                path=temp_file_path,
+                name=file_name,
+                folder=folder
+            )
+            return self.upload_file(upload_file)
+        finally:
+            if temp_file:
+                try:
+                    Path(temp_file_path).unlink(missing_ok=True)
+                except Exception as e:
+                    logger.warning(f"Failed to delete temporary file {temp_file_path}: {e}")

pygeai/core/files/mappers.py

@@ -0,0 +1,44 @@
+from pygeai.core.files.models import FileList, File
+from pygeai.core.files.responses import UploadFileResponse
+
+
+class FileResponseMapper:
+
+    @classmethod
+    def map_to_upload_file_response(cls, data: dict) -> UploadFileResponse:
+        return UploadFileResponse(
+            id=data.get('dataFileId'),
+            url=data.get('dataFileUrl'),
+            success=data.get('success')
+        )
+
+    @classmethod
+    def map_to_file_list_response(cls, data: dict) -> FileList:
+        file_list = cls.map_to_file_list(data)
+
+        return FileList(
+            files=file_list
+        )
+
+    @classmethod
+    def map_to_file_list(cls, data: dict) -> list[File]:
+        file_list = list()
+        files = data.get('dataFiles')
+        if files is not None and any(files):
+            for file_data in files:
+                file = cls.map_to_file(file_data)
+                file_list.append(file)
+
+        return file_list
+
+    @classmethod
+    def map_to_file(cls, data: dict) -> File:
+        return File(
+            id=data.get('DataFileId') or data.get('dataFileId'),
+            name=data.get('DataFileName') or data.get('dataFileName'),
+            extension=data.get('DataFileExtension') or data.get('dataFileExtension'),
+            purpose=data.get('DataFilePurpose') or data.get('dataFilePurpose'),
+            size=data.get('DataFileSize') or data.get('dataFileSize'),
+            url=data.get('DataFileUrl') or data.get('dataFileUrl')
+
+        )

pygeai/core/files/models.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from pydantic.main import BaseModel
+
+
+class BaseFile(BaseModel):
+    id: Optional[str] = None
+    name: Optional[str] = None
+
+
+class UploadFile(BaseFile):
+    path: str
+    folder: Optional[str] = None
+
+
+class File(BaseFile):
+    extension: Optional[str] = None
+    purpose: Optional[str] = None
+    size: Optional[int] = 0
+    url: Optional[str] = None
+
+
+class FileList(BaseModel):
+    files: list[File] = []

pygeai/core/files/responses.py

@@ -0,0 +1,19 @@
+from typing import Optional
+from pydantic.main import BaseModel
+
+
+class UploadFileResponse(BaseModel):
+    id: Optional[str] = None
+    url: Optional[str] = None
+    success: Optional[bool] = None
+
+    def to_dict(self):
+        return {
+            'dataFileId': self.id,
+            'dataFileUrl': self.url,
+            'success': self.success
+        }
+
+    def __str__(self):
+        data = self.to_dict()
+        return str(data)

pygeai/core/handlers.py

@@ -0,0 +1,32 @@
+from pygeai.core.base.mappers import ErrorMapper
+
+
+class ErrorHandler:
+
+    @classmethod
+    def has_errors(cls, response):
+        error_found = False
+        if (
+                "errors" in response or
+                "error" in response or
+                (
+                        "message" in response and
+                        isinstance(response.get("message"), list) and
+                        len(response.get("message")) > 0 and
+                        response.get("message")[0].get("type") == "error"
+                )
+        ):
+            error_found = True
+
+        return error_found
+
+    @classmethod
+    def extract_error(cls, response):
+        if "errors" in response:
+            result = ErrorMapper.map_to_error_list_response(response)
+        elif "error" in response:
+            result = ErrorMapper.map_to_error(response.get('error'))
+        else:
+            result = response
+
+        return result

pygeai/core/llm/clients.py

@@ -0,0 +1,53 @@
+
+from pygeai import logger
+from pygeai.core.base.clients import BaseClient
+from pygeai.core.common.exceptions import InvalidAPIResponseException
+from pygeai.core.llm.endpoints import GET_PROVIDER_LIST_V2, GET_PROVIDER_DATA_V2, GET_PROVIDER_MODELS_V2, \
+    GET_MODEL_DATA_V2
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
+
+
+class LlmClient(BaseClient):
+
+    def get_provider_list(self) -> dict:
+        logger.debug("Obtaining provider list")
+        response = self.api_service.get(endpoint=GET_PROVIDER_LIST_V2)
+        validate_status_code(response)
+        return parse_json_response(response, "obtain provider list")
+
+    def get_provider_data(self, provider_name: str) -> dict:
+        endpoint = GET_PROVIDER_DATA_V2.format(providerName=provider_name)
+
+        logger.debug(f"Obtaining provider data for {provider_name}")
+
+        response = self.api_service.get(endpoint=endpoint)
+        validate_status_code(response)
+        return parse_json_response(response, "obtain provider data", provider_name=provider_name)
+
+    def get_provider_models(self, provider_name: str) -> dict:
+        endpoint = GET_PROVIDER_MODELS_V2.format(providerName=provider_name)
+
+        logger.debug(f"Obtaining provider models for {provider_name}")
+
+        response = self.api_service.get(endpoint=endpoint)
+        validate_status_code(response)
+        return parse_json_response(response, "obtain provider models", provider_name=provider_name)
+
+    def get_model_data(
+            self,
+            provider_name: str,
+            model_name: str = None,
+            model_id: str = None
+    ) -> dict:
+        endpoint = GET_MODEL_DATA_V2.format(
+            providerName=provider_name,
+            modelNameOrId=model_name or model_id
+        )
+
+        logger.debug(f"Obtaining model data for {provider_name}/{model_name or model_id}")
+
+        response = self.api_service.get(endpoint=endpoint)
+        model_identifier = model_name or model_id
+        validate_status_code(response)
+        return parse_json_response(response, f"obtain model data for {provider_name}/{model_identifier}")

pygeai/core/llm/endpoints.py

@@ -0,0 +1,4 @@
+GET_PROVIDER_LIST_V2 = "v2/llm/providers"	 # GET -> Gets a list of available LLM providers.
+GET_PROVIDER_DATA_V2 = "v2/llm/providers/{providerName}"  # GET -> Gets specific data for a provider.
+GET_PROVIDER_MODELS_V2 = "v2/llm/providers/{providerName}/models"  # GET -> Gets a list of models for a specific provider.
+GET_MODEL_DATA_V2 = "v2/llm/providers/{providerName}/models/{modelNameOrId}"  # GET -> Gets data for a specific model.