pygeai 0.7.0b1__py3-none-any.whl → 0.7.0b4__py3-none-any.whl

pygeai/chat/clients.py

@@ -178,27 +178,39 @@ class ChatClient(BaseClient):
         """
         Processes a streaming response and yields content strings.
 
+        Optimized for performance:
+        - Early exits to avoid unnecessary processing
+        - Reduced string operations
+        - Single dict lookups with guards
+
         :param response: The streaming response from the API.
         :return: Generator[str, None, None] - Yields content strings extracted from streaming chunks.
         """
         try:
             for line in response:
-                if line.startswith("data:"):
-                    chunk = line[5:].strip()
-                    if chunk == "[DONE]":
-                        break
-                    try:
-                        json_data = json.loads(chunk)
-                        if (
-                                json_data.get("choices")
-                                and len(json_data["choices"]) > 0
-                                and "delta" in json_data["choices"][0]
-                                and "content" in json_data["choices"][0]["delta"]
-                        ):
-                            content = json_data["choices"][0]["delta"]["content"]
-                            yield content
-                    except JSONDecodeError:
-                        continue
+                if not line.startswith("data:"):
+                    continue
+                
+                chunk = line[5:].strip()
+                if chunk == "[DONE]":
+                    break
+                
+                try:
+                    json_data = json.loads(chunk)
+                except JSONDecodeError:
+                    continue
+                
+                choices = json_data.get("choices")
+                if not choices:
+                    continue
+                
+                first_choice = choices[0] if choices else None
+                if not first_choice:
+                    continue
+                
+                delta = first_choice.get("delta")
+                if delta and "content" in delta:
+                    yield delta["content"]
         except Exception as e:
             raise InvalidAPIResponseException(f"Unable to process streaming chat response: {e}")
 
@@ -206,27 +218,39 @@ class ChatClient(BaseClient):
         """
         Processes a streaming response from the Responses API and yields content strings.
 
+        Optimized for performance:
+        - Early exits to avoid unnecessary processing
+        - Reduced string operations
+        - Single dict lookups with guards
+
         :param response: The streaming response from the API.
         :return: Generator[str, None, None] - Yields content strings extracted from streaming chunks.
         """
         try:
             for line in response:
-                if line.startswith("data:"):
-                    chunk = line[5:].strip()
-                    if chunk == "[DONE]":
-                        break
-                    try:
-                        json_data = json.loads(chunk)
-                        if (
-                                json_data.get("choices")
-                                and len(json_data["choices"]) > 0
-                                and "delta" in json_data["choices"][0]
-                                and "content" in json_data["choices"][0]["delta"]
-                        ):
-                            content = json_data["choices"][0]["delta"]["content"]
-                            yield content
-                    except JSONDecodeError:
-                        continue
+                if not line.startswith("data:"):
+                    continue
+                
+                chunk = line[5:].strip()
+                if chunk == "[DONE]":
+                    break
+                
+                try:
+                    json_data = json.loads(chunk)
+                except JSONDecodeError:
+                    continue
+                
+                choices = json_data.get("choices")
+                if not choices:
+                    continue
+                
+                first_choice = choices[0] if choices else None
+                if not first_choice:
+                    continue
+                
+                delta = first_choice.get("delta")
+                if delta and "content" in delta:
+                    yield delta["content"]
         except Exception as e:
             raise InvalidAPIResponseException(f"Unable to process streaming response: {e}")
 

pygeai/cli/commands/base.py

@@ -1,3 +1,9 @@
+import signal
+import sys
+import time
+from datetime import datetime
+from typing import Optional
+
 from pygeai.cli.commands import ArgumentsEnum, Command, Option
 from pygeai.cli.commands.admin import admin_commands
 from pygeai.cli.commands.analytics import analytics_commands
@@ -53,12 +59,142 @@ def check_for_updates():
     Console.write_stdout(f"{version_status}")
 
 
-def check_api_status():
+def check_api_status(option_list: list = None):
     """
-    Checks API status
+    Checks API status with optional monitoring capabilities
+    
+    :param option_list: List of tuples (option, value) including monitor, file, interval, and count
     """
