cli ¶

@artifact_app.command(help="Clear built TensorRT & MIGraphxX artifacts.")
@onnx_app.command(help="Clear downloaded ONNX models.")
def clear(
    global_: Annotated[
        bool,
        cyclopts.Parameter(negative=(), show_default=False, env_var=["VSSCALE_CLEAR_GLOBAL", "VSSCALE_GLOBAL"]),
    ] = False,
) -> None:
    """
    Delete downloaded ONNX models or built TensorRT & MIGraphxX artifacts.

    If no model specs are provided, the entire directory is cleared.

    Args:
        global_: Whether to clear files in the global folder.
    """
    (cmd, *_), _, _ = app.parse_commands()

    match cmd:
        case "onnx":
            folder = get_onnx_folder(global_=global_)
        case "artifact":
            folder = get_artifacts_folder(global_=global_)
        case _:
            raise ValueError

    return shutil.rmtree(folder, ignore_errors=True)

@config_app.default
def config(
    file: Path | None = None,
    /,
    *provider: str,
    latest: bool | None = None,
    auto: bool | None = None,
    global_: bool | None = None,
    fallback: bool | None = None,
    assumeyes: Annotated[bool, cyclopts.Parameter(alias="-y", negative=(), show_default=False)] = False,
) -> None:
    """
    Write or update vsscale configuration in pyproject.toml or vsjet.toml.

    Args:
        file: Target configuration file ('pyproject.toml' or 'vsjet.toml').
        provider: Default ONNX model(s) to configure (e.g. 'ArtCNN', 'DPIR', 'Waifu2x').
        latest: Whether to download latest model releases by default.
        auto: Whether to automatically download missing models on demand.
        global_: Whether to use global cache directory by default.
        fallback: Whether to enable global cache fallback.
        assumeyes: Answer yes for all questions and skip interactive wizard.
    """
    if file is None:
        toml = "pyproject.toml" if Path("pyproject.toml").exists() else "vsjet.toml"
        if assumeyes:
            target_path = Path(toml)
        else:
            choices = [
                quest.Choice("pyproject.toml", value="pyproject.toml"),
                quest.Choice("vsjet.toml", value="vsjet.toml"),
            ]
            selected = quest.select("Select configuration file target:", choices, toml, qmark="📝").ask()
            if selected is None:
                raise SystemExit(0)
            target_path = Path(selected)
    else:
        target_path = Path(file)

    if not assumeyes:
        if global_ is None:
            global_ = quest.confirm("Use global cache directory by default?", default=False, qmark="🌐").ask()
            if global_ is None:
                raise SystemExit(0)

        if fallback is None:
            fallback = quest.confirm(
                "Enable global cache fallback if local model is missing?", default=True, qmark="🔄"
            ).ask()
            if fallback is None:
                raise SystemExit(0)

        if not provider:
            choices = [quest.Choice(title=name, value=name, checked=True) for name in Feed.all_feeds]
            providers = quest.checkbox("Select default ONNX models to configure:", choices=choices, qmark="📦").ask()
            if providers is None:
                raise SystemExit(0)
            provider = tuple(providers)

        if latest is None:
            latest = quest.confirm("Download latest model release automatically?", default=True, qmark="🏷️").ask()
            if latest is None:
                raise SystemExit(0)

        if auto is None:
            auto = quest.confirm("Auto-download models when used in Python?", default=True, qmark="⚡").ask()
            if auto is None:
                raise SystemExit(0)

    written_path = write_toml_config(
        target_path,
        global_=global_,
        fallback=fallback,
        provider=provider,
        latest=latest,
        auto=auto,
    )

    _display(INFO, "[green]✔ Successfully updated configuration in [bold]%s[/bold][/green]", written_path.name)

