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

pygeai/cli/commands/lab/common.py

@@ -0,0 +1,135 @@
+from pygeai.core.common.exceptions import WrongArgumentError
+
+
+def get_agent_data_prompt_inputs(input_list: list):
+    """
+    Processes a list of input strings.
+
+    :param input_list: list - A list of strings representing input names.
+    :return: list - A list of input strings.
+    :raises WrongArgumentError: If the input list contains non-string elements.
+    """
+    if not all(isinstance(item, str) for item in input_list):
+        raise WrongArgumentError(
+            "Inputs must be a list of strings: '[\"input_name\", \"another_input\"]'. "
+            "Each element in the list must be a string representing an input name."
+        )
+    return input_list
+
+
+def get_agent_data_prompt_outputs(output_list: list):
+    """
+    Processes a list of output dictionaries and extracts the "key" and "description" fields.
+
+    :param output_list: list - A list of dictionaries, where each dictionary must contain the keys "key" and "description".
+    :return: list - A list of dictionaries, each containing the "key" and "description" fields.
+    :raises WrongArgumentError: If a dictionary in the list is not in the expected format or missing required keys.
+    """
+    outputs = []
+    if any(output_list):
+        try:
+            for output_dict in output_list:
+                outputs.append({
+                    "key": output_dict["key"],
+                    "description": output_dict["description"]
+                })
+        except (KeyError, TypeError):
+            raise WrongArgumentError(
+                "Each output must be in JSON format: '{\"key\": \"output_key\", \"description\": \"description of the output\"}' "
+                "It must be a dictionary or a list of dictionaries. Each dictionary must contain 'key' and 'description'."
+            )
+    return outputs
+
+
+def get_agent_data_prompt_examples(example_list: list):
+    """
+    Processes a list of example dictionaries and extracts the "inputData" and "output" fields.
+
+    :param example_list: list - A list of dictionaries, where each dictionary must contain the keys "inputData" and "output".
+    :return: list - A list of dictionaries, each containing the "inputData" and "output" fields.
+    :raises WrongArgumentError: If a dictionary in the list is not in the expected format or missing required keys.
+    """
+    examples = []
+    if any(example_list):
+        try:
+            for example_dict in example_list:
+                examples.append({
+                    "inputData": example_dict["inputData"],
+                    "output": example_dict["output"]
+                })
+        except (KeyError, TypeError):
+            raise WrongArgumentError(
+                "Each example must be in JSON format: '{\"inputData\": \"example input\", \"output\": \"expected output in JSON string format\"}' "
+                "Each dictionary must contain 'inputData' and 'output'."
+            )
+    return examples
+
+
+def get_tool_parameters(parameter_list: list) -> list:
+    """
+    Processes a list of parameter dictionaries and validates their format.
+
+    :param parameter_list: list - A list of dictionaries, where each dictionary represents a parameter.
+        Regular parameters must contain "key", "dataType", "description", and "isRequired".
+        Config parameters must additionally include "type" as "config", and may include "fromSecret" and "value".
+    :return: list - A list of validated parameter dictionaries.
+    :raises WrongArgumentError: If a dictionary in the list is not in the expected format or missing required keys.
+    """
+    parameters = []
+
+    if not parameter_list:
+        return parameters
+
+    try:
+        for param_dict in parameter_list:
+            required_fields = ["key", "dataType", "description", "isRequired"]
+            if not all(field in param_dict for field in required_fields):
+                raise WrongArgumentError(
+                    "Each parameter must contain 'key', 'dataType', 'description', and 'isRequired'. "
+                    "For regular parameters: '{\"key\": \"param_name\", \"dataType\": \"String\", \"description\": \"param description\", \"isRequired\": true}'. "
+                    "For config parameters: additionally include '\"type\": \"config\", \"fromSecret\": boolean, \"value\": \"config_value\"'."
+                )
+
+            if not isinstance(param_dict["key"], str):
+                raise WrongArgumentError("Parameter 'key' must be a string.")
+            if not isinstance(param_dict["dataType"], str):
+                raise WrongArgumentError("Parameter 'dataType' must be a string.")
+            if not isinstance(param_dict["description"], str):
+                raise WrongArgumentError("Parameter 'description' must be a string.")
+            if not isinstance(param_dict["isRequired"], bool):
+                raise WrongArgumentError("Parameter 'isRequired' must be a boolean.")
+
+            if "type" in param_dict:
+                if param_dict["type"] != "config":
+                    raise WrongArgumentError("Parameter 'type' must be 'config' if present.")
+                if "fromSecret" in param_dict and not isinstance(param_dict["fromSecret"], bool):
+                    raise WrongArgumentError("Parameter 'fromSecret' must be a boolean if present.")
+                if "value" in param_dict and not isinstance(param_dict["value"], str):
+                    raise WrongArgumentError("Parameter 'value' must be a string if present.")
+
+            validated_param = {
+                "key": param_dict["key"],
+                "dataType": param_dict["dataType"],
+                "description": param_dict["description"],
+                "isRequired": param_dict["isRequired"]
+            }
+
+            if "type" in param_dict:
+                validated_param["type"] = param_dict["type"]
+            if "fromSecret" in param_dict:
+                validated_param["fromSecret"] = param_dict["fromSecret"]
+            if "value" in param_dict:
+                validated_param["value"] = param_dict["value"]
+
+            parameters.append(validated_param)
+
+    except (KeyError, TypeError) as e:
+        raise WrongArgumentError(
+            "Each parameter must be in JSON format: "
+            "'{\"key\": \"param_name\", \"dataType\": \"String\", \"description\": \"param description\", \"isRequired\": true}' "
+            "or for config parameters: "
+            "'{\"key\": \"config_name\", \"dataType\": \"String\", \"description\": \"config description\", \"isRequired\": true, \"type\": \"config\", \"fromSecret\": false, \"value\": \"config_value\"}'"
+        )
+
+    return parameters
+

