uipath 2.1.124__py3-none-any.whl → 2.1.125__py3-none-any.whl

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/_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/_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/_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/_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/_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/_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/_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/_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/_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

{uipath-2.1.124.dist-info → uipath-2.1.125.dist-info}/METADATA

@@ -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.dist-info → uipath-2.1.125.dist-info}/RECORD

@@ -1,5 +1,5 @@
 uipath/__init__.py,sha256=IaeKItOOQXMa95avueJ3dAq-XcRHyZVNjcCGwlSB000,634
-uipath/_config.py,sha256=YEiLmpHeeT2K_CinSVWr9aIWU6txfkgAUPP-jqxa9R0,990
+uipath/_config.py,sha256=wLE_DLB4d-tHDAA6biyv8hzCZ2RmYS--fab8t2EAjqI,1298
 uipath/_execution_context.py,sha256=Qo8VMUFgtiL-40KsZrvul5bGv1CRERle_fCw1ORCggY,2374
 uipath/_folder_context.py,sha256=D-bgxdwpwJP4b_QdVKcPODYh15kMDrOar2xNonmMSm4,1861
 uipath/_uipath.py,sha256=ycu11bjIUx5priRkB3xSRcilugHuSmfSN4Nq6Yz88gk,3702
@@ -8,10 +8,10 @@ uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=rEk5GEldWxhjfe7R4DiDDXsc6O4GMUX86CyuUDU4QCY,2471
 uipath/_cli/cli_add.py,sha256=7XpyeXIVnocNTJg_Wo1GeDFSoHDu8ACaYx__eYpiXzY,3690
 uipath/_cli/cli_auth.py,sha256=CzetSRqSUvMs02PtI4w5Vi_0fv_ETA307bB2vXalWzY,2628
-uipath/_cli/cli_debug.py,sha256=-s6Nmy0DnDyITjZAf6f71hZ1YDDt0Yl57XklEkuL0FU,4068
+uipath/_cli/cli_debug.py,sha256=6I3NutFahQ7nvbxUIgW8bmKeoShVf8RCvco3XU0kfTk,4796
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
-uipath/_cli/cli_eval.py,sha256=odAZtE8jfT9Yl3UyJgN6WJJcImt32iSJyi_uw1BTUtg,5404
+uipath/_cli/cli_eval.py,sha256=lRNP9kHxIsgdo2tl0bQraCMYLSyANS9VlAOJMr_JdEA,6229
 uipath/_cli/cli_init.py,sha256=39sQnIHol46D5ce4MBJRrD_8KOqvK1IyYhgn42_XYIM,7545
 uipath/_cli/cli_invoke.py,sha256=m-te-EjhDpk_fhFDkt-yQFzmjEHGo5lQDGEQWxSXisQ,4395
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
@@ -20,7 +20,7 @@ uipath/_cli/cli_publish.py,sha256=DgyfcZjvfV05Ldy0Pk5y_Le_nT9JduEE_x-VpIc_Kq0,64
 uipath/_cli/cli_pull.py,sha256=nV-OCdue_7C6x4f8jRoTYSnM-BgsWVsZUVibkgnogDU,2117
 uipath/_cli/cli_push.py,sha256=5J-dhDilsYrlYg1aV1eWOU84QC_PlwTi9tI3UZptg1k,3743
 uipath/_cli/cli_register.py,sha256=5-Asb8DSTR4W6M3TDi4U-AKXYOCZ3l2vcTuMOybDHEo,1465
-uipath/_cli/cli_run.py,sha256=9vbmSG_FzS0x8KNNzSrST37FKjUOzhXPjl8xTm2ZEqQ,4203
+uipath/_cli/cli_run.py,sha256=-pSuoPEfT-NzOmxLgNUtMvkYY-Lhk-dO5qv6UZkmkKU,4797
 uipath/_cli/middlewares.py,sha256=tb0c4sU1SCYi0PNs956Qmk24NDk0C0mBfVQmTcyORE0,5000
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=v_b8KNwn0tAv8jxpeKdllOVzl31q9AcdwpE_koAK_w4,7235
@@ -86,7 +86,7 @@ uipath/_cli/_templates/[Content_Types].xml.template,sha256=bYsKDz31PkIF9QksjgAY_
 uipath/_cli/_templates/custom_evaluator.py.template,sha256=OuYQb8ScAOK7Qwz4FYwdETlC2NonEhLF5DXGnsYOzHg,2313
 uipath/_cli/_templates/main.py.template,sha256=QB62qX5HKDbW4lFskxj7h9uuxBITnTWqu_DE6asCwcU,476
 uipath/_cli/_templates/package.nuspec.template,sha256=YZyLc-u_EsmIoKf42JsLQ55OGeFmb8VkIU2VF7DFbtw,359
