uipath 2.1.124__tar.gz → 2.1.126__tar.gz

{uipath-2.1.124 → uipath-2.1.126}/.github/workflows/ci.yml

@@ -19,4 +19,4 @@ jobs:
     uses: ./.github/workflows/lint.yml
 
   test:
-    uses: ./.github/workflows/test.yml
+    uses: ./.github/workflows/test.yml

uipath-2.1.126/.pipelines/security-scans.yml

@@ -0,0 +1,53 @@
+trigger: none
+pr: none
+
+schedules:
+  - cron: "0 11 * * 1"
+    displayName: "Every Monday at 1:00 PM"
+    branches:
+      include:
+        - main
+    always: true
+
+resources:
+  repositories:
+    - repository: codeql
+      type: github
+      name: UiPath/AzurePipelinesTemplates
+      ref: refs/tags/uipath.security.codeql.1.9.5
+      endpoint: UiPath
+    - repository: fossa
+      type: github
+      name: UiPath/AzurePipelinesTemplates
+      ref: refs/tags/uipath.security.fossa.3.0.13
+      endpoint: UiPath
+
+variables:
+  - template: ./variables.yml
+
+stages:
+  - stage: FOSSA
+    dependsOn: []
+    jobs:
+      - job: FOSSA
+        steps:
+          - template: Security/fossa.steps.yml@fossa
+            parameters:
+              OS: linux
+              azureSubscription: $(azureInternalProductionEaConnectionName)
+              FOSSAFlags: '--project "Coded Agents" --branch "$(Build.SourceBranch)" --revision "$(Build.SourceVersion)-$(Build.BuildId)"'
+              FOSSATestFlags: '--project "Coded Agents" --revision "$(Build.SourceVersion)-$(Build.BuildId)"'
+              ${{ if contains(variables['Build.SourceBranch'], 'main') }}:
+                publishSecurityReports: true
+
+
+  - stage: CODEQL
+    dependsOn: []
+    jobs:
+      - job: CODEQL
+        steps:
+          - template: Security/codeql.interpreted.steps.yml@codeql
+            parameters:
+              os: 'linux64'
+              language: 'python'
+              azureSubscription: $(azureInternalProductionEaConnectionName)

uipath-2.1.126/.pipelines/variables.yml

@@ -0,0 +1,2 @@
+variables:
+  azureInternalProductionEaConnectionName: Internal-Production-EA

{uipath-2.1.124 → uipath-2.1.126}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.124
+Version: 2.1.126
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.124 → uipath-2.1.126}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.124"
+version = "2.1.126"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.124 → uipath-2.1.126}/scripts/update_agents_md.py

