uipath 2.1.14__py3-none-any.whl → 2.1.15__py3-none-any.whl

uipath/_cli/cli_push.py

@@ -1,360 +1,41 @@
 # type: ignore
-"""CLI command for pushing local project files to UiPath StudioWeb solution.
-
-This module provides functionality to push local project files to a UiPath StudioWeb solution.
-It handles:
-- File uploads and updates
-- File deletions for removed local files
-- Optional UV lock file management
-- Project structure pushing
-
-The push process ensures that the remote project structure matches the local files,
-taking into account:
-- Entry point files from uipath.json
-- Project configuration from pyproject.toml
-- Optional UV lock file for dependency management
-"""
-
-import json
+import asyncio
 import os
-from datetime import datetime, timezone
-from typing import Any, Dict, Optional, Set, Tuple
+from typing import Any
 from urllib.parse import urlparse
 
 import click
-import httpx
-import jwt
 from dotenv import load_dotenv
 
-from .._utils._ssl_context import get_httpx_client_kwargs
 from ..telemetry import track
-from ._utils._common import get_env_vars
+from ._push.sw_file_handler import SwFileHandler
 from ._utils._console import ConsoleLogger
 from ._utils._constants import (
-    AGENT_INITIAL_CODE_VERSION,
-    AGENT_STORAGE_VERSION,
-    AGENT_TARGET_RUNTIME,
-    AGENT_VERSION,
+    UIPATH_PROJECT_ID,
 )
 from ._utils._project_files import (
     ensure_config_file,
-    files_to_include,
     get_project_config,
-    read_toml_project,
     validate_config,
 )
-from ._utils._studio_project import ProjectFile, ProjectFolder, ProjectStructure
 from ._utils._uv_helpers import handle_uv_operations
 
 console = ConsoleLogger()
 load_dotenv(override=True)
 
 
-def get_author_from_token_or_toml(directory: str) -> str:
-    """Extract preferred_username from JWT token or fall back to pyproject.toml author.
-
-    Args:
-        directory: Project directory containing pyproject.toml
-
-    Returns:
-        str: Author name from JWT preferred_username or pyproject.toml authors field
-    """
-    # Try to get author from JWT token first
-    token = os.getenv("UIPATH_ACCESS_TOKEN")
-    if token:
-        try:
-            decoded_token = jwt.decode(token, options={"verify_signature": False})
-            preferred_username = decoded_token.get("preferred_username")
-            if preferred_username:
-                return preferred_username
-        except Exception:
-            # If JWT decoding fails, fall back to toml
-            pass
-
-    toml_data = read_toml_project(os.path.join(directory, "pyproject.toml"))
-    return toml_data.get("authors", "").strip()
-
-
 def get_org_scoped_url(base_url: str) -> str:
     parsed = urlparse(base_url)
     org_name, *_ = parsed.path.strip("/").split("/")
 
-    # Construct the new scoped URL (scheme + domain + org_name)
     org_scoped_url = f"{parsed.scheme}://{parsed.netloc}/{org_name}"
     return org_scoped_url
 
 