-    api_status = HealthClient().check_api_status()
-    Console.write_stdout(f"API Status: {api_status}")
+    if option_list is None or not any(option_list):
+        api_status = HealthClient().check_api_status()
+        Console.write_stdout(f"API Status: {api_status}")
+        return
+    
+    options_dict = {opt.name: arg for opt, arg in option_list}
+    
+    monitor = 'monitor' in options_dict
+    file_path = options_dict.get('file')
+    interval = int(options_dict.get('interval', 5)) if 'interval' in options_dict else 5
+    count = int(options_dict.get('count', 0)) if 'count' in options_dict else 0
+    
+    if not monitor:
+        api_status = HealthClient().check_api_status()
+        Console.write_stdout(f"API Status: {api_status}")
+        return
+    
+    health_client = HealthClient()
+    check_count = 0
+    success_count = 0
+    failure_count = 0
+    downtime_periods = []
+    current_downtime_start = None
+    interrupted = False
+    
+    file_handle = None
+    if file_path:
+        try:
+            file_handle = open(file_path, 'w')
+            file_handle.write("Timestamp,Status,Running,Version,Error\n")
+        except Exception as e:
+            Console.write_stdout(f"Warning: Could not open file {file_path}: {e}")
+            file_handle = None
+    
+    def signal_handler(sig, frame):
+        nonlocal interrupted
+        interrupted = True
+    
+    signal.signal(signal.SIGINT, signal_handler)
+    
+    Console.write_stdout(f"Monitoring API status every {interval} seconds. Press Ctrl+C to stop...")
+    Console.write_stdout("")
+    
+    try:
+        while True:
+            timestamp = datetime.now()
+            timestamp_str = timestamp.strftime("%Y-%m-%d %H:%M:%S")
+            
+            try:
+                api_status = health_client.check_api_status()
+                check_count += 1
+                
+                running = api_status.get('running', False)
+                version = api_status.get('version', 'N/A')
+                
+                if running:
+                    success_count += 1
+                    status = "✓ UP"
+                    if current_downtime_start:
+                        downtime_end = timestamp
+                        downtime_periods.append((current_downtime_start, downtime_end))
+                        current_downtime_start = None
+                else:
+                    failure_count += 1
+                    status = "✗ DOWN"
+                    if not current_downtime_start:
+                        current_downtime_start = timestamp
+                
+                Console.write_stdout(f"[{timestamp_str}] {status} - Version: {version}")
+                
+                if file_handle:
+                    file_handle.write(f"{timestamp_str},{'UP' if running else 'DOWN'},{running},{version},\n")
+                    file_handle.flush()
+                    
+            except Exception as e:
+                check_count += 1
+                failure_count += 1
+                status = "✗ ERROR"
+                error_msg = str(e)
+                
+                Console.write_stdout(f"[{timestamp_str}] {status} - {error_msg}")
+                
+                if not current_downtime_start:
+                    current_downtime_start = timestamp
+                
+                if file_handle:
+                    file_handle.write(f"{timestamp_str},ERROR,False,N/A,{error_msg}\n")
+                    file_handle.flush()
+            
+            if count > 0 and check_count >= count:
+                break
+            
+            if interrupted:
+                Console.write_stdout("\nMonitoring stopped by user.")
+                break
+            
+            time.sleep(interval)
+            
+    finally:
+        if current_downtime_start:
+            downtime_periods.append((current_downtime_start, datetime.now()))
+        
+        if file_handle:
+            file_handle.close()
+        
+        Console.write_stdout("")
+        Console.write_stdout("=" * 60)
+        Console.write_stdout("MONITORING SUMMARY")
+        Console.write_stdout("=" * 60)
+        Console.write_stdout(f"Total checks performed: {check_count}")
+        Console.write_stdout(f"Successful checks: {success_count}")
+        Console.write_stdout(f"Failed checks: {failure_count}")
+        
+        if success_count > 0:
+            uptime_percentage = (success_count / check_count) * 100
+            Console.write_stdout(f"Uptime: {uptime_percentage:.2f}%")
+        
+        if downtime_periods:
+            total_downtime = sum(
+                (end - start).total_seconds()
+                for start, end in downtime_periods
+            )
+            Console.write_stdout(f"Estimated total downtime: {total_downtime:.2f} seconds ({total_downtime/60:.2f} minutes)")
+            Console.write_stdout(f"Number of downtime incidents: {len(downtime_periods)}")
+        else:
+            Console.write_stdout("No downtime detected during monitoring period")
+        
+        if file_path:
+            Console.write_stdout(f"Results saved to: {file_path}")
+        Console.write_stdout("=" * 60)
 
 
 """
@@ -99,9 +235,34 @@ base_commands = [
         ["status", "s"],
         "Check API status for Globant Enterprise AI instance",
         check_api_status,
-        ArgumentsEnum.NOT_AVAILABLE,
+        ArgumentsEnum.OPTIONAL,
         [],
-        []
+        [
+            Option(
+                "monitor",
+                ["--monitor", "-m"],
+                "Enable continuous monitoring mode",
+                False
+            ),
+            Option(
+                "file",
+                ["--file", "-f"],
+                "Log status checks to specified file",
+                True
+            ),
+            Option(
+                "interval",
+                ["--interval", "-i"],
+                "Interval in seconds between checks (default: 5)",
+                True
+            ),
+            Option(
+                "count",
+                ["--count", "-c"],
+                "Number of times to check before stopping (default: infinite)",
+                True
+            ),
+        ]
     ),
     Command(
         "configure",

pygeai/cli/commands/migrate.py

@@ -703,7 +703,6 @@ def clone_project(option_list: list) -> None:
         logger.debug(f"  - to_organization_api_key exists: {to_organization_api_key is not None}")
         logger.debug(f"  - from_organization_api_key exists: {from_organization_api_key is not None}")
         logger.debug(f"  - Using key (first 20 chars): {org_key_to_use[:20] if org_key_to_use else 'None'}...")
-        Console.write_stderr(f"DEBUG: Using org key for project creation (first 20 chars): {org_key_to_use[:20] if org_key_to_use else 'None'}...")
         
         project_strategy = ProjectMigrationStrategy(
             from_api_key=from_organization_api_key,
@@ -993,7 +992,7 @@ clone_project_options = [
     ),
     Option(
         "from_organization_api_key",
-        ["--from-org-key", "--from-organization-key"],
+        ["--from-org-key", "--from-organization-key", "--from-organization-api-key"],
         "Source instance organization scope API key (optional, for project creation)",
         True
     ),
@@ -1023,7 +1022,7 @@ clone_project_options = [
     ),
     Option(
         "to_organization_api_key",
-        ["--to-org-key", "--to-organization-key"],
+        ["--to-org-key", "--to-organization-key", "--to-organization-api-key"],
         "Destination instance organization scope API key (optional, for project creation)",
         True
     ),

pygeai/cli/geai.py

@@ -107,10 +107,14 @@ class CLIDriver:
         elif "--alias" in arguments:
             alias_index = arguments.index("--alias")
 
-        _ = arguments.pop(alias_index)
-        alias = arguments.pop(alias_index)
-        return alias
-    
+        try:
+            _ = arguments.pop(alias_index)
+            alias = arguments.pop(alias_index)
+            return alias
+        except IndexError as e:
+            Console.write_stderr("-a/--alias option requires an alias. Please provide a valid alias after the option")
+            raise MissingRequirementException("Couldn't find a valid alias in parameter list.")
+
     def _get_credentials_file(self, arguments: List[str]) -> str:
         """
         Retrieves and removes credentials file path and flag from argument list.
