confit.cli

def add_subcommands(
    self,
    cli: "Cli",
    *,
    name: Optional[str] = None,
    help: Optional[str] = None,
    short_help: Optional[str] = None,
    hidden: bool = False,
    deprecated: bool = False,
) -> None:
    """Add another Confit CLI as a group or flattened command entries"""
    if not isinstance(cli, Cli):
        raise TypeError("add_subcommands expects a Confit Cli instance")
    self.subcommands.append(
        {
            "cli": cli,
            "name": name,
            "help": help,
            "short_help": short_help,
            "hidden": hidden,
            "deprecated": deprecated,
        }
    )
    self.typer_cli = None

def add_typer(
    self,
    cli: "Cli",
    *,
    name: Optional[str] = None,
    help: Optional[str] = None,
    short_help: Optional[str] = None,
    hidden: bool = False,
    deprecated: bool = False,
) -> None:
    """Add Confit subcommands through the deprecated Typer compatible name"""
    warnings.warn(
        "Cli.add_typer() is deprecated, use Cli.add_subcommands() instead.",
        VisibleDeprecationWarning,
        stacklevel=2,
    )
    self.add_subcommands(
        cli,
        name=name,
        help=help,
        short_help=short_help,
        hidden=hidden,
        deprecated=deprecated,
    )

def command_entries(self):
    """Return the command and group entries used by dispatch and help"""
    entries = {
        name: {"kind": "command", "cli": self, "command": command}
        for name, command in self.commands.items()
    }
    for group in self.subcommands:
        if group["name"] is None:
            entries.update(group["cli"].command_entries())
        else:
            entries[group["name"]] = {
                "kind": "group",
                "cli": group["cli"],
                "group": group,
            }
    return entries

def format_commands_help(self):
    """Render the visible commands and groups for the current CLI level"""
    lines = ["Commands:"]
    for name, entry in self.command_entries().items():
        if entry["kind"] == "command":
            options = entry["command"]["typer_options"]
        else:
            options = entry["group"]
        if options["hidden"]:
            continue
        description = options.get("short_help") or options.get("help")
        suffix = " (deprecated)" if options["deprecated"] else ""
        if description:
            description = inspect.cleandoc(description).splitlines()[0]
            lines.append(f"  {name}{suffix}  {description}")
        else:
            lines.append(f"  {name}{suffix}")
    return "\n".join(lines)

def get_typer_cli(self):
    """Build and cache the Typer representation read by external Typer apps"""
    if self.typer_cli is not None:
        return self.typer_cli
    try:
        typer = importlib.import_module("typer")
    except ImportError as e:
        raise ImportError(
            "Typer interoperability requires the application to install "
            "and declare a dependency on 'typer'."
        ) from e

    if not self.typer_warning_emitted:
        warnings.warn(
            "Adapting a Confit Cli for Typer is deprecated and will be removed "
            "in the next major Confit release.",
            VisibleDeprecationWarning,
            stacklevel=3,
        )
        self.typer_warning_emitted = True

    typer_cli = typer.Typer(*self.typer_args, **self.typer_kwargs)
    for name, command in self.commands.items():
        options = dict(command["typer_options"])
        options["context_settings"] = {
            **(options["context_settings"] or {}),
            "ignore_unknown_options": True,
            "allow_extra_args": True,
        }

        def create_callback(command_name, command_record):
            def callback(
                ctx: typer.Context,
                config: Optional[List[Path]] = None,
            ):
                return self.run_command(
                    command_name,
                    command_record,
                    config,
                    list(ctx.args),
                )

            return callback

        typer_cli.command(name=name, **options)(create_callback(name, command))

    for group in self.subcommands:
        typer_cli.add_typer(
            group["cli"],
            name=group["name"],
            help=group["help"],
            short_help=group["short_help"],
            hidden=group["hidden"],
            deprecated=group["deprecated"],
        )
    self.typer_cli = typer_cli
    return typer_cli