uipath 2.1.127__tar.gz → 2.1.129__tar.gz

{uipath-2.1.127 → uipath-2.1.129}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.127
+Version: 2.1.129
 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.127 → uipath-2.1.129}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.127"
+version = "2.1.129"
 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"

{uipath-2.1.127 → uipath-2.1.129}/src/uipath/_cli/_push/sw_file_handler.py

@@ -23,6 +23,8 @@ from .._utils._constants import (
 from .._utils._project_files import (  # type: ignore
     FileInfo,
     FileOperationUpdate,
+    InteractiveConflictHandler,
+    compute_normalized_hash,
     files_to_include,
     read_toml_project,
 )
@@ -56,6 +58,7 @@ class SwFileHandler:
         project_id: str,
         directory: str,
         include_uv_lock: bool = True,
+        conflict_handler: Optional[InteractiveConflictHandler] = None,
     ) -> None:
         """Initialize the SwFileHandler.
 
@@ -63,12 +66,16 @@ class SwFileHandler:
             project_id: The ID of the UiPath project
             directory: Local project directory
             include_uv_lock: Whether to include uv.lock file
+            conflict_handler: Optional handler for file conflicts
         """
         self.directory = directory
         self.include_uv_lock = include_uv_lock
         self.console = ConsoleLogger()
         self._studio_client = StudioClient(project_id)
         self._project_structure: Optional[ProjectStructure] = None
+        self._conflict_handler = conflict_handler or InteractiveConflictHandler(
+            operation="push"
+        )
 
     def _get_folder_by_name(
         self, structure: ProjectStructure, folder_name: str
@@ -186,20 +193,78 @@ class SwFileHandler:
             )
 
             if remote_file:
-                # File exists remotely - mark for update
+                # File exists remotely - check if content differs
                 processed_source_files.add(remote_file.id)
