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

ruyi/cli/user_input.py

@@ -1,5 +1,6 @@
 import os.path
 
+from ..i18n import _
 from ..log import RuyiLogger
 
 
@@ -10,7 +11,7 @@ def pause_before_continuing(
 
     EOFError should be handled by the caller."""
 
-    logger.stdout("Press [green]<ENTER>[/] to continue: ", end="")
+    logger.stdout(_("Press [green]<ENTER>[/] to continue: "), end="")
     input()
 
 
@@ -26,9 +27,11 @@ def ask_for_yesno_confirmation(
             logger.stdout(f"{prompt} {choices_help} ", end="")
             user_input = input()
         except EOFError:
-            yesno = "YES" if default else "NO"
+            yesno = _("YES") if default else _("NO")
             logger.W(
-                f"EOF while reading user input, assuming the default choice {yesno}"
+                _(
+                    "EOF while reading user input, assuming the default choice {yesno}"
+                ).format(yesno=yesno)
             )
             return default
 
@@ -39,8 +42,12 @@ def ask_for_yesno_confirmation(
         if user_input in {"N", "n", "no"}:
             return False
         else:
-            logger.stdout(f"Unrecognized input [yellow]'{user_input}'[/].")
-            logger.stdout("Accepted choices: Y/y/yes for YES, N/n/no for NO.")
+            logger.stdout(
+                _("Unrecognized input [yellow]'{user_input}'[/].").format(
+                    user_input=user_input
+                )
+            )
+            logger.stdout(_("Accepted choices: Y/y/yes for YES, N/n/no for NO."))
 
 
 def ask_for_kv_choice(
@@ -81,12 +88,19 @@ def ask_for_choice(
     if default_idx is not None:
         if not (0 <= default_idx < nr_choices):
             raise ValueError(f"Default choice index {default_idx} out of range")
-        choices_help = f"(1-{nr_choices}, default {default_idx + 1})"
+        choices_help = _("(1-{nr_choices}, default {default})").format(
+            nr_choices=nr_choices,
+            default=default_idx + 1,
+        )
     else:
-        choices_help = f"(1-{nr_choices})"
+        choices_help = _("(1-{nr_choices})").format(nr_choices=nr_choices)
     while True:
         try:
-            user_input = input(f"Choice? {choices_help} ")
+            user_input = input(
+                _("Choice? {choices_help} ").format(
+                    choices_help=choices_help,
+                )
+            )
         except EOFError:
             raise ValueError("EOF while reading user choice")
 
@@ -96,18 +110,34 @@ def ask_for_choice(
         try:
             choice_int = int(user_input)
         except ValueError:
-            logger.stdout(f"Unrecognized input [yellow]'{user_input}'[/].")
             logger.stdout(
-                f"Accepted choices: an integer number from 1 to {nr_choices} inclusive."
+                _("Unrecognized input [yellow]'{user_input}'[/].").format(
+                    user_input=user_input,
+                )
+            )
+            logger.stdout(
+                _(
+                    "Accepted choices: an integer number from 1 to {nr_choices} inclusive."
+                ).format(
+                    nr_choices=nr_choices,
+                )
             )
             continue
 
         if 1 <= choice_int <= nr_choices:
             return choice_int - 1
 
-        logger.stdout(f"Out-of-range input [yellow]'{user_input}'[/].")
         logger.stdout(
-            f"Accepted choices: an integer number from 1 to {nr_choices} inclusive."
+            _("Out-of-range input [yellow]'{user_input}'[/].").format(
+                user_input=user_input,
+            )
+        )
+        logger.stdout(
+            _(
+                "Accepted choices: an integer number from 1 to {nr_choices} inclusive."
+            ).format(
+                nr_choices=nr_choices,
+            )
         )
 
 

ruyi/cli/version_cli.py

@@ -1,6 +1,7 @@
 import argparse
 from typing import TYPE_CHECKING
 
+from ..i18n import _
 from .cmd import RootCommand
 
 if TYPE_CHECKING:
@@ -11,7 +12,7 @@ if TYPE_CHECKING:
 class VersionCommand(
     RootCommand,
     cmd="version",
-    help="Print version information",
+    help=_("Print version information"),
 ):
     @classmethod
     def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
@@ -27,19 +28,24 @@ def cli_version(cfg: "GlobalConfig", args: argparse.Namespace) -> int:
     from ..ruyipkg.host import get_native_host
     from ..version import COPYRIGHT_NOTICE, MPL_REDIST_NOTICE, RUYI_SEMVER
 
-    print(f"Ruyi {RUYI_SEMVER}\n\nRunning on {get_native_host()}.")
+    print(
+        _("Ruyi {version}\n\nRunning on {host}.").format(
+            version=RUYI_SEMVER,
+            host=get_native_host(),
+        )
+    )
 
     if cfg.is_installation_externally_managed:
-        print("This Ruyi installation is externally managed.")
+        print(_("This Ruyi installation is externally managed."))
 
     print()
 
-    cfg.logger.stdout(COPYRIGHT_NOTICE)
+    cfg.logger.stdout(_(COPYRIGHT_NOTICE))
 
     # Output the MPL notice only when we actually bundle and depend on the
     # MPL component(s), which right now is only certifi. Keep the condition
     # synced with __main__.py.
     if hasattr(ruyi, "__compiled__") and ruyi.__compiled__.standalone:
-        cfg.logger.stdout(MPL_REDIST_NOTICE)
+        cfg.logger.stdout(_(MPL_REDIST_NOTICE))
 
     return 0

ruyi/config/__init__.py

@@ -18,6 +18,13 @@ 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
 
@@ -115,7 +122,11 @@ 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(
-                    f"the config key [yellow]{iem_cfg_key}[/] cannot be set from user config; ignoring",
+                    _(
+                        "the config key [yellow]{key}[/] cannot be set from user config; ignoring"
+                    ).format(
+                        key=iem_cfg_key,
+                    ),
                 )
             else:
                 self.is_installation_externally_managed = bool(iem)
@@ -133,7 +144,11 @@ class GlobalConfig:
             if self.override_repo_dir:
                 if not pathlib.Path(self.override_repo_dir).is_absolute():
                     self.logger.W(
-                        f"the local repo path '{self.override_repo_dir}' is not absolute; ignoring"
+                        _(
+                            "the local repo path '{path}' is not absolute; ignoring"
+                        ).format(
+                            path=self.override_repo_dir,
+                        )
                     )
                     self.override_repo_dir = None
 
@@ -274,6 +289,15 @@ 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
@@ -297,17 +321,13 @@ class GlobalConfig:
     def telemetry_root(self) -> os.PathLike[Any]:
         return pathlib.Path(self.ensure_state_dir()) / "telemetry"
 
-    @property
-    def telemetry(self) -> "TelemetryProvider | None":
-        return None if self.telemetry_mode == "off" else self._telemetry_provider
-
     @cached_property
-    def _telemetry_provider(self) -> "TelemetryProvider | None":
-        """Do not access directly; use the ``telemetry`` property instead."""
-
+    def telemetry(self) -> "TelemetryProvider":
         from ..telemetry.provider import TelemetryProvider
 
-        return None if self.telemetry_mode == "off" else TelemetryProvider(self)
+        # for allowing minimal uploads when telemetry is off
+        minimal_mode = self.telemetry_mode == "off"
+        return TelemetryProvider(self, minimal_mode)
 
     @property
     def telemetry_mode(self) -> str:

ruyi/config/errors.py

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