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

uipath/_cli/_utils/_studio_project.py

@@ -1,8 +1,13 @@
-from typing import Any, List, Optional, Union
+import json
+import os
+from functools import wraps
+from typing import Any, Callable, List, Optional, Union
 
-import httpx
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
+from uipath._utils.constants import HEADER_SW_LOCK_KEY
+from uipath.models.exceptions import EnrichedException
+
 
 class ProjectFile(BaseModel):
     """Model representing a file in a UiPath project.
@@ -139,45 +144,16 @@ class ProjectStructure(BaseModel):
         return v
 
 
-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
-    """
-    headers = {"Authorization": f"Bearer {token}"}
-    url = (
-        f"{base_url}/studio_/backend/api/Project/{project_id}/FileOperations/Structure"
+class LockInfo(BaseModel):
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        extra="allow",
     )
-
-    response = client.get(url, headers=headers)
-    response.raise_for_status()
-    return ProjectStructure.model_validate(response.json())
-
-
-def download_file(base_url: str, file_id: str, client: httpx.Client, token: str) -> Any:
-    file_url = f"{base_url}/File/{file_id}"
-    response = client.get(file_url, headers={"Authorization": f"Bearer {token}"})
-    response.raise_for_status()
-    return response
+    project_lock_key: str = Field(alias="projectLockKey")
+    solution_lock_key: str = Field(alias="solutionLockKey")
 
 
 def get_folder_by_name(
@@ -196,3 +172,248 @@ def get_folder_by_name(
         if folder.name == folder_name:
             return folder
     return None
+
+
+class AddedResource(BaseModel):
+    content_file_path: str
+    parent_path: Optional[str] = None
+
+
+class ModifiedResource(BaseModel):
+    id: str
+    content_file_path: str
+
+
+class StructuralMigration(BaseModel):
+    deleted_resources: List[str]
+    added_resources: List[AddedResource]
+    modified_resources: List[ModifiedResource]
+
+
+def with_lock_retry(func: Callable[..., Any]) -> Callable[..., Any]:
+    @wraps(func)
+    async def wrapper(self, *args, **kwargs):
+        try:
+            lock_info = await self._retrieve_lock()
+
+            headers = kwargs.get("headers", {}) or {}
+            headers[HEADER_SW_LOCK_KEY] = lock_info.project_lock_key
+            kwargs["headers"] = headers
+
+            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.error(
+                    "The project is temporarily locked. This could be due to modifications or active processes. Please wait a moment and try again."
+                )
+            raise
+
+    return wrapper
+
+
+class StudioClient:
+    def __init__(self, project_id: str):
+        from uipath import UiPath
+
+        self.uipath: UiPath = 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"
+        )
+
+    async def get_project_structure_async(self) -> 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.
+
+        Returns:
+            ProjectStructure: The complete project structure
+        """
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"{self.file_operations_base_url}/Structure",
+            scoped="org",
+        )
+
+        return ProjectStructure.model_validate(response.json())
+
+    @with_lock_retry
+    async def create_folder_async(
+        self,
+        folder_name: str,
+        parent_id: Optional[str] = None,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> str:
+        """Create a folder in the project.
+
+        Args:
+            folder_name: Name of the folder to create
+            parent_id: Optional parent folder ID
+            headers: HTTP headers (automatically injected by decorator)
+
+        Returns:
+            str: The created folder ID
+        """
+        data = {"name": folder_name}
+        if parent_id:
+            data["parent_id"] = parent_id
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"{self.file_operations_base_url}/Folder",
+            scoped="org",
+            json=data,
+            headers=headers or {},
+        )
+        return response.json()
+
+    async def download_file_async(self, file_id: str) -> Any:
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"{self.file_operations_base_url}/File/{file_id}",
+            scoped="org",
+        )
+        return response
+
+    @with_lock_retry
+    async def upload_file_async(
+        self,
+        *,
+        local_file_path: Optional[str] = None,
+        file_content: Optional[str] = None,
+        file_name: str,
+        folder: Optional[ProjectFolder] = None,
+        remote_file: Optional[ProjectFile] = None,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> tuple[str, str]:
+        if local_file_path:
+            with open(local_file_path, "rb") as f:
+                file_content = f.read()  # type: ignore
+        files_data = {"file": (file_name, file_content, "application/octet-stream")}
+
+        if remote_file:
+            # File exists in source_code folder, use PUT to update
+            response = await self.uipath.api_client.request_async(
+                "PUT",
+                files=files_data,
+                url=f"{self.file_operations_base_url}/File/{remote_file.id}",
+                scoped="org",
+                infer_content_type=True,
+                headers=headers or {},
+            )
+            action = "Updated"
+        else:
+            response = await self.uipath.api_client.request_async(
+                "POST",
+                url=f"{self.file_operations_base_url}/File",
+                data={"parentId": folder.id} if folder else None,
+                files=files_data,
+                scoped="org",
+                infer_content_type=True,
+                headers=headers or {},
+            )
+            action = "Uploaded"
+
+        # response contains only the uploaded file identifier
+        return response.json(), action
+
+    @with_lock_retry
+    async def delete_item_async(
+        self,
+        item_id: str,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> None:
+        await self.uipath.api_client.request_async(
+            "DELETE",
+            url=f"{self.file_operations_base_url}/Delete/{item_id}",
+            scoped="org",
+            headers=headers or {},
+        )
+
+    @with_lock_retry
+    async def perform_structural_migration_async(
+        self,
+        structural_migration: StructuralMigration,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> Any:
+        """Perform structural migration of project files.
+
+        Args:
+            structural_migration: The structural migration data containing deleted and added resources
+            headers: HTTP headers (automatically injected by decorator)
+
+        Returns:
+            Any: The API response
+        """
+        files: Any = []
+        deleted_resources_json = json.dumps(structural_migration.deleted_resources)
+
+        files.append(
+            (
+                "DeletedResources",
+                (None, deleted_resources_json),
+            )
+        )
+
+        for i, added_resource in enumerate(structural_migration.added_resources):
+            if os.path.exists(added_resource.content_file_path):
+                with open(added_resource.content_file_path, "rb") as f:
+                    content = f.read()
+
+                filename = os.path.basename(added_resource.content_file_path)
+                files.append((f"AddedResources[{i}].Content", (filename, content)))
+
+                if added_resource.parent_path:
+                    files.append(
+                        (
+                            f"AddedResources[{i}].ParentPath",
+                            (None, added_resource.parent_path),
+                        )
+                    )
+            else:
+                raise FileNotFoundError(
+                    f"File not found: {added_resource.content_file_path}"
+                )
+
+        for i, modified_resource in enumerate(structural_migration.modified_resources):
+            if os.path.exists(modified_resource.content_file_path):
+                with open(modified_resource.content_file_path, "rb") as f:
+                    content = f.read()
+
+                filename = os.path.basename(modified_resource.content_file_path)
+                files.append((f"ModifiedResources[{i}].Content", (filename, content)))
+                files.append(
+                    (
+                        f"ModifiedResources[{i}].Id",
+                        (None, modified_resource.id),
+                    )
+                )
+            else:
+                raise FileNotFoundError(
+                    f"File not found: {modified_resource.content_file_path}"
+                )
+
+        response = await self.uipath.api_client.request_async(
+            "POST",
+            url=f"{self.file_operations_base_url}/StructuralMigration",
+            scoped="org",
+            files=files,
+            infer_content_type=True,
+            headers=headers or {},
+        )
+
+        return response
+
+    async def _retrieve_lock(self) -> LockInfo:
+        response = await self.uipath.api_client.request_async(
+            "GET",
+            url=f"{self._lock_operations_base_url}",
+            scoped="org",
+        )
+        return LockInfo.model_validate(response.json())

uipath/_cli/cli_init.py

@@ -39,7 +39,9 @@ def create_telemetry_config_file(target_directory: str) -> None:
         return
 
     os.makedirs(uipath_dir, exist_ok=True)
-    telemetry_data = {_PROJECT_KEY: str(uuid.uuid4())}
+    telemetry_data = {
+        _PROJECT_KEY: os.getenv("UIPATH_PROJECT_ID", None) or str(uuid.uuid4())
+    }
 
     with open(telemetry_file, "w") as f:
         json.dump(telemetry_data, f, indent=4)

uipath/_cli/cli_pack.py

@@ -7,6 +7,8 @@ from string import Template
 
 import click
 
+from uipath._cli._utils._constants import UIPATH_PROJECT_ID
+
 from ..telemetry import track
 from ..telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
 from ._utils._console import ConsoleLogger
@@ -30,6 +32,10 @@ def get_project_id() -> str:
     Returns:
         Project ID string (either from telemetry file or newly generated).
     """
+    # first check if this is a studio project
+    if os.getenv(UIPATH_PROJECT_ID, None):
+        return os.getenv(UIPATH_PROJECT_ID)
+
     telemetry_file = os.path.join(".uipath", _TELEMETRY_CONFIG_FILE)
 
     if os.path.exists(telemetry_file):
@@ -247,7 +253,7 @@ def pack_fn(
         z.writestr(f"{projectName}.nuspec", nuspec_content)
         z.writestr("_rels/.rels", rels_content)
 
-        files = files_to_include(config_data, directory)
+        files = files_to_include(config_data, directory, include_uv_lock)
 
         for file in files:
             if file.is_binary:
@@ -269,17 +275,6 @@ def pack_fn(
                         with open(file.file_path, "r", encoding="latin-1") as f:
                             z.writestr(f"content/{file.relative_path}", f.read())
 
-        if include_uv_lock:
-            file = "uv.lock"
-            file_path = os.path.join(directory, file)
-            if os.path.exists(file_path):
-                try:
-                    with open(file_path, "r", encoding="utf-8") as f:
-                        z.writestr(f"content/{file}", f.read())
-                except UnicodeDecodeError:
-                    with open(file_path, "r", encoding="latin-1") as f:
-                        z.writestr(f"content/{file}", f.read())
-
 
 def display_project_info(config):
     max_label_length = max(

uipath/_cli/cli_pull.py

@@ -10,25 +10,23 @@ It handles:
 """
 
 # type: ignore
+import asyncio
 import hashlib
 import json
 import os
 from typing import Dict, Set
 
 import click
-import httpx
 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, get_org_scoped_url
 from ._utils._console import ConsoleLogger
+from ._utils._constants import UIPATH_PROJECT_ID
 from ._utils._studio_project import (
     ProjectFile,
     ProjectFolder,
-    download_file,
+    StudioClient,
     get_folder_by_name,
-    get_project_structure,
 )
 
 console = ConsoleLogger()
@@ -76,22 +74,18 @@ def collect_files_from_folder(
         collect_files_from_folder(subfolder, subfolder_path, files_dict)
 
 
-def download_folder_files(
+async def download_folder_files(
+    studio_client: StudioClient,
     folder: ProjectFolder,
     base_path: str,
-    base_url: str,
-    token: str,
-    client: httpx.Client,
     processed_files: Set[str],
 ) -> None:
     """Download files from a folder recursively.
 
     Args:
+        studio_client: Studio client
         folder: The folder to download files from
         base_path: Base path for local file storage
-        base_url: Base URL for API requests
-        token: Authentication token
-        client: HTTP client
         processed_files: Set to track processed files
     """
     files_dict: Dict[str, ProjectFile] = {}
@@ -106,7 +100,7 @@ def download_folder_files(
             os.makedirs(local_dir)
 
         # Download remote file
-        response = download_file(base_url, remote_file.id, client, token)
+        response = await studio_client.download_file_async(remote_file.id)
         remote_content = response.read().decode("utf-8")
         remote_hash = compute_normalized_hash(remote_content)
 
@@ -163,53 +157,45 @@ def pull(root: str) -> None:
         $ uipath pull
         $ uipath pull /path/to/project
     """
-    if not os.getenv("UIPATH_PROJECT_ID", False):
+    if not (project_id := os.getenv(UIPATH_PROJECT_ID, False)):
         console.error("UIPATH_PROJECT_ID environment variable not found.")
 
-    [base_url, token] = get_env_vars()
-    base_api_url = f"{get_org_scoped_url(base_url)}/studio_/backend/api/Project/{os.getenv('UIPATH_PROJECT_ID')}/FileOperations"
+    studio_client = StudioClient(project_id)
 
     with console.spinner("Pulling UiPath project files..."):
         try:
-            with httpx.Client(**get_httpx_client_kwargs()) as client:
-                # Get project structure
-                structure = get_project_structure(
-                    os.getenv("UIPATH_PROJECT_ID"),  # type: ignore
-                    get_org_scoped_url(base_url),
-                    token,
-                    client,
-                )
+            structure = asyncio.run(studio_client.get_project_structure_async())
 
-                processed_files: Set[str] = set()
+            processed_files: Set[str] = set()
 
-                # Process source_code folder
-                source_code_folder = get_folder_by_name(structure, "source_code")
-                if source_code_folder:
+            # Process source_code folder
+            source_code_folder = get_folder_by_name(structure, "source_code")
+            if source_code_folder:
+                asyncio.run(
                     download_folder_files(
+                        studio_client,
                         source_code_folder,
                         root,
-                        base_api_url,
-                        token,
-                        client,
                         processed_files,
                     )
-                else:
-                    console.warning("No source_code folder found in remote project")
+                )
+            else:
+                console.warning("No source_code folder found in remote project")
 
-                # Process evals folder
-                evals_folder = get_folder_by_name(structure, "evals")
-                if evals_folder:
-                    evals_path = os.path.join(root, "evals")
+            # Process evals folder
+            evals_folder = get_folder_by_name(structure, "evals")
+            if evals_folder:
+                evals_path = os.path.join(root, "evals")
+                asyncio.run(
                     download_folder_files(
+                        studio_client,
                         evals_folder,
                         evals_path,
-                        base_api_url,
-                        token,
-                        client,
                         processed_files,
                     )
-                else:
-                    console.warning("No evals folder found in remote project")
+                )
+            else:
+                console.warning("No evals folder found in remote project")
 
         except Exception as e:
             console.error(f"Failed to pull UiPath project: {str(e)}")