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

pygeai/core/plugins/clients.py

@@ -0,0 +1,32 @@
+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):
+    """
+    Client for interacting with plugin endpoints of the API.
+    """
+
+    def list_assistants(
+        self,
+        organization_id: str,
+        project_id: str
+    ) -> dict:
+        params = {
+            "organization": organization_id,
+            "project": project_id,
+        }
+
+        response = self.api_service.get(
+            endpoint=LIST_ASSISTANTS_PLUGINS_V1,
+            params=params
+        )
+        validate_status_code(response)
+        return parse_json_response(response, f"list assistants for organization {organization_id} and project {project_id}")
+

pygeai/core/plugins/endpoints.py

@@ -0,0 +1 @@
+LIST_ASSISTANTS_PLUGINS_V1 = "v1/plugins"    # GET -> Obtain the list of assistants permitted to access in a particular organization and project.

pygeai/core/plugins/models.py

@@ -0,0 +1,86 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List, Literal
+from uuid import UUID
+
+from pygeai.core import CustomBaseModel
+
+
+class PluginBase(CustomBaseModel):
+    can_regenerate_answer: bool = Field(..., alias="canRegenerateAnswer")
+    can_show_preview: bool = Field(..., alias="canShowPreview")
+    full_conversation: bool = Field(..., alias="fullConversation")
+    max_output_tokens: int = Field(..., alias="maxOutputTokens")
+    must_trigger_initial_message: bool = Field(..., alias="mustTriggerInitialMessage")
+    plugin_id: str = Field(..., alias="pluginId")
+    plugin_name: str = Field(..., alias="pluginName")
+    plugin_type: str = Field(..., alias="pluginType")
+    share_scope: str = Field(..., alias="shareScope")
+    streams: bool = Field(..., alias="streams")
+    supports_raw_html: bool = Field(..., alias="supportsRawHtml")
+    upload_files: bool = Field(..., alias="uploadFiles")
+    upload_max_file_count: int = Field(..., alias="uploadMaxFileCount")
+    upload_max_file_size: int = Field(..., alias="uploadMaxFileSize")
+    plugin_description: Optional[str] = Field(None, alias="pluginDescription")
+    temperature: Optional[float] = Field(None, alias="temperature")
+
+    class Config:
+        populate_by_name = True
+
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+    def __str__(self):
+        return str(self.to_dict())
+
+
+class DataAnalystPlugin(PluginBase):
+    model_id: UUID = Field(..., alias="modelId")
+    model_name: str = Field(..., alias="modelName")
+    provider_name: str = Field(..., alias="providerName")
+
+
+class TextPromptAssistantPlugin(PluginBase):
+    input_moderation: bool = Field(..., alias="inputModeration")
+    llm_output: bool = Field(..., alias="llmOutput")
+    max_token_send_limit: int = Field(..., alias="maxTokenSendLimit")
+    model_id: UUID = Field(..., alias="modelId")
+    model_name: str = Field(..., alias="modelName")
+    prompt_injection: bool = Field(..., alias="promptInjection")
+    provider_name: str = Field(..., alias="providerName")
+    supported_categories: str = Field(..., alias="supportedCategories")
+    supported_file_extensions: str = Field(..., alias="supportedFileExtensions")
+    supports_multimodal: bool = Field(..., alias="supportsMultimodal")
+    supports_function_calling: Optional[bool] = Field(None, alias="supportsFunctionCalling")
+    supports_tool_calling: Optional[bool] = Field(None, alias="supportsToolCalling")
+    plugin_icon: Optional[str] = Field(None, alias="pluginIcon")
+
+
+class RAGPlugin(CustomBaseModel):
+    pass
+
+
+class AgentPlugin(CustomBaseModel):
+    max_token_send_limit: Optional[int] = Field(None, alias="maxTokenSendLimit")
+    model_id: Optional[UUID] = Field(None, alias="modelId")
+    model_name: Optional[str] = Field(None, alias="modelName")
+    provider_name: Optional[str] = Field(None, alias="providerName")
+    supported_categories: Optional[str] = Field(None, alias="supportedCategories")
+    supported_file_extensions: Optional[str] = Field(None, alias="supportedFileExtensions")
+    supports_function_calling: Optional[bool] = Field(None, alias="supportsFunctionCalling")
+    supports_multimodal: Optional[bool] = Field(None, alias="supportsMultimodal")
+    supports_tool_calling: Optional[bool] = Field(None, alias="supportsToolCalling")
+    plugin_icon: Optional[str] = Field(None, alias="pluginIcon")
+
+
+class PluginsResponse(CustomBaseModel):
+    plugins: List[PluginBase] = Field(..., alias="plugins")
+
+    class Config:
+        populate_by_name = True
+
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+    def __str__(self):
+        return str(self.to_dict())
+

