uipath 2.1.43__py3-none-any.whl → 2.1.45__py3-none-any.whl

uipath/_cli/_evals/_runtime.py

@@ -1,4 +1,3 @@
-import copy
 from collections import defaultdict
 from time import time
 from typing import Dict, Generic, List, Optional, Sequence, TypeVar
@@ -6,8 +5,6 @@ from typing import Dict, Generic, List, Optional, Sequence, TypeVar
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
-from uipath.eval._helpers import auto_discover_entrypoint
-
 from .._runtime._contracts import (
     UiPathBaseRuntime,
     UiPathRuntimeContext,
@@ -54,58 +51,30 @@ class ExecutionSpanExporter(SpanExporter):
         self.clear()
 
 
-class UiPathEvalContext(UiPathRuntimeContext, Generic[C]):
+class UiPathEvalContext(UiPathRuntimeContext):
     """Context used for evaluation runs."""
 
-    runtime_context: C
-    no_report: bool
-    workers: int
+    no_report: Optional[bool] = False
+    workers: Optional[int] = 1
     eval_set: Optional[str] = None
     eval_ids: Optional[List[str]] = None
 
-    def __init__(
-        self,
-        runtime_context: C,
-        no_report: bool,
-        workers: int,
-        eval_set: Optional[str] = None,
-        eval_ids: Optional[List[str]] = None,
-        **kwargs,
-    ):
-        super().__init__(
-            runtime_context=runtime_context,  # type: ignore
-            no_report=no_report,
-            workers=workers,
-            eval_set=eval_set,
-            eval_ids=eval_ids,
-            **kwargs,
-        )
-        self._auto_discover()
-
-    def _auto_discover(self):
-        self.runtime_context.entrypoint = (
-            self.runtime_context.entrypoint or auto_discover_entrypoint()
-        )
-        self.eval_set = self.eval_set or EvalHelpers.auto_discover_eval_set()
-
 
 class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     """Specialized runtime for evaluation runs, with access to the factory."""
 
-    def __init__(
-        self, context: "UiPathEvalContext[C]", factory: "UiPathRuntimeFactory[T, C]"
-    ):
+    def __init__(self, context: UiPathEvalContext, factory: UiPathRuntimeFactory[T, C]):
         super().__init__(context)
-        self.context: "UiPathEvalContext[C]" = context
+        self.context: UiPathEvalContext = context
         self.factory: UiPathRuntimeFactory[T, C] = factory
         self.span_exporter: ExecutionSpanExporter = ExecutionSpanExporter()
         self.factory.add_span_exporter(self.span_exporter)
 
     @classmethod
-    def from__eval_context(
+    def from_eval_context(
         cls,
-        context: "UiPathEvalContext[C]",
-        factory: "UiPathRuntimeFactory[T, C]",
+        context: UiPathEvalContext,
+        factory: UiPathRuntimeFactory[T, C],
     ) -> "UiPathEvalRuntime[T, C]":
         return cls(context, factory)
 
@@ -119,30 +88,26 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         )
         execution_output_list: list[UiPathEvalRunExecutionOutput] = []
         for eval_item in evaluation_set.evaluations:
-            execution_output_list.append(await self.execute_agent(eval_item))
+            execution_output = await self.execute_runtime(eval_item)
+            execution_output_list.append(execution_output)
 
         self.context.result = UiPathRuntimeResult(
             output={
                 "results": execution_output_list,
             },
             status=UiPathRuntimeStatus.SUCCESSFUL,
-            resume=None,
         )
 
-        return self.context.runtime_context.result
-
-    def _prepare_new_runtime_context(self, eval_item: EvaluationItem) -> C:
-        runtime_context = copy.deepcopy(self.context.runtime_context)
-        runtime_context.execution_id = eval_item.id
-        runtime_context.input_json = eval_item.inputs
-        # here we can pass other values from eval_item: expectedAgentBehavior, simulationInstructions etc.
-        return runtime_context
+        return self.context.result
 
-    # TODO: this would most likely need to be ported to a public AgentEvaluator class
-    async def execute_agent(
+    async def execute_runtime(
         self, eval_item: EvaluationItem
-    ) -> "UiPathEvalRunExecutionOutput":
-        runtime_context = self._prepare_new_runtime_context(eval_item)
+    ) -> UiPathEvalRunExecutionOutput:
+        runtime_context: C = self.factory.new_context(
+            execution_id=eval_item.id,
+            input_json=eval_item.inputs,
+            is_eval_run=True,
+        )
         start_time = time()
         result = await self.factory.execute_in_root_span(
             runtime_context, root_span=eval_item.name

uipath/_cli/_runtime/_contracts.py

@@ -30,6 +30,9 @@ from ._logging import LogsInterceptor
 
 logger = logging.getLogger(__name__)
 
+T = TypeVar("T", bound="UiPathBaseRuntime")
+C = TypeVar("C", bound="UiPathRuntimeContext")
+
 
 class UiPathResumeTriggerType(str, Enum):
     """Constants representing different types of resume job triggers in the system."""
@@ -315,21 +318,43 @@ class UiPathRuntimeContext(BaseModel):
     model_config = {"arbitrary_types_allowed": True}
 
     @classmethod
-    def from_config(cls, config_path=None, **kwargs):
-        """Load configuration from uipath.json file.
+    def with_defaults(cls: type[C], config_path: Optional[str] = None, **kwargs) -> C:
+        """Construct a context with defaults, reading env vars and config file."""
+        resolved_config_path = config_path or os.environ.get(
+            "UIPATH_CONFIG_PATH", "uipath.json"
+        )
 
-        Args:
-            config_path: Path to the configuration file. If None, uses the default "uipath.json"
-            **kwargs: Additional keyword arguments to use as fallback for configuration values
+        base = cls.from_config(resolved_config_path)
+
+        # Apply defaults from env
+        base.job_id = os.environ.get("UIPATH_JOB_KEY")
+        base.trace_id = os.environ.get("UIPATH_TRACE_ID")
+        base.tracing_enabled = os.environ.get("UIPATH_TRACING_ENABLED", True)
+        base.logs_min_level = os.environ.get("LOG_LEVEL", "INFO")
+
+        base.trace_context = UiPathTraceContext(
+            trace_id=os.environ.get("UIPATH_TRACE_ID"),
+            parent_span_id=os.environ.get("UIPATH_PARENT_SPAN_ID"),
+            root_span_id=os.environ.get("UIPATH_ROOT_SPAN_ID"),
+            enabled=os.environ.get("UIPATH_TRACING_ENABLED", True),
+            job_id=os.environ.get("UIPATH_JOB_KEY"),
+            org_id=os.environ.get("UIPATH_ORGANIZATION_ID"),
+            tenant_id=os.environ.get("UIPATH_TENANT_ID"),
+            process_key=os.environ.get("UIPATH_PROCESS_UUID"),
+            folder_key=os.environ.get("UIPATH_FOLDER_KEY"),
+            reference_id=os.environ.get("UIPATH_JOB_KEY") or str(uuid4()),
+        )
 
-        Returns:
-            An instance of the class with fields populated from the config file
-        """
-        import json
-        import os
+        # Override with kwargs
+        for k, v in kwargs.items():
+            setattr(base, k, v)
 
-        path = config_path or "uipath.json"
+        return base
 
+    @classmethod
+    def from_config(cls: type[C], config_path: Optional[str] = None, **kwargs) -> C:
+        """Load configuration from uipath.json file."""
+        path = config_path or "uipath.json"
         config = {}
 
         if os.path.exists(path):
@@ -346,7 +371,6 @@ class UiPathRuntimeContext(BaseModel):
         }
 
         attributes_set = set()
-        # set values from config file if available
         if "runtime" in config:
             runtime_config = config["runtime"]
             for config_key, attr_name in mapping.items():
@@ -354,10 +378,8 @@ class UiPathRuntimeContext(BaseModel):
                     attributes_set.add(attr_name)
                     setattr(instance, attr_name, runtime_config[config_key])
 
-        # fallback to kwargs for any values not set from config file
         for _, attr_name in mapping.items():
             if attr_name in kwargs and hasattr(instance, attr_name):
-                # Only set from kwargs if not already set from config file
                 if attr_name not in attributes_set:
                     setattr(instance, attr_name, kwargs[attr_name])
 
@@ -383,7 +405,7 @@ class UiPathRuntimeError(Exception):
             if (
                 tb and tb.strip() != "NoneType: None"
             ):  # Ensure there's an actual traceback
-                detail = f"{detail}\n\nTraceback:\n{tb}"
+                detail = f"{detail}\n\n{tb}"
 
         if status is None:
             status = self._extract_http_status()
@@ -473,6 +495,21 @@ class UiPathBaseRuntime(ABC):
             with open(self.context.input_file) as f:
                 self.context.input = f.read()
 
+        try:
+            if self.context.input:
+                self.context.input_json = json.loads(self.context.input)
+            if self.context.input_json is None:
+                self.context.input_json = {}
+        except json.JSONDecodeError as e:
+            raise UiPathRuntimeError(
+                "INPUT_INVALID_JSON",
+                "Invalid JSON input",
+                f"The input data is not valid JSON: {str(e)}",
+                UiPathErrorCategory.USER,
+            ) from e
+
+        await self.validate()
+
         # Intercept all stdout/stderr/logs and write them to a file (runtime/evals), stdout (debug)
         self.logs_interceptor = LogsInterceptor(
             min_level=self.context.logs_min_level,
@@ -620,14 +657,16 @@ class UiPathBaseRuntime(ABC):
         return os.path.join("__uipath", "state.db")
 
 
-T = TypeVar("T", bound=UiPathBaseRuntime)
-C = TypeVar("C", bound=UiPathRuntimeContext)
-
-
 class UiPathRuntimeFactory(Generic[T, C]):
     """Generic factory for UiPath runtime classes."""
 
-    def __init__(self, runtime_class: Type[T], context_class: Type[C]):
+    def __init__(
+        self,
+        runtime_class: Type[T],
+        context_class: Type[C],
+        runtime_generator: Optional[Callable[[C], T]] = None,
+        context_generator: Optional[Callable[..., C]] = None,
+    ):
         if not issubclass(runtime_class, UiPathBaseRuntime):
             raise TypeError(
                 f"runtime_class {runtime_class.__name__} must inherit from UiPathBaseRuntime"
@@ -640,10 +679,11 @@ class UiPathRuntimeFactory(Generic[T, C]):
 
         self.runtime_class = runtime_class
         self.context_class = context_class
+        self.runtime_generator = runtime_generator
+        self.context_generator = context_generator
         self.tracer_provider: TracerProvider = TracerProvider()
         self.tracer_span_processors: List[SpanProcessor] = []
         trace.set_tracer_provider(self.tracer_provider)
-
         if os.getenv("UIPATH_JOB_KEY"):
             self.add_span_exporter(LlmOpsHttpExporter())
 
@@ -674,36 +714,49 @@ class UiPathRuntimeFactory(Generic[T, C]):
 
     def new_context(self, **kwargs) -> C:
         """Create a new context instance."""
+        if self.context_generator:
+            return self.context_generator(**kwargs)
         return self.context_class(**kwargs)
 
+    def new_runtime(self) -> T:
+        """Create a new runtime instance."""
+        context = self.new_context()
+        if self.runtime_generator:
+            return self.runtime_generator(context)
+        return self.runtime_class.from_context(context)
+
     def from_context(self, context: C) -> T:
         """Create runtime instance from context."""
+        if self.runtime_generator:
+            return self.runtime_generator(context)
         return self.runtime_class.from_context(context)
 
     async def execute(self, context: C) -> Optional[UiPathRuntimeResult]:
         """Execute runtime with context."""
         async with self.from_context(context) as runtime:
-            result = await runtime.execute()
-            for span_processor in self.tracer_span_processors:
-                span_processor.force_flush()
-            return result
+            try:
+                return await runtime.execute()
+            finally:
+                for span_processor in self.tracer_span_processors:
+                    span_processor.force_flush()
 
     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
+            try:
+                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 {},
+                ):
+                    return await runtime.execute()
+            finally:
+                for span_processor in self.tracer_span_processors:
+                    span_processor.force_flush()
 
 
 class UiPathExecutionTraceProcessorMixin:

uipath/_cli/_runtime/_runtime.py

@@ -1,30 +1,37 @@
 """Python script runtime implementation for executing and managing python scripts."""
 
-import importlib.util
-import inspect
-import json
 import logging
-import os
-from dataclasses import asdict, is_dataclass
-from typing import Any, Dict, Optional, Type, TypeVar, cast, get_type_hints
-
-from pydantic import BaseModel
+from typing import Any, Awaitable, Callable, Optional, TypeVar
 
 from ._contracts import (
     UiPathBaseRuntime,
     UiPathErrorCategory,
+    UiPathRuntimeContext,
     UiPathRuntimeError,
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
 )
+from ._script_executor import ScriptExecutor
 
 logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
+R = TypeVar("R")
+AsyncFunc = Callable[[T], Awaitable[R]]
 
 
 class UiPathRuntime(UiPathBaseRuntime):
-    """Runtime for executing Python scripts."""
+    def __init__(self, context: UiPathRuntimeContext, executor: AsyncFunc[Any, Any]):
+        self.context = context
+        self.executor = executor
+
+    async def cleanup(self) -> None:
+        """Cleanup runtime resources."""
+        pass
+
+    async def validate(self):
+        """Validate runtime context."""
+        pass
 
     async def execute(self) -> Optional[UiPathRuntimeResult]:
         """Execute the Python script with the provided input and configuration.
@@ -35,15 +42,8 @@ class UiPathRuntime(UiPathBaseRuntime):
         Raises:
             UiPathRuntimeError: If execution fails
         """
-        await self.validate()
-
         try:
-            if self.context.entrypoint is None:
-                return None
-
-            script_result = await self._execute_python_script(
-                self.context.entrypoint, self.context.input_json
-            )
+            script_result = await self.executor(self.context.input_json)
 
             if self.context.job_id is None:
                 logger.info(script_result)
@@ -65,248 +65,15 @@ class UiPathRuntime(UiPathBaseRuntime):
                 UiPathErrorCategory.SYSTEM,
             ) from e
 
-    async def validate(self) -> None:
-        """Validate runtime inputs."""
-        if not self.context.entrypoint:
-            raise UiPathRuntimeError(
-                "ENTRYPOINT_MISSING",
-                "No entrypoint specified",
-                "Please provide a path to a Python script.",
-                UiPathErrorCategory.USER,
-            )
-
-        if not os.path.exists(self.context.entrypoint):
-            raise UiPathRuntimeError(
-                "ENTRYPOINT_NOT_FOUND",
-                "Script not found",
-                f"Script not found at path {self.context.entrypoint}.",
-                UiPathErrorCategory.USER,
-            )
-
-        try:
-            if self.context.input:
-                self.context.input_json = json.loads(self.context.input)
-            if self.context.input_json is None:
-                self.context.input_json = {}
-        except json.JSONDecodeError as e:
-            raise UiPathRuntimeError(
-                "INPUT_INVALID_JSON",
-                "Invalid JSON input",
-                f"The input data is not valid JSON: {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-
-    async def cleanup(self) -> None:
-        """Cleanup runtime resources."""
-        pass
-
-    async def _execute_python_script(self, script_path: str, input_data: Any) -> Any:
-        """Execute the Python script with the given input."""
-        spec = importlib.util.spec_from_file_location("dynamic_module", script_path)
-        if not spec or not spec.loader:
-            raise UiPathRuntimeError(
-                "IMPORT_ERROR",
-                "Module import failed",
-                f"Could not load spec for {script_path}",
-                UiPathErrorCategory.USER,
-            )
-
-        module = importlib.util.module_from_spec(spec)
-        try:
-            spec.loader.exec_module(module)
-        except Exception as e:
-            raise UiPathRuntimeError(
-                "MODULE_EXECUTION_ERROR",
-                "Module execution failed",
-                f"Error executing module: {str(e)}",
-                UiPathErrorCategory.USER,
-            ) from e
-
-        for func_name in ["main", "run", "execute"]:
-            if hasattr(module, func_name):
-                main_func = getattr(module, func_name)
-                sig = inspect.signature(main_func)
-                params = list(sig.parameters.values())
-
-                # Check if the function is asynchronous
-                is_async = inspect.iscoroutinefunction(main_func)
-
-                # Case 1: No parameters
-                if not params:
-                    try:
-                        result = await main_func() if is_async else main_func()
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-                input_param = params[0]
-                input_type = input_param.annotation
-
-                # Case 2: Class, dataclass, or Pydantic model parameter
-                if input_type != inspect.Parameter.empty and (
-                    is_dataclass(input_type)
-                    or self._is_pydantic_model(input_type)
-                    or hasattr(input_type, "__annotations__")
-                ):
-                    try:
-                        valid_type = cast(Type[Any], input_type)
-                        typed_input = self._convert_to_class(input_data, valid_type)
-                        result = (
-                            await main_func(typed_input)
-                            if is_async
-                            else main_func(typed_input)
-                        )
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function with typed input",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-                # Case 3: Dict parameter
-                else:
-                    try:
-                        result = (
-                            await main_func(input_data)
-                            if is_async
-                            else main_func(input_data)
-                        )
-                        return (
-                            self._convert_from_class(result)
-                            if result is not None
-                            else {}
-                        )
-                    except Exception as e:
-                        raise UiPathRuntimeError(
-                            "FUNCTION_EXECUTION_ERROR",
-                            f"Error executing {func_name} function with dictionary input",
-                            f"Error: {str(e)}",
-                            UiPathErrorCategory.USER,
-                        ) from e
-
-        raise UiPathRuntimeError(
-            "ENTRYPOINT_FUNCTION_MISSING",
-            "No entry function found",
-            f"No main function (main, run, or execute) found in {script_path}",
-            UiPathErrorCategory.USER,
-        )
-
-    def _convert_to_class(self, data: Dict[str, Any], cls: Type[T]) -> T:
-        """Convert a dictionary to either a dataclass, Pydantic model, or regular class instance."""
-        # Handle Pydantic models
-        try:
-            if inspect.isclass(cls) and issubclass(cls, BaseModel):
-                return cls.model_validate(data)
-        except TypeError:
-            # issubclass can raise TypeError if cls is not a class
-            pass
-
-        # Handle dataclasses
-        if is_dataclass(cls):
-            field_types = get_type_hints(cls)
-            converted_data = {}
 
-            for field_name, field_type in field_types.items():
-                if field_name not in data:
-                    continue
-
-                value = data[field_name]
-                if (
-                    is_dataclass(field_type)
-                    or self._is_pydantic_model(field_type)
-                    or hasattr(field_type, "__annotations__")
-                ) and isinstance(value, dict):
-                    typed_field = cast(Type[Any], field_type)
-                    value = self._convert_to_class(value, typed_field)
-                converted_data[field_name] = value
-
-            return cls(**converted_data)
-
-        # Handle regular classes
-        else:
-            sig = inspect.signature(cls.__init__)
-            params = sig.parameters
-
-            init_args = {}
-
-            for param_name, param in params.items():
-                if param_name == "self":
-                    continue
-
-                if param_name in data:
-                    value = data[param_name]
-                    param_type = (
-                        param.annotation
-                        if param.annotation != inspect.Parameter.empty
-                        else Any
-                    )
-
-                    if (
-                        is_dataclass(param_type)
-                        or self._is_pydantic_model(param_type)
-                        or hasattr(param_type, "__annotations__")
-                    ) and isinstance(value, dict):
-                        typed_param = cast(Type[Any], param_type)
-                        value = self._convert_to_class(value, typed_param)
-
-                    init_args[param_name] = value
-                elif param.default != inspect.Parameter.empty:
-                    init_args[param_name] = param.default
-
-            return cls(**init_args)
-
-    def _is_pydantic_model(self, cls: Type[Any]) -> bool:
-        """Safely check if a class is a Pydantic model."""
-        try:
-            return inspect.isclass(cls) and issubclass(cls, BaseModel)
-        except TypeError:
-            # issubclass can raise TypeError if cls is not a class
-            return False
-
-    def _convert_from_class(self, obj: Any) -> Dict[str, Any]:
-        """Convert a class instance (dataclass, Pydantic model, or regular) to a dictionary."""
-        if obj is None:
-            return {}
-
-        # Handle Pydantic models
-        if isinstance(obj, BaseModel):
-            return obj.model_dump()
+class UiPathScriptRuntime(UiPathRuntime):
+    """Runtime for executing Python scripts."""
 
-        # Handle dataclasses
-        elif is_dataclass(obj):
-            # Make sure obj is an instance, not a class
-            if isinstance(obj, type):
-                return {}
-            return asdict(obj)
+    def __init__(self, context: UiPathRuntimeContext, entrypoint: str):
+        executor = ScriptExecutor(entrypoint)
+        super().__init__(context, executor)
 
-        # Handle regular classes
-        elif hasattr(obj, "__dict__"):
-            result = {}
-            for key, value in obj.__dict__.items():
-                # Skip private attributes
-                if not key.startswith("_"):
-                    if (
-                        isinstance(value, BaseModel)
-                        or hasattr(value, "__dict__")
-                        or is_dataclass(value)
-                    ):
-                        result[key] = self._convert_from_class(value)
-                    else:
-                        result[key] = value
-            return result
-        return {} if obj is None else {str(type(obj).__name__): str(obj)}  # Fallback
+    @classmethod
+    def from_context(cls, context: UiPathRuntimeContext):
+        """Create runtime instance from context."""
+        return UiPathScriptRuntime(context, context.entrypoint or "")