uipath 2.0.53__tar.gz → 2.0.54__tar.gz

{uipath-2.0.53 → uipath-2.0.54}/.github/workflows/test.yml

@@ -24,11 +24,19 @@ jobs:
 
       - name: Run tests
         run: |
-          uv run pytest
+          uv run pytest --cov-report xml:./coverage/coverage.xml
         env:
           UIPATH_URL: ${{ secrets.UIPATH_URL }}
+          UIPATH_BASE_URL: ${{ secrets.UIPATH_BASE_URL }}
           UIPATH_CLIENT_ID: ${{ secrets.UIPATH_CLIENT_ID }}
           UIPATH_CLIENT_SECRET: ${{ secrets.UIPATH_CLIENT_SECRET }}
           UIPATH_ORGANIZATION_ID: ${{ vars.UIPATH_ORGANIZATION_ID }}
           UIPATH_TENANT_ID: ${{ vars.UIPATH_TENANT_ID }}
 
+      - name: Get Cover
+        uses: orgoro/coverage@v3.2
+        with:
+          coverageFile: ./coverage/coverage.xml
+          token: ${{ secrets.GITHUB_TOKEN }}
+        if: ${{ github.event_name == 'pull_request_target' }}
+

{uipath-2.0.53 → uipath-2.0.54}/.gitignore

@@ -6,6 +6,10 @@ dist/
 wheels/
 *.egg-info
 
+.coverage
+.coverage/
+.coverage/*
+
 # Virtual environments
 .venv
 **/.env

