uipath 2.1.4__py3-none-any.whl → 2.1.6__py3-none-any.whl

uipath/_cli/__init__.py

@@ -10,6 +10,7 @@ from .cli_invoke import invoke as invoke  # type: ignore
 from .cli_new import new as new  # type: ignore
 from .cli_pack import pack as pack  # type: ignore
 from .cli_publish import publish as publish  # type: ignore
+from .cli_push import push as push  # type: ignore
 from .cli_run import run as run  # type: ignore
 
 
@@ -63,3 +64,4 @@ cli.add_command(run)
 cli.add_command(deploy)
 cli.add_command(auth)
 cli.add_command(invoke)
+cli.add_command(push)

uipath/_cli/_auth/auth_config.json

@@ -1,6 +1,6 @@
 {
   "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
   "redirect_uri": "http://localhost:__PY_REPLACE_PORT__/oidc/login",
-  "scope": "offline_access OrchestratorApiUserAccess IdentityServerApi ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets",
+  "scope": "offline_access OrchestratorApiUserAccess StudioWebBackend IdentityServerApi ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization TM.Projects TM.TestCases TM.Requirements TM.TestSets",
   "port": 8104
-}
+}

uipath/_cli/_utils/_constants.py

@@ -1,5 +1,11 @@
 BINDINGS_VERSION = "2.2"
 
