ruyi 0.42.0b20251014__tar.gz → 0.42.0b20251015__tar.gz

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ruyi
-Version: 0.42.0b20251014
+Version: 0.42.0b20251015
 Summary: Package manager for RuyiSDK
 License: Apache License
                                     Version 2.0, January 2004
@@ -221,7 +221,7 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Software Development :: Embedded Systems
 Classifier: Topic :: System :: Software Distribution
 Classifier: Typing :: Typed
-Requires-Dist: argcomplete (>=2.0.0,<4.0.0)
+Requires-Dist: argcomplete (>=2.0.0)
 Requires-Dist: arpy
 Requires-Dist: fastjsonschema (>=2.15.1)
 Requires-Dist: jinja2 (>=3,<4)

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "ruyi"
-version = "0.42.0-beta.20251014"
+version = "0.42.0-beta.20251015"
 description = "Package manager for RuyiSDK"
 keywords = ["ruyi", "ruyisdk"]
 license = { file = "LICENSE-Apache.txt" }
@@ -29,6 +29,7 @@ classifiers = [
 ]
 requires-python = ">=3.10"
 dependencies = [
+  "argcomplete>=2.0.0",
   "arpy",
   "fastjsonschema>=2.15.1",
   "jinja2 (>=3, <4)",
@@ -41,7 +42,6 @@ dependencies = [
   "tomlkit>=0.9",
   "tomli>=1.2; python_version<'3.11'",
   "tzdata; sys_platform=='win32'",
-  "argcomplete (>=2.0.0,<4.0.0)",
 ]
 
 [project.scripts]

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/ruyi/cli/oobe.py

@@ -41,10 +41,16 @@ class OOBE:
     def should_prompt(self) -> bool:
         from ..utils.global_mode import is_env_var_truthy
 
+        if not sys.stdin.isatty() or not sys.stdout.isatty():
+            # This is of higher priority than even the debug override, because
+            # we don't want to mess up non-interactive sessions even in case of
+            # debugging.
+            return False
+
         if is_env_var_truthy(os.environ, "RUYI_DEBUG_FORCE_FIRST_RUN"):
             return True
 
-        return self.is_first_run() and sys.stdin.isatty()
+        return self.is_first_run()
 
     def maybe_prompt(self) -> None:
         if not self.should_prompt():

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/ruyi/cli/self_cli.py

@@ -131,12 +131,16 @@ class SelfCleanCommand(
         _do_reset(
             cfg,
             quiet=quiet,
+            # state-related
+            all_state=all,
+            news_read_status=news_read_status,
+            telemetry=telemetry,
+            # cache-related
+            all_cache=all,
             distfiles=distfiles,
             installed_pkgs=installed_pkgs,
-            news_read_status=news_read_status,
             progcache=progcache,
             repo=repo,
-            telemetry=telemetry,
         )
 
         return 0
@@ -233,6 +237,7 @@ def _do_reset(
     if installed_pkgs:
         status("removing installed packages")
         shutil.rmtree(cfg.data_root, True)
+        cfg.ruyipkg_global_state.purge_installation_info()
 
     # do not record any telemetry data if we're purging it
     if all_state or telemetry:

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/ruyi/config/__init__.py

@@ -166,13 +166,7 @@ class GlobalConfig:
         attr_name = self._get_attr_name_by_key(section, sel)
         if attr_name is None:
             raise errors.InvalidConfigKeyError(key)
-
-        expected_type = schema.get_expected_type_for_config_key(key)
-        if not isinstance(value, expected_type):
-            raise TypeError(
-                f"expected type {expected_type.__name__} for config key '{key}', got {type(value).__name__}"
-            )
-
+        schema.ensure_valid_config_kv(key, True, value)
         setattr(self, attr_name, value)
 
     @classmethod

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/ruyi/config/errors.py

@@ -31,7 +31,7 @@ class InvalidConfigValueTypeError(TypeError):
         self,
         key: str | Sequence[str],
         val: object | None,
-        expected: type,
+        expected: type | Sequence[type],
     ) -> None:
         super().__init__()
         self._key = key
@@ -48,20 +48,24 @@ class InvalidConfigValueTypeError(TypeError):
 class InvalidConfigValueError(ValueError):
     def __init__(
         self,
-        key: str | Sequence[str] | type,
+        key: str | Sequence[str] | None,
         val: object | None,
+        typ: type | Sequence[type],
     ) -> None:
         super().__init__()
         self._key = key
         self._val = val
+        self._typ = typ
 
     def __str__(self) -> str:
-        if isinstance(self._key, type):
-            return f"invalid config value for type {self._key}: {self._val}"
-        return f"invalid config value for key {self._key}: {self._val}"
+        return (
+            f"invalid config value for key {self._key} (type {self._typ}): {self._val}"
+        )
 
     def __repr__(self) -> str:
-        return f"InvalidConfigValueError({self._key:!r}, {self._val:!r})"
+        return (
+            f"InvalidConfigValueError({self._key:!r}, {self._val:!r}, {self._typ:!r})"
+        )
 
 
 class MalformedConfigFileError(Exception):

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/ruyi/config/schema.py

@@ -1,6 +1,6 @@
 import datetime
 import sys
-from typing import Final, Sequence
+from typing import Final, Sequence, TypeGuard
 
 from .errors import (
     InvalidConfigKeyError,
@@ -43,7 +43,7 @@ def validate_section(section: str) -> None:
         raise InvalidConfigSectionError(section)
 
 
-def get_expected_type_for_config_key(key: str | Sequence[str]) -> type:
+def get_expected_type_for_config_key(key: str | Sequence[str]) -> type | Sequence[type]:
     parsed_key = parse_config_key(key)
     if len(parsed_key) != 2:
         # for now there's no nested config option
@@ -87,17 +87,29 @@ def _get_expected_type_for_section_repo(sel: str) -> type:
         raise InvalidConfigKeyError(sel)
 
 
-def _get_expected_type_for_section_telemetry(sel: str) -> type:
+def _get_expected_type_for_section_telemetry(sel: str) -> type | tuple[type, ...]:
     if sel == KEY_TELEMETRY_MODE:
         return str
     elif sel == KEY_TELEMETRY_PM_TELEMETRY_URL:
         return str
     elif sel == KEY_TELEMETRY_UPLOAD_CONSENT:
-        return datetime.datetime
+        return (type(None), datetime.datetime)
     else:
         raise InvalidConfigKeyError(sel)
 
 
+def _is_all_str(obj: object) -> TypeGuard[Sequence[str]]:
+    if not isinstance(obj, Sequence):
+        return False
+    return all(isinstance(i, str) for i in obj)
+
+
+def _is_all_type(obj: object) -> TypeGuard[Sequence[type]]:
+    if not isinstance(obj, Sequence):
+        return False
+    return all(isinstance(i, type) for i in obj)
+
+
 def ensure_valid_config_kv(
     key: str | Sequence[str],
     check_val: bool = False,
@@ -108,9 +120,9 @@ def ensure_valid_config_kv(
         # for now there's no nested config option
         raise InvalidConfigKeyError(key)
 
-    expected_type = get_expected_type_for_config_key(parsed_key)
+    expected_types = get_expected_type_for_config_key(parsed_key)
     # validity of config key is already checked by get_expected_type_for_config_key
-    _ensure_value_type(key, check_val, val, expected_type)
+    ensure_value_type(key, check_val, val, expected_types)
 
     if not check_val:
         return
@@ -120,14 +132,26 @@ def ensure_valid_config_kv(
         return _extra_validate_section_telemetry_kv(key, sel, val)
 
 
-def _ensure_value_type(
+def ensure_value_type(
     key: str | Sequence[str],
     check_val: bool,
     val: object | None,
-    expected: type,
+    expected: type | Sequence[type],
 ) -> None:
-    if check_val and not isinstance(val, expected):
-        raise InvalidConfigValueTypeError(key, val, expected)
+    if not check_val:
+        return
+
+    expected_types: tuple[type, ...]
+    if isinstance(expected, type):
+        expected_types = (expected,)
+    else:
+        expected_types = tuple(expected)
+
+    for ty in expected_types:
+        if isinstance(val, ty):
+            return
+
+    raise InvalidConfigValueTypeError(key, val, expected)
 
 
 def _extra_validate_section_telemetry_kv(
@@ -138,7 +162,7 @@ def _extra_validate_section_telemetry_kv(
     if sel == KEY_TELEMETRY_MODE:
         # value type is already ensured earlier
         if val not in ("local", "off", "on"):
-            raise InvalidConfigValueError(key, val)
+            raise InvalidConfigValueError(key, val, str)
 
 
 def encode_value(v: object) -> str:
@@ -169,24 +193,50 @@ def encode_value(v: object) -> str:
 
 
 def decode_value(
-    key: str | Sequence[str] | type,
+    key: str | Sequence[str],
     val: str,
 ) -> object:
     """Decodes the given string representation of a config value into a Python
     value, directed by type information implied by the config key."""
 
     if isinstance(key, type):
-        expected_type = key
-    else:
-        expected_type = get_expected_type_for_config_key(key)
+        return _decode_single_type_value(None, val, key)
+    elif _is_all_type(key):
+        return _decode_typed_value(None, val, key)
+
+    assert isinstance(key, str) or _is_all_str(key)
+    expected_types = get_expected_type_for_config_key(key)
+
+    if isinstance(expected_types, type):
+        return _decode_single_type_value(key, val, expected_types)
+    return _decode_typed_value(key, val, expected_types)
+
+
+def _decode_typed_value(
+    key: str | Sequence[str] | None,
+    val: str,
+    expected_types: Sequence[type],
+) -> object:
+    for ty in expected_types:
+        try:
+            return _decode_single_type_value(key, val, ty)
+        except (RuntimeError, TypeError, ValueError):
+            continue
+    raise InvalidConfigValueError(key, val, expected_types)
+
 
+def _decode_single_type_value(
+    key: str | Sequence[str] | None,
+    val: str,
+    expected_type: type,
+) -> object:
     if expected_type is bool:
         if val in ("true", "yes", "1"):
             return True
         elif val in ("false", "no", "0"):
             return False
         else:
-            raise InvalidConfigValueError(key, val)
+            raise InvalidConfigValueError(key, val, expected_type)
     elif expected_type is int:
         return int(val, 10)
     elif expected_type is str:
@@ -199,4 +249,4 @@ def decode_value(
         v = datetime.datetime.fromisoformat(val)
         return v.astimezone() if v.tzinfo is None else v
     else:
-        raise NotImplementedError(f"invalid type for config value: {expected_type}")
+        raise NotImplementedError(f"unhandled type for config value: {expected_type}")

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/ruyi/ruyipkg/state.py

@@ -76,6 +76,16 @@ class RuyipkgGlobalStateStore:
         """Ensure the state directory exists."""
         self.root.mkdir(parents=True, exist_ok=True)
 
+    def purge_installation_info(self) -> None:
+        """Purge installation records."""
+        self._installs_file.unlink(missing_ok=True)
+        self._installs_cache = None
+        # if the state dir is empty, remove it
+        try:
+            self.root.rmdir()
+        except OSError:
+            pass
+
     def _load_installs(self) -> dict[str, PackageInstallationInfo]:
         """Load installation records from disk."""
         if self._installs_cache is not None:

{ruyi-0.42.0b20251014 → ruyi-0.42.0b20251015}/ruyi/utils/global_mode.py

@@ -128,6 +128,24 @@ def _guess_porcelain_from_argv(argv: list[str]) -> bool:
     return len(argv) > 1 and argv[1] == "--porcelain"
 
 
+def _probe_cli_autocomplete(env: Mapping[str, str], argv: list[str]) -> bool:
+    """
+    Probe if the current invocation is related to shell completion based on
+    the arguments passed, without requiring the ``argparse`` machinery to be
+    completely initialized, and the environment.
+    """
+
+    # If `--output-completion-script` is present anywhere in the arguments,
+    # then this is related to shell completion even if _ARGCOMPLETE is not yet
+    # set (which is only set for invocations after the shell finished sourcing
+    # the completion script).
+    for arg in argv:
+        if arg.startswith("--output-completion-script"):
+            return True
+
+    return "_ARGCOMPLETE" in os.environ
+
+
 class EnvGlobalModeProvider(GlobalModeProvider):
     def __init__(
         self,
@@ -150,7 +168,7 @@ class EnvGlobalModeProvider(GlobalModeProvider):
 
         # We have to lift this piece of implementation detail out of argcomplete,
         # as the argcomplete import is very costly in terms of startup time.
-        self._is_cli_autocomplete = "_ARGCOMPLETE" in os.environ
+        self._is_cli_autocomplete = _probe_cli_autocomplete(env, argv)
 
         self._venv_root = env.get(ENV_VENV_ROOT_KEY)