ruyi 0.39.0__py3-none-any.whl

ruyi/cli/self_cli.py

@@ -0,0 +1,295 @@
+import argparse
+import os
+import pathlib
+import shutil
+from typing import Final, TYPE_CHECKING
+
+from .cmd import RootCommand
+
+if TYPE_CHECKING:
+    from .completion import ArgumentParser
+    from .. import config
+
+UNINSTALL_NOTICE: Final = """
+[bold]Thanks for hacking with [yellow]Ruyi[/]![/]
+
+This will uninstall [yellow]Ruyi[/] from your system, and optionally remove
+all installed packages and [yellow]Ruyi[/]-managed repository data if the
+[green]--purge[/] switch is given on the command line.
+
+Note that your [yellow]Ruyi[/] virtual environments [bold]will become unusable[/] after
+[yellow]Ruyi[/] is uninstalled. You should take care of migrating or cleaning
+them yourselves afterwards.
+"""
+
+
+# Self-management commands
+class SelfCommand(
+    RootCommand,
+    cmd="self",
+    has_subcommands=True,
+    help="Manage this Ruyi installation",
+):
+    @classmethod
+    def configure_args(
+        cls,
+        gc: "config.GlobalConfig",
+        p: "ArgumentParser",
+    ) -> None:
+        pass
+
+
+class SelfCleanCommand(
+    SelfCommand,
+    cmd="clean",
+    help="Remove various Ruyi-managed data to reclaim storage",
+):
+    @classmethod
+    def configure_args(
+        cls,
+        gc: "config.GlobalConfig",
+        p: "ArgumentParser",
+    ) -> None:
+        p.add_argument(
+            "--quiet",
+            "-q",
+            action="store_true",
+            help="Do not print out the actions being performed",
+        )
+        p.add_argument(
+            "--all",
+            action="store_true",
+            help="Remove all covered data",
+        )
+        p.add_argument(
+            "--distfiles",
+            action="store_true",
+            help="Remove all downloaded distfiles if any",
+        )
+        p.add_argument(
+            "--installed-pkgs",
+            action="store_true",
+            help="Remove all installed packages if any",
+        )
+        p.add_argument(
+            "--news-read-status",
+            action="store_true",
+            help="Mark all news items as unread",
+        )
+        p.add_argument(
+            "--progcache",
+            action="store_true",
+            help="Clear the Ruyi program cache",
+        )
+        p.add_argument(
+            "--repo",
+            action="store_true",
+            help="Remove the Ruyi repo if located in Ruyi-managed cache directory",
+        )
+        p.add_argument(
+            "--telemetry",
+            action="store_true",
+            help="Remove all telemetry data recorded if any",
+        )
+
+    @classmethod
+    def main(cls, cfg: "config.GlobalConfig", args: argparse.Namespace) -> int:
+        logger = cfg.logger
+        quiet: bool = args.quiet
+        all: bool = args.all
+        distfiles: bool = args.distfiles
+        installed_pkgs: bool = args.installed_pkgs
+        news_read_status: bool = args.news_read_status
+        progcache: bool = args.progcache
+        repo: bool = args.repo
+        telemetry: bool = args.telemetry
+
+        if all:
+            distfiles = True
+            installed_pkgs = True
+            news_read_status = True
+            progcache = True
+            repo = True
+            telemetry = True
+
+        if not any(
+            [
+                distfiles,
+                installed_pkgs,
+                news_read_status,
+                progcache,
+                repo,
+                telemetry,
+            ]
+        ):
+            logger.F("no data specified for cleaning")
+            logger.I(
+                "please check [yellow]ruyi self clean --help[/] for a list of cleanable data"
+            )
+            return 1
+
+        _do_reset(
+            cfg,
+            quiet=quiet,
+            distfiles=distfiles,
+            installed_pkgs=installed_pkgs,
+            news_read_status=news_read_status,
+            progcache=progcache,
+            repo=repo,
+            telemetry=telemetry,
+        )
+
+        return 0
+
+
+class SelfUninstallCommand(
+    SelfCommand,
+    cmd="uninstall",
+    help="Uninstall Ruyi",
+):
+    @classmethod
+    def configure_args(
+        cls,
+        gc: "config.GlobalConfig",
+        p: "ArgumentParser",
+    ) -> None:
+        p.add_argument(
+            "--purge",
+            action="store_true",
+            help="Remove all installed packages and Ruyi-managed remote repo data",
+        )
+        p.add_argument(
+            "-y",
+            action="store_true",
+            dest="consent",
+            help="Give consent for uninstallation on CLI; do not ask for confirmation",
+        )
+
+    @classmethod
+    def main(cls, cfg: "config.GlobalConfig", args: argparse.Namespace) -> int:
+        from . import user_input
+
+        logger = cfg.logger
+        purge: bool = args.purge
+        consent: bool = args.consent
+        logger.D(f"ruyi self uninstall: purge={purge}, consent={consent}")
+
+        if cfg.is_installation_externally_managed:
+            logger.F(
+                "this [yellow]ruyi[/] is externally managed, for example, by the system package manager, and cannot be uninstalled this way"
+            )
+            logger.I("please uninstall via the external manager instead")
+            return 1
+
+        if not cfg.is_packaged:
+            logger.F(
+                "this [yellow]ruyi[/] is not in standalone form, and cannot be uninstalled this way"
+            )
+            return 1
+
+        if not consent:
+            logger.stdout(UNINSTALL_NOTICE)
+            if not user_input.ask_for_yesno_confirmation(logger, "Continue?"):
+                logger.I("aborting uninstallation")
+                return 0
+        else:
+            logger.I("uninstallation consent given over CLI, proceeding")
+
+        _do_reset(
+            cfg,
+            quiet=False,
+            installed_pkgs=purge,
+            all_state=purge,
+            all_cache=purge,
+            self_binary=True,
+        )
+
+        logger.I("[yellow]ruyi[/] is uninstalled")
+
+        return 0
+
+
+def _do_reset(
+    cfg: "config.GlobalConfig",
+    quiet: bool = False,
+    *,
+    installed_pkgs: bool = False,
+    all_state: bool = False,
+    news_read_status: bool = False,  # ignored if all_state=True
+    telemetry: bool = False,  # ignored if all_state=True
+    all_cache: bool = False,
+    distfiles: bool = False,  # ignored if all_cache=True
+    progcache: bool = False,  # ignored if all_cache=True
+    repo: bool = False,  # ignored if all_cache=True
+    self_binary: bool = False,
+) -> None:
+    logger = cfg.logger
+
+    def status(s: str) -> None:
+        if quiet:
+            return
+        logger.I(s)
+
+    if installed_pkgs:
+        status("removing installed packages")
+        shutil.rmtree(cfg.data_root, True)
+
+    # do not record any telemetry data if we're purging it
+    if all_state or telemetry:
+        if tm := cfg.telemetry:
+            tm.discard_events(True)
+
+    if all_state:
+        status("removing state data")
+        shutil.rmtree(cfg.state_root, True)
+    else:
+        if news_read_status:
+            status("removing read status of news items")
+            cfg.news_read_status.remove()
+
+        if telemetry:
+            status("removing all telemetry data")
+            shutil.rmtree(cfg.telemetry_root, True)
+
+    if all_cache:
+        status("removing cached data")
+        shutil.rmtree(cfg.cache_root, True)
+    else:
+        if distfiles:
+            status("removing downloaded distfiles")
+            # TODO: deduplicate the path derivation
+            shutil.rmtree(os.path.join(cfg.cache_root, "distfiles"), True)
+
+        if progcache:
+            status("clearing the Ruyi program cache")
+            # TODO: deduplicate the path derivation
+            shutil.rmtree(os.path.join(cfg.cache_root, "progcache"), True)
+
+        if repo:
+            # for safety, don't remove the repo if it's outside of Ruyi's XDG
+            # cache root
+            repo_dir = pathlib.Path(cfg.get_repo_dir()).resolve()
+            cache_root = pathlib.Path(cfg.cache_root).resolve()
+
+            repo_is_below_cache_root = False
+            for p in repo_dir.parents:
+                if p == cache_root:
+                    repo_is_below_cache_root = True
+                    break
+
+            if not repo_is_below_cache_root:
+                logger.W(
+                    "not removing the Ruyi repo: it is outside of the Ruyi cache directory"
+                )
+            else:
+                status("removing the Ruyi repo")
+                shutil.rmtree(repo_dir, True)
+
+    if self_binary:
+        status("removing the ruyi binary")
+        try:
+            os.unlink(cfg.self_exe)
+        except FileNotFoundError:
+            # we might have already removed ourselves during the purge; nothing to
+            # do now.
+            pass