-def get_project_structure(
-    project_id: str,
-    base_url: str,
-    token: str,
-    client: httpx.Client,
-) -> ProjectStructure:
-    """Retrieve the project's file structure from UiPath Cloud.
-
-    Makes an API call to fetch the complete file structure of a project,
-    including all files and folders. The response is validated against
-    the ProjectStructure model.
-
-    Args:
-        project_id: The ID of the project
-        base_url: The base URL for the API
-        token: Authentication token
-        client: HTTP client to use for requests
-
-    Returns:
-        ProjectStructure: The complete project structure
-
-    Raises:
-        httpx.HTTPError: If the API request fails
-    """
-    url = get_org_scoped_url(base_url)
-    headers = {"Authorization": f"Bearer {token}"}
-    url = f"{url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure"
-
-    response = client.get(url, headers=headers)
-    response.raise_for_status()
-    return ProjectStructure.model_validate(response.json())
-
-
-def collect_all_files(
-    folder: ProjectFolder, files_dict: Dict[str, ProjectFile]
-) -> None:
-    """Recursively collect all files from a folder and its subfolders.
-
-    Traverses the folder structure recursively and adds all files to the
-    provided dictionary, using the file name as the key.
-    """
-    # Add files from current folder
-    for file in folder.files:
-        files_dict[file.name] = file
-
-    # Recursively process subfolders
-    for subfolder in folder.folders:
-        collect_all_files(subfolder, files_dict)
-
-
-def get_folder_by_name(
-    structure: ProjectStructure, folder_name: str
-) -> Optional[ProjectFolder]:
-    """Get a folder from the project structure by name.
-
-    Args:
-        structure: The project structure
-        folder_name: Name of the folder to find
-
-    Returns:
-        Optional[ProjectFolder]: The found folder or None
-    """
-    for folder in structure.folders:
-        if folder.name == folder_name:
-            return folder
-    return None
-
-
-def get_all_remote_files(
-    structure: ProjectStructure, source_code_folder: Optional[ProjectFolder] = None
-) -> Tuple[Dict[str, ProjectFile], Dict[str, ProjectFile]]:
-    """Get all files from the project structure indexed by name.
-
-    Creates two flat dictionaries of files in the project:
-    1. Root level files
-    2. Files in the source_code folder (if exists)
-
-    Args:
-        structure: The project structure
-        source_code_folder: Optional source_code folder to collect files from
-
-    Returns:
-        Tuple[Dict[str, ProjectFile], Dict[str, ProjectFile]]:
-            (root_files, source_code_files)
-    """
-    root_files: Dict[str, ProjectFile] = {}
-    source_code_files: Dict[str, ProjectFile] = {}
-
-    # Add files from root level
-    for file in structure.files:
-        root_files[file.name] = file
-
-    # Add files from source_code folder if it exists
-    if source_code_folder:
-        collect_all_files(source_code_folder, source_code_files)
-
-    return root_files, source_code_files
-
-
-def delete_remote_file(
-    project_id: str, file_id: str, base_url: str, token: str, client: httpx.Client
-) -> None:
-    """Delete a file from the remote project.
-
-    Makes an API call to delete a specific file from the UiPath Cloud project.
-
-    Args:
-        project_id: The ID of the project
-        file_id: The ID of the file to delete
-        base_url: The base URL for the API
-        token: Authentication token
-        client: HTTP client to use for the request
-
-    Raises:
-        httpx.HTTPError: If the API request fails
-    """
-    url = get_org_scoped_url(base_url)
-    headers = {"Authorization": f"Bearer {token}"}
-    url = f"{url}/studio_/backend/api/Project/{project_id}/FileOperations/Delete/{file_id}"
-
-    response = client.delete(url, headers=headers)
-    response.raise_for_status()
-
-
-def update_agent_json(
-    project_id: str,
-    base_url: str,
-    token: str,
-    directory: str,
-    client: httpx.Client,
-    processed_files: Optional[Set[str]] = None,
-    agent_json_file: Optional[ProjectFile] = None,
-) -> None:
-    """Update agent.json file with metadata from uipath.json.
-
-    This function:
-    1. Downloads existing agent.json if it exists
-    2. Updates metadata based on uipath.json content
-    3. Increments code version
-    4. Updates author from JWT or pyproject.toml
-    5. Uploads updated agent.json
-
-    Args:
-        project_id: The ID of the project
-        base_url: The base URL for the API
-        token: Authentication token
-        directory: Project root directory
-        client: HTTP client to use for requests
-        processed_files: Optional set to track processed files
-        agent_json_file: Optional existing agent.json file
-
-    Raises:
-        httpx.HTTPError: If API requests fail
-        FileNotFoundError: If required files are missing
-        json.JSONDecodeError: If JSON parsing fails
-    """
-    url = get_org_scoped_url(base_url)
-    headers = {"Authorization": f"Bearer {token}"}
-
-    # Read uipath.json
-    with open(os.path.join(directory, "uipath.json"), "r") as f:
-        uipath_config = json.load(f)
-
-    try:
-        entrypoints = [
-            {"input": entry_point["input"], "output": entry_point["output"]}
-            for entry_point in uipath_config["entryPoints"]
-        ]
-    except (FileNotFoundError, KeyError) as e:
-        console.error(
-            f"Unable to extract entrypoints from configuration file. Please run 'uipath init' : {str(e)}",
-        )
-
-    author = get_author_from_token_or_toml(directory)
-
-    # Initialize agent.json structure
-    agent_json = {
-        "version": AGENT_VERSION,
-        "metadata": {
-            "storageVersion": AGENT_STORAGE_VERSION,
-            "targetRuntime": AGENT_TARGET_RUNTIME,
-            "isConversational": False,
-            "codeVersion": AGENT_INITIAL_CODE_VERSION,
-            "author": author,
-            "pushDate": datetime.now(timezone.utc).isoformat(),
-        },
-        "entryPoints": entrypoints,
-        "bindings": uipath_config.get("bindings", {"version": "2.0", "resources": []}),
-    }
-
-    base_api_url = f"{url}/studio_/backend/api/Project/{project_id}/FileOperations"
-    if agent_json_file:
-        # Download existing agent.json
-        file_url = f"{base_api_url}/File/{agent_json_file.id}"
-        response = client.get(file_url, headers=headers)
-        response.raise_for_status()
-
-        try:
-            existing_agent = response.json()
-            # Get current version and increment patch version
-            version_parts = existing_agent["metadata"]["codeVersion"].split(".")
-            if len(version_parts) >= 3:
-                version_parts[-1] = str(int(version_parts[-1]) + 1)
-                agent_json["metadata"]["codeVersion"] = ".".join(version_parts)
-            else:
-                # If version format is invalid, start from initial version + 1
-                agent_json["metadata"]["codeVersion"] = (
-                    AGENT_INITIAL_CODE_VERSION[:-1] + "1"
-                )
-        except (json.JSONDecodeError, KeyError, ValueError):
-            console.warning(
-                "Could not parse existing agent.json, using default version"
-            )
-
-    # Upload updated agent.json
-    files_data = {"file": ("agent.json", json.dumps(agent_json), "application/json")}
-
-    # if agent.json already exists update it, otherwise upload it
-    if agent_json_file:
-        url = f"{base_api_url}/File/{agent_json_file.id}"
-        response = client.put(url, files=files_data, headers=headers)
-    else:
-        url = f"{base_api_url}/File"
-        response = client.post(url, files=files_data, headers=headers)
-
-    response.raise_for_status()
-    console.success(f"Updated {click.style('agent.json', fg='cyan')}")
-
-    # Mark agent.json as processed to prevent deletion
-    if processed_files is not None:
-        processed_files.add("agent.json")
-
-
-def create_project_folder(
-    project_id: str,
-    folder_name: str,
-    base_url: str,
-    token: str,
-    client: httpx.Client,
-) -> ProjectFolder:
-    """Create a new folder in the project.
-
-    Args:
-        project_id: The ID of the project
-        folder_name: Name of the folder to create
-        base_url: The base URL for the API
-        token: Authentication token
-        client: HTTP client to use for requests
-
-    Returns:
-        ProjectFolder: The created folder object
-
-    Raises:
-        httpx.HTTPError: If the API request fails
-    """
-    url = get_org_scoped_url(base_url)
-    headers = {"Authorization": f"Bearer {token}"}
-    url = f"{url}/studio_/backend/api/Project/{project_id}/FileOperations/Folder"
-
-    data = {"name": folder_name}
-    response = client.post(url, json=data, headers=headers)
-    response.raise_for_status()
-    return ProjectFolder(name="source_code", id=response.content.decode("utf-8"))
-
-
-def upload_source_files_to_project(
+async def upload_source_files_to_project(
     project_id: str,
     config_data: dict[Any, str],
     directory: str,
-    base_url: str,
-    token: str,
     include_uv_lock: bool = True,
 ) -> None:
     """Upload source files to UiPath project.
@@ -365,130 +46,13 @@ def upload_source_files_to_project(
     - Deletes remote files that no longer exist locally
     - Optionally includes the UV lock file
     """
-    files = [
-        file.file_path.replace("./", "", 1)
-        for file in files_to_include(config_data, directory)
-    ]
-    if include_uv_lock:
-        files.append("uv.lock")
-
-    url = get_org_scoped_url(base_url)
-    headers = {"Authorization": f"Bearer {token}"}
-    base_api_url = f"{url}/studio_/backend/api/Project/{project_id}/FileOperations"
-
-    with httpx.Client(**get_httpx_client_kwargs()) as client:
-        # get existing project structure
-        try:
-            structure = get_project_structure(project_id, base_url, token, client)
-            source_code_folder = get_folder_by_name(structure, "source_code")
-            root_files, source_code_files = get_all_remote_files(
-                structure, source_code_folder
-            )
-        except Exception as e:
-            console.error(f"Failed to get project structure: {str(e)}")
-            raise
+    sw_file_handler = SwFileHandler(
+        project_id=project_id,
+        directory=directory,
+        include_uv_lock=include_uv_lock,
+    )
 
-        # keep track of processed files to identify which ones to delete later
-        processed_root_files: Set[str] = set()
-        processed_source_files: Set[str] = set()
-
-        # Create source_code folder if it doesn't exist
-        if not source_code_folder:
-            try:
-                source_code_folder = create_project_folder(
-                    project_id, "source_code", base_url, token, client
-                )
-                console.success(
-                    f"Created {click.style('source_code', fg='cyan')} folder"
-                )
-                source_code_files = {}  # Initialize empty dict for new folder
-            except httpx.HTTPStatusError as http_err:
-                if http_err.response.status_code == 423:
-                    console.error(
-                        "Resource is locked. Unable to create 'source_code' folder."
-                    )
-                raise
-
-            except Exception as e:
-                console.error(f"Failed to create 'source_code' folder: {str(e)}")
-                raise
-
-        # Update agent.json first at root level
-        try:
-            update_agent_json(
-                project_id,
-                base_url,
-                token,
-                directory,
-                client,
-                processed_root_files,
-                root_files.get("agent.json", None),
-            )
-        except Exception as e:
-            console.error(f"Failed to update agent.json: {str(e)}")
-            raise
-
-        # Continue with rest of files in source_code folder
-        for file_path in files:
-            try:
-                abs_path = os.path.abspath(os.path.join(directory, file_path))
-                if not os.path.exists(abs_path):
-                    console.warning(
-                        f"File not found: {click.style(abs_path, fg='cyan')}"
-                    )
-                    continue
-
-                file_name = os.path.basename(file_path)
-
-                # Skip agent.json as it's already handled
-                if file_name == "agent.json":
-                    continue
-
-                remote_file = source_code_files.get(file_name)
-                processed_source_files.add(file_name)
-
-                with open(abs_path, "rb") as f:
-                    files_data = {"file": (file_name, f, "application/octet-stream")}
-                    form_data = {"parentId": source_code_folder.id}
-
-                    if remote_file:
-                        # File exists in source_code folder, use PUT to update
-                        url = f"{base_api_url}/File/{remote_file.id}"
-                        response = client.put(url, files=files_data, headers=headers)
-                        action = "Updated"
-                    else:
-                        # File doesn't exist, use POST to create in source_code folder
-                        url = f"{base_api_url}/File"
-                        response = client.post(
-                            url, files=files_data, data=form_data, headers=headers
-                        )
-                        action = "Uploaded"
-
-                    response.raise_for_status()
-                    console.success(f"{action} {click.style(file_path, fg='cyan')}")
-
-            except Exception as e:
-                console.error(
-                    f"Failed to upload {click.style(file_path, fg='cyan')}: {str(e)}"
-                )
-                raise
-
-        # Delete files that no longer exist locally
-        if source_code_files:
-            for file_name, remote_file in source_code_files.items():
-                if file_name not in processed_source_files:
-                    try:
-                        delete_remote_file(
-                            project_id, remote_file.id, base_url, token, client
-                        )
-                        console.success(
-                            f"Deleted remote file {click.style(file_name, fg='cyan')}"
-                        )
-                    except Exception as e:
-                        console.error(
-                            f"Failed to delete remote file {click.style(file_name, fg='cyan')}: {str(e)}"
-                        )
-                        raise
+    await sw_file_handler.upload_source_files(config_data)
 
 
 @click.command()
@@ -526,23 +90,21 @@ def push(root: str, nolock: bool) -> None:
     config = get_project_config(root)
     validate_config(config)
 
-    if not os.getenv("UIPATH_PROJECT_ID", False):
+    if not os.getenv(UIPATH_PROJECT_ID, False):
         console.error("UIPATH_PROJECT_ID environment variable not found.")
-    [base_url, token] = get_env_vars()
 
     with console.spinner("Pushing coded UiPath project to Studio Web..."):
         try:
-            # Handle uv operations before packaging, unless nolock is specified
             if not nolock:
                 handle_uv_operations(root)
 
-            upload_source_files_to_project(
-                os.getenv("UIPATH_PROJECT_ID"),
-                config,
-                root,
-                base_url,
-                token,
-                include_uv_lock=not nolock,
+            asyncio.run(
+                upload_source_files_to_project(
+                    os.getenv(UIPATH_PROJECT_ID),
+                    config,
+                    root,
+                    include_uv_lock=not nolock,
+                )
             )
-        except Exception:
-            console.error("Failed to push UiPath project")
+        except Exception as e:
+            console.error(f"Failed to push UiPath project: {e}")

uipath/_services/_base_service.py

@@ -74,6 +74,7 @@ class BaseService:
         url: Union[URL, str],
         *,
         scoped: Literal["org", "tenant"] = "tenant",
+        infer_content_type=False,
         **kwargs: Any,
     ) -> Response:
         self._logger.debug(f"Request: {method} {url}")
@@ -105,6 +106,9 @@ class BaseService:
 
         scoped_url = self._url.scope_url(str(url), scoped)
 
+        if infer_content_type:
+            self._client_async.headers.pop("Content-Type", None)
+
         response = self._client.request(method, scoped_url, **kwargs)
 
         try:
@@ -128,6 +132,7 @@ class BaseService:
         url: Union[URL, str],
         *,
         scoped: Literal["org", "tenant"] = "tenant",
+        infer_content_type=False,
         **kwargs: Any,
     ) -> Response:
         self._logger.debug(f"Request: {method} {url}")