@@ -126,9 +130,13 @@ class CLIDriver:
         elif "--creds" in arguments:
             creds_index = arguments.index("--creds")
 
-        _ = arguments.pop(creds_index)
-        credentials_file = arguments.pop(creds_index)
-        return credentials_file
+        try:
+            _ = arguments.pop(creds_index)
+            credentials_file = arguments.pop(creds_index)
+            return credentials_file
+        except IndexError as e:
+            Console.write_stderr("--creds/--credentials option requires a file path. Please provide a valid path after the option.")
+            raise MissingRequirementException("Couldn't find a valid path in parameter list.")
 
     def main(self, args: Optional[List[str]] = None) -> int:
         """

pygeai/cli/texts/help.py

@@ -107,7 +107,32 @@ EXAMPLES
     will help you setup the required environment variables to work with GEAI.
     
     The command:
-        ...
+        geai version
+    displays the current version of the GEAI CLI utility.
+    
+    The command:
+        geai check-updates
+    checks if there are new versions of the GEAI package available.
+    
+    The command:
+        geai status
+    checks the current API status of the Globant Enterprise AI instance.
+    
+    The command:
+        geai status -m -i 10
+    monitors the API status every 10 seconds until stopped with Ctrl+C.
+    
+    The command:
+        geai admin validate-token
+    validates your API token and displays organization and project information.
+    
+    The command:
+        geai llm list-providers
+    lists all available LLM providers in GEAI.
+    
+    The command:
+        geai emb generate -i "Hello world" -m "openai/text-embedding-3-small"
+    generates embeddings for the provided text using the specified model
     
 INSTALL MAN PAGES
     To install the manual pages, run:

pygeai/core/handlers.py

@@ -5,23 +5,36 @@ class ErrorHandler:
 
     @classmethod
     def has_errors(cls, response):
-        error_found = False
-        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
+        """
+        Check if the response contains errors.
+        
+        Handles both dict and string responses for backward compatibility.
+        Optimized to reduce redundant dictionary lookups when response is a dict.
+        
+        :param response: Response (dict or string) to check
+        :return: True if errors found, False otherwise
+        """
+        if "errors" in response or "error" in response:
+            return True
+        
+        if not isinstance(response, dict):
+            return False
+        
+        message = response.get("message")
+        return (
+            isinstance(message, list) and
+            message and
+            message[0].get("type") == "error"
+        )
 
     @classmethod
     def extract_error(cls, response):
+        """
+        Extract and map error information from response.
+        
+        :param response: Response dictionary containing error
+        :return: Mapped error object
+        """
         if "errors" in response:
             result = ErrorMapper.map_to_error_list_response(response)
         elif "error" in response:

pygeai/core/utils/console.py

@@ -1,3 +1,4 @@
+import os
 import sys
 from abc import ABC, abstractmethod
 
@@ -11,10 +12,19 @@ class StreamWriter(ABC):
     def write_stdout(self, message: str = "", end: str = "\n"):
         pass
 
+    @abstractmethod
+    def write_success(self, message: str = "", end: str = "\n"):
+        pass
+
+    @abstractmethod
+    def write_warning(self, message: str = "", end: str = "\n"):
+        pass
+
     @abstractmethod
     def write_stderr(self, message: str = "", end: str = "\n"):
         pass
 
+
 class ConsoleMeta(type):
     def __getattr__(cls, name):
         writer = cls._writer
@@ -26,6 +36,7 @@ class ConsoleMeta(type):
             pass
         return noop
 
+
 class Console(metaclass=ConsoleMeta):
     """
     A utility class for writing messages to standard output and standard error streams.
