uipath 2.0.53__py3-none-any.whl → 2.0.55__py3-none-any.whl

uipath/_cli/_auth/_auth_server.py

@@ -2,7 +2,6 @@ import http.server
 import json
 import os
 import socketserver
-import ssl
 import time
 
 import click
@@ -109,19 +108,15 @@ def make_request_handler_class(state, code_verifier, token_callback, domain):
     return SimpleHTTPSRequestHandler
 
 
-class HTTPSServer:
-    def __init__(self, port=6234, cert_file="localhost.crt", key_file="localhost.key"):
-        """Initialize HTTPS server with configurable parameters.
+class HTTPServer:
+    def __init__(self, port=6234):
+        """Initialize HTTP server with configurable parameters.
 
         Args:
             port (int, optional): Port number to run the server on. Defaults to 6234.
-            cert_file (str, optional): SSL certificate file. Defaults to "localhost.crt".
-            key_file (str, optional): SSL key file. Defaults to "localhost.key".
         """
         self.current_path = os.path.dirname(os.path.abspath(__file__))
         self.port = port
-        self.cert_file = os.path.join(self.current_path, "localhost.crt")
-        self.key_file = os.path.join(self.current_path, "localhost.key")
         self.httpd = None
         self.token_data = None
         self.should_shutdown = False
@@ -136,7 +131,7 @@ class HTTPSServer:
         self.should_shutdown = True
 
     def create_server(self, state, code_verifier, domain):
-        """Create and configure the HTTPS server.
+        """Create and configure the HTTP server.
 
         Args:
             state (str): The OAuth state parameter.
@@ -144,20 +139,14 @@ class HTTPSServer:
             domain (str): The domain for authentication.
 
         Returns:
-            socketserver.TCPServer: The configured HTTPS server.
+            socketserver.TCPServer: The configured HTTP server.
         """
-        # Create SSL context
-        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-        context.load_cert_chain(self.cert_file, self.key_file)
-
         # Create server with address reuse
         socketserver.TCPServer.allow_reuse_address = True
         handler = make_request_handler_class(
             state, code_verifier, self.token_received_callback, domain
         )
         self.httpd = socketserver.TCPServer(("", self.port), handler)
-        self.httpd.socket = context.wrap_socket(self.httpd.socket, server_side=True)
-
         return self.httpd
 
     def start(self, state, code_verifier, domain):

uipath/_cli/_auth/auth_config.json

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

uipath/_cli/cli_auth.py

@@ -8,7 +8,7 @@ import click
 from dotenv import load_dotenv
 
 from ..telemetry import track
-from ._auth._auth_server import HTTPSServer
+from ._auth._auth_server import HTTPServer
 from ._auth._oidc_utils import get_auth_config, get_auth_url
 from ._auth._portal_service import PortalService, select_tenant
 from ._auth._utils import update_auth_file, update_env_file
@@ -97,7 +97,7 @@ def auth(domain, force: None | bool = False):
             auth_url,
         )
 
-        server = HTTPSServer(port=auth_config["port"])
+        server = HTTPServer(port=auth_config["port"])
         token_data = server.start(state, code_verifier, domain)
 
         if token_data:

uipath/_cli/cli_run.py

