pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/cli/commands/common.py

@@ -109,39 +109,43 @@ def get_messages(message_list: list):
     return messages
 
 
-def get_boolean_value(option_arg: str):
+def get_boolean_value(option_arg: str) -> bool:
     """
-   Converts a string argument into a boolean value.
-
-   :param option_arg: str - A string representation of an integer (e.g., "0" or "1") to be converted to a boolean.
-                          "0" is interpreted as `False`, and "1" is interpreted as `True`.
-   :return: bool - The boolean value corresponding to the input.
-   :raises WrongArgumentError: If the input is not a valid integer or is not "0" or "1".
-                               Possible values for `option_arg` are "0" (off) or "1" (on).
-   """
-    try:
-        return bool(int(option_arg))
-    except ValueError as e:
+    Converts a string argument into a boolean value with flexible input formats.
+
+    :param option_arg: str - A string representation of a boolean.
+                            Accepts: "0"/"1", "true"/"false", "yes"/"no", "on"/"off".
+    :return: bool - The boolean value corresponding to the input.
+    :raises WrongArgumentError: If the input is not a valid boolean representation.
+    """
+    normalized = option_arg.lower().strip()
+    
+    if normalized in ("0", "false", "no", "off"):
+        return False
+    elif normalized in ("1", "true", "yes", "on"):
+        return True
+    else:
         raise WrongArgumentError("Possible values are 0 or 1, for off and on, respectively.")
 
 
-def get_penalty_float_value(option_arg: str):
+def get_penalty_float_value(option_arg: str) -> float:
     """
-   Converts a string argument into a float value representing a penalty and validates its range.
+    Converts a string argument into a float value representing a penalty and validates its range.
 
-   :param option_arg: str - A string representation of a float to be converted to a penalty value.
+    :param option_arg: str - A string representation of a float to be converted to a penalty value.
                             The value must be between -2.0 and 2.0 (inclusive).
-   :return: float - The float value corresponding to the input, if valid.
-   :raises WrongArgumentError: If the input is not a valid float or if the value is outside the range [-2.0, 2.0].
-                               The penalty must be a number between -2.0 and 2.0.
-   """
+    :return: float - The float value corresponding to the input, if valid.
+    :raises WrongArgumentError: If the input is not a valid float or if the value is outside the range [-2.0, 2.0].
+    """
     try:
-        penalty = float(option_arg)
-        if penalty < -2.0 or 2.0 > penalty:
-            raise ValueError("Penalty out of range")
-        return penalty
-    except Exception as e:
+        penalty_value = float(option_arg)
+    except ValueError:
+        raise WrongArgumentError("If defined, penalty must be a number between -2.0 and 2.0")
+    
+    if not (-2.0 <= penalty_value <= 2.0):
         raise WrongArgumentError("If defined, penalty must be a number between -2.0 and 2.0")