@@ -152,6 +152,8 @@ def generate_quick_api_docs() -> str:
     Returns:
         Markdown string with SDK API documentation
     """
+    from functools import cached_property
+
     from uipath import UiPath
 
     output = StringIO()
@@ -178,7 +180,7 @@ def generate_quick_api_docs() -> str:
         if name.startswith("_"):
             continue
         attr = getattr(UiPath, name, None)
-        if isinstance(attr, property):
+        if isinstance(attr, (property, cached_property)):
             uipath_properties.append(name)
 
     uipath_properties.sort()
@@ -186,12 +188,19 @@ def generate_quick_api_docs() -> str:
     for service_name in uipath_properties:
         try:
             service_property = getattr(UiPath, service_name)
-            if not isinstance(service_property, property):
+            if not isinstance(service_property, (property, cached_property)):
                 continue
 
-            service_doc = (
-                service_property.fget.__doc__ if service_property.fget else None
-            )
+            # Get the function object (property uses .fget, cached_property uses .func)
+            if isinstance(service_property, cached_property):
+                func = service_property.func
+            else:
+                func = service_property.fget  # type: ignore[assignment]
+
+            if func is None:
+                continue
+
+            service_doc = func.__doc__
 
             description = (
                 service_doc.strip().split("\n")[0]
@@ -200,9 +209,8 @@ def generate_quick_api_docs() -> str:
             )
 
             return_annotation = None
-            if service_property.fget:
-                property_sig = inspect.signature(service_property.fget)
-                return_annotation = property_sig.return_annotation
+            property_sig = inspect.signature(func)
+            return_annotation = property_sig.return_annotation
 
             output.write(f"### {service_name.replace('_', ' ').title()}\n\n")
             output.write(f"{description}\n\n")
@@ -473,6 +481,115 @@ def generate_cli_docs() -> str:
     return output.getvalue()
 
 
+def generate_service_cli_docs() -> str:
+    """Generate documentation for service CLI commands.
+
+    Returns:
+        Markdown string with service CLI commands documentation
+    """
+    from uipath._cli import cli
+
+    output = StringIO()
+    output.write("\n## Service Commands Reference\n\n")
+    output.write(
+        "The UiPath CLI provides commands for interacting with UiPath platform services. "
+        "These commands allow you to manage buckets, assets, jobs, and other resources.\n\n"
+    )
+
+    # Find all service command groups (Groups registered in CLI)
+    service_groups = []
+    for name, cmd in sorted(cli.commands.items()):
+        if isinstance(cmd, click.Group) and name not in [
+            "init",
+            "run",
+            "eval",
+            "new",
+            "pack",
+            "publish",
+            "deploy",
+        ]:
+            service_groups.append((name, cmd))
+
+    if not service_groups:
+        return ""
+
+    for service_name, service_group in service_groups:
+        output.write(f"### `uipath {service_name}`\n\n")
+        output.write(f"{service_group.help or 'Manage ' + service_name}\n\n")
+
+        # Document subcommands
+        if hasattr(service_group, "commands"):
+            subcommands = sorted(service_group.commands.items())
+            output.write("**Subcommands:**\n\n")
+
+            for subcmd_name, subcmd in subcommands:
+                # Handle nested groups (e.g., buckets files)
+                if isinstance(subcmd, click.Group):
+                    output.write(f"#### `uipath {service_name} {subcmd_name}`\n\n")
+                    output.write(f"{subcmd.help or f'{subcmd_name} commands'}\n\n")
+
+                    if hasattr(subcmd, "commands"):
+                        nested_cmds = sorted(subcmd.commands.items())
+                        for nested_name, nested_cmd in nested_cmds:
+                            cmd_info = get_command_help(
+                                nested_cmd,
+                                f"{service_name} {subcmd_name} {nested_name}",
+                            )
+                            _write_command_doc(
+                                output, cmd_info, service_name, subcmd_name
+                            )
+                else:
+                    cmd_info = get_command_help(subcmd, f"{service_name} {subcmd_name}")
+                    _write_command_doc(output, cmd_info, service_name)
+
+        output.write("---\n\n")
+
+    return output.getvalue()
+
+
+def _write_command_doc(
+    output: StringIO, cmd_info: Dict[str, Any], *path_parts: str
+) -> None:
+    """Write command documentation to output stream.
+
+    Args:
+        output: StringIO buffer to write to
+        cmd_info: Command information dict
+        path_parts: Command path parts (e.g., "buckets", "files")
+    """
+    full_path = " ".join(path_parts + (cmd_info["name"].split()[-1],))
+
+    output.write(f"**`uipath {full_path}`**\n\n")
+    output.write(f"{cmd_info['help']}\n\n")
+
+    arguments = [p for p in cmd_info["params"] if p["type"] == "Argument"]
+    options = [p for p in cmd_info["params"] if p["type"] == "Option"]
+
+    if arguments:
+        output.write("Arguments:\n")
+        for arg in arguments:
+            required = " (required)" if arg.get("required") else ""
+            help_text = arg["help"] if arg["help"] else "N/A"
+            output.write(f"- `{arg['name']}`{required}: {help_text}\n")
+        output.write("\n")
+
+    if options:
+        output.write("Options:\n")
+        for opt in options:
+            opts_str = ", ".join(f"`{o}`" for o in opt.get("opts", []))
+            help_text = opt["help"] if opt["help"] else ""
+
+            if opt.get("default") is not None and not opt.get("is_flag"):
+                default = opt["default"]
+                if isinstance(default, str):
+                    help_text += f" (default: `{default}`)"
+                else:
+                    help_text += f" (default: `{default}`)"
+
+            output.write(f"- {opts_str}: {help_text}\n")
+        output.write("\n")
+
+
 def generate_agents_md_reference_files() -> None:
     """Generate separate reference files."""
     resources_dir = Path(__file__).parent.parent / "src" / "uipath" / "_resources"
@@ -482,12 +599,15 @@ def generate_agents_md_reference_files() -> None:
 
     api_docs = generate_quick_api_docs()
     cli_docs = generate_cli_docs()
+    service_cli_docs = generate_service_cli_docs()
 
     with open(sdk_reference_path, "w", encoding="utf-8") as f:
         f.write(api_docs.lstrip("\n"))
 
     with open(cli_reference_path, "w", encoding="utf-8") as f:
         f.write(cli_docs.lstrip("\n"))
+        if service_cli_docs:
+            f.write(service_cli_docs)
 
 
 def main():

{uipath-2.1.124 → uipath-2.1.126}/src/uipath/_cli/_auth/_auth_service.py

@@ -19,7 +19,7 @@ from uipath.models.auth import TokenData
 class AuthService:
     def __init__(
         self,
-        environment: str,
+        environment: Optional[str],
         *,
         force: bool,
         client_id: Optional[str] = None,
@@ -34,7 +34,7 @@ class AuthService:
         self._client_secret = client_secret
         self._base_url = base_url
         self._tenant = tenant
-        self._domain = resolve_domain(self._base_url, environment, self._force)
+        self._domain = resolve_domain(self._base_url, environment)
         self._scope = scope
 
     def authenticate(self) -> None:

{uipath-2.1.124 → uipath-2.1.126}/src/uipath/_cli/_auth/_url_utils.py

@@ -7,9 +7,7 @@ from .._utils._console import ConsoleLogger
 console = ConsoleLogger()
 
 
-def resolve_domain(
-    base_url: Optional[str], environment: Optional[str], force: bool = False
-) -> str:
+def resolve_domain(base_url: Optional[str], environment: Optional[str]) -> str:
     """Resolve the UiPath domain, giving priority to base_url when valid.
 
     Args:
