ruyi 0.45.0__py3-none-any.whl → 0.45.0a20251230__py3-none-any.whl

ruyi/mux/runtime.py

@@ -5,7 +5,6 @@ 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
 
@@ -32,8 +31,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)
@@ -61,11 +60,7 @@ def mux_main(
             tgt_data = vcfg.targets.get(target_tuple)
             if tgt_data is None:
                 logger.F(
-                    _(
-                        "internal error: no target data for tuple [yellow]{target_tuple}[/]"
-                    ).format(
-                        target_tuple=target_tuple,
-                    )
+                    f"internal error: no target data for tuple [yellow]{target_tuple}[/]"
                 )
                 return 1
             toolchain_sysroot = tgt_data.get("toolchain_sysroot")
@@ -88,22 +83,14 @@ def mux_main(
         if toolchain_bindir is None:
             # should not happen
             logger.F(
-                _(
-                    "internal error: no bindir configured for target [yellow]{target_tuple}[/]"
-                ).format(
-                    target_tuple=target_tuple,
-                )
+                f"internal error: no bindir configured for target [yellow]{target_tuple}[/]"
             )
             return 1
 
         binpath = os.path.join(toolchain_bindir, basename)
 
     if target_tuple is None:
-        logger.F(
-            _("no configured target found for command [yellow]{basename}[/]").format(
-                basename=basename,
-            )
-        )
+        logger.F(f"no configured target found for command [yellow]{basename}[/]")
         return 1
 
     logger.D(f"binary to exec: {binpath}")
@@ -189,7 +176,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,13 +7,11 @@ 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
 
@@ -69,7 +67,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
 
@@ -77,7 +75,7 @@ def do_make_venv(
 
     profile = mr.get_profile(profile_name)
     if profile is None:
-        logger.F(_("profile '{profile}' not found").format(profile=profile_name))
+        logger.F(f"profile '{profile_name}' not found")
         return 1
 
     target_arch = ""
@@ -95,46 +93,32 @@ 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(_("cannot match a toolchain package with [yellow]{atom}[/]").format(
-                atom=tc_atom_str,
-            ))
+            logger.F(f"cannot match a toolchain package with [yellow]{tc_atom_str}[/]")
             return 1
 
         if tc_pm.toolchain_metadata is None:
-            logger.F(_("the package [yellow]{atom}[/] is not a toolchain").format(
-                atom=tc_atom_str,
-            ))
+            logger.F(f"the package [yellow]{tc_atom_str}[/] is not a toolchain")
             return 1
 
         if not tc_pm.toolchain_metadata.satisfies_quirk_set(profile.need_quirks):
-            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.F(
+                f"the package [yellow]{tc_atom_str}[/] does not support all necessary features for the profile [yellow]{profile_name}[/]"
             )
             logger.I(
-                _("quirks needed by profile:   {humanized_list}").format(
-                humanized_list=humanize_list(profile.need_quirks, item_color='cyan'),
-                )
+                f"quirks needed by profile:   {humanize_list(profile.need_quirks, item_color='cyan')}"
             )
             logger.I(
-                _("quirks provided by package: {humanized_list}").format(
-                humanized_list=humanize_list(tc_pm.toolchain_metadata.quirks, item_color='yellow'),
-                )
+                f"quirks provided by package: {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(
-                _("the target tuple [yellow]{target_tuple}[/] is already covered by one of the requested toolchains").format(
-                    target_tuple=target_tuple,
-                    )
+                f"the target tuple [yellow]{target_tuple}[/] is already covered by one of the requested toolchains"
             )
             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
 
@@ -143,7 +127,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
@@ -155,7 +139,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
 
@@ -166,17 +150,13 @@ 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(
-                        _("cannot match a toolchain package with [yellow]{atom}[/]").format(
-                            atom=sysroot_atom_str,
-                        )
+                        f"cannot match a toolchain package with [yellow]{sysroot_atom_str}[/]"
                     )
                     return 1
 
                 if gcc_pkg_pm.toolchain_metadata is None:
                     logger.F(
-                        _("the package [yellow]{atom}[/] is not a toolchain").format(
-                            atom=sysroot_atom_str,
-                        )
+                        f"the package [yellow]{sysroot_atom_str}[/] is not a toolchain"
                     )
                     return 1
 
@@ -186,16 +166,14 @@ 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(
-                        _("sysroot is requested but the package [yellow]{atom}[/] does not contain one").format(
-                            atom=sysroot_atom_str,
-                        )
+                        f"sysroot is requested but the package [yellow]{sysroot_atom_str}[/] does not contain one"
                     )
                     return 1
 
@@ -213,7 +191,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
 
@@ -250,11 +228,9 @@ 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(
-            _("using the target architecture of the first toolchain: [yellow]{arch}[/]").format(
-                arch=target_arch,
-                )
+            f"using the target architecture of the first toolchain: [yellow]{target_arch}[/]"
         )
 
     # Now handle the emulator.
@@ -264,24 +240,17 @@ 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(_("cannot match an emulator package with [yellow]{atom}[/]").format(
-                atom=emu_atom_str,
-            ))
+            logger.F(f"cannot match an emulator package with [yellow]{emu_atom_str}[/]")
             return 1
 
         if emu_pm.emulator_metadata is None:
-            logger.F(_("the package [yellow]{atom}[/] is not an emulator").format(
-                atom=emu_atom_str,
-            ))
+            logger.F(f"the package [yellow]{emu_atom_str}[/] is not an emulator")
             return 1
 
         emu_progs = list(emu_pm.emulator_metadata.list_for_arch(target_arch))
         if not emu_progs:
             logger.F(
-                _("the emulator package [yellow]{atom}[/] does not support the target architecture [yellow]{arch}[/]").format(
-                    atom=emu_atom_str,
-                    arch=target_arch,
-                )
+                f"the emulator package [yellow]{emu_atom_str}[/] does not support the target architecture [yellow]{target_arch}[/]"
             )
             return 1
 
@@ -291,20 +260,13 @@ def do_make_venv(
                 emu_pm.emulator_metadata.quirks,
             ):
                 logger.F(
-                    _("the package [yellow]{atom}[/] does not support all necessary features for the profile [yellow]{profile}[/]").format(
-                        atom=emu_atom_str,
-                        profile=profile_name,
-                    )
+                    f"the package [yellow]{emu_atom_str}[/] does not support all necessary features for the profile [yellow]{profile_name}[/]"
                 )
                 logger.I(
-                    _("quirks needed by profile:   {humanized_list}").format(
-                        humanized_list=humanize_list(profile.get_needed_emulator_pkg_flavors(prog.flavor), item_color='cyan'),
-                    )
+                    f"quirks needed by profile:   {humanize_list(profile.get_needed_emulator_pkg_flavors(prog.flavor), item_color='cyan')}"
                 )
                 logger.I(
-                    _("quirks provided by package: {humanized_list}").format(
-                        humanized_list=humanize_list(emu_pm.emulator_metadata.quirks or [], item_color='yellow'),
-                    )
+                    f"quirks provided by package: {humanize_list(emu_pm.emulator_metadata.quirks or [], item_color='yellow')}"
                 )
                 return 1
 
@@ -313,7 +275,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)
@@ -329,28 +291,21 @@ def do_make_venv(
             )
             if extra_cmd_pm is None:
                 logger.F(
-                    _("cannot match an extra command package with [yellow]{atom}[/]").format(
-                        atom=extra_cmd_atom_str,
-                    )
+                    f"cannot match an extra command package with [yellow]{extra_cmd_atom_str}[/]"
                 )
                 return 1
 
             extra_cmd_bm = extra_cmd_pm.binary_metadata
             if not extra_cmd_bm:
                 logger.F(
-                    _("the package [yellow]{atom}[/] is not a binary-providing package").format(
-                        atom=extra_cmd_atom_str,
-                    )
+                    f"the package [yellow]{extra_cmd_atom_str}[/] is not a binary-providing package"
                 )
                 return 1
 
             extra_cmds_decl = extra_cmd_bm.get_commands_for_host(host)
             if not extra_cmds_decl:
                 logger.W(
-                    _("the package [yellow]{atom}[/] does not provide any command for host [yellow]{host}[/], ignoring").format(
-                        atom=extra_cmd_atom_str,
-                        host=host,
-                    )
+                    f"the package [yellow]{extra_cmd_atom_str}[/] does not provide any command for host [yellow]{host}[/], ignoring"
                 )
                 continue
 
@@ -360,9 +315,7 @@ def do_make_venv(
             )
             if cmd_root is None:
                 logger.F(
-                    _("cannot find the installed directory for the package [yellow]{pkg}[/]").format(
-                        pkg=extra_cmd_pm.name_for_installation,
-                    )
+                    f"cannot find the installed directory for the package [yellow]{extra_cmd_pm.name_for_installation}[/]"
                 )
                 return 1
             cmd_root = pathlib.Path(cmd_root)
@@ -376,7 +329,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
 
@@ -385,17 +338,10 @@ def do_make_venv(
 
     if override_name is not None:
         logger.I(
-            _("Creating a Ruyi virtual environment [cyan]'{name}'[/] at [green]{dest}[/]...").format(
-                name=override_name,
-                dest=dest,
-            )
+            f"Creating a Ruyi virtual environment [cyan]'{override_name}'[/] at [green]{dest}[/]..."
         )
     else:
-        logger.I(
-            _("Creating a Ruyi virtual environment at [green]{dest}[/]...").format(
-                dest=dest,
-            )
-        )
+        logger.I(f"Creating a Ruyi virtual environment at [green]{dest}[/]...")
 
     maker = VenvMaker(
         config,
@@ -410,11 +356,9 @@ 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(
-            f"prompt.venv-created.{locale}.txt",
+            "prompt.venv-created.txt",
             {
                 "sysroot": maker.sysroot_destdir(None),
             },
@@ -615,9 +559,7 @@ class VenvMaker:
         for cmd, dest in extra_cmds.items():
             if cmd in cmd_metadata_map:
                 self.logger.W(
-                    _("extra command {cmd} is already provided by another package, overriding it").format(
-                        cmd=cmd,
-                        )
+                    f"extra command {cmd} is already provided by another package, overriding it"
                 )
             cmd_metadata_map[cmd] = {
                 "dest": dest,

ruyi/mux/venv/venv_cli.py

@@ -3,7 +3,6 @@ import pathlib
 from typing import TYPE_CHECKING
 
 from ...cli.cmd import RootCommand
-from ...i18n import _
 
 if TYPE_CHECKING:
     from ...cli.completion import ArgumentParser
@@ -13,57 +12,55 @@ 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,7 +2,6 @@ import argparse
 from typing import TYPE_CHECKING
 
 from ..cli.cmd import AdminCommand
-from ..i18n import _
 
 if TYPE_CHECKING:
     from ..cli.completion import ArgumentParser
@@ -12,7 +11,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:
@@ -20,14 +19,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,34 +1,20 @@
 import base64
 import zlib
 
-from .data import RESOURCES, TEMPLATE_NAME_MAP
+from .data import RESOURCES, TEMPLATES
 
 
-def _unpack_payload(x: bytes) -> bytes:
-    return zlib.decompress(base64.b64decode(x))
+def _unpack_payload(x: bytes) -> str:
+    return zlib.decompress(base64.b64decode(x)).decode("utf-8")
 
 
-_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")
+def get_resource_str(template_name: str) -> str | None:
+    if t := RESOURCES.get(template_name):
+        return _unpack_payload(t)
     return None
 
 
 def get_template_str(template_name: str) -> str | None:
-    if t := TEMPLATE_NAME_MAP.get(template_name):
-        return get_resource_str(t)
+    if t := TEMPLATES.get(template_name):
+        return _unpack_payload(t)
     return None

ruyi/resource_bundle/__main__.py

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