uipath 2.1.96__tar.gz → 2.1.98__tar.gz

{uipath-2.1.96 → uipath-2.1.98}/.github/workflows/integration_tests.yml

@@ -63,10 +63,27 @@ jobs:
         USE_AZURE_CHAT: ${{ matrix.use_azure_chat }}
       working-directory: testcases/${{ matrix.testcase }}
       run: |
+        # If any errors occur execution will stop with exit code
+        set -e
+      
         echo "Running testcase: ${{ matrix.testcase }}"
         echo "Environment: ${{ matrix.environment }}"
         echo "Working directory: $(pwd)"
         
         # Execute the testcase run script directly
         bash run.sh
-        bash ../common/validate_output.sh
+        bash ../common/validate_output.sh
+    
+  summarize-results:
+    needs: [integration-tests]
+    runs-on: ubuntu-latest
+    if: always() # This ensures the job runs even if the tests fail
+    steps:
+      - name: Check integration tests status
+        run: |
+          if [[ "${{ needs.integration-tests.result }}" == "success" ]]; then
+            echo "All integration tests passed"
+          else
+            echo "Some integration tests failed"
+            exit 1
+          fi

{uipath-2.1.96 → uipath-2.1.98}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.96"
+version = "2.1.98"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.96 → uipath-2.1.98}/src/uipath/_cli/__init__.py

@@ -3,6 +3,7 @@ import sys
 
 import click
 
+from .._utils._logs import setup_logging
 from ._utils._common import add_cwd_to_path, load_environment_variables
 from .cli_auth import auth as auth
 from .cli_debug import debug as debug  # type: ignore
@@ -47,6 +48,7 @@ def _get_safe_version() -> str:
 def cli(lv: bool, v: bool) -> None:
     load_environment_variables()
     add_cwd_to_path()
+    setup_logging()
     if lv:
         try:
             version = importlib.metadata.version("uipath-langchain")

{uipath-2.1.96 → uipath-2.1.98}/src/uipath/_cli/_debug/_bridge.py

@@ -5,9 +5,11 @@ import os
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional
 
+from pydantic import BaseModel
 from pysignalr.client import SignalRClient
 from rich.console import Console
 from rich.syntax import Syntax