@@ -27,10 +25,9 @@ def resolve_domain(
         if domain:
             return domain
 
-    # If base_url is not set (or force is False), check UIPATH_URL
-    if not base_url or not force:
+    if environment is None:
         uipath_url = os.getenv("UIPATH_URL")
-        if uipath_url and environment == "cloud":
+        if uipath_url:
             parsed = urlparse(uipath_url)
             if parsed.scheme and parsed.netloc:
                 domain = f"{parsed.scheme}://{parsed.netloc}"

{uipath-2.1.124 → uipath-2.1.126}/src/uipath/_cli/_utils/_common.py

@@ -1,10 +1,14 @@
+import json
 import os
+from pathlib import Path
 from typing import Optional
 from urllib.parse import urlparse
 
 import click
 from dotenv import load_dotenv
 
+from ..._config import UiPathConfig
+from ..._utils._bindings import ResourceOverwrite
 from ..._utils.constants import DOTENV_FILE
 from ..spinner import Spinner
 
@@ -34,7 +38,6 @@ def environment_options(function):
         "--cloud",
         "environment",
         flag_value="cloud",
-        default=True,
         help="Use production environment",
     )(function)
     return function
@@ -116,3 +119,37 @@ def clean_directory(directory: str) -> None:
 
 def load_environment_variables():
     load_dotenv(dotenv_path=os.path.join(os.getcwd(), DOTENV_FILE), override=True)
