pygeai 0.6.0b6__py3-none-any.whl → 0.6.0b10__py3-none-any.whl

pygeai/cli/commands/organization.py

@@ -288,6 +288,202 @@ export_request_data_options = [
     )
 ]
 
+
+def get_memberships(option_list: list):
+    email = None
+    start_page = 1
+    page_size = 20
+    order_key = None
+    order_direction = "desc"
+    role_types = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "email":
+            email = option_arg
+        if option_flag.name == "start_page":
+            start_page = int(option_arg)
+        if option_flag.name == "page_size":
+            page_size = int(option_arg)
+        if option_flag.name == "order_key":
+            order_key = option_arg
+        if option_flag.name == "order_direction":
+            order_direction = option_arg
+        if option_flag.name == "role_types":
+            role_types = option_arg
+
+    client = OrganizationClient()
+    result = client.get_memberships(email, start_page, page_size, order_key, order_direction, role_types)
+    Console.write_stdout(f"Memberships: \n{result}")
+
+
+get_memberships_options = [
+    Option(
+        "email",
+        ["--email", "-e"],
+        "Email address of the user (optional, case-insensitive)",
+        True
+    ),
+    Option(
+        "start_page",
+        ["--start-page"],
+        "Page number for pagination (default: 1)",
+        True
+    ),
+    Option(
+        "page_size",
+        ["--page-size"],
+        "Number of items per page (default: 20)",
+        True
+    ),
+    Option(
+        "order_key",
+        ["--order-key"],
+        "Field for sorting (only 'organizationName' supported)",
+        True
+    ),
+    Option(
+        "order_direction",
+        ["--order-direction"],
+        "Sort direction: asc or desc (default: desc)",
+        True
+    ),
+    Option(
+        "role_types",
+        ["--role-types"],
+        "Comma-separated list: backend, frontend (optional, case-insensitive)",
+        True
+    ),
+]
+
+
+def get_project_memberships(option_list: list):
+    email = None
+    start_page = 1
+    page_size = 20
+    order_key = None
+    order_direction = "desc"
+    role_types = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "email":
+            email = option_arg
+        if option_flag.name == "start_page":
+            start_page = int(option_arg)
+        if option_flag.name == "page_size":
+            page_size = int(option_arg)
+        if option_flag.name == "order_key":
+            order_key = option_arg
+        if option_flag.name == "order_direction":
+            order_direction = option_arg
+        if option_flag.name == "role_types":
+            role_types = option_arg
+
+    client = OrganizationClient()
+    result = client.get_project_memberships(email, start_page, page_size, order_key, order_direction, role_types)
+    Console.write_stdout(f"Project memberships: \n{result}")
+
+
+get_project_memberships_options = [
+    Option(
+        "email",
+        ["--email", "-e"],
+        "Email address of the user (optional, case-insensitive)",
+        True
+    ),
+    Option(
+        "start_page",
+        ["--start-page"],
+        "Page number for pagination (default: 1)",
+        True
+    ),
+    Option(
+        "page_size",
+        ["--page-size"],
+        "Number of items per page (default: 20)",
+        True
+    ),
+    Option(
+        "order_key",
+        ["--order-key"],
+        "Field for sorting (only 'projectName' supported)",
+        True
+    ),
+    Option(
+        "order_direction",
+        ["--order-direction"],
+        "Sort direction: asc or desc (default: desc)",
+        True
+    ),
+    Option(
+        "role_types",
+        ["--role-types"],
+        "Comma-separated list: backend, frontend (optional, case-insensitive)",
+        True
+    ),
+]
+
+
+def get_project_roles(option_list: list):
+    project_id = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+
+    if not project_id:
+        raise MissingRequirementException("Cannot retrieve project roles without project-id")
+
+    client = OrganizationClient()
+    result = client.get_project_roles(project_id)
+    Console.write_stdout(f"Project roles: \n{result}")
+
+
+get_project_roles_options = [
+    PROJECT_ID_OPTION,
+]
+
+
+def get_project_members(option_list: list):
+    project_id = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+
+    if not project_id:
+        raise MissingRequirementException("Cannot retrieve project members without project-id")
+
+    client = OrganizationClient()
+    result = client.get_project_members(project_id)
+    Console.write_stdout(f"Project members: \n{result}")
+
+
+get_project_members_options = [
+    PROJECT_ID_OPTION,
+]
+
+
+def get_organization_members(option_list: list):
+    organization_id = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "organization_id":
+            organization_id = option_arg
+
+    if not organization_id:
+        raise MissingRequirementException("Cannot retrieve organization members without organization-id")
+
+    client = OrganizationClient()
+    result = client.get_organization_members(organization_id)
+    Console.write_stdout(f"Organization members: \n{result}")
+
+
+get_organization_members_options = [
+    Option(
+        "organization_id",
+        ["--organization-id", "--oid"],
+        "GUID of the organization (required)",
+        True
+    ),
+]
+
 organization_commands = [
     Command(
         "help",
@@ -370,4 +566,49 @@ organization_commands = [
         [],
         export_request_data_options
     ),
+    Command(
+        "get_memberships",
+        ["get-memberships"],
+        "Get user memberships across organizations and projects",
+        get_memberships,
+        ArgumentsEnum.OPTIONAL,
+        [],
+        get_memberships_options
+    ),
+    Command(
+        "get_project_memberships",
+        ["get-project-memberships"],
+        "Get user project memberships within an organization",
+        get_project_memberships,
+        ArgumentsEnum.OPTIONAL,
+        [],
+        get_project_memberships_options
+    ),
+    Command(
+        "get_project_roles",
+        ["get-project-roles"],
+        "Get all roles supported by a project",
+        get_project_roles,
+        ArgumentsEnum.REQUIRED,
+        [],
+        get_project_roles_options
+    ),
+    Command(
+        "get_project_members",
+        ["get-project-members"],
+        "Get all members and their roles for a project",
+        get_project_members,
+        ArgumentsEnum.REQUIRED,
+        [],
+        get_project_members_options
+    ),
+    Command(
+        "get_organization_members",
+        ["get-organization-members"],
+        "Get all members and their roles for an organization",
+        get_organization_members,
+        ArgumentsEnum.REQUIRED,
+        [],
+        get_organization_members_options
+    ),
 ]

pygeai/cli/error_handler.py

@@ -0,0 +1,116 @@
+import traceback
+from difflib import SequenceMatcher
+from typing import List, Optional
+
+from pygeai import logger
+from pygeai.cli.commands import Command, Option
+from pygeai.core.utils.console import Console
+
+
+class ExitCode:
+    SUCCESS = 0
+    USER_INPUT_ERROR = 1
+    MISSING_REQUIREMENT = 2
+    SERVICE_ERROR = 3
+    KEYBOARD_INTERRUPT = 130
+    UNEXPECTED_ERROR = 255
+
+
+class ErrorHandler:
+
+    @staticmethod
+    def format_error(error_type: str, message: str, suggestion: Optional[str] = None, show_help: bool = True) -> str:
+        output = f"ERROR: {message}"
+        
+        if suggestion:
+            output += f"\n  → {suggestion}"
+        
+        if show_help:
+            output += "\n\nRun 'geai help' for usage information."
+        
+        return output
+
+    @staticmethod
+    def find_similar_items(item: str, available_items: List[str], threshold: float = 0.6) -> List[str]:
+        similarities = []
+        for available in available_items:
+            ratio = SequenceMatcher(None, item.lower(), available.lower()).ratio()
+            if ratio >= threshold:
+                similarities.append((available, ratio))
+        
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        return [item[0] for item in similarities[:3]]
+
+    @staticmethod
+    def get_available_commands(commands: List[Command]) -> List[str]:
+        all_identifiers = []
+        for cmd in commands:
+            all_identifiers.extend(cmd.identifiers)
+        return all_identifiers
+
+    @staticmethod
+    def get_available_options(options: List[Option]) -> List[str]:
+        all_identifiers = []
+        for opt in options:
+            all_identifiers.extend(opt.identifiers)
+        return all_identifiers
+
+    @staticmethod
+    def handle_unknown_command(command: str, available_commands: List[Command]) -> str:
+        cmd_identifiers = ErrorHandler.get_available_commands(available_commands)
+        similar = ErrorHandler.find_similar_items(command, cmd_identifiers)
+        
+        message = f"'{command}' is not a valid command."
+        
+        if similar:
+            suggestion = f"Did you mean: {', '.join(similar)}?"
+        else:
+            suggestion = f"Available commands: {', '.join(sorted(set([cmd.identifiers[0] for cmd in available_commands])))}"
+        
+        return ErrorHandler.format_error("Unknown Command", message, suggestion)
+
+    @staticmethod
+    def handle_unknown_option(option: str, available_options: List[Option]) -> str:
+        opt_identifiers = ErrorHandler.get_available_options(available_options)
+        similar = ErrorHandler.find_similar_items(option, opt_identifiers)
+        
+        message = f"'{option}' is not a valid option."
+        
+        if similar:
+            suggestion = f"Did you mean: {', '.join(similar)}?"
+        else:
+            suggestion = f"Available options: {', '.join(sorted(set([opt.identifiers[0] for opt in available_options])))}"
+        
+        return ErrorHandler.format_error("Unknown Option", message, suggestion)
+
+    @staticmethod
+    def handle_missing_requirement(requirement_message: str) -> str:
+        message = requirement_message
+        suggestion = "Please provide all required parameters."
+        return ErrorHandler.format_error("Missing Requirement", message, suggestion)
+
+    @staticmethod
+    def handle_invalid_agent(error_message: str) -> str:
+        message = f"Failed to retrieve or validate the agent.\n  Details: {error_message}"
+        suggestion = "Check your agent configuration and ensure the agent exists."
+        return ErrorHandler.format_error("Invalid Agent", message, suggestion)
+
+    @staticmethod
+    def handle_wrong_argument(error_message: str, usage: str) -> str:
+        Console.write_stderr(f"usage: {usage}")
+        message = error_message
+        suggestion = "Check the command syntax and try again."
+        return ErrorHandler.format_error("Invalid Argument", message, suggestion)
+
+    @staticmethod
+    def handle_keyboard_interrupt() -> str:
+        return "\n\nOperation cancelled by user."
+
+    @staticmethod
+    def handle_unexpected_error(exception: Exception) -> str:
+        logger.error(f"Unexpected error occurred: {exception}")
+        logger.error(traceback.format_exc())
+        
+        message = "An unexpected error occurred. This may be a bug."
+        suggestion = f"Please report this issue to geai-sdk@globant.com with the following details:\n  Error: {str(exception)}\n  Run with geai-dbg for more details."
+        return ErrorHandler.format_error("Critical Error", message, suggestion, show_help=False)

pygeai/cli/geai.py

@@ -5,6 +5,7 @@ from pygeai.cli.commands.base import base_commands, base_options
 from pygeai.cli.commands import ArgumentsEnum, Command
 from pygeai.cli.parsers import CommandParser
 from pygeai.cli.texts.help import CLI_USAGE
+from pygeai.cli.error_handler import ErrorHandler, ExitCode
 from pygeai.core.base.session import get_session
 from pygeai.core.common.exceptions import UnknownArgumentError, MissingRequirementException, WrongArgumentError, \
     InvalidAgentException
@@ -64,19 +65,37 @@ class CLIDriver:
                 arguments = []
 
             self.process_command(command, arguments)
-        except (UnknownArgumentError, WrongArgumentError) as e:
-            Console.write_stderr(f"usage: {CLI_USAGE}")
-            Console.write_stderr(str(e))
-            Console.write_stderr()
+            return ExitCode.SUCCESS
+        except UnknownArgumentError as e:
+            if hasattr(e, 'available_commands') and e.available_commands:
+                error_msg = ErrorHandler.handle_unknown_command(e.arg, e.available_commands)
+            elif hasattr(e, 'available_options') and e.available_options:
+                error_msg = ErrorHandler.handle_unknown_option(e.arg, e.available_options)
+            else:
+                error_msg = ErrorHandler.format_error("Unknown Argument", str(e))
+            
+            Console.write_stderr(error_msg)
+            return ExitCode.USER_INPUT_ERROR
+        except WrongArgumentError as e:
+            error_msg = ErrorHandler.handle_wrong_argument(str(e), CLI_USAGE)
+            Console.write_stderr(error_msg)
+            return ExitCode.USER_INPUT_ERROR
         except MissingRequirementException as e:
-            Console.write_stderr(f"ERROR: Something is missing! \nDetail: {e}")
+            error_msg = ErrorHandler.handle_missing_requirement(str(e))
+            Console.write_stderr(error_msg)
+            return ExitCode.MISSING_REQUIREMENT
         except InvalidAgentException as e:
-            Console.write_stderr(f"ERROR: There was an error retrieving the agent. \nDetail: {e}")
+            error_msg = ErrorHandler.handle_invalid_agent(str(e))
+            Console.write_stderr(error_msg)
+            return ExitCode.SERVICE_ERROR
         except KeyboardInterrupt:
-            Console.write_stdout()
+            message = ErrorHandler.handle_keyboard_interrupt()
+            Console.write_stdout(message)
+            return ExitCode.KEYBOARD_INTERRUPT
         except Exception as e:
-            Console.write_stderr(f"CRITICAL: There has ben an unexpected error. Please report this bug to geai-sdk@globant.com. Error: {e}")
-            return 255
+            error_msg = ErrorHandler.handle_unexpected_error(e)
+            Console.write_stderr(error_msg)
+            return ExitCode.UNEXPECTED_ERROR
 
     def process_command(self, command: Command, arguments: list[str]):
         """
@@ -107,4 +126,3 @@ class CLIDriver:
             else:
                 option_list = CommandParser(None, subcommand.options).extract_option_list(subcommand_arguments)
                 subcommand.action(option_list)
-

pygeai/cli/parsers.py

@@ -18,7 +18,10 @@ class CommandParser:
         """
         command = self._get_associated_command(arg)
         if not command:
-            raise UnknownArgumentError(f"'{arg}' is not a valid command. Run with help or h to check usage.")
+            error = UnknownArgumentError(f"'{arg}' is not a valid command.")
+            error.arg = arg
+            error.available_commands = self.available_commands
+            raise error
 
         return command
 
@@ -39,7 +42,10 @@ class CommandParser:
 
             flag = self._get_associated_option(arg)
             if not flag:
-                raise UnknownArgumentError(f"'{arg}' is not a valid option. Run with help or h to check usage.")
+                error = UnknownArgumentError(f"'{arg}' is not a valid option.")
+                error.arg = arg
+                error.available_options = self.available_options
+                raise error
 
             if flag.requires_args:
                 complementary_arg = True

pygeai/core/base/clients.py

@@ -3,6 +3,7 @@ from abc import ABC
 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):
