uipath 2.1.27__py3-none-any.whl → 2.1.29__py3-none-any.whl

uipath/_cli/_dev/_terminal/_traces/_exporter.py

@@ -0,0 +1,119 @@
+import logging
+from datetime import datetime
+from typing import Callable, Sequence
+
+from opentelemetry import trace
+from opentelemetry.sdk.trace import Event, ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.trace import StatusCode
+
+from .._models._messages import LogMessage, TraceMessage
+
+
+class RunContextExporter(SpanExporter):
+    """Custom trace exporter that sends traces and logs to CLI UI."""
+
+    def __init__(
+        self,
+        on_trace: Callable[[TraceMessage], None],
+        on_log: Callable[[LogMessage], None],
+    ):
+        self.on_trace = on_trace
+        self.on_log = on_log
+        self.logger = logging.getLogger(__name__)
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """Export spans to CLI UI."""
+        try:
+            for span in spans:
+                self._export_span(span)
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            self.logger.error(f"Failed to export spans: {e}")
+            return SpanExportResult.FAILURE
+
+    def _export_span(self, span: ReadableSpan):
+        """Export a single span to CLI UI."""
+        # Calculate duration
+        start_time = (
+            span.start_time / 1_000_000_000 if span.start_time is not None else 0
+        )
+        end_time = span.end_time / 1_000_000_000 if span.end_time is not None else None
+        duration_ms = (end_time - start_time) * 1000 if end_time else None
+
+        # Determine status
+        if span.status.status_code == StatusCode.ERROR:
+            status = "failed"
+        elif end_time:
+            status = "completed"
+        else:
+            status = "running"
+
+        # Extract span context information
+        span_context = span.get_span_context()
+
+        # Convert span IDs to string format (they're usually int64)
+        span_id = f"{span_context.span_id:016x}"  # 16-char hex string
+        trace_id = f"{span_context.trace_id:032x}"  # 32-char hex string
+
+        run_id = span.attributes.get("execution.id") if span.attributes else None
+        run_id_val = str(run_id) if run_id is not None else None
+
+        if run_id_val is None:
+            return
+
+        # Get parent span ID if available
+        parent_span_id = None
+        if hasattr(span, "parent") and span.parent:
+            parent_span_id = f"{span.parent.span_id:016x}"
+
+        # Create trace message with all required fields
+        trace_msg = TraceMessage(
+            run_id=run_id_val,
+            span_name=span.name,
+            span_id=span_id,
+            parent_span_id=parent_span_id,
+            trace_id=trace_id,
+            status=status,
+            duration_ms=duration_ms,
+            timestamp=datetime.fromtimestamp(start_time),
+            attributes=dict(span.attributes) if span.attributes else {},
+        )
+
+        # Send to UI
+        self.on_trace(trace_msg)
+
+        # Also send logs if there are events
+        if hasattr(span, "events") and span.events:
+            for event in span.events:
+                log_level = self._determine_log_level(event, span.status)
+                log_msg = LogMessage(
+                    run_id=run_id_val,
+                    level=log_level,
+                    message=event.name,
+                    timestamp=datetime.fromtimestamp(event.timestamp / 1_000_000_000),
+                )
+                self.on_log(log_msg)
+
+    def _determine_log_level(self, event: Event, span_status: trace.Status) -> str:
+        """Determine log level from span event."""
+        event_name = event.name.lower()
+
+        if span_status.status_code == StatusCode.ERROR:
+            return "ERROR"
+        elif "error" in event_name or "exception" in event_name:
+            return "ERROR"
+        elif "warn" in event_name:
+            return "WARNING"
+        elif "debug" in event_name:
+            return "DEBUG"
+        else:
+            return "INFO"
+
+    def shutdown(self) -> None:
+        """Shutdown the exporter."""
+        pass
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Force flush any pending spans."""
+        return True

uipath/_cli/_dev/_terminal/_traces/_logger.py

@@ -0,0 +1,32 @@
+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,
+        on_log: Callable[[LogMessage], None],
+    ):
+        super().__init__()
+        self.run_id = run_id
+        self.on_log = on_log
+
+    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.on_log(log_msg)
+        except Exception:
+            # Don't let logging errors crash the app
+            pass

uipath/_cli/_push/sw_file_handler.py

@@ -395,10 +395,8 @@ class SwFileHandler:
             return toml_data.get("authors", "").strip()
 
         try:
-            entrypoints = [
-                {"input": entrypoint["input"], "output": entrypoint["output"]}
-                for entrypoint in uipath_config["entryPoints"]
-            ]
+            input_schema = uipath_config["entryPoints"][0]["input"]
+            output_schema = uipath_config["entryPoints"][0]["output"]
         except (FileNotFoundError, KeyError) as e:
             self.console.error(
                 f"Unable to extract entrypoints from configuration file. Please run 'uipath init' : {str(e)}",
@@ -417,10 +415,12 @@ class SwFileHandler:
                 "author": author,
                 "pushDate": datetime.now(timezone.utc).isoformat(),
             },
-            "entryPoints": entrypoints,
+            "inputSchema": input_schema,
+            "outputSchema": output_schema,
             "bindings": uipath_config.get(
                 "bindings", {"version": "2.0", "resources": []}
             ),
+            "settings": {},
         }
 
         existing = root_files.get("agent.json")

uipath/_cli/_runtime/_contracts.py

@@ -8,10 +8,22 @@ import traceback
 from abc import ABC, abstractmethod
 from enum import Enum
 from functools import cached_property
-from typing import Any, Dict, Generic, Optional, Type, TypeVar, Union
-
+from typing import Any, Callable, Dict, Generic, List, Optional, Type, TypeVar, Union
+
+from opentelemetry import context as context_api
+from opentelemetry import trace
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor  # type: ignore
+from opentelemetry.sdk.trace import Span, SpanProcessor, TracerProvider
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+    SimpleSpanProcessor,
+    SpanExporter,
+)
+from opentelemetry.trace import Tracer
 from pydantic import BaseModel, Field
 
+from uipath.tracing import TracingManager
+
 from ._logging import LogsInterceptor
 
 logger = logging.getLogger(__name__)
@@ -144,6 +156,7 @@ class UiPathRuntimeContext(BaseModel):
     input: Optional[str] = None
     input_json: Optional[Any] = None
     job_id: Optional[str] = None
+    execution_id: Optional[str] = None
     trace_id: Optional[str] = None
     trace_context: Optional[UiPathTraceContext] = None
     tracing_enabled: Union[bool, str] = False
@@ -159,7 +172,7 @@ class UiPathRuntimeContext(BaseModel):
     execution_output_file: Optional[str] = None
     input_file: Optional[str] = None
     is_eval_run: bool = False
-
+    log_handler: Optional[logging.Handler] = None
     model_config = {"arbitrary_types_allowed": True}
 
     @classmethod
@@ -328,6 +341,7 @@ class UiPathBaseRuntime(ABC):
             file=self.context.logs_file,
             job_id=self.context.job_id,
             is_debug_run=self.is_debug_run(),
+            log_handler=self.context.log_handler,
         )
         self.logs_interceptor.setup()
 
@@ -487,6 +501,34 @@ class UiPathRuntimeFactory(Generic[T, C]):
 
         self.runtime_class = runtime_class
         self.context_class = context_class
+        self.tracer_provider: TracerProvider = TracerProvider()
+        self.tracer_span_processors: List[SpanProcessor] = []
+        trace.set_tracer_provider(self.tracer_provider)
+
+    def add_span_exporter(
+        self,
+        span_exporter: SpanExporter,
+        batch: bool = True,
+    ) -> "UiPathRuntimeFactory[T, C]":
+        """Add a span processor to the tracer provider."""
+        span_processor: SpanProcessor
+        if batch:
+            span_processor = UiPathExecutionBatchTraceProcessor(span_exporter)
+        else:
+            span_processor = UiPathExecutionSimpleTraceProcessor(span_exporter)
+        self.tracer_span_processors.append(span_processor)
+        self.tracer_provider.add_span_processor(span_processor)
+        return self
+
+    def add_instrumentor(
+        self,
+        instrumentor_class: Type[BaseInstrumentor],
+        get_current_span_func: Callable[[], Optional[Span]],
+    ) -> "UiPathRuntimeFactory[T, C]":
+        """Add and instrument immediately."""
+        instrumentor_class().instrument(tracer_provider=self.tracer_provider)
+        TracingManager.register_current_span_provider(get_current_span_func)
+        return self
 
     def new_context(self, **kwargs) -> C:
         """Create a new context instance."""
@@ -499,4 +541,52 @@ class UiPathRuntimeFactory(Generic[T, C]):
     async def execute(self, context: C) -> Optional[UiPathRuntimeResult]:
         """Execute runtime with context."""
         async with self.from_context(context) as runtime:
-            return await runtime.execute()
+            result = await runtime.execute()
+            for span_processor in self.tracer_span_processors:
+                span_processor.force_flush()
+            return result
+
+    async def execute_in_root_span(
+        self, context: C, root_span: str = "root"
+    ) -> Optional[UiPathRuntimeResult]:
+        """Execute runtime with context."""
+        async with self.from_context(context) as runtime:
+            tracer: Tracer = trace.get_tracer("uipath-runtime")
+            with tracer.start_as_current_span(
+                root_span,
+                attributes={"execution.id": context.execution_id}
+                if context.execution_id
+                else {},
+            ):
+                result = await runtime.execute()
+            for span_processor in self.tracer_span_processors:
+                span_processor.force_flush()
+            return result
+
+
+class UiPathExecutionTraceProcessorMixin:
+    def on_start(
+        self, span: Span, parent_context: Optional[context_api.Context] = None
+    ):
+        """Called when a span is started."""
+        if parent_context:
+            parent_span = trace.get_current_span(parent_context)
+        else:
+            parent_span = trace.get_current_span()
+
+        if parent_span and parent_span.is_recording():
+            run_id = parent_span.attributes.get("execution.id")  # type: ignore[attr-defined]
+            if run_id:
+                span.set_attribute("execution.id", run_id)
+
+
+class UiPathExecutionBatchTraceProcessor(
+    UiPathExecutionTraceProcessorMixin, BatchSpanProcessor
+):
+    """Batch span processor that propagates execution.id."""
+
+
+class UiPathExecutionSimpleTraceProcessor(
+    UiPathExecutionTraceProcessorMixin, SimpleSpanProcessor
+):
+    """Simple span processor that propagates execution.id."""

uipath/_cli/_runtime/_logging.py

@@ -30,6 +30,7 @@ class LogsInterceptor:
         file: Optional[str] = "execution.log",
         job_id: Optional[str] = None,
         is_debug_run: bool = False,
+        log_handler: Optional[logging.Handler] = None,
     ):
         """Initialize the log interceptor.
 