+
+
+async def read_resource_overwrites_from_file(
+    directory_path: Optional[Path] = None,
+) -> dict[str, ResourceOverwrite]:
+    """Read resource overwrites from a JSON file."""
+    config_file_name = UiPathConfig.config_file_name
+    if directory_path is not None:
+        file_path = Path(f"{directory_path}/{config_file_name}")
+    else:
+        file_path = Path(f"{config_file_name}")
+
+    overwrites_dict = {}
+
+    try:
+        with open(file_path, "r") as f:
+            data = json.load(f)
+            resource_overwrites = (
+                data.get("runtime", {})
+                .get("internalArguments", {})
+                .get("resourceOverwrites", {})
+            )
+
+            for key, value in resource_overwrites.items():
+                overwrite = ResourceOverwrite.model_validate(value)
+                overwrites_dict[key] = overwrite
+
+    # Return empty dict if file doesn't exist or invalid json
+    except FileNotFoundError:
+        pass
+    except json.JSONDecodeError:
+        pass
+
+    return overwrites_dict

{uipath-2.1.124 → uipath-2.1.126}/src/uipath/_cli/_utils/_studio_project.py

@@ -1,12 +1,18 @@
 import json
 import os
+from enum import Enum
 from functools import wraps
 from pathlib import PurePath
 from typing import Any, Callable, List, Optional, Union
 
+import click
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
-from uipath._utils.constants import HEADER_SW_LOCK_KEY
+from uipath import UiPath
+from uipath._cli._utils._console import ConsoleLogger
+from uipath._config import UiPathConfig
+from uipath._utils._bindings import ResourceOverwrite
+from uipath._utils.constants import ENV_TENANT_ID, HEADER_SW_LOCK_KEY, HEADER_TENANT_ID
 from uipath.models.exceptions import EnrichedException
 from uipath.tracing import traced
 
@@ -131,6 +137,54 @@ class LockInfo(BaseModel):
     solution_lock_key: Optional[str] = Field(alias="solutionLockKey")
 
 
+class Severity(str, Enum):
+    """Severity level for virtual resource operation results."""
+
+    SUCCESS = "success"
+    ATTENTION = "attention"
+    WARN = "warn"
+
+
+class VirtualResourceRequest(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+    )
+
+    kind: str = Field(alias="kind")
+    name: str = Field(alias="name")
+    type: Optional[str] = Field(default=None, alias="type")
+    activity_name: Optional[str] = Field(default=None, alias="activityName")
+    api_version: Optional[str] = Field(default=None, alias="apiVersion")
+
+
+class VirtualResourceResult(BaseModel):
+    """Result of a virtual resource creation operation.
+
+    Attributes:
+        severity: The severity level (log, warn or attention)
+        message: The result message with styling
+    """
+
+    severity: Severity
+    message: str
+
+
+class ResourceOverwriteData(BaseModel):
+    """Represents the overwrite details from the API response.
+
+    Attributes:
+        name: The name of the resource being overwritten
+        folder_path: The folder path of the overwrite resource
+    """
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+    )
+
+    name: str = Field(alias="name")
+    folder_path: str = Field(alias="folderPath")
+
+
 def get_folder_by_name(
     structure: ProjectStructure, folder_name: str
 ) -> Optional[ProjectFolder]:
@@ -232,9 +286,7 @@ def with_lock_retry(func: Callable[..., Any]) -> Callable[..., Any]:
             return await func(self, *args, **kwargs)
         except EnrichedException as e:
             if e.status_code == 423:
-                from uipath._cli._utils._console import ConsoleLogger
-
-                console = ConsoleLogger()
+                console = ConsoleLogger().get_instance()
                 console.error(
                     "The project is temporarily locked. This could be due to modifications or active processes. Please wait a moment and try again."
                 )
