uipath 2.1.73__py3-none-any.whl → 2.1.75__py3-none-any.whl

uipath/_cli/_evals/_console_progress_reporter.py

@@ -0,0 +1,241 @@
+"""Console progress reporter for evaluation runs with line-by-line output."""
+
+import logging
+from typing import Any, Dict
+
+from rich.console import Console
+from rich.rule import Rule
+from rich.table import Table
+
+from uipath._events._event_bus import EventBus
+from uipath._events._events import (
+    EvalRunCreatedEvent,
+    EvalRunUpdatedEvent,
+    EvalSetRunCreatedEvent,
+    EvalSetRunUpdatedEvent,
+    EvaluationEvents,
+)
+from uipath.eval.evaluators import BaseEvaluator
+from uipath.eval.models import ScoreType
+
+logger = logging.getLogger(__name__)
+
+
+class ConsoleProgressReporter:
+    """Handles displaying evaluation progress to the console with line-by-line output."""
+
+    def __init__(self):
+        self.console = Console()
+        self.evaluators: Dict[str, BaseEvaluator[Any]] = {}
+        self.display_started = False
+        self.eval_results_by_name: Dict[str, list[Any]] = {}
+
+    def _convert_score_to_numeric(self, eval_result) -> float:
+        """Convert evaluation result score to numeric value."""
+        score_value = eval_result.result.score
+        if eval_result.result.score_type == ScoreType.BOOLEAN:
+            score_value = 100 if score_value else 0
+        return score_value
+
+    def _get_evaluator_name(self, evaluator_id: str) -> str:
+        """Get evaluator name from ID, with fallback."""
+        return self.evaluators.get(
+            evaluator_id,
+            type(
+                "obj",
+                (object,),
+                {"name": f"Evaluator {evaluator_id[:8]}"},
+            )(),
+        ).name
+
+    def _display_successful_evaluation(self, eval_name: str, eval_results) -> None:
+        """Display results for a successful evaluation."""
+        from rich.text import Text
+
+        if eval_results:
+            result = Text()
+            result.append("▌", style="bold green")
+            result.append(" ", style="")
+            result.append(eval_name, style="bold green")
+            self.console.print(result)
+            table = Table(show_header=False, box=None, padding=(0, 2, 0, 2))
+
+            for eval_result in eval_results:
+                evaluator_name = self._get_evaluator_name(eval_result.evaluator_id)
+                score_value = self._convert_score_to_numeric(eval_result)
+                table.add_row(
+                    f"{evaluator_name}", f"[bold cyan]{score_value:.1f}[/bold cyan]"
+                )
+
+            self.console.print(table)
+        else:
+            result = Text()
+            result.append("  ✓ ", style="bold green")
+            result.append(eval_name, style="bold white")
+            result.append(" - No evaluators", style="dim")
+            self.console.print(result)
+
+    def _extract_error_message(self, eval_item_payload) -> str:
+        """Extract clean error message from evaluation item."""
+        if hasattr(eval_item_payload, "_error_message"):
+            error_message = getattr(eval_item_payload, "_error_message", None)
+            if error_message:
+                return str(error_message) or "Execution failed"
+        return "Execution failed"
+
+    def _display_failed_evaluation(self, eval_name: str, error_msg: str) -> None:
+        """Display results for a failed evaluation."""
+        from rich.text import Text
+
+        result = Text()
+        result.append("  ✗ ", style="bold red")
+        result.append(eval_name, style="bold white")
+        self.console.print(result)
+
+        error_text = Text()
+        error_text.append("    ", style="")
+        error_text.append(error_msg, style="red")
+        self.console.print(error_text)
+
+    def start_display(self):
+        """Start the display."""
+        if not self.display_started:
+            self.console.print()
+            self.console.print("→ [bold]Running Evaluations[/bold]")
+            self.console.print()
+            self.display_started = True
+
+    async def handle_create_eval_set_run(self, payload: EvalSetRunCreatedEvent) -> None:
+        """Handle evaluation set run creation."""
+        try:
+            self.evaluators = {eval.id: eval for eval in payload.evaluators}
+        except Exception as e:
+            logger.error(f"Failed to handle create eval set run event: {e}")
+
+    async def handle_create_eval_run(self, payload: EvalRunCreatedEvent) -> None:
+        """Handle individual evaluation run creation."""
+        try:
+            if not self.display_started:
+                self.start_display()
+
+            self.console.print(f"  ○ [dim]{payload.eval_item.name}[/dim] - Running...")
+        except Exception as e:
+            logger.error(f"Failed to handle create eval run event: {e}")
+
+    async def handle_update_eval_run(self, payload: EvalRunUpdatedEvent) -> None:
+        """Handle evaluation run updates."""
+        try:
+            if payload.success:
+                # Store results for final display
+                self.eval_results_by_name[payload.eval_item.name] = payload.eval_results
+                self._display_successful_evaluation(
+                    payload.eval_item.name, payload.eval_results
+                )
+            else:
+                error_msg = self._extract_error_message(payload.eval_item)
+                self._display_failed_evaluation(payload.eval_item.name, error_msg)
+
+            logs = payload.logs
+
+            self.console.print(
+                Rule(
+                    f"[dim italic]Execution Logs: {payload.eval_item.name}[/dim italic]",
+                    style="dim",
+                    align="center",
+                )
+            )
+
+            if len(logs) > 0:
+                for record in logs:
+                    log_line = f"  [dim]{record.getMessage()}[/dim]"
+                    self.console.print(log_line)
+            else:
+                self.console.print("  [dim italic]No execution logs[/dim italic]")
+
+            self.console.print(Rule(style="dim"))
+        except Exception as e:
+            logger.error(f"Console reporter error: {e}")
+
+    async def handle_update_eval_set_run(self, payload: EvalSetRunUpdatedEvent) -> None:
+        """Handle evaluation set run completion."""
+        try:
+            self.final_results = payload.evaluator_scores
+            self.display_final_results()
+        except Exception as e:
+            logger.error(f"Console reporter error: {e}")
+
+    def display_final_results(self):
+        """Display final results summary."""
+        self.console.print()
+
+        if hasattr(self, "final_results") and self.final_results:
+            from rich.table import Table
+
+            # Group evaluators by ID to organize display
+            evaluator_ids = list(self.final_results.keys())
+
+            # Print title
+            self.console.print("[bold]Evaluation Results[/bold]")
+            self.console.print()
+
+            # Create single summary table
+            summary_table = Table(show_header=True, padding=(0, 2))
+            summary_table.add_column("Evaluation", style="cyan")
+
+            # Add column for each evaluator
+            for evaluator_id in evaluator_ids:
+                evaluator_name = self._get_evaluator_name(evaluator_id)
+                summary_table.add_column(evaluator_name, justify="right")
+
+            # Add row for each evaluation
+            for eval_name, eval_results in self.eval_results_by_name.items():
+                row_values = [eval_name]
+
+                # Get score for each evaluator
+                for evaluator_id in evaluator_ids:
+                    score_found = False
+                    for eval_result in eval_results:
+                        if eval_result.evaluator_id == evaluator_id:
+                            score_value = self._convert_score_to_numeric(eval_result)
+                            row_values.append(f"{score_value:.1f}")
+                            score_found = True
+                            break
+
+                    if not score_found:
+                        row_values.append("-")
+
+                summary_table.add_row(*row_values)
+
+            # Add separator row before average
+            summary_table.add_section()
+
+            # Add average row
+            avg_row_values = ["[bold]Average[/bold]"]
+            for evaluator_id in evaluator_ids:
+                avg_score = self.final_results[evaluator_id]
+                avg_row_values.append(f"[bold]{avg_score:.1f}[/bold]")
+
+            summary_table.add_row(*avg_row_values)
+
+            self.console.print(summary_table)
+            self.console.print()
+        else:
+            self.console.print(
+                "→ [bold green]All evaluations completed successfully![/bold green]"
+            )
+            self.console.print()
+
+    async def subscribe_to_eval_runtime_events(self, event_bus: EventBus) -> None:
+        """Subscribe to evaluation runtime events."""
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_SET_RUN, self.handle_create_eval_set_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_RUN, self.handle_create_eval_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_RUN, self.handle_update_eval_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_SET_RUN, self.handle_update_eval_set_run
+        )