-uipath/_cli/_utils/_common.py,sha256=fSZkps1sjOXRyWn8GqmQfGqYAZ_tVua6dgT18Lpscds,3467
+uipath/_cli/_utils/_common.py,sha256=RVLfHIRJ7mUIxpV61lwqGqQbr1QIhJ8cb5r_GKZzpws,4628
 uipath/_cli/_utils/_console.py,sha256=scvnrrFoFX6CE451K-PXKV7UN0DUkInbOtDZ5jAdPP0,10070
 uipath/_cli/_utils/_constants.py,sha256=AXeVidtHUFiODrkB2BCX_bqDL-bUzRg-Ieh1-2cCrGA,1374
 uipath/_cli/_utils/_debug.py,sha256=zamzIR4VgbdKADAE4gbmjxDsbgF7wvdr7C5Dqp744Oc,1739
@@ -97,7 +97,7 @@ uipath/_cli/_utils/_parse_ast.py,sha256=24YL28qK5Ss2O26IlzZ2FgEC_ZazXld_u3vkj8zV
 uipath/_cli/_utils/_processes.py,sha256=q7DfEKHISDWf3pngci5za_z0Pbnf_shWiYEcTOTCiyk,1855
 uipath/_cli/_utils/_project_files.py,sha256=i3F94aYekpM7PHVC3FrC1-lRBw-Tpe9XihN7pjCUkys,21812
 uipath/_cli/_utils/_resources.py,sha256=0MpEZWaY2oDDoxOVVTOXrTWpuwhQyypLcM8TgnXFQq0,577
-uipath/_cli/_utils/_studio_project.py,sha256=2QzB9lyDlWukWMlFbAyv-DXhhGBK973Bsl3ZbiIambg,18286
+uipath/_cli/_utils/_studio_project.py,sha256=kEjCFyP-pm9mVOR-C-makoZ_vbgQRHfu8kRZfRsJino,26308
 uipath/_cli/_utils/_tracing.py,sha256=2igb03j3EHjF_A406UhtCKkPfudVfFPjUq5tXUEG4oo,1541
 uipath/_cli/_utils/_uv_helpers.py,sha256=6SvoLnZPoKIxW0sjMvD1-ENV_HOXDYzH34GjBqwT138,3450
 uipath/_cli/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -111,10 +111,10 @@ uipath/_resources/CLI_REFERENCE.md,sha256=PNVZINTXDSW4XN8QtxV3kS2WLreR7UyLfSso1_
 uipath/_resources/REQUIRED_STRUCTURE.md,sha256=3laqGiNa3kauJ7jRI1d7w_fWKUDkqYBjcTT_6_8FAGk,1417
 uipath/_resources/SDK_REFERENCE.md,sha256=lvQxxdsHi-kzur2C1L4fJ6cEvjVdJPUNSX8UMofgqUQ,19485
 uipath/_services/__init__.py,sha256=_LNy4u--VlhVtTO66bULbCoBjyJBTuyh9jnzjWrv-h4,1140
-uipath/_services/_base_service.py,sha256=x9-9jhPzn9Z16KRdFHhJNvV-FZHvTniMsDfxlS4Cutk,5782
+uipath/_services/_base_service.py,sha256=6yGNEZ-px6lVR9l4wiMr8NDSeLrZU6nmjUlRp3lMDi8,5665
 uipath/_services/actions_service.py,sha256=2RPMR-hFMsOlqEyjIf3aF7-lrf57jdrSD0pBjj0Kyko,16040
 uipath/_services/api_client.py,sha256=kGm04ijk9AOEQd2BMxvQg-2QoB8dmyoDwFFDPyutAGw,1966
-uipath/_services/assets_service.py,sha256=mcnjbxW1JL_lk_FlWyaVQyfz9qYlHTJngBJPxF8Jric,12201
+uipath/_services/assets_service.py,sha256=Z46_Nm4X7R0JcwF_Fph-5GwQ_qhQHRKJltCtwo3J8Yo,12090
 uipath/_services/attachments_service.py,sha256=NPQYK7CGjfBaNT_1S5vEAfODmOChTbQZforllFM2ofU,26678
 uipath/_services/buckets_service.py,sha256=FGWhJ3ewMEAahcSPY60wtFB0_qwAfaQAaAjqrC52VDk,44603
 uipath/_services/connections_service.py,sha256=tKJHHOKQYKR6LkgB-V_2d0vFpLEdFeMzwj_xmBVHUDw,18416