@onnx_app.command(help_formatter=_custom_help_formatter)
async def download(
    *provider: Annotated[str, cyclopts.Parameter(name="--provider")],
    latest: Annotated[
        bool,
        cyclopts.Parameter(negative=(), show_default=False, env_var="VSSCALE_LATEST"),
    ] = False,
    global_: Annotated[
        bool,
        cyclopts.Parameter(negative=(), show_default=False, env_var="VSSCALE_GLOBAL"),
    ] = False,
    assumeyes: Annotated[
        bool,
        cyclopts.Parameter(alias="-y", negative=(), show_default=False),
    ] = False,
    console: Annotated[Console | None, cyclopts.Parameter(parse=False)] = None,
) -> None:
    """
    Download ONNX models.

    Supports multiple invocation styles:
      - Interactive:        vsscale onnx download
      - Pick tag for model: vsscale onnx download ArtCNN
      - Pinned version:     vsscale onnx download ArtCNN==v1.6.2
      - Latest release:     vsscale onnx download ArtCNN --latest

    If a `vsjet.toml` or a `pyproject.toml` file is detected with a valid configuration,
    the interactive mode may be partially or fully skipped.

    Args:
        provider: The ONNX model(s) to download. Possible choices: "ArtCNN", "DPIR", "Waifu2X".
            Use '==' syntax to pin a version (e.g. ArtCNN==v1.6.2).
        latest: Whether to automatically download all models from the latest release.
        global_: Whether to download models to the global folder.
        assumeyes: Answer yes for all questions.
    """
    if not provider:
        # Fully interactive: pick model, then tag, then assets
        feed = await _select_model()
        releases = await _fetch_releases(feed)
        release = await _select_tag(releases)
        assets = await _select_assets(release)
        dest_folder = get_onnx_folder(global_=global_) / feed.display_name.lower() / release.tag
        if not assumeyes:
            await _confirm_download(dest_folder)
        return await _download_assets(feed, assets, dest_folder)

    for spec in provider:
        model_name, pinned_version = _parse_model_spec(spec)
        feed = _find_feed(model_name)

        releases = await _fetch_releases(feed, console=console)

        if pinned_version is not None:
            release = next((r for r in releases if r.tag == pinned_version), None)

            if not release:
                raise ValueError(
                    f"Version {pinned_version} not found. Available versions: {', '.join(r.tag for r in releases[:10])}"
                )

            assets = release.assets
        elif latest:
            release = releases[0]
            assets = release.assets
            _display(
                INFO,
                "[bold]Latest release for %s: %s (%s)[/bold]",
                feed.display_name,
                release.tag,
                release.published_at[:10],
            )
        else:
            release = await _select_tag(releases)
            assets = await _select_assets(release)

        dest_folder = get_onnx_folder(global_=global_) / feed.display_name.lower() / release.tag

        if not assumeyes:
            await _confirm_download(dest_folder)
        await _download_assets(feed, assets, dest_folder, console=console)
        _display(INFO, "")

@app.meta.default
def meta_main(
    *tokens: Annotated[str, cyclopts.Parameter(show=False, allow_leading_hyphen=True)],
    no_config: Annotated[
        bool,
        cyclopts.Parameter(
            negative=(),
            show_default=False,
            help="Ignore TOML configuration files and environment variables.",
        ),
    ] = False,
) -> None:
    os.environ["VSSCALE_CLI"] = "1"
    if no_config:
        app.config = None
    try:
        app(tokens)
    except Exception as e:  # noqa: BLE001
        app.console.print(f"[red]{e.__class__.__name__}:[/red] {e}")
        raise SystemExit(1)

@artifact_app.command(help="List built TensorRT & MIGraphxX artifacts.")
@onnx_app.command(help="List downloaded ONNX models.")
def show(
    global_: Annotated[
        bool,
        cyclopts.Parameter(
            negative=(),
            show_default=False,
            env_var=["VSSCALE_SHOW_GLOBAL", "VSSCALE_GLOBAL"],
        ),
    ] = False,
) -> None:
    """
    List downloaded ONNX models or built TensorRT & MIGraphxX artifacts.

    Args:
        global_: Whether to show models in the global folder.
    """
    (cmd, *_), _, _ = app.parse_commands()

    match cmd:
        case "onnx":
            folder = get_onnx_folder(global_=global_)
            ext = [".onnx"]
        case "artifact":
            folder = get_artifacts_folder(global_=global_)
            ext = [".mxr", ".engine", ".cache"]
        case _:
            raise ValueError

    files = (f for f in folder.glob("**/*", case_sensitive=False) if f.suffix in ext)
    return print(pretty_repr(sorted(files, reverse=True)))

@config_app.command(name="show")
def show_config() -> None:
    """Display the currently active vsscale configuration."""
    config = get_toml_config()
    detected_file = None
    for config_file in TOML_CONFIG:
        p = Path(config_file).expanduser().resolve().absolute()
        if p.exists():
            detected_file = p
            break

    if detected_file:
        _display(INFO, "[bold]Active configuration file:[/bold] [cyan]%s[/cyan]", detected_file)
    else:
        _display(WARNING, "No active configuration file found.")

    _display(INFO, pretty_repr(config))