pygeai 0.1.6__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:
-        raise WrongArgumentError("Possible values for stream ar 0 or 1, for off and on, respectively.")
+    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(
@@ -311,7 +315,7 @@ def get_search_options(
     :return: dict - A dictionary containing the configured options for LLM, search, and retriever.
     """
     return {
-        "historyCount": history_count if history_count else None,
+        "history_count": history_count if history_count else None,
         "llm": _build_llm_options(
             llm_cache, llm_frequency_penalty, llm_max_tokens, llm_model_name,
             llm_n, llm_presence_penalty, llm_provider, llm_stream,

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"
@@ -18,24 +17,81 @@ def configure(option_list: list[str, str] = None):
         base_url = str(input("-> Insert your GEAI API BASE URL (Leave empty to keep current value): "))
         if base_url:
             configure_base_url(base_url, alias)
+
+        eval_url = str(input("-> Insert your GEAI API EVAL URL (Leave empty to keep current value): "))
+        if eval_url:
+            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:
+            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)
+                api_key = option_arg
             if option_flag.name == "base_url":
-                configure_base_url(base_url=option_arg)
+                base_url = option_arg
+            if option_flag.name == "eval_url":
+                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)
+    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 = (
@@ -52,9 +108,28 @@ configuration_options = (
         True
     ),
     Option(
-        "alias",
-        ["--alias", "-a"],
+        "eval_url",
+        ["--eval-url", "--eu"],
+        "Set GEAI API EVAL URL for the evaluation module",
+        True
+    ),
+    Option(
+        "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

@@ -0,0 +1,187 @@
+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():
+    """
+    Displays help text in stdout
+    """
+    help_text = build_help_text(embeddings_commands, EMBEDDINGS_HELP_TEXT)
+    Console.write_stdout(help_text)
+
+
+def generate_embeddings(option_list: list):
+    model = None
+    encoding_format = None
+    dimensions = None
+    user = None
+    input_type = None
+    timeout = None
+    cache = None
+    preview = True
+    input_list = list()
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "model":
+            model = option_arg
+        if option_flag.name == "input":
+            input_list.append(option_arg)
+        if option_flag.name == "encoding_format":
+            encoding_format = option_arg
+        if option_flag.name == "dimensions":
+            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":
+            try:
+                timeout = int(option_arg)
+            except (ValueError, TypeError):
+                raise WrongArgumentError("timeout must be an integer")
+        if option_flag.name == "cache":
+            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")
+
+    client = EmbeddingsClient()
+    result = client.generate_embeddings(
+        input_list=input_list,
+        model=model,
+        encoding_format=encoding_format,
+        dimensions=dimensions,
+        user=user,
+        input_type=input_type,
+        timeout=timeout,
+        cache=cache
+    )
+    
+    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 = [
+    Option(
+        "input",
+        ["--input", "-i"],
+        "string: Input to embed, encoded as a string. To embed multiple inputs in a single request, pass the string inputs "
+        "multiple times using -i. The input must not exceed the max input tokens for the model and cannot be an empty string",
+        True
+    ),
+    Option(
+        "model",
+        ["--model", "-m"],
+        "string: provider/modelId to use",
+        True
+    ),
+    Option(
+        "encoding_format",
+        ["--encoding-format", "--enc-for"],
+        "string: The format to return the embeddings. It can be either float (default) or base64 (optional)",
+        True
+    ),
+    Option(
+        "dimensions",
+        ["--dimensions", "--dim"],
+        "integer: The number of dimensions the resulting output embeddings should have. Only supported in text-embedding-3* and later models (optional)",
+        True
+    ),
+    Option(
+        "user",
+        ["--user", "-u"],
+        "string: A unique identifier representing your end-user",
+        True
+    ),
+    Option(
+        "input_type",
+        ["--input-type", "--it"],
+        "string: Defines how the input data will be used when generating embeddings (optional)",
+        True
+    ),
+    Option(
+        "timeout",
+        ["--timeout", "-t"],
+        "integer: The maximum time, in seconds, to wait for the API to respond. Defaults to 600 seconds",
+        True
+    ),
+    Option(
+        "cache",
+        ["--cache"],
+        "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
+    ),
+
+]
+
+
+embeddings_commands = [
+    Command(
+        "help",
+        ["help", "h"],
+        "Display help text",
+        show_help,
+        ArgumentsEnum.NOT_AVAILABLE,
+        [],
+        []
+    ),
+    Command(
+        "generate_embeddings",
+        ["generate", "gen"],
+        "Get embeddings",
+        generate_embeddings,
+        ArgumentsEnum.REQUIRED,
+        [],
+        generate_embeddings_options
+    ),
+]