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

uipath/_cli/_runtime/_script_executor.py

@@ -0,0 +1,254 @@
+"""Python script runtime implementation for executing and managing python scripts."""
+
+import importlib.util
+import inspect
+import os
+from dataclasses import asdict, is_dataclass
+from typing import Any, Dict, Type, TypeVar, cast, get_type_hints
+
+from pydantic import BaseModel
+
+from ._contracts import (
+    UiPathErrorCategory,
+    UiPathRuntimeError,
+)
+
+T = TypeVar("T")
+
+
+class ScriptExecutor:
+    def __init__(self, entrypoint: str):
+        self.entrypoint = entrypoint
+        self.validate_entrypoint()
+
+    async def __call__(self, input: Any) -> Any:
+        return await self._execute_python_script(input)
+
+    def validate_entrypoint(self) -> None:
+        """Validate runtime inputs."""
+        if not self.entrypoint:
+            raise UiPathRuntimeError(
+                "ENTRYPOINT_MISSING",
+                "No entrypoint specified",
+                "Please provide a path to a Python script.",
+                UiPathErrorCategory.USER,
+            )
+
+        if not os.path.exists(self.entrypoint):
+            raise UiPathRuntimeError(
+                "ENTRYPOINT_NOT_FOUND",
+                "Script not found",
+                f"Script not found at path {self.entrypoint}.",
+                UiPathErrorCategory.USER,
+            )
+
+    async def _execute_python_script(self, input_data: Any) -> Any:
+        """Execute the Python script with the given input."""
+        spec = importlib.util.spec_from_file_location("dynamic_module", self.entrypoint)
+        if not spec or not spec.loader:
+            raise UiPathRuntimeError(
+                "IMPORT_ERROR",
+                "Module import failed",
+                f"Could not load spec for {self.entrypoint}",
+                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 {self.entrypoint}",
+            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()
+
+        # Handle dataclasses
+        elif is_dataclass(obj):
+            # Make sure obj is an instance, not a class
+            if isinstance(obj, type):
+                return {}
+            return asdict(obj)
+
+        # 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

uipath/_cli/cli_dev.py

@@ -6,7 +6,7 @@ import click
 
 from uipath._cli._dev._terminal import UiPathDevTerminal
 from uipath._cli._runtime._contracts import UiPathRuntimeContext, UiPathRuntimeFactory
-from uipath._cli._runtime._runtime import UiPathRuntime
+from uipath._cli._runtime._runtime import UiPathScriptRuntime
 from uipath._cli._utils._console import ConsoleLogger
 from uipath._cli._utils._debug import setup_debugging
 from uipath._cli.cli_init import init  # type: ignore[attr-defined]
@@ -53,7 +53,9 @@ def dev(interface: Optional[str], debug: bool, debug_port: int) -> None:
 
     try:
         if interface == "terminal":
-            runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
+            runtime_factory = UiPathRuntimeFactory(
+                UiPathScriptRuntime, UiPathRuntimeContext
+            )
             app = UiPathDevTerminal(runtime_factory)
             asyncio.run(app.run_async())
         else:

uipath/_cli/cli_eval.py

@@ -10,15 +10,16 @@ import click
 from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
 from uipath._cli._runtime._contracts import (
     UiPathRuntimeContext,
-    UiPathRuntimeContextBuilder,
     UiPathRuntimeFactory,
 )
-from uipath._cli._runtime._runtime import UiPathRuntime
+from uipath._cli._runtime._runtime import UiPathScriptRuntime
 from uipath._cli.middlewares import MiddlewareResult, Middlewares
+from uipath.eval._helpers import auto_discover_entrypoint
 
 from .._utils.constants import ENV_JOB_ID
 from ..telemetry import track
 from ._utils._console import ConsoleLogger
+from ._utils._eval_set import EvalHelpers
 
 console = ConsoleLogger()
 
@@ -39,42 +40,35 @@ def eval_agent_middleware(
     no_report: bool = False,
     **kwargs,
 ) -> MiddlewareResult:
-    def generate_eval_context(
-        runtime_context: UiPathRuntimeContext,
-    ) -> UiPathEvalContext:
-        os.makedirs("evals/results", exist_ok=True)
-        timestamp = datetime.now(timezone.utc).strftime("%M-%H-%d-%m-%Y")
-        base_context = UiPathRuntimeContextBuilder().with_defaults().build()
-        # TODO: the name should include the eval_set name. those files should not be commited to SW
-        base_context.execution_output_file = (
-            f"evals/results/{timestamp}.json"
-            if not os.getenv("UIPATH_JOB_KEY")
-            else None
-        )
-        return UiPathEvalContext(
-            runtime_context=runtime_context,
-            no_report=no_report,
-            workers=workers,
-            eval_set=eval_set,
-            eval_ids=eval_ids,
-            **kwargs,
-            **base_context.model_dump(),
-        )
+    """Middleware to run an evaluation set against the agent."""
+    timestamp = datetime.now(timezone.utc).strftime("%M-%H-%d-%m-%Y")
+
+    eval_context = UiPathEvalContext.with_defaults()
+    eval_context.no_report = no_report
+    eval_context.workers = workers
+    eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
+    eval_context.eval_ids = eval_ids
+    eval_context.execution_output_file = (
+        f"evals/results/{timestamp}.json" if not os.getenv("UIPATH_JOB_KEY") else None
+    )
+
+    runtime_entrypoint = entrypoint or auto_discover_entrypoint()
+
+    def generate_runtime_context(**context_kwargs) -> UiPathRuntimeContext:
+        runtime_context = UiPathRuntimeContext.with_defaults(**context_kwargs)
+        runtime_context.entrypoint = runtime_entrypoint
+        return runtime_context
 
     try:
-        runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
-        context = (
-            UiPathRuntimeContextBuilder()
-            .with_defaults(**kwargs)
-            .with_entrypoint(entrypoint)
-            .with_entrypoint(entrypoint)
-            .mark_eval_run()
-            .build()
+        runtime_factory = UiPathRuntimeFactory(
+            UiPathScriptRuntime,
+            UiPathRuntimeContext,
+            context_generator=generate_runtime_context,
         )
 
         async def execute():
-            async with UiPathEvalRuntime.from__eval_context(
-                factory=runtime_factory, context=generate_eval_context(context)
+            async with UiPathEvalRuntime.from_eval_context(
+                factory=runtime_factory, context=eval_context
             ) as eval_runtime:
                 await eval_runtime.execute()
 

uipath/_cli/cli_run.py

@@ -1,9 +1,8 @@
 # type: ignore
 import asyncio
 import os
-import traceback
 from os import environ as env
-from typing import Optional, Tuple
+from typing import Optional
 
 import click
 
@@ -15,138 +14,16 @@ from .._utils.constants import (
 from ..telemetry import track
 from ._runtime._contracts import (
     UiPathRuntimeContext,
-    UiPathRuntimeContextBuilder,
     UiPathRuntimeError,
     UiPathRuntimeFactory,
 )
-from ._runtime._runtime import UiPathRuntime
+from ._runtime._runtime import UiPathScriptRuntime
 from ._utils._console import ConsoleLogger
-from .middlewares import MiddlewareResult, Middlewares
+from .middlewares import Middlewares
 
 console = ConsoleLogger()
 
 
-def python_run_middleware(
-    entrypoint: Optional[str],
-    input: Optional[str],
-    resume: bool,
-    **kwargs,
-) -> MiddlewareResult:
-    """Middleware to handle Python script execution.
-
-    Args:
-        entrypoint: Path to the Python script to execute
-        input: JSON string with input data
-        resume: Flag indicating if this is a resume execution
-        debug: Enable debugging with debugpy
-        debug_port: Port for debug server (default: 5678)
-
-    Returns:
-        MiddlewareResult with execution status and messages
-    """
-    if not entrypoint:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message="""No entrypoint specified. Please provide a path to a Python script.
-Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
-        )
-
-    if not os.path.exists(entrypoint):
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"""Script not found at path {entrypoint}.
-Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""",
-        )
-
-    try:
-        runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
-        context = (
-            UiPathRuntimeContextBuilder()
-            .with_defaults(**kwargs)
-            .with_entrypoint(entrypoint)
-            .with_input(input)
-            .with_resume(resume)
-            .build()
-        )
-
-        asyncio.run(runtime_factory.execute(context))
-
-        return MiddlewareResult(should_continue=False)
-
-    except UiPathRuntimeError as e:
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"Error: {e.error_info.title} - {e.error_info.detail}",
-            should_include_stacktrace=False,
-        )
-    except Exception as e:
-        # Handle unexpected errors
-        return MiddlewareResult(
-            should_continue=False,
-            error_message=f"Error: Unexpected error occurred - {str(e)}",
-            should_include_stacktrace=True,
-        )
-
-
-def run_core(
-    entrypoint: Optional[str],
-    resume: bool,
-    input: Optional[str] = None,
-    input_file: Optional[str] = None,
-    execution_output_file: Optional[str] = None,
-    logs_file: Optional[str] = None,
-    **kwargs,
-) -> Tuple[bool, Optional[str], Optional[str]]:
-    """Core execution logic that can be called programmatically.
-
-    Args:
-        entrypoint: Path to the Python script to execute
-        input: JSON string with input data
-        resume: Flag indicating if this is a resume execution
-        input_file: Path to input JSON file
-        execution_output_file: Path to execution output file
-        logs_file: Path where execution output will be written
-        **kwargs: Additional arguments to be forwarded to the middleware
-
-    Returns:
-        Tuple containing:
-            - success: True if execution was successful
-            - error_message: Error message if any
-            - info_message: Info message if any
-    """
-    # Process through middleware chain
-    result = Middlewares.next(
-        "run",
-        entrypoint,
-        input,
-        resume,
-        input_file=input_file,
-        execution_output_file=execution_output_file,
-        logs_file=logs_file,
-        **kwargs,
-    )
-
-    if result.should_continue:
-        result = python_run_middleware(
-            entrypoint=entrypoint,
-            input=input,
-            resume=resume,
-            input_file=input_file,
-            execution_output_file=execution_output_file,
-            logs_file=logs_file,
-            **kwargs,
-        )
-
-    if result.should_continue:
-        return False, "Could not process the request with any available handler.", None
-
-    return (
-        not bool(result.error_message),
-        result.error_message,
-        result.info_message,
-    )
-
-
 @click.command()
 @click.argument("entrypoint", required=False)
 @click.argument("input", required=False, default="{}")
@@ -198,27 +75,53 @@ def run(
     if not setup_debugging(debug, debug_port):
         console.error(f"Failed to start debug server on port {debug_port}")
 
-    success, error_message, info_message = run_core(
-        entrypoint=entrypoint,
-        input=input,
-        resume=resume,
+    result = Middlewares.next(
+        "run",
+        entrypoint,
+        input,
+        resume,
         input_file=input_file,
         execution_output_file=output_file,
         debug=debug,
         debug_port=debug_port,
     )
 
-    if error_message:
-        console.error(error_message, include_traceback=True)
-        if not success:  # If there was an error and execution failed
-            console.error(traceback.format_exc())
-        click.get_current_context().exit(1)
-
-    if info_message:
-        console.info(info_message)
+    if result.error_message:
+        console.error(result.error_message)
 
-    if success:
-        console.success("Successful execution.")
+    if result.should_continue:
+        if not entrypoint:
+            console.error("""No entrypoint specified. Please provide a path to a Python script.
+    Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""")
+
+        if not os.path.exists(entrypoint):
+            console.error(f"""Script not found at path {entrypoint}.
+    Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path>]`""")
+
+        try:
+            runtime_factory = UiPathRuntimeFactory(
+                UiPathScriptRuntime, UiPathRuntimeContext
+            )
+            context = UiPathRuntimeContext.with_defaults(
+                entrypoint=entrypoint,
+                input=input,
+                input_file=input_file,
+                resume=resume,
+                execution_output_file=output_file,
+                debug=debug,
+            )
+
+            asyncio.run(runtime_factory.execute(context))
+
+        except UiPathRuntimeError as e:
+            console.error(f"{e.error_info.title} - {e.error_info.detail}")
+        except Exception as e:
+            # Handle unexpected errors
+            console.error(
+                f"Error: Unexpected error occurred - {str(e)}", include_traceback=True
+            )
+
+    console.success("Successful execution.")
 
 
 if __name__ == "__main__":

uipath/_services/processes_service.py

@@ -7,7 +7,7 @@ from .._config import Config
 from .._execution_context import ExecutionContext
 from .._folder_context import FolderContext
 from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
-from .._utils.constants import ENV_JOB_ID, HEADER_JOB_KEY
+from .._utils.constants import ENV_JOB_KEY, HEADER_JOB_KEY
 from ..models.job import Job
 from ..tracing._traced import traced
 from . import AttachmentsService
@@ -241,7 +241,7 @@ class ProcessesService(FolderContext, BaseService):
                 **header_folder(folder_key, folder_path),
             },
         )
-        job_key = os.environ.get(ENV_JOB_ID, None)
+        job_key = os.environ.get(ENV_JOB_KEY, None)
         if job_key:
             request_scope.headers[HEADER_JOB_KEY] = job_key
         return request_scope

uipath/models/errors.py

@@ -1,7 +1,7 @@
 class BaseUrlMissingError(Exception):
     def __init__(
         self,
-        message="Authentication required. Please run \033[1muipath auth\033[22m.",
+        message="Authentication required. Please run \033[1muipath auth\033[22m or set the base URL via the UIPATH_URL environment variable.",
     ):
         self.message = message
         super().__init__(self.message)
@@ -10,7 +10,7 @@ class BaseUrlMissingError(Exception):
 class SecretMissingError(Exception):
     def __init__(
         self,
-        message="Authentication required. Please run \033[1muipath auth\033[22m.",
+        message="Authentication required. Please run \033[1muipath auth\033[22m or set the UIPATH_ACCESS_TOKEN environment variable to a valid access token.",
     ):
         self.message = message
         super().__init__(self.message)

{uipath-2.1.43.dist-info → uipath-2.1.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.43
+Version: 2.1.45
 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