+from rich.tree import Tree
 
 from uipath._cli._runtime._contracts import (
     UiPathBreakpointResult,
@@ -115,7 +117,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
 
         self.console.print(f"[yellow]●[/yellow] [bold]{state_event.node_name}[/bold]")
         if state_event.payload:
-            self._print_json(state_event.payload, label="State")
+            self._print_json(state_event.payload, label="state")
 
     async def emit_breakpoint_hit(
         self, breakpoint_result: UiPathBreakpointResult
@@ -135,7 +137,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
 
         # Display current state
         if breakpoint_result.current_state:
-            self._print_json(breakpoint_result.current_state, label="State")
+            self._print_json(breakpoint_result.current_state, label="state")
 
     async def emit_execution_completed(
         self,
@@ -157,7 +159,7 @@ class ConsoleDebugBridge(UiPathDebugBridge):
 
         self.console.print(f"[{color}]{symbol} END[/{color}]")
         if runtime_result.output:
-            self._print_json(runtime_result.output, label="Output")
+            self._print_json(runtime_result.output, label="output")
 
     async def emit_execution_error(
         self,
@@ -193,36 +195,83 @@ class ConsoleDebugBridge(UiPathDebugBridge):
         self.console.print()
         return user_input
 
-    def _print_json(self, data: Dict[str, Any], label: str = "Data") -> None:
-        """Print JSON data in a readable format."""
+    def _print_json(self, data: Dict[str, Any], label: str = "data") -> None:
+        """Print JSON data with enhanced hierarchy."""
         try:
-            json_str = json.dumps(data, indent=2, default=str)
-
-            # Limit output if too large
-            is_truncated = False
-            if len(json_str) > 2000:
-                json_str = json_str[:2000] + "\n..."
-                is_truncated = True
-
-            syntax = Syntax(
-                json_str,
-                "json",
-                theme="monokai",
-                line_numbers=False,
-                background_color="default",
-            )
+            # Create a tree for nested structure
+            tree = Tree(f"[bold cyan]{label}[/bold cyan]")
+
+            def process_value(
+                node: Tree, value: Any, key_label: str, depth: int
+            ) -> None:
+                """Process a single value and add it to the tree."""
+                if isinstance(value, BaseModel):
+                    branch = node.add(
+                        f"{key_label} [dim]({type(value).__name__})[/dim]"
+                    )
+                    add_to_tree(branch, value, depth + 1)
+                elif isinstance(value, dict):
+                    branch = node.add(f"{key_label} [dim](dict)[/dim]")
+                    add_to_tree(branch, value, depth + 1)
+                elif isinstance(value, list):
+                    branch = node.add(
+                        f"{key_label} [dim](list, {len(value)} items)[/dim]"
+                    )
+                    add_to_tree(branch, value, depth + 1)
+                else:
+                    val_str = str(value)
+                    if len(val_str) > 250:
+                        val_str = val_str[:250] + "..."
+                    node.add(f"{key_label}: [green]{val_str}[/green]")
+
+            def add_to_tree(node: Tree, payload: Any, depth: int = 0):
+                if depth > 10:
+                    node.add("[dim]...[/dim]")
+                    return
+
+                if isinstance(payload, BaseModel):
+                    try:
+                        payload = payload.model_dump()  # Pydantic v2
+                    except AttributeError:
+                        payload = payload.dict()  # Pydantic v1
+                    add_to_tree(node, payload, depth)
+
+                elif isinstance(payload, dict):
+                    for key, value in payload.items():
+                        process_value(node, value, f"[yellow]{key}[/yellow]", depth)
+
+                elif isinstance(payload, list):
+                    for i, item in enumerate(payload):
+                        process_value(node, item, f"[cyan]#{i}[/cyan]", depth)
+
+                else:
+                    val_str = str(payload)
+                    if len(val_str) > 250:
+                        val_str = val_str[:250] + "..."
+                    node.add(f"[green]{val_str}[/green]")
+
+            add_to_tree(tree, data)
 
             self.console.print()
-            truncated_text = " (truncated)" if is_truncated else ""
-            self.console.print(f"[dim]{label}{truncated_text}:")
-            self.console.print(syntax)
+            self.console.print(tree)
             self.console.print()
+
         except Exception:
-            # Fallback to simple print
-            self.console.print()
-            self.console.print(f"[dim]{label}:")
-            self.console.print(str(data))
-            self.console.print()
+            try:
+                json_str = json.dumps(data, indent=2, default=str)
+                if len(json_str) > 10000:
+                    json_str = json_str[:10000] + "\n..."
+
+                syntax = Syntax(json_str, "json", theme="monokai", line_numbers=False)
+                self.console.print(f"\n[dim]{label}:")
+                self.console.print(syntax)
+                self.console.print()
+            except Exception:
+                # Fallback to simple print
+                self.console.print()
+                self.console.print(f"[dim]{label}:")
+                self.console.print(str(data))
+                self.console.print()
 
 
 class SignalRDebugBridge(UiPathDebugBridge):

{uipath-2.1.96 → uipath-2.1.98}/src/uipath/_cli/_debug/_runtime.py

@@ -56,7 +56,7 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
                 raise RuntimeError("Failed to create inner runtime")
 
             await self.debug_bridge.emit_execution_started(
-                execution_id=self.context.execution_id or "default"
+                execution_id=self.context.job_id or "default"
             )
 
             # Try to stream events from inner runtime
@@ -78,7 +78,7 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
         except Exception as e:
             # Emit execution error
             await self.debug_bridge.emit_execution_error(
-                execution_id=self.context.execution_id or "default",
+                execution_id=self.context.job_id or "default",
                 error=str(e),
             )
             raise

{uipath-2.1.96 → uipath-2.1.98}/src/uipath/_cli/_evals/_runtime.py

@@ -451,12 +451,12 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     async def execute_runtime(
         self, eval_item: EvaluationItem, execution_id: str
     ) -> UiPathEvalRunExecutionOutput:
-        runtime_context: C = self.factory.new_context(
-            execution_id=execution_id,
-            input_json=eval_item.inputs,
-            is_eval_run=True,
-            log_handler=self._setup_execution_logging(execution_id),
-        )
+        context_args = self.context.model_dump()
+        context_args["execution_id"] = execution_id
+        context_args["input_json"] = eval_item.inputs
+        context_args["is_eval_run"] = True
+        context_args["log_handler"] = self._setup_execution_logging(execution_id)
+        runtime_context: C = self.factory.new_context(**context_args)
         if runtime_context.execution_id is None:
             raise ValueError("execution_id must be set for eval runs")
 

{uipath-2.1.96 → uipath-2.1.98}/src/uipath/_cli/_runtime/_contracts.py

@@ -39,6 +39,7 @@ from uipath._events._events import UiPathRuntimeEvent
 from uipath.agent.conversation import UiPathConversationEvent, UiPathConversationMessage
 from uipath.tracing import TracingManager
 
+from ..models.runtime_schema import BindingResource, Entrypoint
 from ._logging import LogsInterceptor
 
 logger = logging.getLogger(__name__)
@@ -516,6 +517,22 @@ class UiPathBaseRuntime(ABC):
         runtime = cls(context)
         return runtime
 
+    @property
+    def get_binding_resources(self) -> List[BindingResource]:
+        """Get binding resources for this runtime.
+
+        Returns: A list of binding resources.
+        """
+        raise NotImplementedError()
+
+    @property
+    def get_entrypoint(self) -> Entrypoint:
+        """Get entrypoint for this runtime.
+
+        Returns: A entrypoint for this runtime.
+        """
+        raise NotImplementedError()
+
     async def __aenter__(self):
         """Async enter method called when entering the 'async with' block.
 
@@ -806,9 +823,9 @@ class UiPathRuntimeFactory(Generic[T, C]):
             return self.context_generator(**kwargs)
         return self.context_class(**kwargs)
 
-    def new_runtime(self) -> T:
+    def new_runtime(self, **kwargs) -> T:
         """Create a new runtime instance."""
-        context = self.new_context()
+        context = self.new_context(**kwargs)
         if self.runtime_generator:
             return self.runtime_generator(context)
         return self.runtime_class.from_context(context)

uipath-2.1.98/src/uipath/_cli/_runtime/_runtime.py

@@ -0,0 +1,145 @@
+"""Python script runtime implementation for executing and managing python scripts."""
+
+import logging
+import os
+import uuid
+from functools import cached_property
+from pathlib import Path
+from typing import Any, Awaitable, Callable, List, Optional, TypeVar
+
+from typing_extensions import override
+
+from .._utils._console import ConsoleLogger
+from .._utils._input_args import generate_args
+from .._utils._parse_ast import generate_bindings  # type: ignore[attr-defined]
+from ..models.runtime_schema import BindingResource, Entrypoint
+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):
+    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.
+
+        Returns:
+            Dictionary with execution results
+
+        Raises:
+            UiPathRuntimeError: If execution fails
+        """
+        try:
+            script_result = await self.executor(self.context.input_json)
+
+            self.context.result = UiPathRuntimeResult(
+                output=script_result, status=UiPathRuntimeStatus.SUCCESSFUL
+            )
+
+            return self.context.result
+
+        except Exception as e:
+            if isinstance(e, UiPathRuntimeError):
+                raise
+
+            raise UiPathRuntimeError(
+                "EXECUTION_ERROR",
+                "Python script execution failed",
+                f"Error: {str(e)}",
+                UiPathErrorCategory.SYSTEM,
+            ) from e
+
+
+console = ConsoleLogger()
+
+
+def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optional[str]:
+    """Find the Python script to process."""
+    if entrypoint:
+        script_path = os.path.join(directory, entrypoint)
+        if not os.path.isfile(script_path):
+            console.error(
+                f"The {entrypoint} file does not exist in the current directory."
+            )
+            return None
+        return script_path
+
+    python_files = [f for f in os.listdir(directory) if f.endswith(".py")]
+
+    if not python_files:
+        console.error(
+            "No python files found in the current directory.\nPlease specify the entrypoint: `uipath init <entrypoint_path>`"
+        )
+        return None
+    elif len(python_files) == 1:
+        return os.path.join(directory, python_files[0])
+    else:
+        console.error(
+            "Multiple python files found in the current directory.\nPlease specify the entrypoint: `uipath init <entrypoint_path>`"
+        )
+        return None
+
+
+class UiPathScriptRuntime(UiPathRuntime):
+    """Runtime for executing Python scripts."""
+
+    def __init__(self, context: UiPathRuntimeContext, entrypoint: str):
+        executor = ScriptExecutor(entrypoint)
+        super().__init__(context, executor)
+
+    @classmethod
+    def from_context(cls, context: UiPathRuntimeContext):
+        """Create runtime instance from context."""
+        return UiPathScriptRuntime(context, context.entrypoint or "")
+
+    @cached_property
+    @override
+    def get_binding_resources(self) -> List[BindingResource]:
+        """Get binding resources for script runtime.
+
+        Returns: A list of binding resources.
+        """
+        working_dir = self.context.runtime_dir or os.getcwd()
+        script_path = get_user_script(working_dir, entrypoint=self.context.entrypoint)
+        bindings = generate_bindings(script_path)
+        return bindings.resources
+
+    @cached_property
+    @override
+    def get_entrypoint(self) -> Entrypoint:
+        working_dir = self.context.runtime_dir or os.getcwd()
+        script_path = get_user_script(working_dir, entrypoint=self.context.entrypoint)
+        if not script_path:
+            raise ValueError("Entrypoint not found.")
+        relative_path = Path(script_path).relative_to(working_dir).as_posix()
+        args = generate_args(script_path)
+        return Entrypoint(
+            file_path=relative_path,  # type: ignore[call-arg] # This exists
+            unique_id=str(uuid.uuid4()),
+            type="agent",
+            input=args["input"],
+            output=args["output"],
+        )

uipath-2.1.98/src/uipath/_cli/_runtime/_runtime_factory.py

@@ -0,0 +1,21 @@
+from uipath._cli._runtime._contracts import (
+    UiPathBaseRuntime,
+    UiPathRuntimeContext,
+    UiPathRuntimeFactory,
+)
+from uipath._cli._runtime._runtime import UiPathScriptRuntime
+
+
+def generate_runtime_factory() -> UiPathRuntimeFactory[
+    UiPathBaseRuntime, UiPathRuntimeContext
+]:
+    runtime_factory: UiPathRuntimeFactory[UiPathBaseRuntime, UiPathRuntimeContext] = (
+        UiPathRuntimeFactory(
+            UiPathScriptRuntime,
+            UiPathRuntimeContext,
+            context_generator=lambda **kwargs: UiPathRuntimeContext.with_defaults(
+                **kwargs
+            ),
+        )
+    )
+    return runtime_factory

{uipath-2.1.96 → uipath-2.1.98}/src/uipath/_cli/cli_debug.py

@@ -1,7 +1,6 @@
 # type: ignore
 import asyncio
 import os
-import uuid
 from os import environ as env
 from typing import Optional
 
@@ -110,7 +109,6 @@ def debug(
                 execution_output_file=output_file,
                 debug=debug,
             )
-            debug_context.execution_id = debug_context.job_id or str(uuid.uuid4())
 
             runtime_factory = UiPathRuntimeFactory(
                 UiPathScriptRuntime,

{uipath-2.1.96 → uipath-2.1.98}/src/uipath/_cli/cli_eval.py

@@ -12,11 +12,7 @@ from uipath._cli._evals._runtime import (
     UiPathEvalContext,
     UiPathEvalRuntime,
 )
-from uipath._cli._runtime._contracts import (
-    UiPathRuntimeContext,
-    UiPathRuntimeFactory,
-)
-from uipath._cli._runtime._runtime import UiPathScriptRuntime
+from uipath._cli._runtime._runtime_factory import generate_runtime_factory
 from uipath._cli._utils._constants import UIPATH_PROJECT_ID
 from uipath._cli._utils._folders import get_personal_workspace_key_async
 from uipath._cli.middlewares import Middlewares
@@ -96,6 +92,15 @@ def eval(
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
     """
+    context_args = {
+        "entrypoint": entrypoint or auto_discover_entrypoint(),
+        "eval_set": eval_set,
+        "eval_ids": eval_ids,
+        "workers": workers,
+        "no_report": no_report,
+        "output_file": output_file,
+    }
+
     should_register_progress_reporter = setup_reporting_prereq(no_report)
 
     result = Middlewares.next(
@@ -119,16 +124,9 @@ def eval(
             progress_reporter = StudioWebProgressReporter(LlmOpsHttpExporter())
             asyncio.run(progress_reporter.subscribe_to_eval_runtime_events(event_bus))
 
-        def generate_runtime_context(**context_kwargs) -> UiPathRuntimeContext:
-            runtime_context = UiPathRuntimeContext.with_defaults(**context_kwargs)
-            runtime_context.entrypoint = runtime_entrypoint
-            return runtime_context
-
-        runtime_entrypoint = entrypoint or auto_discover_entrypoint()
-
         eval_context = UiPathEvalContext.with_defaults(
             execution_output_file=output_file,
-            entrypoint=runtime_entrypoint,
+            entrypoint=context_args["entrypoint"],
         )
 
         eval_context.no_report = no_report
@@ -140,11 +138,7 @@ def eval(
         asyncio.run(console_reporter.subscribe_to_eval_runtime_events(event_bus))
 
         try:
-            runtime_factory = UiPathRuntimeFactory(
-                UiPathScriptRuntime,
-                UiPathRuntimeContext,
-                context_generator=generate_runtime_context,
-            )
+            runtime_factory = generate_runtime_factory()
             if eval_context.job_id:
                 runtime_factory.add_span_exporter(LlmOpsHttpExporter())
 

{uipath-2.1.96 → uipath-2.1.98}/src/uipath/_cli/cli_init.py

@@ -5,7 +5,6 @@ import logging
 import os
 import shutil
 import uuid
-from pathlib import Path
 from typing import Any, Dict, Optional
 
 import click
@@ -13,11 +12,11 @@ import click
 from .._utils.constants import ENV_TELEMETRY_ENABLED
 from ..telemetry import track
 from ..telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
+from ._runtime._runtime import get_user_script
+from ._runtime._runtime_factory import generate_runtime_factory
 from ._utils._console import ConsoleLogger
-from ._utils._input_args import generate_args
-from ._utils._parse_ast import generate_bindings
 from .middlewares import Middlewares
-from .models.runtime_schema import Bindings, Entrypoint, RuntimeSchema
+from .models.runtime_schema import Bindings, RuntimeSchema
 
 console = ConsoleLogger()
 logger = logging.getLogger(__name__)
@@ -126,33 +125,6 @@ def get_existing_settings(config_path: str) -> Optional[Dict[str, Any]]:
         return None
 
 
-def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optional[str]:
-    """Find the Python script to process."""
-    if entrypoint:
-        script_path = os.path.join(directory, entrypoint)
-        if not os.path.isfile(script_path):
-            console.error(
-                f"The {entrypoint} file does not exist in the current directory."
-            )
-            return None
-        return script_path
-
-    python_files = [f for f in os.listdir(directory) if f.endswith(".py")]
-
-    if not python_files:
-        console.error(
-            "No python files found in the current directory.\nPlease specify the entrypoint: `uipath init <entrypoint_path>`"
-        )
-        return None
-    elif len(python_files) == 1:
-        return os.path.join(directory, python_files[0])
-    else:
-        console.error(
-            "Multiple python files found in the current directory.\nPlease specify the entrypoint: `uipath init <entrypoint_path>`"
-        )
-        return None
-
-
 def write_config_file(config_data: Dict[str, Any] | RuntimeSchema) -> None:
     existing_settings = get_existing_settings(CONFIG_PATH)
     if existing_settings is not None:
@@ -205,39 +177,28 @@ def init(entrypoint: str, infer_bindings: bool) -> None:
 
         generate_agent_md_files(current_directory)
         script_path = get_user_script(current_directory, entrypoint=entrypoint)
-
         if not script_path:
             return
 
-        try:
-            args = generate_args(script_path)
-
-            relative_path = Path(script_path).relative_to(current_directory).as_posix()
-            bindings = None
-            if infer_bindings:
-                try:
-                    bindings = generate_bindings(script_path)
-                except Exception as e:
-                    console.warning(f"Warning: Could not generate bindings: {str(e)}")
-            if bindings is None:
+        context_args = {
+            "runtime_dir": os.getcwd(),
+            "entrypoint": script_path,
+        }
+
+        def initialize() -> None:
+            try:
+                runtime = generate_runtime_factory().new_runtime(**context_args)
                 bindings = Bindings(
                     version="2.0",
-                    resources=[],
+                    resources=runtime.get_binding_resources,
                 )
-            config_data = RuntimeSchema(
-                entrypoints=[
-                    Entrypoint(
-                        file_path=relative_path,
-                        unique_id=str(uuid.uuid4()),
-                        type="agent",
-                        input=args["input"],
-                        output=args["output"],
-                    )
-                ],
-                bindings=bindings,
-            )
+                config_data = RuntimeSchema(
+                    entryPoints=[runtime.get_entrypoint],
+                    bindings=bindings,
+                )
+                config_path = write_config_file(config_data)
+                console.success(f"Created '{config_path}' file.")
+            except Exception as e:
+                console.error(f"Error creating configuration file:\n {str(e)}")
 
-            config_path = write_config_file(config_data)
-            console.success(f"Created '{config_path}' file.")
-        except Exception as e:
-            console.error(f"Error creating configuration file:\n {str(e)}")
+        initialize()