@@ -142,6 +147,9 @@ class BaseService:
 
         scoped_url = self._url.scope_url(str(url), scoped)
 
+        if infer_content_type:
+            self._client_async.headers.pop("Content-Type", None)
+
         response = await self._client_async.request(method, scoped_url, **kwargs)
 
         try:

uipath/_services/api_client.py

@@ -25,6 +25,7 @@ class ApiClient(FolderContext, BaseService):
         method: str,
         url: Union[URL, str],
         scoped: Literal["org", "tenant"] = "tenant",
+        infer_content_type=False,
         **kwargs: Any,
     ) -> Response:
         if kwargs.get("include_folder_headers", False):
@@ -36,13 +37,16 @@ class ApiClient(FolderContext, BaseService):
         if "include_folder_headers" in kwargs:
             del kwargs["include_folder_headers"]
 
-        return super().request(method, url, scoped=scoped, **kwargs)
+        return super().request(
+            method, url, scoped=scoped, infer_content_type=infer_content_type, **kwargs
+        )
 
     async def request_async(
         self,
         method: str,
         url: Union[URL, str],
         scoped: Literal["org", "tenant"] = "tenant",
+        infer_content_type=False,
         **kwargs: Any,
     ) -> Response:
         if kwargs.get("include_folder_headers", False):
