uipath 2.1.31__tar.gz → 2.1.33__tar.gz

{uipath-2.1.31 → uipath-2.1.33}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.31"
+version = "2.1.33"
 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.31 → uipath-2.1.33}/src/uipath/_cli/_dev/_terminal/__init__.py

@@ -10,17 +10,19 @@ from uuid import uuid4
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Container, Horizontal
-from textual.widgets import Button, ListView
+from textual.widgets import Button, Footer, ListView
 
 from ..._runtime._contracts import (
     UiPathErrorContract,
     UiPathRuntimeContext,
     UiPathRuntimeError,
     UiPathRuntimeFactory,
+    UiPathRuntimeStatus,
 )
 from ._components._details import RunDetailsPanel
 from ._components._history import RunHistoryPanel
 from ._components._new import NewRunPanel
+from ._components._resume import ResumePanel
 from ._models._execution import ExecutionRun
 from ._models._messages import LogMessage, TraceMessage
 from ._traces._exporter import RunContextExporter
@@ -34,8 +36,8 @@ class UiPathDevTerminal(App[Any]):
 
     BINDINGS = [
         Binding("q", "quit", "Quit"),
-        Binding("n", "new_run", "New Run"),
-        Binding("r", "execute_run", "Execute"),
+        Binding("n", "new_run", "New"),
+        Binding("r", "execute_run", "Run"),
         Binding("c", "clear_history", "Clear History"),
         Binding("escape", "cancel", "Cancel"),
     ]
@@ -76,6 +78,8 @@ class UiPathDevTerminal(App[Any]):
                 # Run details panel (initially hidden)
                 yield RunDetailsPanel(id="details-panel", classes="hidden")
 
+        yield Footer()
+
     async def on_button_pressed(self, event: Button.Pressed) -> None:
         """Handle button press events."""
         if event.button.id == "new-run-btn":
@@ -84,6 +88,8 @@ class UiPathDevTerminal(App[Any]):
             await self.action_execute_run()
         elif event.button.id == "cancel-btn":
             await self.action_cancel()
+        elif event.button.id == "resume-btn":
+            await self.action_resume()
 
     async def on_list_view_selected(self, event: ListView.Selected) -> None:
         """Handle run selection from history."""
@@ -107,6 +113,20 @@ class UiPathDevTerminal(App[Any]):
         """Cancel and return to new run view."""
         await self.action_new_run()
 
+    async def action_resume(self) -> None:
+        """Resume the suspended run."""
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        if details_panel and details_panel.current_run:
+            input: Dict[str, Any] = {}
+            input_data = self.query_one("#resume-panel", ResumePanel).get_input_values()
+            try:
+                input = json.loads(input_data)
+            except json.JSONDecodeError:
+                return
+            details_panel.current_run.resume_data = input
+            asyncio.create_task(self._execute_runtime(details_panel.current_run))
+            details_panel.switch_tab("run-tab")
+
     async def action_execute_run(self) -> None:
         """Execute a new run with UiPath runtime."""
         new_run_panel = self.query_one("#new-run-panel", NewRunPanel)
@@ -115,12 +135,14 @@ class UiPathDevTerminal(App[Any]):
         if not entrypoint:
             return
 
+        input: Dict[str, Any] = {}
         try:
-            json.loads(input_data)
+            input = json.loads(input_data)
         except json.JSONDecodeError:
             return
 
-        run = ExecutionRun(entrypoint, input_data)
+        run = ExecutionRun(entrypoint, input)
+
         self.runs[run.id] = run
 
         self._add_run_in_history(run)
@@ -140,7 +162,6 @@ class UiPathDevTerminal(App[Any]):
         try:
             context: UiPathRuntimeContext = self.runtime_factory.new_context(
                 entrypoint=run.entrypoint,
-                input=run.input_data,
                 trace_id=str(uuid4()),
                 execution_id=run.id,
                 logs_min_level=env.get("LOG_LEVEL", "INFO"),
@@ -149,17 +170,29 @@ class UiPathDevTerminal(App[Any]):
                 ),
             )
 