@@ -128,12 +128,11 @@ uipath/_services/jobs_service.py,sha256=tTZNsdZKN3uP7bWPQyBCpJeQxTfuOWbKYOR4L-_y
 uipath/_services/llm_gateway_service.py,sha256=vRnx5MSSkxxR0Xw4_km0_aDBrWgkZmyJ1QRBp_anfog,24995
 uipath/_services/processes_service.py,sha256=O_uHgQ1rnwiV5quG0OQqabAnE6Rf6cWrMENYY2jKWt8,8585
 uipath/_services/queues_service.py,sha256=VaG3dWL2QK6AJBOLoW2NQTpkPfZjsqsYPl9-kfXPFzA,13534
-uipath/_utils/__init__.py,sha256=VdcpnENJIa0R6Y26NoxY64-wUVyvb4pKfTh1wXDQeMk,526
+uipath/_utils/__init__.py,sha256=EhATIyHXvey01-2NPfkYVZepe-oEh2e5k7v2eQSGLqc,520
 uipath/_utils/_auth.py,sha256=5R30ALuRrIatf_0Lk-AETJvt6ora7h0R7yeDdliW1Lg,2524
+uipath/_utils/_bindings.py,sha256=KDo1VdtGjZ4lnklwQysFI_sy3_PFNZIHnihtUjDlzNI,3735
 uipath/_utils/_endpoint.py,sha256=yYHwqbQuJIevpaTkdfYJS9CrtlFeEyfb5JQK5osTCog,2489
-uipath/_utils/_infer_bindings.py,sha256=eCxfUjd37fOFZ6vOfKl2BhWVUt7iSSJ-VQ0-nDTBcaA,1836
 uipath/_utils/_logs.py,sha256=QNo2YnUT1ANFHNEzYWv6PzX11438HPjo9MweQYS9UnU,408
-uipath/_utils/_read_overwrites.py,sha256=OQgG9ycPpFnLub5ELQdX9V2Fyh6F9_zDR3xoYagJaMI,5287
 uipath/_utils/_request_override.py,sha256=fIVHzgHVXITUlWcp8osNBwIafM1qm4_ejx0ng5UzfJ4,573
 uipath/_utils/_request_spec.py,sha256=iCtBLqtbWUpFG5g1wtIZBzSupKsfaRLiQFoFc_4B70Q,747
 uipath/_utils/_ssl_context.py,sha256=xSYitos0eJc9cPHzNtHISX9PBvL6D2vas5G_GiBdLp8,1783
@@ -225,8 +224,8 @@ uipath/tracing/_utils.py,sha256=emsQRgYu-P1gj1q7XUPJD94mOa12JvhheRkuZJpLd9Y,1505
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=tnF_FiCx8qI2XaJDQgYkMN_gl9V0VqNR1uX7iawuLp8,8230
 uipath/utils/dynamic_schema.py,sha256=w0u_54MoeIAB-mf3GmwX1A_X8_HDrRy6p998PvX9evY,3839
-uipath-2.1.124.dist-info/METADATA,sha256=n6KKj2X088M0x2A4gwgZKxErG_9FP5kgmAYpMe7UujU,6626
-uipath-2.1.124.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.124.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.124.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.124.dist-info/RECORD,,
+uipath-2.1.125.dist-info/METADATA,sha256=PFJv_XJNWdOSugtGeBceOV_hdA-_yMdyumhnlwb_vTM,6626
+uipath-2.1.125.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.125.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.125.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.125.dist-info/RECORD,,

uipath/_utils/_infer_bindings.py

@@ -1,51 +0,0 @@
-import functools
-import inspect
-from typing import Any, Callable, TypeVar
-
-from ._read_overwrites import read_resource_overwrites
-
-T = TypeVar("T")
-
-
-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)
-
-            if name in all_args or folder_path in all_args:
-                with read_resource_overwrites(
-                    resource_type,
-                    all_args.get(name),  # type: ignore
-                    all_args.get(folder_path, None),
-                ) as (name_overwrite_or_default, folder_path_overwrite_or_default):
-                    if name in sig.parameters:
-                        all_args[name] = name_overwrite_or_default
-                    if folder_path in sig.parameters:
-                        all_args[folder_path] = folder_path_overwrite_or_default
-
-            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

uipath/_utils/_read_overwrites.py

