feat!(cli): Switch to cyclopts for CI

pyproject.toml

@@ -7,17 +7,17 @@ description = "Evaluate Lidar-Inertial Odometry on public datasets"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
+    "cyclopts==4.0",
     "asteval>=1.0.6",
     "distinctipy>=1.3.4",
     "gdown>=5.2.0",
     "joblib>=1.5.2",
     "numpy",
     "polars>=1.33.1",
     "pyyaml>=6.0",
-    "rapidfuzz>=3.12.2",
+    "rapidfuzz>=3.14.1",
     "rosbags>=0.10.10",
     "tqdm>=4.66",
-    "typer>=0.15.3",
 ]
 keywords = [
     "lidar",
@@ -37,7 +37,7 @@ requires = ["scikit-build-core>=0.8", "nanobind>=2.9.2", "numpy"]
 build-backend = "scikit_build_core.build"
 
 [project.scripts]
-evalio = "evalio.cli:app"
+evalio = "evalio.cli:app.meta"
 
 # -------------- Tools -------------- #
 # building

python/evalio/cli/__init__.py

@@ -1,106 +1,201 @@
+from inspect import isclass
 from pathlib import Path
-from typing import Annotated, Any, Optional
-
-import typer
+from cyclopts import App, Group, Parameter
+from cyclopts.completion import detect_shell
+from cyclopts.help import DefaultFormatter, ColumnSpec, HelpEntry, PanelSpec, TableSpec
+from enum import Enum
+from rich.console import Console, ConsoleOptions
+from typing import Any, Union, get_args, get_origin, Literal, Annotated, Optional
+
+
+# ------------------------- Prettier Helper Pages ------------------------- #
+# Define custom column renderers
+def names_long(entry: HelpEntry) -> str:
+    """Combine parameter names and shorts."""
+    if not entry.names:
+        return ""
+    # If positional with single name, just return it
+    if len(entry.names) == 1:
+        return entry.names[0]
+    # If multiples, skip ALL_CAPS
+    if entry.names[0].isupper():
+        names = entry.names[1:]
+    else:
+        names = entry.names
+
+    return " ".join(names).strip()
+
+
+def render_type(type_: Any) -> str:
+    """Show the parameter type."""
+    if type_ is bool:
+        return ""
+    elif type_ is str:
+        return "text"
+    elif type_ is int:
+        return "int"
+    elif type_ is float:
+        return "float"
+    elif type_ is Path:
+        return "path"
+    elif type_ is None:
+        return ""
+    elif (origin := get_origin(type_)) is Literal:
+        args = get_args(type_)
+        if len(args) > 5:
+            return "text"
+        return "|".join(str(a) for a in args)
+    elif origin is Union:
+        # handle Optional
+        args = get_args(type_)
+        if len(args) == 2 and type(None) in args:
+            type_ = args[0] if args[1] is type(None) else args[1]
+            return render_type(type_)
+        else:
+            return " | ".join(render_type(t) for t in args)
+    elif origin is list:
+        return render_type(get_args(type_)[0])
+    elif isclass(type_) and issubclass(type_, Enum):
+        return "|".join(e.name for e in type_)
+
+    raise ValueError(f"Unsupported type for rendering: {type_}")
+
+
+def columns(
+    console: Console, options: ConsoleOptions, entries: list[HelpEntry]
+) -> list[ColumnSpec]:
+    columns: list[ColumnSpec] = []
+
+    if any(e.required for e in entries):
+        columns.append(
+            ColumnSpec(
+                renderer=lambda e: "*" if e.required else " ",  # type: ignore
+                width=1,
+                style="red bold",
+            )
+        )
+
+    columns.extend(
+        [
+            ColumnSpec(
+                renderer=names_long,
+                style="cyan",
+            ),
+            ColumnSpec(
+                renderer=lambda e: " ".join(e.shorts).strip() if e.shorts else "",  # type: ignore
+                style="green",
+                max_width=30,
+            ),
+            ColumnSpec(
+                renderer=lambda e: render_type(e.type),  # type: ignore
+                style="yellow",
+                justify="center",
+            ),
+            ColumnSpec(
+                renderer="description",  # Use attribute name
+                overflow="fold",
+            ),
+        ]
+    )
+
+    return columns
+
+
+# Create custom columns
+spec = DefaultFormatter(
+    table_spec=TableSpec(show_header=False),
+    column_specs=columns,  # type: ignore
+    panel_spec=PanelSpec(border_style="bright_black"),
+)
 
-import evalio
-from evalio.datasets import set_data_dir
 
-# import typer apps
-from .dataset_manager import app as app_dl
-from .ls import app as app_ls
-from .run import app as app_run
-from .stats import app as app_stats
+# ------------------------- Make CLI App ------------------------- #
+mg = Group("Misc", sort_key=1)
+gg = Group("Global Options", sort_key=100)
 
-app = typer.Typer(
+app = App(
     help="Tool for evaluating Lidar-Inertial Odometry pipelines on open-source datasets",
-    rich_markup_mode="rich",
-    no_args_is_help=True,
-    pretty_exceptions_enable=False,
+    help_formatter=spec,
+    help_on_error=True,
+    default_parameter=Parameter(negative=""),
+    version_flags=[],
 )
 
-app.add_typer(app_dl)
-app.add_typer(app_ls)
-app.add_typer(app_run)
-app.add_typer(app_stats)
+# Register commands
+app.register_install_completion_command(add_to_startup=True)  # type: ignore
+app.command("evalio.cli.ls:ls")
+app.command("evalio.cli.dataset_manager:dl")
+app.command("evalio.cli.dataset_manager:rm")
+app.command("evalio.cli.dataset_manager:filter")
+app.command("evalio.cli.stats:evaluate_cli", name="stats")
+app.command("evalio.cli.run:run_from_cli", name="run")
 
+# Assign groups
+app["--install-completion"].group = mg
+app["--help"].group = gg
 
-def version_callback(value: bool):
-    """
-    Show version and exit.
-    """
-    if value:
-        print(evalio.__version__)
-        raise typer.Exit()
+for c in app:
+    if c in ["--help", "-h"]:
+        continue
+    app[c]["--help"].group = gg
 
 
-def data_callback(value: Optional[Path]):
+@app.command(name="--show-completion", group=mg)
+def show_completion():
     """
-    Set the data directory.
+    Show shell completion script.
     """
-    if value is not None:
-        set_data_dir(value)
+    comp = app.generate_completion()
+    # zsh needs an extra line
+    if detect_shell() == "zsh":
+        comp += "compdef _evalio evalio"
+        # Fix wildcard completions
+        comp = comp.replace("/*", "/\\*")
+    print(comp)
 
 
-def module_callback(value: Optional[list[str]]) -> list[Any]:
+@app.command(name="--version", alias="-V", group=mg)
+def version():
     """
-    Set the module to use.
+    Show version and exit.
     """
-    if value is not None:
-        for module in value:
-            evalio._register_custom_modules(module)
+    import evalio
 
-    return []
+    print(evalio.__version__)
 
 
-@app.callback()
+@app.meta.default
 def global_options(
-    # Marking this as a str for now to get autocomplete to work,
-    # Once this fix is released (hasn't been as of 0.15.2), we can change it to a Path
-    # https://github.com/fastapi/typer/pull/1138
-    data_dir: Annotated[
-        Optional[Path],
-        typer.Option(
-            "-D",
-            "--data-dir",
-            help="Directory to store downloaded datasets.",
-            show_default=False,
-            rich_help_panel="Global options",
-            callback=data_callback,
-        ),
-    ] = None,
-    custom_modules: Annotated[
-        Optional[list[str]],
-        typer.Option(
-            "-M",
-            "--module",
-            help="Custom module to load (for custom datasets or pipelines). Can be used multiple times.",
-            show_default=False,
-            rich_help_panel="Global options",
-            callback=module_callback,
-        ),
-    ] = None,
-    version: Annotated[
-        bool,
-        typer.Option(
-            "--version",
-            "-V",
-            help="Show version and exit.",
-            is_eager=True,
-            show_default=False,
-            callback=version_callback,
-        ),
-    ] = False,
+    *tokens: Annotated[str, Parameter(show=False, allow_leading_hyphen=True)],
+    module: Annotated[Optional[list[str]], Parameter(alias="-M", group=gg)] = None,
+    data_dir: Annotated[Optional[Path], Parameter(alias="-D", group=gg)] = None,
 ):
+    """Define a number of global options that are set before any command is run.
+
+    Args:
+        module (list[str]): Custom module to import. Can be repeated.
+        data_dir (Optional[Path]): Directory to store downloaded datasets.
     """
-    Global options for the evalio CLI.
-    """
-    pass
+    # Register custom modules
+    if module is not None:
+        from evalio import _register_custom_modules
+
+        for m in module:
+            _register_custom_modules(m)
+
+    # Set data directory
+    if data_dir is not None:
+        from evalio.datasets import set_data_dir
+
+        set_data_dir(data_dir)
+
+    app(tokens)
+
+
+def launch():
+    app.meta()
 
 
 __all__ = [
     "app",
 ]
-
-if __name__ == "__main__":
-    app()