-            self._add_info_log(run, f"Starting execution: {run.entrypoint}")
+            if run.status == "suspended":
+                context.resume = True
+                context.input_json = run.resume_data
+                self._add_info_log(run, f"Resuming execution: {run.entrypoint}")
+            else:
+                context.input_json = run.input_data
+                self._add_info_log(run, f"Starting execution: {run.entrypoint}")
+
+            run.status = "running"
+            run.start_time = datetime.now()
 
             result = await self.runtime_factory.execute_in_root_span(context)
 
             if result is not None:
-                run.output_data = json.dumps(result.output)
+                if result.status == UiPathRuntimeStatus.SUSPENDED.value:
+                    run.status = "suspended"
+                else:
+                    run.output_data = result.output
+                    run.status = "completed"
                 if run.output_data:
                     self._add_info_log(run, f"Execution result: {run.output_data}")
 
             self._add_info_log(run, "✅ Execution completed successfully")
-            run.status = "completed"
             run.end_time = datetime.now()
 
         except UiPathRuntimeError as e:

{uipath-2.1.31 → uipath-2.1.33}/src/uipath/_cli/_dev/_terminal/_components/_details.py

@@ -8,6 +8,7 @@ from textual.widgets.tree import TreeNode
 
 from .._models._execution import ExecutionRun
 from .._models._messages import LogMessage, TraceMessage
+from ._resume import ResumePanel
 
 
 class SpanDetailsDisplay(Container):
@@ -27,14 +28,7 @@ class SpanDetailsDisplay(Container):
         details_log = self.query_one("#span-details", RichLog)
         details_log.clear()
 
-        # Format span details
         details_log.write(f"[bold cyan]Span: {trace_msg.span_name}[/bold cyan]")
-        details_log.write(f"[dim]Trace ID: {trace_msg.trace_id}[/dim]")
-        details_log.write(f"[dim]Span ID: {trace_msg.span_id}[/dim]")
-        details_log.write(f"[dim]Run ID: {trace_msg.run_id}[/dim]")
-
-        if trace_msg.parent_span_id:
-            details_log.write(f"[dim]Parent Span: {trace_msg.parent_span_id}[/dim]")
 
         details_log.write("")  # Empty line
 
@@ -66,6 +60,16 @@ class SpanDetailsDisplay(Container):
             for key, value in trace_msg.attributes.items():
                 details_log.write(f"  {key}: {value}")
 
+        details_log.write("")  # Empty line
+
+        # Format span details
+        details_log.write(f"[dim]Trace ID: {trace_msg.trace_id}[/dim]")
+        details_log.write(f"[dim]Span ID: {trace_msg.span_id}[/dim]")
+        details_log.write(f"[dim]Run ID: {trace_msg.run_id}[/dim]")
+
+        if trace_msg.parent_span_id:
+            details_log.write(f"[dim]Parent Span: {trace_msg.parent_span_id}[/dim]")
+
 
 class RunDetailsPanel(Container):
     """Panel showing traces and logs for selected run with tabbed interface."""
@@ -112,6 +116,9 @@ class RunDetailsPanel(Container):
                     classes="detail-log",
                 )
 
+            with TabPane("Resume", id="resume-tab"):
+                yield ResumePanel(id="resume-panel")
+
     def watch_current_run(
         self, old_value: Optional[ExecutionRun], new_value: Optional[ExecutionRun]
     ):
@@ -139,8 +146,69 @@ class RunDetailsPanel(Container):
         # Clear and rebuild traces tree using TraceMessage objects
         self._rebuild_spans_tree()
 