@@ -54,4 +58,6 @@ class ApiClient(FolderContext, BaseService):
         if "include_folder_headers" in kwargs:
             del kwargs["include_folder_headers"]
 
-        return await super().request_async(method, url, scoped=scoped, **kwargs)
+        return await super().request_async(
+            method, url, scoped=scoped, infer_content_type=infer_content_type, **kwargs
+        )

uipath/_utils/constants.py

@@ -18,6 +18,7 @@ HEADER_USER_AGENT = "x-uipath-user-agent"
 HEADER_TENANT_ID = "x-uipath-tenantid"
 HEADER_INTERNAL_TENANT_ID = "x-uipath-internal-tenantid"
 HEADER_JOB_KEY = "x-uipath-jobkey"
+HEADER_SW_LOCK_KEY = "x-uipath-sw-lockkey"
 
 # Data sources
 ORCHESTRATOR_STORAGE_BUCKET_DATA_SOURCE = (

uipath/models/exceptions.py

@@ -18,18 +18,18 @@ class IngestionInProgressException(Exception):
 class EnrichedException(Exception):
     def __init__(self, error: HTTPStatusError) -> None:
         # Extract the relevant details from the HTTPStatusError
-        status_code = error.response.status_code if error.response else "Unknown"
-        url = str(error.request.url) if error.request else "Unknown"
-        response_content = (
+        self.status_code = error.response.status_code if error.response else "Unknown"
+        self.url = str(error.request.url) if error.request else "Unknown"
+        self.response_content = (
             error.response.content.decode("utf-8")
             if error.response and error.response.content
             else "No content"
         )
 
         enriched_message = (
-            f"\nRequest URL: {url}"
-            f"\nStatus Code: {status_code}"
-            f"\nResponse Content: {response_content}"
+            f"\nRequest URL: {self.url}"
+            f"\nStatus Code: {self.status_code}"
+            f"\nResponse Content: {self.response_content}"
         )
 
         # Initialize the parent Exception class with the formatted message

{uipath-2.1.14.dist-info → uipath-2.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.14
+Version: 2.1.15
 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