ruyi 0.39.0__py3-none-any.whl

ruyi/mux/venv/venv_cli.py

@@ -0,0 +1,92 @@
+import argparse
+import pathlib
+from typing import TYPE_CHECKING
+
+from ...cli.cmd import RootCommand
+
+if TYPE_CHECKING:
+    from ...cli.completion import ArgumentParser
+    from ...config import GlobalConfig
+
+
+class VenvCommand(
+    RootCommand,
+    cmd="venv",
+    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(
+            "--name",
+            "-n",
+            type=str,
+            default=None,
+            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",
+        )
+        p.add_argument(
+            "--emulator",
+            "-e",
+            type=str,
+            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)",
+        )
+        p.add_argument(
+            "--without-sysroot",
+            action="store_false",
+            dest="with_sysroot",
+            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",
+        )
+        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",
+        )
+
+    @classmethod
+    def main(cls, cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+        from ...ruyipkg.host import get_native_host
+        from .maker import do_make_venv
+
+        profile_name: str = args.profile
+        dest = pathlib.Path(args.dest)
+        with_sysroot: bool = args.with_sysroot
+        override_name: str | None = args.name
+        tc_atoms_str: list[str] | None = args.toolchain
+        emu_atom_str: str | None = args.emulator
+        sysroot_atom_str: str | None = args.sysroot_from
+        extra_cmd_atoms_str: list[str] | None = args.extra_commands_from
+        host = str(get_native_host())
+
+        return do_make_venv(
+            cfg,
+            host,
+            profile_name,
+            dest,
+            with_sysroot,
+            override_name,
+            tc_atoms_str,
+            emu_atom_str,
+            sysroot_atom_str,
+            extra_cmd_atoms_str,
+        )

ruyi/mux/venv_cfg.py

@@ -0,0 +1,214 @@
+import copy
+import os.path
+import pathlib
+import sys
+from typing import Any, TypedDict, TYPE_CHECKING, cast
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+if TYPE_CHECKING:
+    from typing_extensions import NotRequired, Self
+
+
+from ..log import RuyiLogger
+from ..utils.global_mode import ProvidesGlobalMode
+
+
+class VenvConfigType(TypedDict):
+    profile: str
+    sysroot: "NotRequired[str]"
+
+
+class VenvConfigRootType(TypedDict):
+    config: VenvConfigType
+
+
+class VenvCacheV0Type(TypedDict):
+    target_tuple: str
+    toolchain_bindir: str
+    gcc_install_dir: "NotRequired[str]"
+    profile_common_flags: str
+    qemu_bin: "NotRequired[str]"
+    profile_emu_env: "NotRequired[dict[str, str]]"
+
+
+class VenvCacheV1TargetType(TypedDict):
+    toolchain_bindir: str
+    toolchain_sysroot: "NotRequired[str]"
+    gcc_install_dir: "NotRequired[str]"
+
+
+class VenvCacheV2TargetType(VenvCacheV1TargetType):
+    toolchain_flags: str
+
+
+class VenvCacheV1CmdMetadataEntryType(TypedDict):
+    dest: str
+    target_tuple: str
+
+
+class VenvCacheV1Type(TypedDict):
+    profile_common_flags: str
+    profile_emu_env: "NotRequired[dict[str, str]]"
+    qemu_bin: "NotRequired[str]"
+    targets: dict[str, VenvCacheV1TargetType]
+    cmd_metadata_map: "NotRequired[dict[str, VenvCacheV1CmdMetadataEntryType]]"
+
+
+class VenvCacheV2Type(TypedDict):
+    profile_emu_env: "NotRequired[dict[str, str]]"
+    qemu_bin: "NotRequired[str]"
+    targets: dict[str, VenvCacheV2TargetType]
+    cmd_metadata_map: "NotRequired[dict[str, VenvCacheV1CmdMetadataEntryType]]"
+
+
+class VenvCacheRootType(TypedDict):
+    cached: "NotRequired[VenvCacheV0Type]"
+    cached_v1: "NotRequired[VenvCacheV1Type]"
+    cached_v2: "NotRequired[VenvCacheV2Type]"
+
+
+def parse_venv_cache(
+    cache: VenvCacheRootType,
+    global_sysroot: str | None,
+) -> VenvCacheV2Type:
+    if "cached_v2" in cache:
+        return cache["cached_v2"]
+    if "cached_v1" in cache:
+        return upgrade_venv_cache_v1(cache["cached_v1"])
+    if "cached" in cache:
+        return upgrade_venv_cache_v0(cache["cached"], global_sysroot)
+    raise RuntimeError("unsupported venv cache version")
+
+
+def upgrade_venv_cache_v1(x: VenvCacheV1Type) -> VenvCacheV2Type:
+    profile_common_flags = x["profile_common_flags"]
+    tmp = cast(dict[str, Any], copy.deepcopy(x))
+    del tmp["profile_common_flags"]
+    v2 = cast(VenvCacheV2Type, tmp)
+    for tgt in v2["targets"].values():
+        tgt["toolchain_flags"] = profile_common_flags
+    return v2
+
+
+def upgrade_venv_cache_v0(
+    x: VenvCacheV0Type,
+    global_sysroot: str | None,
+) -> VenvCacheV2Type:
+    # v0 only supports one single target so upgrading is trivial
+    v1_target: VenvCacheV1TargetType = {
+        "toolchain_bindir": x["toolchain_bindir"],
+    }
+    if "gcc_install_dir" in x:
+        v1_target["gcc_install_dir"] = x["gcc_install_dir"]
+    if global_sysroot is not None:
+        v1_target["toolchain_sysroot"] = global_sysroot
+
+    y: VenvCacheV1Type = {
+        "profile_common_flags": x["profile_common_flags"],
+        "targets": {x["target_tuple"]: v1_target},
+    }
+    if "profile_emu_env" in x:
+        y["profile_emu_env"] = x["profile_emu_env"]
+    if "qemu_bin" in x:
+        y["qemu_bin"] = x["qemu_bin"]
+
+    return upgrade_venv_cache_v1(y)
+
+
+class RuyiVenvConfig:
+    def __init__(
+        self,
+        venv_root: pathlib.Path,
+        cfg: VenvConfigRootType,
+        cache: VenvCacheRootType,
+    ) -> None:
+        self.venv_root = venv_root
+        self.profile = cfg["config"]["profile"]
+        self.sysroot = cfg["config"].get("sysroot")
+
+        parsed_cache = parse_venv_cache(cache, self.sysroot)
+        self.targets = parsed_cache["targets"]
+        self.qemu_bin = parsed_cache.get("qemu_bin")
+        self.profile_emu_env = parsed_cache.get("profile_emu_env")
+        self.cmd_metadata_map = parsed_cache.get("cmd_metadata_map")
+
+        # this must be in sync with provision.py
+        self._ruyi_priv_dir = self.venv_root / "ruyi-private"
+        self._cached_cmd_targets_dir = self._ruyi_priv_dir / "cached-cmd-targets"
+
+    @classmethod
+    def explicit_ruyi_venv_root(cls, gm: ProvidesGlobalMode) -> str | None:
+        return gm.venv_root
+
+    @classmethod
+    def probe_venv_root(cls, gm: ProvidesGlobalMode) -> pathlib.Path | None:
+        if explicit_root := cls.explicit_ruyi_venv_root(gm):
+            return pathlib.Path(explicit_root)
+
+        # check ../.. from argv[0]
+        # this only works if it contains a path separator, otherwise it's really
+        # hard without an explicit root (/proc/*/exe points to the resolved file,
+        # but we want the path to the first symlink without any symlink dereference)
+        argv0_path = gm.argv0
+        if os.path.sep not in argv0_path:
+            return None
+
+        implied_root = pathlib.Path(os.path.dirname(os.path.dirname(argv0_path)))
+        if (implied_root / "ruyi-venv.toml").exists():
+            return implied_root
+
+        return None
+
+    @classmethod
+    def load_from_venv(
+        cls,
+        gm: ProvidesGlobalMode,
+        logger: RuyiLogger,
+    ) -> "Self | None":
+        venv_root = cls.probe_venv_root(gm)
+        if venv_root is None:
+            return None
+
+        if cls.explicit_ruyi_venv_root(gm) is not None:
+            logger.D(f"using explicit venv root {venv_root}")
+        else:
+            logger.D(f"detected implicit venv root {venv_root}")
+
+        venv_config_path = venv_root / "ruyi-venv.toml"
+        with open(venv_config_path, "rb") as fp:
+            cfg: Any = tomllib.load(fp)  # in order to cast to our stricter type
+
+        cache: Any  # in order to cast to our stricter type
+        venv_cache_v2_path = venv_root / "ruyi-cache.v2.toml"
+        try:
+            with open(venv_cache_v2_path, "rb") as fp:
+                cache = tomllib.load(fp)
+        except FileNotFoundError:
+            venv_cache_v1_path = venv_root / "ruyi-cache.v1.toml"
+            try:
+                with open(venv_cache_v1_path, "rb") as fp:
+                    cache = tomllib.load(fp)
+            except FileNotFoundError:
+                venv_cache_v0_path = venv_root / "ruyi-cache.toml"
+                with open(venv_cache_v0_path, "rb") as fp:
+                    cache = tomllib.load(fp)
+
+        # NOTE: for now it's not prohibited to have cache data of a different
+        # version in a certain version's cache path, but this situation is
+        # harmless
+        return cls(venv_root, cfg, cache)
+
+    def resolve_cmd_metadata_with_cache(
+        self,
+        basename: str,
+    ) -> VenvCacheV1CmdMetadataEntryType | None:
+        if self.cmd_metadata_map is None:
+            # we are operating in a venv created with an older ruyi, thus no
+            # cmd_metadata_map in cache
+            return None
+
+        return self.cmd_metadata_map.get(basename)

ruyi/pluginhost/api.py

@@ -0,0 +1,206 @@
+from contextlib import AbstractContextManager
+import pathlib
+import subprocess
+import sys
+import time
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, cast
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+from rich.console import Console, RenderableType
+
+from ..cli import user_input
+from ..log import RuyiLogger
+from ..version import RUYI_SEMVER
+from .paths import resolve_ruyi_load_path
+
+if TYPE_CHECKING:
+    from .ctx import PluginHostContext, SupportsEvalFunction, SupportsGetOption
+
+T = TypeVar("T")
+U = TypeVar("U")
+
+
+class RuyiHostAPI:
+    def __init__(
+        self,
+        phctx: "PluginHostContext[SupportsGetOption, SupportsEvalFunction]",
+        this_file: pathlib.Path,
+        this_plugin_dir: pathlib.Path,
+        allow_host_fs_access: bool,
+    ) -> None:
+        self._phctx = phctx
+        self._this_file = this_file
+        self._this_plugin_dir = this_plugin_dir
+        self._ev = phctx.make_evaluator()
+        self._allow_host_fs_access = allow_host_fs_access
+
+        self._logger = RuyiPluginLogger(self._phctx.host_logger)
+        # TODO: unify into the plugin logger
+        self._host_logger = self._phctx.host_logger
+
+    @property
+    def ruyi_version(self) -> str:
+        return str(RUYI_SEMVER)
+
+    @property
+    def ruyi_plugin_api_rev(self) -> int:
+        return 1
+
+    def load_toml(self, path: str) -> object:
+        resolved_path = resolve_ruyi_load_path(
+            path,
+            self._phctx.plugin_root,
+            True,
+            self._this_file,
+            self._allow_host_fs_access,
+        )
+        with open(resolved_path, "rb") as f:
+            return tomllib.load(f)
+
+    @property
+    def log(self) -> "RuyiPluginLogger":
+        return self._logger
+
+    def cli_ask_for_choice(self, prompt: str, choice_texts: list[str]) -> int:
+        return user_input.ask_for_choice(self._host_logger, prompt, choice_texts)
+
+    def cli_ask_for_file(self, prompt: str) -> str:
+        return user_input.ask_for_file(self._host_logger, prompt)
+
+    def cli_ask_for_kv_choice(self, prompt: str, choices_kv: dict[str, str]) -> str:
+        return user_input.ask_for_kv_choice(self._host_logger, prompt, choices_kv)
+
+    def cli_ask_for_yesno_confirmation(
+        self,
+        prompt: str,
+        default: bool = False,
+    ) -> bool:
+        return user_input.ask_for_yesno_confirmation(self._host_logger, prompt, default)
+
+    def call_subprocess_argv(
+        self,
+        argv: list[str],
+    ) -> int:
+        # TODO: restrictions on this
+        return subprocess.call(argv)
+
+    def sleep(self, seconds: float, /) -> None:
+        return time.sleep(seconds)
+
+    def with_(
+        self,
+        cm: AbstractContextManager[T],
+        fn: object | Callable[[T], U],
+    ) -> U:
+        with cm as obj:
+            return cast(U, self._ev.eval_function(fn, obj))
+
+
+def _ensure_str(message: RenderableType) -> None:
+    if not isinstance(message, str):
+        raise TypeError("message must be str in plugins")
+
+
+class RuyiPluginLogger(RuyiLogger):
+    def __init__(self, host_logger: RuyiLogger) -> None:
+        self._h = host_logger
+
+    @property
+    def log_console(self) -> Console:
+        return self._h.log_console
+
+    def stdout(
+        self,
+        message: RenderableType,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        _ensure_str(message)
+        self._h.stdout(message, *objects, sep=sep, end=end)
+
+    def D(
+        self,
+        message: RenderableType,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        _stack_offset_delta: int = 0,
+    ) -> None:
+        _ensure_str(message)
+        if _stack_offset_delta != 0:
+            raise ValueError("_stack_offset_delta is not supported in plugins")
+        self._h.D(message, *objects, sep=sep, end=end, _stack_offset_delta=1)
+
+    def W(
+        self,
+        message: RenderableType,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        _ensure_str(message)
+        self._h.W(message, *objects, sep=sep, end=end)
+
+    def I(  # noqa: E743 # the name intentionally mimics Android logging for brevity
+        self,
+        message: RenderableType,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        _ensure_str(message)
+        self._h.I(message, *objects, sep=sep, end=end)
+
+    def F(
+        self,
+        message: RenderableType,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+    ) -> None:
+        _ensure_str(message)
+        self._h.F(message, *objects, sep=sep, end=end)
+
+
+def _ruyi_plugin_rev(
+    phctx: "PluginHostContext[SupportsGetOption, SupportsEvalFunction]",
+    this_file: pathlib.Path,
+    this_plugin_dir: pathlib.Path,
+    allow_host_fs_access: bool,
+    rev: object,
+) -> RuyiHostAPI:
+    if not isinstance(rev, int):
+        raise TypeError("rev must be int in ruyi_plugin_rev calls")
+    if rev != 1:
+        raise ValueError(
+            f"Ruyi plugin API revision {rev} is not supported by this Ruyi"
+        )
+    return RuyiHostAPI(
+        phctx,
+        this_file,
+        this_plugin_dir,
+        allow_host_fs_access,
+    )
+
+
+def make_ruyi_plugin_api_for_module(
+    phctx: "PluginHostContext[SupportsGetOption, SupportsEvalFunction]",
+    this_file: pathlib.Path,
+    this_plugin_dir: pathlib.Path,
+    is_cmd: bool,
+) -> Callable[[object], RuyiHostAPI]:
+    # Only allow access to host FS when we're being loaded as a command plugin
+    allow_host_fs_access = is_cmd
+
+    return lambda rev: _ruyi_plugin_rev(
+        phctx,
+        this_file,
+        this_plugin_dir,
+        allow_host_fs_access,
+        rev,
+    )