+    def switch_tab(self, tab_id: str) -> None:
+        """Switch to a specific tab by id (e.g. 'run-tab', 'traces-tab')."""
+        tabbed = self.query_one(TabbedContent)
+        tabbed.active = tab_id
+
+    def _update_resume_tab(self, run: ExecutionRun) -> None:
+        resume_panel = self.query_one("#resume-panel", ResumePanel)
+        resume_panel.display = run.status == "suspended"
+
+    def _flatten_values(self, value: object, prefix: str = "") -> list[str]:
+        """Flatten nested dict/list structures into dot-notation paths."""
+        lines: list[str] = []
+
+        if value is None:
+            lines.append(f"{prefix}: [dim]—[/dim]" if prefix else "[dim]—[/dim]")
+
+        elif isinstance(value, dict):
+            if not value:
+                lines.append(f"{prefix}: {{}}" if prefix else "{}")
+            else:
+                for k, v in value.items():
+                    new_prefix = f"{prefix}.{k}" if prefix else k
+                    lines.extend(self._flatten_values(v, new_prefix))
+
+        elif isinstance(value, list):
+            if not value:
+                lines.append(f"{prefix}: []" if prefix else "[]")
+            else:
+                for i, item in enumerate(value):
+                    new_prefix = f"{prefix}[{i}]"
+                    lines.extend(self._flatten_values(item, new_prefix))
+
+        elif isinstance(value, str):
+            if prefix:
+                for line in value.splitlines():
+                    lines.append(f"{prefix}: {line}")
+            else:
+                lines.extend(value.splitlines())
+
+        else:
+            if prefix:
+                lines.append(f"{prefix}: {value}")
+            else:
+                lines.append(str(value))
+
+        return lines
+
+    def _write_block(
+        self, log: RichLog, title: str, data: object, style: str = "white"
+    ) -> None:
+        """Pretty-print a block with flattened dot-notation paths."""
+        log.write(f"[bold {style}]{title.upper()}:[/bold {style}]")
+        log.write("[dim]" + "=" * 50 + "[/dim]")
+
+        for line in self._flatten_values(data):
+            log.write(line)
+
+        log.write("")
+
     def _show_run_details(self, run: ExecutionRun):
         """Display detailed information about the run in the Details tab."""
+        self._update_resume_tab(run)
+
         run_details_log = self.query_one("#run-details-log", RichLog)
         run_details_log.clear()
 
@@ -191,39 +259,16 @@ class RunDetailsPanel(Container):
 
         run_details_log.write("")
 
-        # Input section
-        if hasattr(run, "input_data") and run.input_data is not None:
-            run_details_log.write("[bold green]INPUT:[/bold green]")
-            run_details_log.write("[dim]" + "=" * 50 + "[/dim]")
-
-            # Handle different input types
-            if isinstance(run.input_data, str):
-                run_details_log.write(run.input_data)
-            elif isinstance(run.input_data, dict):
-                import json
+        if hasattr(run, "input_data"):
+            self._write_block(run_details_log, "Input", run.input_data, style="green")
 
-                run_details_log.write(json.dumps(run.input_data, indent=2))
-            else:
-                run_details_log.write(str(run.input_data))
+        if hasattr(run, "resume_data") and run.resume_data:
+            self._write_block(run_details_log, "Resume", run.resume_data, style="green")
 
-            run_details_log.write("")
-
-        # Output section
-        if hasattr(run, "output_data") and run.output_data is not None:
-            run_details_log.write("[bold magenta]OUTPUT:[/bold magenta]")
-            run_details_log.write("[dim]" + "=" * 50 + "[/dim]")
-
-            # Handle different output types
-            if isinstance(run.output_data, str):
-                run_details_log.write(run.output_data)
-            elif isinstance(run.output_data, dict):
-                import json
-
-                run_details_log.write(json.dumps(run.output_data, indent=2))
-            else:
-                run_details_log.write(str(run.output_data))
-
-            run_details_log.write("")
+        if hasattr(run, "output_data"):
+            self._write_block(
+                run_details_log, "Output", run.output_data, style="magenta"
+            )
 
         # Error section (if applicable)
         if hasattr(run, "error") and run.error:
@@ -235,25 +280,6 @@ class RunDetailsPanel(Container):
             run_details_log.write(f"[red]\n{run.error.detail}[/red]")
             run_details_log.write("")
 
