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

pygeai/core/__init__.py

@@ -2,4 +2,12 @@
 GEAI - Core
 -----------
 Core functionality for the PyGEAI SDK
-"""
+"""
+
+from pydantic import BaseModel
+
+
+class CustomBaseModel(BaseModel):
+
+    class Config:
+        populate_by_name = True

pygeai/core/base/clients.py

@@ -1,37 +1,88 @@
 from abc import ABC
+from pygeai import logger
 
 from pygeai.core.base.session import get_session, Session
 from pygeai.core.common.exceptions import MissingRequirementException
 from pygeai.core.services.rest import ApiService
+from pygeai.core.utils.validators import validate_status_code
+
 
 
 class BaseClient(ABC):
+    _logged_session_config = None
 
-    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, *,
+                 access_token: str = None, project_id: str = None):
         """
         If commont settings are not specified, they're retrieved from default Session, based on the
         credential files.
         :param api_key: GEAI API KEY to access services
         :param base_url: URL for GEAI instance to be used
+        :param alias: Alias to use from credentials file
+        :param access_token: OAuth access token (keyword-only)
+        :param project_id: Project ID for OAuth authentication (keyword-only)
         """
-        if not (api_key and base_url):
-            session = get_session(alias)
-            if not session:
+        if access_token and not project_id:
+            raise MissingRequirementException("project_id is required when using access_token")
+
+        if not (api_key and base_url) and not (access_token and base_url) and alias:
+            self.__session = get_session(alias)
+            if not self.__session:
                 raise MissingRequirementException("API KEY and BASE URL must be defined in order to use this functionality")
+        elif (api_key or access_token) and base_url:
+            self.__session = get_session()
+            self.__session.api_key = api_key
+            self.__session.access_token = access_token
+            self.__session.project_id = project_id
+            self.__session.base_url = base_url
+        else:
+            self.__session = get_session()
 
-            if not api_key:
-                api_key = session.api_key
-            if not base_url:
-                base_url = session.base_url
+        if self.session is None:
+            raise MissingRequirementException("Cannot access this functionality without setting API_KEY and BASE_URL")
+        
+        # Log session config only once per unique session configuration
+        session_config_key = (
+            self.session.alias,
+            self.session.base_url,
+            bool(self.session.access_token),
+            bool(self.session.api_key)
+        )
+        
+        if BaseClient._logged_session_config != session_config_key:
+            if self.session.access_token and self.session.project_id:
+                logger.info(f"Using OAuth 2.0 authentication")
+            elif self.session.api_key:
+                logger.info(f"Using API Key authentication")
+            else:
+                logger.warning("No authentication method configured")
+            
+            logger.info(f"Alias: {self.session.alias}")
+            logger.info(f"Base URL: {self.session.base_url}")
+            
+            BaseClient._logged_session_config = session_config_key
 
-        self.__session = Session(api_key=api_key, base_url=base_url)
-        self.__api_service = ApiService(base_url=self.session.base_url, token=self.session.api_key)
+        token = self.session.access_token if self.session.access_token else self.session.api_key
+        
+        self.__api_service = ApiService(
+            base_url=self.session.base_url,
+            token=token,
+            project_id=self.session.project_id
+        )
 
     @property
     def session(self):
         return self.__session
 
+    @session.setter
+    def session(self, session: Session):
+        self.__session = session
+
     @property
     def api_service(self):
         return self.__api_service
 
+    @api_service.setter
+    def api_service(self, api_service: ApiService):
+        self.__api_service = api_service
+

pygeai/core/base/mappers.py

@@ -1,5 +1,8 @@
-from pygeai.core.base.models import Organization, Assistant, AssistantIntent, AssistantRevision, \
-    AssistantRevisionMetadata, Project, Error, ProjectUsageLimit, ProjectSearchProfile, ProjectToken, ProjectItem
+from pygeai.core.models import Organization, AssistantIntent, AssistantRevision, \
+    AssistantRevisionMetadata, Project, UsageLimit, SearchProfile, ProjectToken, RequestItem, \
+    Assistant, TextAssistant, ChatAssistant, LlmSettings, WelcomeData, WelcomeDataFeature, WelcomeDataExamplePrompt, \
+    GuardrailSettings
+from pygeai.core.base.models import Error
 from pygeai.core.base.responses import ErrorListResponse, EmptyResponse
 
 