+# Agent.json constants
+AGENT_VERSION = "1.0.0"
+AGENT_STORAGE_VERSION = "1.0.0"
+AGENT_INITIAL_CODE_VERSION = "1.0.0"
+AGENT_TARGET_RUNTIME = "python"
+
 # Binary file extension categories
 IMAGE_EXTENSIONS = {
     ".png",

uipath/_cli/_utils/_project_files.py

@@ -0,0 +1,361 @@
+# type: ignore
+import json
+import os
+import re
+from typing import Any, Dict, Optional, Tuple
+
+from pydantic import BaseModel
+
+from .._utils._console import ConsoleLogger
+from ._constants import is_binary_file
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib
+
+
+class FileInfo(BaseModel):
+    """Information about a file to be included in the project.
+
+    Attributes:
+        file_path: The absolute path to the file
+        relative_path: The path relative to the project root
+        is_binary: Whether the file should be treated as binary
+    """
+
+    file_path: str
+    relative_path: str
+    is_binary: bool
+
+
+console = ConsoleLogger()
+
+
+def get_project_config(directory: str) -> dict[str, str]:
+    """Retrieve and combine project configuration from uipath.json and pyproject.toml.
+
+    Args:
+        directory: The root directory containing the configuration files
+
+    Returns:
+        dict[str, str]: Combined configuration including project name, description,
+            entry points, version, and authors
+
+    Raises:
+        SystemExit: If required configuration files are missing or invalid
+    """
+    config_path = os.path.join(directory, "uipath.json")
+    toml_path = os.path.join(directory, "pyproject.toml")
+
+    if not os.path.isfile(config_path):
+        console.error("uipath.json not found, please run `uipath init`.")
+    if not os.path.isfile(toml_path):
+        console.error("pyproject.toml not found.")
+
+    with open(config_path, "r") as config_file:
+        config_data = json.load(config_file)
+
+    validate_config_structure(config_data)
+
+    toml_data = read_toml_project(toml_path)
+
+    return {
+        "project_name": toml_data["name"],
+        "description": toml_data["description"],
+        "entryPoints": config_data["entryPoints"],
+        "version": toml_data["version"],
+        "authors": toml_data["authors"],
+        "dependencies": toml_data.get("dependencies", {}),
+    }
+
+
+def validate_config(config: dict[str, str]) -> None:
+    """Validate the combined project configuration.
+
+    Checks for required fields and invalid characters in project name and description.
+
+    Args:
+        config: The combined configuration dictionary from uipath.json and pyproject.toml
+
+    Raises:
+        SystemExit: If validation fails for any required field or contains invalid characters
+    """
+    if not config["project_name"] or config["project_name"].strip() == "":
+        console.error(
+            "Project name cannot be empty. Please specify a name in pyproject.toml."
+        )
+
+    if not config["description"] or config["description"].strip() == "":
+        console.error(
+            "Project description cannot be empty. Please specify a description in pyproject.toml."
+        )
+
+    if not config["authors"] or config["authors"].strip() == "":
+        console.error(
+            'Project authors cannot be empty. Please specify authors in pyproject.toml:\n    authors = [{ name = "John Doe" }]'
+        )
+
+    invalid_chars = ["&", "<", ">", '"', "'", ";"]
+    for char in invalid_chars:
+        if char in config["project_name"]:
+            console.error(f"Project name contains invalid character: '{char}'")
+
+    for char in invalid_chars:
+        if char in config["description"]:
+            console.error(f"Project description contains invalid character: '{char}'")
+
+
+def validate_config_structure(config_data: dict[str, Any]) -> None:
+    """Validate the structure of uipath.json configuration.
+
+    Args:
+        config_data: The raw configuration data from uipath.json
+
+    Raises:
+        SystemExit: If required fields are missing from the configuration
+    """
+    required_fields = ["entryPoints"]
+    for field in required_fields:
+        if field not in config_data:
+            console.error(f"uipath.json is missing the required field: {field}.")
+
+
+def ensure_config_file(directory: str) -> None:
+    """Check if uipath.json exists in the specified directory.
+
+    Args:
+        directory: The directory to check for uipath.json
+
+    Raises:
+        SystemExit: If uipath.json is not found in the directory
+    """
+    if not os.path.isfile(os.path.join(directory, "uipath.json")):
+        console.error(
+            "uipath.json not found. Please run `uipath init` in the project directory."
+        )
+
+
+def extract_dependencies_from_toml(project_data: Dict) -> Dict[str, str]:
+    """Extract and parse dependencies from pyproject.toml project data.
+
+    Args:
+        project_data: The "project" section from pyproject.toml
+
+    Returns:
+        Dictionary mapping package names to version specifiers
+    """
+    dependencies = {}
+
+    if "dependencies" not in project_data:
+        return dependencies
+
+    deps_list = project_data["dependencies"]
+    if not isinstance(deps_list, list):
+        console.warning("dependencies should be a list in pyproject.toml")
+        return dependencies
+
+    for dep in deps_list:
+        if not isinstance(dep, str):
+            console.warning(f"Skipping non-string dependency: {dep}")
+            continue
+
+        try:
+            name, version_spec = parse_dependency_string(dep)
+            if name:  # Only add if we got a valid name
+                dependencies[name] = version_spec
+        except Exception as e:
+            console.warning(f"Failed to parse dependency '{dep}': {e}")
+            continue
+
+    return dependencies
+
+
+def parse_dependency_string(dependency: str) -> Tuple[str, str]:
+    """Parse a dependency string into package name and version specifier.
+
+    Handles PEP 508 dependency specifications including:
+    - Simple names: "requests"
+    - Version specifiers: "requests>=2.28.0"
+    - Complex specifiers: "requests>=2.28.0,<3.0.0"
+    - Extras: "requests[security]>=2.28.0"
+    - Environment markers: "requests>=2.28.0; python_version>='3.8'"
+
+    Args:
+        dependency: Raw dependency string from pyproject.toml
+
+    Returns:
+        Tuple of (package_name, version_specifier)
+
+    Examples:
+        "requests" -> ("requests", "*")
+        "requests>=2.28.0" -> ("requests", ">=2.28.0")
+        "requests>=2.28.0,<3.0.0" -> ("requests", ">=2.28.0,<3.0.0")
+        "requests[security]>=2.28.0" -> ("requests", ">=2.28.0")
+    """
+    # Remove whitespace
+    dependency = dependency.strip()
+
+    # Handle environment markers (everything after semicolon)
+    if ";" in dependency:
+        dependency = dependency.split(";")[0].strip()
+
+    # Pattern to match package name with optional extras and version specifiers
+    # Matches: package_name[extras] version_specs
+    pattern = r"^([a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?)(\[[^\]]+\])?(.*)"
+    match = re.match(pattern, dependency)
+
+    if not match:
+        # Fallback for edge cases
+        return dependency, "*"
+
+    package_name = match.group(1)
+    version_part = match.group(4).strip() if match.group(4) else ""
+
+    # If no version specifier, return wildcard
+    if not version_part:
+        return package_name, "*"
+
+    # Clean up version specifier
+    version_spec = version_part.strip()
+
+    # Validate that version specifier starts with a valid operator
+    valid_operators = [">=", "<=", "==", "!=", "~=", ">", "<"]
+    if not any(version_spec.startswith(op) for op in valid_operators):
+        # If it doesn't start with an operator, treat as exact version
+        if version_spec:
+            version_spec = f"=={version_spec}"
+        else:
+            version_spec = "*"
+
+    return package_name, version_spec
+
+
+def read_toml_project(file_path: str) -> dict:
+    """Read and parse pyproject.toml file with improved error handling and validation.
+
+    Args:
+        file_path: Path to pyproject.toml file
+
+    Returns:
+        Dictionary containing project metadata and dependencies
+    """
+    try:
+        with open(file_path, "rb") as f:
+            content = tomllib.load(f)
+    except Exception as e:
+        console.error(f"Failed to read or parse pyproject.toml: {e}")
+
+    # Validate required sections
+    if "project" not in content:
+        console.error("pyproject.toml is missing the required field: project.")
+
+    project = content["project"]
+
+    # Validate required fields with better error messages
+    required_fields = {
+        "name": "Project name is required in pyproject.toml",
+        "description": "Project description is required in pyproject.toml",
+        "version": "Project version is required in pyproject.toml",
+    }
+
+    for field, error_msg in required_fields.items():
+        if field not in project:
+            console.error(
+                f"pyproject.toml is missing the required field: project.{field}. {error_msg}"
+            )
+
+        # Check for empty values only if field exists
+        if field in project and (
+            not project[field]
+            or (isinstance(project[field], str) and not project[field].strip())
+        ):
+            console.error(
+                f"Project {field} cannot be empty. Please specify a {field} in pyproject.toml."
+            )
+
+    # Extract author information safely
+    authors = project.get("authors", [])
+    author_name = ""
+
+    if authors and isinstance(authors, list) and len(authors) > 0:
+        first_author = authors[0]
+        if isinstance(first_author, dict):
+            author_name = first_author.get("name", "")
+        elif isinstance(first_author, str):
+            # Handle case where authors is a list of strings
+            author_name = first_author
+
+    # Extract dependencies with improved parsing
+    dependencies = extract_dependencies_from_toml(project)
+
+    return {
+        "name": project["name"].strip(),
+        "description": project["description"].strip(),
+        "version": project["version"].strip(),
+        "authors": author_name.strip(),
+        "dependencies": dependencies,
+    }
+
+
+def files_to_include(
+    config_data: Optional[dict[Any, Any]], directory: str
+) -> list[FileInfo]:
+    """Get list of files to include in the project based on configuration.
+
+    Walks through the directory tree and identifies files to include based on extensions
+    and explicit inclusion rules. Skips virtual environments and hidden directories.
+
+    Args:
+        settings_section: Configuration section containing file inclusion rules
+        directory: Root directory to search for files
+
+    Returns:
+        list[FileInfo]: List of file information objects for included files
+    """
+    file_extensions_included = [".py", ".mermaid", ".json", ".yaml", ".yml", ".md"]
+    files_included = ["pyproject.toml"]
+    if "settings" in config_data:
+        settings = config_data["settings"]
+        if "fileExtensionsIncluded" in settings:
+            file_extensions_included.extend(settings["fileExtensionsIncluded"])
+        if "filesIncluded" in settings:
+            files_included.extend(settings["filesIncluded"])
+
+    def is_venv_dir(d: str) -> bool:
+        """Check if a directory is a Python virtual environment.
+
+        Args:
+            d: Directory path to check
+
+        Returns:
+            bool: True if directory is a virtual environment, False otherwise
+        """
+        return (
+            os.path.exists(os.path.join(d, "Scripts", "activate"))
+            if os.name == "nt"
+            else os.path.exists(os.path.join(d, "bin", "activate"))
+        )
+
+    extra_files: list[FileInfo] = []
+    # Walk through directory and return all files in the allowlist
+    for root, dirs, files in os.walk(directory):
+        # Skip all directories that start with . or are a venv
+        dirs[:] = [
+            d
+            for d in dirs
+            if not d.startswith(".") and not is_venv_dir(os.path.join(root, d))
+        ]
+        for file in files:
+            file_extension = os.path.splitext(file)[1].lower()
+            if file_extension in file_extensions_included or file in files_included:
+                file_path = os.path.join(root, file)
+                rel_path = os.path.relpath(file_path, directory)
+                extra_files.append(
+                    FileInfo(
+                        file_path=file_path,
+                        relative_path=rel_path,
+                        is_binary=is_binary_file(file_extension),
+                    )
+                )
+    return extra_files

uipath/_cli/_utils/_studio_project.py

@@ -0,0 +1,138 @@
+from typing import List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class ProjectFile(BaseModel):
+    """Model representing a file in a UiPath project.
+
+    Attributes:
+        id: The unique identifier of the file
+        name: The name of the file
+        is_main: Whether this is a main file
+        file_type: The type of the file
+        is_entry_point: Whether this is an entry point
+        ignored_from_publish: Whether this file is ignored during publish
+        app_form_id: The ID of the associated app form
+        external_automation_id: The ID of the external automation
+        test_case_id: The ID of the associated test case
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    id: str = Field(alias="id")
+    name: str = Field(alias="name")
+    is_main: Optional[bool] = Field(default=None, alias="isMain")
+    file_type: Optional[str] = Field(default=None, alias="fileType")
+    is_entry_point: Optional[bool] = Field(default=None, alias="isEntryPoint")
+    ignored_from_publish: Optional[bool] = Field(
+        default=None, alias="ignoredFromPublish"
+    )
+    app_form_id: Optional[str] = Field(default=None, alias="appFormId")
+    external_automation_id: Optional[str] = Field(
+        default=None, alias="externalAutomationId"
+    )
+    test_case_id: Optional[str] = Field(default=None, alias="testCaseId")
+
+    @field_validator("file_type", mode="before")
+    @classmethod
+    def convert_file_type(cls, v: Union[str, int, None]) -> Optional[str]:
+        """Convert numeric file type to string.
+
+        Args:
+            v: The value to convert
+
+        Returns:
+            Optional[str]: The converted value or None
+        """
+        if isinstance(v, int):
+            return str(v)
+        return v
+
+
+class ProjectFolder(BaseModel):
+    """Model representing a folder in a UiPath project structure.
+
+    Attributes:
+        id: The unique identifier of the folder
+        name: The name of the folder
+        folders: List of subfolders
+        files: List of files in the folder
+        folder_type: The type of the folder
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    id: str = Field(alias="id")
+    name: str = Field(alias="name")
+    folders: List["ProjectFolder"] = Field(default_factory=list)
+    files: List[ProjectFile] = Field(default_factory=list)
+    folder_type: Optional[str] = Field(default=None, alias="folderType")
+
+    @field_validator("folder_type", mode="before")
+    @classmethod
+    def convert_folder_type(cls, v: Union[str, int, None]) -> Optional[str]:
+        """Convert numeric folder type to string.
+
+        Args:
+            v: The value to convert
+
+        Returns:
+            Optional[str]: The converted value or None
+        """
+        if isinstance(v, int):
+            return str(v)
+        return v
+
+
+class ProjectStructure(BaseModel):
+    """Model representing the complete file structure of a UiPath project.
+
+    Attributes:
+        id: The unique identifier of the root folder (optional)
+        name: The name of the root folder (optional)
+        folders: List of folders in the project
+        files: List of files at the root level
+        folder_type: The type of the root folder (optional)
+    """
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
+    )
+
+    id: Optional[str] = Field(default=None, alias="id")
+    name: Optional[str] = Field(default=None, alias="name")
+    folders: List[ProjectFolder] = Field(default_factory=list)
+    files: List[ProjectFile] = Field(default_factory=list)
+    folder_type: Optional[str] = Field(default=None, alias="folderType")
+
+    @field_validator("folder_type", mode="before")
+    @classmethod
+    def convert_folder_type(cls, v: Union[str, int, None]) -> Optional[str]:
+        """Convert numeric folder type to string.
+
+        Args:
+            v: The value to convert
+
+        Returns:
+            Optional[str]: The converted value or None
+        """
+        if isinstance(v, int):
+            return str(v)
+        return v