ruyi/cli/user_input.py

@@ -0,0 +1,127 @@
+import os.path
+
+from ..log import RuyiLogger
+
+
+def pause_before_continuing(
+    logger: RuyiLogger,
+) -> None:
+    """Pause and wait for the user to press Enter before continuing.
+
+    EOFError should be handled by the caller."""
+
+    logger.stdout("Press [green]<ENTER>[/] to continue: ", end="")
+    input()
+
+
+def ask_for_yesno_confirmation(
+    logger: RuyiLogger,
+    prompt: str,
+    default: bool = False,
+) -> bool:
+    choices_help = "(Y/n)" if default else "(y/N)"
+
+    while True:
+        try:
+            logger.stdout(f"{prompt} {choices_help} ", end="")
+            user_input = input()
+        except EOFError:
+            yesno = "YES" if default else "NO"
+            logger.W(
+                f"EOF while reading user input, assuming the default choice {yesno}"
+            )
+            return default
+
+        if not user_input:
+            return default
+        if user_input in {"Y", "y", "yes"}:
+            return True
+        if user_input in {"N", "n", "no"}:
+            return False
+        else:
+            logger.stdout(f"Unrecognized input [yellow]'{user_input}'[/].")
+            logger.stdout("Accepted choices: Y/y/yes for YES, N/n/no for NO.")
+
+
+def ask_for_kv_choice(
+    logger: RuyiLogger,
+    prompt: str,
+    choices_kv: dict[str, str],
+    default_key: str | None = None,
+) -> str:
+    choices_kv_list = list(choices_kv.items())
+    choices_prompts = [i[1] for i in choices_kv_list]
+
+    default_idx: int | None = None
+    if default_key is not None:
+        for i, k in enumerate(choices_kv_list):
+            if k[0] == default_key:
+                default_idx = i
+                break
+        if default_idx is None:
+            raise ValueError(f"Default choice key '{default_key}' not in choices")
+
+    choice = ask_for_choice(logger, prompt, choices_prompts, default_idx)
+    return choices_kv_list[choice][0]
+
+
+def ask_for_choice(
+    logger: RuyiLogger,
+    prompt: str,
+    choices_texts: list[str],
+    default_idx: int | None = None,
+) -> int:
+    logger.stdout(prompt, end="\n\n")
+    for i, choice_text in enumerate(choices_texts):
+        logger.stdout(f"  {i + 1}. {choice_text}")
+
+    logger.stdout("")
+
+    nr_choices = len(choices_texts)
+    if default_idx is not None:
+        if not (0 <= default_idx < nr_choices):
+            raise ValueError(f"Default choice index {default_idx} out of range")
+        choices_help = f"(1-{nr_choices}, default {default_idx + 1})"
+    else:
+        choices_help = f"(1-{nr_choices})"
+    while True:
+        try:
+            user_input = input(f"Choice? {choices_help} ")
+        except EOFError:
+            raise ValueError("EOF while reading user choice")
+
+        if default_idx is not None and not user_input:
+            return default_idx
+
+        try:
+            choice_int = int(user_input)
+        except ValueError:
+            logger.stdout(f"Unrecognized input [yellow]'{user_input}'[/].")
+            logger.stdout(
+                f"Accepted choices: an integer number from 1 to {nr_choices} inclusive."
+            )
+            continue
+
+        if 1 <= choice_int <= nr_choices:
+            return choice_int - 1
+
+        logger.stdout(f"Out-of-range input [yellow]'{user_input}'[/].")
+        logger.stdout(
+            f"Accepted choices: an integer number from 1 to {nr_choices} inclusive."
+        )
+
+
+def ask_for_file(
+    logger: RuyiLogger,
+    prompt: str,
+) -> str:
+    while True:
+        try:
+            user_input = input(f"{prompt} ")
+        except EOFError:
+            raise ValueError("EOF while reading user input")
+
+        if os.path.exists(user_input):
+            return user_input
+
+        logger.stdout(f"[yellow]'{user_input}'[/] is not a path to an existing file.")