pygeai/cli/commands/lab/options.py

@@ -0,0 +1,8 @@
+from pygeai.cli.commands import Option
+
+PROJECT_ID_OPTION = Option(
+    "project_id",
+    ["--project-id", "--pid"],
+    "GUID of the project (optional)",
+    True
+)

pygeai/cli/commands/lab/spec.py

@@ -0,0 +1,273 @@
+from pygeai import logger
+from pygeai.cli.commands import Command, Option, ArgumentsEnum
+from pygeai.cli.commands.builders import build_help_text
+from pygeai.cli.texts.help import SPEC_HELP_TEXT
+from pygeai.core.common.exceptions import MissingRequirementException
+
+from pygeai.core.utils.console import Console
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.spec.loader import JSONLoader
+from pygeai.lab.spec.parsers import AgentParser, ToolParser, TaskParser, AgenticProcessParser
+
+
+def show_help():
+    """
+    Displays help text in stdout
+    """
+    help_text = build_help_text(spec_commands, SPEC_HELP_TEXT)
+    Console.write_stdout(help_text)
+
+
+def load_agent(option_list: list):
+    file = None
+    automatic_publish = False
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "file":
+            file = option_arg
+        if option_flag.name == "automatic_publish":
+            automatic_publish = option_arg
+
+    if not file:
+        raise MissingRequirementException("Cannot load agent definition without specifying path to JSON file.")
+
+    agent_data = JSONLoader.load_data(file_path=file)
+    if isinstance(agent_data, dict):
+        agent = AgentParser.get_agent(agent_data)
+        create_agent(agent, automatic_publish)
+    elif isinstance(agent_data, list):
+        for agent_spec in agent_data:
+            agent = AgentParser.get_agent(agent_spec)
+            create_agent(agent, automatic_publish)
+
+
+def create_agent(agent, automatic_publish):
+    try:
+        created_agent = AILabManager().create_agent(
+            agent=agent,
+            automatic_publish=automatic_publish
+        )
+
+        Console.write_stdout(f"Created agent detail: \n{created_agent}")
+    except Exception as e:
+        logger.error(f"Error creating agent: {e}\nAgent data: {agent}")
+        Console.write_stderr(f"Error creating agent: \n{agent}")
+
+
+load_agent_options = [
+    Option(
+        "file",
+        ["--file", "-f"],
+        "Path to the file containing agent definition in JSON format.",
+        True
+    ),
+    Option(
+        "automatic_publish",
+        ["--automatic-publish", "--ap"],
+        "Define if reasoning strategy must be published besides being created. 0: Create as draft. 1: Create and publish.",
+        True
+    ),
+]
+
+
+def load_tool(option_list: list):
+    file = None
+    automatic_publish = False
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "file":
+            file = option_arg
+        if option_flag.name == "automatic_publish":
+            automatic_publish = option_arg
+
+    if not file:
+        raise MissingRequirementException("Cannot load tool definition without specifying path to JSON file.")
+
+    tool_data = JSONLoader.load_data(file_path=file)
+    if isinstance(tool_data, dict):
+        tool = ToolParser.get_tool(tool_data)
+        create_tool(tool, automatic_publish)
+    elif isinstance(tool_data, list):
+        for tool_spec in tool_data:
+            tool = ToolParser.get_tool(tool_spec)
+            create_tool(tool, automatic_publish)
+
+
+def create_tool(tool, automatic_publish):
+    try:
+        created_tool = AILabManager().create_tool(
+            tool=tool,
+            automatic_publish=automatic_publish
+        )
+        Console.write_stdout(f"Created tool detail: \n{created_tool}")
+    except Exception as e:
+        logger.error(f"Error creating tool: {e}\nTool data: {tool}")
+        Console.write_stderr(f"Error creating tool: \n{tool}")
+
+
+load_tool_options = [
+    Option(
+        "file",
+        ["--file", "-f"],
+        "Path to the file containing tool definition in JSON format.",
+        True
+    ),
+    Option(
+        "automatic_publish",
+        ["--automatic-publish", "--ap"],
+        "Define if tool must be published besides being created. 0: Create as draft. 1: Create and publish.",
+        True
+    ),
+]
+
+
+def load_task(option_list: list):
+    file = None
+    automatic_publish = False
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "file":
+            file = option_arg
+        if option_flag.name == "automatic_publish":
+            automatic_publish = option_arg
+
+    if not file:
+        raise MissingRequirementException("Cannot load task definition without specifying path to JSON file.")
+
+    task_data = JSONLoader.load_data(file_path=file)
+    if isinstance(task_data, dict):
+        task = TaskParser.get_task(task_data)
+        create_task(task, automatic_publish)
+    elif isinstance(task_data, list):
+        for task_spec in task_data:
+            task = TaskParser.get_task(task_spec)
+            create_task(task, automatic_publish)
+
+
+def create_task(task, automatic_publish):
+    try:
+        created_task = AILabManager().create_task(
+            task=task,
+            automatic_publish=automatic_publish
+        )
+        Console.write_stdout(f"Created task detail: \n{created_task}")
+    except Exception as e:
+        logger.error(f"Error creating task: {e}\nTask data: {task}")
+        Console.write_stderr(f"Error creating task: \n{task}")
+
+
+load_task_options = [
+    Option(
+        "file",
+        ["--file", "-f"],
+        "Path to the file containing task definition in JSON format.",
+        True
+    ),
+    Option(
+        "automatic_publish",
+        ["--automatic-publish", "--ap"],
+        "Define if task must be published besides being created. 0: Create as draft. 1: Create and publish.",
+        True
+    ),
+]
+
+
+def load_agentic_process(option_list: list):
+    file = None
+    automatic_publish = False
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "file":
+            file = option_arg
+        if option_flag.name == "automatic_publish":
+            automatic_publish = option_arg
+
+
+    if not file:
+        raise MissingRequirementException("Cannot load agentic process definition without specifying path to JSON file.")
+
+    process_data = JSONLoader.load_data(file_path=file)
+    if isinstance(process_data, dict):
+        process = AgenticProcessParser.get_agentic_process(process_data)
+        create_agentic_process(process, automatic_publish)
+    elif isinstance(process_data, list):
+        for process_spec in process_data:
+            process = AgenticProcessParser.get_agentic_process(process_spec)
+            create_agentic_process(process, automatic_publish)
+
+
+def create_agentic_process(process, automatic_publish):
+    try:
+        created_process = AILabManager().create_process(
+            process=process,
+            automatic_publish=automatic_publish
+        )
+        Console.write_stdout(f"Created agentic process detail: \n{created_process}")
+    except Exception as e:
+        logger.error(f"Error creating agentic process: {e}\nProcess data: {process}")
+        Console.write_stderr(f"Error creating agentic process: \n{process}")
+
+
+load_agentic_process_options = [
+    Option(
+        "file",
+        ["--file", "-f"],
+        "Path to the file containing agentic process definition in JSON format.",
+        True
+    ),
+    Option(
+        "automatic_publish",
+        ["--automatic-publish", "--ap"],
+        "Define if agentic process must be published besides being created. 0: Create as draft. 1: Create and publish.",
+        True
+    ),
+]
+
+
+spec_commands = [
+    Command(
+        "help",
+        ["help", "h"],
+        "Display help text",
+        show_help,
+        ArgumentsEnum.NOT_AVAILABLE,
+        [],
+        []
+    ),
+    Command(
+        "load_agent",
+        ["load-agent", "la"],
+        "Load agent from JSON specification",
+        load_agent,
+        ArgumentsEnum.REQUIRED,
+        [],
+        load_agent_options
+    ),
+    Command(
+        "load_tool",
+        ["load-tool", "lt"],
+        "Load tool from JSON specification",
+        load_tool,
+        ArgumentsEnum.REQUIRED,
+        [],
+        load_tool_options
+    ),
+    Command(
+        "load_task",
+        ["load-task"],
+        "Load task from JSON specification",
+        load_task,
+        ArgumentsEnum.REQUIRED,
+        [],
+        load_task_options
+    ),
+    Command(
+        "load_agentic_process",
+        ["load-agentic-process", "lap"],
+        "Load agentic process from JSON specification",
+        load_agentic_process,
+        ArgumentsEnum.REQUIRED,
+        [],
+        load_agentic_process_options
+    ),
+]