@@ -284,16 +336,189 @@ class StudioSolutionsClient:
 
 
 class StudioClient:
-    def __init__(self, project_id: str):
-        from uipath import UiPath
-
-        self.uipath: UiPath = UiPath()
+    def __init__(self, project_id: str, uipath: Optional[UiPath] = None):
+        self.uipath: UiPath = uipath or UiPath()
         self.file_operations_base_url: str = (
             f"/studio_/backend/api/Project/{project_id}/FileOperations"
         )
         self._lock_operations_base_url: str = (
             f"/studio_/backend/api/Project/{project_id}/Lock"
         )
+        self._project_id = project_id
+        self._solution_id_cache: Optional[str] = None
+        self._resources_cache: Optional[List[dict[str, Any]]] = None
+
+    async def _get_solution_id(self) -> str:
+        # implement property cache logic as coroutines are not supported
+        if self._solution_id_cache is not None:
+            return self._solution_id_cache
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"/studio_/backend/api/Project/{self._project_id}",
+            scoped="org",
+        )
+        self._solution_id_cache = response.json()["solutionId"]
+        return self._solution_id_cache
+
+    async def _get_existing_resources(self) -> List[dict[str, Any]]:
+        if self._resources_cache is not None:
+            return self._resources_cache
+
+        solution_id = await self._get_solution_id()
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"/studio_/backend/api/resourcebuilder/solutions/{solution_id}/entities",
+            scoped="org",
+        )
+        resources_data = response.json().get("resources", [])
+        self._resources_cache = [
+            {"name": r.get("name"), "kind": r.get("kind")} for r in resources_data
+        ]
+        return self._resources_cache
+
+    async def get_resource_overwrites(self) -> dict[str, ResourceOverwrite]:
+        """Get resource overwrites from the solution.
+
+        Returns:
+            dict[str, ResourceOverwrite]: Dict of resource overwrites
+        """
+        if not os.path.exists(UiPathConfig.bindings_file_path):
+            return {}
+
+        with open(UiPathConfig.bindings_file_path, "rb") as f:
+            file_content = f.read()
+
+        solution_id = await self._get_solution_id()
+        tenant_id = os.getenv(ENV_TENANT_ID, None)
+
+        files = [
+            (
+                "file",
+                (
+                    os.path.basename(UiPathConfig.bindings_file_path),
+                    file_content,
+                    "application/json",
+                ),
+            )
+        ]
+
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"/studio_/backend/api/resourcebuilder/{solution_id}/binding-overwrites",
+            scoped="org",
+            headers={HEADER_TENANT_ID: tenant_id},
+            files=files,
+        )
+        data = response.json()
+        overwrites = {}
+
+        for key, value in data.items():
+            overwrites[key] = ResourceOverwrite.model_validate(value)
+
+        return overwrites
+
+    async def create_virtual_resource(
+        self, virtual_resource_request: VirtualResourceRequest
+    ) -> VirtualResourceResult:
+        """Create a virtual resource or return appropriate status if it already exists.
+
+        Args:
+            virtual_resource_request: The virtual resource request details
+
+        Returns:
+            VirtualResourceResult: Result indicating the operation status and a formatted message
+        """
+        # Build base message with resource details
+        base_message_parts = [
+            f"Resource {click.style(virtual_resource_request.name, fg='cyan')}",
+            f" (kind: {click.style(virtual_resource_request.kind, fg='yellow')}",
+        ]
+
+        if virtual_resource_request.type:
+            base_message_parts.append(
+                f", type: {click.style(virtual_resource_request.type, fg='yellow')}"
+            )
+
+        if virtual_resource_request.activity_name:
+            base_message_parts.append(
+                f", activity: {click.style(virtual_resource_request.activity_name, fg='yellow')}"
+            )
+
+        base_message_parts.append(")")
+        base_message = "".join(base_message_parts)
+
+        existing_resources = await self._get_existing_resources()
+
+        # Check if resource with same kind and name exists
+        existing_same_kind = next(
+            (
+                r
+                for r in existing_resources
+                if r["name"] == virtual_resource_request.name
+                and r["kind"] == virtual_resource_request.kind
+            ),
+            None,
+        )
+        if existing_same_kind:
+            message = f"{base_message} already exists. Skipping..."
+            return VirtualResourceResult(severity=Severity.ATTENTION, message=message)
+
+        # Check if resource with same name but different kind exists
+        existing_diff_kind = next(
+            (
+                r
+                for r in existing_resources
+                if r["name"] == virtual_resource_request.name
+                and r["kind"] != virtual_resource_request.kind
+            ),
+            None,
+        )
+        if existing_diff_kind:
+            message = (
+                f"Cannot create {base_message}. "
+                f"A resource with this name already exists with kind {click.style(existing_diff_kind['kind'], fg='yellow')}. "
+                f"Consider renaming the resource in code."
+            )
+            return VirtualResourceResult(severity=Severity.WARN, message=message)
+
+        # Create the virtual resource
+        solution_id = await self._get_solution_id()
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/virtual",
+            scoped="org",
+            json=virtual_resource_request.model_dump(exclude_none=True),
+        )
+        resource_key = response.json()["key"]
+        await self._update_resource_specs(
+            resource_key, new_specs={"name": virtual_resource_request.name}
+        )
+
+        # Update cache with newly created resource
+        if self._resources_cache is not None:
+            self._resources_cache.append(
+                {
+                    "name": virtual_resource_request.name,
+                    "kind": virtual_resource_request.kind,
+                }
+            )
+
+        message = f"{base_message} created successfully."
+        return VirtualResourceResult(severity=Severity.SUCCESS, message=message)
+
+    async def _update_resource_specs(
+        self, resource_key: str, new_specs: dict[str, Any]
+    ):
+        solution_id = await self._get_solution_id()
+        tenant_id = os.getenv(ENV_TENANT_ID, None)
+
+        await self.uipath.api_client.request_async(
+            "PATCH",
+            url=f"/studio_/backend/api/resourcebuilder/solutions/{solution_id}/resources/{resource_key}/configuration",
+            scoped="org",
+            json=new_specs,
+            headers={HEADER_TENANT_ID: tenant_id},
+        )
 
     @traced(name="get_project_structure", run_type="uipath")
     async def get_project_structure_async(self) -> ProjectStructure:

