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

pygeai/core/base/models.py

@@ -1,316 +1,16 @@
-from datetime import datetime
-
-from pydantic.main import BaseModel
 from typing import Optional
 
+from pydantic import Field
 
-class Error(BaseModel):
-    error_id: int
-    description: str
-
-    def __str__(self):
-        error = {
-            "id": self.error_id,
-            "description": self.description
-        }
-        return str(error)
-
-
-class AssistantRevisionMetadata(BaseModel):
-    """
-    {
-      "key": "string",
-      "type": "string",
-      "value": "string"
-    }
-    """
-    key: str
-    type: str
-    value: str
-
-    def __str__(self):
-        metadata = {
-            "key": self.key,
-            "type": self.type,
-            "value": self.value
-        }
-        return str(metadata)
-
-
-class AssistantRevision(BaseModel):
-    """
-    {
-      "metadata": [
-        ...
-      ],
-      "modelId": "string",
-      "modelName": "string",
-      "prompt": "string",
-      "providerName": "string",
-      "revisionDescription": "string",
-      "revisionId": "string",
-      "revisionName": "string",
-      "timestamp": "timestamp"
-    }
-    """
-    metadata: Optional[list[AssistantRevisionMetadata]] = []
-    model_id: str
-    model_name: str
-    prompt: str
-    provider_name: str
-    revision_description: str
-    revision_id: str
-    revision_name: str
-    timestamp: datetime
-
-    def __str__(self):
-        revision = {
-            "modelId": self.model_id,
-            "modelName": self.model_name,
-            "prompt": self.prompt,
-            "providerName": self.provider_name,
-            "revisionDescription": self.revision_description,
-            "revisionId": self.revision_id,
-            "revisionName": self.revision_name,
-            "timestamp": self.timestamp
-        }
-        if any(self.metadata):
-            revision["metadata"] = self.metadata
-
-        return str(revision)
-
-
-class AssistantIntent(BaseModel):
-    """
-    {
-          "assistantIntentDefaultRevision": "number",
-          "assistantIntentDescription": "string",
-          "assistantIntentId": "string",
-          "assistantIntentName": "string",
-          "revisions": [
-            ...
-          ]
-        }
-    """
-    assistant_intent_default_revision: float
-    assistant_intent_description: str
-    assistant_intent_id: str
-    assistant_intent_name: str
-    revisions: Optional[list[AssistantRevision]] = []
-
-    def __str__(self):
-        intent = {
-            "assistantIntentDefaultRevision": self.assistant_intent_default_revision,
-            "assistantIntentDescription": self.assistant_intent_description,
-            "assistantIntentId": self.assistant_intent_id,
-            "assistantIntentName": self.assistant_intent_name
-        }
-        if any(self.revisions):
-            intent["revisions"] = self.revisions
-
-        return str(intent)
-
-
-class Assistant(BaseModel):
-    """
-    {
-      "assistantId": "string",
-      "assistantName": "string",
-      "intents": [ /* full option */
-
-      ]
-    }
-    """
-    id: str
-    name: str
-    type: str
-    intents: Optional[list[AssistantIntent]] = []
-
-    def __str__(self):
-        assistant = {
-            "assistantId": self.id,
-            "assistantName": self.name,
-            "assistantType": self.type
-        }
-        if any(self.intents):
-            assistant["intents"] = self.intents
-
-        return str(assistant)
-
-
-class Organization(BaseModel):
-    organization_id: str
-    organization_name: str
-
-    def __str__(self):
-        organization = {
-            "organizationId": self.organization_id,
-            "organizationName": self.organization_name
-        }
-        return str(organization)
-
-
-class ProjectSearchProfile(BaseModel):
-    """
-     {
-      "name": "string",
-      "description": "string"
-    }
-    """
-    name: str
-    description: str
-
-    def __str__(self):
-        search_profile = {
-            "name": self.name,
-            "description": self.description
-        }
-        return str(search_profile)
-
-
-class ProjectToken(BaseModel):
-    """
-     {
-      "description": "string",
-      "id": "string",
-      "name": "string",
-      "status": "string", /* Active, Blocked */
-      "timestamp": "timestamp"
-    }
-    """
-    description: str
-    token_id: str
-    name: str
-    status: str
-    timestamp: datetime
-
-    def __str__(self):
-        token = {
-            "description": self.description,
-            "id": self.token_id,
-            "name": self.name,
-            "status": self.status,
-            "timestamp": self.timestamp
-        }
-        return str(token)
-
-
-class ProjectUsageLimit(BaseModel):
-    """
-    "hardLimit": "number",                // Upper usage limit
-    "id": "string",                       // Usage limit ID
-    "relatedEntityName": "string",        // Name of the related entity
-    "remainingUsage": "number",           // Remaining usage
-    "renewalStatus": "string",            // Renewal status (Renewable, NonRenewable)
-    "softLimit": "number",                // Lower usage limit
-    "status": "integer",                  // Status (1: Active, 2: Expired, 3: Empty, 4: Cancelled)
-    "subscriptionType": "string",         // Subscription type (Freemium, Daily, Weekly, Monthly)
-    "usageUnit": "string",                // Usage unit (Requests, Cost)
-    "usedAmount": "number",               // Amount used (decimal or scientific notation)
-    "validFrom": "timestamp",             // Start date of the usage limit
-    "validUntil": "timestamp"             // Expiration or renewal date
-    """
-    hard_limit: float
-    usage_limit_id: str
-    related_entity_name: str
-    remaining_usage: float
-    renewal_status: str
-    soft_limit: float
-    status: int
-    subscription_type: str
-    usage_unit: str
-    used_amount: float
-    valid_from: datetime
-    valid_until: datetime
-
-    def __str__(self):
-        usage_limit = {
-            "hardLimit": self.hard_limit,
-            "id": self.usage_limit_id,
-            "relatedEntityName": self.related_entity_name,
-            "remainingUsage": self.remaining_usage,
-            "renewalStatus": self.renewal_status,
-            "softLimit": self.soft_limit,
-            "status": self.status,
-            "subscriptionType": self.subscription_type,
-            "usageUnit": self.usage_unit,
-            "usedAmount": self.used_amount,
-            "validFrom": self.valid_from,
-            "validUntil": self.valid_until
-        }
-        return str(usage_limit)
-
-
-class Project(BaseModel):
-    """
-     {
-      "projectActive": "boolean",
-      "projectDescription": "string",
-      "projectId": "string",
-      "projectName": "string",
-      "projectStatus": "integer", /* 0:Active, 2:Hidden */
-    }
-    """
-    organization: Optional[Organization] = None
-    active: Optional[bool] = None
-    description: Optional[str] = None
-    id: Optional[str] = None
-    name: str
-    email: Optional[str]
-    status: Optional[int] = None
-    search_profiles: Optional[list[ProjectSearchProfile]] = []
-    tokens: Optional[list[ProjectToken]] = []
-    usage_limit: Optional[ProjectUsageLimit] = None
-
-    def __str__(self):
-        project = {
-            "projectName": self.name
-        }
-
-        if self.id:
-            project["projectId"] = self.id
-
-        if self.organization:
-            project["organization"] = self.organization
-
-        if self.active is not None:
-            project["projectActive"] = self.active
-
-        if self.description is not None:
-            project["projectDescription"] = self.description
-
-        if self.status is not None:
-            project["projectStatus"] = self.status
-
-        if any(self.search_profiles):
-            project["searchProfiles"] = self.search_profiles
-
-        if any(self.tokens):
-            project["tokens"] = self.tokens
-
-        if any(self.usage_limit):
-            project["usageLimit"] = self.usage_limit
+from pygeai.core import CustomBaseModel
 