{uipath-2.0.53 → uipath-2.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.53
+Version: 2.0.54
 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.0.54/docs/FAQ.md

@@ -0,0 +1,77 @@
+# Frequently Asked Questions (FAQ)
+
+### Q: Why am I getting a "Failed to prepare environment" error when deploying my python agent to UiPath Cloud Platform?
+
+#### Error Message
+
+```json
+{
+    "Code": "Serverless.PythonCodedAgent.PrepareEnvironmentError",
+    "Title": "Failed to prepare environment",
+    "Detail": "An error occurred while installing the package dependencies. Please try again. If the error persists, please contact support.",
+    "Category": "System",
+    "Status": null
+}
+```
+
+#### Visual Example
+
+<picture data-light="../assets/env-preparation-failed-light.png" data-dark="../assets/env-preparation-failed-dark.png">
+  <source
+    media="(prefers-color-scheme: dark)"
+    srcset="../assets/env-preparation-failed-dark.png"
+  />
+  <img
+    src="../assets/env-preparation-failed-light.png"
+  />
+</picture>
+
+*Example of the error as it appears in UiPath Cloud Platform*
+
+#### Description
+
+This error might occur when deploying coded-agents to UiPath Cloud Platform, even though the same project might work correctly in your local environment. The issue is often related to how Python packages are discovered and distributed during the cloud deployment process.
+
+#### Common Causes
+
+1. Multiple top-level packages or modules in your project structure
+2. Improper configuration or formatting in the pyproject.toml or requirements.txt files
+
+#### Solution
+
+##### 1. Check Your Project Structure
+
+- Ensure your Python files are organized under a non top-level directory (e.g., using the `src` layout)
+- Follow the recommended project structure:
+
+  ```plaintext
+  project_root/
+  ├── src/
+  │   └── your_package/
+  │       ├── __init__.py
+  │       └── your_modules.py
+  ├── pyproject.toml
+  └── setup.cfg/setup.py
+  ```
+
+##### 2. Configure Package Discovery
+
+If you need to maintain your current project structure, you can configure custom package discovery in your `pyproject.toml`:
+
+```toml
+[tool.setuptools]
+py-modules = []
+packages = ["your_package"]
+```
+
+##### 3. Verify Dependencies
+
+- Ensure all required dependencies are properly listed in your `requirements.txt` or `pyproject.toml`
+
+#### Reference
+
+For more detailed information about package discovery and configuration, refer to the [official setuptools documentation](https://setuptools.pypa.io/en/latest/userguide/package_discovery.html).
+
+---
+
+*Note: This FAQ will be updated as new information becomes available. If you continue experiencing issues after following these solutions, please contact UiPath support.*

uipath-2.0.54/docs/core/environment_variables.md

@@ -0,0 +1,115 @@
+# Environment Variables
+
+Environment variables are configuration values stored at the operating system level that can be accessed by applications and scripts. They provide a flexible way to configure application behavior without hardcoding values in your source code.
+
+Environment variables are loaded in the following order (highest to lowest priority):
+
+1. `.env` file in the current directory
+2. System environment variables
+3. Default values in code
+
+Example:
+```bash
+# .env file
+UIPATH_FOLDER_PATH=/default/path
+
+# System environment
+export UIPATH_FOLDER_PATH=/system/path
+```
+/// warning
+When deploying your agent to production, ensure that all required environment variables (such as API keys and custom configurations) are properly configured in your process settings. This step is crucial for the successful operation of your published package.
+///
+
+## Design
+
+Create a `.env` file in your project's root directory to manage environment variables locally. When using the `uipath auth` or `uipath new my-agent` commands, this file is automatically created.
+
+The `uipath auth` command automatically populates this file with essential variables:
+
+- `UIPATH_URL`: Your UiPath Orchestrator instance URL
+- `UIPATH_ACCESS_TOKEN`: Authentication token for API access
+
+### Folder Configuration
+Most UiPath services operate within a specific folder context. Configure your folder context using either:
+
+- `UIPATH_FOLDER_PATH`: The full path to your target folder
+- `UIPATH_FOLDER_KEY`: The unique identifier for your target folder
+
+To obtain the folder path, right-click on the folder in UiPath Orchestrator and select "Copy folder path" from the context menu.
+
+<picture data-light="../assets/copy_path_light.png" data-dark="../assets/copy_path_dark.png">
+  <source
+    media="(prefers-color-scheme: dark)"
+    srcset="
+      ../assets/copy_path_dark.png
+    "
+  />
+  <img
+    src="../assets/copy_path_light.png"
+  />
+</picture>
+
+### Telemetry
+To help us improve the developer experience, the CLI collects basic usage data about command invocations. For more details about UiPath's privacy practices, please review the [privacy statement](https://www.uipath.com/legal/privacy-policy).
+
+Telemetry is enabled by default. You can opt out by setting the `UIPATH_TELEMETRY_ENABLED` environment variable to `false` in your `.env` file:
+
+```bash
+UIPATH_TELEMETRY_ENABLED=false
+```
+
+## Runtime
+
+When executing processes or starting jobs, you can configure environment variables through the UiPath Orchestrator interface. For sensitive information like API keys and secrets, we strongly recommend using secret assets instead of environment variables. Secret assets provide enhanced security and better management capabilities.
+
+### Secret Assets
+To use a secret asset in your environment variables, reference it using the following format:
+
+```bash
+NAME=%ASSETS/your-secret-asset-name%
+```
+
+<picture data-light="../assets/cloud_env_var_light.gif" data-dark="../assets/cloud_env_var_dark.gif">
+  <source
+    media="(prefers-color-scheme: dark)"
+    srcset="
+      ../assets/cloud_env_var_dark.gif
+    "
+  />
+  <img
+    src="../assets/cloud_env_var_light.gif"
+  />
+</picture>
+
+### Sensitive Variables
+If you must use environment variables for sensitive information (not recommended), variables containing `API_KEY` or `SECRET` in their names will have their values masked as `****` in the interface for security purposes.
+
+<picture data-light="../assets/cloud_env_var_secret_light.png" data-dark="../assets/cloud_env_var_secret_dark.png">
+  <source
+    media="(prefers-color-scheme: dark)"
+    srcset="
+      ../assets/cloud_env_var_secret_dark.png
+    "
+  />
+  <img
+    src="../assets/cloud_env_var_secret_light.png"
+  />
+</picture>
+
+### Log Level
+The `LOG_LEVEL` environment variable controls the verbosity of logging in the Orchestrator UI's Log tab during runtime execution. This setting determines which log messages are displayed in the interface.
+
+| Level | Description |
+|-------|-------------|
+| TRACE | Most detailed logging level, shows all possible information |
+| DEBUG | Detailed information for debugging purposes |
+| INFORMATION | General operational information |
+| WARNING | Warning messages for potentially harmful situations |
+| ERROR | Error events that might still allow the application to continue |
+| CRITICAL | Critical events that may lead to application failure |
+| NONE | No logging |
+
+The default value is `INFORMATION`
+
+### Builtin Variables
+The runtime environment automatically includes certain variables (such as `UIPATH_FOLDER_KEY`, `UIPATH_ROBOT_KEY`), eliminating the need for manual configuration.

{uipath-2.0.53 → uipath-2.0.54}/mkdocs.yml

@@ -59,6 +59,7 @@ nav:
       - Sample Agents: https://github.com/UiPath/uipath-langchain-python/tree/main/samples
   - UiPath SDK:
       - Getting Started: core/getting_started.md
+      - Environment Variables: core/environment_variables.md
       - CLI Reference: cli/index.md
       - Services:
         - Actions: core/actions.md
@@ -70,6 +71,7 @@ nav:
         - Queues: core/queues.md
         - Processes: core/processes.md
   - How To Contribute: CONTRIBUTING.md
+  - FAQ: FAQ.md
   - Release Policy: release_policy.md
 
 plugins:
@@ -134,4 +136,4 @@ markdown_extensions:
       alternate_style: true
   - toc:
       title: On this page
-      permalink: true
+      permalink: true

{uipath-2.0.53 → uipath-2.0.54}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.53"
+version = "2.0.54"
 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"
@@ -59,6 +59,11 @@ dev = [
   "mkdocs-click>=0.9.0",
   "pytest-asyncio>=0.26.0",
   "mkdocs-open-in-new-tab>=1.0.8",
+  "toml>=0.10.2",
+  "inflection>=0.5.1",
+  "pytest-httpx>=0.35.0",
+  "pytest-trio>=0.8.0",
+  "types-toml>=0.10.8",
 ]
 
 [project.optional-dependencies]
@@ -115,5 +120,11 @@ warn_required_dynamic_aliases = true
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = "test_*.py"
-addopts = "-ra -q"
+addopts = "-ra -q --cov"
+asyncio_default_fixture_loop_scope = "function"
 
+[tool.coverage.report]
+show_missing = true
+
+[tool.coverage.run]
+source = ["src"]

uipath-2.0.54/src/uipath/_services/_base_service.py

@@ -0,0 +1,183 @@
+import inspect
+from logging import getLogger
+from typing import Any, Literal, Union
+
+from httpx import (
+    URL,
+    AsyncClient,
+    Client,
+    ConnectTimeout,
+    Headers,
+    Response,
+    TimeoutException,
+)
+from tenacity import (
+    retry,
+    retry_if_exception,
+    retry_if_result,
+    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
+from .._utils.constants import HEADER_USER_AGENT
+
+
+def is_retryable_exception(exception: BaseException) -> bool:
+    return isinstance(exception, (ConnectTimeout, TimeoutException))
+
+
+def is_retryable_status_code(response: Response) -> bool:
+    return response.status_code >= 500 and response.status_code < 600
+
+
+class BaseService:
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        self._logger = getLogger("uipath")
+        self._config = config
+        self._execution_context = execution_context
+
+        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._client_async = AsyncClient(
+            base_url=self._url.base_url,
+            headers=Headers(self.default_headers),
+            timeout=30.0,
+        )
+
+        self._overwrites_manager = OverwritesManager()
+        self._logger.debug(f"HEADERS: {self.default_headers}")
+
+        super().__init__()
+
+    @retry(
+        retry=(
+            retry_if_exception(is_retryable_exception)
+            | retry_if_result(is_retryable_status_code)
+        ),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+    )
+    def request(
+        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._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 ""
+        )
+
+        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
+
+    @retry(
+        retry=(
+            retry_if_exception(is_retryable_exception)
+            | retry_if_result(is_retryable_status_code)
+        ),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+    )
+    async def request_async(
+        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._client_async.headers)}"
+        )
+
+        kwargs.setdefault("headers", {})
+        kwargs["headers"][HEADER_USER_AGENT] = user_agent_value(
+            self._specific_component
+        )
+
+        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
+
+    @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 {}
+
+    @property
+    def _specific_component(self) -> str:
+        try:
+            stack = inspect.stack()
+
+            caller_frame = stack[4].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 ""
+        )
+
+        return specific_component

{uipath-2.0.53 → uipath-2.0.54}/src/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-2.0.53 → uipath-2.0.54}/src/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)