-                structural_migration.modified_resources.append(
-                    ModifiedResource(
-                        id=remote_file.id, content_file_path=local_file.file_path
+
+                # Download remote file and compare with local
+                try:
+                    remote_response = (
+                        await self._studio_client.download_project_file_async(
+                            remote_file
+                        )
                     )
-                )
-                updates.append(
-                    FileOperationUpdate(
-                        file_path=local_file.file_path,
-                        status="updating",
-                        message=f"Updating '{local_file.file_name}'",
+                    remote_content = remote_response.read().decode("utf-8")
+                    remote_hash = compute_normalized_hash(remote_content)
+
+                    with open(local_file.file_path, "r", encoding="utf-8") as f:
+                        local_content = f.read()
+                        local_hash = compute_normalized_hash(local_content)
+
+                    # Only update if content differs and user confirms
+                    if local_hash != remote_hash:
+                        if self._conflict_handler.should_overwrite(
+                            local_file.relative_path,
+                            remote_hash,
+                            local_hash,
+                            local_full_path=os.path.abspath(local_file.file_path),
+                        ):
+                            structural_migration.modified_resources.append(
+                                ModifiedResource(
+                                    id=remote_file.id,
+                                    content_file_path=local_file.file_path,
+                                )
+                            )
+                            updates.append(
+                                FileOperationUpdate(
+                                    file_path=local_file.file_path,
+                                    status="updating",
+                                    message=f"Updating '{local_file.file_name}'",
+                                )
+                            )
+                        else:
+                            updates.append(
+                                FileOperationUpdate(
+                                    file_path=local_file.file_path,
+                                    status="skipped",
+                                    message=f"Skipped '{local_file.file_name}'",
+                                )
+                            )
+                    else:
+                        # Content is the same, no need to update
+                        updates.append(
+                            FileOperationUpdate(
+                                file_path=local_file.file_path,
+                                status="up_to_date",
+                                message=f"File '{local_file.file_name}' is up to date",
+                            )
+                        )
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to compare file '{local_file.file_path}': {e}"
+                    )
+                    # If comparison fails, proceed with update
+                    structural_migration.modified_resources.append(
+                        ModifiedResource(
+                            id=remote_file.id, content_file_path=local_file.file_path
+                        )
+                    )
+                    updates.append(
+                        FileOperationUpdate(
+                            file_path=local_file.file_path,
+                            status="updating",
+                            message=f"Updating '{local_file.file_name}'",
+                        )
                     )
-                )
             else:
                 # File doesn't exist remotely - mark for upload
                 parent_path = os.path.dirname(local_file.relative_path)
@@ -741,7 +806,7 @@ class SwFileHandler:
                 files[file.name] = file
         return files
 
-    def _process_file_sync(
+    async def _process_file_sync(
         self,
         local_file_path: str,
         remote_files: Dict[str, ProjectFile],
@@ -766,10 +831,51 @@ class SwFileHandler:
 
         if remote_file:
             processed_ids.add(remote_file.id)
-            structural_migration.modified_resources.append(
-                ModifiedResource(id=remote_file.id, content_file_path=local_file_path)
-            )
-            self.console.info(f"Updating {click.style(destination, fg='yellow')}")
+
+            # Download remote file and compare with local
+            try:
+                remote_response = await self._studio_client.download_project_file_async(
+                    remote_file
+                )
+                remote_content = remote_response.read().decode("utf-8")
+                remote_hash = compute_normalized_hash(remote_content)
+
+                with open(local_file_path, "r", encoding="utf-8") as f:
+                    local_content = f.read()
+                    local_hash = compute_normalized_hash(local_content)
+
+                # Only update if content differs and user confirms
+                if local_hash != remote_hash:
+                    if self._conflict_handler.should_overwrite(
+                        destination,
+                        remote_hash,
+                        local_hash,
+                        local_full_path=os.path.abspath(local_file_path),
+                    ):
+                        structural_migration.modified_resources.append(
+                            ModifiedResource(
+                                id=remote_file.id, content_file_path=local_file_path
+                            )
+                        )
+                        self.console.info(
+                            f"Updating {click.style(destination, fg='yellow')}"
+                        )
+                    else:
+                        self.console.info(
+                            f"Skipped {click.style(destination, fg='bright_black')}"
+                        )
+                else:
+                    # Content is the same, no need to update
+                    self.console.info(f"File '{destination}' is up to date")
+            except Exception as e:
+                logger.warning(f"Failed to compare file '{local_file_path}': {e}")
+                # If comparison fails, proceed with update
+                structural_migration.modified_resources.append(
+                    ModifiedResource(
+                        id=remote_file.id, content_file_path=local_file_path
+                    )
+                )
+                self.console.info(f"Updating {click.style(destination, fg='yellow')}")
         else:
             structural_migration.added_resources.append(
                 AddedResource(
@@ -870,7 +976,7 @@ class SwFileHandler:
                         register_evaluator(evaluator.custom_evaluator_file_name)
                     )
 
-                    self._process_file_sync(
+                    await self._process_file_sync(
                         evaluator_schema_file_path,
                         remote_custom_evaluator_files,
                         "coded-evals/evaluators/custom",
@@ -879,7 +985,7 @@ class SwFileHandler:
                         processed_custom_evaluator_ids,
                     )
 
-                    self._process_file_sync(
+                    await self._process_file_sync(
                         evaluator_types_file_path,
                         remote_custom_evaluator_type_files,
                         "coded-evals/evaluators/custom/types",
@@ -888,7 +994,7 @@ class SwFileHandler:
                         processed_evaluator_type_ids,
                     )
 
-                self._process_file_sync(
+                await self._process_file_sync(
                     evaluator.path,
                     remote_evaluator_files,
                     "coded-evals/evaluators",
@@ -898,7 +1004,7 @@ class SwFileHandler:
                 )
 
             for eval_set_file in eval_set_files:
-                self._process_file_sync(
+                await self._process_file_sync(
                     eval_set_file,
                     remote_eval_set_files,
                     "coded-evals/eval-sets",

{uipath-2.1.127 → uipath-2.1.129}/src/uipath/_cli/_utils/_project_files.py

@@ -57,7 +57,11 @@ class FileConflictHandler(Protocol):
     """Protocol for handling file conflicts."""
 
     def should_overwrite(
-        self, file_path: str, local_hash: str, remote_hash: str
+        self,
+        file_path: str,
+        local_hash: str,
+        remote_hash: str,
+        local_full_path: Optional[Path] = None,
     ) -> bool:
         """Return True to overwrite, False to skip."""
         ...
@@ -67,7 +71,11 @@ class AlwaysOverwriteHandler:
     """Handler that always overwrites files."""
 
     def should_overwrite(
-        self, file_path: str, local_hash: str, remote_hash: str
+        self,
+        file_path: str,
+        local_hash: str,
+        remote_hash: str,
+        local_full_path: Optional[Path] = None,
     ) -> bool:
         return True
 
@@ -76,11 +84,73 @@ class AlwaysSkipHandler:
     """Handler that always skips conflicts."""
 
     def should_overwrite(
-        self, file_path: str, local_hash: str, remote_hash: str
+        self,
+        file_path: str,
+        local_hash: str,
+        remote_hash: str,
+        local_full_path: Optional[Path] = None,
     ) -> bool:
         return False
 
 
+class InteractiveConflictHandler:
+    """Handler that prompts the user for each conflict during pull or push operations.
+
+    Attributes:
+        operation: The operation type - either "pull" or "push"
+    """
+
+    def __init__(self, operation: Literal["pull", "push"]) -> None:
+        """Initialize the handler with an operation type.
+
+        Args:
+            operation: Either "pull" or "push" to determine the prompt message
+        """
+        self.operation = operation
+
+    def should_overwrite(
+        self,
+        file_path: str,
+        local_hash: str,
+        remote_hash: str,
+        local_full_path: Optional[Path] = None,
+    ) -> bool:
+        """Ask the user if they want to overwrite based on the operation.
+
+        Args:
+            file_path: Relative path to the file (for display)
+            local_hash: Hash of the local file content
+            remote_hash: Hash of the remote file content
+            local_full_path: Full path to the local file (unused, kept for protocol compatibility)
+
+        Returns:
+            True if the user wants to overwrite, False otherwise
+        """
+        import sys
+
+        import click
+
+        click.echo(
+            click.style(
+                f"\nFile '{file_path}' has different content on remote.",
+                fg="yellow",
+            )
+        )
+
+        # Prompt user for confirmation with operation-specific message
+        sys.stdout.flush()
+        if self.operation == "pull":
+            return click.confirm(
+                "Do you want to overwrite the local file with the remote version?",
+                default=False,
+            )
+        else:  # push
+            return click.confirm(
+                "Do you want to push and overwrite the remote file with your local version?",
+                default=False,
+            )
+
+
 class FileInfo(BaseModel):
     """Information about a file to be included in the project.
 
@@ -608,7 +678,7 @@ async def download_folder_files(
 
             if local_hash != remote_hash:
                 if conflict_handler.should_overwrite(
-                    file_path, local_hash, remote_hash
+                    file_path, local_hash, remote_hash, local_path
                 ):
                     with open(local_path, "w", encoding="utf-8", newline="\n") as f:
                         f.write(remote_content)

{uipath-2.1.127 → uipath-2.1.129}/src/uipath/_cli/cli_pull.py

@@ -3,7 +3,7 @@
 
 This module provides functionality to pull remote project files from a UiPath StudioWeb solution.
 It handles:
-- File downloads from source_code and evals folders
+- File downloads from source_code and coded-evals folders
 - Maintaining folder structure locally
 - File comparison using hashes
 - Interactive confirmation for overwriting files
@@ -18,7 +18,11 @@ import click
 from .._config import UiPathConfig
 from ..telemetry import track
 from ._utils._console import ConsoleLogger
-from ._utils._project_files import ProjectPullError, pull_project
+from ._utils._project_files import (
+    InteractiveConflictHandler,
+    ProjectPullError,
+    pull_project,
+)
 
 console = ConsoleLogger()
 
@@ -34,7 +38,7 @@ def pull(root: Path) -> None:
     """Pull remote project files from Studio Web Project.
 
     This command pulls the remote project files from a UiPath Studio Web project.
-    It downloads files from the source_code and evals folders, maintaining the
+    It downloads files from the source_code and coded-evals folders, maintaining the
     folder structure locally. Files are compared using hashes before overwriting,
     and user confirmation is required for differing files.
 
@@ -54,13 +58,18 @@ def pull(root: Path) -> None:
 
     download_configuration = {
         "source_code": root,
-        "evals": root / "evals",
+        "coded-evals": root / "evals",
     }
 
+    # Create interactive conflict handler for user confirmation
+    conflict_handler = InteractiveConflictHandler(operation="pull")
+
     try:
 
         async def run_pull():
-            async for update in pull_project(project_id, download_configuration):
+            async for update in pull_project(
+                project_id, download_configuration, conflict_handler
+            ):
                 console.info(f"Processing: {update.file_path}")
                 console.info(update.message)
 

uipath-2.1.129/src/uipath/utils/dynamic_schema.py

@@ -0,0 +1,128 @@
+"""Json schema to dynamic pydantic model."""
+
+from enum import Enum
+from typing import Any, Dict, List, Type, Union
+
+from pydantic import BaseModel, Field, create_model
+
+
+def jsonschema_to_pydantic(
+    schema: dict[str, Any],
+) -> Type[BaseModel]:
+    """Convert a schema dict to a pydantic model.
+
+    Modified version of https://github.com/kreneskyp/jsonschema-pydantic to account for three unresolved issues.
+      1. Support for title
+      2. Better representation of optionals.
+      3. Support for optional
+
+    Args:
+        schema: JSON schema.
+        definitions: Definitions dict. Defaults to `$def`.
+
+    Returns: Pydantic model.
+    """
+    dynamic_type_counter = 0
+    combined_model_counter = 0
+
+    def convert_type(prop: dict[str, Any]) -> Any:
+        nonlocal dynamic_type_counter, combined_model_counter
+        if "$ref" in prop:
+            # This is the full path. It will be updated in update_forward_refs.
+            return prop["$ref"].split("/")[-1].capitalize()
+
+        if "type" in prop:
+            type_mapping = {
+                "string": str,
+                "number": float,
+                "integer": int,
+                "boolean": bool,
+                "array": List,
+                "object": Dict[str, Any],
+                "null": None,
+            }
+
+            type_ = prop["type"]
+
+            if "enum" in prop:
+                dynamic_members = {
+                    f"KEY_{i}": value for i, value in enumerate(prop["enum"])
+                }
+
+                base_type: Any = type_mapping.get(type_, Any)
+
+                class DynamicEnum(base_type, Enum):
+                    pass
+
+                type_ = DynamicEnum(prop.get("title", "DynamicEnum"), dynamic_members)  # type: ignore[call-arg]
+                return type_
+            elif type_ == "array":
+                item_type: Any = convert_type(prop.get("items", {}))
+                return List[item_type]  # noqa F821
+            elif type_ == "object":
+                if "properties" in prop:
+                    if "title" in prop and prop["title"]:
+                        title = prop["title"]
+                    else:
+                        title = f"DynamicType_{dynamic_type_counter}"
+                        dynamic_type_counter += 1
+
+                    fields: dict[str, Any] = {}
+                    required_fields = prop.get("required", [])
+
+                    for name, property in prop.get("properties", {}).items():
+                        pydantic_type = convert_type(property)
+                        field_kwargs = {}
+                        if "default" in property:
+                            field_kwargs["default"] = property["default"]
+                        if name not in required_fields:
+                            # Note that we do not make this optional. This is due to a limitation in Pydantic/Python.
+                            # If we convert the Optional type back to json schema, it is represented as type | None.
+                            # pydantic_type = Optional[pydantic_type]
+
+                            if "default" not in field_kwargs:
+                                field_kwargs["default"] = None
+                        if "description" in property:
+                            field_kwargs["description"] = property["description"]
+                        if "title" in property:
+                            field_kwargs["title"] = property["title"]
+
+                        fields[name] = (pydantic_type, Field(**field_kwargs))
+
+                    object_model = create_model(title, **fields)
+                    if "description" in prop:
+                        object_model.__doc__ = prop["description"]
+                    return object_model
+                else:
+                    return Dict[str, Any]
+            else:
+                return type_mapping.get(type_, Any)
+
+        elif "allOf" in prop:
+            combined_fields = {}
+            for sub_schema in prop["allOf"]:
+                model = convert_type(sub_schema)
+                combined_fields.update(model.__annotations__)
+            combined_model = create_model(
+                f"CombinedModel_{combined_model_counter}", **combined_fields
+            )
+            combined_model_counter += 1
+            return combined_model
+
+        elif "anyOf" in prop:
+            unioned_types = tuple(
+                convert_type(sub_schema) for sub_schema in prop["anyOf"]
+            )
+            return Union[unioned_types]
+        elif prop == {} or "type" not in prop:
+            return Any
+        else:
+            raise ValueError(f"Unsupported schema: {prop}")
+
+    namespace: dict[str, Any] = {}
+    for name, definition in schema.get("$defs", schema.get("definitions", {})).items():
+        model = convert_type(definition)
+        namespace[name.capitalize()] = model
+    model = convert_type(schema)
+    model.model_rebuild(force=True, _types_namespace=namespace)
+    return model