uipath/_cli/_utils/_uv_helpers.py

@@ -0,0 +1,114 @@
+import os
+import subprocess
+
+from .._utils._console import ConsoleLogger
+
+console = ConsoleLogger()
+
+
+def handle_uv_operations(directory: str) -> None:
+    """Handle UV package manager operations for the project.
+
+    This function checks if UV is available and if the project uses UV,
+    then ensures the lock file is up to date by running 'uv lock'.
+
+    Args:
+        directory: The project root directory where UV operations should be performed
+
+    Note:
+        This function will silently return if UV is not available or if the project
+        doesn't use UV (no uv.lock file present).
+    """
+    if not is_uv_available():
+        return
+    if not is_uv_project(directory):
+        return
+    # Always run uv lock to ensure lock file is up to date
+    run_uv_lock(directory)
+
+
+def is_uv_available() -> bool:
+    """Check if UV package manager is available in the system.
+
+    Attempts to run 'uv --version' to verify UV is installed and accessible.
+
+    Returns:
+        bool: True if UV is available and working, False otherwise
+
+    Note:
+        This function will return False if:
+        - UV is not installed
+        - UV command fails to execute
+        - Any unexpected error occurs during version check
+    """
+    try:
+        subprocess.run(["uv", "--version"], capture_output=True, check=True, timeout=20)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+    except Exception as e:
+        console.warning(
+            f"An unexpected error occurred while checking uv availability: {str(e)}"
+        )
+        return False
+
+
+def is_uv_project(directory: str) -> bool:
+    """Check if the project uses UV package manager.
+
+    Determines if this is a UV project by checking for the presence
+    of a uv.lock file in the project directory.
+
+    Args:
+        directory: The project root directory to check
+
+    Returns:
+        bool: True if uv.lock exists, indicating a UV project, False otherwise
+    """
+    uv_lock_path = os.path.join(directory, "uv.lock")
+
+    # If uv.lock exists, it's definitely a uv project
+    if os.path.exists(uv_lock_path):
+        return True
+
+    return False
+
+
+def run_uv_lock(directory: str) -> bool:
+    """Run 'uv lock' command to update the project's lock file.
+
+    Executes UV lock command to ensure dependencies are properly locked
+    and the lock file is up to date.
+
+    Args:
+        directory: The project root directory where the lock command should be run
+
+    Returns:
+        bool: True if the lock command succeeds, False if it fails for any reason
+
+    Note:
+        This function will log warnings and return False if:
+        - The UV command fails to execute
+        - UV is not found in the system
+        - The lock command times out (60 seconds)
+        - Any unexpected error occurs during execution
+    """
+    try:
+        subprocess.run(
+            ["uv", "lock"],
+            cwd=directory,
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=60,
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        console.warning(f"uv lock failed: {e.stderr}")
+        return False
+    except FileNotFoundError:
+        console.warning("uv command not found. Skipping lock file update.")
+        return False
+    except Exception as e:
+        console.warning(f"An unexpected error occurred while running uv lock: {str(e)}")
+        return False