pygeai/core/rerank/clients.py

@@ -0,0 +1,35 @@
+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):
+
+    def rerank_chunks(
+            self,
+            query: str,
+            model: str,
+            documents: list[str],
+            top_n: int = 3
+    ) -> dict:
+        data = {
+            "query": query,
+            "model": model,
+            "documents": documents,
+            "top_n": top_n
+        }
+
+        logger.debug(f"Generating rerank with data: {data}")
+
+        response = self.api_service.post(
+            endpoint=RERANK_V1,
+            data=data
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "rerank chunks for query with model", query=query, model=model)
+

pygeai/core/rerank/endpoints.py

@@ -0,0 +1 @@
+RERANK_V1 = "/rerank"   # POST -> Reranks a list of document chunks based on a query.

pygeai/core/rerank/managers.py

@@ -0,0 +1,47 @@
+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
+from pygeai.core.rerank.models import RerankResponse
+
+
+class RerankManager:
+
+    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(
+            self,
+            query: str,
+            model: str,
+            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,
+            documents=documents,
+            top_n=top_n
+        )
+        if ErrorHandler.has_errors(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

pygeai/core/rerank/mappers.py

@@ -0,0 +1,23 @@
+from pygeai.core.rerank.models import RerankResponse, RerankResult, RerankMetaData, ApiVersion, BilledUnits
+
+
+class RerankResponseMapper:
+
+    @classmethod
+    def map_to_rerank_response(cls, data: dict) -> RerankResponse:
+        return RerankResponse(
+            id=data.get("id"),
+            results=cls.map_to_rerank_results(data.get("results", [])),
+            meta=cls.map_to_rerank_metadata(data.get("meta", {}))
+        )
+
+    @classmethod
+    def map_to_rerank_results(cls, results: list) -> list[RerankResult]:
+        return [RerankResult(index=item["index"], relevance_score=item["relevance_score"]) for item in results]
+
+    @classmethod
+    def map_to_rerank_metadata(cls, data: dict) -> RerankMetaData:
+        return RerankMetaData(
+            api_version=ApiVersion(version=data.get("api_version", {}).get("version", "")),
+            billed_units=BilledUnits(search_units=data.get("billed_units", {}).get("search_units", 0))
+        )

pygeai/core/rerank/models.py

@@ -0,0 +1,27 @@
+from typing import List
+
+from pydantic import BaseModel
+
+
+class RerankResult(BaseModel):
+    index: int
+    relevance_score: float
+
+
+class ApiVersion(BaseModel):
+    version: str
+
+
+class BilledUnits(BaseModel):
+    search_units: int
+
+
+class RerankMetaData(BaseModel):
+    api_version: ApiVersion
+    billed_units: BilledUnits
+
+
+class RerankResponse(BaseModel):
+    id: str
+    results: List[RerankResult]
+    meta: RerankMetaData

pygeai/core/responses.py

@@ -0,0 +1,104 @@
+from typing import Optional, List
+
+from pydantic.main import BaseModel
+
+from pygeai.core.models import Project, Assistant, ChatMessage
+
+
+class AssistantResponse(BaseModel):
+    assistant: Assistant
+
+
+class NewAssistantResponse(BaseModel):
+    assistant: Optional[Assistant] = None
+    project: Optional[Project] = None
+
+
+class TokenDetails(BaseModel):
+    reasoning_tokens: Optional[int] = None
+    cached_tokens: Optional[int] = None
+
+
+class UsageDetails(BaseModel):
+    completion_tokens: int
+    prompt_tokens: int
+    total_cost: float
+    completion_tokens_details: Optional[TokenDetails] = None
+    prompt_tokens_details: Optional[TokenDetails] = None
+    total_tokens: int
+    currency: str
+    completion_cost: float
+    prompt_cost: float
+
+
+class Choice(BaseModel):
+    finish_reason: str
+    index: int
+    message: Optional[ChatMessage] = None
+
+
+class ProviderResponse(BaseModel):
+    created: int
+    usage: UsageDetails
+    model: str
+    service_tier: Optional[str] = None
+    id: Optional[str] = None
+    system_fingerprint: Optional[str] = None
+    choices: List[Choice]
+    object: Optional[str] = None
+
+
+class ChatResponse(BaseModel):
+    """
+    {
+    'progress': 100,
+    'providerName': 'openai',
+    'providerResponse': '{
+        "created":1738936741,
+        "usage":{
+            "completion_tokens":15,
+            "prompt_tokens":34,
+            "total_cost":0.00192,
+            "completion_tokens_details":{
+                "reasoning_tokens":0
+            },
+            "prompt_tokens_details":{
+                "cached_tokens":0
+            },
+            "total_tokens":49,
+            "currency":"USD",
+            "completion_cost":0.0009,
+            "prompt_cost":0.00102
+        },
+        "model":"gpt-4o-2024-08-06",
+        "service_tier":"default",
+        "id":"chatcmpl-AyJAjwWvbcvKQ5HO29YbGS7t4b5hr",
+        "system_fingerprint":"fp_4691090a87",
+        "choices":[
+            {
+            "finish_reason":"stop",
+            "index":0,
+            "message":{
+                "role":"assistant",
+                "function_call":null,
+                "refusal":null,
+                "tool_calls":null,
+                "content":"Le logiciel libre est le logiciel qui protège les libertés des utilisateurs."
+                }
+            }
+        ],
+        "object":"chat.completion"
+    }',
+    'requestId': '458c003a-d7fb-4d31-867c-d009ebb9d9c5',
+    'status': 'succeeded',
+    'success': True,
+    'text': 'Le logiciel libre est le logiciel qui protège les libertés des utilisateurs.'
+    }
+    """
+    progress: Optional[int] = None
+    provider_name: Optional[str] = None
+    provider_response: Optional[ProviderResponse] = None
+    request_id: Optional[str] = None
+    status: Optional[str] = None
+    success: Optional[bool] = False
+    text: Optional[str] = False

pygeai/core/secrets/clients.py

@@ -0,0 +1,212 @@
+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.secrets.endpoints import LIST_SECRETS_V1, GET_SECRET_V1, CREATE_SECRET_V1, UPDATE_SECRET_V1, \
+    SET_SECRET_ACCESSES_V1, GET_SECRET_ACCESSES_V1
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
+
+
+class SecretClient(BaseClient):
+    """
+    Client for interacting with secret-related endpoints of the API.
+    """
+
+    def list_secrets(
+        self,
+        name: str = None,
+        id: str = None,
+        start: int = 0,
+        count: int = 10
+    ) -> dict:
+        """
+        Retrieves a list of secrets with optional filtering and pagination.
+
+        This method sends a GET request to the LIST_SECRETS_V1 endpoint to fetch a list of secrets.
+        Optional query parameters can be used to filter by name or ID and control pagination.
+
+        :param name: str, optional - Filter secrets by name.
+        :param id: str, optional - Filter secrets by ID.
+        :param start: int, optional - Starting index for pagination, defaults to 0.
+        :param count: int, optional - Number of secrets to return, defaults to 10.
+        :return: dict - The API response as a dictionary if JSON parsing succeeds, otherwise the raw response text.
+        """
+        params = {
+            "name": name,
+            "id": id,
+            "start": start,
+            "count": count
+        }
+        params = {k: v for k, v in params.items() if v is not None}
+
+        response = self.api_service.get(
+            endpoint=LIST_SECRETS_V1,
+            params=params
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "list secrets with params")
+
+    def get_secret(self, secret_id: str) -> dict:
+        """
+        Retrieves a secret by its ID.
+
+        This method sends a GET request to the GET_SECRET_V1 endpoint to fetch details of a specific secret
+        identified by its ID.
+
+        :param secret_id: str - The unique identifier of the secret to retrieve.
+        :return: dict - The API response as a dictionary if JSON parsing succeeds, otherwise the raw response text.
+        :raises ValueError: If secret_id is not provided or is empty.
+        """
+        if not secret_id:
+            raise ValueError("secret_id must be provided and non-empty.")
+
+        endpoint = GET_SECRET_V1.format(secretID=secret_id)
+        response = self.api_service.get(
+            endpoint=endpoint
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "get secret with ID", secret_id=secret_id)
+
+    def create_secret(
+            self,
+            name: str,
+            secret_string: str,
+            description: Optional[str] = None
+    ) -> dict:
+        """
+        Creates a new secret with the specified details.
+
+        This method sends a POST request to the CREATE_SECRET_V1 endpoint to create a secret
+        with the provided name, secret string, and optional description.
+
+        :param name: str - The name of the secret.
+        :param secret_string: str - The secret value to store.
+        :param description: str, optional - A description of the secret.
+        :return: dict - The API response as a dictionary if JSON parsing succeeds, otherwise the raw response text.
+        :raises ValueError: If name or secret_string is not provided or is empty.
+        """
+        if not name or not secret_string:
+            raise ValueError("name and secret_string must be provided and non-empty.")
+
+        secret_definition = {
+            "name": name,
+            "secretString": secret_string,
+            "description": description
+        }
+        secret_definition = {k: v for k, v in secret_definition.items() if v is not None}
+
+        data = {
+            "secretDefinition": secret_definition
+        }
+        response = self.api_service.post(
+            endpoint=CREATE_SECRET_V1,
+            data=data
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "create secret with name", name=name)
+
+    def update_secret(
+            self,
+            secret_id: str,
+            name: str,
+            secret_string: str,
+            description: Optional[str] = None
+    ) -> dict:
+        """
+        Updates an existing secret identified by its ID with the specified details.
+
+        This method sends a PUT request to the UPDATE_SECRET_V1 endpoint to update a secret
+        with the provided name, secret string, and optional description.
+
+        :param secret_id: str - The unique identifier of the secret to update.
+        :param name: str - The updated name of the secret.
+        :param secret_string: str - The updated secret value.
+        :param description: str, optional - The updated description of the secret.
+        :return: dict - The API response as a dictionary if JSON parsing succeeds, otherwise the raw response text.
+        :raises ValueError: If secret_id, name, or secret_string is not provided or is empty.
+        """
+        if not secret_id or not name or not secret_string:
+            raise ValueError("secret_id, name, and secret_string must be provided and non-empty.")
+
+        secret_definition = {
+            "name": name,
+            "secretString": secret_string,
+            "description": description
+        }
+
+        secret_definition = {k: v for k, v in secret_definition.items() if v is not None}
+
+        data = {
+            "secretDefinition": secret_definition
+        }
+        endpoint = UPDATE_SECRET_V1.format(secretID=secret_id)
+        response = self.api_service.put(
+            endpoint=endpoint,
+            data=data
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "update secret with ID", secret_id=secret_id)
+
+    def set_secret_accesses(
+            self,
+            secret_id: str,
+            access_list: List[Dict[str, str]]
+    ) -> dict:
+        """
+        Sets access configurations for a secret identified by its ID.
+
+        This method sends a POST request to the SET_SECRET_ACCESSES_V1 endpoint to set the access
+        configurations for a secret, specifying the access level and principal type for each entry.
+
+        :param secret_id: str - The unique identifier of the secret.
+        :param access_list: List[Dict[str, str]] - A list of access configurations, each containing
+            'accessLevel' (e.g., 'write') and 'principalType' (e.g., 'service').
+        :return: dict - The API response as a dictionary if JSON parsing succeeds, otherwise the raw response text.
+        :raises ValueError: If secret_id is not provided or empty, or if access_list is empty or invalid.
+        """
+        if not secret_id:
+            raise ValueError("secret_id must be provided and non-empty.")
+        if not access_list:
+            raise ValueError("access_list must be provided and non-empty.")
+
+        for access in access_list:
+            if not all(key in access for key in ["accessLevel", "principalType"]):
+                raise ValueError("Each access entry must contain 'accessLevel' and 'principalType'.")
+            if not all(isinstance(access[key], str) and access[key] for key in ["accessLevel", "principalType"]):
+                raise ValueError("'accessLevel' and 'principalType' must be non-empty strings.")
+
+        data = {
+            "secretDefinition": {
+                "accessList": access_list
+            }
+        }
+        endpoint = SET_SECRET_ACCESSES_V1.format(secretID=secret_id)
+        response = self.api_service.post(
+            endpoint=endpoint,
+            data=data
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "set accesses for secret with ID", secret_id=secret_id)
+
+    def get_secret_accesses(self, secret_id: str) -> dict:
+        """
+        Retrieves access configurations for a secret identified by its ID.
+
+        This method sends a GET request to the GET_SECRET_ACCESSES_V1 endpoint to fetch the access
+        configurations for a specific secret.
+
+        :param secret_id: str - The unique identifier of the secret.
+        :return: dict - The API response as a dictionary if JSON parsing succeeds, otherwise the raw response text.
+        :raises ValueError: If secret_id is not provided or is empty.
+        """
+        if not secret_id:
+            raise ValueError("secret_id must be provided and non-empty.")
+
+        endpoint = GET_SECRET_ACCESSES_V1.format(secretID=secret_id)
+        response = self.api_service.get(
+            endpoint=endpoint
+        )
+        validate_status_code(response)
+        return parse_json_response(response, "get accesses for secret with ID", secret_id=secret_id)

pygeai/core/secrets/endpoints.py

@@ -0,0 +1,7 @@
+LIST_SECRETS_V1 = "/v1/secrets"     # GET -> Get secrets (Params: ?name=&id=&start=&count=)
+GET_SECRET_V1 = "/v1/secrets/{secretID}"    # GET -> Get secret by Id
+CREATE_SECRET_V1 = "/v1/secrets"    # POST -> Create secret
+UPDATE_SECRET_V1 = "/v1/secrets/{secretID}"    # PUT -> Update secret by Id
+SET_SECRET_ACCESSES_V1 = "/v1/secrets/{secretID}/accesses"    # POST -> Set accesses
+GET_SECRET_ACCESSES_V1 = "/v1/secrets/{secretID}/accesses"    # GET -> Get accesses
+