-        # Additional metadata
-        run_details_log.write("[bold]METADATA:[/bold]")
-        run_details_log.write("[dim]" + "=" * 50 + "[/dim]")
-
-        # Show available attributes
-        for attr in ["id", "status", "start_time", "end_time", "duration_ms"]:
-            if hasattr(run, attr):
-                value = getattr(run, attr)
-                if value is not None:
-                    run_details_log.write(f"  {attr}: {value}")
-
-        # Show traces count
-        traces_count = len(run.traces) if run.traces else 0
-        run_details_log.write(f"  traces_count: {traces_count}")
-
-        # Show logs count
-        logs_count = len(run.logs) if run.logs else 0
-        run_details_log.write(f"  logs_count: {logs_count}")
-
     def _rebuild_spans_tree(self):
         """Rebuild the spans tree from current run's traces."""
         spans_tree = self.query_one("#spans-tree", Tree)

{uipath-2.1.31 → uipath-2.1.33}/src/uipath/_cli/_dev/_terminal/_components/_history.py

@@ -2,7 +2,14 @@ from typing import List, Optional
 
 from textual.app import ComposeResult
 from textual.containers import Container, Vertical
-from textual.widgets import Button, ListItem, ListView, Static
+from textual.widgets import (
+    Button,
+    ListItem,
+    ListView,
+    Static,
+    TabbedContent,
+    TabPane,
+)
 
 from .._models._execution import ExecutionRun
 
@@ -16,11 +23,16 @@ class RunHistoryPanel(Container):
         self.selected_run: Optional[ExecutionRun] = None
 
     def compose(self) -> ComposeResult:
-        with Vertical():
-            yield ListView(id="run-list", classes="run-list")
-            yield Button(
-                "+ New Run", id="new-run-btn", variant="primary", classes="new-run-btn"
-            )
+        with TabbedContent():
+            with TabPane("History", id="history-tab"):
+                with Vertical():
+                    yield ListView(id="run-list", classes="run-list")
+                    yield Button(
+                        "+ New",
+                        id="new-run-btn",
+                        variant="primary",
+                        classes="new-run-btn",
+                    )
 
     def add_run(self, run: ExecutionRun):
         """Add a new run to history."""

uipath-2.1.33/src/uipath/_cli/_dev/_terminal/_components/_json_input.py

@@ -0,0 +1,23 @@
+import json
+
+from textual.widgets import TextArea
+
+
+class JsonInput(TextArea):
+    """TextArea that validates JSON on change."""
+
+    def validate_json(self) -> bool:
+        text = self.text.strip()
+        if not text:
+            self.remove_class("invalid")
+            return True
+        try:
+            json.loads(text)
+            self.remove_class("invalid")
+            return True
+        except json.JSONDecodeError:
+            self.add_class("invalid")
+            return False
+
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        self.validate_json()

{uipath-2.1.31 → uipath-2.1.33}/src/uipath/_cli/_dev/_terminal/_components/_new.py

@@ -5,7 +5,9 @@ from typing import Any, Dict, Tuple, cast
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal, Vertical
 from textual.reactive import reactive
-from textual.widgets import Button, Select, TextArea
+from textual.widgets import Button, Select, TabbedContent, TabPane, TextArea
+
+from ._json_input import JsonInput
 
 
 def mock_json_from_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
@@ -63,32 +65,31 @@ class NewRunPanel(Container):
         )
 
     def compose(self) -> ComposeResult:
