ruyi 0.44.0a20251118__py3-none-any.whl → 0.45.0__py3-none-any.whl

ruyi/ruyipkg/fetcher.py

@@ -7,6 +7,7 @@ from typing import Any, Final
 import requests
 from rich import progress
 
+from ..i18n import _
 from ..log import RuyiLogger
 
 ENV_OVERRIDE_FETCHER: Final = "RUYI_OVERRIDE_FETCHER"
@@ -40,19 +41,31 @@ class BaseFetcher:
     ) -> bool:
         for t in range(retries):
             if t > 0:
-                self._logger.I(f"retrying download ({t + 1} of {retries} times)")
+                self._logger.I(
+                    _("retrying download ({current} of {total} times)").format(
+                        current=t + 1,
+                        total=retries,
+                    )
+                )
             if self.fetch_one(url, dest, resume):
                 return True
         return False
 
     def fetch(self, *, resume: bool = False, retries: int = 3) -> None:
         for url in self.urls:
-            self._logger.I(f"downloading {url} to {self.dest}")
+            self._logger.I(
+                _("downloading {url} to {dest}").format(
+                    url=url,
+                    dest=self.dest,
+                )
+            )
             if self.fetch_one_with_retry(url, self.dest, resume, retries):
                 return
         # all URLs have been tried and all have failed
         raise RuntimeError(
-            f"failed to fetch '{self.dest}': all source URLs have failed"
+            _("failed to fetch '{dest}': all source URLs have failed").format(
+                dest=self.dest,
+            )
         )
 
     @classmethod
@@ -78,7 +91,7 @@ def get_usable_fetcher_cls(logger: RuyiLogger) -> type[BaseFetcher]:
 
     if _fetcher_cache_populated:
         if _cached_usable_fetcher_class is None:
-            raise RuntimeError("no fetcher is available on the system")
+            raise RuntimeError(_("no fetcher is available on the system"))
         return _cached_usable_fetcher_class
 
     _fetcher_cache_populated = True
@@ -88,10 +101,16 @@ def get_usable_fetcher_cls(logger: RuyiLogger) -> type[BaseFetcher]:
 
         cls = KNOWN_FETCHERS.get(override_name)
         if cls is None:
-            raise RuntimeError(f"unknown fetcher '{override_name}'")
+            raise RuntimeError(
+                _("unknown fetcher '{name}'").format(
+                    name=override_name,
+                )
+            )
         if not cls.is_available(logger):
             raise RuntimeError(
-                f"the requested fetcher '{override_name}' is unavailable on the system"
+                _("the requested fetcher '{name}' is unavailable on the system").format(
+                    name=override_name,
+                )
             )
         _cached_usable_fetcher_class = cls
         return cls
@@ -103,7 +122,7 @@ def get_usable_fetcher_cls(logger: RuyiLogger) -> type[BaseFetcher]:
         _cached_usable_fetcher_class = cls
         return cls
 
-    raise RuntimeError("no fetcher is available on the system")
+    raise RuntimeError(_("no fetcher is available on the system"))
 
 
 class CurlFetcher(BaseFetcher):
@@ -152,7 +171,12 @@ class CurlFetcher(BaseFetcher):
         retcode = subprocess.call(argv)
         if retcode != 0:
             self._logger.W(
-                f"failed to fetch distfile: command '{' '.join(argv)}' returned {retcode}"
+                _(
+                    "failed to fetch distfile: command '{cmd}' returned {retcode}"
+                ).format(
+                    cmd=" ".join(argv),
+                    retcode=retcode,
+                )
             )
             return False
 
@@ -190,7 +214,12 @@ class WgetFetcher(BaseFetcher):
         retcode = subprocess.call(argv)
         if retcode != 0:
             self._logger.W(
-                f"failed to fetch distfile: command '{' '.join(argv)}' returned {retcode}"
+                _(
+                    "failed to fetch distfile: command '{cmd}' returned {retcode}"
+                ).format(
+                    cmd=" ".join(argv),
+                    retcode=retcode,
+                )
             )
             return False
 

