uipath 2.1.124__tar.gz → 2.1.125__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.124
+Version: 2.1.125
 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.125}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.124"
+version = "2.1.125"
 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.125}/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
 
@@ -116,3 +120,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.125}/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.125}/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(

{uipath-2.1.124 → uipath-2.1.125}/src/uipath/_cli/cli_eval.py

@@ -13,9 +13,11 @@ from uipath._cli._evals._runtime import (
 )
 from uipath._cli._runtime._runtime_factory import generate_runtime_factory
 from uipath._cli._utils._folders import get_personal_workspace_key_async
+from uipath._cli._utils._studio_project import StudioClient
 from uipath._cli.middlewares import Middlewares
 from uipath._config import UiPathConfig
 from uipath._events._event_bus import EventBus
+from uipath._utils._bindings import ResourceOverwritesContext
 from uipath.eval._helpers import auto_discover_entrypoint
 from uipath.tracing import LlmOpsHttpExporter
 
@@ -155,7 +157,25 @@ def eval(
             runtime_factory = generate_runtime_factory()
             if eval_context.job_id:
                 runtime_factory.add_span_exporter(LlmOpsHttpExporter())
-            asyncio.run(evaluate(runtime_factory, eval_context, event_bus))
+
+            async def execute_eval():
+                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} resource overwrite(s)"
+                        )
+                        await evaluate(runtime_factory, eval_context, event_bus)
+                else:
+                    # Fall back to execution without overwrites
+                    await evaluate(runtime_factory, eval_context, event_bus)
+
+            asyncio.run(execute_eval())
 
         except Exception as e:
             console.error(

{uipath-2.1.124 → uipath-2.1.125}/src/uipath/_cli/cli_run.py

@@ -7,7 +7,9 @@ from typing import Optional
 import click
 
 from uipath._cli._runtime._runtime_factory import generate_runtime_factory
+from uipath._cli._utils._common import read_resource_overwrites_from_file
 from uipath._cli._utils._debug import setup_debugging
+from uipath._utils._bindings import ResourceOverwritesContext
 from uipath.tracing import JsonLinesFileExporter, LlmOpsHttpExporter
 
 from .._utils.constants import (
@@ -123,7 +125,17 @@ def run(
                 if trace_file:
                     runtime_factory.add_span_exporter(JsonLinesFileExporter(trace_file))
 
-                result = await runtime_factory.execute(context)
+                if context.job_id:
+                    async with ResourceOverwritesContext(
+                        lambda: read_resource_overwrites_from_file(context.runtime_dir)
+                    ) as ctx:
+                        console.info(
+                            f"Applied {ctx.overwrites_count} resource overwrite(s)"
+                        )
+
+                        result = await runtime_factory.execute(context)
+                else:
+                    result = await runtime_factory.execute(context)
 
                 if not context.job_id:
                     console.info(result.output)

{uipath-2.1.124 → uipath-2.1.125}/src/uipath/_config.py

@@ -24,6 +24,12 @@ class ConfigurationManager:
 
         return Path(UIPATH_BINDINGS_FILE)
 
+    @property
+    def config_file_name(self) -> str:
+        from uipath._utils.constants import UIPATH_CONFIG_FILE
+
+        return UIPATH_CONFIG_FILE
+
     @property
     def project_id(self) -> Optional[str]:
         from uipath._utils.constants import ENV_UIPATH_PROJECT_ID
@@ -40,5 +46,11 @@ class ConfigurationManager:
     def is_studio_project(self) -> bool:
         return self.project_id is not None
 
+    @property
+    def job_key(self) -> Optional[str]:
+        from uipath._utils.constants import ENV_JOB_KEY
+
+        return os.getenv(ENV_JOB_KEY, None)
+
 
 UiPathConfig = ConfigurationManager()

{uipath-2.1.124 → uipath-2.1.125}/src/uipath/_services/_base_service.py

@@ -19,8 +19,6 @@ from tenacity import (
     wait_exponential,
 )
 
-from uipath._utils._read_overwrites import OverwritesManager
-
 from .._config import Config
 from .._execution_context import ExecutionContext
 from .._utils import UiPathUrl, user_agent_value
@@ -56,7 +54,6 @@ class BaseService:
         self._client = Client(**client_kwargs)
         self._client_async = AsyncClient(**client_kwargs)
 
-        self._overwrites_manager = OverwritesManager()
         self._logger.debug(f"HEADERS: {self.default_headers}")
 
         super().__init__()

{uipath-2.1.124 → uipath-2.1.125}/src/uipath/_services/assets_service.py

@@ -6,7 +6,6 @@ from .._config import Config
 from .._execution_context import ExecutionContext
 from .._folder_context import FolderContext
 from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
-from .._utils._read_overwrites import OverwritesManager
 from ..models import Asset, UserAsset
 from ..tracing._traced import traced
 from ._base_service import BaseService
@@ -21,7 +20,6 @@ class AssetsService(FolderContext, BaseService):
 
     def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
         super().__init__(config=config, execution_context=execution_context)
-        self._overwrites_manager = OverwritesManager()
         self._base_url = "assets"
 
     @traced(

{uipath-2.1.124 → uipath-2.1.125}/src/uipath/_utils/__init__.py

@@ -1,5 +1,5 @@
+from ._bindings import get_inferred_bindings_names, infer_bindings
 from ._endpoint import Endpoint
-from ._infer_bindings import get_inferred_bindings_names, infer_bindings
 from ._logs import setup_logging
 from ._request_override import header_folder
 from ._request_spec import RequestSpec

uipath-2.1.125/src/uipath/_utils/_bindings.py

@@ -0,0 +1,109 @@
+import functools
+import inspect
+from contextvars import ContextVar, Token
+from typing import Any, Callable, Coroutine, Optional, TypeVar
+
+from pydantic import BaseModel, ConfigDict, Field
+
+T = TypeVar("T")
+
+
+class ResourceOverwrite(BaseModel):
+    """Represents a resource overwrite configuration.
+
+    Attributes:
+        overwrite_name: The name of the resource being overwritten
+        overwrite_folder_path: The folder path of the overwrite resource
+    """
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+    )
+
+    overwrite_name: str = Field(alias="name")
+    overwrite_folder_path: str = Field(alias="folderPath")
+
+
+_resource_overwrites: ContextVar[Optional[dict[str, ResourceOverwrite]]] = ContextVar(
+    "resource_overwrites", default=None
+)
+
+
+class ResourceOverwritesContext:
+    def __init__(
+        self,
+        get_overwrites_callable: Callable[
+            [], Coroutine[Any, Any, dict[str, ResourceOverwrite]]
+        ],
+    ):
+        self.get_overwrites_callable = get_overwrites_callable
+        self._token: Optional[Token[Optional[dict[str, ResourceOverwrite]]]] = None
+        self.overwrites_count = 0
+
+    async def __aenter__(self) -> "ResourceOverwritesContext":
+        overwrites = await self.get_overwrites_callable()
+        self._token = _resource_overwrites.set(overwrites)
+        self.overwrites_count = len(overwrites)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._token:
+            _resource_overwrites.reset(self._token)
+
+
+def infer_bindings(
+    resource_type: str,
+    name: str = "name",
+    folder_path: str = "folder_path",
+    ignore: bool = False,
+) -> Callable[..., Any]:
+    def decorator(func: Callable[..., Any]):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # convert both args and kwargs to single dict
+            sig = inspect.signature(func)
+            bound = sig.bind_partial(*args, **kwargs)
+            bound.apply_defaults()
+            all_args = dict(bound.arguments)
+
+            # Get overwrites from context variable
+            context_overwrites = _resource_overwrites.get()
+
+            if context_overwrites is not None:
+                resource_name = all_args.get(name)
+                resource_folder_path = all_args.get(folder_path)
+
+                key = f"{resource_type}.{resource_name}"
+                # try to apply folder path, fallback to resource_type.resource_name
+                if resource_folder_path:
+                    key = (
+                        f"{key}.{resource_folder_path}"
+                        if f"{key}.{resource_folder_path}" in context_overwrites
+                        else key
+                    )
+
+                matched_overwrite = context_overwrites.get(key)
+
+                # Apply the matched overwrite
+                if matched_overwrite is not None:
+                    if name in sig.parameters:
+                        all_args[name] = matched_overwrite.overwrite_name
+                    if folder_path in sig.parameters:
+                        all_args[folder_path] = matched_overwrite.overwrite_folder_path
+
+            return func(**all_args)
+
+        wrapper._should_infer_bindings = not ignore  # type: ignore
+        wrapper._infer_bindings_mappings = {"name": name, "folder_path": folder_path}  # type: ignore
+        return wrapper
+
+    return decorator
+
+
+def get_inferred_bindings_names(cls: T):
+    inferred_bindings = {}
+    for name, method in inspect.getmembers(cls, inspect.isfunction):
+        if hasattr(method, "_should_infer_bindings") and method._should_infer_bindings:
+            inferred_bindings[name] = method._infer_bindings_mappings  # type: ignore
+
+    return inferred_bindings