{uipath-2.1.124 → uipath-2.1.126}/src/uipath/_cli/cli_debug.py

@@ -7,6 +7,9 @@ from typing import Optional
 import click
 
 from uipath._cli._utils._debug import setup_debugging
+from uipath._cli._utils._studio_project import StudioClient
+from uipath._config import UiPathConfig
+from uipath._utils._bindings import ResourceOverwritesContext
 from uipath.tracing import LlmOpsHttpExporter
 
 from .._utils.constants import (
@@ -121,7 +124,7 @@ def debug(
             if debug_context.job_id:
                 runtime_factory.add_span_exporter(LlmOpsHttpExporter())
 
-            async def execute():
+            async def execute_debug_runtime():
                 async with UiPathDebugRuntime.from_debug_context(
                     factory=runtime_factory,
                     context=debug_context,
@@ -129,6 +132,20 @@ def debug(
                 ) as debug_runtime:
                     await debug_runtime.execute()
 
+            async def execute():
+                project_id = UiPathConfig.project_id
+
+                if project_id:
+                    studio_client = StudioClient(project_id)
+
+                    async with ResourceOverwritesContext(
+                        lambda: studio_client.get_resource_overwrites()
+                    ) as ctx:
+                        console.info(f"Applied {ctx.overwrites_count} overwrite(s)")
+                        await execute_debug_runtime()
+                else:
+                    await execute_debug_runtime()
+
             asyncio.run(execute())
         except Exception as e:
             console.error(