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

ruyi/i18n/__init__.py

@@ -0,0 +1,129 @@
+from io import BytesIO
+import gettext
+import os
+import sys
+from typing import Final, Mapping, NewType
+
+if sys.version_info >= (3, 11):
+    from typing import LiteralString
+else:
+    # It may happen that Python and typing_extensions are both too old, which
+    # is unfortunately the case with Ubuntu 22.04 LTS system packages, meaning
+    # typing_extensions cannot guarantee us LiteralString either.
+    #
+    # We don't expect development work within such an environment, so just
+    # alias to str to avoid importing typing_extensions altogether. This also
+    # helps CLI startup performance.
+    #
+    # Unfortunately, simply assigning str to LiteralString would not work either,
+    # due to mypy/pyright not wanting us to re-assign types; we have to
+    # resort to providing different function signatures for Python 3.10, which
+    # is done below.
+    #
+    # LiteralString = str  # type: ignore[misc]
+    pass
+
+from ..resource_bundle import get_resource_blob
+
+
+def _probe_lang(environ: Mapping[str, str]) -> list[str]:
+    """Probe the environment variables the gettext way, to determine the list
+    of preferred languages."""
+    languages: list[str] = []
+    # check the variables in this order
+    for envar in ("LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"):
+        if val := environ.get(envar):
+            languages = val.split(":")
+            break
+    if "C" not in languages:
+        languages.append("C")
+
+    for i, lang in enumerate(languages):
+        # normalize things like en_US.UTF-8 to en_US
+        if "." in lang:
+            languages[i] = lang.split(".", 1)[0]
+
+    return languages
+
+
+_DOMAINS = (
+    "argparse",
+    "ruyi",
+)
+"""gettext domains we supply and use ourselves"""
+
+
+class I18nAdapter:
+    """Adapter for gettext translation functions."""
+
+    def __init__(self) -> None:
+        self._t = gettext.NullTranslations()
+
+    def hook(self) -> None:
+        # monkey-patch the global gettext functions
+        # the type ignore comments are necessary because mypy doesn't see
+        # the bounded methods as compatible with the unbound functions
+        # (it doesn't remove self from the unbound method signature)
+        gettext.gettext = self.gettext  # type: ignore[assignment]
+        gettext.ngettext = self.ngettext  # type: ignore[assignment]
+
+    def init_from_env(self, environ: Mapping[str, str] | None = None) -> None:
+        if environ is None:
+            environ = os.environ
+
+        langs = _probe_lang(environ)
+        for domain in _DOMAINS:
+            for lang in langs:
+                if self.set_locale(domain, lang):
+                    break
+
+    def _get_mo(self, domain: str, locale: str) -> BytesIO | None:
+        # this is always forward-slash-separated, because this is not a concrete
+        # filesystem path, rather a resource bundle key
+        path = f"locale/{locale}/LC_MESSAGES/{domain}.mo"
+        blob = get_resource_blob(path)
+        if blob:
+            return BytesIO(blob)
+        return None
+
+    def set_locale(self, domain: str, locale: str | None = None) -> bool:
+        if locale is not None:
+            if mo_file := self._get_mo(domain, locale):
+                self._t.add_fallback(gettext.GNUTranslations(mo_file))
+                return True
+        return False
+
+    def gettext(self, x: str) -> str:
+        return self._t.gettext(x)
+
+    def ngettext(self, singular: str, plural: str, n: int) -> str:
+        return self._t.ngettext(singular, plural, n)
+
+
+ADAPTER: Final = I18nAdapter()
+
+
+DeferredI18nString = NewType("DeferredI18nString", str)
+
+
+if sys.version_info >= (3, 11):
+
+    def _(x: LiteralString | DeferredI18nString) -> str:
+        """``gettext`` alias that ensures its input is string literal via type
+        signature."""
+        return ADAPTER.gettext(x)
+
+    def d_(x: LiteralString) -> DeferredI18nString:
+        """Mark a string literal for deferred translation: call ``_`` at use sites."""
+        return DeferredI18nString(x)
+
+else:
+
+    def _(x: str | DeferredI18nString) -> str:
+        """``gettext`` alias that ensures its input is string literal via type
+        signature."""
+        return ADAPTER.gettext(x)
+
+    def d_(x: str) -> DeferredI18nString:
+        """Mark a string literal for deferred translation: call ``_`` at use sites."""
+        return DeferredI18nString(x)

ruyi/log/__init__.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from rich.console import Console, RenderableType
     from rich.text import Text
 
+from ..i18n import _
 from ..utils.global_mode import ProvidesGlobalMode
 from ..utils.porcelain import PorcelainEntity, PorcelainEntityType, PorcelainOutput
 
@@ -217,7 +218,7 @@ class RuyiConsoleLogger(RuyiLogger):
             return self._emit_porcelain_log("F", message, sep, *objects)
 
         return self.log_console.print(
-            f"[bold red]fatal error:[/] {message}",
+            _("[bold red]fatal error:[/] {message}").format(message=message),
             *objects,
             sep=sep,
             end=end,
@@ -234,7 +235,7 @@ class RuyiConsoleLogger(RuyiLogger):
             return self._emit_porcelain_log("I", message, sep, *objects)
 
         return self.log_console.print(
-            f"[bold green]info:[/] {message}",
+            _("[bold green]info:[/] {message}").format(message=message),
             *objects,
             sep=sep,
             end=end,
@@ -251,7 +252,7 @@ class RuyiConsoleLogger(RuyiLogger):
             return self._emit_porcelain_log("W", message, sep, *objects)
 
         return self.log_console.print(
-            f"[bold yellow]warn:[/] {message}",
+            _("[bold yellow]warn:[/] {message}").format(message=message),
             *objects,
             sep=sep,
             end=end,
@@ -263,10 +264,10 @@ def humanize_list(
     *,
     sep: str = ", ",
     item_color: str | None = None,
-    empty_prompt: str = "(none)",
+    empty_prompt: str | None = None,
 ) -> str:
     if not obj:
-        return empty_prompt
+        return empty_prompt if empty_prompt is not None else _("(none)")
     if item_color is None:
         return sep.join(obj)
     return sep.join(f"[{item_color}]{x}[/]" for x in obj)

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