-        return str(project)
 
+class Error(CustomBaseModel):
+    id: Optional[int] = Field(None, alias="id")
+    description: str = Field(..., alias="description")
 
-class ProjectItem(BaseModel):
-    assistant: str
-    intent: str
-    timestamp: str
-    prompt: str
-    output: str
-    input_text: str
-    status: str
+    def to_dict(self):
+        return self.model_dump(by_alias=True, exclude_none=True)
 
     def __str__(self):
-        item = {
-            "assistant": self.assistant,
-            "intent": self.intent,
-            "timestamp": self.timestamp,
-            "prompt": self.prompt,
-            "output": self.output,
-            "inputText": self.input_text,
-            "status": self.status
-        }
-        return str(item)
+        return str(self.to_dict())

pygeai/core/base/responses.py

@@ -1,3 +1,6 @@
+from typing import Optional, Union
+from pydantic import Field
+
 from pydantic.main import BaseModel
 
 from pygeai.core.base.models import Error
@@ -6,6 +9,20 @@ from pygeai.core.base.models import Error
 class ErrorListResponse(BaseModel):
     errors: list[Error]
 
+    def to_dict(self):
+        return [error.to_dict() for error in self.errors]
+
 
 class EmptyResponse(BaseModel):
-    content: dict
+    content: Optional[Union[dict, str]] = Field(default=None, description="The response content, either a dict, str, or None")
+
+    def to_dict(self):
+        """
+        Serializes the EmptyResponse instance to a dictionary.
+
+        :return: dict - A dictionary representation of the response.
+        """
+        return {"content": self.content} if self.content is not None else {}
+
+    def __str__(self):
+        return str(self.to_dict())

