feat: debug and output file support

Author: radu-mocanu

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.82"
+version = "2.1.0"
 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"
@@ -67,9 +67,6 @@ dev = [
   "types-toml>=0.10.8",
 ]
 
-[project.optional-dependencies]
-langchain = ["uipath-langchain>=0.0.88,<0.1.0"]
-
 [tool.hatch.build.targets.wheel]
 packages = ["src/uipath"]
 

src/uipath/_cli/_runtime/_contracts.py

@@ -148,11 +148,13 @@ class UiPathRuntimeContext(BaseModel):
     trace_context: Optional[UiPathTraceContext] = None
     tracing_enabled: Union[bool, str] = False
     resume: bool = False
+    debug: bool = False
     config_path: str = "uipath.json"
     runtime_dir: Optional[str] = "__uipath"
     logs_file: Optional[str] = "execution.log"
     logs_min_level: Optional[str] = "INFO"
     output_file: str = "output.json"
+    execution_output_file: str = "execution_output.json"
     state_file: str = "state.db"
     result: Optional[UiPathRuntimeResult] = None
 
@@ -187,6 +189,7 @@ def from_config(cls, config_path=None):
             mapping = {
                 "dir": "runtime_dir",
                 "outputFile": "output_file",
+                "executionOutputFile": "execution_output_file",
                 "stateFile": "state_file",
                 "logsFile": "logs_file",
             }
@@ -365,11 +368,14 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
             content = execution_result.to_dict()
             logger.debug(content)
 
-            # Always write output file at runtime
+            # Always write output and execution_output files at runtime
             if self.context.job_id:
                 with open(self.output_file_path, "w") as f:
                     json.dump(content, f, indent=2, default=str)
 
+                with open(self.execution_output_file_path, "w") as f:
+                    json.dump(execution_result.output or "", f, indent=2, default=str)
+
             # Don't suppress exceptions
             return False
 
@@ -424,6 +430,15 @@ def output_file_path(self) -> str:
             return os.path.join(self.context.runtime_dir, self.context.output_file)
         return os.path.join("__uipath", "output.json")
 
+    @cached_property
+    def execution_output_file_path(self) -> str:
+        if self.context.runtime_dir and self.context.execution_output_file:
+            os.makedirs(self.context.runtime_dir, exist_ok=True)
+            return os.path.join(
+                self.context.runtime_dir, self.context.execution_output_file
+            )
+        return os.path.join("__uipath", "execution_output.json")
+
     @cached_property
     def state_file_path(self) -> str:
         if self.context.runtime_dir and self.context.state_file:

src/uipath/_cli/cli_run.py

@@ -21,6 +21,7 @@
     UiPathTraceContext,
 )
 from ._runtime._runtime import UiPathRuntime
+from ._utils._common import serialize_object
 from ._utils._console import ConsoleLogger
 from .middlewares import MiddlewareResult, Middlewares
 
@@ -32,6 +33,7 @@ def python_run_middleware(
     entrypoint: Optional[str],
     input: Optional[str],
     resume: bool,
+    **kwargs,
 ) -> MiddlewareResult:
     """Middleware to handle Python script execution.
 
@@ -85,12 +87,14 @@ async def execute():
             )
             context.logs_min_level = env.get("LOG_LEVEL", "INFO")
             async with UiPathRuntime.from_context(context) as runtime:
-                await runtime.execute()
+                return await runtime.execute()
 
-        asyncio.run(execute())
+        result = asyncio.run(execute())
 
         # Return success
-        return MiddlewareResult(should_continue=False)
+        return MiddlewareResult(
+            should_continue=False, output=serialize_object(result.output)
+        )
 
     except UiPathRuntimeError as e:
         return MiddlewareResult(
@@ -118,6 +122,18 @@ async def execute():
     type=click.Path(exists=True),
     help="File path for the .json input",
 )
+@click.option(
+    "--input-file",
+    required=False,
+    type=click.Path(exists=True),
+    help="Alias for '-f/--file' arguments",
+)
+@click.option(
+    "--output-file",
+    required=False,
+    type=click.Path(exists=False),
+    help="File path where the output will be written",
+)
 @click.option(
     "--debug",
     is_flag=True,
@@ -135,30 +151,37 @@ def run(
     input: Optional[str],
     resume: bool,
     file: Optional[str],
+    input_file: Optional[str],
+    output_file: Optional[str],
     debug: bool,
     debug_port: int,
 ) -> None:
     """Execute the project."""
-    if file:
+    if file:= (file or input_file):
         _, file_extension = os.path.splitext(file)
         if file_extension != ".json":
             console.error("Input file extension must be '.json'.")
         with open(file) as f:
             input = f.read()
-    # Setup debugging if requested
 
+    # Setup debugging if requested
     if not setup_debugging(debug, debug_port):
         console.error(f"Failed to start debug server on port {debug_port}")
 
     # Process through middleware chain
-    result = Middlewares.next("run", entrypoint, input, resume)
+    result = Middlewares.next(
+        "run", entrypoint, input, resume, debug=debug, debug_port=debug_port
+    )
 
     if result.should_continue:
         result = python_run_middleware(
             entrypoint=entrypoint,
             input=input,
             resume=resume,
         )
+    if output_file:
+        with open(output_file, "w") as f:
+            f.write(str(result.output))
 
     # Handle result from middleware
     if result.error_message:

src/uipath/_cli/middlewares.py

@@ -16,6 +16,7 @@ class MiddlewareResult:
     info_message: Optional[str] = None
     error_message: Optional[str] = None
     should_include_stacktrace: bool = False
+    output: Optional[str] = None
 
 
 MiddlewareFunc = Callable[..., MiddlewareResult]
@@ -67,7 +68,7 @@ def next(cls, command: str, *args: Any, **kwargs: Any) -> MiddlewareResult:
                     name
                     for name, param in sig.parameters.items()
                     if param.kind
-                    in (param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD)
+                       in (param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD)
                 ]
 
                 trimmed_args = args[: len(accepted_args)]

tests/cli/test_run.py

@@ -100,7 +100,12 @@ def test_run_input_file_success(
                     assert "Successful execution." in result.output
                     assert mock_middleware.call_count == 1
                     assert mock_middleware.call_args == mock.call(
-                        "run", entrypoint, json_content, False
+                        "run",
+                        entrypoint,
+                        json_content,
+                        False,
+                        debug=False,
+                        debug_port=5678,
                     )
 
     class TestMiddleware: