pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/core/files/managers.py

@@ -1,3 +1,9 @@
+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
@@ -5,6 +11,7 @@ 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:
@@ -17,7 +24,7 @@ class FileManager:
             self,
             api_key: str = None,
             base_url: str = None,
-            alias: str = "default",
+            alias: str = None,
             organization_id: str = None,
             project_id: str = None
     ):
@@ -26,8 +33,26 @@ class FileManager:
             base_url,
             alias
         )
-        self.__organization_id = organization_id
-        self.__project_id = project_id
+        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,
@@ -36,20 +61,26 @@ class FileManager:
         """
         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,
+            organization_id=self.organization_id,
+            project_id=self.project_id,
             folder=file.folder,
             file_name=file.name,
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = FileResponseMapper.map_to_upload_file_response(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(
@@ -59,18 +90,24 @@ class FileManager:
         """
         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,
+            organization=self.organization_id,
+            project=self.project_id,
             file_id=file_id
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = FileResponseMapper.map_to_file(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(
@@ -80,18 +117,23 @@ class FileManager:
         """
         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 or failure of the operation.
+        :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,
+            organization=self.organization_id,
+            project=self.project_id,
             file_id=file_id
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = ResponseMapper.map_to_empty_response(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(
@@ -101,33 +143,82 @@ class FileManager:
         """
         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,
+            organization=self.organization_id,
+            project=self.project_id,
             file_id=file_id
         )
         if isinstance(response_data, dict) and "errors" in response_data:
-            result = ErrorMapper.map_to_error_list_response(response_data)
-        else:
-            result = 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.
+        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
+            organization=self.organization_id,
+            project=self.project_id
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = FileResponseMapper.map_to_file_list_response(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/responses.py

@@ -1,10 +1,11 @@
+from typing import Optional
 from pydantic.main import BaseModel
 
 
 class UploadFileResponse(BaseModel):
-    id: str
-    url: str
-    success: bool
+    id: Optional[str] = None
+    url: Optional[str] = None
+    success: Optional[bool] = None
 
     def to_dict(self):
         return {

pygeai/core/handlers.py

@@ -6,7 +6,16 @@ class ErrorHandler:
     @classmethod
     def has_errors(cls, response):
         error_found = False
-        if "errors" in response or "error" in response:
+        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

pygeai/core/llm/clients.py

@@ -1,41 +1,38 @@
-import json
-from json import JSONDecodeError
 
+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)
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
+        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)
-        response = self.api_service.get(endpoint=endpoint)
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
 
-        return result
+        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)
-        response = self.api_service.get(endpoint=endpoint)
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
 
-        return result
+        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,
@@ -47,14 +44,10 @@ class LlmClient(BaseClient):
             providerName=provider_name,
             modelNameOrId=model_name or model_id
         )
-        response = self.api_service.get(endpoint=endpoint)
-        try:
-            result = response.json()
-        except JSONDecodeError as e:
-            result = response.text
-
-        return result
-
-
 
+        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/models.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
 from typing import Optional, Literal, Any, List, Union, Iterator
 
 from pygeai.core import CustomBaseModel
@@ -247,23 +247,32 @@ class Project(CustomBaseModel):
 
 class RequestItem(CustomBaseModel):
     """
-    {
-      "assistant": "string",
-      "intent": "string",
-      "timestamp": "string",
-      "prompt": "string",
-      "output": "string",
-      "inputText": "string",
-      "status": "string"
-    }
+    Represents a request item with metadata about an API interaction.
+    Follows a JSON schema with camelCase aliases for external compatibility.
     """
+    api_token: str = Field(..., alias="apiToken")
     assistant: str = Field(..., alias="assistant")
+    cost: float = Field(..., alias="cost")
+    elapsed_time_ms: int = Field(..., alias="elapsedTimeMs")
+    end_timestamp: datetime = Field(..., alias="endTimestamp")
+    feedback: Optional[str] = Field(None, alias="feedback")
     intent: Optional[str] = Field(None, alias="intent")