+    
+    return penalty_value
 
 
 def _build_llm_options(

pygeai/cli/commands/configuration.py

@@ -1,12 +1,11 @@
-import sys
-
 from pygeai.cli.commands import Option
 from pygeai.core.common.config import get_settings
+from pygeai.core.utils.console import Console
 
 
 def configure(option_list: list[str, str] = None):
     if not any(option_list):
-        sys.stdout.write("# Configuring GEAI credentials...\n")
+        Console.write_stdout("# Configuring GEAI credentials...")
         alias = str(input("-> Select an alias (Leave empty to use 'default'): "))
         if not alias:
             alias = "default"
@@ -24,34 +23,75 @@ def configure(option_list: list[str, str] = None):
             configure_eval_url(eval_url, alias)
 
     else:
+        list_alias = False
+        remove_alias = False
+        api_key = None
+        base_url = None
+        eval_url = None
+        alias = "default"
+
         for option_flag, option_arg in option_list:
-            alias = "default"
-            if option_flag.name == "alias":
+            if option_flag.name == "list":
+                list_alias = True
+            if option_flag.name == "profile_alias":
                 alias = option_arg
             if option_flag.name == "api_key":
-                configure_api_key(api_key=option_arg, alias=alias)
+                api_key = option_arg
             if option_flag.name == "base_url":
-                configure_base_url(base_url=option_arg, alias=alias)
+                base_url = option_arg
             if option_flag.name == "eval_url":
-                configure_eval_url(eval_url=option_arg, alias=alias)
+                eval_url = option_arg
+            if option_flag.name == "remove_alias":
+                alias = option_arg
+                remove_alias = True
+
+
+        if list_alias:
+            display_alias_list()
+        elif remove_alias:
+            remove_alias_from_config(alias)
+        else:
+            if api_key:
+                configure_api_key(api_key=api_key, alias=alias)
+            if base_url:
+                configure_base_url(base_url=base_url, alias=alias)
+            if eval_url:
+                configure_eval_url(eval_url=eval_url, alias=alias)
 
 
 def configure_api_key(api_key: str, alias: str = "default"):
     settings = get_settings()
     settings.set_api_key(api_key, alias)
-    sys.stdout.write(f"GEAI API KEY for alias '{alias}' saved successfully!\n")
+    Console.write_stdout(f"GEAI API KEY for alias '{alias}' saved successfully!")
 
 
 def configure_base_url(base_url: str, alias: str = "default"):
     settings = get_settings()
     settings.set_base_url(base_url, alias)
-    sys.stdout.write(f"GEAI API BASE URL for alias '{alias}' saved successfully!\n")
+    Console.write_stdout(f"GEAI API BASE URL for alias '{alias}' saved successfully!")
 
 
 def configure_eval_url(eval_url: str, alias: str = "default"):
     settings = get_settings()
     settings.set_eval_url(eval_url, alias)
-    sys.stdout.write(f"GEAI API EVAL URL for alias '{alias}' saved successfully!\n")
+    Console.write_stdout(f"GEAI API EVAL URL for alias '{alias}' saved successfully!")
+
+
+def display_alias_list():
+    settings = get_settings()
+    for alias, url in settings.list_aliases().items():
+        Console.write_stdout(f"Alias: {alias} -> Base URL: {url}")
+
+
+def remove_alias_from_config(alias: str):
+    delete_confirmed = str(input(f"-> Are you sure you want to delete {alias} from config file? (y/N) "))
+    if delete_confirmed.lower() in ["yes", "y"]:
+        settings = get_settings()
+        settings.remove_alias(alias)
+        Console.write_stdout(f"Alias {alias} removed from configuration file.")
+    else:
+        Console.write_stdout(f"Alias {alias} kept in configuration file.")
+
 
 
 configuration_options = (
@@ -74,9 +114,22 @@ configuration_options = (
         True
     ),
     Option(
-        "alias",
-        ["--alias", "-a"],
+        "profile_alias",
+        ["--profile-alias", "--pa"],
         "Set alias for settings section",
         True
     ),
+    Option(
+        "list",
+        ["--list", "-l"],
+        "List available alias",
+        False
+    ),
+    Option(
+        "remove_alias",
+        ["--remove-alias", "--ra"],
+        "Remove selected alias",
+        True
+    ),
+
 )

pygeai/cli/commands/docs.py

@@ -0,0 +1,105 @@
+import os
+import subprocess
+import webbrowser
+from pathlib import Path
+
+from pygeai.cli.commands import Command, ArgumentsEnum
+from pygeai.cli.commands.builders import build_help_text
+from pygeai.cli.texts.help import DOCS_HELP_TEXT
+from pygeai.core.utils.console import Console
+
+
+def show_help():
+    help_text = build_help_text(docs_commands, DOCS_HELP_TEXT)
+    Console.write_stdout(help_text)
+
+
+def open_documentation():
+    try:
+        import sphinx
+    except ImportError:
+        Console.write_stdout(
+            "Documentation dependencies (sphinx, sphinx-rtd-theme) are not installed.\n"
+            "Would you like to install them now? [Y/n]: "
+        )
+        response = input().strip().lower()
+        
+        if response in ['', 'y', 'yes']:
+            Console.write_stdout("Installing documentation dependencies...")
+            try:
+                subprocess.run(
+                    ["pip", "install", "pygeai[docs]"],
+                    check=True,
+                    text=True
+                )
+                Console.write_stdout("Documentation dependencies installed successfully.")
+            except subprocess.CalledProcessError as e:
+                Console.write_stderr(f"ERROR: Failed to install dependencies.\n{e}")
+                return
+            except FileNotFoundError:
+                Console.write_stderr("ERROR: pip command not found.")
+                return
+        else:
+            Console.write_stdout("Installation cancelled. Documentation dependencies are required.")
+            return
+
+    pygeai_package_dir = Path(__file__).parent.parent.parent
+    docs_dir = pygeai_package_dir / "_docs"
+    build_dir = docs_dir / "build" / "html"
+    index_file = build_dir / "index.html"
+
+    if not index_file.exists():
+        Console.write_stdout("Documentation not found. Building documentation (this may take a minute)...")
+        source_dir = docs_dir / "source"
+        
+        try:
+            result = subprocess.run(
+                ["sphinx-build", "-b", "html", str(source_dir), str(build_dir)],
+                check=True,
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
+            Console.write_stdout("Documentation built successfully.")
+        except subprocess.CalledProcessError as e:
+            Console.write_stderr(f"ERROR: Failed to build documentation.\n{e.stderr}")
+            return
+        except subprocess.TimeoutExpired:
+            Console.write_stderr("ERROR: Documentation build timed out after 5 minutes.")
+            return
+        except FileNotFoundError:
+            Console.write_stderr(
+                "ERROR: sphinx-build command not found.\n"
+                "Install documentation dependencies: pip install pygeai[docs]"
+            )
+            return
+
+    doc_url = f"file://{index_file.absolute()}"
+    Console.write_stdout(f"Opening documentation at: {doc_url}")
+    
+    try:
+        webbrowser.open(doc_url)
+    except Exception as e:
+        Console.write_stderr(f"ERROR: Failed to open browser.\n{e}")
+
+
+docs_commands = [
+    Command(
+        "open",
+        ["open", "o"],
+        "Open documentation in web browser",
+        open_documentation,
+        ArgumentsEnum.NOT_AVAILABLE,
+        [],
+        []
+    ),
+    Command(
+        "help",
+        ["help", "h"],
+        "Display help text",
+        show_help,
+        ArgumentsEnum.NOT_AVAILABLE,
+        [],
+        []
+    ),
+]

pygeai/cli/commands/embeddings.py

@@ -1,10 +1,11 @@
-import sys
-
+import json
 from pygeai.cli.commands import Command, Option, ArgumentsEnum
 from pygeai.cli.commands.builders import build_help_text
+from pygeai.cli.commands.common import get_boolean_value
 from pygeai.cli.texts.help import EMBEDDINGS_HELP_TEXT
 from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
 from pygeai.core.embeddings.clients import EmbeddingsClient
+from pygeai.core.utils.console import Console
 
 
 def show_help():
@@ -12,7 +13,7 @@ def show_help():
     Displays help text in stdout
     """
     help_text = build_help_text(embeddings_commands, EMBEDDINGS_HELP_TEXT)
-    sys.stdout.write(help_text)
+    Console.write_stdout(help_text)
 
 
 def generate_embeddings(option_list: list):
@@ -23,6 +24,7 @@ def generate_embeddings(option_list: list):
     input_type = None
     timeout = None
     cache = None
+    preview = True
     input_list = list()
 
     for option_flag, option_arg in option_list:
@@ -33,18 +35,23 @@ def generate_embeddings(option_list: list):
         if option_flag.name == "encoding_format":
             encoding_format = option_arg
         if option_flag.name == "dimensions":
-            dimensions = option_arg
+            try:
+                dimensions = int(option_arg)
+            except (ValueError, TypeError):
+                raise WrongArgumentError("dimensions must be an integer")
         if option_flag.name == "user":
             user = option_arg
         if option_flag.name == "input_type":
             input_type = option_arg
         if option_flag.name == "timeout":
-            timeout = option_arg
+            try:
+                timeout = int(option_arg)
+            except (ValueError, TypeError):
+                raise WrongArgumentError("timeout must be an integer")
         if option_flag.name == "cache":
-            if not str(option_arg).isdigit() or int(option_arg) not in [0, 1]:
-                raise WrongArgumentError("If specified, cache must be 0 or 1")
-
-            cache = bool(int(option_arg))
+            cache = get_boolean_value(option_arg)
+        if option_flag.name == "preview":
+            preview = get_boolean_value(option_arg)
 
     if not (model and any(input_list)):
         raise MissingRequirementException("Cannot generate embeddings without specifying model and at least one input")
@@ -60,7 +67,40 @@ def generate_embeddings(option_list: list):
         timeout=timeout,
         cache=cache
     )
-    sys.stdout.write(f"Embeddings detail: \n{result}\n")
+    
+    output = {
+        "model": result.get("model"),
+        "object": result.get("object"),
+        "embeddings_count": len(result.get("data", [])),
+        "usage": result.get("usage"),
+        "data": []
+    }
+    
+    for item in result.get("data", []):
+        embedding_data = item.get("embedding")
+        if isinstance(embedding_data, list):
+            embedding_info = {
+                "index": item.get("index"),
+                "dimensions": len(embedding_data),
+                "object": item.get("object")
+            }
+            if preview:
+                embedding_info["preview"] = embedding_data[:5] if len(embedding_data) > 5 else embedding_data
+            else:
+                embedding_info["embedding"] = embedding_data
+        else:
+            embedding_info = {
+                "index": item.get("index"),
+                "object": item.get("object"),
+                "format": "base64"
+            }
+            if preview:
+                embedding_info["preview"] = str(embedding_data)[:50] + "..." if len(str(embedding_data)) > 50 else embedding_data
+            else:
+                embedding_info["embedding"] = embedding_data
+        output["data"].append(embedding_info)
+    
+    Console.write_stdout(json.dumps(output, indent=2))
 
 
 generate_embeddings_options = [
@@ -110,10 +150,17 @@ generate_embeddings_options = [
     Option(
         "cache",
         ["--cache"],
-        "Enable X-Saia-Cache-Enabled to cache the embeddings for the model; it applies by Organization/Project."
+        "Enable X-Saia-Cache-Enabled to cache the embeddings for the model; it applies by Organization/Project. "
         "1 to set to True and 0 to false. 0 is default",
         True
     ),
+    Option(
+        "preview",
+        ["--preview"],
+        "Control embedding display in output. 1 (default) shows a preview (first 5 values for float, 50 chars for base64). "
+        "0 shows the full embedding vector. Use 0 to get complete embeddings for further processing",
+        True
+    ),
 
 ]