@@ -1,144 +0,0 @@
-import json
-from contextlib import contextmanager
-from pathlib import Path
-from typing import Any, Dict, Generator, Optional, Tuple
-
-
-class OverwritesManager:
-    """Manages overwrites for different resource types and methods.
-
-    This class handles reading and accessing bindings overwrites from a JSON file.
-    The overwrites are stored under the 'resourceOverwrites' key, where each key is a
-    resource key (e.g., 'asset.MyAssetKeyFromBindingsJson') and the value contains
-    'name' and 'folderPath' fields.
-
-    This is a singleton class to ensure only one instance exists throughout the application.
-    """
-
-    _instance = None
-    _overwrites_file_path: Path = Path("__uipath/uipath.json")
-    _runtime_overwrites: Dict[str, Any] = {}
-
-    def __new__(
-        cls, overwrites_file_path: Optional[Path] = None
-    ) -> "OverwritesManager":
-        """Create or return the singleton instance.
-
-        Args:
-            overwrites_file_path: Optional path to the overwrites JSON file.
-                If not provided, defaults to 'uipath.json' in the project root.
-
-        Returns:
-            The singleton instance of OverwritesManager.
-        """
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._overwrites_file_path = (
-                overwrites_file_path or cls._overwrites_file_path
-            )
-            cls._instance._read_overwrites_file()
-        elif (
-            overwrites_file_path
-            and overwrites_file_path != cls._instance._overwrites_file_path
-        ):
-            # If a new file path is provided and it's different from the current one,
-            # update the path and re-read the file
-            cls._instance._overwrites_file_path = overwrites_file_path
-            cls._instance._read_overwrites_file()
-        return cls._instance
-
-    def _read_overwrites_file(self) -> None:
-        """Read the overwrites JSON file and cache the data.
-
-        Raises:
-            FileNotFoundError: If the overwrites file doesn't exist.
-            json.JSONDecodeError: If the file contains invalid JSON.
-        """
-        try:
-            with open(self._overwrites_file_path, "r") as f:
-                data = json.load(f)
-                self._runtime_overwrites = (
-                    data.get("runtime", {})
-                    .get("internalArguments", {})
-                    .get("resourceOverwrites", {})
-                )
-        except FileNotFoundError:
-            self._runtime_overwrites = {}
-
-    def get_overwrite(
-        self, resource_type: str, resource_name: str, folder_path: Optional[str] = None
-    ) -> Optional[Tuple[str, str]]:
-        """Get an overwrite value for a specific resource.
-
-        Args:
-            resource_type: The type of resource (e.g., 'process', 'asset').
-            resource_name: The name of the resource.
-
-        Returns:
-            A tuple of (name, folder_path) if found, None otherwise.
-        """
-        if folder_path:
-            key = f"{resource_type}.{resource_name}.{folder_path}"
-        else:
-            key = f"{resource_type}.{resource_name}"
-
-        if key not in self._runtime_overwrites:
-            return None
-
-        overwrite = self._runtime_overwrites[key]
-        return (
-            overwrite.get("name", resource_name),
-            overwrite.get("folderPath", ""),
-        )
-
-    def get_and_apply_overwrite(
-        self, resource_type: str, resource_name: str, folder_path: Optional[str] = None
-    ) -> Tuple[Any, Any]:
-        """Get and apply overwrites for a resource, falling back to provided values if no overwrites exist.
-
-        Args:
-            resource_type: The type of resource (e.g., 'process', 'asset').
-            resource_name: The name of the resource.
-            folder_path: Optional folder path to use if no overwrite exists.
-
-        Returns:
-            A tuple of (name, folder_path) with overwritten values if available,
-            otherwise the original values.
-        """
-        overwrite = self.get_overwrite(resource_type, resource_name, folder_path)
-        if overwrite:
-            resource_name, folder_path = overwrite
-        return resource_name, folder_path or None
-
-
-@contextmanager
-def read_resource_overwrites(
-    resource_type: str,
-    resource_name: str,
-    folder_path: Optional[str] = None,
-    overwrites_file_path: Optional[Path] = None,
-) -> Generator[Tuple[str, str], None, None]:
-    """Context manager for reading and applying resource overwrites.
-
-    Args:
-        resource_type: The type of resource (e.g., 'process', 'asset').
-        resource_name: The name of the resource.
-        folder_path: Optional folder path to use if no overwrite exists.
-        overwrites_file_path: Optional path to the overwrites JSON file.
-
-    Yields:
-        A tuple of (name, folder_path) with overwritten values if available,
-        otherwise the original values.
-
-    Example:
-        ```python
-        with read_resource_overwrites("asset", "MyAsset") as (name, folder_path):
-            # Use name and folder_path here
-            pass
-        ```
-    """
-    manager = OverwritesManager(overwrites_file_path)
-    try:
-        yield manager.get_and_apply_overwrite(resource_type, resource_name, folder_path)
-    finally:
-        pass