uipath 2.1.128__tar.gz → 2.1.130__tar.gz

{uipath-2.1.128 → uipath-2.1.130}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.128"
+version = "2.1.130"
 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.128 → uipath-2.1.130}/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.128 → uipath-2.1.130}/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.128 → uipath-2.1.130}/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.128 → uipath-2.1.130}/src/uipath/telemetry/_track.py

@@ -2,7 +2,7 @@ import json
 import os
 from functools import wraps
 from importlib.metadata import version
-from logging import WARNING, LogRecord, getLogger
+from logging import INFO, WARNING, LogRecord, getLogger
 from typing import Any, Callable, Dict, Optional, Union
 
 from azure.monitor.opentelemetry import configure_azure_monitor
@@ -104,7 +104,7 @@ class _TelemetryClient:
 
             getLogger("azure").setLevel(WARNING)
             _logger.addHandler(_AzureMonitorOpenTelemetryEventHandler())
-            _logger.setLevel(WARNING)
+            _logger.setLevel(INFO)
 
             _TelemetryClient._initialized = True
         except Exception:

uipath-2.1.130/tests/cli/test_conflict_handlers.py

@@ -0,0 +1,249 @@
+# type: ignore
+"""Tests for conflict handlers used in push and pull operations."""
+
+import os
+import tempfile
+from pathlib import Path
+
+
+class TestInteractiveConflictHandler:
+    """Tests for InteractiveConflictHandler used during pull operations."""
+
+    def test_should_overwrite_with_user_confirmation(self, monkeypatch):
+        """Test that handler returns True when user confirms overwrite."""
+        from uipath._cli._utils._project_files import InteractiveConflictHandler
+
+        # Create a temporary file to test with
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("test content")
+            temp_file = Path(f.name)
+
+        try:
+            handler = InteractiveConflictHandler(operation="pull")
+
+            # Mock click.confirm to return True
+            monkeypatch.setattr("click.confirm", lambda *args, **kwargs: True)
+
+            # Mock click.echo to capture output
+            outputs = []
+            monkeypatch.setattr(
+                "click.echo", lambda msg, **kwargs: outputs.append(str(msg))
+            )
+
+            result = handler.should_overwrite(
+                "test/file.py",
+                "local_hash",
+                "remote_hash",
+                local_full_path=temp_file,
+            )
+
+            assert result is True
+            # Check that the warning message was displayed
+            assert any("has different content on remote" in str(out) for out in outputs)
+        finally:
+            os.unlink(temp_file)
+
+    def test_should_overwrite_with_user_rejection(self, monkeypatch):
+        """Test that handler returns False when user rejects overwrite."""
+        from uipath._cli._utils._project_files import InteractiveConflictHandler
+
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("test content")
+            temp_file = Path(f.name)
+
+        try:
+            handler = InteractiveConflictHandler(operation="pull")
+
+            # Mock click.confirm to return False
+            monkeypatch.setattr("click.confirm", lambda *args, **kwargs: False)
+
+            outputs = []
+            monkeypatch.setattr(
+                "click.echo", lambda msg, **kwargs: outputs.append(str(msg))
+            )
+
+            result = handler.should_overwrite(
+                "test/file.py",
+                "local_hash",
+                "remote_hash",
+                local_full_path=temp_file,
+            )
+
+            assert result is False
+        finally:
+            os.unlink(temp_file)
+
+    def test_should_overwrite_prompt_message_for_pull(self, monkeypatch):
+        """Test that prompt message is appropriate for pull operation."""
+        from uipath._cli._utils._project_files import InteractiveConflictHandler
+
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("test content")
+            temp_file = Path(f.name)
+
+        try:
+            handler = InteractiveConflictHandler(operation="pull")
+
+            # Capture the prompt message
+            prompt_messages = []
+
+            def mock_confirm(msg, *args, **kwargs):
+                prompt_messages.append(msg)
+                return True
+
+            monkeypatch.setattr("click.confirm", mock_confirm)
+            monkeypatch.setattr("click.echo", lambda *args, **kwargs: None)
+
+            handler.should_overwrite(
+                "test/file.py",
+                "local_hash",
+                "remote_hash",
+                local_full_path=temp_file,
+            )
+
+            # Verify the prompt message is for pull (overwrite local with remote)
+            assert len(prompt_messages) == 1
+            assert (
+                "overwrite the local file with the remote version" in prompt_messages[0]
+            )
+        finally:
+            os.unlink(temp_file)
+
+    def test_should_overwrite_without_file_path(self, monkeypatch):
+        """Test handler behavior when no file path is provided."""
+        from uipath._cli._utils._project_files import InteractiveConflictHandler
+
+        handler = InteractiveConflictHandler(operation="pull")
+
+        monkeypatch.setattr("click.confirm", lambda *args, **kwargs: True)
+
+        outputs = []
+        monkeypatch.setattr(
+            "click.echo", lambda msg, **kwargs: outputs.append(str(msg))
+        )
+
+        result = handler.should_overwrite(
+            "test/file.py",
+            "local_hash",
+            "remote_hash",
+            local_full_path=None,
+        )
+
+        assert result is True
+        # Should still show warning but not modification date
+        assert any("has different content on remote" in str(out) for out in outputs)
+        assert not any("Local file last modified:" in str(out) for out in outputs)
+
+    def test_handler_with_explicit_pull_operation(self, monkeypatch):
+        """Test that handler with operation='pull' shows correct prompt."""
+        from uipath._cli._utils._project_files import InteractiveConflictHandler
+
+        handler = InteractiveConflictHandler(operation="pull")
+
+        # Capture the prompt message
+        prompt_messages = []
+
+        def mock_confirm(msg, *args, **kwargs):
+            prompt_messages.append(msg)
+            return True
+
+        monkeypatch.setattr("click.confirm", mock_confirm)
+        monkeypatch.setattr("click.echo", lambda *args, **kwargs: None)
+
+        result = handler.should_overwrite(
+            "test/file.py",
+            "local_hash",
+            "remote_hash",
+        )
+
+        assert result is True
+        assert len(prompt_messages) == 1
+        assert "overwrite the local file with the remote version" in prompt_messages[0]
+
+    def test_handler_with_explicit_push_operation(self, monkeypatch):
+        """Test that handler with operation='push' shows correct prompt."""
+        from uipath._cli._utils._project_files import InteractiveConflictHandler
+
+        handler = InteractiveConflictHandler(operation="push")
+
+        # Capture the prompt message
+        prompt_messages = []
+
+        def mock_confirm(msg, *args, **kwargs):
+            prompt_messages.append(msg)
+            return True
+
+        monkeypatch.setattr("click.confirm", mock_confirm)
+        monkeypatch.setattr("click.echo", lambda *args, **kwargs: None)
+
+        result = handler.should_overwrite(
+            "test/file.py",
+            "local_hash",
+            "remote_hash",
+        )
+
+        assert result is True
+        assert len(prompt_messages) == 1
+        assert "push and overwrite the remote file" in prompt_messages[0]
+        assert "local version" in prompt_messages[0]
+
+    def test_no_modification_timestamp_displayed(self, monkeypatch):
+        """Test that modification timestamp is never displayed."""
+        from uipath._cli._utils._project_files import InteractiveConflictHandler
+
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("test content")
+            temp_file = Path(f.name)
+
+        try:
+            handler = InteractiveConflictHandler(operation="pull")
+
+            monkeypatch.setattr("click.confirm", lambda *args, **kwargs: True)
+
+            outputs = []
+            monkeypatch.setattr(
+                "click.echo", lambda msg, **kwargs: outputs.append(str(msg))
+            )
+
+            handler.should_overwrite(
+                "test/file.py",
+                "local_hash",
+                "remote_hash",
+                local_full_path=temp_file,
+            )
+
+            # Verify that no modification timestamp is displayed
+            assert not any("Local file last modified:" in str(out) for out in outputs)
+            assert not any("last modified" in str(out).lower() for out in outputs)
+        finally:
+            os.unlink(temp_file)
+
+
+class TestAlwaysOverwriteHandler:
+    """Tests for AlwaysOverwriteHandler."""
+
+    def test_always_returns_true(self):
+        """Test that AlwaysOverwriteHandler always returns True."""
+        from uipath._cli._utils._project_files import AlwaysOverwriteHandler
+
+        handler = AlwaysOverwriteHandler()
+        assert handler.should_overwrite("file.py", "hash1", "hash2") is True
+        assert (
+            handler.should_overwrite("other.py", "hash3", "hash4", Path("test.py"))
+            is True
+        )
+
+
+class TestAlwaysSkipHandler:
+    """Tests for AlwaysSkipHandler."""
+
+    def test_always_returns_false(self):
+        """Test that AlwaysSkipHandler always returns False."""
+        from uipath._cli._utils._project_files import AlwaysSkipHandler
+
+        handler = AlwaysSkipHandler()
+        assert handler.should_overwrite("file.py", "hash1", "hash2") is False
+        assert (
+            handler.should_overwrite("other.py", "hash3", "hash4", Path("test.py"))
+            is False
+        )