@@ -42,14 +42,14 @@ def python_run_middleware(
     if not entrypoint:
         return MiddlewareResult(
             should_continue=False,
-            info_message="""Error: No entrypoint specified. Please provide a path to a Python script.
+            error_message="""No entrypoint specified. Please provide a path to a Python script.
 Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
         )
 
     if not os.path.exists(entrypoint):
         return MiddlewareResult(
             should_continue=False,
-            error_message=f"""Error: Script not found at path {entrypoint}.
+            error_message=f"""Script not found at path {entrypoint}.
 Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
         )
 

uipath/_services/__init__.py

@@ -1,6 +1,7 @@
 from .actions_service import ActionsService
 from .api_client import ApiClient
 from .assets_service import AssetsService
+from .attachments_service import AttachmentsService
 from .buckets_service import BucketsService
 from .connections_service import ConnectionsService
 from .context_grounding_service import ContextGroundingService
@@ -13,6 +14,7 @@ from .queues_service import QueuesService
 __all__ = [
     "ActionsService",
     "AssetsService",
+    "AttachmentsService",
     "BucketsService",
     "ConnectionsService",
     "ContextGroundingService",

uipath/_services/_base_service.py

@@ -1,6 +1,6 @@
 import inspect
 from logging import getLogger
-from typing import Any, Union
+from typing import Any, Literal, Union
 
 from httpx import (
     URL,
@@ -22,7 +22,7 @@ from uipath._utils._read_overwrites import OverwritesManager
 
 from .._config import Config
 from .._execution_context import ExecutionContext
-from .._utils import user_agent_value
+from .._utils import UiPathUrl, user_agent_value
 from .._utils.constants import HEADER_USER_AGENT
 
 
@@ -39,24 +39,17 @@ class BaseService:
         self._logger = getLogger("uipath")
         self._config = config
         self._execution_context = execution_context
-        self._tenant_scope_client = Client(
-            base_url=self._config.base_url,
-            headers=Headers(self.default_headers),
-            timeout=30.0,
-        )
-        self._tenant_scope_client_async = AsyncClient(
-            base_url=self._config.base_url,
-            headers=Headers(self.default_headers),
-            timeout=30.0,
-        )
-        org_scope_base_url = self.__get_org_scope_base_url()
-        self._org_scope_client = Client(
-            base_url=org_scope_base_url,
+
+        self._url = UiPathUrl(self._config.base_url)
+
+        self._client = Client(
+            base_url=self._url.base_url,
             headers=Headers(self.default_headers),
             timeout=30.0,
         )
-        self._org_scope_client_async = AsyncClient(
-            base_url=org_scope_base_url,
+
+        self._client_async = AsyncClient(
+            base_url=self._url.base_url,
             headers=Headers(self.default_headers),
             timeout=30.0,
         )
@@ -77,12 +70,12 @@ class BaseService:
         self,
         method: str,
         url: Union[URL, str],
+        *,
+        scoped: Literal["org", "tenant"] = "tenant",
         **kwargs: Any,
     ) -> Response:
         self._logger.debug(f"Request: {method} {url}")
-        self._logger.debug(
-            f"HEADERS: {kwargs.get('headers', self._tenant_scope_client.headers)}"
-        )
+        self._logger.debug(f"HEADERS: {kwargs.get('headers', self._client.headers)}")
 
         try:
             stack = inspect.stack()
@@ -104,10 +97,13 @@ class BaseService:
         specific_component = (
             f"{module_name}.{function_name}" if module_name and function_name else ""
         )
-        headers = kwargs.get("headers", {})
-        headers[HEADER_USER_AGENT] = user_agent_value(specific_component)
 
-        response = self._tenant_scope_client.request(method, url, **kwargs)
+        kwargs.setdefault("headers", {})
+        kwargs["headers"][HEADER_USER_AGENT] = user_agent_value(specific_component)
+
+        scoped_url = self._url.scope_url(str(url), scoped)
+
+        response = self._client.request(method, scoped_url, **kwargs)
         response.raise_for_status()
 
         return response
@@ -123,96 +119,51 @@ class BaseService:
         self,
         method: str,
         url: Union[URL, str],
+        *,
+        scoped: Literal["org", "tenant"] = "tenant",
         **kwargs: Any,
     ) -> Response:
         self._logger.debug(f"Request: {method} {url}")
         self._logger.debug(
-            f"HEADERS: {kwargs.get('headers', self._tenant_scope_client.headers)}"
+            f"HEADERS: {kwargs.get('headers', self._client_async.headers)}"
         )
 
-        try:
-            stack = inspect.stack()
-
-            # use the third frame because of the retry decorator
-            caller_frame = stack[3].frame
-            function_name = caller_frame.f_code.co_name
-
-            if "self" in caller_frame.f_locals:
-                module_name = type(caller_frame.f_locals["self"]).__name__
-            elif "cls" in caller_frame.f_locals:
-                module_name = caller_frame.f_locals["cls"].__name__
-            else:
-                module_name = ""
-        except Exception:
-            function_name = ""
-            module_name = ""
-
-        specific_component = (
-            f"{module_name}.{function_name}" if module_name and function_name else ""
+        kwargs.setdefault("headers", {})
+        kwargs["headers"][HEADER_USER_AGENT] = user_agent_value(
+            self._specific_component
         )
-        headers = kwargs.get("headers", {})
-        headers[HEADER_USER_AGENT] = user_agent_value(specific_component)
 
-        response = await self._tenant_scope_client_async.request(method, url, **kwargs)
+        scoped_url = self._url.scope_url(str(url), scoped)
+
+        response = await self._client_async.request(method, scoped_url, **kwargs)
         response.raise_for_status()
 
         return response
 
-    def request_org_scope(
-        self,
-        method: str,
-        url: Union[URL, str],
-        **kwargs: Any,
-    ) -> Response:
-        self._logger.debug(f"Request: {method} {url}")
-        self._logger.debug(
-            f"HEADERS: {kwargs.get('headers', self._tenant_scope_client.headers)}"
-        )
-
-        try:
-            stack = inspect.stack()
-
-            # use the third frame because of the retry decorator
-            caller_frame = stack[3].frame
-            function_name = caller_frame.f_code.co_name
-
-            if "self" in caller_frame.f_locals:
-                module_name = type(caller_frame.f_locals["self"]).__name__
-            elif "cls" in caller_frame.f_locals:
-                module_name = caller_frame.f_locals["cls"].__name__
-            else:
-                module_name = ""
-        except Exception:
-            function_name = ""
-            module_name = ""
-
-        specific_component = (
-            f"{module_name}.{function_name}" if module_name and function_name else ""
-        )
-        headers = kwargs.get("headers", {})
-        headers[HEADER_USER_AGENT] = user_agent_value(specific_component)
-
-        response = self._org_scope_client.request(method, url, **kwargs)
-        response.raise_for_status()
+    @property
+    def default_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            **self.auth_headers,
+            **self.custom_headers,
+        }
 
-        return response
+    @property
+    def auth_headers(self) -> dict[str, str]:
+        header = f"Bearer {self._config.secret}"
+        return {"Authorization": header}
 
-    async def request_org_scope_async(
-        self,
-        method: str,
-        url: Union[URL, str],
-        **kwargs: Any,
-    ) -> Response:
-        self._logger.debug(f"Request: {method} {url}")
-        self._logger.debug(
-            f"HEADERS: {kwargs.get('headers', self._tenant_scope_client.headers)}"
-        )
+    @property
+    def custom_headers(self) -> dict[str, str]:
+        return {}
 
+    @property
+    def _specific_component(self) -> str:
         try:
             stack = inspect.stack()
 
-            # use the third frame because of the retry decorator
-            caller_frame = stack[3].frame
+            caller_frame = stack[4].frame
             function_name = caller_frame.f_code.co_name
 
             if "self" in caller_frame.f_locals:
@@ -228,34 +179,5 @@ class BaseService:
         specific_component = (
             f"{module_name}.{function_name}" if module_name and function_name else ""
         )
-        headers = kwargs.get("headers", {})
-        headers[HEADER_USER_AGENT] = user_agent_value(specific_component)
-
-        response = await self._org_scope_client_async.request(method, url, **kwargs)
-        response.raise_for_status()
-
-        return response
-
-    @property
-    def default_headers(self) -> dict[str, str]:
-        return {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-            **self.auth_headers,
-            **self.custom_headers,
-        }
-
-    @property
-    def auth_headers(self) -> dict[str, str]:
-        header = f"Bearer {self._config.secret}"
-        return {"Authorization": header}
-
-    @property
-    def custom_headers(self) -> dict[str, str]:
-        return {}
 
-    def __get_org_scope_base_url(self) -> str:
-        base_url = str(self._config.base_url)
-        if base_url.endswith("/"):
-            base_url = base_url[:-1]
-        return base_url.rsplit("/", 1)[0] + "/"
+        return specific_component

uipath/_services/actions_service.py

@@ -349,8 +349,12 @@ class ActionsService(FolderContext, BaseService):
             raise Exception("appName or appKey is required")
         spec = _retrieve_app_key_spec(app_name=app_name)
 
-        response = await self.request_org_scope_async(
-            spec.method, spec.endpoint, params=spec.params, headers=spec.headers
+        response = await self.request_async(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+            scoped="org",
         )
         try:
             deployed_app = self._extract_deployed_app(
@@ -382,8 +386,12 @@ class ActionsService(FolderContext, BaseService):
 
         spec = _retrieve_app_key_spec(app_name=app_name)
 
-        response = self.request_org_scope(
-            spec.method, spec.endpoint, params=spec.params, headers=spec.headers
+        response = self.request(
+            spec.method,
+            spec.endpoint,
+            params=spec.params,
+            headers=spec.headers,
+            scoped="org",
         )
 
         try:

uipath/_services/api_client.py

@@ -28,7 +28,7 @@ class ApiClient(FolderContext, BaseService):
     ) -> Response:
         if kwargs.get("include_folder_headers", False):
             kwargs["headers"] = {
-                **kwargs.get("headers", self._tenant_scope_client.headers),
+                **kwargs.get("headers", self._client.headers),
                 **self.folder_headers,
             }
 
@@ -45,7 +45,7 @@ class ApiClient(FolderContext, BaseService):
     ) -> Response:
         if kwargs.get("include_folder_headers", False):
             kwargs["headers"] = {
-                **kwargs.get("headers", self._tenant_scope_client_async.headers),
+                **kwargs.get("headers", self._client_async.headers),
                 **self.folder_headers,
             }
 
@@ -53,37 +53,3 @@ class ApiClient(FolderContext, BaseService):
             del kwargs["include_folder_headers"]
 
         return await super().request_async(method, url, **kwargs)
-
-    def request_org_scope(
-        self,
-        method: str,
-        url: Union[URL, str],
-        **kwargs: Any,
-    ) -> Response:
-        if kwargs.get("include_folder_headers", False):
-            kwargs["headers"] = {
-                **kwargs.get("headers", self._org_scope_client.headers),
-                **self.folder_headers,
-            }
-
-        if "include_folder_headers" in kwargs:
-            del kwargs["include_folder_headers"]
-
-        return super().request_org_scope(method, url, **kwargs)
-
-    async def request_org_scope_async(
-        self,
-        method: str,
-        url: Union[URL, str],
-        **kwargs: Any,
-    ) -> Response:
-        if kwargs.get("include_folder_headers", False):
-            kwargs["headers"] = {
-                **kwargs.get("headers", self._org_scope_client_async.headers),
-                **self.folder_headers,
-            }
-
-        if "include_folder_headers" in kwargs:
-            del kwargs["include_folder_headers"]
-
-        return await super().request_org_scope_async(method, url, **kwargs)

uipath/_services/assets_service.py

@@ -7,7 +7,7 @@ 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, read_resource_overwrites
-from ..models import UserAsset
+from ..models import Asset, UserAsset
 from ..tracing._traced import traced
 from ._base_service import BaseService
 
@@ -34,7 +34,7 @@ class AssetsService(FolderContext, BaseService):
         *,
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
-    ) -> UserAsset:
+    ) -> UserAsset | Asset:
         """Retrieve an asset by its name.
 
         Related Activity: [Get Asset](https://docs.uipath.com/activities/other/latest/workflow/get-robot-asset)
@@ -56,6 +56,11 @@ class AssetsService(FolderContext, BaseService):
             client.assets.retrieve(name="MyAsset")
             ```
         """
+        try:
+            is_user = self._execution_context.robot_key is not None
+        except ValueError:
+            is_user = False
+
         with read_resource_overwrites("asset", name, folder_path) as (
             overwritten_name,
             overwritten_folder_path,
@@ -68,11 +73,15 @@ class AssetsService(FolderContext, BaseService):
             response = self.request(
                 spec.method,
                 url=spec.endpoint,
+                params=spec.params,
                 content=spec.content,
                 headers=spec.headers,
             )
 
-            return UserAsset.model_validate(response.json())
+            if is_user:
+                return UserAsset.model_validate(response.json())
+            else:
+                return Asset.model_validate(response.json()["value"][0])
 
     @traced(
         name="assets_retrieve", run_type="uipath", hide_input=True, hide_output=True
@@ -83,7 +92,7 @@ class AssetsService(FolderContext, BaseService):
         *,
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
-    ) -> UserAsset:
+    ) -> UserAsset | Asset:
         """Asynchronously retrieve an asset by its name.
 
         Related Activity: [Get Asset](https://docs.uipath.com/activities/other/latest/workflow/get-robot-asset)
@@ -96,6 +105,11 @@ class AssetsService(FolderContext, BaseService):
         Returns:
             UserAsset: The asset data.
         """
+        try:
+            is_user = self._execution_context.robot_key is not None
+        except ValueError:
+            is_user = False
+
         with read_resource_overwrites("asset", name, folder_path) as (
             overwritten_name,
             overwritten_folder_path,
@@ -108,11 +122,15 @@ class AssetsService(FolderContext, BaseService):
             response = await self.request_async(
                 spec.method,
                 url=spec.endpoint,
+                params=spec.params,
                 content=spec.content,
                 headers=spec.headers,
             )
 
-            return UserAsset.model_validate(response.json())
+            if is_user:
+                return UserAsset.model_validate(response.json())
+            else:
+                return Asset.model_validate(response.json()["value"][0])
 
     @infer_bindings()
     @traced(
@@ -138,7 +156,18 @@ class AssetsService(FolderContext, BaseService):
 
         Returns:
             Optional[str]: The decrypted credential password.
+
+        Raises:
+            ValueError: If the method is called for a user asset.
         """
+        try:
+            is_user = self._execution_context.robot_key is not None
+        except ValueError:
+            is_user = False
+
+        if not is_user:
+            raise ValueError("This method can only be used for robot assets.")
+
         with read_resource_overwrites("asset", name, folder_path) as (
             overwritten_name,
             overwritten_folder_path,
@@ -185,7 +214,17 @@ class AssetsService(FolderContext, BaseService):
         Returns:
             Optional[str]: The decrypted credential password.
 
+        Raises:
+            ValueError: If the method is called for a user asset.
         """
+        try:
+            is_user = self._execution_context.robot_key is not None
+        except ValueError:
+            is_user = False
+
+        if not is_user:
+            raise ValueError("This method can only be used for robot assets.")
+
         with read_resource_overwrites("asset", name, folder_path) as (
             overwritten_name,
             overwritten_folder_path,
@@ -224,7 +263,18 @@ class AssetsService(FolderContext, BaseService):
 
         Returns:
             Response: The HTTP response confirming the update.
+
+        Raises:
+            ValueError: If the method is called for a user asset.
         """
+        try:
+            is_user = self._execution_context.robot_key is not None
+        except ValueError:
+            is_user = False
+
+        if not is_user:
+            raise ValueError("This method can only be used for robot assets.")
+
         with read_resource_overwrites("asset", robot_asset.name or "", folder_path) as (
             overwritten_name,
             overwritten_folder_path,
@@ -288,14 +338,29 @@ class AssetsService(FolderContext, BaseService):
         folder_key: Optional[str] = None,
         folder_path: Optional[str] = None,
     ) -> RequestSpec:
+        try:
+            robot_key = self._execution_context.robot_key
+        except ValueError:
+            robot_key = None
+
+        if robot_key is None:
+            return RequestSpec(
+                method="GET",
+                endpoint=Endpoint(
+                    "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetFiltered",
+                ),
+                params={"$filter": f"Name eq '{name}'", "$top": 1},
+                headers={
+                    **header_folder(folder_key, folder_path),
+                },
+            )
+
         return RequestSpec(
             method="POST",
             endpoint=Endpoint(
                 "/orchestrator_/odata/Assets/UiPath.Server.Configuration.OData.GetRobotAssetByNameForRobotKey"
             ),
-            content=str(
-                {"assetName": name, "robotKey": self._execution_context.robot_key}
-            ),
+            content=str({"assetName": name, "robotKey": robot_key}),
             headers={
                 **header_folder(folder_key, folder_path),
             },