@@ -39,6 +40,7 @@ class LogsInterceptor:
             file (str): The log file name.
             job_id (str, optional): If provided, logs go to file; otherwise, to stdout.
             is_debug_run (bool, optional): If True, log the output to stdout/stderr.
+            log_handler (logging.Handler, optional): Custom log handler to use.
         """
         min_level = min_level or "INFO"
         self.job_id = job_id
@@ -57,21 +59,26 @@ class LogsInterceptor:
         self.original_stdout = cast(TextIO, sys.stdout)
         self.original_stderr = cast(TextIO, sys.stderr)
 
-        self.log_handler: Union[PersistentLogsHandler, logging.StreamHandler[TextIO]]
+        self.log_handler: Union[
+            PersistentLogsHandler, logging.StreamHandler[TextIO], logging.Handler
+        ]
 
-        # Create either file handler (runtime) or stdout handler (debug)
-        if is_debug_run:
-            # Use stdout handler when not running as a job or eval
-            self.log_handler = logging.StreamHandler(sys.stdout)
-            formatter = logging.Formatter("%(message)s")
-            self.log_handler.setFormatter(formatter)
+        if log_handler:
+            self.log_handler = log_handler
         else:
-            # Ensure directory exists for file logging
-            dir = dir or "__uipath"
-            file = file or "execution.log"
-            os.makedirs(dir, exist_ok=True)
-            log_file = os.path.join(dir, file)
-            self.log_handler = PersistentLogsHandler(file=log_file)
+            # Create either file handler (runtime) or stdout handler (debug)
+            if is_debug_run:
+                # Use stdout handler when not running as a job or eval
+                self.log_handler = logging.StreamHandler(sys.stdout)
+                formatter = logging.Formatter("%(message)s")
+                self.log_handler.setFormatter(formatter)
+            else:
+                # Ensure directory exists for file logging
+                dir = dir or "__uipath"
+                file = file or "execution.log"
+                os.makedirs(dir, exist_ok=True)
+                log_file = os.path.join(dir, file)
+                self.log_handler = PersistentLogsHandler(file=log_file)
 
         self.log_handler.setLevel(self.numeric_min_level)
         self.logger = logging.getLogger("runtime")

uipath/_cli/_runtime/_runtime.py

@@ -8,13 +8,8 @@ import os
 from dataclasses import asdict, is_dataclass
 from typing import Any, Dict, Optional, Type, TypeVar, cast, get_type_hints
 
-from opentelemetry import trace
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from pydantic import BaseModel
 
-from uipath.tracing import LlmOpsHttpExporter
-
 from ._contracts import (
     UiPathBaseRuntime,
     UiPathErrorCategory,
@@ -43,11 +38,6 @@ class UiPathRuntime(UiPathBaseRuntime):
         await self.validate()
 
         try:
-            trace.set_tracer_provider(TracerProvider())
-            trace.get_tracer_provider().add_span_processor(  # type: ignore
-                BatchSpanProcessor(LlmOpsHttpExporter())
-            )
-
             if self.context.entrypoint is None:
                 return None
 
@@ -74,8 +64,6 @@ class UiPathRuntime(UiPathBaseRuntime):
                 f"Error: {str(e)}",
                 UiPathErrorCategory.SYSTEM,
             ) from e
-        finally:
-            trace.get_tracer_provider().shutdown()  # type: ignore
 
     async def validate(self) -> None:
         """Validate runtime inputs."""
@@ -223,7 +211,7 @@ class UiPathRuntime(UiPathBaseRuntime):
         # Handle Pydantic models
         try:
             if inspect.isclass(cls) and issubclass(cls, BaseModel):
-                return cast(T, cls.model_validate(data))
+                return cls.model_validate(data)
         except TypeError:
             # issubclass can raise TypeError if cls is not a class
             pass
@@ -247,7 +235,7 @@ class UiPathRuntime(UiPathBaseRuntime):
                     value = self._convert_to_class(value, typed_field)
                 converted_data[field_name] = value
 
-            return cast(T, cls(**converted_data))
+            return cls(**converted_data)
 
         # Handle regular classes
         else:

uipath/_cli/cli_dev.py

@@ -0,0 +1,44 @@
+import asyncio
+from typing import Optional
+
+import click
+
+from ..telemetry import track
+from ._dev._terminal import UiPathDevTerminal
+from ._runtime._contracts import UiPathRuntimeContext, UiPathRuntimeFactory
+from ._runtime._runtime import UiPathRuntime
+from ._utils._console import ConsoleLogger
+from .middlewares import Middlewares
+
+console = ConsoleLogger()
+
+
+@click.command()
+@click.argument("interface", default="terminal")
+@track
+def dev(interface: Optional[str]) -> None:
+    """Launch interactive debugging interface."""
+    console.info("🚀 Starting UiPath Dev Terminal...")
+    console.info("Use 'q' to quit, 'n' for new run, 'r' to execute")
+
+    result = Middlewares.next(
+        "dev",
+        interface,
+    )
+
+    if result.should_continue is False:
+        return
+
+    try:
+        if interface == "terminal":
+            runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
+            app = UiPathDevTerminal(runtime_factory)
+            asyncio.run(app.run_async())
+        else:
+            console.error(f"Unknown interface: {interface}")
+    except KeyboardInterrupt:
+        console.info("Debug session interrupted by user")
+    except Exception as e:
+        console.error(
+            f"Error running debug interface: {str(e)}", include_traceback=True
+        )

uipath/_cli/cli_run.py

@@ -10,6 +10,7 @@ import click
 from dotenv import load_dotenv
 
 from uipath._cli._utils._debug import setup_debugging
+from uipath.tracing import LlmOpsHttpExporter
 
 from .._utils.constants import (
     ENV_JOB_ID,
@@ -18,6 +19,7 @@ from ..telemetry import track
 from ._runtime._contracts import (
     UiPathRuntimeContext,
     UiPathRuntimeError,
+    UiPathRuntimeFactory,
     UiPathTraceContext,
 )
 from ._runtime._runtime import UiPathRuntime
@@ -61,39 +63,42 @@ Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path
         )
 
     try:
+        context = UiPathRuntimeContext.from_config(
+            env.get("UIPATH_CONFIG_PATH", "uipath.json"), **kwargs
+        )
+        context.entrypoint = entrypoint
+        context.input = input
+        context.resume = resume
+        context.job_id = env.get("UIPATH_JOB_KEY")
+        context.trace_id = env.get("UIPATH_TRACE_ID")
+        context.input_file = kwargs.get("input_file", None)
+        context.execution_output_file = kwargs.get("execution_output_file", None)
+        context.is_eval_run = kwargs.get("is_eval_run", False)
+        context.logs_min_level = env.get("LOG_LEVEL", "INFO")
+        context.tracing_enabled = env.get("UIPATH_TRACING_ENABLED", True)
+        context.trace_context = UiPathTraceContext(
+            trace_id=env.get("UIPATH_TRACE_ID"),
+            parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
+            root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),
+            enabled=env.get("UIPATH_TRACING_ENABLED", True),
+            job_id=env.get("UIPATH_JOB_KEY"),
+            org_id=env.get("UIPATH_ORGANIZATION_ID"),
+            tenant_id=env.get("UIPATH_TENANT_ID"),
+            process_key=env.get("UIPATH_PROCESS_UUID"),
+            folder_key=env.get("UIPATH_FOLDER_KEY"),
+            reference_id=env.get("UIPATH_JOB_KEY") or str(uuid4()),
+        )
+
+        runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
+
+        if context.job_id:
+            runtime_factory.add_span_exporter(LlmOpsHttpExporter())
 
         async def execute():
-            context = UiPathRuntimeContext.from_config(
-                env.get("UIPATH_CONFIG_PATH", "uipath.json"), **kwargs
-            )
-            context.entrypoint = entrypoint
-            context.input = input
-            context.resume = resume
-            context.job_id = env.get("UIPATH_JOB_KEY")
-            context.trace_id = env.get("UIPATH_TRACE_ID")
-            context.input_file = kwargs.get("input_file", None)
-            context.execution_output_file = kwargs.get("execution_output_file", None)
-            context.is_eval_run = kwargs.get("is_eval_run", False)
-            context.tracing_enabled = env.get("UIPATH_TRACING_ENABLED", True)
-            context.trace_context = UiPathTraceContext(
-                trace_id=env.get("UIPATH_TRACE_ID"),
-                parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
-                root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),
-                enabled=env.get("UIPATH_TRACING_ENABLED", True),
-                job_id=env.get("UIPATH_JOB_KEY"),
-                org_id=env.get("UIPATH_ORGANIZATION_ID"),
-                tenant_id=env.get("UIPATH_TENANT_ID"),
-                process_key=env.get("UIPATH_PROCESS_UUID"),
-                folder_key=env.get("UIPATH_FOLDER_KEY"),
-                reference_id=env.get("UIPATH_JOB_KEY") or str(uuid4()),
-            )
-            context.logs_min_level = env.get("LOG_LEVEL", "INFO")
-            async with UiPathRuntime.from_context(context) as runtime:
-                await runtime.execute()
+            await runtime_factory.execute(context)
 
         asyncio.run(execute())
 
-        # Return success
         return MiddlewareResult(should_continue=False)
 
     except UiPathRuntimeError as e:

uipath/_cli/middlewares.py

@@ -28,6 +28,7 @@ class Middlewares:
         "pack": [],
         "publish": [],
         "run": [],
+        "dev": [],
     }
     _plugins_loaded = False
 

uipath/telemetry/_track.py

@@ -58,7 +58,7 @@ def _get_project_key() -> str:
 
 class _AzureMonitorOpenTelemetryEventHandler(LoggingHandler):
     @staticmethod
-    def _get_attributes(record: LogRecord) -> Attributes:
+    def _get_attributes(record: LogRecord) -> Attributes:  # type: ignore[override]
         attributes = dict(LoggingHandler._get_attributes(record) or {})
         attributes[_APP_INSIGHTS_EVENT_MARKER_ATTRIBUTE] = True
         attributes[_CLOUD_TENANT_ID] = os.getenv(ENV_TENANT_ID, _UNKNOWN)
@@ -75,7 +75,7 @@ class _AzureMonitorOpenTelemetryEventHandler(LoggingHandler):
         if _CODE_LINENO in attributes:
             del attributes[_CODE_LINENO]
 
-        return attributes
+        return attributes  # type: ignore[return-value]
 
 
 class _TelemetryClient:

{uipath-2.1.27.dist-info → uipath-2.1.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.27
+Version: 2.1.29
 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
@@ -17,12 +17,14 @@ Requires-Python: >=3.10
 Requires-Dist: azure-monitor-opentelemetry>=1.6.8
 Requires-Dist: click>=8.1.8
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: opentelemetry-instrumentation>=0.52b1
 Requires-Dist: opentelemetry-sdk>=1.31.1
 Requires-Dist: pathlib>=1.0.1
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: rich>=13.0.0
 Requires-Dist: tenacity>=9.0.0
+Requires-Dist: textual>=5.3.0
 Requires-Dist: tomli>=2.2.1
 Requires-Dist: truststore>=0.10.1
 Description-Content-Type: text/markdown