pygeai 0.2.7b51__tar.gz → 0.2.7b52__tar.gz

{pygeai-0.2.7b51/pygeai.egg-info → pygeai-0.2.7b52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeai
-Version: 0.2.7b51
+Version: 0.2.7b52
 Summary: Software Development Kit to interact with Globant Enterprise AI.
 Author-email: Globant <geai-sdk@globant.com>
 License-Expression: MIT

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/chat/clients.py

@@ -3,7 +3,7 @@ from json import JSONDecodeError
 from typing import List, Dict, Optional, Union, Generator
 
 from pygeai import logger
-from pygeai.chat.endpoints import CHAT_V1
+from pygeai.chat.endpoints import CHAT_V1, GENERATE_IMAGE_V1
 from pygeai.core.base.clients import BaseClient
 from pygeai.core.common.exceptions import InvalidAPIResponseException
 
@@ -193,3 +193,49 @@ class ChatClient(BaseClient):
                         continue
         except Exception as e:
             raise InvalidAPIResponseException(f"Unable to process streaming chat response: {e}")
+
+    def generate_image(
+            self,
+            model: str,
+            prompt: str,
+            n: int,
+            quality: str,
+            size: str,
+            aspect_ratio: Optional[str] = None
+    ) -> dict:
+        """
+        Generates an image based on the provided parameters.
+
+        :param model: str - The model specification for image generation, e.g., "openai/gpt-image-1". (Required)
+        :param prompt: str - Description of the desired image. (Required)
+        :param n: int - Number of images to generate (1-10, depending on the model). (Required)
+        :param quality: str - Rendering quality, e.g., "high". (Required)
+        :param size: str - Image dimensions, e.g., "1024x1024". (Required)
+        :param aspect_ratio: Optional[str] - Relationship between image’s width and height, e.g., "1:1", "9:16", "16:9", "3:4", "4:3". (Optional)
+        :return: dict - The API response containing the generated image data.
+        :raises InvalidAPIResponseException: If the API response cannot be processed.
+        """
+        data = {
+            'model': model,
+            'prompt': prompt,
+            'n': n,
+            'quality': quality,
+            'size': size
+        }
+
+        if aspect_ratio:
+            data['aspect_ratio'] = aspect_ratio
+
+        logger.debug(f"Generating image with data: {data}")
+
+        response = self.api_service.post(
+            endpoint=GENERATE_IMAGE_V1,
+            data=data
+        )
+
+        try:
+            result = response.json()
+            logger.debug(f"Image generation result: {result}")
+            return result
+        except JSONDecodeError as e:
+            raise InvalidAPIResponseException(f"Unable to process image generation request: {response.text}")

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/chat/endpoints.py

@@ -1,2 +1,3 @@
 CHAT_V1 = "/chat"                           # POST Chat endpoint
 CHAT_COMPLETION_V1 = "/chat/completion"     # POST Chat completion endpoint
+GENERATE_IMAGE_V1 = "/images"               # POST Generate image

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/cli/commands/chat.py

@@ -565,6 +565,92 @@ chat_with_agent_options = [
 ]
 
 
+def get_generate_image(option_list: list):
+    model = None
+    prompt = None
+    n = None
+    quality = None
+    size = None
+    aspect_ratio = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "model":
+            model = option_arg
+        if option_flag.name == "prompt":
+            prompt = option_arg
+        if option_flag.name == "n":
+            try:
+                n = int(option_arg)
+                if n < 1 or n > 10:
+                    raise WrongArgumentError("n must be an integer between 1 and 10.")
+            except ValueError:
+                raise WrongArgumentError("n must be a valid integer.")
+        if option_flag.name == "quality":
+            quality = option_arg
+        if option_flag.name == "size":
+            size = option_arg
+        if option_flag.name == "aspect_ratio":
+            aspect_ratio = option_arg
+
+    if not (model and prompt and n is not None and quality and size):
+        raise MissingRequirementException("Cannot generate image without specifying model, prompt, n, quality, and size.")
+
+    client = ChatClient()
+    try:
+        result = client.generate_image(
+            model=model,
+            prompt=prompt,
+            n=n,
+            quality=quality,
+            size=size,
+            aspect_ratio=aspect_ratio
+        )
+        Console.write_stdout(f"Image generation result: \n{result}\n")
+    except Exception as e:
+        logger.error(f"Error generating image: {e}")
+        Console.write_stderr(f"Failed to generate image: {e}")
+
+
+generate_image_options = [
+    Option(
+        "model",
+        ["--model", "-m"],
+        "The model specification for image generation, e.g., 'openai/gpt-image-1'.",
+        True
+    ),
+    Option(
+        "prompt",
+        ["--prompt", "-p"],
+        "Description of the desired image.",
+        True
+    ),
+    Option(
+        "n",
+        ["--n"],
+        "Number of images to generate (1-10, depending on the model).",
+        True
+    ),
+    Option(
+        "quality",
+        ["--quality", "-q"],
+        "Rendering quality, e.g., 'high'.",
+        True
+    ),
+    Option(
+        "size",
+        ["--size", "-s"],
+        "Image dimensions, e.g., '1024x1024'.",
+        True
+    ),
+    Option(
+        "aspect_ratio",
+        ["--aspect-ratio", "-ar"],
+        "Relationship between image’s width and height, e.g., '1:1', '9:16', '16:9', '3:4', '4:3'.",
+        True
+    ),
+]
+
+
 chat_commands = [
     Command(
         "help",
@@ -602,6 +688,14 @@ chat_commands = [
         [],
         chat_with_agent_options
     ),
-
+    Command(
+        "generate_image",
+        ["generate-image", "gen-img"],
+        "Generate an image using the specified model and parameters",
+        get_generate_image,
+        ArgumentsEnum.REQUIRED,
+        [],
+        generate_image_options
+    ),
 
 ]

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/cli/commands/configuration.py

@@ -23,7 +23,8 @@ def configure(option_list: list[str, str] = None):
             configure_eval_url(eval_url, alias)
 
     else:
-        list_alias = None
+        list_alias = False
+        remove_alias = False
         api_key = None
         base_url = None
         eval_url = None
@@ -40,9 +41,15 @@ def configure(option_list: list[str, str] = None):
                 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)
@@ -76,6 +83,17 @@ def display_alias_list():
         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 = (
     Option(
         "api_key",
@@ -107,4 +125,11 @@ configuration_options = (
         "List available alias",
         False
     ),
+    Option(
+        "remove_alias",
+        ["--remove-alias", "--ra"],
+        "Remove selected alias",
+        True
+    ),
+
 )

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/cli/commands/lab/ai_lab.py

@@ -1,5 +1,6 @@
 import json
 
+from pygeai import logger
 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
@@ -450,6 +451,111 @@ get_agent_options = [
 ]
 
 
+def export_agent(option_list: list):
+    project_id = None
+    agent_id = None
+    file = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "agent_id":
+            agent_id = option_arg
+        if option_flag.name == "file":
+            file = option_arg
+
+
+    if not (project_id and agent_id):
+        raise MissingRequirementException("Project ID and Agent id must be specified.")
+
+    client = AgentClient()
+    result = client.export_agent(
+        project_id=project_id,
+        agent_id=agent_id,
+    )
+    if file:
+        try:
+            data = json.loads(result) if isinstance(result, str) else result
+            with open(file, "w") as f:
+                json.dump(data, f, indent=4)
+            Console.write_stdout(f"Result from API saved to {file}.")
+        except json.JSONDecodeError as e:
+            logger.error(f"Result from API endpoint is not in JSON format: {e}")
+            Console.write_stderr(f"Result from API endpoint is not in JSON format.")
+    else:
+        Console.write_stdout(f"Agent spec: \n{result}")
+
+
+
+export_agent_options = [
+    Option(
+        "project_id",
+        ["--project-id", "--pid"],
+        "ID of the project",
+        True
+    ),
+    Option(
+        "agent_id",
+        ["--agent-id", "--aid"],
+        "ID of the agent to retrieve",
+        True
+    ),
+    Option(
+        "file",
+        ["--file", "-f"],
+        "File path to save export specification for agent",
+        True
+    ),
+]
+
+
+def import_agent(option_list: list):
+    project_id = None
+    file = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "file":
+            file = option_arg
+
+
+    if not (project_id and file):
+        raise MissingRequirementException("Project ID  and file path to spec must be specified.")
+
+    try:
+        with open(file, "r") as f:
+            agent_data = json.load(f)
+    except json.JSONDecodeError as e:
+        logger.error(f"File is not in JSON format: {e}")
+        Console.write_stderr(f"File is not in JSON format.")
+
+    client = AgentClient()
+    result = client.import_agent(
+        project_id=project_id,
+        data=agent_data
+    )
+
+    Console.write_stdout(f"Agent import details: {result}")
+
+
+
+import_agent_options = [
+    Option(
+        "project_id",
+        ["--project-id", "--pid"],
+        "ID of the project",
+        True
+    ),
+    Option(
+        "file",
+        ["--file", "-f"],
+        "File path to save export specification for agent",
+        True
+    ),
+]
+
+
 def create_sharing_link(option_list: list):
     project_id = None
     agent_id = None
@@ -1188,6 +1294,64 @@ get_tool_options = [
 ]
 
 
+def export_tool(option_list: list):
+    project_id = None
+    tool_id = None
+    file = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "tool_id":
+            tool_id = option_arg
+        if option_flag.name == "file":
+            file = option_arg
+
+
+    if not (project_id and tool_id):
+        raise MissingRequirementException("Project ID and Tool id must be specified.")
+
+    client = ToolClient()
+    result = client.export_tool(
+        project_id=project_id,
+        tool_id=tool_id,
+    )
+    Console.write_stdout(f"Tool spec: \n{result}")
+    if file:
+        try:
+            data = json.loads(result) if isinstance(result, str) else result
+            with open(file, "w") as f:
+                json.dump(data, f, indent=4)
+            Console.write_stdout(f"Result from API saved to {file}.")
+        except json.JSONDecodeError as e:
+            logger.error(f"Result from API endpoint is not in JSON format: {e}")
+            Console.write_stderr(f"Result from API endpoint is not in JSON format.")
+
+
+
+export_tool_options = [
+    Option(
+        "project_id",
+        ["--project-id", "--pid"],
+        "ID of the project",
+        True
+    ),
+    Option(
+        "tool_id",
+        ["--tool-id", "--tid"],
+        "ID of the tool to retrieve",
+        True
+    ),
+    Option(
+        "file",
+        ["--file", "-f"],
+        "File path to save export specification for tool",
+        True
+    ),
+]
+
+
+
 def delete_tool(option_list: list):
     project_id = None
     tool_id = None
@@ -3885,6 +4049,24 @@ ai_lab_commands = [
         [],
         get_agent_options
     ),
+    Command(
+        "export_agent",
+        ["export-agent", "ea"],
+        "Export agent",
+        export_agent,
+        ArgumentsEnum.REQUIRED,
+        [],
+        export_agent_options
+    ),
+    Command(
+        "import_agent",
+        ["import-agent", "ia"],
+        "Import agent",
+        import_agent,
+        ArgumentsEnum.REQUIRED,
+        [],
+        import_agent_options
+    ),
     Command(
         "create_sharing_link",
         ["create-sharing-link", "csl"],
@@ -3949,6 +4131,15 @@ ai_lab_commands = [
         [],
         get_tool_options
     ),
+    #Command(
+    #    "export_tool",
+    #    ["export-tool", "et"],
+    #    "Export tool",
+    #    export_tool,
+    #    ArgumentsEnum.REQUIRED,
+    #    [],
+    #    export_tool_options
+    #),
     Command(
         "delete_tool",
         ["delete-tool", "dt"],

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/core/common/config.py

@@ -95,6 +95,17 @@ class SettingsManager:
             for section in self.config.sections()
         }
 
+    def remove_alias(self, alias: str):
+        """Removes a specific alias and its settings from the credentials file."""
+        if alias in self.config:
+            self.config.remove_section(alias)
+            with self.GEAI_CREDS_FILE.open("w") as file:
+                self.config.write(file)
+            logger.info(f"Alias '{alias}' removed from the credentials file.")
+        else:
+            logger.warning(f"Alias '{alias}' not found in the credentials file.")
+
+
 
 @lru_cache()
 def get_settings():

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/lab/agents/clients.py

@@ -5,7 +5,7 @@ from pygeai import logger
 from pygeai.core.base.clients import BaseClient
 from pygeai.core.common.exceptions import MissingRequirementException, InvalidAPIResponseException
 from pygeai.lab.agents.endpoints import CREATE_AGENT_V2, LIST_AGENTS_V2, GET_AGENT_V2, CREATE_SHARING_LINK_V2, \
-    PUBLISH_AGENT_REVISION_V2, DELETE_AGENT_V2, UPDATE_AGENT_V2, UPSERT_AGENT_V2
+    PUBLISH_AGENT_REVISION_V2, DELETE_AGENT_V2, UPDATE_AGENT_V2, UPSERT_AGENT_V2, EXPORT_AGENT_V2, IMPORT_AGENT_V2
 from pygeai.lab.constants import VALID_ACCESS_SCOPES
 
 
@@ -409,3 +409,82 @@ class AgentClient(BaseClient):
             raise InvalidAPIResponseException(f"Unable to update agent {agent_id} in project {project_id}: {response.text}")
 
         return result
+
+    def export_agent(
+            self,
+            project_id: str,
+            agent_id: str,
+    ) -> dict:
+        """
+        Retrieves details of a specific agent from the specified project.
+
+        :param project_id: str - Unique identifier of the project containing the agent.
+        :param agent_id: str - Unique identifier of the agent to retrieve.
+        :return: dict - JSON response containing the agent details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises MissingRequirementException: If project_id or agent_id is not provided.
+        """
+        if not project_id:
+            raise MissingRequirementException("Cannot export agent without specifying project_id")
+
+        if not agent_id:
+            raise MissingRequirementException("agent_id must be specified in order to export the agent")
+
+        endpoint = EXPORT_AGENT_V2.format(agentId=agent_id)
+        headers = {
+            "Authorization": self.api_service.token,
+            "ProjectId": project_id
+        }
+
+        logger.debug(f"Exporting agent with ID {agent_id}")
+
+        response = self.api_service.get(
+            endpoint=endpoint,
+            headers=headers,
+        )
+        try:
+            result = response.json()
+        except JSONDecodeError as e:
+            logger.error(f"Unable to export agent {agent_id} for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to export agent {agent_id} for project {project_id}: {response.text}")
+
+        return result
+
+    def import_agent(
+            self,
+            project_id: str,
+            data: dict,
+    ) -> dict:
+        """
+        Retrieves details of a specific agent from the specified project.
+
+        :param project_id: str - Unique identifier of the project containing the agent.
+        :param data: dict - Agent specification to import
+        :return: dict - JSON response containing the agent details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises MissingRequirementException: If project_id or agent_id is not provided.
+        """
+        if not project_id:
+            raise MissingRequirementException("Cannot import agent without specifying project_id")
+
+        if not data:
+            raise MissingRequirementException("data for spec must be specified in order to import the agent")
+
+        endpoint = IMPORT_AGENT_V2
+        headers = {
+            "Authorization": self.api_service.token,
+            "ProjectId": project_id
+        }
+
+        response = self.api_service.post(
+            endpoint=endpoint,
+            headers=headers,
+            data=data
+        )
+        try:
+            result = response.json()
+        except JSONDecodeError as e:
+            logger.error(f"Unable to import agent for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to import agent for project {project_id}: {response.text}")
+
+        return result

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/lab/agents/endpoints.py

@@ -6,3 +6,5 @@ PUBLISH_AGENT_REVISION_V2 = "v2/agents/{agentId}/publish-revision"  # POST -> Pu
 DELETE_AGENT_V2 = "v2/agents/{agentId}"  # DEL -> Delete agent
 UPDATE_AGENT_V2 = "v2/agents/{agentId}"  # PUT -> Update agent
 UPSERT_AGENT_V2 = "v2/agents/{agentId}/upsert"  # PUT -> Update or Insert agent
+EXPORT_AGENT_V2 = "v2/agents/{agentId}/export"  # GET -> Export agent
+IMPORT_AGENT_V2 = "v2/agents/import"  # POST -> Import agent

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/lab/models.py

@@ -1,3 +1,4 @@
+import re
 from typing import Literal, Optional, List, Dict, Any, Union, Iterator
 
 from pydantic import model_validator, Field, field_validator
@@ -708,6 +709,9 @@ class Tool(CustomBaseModel):
             raise ValueError("name cannot be blank")
         if ":" in value or "/" in value:
             raise ValueError("name cannot contain ':' or '/'")
+        if not re.match(r'^[A-Za-z0-9_-]{1,64}$', value):
+            raise ValueError(
+                "name must contain only letters, numbers, underscores, or hyphens, and be 1-64 characters long")
         return value
 
     @field_validator("public_name")

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/lab/tools/clients.py

@@ -3,10 +3,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, MissingRequirementException
 from pygeai.lab.constants import VALID_SCOPES, VALID_ACCESS_SCOPES, VALID_REPORT_EVENTS
 from pygeai.lab.tools.endpoints import CREATE_TOOL_V2, LIST_TOOLS_V2, GET_TOOL_V2, UPDATE_TOOL_V2, UPSERT_TOOL_V2, \
-    PUBLISH_TOOL_REVISION_V2, GET_PARAMETER_V2, SET_PARAMETER_V2, DELETE_TOOL_V2
+    PUBLISH_TOOL_REVISION_V2, GET_PARAMETER_V2, SET_PARAMETER_V2, DELETE_TOOL_V2, EXPORT_TOOL_V2
 
 
 class ToolClient(BaseClient):
@@ -525,3 +525,43 @@ class ToolClient(BaseClient):
             raise InvalidAPIResponseException(f"Unable to set parameters for tool {tool_id or tool_public_name} in project {project_id}: {response.text}")
 
         return result
+
+    def export_tool(
+            self,
+            project_id: str,
+            tool_id: str,
+    ) -> dict:
+        """
+        Retrieves details of a specific tool from the specified project.
+
+        :param project_id: str - Unique identifier of the project containing the tool.
+        :param tool_id: str - Unique identifier of the tool to retrieve.
+        :return: dict - JSON response containing the tool details.
+        :raises InvalidAPIResponseException: If the response cannot be parsed as JSON or an error occurs.
+        :raises MissingRequirementException: If project_id or tool_id is not provided.
+        """
+        if not project_id:
+            raise MissingRequirementException("Cannot retrieve tool without specifying project_id")
+
+        if not tool_id:
+            raise MissingRequirementException("tool_id must be specified in order to retrieve the tool")
+
+        endpoint = EXPORT_TOOL_V2.format(toolId=tool_id)
+        headers = {
+            "Authorization": self.api_service.token,
+            "ProjectId": project_id
+        }
+
+        logger.debug(f"Exporting tool with ID {tool_id}")
+
+        response = self.api_service.get(
+            endpoint=endpoint,
+            headers=headers,
+        )
+        try:
+            result = response.json()
+        except JSONDecodeError as e:
+            logger.error(f"Unable to export tool {tool_id} for project {project_id}: JSON parsing error (status {response.status_code}): {e}. Response: {response.text}")
+            raise InvalidAPIResponseException(f"Unable to export tool {tool_id} for project {project_id}: {response.text}")
+
+        return result

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/lab/tools/endpoints.py

@@ -7,3 +7,4 @@ UPSERT_TOOL_V2 = "v2/tools/{toolId}/upsert"  # PUT -> Update or insert tool data
 PUBLISH_TOOL_REVISION_V2 = "v2/tools/{toolId}/publish-revision"  # POST -> Publish Tool revision
 GET_PARAMETER_V2 = "v2/tools/{toolPublicName}/config"  # GET -> Get tool parameter
 SET_PARAMETER_V2 = "v2/tools/{toolPublicName}/config"  # POST -> Set tool parameter
+EXPORT_TOOL_V2 = "v2/tools/{toolId}/export"  # GET -> Export tool

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/proxy/servers.py

@@ -193,6 +193,7 @@ class MCPServer(ToolServer):
     """
     def __init__(self, sever_name: str, config: Dict[str, Any], settings: ProxySettingsManager):
         super().__init__(sever_name, config, settings)
+        self.public_prefix = config.get("public_prefix")
         self.stdio_context: Any | None = None
         self.session: ClientSession | None = None
 

{pygeai-0.2.7b51 → pygeai-0.2.7b52}/pygeai/proxy/tool.py

@@ -40,9 +40,12 @@ class ProxiedTool:
 
     def get_public_name(self) -> str:
         """Get the public name of the tool."""
-        return (
-            f"{self.public_prefix}.{self.name if self.server_name in self.public_prefix else self.get_full_name()}"
-        )
+        if not self.public_prefix:
+            return ""
+        if self.server_name in self.public_prefix:
+            return f"{self.public_prefix}.{self.name}"
+        else:
+            return f"{self.public_prefix}.{self.get_full_name()}"
 
     def format_for_llm(self) -> str:
         """Format tool information for LLM.

pygeai-0.2.7b52/pygeai/tests/proxy/__init__.py

@@ -0,0 +1 @@
+