@@ -19,7 +20,9 @@ class BaseClient(ABC):
             if not self.__session:
                 raise MissingRequirementException("API KEY and BASE URL must be defined in order to use this functionality")
         elif api_key and base_url:
-            self.__session = Session(api_key=api_key, base_url=base_url)
+            self.__session = get_session()
+            self.__session.api_key = api_key
+            self.__session.base_url = base_url
         else:
             self.__session = get_session()
 

pygeai/core/common/exceptions.py

@@ -6,55 +6,56 @@ class GEAIException(Exception):
 
 
 class UnknownArgumentError(GEAIException):
-    """Argument provided is not valid"""
+    """Raised when an unknown or invalid command/option is provided"""
     pass
 
 
 class MissingRequirementException(GEAIException):
-    """Requirement not available"""
+    """Raised when a required parameter or argument is missing"""
     pass
 
 
 class WrongArgumentError(GEAIException):
-    """Wrongly formatted arguments"""
+    """Raised when arguments are incorrectly formatted or invalid"""
     pass
 
 
 class ServerResponseError(GEAIException):
-    """There was an error in the request to the server"""
+    """Raised when the server returns an error response"""
     pass
 
 
 class APIError(GEAIException):
-    """There was an error in the request to the server"""
+    """Raised when an API request fails"""
     pass
 
 
 class InvalidPathException(GEAIException):
