uipath 2.1.69__tar.gz → 2.1.70__tar.gz

{uipath-2.1.69 → uipath-2.1.70}/PKG-INFO

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

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

@@ -37,7 +37,7 @@ from ._models._execution import ExecutionRun
 from ._models._messages import LogMessage, TraceMessage
 from ._utils._chat import RunContextChatHandler, build_user_message_event
 from ._utils._exporter import RunContextExporter
-from ._utils._logger import RunContextLogHandler
+from ._utils._logger import RunContextLogHandler, patch_textual_stderr
 
 
 class UiPathDevTerminal(App[Any]):
@@ -61,6 +61,8 @@ class UiPathDevTerminal(App[Any]):
         runtime_factory: UiPathRuntimeFactory[Any, Any],
         **kwargs,
     ):
+        self._stderr_write_fd: int = patch_textual_stderr(self._add_subprocess_log)
+
         super().__init__(**kwargs)
 
         self.initial_entrypoint: str = "main.py"
@@ -357,3 +359,15 @@ class UiPathDevTerminal(App[Any]):
         )
         log_msg = LogMessage(run.id, "ERROR", tb, timestamp)
         self._handle_log_message(log_msg)
+
+    def _add_subprocess_log(self, level: str, message: str) -> None:
+        """Handle a stderr line coming from subprocesses."""
+
+        def add_log() -> None:
+            details_panel = self.query_one("#details-panel", RunDetailsPanel)
+            run = getattr(details_panel, "current_run", None)
+            if run:
+                log_msg = LogMessage(run.id, level, message, datetime.now())
+                self._handle_log_message(log_msg)
+
+        self.call_from_thread(add_log)

uipath-2.1.70/src/uipath/_cli/_dev/_terminal/_utils/_logger.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import logging
+import os
+import re
+import threading
+from datetime import datetime
+from typing import Callable, Pattern
+
+from .._models._messages import LogMessage
+
+
+class RunContextLogHandler(logging.Handler):
+    """Custom log handler that sends logs to CLI UI."""
+
+    def __init__(
+        self,
+        run_id: str,
+        callback: Callable[[LogMessage], None],
+    ):
+        super().__init__()
+        self.run_id = run_id
+        self.callback = callback
+
+    def emit(self, record: logging.LogRecord):
+        """Emit a log record to CLI UI."""
+        try:
+            log_msg = LogMessage(
+                run_id=self.run_id,
+                level=record.levelname,
+                message=self.format(record),
+                timestamp=datetime.fromtimestamp(record.created),
+            )
+            self.callback(log_msg)
+        except Exception:
+            # Don't let logging errors crash the app
+            pass
+
+
+# A dispatcher is a callable that accepts (level, message) pairs
+DispatchLog = Callable[[str, str], None]
+
+LEVEL_PATTERNS: list[tuple[str, Pattern[str]]] = [
+    ("DEBUG", re.compile(r"^(DEBUG)[:\s-]+", re.I)),
+    ("INFO", re.compile(r"^(INFO)[:\s-]+", re.I)),
+    ("WARN", re.compile(r"^(WARNING|WARN)[:\s-]+", re.I)),
+    ("ERROR", re.compile(r"^(ERROR|ERRO)[:\s-]+", re.I)),
+]
+
+
+def patch_textual_stderr(dispatch_log: DispatchLog) -> int:
+    """Redirect subprocess stderr into a provided dispatcher.
+
+    Args:
+        dispatch_log: Callable invoked with (level, message) for each stderr line.
+                      This will be called from a background thread, so the caller
+                      should use `App.call_from_thread` or equivalent.
+
+    Returns:
+        int: The write file descriptor for stderr (pass to subprocesses).
+    """
+    from textual.app import _PrintCapture
+
+    read_fd, write_fd = os.pipe()
+
+    # Patch fileno() so subprocesses can write to our pipe
+    _PrintCapture.fileno = lambda self: write_fd  # type: ignore[method-assign]
+
+    def read_stderr_pipe() -> None:
+        with os.fdopen(read_fd, "r", buffering=1) as pipe_reader:
+            try:
+                for raw in pipe_reader:
+                    text = raw.rstrip()
+                    level: str = "ERROR"
+                    message: str = text
+
+                    # Try to parse a known level prefix
+                    for lvl, pattern in LEVEL_PATTERNS:
+                        m = pattern.match(text)
+                        if m:
+                            level = lvl
+                            message = text[m.end() :]
+                            break
+
+                    dispatch_log(level, message)
+
+            except Exception:
+                # Never raise from thread
+                pass
+
+    thread = threading.Thread(
+        target=read_stderr_pipe,
+        daemon=True,
+        name="stderr-reader",
+    )
+    thread.start()
+
+    return write_fd

{uipath-2.1.69 → uipath-2.1.70}/uv.lock

@@ -2092,7 +2092,7 @@ wheels = [
 
 [[package]]
 name = "uipath"
-version = "2.1.69"
+version = "2.1.70"
 source = { editable = "." }
 dependencies = [
     { name = "azure-monitor-opentelemetry" },

uipath-2.1.69/src/uipath/_cli/_dev/_terminal/_utils/_logger.py

@@ -1,32 +0,0 @@
-import logging
-from datetime import datetime
-from typing import Callable
-
-from .._models._messages import LogMessage
-
-
-class RunContextLogHandler(logging.Handler):
-    """Custom log handler that sends logs to CLI UI."""
-
-    def __init__(
-        self,
-        run_id: str,
-        callback: Callable[[LogMessage], None],
-    ):
-        super().__init__()
-        self.run_id = run_id
-        self.callback = callback
-
-    def emit(self, record: logging.LogRecord):
-        """Emit a log record to CLI UI."""
-        try:
-            log_msg = LogMessage(
-                run_id=self.run_id,
-                level=record.levelname,
-                message=self.format(record),
-                timestamp=datetime.fromtimestamp(record.created),
-            )
-            self.callback(log_msg)
-        except Exception:
-            # Don't let logging errors crash the app
-            pass