@@ -18,9 +21,11 @@ class ErrorMapper:
         :param data: dict - The dictionary containing error details.
         :return: Error - An `Error` object with extracted error details.
         """
+        identifier = data.get('id') or data.get('code')
+        description = data.get('description') or data.get('message')
         return Error(
-            error_id=data.get('id'),
-            description=data.get('description')
+            id=identifier,
+            description=description
         )
 
     @classmethod
@@ -81,8 +86,8 @@ class ModelMapper:
         :return: Organization - The mapped `Organization` object.
         """
         return Organization(
-            organization_id=data.get('organizationId'),
-            organization_name=data.get('organizationName')
+            id=data.get('organizationId'),
+            name=data.get('organizationName')
         )
 
     @classmethod
@@ -93,13 +98,28 @@ class ModelMapper:
         :param data: dict - The dictionary containing assistant details.
         :return: Assistant - The mapped `Assistant` object.
         """
-        intent_list = cls.map_to_intent_list(data)
+        intent_data = data.get('intents')[0] if 'intents' in data and len(data.get('intents')) > 0 else {}
+        revision_list = cls.map_to_revision_list(intent_data)
+        project = cls.map_to_project(data) if 'projectId' in data and 'projectName' in data else None
+        welcome_data = cls.map_to_welcome_data(data.get('welcomeData')) if 'welcomeData' in data else None
+        llm_settings = cls.map_to_llm_settings(data.get('llmSettings')) if 'llmSettings' in data else None
 
         return Assistant(
-            assistant_id=data.get("assistantId"),
-            assistant_name=data.get("assistantName"),
-            assistant_type=data.get("assistantType"),
-            intents=intent_list
+            id=data.get("assistantId"),
+            name=data.get("assistantName"),
+            type=data.get("assistantType"),
+            status=data.get("assistantStatus"),
+            priority=data.get("assistantPriority"),
+            description=data.get("assistantDescription"),
+            prompt=data.get("prompt"),
+            default_revision=intent_data.get('assistantIntentDefaultRevision'),
+            intent_description=intent_data.get('assistantIntentDescription'),
+            intent_id=intent_data.get('assistantIntentId'),
+            intent_name=intent_data.get('assistantIntentName'),
+            revisions=revision_list,
+            project=project,
+            welcome_data=welcome_data,
+            llm_settings=llm_settings
         )
 
     @classmethod
@@ -130,10 +150,10 @@ class ModelMapper:
         revision_list = cls.map_to_revision_list(data)
 
         return AssistantIntent(
-            assistant_intent_default_revision=data.get("assistantIntentDefaultRevision"),
-            assistant_intent_description=data.get("assistantIntentDescription"),
-            assistant_intent_id=data.get("assistantIntentId"),
-            assistant_intent_name=data.get("assistantIntentName"),
+            default_revision=data.get("assistantIntentDefaultRevision"),
+            description=data.get("assistantIntentDescription"),
+            id=data.get("assistantIntentId"),
+            name=data.get("assistantIntentName"),
             revisions=revision_list,
         )
 
@@ -215,25 +235,58 @@ class ModelMapper:
         :param data: dict - The dictionary containing project details.
         :return: Project - The mapped `Project` object.
         """
+        organization = cls.map_to_organization(data) if "organizationId" in data and "organizationName" in data else None
+        # search_profiles = cls.map_to_search_profile_list(data)
+        tokens = cls.map_to_token_list(data)
+        usage_limit = cls.map_to_usage_limit(data.get('usageLimit')) if "usageLimit" in data else None
 
         return Project(
-            project_id=data.get('projectId'),
-            project_name=data.get('projectName')
+            organization=organization,
+            id=data.get('projectId'),
+            name=data.get('projectName'),
+            active=data.get('projectActive'),
+            description=data.get('projectDescription'),
+            status=data.get('projectStatus'),
+            # search_profiles=search_profiles,
+            tokens=tokens,
+            usage_limit=usage_limit
         )
 
     @classmethod