-    """There was an error trying to find the file in the specified path"""
+    """Raised when a file or directory path is invalid or not found"""
     pass
 
 
 class InvalidJSONException(GEAIException):
-    """There was an error trying to load data from the JSON file"""
+    """Raised when JSON data cannot be parsed or is malformed"""
     pass
 
 
 class InvalidAPIResponseException(GEAIException):
-    """There was an error handling response from the server"""
+    """Raised when the API response format is unexpected or invalid"""
     pass
 
 
 class InvalidResponseException(GEAIException):
-    """There was an error getting a response from the server"""
+    """Raised when a response cannot be retrieved or processed"""
     pass
 
 
 class InvalidAgentException(GEAIException):
-    """There was an error getting a response from the server"""
+    """Raised when an agent cannot be retrieved, validated, or is misconfigured"""
     pass
 
 
 class APIResponseError(GEAIException):
+    """Raised when there is an error in the API response"""
     pass
 

pygeai/core/embeddings/__init__.py

@@ -0,0 +1,19 @@
+from pygeai.core.embeddings.clients import EmbeddingsClient
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.embeddings.responses import (
+    EmbeddingResponse,
+    EmbeddingData,
+    UsageInfo,
+    TokenDetails
+)
+
+__all__ = [
+    'EmbeddingsClient',
+    'EmbeddingsManager',
+    'EmbeddingConfiguration',
+    'EmbeddingResponse',
+    'EmbeddingData',
+    'UsageInfo',
+    'TokenDetails'
+]