-        with Vertical():
-            options = [(path, path) for path in self.entrypoint_paths]
-            yield Select(
-                options,
-                id="entrypoint-select",
-                value=self.selected_entrypoint,
-                allow_blank=False,
-            )
-
-            yield TextArea(
-                text=self.initial_input,
-                language="json",
-                id="json-input",
-                classes="input-field json-input",
-            )
-
-            with Horizontal(classes="run-actions"):
-                yield Button(
-                    "▶ Run", id="execute-btn", variant="primary", classes="action-btn"
-                )
-                yield Button(
-                    "Cancel",
-                    id="cancel-btn",
-                    variant="default",
-                    classes="action-btn cancel-btn",
-                )
+        with TabbedContent():
+            with TabPane("New run", id="new-tab"):
+                with Vertical():
+                    options = [(path, path) for path in self.entrypoint_paths]
+                    yield Select(
+                        options,
+                        id="entrypoint-select",
+                        value=self.selected_entrypoint,
+                        allow_blank=False,
+                    )
+
+                    yield JsonInput(
+                        text=self.initial_input,
+                        language="json",
+                        id="json-input",
+                        classes="input-field json-input",
+                    )
+
+                    with Horizontal(classes="run-actions"):
+                        yield Button(
+                            "▶ Run",
+                            id="execute-btn",
+                            variant="primary",
+                            classes="action-btn",
+                        )
 
     async def on_select_changed(self, event: Select.Changed) -> None:
         """Update JSON input when user selects an entrypoint."""

uipath-2.1.33/src/uipath/_cli/_dev/_terminal/_components/_resume.py

@@ -0,0 +1,35 @@
+import json
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import Button, TextArea
+
+from ._json_input import JsonInput
+
+
+class ResumePanel(Container):
+    """Panel for resuming a suspended run."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield JsonInput(
+                text=json.dumps({"value": ""}, indent=2),
+                language="json",
+                id="resume-json-input",
+                classes="input-field json-input",
+            )
+            with Horizontal(classes="run-actions"):
+                yield Button(
+                    "▶ Resume",
+                    id="resume-btn",
+                    variant="primary",
+                    classes="action-btn",
+                )
+
+    def get_input_values(self) -> str:
+        """Return the JSON text to resume with."""
+        json_input = self.query_one("#resume-json-input", TextArea)
+        return json_input.text.strip()

{uipath-2.1.31 → uipath-2.1.33}/src/uipath/_cli/_dev/_terminal/_models/_execution.py

@@ -1,8 +1,10 @@
 import os
 from datetime import datetime
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 from uuid import uuid4
 
+from rich.text import Text
+
 from ...._runtime._contracts import UiPathErrorContract
 from ._messages import LogMessage, TraceMessage
 
@@ -10,11 +12,12 @@ from ._messages import LogMessage, TraceMessage
 class ExecutionRun:
     """Represents a single execution run."""
 
-    def __init__(self, entrypoint: str, input_data: str):
+    def __init__(self, entrypoint: str, input_data: Dict[str, Any]):
         self.id = str(uuid4())[:8]
         self.entrypoint = entrypoint
         self.input_data = input_data
-        self.output_data: Optional[str] = None
+        self.resume_data: Optional[Dict[str, Any]] = None
+        self.output_data: Optional[Dict[str, Any]] = None
         self.start_time = datetime.now()
         self.end_time: Optional[datetime] = None
         self.status = "running"  # running, completed, failed
@@ -32,14 +35,32 @@ class ExecutionRun:
             return f"{delta.total_seconds():.1f}s"
 
     @property
-    def display_name(self) -> str:
-        status_icon = {"running": "⚙️", "completed": "✅", "failed": "❌"}.get(
-            self.status, "❓"
-        )
+    def display_name(self) -> Text:
+        status_colors = {
+            "running": "yellow",
+            "suspended": "cyan",
+            "completed": "green",
+            "failed": "red",
+        }
+
+        status_icon = {
+            "running": "▶",
+            "suspended": "⏸",
+            "completed": "✔",
+            "failed": "✖",
+        }.get(self.status, "?")
 
         script_name = (
             os.path.basename(self.entrypoint) if self.entrypoint else "untitled"
         )
+        truncated_script = script_name[:10]
         time_str = self.start_time.strftime("%H:%M:%S")
+        duration_str = self.duration[:6]
+
+        text = Text()
+        text.append(f"{status_icon:<2} ", style=status_colors.get(self.status, "white"))
+        text.append(f"{truncated_script:<10} ")
+        text.append(f"({time_str:<8}) ")
+        text.append(f"[{duration_str:<6}]")
 
-        return f"{status_icon} {script_name} ({time_str}) [{self.duration}]"
+        return text