-    timestamp: str = Field(..., alias="timestamp")
+    module: str = Field(..., alias="module")
     prompt: Optional[str] = Field(None, alias="prompt")
     output: Optional[str] = Field(None, alias="output")
     input_text: Optional[str] = Field(None, alias="inputText")
+    rag_sources_consulted: Optional[str] = Field(None, alias="ragSourcesConsulted")
+    session_id: str = Field(..., alias="sessionId")
+    start_timestamp: datetime = Field(..., alias="startTimestamp")
     status: str = Field(..., alias="status")
+    timestamp: datetime = Field(..., alias="timestamp")
+
+    @model_validator(mode="after")
+    def validate_status(self):
+        valid_statuses = {"succeeded", "failed", "pending"}
+        if self.status not in valid_statuses:
+            raise ValueError(f"Status must be one of {valid_statuses}")
+        return self
 
     def to_dict(self):
         return self.model_dump(by_alias=True, exclude_none=True)
@@ -681,3 +690,110 @@ class DataAnalystAssistant(Assistant):
 
 class ChatWithDataAssistant(Assistant):
     type: Literal["ChatWithData"] = "ChatWithData"
+
+
+class Role(CustomBaseModel):
+    """
+    {
+      "id": "string",
+      "name": "string",
+      "externalId": "string",
+      "type": "string",
+      "origin": "string"
+    }
+    """
+    id: str = Field(..., alias="id")
+    name: str = Field(..., alias="name")
+    external_id: Optional[str] = Field(None, alias="externalId")
+    type: Optional[str] = Field(None, alias="type")
+    origin: Optional[str] = Field(None, alias="origin")
+
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+    def __str__(self):
+        return str(self.to_dict())
+
+
+class Member(CustomBaseModel):
+    """
+    {
+      "email": "string",
+      "roles": [...]
+    }
+    """
+    email: str = Field(..., alias="email")
+    roles: Optional[List[Role]] = Field(default_factory=list, alias="roles")
+
+    @field_validator("roles", mode="before")
+    @classmethod
+    def normalize_roles(cls, value):
+        if isinstance(value, list):
+            return [Role.model_validate(item) if isinstance(item, dict) else item for item in value]
+        return value
+
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+    def __str__(self):
+        return str(self.to_dict())
+
+
+class ProjectMembership(CustomBaseModel):
+    """
+    {
+      "organizationId": "string",
+      "organizationName": "string",
+      "projectDescription": "string",
+      "projectId": "string",
+      "projectName": "string",
+      "roles": [...]
+    }
+    """
+    organization_id: Optional[str] = Field(None, alias="organizationId")
+    organization_name: Optional[str] = Field(None, alias="organizationName")
+    project_description: Optional[str] = Field(None, alias="projectDescription")
+    project_id: str = Field(..., alias="projectId")
+    project_name: str = Field(..., alias="projectName")
+    roles: Optional[List[Role]] = Field(default_factory=list, alias="roles")
+
+    @field_validator("roles", mode="before")
+    @classmethod
+    def normalize_roles(cls, value):
+        if isinstance(value, list):
+            return [Role.model_validate(item) if isinstance(item, dict) else item for item in value]
+        return value
+
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+    def __str__(self):
+        return str(self.to_dict())
+
+
+class OrganizationMembership(CustomBaseModel):
+    """
+    {
+      "isStationAvailable": true,
+      "organizationId": "string",
+      "organizationName": "string",
+      "projects": [...]
+    }
+    """
+    is_station_available: Optional[bool] = Field(None, alias="isStationAvailable")
+    organization_id: str = Field(..., alias="organizationId")
+    organization_name: str = Field(..., alias="organizationName")
+    projects: Optional[List[ProjectMembership]] = Field(default_factory=list, alias="projects")
+
+    @field_validator("projects", mode="before")
+    @classmethod
+    def normalize_projects(cls, value):
+        if isinstance(value, list):
+            return [ProjectMembership.model_validate(item) if isinstance(item, dict) else item for item in value]
+        return value
+
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+    def __str__(self):
+        return str(self.to_dict())

