uipath 2.1.131__tar.gz → 2.1.132__tar.gz

{uipath-2.1.131 → uipath-2.1.132}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.131"
+version = "2.1.132"
 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.131 → uipath-2.1.132}/src/uipath/_cli/__init__.py

@@ -4,6 +4,7 @@ import sys
 import click
 
 from ._utils._common import add_cwd_to_path, load_environment_variables
+from ._utils._context import CliContext
 from .cli_add import add as add
 from .cli_auth import auth as auth
 from .cli_debug import debug as debug  # type: ignore
@@ -20,6 +21,9 @@ from .cli_push import push as push  # type: ignore
 from .cli_register import register as register  # type: ignore
 from .cli_run import run as run  # type: ignore
 
+load_environment_variables()
+add_cwd_to_path()
+
 
 def _get_safe_version() -> str:
     """Get the version of the uipath package."""
@@ -46,9 +50,39 @@ def _get_safe_version() -> str:
     is_flag=True,
     help="Display the current version of uipath.",
 )
-def cli(lv: bool, v: bool) -> None:
-    load_environment_variables()
-    add_cwd_to_path()
+@click.option(
+    "--format",
+    type=click.Choice(["json", "table", "csv"]),
+    default="table",
+    help="Output format for commands",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debug logging and show stack traces",
+)
+@click.pass_context
+def cli(
+    ctx: click.Context,
+    lv: bool,
+    v: bool,
+    format: str,
+    debug: bool,
+) -> None:
+    """UiPath CLI - Automate everything.
+
+    \b
+    Examples:
+        uipath new my-project
+        uipath dev
+        uipath deploy
+        uipath buckets list --folder-path "Shared"
+    """  # noqa: D301
+    ctx.obj = CliContext(
+        output_format=format,
+        debug=debug,
+    )
+
     if lv:
         try:
             version = importlib.metadata.version("uipath-langchain")
@@ -64,6 +98,10 @@ def cli(lv: bool, v: bool) -> None:
             click.echo("uipath is not installed", err=True)
             sys.exit(1)
 
+    # Show help if no command was provided (matches docker, kubectl, git behavior)
+    if ctx.invoked_subcommand is None and not lv and not v:
+        click.echo(ctx.get_help())
+
 
 cli.add_command(new)
 cli.add_command(init)
@@ -80,3 +118,7 @@ cli.add_command(dev)
 cli.add_command(add)
 cli.add_command(register)
 cli.add_command(debug)
+
+from .services import register_service_commands  # noqa: E402
+
+register_service_commands(cli)

{uipath-2.1.131 → uipath-2.1.132}/src/uipath/_cli/_runtime/_contracts.py

@@ -384,6 +384,7 @@ class UiPathRuntimeContext(BaseModel):
     chat_handler: Optional[UiPathConversationHandler] = None
     is_conversational: Optional[bool] = None
     breakpoints: Optional[List[str] | Literal["*"]] = None
+    intercept_logs: bool = True
 
     model_config = {"arbitrary_types_allowed": True, "extra": "allow"}
 
@@ -631,16 +632,17 @@ class UiPathBaseRuntime(ABC):
 
         # Intercept all stdout/stderr/logs
         # write to file (runtime) or stdout (debug)
-        self.logs_interceptor = LogsInterceptor(
-            min_level=self.context.logs_min_level,
-            dir=self.context.runtime_dir,
-            file=self.context.logs_file,
-            job_id=self.context.job_id,
-            execution_id=self.context.execution_id,
-            is_debug_run=self.is_debug_run(),
-            log_handler=self.context.log_handler,
-        )
-        self.logs_interceptor.setup()
+        if self.context.intercept_logs:
+            self.logs_interceptor = LogsInterceptor(
+                min_level=self.context.logs_min_level,
+                dir=self.context.runtime_dir,
+                file=self.context.logs_file,
+                job_id=self.context.job_id,
+                execution_id=self.context.execution_id,
+                is_debug_run=self.is_debug_run(),
+                log_handler=self.context.log_handler,
+            )
+            self.logs_interceptor.setup()
 
         logger.debug(f"Starting runtime with job id: {self.context.job_id}")
 

uipath-2.1.132/src/uipath/_cli/_utils/_context.py

@@ -0,0 +1,65 @@
+"""Type-safe context management for Click commands.
+
+This module provides type-safe access to CLI context across all commands,
+improving developer experience and enabling better IDE autocomplete.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+import click
+
+
+@dataclass
+class CliContext:
+    """CLI global context object.
+
+    This provides type-safe access to configuration shared across all commands.
+    Using a dataclass ensures all attributes are properly typed and documented.
+
+    Attributes:
+        output_format: Output format (table, json, csv)
+        debug: Enable debug logging
+
+    Note:
+        Authentication (URL and secret) are always read from environment variables
+        (UIPATH_URL and UIPATH_ACCESS_TOKEN).
+    """
+
+    output_format: str = "table"
+    debug: bool = False
+
+    _client: Any = field(default=None, init=False, repr=False)
+
+
+def get_cli_context(ctx: click.Context) -> CliContext:
+    """Type-safe helper to retrieve CliContext from Click context.
+
+    This eliminates repeated cast() calls and provides autocompletion
+    for CLI context attributes.
+
+    Args:
+        ctx: Click context object
+
+    Returns:
+        Typed CliContext object
+
+    Raises:
+        click.ClickException: If context object is not properly initialized
+
+    Example:
+        >>> @buckets.command()
+        >>> @click.pass_context
+        >>> def list(ctx):
+        ...     cli_ctx = get_cli_context(ctx)  # Fully typed!
+        ...     print(cli_ctx.output_format)  # Autocomplete works
+    """
+    if not isinstance(ctx.obj, CliContext):
+        raise click.ClickException(
+            "Internal error: CLI context not initialized. "
+            "This is a bug - please report it."
+        )
+    return ctx.obj
+
+
+pass_cli_context = click.make_pass_decorator(CliContext, ensure=True)

uipath-2.1.132/src/uipath/_cli/_utils/_formatters.py

@@ -0,0 +1,173 @@
+"""Output formatting for different output modes.
+
+This module provides consistent output formatting across all CLI commands,
+supporting multiple formats (table, JSON, CSV) with proper handling of
+Pydantic models, iterators, and large datasets.
+"""
+
+import csv
+import json
+from collections.abc import Generator, Iterator
+from io import StringIO
+from pathlib import Path
+from typing import Any, Optional
+
+import click
+
+
+def format_output(
+    data: Any,
+    fmt: str = "table",
+    output: Optional[str] = None,
+    no_color: bool = False,
+) -> None:
+    """Format and output data to stdout or file.
+
+    Handles:
+    - Pydantic models (via model_dump())
+    - Iterators and generators (converts to list)
+    - Lists, dicts, primitives
+    - Large datasets (warns at 10k+ items)
+
+    Args:
+        data: Data to format
+        fmt: Output format (json, table, csv)
+        output: Optional file path to write to
+        no_color: Disable colored output for table format
+
+    Example:
+        >>> format_output([{"name": "bucket1"}, {"name": "bucket2"}], fmt="table")
+        name
+        --------
+        bucket1
+        bucket2
+    """
+    if isinstance(data, (Iterator, Generator)):
+        data = list(data)
+        # Warn about large datasets
+        if len(data) > 10000:
+            click.echo(
+                f"Warning: Loading {len(data)} items into memory for formatting. "
+                "This may be slow or cause memory issues. "
+                "Consider using --limit or redirecting output for large datasets.",
+                err=True,
+            )
+
+    if hasattr(data, "model_dump"):
+        data = data.model_dump()
+    elif isinstance(data, list) and len(data) > 0 and hasattr(data[0], "model_dump"):
+        data = [item.model_dump() for item in data]
+
+    if hasattr(data, "__aiter__"):
+        raise TypeError(
+            "Async iterators not supported in CLI output. "
+            "Use synchronous methods or convert to list first."
+        )
+
+    if output and fmt == "table":
+        no_color = True
+
+    if fmt == "json":
+        text = _format_json(data)
+    elif fmt == "table":
+        text = _format_table(data, no_color=no_color)
+    elif fmt == "csv":
+        text = _format_csv(data)
+    else:
+        text = str(data)
+
+    if output:
+        Path(output).write_text(text, encoding="utf-8")
+        click.echo(f"Output written to {output}", err=True)
+    else:
+        click.echo(text)
+
+
+def _format_json(data: Any) -> str:
+    """Format data as JSON.
+
+    Args:
+        data: Data to format
+
+    Returns:
+        JSON string with 2-space indentation
+    """
+    return json.dumps(data, indent=2, default=str)
+
+
+def _format_table(data: Any, no_color: bool = False) -> str:
+    """Format data as simple table (AWS/Azure CLI style).
+
+    Uses a simple ASCII table format with column alignment similar to
+    AWS CLI and Azure CLI, avoiding fancy box-drawing characters.
+
+    Args:
+        data: Data to format
+        no_color: Disable colored output (ignored, kept for API compatibility)
+
+    Returns:
+        Formatted table string
+    """
+    items = data if isinstance(data, list) else [data]
+    if not items:
+        return "No results"
+
+    if not isinstance(items[0], dict):
+        items = [{"value": str(item)} for item in items]
+
+    columns = list(items[0].keys())
+
+    str_items = []
+    for item in items:
+        str_items.append({col: str(item.get(col, "")) for col in columns})
+
+    col_widths = {}
+    for col in columns:
+        col_widths[col] = len(col)
+        for item in str_items:
+            col_widths[col] = max(col_widths[col], len(item[col]))
+
+    header_parts = []
+    separator_parts = []
+    for col in columns:
+        header_parts.append(col.ljust(col_widths[col]))
+        separator_parts.append("-" * col_widths[col])
+
+    header = "  ".join(header_parts)
+    separator = "  ".join(separator_parts)
+
+    rows = []
+    for item in str_items:
+        row_parts = [item[col].ljust(col_widths[col]) for col in columns]
+        rows.append("  ".join(row_parts))
+
+    return "\n".join([header, separator, *rows])
+
+
+def _format_csv(data: Any) -> str:
+    """Format data as CSV.
+
+    Args:
+        data: Data to format
+
+    Returns:
+        CSV string with header
+    """
+    items = data if isinstance(data, list) else [data]
+    if not items:
+        return ""
+
+    if not isinstance(items[0], dict):
+        items = [{"value": str(item)} for item in items]
+
+    columns = list(items[0].keys())
+
+    output = StringIO()
+    writer = csv.DictWriter(output, fieldnames=columns, extrasaction="ignore")
+    writer.writeheader()
+
+    for item in items:
+        normalized_row = {col: item.get(col, "") for col in columns}
+        writer.writerow(normalized_row)
+
+    return output.getvalue()