uipath 2.1.85__py3-none-any.whl → 2.1.87__py3-none-any.whl

uipath/_cli/__init__.py

@@ -8,7 +8,6 @@ from .cli_auth import auth as auth
 from .cli_deploy import deploy as deploy  # type: ignore
 from .cli_dev import dev as dev
 from .cli_eval import eval as eval  # type: ignore
-from .cli_init import generate_agents_md as generate_agents_md  # type: ignore
 from .cli_init import init as init  # type: ignore
 from .cli_invoke import invoke as invoke  # type: ignore
 from .cli_new import new as new  # type: ignore

uipath/_cli/_utils/_input_args.py

@@ -2,6 +2,7 @@ import importlib.util
 import inspect
 import sys
 from dataclasses import fields, is_dataclass
+from enum import Enum
 from types import ModuleType
 from typing import (
     Any,
@@ -16,11 +17,11 @@ from typing import (
 
 from pydantic import BaseModel
 
-SchemaType = Literal["object", "integer", "double", "string", "boolean", "array"]
+SchemaType = Literal["object", "integer", "number", "string", "boolean", "array"]
 
 TYPE_MAP: Dict[str, SchemaType] = {
     "int": "integer",
-    "float": "double",
+    "float": "number",
     "str": "string",
     "bool": "boolean",
     "list": "array",
@@ -52,7 +53,25 @@ def get_type_schema(type_hint: Any) -> Dict[str, Any]:
         return {"type": "object"}
 
     if inspect.isclass(type_hint):
-        # Handle Pydantic models
+        if issubclass(type_hint, Enum):
+            enum_values = [member.value for member in type_hint]
+            if not enum_values:
+                return {"type": "string", "enum": []}
+
+            first_value = enum_values[0]
+            if isinstance(first_value, str):
+                enum_type = "string"
+            elif isinstance(first_value, int):
+                enum_type = "integer"
+            elif isinstance(first_value, float):
+                enum_type = "number"
+            elif isinstance(first_value, bool):
+                enum_type = "boolean"
+            else:
+                enum_type = "string"
+
+            return {"type": enum_type, "enum": enum_values}
+
         if issubclass(type_hint, BaseModel):
             properties = {}
             required = []

uipath/_cli/_utils/_project_files.py

@@ -1,13 +1,22 @@
 # type: ignore
+import hashlib
 import json
 import os
 import re
+from pathlib import Path
 from typing import Any, Dict, Optional, Tuple
 
+import click
 from pydantic import BaseModel
 
 from .._utils._console import ConsoleLogger
 from ._constants import is_binary_file
+from ._studio_project import (
+    ProjectFile,
+    ProjectFolder,
+    StudioClient,
+    get_folder_by_name,
+)
 
 try:
     import tomllib
@@ -431,3 +440,116 @@ def files_to_include(
                     )
                 )
     return extra_files
+
+
+def compute_normalized_hash(content: str) -> str:
+    """Compute hash of normalized content.
+
+    Args:
+        content: Content to hash
+
+    Returns:
+        str: SHA256 hash of the normalized content
+    """
+    try:
+        # Try to parse as JSON to handle formatting
+        json_content = json.loads(content)
+        normalized = json.dumps(json_content, indent=2)
+    except json.JSONDecodeError:
+        # Not JSON, normalize line endings
+        normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
+
+
+def collect_files_from_folder(
+    folder: ProjectFolder, base_path: str, files_dict: Dict[str, ProjectFile]
+) -> None:
+    """Recursively collect all files from a folder and its subfolders.
+
+    Args:
+        folder: The folder to collect files from
+        base_path: Base path for file paths
+        files_dict: Dictionary to store collected files
+    """
+    # Add files from current folder
+    for file in folder.files:
+        file_path = os.path.join(base_path, file.name)
+        files_dict[file_path] = file
+
+    # Recursively process subfolders
+    for subfolder in folder.folders:
+        subfolder_path = os.path.join(base_path, subfolder.name)
+        collect_files_from_folder(subfolder, subfolder_path, files_dict)
+
+
+async def download_folder_files(
+    studio_client: StudioClient,
+    folder: ProjectFolder,
+    base_path: Path,
+) -> None:
+    """Download files from a folder recursively.
+
+    Args:
+        studio_client: Studio client
+        folder: The folder to download files from
+        base_path: Base path for local file storage
+    """
+    files_dict: Dict[str, ProjectFile] = {}
+    collect_files_from_folder(folder, "", files_dict)
+    for file_path, remote_file in files_dict.items():
+        local_path = base_path / file_path
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Download remote file
+        response = await studio_client.download_file_async(remote_file.id)
+        remote_content = response.read().decode("utf-8")
+        remote_hash = compute_normalized_hash(remote_content)
+
+        if os.path.exists(local_path):
+            # Read and hash local file
+            with open(local_path, "r", encoding="utf-8") as f:
+                local_content = f.read()
+                local_hash = compute_normalized_hash(local_content)
+
+            # Compare hashes
+            if local_hash != remote_hash:
+                styled_path = click.style(str(file_path), fg="cyan")
+                console.warning(f"File {styled_path}" + " differs from remote version.")
+                response = click.prompt("Do you want to overwrite it? (y/n)", type=str)
+                if response.lower() == "y":
+                    with open(local_path, "w", encoding="utf-8", newline="\n") as f:
+                        f.write(remote_content)
+                    console.success(f"Updated {click.style(str(file_path), fg='cyan')}")
+                else:
+                    console.info(f"Skipped {click.style(str(file_path), fg='cyan')}")
+            else:
+                console.info(
+                    f"File {click.style(str(file_path), fg='cyan')} is up to date"
+                )
+        else:
+            # File doesn't exist locally, create it
+            with open(local_path, "w", encoding="utf-8", newline="\n") as f:
+                f.write(remote_content)
+            console.success(f"Downloaded {click.style(str(file_path), fg='cyan')}")
+
+
+async def pull_project(project_id: str, download_configuration: dict[str, Path]):
+    studio_client = StudioClient(project_id)
+
+    with console.spinner("Pulling UiPath project files..."):
+        try:
+            structure = await studio_client.get_project_structure_async()
+            for source_key, destination in download_configuration.items():
+                source_folder = get_folder_by_name(structure, source_key)
+                if source_folder:
+                    await download_folder_files(
+                        studio_client,
+                        source_folder,
+                        destination,
+                    )
+                else:
+                    console.warning(f"No {source_key} folder found in remote project")
+
+        except Exception as e:
+            console.error(f"Failed to pull UiPath project: {str(e)}")

uipath/_cli/cli_init.py

@@ -58,32 +58,28 @@ def generate_env_file(target_directory):
         console.success(f" Created '{relative_path}' file.")
 
 
-def generate_agents_md(target_directory: str) -> None:
-    """Generate AGENTS.md file from the packaged resource.
+def generate_agent_specific_file_md(target_directory: str, file_name: str) -> None:
+    """Generate an agent-specific file from the packaged resource.
 
     Args:
-        target_directory: The directory where AGENTS.md should be created.
+        target_directory: The directory where the file should be created.
+        file_name: The name of the file should be created.
     """
-    target_path = os.path.join(target_directory, "AGENTS.md")
+    target_path = os.path.join(target_directory, file_name)
 
-    # Skip if file already exists
     if os.path.exists(target_path):
-        console.info("Skipping 'AGENTS.md' creation as it already exists.")
+        console.info(f"Skipping '{file_name}' creation as it already exists.")
         return
 
     try:
-        # Get the resource path using importlib.resources
-        source_path = importlib.resources.files("uipath._resources").joinpath(
-            "AGENTS.md"
-        )
+        source_path = importlib.resources.files("uipath._resources").joinpath(file_name)
 
-        # Copy the file to the target directory
         with importlib.resources.as_file(source_path) as s_path:
             shutil.copy(s_path, target_path)
 
-        console.success(" Created 'AGENTS.md' file.")
+        console.success(f" Created '{file_name}' file.")
     except Exception as e:
-        console.warning(f"Could not create AGENTS.md: {e}")
+        console.warning(f"Could not create {file_name}: {e}")
 
 
 def get_existing_settings(config_path: str) -> Optional[Dict[str, Any]]:
@@ -160,7 +156,17 @@ def init(entrypoint: str, infer_bindings: bool) -> None:
         current_directory = os.getcwd()
         generate_env_file(current_directory)
         create_telemetry_config_file(current_directory)
-        generate_agents_md(current_directory)
+        generate_agent_specific_file_md(current_directory, "AGENTS.md")
+        generate_agent_specific_file_md(
+            os.path.join(current_directory, ".agent"), "CLI_REFERENCE.md"
+        )
+        generate_agent_specific_file_md(
+            os.path.join(current_directory, ".agent"), "REQUIRED_STRUCTURE.md"
+        )
+        generate_agent_specific_file_md(
+            os.path.join(current_directory, ".agent"), "SDK_REFERENCE.md"
+        )
+        generate_agent_specific_file_md(current_directory, "CLAUDE.md")
 
         result = Middlewares.next(
             "init",

uipath/_cli/cli_pull.py

@@ -11,133 +11,27 @@ It handles:
 
 # type: ignore
 import asyncio
-import hashlib
-import json
 import os
-from typing import Dict, Set
+from pathlib import Path
 
 import click
 
 from ..telemetry import track
 from ._utils._console import ConsoleLogger
 from ._utils._constants import UIPATH_PROJECT_ID
-from ._utils._studio_project import (
-    ProjectFile,
-    ProjectFolder,
-    StudioClient,
-    get_folder_by_name,
-)
+from ._utils._project_files import pull_project
 
 console = ConsoleLogger()
 
 
-def compute_normalized_hash(content: str) -> str:
-    """Compute hash of normalized content.
-
-    Args:
-        content: Content to hash
-
-    Returns:
-        str: SHA256 hash of the normalized content
-    """
-    try:
-        # Try to parse as JSON to handle formatting
-        json_content = json.loads(content)
-        normalized = json.dumps(json_content, indent=2)
-    except json.JSONDecodeError:
-        # Not JSON, normalize line endings
-        normalized = content.replace("\r\n", "\n").replace("\r", "\n")
-
-    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
-
-
-def collect_files_from_folder(
-    folder: ProjectFolder, base_path: str, files_dict: Dict[str, ProjectFile]
-) -> None:
-    """Recursively collect all files from a folder and its subfolders.
-
-    Args:
-        folder: The folder to collect files from
-        base_path: Base path for file paths
-        files_dict: Dictionary to store collected files
-    """
-    # Add files from current folder
-    for file in folder.files:
-        file_path = os.path.join(base_path, file.name)
-        files_dict[file_path] = file
-
-    # Recursively process subfolders
-    for subfolder in folder.folders:
-        subfolder_path = os.path.join(base_path, subfolder.name)
-        collect_files_from_folder(subfolder, subfolder_path, files_dict)
-
-
-async def download_folder_files(
-    studio_client: StudioClient,
-    folder: ProjectFolder,
-    base_path: str,
-    processed_files: Set[str],
-) -> None:
-    """Download files from a folder recursively.
-
-    Args:
-        studio_client: Studio client
-        folder: The folder to download files from
-        base_path: Base path for local file storage
-        processed_files: Set to track processed files
-    """
-    files_dict: Dict[str, ProjectFile] = {}
-    collect_files_from_folder(folder, "", files_dict)
-
-    for file_path, remote_file in files_dict.items():
-        local_path = os.path.join(base_path, file_path)
-        local_dir = os.path.dirname(local_path)
-
-        # Create directory if it doesn't exist
-        if not os.path.exists(local_dir):
-            os.makedirs(local_dir)
-
-        # Download remote file
-        response = await studio_client.download_file_async(remote_file.id)
-        remote_content = response.read().decode("utf-8")
-        remote_hash = compute_normalized_hash(remote_content)
-
-        if os.path.exists(local_path):
-            # Read and hash local file
-            with open(local_path, "r", encoding="utf-8") as f:
-                local_content = f.read()
-                local_hash = compute_normalized_hash(local_content)
-
-            # Compare hashes
-            if local_hash != remote_hash:
-                styled_path = click.style(str(file_path), fg="cyan")
-                console.warning(f"File {styled_path}" + " differs from remote version.")
-                response = click.prompt("Do you want to overwrite it? (y/n)", type=str)
-                if response.lower() == "y":
-                    with open(local_path, "w", encoding="utf-8", newline="\n") as f:
-                        f.write(remote_content)
-                    console.success(f"Updated {click.style(str(file_path), fg='cyan')}")
-                else:
-                    console.info(f"Skipped {click.style(str(file_path), fg='cyan')}")
-            else:
-                console.info(
-                    f"File {click.style(str(file_path), fg='cyan')} is up to date"
-                )
-        else:
-            # File doesn't exist locally, create it
-            with open(local_path, "w", encoding="utf-8", newline="\n") as f:
-                f.write(remote_content)
-            console.success(f"Downloaded {click.style(str(file_path), fg='cyan')}")
-
-        processed_files.add(file_path)
-
-
 @click.command()
 @click.argument(
-    "root", type=click.Path(exists=True, file_okay=False, dir_okay=True), default="."
+    "root",
+    type=click.Path(exists=False, file_okay=False, dir_okay=True, path_type=Path),
+    default=Path("."),
 )
 @track
-def pull(root: str) -> None:
+def pull(root: Path) -> None:
     """Pull remote project files from Studio Web Project.
 
     This command pulls the remote project files from a UiPath Studio Web project.
@@ -158,42 +52,8 @@ def pull(root: str) -> None:
     if not (project_id := os.getenv(UIPATH_PROJECT_ID, False)):
         console.error("UIPATH_PROJECT_ID environment variable not found.")
 
-    studio_client = StudioClient(project_id)
-
-    with console.spinner("Pulling UiPath project files..."):
-        try:
-            structure = asyncio.run(studio_client.get_project_structure_async())
-
-            processed_files: Set[str] = set()
-
-            # Process source_code folder
-            source_code_folder = get_folder_by_name(structure, "source_code")
-            if source_code_folder:
-                asyncio.run(
-                    download_folder_files(
-                        studio_client,
-                        source_code_folder,
-                        root,
-                        processed_files,
-                    )
-                )
-            else:
-                console.warning("No source_code folder found in remote project")
-
-            # Process evals folder
-            evals_folder = get_folder_by_name(structure, "evals")
-            if evals_folder:
-                evals_path = os.path.join(root, "evals")
-                asyncio.run(
-                    download_folder_files(
-                        studio_client,
-                        evals_folder,
-                        evals_path,
-                        processed_files,
-                    )
-                )
-            else:
-                console.warning("No evals folder found in remote project")
-
-        except Exception as e:
-            console.error(f"Failed to pull UiPath project: {str(e)}")
+    default_download_configuration = {
+        "source_code": root,
+        "evals": root / "evals",
+    }
+    asyncio.run(pull_project(project_id, default_download_configuration))