pygeai/cli/commands/lab/utils.py

@@ -0,0 +1,13 @@
+from pygeai import logger
+from pygeai.admin.clients import AdminClient
+from pygeai.core.common.exceptions import APIError
+
+
+def get_project_id():
+    response = None
+    try:
+        response = AdminClient().validate_api_token()
+        return response.get("projectId")
+    except Exception as e:
+        logger.error(f"Error retrieving project_id from GEAI. Response: {response}: {e}")
+        raise APIError(f"Error retrieving project_id from GEAI: {e}")

pygeai/cli/commands/llm.py

@@ -0,0 +1,164 @@
+from pygeai.cli.commands import Command, ArgumentsEnum, Option
+from pygeai.cli.commands.builders import build_help_text
+from pygeai.cli.texts.help import LLM_HELP_TEXT
+from pygeai.core.common.exceptions import MissingRequirementException
+from pygeai.core.llm.clients import LlmClient
+from pygeai.core.utils.console import Console
+
+
+def show_help():
+    """
+    Displays help text in stdout
+    """
+    help_text = build_help_text(llm_commands, LLM_HELP_TEXT)
+    Console.write_stdout(help_text)
+
+
+def get_provider_list():
+    client = LlmClient()
+    result = client.get_provider_list()
+    Console.write_stdout(f"Provider list: \n{result}")
+
+
+def get_provider_data(option_list: list):
+    provider_name = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "provider_name":
+            provider_name = option_arg
+
+    if not provider_name:
+        raise MissingRequirementException("Cannot retrieve provider data without name")
+
+    client = LlmClient()
+    result = client.get_provider_data(provider_name=provider_name)
+    Console.write_stdout(f"Provider detail: \n{result}")
+
+
+get_provider_data_options = [
+    Option(
+        "provider_name",
+        ["--provider-name", "--pn"],
+        "LLM Provider name (required)",
+        True
+    ),
+]
+
+
+def get_provider_models(option_list: list):
+    provider_name = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "provider_name":
+            provider_name = option_arg
+
+    if not provider_name:
+        raise MissingRequirementException("Cannot retrieve provider models without name")
+
+    client = LlmClient()
+    result = client.get_provider_models(provider_name=provider_name)
+    Console.write_stdout(f"Provider models: \n{result}")
+
+
+get_provider_models_options = [
+    Option(
+        "provider_name",
+        ["--provider-name", "--pn"],
+        "LLM Provider name (required)",
+        True
+    ),
+]
+
+
+def get_model_data(option_list: list):
+    provider_name = None
+    model_name = None
+    model_id = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "provider_name":
+            provider_name = option_arg
+        if option_flag.name == "model_name":
+            model_name = option_arg
+        if option_flag.name == "model_id":
+            model_id = option_arg
+
+    if not (provider_name and (model_name or model_id)):
+        raise MissingRequirementException("Cannot retrieve model data without provider name and model id or name.")
+
+    client = LlmClient()
+    result = client.get_model_data(
+        provider_name=provider_name,
+        model_name=model_name or model_id
+    )
+    Console.write_stdout(f"Model details: \n{result}")
+
+
+get_model_data_options = [
+    Option(
+        "provider_name",
+        ["--provider-name", "--pn"],
+        "LLM Provider name (required)",
+        True
+    ),
+    Option(
+        "model_name",
+        ["--model-name", "--mn"],
+        "LLM Model name",
+        True
+    ),
+    Option(
+        "model_id",
+        ["--model-id", "--mid"],
+        "LLM Model ID",
+        True
+    ),
+
+]
+
+
+llm_commands = [
+    Command(
+        "help",
+        ["help", "h"],
+        "Display help text",
+        show_help,
+        ArgumentsEnum.NOT_AVAILABLE,
+        [],
+        []
+    ),
+    Command(
+        "list_providers",
+        ["list-providers", "lp"],
+        "Retrieve providers list",
+        get_provider_list,
+        ArgumentsEnum.NOT_AVAILABLE,
+        [],
+        []
+    ),
+    Command(
+        "get_provider",
+        ["get-provider", "gp"],
+        "Retrieve provider data",
+        get_provider_data,
+        ArgumentsEnum.REQUIRED,
+        [],
+        get_provider_data_options
+    ),
+    Command(
+        "list_models",
+        ["list-models", "lm"],
+        "Retrieve provider models",
+        get_provider_models,
+        ArgumentsEnum.REQUIRED,
+        [],
+        get_provider_models_options
+    ),
+    Command(
+        "get_model",
+        ["get-model", "gm"],
+        "Retrieve model data",
+        get_model_data,
+        ArgumentsEnum.REQUIRED,
+        [],
+        get_model_data_options
+    ),
+
+]