ruyi/ruyipkg/install.py

@@ -8,6 +8,7 @@ from ruyi.ruyipkg.state import BoundInstallationStateStore
 
 from ..cli.user_input import ask_for_yesno_confirmation
 from ..config import GlobalConfig
+from ..i18n import _
 from ..telemetry.scope import TelemetryScope
 from .atom import Atom
 from .distfile import Distfile
@@ -43,12 +44,16 @@ def do_extract_atoms(
         a = Atom.parse(a_str)
         pm = a.match_in_repo(mr, cfg.include_prereleases)
         if pm is None:
-            logger.F(f"atom {a_str} matches no package in the repository")
+            logger.F(
+                _("atom {atom} matches no package in the repository").format(
+                    atom=a_str,
+                )
+            )
             return 1
 
         sv = pm.service_level
         if sv.has_known_issues:
-            logger.W("package has known issue(s)")
+            logger.W(_("package has known issue(s)"))
             for s in sv.render_known_issues(pm.repo.messages, cfg.lang_code):
                 logger.I(s)
 
@@ -97,12 +102,20 @@ def _do_extract_pkg(
     bm = pm.binary_metadata
     sm = pm.source_metadata
     if bm is None and sm is None:
-        logger.F(f"don't know how to extract package [green]{pkg_name}[/]")
+        logger.F(
+            _("don't know how to extract package [green]{pkg}[/]").format(
+                pkg=pkg_name,
+            )
+        )
         return 2
 
     if bm is not None and sm is not None:
         logger.F(
-            f"cannot handle package [green]{pkg_name}[/]: package is both binary and source"
+            _(
+                "cannot handle package [green]{pkg}[/]: package is both binary and source"
+            ).format(
+                pkg=pkg_name,
+            )
         )
         return 2
 
@@ -114,7 +127,10 @@ def _do_extract_pkg(
 
     if not distfiles_for_host:
         logger.F(
-            f"package [green]{pkg_name}[/] declares no distfile for host {canonicalized_host}"
+            _("package [green]{pkg}[/] declares no distfile for host {host}").format(
+                pkg=pkg_name,
+                host=canonicalized_host,
+            )
         )
         return 2
 
@@ -130,13 +146,21 @@ def _do_extract_pkg(
             logger.D("skipping extraction because [yellow]--fetch-only[/] is given")
             continue
 
-        logger.I(f"extracting [green]{df_name}[/] for package [green]{pkg_name}[/]")
+        logger.I(
+            _("extracting [green]{distfile}[/] for package [green]{pkg}[/]").format(
+                distfile=df_name,
+                pkg=pkg_name,
+            )
+        )
         # unpack into destination
         df.unpack(dest_dir, logger)
 
     if not fetch_only:
         logger.I(
-            f"package [green]{pkg_name}[/] has been extracted to {dest_dir}",
+            _("package [green]{pkg}[/] has been extracted to {dest_dir}").format(
+                pkg=pkg_name,
+                dest_dir=dest_dir,
+            )
         )
 
     return 0
@@ -158,27 +182,28 @@ def do_install_atoms(
         a = Atom.parse(a_str)
         pm = a.match_in_repo(mr, config.include_prereleases)
         if pm is None:
-            logger.F(f"atom {a_str} matches no package in the repository")
+            logger.F(
+                _("atom {atom} matches no package in the repository").format(atom=a_str)
+            )
             return 1
         pkg_name = pm.name_for_installation
 
         sv = pm.service_level
         if sv.has_known_issues:
-            logger.W("package has known issue(s)")
+            logger.W(_("package has known issue(s)"))
             for s in sv.render_known_issues(pm.repo.messages, config.lang_code):
                 logger.I(s)
 
-        if tm := config.telemetry:
-            tm.record(
-                TelemetryScope(mr.repo_id),
-                "repo:package-install-v1",
-                atom=a_str,
-                host=canonicalized_host,
-                pkg_category=pm.category,
-                pkg_kinds=pm.kind,
-                pkg_name=pm.name,
-                pkg_version=pm.ver,
-            )
+        config.telemetry.record(
+            TelemetryScope(mr.repo_id),
+            "repo:package-install-v1",
+            atom=a_str,
+            host=canonicalized_host,
+            pkg_category=pm.category,
+            pkg_kinds=pm.kind,
+            pkg_name=pm.name,
+            pkg_version=pm.ver,
+        )
 
         if pm.binary_metadata is not None:
             ret = _do_install_binary_pkg(
@@ -214,7 +239,11 @@ def do_install_atoms(
                 return ret
             continue
 
-        logger.F(f"don't know how to handle non-binary package [green]{pkg_name}[/]")
+        logger.F(
+            _("don't know how to handle non-binary package [green]{pkg}[/]").format(
+                pkg=pkg_name,
+            )
+        )
         return 2
 
     return 0
@@ -250,11 +279,17 @@ def _do_install_binary_pkg(
 
     if is_installed:
         if not reinstall:
-            logger.I(f"skipping already installed package [green]{pkg_name}[/]")
+            logger.I(
+                _("skipping already installed package [green]{pkg}[/]").format(
+                    pkg=pkg_name,
+                )
+            )
             return 0
 
         logger.W(
-            f"package [green]{pkg_name}[/] seems already installed; purging and re-installing due to [yellow]--reinstall[/]"
+            _(
+                "package [green]{pkg}[/] seems already installed; purging and re-installing due to [yellow]--reinstall[/]"
+            ).format(pkg=pkg_name)
         )
         # Remove from state tracking before purging
         rgs.remove_installation(
@@ -291,7 +326,12 @@ def _do_install_binary_pkg(
             install_path=install_root,
         )
 
-    logger.I(f"package [green]{pkg_name}[/] installed to [yellow]{install_root}[/]")
+    logger.I(
+        _("package [green]{pkg}[/] installed to [yellow]{install_root}[/]").format(
+            pkg=pkg_name,
+            install_root=install_root,
+        )
+    )
     return 0
 
 
@@ -313,7 +353,10 @@ def _do_install_binary_pkg_to(
     distfiles_for_host = bm.get_distfile_names_for_host(str(canonicalized_host))
     if not distfiles_for_host:
         logger.F(
-            f"package [green]{pkg_name}[/] declares no binary for host {canonicalized_host}"
+            _("package [green]{pkg}[/] declares no binary for host {host}").format(
+                pkg=pkg_name,
+                host=canonicalized_host,
+            )
         )
         return 2
 
@@ -324,10 +367,17 @@ def _do_install_binary_pkg_to(
         df.ensure(logger)
 
         if fetch_only:
-            logger.D("skipping installation because [yellow]--fetch-only[/] is given")
+            logger.D(
+                _("skipping installation because [yellow]--fetch-only[/] is given")
+            )
             continue
 
-        logger.I(f"extracting [green]{df_name}[/] for package [green]{pkg_name}[/]")
+        logger.I(
+            _("extracting [green]{distfile}[/] for package [green]{pkg}[/]").format(
+                distfile=df_name,
+                pkg=pkg_name,
+            )
+        )
         df.unpack(install_root, logger)
 
     return 0
@@ -362,11 +412,17 @@ def _do_install_blob_pkg(
 
     if is_installed:
         if not reinstall:
-            logger.I(f"skipping already installed package [green]{pkg_name}[/]")
+            logger.I(
+                _("skipping already installed package [green]{pkg}[/]").format(
+                    pkg=pkg_name,
+                )
+            )
             return 0
 
         logger.W(
-            f"package [green]{pkg_name}[/] seems already installed; purging and re-installing due to [yellow]--reinstall[/]"
+            _(
+                "package [green]{pkg}[/] seems already installed; purging and re-installing due to [yellow]--reinstall[/]"
+            ).format(pkg=pkg_name)
         )
         # Remove from state tracking before purging
         rgs.remove_installation(
@@ -402,7 +458,12 @@ def _do_install_blob_pkg(
             install_path=install_root,
         )
 
-    logger.I(f"package [green]{pkg_name}[/] installed to [yellow]{install_root}[/]")
+    logger.I(
+        _("package [green]{pkg}[/] installed to [yellow]{install_root}[/]").format(
+            pkg=pkg_name,
+            install_root=install_root,
+        )
+    )
     return 0
 
 
@@ -421,7 +482,9 @@ def _do_install_blob_pkg_to(
     dfs = pm.distfiles
     distfile_names = bm.get_distfile_names()
     if not distfile_names:
-        logger.F(f"package [green]{pkg_name}[/] declares no blob distfile")
+        logger.F(
+            _("package [green]{pkg}[/] declares no blob distfile").format(pkg=pkg_name)
+        )
         return 2
 
     for df_name in distfile_names:
@@ -431,10 +494,17 @@ def _do_install_blob_pkg_to(
         df.ensure(logger)
 
         if fetch_only:
-            logger.D("skipping installation because [yellow]--fetch-only[/] is given")
+            logger.D(
+                _("skipping installation because [yellow]--fetch-only[/] is given")
+            )
             continue
 
-        logger.I(f"extracting [green]{df_name}[/] for package [green]{pkg_name}[/]")
+        logger.I(
+            _("extracting [green]{distfile}[/] for package [green]{pkg}[/]").format(
+                distfile=df_name,
+                pkg=pkg_name,
+            )
+        )
         df.unpack_or_symlink(install_root, logger)
 
     return 0
@@ -458,37 +528,46 @@ def do_uninstall_atoms(
         a = Atom.parse(a_str)
         pm = a.match_in_repo(bis, config.include_prereleases)
         if pm is None:
-            logger.F(f"atom [yellow]{a_str}[/] is non-existent or not installed")
+            logger.F(
+                _("atom [yellow]{atom}[/] is non-existent or not installed").format(
+                    atom=a_str,
+                )
+            )
             return 1
         pms_to_uninstall.append((a_str, pm))
 
     if not pms_to_uninstall:
-        logger.I("no packages to uninstall")
+        logger.I(_("no packages to uninstall"))
         return 0
 
-    logger.I("the following packages will be uninstalled:")
-    for _, pm in pms_to_uninstall:
-        logger.I(f"  - [green]{pm.category}/{pm.name}[/] ({pm.ver})")
+    logger.I(_("the following packages will be uninstalled:"))
+    for _unused, pm in pms_to_uninstall:
+        logger.I(
+            _("  - [green]{category}/{name}[/] ({version})").format(
+                category=pm.category,
+                name=pm.name,
+                version=pm.ver,
+            )
+        )
 
     if not assume_yes:
-        if not ask_for_yesno_confirmation(logger, "Proceed?", default=False):
-            logger.I("uninstallation aborted")
+        if not ask_for_yesno_confirmation(logger, _("Proceed?"), default=False):
+            logger.I(_("uninstallation aborted"))
             return 0
 
     for a_str, pm in pms_to_uninstall:
         pkg_name = pm.name_for_installation
 
-        if tm := config.telemetry:
-            tm.record(
-                TelemetryScope(mr.repo_id),
-                "repo:package-uninstall-v1",
-                atom=a_str,
-                host=canonicalized_host,
-                pkg_category=pm.category,
-                pkg_kinds=pm.kind,
-                pkg_name=pm.name,
-                pkg_version=pm.ver,
-            )
+        config.telemetry.record(
+            TelemetryScope(mr.repo_id),
+            "repo:package-uninstall-v1",
+            atom=a_str,
+            host=canonicalized_host,
+            pkg_category=pm.category,
+            pkg_kinds=pm.kind,
+            pkg_name=pm.name,
+            pkg_version=pm.ver,
+        )
 
         if pm.binary_metadata is not None:
             ret = _do_uninstall_binary_pkg(
@@ -506,7 +585,11 @@ def do_uninstall_atoms(
                 return ret
             continue
 
-        logger.F(f"don't know how to handle non-binary package [green]{pkg_name}[/]")
+        logger.F(
+            _("don't know how to handle non-binary package [green]{pkg}[/]").format(
+                pkg=pkg_name,
+            )
+        )
         return 2
 
     return 0
@@ -536,21 +619,29 @@ def _do_uninstall_binary_pkg(
     # Check directory existence if the PM state says the package is not installed
     if not is_installed:
         if not os.path.exists(install_root):
-            logger.I(f"skipping not-installed package [green]{pkg_name}[/]")
+            logger.I(
+                _("skipping not-installed package [green]{pkg}[/]").format(
+                    pkg=pkg_name,
+                )
+            )
             return 0
 
         # There may be potentially user-generated data in the directory,
         # let's be safe and fail the process.
         logger.F(
-            f"package [green]{pkg_name}[/] is not tracked as installed, but its directory [yellow]{install_root}[/] exists."
+            _(
+                "package [green]{pkg}[/] is not tracked as installed, but its directory [yellow]{install_root}[/] exists."
+            ).format(pkg=pkg_name, install_root=install_root)
         )
-        logger.I("Please remove it manually if you are sure it's safe to do so.")
+        logger.I(_("Please remove it manually if you are sure it's safe to do so."))
         logger.I(
-            "If you believe this is a bug, please file an issue at [yellow]https://github.com/ruyisdk/ruyi/issues[/]."
+            _(
+                "If you believe this is a bug, please file an issue at [yellow]https://github.com/ruyisdk/ruyi/issues[/]."
+            )
         )
         return 1
 
-    logger.I(f"uninstalling package [green]{pkg_name}[/]")
+    logger.I(_("uninstalling package [green]{pkg}[/]").format(pkg=pkg_name))
     if is_installed:
         rgs.remove_installation(
             pm.repo_id,
@@ -563,7 +654,7 @@ def _do_uninstall_binary_pkg(
     if os.path.exists(install_root):
         shutil.rmtree(install_root)
 
-    logger.I(f"package [green]{pkg_name}[/] uninstalled")
+    logger.I(_("package [green]{pkg}[/] uninstalled").format(pkg=pkg_name))
     return 0
 
 
@@ -590,21 +681,29 @@ def _do_uninstall_blob_pkg(
     # Check directory existence if the PM state says the package is not installed
     if not is_installed:
         if not os.path.exists(install_root):
-            logger.I(f"skipping not-installed package [green]{pkg_name}[/]")
+            logger.I(
+                _("skipping not-installed package [green]{pkg}[/]").format(
+                    pkg=pkg_name,
+                )
+            )
             return 0
 
         # There may be potentially user-generated data in the directory,
         # let's be safe and fail the process.
         logger.F(
-            f"package [green]{pkg_name}[/] is not tracked as installed, but its directory [yellow]{install_root}[/] exists."
+            _(
+                "package [green]{pkg}[/] is not tracked as installed, but its directory [yellow]{install_root}[/] exists."
+            ).format(pkg=pkg_name, install_root=install_root)
         )
-        logger.I("Please remove it manually if you are sure it's safe to do so.")
+        logger.I(_("Please remove it manually if you are sure it's safe to do so."))
         logger.I(
-            "If you believe this is a bug, please file an issue at [yellow]https://github.com/ruyisdk/ruyi/issues[/]."
+            _(
+                "If you believe this is a bug, please file an issue at [yellow]https://github.com/ruyisdk/ruyi/issues[/]."
+            )
         )
         return 1
 
-    logger.I(f"uninstalling package [green]{pkg_name}[/]")
+    logger.I(_("uninstalling package [green]{pkg}[/]").format(pkg=pkg_name))
     if is_installed:
         rgs.remove_installation(
             pm.repo_id,
@@ -617,5 +716,5 @@ def _do_uninstall_blob_pkg(
     if os.path.exists(install_root):
         shutil.rmtree(install_root)
 
-    logger.I(f"package [green]{pkg_name}[/] uninstalled")
+    logger.I(_("package [green]{pkg}[/] uninstalled").format(pkg=pkg_name))
     return 0

ruyi/ruyipkg/install_cli.py

@@ -3,6 +3,7 @@ import pathlib
 from typing import TYPE_CHECKING
 
 from ..cli.cmd import RootCommand
+from ..i18n import _
 from .cli_completion import package_completer_builder
 from .host import get_native_host
 
@@ -14,7 +15,7 @@ if TYPE_CHECKING:
 class ExtractCommand(
     RootCommand,
     cmd="extract",
-    help="Fetch package(s) then extract to current directory",
+    help=_("Fetch package(s) then extract to current directory"),
 ):
     @classmethod
     def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
@@ -22,7 +23,7 @@ class ExtractCommand(
             "atom",
             type=str,
             nargs="+",
-            help="Specifier (atom) of the package(s) to extract",
+            help=_("Specifier (atom) of the package(s) to extract"),
         )
         if gc.is_cli_autocomplete:
             a.completer = package_completer_builder(gc)
@@ -33,24 +34,26 @@ class ExtractCommand(
             type=str,
             metavar="DESTDIR",
             default=".",
-            help="Destination directory to extract to (default: current directory)",
+            help=_("Destination directory to extract to (default: current directory)"),
         )
         p.add_argument(
             "--extract-without-subdir",
             action="store_true",
-            help="Extract files directly into DESTDIR instead of package-named subdirectories",
+            help=_(
+                "Extract files directly into DESTDIR instead of package-named subdirectories"
+            ),
         )
         p.add_argument(
             "-f",
             "--fetch-only",
             action="store_true",
-            help="Fetch distribution files only without installing",
+            help=_("Fetch distribution files only without installing"),
         )
         p.add_argument(
             "--host",
             type=str,
             default=get_native_host(),
-            help="Override the host architecture (normally not needed)",
+            help=_("Override the host architecture (normally not needed)"),
         )
 
     @classmethod
@@ -81,7 +84,7 @@ class InstallCommand(
     RootCommand,
     cmd="install",
     aliases=["i"],
-    help="Install package from configured repository",
+    help=_("Install package from configured repository"),
 ):
     @classmethod
     def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
@@ -89,7 +92,7 @@ class InstallCommand(
             "atom",
             type=str,
             nargs="+",
-            help="Specifier (atom) of the package to install",
+            help=_("Specifier (atom) of the package to install"),
         )
         if gc.is_cli_autocomplete:
             a.completer = package_completer_builder(gc)
@@ -98,18 +101,18 @@ class InstallCommand(
             "-f",
             "--fetch-only",
             action="store_true",
-            help="Fetch distribution files only without installing",
+            help=_("Fetch distribution files only without installing"),
         )
         p.add_argument(
             "--host",
             type=str,
             default=get_native_host(),
-            help="Override the host architecture (normally not needed)",
+            help=_("Override the host architecture (normally not needed)"),
         )
         p.add_argument(
             "--reinstall",
             action="store_true",
-            help="Force re-installation of already installed packages",
+            help=_("Force re-installation of already installed packages"),
         )
 
     @classmethod
@@ -136,7 +139,7 @@ class UninstallCommand(
     RootCommand,
     cmd="uninstall",
     aliases=["remove", "rm"],
-    help="Uninstall installed packages",
+    help=_("Uninstall installed packages"),
 ):
     @classmethod
     def configure_args(cls, gc: "GlobalConfig", p: argparse.ArgumentParser) -> None:
@@ -144,20 +147,20 @@ class UninstallCommand(
             "atom",
             type=str,
             nargs="+",
-            help="Specifier (atom) of the package to uninstall",
+            help=_("Specifier (atom) of the package to uninstall"),
         )
         p.add_argument(
             "--host",
             type=str,
             default=get_native_host(),
-            help="Override the host architecture (normally not needed)",
+            help=_("Override the host architecture (normally not needed)"),
         )
         p.add_argument(
             "-y",
             "--yes",
             action="store_true",
             dest="assume_yes",
-            help="Assume yes to all prompts",
+            help=_("Assume yes to all prompts"),
         )
 
     @classmethod