@@ -39,14 +50,45 @@ class Console(metaclass=ConsoleMeta):
     """
     class DefaultStreamWriter(StreamWriter):
         """
-        Default StreamWriter that writes to sys.stdout and sys.stderr.
+        Default StreamWriter that writes to sys.stdout and sys.stderr with color support.
         """
+        
+        # ANSI color codes
+        GREEN = "\033[32m"
+        YELLOW = "\033[33m"
+        RED = "\033[31m"
+        RESET = "\033[0m"
+        
+        @staticmethod
+        def _should_use_color(stream) -> bool:
+            """Check if colors should be used based on terminal support and environment."""
+            if os.getenv("NO_COLOR"):
+                return False
+            return hasattr(stream, "isatty") and stream.isatty()
+        
         def write_stdout(self, message: str = "", end: str = "\n"):
             sys.stdout.write(f"{message}{end}")
             sys.stdout.flush()
 
+        def write_success(self, message: str = "", end: str = "\n"):
+            if self._should_use_color(sys.stdout):
+                sys.stdout.write(f"{self.GREEN}{message}{self.RESET}{end}")
+            else:
+                sys.stdout.write(f"{message}{end}")
+            sys.stdout.flush()
+
+        def write_warning(self, message: str = "", end: str = "\n"):
+            if self._should_use_color(sys.stderr):
+                sys.stderr.write(f"{self.YELLOW}{message}{self.RESET}{end}")
+            else:
+                sys.stderr.write(f"{message}{end}")
+            sys.stderr.flush()
+
         def write_stderr(self, message: str = "", end: str = "\n"):
-            sys.stderr.write(f"{message}{end}")
+            if self._should_use_color(sys.stderr):
+                sys.stderr.write(f"{self.RED}{message}{self.RESET}{end}")
+            else:
+                sys.stderr.write(f"{message}{end}")
             sys.stderr.flush()
 
     _writer: StreamWriter = DefaultStreamWriter()
@@ -57,18 +99,40 @@ class Console(metaclass=ConsoleMeta):
         Writes a message to the standard output stream (sys.stdout).
 
         :param message: str - The message to write. Defaults to an empty string.
-        :param end: str - The string to append after the message. Defaults to a newline ('\n').
+        :param end: str - The string to append after the message. Defaults to a newline ('\\n').
         :return: None - No return value; output is written to sys.stdout.
         """
         Console._writer.write_stdout(message, end)
 
+    @staticmethod
+    def write_success(message: str = "", end: str = "\n"):
+        """
+        Writes a success message to the standard output stream (sys.stdout) in green.
+
+        :param message: str - The message to write. Defaults to an empty string.
+        :param end: str - The string to append after the message. Defaults to a newline ('\\n').
+        :return: None - No return value; output is written to sys.stdout.
+        """
+        Console._writer.write_success(message, end)
+
+    @staticmethod
+    def write_warning(message: str = "", end: str = "\n"):
+        """
+        Writes a warning message to the standard error stream (sys.stderr) in yellow.
+
+        :param message: str - The message to write. Defaults to an empty string.
+        :param end: str - The string to append after the message. Defaults to a newline ('\\n').
+        :return: None - No return value; output is written to sys.stderr.
+        """
+        Console._writer.write_warning(message, end)
+
     @staticmethod
     def write_stderr(message: str = "", end: str = "\n"):
         """
-        Writes a message to the standard error stream (sys.stderr).
+        Writes a message to the standard error stream (sys.stderr) in red.
 
         :param message: str - The message to write. Defaults to an empty string.
-        :param end: str - The string to append after the message. Defaults to a newline ('\n').
+        :param end: str - The string to append after the message. Defaults to a newline ('\\n').
         :return: None - No return value; output is written to sys.stderr.
         """
         Console._writer.write_stderr(message, end)