pygeai/core/embeddings/clients.py

@@ -1,9 +1,10 @@
-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.common.exceptions import InvalidAPIResponseException, APIResponseError
 from pygeai.core.embeddings.endpoints import GENERATE_EMBEDDINGS
+from pygeai.core.utils.validators import validate_status_code
+from pygeai.core.utils.parsers import parse_json_response
 
 
 class EmbeddingsClient(BaseClient):
@@ -42,7 +43,21 @@ class EmbeddingsClient(BaseClient):
 
         :return: dict - A dictionary containing the embedding results, including the model used, the generated
                         embedding vectors, and usage statistics.
+        :raises ValueError: If validation fails for input parameters.
         """
+        if not input_list or len(input_list) == 0:
+            raise ValueError("input_list cannot be empty")
+        
+        for idx, inp in enumerate(input_list):
+            if not inp or (isinstance(inp, str) and inp.strip() == ""):
+                raise ValueError(f"Input at index {idx} cannot be empty")
+        
+        if encoding_format is not None and encoding_format not in ['float', 'base64']:
+            raise ValueError("encoding_format must be either 'float' or 'base64'")
+        
+        if dimensions is not None and dimensions <= 0:
+            raise ValueError("dimensions must be a positive integer")
+        
         data = {
             'model': model,
             'input': input_list,
@@ -73,10 +88,6 @@ class EmbeddingsClient(BaseClient):
             data=data,
             headers=headers
         )
-        try:
-            result = response.json()
-            return result
-        except JSONDecodeError as e:
-            logger.error(f"Unable to generate embeddings: JSON parsin error: {e}; Response: {response.text}")
-            raise InvalidAPIResponseException(f"Unable to generate embeddings: {response.text}")
-
+        validate_status_code(response)
+        return parse_json_response(response, "generate embeddings")
+        

pygeai/core/embeddings/mappers.py

@@ -1,4 +1,4 @@
-from pygeai.core.embeddings.responses import EmbeddingResponse, EmbeddingData, UsageInfo
+from pygeai.core.embeddings.responses import EmbeddingResponse, EmbeddingData, UsageInfo, TokenDetails
 
 
 class EmbeddingsResponseMapper:
@@ -29,10 +29,24 @@ class EmbeddingsResponseMapper:
 
     @classmethod
     def map_to_usage_info(cls, data: dict) -> UsageInfo:
+        completion_tokens_details_data = data.get('completion_tokens_details')
+        prompt_tokens_details_data = data.get('prompt_tokens_details')
+        
         return UsageInfo(
             prompt_tokens=data.get('prompt_tokens', 0),
             total_cost=data.get('total_cost', 0.0),
             total_tokens=data.get('total_tokens', 0),
             currency=data.get('currency', ''),
-            prompt_cost=data.get('prompt_cost', 0.0)
+            prompt_cost=data.get('prompt_cost', 0.0),
+            completion_tokens_details=cls._parse_token_details(completion_tokens_details_data),
+            prompt_tokens_details=cls._parse_token_details(prompt_tokens_details_data)
+        )
+
+    @classmethod
+    def _parse_token_details(cls, data: dict) -> TokenDetails | None:
+        if data is None:
+            return None
+        return TokenDetails(
+            reasoning_tokens=data.get('reasoning_tokens'),
+            cached_tokens=data.get('cached_tokens')
         )

pygeai/core/embeddings/responses.py

@@ -1,11 +1,16 @@
-from typing import List
+from typing import List, Union, Optional
 
 from pydantic.main import BaseModel
 
 
+class TokenDetails(BaseModel):
+    reasoning_tokens: Optional[int] = None
+    cached_tokens: Optional[int] = None
+
+
 class EmbeddingData(BaseModel):
     index: int
-    embedding: List[float]
+    embedding: Union[List[float], str]
     object: str
 
 
@@ -15,6 +20,8 @@ class UsageInfo(BaseModel):
     total_tokens: int
     currency: str
     prompt_cost: float
+    completion_tokens_details: Optional[TokenDetails] = None
+    prompt_tokens_details: Optional[TokenDetails] = None
 
 
 class EmbeddingResponse(BaseModel):