uipath/_cli/_evals/_models/_output.py

@@ -1,3 +1,4 @@
+import logging
 from typing import List, Optional
 
 from opentelemetry.sdk.trace import ReadableSpan
@@ -15,6 +16,7 @@ class UiPathEvalRunExecutionOutput(BaseModel):
 
     execution_time: float
     spans: list[ReadableSpan]
+    logs: list[logging.LogRecord]
     result: UiPathRuntimeResult
 
 

uipath/_cli/_evals/_progress_reporter.py

@@ -7,6 +7,7 @@ import os
 from typing import Any, Dict, List
 
 from opentelemetry import trace
+from rich.console import Console
 
 from uipath import UiPath
 from uipath._cli._evals._models._evaluation_set import EvaluationItem, EvaluationStatus
@@ -68,6 +69,7 @@ class StudioWebProgressReporter:
 
         self._client = uipath.api_client
         self._console = console_logger
+        self._rich_console = Console()
         self._project_id = os.getenv("UIPATH_PROJECT_ID", None)
         if not self._project_id:
             logger.warning(
@@ -79,6 +81,10 @@ class StudioWebProgressReporter:
         self.evaluator_scores: Dict[str, List[float]] = {}
         self.eval_run_ids: Dict[str, str] = {}
 
+    def _format_error_message(self, error: Exception, context: str) -> None:
+        """Helper method to format and display error messages consistently."""
+        self._rich_console.print(f"    • \u26a0  [dim]{context}: {error}[/dim]")
+
     @gracefully_handle_errors
     async def create_eval_set_run(
         self,
@@ -182,7 +188,7 @@ class StudioWebProgressReporter:
             logger.debug(f"Created eval set run with ID: {eval_set_run_id}")
 
         except Exception as e:
-            logger.error(f"Failed to handle create eval set run event: {e}")
+            self._format_error_message(e, "StudioWeb create eval set run error")
 
     async def handle_create_eval_run(self, payload: EvalRunCreatedEvent) -> None:
         try:
@@ -197,7 +203,7 @@ class StudioWebProgressReporter:
                 logger.warning("Cannot create eval run: eval_set_run_id not available")
 
         except Exception as e:
-            logger.error(f"Failed to handle create eval run event: {e}")
+            self._format_error_message(e, "StudioWeb create eval run error")
 
     async def handle_update_eval_run(self, payload: EvalRunUpdatedEvent) -> None:
         try:
@@ -238,7 +244,7 @@ class StudioWebProgressReporter:
                 logger.debug(f"Updated eval run with ID: {eval_run_id}")
 
         except Exception as e:
-            logger.error(f"Failed to handle update eval run event: {e}")
+            self._format_error_message(e, "StudioWeb reporting error")
 
     async def handle_update_eval_set_run(self, payload: EvalSetRunUpdatedEvent) -> None:
         try:
@@ -254,7 +260,7 @@ class StudioWebProgressReporter:
                 )
 
         except Exception as e:
-            logger.error(f"Failed to handle update eval set run event: {e}")
+            self._format_error_message(e, "StudioWeb update eval set run error")
 
     async def subscribe_to_eval_runtime_events(self, event_bus: EventBus) -> None:
         event_bus.subscribe(
@@ -270,7 +276,7 @@ class StudioWebProgressReporter:
             EvaluationEvents.UPDATE_EVAL_SET_RUN, self.handle_update_eval_set_run
         )
 
-        logger.info("StudioWeb progress reporter subscribed to evaluation events")
+        logger.debug("StudioWeb progress reporter subscribed to evaluation events")
 
     def _extract_agent_snapshot(self, entrypoint: str) -> StudioWebAgentSnapshot:
         try:

uipath/_cli/_evals/_runtime.py

@@ -1,4 +1,6 @@
 import json
+import logging
+import uuid
 from collections import defaultdict
 from pathlib import Path
 from time import time
@@ -25,6 +27,7 @@ from .._runtime._contracts import (
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
 )
+from .._runtime._logging import ExecutionLogHandler
 from .._utils._eval_set import EvalHelpers
 from ._evaluator_factory import EvaluatorFactory
 from ._models._evaluation_set import EvaluationItem, EvaluationSet
@@ -72,6 +75,33 @@ class ExecutionSpanExporter(SpanExporter):
         self.clear()
 
 
+class ExecutionLogsExporter:
+    """Custom exporter that stores multiple execution log handlers."""
+
+    def __init__(self):
+        self._log_handlers: dict[str, ExecutionLogHandler] = {}
+
+    def register(self, execution_id: str, handler: ExecutionLogHandler) -> None:
+        self._log_handlers[execution_id] = handler
+
+    def get_logs(self, execution_id: str) -> list[logging.LogRecord]:
+        """Clear stored spans for one or all executions."""
+        log_handler = self._log_handlers.get(execution_id)
+        return log_handler.buffer if log_handler else []
+
+    def clear(self, execution_id: Optional[str] = None) -> None:
+        """Clear stored spans for one or all executions."""
+        if execution_id:
+            self._log_handlers.pop(execution_id, None)
+        else:
+            self._log_handlers.clear()
+
+    def flush_logs(self, execution_id: str, target_handler: logging.Handler) -> None:
+        log_handler = self._log_handlers.get(execution_id)
+        if log_handler:
+            log_handler.flush_execution_logs(target_handler)
+
+
 class UiPathEvalContext(UiPathRuntimeContext):
     """Context used for evaluation runs."""
 
@@ -96,6 +126,8 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         self.event_bus: EventBus = event_bus
         self.span_exporter: ExecutionSpanExporter = ExecutionSpanExporter()
         self.factory.add_span_exporter(self.span_exporter)
+        self.logs_exporter: ExecutionLogsExporter = ExecutionLogsExporter()
+        self.execution_id = str(uuid.uuid4())
 
     @classmethod
     def from_eval_context(
@@ -110,9 +142,6 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         if self.context.eval_set is None:
             raise ValueError("eval_set must be provided for evaluation runs")
 
-        if not self.context.execution_id:
-            raise ValueError("execution_id must be provided for evaluation runs")
-
         event_bus = self.event_bus
 
         evaluation_set = EvalHelpers.load_eval_set(
@@ -126,7 +155,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         await event_bus.publish(
             EvaluationEvents.CREATE_EVAL_SET_RUN,
             EvalSetRunCreatedEvent(
-                execution_id=self.context.execution_id,
+                execution_id=self.execution_id,
                 entrypoint=self.context.entrypoint or "",
                 eval_set_id=evaluation_set.id,
                 no_of_evals=len(evaluation_set.evaluations),
@@ -142,7 +171,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
             await event_bus.publish(
                 EvaluationEvents.CREATE_EVAL_RUN,
                 EvalRunCreatedEvent(
-                    execution_id=self.context.execution_id,
+                    execution_id=self.execution_id,
                     eval_item=eval_item,
                 ),
             )
@@ -153,60 +182,87 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
 
             results.evaluation_set_results.append(evaluation_run_results)
 
-            agent_execution_output = await self.execute_runtime(eval_item)
-            evaluation_item_results: list[EvalItemResult] = []
-
-            for evaluator in evaluators:
-                evaluation_result = await self.run_evaluator(
-                    evaluator=evaluator,
-                    execution_output=agent_execution_output,
-                    eval_item=eval_item,
-                )
+            try:
+                agent_execution_output = await self.execute_runtime(eval_item)
+                evaluation_item_results: list[EvalItemResult] = []
+
+                for evaluator in evaluators:
+                    evaluation_result = await self.run_evaluator(
+                        evaluator=evaluator,
+                        execution_output=agent_execution_output,
+                        eval_item=eval_item,
+                    )
 
-                dto_result = EvaluationResultDto.from_evaluation_result(
-                    evaluation_result
-                )
-                evaluator_counts[evaluator.id] += 1
-                count = evaluator_counts[evaluator.id]
-                evaluator_averages[evaluator.id] += (
-                    dto_result.score - evaluator_averages[evaluator.id]
-                ) / count
-
-                evaluation_run_results.evaluation_run_results.append(
-                    EvaluationRunResultDto(
-                        evaluator_name=evaluator.name,
-                        result=dto_result,
+                    dto_result = EvaluationResultDto.from_evaluation_result(
+                        evaluation_result
                     )
-                )
-                evaluation_item_results.append(
-                    EvalItemResult(
-                        evaluator_id=evaluator.id,
-                        result=evaluation_result,
+                    evaluator_counts[evaluator.id] += 1
+                    count = evaluator_counts[evaluator.id]
+                    evaluator_averages[evaluator.id] += (
+                        dto_result.score - evaluator_averages[evaluator.id]
+                    ) / count
+
+                    evaluation_run_results.evaluation_run_results.append(
+                        EvaluationRunResultDto(
+                            evaluator_name=evaluator.name,
+                            result=dto_result,
+                        )
+                    )
+                    evaluation_item_results.append(
+                        EvalItemResult(
+                            evaluator_id=evaluator.id,
+                            result=evaluation_result,
+                        )
                     )
-                )
-
-            evaluation_run_results.compute_average_score()
 
-            await event_bus.publish(
-                EvaluationEvents.UPDATE_EVAL_RUN,
-                EvalRunUpdatedEvent(
-                    execution_id=self.context.execution_id,
-                    eval_item=eval_item,
-                    eval_results=evaluation_item_results,
-                    success=not agent_execution_output.result.error,
-                    agent_output=agent_execution_output.result.output,
-                    agent_execution_time=agent_execution_output.execution_time,
-                    spans=agent_execution_output.spans,
-                ),
-                wait_for_completion=False,
-            )
+                evaluation_run_results.compute_average_score()
+
+                await event_bus.publish(
+                    EvaluationEvents.UPDATE_EVAL_RUN,
+                    EvalRunUpdatedEvent(
+                        execution_id=self.execution_id,
+                        eval_item=eval_item,
+                        eval_results=evaluation_item_results,
+                        success=not agent_execution_output.result.error,
+                        agent_output=agent_execution_output.result.output,
+                        agent_execution_time=agent_execution_output.execution_time,
+                        spans=agent_execution_output.spans,
+                        logs=agent_execution_output.logs,
+                    ),
+                    wait_for_completion=False,
+                )
+            except Exception as e:
+                error_msg = str(e)
+                eval_item._error_message = error_msg  # type: ignore[attr-defined]
+
+                for evaluator in evaluators:
+                    evaluator_counts[evaluator.id] += 1
+                    count = evaluator_counts[evaluator.id]
+                    evaluator_averages[evaluator.id] += (
+                        0.0 - evaluator_averages[evaluator.id]
+                    ) / count
+
+                await event_bus.publish(
+                    EvaluationEvents.UPDATE_EVAL_RUN,
+                    EvalRunUpdatedEvent(
+                        execution_id=self.execution_id,
+                        eval_item=eval_item,
+                        eval_results=[],
+                        success=False,
+                        agent_output={},
+                        agent_execution_time=0.0,
+                        spans=[],
+                        logs=[],
+                    ),
+                    wait_for_completion=False,
+                )
 
         results.compute_average_score()
 
         await event_bus.publish(
             EvaluationEvents.UPDATE_EVAL_SET_RUN,
             EvalSetRunUpdatedEvent(
-                execution_id=self.context.execution_id,
+                execution_id=self.execution_id,
                 evaluator_scores=evaluator_averages,
             ),
             wait_for_completion=False,
@@ -221,10 +277,12 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     async def execute_runtime(
         self, eval_item: EvaluationItem
     ) -> UiPathEvalRunExecutionOutput:
+        eval_item_id = eval_item.id
         runtime_context: C = self.factory.new_context(
-            execution_id=eval_item.id,
+            execution_id=eval_item_id,
             input_json=eval_item.inputs,
             is_eval_run=True,
+            log_handler=self._setup_execution_logging(eval_item_id),
         )
         attributes = {
             "evalId": eval_item.id,
@@ -247,15 +305,24 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         spans = self.span_exporter.get_spans(runtime_context.execution_id)
         self.span_exporter.clear(runtime_context.execution_id)
 
+        logs = self.logs_exporter.get_logs(runtime_context.execution_id)
+        self.logs_exporter.clear(runtime_context.execution_id)
+
         if result is None:
             raise ValueError("Execution result cannot be None for eval runs")
 
         return UiPathEvalRunExecutionOutput(
             execution_time=end_time - start_time,
             spans=spans,
+            logs=logs,
             result=result,
         )
 
+    def _setup_execution_logging(self, eval_item_id: str) -> ExecutionLogHandler:
+        execution_log_handler = ExecutionLogHandler(eval_item_id)
+        self.logs_exporter.register(eval_item_id, execution_log_handler)
+        return execution_log_handler
+
     async def run_evaluator(
         self,
         evaluator: BaseEvaluator[Any],

uipath/_cli/_runtime/_contracts.py

@@ -519,7 +519,8 @@ class UiPathBaseRuntime(ABC):
 
         await self.validate()
 
-        # Intercept all stdout/stderr/logs and write them to a file (runtime/evals), stdout (debug)
+        # Intercept all stdout/stderr/logs
+        # write to file (runtime) or stdout (debug)
         self.logs_interceptor = LogsInterceptor(
             min_level=self.context.logs_min_level,
             dir=self.context.runtime_dir,
@@ -649,7 +650,7 @@ class UiPathBaseRuntime(ABC):
             raise
         finally:
             # Restore original logging
-            if self.logs_interceptor:
+            if hasattr(self, "logs_interceptor"):
                 self.logs_interceptor.teardown()
 
             await self.cleanup()
@@ -698,6 +699,7 @@ class UiPathRuntimeFactory(Generic[T, C]):
         self.context_generator = context_generator
         self.tracer_provider: TracerProvider = TracerProvider()
         self.tracer_span_processors: List[SpanProcessor] = []
+        self.logs_exporter: Optional[Any] = None
         trace.set_tracer_provider(self.tracer_provider)
 
     def add_span_exporter(

uipath/_cli/_runtime/_logging.py

@@ -10,6 +10,35 @@ current_execution_id: ContextVar[Optional[str]] = ContextVar(
 )
 
 
+class ExecutionLogHandler(logging.Handler):
+    """Handler for an execution unit."""
+
+    def __init__(self, execution_id: str):
+        """Initialize the buffered handler."""
+        super().__init__()
+        self.execution_id: str = execution_id
+        self.buffer: list[logging.LogRecord] = []
+        self.setFormatter(logging.Formatter("[%(asctime)s][%(levelname)s] %(message)s"))
+
+    def emit(self, record: logging.LogRecord):
+        """Store log record in buffer grouped by execution_id."""
+        self.buffer.append(record)
+
+    def flush_execution_logs(self, target_handler: logging.Handler) -> None:
+        """Flush buffered logs to a target handler.
+
+        Args:
+            target_handler: The handler to write the logs to
+        """
+        for record in self.buffer:
+            target_handler.handle(record)
+        target_handler.flush()
+
+    def clear_execution(self) -> None:
+        """Clear buffered logs without writing them."""
+        self.buffer.clear()
+
+
 class PersistentLogsHandler(logging.FileHandler):
     """A simple log handler that always writes to a single file without rotation."""
 
@@ -50,6 +79,16 @@ class ExecutionContextFilter(logging.Filter):
         return False
 
 
+class MasterExecutionFilter(logging.Filter):
+    """Filter for master handler that blocks logs from any child execution."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Block logs that belong to a child execution context."""
+        ctx_execution_id = current_execution_id.get()
+        # Block if there's an active child execution context
+        return ctx_execution_id is None
+
+
 class LogsInterceptor:
     """Intercepts all logging and stdout/stderr, routing to either persistent log files or stdout based on whether it's running as a job or not."""
 
@@ -93,7 +132,9 @@ class LogsInterceptor:
         self.original_stderr = cast(TextIO, sys.stderr)
 
         self.log_handler: Union[
-            PersistentLogsHandler, logging.StreamHandler[TextIO], logging.Handler
+            PersistentLogsHandler,
+            logging.StreamHandler[TextIO],
+            logging.Handler,
         ]
 
         if log_handler:
@@ -116,9 +157,14 @@ class LogsInterceptor:
         self.log_handler.setLevel(self.numeric_min_level)
 
         # Add execution context filter if execution_id provided
+        self.execution_filter: Optional[logging.Filter] = None
         if execution_id:
             self.execution_filter = ExecutionContextFilter(execution_id)
             self.log_handler.addFilter(self.execution_filter)
+        else:
+            # Master execution: filter out child execution logs
+            self.execution_filter = MasterExecutionFilter()
+            self.log_handler.addFilter(self.execution_filter)
 
         self.logger = logging.getLogger("runtime")
         self.patched_loggers: set[str] = set()
@@ -146,17 +192,23 @@ class LogsInterceptor:
         self.root_logger.setLevel(self.numeric_min_level)
 
         if self.execution_id:
-            # Parallel execution mode: add our handler without removing others
+            # Child execution mode: add our handler without removing others
             if self.log_handler not in self.root_logger.handlers:
                 self.root_logger.addHandler(self.log_handler)
 
-            # Set up propagation for all existing loggers
+            # Keep propagation enabled so logs flow through filters
+            # Our ExecutionContextFilter will ensure only our logs get through our handler
             for logger_name in logging.root.manager.loggerDict:
                 logger = logging.getLogger(logger_name)
-                # Keep propagation enabled so logs flow to all handlers
+                # Keep propagation enabled for filtering to work
+                # logger.propagate remains True (default)
                 self.patched_loggers.add(logger_name)
+
+            # Child executions should redirect stdout/stderr to their own handler
+            # This ensures print statements are captured per execution
+            self._redirect_stdout_stderr()
         else:
-            # Single execution mode: remove all handlers and add only ours
+            # Master execution mode: remove all handlers and add only ours
             self._clean_all_handlers(self.root_logger)
 
             # Set up propagation for all existing loggers
@@ -166,8 +218,8 @@ class LogsInterceptor:
                 self._clean_all_handlers(logger)
                 self.patched_loggers.add(logger_name)
 
-        # Set up stdout/stderr redirection
-        self._redirect_stdout_stderr()
+            # Master redirects stdout/stderr
+            self._redirect_stdout_stderr()
 
     def _redirect_stdout_stderr(self) -> None:
         """Redirect stdout and stderr to the logging system."""
@@ -218,15 +270,20 @@ class LogsInterceptor:
         stdout_logger = logging.getLogger("stdout")
         stderr_logger = logging.getLogger("stderr")
 
-        stdout_logger.propagate = False
-        stderr_logger.propagate = False
-
         if self.execution_id:
+            # Child execution: add our handler to stdout/stderr loggers
+            stdout_logger.propagate = False
+            stderr_logger.propagate = False
+
             if self.log_handler not in stdout_logger.handlers:
                 stdout_logger.addHandler(self.log_handler)
             if self.log_handler not in stderr_logger.handlers:
                 stderr_logger.addHandler(self.log_handler)
         else:
+            # Master execution: clean and set up handlers
+            stdout_logger.propagate = False
+            stderr_logger.propagate = False
+
             self._clean_all_handlers(stdout_logger)
             self._clean_all_handlers(stderr_logger)
 
@@ -249,23 +306,22 @@ class LogsInterceptor:
             logging.disable(self.original_disable_level)
 
         # Remove our handler and filter
-        if self.execution_id:
-            if hasattr(self, "execution_filter"):
-                self.log_handler.removeFilter(self.execution_filter)
-            if self.log_handler in self.root_logger.handlers:
-                self.root_logger.removeHandler(self.log_handler)
-
-            # Remove from stdout/stderr loggers too
-            stdout_logger = logging.getLogger("stdout")
-            stderr_logger = logging.getLogger("stderr")
-            if self.log_handler in stdout_logger.handlers:
-                stdout_logger.removeHandler(self.log_handler)
-            if self.log_handler in stderr_logger.handlers:
-                stderr_logger.removeHandler(self.log_handler)
-        else:
-            if self.log_handler in self.root_logger.handlers:
-                self.root_logger.removeHandler(self.log_handler)
+        if self.execution_filter:
+            self.log_handler.removeFilter(self.execution_filter)
 
+        if self.log_handler in self.root_logger.handlers:
+            self.root_logger.removeHandler(self.log_handler)
+
+        # Remove from stdout/stderr loggers
+        stdout_logger = logging.getLogger("stdout")
+        stderr_logger = logging.getLogger("stderr")
+        if self.log_handler in stdout_logger.handlers:
+            stdout_logger.removeHandler(self.log_handler)
+        if self.log_handler in stderr_logger.handlers:
+            stderr_logger.removeHandler(self.log_handler)
+
+        if not self.execution_id:
+            # Master execution: restore everything
             for logger_name in self.patched_loggers:
                 logger = logging.getLogger(logger_name)
                 if self.log_handler in logger.handlers:
@@ -278,6 +334,7 @@ class LogsInterceptor:
 
         self.log_handler.close()
 
+        # Only restore streams if we redirected them
         if self.original_stdout and self.original_stderr:
             sys.stdout = self.original_stdout
             sys.stderr = self.original_stderr

uipath/_cli/cli_eval.py

@@ -2,11 +2,11 @@
 import ast
 import asyncio
 import os
-import uuid
 from typing import List, Optional
 
 import click
 
+from uipath._cli._evals._console_progress_reporter import ConsoleProgressReporter
 from uipath._cli._evals._progress_reporter import StudioWebProgressReporter
 from uipath._cli._evals._runtime import (
     UiPathEvalContext,
@@ -114,7 +114,6 @@ def eval(
         eval_context = UiPathEvalContext.with_defaults(
             execution_output_file=output_file,
             entrypoint=runtime_entrypoint,
-            execution_id=str(uuid.uuid4()),
         )
 
         eval_context.no_report = no_report
@@ -122,6 +121,9 @@ def eval(
         eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
         eval_context.eval_ids = eval_ids
 
+        console_reporter = ConsoleProgressReporter()
+        asyncio.run(console_reporter.subscribe_to_eval_runtime_events(event_bus))
+
         try:
             runtime_factory = UiPathRuntimeFactory(
                 UiPathScriptRuntime,
@@ -143,11 +145,9 @@ def eval(
             asyncio.run(execute())
         except Exception as e:
             console.error(
-                f"Error: Unexpected error occurred - {str(e)}", include_traceback=True
+                f"Error occurred: {e or 'Execution failed'}", include_traceback=True
             )
 
-    console.success("Evaluation completed successfully")
-
 
 if __name__ == "__main__":
     eval()

uipath/_cli/middlewares.py

@@ -121,20 +121,20 @@ class Middlewares:
                 ]
 
             if middlewares:
-                logger.info(f"Found {len(middlewares)} middleware plugins")
+                logger.debug(f"Found {len(middlewares)} middleware plugins")
 
                 for entry_point in middlewares:
                     try:
                         register_func = entry_point.load()
                         register_func()
-                        logger.info(f"Loaded middleware plugin: {entry_point.name}")
+                        logger.debug(f"Loaded middleware plugin: {entry_point.name}")
                     except Exception as e:
                         console.error(
                             f"Failed to load middleware plugin {entry_point.name}: {str(e)}",
                             include_traceback=True,
                         )
             else:
-                logger.info("No middleware plugins found")
+                logger.debug("No middleware plugins found")
 
         except Exception as e:
             logger.error(f"No middleware plugins loaded: {str(e)}")

uipath/_events/_events.py

@@ -1,4 +1,5 @@
 import enum
+import logging
 from typing import Any, List, Union
 
 from opentelemetry.sdk.trace import ReadableSpan
@@ -38,6 +39,7 @@ class EvalRunUpdatedEvent(BaseModel):
     agent_output: Any
     agent_execution_time: float
     spans: List[ReadableSpan]
+    logs: List[logging.LogRecord]
 
 
 class EvalSetRunUpdatedEvent(BaseModel):

{uipath-2.1.73.dist-info → uipath-2.1.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.73
+Version: 2.1.75
 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.73.dist-info → uipath-2.1.75.dist-info}/RECORD

@@ -9,7 +9,7 @@ uipath/_cli/__init__.py,sha256=2RUgXYd8uJaYjA67xWb0w4IZuBmZoY8G1ccNmEQk9oM,2343
 uipath/_cli/cli_auth.py,sha256=ZEA0Fwoo77Ez9ctpRAIq7sbAwj8F4OouAbMp1g1OvjM,2601
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
-uipath/_cli/cli_eval.py,sha256=DK7FBLrNiBVEZgNBarlgjO065hsmQYLas-1e7nfIjLk,4816
+uipath/_cli/cli_eval.py,sha256=yMXx56sk7IqVcpR3MIjjGGYcFaciKaZ4iIi8SY-Oixo,4918
 uipath/_cli/cli_init.py,sha256=Ac3-9tIH3rpikIX1ehWTo7InW5tjVNoz_w6fjvgLK4w,7052
 uipath/_cli/cli_invoke.py,sha256=m-te-EjhDpk_fhFDkt-yQFzmjEHGo5lQDGEQWxSXisQ,4395
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
@@ -18,7 +18,7 @@ uipath/_cli/cli_publish.py,sha256=DgyfcZjvfV05Ldy0Pk5y_Le_nT9JduEE_x-VpIc_Kq0,64
 uipath/_cli/cli_pull.py,sha256=PZ2hkfsfN-ElNa3FHjNetTux8XH03tDY5kWWqydQ2OY,6832
 uipath/_cli/cli_push.py,sha256=-j-gDIbT8GyU2SybLQqFl5L8KI9nu3CDijVtltDgX20,3132
 uipath/_cli/cli_run.py,sha256=1FKv20EjxrrP1I5rNSnL_HzbWtOAIMjB3M--4RPA_Yo,3709
-uipath/_cli/middlewares.py,sha256=GvMhDnx1BmA7rIe12s6Uqv1JdqNZhvraU0a91oqGag4,4976
+uipath/_cli/middlewares.py,sha256=0D9a-wphyetnH9T97F08o7-1OKWF1lMweFHHAR0xiOw,4979
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=22km0F1NFNXgyLbvtAx3ssiQlVGHroLdtDCWEqiCiMg,7106
 uipath/_cli/_auth/_auth_service.py,sha256=Thtp2wXZQAHqossPPXuP6sAEe4Px9xThhZutMECRrdU,6386
@@ -44,13 +44,14 @@ uipath/_cli/_dev/_terminal/_styles/terminal.tcss,sha256=ktVpKwXIXw2VZp8KIZD6fO9i
 uipath/_cli/_dev/_terminal/_utils/_chat.py,sha256=YUZxYVdmEManwHDuZsczJT1dWIYE1dVBgABlurwMFcE,8493
 uipath/_cli/_dev/_terminal/_utils/_exporter.py,sha256=oI6D_eMwrh_2aqDYUh4GrJg8VLGrLYhDahR-_o0uJns,4144
 uipath/_cli/_dev/_terminal/_utils/_logger.py,sha256=_ipTl_oAiMF9I7keGt2AAFAMz40DNLVMVkoiq-07UAU,2943
+uipath/_cli/_evals/_console_progress_reporter.py,sha256=lpQvppoejRKD4Xli15Q9dJIJJz9AckhVzuOv7rcPkcM,9230
 uipath/_cli/_evals/_evaluator_factory.py,sha256=Gycv94VtGOpMir_Gba-UoiAyrSRfbSfe8_pTfjzcA9Q,3875
-uipath/_cli/_evals/_progress_reporter.py,sha256=hpSt0CXpIoFJGsbqZkqmwyGO_TBNesbWKlvDJUEDxd8,16455
-uipath/_cli/_evals/_runtime.py,sha256=fo-wtUxZ9bvo1ftt_yu7o2oUBvrMqVNKCjaGH556-Vo,11506
+uipath/_cli/_evals/_progress_reporter.py,sha256=kX7rNSa-QCLXIzK-vb9Jjf-XLEtucdeiQPgPlSkpp2U,16778
+uipath/_cli/_evals/_runtime.py,sha256=z4wJceJcGT5psBOB87tLDCLkhHafSmtE1q0EU65wnaw,14407
 uipath/_cli/_evals/_models/_evaluation_set.py,sha256=XgPNLWciE4FgCYzZXV2kRYHzdtbc33FWSQmZQqVSdMk,4747
 uipath/_cli/_evals/_models/_evaluator.py,sha256=fuC3UOYwPD4d_wdynHeLSCzbu82golNAnnPnxC8Y4rk,3315
 uipath/_cli/_evals/_models/_evaluator_base_params.py,sha256=lTYKOV66tcjW85KHTyOdtF1p1VDaBNemrMAvH8bFIFc,382
-uipath/_cli/_evals/_models/_output.py,sha256=LjwMBGI78sDFa2Dl8b9ReXJmjig57pdLWpuiwChrRLo,3096
+uipath/_cli/_evals/_models/_output.py,sha256=DmwFXh1YdLiMXyXmyoZr_4hgrrv3oiHbrrtIWMqGfsg,3145
 uipath/_cli/_evals/_models/_sw_reporting.py,sha256=tSBLQFAdOIun8eP0vsqt56K6bmCZz_uMaWI3hskg_24,536
 uipath/_cli/_evals/_models/_trajectory_span.py,sha256=8ukM8sB9rvzBMHfC_gnexAC3xlp4uMDevKZrRzcgrm4,3637
 uipath/_cli/_evals/mocks/__init__.py,sha256=2WXwAy_oZw5bKp6L0HB13QygCJeftOB_Bget0AI6Gik,32
@@ -60,10 +61,10 @@ uipath/_cli/_evals/mocks/mocker_factory.py,sha256=V5QKSTtQxztTo4-fK1TyAaXw2Z3mHf
 uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=LtYT6lJM9vc3qtbSZJcUeCzDn4zarkBVj7In_EX7kYY,2087
 uipath/_cli/_evals/mocks/mocks.py,sha256=WqjWtHqKQXAsO1Wwom3Zcr1T09GQygwBWVp-EsxdW8o,4443
 uipath/_cli/_push/sw_file_handler.py,sha256=iE8Sk1Z-9hxmLFFj3j-k4kTK6TzNFP6hUCmxTudG6JQ,18251
-uipath/_cli/_runtime/_contracts.py,sha256=D57cq5V5CZ9p13n_vRDHRcwyJYQUcJLlAMbAOzIiBNI,28932
+uipath/_cli/_runtime/_contracts.py,sha256=E8Is7EQfAu7_hCbeZI68gmTxSxo4X7_U4vcSl7D3Syg,28988
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
-uipath/_cli/_runtime/_logging.py,sha256=iO0AG_tqUBp7aJZTK_ZgwV3fFvxbi9Rp1UOBn3F76lw,11684
+uipath/_cli/_runtime/_logging.py,sha256=jwBfsy0Hi4zkfPH-v9dQ7m5dcJeuE0j_OxdpI-DhHaw,13854
 uipath/_cli/_runtime/_runtime.py,sha256=gby9-avNNlEATEfSXtY8FfJ8nREsSCGA4wMgDlSXTDE,2297
 uipath/_cli/_runtime/_script_executor.py,sha256=PjbmEbyCMofGH2F85b8RFsxdV3Tqw0kVqdWOOk2ZLlI,9687
 uipath/_cli/_templates/.psmdcp.template,sha256=C7pBJPt98ovEljcBvGtEUGoWjjQhu9jls1bpYjeLOKA,611
@@ -86,7 +87,7 @@ uipath/_cli/_utils/_tracing.py,sha256=2igb03j3EHjF_A406UhtCKkPfudVfFPjUq5tXUEG4o
 uipath/_cli/_utils/_uv_helpers.py,sha256=6SvoLnZPoKIxW0sjMvD1-ENV_HOXDYzH34GjBqwT138,3450
 uipath/_events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_events/_event_bus.py,sha256=4-VzstyX69cr7wT1EY7ywp-Ndyz2CyemD3Wk_-QmRpo,5496
-uipath/_events/_events.py,sha256=FhSqbEW4lcBp_QWcDsMtF5XtUtQ8S3rts6uEtMDmGbA,1252
+uipath/_events/_events.py,sha256=rZAXze6F4M9MkoFv-Zcwmatfzq5JapyJoxKeeWuI_DY,1301
 uipath/_resources/AGENTS.md,sha256=YWhWuX9XIbyVhVT3PnPc4Of3_q6bsNJcuzYu3N8f_Ug,25850
 uipath/_services/__init__.py,sha256=eYZElMfYDQTQU6MMjIke5J-GGT9pzLD5QfbwLiTQkEE,1037
 uipath/_services/_base_service.py,sha256=x9-9jhPzn9Z16KRdFHhJNvV-FZHvTniMsDfxlS4Cutk,5782
@@ -165,8 +166,8 @@ uipath/tracing/_traced.py,sha256=yBIY05PCCrYyx50EIHZnwJaKNdHPNx-YTR1sHQl0a98,199
 uipath/tracing/_utils.py,sha256=qd7N56tg6VXQ9pREh61esBgUWLNA0ssKsE0QlwrRWFM,11974
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.73.dist-info/METADATA,sha256=JMXtiT-80R6YqDxcl-MdGOYRi8HDuqGSh1EpcEJ7o_Q,6593
-uipath-2.1.73.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.73.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.73.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.73.dist-info/RECORD,,
+uipath-2.1.75.dist-info/METADATA,sha256=lxr5-VGeCGyTy7OCmrvbR5NqTL0nsu3T7U5W1BxLEXI,6593
+uipath-2.1.75.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.75.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.75.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.75.dist-info/RECORD,,