pygeai/core/utils/parsers.py

@@ -8,6 +8,9 @@ def parse_json_response(response, operation: str, **context):
     """
     Parse JSON response with standardized error handling.
 
+    Optimized to keep the hot path (success case) fast by separating
+    error handling logic into a dedicated function.
+
     :param response: HTTP response object
     :param operation: Description of operation (e.g., "get project API token")
     :param context: Additional context (e.g., api_token_id="123")
@@ -17,16 +20,34 @@ def parse_json_response(response, operation: str, **context):
     try:
         return response.json()
     except JSONDecodeError as e:
-        full_msg = f"Unable to {operation}"
-        if context:
-            if len(context) == 1:
-                # Single context value: append as 'value'
-                value = list(context.values())[0]
-                full_msg += f" '{value}'"
-            else:
-                # Multiple context values: format as (key1='value1', key2='value2')
-                context_str = ", ".join([f"{k}='{v}'" for k, v in context.items()])
-                full_msg += f" ({context_str})"
+        _handle_json_parse_error(response, operation, context, e)
+
 
-        logger.error(f"{full_msg}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
-        raise InvalidAPIResponseException(f"{full_msg}: {response.text}")
+def _handle_json_parse_error(response, operation: str, context: dict, error: JSONDecodeError):
+    """
+    Handle JSON parsing errors with detailed error messages.
+    
+    Separated from main parsing function to optimize the hot path.
+    This function is only called when parsing fails (rare case).
+    
+    :param response: HTTP response object
+    :param operation: Description of operation
+    :param context: Additional context parameters
+    :param error: The JSONDecodeError that occurred
+    :raises InvalidAPIResponseException: Always raises with detailed message
+    """
+    full_msg = f"Unable to {operation}"
+    
+    if context:
+        if len(context) == 1:
+            value = next(iter(context.values()))
+            full_msg += f" '{value}'"
+        else:
+            context_str = ", ".join(f"{k}='{v}'" for k, v in context.items())
+            full_msg += f" ({context_str})"
+    
+    logger.error(
+        f"{full_msg}: JSON parsing error (status {response.status_code}): {error}. "
+        f"Response: {response.text}"
+    )
+    raise InvalidAPIResponseException(f"{full_msg}: {response.text}")

pygeai/lab/models.py

@@ -427,7 +427,7 @@ class AgentData(CustomBaseModel):
     :param resource_pools: Optional[List[ResourcePool]] - List of resource pools organizing tools and helper agents.
     """
     prompt: Prompt = Field(..., alias="prompt")
-    llm_config: LlmConfig = Field(..., alias="llmConfig")
+    llm_config: LlmConfig = Field(None, alias="llmConfig")
     strategy_name: Optional[str] = Field("Dynamic Prompting", alias="strategyName")
     models: Optional[Union[ModelList, List[Model]]] = Field(None, alias="models")
     resource_pools: Optional[ResourcePoolList] = Field(None, alias="resourcePools", description="List of resource pools organizing tools and helper agents")

pygeai/lab/processes/endpoints.py

@@ -2,7 +2,7 @@ CREATE_PROCESS_V2 = "v2/processes"  # POST -> Create process
 UPDATE_PROCESS_V2 = "v2/processes/{processId}"  # PUT -> Update process
 UPSERT_PROCESS_V2 = "v2/processes/{processId}/upsert"  # PUT -> Update or insert process
 GET_PROCESS_V2 = "v2/processes/{processId}"  # GET -> Get process
-LIST_PROCESSES_V2 = "v2/processes"  # GET -> Get process
+LIST_PROCESSES_V2 = "v2/processes"  # GET -> Get process list
 LIST_PROCESS_INSTANCES_V2 = "v2/processes/{processId}/instances"  # GET -> Get process instances
 DELETE_PROCESS_V2 = "v2/processes/{processId}"  # DELETE -> Get process
 PUBLISH_PROCESS_REVISION_V2 = "v2/processes/{processId}/publish-revision"  # POST -> Publish process revision