Merge pull request #411 from UiPath/feat/no-infer-bindings

chore: enhance CLI documentation and add settings retrieval functiona…

Author: gheorghitahurmuz

docs/cli/index.md

@@ -27,6 +27,10 @@ Selected tenant: Tenant1
     :depth: 1
     :style: table
 
+Package requirements (bindings) are dependencies that are required by the automation package for successful execution.
+
+For more information about package requirements, see  [the official documentation](https://docs.uipath.com/orchestrator/automation-cloud/latest/user-guide/managing-package-requirements)
+
 /// warning
 
 The `uipath init` command executes your `main.py` file to analyze its structure and collect information about inputs and outputs.

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.0.70"
+version = "2.0.71"
 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"

src/uipath/_cli/cli_init.py

@@ -3,7 +3,7 @@
 import os
 import uuid
 from pathlib import Path
-from typing import Optional
+from typing import Any, Dict, Optional
 
 import click
 from dotenv import load_dotenv
@@ -16,6 +16,8 @@
 
 console = ConsoleLogger()
 
+CONFIG_PATH = "uipath.json"
+
 
 def generate_env_file(target_directory):
     env_path = os.path.join(target_directory, ".env")
@@ -27,6 +29,26 @@ def generate_env_file(target_directory):
         console.success(f" Created '{relative_path}' file.")
 
 
+def get_existing_settings(config_path: str) -> Optional[Dict[str, Any]]:
+    """Read existing settings from uipath.json if it exists.
+
+    Args:
+        config_path: Path to the uipath.json file.
+
+    Returns:
+        The settings dictionary if it exists, None otherwise.
+    """
+    if not os.path.exists(config_path):
+        return None
+
+    try:
+        with open(config_path, "r") as config_file:
+            existing_config = json.load(config_file)
+            return existing_config.get("settings")
+    except (json.JSONDecodeError, IOError):
+        return None
+
+
 def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optional[str]:
     """Find the Python script to process."""
     if entrypoint:
@@ -52,10 +74,28 @@ def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optiona
         return None
 
 
+def write_config_file(config_data: Dict[str, Any]) -> None:
+    existing_settings = get_existing_settings(CONFIG_PATH)
+    if existing_settings is not None:
+        config_data["settings"] = existing_settings
+
+    with open(CONFIG_PATH, "w") as config_file:
+        json.dump(config_data, config_file, indent=4)
+
+    return CONFIG_PATH
+
+
 @click.command()
 @click.argument("entrypoint", required=False, default=None)
+@click.option(
+    "--infer-bindings/--no-infer-bindings",
+    is_flag=True,
+    required=False,
+    default=True,
+    help="Infer bindings from the script.",
+)
 @track
-def init(entrypoint: str) -> None:
+def init(entrypoint: str, infer_bindings: bool) -> None:
     """Create uipath.json with input/output schemas and bindings."""
     current_path = os.getcwd()
     load_dotenv(os.path.join(current_path, ".env"), override=True)
@@ -64,7 +104,12 @@ def init(entrypoint: str) -> None:
         current_directory = os.getcwd()
         generate_env_file(current_directory)
 
-        result = Middlewares.next("init", entrypoint)
+        result = Middlewares.next(
+            "init",
+            entrypoint,
+            options={"infer_bindings": infer_bindings},
+            write_config=write_config_file,
+        )
 
         if result.error_message:
             console.error(
@@ -102,16 +147,16 @@ def init(entrypoint: str) -> None:
 
             # Generate bindings JSON based on the script path
             try:
-                bindings_data = generate_bindings_json(script_path)
+                if infer_bindings:
+                    bindings_data = generate_bindings_json(script_path)
+                else:
+                    bindings_data = {}
                 # Add bindings to the config data
                 config_data["bindings"] = bindings_data
             except Exception as e:
                 console.warning(f"Warning: Could not generate bindings: {str(e)}")
 
-            config_path = "uipath.json"
-            with open(config_path, "w") as config_file:
-                json.dump(config_data, config_file, indent=4)
-
+            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)}")

src/uipath/_cli/middlewares.py

@@ -1,9 +1,13 @@
 import importlib.metadata
+import inspect
 import logging
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional
 
+from ._utils._console import ConsoleLogger
+
 logger = logging.getLogger(__name__)
+console = ConsoleLogger()
 
 
 @dataclass
@@ -50,8 +54,30 @@ def next(cls, command: str, *args: Any, **kwargs: Any) -> MiddlewareResult:
 
         middlewares = cls.get(command)
         for middleware in middlewares:
+            sig = inspect.signature(middleware)
+
+            # handle older versions of plugins that don't support the new signature
+            try:
+                bound = sig.bind(*args, **kwargs)
+                new_args = bound.args
+                new_kwargs = bound.kwargs
+            except TypeError:
+                console.warning("Install the latest version for uipath packages")
+                accepted_args = [
+                    name
+                    for name, param in sig.parameters.items()
+                    if param.kind
+                    in (param.POSITIONAL_ONLY, param.POSITIONAL_OR_KEYWORD)
+                ]
+
+                trimmed_args = args[: len(accepted_args)]
+                trimmed_kwargs = {k: v for k, v in kwargs.items() if k in accepted_args}
+
+                new_args = trimmed_args
+                new_kwargs = trimmed_kwargs
+
             try:
-                result = middleware(*args, **kwargs)
+                result = middleware(*new_args, **new_kwargs)
                 if not result.should_continue:
                     logger.debug(
                         f"Command '{command}' stopped by {middleware.__name__}"