pygeai/core/base/session.py

@@ -1,33 +1,52 @@
-import os
 import sys
+from typing import Optional
 
+from pygeai import logger
 from pygeai.core.common.config import get_settings
 from pygeai.core.common.exceptions import MissingRequirementException
 from pygeai.core.singleton import Singleton
 
-settings = get_settings()
+
+_session = None
 
 
-# TODO -> Review if it's convenient to use singleton over precise parameters
 class Session(metaclass=Singleton):
     """
     A session to store configuration state required to interact with different resources.
 
-    Args:
-        api_key (str): Key to interact with API of GEAI
-        base_url (str): Base URL to connect to instance of GEAI
-
-    Returns:
-        Instance of Session
+    :param api_key: str - API key to interact with GEAI
+    :param base_url: str - Base URL of the GEAI instance
+    :param eval_url: Optional[str] - Optional evaluation endpoint URL
+    :param access_token: Optional[str] - OAuth access token (keyword-only)
+    :param project_id: Optional[str] - Project ID for OAuth authentication (keyword-only)
+    :return: Session - Instance of the Session class
+    :raises: ValueError - If required parameters are missing or invalid
     """
 
     def __init__(
             self,
-            api_key: str,
-            base_url: str
-        ):
+            api_key: str = None,
+            base_url: str = None,
+            eval_url: Optional[str] = None,
+            *,
+            access_token: Optional[str] = None,
+            project_id: Optional[str] = None,
+            alias: Optional[str] = None,
+    ):
+        if not api_key and not access_token:
+            logger.warning("Cannot instantiate session without api_key or access_token")
+        if not base_url:
+            logger.warning("Cannot instantiate session without base_url")
+
         self.__api_key = api_key
         self.__base_url = base_url
+        self.__eval_url = eval_url
+        self.__access_token = access_token
+        self.__project_id = project_id
+        self.__alias = alias if alias else "default"
+
+        global _session
+        _session = self
 
     @property
     def api_key(self):
@@ -45,17 +64,91 @@ class Session(metaclass=Singleton):
     def base_url(self, base_url: str):
         self.__base_url = base_url
 
+    @property
+    def eval_url(self):
+        return self.__eval_url
+
+    @eval_url.setter
+    def eval_url(self, eval_url: str):
+        self.__eval_url = eval_url
+
+    @property
+    def access_token(self):
+        return self.__access_token
+
+    @access_token.setter
+    def access_token(self, access_token: str):
+        self.__access_token = access_token
+
+    @property
+    def project_id(self):
+        return self.__project_id
+
+    @project_id.setter
+    def project_id(self, project_id: str):
+        self.__project_id = project_id
 
-def get_session(alias: str = "default") -> Session:
+    @property
+    def alias(self):
+        return self.__alias
+
+    @alias.setter
+    def alias(self, alias: str):
+        self.__alias = alias
+
+
+def get_session(alias: str = None) -> Session:
     """
     Session is a singleton object:
     On the first invocation, returns Session configured with the API KEY and BASE URL corresponding to the
     alias provided. On the following invocations, it returns the first object instantiated.
     """
     try:
-        return Session(
-            api_key=settings.get_api_key(alias),
-            base_url=settings.get_base_url(alias)
-        )
+        settings = get_settings()
+        global _session
+        if _session is None:
+            if not alias:
+                alias = "default"
+            
+            _validate_alias(alias, allow_missing_default=True)
+
+            _session = Session(
+                api_key=settings.get_api_key(alias),
+                base_url=settings.get_base_url(alias),
+                eval_url=settings.get_eval_url(alias),
+                access_token=settings.get_access_token(alias),
+                project_id=settings.get_project_id(alias),
+                alias=alias,
+            )
+                
+        elif _session is not None and alias:
+            _validate_alias(alias, allow_missing_default=False)
+            
+            _session.alias = alias
+            _session.api_key = settings.get_api_key(alias)
+            _session.base_url = settings.get_base_url(alias)
+            _session.eval_url = settings.get_eval_url(alias)
+            _session.access_token = settings.get_access_token(alias)
+            _session.project_id = settings.get_project_id(alias)
+
+        return _session
     except ValueError as e:
+        logger.warning(f"Warning: API_KEY and/or BASE_URL not set. {e}")
         sys.stdout.write("Warning: API_KEY and/or BASE_URL not set. Please run geai configure to set them up.\n")
+
+
+def _validate_alias(alias: str, allow_missing_default: bool = False):
+    settings = get_settings()
+    available_aliases = settings.list_aliases()
+    if alias not in available_aliases:
+        if allow_missing_default and alias == "default":
+            return
+        raise MissingRequirementException(
+            f"The profile '{alias}' doesn't exist. Use 'geai configure --list' to see available profiles."
+        )
+
+
+def reset_session():
+    """Reset the session instance. Useful for testing."""
+    global _session
+    _session = None

pygeai/core/common/config.py

@@ -1,9 +1,10 @@
 import os
 import sys
-from functools import lru_cache
 from pathlib import Path
 import configparser
 
+from pygeai import logger
+
 HOME_DIR = Path.home()
 SETTINGS_DIR = HOME_DIR / ".geai"
 SETTINGS_DIR.mkdir(parents=True, exist_ok=True)
@@ -19,25 +20,40 @@ class SettingsManager:
     GEAI_SETTINGS_DIR = str(SETTINGS_DIR)
     GEAI_CREDS_FILE = SETTINGS_DIR / "credentials"
 
-    def __init__(self):
+    def __init__(self, credentials_file: str = None):
         self.config = configparser.ConfigParser()
-
+        
+        if credentials_file:
+            self.GEAI_CREDS_FILE = Path(credentials_file)
+            logger.debug(f"Using custom credentials file: {self.GEAI_CREDS_FILE}")
+        
         if self.GEAI_CREDS_FILE.exists():
             self.config.read(self.GEAI_CREDS_FILE)
         else:
             self.GEAI_CREDS_FILE.touch()
-            # raise FileNotFoundError(f"Credentials file not found at {self.GEAI_CREDS_FILE}")
             sys.stdout.write(f"INFO: Credentials file not found. Creating empty one at {self.GEAI_CREDS_FILE}\n")
 
+    def has_value(self, setting_key: str, alias: str):
+        """Checks if a setting value exists for a specific alias in the credentials file."""
+        return alias in self.config and setting_key in self.config[alias]
+
     def get_setting_value(self, setting_key: str, alias: str):
         """Reads a setting value for a specific alias from the credentials file."""
         if alias not in self.config:
-            raise ValueError(f"Alias '{alias}' not found in the credentials file.")
-
+            logger.warning(f"Alias '{alias}' not found in the credentials file.")
+            return
+        
         if setting_key not in self.config[alias]:
-            raise ValueError(f"'{setting_key}' not found in alias '{alias}' in the credentials file.")
+            sys.stdout.write(f"'{setting_key}' not found in alias '{alias}' in the credentials file. Adding empty value.\n")
+            # SET ADDITIONAL VARS
+            if setting_key.lower() == "GEAI_API_EVAL_URL".lower():
+                self.set_eval_url("", alias)
+            if setting_key.lower() == "GEAI_OAUTH_ACCESS_TOKEN".lower():
+                self.set_access_token("", alias)
+            if setting_key.lower() == "GEAI_PROJECT_ID".lower():
+                self.set_project_id("", alias)
 
-        return self.config[alias][setting_key]
+        return self.config[alias].get(setting_key, "")
 
     def set_setting_value(self, setting_key: str, setting_value: str, alias: str):
         """Writes or updates a setting value for a specific alias in the credentials file."""
@@ -50,7 +66,7 @@ class SettingsManager:
             self.config.write(file)
 
     def get_api_key(self, alias: str = "default"):
-        api_key = os.environ.get("GEAI_API_KEY") if alias == "default" else None
+        api_key = os.environ.get("GEAI_API_KEY") if not alias or alias == "default" else None
         if not api_key:
             api_key = self.get_setting_value("GEAI_API_KEY", alias)
 
@@ -60,7 +76,7 @@ class SettingsManager:
         self.set_setting_value("GEAI_API_KEY", api_key, alias)
 
     def get_base_url(self, alias: str = "default"):
-        base_url = os.environ.get("GEAI_API_BASE_URL") if alias == "default" else None
+        base_url = os.environ.get("GEAI_API_BASE_URL") if not alias or alias == "default" else None
         if not base_url:
             base_url = self.get_setting_value("GEAI_API_BASE_URL", alias)
 
@@ -69,15 +85,81 @@ class SettingsManager:
     def set_base_url(self, base_url, alias: str = "default"):
         self.set_setting_value("GEAI_API_BASE_URL", base_url, alias)
 
+    def get_access_token(self, alias: str = "default"):
+        access_token = os.environ.get("GEAI_OAUTH_ACCESS_TOKEN") if not alias or alias == "default" else None
+        if not access_token:
+            access_token = self.get_setting_value("GEAI_OAUTH_ACCESS_TOKEN", alias)
+
+        return access_token
+
+    def set_access_token(self, access_token, alias: str = "default"):
+        self.set_setting_value("GEAI_OAUTH_ACCESS_TOKEN", access_token, alias)
+
+    def get_project_id(self, alias: str = "default"):
+        project_id = os.environ.get("GEAI_PROJECT_ID") if not alias or alias == "default" else None
+        if not project_id:
+            project_id = self.get_setting_value("GEAI_PROJECT_ID", alias)
+
+        return project_id
+
+    def set_project_id(self, project_id, alias: str = "default"):
+        self.set_setting_value("GEAI_PROJECT_ID", project_id, alias)
+
+    def get_eval_url(self, alias: str = "default"):
+        eval_url = os.environ.get("GEAI_API_EVAL_URL") if not alias or alias == "default" else None
+        if not eval_url:
+            eval_url = self.get_setting_value("GEAI_API_EVAL_URL", alias)
+
+        return eval_url
+
+    def set_eval_url(self, eval_url, alias: str = "default"):
+        self.set_setting_value("GEAI_API_EVAL_URL", eval_url, alias)
+
+    def list_aliases(self):
+        """Returns a dict of all aliases and their base URLs."""
+        return {
+            section: self.config[section].get("GEAI_API_BASE_URL", "")
+            for section in self.config.sections()
+        }
+
+    def remove_alias(self, alias: str):
+        """Removes a specific alias and its settings from the credentials file."""
+        if alias in self.config:
+            self.config.remove_section(alias)
+            with self.GEAI_CREDS_FILE.open("w") as file:
+                self.config.write(file)
+            logger.info(f"Alias '{alias}' removed from the credentials file.")
+        else:
+            logger.warning(f"Alias '{alias}' not found in the credentials file.")
+
+
+_settings_instance = None
+
+
+def get_settings(credentials_file: str = None):
+    """
+    Get or create the SettingsManager instance.
+    
+    :param credentials_file: Optional path to a custom credentials file.
+                            If provided on first call, uses that file.
+                            Subsequent calls ignore this parameter.
+    :return: SettingsManager instance
+    """
+    global _settings_instance
+    if _settings_instance is None:
+        _settings_instance = SettingsManager(credentials_file=credentials_file)
+    return _settings_instance
+
 
-@lru_cache()
-def get_settings():
-    return SettingsManager()
+def reset_settings():
+    """Reset the settings instance. Useful for testing."""
+    global _settings_instance
+    _settings_instance = None
 
 
 if __name__ == "__main__":
     settings = get_settings()
-    geai_api_key = settings.get_api_key()
     geai_base_url = settings.get_base_url()
-    print(f"api_key: {geai_api_key}")
-    print(f"base_url: {geai_base_url}")
+    geai_eval_url = settings.get_eval_url()
+    print(f"base_url: {geai_base_url}")
+    print(f"eval_url: {geai_eval_url}")