ruyi/cli/version_cli.py

@@ -0,0 +1,45 @@
+import argparse
+from typing import TYPE_CHECKING
+
+from .cmd import RootCommand
+
+if TYPE_CHECKING:
+    from .completion import ArgumentParser
+    from ..config import GlobalConfig
+
+
+class VersionCommand(
+    RootCommand,
+    cmd="version",
+    help="Print version information",
+):
+    @classmethod
+    def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
+        pass
+
+    @classmethod
+    def main(cls, cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+        return cli_version(cfg, args)
+
+
+def cli_version(cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+    import ruyi
+    from ..ruyipkg.host import get_native_host
+    from ..version import COPYRIGHT_NOTICE, MPL_REDIST_NOTICE, RUYI_SEMVER
+
+    print(f"Ruyi {RUYI_SEMVER}\n\nRunning on {get_native_host()}.")
+
+    if cfg.is_installation_externally_managed:
+        print("This Ruyi installation is externally managed.")
+
+    print()
+
+    cfg.logger.stdout(COPYRIGHT_NOTICE)
+
+    # Output the MPL notice only when we actually bundle and depend on the
+    # MPL component(s), which right now is only certifi. Keep the condition
+    # synced with __main__.py.
+    if hasattr(ruyi, "__compiled__") and ruyi.__compiled__.standalone:
+        cfg.logger.stdout(MPL_REDIST_NOTICE)
+
+    return 0