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

ruyi/mux/runtime.py

@@ -5,6 +5,7 @@ import shlex
 from typing import Final, List, NoReturn
 
 from ..config import GlobalConfig
+from ..i18n import _
 from ..utils.global_mode import ProvidesGlobalMode
 from .venv_cfg import RuyiVenvConfig
 
@@ -31,8 +32,8 @@ def mux_main(
 
     vcfg = RuyiVenvConfig.load_from_venv(gm, logger)
     if vcfg is None:
-        logger.F("the Ruyi toolchain mux is not configured")
-        logger.I("check out `ruyi venv` for making a virtual environment")
+        logger.F(_("the Ruyi toolchain mux is not configured"))
+        logger.I(_("check out `ruyi venv` for making a virtual environment"))
         return 1
 
     direct_symlink_target = resolve_direct_symlink_target(gm.argv0, vcfg)
@@ -60,7 +61,11 @@ def mux_main(
             tgt_data = vcfg.targets.get(target_tuple)
             if tgt_data is None:
                 logger.F(
-                    f"internal error: no target data for tuple [yellow]{target_tuple}[/]"
+                    _(
+                        "internal error: no target data for tuple [yellow]{target_tuple}[/]"
+                    ).format(
+                        target_tuple=target_tuple,
+                    )
                 )
                 return 1
             toolchain_sysroot = tgt_data.get("toolchain_sysroot")
@@ -83,14 +88,22 @@ def mux_main(
         if toolchain_bindir is None:
             # should not happen
             logger.F(
-                f"internal error: no bindir configured for target [yellow]{target_tuple}[/]"
+                _(
+                    "internal error: no bindir configured for target [yellow]{target_tuple}[/]"
+                ).format(
+                    target_tuple=target_tuple,
+                )
             )
             return 1
 
         binpath = os.path.join(toolchain_bindir, basename)
 
     if target_tuple is None:
-        logger.F(f"no configured target found for command [yellow]{basename}[/]")
+        logger.F(
+            _("no configured target found for command [yellow]{basename}[/]").format(
+                basename=basename,
+            )
+        )
         return 1
 
     logger.D(f"binary to exec: {binpath}")
@@ -176,7 +189,7 @@ def mux_qemu_main(
     logger = gc.logger
     binpath = vcfg.qemu_bin
     if binpath is None:
-        logger.F("this virtual environment has no QEMU-like emulator configured")
+        logger.F(_("this virtual environment has no QEMU-like emulator configured"))
         return 1
 
     if vcfg.profile_emu_env is not None:

ruyi/mux/venv/maker.py

@@ -7,11 +7,13 @@ import shutil
 from typing import Any, Final, Iterator, TypedDict
 
 from ...config import GlobalConfig
+from ...i18n import _
 from ...log import RuyiLogger, humanize_list
 from ...ruyipkg.atom import Atom
 from ...ruyipkg.pkg_manifest import BoundPackageManifest, EmulatorProgDecl
 from ...ruyipkg.profile import ProfileProxy
 from ...utils.global_mode import ProvidesGlobalMode
+from ...utils.l10n import match_lang_code
 from ...utils.templating import render_template_str
 from .emulator_cfg import ResolvedEmulatorProg
 
@@ -67,7 +69,7 @@ def do_make_venv(
     # this should come after implementation of local state cache
     if tc_atoms_str is None:
         logger.F(
-            "You have to specify at least one toolchain atom for now, e.g. [yellow]`-t gnu-plct`[/]"
+            _("You have to specify at least one toolchain atom for now, e.g. [yellow]`-t gnu-plct`[/]")
         )
         return 1
 
@@ -75,7 +77,7 @@ def do_make_venv(
 
     profile = mr.get_profile(profile_name)
     if profile is None:
-        logger.F(f"profile '{profile_name}' not found")
+        logger.F(_("profile '{profile}' not found").format(profile=profile_name))
         return 1
 
     target_arch = ""
@@ -93,32 +95,46 @@ def do_make_venv(
         tc_atom = Atom.parse(tc_atom_str)
         tc_pm = tc_atom.match_in_repo(mr, config.include_prereleases)
         if tc_pm is None:
-            logger.F(f"cannot match a toolchain package with [yellow]{tc_atom_str}[/]")
+            logger.F(_("cannot match a toolchain package with [yellow]{atom}[/]").format(
+                atom=tc_atom_str,
+            ))
             return 1
 
         if tc_pm.toolchain_metadata is None:
-            logger.F(f"the package [yellow]{tc_atom_str}[/] is not a toolchain")
+            logger.F(_("the package [yellow]{atom}[/] is not a toolchain").format(
+                atom=tc_atom_str,
+            ))
             return 1
 
         if not tc_pm.toolchain_metadata.satisfies_quirk_set(profile.need_quirks):
-            logger.F(
-                f"the package [yellow]{tc_atom_str}[/] does not support all necessary features for the profile [yellow]{profile_name}[/]"
+            logger.F(_(
+                "the package [yellow]{atom}[/] does not support all necessary features for the profile [yellow]{profile}[/]"
+                ).format(
+                    atom=tc_atom_str,
+                    profile=profile_name,
+                    )
             )
             logger.I(
-                f"quirks needed by profile:   {humanize_list(profile.need_quirks, item_color='cyan')}"
+                _("quirks needed by profile:   {humanized_list}").format(
+                humanized_list=humanize_list(profile.need_quirks, item_color='cyan'),
+                )
             )
             logger.I(
-                f"quirks provided by package: {humanize_list(tc_pm.toolchain_metadata.quirks, item_color='yellow')}"
+                _("quirks provided by package: {humanized_list}").format(
+                humanized_list=humanize_list(tc_pm.toolchain_metadata.quirks, item_color='yellow'),
+                )
             )
             return 1
 
         target_tuple = tc_pm.toolchain_metadata.target
         if target_tuple in seen_target_tuples:
             logger.F(
-                f"the target tuple [yellow]{target_tuple}[/] is already covered by one of the requested toolchains"
+                _("the target tuple [yellow]{target_tuple}[/] is already covered by one of the requested toolchains").format(
+                    target_tuple=target_tuple,
+                    )
             )
             logger.I(
-                "for now, only toolchains with differing target tuples can co-exist in one virtual environment"
+                _("for now, only toolchains with differing target tuples can co-exist in one virtual environment")
             )
             return 1
 
@@ -127,7 +143,7 @@ def do_make_venv(
             tc_pm.name_for_installation,
         )
         if toolchain_root is None:
-            logger.F("cannot find the installed directory for the toolchain")
+            logger.F(_("cannot find the installed directory for the toolchain"))
             return 1
 
         tc_sysroot_dir: PathLike[Any] | None = None
@@ -139,7 +155,7 @@ def do_make_venv(
             else:
                 if sysroot_atom_str is None:
                     logger.F(
-                        "sysroot is requested but the toolchain package does not include one, and [yellow]--sysroot-from[/] is not given"
+                        _("sysroot is requested but the toolchain package does not include one, and [yellow]--sysroot-from[/] is not given")
                     )
                     return 1
 
@@ -150,13 +166,17 @@ def do_make_venv(
                 gcc_pkg_pm = gcc_pkg_atom.match_in_repo(mr, config.include_prereleases)
                 if gcc_pkg_pm is None:
                     logger.F(
-                        f"cannot match a toolchain package with [yellow]{sysroot_atom_str}[/]"
+                        _("cannot match a toolchain package with [yellow]{atom}[/]").format(
+                            atom=sysroot_atom_str,
+                        )
                     )
                     return 1
 
                 if gcc_pkg_pm.toolchain_metadata is None:
                     logger.F(
-                        f"the package [yellow]{sysroot_atom_str}[/] is not a toolchain"
+                        _("the package [yellow]{atom}[/] is not a toolchain").format(
+                            atom=sysroot_atom_str,
+                        )
                     )
                     return 1
 
@@ -166,14 +186,16 @@ def do_make_venv(
                 )
                 if gcc_pkg_root is None:
                     logger.F(
-                        "cannot find the installed directory for the sysroot package"
+                        _("cannot find the installed directory for the sysroot package")
                     )
                     return 1
 
                 tc_sysroot_relpath = gcc_pkg_pm.toolchain_metadata.included_sysroot
                 if tc_sysroot_relpath is None:
                     logger.F(
-                        f"sysroot is requested but the package [yellow]{sysroot_atom_str}[/] does not contain one"
+                        _("sysroot is requested but the package [yellow]{atom}[/] does not contain one").format(
+                            atom=sysroot_atom_str,
+                        )
                     )
                     return 1
 
@@ -191,7 +213,7 @@ def do_make_venv(
                 # for now, require this directory to be present (or clang would barely work)
                 if gcc_install_dir is None:
                     logger.F(
-                        "cannot find a GCC include & lib directory in the sysroot package"
+                        _("cannot find a GCC include & lib directory in the sysroot package")
                     )
                     return 1
 
@@ -228,9 +250,11 @@ def do_make_venv(
             warn_differing_target_arch = True
 
     if warn_differing_target_arch:
-        logger.W("multiple toolchains specified with differing target architecture")
+        logger.W(_("multiple toolchains specified with differing target architecture"))
         logger.I(
-            f"using the target architecture of the first toolchain: [yellow]{target_arch}[/]"
+            _("using the target architecture of the first toolchain: [yellow]{arch}[/]").format(
+                arch=target_arch,
+                )
         )
 
     # Now handle the emulator.
@@ -240,17 +264,24 @@ def do_make_venv(
         emu_atom = Atom.parse(emu_atom_str)
         emu_pm = emu_atom.match_in_repo(mr, config.include_prereleases)
         if emu_pm is None:
-            logger.F(f"cannot match an emulator package with [yellow]{emu_atom_str}[/]")
+            logger.F(_("cannot match an emulator package with [yellow]{atom}[/]").format(
+                atom=emu_atom_str,
+            ))
             return 1
 
         if emu_pm.emulator_metadata is None:
-            logger.F(f"the package [yellow]{emu_atom_str}[/] is not an emulator")
+            logger.F(_("the package [yellow]{atom}[/] is not an emulator").format(
+                atom=emu_atom_str,
+            ))
             return 1
 
         emu_progs = list(emu_pm.emulator_metadata.list_for_arch(target_arch))
         if not emu_progs:
             logger.F(
-                f"the emulator package [yellow]{emu_atom_str}[/] does not support the target architecture [yellow]{target_arch}[/]"
+                _("the emulator package [yellow]{atom}[/] does not support the target architecture [yellow]{arch}[/]").format(
+                    atom=emu_atom_str,
+                    arch=target_arch,
+                )
             )
             return 1
 
@@ -260,13 +291,20 @@ def do_make_venv(
                 emu_pm.emulator_metadata.quirks,
             ):
                 logger.F(
-                    f"the package [yellow]{emu_atom_str}[/] does not support all necessary features for the profile [yellow]{profile_name}[/]"
+                    _("the package [yellow]{atom}[/] does not support all necessary features for the profile [yellow]{profile}[/]").format(
+                        atom=emu_atom_str,
+                        profile=profile_name,
+                    )
                 )
                 logger.I(
-                    f"quirks needed by profile:   {humanize_list(profile.get_needed_emulator_pkg_flavors(prog.flavor), item_color='cyan')}"
+                    _("quirks needed by profile:   {humanized_list}").format(
+                        humanized_list=humanize_list(profile.get_needed_emulator_pkg_flavors(prog.flavor), item_color='cyan'),
+                    )
                 )
                 logger.I(
-                    f"quirks provided by package: {humanize_list(emu_pm.emulator_metadata.quirks or [], item_color='yellow')}"
+                    _("quirks provided by package: {humanized_list}").format(
+                        humanized_list=humanize_list(emu_pm.emulator_metadata.quirks or [], item_color='yellow'),
+                    )
                 )
                 return 1
 
@@ -275,7 +313,7 @@ def do_make_venv(
             emu_pm.name_for_installation,
         )
         if emu_root is None:
-            logger.F("cannot find the installed directory for the emulator")
+            logger.F(_("cannot find the installed directory for the emulator"))
             return 1
 
         venv_metadata["emulator_pkgs"][target_arch] = _venv_pkg_info_from_pkg(emu_pm)
@@ -291,21 +329,28 @@ def do_make_venv(
             )
             if extra_cmd_pm is None:
                 logger.F(
-                    f"cannot match an extra command package with [yellow]{extra_cmd_atom_str}[/]"
+                    _("cannot match an extra command package with [yellow]{atom}[/]").format(
+                        atom=extra_cmd_atom_str,
+                    )
                 )
                 return 1
 
             extra_cmd_bm = extra_cmd_pm.binary_metadata
             if not extra_cmd_bm:
                 logger.F(
-                    f"the package [yellow]{extra_cmd_atom_str}[/] is not a binary-providing package"
+                    _("the package [yellow]{atom}[/] is not a binary-providing package").format(
+                        atom=extra_cmd_atom_str,
+                    )
                 )
                 return 1
 
             extra_cmds_decl = extra_cmd_bm.get_commands_for_host(host)
             if not extra_cmds_decl:
                 logger.W(
-                    f"the package [yellow]{extra_cmd_atom_str}[/] does not provide any command for host [yellow]{host}[/], ignoring"
+                    _("the package [yellow]{atom}[/] does not provide any command for host [yellow]{host}[/], ignoring").format(
+                        atom=extra_cmd_atom_str,
+                        host=host,
+                    )
                 )
                 continue
 
@@ -315,7 +360,9 @@ def do_make_venv(
             )
             if cmd_root is None:
                 logger.F(
-                    f"cannot find the installed directory for the package [yellow]{extra_cmd_pm.name_for_installation}[/]"
+                    _("cannot find the installed directory for the package [yellow]{pkg}[/]").format(
+                        pkg=extra_cmd_pm.name_for_installation,
+                    )
                 )
                 return 1
             cmd_root = pathlib.Path(cmd_root)
@@ -329,7 +376,7 @@ def do_make_venv(
                     # we don't allow commands to resolve outside of the
                     # providing package's install root
                     logger.F(
-                        "internal error: resolved command path is outside of the providing package"
+                        _("internal error: resolved command path is outside of the providing package")
                     )
                     return 1
 
@@ -338,10 +385,17 @@ def do_make_venv(
 
     if override_name is not None:
         logger.I(
-            f"Creating a Ruyi virtual environment [cyan]'{override_name}'[/] at [green]{dest}[/]..."
+            _("Creating a Ruyi virtual environment [cyan]'{name}'[/] at [green]{dest}[/]...").format(
+                name=override_name,
+                dest=dest,
+            )
         )
     else:
-        logger.I(f"Creating a Ruyi virtual environment at [green]{dest}[/]...")
+        logger.I(
+            _("Creating a Ruyi virtual environment at [green]{dest}[/]...").format(
+                dest=dest,
+            )
+        )
 
     maker = VenvMaker(
         config,
@@ -356,9 +410,11 @@ def do_make_venv(
     )
     maker.provision()
 
+    # TODO: move the template to PO
+    locale = match_lang_code(config.lang_code, avail=("en", "zh_CN"))
     logger.I(
         render_template_str(
-            "prompt.venv-created.txt",
+            f"prompt.venv-created.{locale}.txt",
             {
                 "sysroot": maker.sysroot_destdir(None),
             },
@@ -559,7 +615,9 @@ class VenvMaker:
         for cmd, dest in extra_cmds.items():
             if cmd in cmd_metadata_map:
                 self.logger.W(
-                    f"extra command {cmd} is already provided by another package, overriding it"
+                    _("extra command {cmd} is already provided by another package, overriding it").format(
+                        cmd=cmd,
+                        )
                 )
             cmd_metadata_map[cmd] = {
                 "dest": dest,

ruyi/mux/venv/venv_cli.py

@@ -3,6 +3,7 @@ import pathlib
 from typing import TYPE_CHECKING
 
 from ...cli.cmd import RootCommand
+from ...i18n import _
 
 if TYPE_CHECKING:
     from ...cli.completion import ArgumentParser
@@ -12,55 +13,57 @@ if TYPE_CHECKING:
 class VenvCommand(
     RootCommand,
     cmd="venv",
-    help="Generate a virtual environment adapted to the chosen toolchain and profile",
+    help=_("Generate a virtual environment adapted to the chosen toolchain and profile"),
 ):
     @classmethod
     def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
-        p.add_argument("profile", type=str, help="Profile to use for the environment")
-        p.add_argument("dest", type=str, help="Path to the new virtual environment")
+        p.add_argument("profile", type=str, help=_("Profile to use for the environment"),
+                       )
+        p.add_argument("dest", type=str, help=_("Path to the new virtual environment"),
+                       )
         p.add_argument(
             "--name",
             "-n",
             type=str,
             default=None,
-            help="Override the venv's name",
+            help=_("Override the venv's name"),
         )
         p.add_argument(
             "--toolchain",
             "-t",
             type=str,
             action="append",
-            help="Specifier(s) (atoms) of the toolchain package(s) to use",
+            help=_("Specifier(s) (atoms) of the toolchain package(s) to use"),
         )
         p.add_argument(
             "--emulator",
             "-e",
             type=str,
-            help="Specifier (atom) of the emulator package to use",
+            help=_("Specifier (atom) of the emulator package to use"),
         )
         p.add_argument(
             "--with-sysroot",
             action="store_true",
             dest="with_sysroot",
             default=True,
-            help="Provision a fresh sysroot inside the new virtual environment (default)",
+            help=_("Provision a fresh sysroot inside the new virtual environment (default)"),
         )
         p.add_argument(
             "--without-sysroot",
             action="store_false",
             dest="with_sysroot",
-            help="Do not include a sysroot inside the new virtual environment",
+            help=_("Do not include a sysroot inside the new virtual environment"),
         )
         p.add_argument(
             "--sysroot-from",
             type=str,
-            help="Specifier (atom) of the sysroot package to use, in favor of the toolchain-included one if applicable",
+            help=_("Specifier (atom) of the sysroot package to use, in favor of the toolchain-included one if applicable"),
         )
         p.add_argument(
             "--extra-commands-from",
             type=str,
             action="append",
-            help="Specifier(s) (atoms) of extra package(s) to add commands to the new virtual environment",
+            help=_("Specifier(s) (atoms) of extra package(s) to add commands to the new virtual environment"),
         )
 
     @classmethod

ruyi/pluginhost/plugin_cli.py

@@ -2,6 +2,7 @@ import argparse
 from typing import TYPE_CHECKING
 
 from ..cli.cmd import AdminCommand
+from ..i18n import _
 
 if TYPE_CHECKING:
     from ..cli.completion import ArgumentParser
@@ -11,7 +12,7 @@ if TYPE_CHECKING:
 class AdminRunPluginCommand(
     AdminCommand,
     cmd="run-plugin-cmd",
-    help="Run a plugin-defined command",
+    help=_("Run a plugin-defined command"),
 ):
     @classmethod
     def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
@@ -19,14 +20,14 @@ class AdminRunPluginCommand(
             "cmd_name",
             type=str,
             metavar="COMMAND-NAME",
-            help="Command name",
+            help=_("Command name"),
         )
         p.add_argument(
             "cmd_args",
             type=str,
             nargs="*",
             metavar="COMMAND-ARG",
-            help="Arguments to pass to the plugin command",
+            help=_("Arguments to pass to the plugin command"),
         )
 
     @classmethod

ruyi/resource_bundle/__init__.py

@@ -1,20 +1,34 @@
 import base64
 import zlib
 
-from .data import RESOURCES, TEMPLATES
+from .data import RESOURCES, TEMPLATE_NAME_MAP
 
 
-def _unpack_payload(x: bytes) -> str:
-    return zlib.decompress(base64.b64decode(x)).decode("utf-8")
+def _unpack_payload(x: bytes) -> bytes:
+    return zlib.decompress(base64.b64decode(x))
 
 
-def get_resource_str(template_name: str) -> str | None:
-    if t := RESOURCES.get(template_name):
-        return _unpack_payload(t)
+_CACHE: dict[str, bytes] = {}
+
+
+def get_resource_blob(name: str) -> bytes | None:
+    if t := RESOURCES.get(name):
+        if name not in _CACHE:
+            # In our use cases, the program is short-lived and involved resources
+            # are small in size, so it is fine to just store the decompressed
+            # blobs without eviction.
+            _CACHE[name] = _unpack_payload(t)
+        return _CACHE[name]
+    return None
+
+
+def get_resource_str(name: str) -> str | None:
+    if blob := get_resource_blob(name):
+        return blob.decode("utf-8")
     return None
 
 
 def get_template_str(template_name: str) -> str | None:
-    if t := TEMPLATES.get(template_name):
-        return _unpack_payload(t)
+    if t := TEMPLATE_NAME_MAP.get(template_name):
+        return get_resource_str(t)
     return None

ruyi/resource_bundle/__main__.py

@@ -20,15 +20,16 @@ def main() -> None:
 
     resources: dict[str, str] = {}
     template_names: dict[str, str] = {}
-    for f in bundled_resource_root.iterdir():
+    for f in bundled_resource_root.glob("**/*"):
         if not f.is_file():
             continue
 
-        resources[f.name] = make_payload_from_file(f)
+        rel_path = f.relative_to(bundled_resource_root)
+        resources[str(rel_path)] = make_payload_from_file(f)
 
         if f.suffix.lower() == ".jinja":
             # strip the .jinja suffix for the template name
-            template_names[f.stem] = f.name
+            template_names[str(rel_path.with_suffix(""))] = str(rel_path)
 
     with open(self_path / "data.py", "w", encoding="utf-8") as fp:
 
@@ -45,9 +46,9 @@ def main() -> None:
             p(f'    "{filename}": b"{payload}",  # fmt: skip')
         p("}\n")
 
-        p("TEMPLATES: Final = {")
+        p("TEMPLATE_NAME_MAP: Final = {")
         for stem, full_filename in sorted(template_names.items()):
-            p(f'    "{stem}": RESOURCES["{full_filename}"],')
+            p(f'    "{stem}": "{full_filename}",')
         p("}")