pygeai 0.6.0b10__py3-none-any.whl → 0.6.0b12__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/migrate.py

@@ -11,6 +11,7 @@ from pygeai.assistant.managers import AssistantManager
 from pygeai.assistant.rag.clients import RAGAssistantClient
 from pygeai.assistant.rag.mappers import RAGAssistantMapper
 from pygeai.core.files.managers import FileManager
+from pygeai.core.secrets.clients import SecretClient
 from pygeai.migration.strategies import (
     ProjectMigrationStrategy,
     AgentMigrationStrategy,
@@ -19,7 +20,8 @@ from pygeai.migration.strategies import (
     TaskMigrationStrategy,
     UsageLimitMigrationStrategy,
     RAGAssistantMigrationStrategy,
-    FileMigrationStrategy
+    FileMigrationStrategy,
+    SecretMigrationStrategy
 )
 from pygeai.migration.tools import MigrationTool, MigrationPlan, MigrationOrchestrator
 from pygeai.admin.clients import AdminClient
@@ -216,7 +218,7 @@ def select_resource_types() -> List[int]:
     """
     Prompt user to select which resource types to migrate.
     
-    :return: List of integers representing selected resource types (1-7)
+    :return: List of integers representing selected resource types (1-8)
     """
     Console.write_stdout("\n--- Resource Type Selection ---")
     Console.write_stdout("Which resource types do you want to migrate?")
@@ -227,15 +229,16 @@ def select_resource_types() -> List[int]:
     Console.write_stdout("  5. RAG Assistants")
     Console.write_stdout("  6. Files")
     Console.write_stdout("  7. Usage Limits")
+    Console.write_stdout("  8. Secrets")
     
     while True:
         resource_choice = input("\nSelect resource types (comma-separated numbers, or empty for all): ").strip()
         if not resource_choice:
-            return [1, 2, 3, 4, 5, 6, 7]
+            return [1, 2, 3, 4, 5, 6, 7, 8]
         try:
             resource_types = [int(x.strip()) for x in resource_choice.split(",")]
-            if any(i < 1 or i > 7 for i in resource_types):
-                Console.write_stdout("Error: Invalid selection. Numbers must be between 1 and 7.")
+            if any(i < 1 or i > 8 for i in resource_types):
+                Console.write_stdout("Error: Invalid selection. Numbers must be between 1 and 8.")
                 continue
             return resource_types
         except ValueError:
@@ -368,6 +371,29 @@ def fetch_and_select_files(
     return None
 
 
+def fetch_and_select_secrets(from_api_key: str, from_instance: str) -> Optional[str]:
+    """
+    Fetch and prompt user to select secrets for migration.
+    
+    :param from_api_key: Source API key
+    :param from_instance: Source instance URL
+    :return: Comma-separated secret IDs, 'all', or None
+    """
+    try:
+        secret_client = SecretClient(api_key=from_api_key, base_url=from_instance)
+        secrets_data = secret_client.list_secrets(count=1000)
+        secrets_list = secrets_data.get("secrets", []) if isinstance(secrets_data, dict) else []
+        
+        if secrets_list:
+            secrets_objects = [type('obj', (object,), {'id': s.get('id'), 'name': s.get('name')})() 
+                             for s in secrets_list if s.get('id')]
+            selection = prompt_resource_selection("secrets", secrets_objects, id_field="id", name_field="name")
+            return selection
+    except Exception as e:
+        Console.write_stdout(f"Warning: Could not retrieve secrets: {e}")
+    return None
+
+
 def handle_usage_limits_keys(
     same_instance: bool,
     from_organization_api_key: Optional[str],
@@ -554,6 +580,11 @@ def clone_project_interactively() -> None:
         )
         selected_resources["usage_limits"] = True
     
+    if 8 in resource_types_to_migrate:
+        selection = fetch_and_select_secrets(from_api_key, from_instance)
+        if selection:
+            selected_resources["secrets"] = selection
+    
     confirmed, stop_on_error = show_summary_and_confirm(from_instance, from_project_id, to_instance, to_project_name, to_project_id, selected_resources)
     if not confirmed:
         Console.write_stdout("Migration cancelled.")
@@ -571,7 +602,7 @@ def clone_project(option_list: list) -> None:
     Clone a project with selected components from source to destination instance.
     
     Supports migration of agents, tools, agentic processes, tasks, usage limits,
-    RAG assistants, and files between GenExus AI instances.
+    RAG assistants, files, and secrets between GEAI instances.
     
     :param option_list: List of (option_flag, option_value) tuples from CLI parsing
     """
@@ -606,6 +637,7 @@ def clone_project(option_list: list) -> None:
     migrate_usage_limits = False
     migrate_rag_assistants = False
     migrate_files = False
+    migrate_secrets = False
     
     agent_ids = None
     tool_ids = None
@@ -613,6 +645,7 @@ def clone_project(option_list: list) -> None:
     task_ids = None
     assistant_names = None
     file_ids = None
+    secret_ids = None
     
     stop_on_error = True
 
@@ -663,6 +696,9 @@ def clone_project(option_list: list) -> None:
         elif option_flag.name == "files":
             migrate_files = True
             file_ids = option_arg if option_arg else "all"
+        elif option_flag.name == "secrets":
+            migrate_secrets = True
+            secret_ids = option_arg if option_arg else "all"
         elif option_flag.name == "stop_on_error":
             from pygeai.cli.commands.common import get_boolean_value
             stop_on_error = get_boolean_value(option_arg)
@@ -778,12 +814,14 @@ def clone_project(option_list: list) -> None:
         migrate_usage_limits = True if from_organization_id and to_organization_id else False
         migrate_rag_assistants = True
         migrate_files = True if from_organization_id and to_organization_id else False
+        migrate_secrets = True
         agent_ids = "all"
         tool_ids = "all"
         process_ids = "all"
         task_ids = "all"
         assistant_names = "all"
         file_ids = "all"
+        secret_ids = "all"
 
     strategies = []
     
@@ -954,6 +992,31 @@ def clone_project(option_list: list) -> None:
                     to_instance=to_instance
                 ))
 
+    if migrate_secrets:
+        secret_client = SecretClient(api_key=from_api_key, base_url=from_instance)
+        if secret_ids == "all":
+            secrets_data = secret_client.list_secrets(count=1000)
+            secrets_list = secrets_data.get("secrets", []) if isinstance(secrets_data, dict) else []
+            discovered_secrets = [s.get('id') for s in secrets_list if s.get('id')]
+            Console.write_stdout(f"Discovered {len(discovered_secrets)} secrets")
+            for secret_id in discovered_secrets:
+                strategies.append(SecretMigrationStrategy(
+                    from_api_key=from_api_key,
+                    from_instance=from_instance,
+                    secret_id=secret_id,
+                    to_api_key=to_api_key,
+                    to_instance=to_instance
+                ))
+        elif secret_ids:
+            for secret_id in secret_ids.split(','):
+                strategies.append(SecretMigrationStrategy(
+                    from_api_key=from_api_key,
+                    from_instance=from_instance,
+                    secret_id=secret_id.strip(),
+                    to_api_key=to_api_key,
+                    to_instance=to_instance
+                ))
+
     if not strategies:
         Console.write_stdout("No migration strategies configured. Use flags like --agents, --tools, --all, etc.")
         return
@@ -1098,6 +1161,12 @@ clone_project_options = [
         "File IDs to migrate: comma-separated IDs or 'all' (requires org/project IDs)",
         True
     ),
+    Option(
+        "secrets",
+        ["--secrets"],
+        "Secret IDs to migrate: comma-separated IDs or 'all'",
+        True
+    ),
     Option(
         "stop_on_error",
         ["--stop-on-error", "--soe"],

pygeai/cli/commands/organization.py

@@ -484,6 +484,235 @@ get_organization_members_options = [
     ),
 ]
 
+
+def add_project_member(option_list: list):
+    project_id = None
+    user_email = None
+    roles = []
+    batch_file = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "user_email":
+            user_email = option_arg
+        if option_flag.name == "roles":
+            roles = [r.strip() for r in option_arg.split(",")]
+        if option_flag.name == "batch_file":
+            batch_file = option_arg
+
+    client = OrganizationClient()
+
+    if batch_file:
+        add_project_member_in_batch(client, batch_file)
+    else:
+        if not (project_id and user_email and roles):
+            raise MissingRequirementException("Cannot add project member without project-id, user email, and roles")
+        result = client.add_project_member(project_id, user_email, roles)
+        Console.write_stdout(f"User invitation sent: \n{result}")
+
+
+def add_project_member_in_batch(client: OrganizationClient, batch_file: str):
+    import csv
+    import os
+
+    if not os.path.exists(batch_file):
+        raise MissingRequirementException(f"Batch file not found: {batch_file}")
+
+    successful = 0
+    failed = 0
+    errors = []
+
+    try:
+        with open(batch_file, 'r') as f:
+            csv_reader = csv.reader(f)
+            for line_num, row in enumerate(csv_reader, start=1):
+                if len(row) < 3:
+                    error_msg = f"Line {line_num}: Invalid format - expected at least 3 columns (project_id, email, role1, ...)"
+                    errors.append(error_msg)
+                    failed += 1
+                    continue
+
+                project_id = row[0].strip()
+                email = row[1].strip()
+                roles = [r.strip() for r in row[2:] if r.strip()]
+
+                if not (project_id and email and roles):
+                    error_msg = f"Line {line_num}: Missing required fields (project_id={project_id}, email={email}, roles={roles})"
+                    errors.append(error_msg)
+                    failed += 1
+                    continue
+
+                try:
+                    client.add_project_member(project_id, email, roles)
+                    successful += 1
+                except Exception as e:
+                    error_msg = f"Line {line_num}: Failed to add {email} to project {project_id}: {str(e)}"
+                    errors.append(error_msg)
+                    failed += 1
+
+        Console.write_stdout(f"Batch processing complete: {successful} successful, {failed} failed")
+        if errors:
+            Console.write_stdout("\nErrors:")
+            for error in errors:
+                Console.write_stdout(f"  - {error}")
+    except Exception as e:
+        raise MissingRequirementException(f"Failed to read batch file: {str(e)}")
+
+
+add_project_member_options = [
+    Option(
+        "project_id",
+        ["--project-id", "--pid"],
+        "GUID of the project (required unless --batch is used)",
+        True
+    ),
+    Option(
+        "user_email",
+        ["--email", "-e"],
+        "Email address of the user to invite (required unless --batch is used)",
+        True
+    ),
+    Option(
+        "roles",
+        ["--roles", "-r"],
+        "Comma-separated list of role names or GUIDs (e.g., 'Project member,Project administrator') (required unless --batch is used)",
+        True
+    ),
+    Option(
+        "batch_file",
+        ["--batch", "-b"],
+        "Path to CSV file with format: project_id,email,role1,role2,... (one invitation per line)",
+        True
+    ),
+]
+
+
+def create_organization(option_list: list):
+    name = None
+    email = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "name":
+            name = option_arg
+
+        if option_flag.name == "admin_email":
+            email = option_arg
+
+    if not (name and email):
+        raise MissingRequirementException("Cannot create organization without name and administrator's email")
+
+    client = OrganizationClient()
+    result = client.create_organization(name, email)
+    Console.write_stdout(f"New organization: \\n{result}")
+
+
+create_organization_options = [
+    Option(
+        "name",
+        ["--name", "-n"],
+        "Name of the new organization",
+        True
+    ),
+    Option(
+        "admin_email",
+        ["--email", "-e"],
+        "Organization administrator's email",
+        True
+    ),
+]
+
+
+def get_organization_list(option_list: list):
+    start_page = None
+    page_size = None
+    order_key = None
+    order_direction = "desc"
+    filter_key = None
+    filter_value = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "start_page":
+            start_page = int(option_arg)
+        if option_flag.name == "page_size":
+            page_size = int(option_arg)
+        if option_flag.name == "order_key":
+            order_key = option_arg
+        if option_flag.name == "order_direction":
+            order_direction = option_arg
+        if option_flag.name == "filter_key":
+            filter_key = option_arg
+        if option_flag.name == "filter_value":
+            filter_value = option_arg
+
+    client = OrganizationClient()
+    result = client.get_organization_list(start_page, page_size, order_key, order_direction, filter_key, filter_value)
+    Console.write_stdout(f"Organization list: \\n{result}")
+
+
+get_organization_list_options = [
+    Option(
+        "start_page",
+        ["--start-page"],
+        "Page number for pagination",
+        True
+    ),
+    Option(
+        "page_size",
+        ["--page-size"],
+        "Number of items per page",
+        True
+    ),
+    Option(
+        "order_key",
+        ["--order-key"],
+        "Field for sorting (only 'name' supported)",
+        True
+    ),
+    Option(
+        "order_direction",
+        ["--order-direction"],
+        "Sort direction: asc or desc (default: desc)",
+        True
+    ),
+    Option(
+        "filter_key",
+        ["--filter-key"],
+        "Field for filtering (only 'name' supported)",
+        True
+    ),
+    Option(
+        "filter_value",
+        ["--filter-value"],
+        "Value to filter by",
+        True
+    ),
+]
+
+
+def delete_organization(option_list: list):
+    organization_id = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "organization_id":
+            organization_id = option_arg
+
+    if not organization_id:
+        raise MissingRequirementException("Cannot delete organization without organization-id")
+
+    client = OrganizationClient()
+    result = client.delete_organization(organization_id)
+    Console.write_stdout(f"Deleted organization: \\n{result}")
+
+
+delete_organization_options = [
+    Option(
+        "organization_id",
+        ["--organization-id", "--oid"],
+        "GUID of the organization (required)",
+        True
+    ),
+]
+
 organization_commands = [
     Command(
         "help",
@@ -611,4 +840,40 @@ organization_commands = [
         [],
         get_organization_members_options
     ),
+    Command(
+        "add_project_member",
+        ["add-project-member", "apm"],
+        "Add a user to a project by sending an invitation email",
+        add_project_member,
+        ArgumentsEnum.REQUIRED,
+        [],
+        add_project_member_options
+    ),
+    Command(
+        "create_organization",
+        ["create-organization"],
+        "Create new organization",
+        create_organization,
+        ArgumentsEnum.REQUIRED,
+        [],
+        create_organization_options
+    ),
+    Command(
+        "organization_list",
+        ["list-organizations"],
+        "List organization information",
+        get_organization_list,
+        ArgumentsEnum.OPTIONAL,
+        [],
+        get_organization_list_options
+    ),
+    Command(
+        "delete_organization",
+        ["delete-organization"],
+        "Delete existing organization",
+        delete_organization,
+        ArgumentsEnum.REQUIRED,
+        [],
+        delete_organization_options
+    ),
 ]

pygeai/cli/commands/validators.py

@@ -1,6 +1,8 @@
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+import json
 
-from pygeai.core.common.exceptions import WrongArgumentError
+from pygeai.core.common.exceptions import WrongArgumentError, ValidationError
 
 
 def validate_dataset_file(dataset_file: str):
@@ -64,3 +66,144 @@ def validate_system_metric(metric: dict):
 
     if not isinstance(metric["systemMetricWeight"], (int, float)) or not (0 <= metric["systemMetricWeight"] <= 1):
         raise WrongArgumentError('"systemMetricWeight" must be a number between 0 and 1 (inclusive).')
+
+
+def validate_json_input(
+    value: str, 
+    expected_type: type,
+    field_name: str,
+    example: Optional[str] = None
+) -> Union[Dict, List]:
+    """
+    Validates and parses JSON input with detailed error messages.
+
+    :param value: str - The JSON string to parse.
+    :param expected_type: type - Expected type (dict or list).
+    :param field_name: str - Name of the field being validated.
+    :param example: Optional[str] - Example of valid input.
+    :return: Union[Dict, List] - Parsed JSON object.
+    :raises ValidationError: If JSON is invalid or doesn't match expected type.
+    """
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as e:
+        raise ValidationError(
+            f"Invalid JSON for '{field_name}'",
+            field=field_name,
+            expected="Valid JSON string",
+            received=value[:100] + "..." if len(value) > 100 else value,
+            example=example or '{"key": "value"}'
+        ) from e
+    
+    if not isinstance(parsed, expected_type):
+        raise ValidationError(
+            f"Wrong type for '{field_name}'",
+            field=field_name,
+            expected=expected_type.__name__,
+            received=type(parsed).__name__,
+            example=example
+        )
+    
+    return parsed
+
+
+def validate_numeric_range(
+    value: str,
+    field_name: str,
+    min_value: Optional[float] = None,
+    max_value: Optional[float] = None,
+    value_type: type = float
+) -> Union[int, float]:
+    """
+    Validates numeric input within a specified range.
+
+    :param value: str - The numeric string to validate.
+    :param field_name: str - Name of the field being validated.
+    :param min_value: Optional[float] - Minimum allowed value.
+    :param max_value: Optional[float] - Maximum allowed value.
+    :param value_type: type - Expected numeric type (int or float).
+    :return: Union[int, float] - Validated numeric value.
+    :raises ValidationError: If value is not numeric or out of range.
+    """
+    try:
+        numeric_value = value_type(value)
+    except ValueError as e:
+        raise ValidationError(
+            f"Invalid {value_type.__name__} for '{field_name}'",
+            field=field_name,
+            expected=f"{value_type.__name__}",
+            received=value
+        ) from e
+    
+    if min_value is not None and numeric_value < min_value:
+        raise ValidationError(
+            f"Value too low for '{field_name}'",
+            field=field_name,
+            expected=f">= {min_value}",
+            received=str(numeric_value)
+        )
+    
+    if max_value is not None and numeric_value > max_value:
+        raise ValidationError(
+            f"Value too high for '{field_name}'",
+            field=field_name,
+            expected=f"<= {max_value}",
+            received=str(numeric_value)
+        )
+    
+    return numeric_value
+
+
+def validate_choice(
+    value: str,
+    field_name: str,
+    choices: List[str],
+    case_sensitive: bool = True
+) -> str:
+    """
+    Validates that input is one of the allowed choices.
+
+    :param value: str - The value to validate.
+    :param field_name: str - Name of the field being validated.
+    :param choices: List[str] - List of allowed values.
+    :param case_sensitive: bool - Whether comparison is case-sensitive.
+    :return: str - Validated value.
+    :raises ValidationError: If value is not in choices.
+    """
+    compare_value = value if case_sensitive else value.lower()
+    compare_choices = choices if case_sensitive else [c.lower() for c in choices]
+    
+    if compare_value not in compare_choices:
+        raise ValidationError(
+            f"Invalid value for '{field_name}'",
+            field=field_name,
+            expected=f"One of: {', '.join(choices)}",
+            received=value
+        )
+    
+    return value
+
+
+def validate_boolean_value(value: str, field_name: str = "boolean option") -> bool:
+    """
+    Converts a string argument into a boolean value with flexible input formats.
+
+    :param value: str - A string representation of a boolean.
+    :param field_name: str - Name of the field being validated.
+    :return: bool - The boolean value corresponding to the input.
+    :raises ValidationError: If the input is not a valid boolean representation.
+    """
+    normalized = value.lower().strip()
+    
+    if normalized in ("0", "false", "no", "off"):
+        return False
+    elif normalized in ("1", "true", "yes", "on"):
+        return True
+    else:
+        raise ValidationError(
+            f"Invalid boolean value for '{field_name}'",
+            field=field_name,
+            expected="0/1, true/false, yes/no, on/off",
+            received=value,
+            example="1 or true"
+        )