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

ruyi/config/__init__.py

@@ -18,13 +18,6 @@ if TYPE_CHECKING:
     from ..utils.xdg_basedir import XDGPathEntry
     from .news import NewsReadStatusStore
 
-import babel
-# not sure why Pyright insists on individual imports
-# otherwise, at the use site (`except babel.core.UnknownLocaleError`):
-#   error: "core" is not a known attribute of module "babel" (reportAttributeAccessIssue)
-from babel.core import UnknownLocaleError
-
-from ..i18n import _
 from . import errors
 from . import schema
 
@@ -122,11 +115,7 @@ class GlobalConfig:
             if iem is not None and not is_global_scope:
                 iem_cfg_key = f"{schema.SECTION_INSTALLATION}.{schema.KEY_INSTALLATION_EXTERNALLY_MANAGED}"
                 self.logger.W(
-                    _(
-                        "the config key [yellow]{key}[/] cannot be set from user config; ignoring"
-                    ).format(
-                        key=iem_cfg_key,
-                    ),
+                    f"the config key [yellow]{iem_cfg_key}[/] cannot be set from user config; ignoring",
                 )
             else:
                 self.is_installation_externally_managed = bool(iem)
@@ -144,11 +133,7 @@ class GlobalConfig:
             if self.override_repo_dir:
                 if not pathlib.Path(self.override_repo_dir).is_absolute():
                     self.logger.W(
-                        _(
-                            "the local repo path '{path}' is not absolute; ignoring"
-                        ).format(
-                            path=self.override_repo_dir,
-                        )
+                        f"the local repo path '{self.override_repo_dir}' is not absolute; ignoring"
                     )
                     self.override_repo_dir = None
 
@@ -289,15 +274,6 @@ class GlobalConfig:
     def lang_code(self) -> str:
         return self._lang_code
 
-    @cached_property
-    def babel_locale(self) -> babel.Locale:
-        try:
-            return babel.Locale.parse(self.lang_code)
-        except UnknownLocaleError:
-            # this can happen in case of unrecognized locale names, which
-            # apparently falls back to "C"
-            return babel.Locale.parse("en_US")
-
     @property
     def cache_root(self) -> os.PathLike[Any]:
         return self._dirs.app_cache

ruyi/config/errors.py

@@ -1,8 +1,6 @@
 from os import PathLike
 from typing import Any, Sequence
 
-from ..i18n import _
-
 
 class InvalidConfigSectionError(Exception):
     def __init__(self, section: str) -> None:
@@ -10,7 +8,7 @@ class InvalidConfigSectionError(Exception):
         self._section = section
 
     def __str__(self) -> str:
-        return _("invalid config section: {section}").format(section=self._section)
+        return f"invalid config section: {self._section}"
 
     def __repr__(self) -> str:
         return f"InvalidConfigSectionError({self._section!r})"
@@ -22,7 +20,7 @@ class InvalidConfigKeyError(Exception):
         self._key = key
 
     def __str__(self) -> str:
-        return _("invalid config key: {key}").format(key=self._key)
+        return f"invalid config key: {self._key}"
 
     def __repr__(self) -> str:
         return f"InvalidConfigKeyError({self._key:!r})"
@@ -41,13 +39,7 @@ class InvalidConfigValueTypeError(TypeError):
         self._expected = expected
 
     def __str__(self) -> str:
-        return _(
-            "invalid value type for config key {key}: {actual_type}, expected {expected_type}"
-        ).format(
-            key=self._key,
-            actual_type=type(self._val),
-            expected_type=self._expected,
-        )
+        return f"invalid value type for config key {self._key}: {type(self._val)}, expected {self._expected}"
 
     def __repr__(self) -> str:
         return f"InvalidConfigValueTypeError({self._key!r}, {self._val!r}, {self._expected:!r})"
@@ -66,10 +58,8 @@ class InvalidConfigValueError(ValueError):
         self._typ = typ
 
     def __str__(self) -> str:
-        return _("invalid config value for key {key} (type {typ}): {val}").format(
-            key=self._key,
-            typ=self._typ,
-            val=self._val,
+        return (
+            f"invalid config value for key {self._key} (type {self._typ}): {self._val}"
         )
 
     def __repr__(self) -> str:
@@ -84,7 +74,7 @@ class MalformedConfigFileError(Exception):
         self._path = path
 
     def __str__(self) -> str:
-        return _("malformed config file: {path}").format(path=self._path)
+        return f"malformed config file: {self._path}"
 
     def __repr__(self) -> str:
         return f"MalformedConfigFileError({self._path:!r})"
@@ -96,9 +86,7 @@ class ProtectedGlobalConfigError(Exception):
         self._key = key
 
     def __str__(self) -> str:
-        return _("attempt to modify protected global config key: {key}").format(
-            key=self._key,
-        )
+        return f"attempt to modify protected global config key: {self._key}"
 
     def __repr__(self) -> str:
         return f"ProtectedGlobalConfigError({self._key!r})"

ruyi/device/provision.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, TypedDict, TypeGuard, cast
 
 from ..cli import user_input
 from ..config import GlobalConfig
-from ..i18n import _
 from ..log import RuyiLogger
 from ..ruyipkg.atom import Atom, ExprAtom, SlugAtom
 from ..ruyipkg.entity_provider import BaseEntity
@@ -37,8 +36,7 @@ def do_provision_interactive(config: GlobalConfig) -> int:
     mr.ensure_git_repo()
 
     log.stdout(
-        _(
-            """
+        """
 [bold green]RuyiSDK Device Provisioning Wizard[/]
 
 This is a wizard intended to help you install a system on your device for your
@@ -54,12 +52,11 @@ required to flash images, you should arrange to allow your user account [yellow]
 access to necessary commands such as [yellow]dd[/]. Flashing will fail if the [yellow]sudo[/]
 configuration does not allow so.
 """
-        )
     )
 
-    if not user_input.ask_for_yesno_confirmation(log, _("Continue?")):
+    if not user_input.ask_for_yesno_confirmation(log, "Continue?"):
         log.stdout(
-            _("\nExiting. You can restart the wizard whenever prepared."),
+            "\nExiting. You can restart the wizard whenever prepared.",
             end="\n\n",
         )
         return 1
@@ -71,9 +68,7 @@ configuration does not allow so.
     dev_choices = {k: v.display_name or "" for k, v in devices_by_id.items()}
     dev_id = user_input.ask_for_kv_choice(
         log,
-        _(
-            "\nThe following devices are currently supported by the wizard. Please pick your device:"
-        ),
+        "\nThe following devices are currently supported by the wizard. Please pick your device:",
         dev_choices,
     )
     dev = devices_by_id[dev_id]
@@ -89,9 +84,7 @@ configuration does not allow so.
     variant_choices = [get_variant_display_name(dev, i) for i in variants]
     variant_idx = user_input.ask_for_choice(
         log,
-        _(
-            "\nThe device has the following variants. Please choose the one corresponding to your hardware at hand:"
-        ),
+        "\nThe device has the following variants. Please choose the one corresponding to your hardware at hand:",
         variant_choices,
     )
     variant = variants[variant_idx]
@@ -108,9 +101,7 @@ configuration does not allow so.
     combo_choices = [combo.display_name or "" for combo in supported_combos]
     combo_idx = user_input.ask_for_choice(
         log,
-        _(
-            "\nThe following system configurations are supported by the device variant you have chosen. Please pick the one you want to put on the device:"
-        ),
+        "\nThe following system configurations are supported by the device variant you have chosen. Please pick the one you want to put on the device:",
         combo_choices,
     )
     combo = supported_combos[combo_idx]
@@ -141,8 +132,7 @@ def do_provision_combo_interactive(
     combo: BaseEntity,
 ) -> int:
     logger = config.logger
-    devid = f"{dev_decl.id}@{variant_decl.id}"
-    logger.D(f"provisioning device variant '{devid}'")
+    logger.D(f"provisioning device variant '{dev_decl.id}@{variant_decl.id}'")
 
     # download packages
     pkg_atoms = combo.data.get("package_atoms", [])
@@ -151,36 +141,28 @@ def do_provision_combo_interactive(
             return 0
 
         logger.F(
-            _(
-                "malformed config: device variant '{devid}' asks for no packages but provides no messages either"
-            ).format(
-                devid=devid,
-            )
+            f"malformed config: device variant '{dev_decl.id}@{variant_decl.id}' asks for no packages but provides no messages either"
         )
         return 1
 
     new_pkg_atoms = customize_package_versions(config, mr, pkg_atoms)
     if new_pkg_atoms is None:
-        logger.stdout(
-            _("\nExiting. You may restart the wizard at any time."), end="\n\n"
-        )
+        logger.stdout("\nExiting. You may restart the wizard at any time.", end="\n\n")
         return 1
     else:
         pkg_atoms = new_pkg_atoms
 
     pkg_names_for_display = "\n".join(f" * [green]{i}[/]" for i in pkg_atoms)
     logger.stdout(
-        _(
-            "\nWe are about to download and install the following packages for your device:"
-        ),
-        end="\n\n",
+        f"""
+We are about to download and install the following packages for your device:
+
+{pkg_names_for_display}
+"""
     )
-    logger.stdout(pkg_names_for_display, end="\n\n")
 
-    if not user_input.ask_for_yesno_confirmation(logger, _("Proceed?")):
-        logger.stdout(
-            _("\nExiting. You may restart the wizard at any time."), end="\n\n"
-        )
+    if not user_input.ask_for_yesno_confirmation(logger, "Proceed?"):
+        logger.stdout("\nExiting. You may restart the wizard at any time.", end="\n\n")
         return 1
 
     ret = do_install_atoms(
@@ -192,8 +174,8 @@ def do_provision_combo_interactive(
         reinstall=False,
     )
     if ret != 0:
-        logger.F(_("failed to download and install packages"))
-        logger.I(_("your device was not touched"))
+        logger.F("failed to download and install packages")
+        logger.I("your device was not touched")
         return 2
 
     strat_provider = ProvisionStrategyProvider(mr)
@@ -216,8 +198,7 @@ def do_provision_combo_interactive(
     host_blkdev_map: PartitionMapDecl = {}
     if requested_host_blkdevs:
         logger.stdout(
-            _(
-                """
+            """
 For initializing this target device, you should plug into this host system the
 device's storage (e.g. SD card or NVMe SSD), or a removable disk to be
 reformatted as a live medium, and note down the corresponding device file
@@ -225,7 +206,6 @@ path(s), e.g. /dev/sdX, /dev/nvmeXnY for whole disks; /dev/sdXY, /dev/nvmeXnYpZ
 for partitions. You may consult e.g. [yellow]sudo blkid[/] output for the
 information you will need later.
 """
-            )
         )
         for part in requested_host_blkdevs:
             part_desc = get_part_desc(part)
@@ -233,9 +213,7 @@ information you will need later.
             while True:
                 path = user_input.ask_for_file(
                     logger,
-                    _("Please give the path for the {part_desc}:").format(
-                        part_desc=part_desc,
-                    ),
+                    f"Please give the path for the {part_desc}:",
                 )
 
                 # Retrieve the latest mount info in case the user un-mounts
@@ -246,17 +224,10 @@ information you will need later.
                 for m in blkdev_mounts:
                     if m.source_path.samefile(path):
                         logger.W(
-                            _(
-                                "path [cyan]'{path}'[/] is currently mounted at [yellow]'{target}'[/]"
-                            ).format(
-                                path=path,
-                                target=m.target,
-                            )
+                            f"path [cyan]'{path}'[/] is currently mounted at [yellow]'{m.target}'[/]"
                         )
                         logger.I(
-                            _(
-                                "rejecting the path for safety; please double-check and retry"
-                            )
+                            "rejecting the path for safety; please double-check and retry"
                         )
                         path_valid = False
                         break
@@ -267,14 +238,12 @@ information you will need later.
 
     # final confirmation
     logger.stdout(
-        _(
-            """
+        """
 We have collected enough information for the actual flashing. Now is the last
 chance to re-check and confirm everything is fine.
 
 We are about to:
 """
-        )
     )
 
     pretend_steps = "\n".join(
@@ -288,11 +257,9 @@ We are about to:
     )
     logger.stdout(pretend_steps, end="\n\n")
 
-    if not user_input.ask_for_yesno_confirmation(logger, _("Proceed with flashing?")):
+    if not user_input.ask_for_yesno_confirmation(logger, "Proceed with flashing?"):
         logger.stdout(
-            _(
-                "\nExiting. The device is not touched and you may re-start the wizard at will."
-            ),
+            "\nExiting. The device is not touched and you may re-start the wizard at will.",
             end="\n\n",
         )
         return 1
@@ -306,20 +273,18 @@ We are about to:
             # ask the user to ensure the device shows up
             # TODO: automate doing so
             logger.stdout(
-                _("""
+                """
 Some flashing steps require the use of fastboot, in which case you should
 ensure the target device is showing up in [yellow]fastboot devices[/] output.
 Please [bold red]confirm it yourself before continuing[/].
-""")
+"""
             )
             if not user_input.ask_for_yesno_confirmation(
                 logger,
-                _("Is the device identified by fastboot now?"),
+                "Is the device identified by fastboot now?",
             ):
                 logger.stdout(
-                    _(
-                        "\nAborting. The device is not touched. You may re-start the wizard after [yellow]fastboot[/] is fixed for the device."
-                    ),
+                    "\nAborting. The device is not touched. You may re-start the wizard after [yellow]fastboot[/] is fixed for the device.",
                     end="\n\n",
                 )
                 return 1
@@ -329,16 +294,16 @@ Please [bold red]confirm it yourself before continuing[/].
         logger.D(f"flashing {pkg} with strategy {strat}")
         ret = strat.flash(pkg_part_maps[pkg], host_blkdev_map)
         if ret != 0:
-            logger.F(_("flashing failed, check your device right now"))
+            logger.F("flashing failed, check your device right now")
             return ret
 
     # parting words
     logger.stdout(
-        _("""
+        """
 It seems the flashing has finished without errors.
 
 [bold green]Happy hacking![/]
-""")
+"""
     )
 
     maybe_render_postinst_msg(logger, mr, combo, config.lang_code)
@@ -349,11 +314,11 @@ It seems the flashing has finished without errors.
 def get_part_desc(part: PartitionKind) -> str:
     match part:
         case "disk":
-            return _("target's whole disk")
+            return "target's whole disk"
         case "live":
-            return _("removable disk to use as live medium")
+            return "removable disk to use as live medium"
         case _:
-            return _("target's '{part}' partition").format(part=part)
+            return f"target's '{part}' partition"
 
 
 class PackageProvisionStrategyDecl(TypedDict):
@@ -524,19 +489,17 @@ def customize_package_versions(
 
     # Ask if the user wants to customize package versions
     logger.stdout(
-        _(
-            "By default, we'll install the latest version of each package, but in this case, other choices are possible."
-        )
+        "By default, we'll install the latest version of each package, but in this case, other choices are possible."
     )
     if not user_input.ask_for_yesno_confirmation(
         logger,
-        _("Would you like to customize package versions?"),
+        "Would you like to customize package versions?",
     ):
         return pkg_atoms
 
     while True:  # Loop to allow restarting the selection process
         result: list[str] = []
-        logger.stdout(_("\n[bold]Package Version Selection[/]"))
+        logger.stdout("\n[bold]Package Version Selection[/]")
 
         for atom_str in pkg_atoms:
             # Parse the atom to get package name
@@ -544,26 +507,18 @@ def customize_package_versions(
             if isinstance(a, ExprAtom):
                 # If it's already an expression with version constraints, show the constraints
                 logger.stdout(
-                    _(
-                        "\nPackage [green]{atom}[/] already has version constraints."
-                    ).format(
-                        atom=atom_str,
-                    )
+                    f"\nPackage [green]{atom_str}[/] already has version constraints."
                 )
                 if not user_input.ask_for_yesno_confirmation(
                     logger,
-                    _("Would you like to change them?"),
+                    "Would you like to change them?",
                 ):
                     result.append(atom_str)
                     continue
             elif isinstance(a, SlugAtom):
                 # Slugs already fix the version, so we can't change them
                 logger.W(
-                    _(
-                        "version cannot be overridden for slug atom [green]{atom}[/]"
-                    ).format(
-                        atom=atom_str,
-                    )
+                    f"version cannot be overridden for slug atom [green]{atom_str}[/]"
                 )
                 result.append(atom_str)
                 continue
@@ -571,24 +526,19 @@ def customize_package_versions(
             # Get all available versions for this package
             package_name = a.name
             category = a.category
-            pkg_fullname = f"{category}/{package_name}" if category else package_name
 
             available_versions: "list[BoundPackageManifest]" = []
             try:
                 available_versions = list(mr.iter_pkg_vers(package_name, category))
             except KeyError:
                 logger.W(
-                    _("could not find package [yellow]{pkg}[/] in repository").format(
-                        pkg=pkg_fullname
-                    )
+                    f"could not find package [yellow]{category}/{package_name}[/] in repository"
                 )
                 result.append(atom_str)
 
             if not available_versions:
                 logger.W(
-                    _("no versions found for package [yellow]{pkg}[/]").format(
-                        pkg=pkg_fullname
-                    )
+                    f"no versions found for package [yellow]{category}/{package_name}[/]"
                 )
                 result.append(atom_str)
                 continue
@@ -597,12 +547,7 @@ def customize_package_versions(
                 # If there's only one version available, use it
                 selected_version = available_versions[0]
                 logger.stdout(
-                    _(
-                        "Only one version available for [green]{pkg}[/]: [blue]{ver}[/], using it."
-                    ).format(
-                        pkg=pkg_fullname,
-                        ver=selected_version.ver,
-                    )
+                    f"Only one version available for [green]{category}/{package_name}[/]: [blue]{selected_version.ver}[/], using it."
                 )
                 result.append(atom_str)
                 continue
@@ -617,15 +562,11 @@ def customize_package_versions(
                 remarks = []
 
                 if pm.is_prerelease:
-                    remarks.append(_("prerelease"))
+                    remarks.append("prerelease")
                 if pm.service_level.has_known_issues:
-                    remarks.append(_("has known issues"))
+                    remarks.append("has known issues")
                 if pm.upstream_version:
-                    remarks.append(
-                        _("upstream: {upstream_ver}").format(
-                            upstream_ver=pm.upstream_version
-                        )
-                    )
+                    remarks.append(f"upstream: {pm.upstream_version}")
 
                 remark_str = f" ({', '.join(remarks)})" if remarks else ""
                 version_choices.append(f"{version_str}{remark_str}")
@@ -633,9 +574,7 @@ def customize_package_versions(
             # Ask the user to select a version
             version_idx = user_input.ask_for_choice(
                 logger,
-                _("\nSelect a version for package [green]{pkg}[/]:").format(
-                    pkg=pkg_fullname,
-                ),
+                f"\nSelect a version for package [green]{category or ''}{('/' + package_name) if category else package_name}[/]:",
                 version_choices,
             )
 
@@ -647,27 +586,27 @@ def customize_package_versions(
             else:
                 new_atom = f"{package_name}(=={selected_version.ver})"
 
-            logger.stdout(_("Selected: [blue]{new_atom}[/]").format(new_atom=new_atom))
+            logger.stdout(f"Selected: [blue]{new_atom}[/]")
             result.append(new_atom)
 
-        logger.stdout(_("\nPackage versions to be installed:"))
+        logger.stdout("\nPackage versions to be installed:")
         for atom in result:
             logger.stdout(f" * [green]{atom}[/]")
 
         confirmation = user_input.ask_for_choice(
             logger,
-            _("\nHow would you like to proceed?"),
+            "\nHow would you like to proceed?",
             [
-                _("Continue with these versions"),
-                _("Restart version selection"),
-                _("Abort device provisioning"),
+                "Continue with these versions",
+                "Restart version selection",
+                "Abort device provisioning",
             ],
         )
 
         if confirmation == 0:  # Continue with these versions
             return result
         elif confirmation == 1:  # Restart version selection
-            logger.stdout(_("\nRestarting package version selection..."))
+            logger.stdout("\nRestarting package version selection...")
             continue
         else:  # Abort installation
             return None

ruyi/device/provision_cli.py

@@ -2,7 +2,6 @@ import argparse
 from typing import TYPE_CHECKING
 
 from ..cli.cmd import RootCommand
-from ..i18n import _
 
 if TYPE_CHECKING:
     from ..cli.completion import ArgumentParser
@@ -13,7 +12,7 @@ class DeviceCommand(
     RootCommand,
     cmd="device",
     has_subcommands=True,
-    help=_("Manage devices"),
+    help="Manage devices",
 ):
     @classmethod
     def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
@@ -24,7 +23,7 @@ class DeviceProvisionCommand(
     DeviceCommand,
     cmd="provision",
     aliases=["flash"],
-    help=_("Interactively initialize a device for development"),
+    help="Interactively initialize a device for development",
 ):
     @classmethod
     def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
@@ -37,7 +36,5 @@ class DeviceProvisionCommand(
         try:
             return do_provision_interactive(cfg)
         except KeyboardInterrupt:
-            cfg.logger.stdout(
-                _("\n\nKeyboard interrupt received, exiting."), end="\n\n"
-            )
+            cfg.logger.stdout("\n\nKeyboard interrupt received, exiting.", end="\n\n")
             return 1

ruyi/log/__init__.py

@@ -11,7 +11,6 @@ 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
 
@@ -218,7 +217,7 @@ class RuyiConsoleLogger(RuyiLogger):
             return self._emit_porcelain_log("F", message, sep, *objects)
 
         return self.log_console.print(
-            _("[bold red]fatal error:[/] {message}").format(message=message),
+            f"[bold red]fatal error:[/] {message}",
             *objects,
             sep=sep,
             end=end,
@@ -235,7 +234,7 @@ class RuyiConsoleLogger(RuyiLogger):
             return self._emit_porcelain_log("I", message, sep, *objects)
 
         return self.log_console.print(
-            _("[bold green]info:[/] {message}").format(message=message),
+            f"[bold green]info:[/] {message}",
             *objects,
             sep=sep,
             end=end,
@@ -252,7 +251,7 @@ class RuyiConsoleLogger(RuyiLogger):
             return self._emit_porcelain_log("W", message, sep, *objects)
 
         return self.log_console.print(
-            _("[bold yellow]warn:[/] {message}").format(message=message),
+            f"[bold yellow]warn:[/] {message}",
             *objects,
             sep=sep,
             end=end,
@@ -264,10 +263,10 @@ def humanize_list(
     *,
     sep: str = ", ",
     item_color: str | None = None,
-    empty_prompt: str | None = None,
+    empty_prompt: str = "(none)",
 ) -> str:
     if not obj:
-        return empty_prompt if empty_prompt is not None else _("(none)")
+        return empty_prompt
     if item_color is None:
         return sep.join(obj)
     return sep.join(f"[{item_color}]{x}[/]" for x in obj)