-    def map_to_search_profile(cls, data: dict) -> ProjectSearchProfile:
+    def map_to_search_profile_list(cls, data: dict) -> list[SearchProfile]:
+        search_profile_list = list()
+        search_profiles = data.get('searchProfiles')
+        if search_profiles is not None and any(search_profiles):
+            for search_profile_data in search_profiles:
+                search_profile = cls.map_to_search_profile(search_profile_data)
+                search_profile_list.append(search_profile)
+
+        return search_profile_list
+
+    @classmethod
+    def map_to_search_profile(cls, data: dict) -> SearchProfile:
         """
-       Maps a dictionary to a `ProjectSearchProfile` object.
+       Maps a dictionary to a `SearchProfile` object.
 
        :param data: dict - The dictionary containing search profile details.
-       :return: ProjectSearchProfile - The mapped `ProjectSearchProfile` object.
+       :return: SearchProfile - The mapped `SearchProfile` object.
        """
-        return ProjectSearchProfile(
+        return SearchProfile(
             name=data.get('name'),
             description=data.get('description'),
         )
 
+    @classmethod
+    def map_to_token_list(cls, data: dict) -> list[ProjectToken]:
+        token_list = list()
+        tokens = data.get('tokens')
+        if tokens is not None and any(tokens):
+            for token_data in tokens:
+                token = cls.map_to_token(token_data)
+                token_list.append(token)
+
+        return token_list
+
     @classmethod
     def map_to_token(cls, data: dict) -> ProjectToken:
         """
@@ -251,16 +304,27 @@ class ModelMapper:
         )
 
     @classmethod
-    def map_to_usage_limit(cls, data: dict) -> ProjectUsageLimit:
+    def map_to_usage_limit_list(cls, data: dict) -> list[UsageLimit]:
+        usage_limit_list = list()
+        usage_limits = data.get('usageLimits')
+        if usage_limits is not None and any(usage_limits):
+            for usage_limit_data in usage_limits:
+                usage_limit = cls.map_to_usage_limit(usage_limit_data)
+                usage_limit_list.append(usage_limit)
+
+        return usage_limit_list
+
+    @classmethod
+    def map_to_usage_limit(cls, data: dict) -> UsageLimit:
         """
-        Maps a dictionary to a `ProjectUsageLimit` object.
+        Maps a dictionary to a `UsageLimit` object.
 
         :param data: dict - The dictionary containing usage limit details.
-        :return: ProjectUsageLimit - The mapped `ProjectUsageLimit` object.
+        :return: UsageLimit - The mapped `UsageLimit` object.
         """
-        return ProjectUsageLimit(
+        return UsageLimit(
             hard_limit=data.get("hardLimit"),
-            usage_limit_id=data.get("id"),
+            id=data.get("id"),
             related_entity_name=data.get("relatedEntityName"),
             remaining_usage=data.get("remainingUsage"),
             renewal_status=data.get("renewalStatus"),
@@ -274,13 +338,127 @@ class ModelMapper:
         )
 
     @classmethod
-    def map_to_item(cls, data: dict) -> ProjectItem:
-        return ProjectItem(
+    def map_to_item_list(cls, data: dict) -> list[RequestItem]:
+        item_list = list()
+        items = data.get('items')
+        if items is not None and any(items):
+            for item_data in items:
+                item = cls.map_to_item(item_data)
+                item_list.append(item)
+
+        return item_list
+
+    @classmethod
+    def map_to_item(cls, data: dict) -> RequestItem:
+        return RequestItem(
+            api_token=data.get('apiToken'),
             assistant=data.get('assistant'),
+            cost=data.get('cost'),
+            elapsed_time_ms=data.get('elapsedTimeMs'),
+            end_timestamp=data.get('endTimestamp'),
+            feedback=data.get('feedback'),
             intent=data.get('intent'),
-            timestamp=data.get('timestamp'),
+            module=data.get('module'),
             prompt=data.get('prompt'),
             output=data.get('output'),
             input_text=data.get('inputText'),
-            status=data.get('status')
+            rag_sources_consulted=data.get('ragSourcesConsulted'),
+            session_id=data.get('sessionId'),
+            start_timestamp=data.get('startTimestamp'),
+            status=data.get('status'),
+            timestamp=data.get('timestamp')
+        )
+
+    @classmethod
+    def map_to_base_assistant(cls, data: dict) -> Assistant:
+        assistant_type = data.get('type')
+        if assistant_type is not None and assistant_type == "text":
+            return TextAssistant(
+                id=data.get("assistantId"),
+                name=data.get("assistantName"),
+                status=bool(data.get("assistantStatus")), # TODO -> Validar casting
+            )
+        elif assistant_type is not None and assistant_type == "chat":
+            return ChatAssistant(
+                id=data.get("assistantId"),
+                name=data.get("assistantName"),
+                status=bool(data.get("assistantStatus")),  # TODO -> Validar casting
+            )
+
+    @classmethod
+    def map_to_llm_settings(cls, data: dict) -> LlmSettings:
+        guardrail_settings = cls.map_to_guardrail_settings(data)
+        return LlmSettings(
+            provider_name=data.get("providerName") or data.get("provider"),
+            model_name=data.get("modelName"),
+            temperature=data.get("temperature"),
+            frequency_penalty=data.get("frequencyPenalty"),
+            presence_penalty=data.get("presencePenalty"),
+            max_tokens=data.get("maxTokens"),
+            upload_files=data.get("uploadFiles"),
+            guardrail_settings=guardrail_settings,
+            cache=data.get("cache"),
+            n=data.get("n"),
+            stream=data.get("stream"),
+            topP=data.get("topP"),
+            type=data.get("type", ""),
+            verbose=data.get("verbose")
         )
+
+    @classmethod
+    def map_to_guardrail_settings(cls, data: dict) -> GuardrailSettings:
+        return GuardrailSettings(
+            llm_output=data.get("llmOutputGuardrail"),
+            input_moderation=data.get("inputModerationGuardrail"),
+            prompt_injection=data.get("promptInjectionGuardrail")
+        )
+
+    @classmethod
+    def map_to_welcome_data(cls, data: dict) -> WelcomeData:
+        feature_list = cls.map_to_feature_list(data)
+        example_prompt_list = cls.map_to_example_prompt_list(data)
+
+        return WelcomeData(
+            title=data.get('title'),
+            description=data.get('description'),
+            features=feature_list,
+            examples_prompt=example_prompt_list
+        )
+
+    @classmethod
+    def map_to_feature_list(cls, data: dict) -> list[WelcomeDataFeature]:
+        feature_list = list()
+        features = data.get("features")
+        if features is not None and any(features):
+            for feature_data in features:
+                feature = cls.map_to_feature(feature_data)
+                feature_list.append(feature)
+
+        return feature_list
+
+    @classmethod
+    def map_to_feature(cls, data: dict) -> WelcomeDataFeature:
+        return WelcomeDataFeature(
+            title=data.get("title"),
+            description=data.get("description"),
+        )
+
+    @classmethod
+    def map_to_example_prompt_list(cls, data: dict) -> list[WelcomeDataExamplePrompt]:
+        example_prompt_list = list()
+        examples_prompt = data.get("examplesPrompt")
+        if examples_prompt is not None and any(examples_prompt):
+            for example_prompt_data in examples_prompt:
+                example_prompt = cls.map_to_example_prompt(example_prompt_data)
+                example_prompt_list.append(example_prompt)
+
+        return example_prompt_list
+
+    @classmethod
+    def map_to_example_prompt(cls, data: dict) -> WelcomeDataExamplePrompt:
+        return WelcomeDataExamplePrompt(
+            title=data.get("title"),
+            description=data.get("description"),
+            prompt_text=data.get("promptText")
+        )
+