pygeai/core/plugins/clients.py

@@ -1,8 +1,11 @@
-from json import JSONDecodeError
 from typing import Optional, List, Dict
 
+from pygeai import logger
 from pygeai.core.base.clients import BaseClient
+from pygeai.core.common.exceptions import InvalidAPIResponseException
 from pygeai.core.plugins.endpoints import LIST_ASSISTANTS_PLUGINS_V1
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
 
 
 class PluginClient(BaseClient):
@@ -24,9 +27,6 @@ class PluginClient(BaseClient):
             endpoint=LIST_ASSISTANTS_PLUGINS_V1,
             params=params
         )
-        try:
-            result = response.json()
-        except JSONDecodeError:
-            result = response.text
+        validate_status_code(response)
+        return parse_json_response(response, f"list assistants for organization {organization_id} and project {project_id}")
 
-        return result

pygeai/core/rerank/clients.py

@@ -1,8 +1,11 @@
-import json
 from typing import Any, Union
 
+from pygeai import logger
 from pygeai.core.base.clients import BaseClient
+from pygeai.core.common.exceptions import InvalidAPIResponseException
 from pygeai.core.rerank.endpoints import RERANK_V1
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
 
 
 class RerankClient(BaseClient):
@@ -20,10 +23,13 @@ class RerankClient(BaseClient):
             "documents": documents,
             "top_n": top_n
         }
+
+        logger.debug(f"Generating rerank with data: {data}")
+
         response = self.api_service.post(
             endpoint=RERANK_V1,
             data=data
         )
-        result = response.json()
-        return result
+        validate_status_code(response)
+        return parse_json_response(response, "rerank chunks for query with model", query=query, model=model)
 

pygeai/core/rerank/managers.py

@@ -1,4 +1,5 @@
-from pygeai.core.base.mappers import ErrorMapper
+from pygeai import logger
+from pygeai.core.common.exceptions import APIError
 from pygeai.core.handlers import ErrorHandler
 from pygeai.core.rerank.clients import RerankClient
 from pygeai.core.rerank.mappers import RerankResponseMapper
@@ -7,7 +8,7 @@ from pygeai.core.rerank.models import RerankResponse
 
 class RerankManager:
 
-    def __init__(self, api_key: str = None, base_url: str = None, alias: str = "default"):
+    def __init__(self, api_key: str = None, base_url: str = None, alias: str = None):
         self.__client = RerankClient(api_key, base_url, alias)
 
     def rerank_chunks(
@@ -17,6 +18,20 @@ class RerankManager:
             documents: list[str],
             top_n: int = 3
     ) -> RerankResponse:
+        """
+        Reranks a list of documents based on their relevance to the given query.
+
+        This method sends a rerank request to the RerankClient using the specified
+        model, query, and list of documents. It processes the API response by
+        checking for errors and mapping the result into a structured RerankResponse.
+
+        :param query: str - The query string used to evaluate document relevance.
+        :param model: str - The identifier of the reranking model to use.
+        :param documents: list[str] - A list of document strings to be evaluated and reranked.
+        :param top_n: int, optional - The number of top-ranked documents to return. Defaults to 3.
+        :return: RerankResponse - The structured reranking response containing the top documents and scores.
+        :raises APIError: If the API returns errors.
+        """
         response_data = self.__client.rerank_chunks(
             query=query,
             model=model,
@@ -24,7 +39,9 @@ class RerankManager:
             top_n=top_n
         )
         if ErrorHandler.has_errors(response_data):
-            result = ErrorHandler.extract_error(response_data)
-        else:
-            result = RerankResponseMapper.map_to_rerank_response(response_data)
+            error = ErrorHandler.extract_error(response_data)
+            logger.error(f"Error received while reranking chunks: {error}")
+            raise APIError(f"Error received while reranking chunks: {error}")
+
+        result = RerankResponseMapper.map_to_rerank_response(response_data)
         return result