ruyi 0.42.0a20251013__tar.gz → 0.42.0b20251015__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ruyi
-Version: 0.42.0a20251013
+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.0a20251013 → ruyi-0.42.0b20251015}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "ruyi"
-version = "0.42.0-alpha.20251013"
+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.0a20251013 → 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.0a20251013 → 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.0a20251013 → 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.0a20251013 → 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.0a20251013 → 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.0a20251013 → ruyi-0.42.0b20251015}/ruyi/ruyipkg/profile.py

@@ -1,7 +1,21 @@
 from os import PathLike
-from typing import Any, Iterable, TypeGuard, cast
+from typing import (
+    Any,
+    Iterable,
+    Mapping,
+    Protocol,
+    Sequence,
+    TypedDict,
+    TypeGuard,
+    TYPE_CHECKING,
+    cast,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import NotRequired
 
 from ..pluginhost.ctx import PluginHostContext, SupportsEvalFunction
+from .entity_provider import BaseEntityProvider
 from .pkg_manifest import EmulatorFlavor
 
 
@@ -206,3 +220,136 @@ class ProfileProxy:
         sysroot: PathLike[Any] | None,
     ) -> dict[str, str] | None:
         return self._provider.get_env_config_for_emu_flavor(self._id, flavor, sysroot)
+
+
+#
+# Protocols
+#
+
+
+# MetadataRepo is defined in repo.py, but we don't want to import repo.py here
+# to avoid circular import. Instead, we just describe the methods and properties
+# that we need from MetadataRepo with a Protocol.
+class ProvidesProfiles(Protocol):
+    def get_supported_arches(self) -> list[str]: ...
+    def get_profile_for_arch(self, arch: str, name: str) -> ProfileProxy | None: ...
+    def iter_profiles_for_arch(self, arch: str) -> Iterable[ProfileProxy]: ...
+
+
+#
+# Entity type and schema for profile entities
+#
+
+PROFILE_V1_ENTITY_TYPE = "profile-v1"
+PROFILE_V1_ENTITY_TYPE_SCHEMA = {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "required": ["profile-v1"],
+    "properties": {
+        "profile-v1": {
+            "type": "object",
+            "properties": {
+                "id": {"type": "string"},
+                "display_name": {"type": "string"},
+                "name": {"type": "string"},
+                "arch": {"type": "string"},
+                "needed_toolchain_quirks": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                },
+                "toolchain_common_flags_str": {"type": "string"},
+            },
+            "required": [
+                "id",
+                "display_name",
+                "name",
+                "arch",
+                "needed_toolchain_quirks",
+                "toolchain_common_flags_str",
+            ],
+        },
+        "related": {
+            "type": "array",
+            "description": "List of related entity references",
+            "items": {"type": "string", "pattern": "^.+:.+"},
+        },
+        "unique_among_type_during_traversal": {
+            "type": "boolean",
+            "description": "Whether this entity should be unique among all entities of the same type during traversal",
+        },
+    },
+}
+
+
+class ProfileV1EntityData(TypedDict):
+    id: str
+    display_name: str
+    name: str
+    arch: str
+    needed_toolchain_quirks: list[str]
+    toolchain_common_flags_str: str
+
+
+ProfileV1Entity = TypedDict(
+    "ProfileV1Entity",
+    {
+        "profile-v1": ProfileV1EntityData,
+        "related": "NotRequired[list[str]]",
+        "unique_among_type_during_traversal": "NotRequired[bool]",
+    },
+    total=False,
+)
+
+
+class ProfileEntityProvider(BaseEntityProvider):
+    def __init__(self, provider: ProvidesProfiles) -> None:
+        super().__init__()
+        self._provider = provider
+
+    def discover_schemas(self) -> dict[str, object]:
+        return {
+            PROFILE_V1_ENTITY_TYPE: PROFILE_V1_ENTITY_TYPE_SCHEMA,
+        }
+
+    def load_entities(
+        self,
+        entity_types: Sequence[str],
+    ) -> Mapping[str, Mapping[str, Mapping[str, Any]]]:
+        result: dict[str, Mapping[str, Mapping[str, Any]]] = {}
+        for ty in entity_types:
+            if ty == PROFILE_V1_ENTITY_TYPE:
+                result[ty] = _load_profile_v1_entities(self._provider)
+        return result
+
+
+def _load_profile_v1_entities(provider: ProvidesProfiles) -> dict[str, ProfileV1Entity]:
+    result: dict[str, ProfileV1Entity] = {}
+    for arch in provider.get_supported_arches():
+        result.update(_load_profile_v1_entities_for_arch(provider, arch))
+    return result
+
+
+def _load_profile_v1_entities_for_arch(
+    provider: ProvidesProfiles,
+    arch: str,
+) -> dict[str, ProfileV1Entity]:
+    result: dict[str, ProfileV1Entity] = {}
+    for profile in provider.iter_profiles_for_arch(arch):
+        full_name = profile.id
+        relations = [f"arch:{arch}"]
+
+        needed_toolchain_quirks = sorted(profile.need_quirks)
+
+        result[profile.id] = {
+            "profile-v1": {
+                "id": profile.id,
+                "display_name": full_name,
+                "name": profile.id,
+                "arch": profile.arch,
+                "needed_toolchain_quirks": needed_toolchain_quirks,
+                "toolchain_common_flags_str": profile.get_common_flags(
+                    needed_toolchain_quirks,
+                ),
+            },
+            "related": relations,
+        }
+    return result

{ruyi-0.42.0a20251013 → ruyi-0.42.0b20251015}/ruyi/ruyipkg/repo.py

@@ -34,7 +34,7 @@ from .pkg_manifest import (
     InputPackageManifestType,
     is_prerelease,
 )
-from .profile import PluginProfileProvider, ProfileProxy
+from .profile import PluginProfileProvider, ProfileEntityProvider, ProfileProxy
 from .protocols import ProvidesPackageManifests
 
 if sys.version_info >= (3, 11):
@@ -234,6 +234,7 @@ class MetadataRepo(ProvidesPackageManifests):
             gc.logger,
             FSEntityProvider(gc.logger, pathlib.Path(self.root) / "entities"),
             MetadataRepoEntityProvider(self),
+            ProfileEntityProvider(self),
         )
         self._plugin_host_ctx = PluginHostContext.new(gc.logger, self.plugin_root)
         self._plugin_fn_evaluator = self._plugin_host_ctx.make_evaluator()

{ruyi-0.42.0a20251013 → 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.0a20251013 → 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)