ruyi 0.39.0__py3-none-any.whl

ruyi/utils/l10n.py

@@ -0,0 +1,83 @@
+import locale
+
+from typing import Iterable, NamedTuple
+
+
+class LangAndRegion(NamedTuple):
+    raw: str
+    lang: str
+    region: str | None
+
+
+def lang_code_to_lang_region(lang_code: str, guess_region: bool) -> LangAndRegion:
+    if not guess_region and "_" not in lang_code:
+        return LangAndRegion(lang_code, lang_code, None)
+
+    lang_region_str = locale.normalize(lang_code).split(".")[0]
+    parts = lang_region_str.split("_", 2)
+    if len(parts) == 1:
+        return LangAndRegion(lang_code, lang_region_str, None)
+    return LangAndRegion(lang_code, parts[0], parts[1])
+
+
+def match_lang_code(
+    req: str,
+    avail: Iterable[str],
+) -> str:
+    """Returns a proper available language code based on a list of available
+    language codes, and a request."""
+
+    if not isinstance(avail, set) or not isinstance(avail, frozenset):
+        avail = set(avail)
+
+    # return the only one choice if this is the case
+    if len(avail) == 1:
+        return next(iter(avail))
+
+    # try exact match
+    if req in avail:
+        return req
+
+    return _match_lang_code_slowpath(
+        lang_code_to_lang_region(req, True),
+        [lang_code_to_lang_region(x, False) for x in avail],
+    )
+
+
+def _match_lang_code_slowpath(
+    req: LangAndRegion,
+    avail: list[LangAndRegion],
+) -> str:
+    # pick one with the requested region
+    if req.region is not None:
+        for x in avail:
+            if x.region == req.region:
+                return x.raw
+
+    # if no match, pick one with the requested language
+    for x in avail:
+        if x.lang == req.lang:
+            return x.raw
+
+    # neither matches, fallback to (en_US, en, en_*, zh_CN, zh, zh_*)
+    # in that order
+    fallback_en = {x.region: x.raw for x in avail if x.lang == "en"}
+    if fallback_en:
+        if "US" in fallback_en:
+            return fallback_en["US"]
+        if None in fallback_en:
+            return fallback_en[None]
+        return fallback_en[sorted(x for x in fallback_en.keys() if x is not None)[0]]
+
+    fallback_zh = {x.region: x.raw for x in avail if x.lang == "zh"}
+    if fallback_zh:
+        if "CN" in fallback_zh:
+            return fallback_zh["CN"]
+        if None in fallback_zh:
+            return fallback_zh[None]
+        return fallback_zh[sorted(x for x in fallback_zh.keys() if x is not None)[0]]
+
+    # neither en nor zh is available (which is highly unlikely at present)
+    # pick the first available one as a last resort
+    # sort the list before picking for determinism
+    return sorted(x.raw for x in avail)[0]

ruyi/utils/markdown.py

@@ -0,0 +1,73 @@
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.markdown import CodeBlock, Heading, Markdown, MarkdownContext
+from rich.syntax import Syntax
+from rich.text import Text
+
+
+class SlimHeading(Heading):
+    def on_enter(self, context: MarkdownContext) -> None:
+        try:
+            # the heading level is indicated in the tag name in rich >= 13.2.0,
+            # e.g. self.tag == 'h1', but directly stored in earlier versions
+            # as self.level.
+            #
+            # see https://github.com/Textualize/rich/commit/a20c3d5468d02a55
+            heading_level = int(self.tag[1:])  # type: ignore[attr-defined,unused-ignore]
+        except AttributeError:
+            heading_level = self.level  # type: ignore[attr-defined,unused-ignore]
+
+        context.enter_style(self.style_name)
+        self.text = Text("#" * heading_level + " ", context.current_style)
+
+    def __rich_console__(
+        self,
+        console: Console,
+        options: ConsoleOptions,
+    ) -> RenderResult:
+        yield self.text
+
+
+# inspired by https://github.com/Textualize/rich/issues/3154
+class NonWrappingCodeBlock(CodeBlock):
+    def __rich_console__(
+        self,
+        console: Console,
+        options: ConsoleOptions,
+    ) -> RenderResult:
+        # re-enable non-wrapping options locally for code blocks
+        render_options = options.update(no_wrap=True, overflow="ignore")
+
+        code = str(self.text).rstrip()
+        syntax = Syntax(
+            code,
+            self.lexer_name,
+            theme=self.theme,
+            word_wrap=False,
+            # not supported in rich <= 12.4.0 (Textualize/rich#2247) but fortunately
+            # zero padding is the default anyway
+            # padding=0,
+        )
+        return syntax.highlight(code).__rich_console__(console, render_options)
+
+
+class RuyiStyledMarkdown(Markdown):
+    elements = Markdown.elements
+    elements["fence"] = NonWrappingCodeBlock
+    elements["heading_open"] = SlimHeading
+
+    # rich < 13.2.0
+    # see https://github.com/Textualize/rich/commit/745bd99e416c2806
+    # it doesn't hurt to just unconditionally add them like below
+    elements["code"] = NonWrappingCodeBlock
+    elements["code_block"] = NonWrappingCodeBlock
+    elements["heading"] = SlimHeading
+
+    def __rich_console__(
+        self,
+        console: Console,
+        options: ConsoleOptions,
+    ) -> RenderResult:
+        # we have to undo the ruyi-global console's non-wrapping setting
+        # for proper CLI rendering of long lines
+        render_options = options.update(no_wrap=False, overflow="fold")
+        return super().__rich_console__(console, render_options)

ruyi/utils/nuitka.py

@@ -0,0 +1,33 @@
+import os
+import sys
+
+
+def get_nuitka_self_exe() -> str:
+    try:
+        # Assume we're a Nuitka onefile build, so our parent process is the onefile
+        # bootstrap process. The onefile bootstrapper puts "our path" in the
+        # undocumented environment variable $NUITKA_ONEFILE_BINARY, which works
+        # on both Linux and Windows.
+        return os.environ["NUITKA_ONEFILE_BINARY"]
+    except KeyError:
+        # It seems we are instead launched from the extracted onefile tempdir.
+        # Assume our name is "ruyi" in this case; directory is available in
+        # Nuitka metadata.
+        import ruyi
+
+        return os.path.join(ruyi.__compiled__.containing_dir, "ruyi")
+
+
+def get_argv0() -> str:
+    import ruyi
+
+    try:
+        if ruyi.__compiled__.original_argv0 is not None:
+            return ruyi.__compiled__.original_argv0
+    except AttributeError:
+        # Either we're not packaged with Nuitka, or the Nuitka used is
+        # without our original_argv0 patch, in which case we cannot do any
+        # better than simply returning sys.argv[0].
+        pass
+
+    return sys.argv[0]

ruyi/utils/porcelain.py

@@ -0,0 +1,51 @@
+from contextlib import AbstractContextManager
+import enum
+import json
+import sys
+from types import TracebackType
+from typing import BinaryIO, TypedDict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+if sys.version_info >= (3, 11):
+
+    class PorcelainEntityType(enum.StrEnum):
+        LogV1 = "log-v1"
+        NewsItemV1 = "newsitem-v1"
+        PkgListOutputV1 = "pkglistoutput-v1"
+        EntityListOutputV1 = "entitylistoutput-v1"
+
+else:
+
+    class PorcelainEntityType(str, enum.Enum):
+        LogV1 = "log-v1"
+        NewsItemV1 = "newsitem-v1"
+        PkgListOutputV1 = "pkglistoutput-v1"
+        EntityListOutputV1 = "entitylistoutput-v1"
+
+
+class PorcelainEntity(TypedDict):
+    ty: PorcelainEntityType
+
+
+class PorcelainOutput(AbstractContextManager["PorcelainOutput"]):
+    def __init__(self, out: BinaryIO | None = None) -> None:
+        self.out = sys.stdout.buffer if out is None else out
+
+    def __enter__(self) -> "Self":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        self.out.flush()
+        return None
+
+    def emit(self, obj: PorcelainEntity) -> None:
+        s = json.dumps(obj, ensure_ascii=False, separators=(",", ":"))
+        self.out.write(s.encode("utf-8"))
+        self.out.write(b"\n")

ruyi/utils/prereqs.py

@@ -0,0 +1,77 @@
+import shutil
+import sys
+from typing import Final, Iterable, NoReturn
+
+from ..cli.user_input import pause_before_continuing
+from ..log import RuyiLogger, humanize_list
+
+
+def has_cmd_in_path(cmd: str) -> bool:
+    return shutil.which(cmd) is not None
+
+
+_CMDS: Final = (
+    "bzip2",
+    "gunzip",
+    "lz4",
+    "tar",
+    "xz",
+    "zstd",
+    "unzip",
+    # commands used by the device provisioner
+    "sudo",
+    "dd",
+    "fastboot",
+)
+
+_CMD_PRESENCE_MAP: Final[dict[str, bool]] = {}
+
+
+def init_cmd_presence_map() -> None:
+    _CMD_PRESENCE_MAP.clear()
+    for cmd in _CMDS:
+        _CMD_PRESENCE_MAP[cmd] = has_cmd_in_path(cmd)
+
+
+def ensure_cmds(
+    logger: RuyiLogger,
+    cmds: Iterable[str],
+    interactive_retry: bool = True,
+) -> None | NoReturn:
+    # only allow interactive retry if stdin is a TTY
+    interactive_retry = interactive_retry and sys.stdin.isatty()
+
+    while True:
+        if not _CMD_PRESENCE_MAP or interactive_retry:
+            init_cmd_presence_map()
+
+        # in case any command's availability is not cached in advance
+        for cmd in cmds:
+            if cmd not in _CMD_PRESENCE_MAP:
+                _CMD_PRESENCE_MAP[cmd] = has_cmd_in_path(cmd)
+
+        absent_cmds = sorted(
+            cmd for cmd in cmds if not _CMD_PRESENCE_MAP.get(cmd, False)
+        )
+        if not absent_cmds:
+            return None
+
+        cmds_str = humanize_list(absent_cmds, item_color="yellow")
+        prompt = f"The command(s) {cmds_str} cannot be found in PATH, which [yellow]ruyi[/] requires"
+        if not interactive_retry:
+            logger.F(prompt)
+            logger.I("please install and retry")
+            sys.exit(1)
+
+        logger.W(prompt)
+        logger.I(
+            "please install them and press [green]Enter[/] to retry, or [green]Ctrl+C[/] to exit"
+        )
+        try:
+            pause_before_continuing(logger)
+        except EOFError:
+            logger.I("exiting due to EOF")
+            sys.exit(1)
+        except KeyboardInterrupt:
+            logger.I("exiting due to keyboard interrupt")
+            sys.exit(1)

ruyi/utils/ssl_patch.py

@@ -0,0 +1,170 @@
+import ctypes
+import os
+import ssl
+import sys
+from typing import Final, NamedTuple
+
+import certifi
+
+from ..log import RuyiConsoleLogger, RuyiLogger
+from .global_mode import EnvGlobalModeProvider
+
+_orig_get_default_verify_paths: Final = ssl.get_default_verify_paths
+_cached_paths: ssl.DefaultVerifyPaths | None = None
+
+
+def get_system_ssl_default_verify_paths() -> ssl.DefaultVerifyPaths:
+    global _cached_paths
+
+    if _cached_paths is None:
+        # no way to pass in the logger because of the function signature
+        # so we have to use a new logger
+        gm = EnvGlobalModeProvider(os.environ)
+        _cached_paths = _get_system_ssl_default_verify_paths(RuyiConsoleLogger(gm))
+    return _cached_paths
+
+
+def _get_system_ssl_default_verify_paths(logger: RuyiLogger) -> ssl.DefaultVerifyPaths:
+    orig_paths = _orig_get_default_verify_paths()
+    if sys.platform != "linux":
+        return orig_paths
+
+    result: ssl.DefaultVerifyPaths | None = None
+
+    # imitate the stdlib flow but with overridden data source
+    try:
+        parts = _query_linux_system_ssl_default_cert_paths(logger)
+        if parts is None:
+            logger.W("failed to probe system libcrypto")
+        else:
+            result = to_ssl_paths(parts)
+    except Exception as e:
+        logger.D(f"cannot get system libcrypto default cert paths: {e}")
+
+    if result is None:
+        logger.D("falling back to probing hard-coded paths")
+        result = probe_fallback_verify_paths()
+
+    if result != orig_paths:
+        logger.D(
+            "get_default_verify_paths() values differ between bundled and system libssl"
+        )
+        logger.D(f"bundled: {orig_paths}")
+        logger.D(f" system: {result}")
+
+    return result
+
+
+def to_ssl_paths(parts: tuple[str, str, str, str]) -> ssl.DefaultVerifyPaths | None:
+    cafile = os.environ.get(parts[0], parts[1])
+    capath = os.environ.get(parts[2], parts[3])
+
+    is_cafile_present = os.path.isfile(cafile)
+    is_capath_present = os.path.isdir(capath)
+    if not is_cafile_present and not is_capath_present:
+        return None
+
+    # must do "else None" like the stdlib, despite the type annotation being just "str"
+    return ssl.DefaultVerifyPaths(
+        cafile if is_cafile_present else None,  # type: ignore[arg-type]
+        capath if is_capath_present else None,  # type: ignore[arg-type]
+        *parts,
+    )
+
+
+def _decode_fsdefault_or_none(val: int | None) -> str:
+    if val is None:
+        return ""
+
+    s = ctypes.c_char_p(val)
+    if s.value is None:
+        return ""
+
+    return s.value.decode(sys.getfilesystemencoding())
+
+
+def _query_linux_system_ssl_default_cert_paths(
+    logger: RuyiLogger,
+    soname: str | None = None,
+) -> tuple[str, str, str, str] | None:
+    if soname is None:
+        # check libcrypto instead of libssl, because if the system libssl is
+        # newer than the bundled one, the system libssl will depend on the
+        # bundled libcrypto that may lack newer ELF symbol version(s). The
+        # functions actually reside in libcrypto, after all.
+        for soname in ("libcrypto.so", "libcrypto.so.3", "libcrypto.so.1.1"):
+            try:
+                return _query_linux_system_ssl_default_cert_paths(logger, soname)
+            except OSError as e:
+                logger.D(f"soname {soname} not working: {e}")
+                continue
+
+        return None
+
+    # dlopen-ing the bare soname will get us the system library
+    lib = ctypes.CDLL(soname)
+    lib.X509_get_default_cert_file_env.restype = ctypes.c_void_p
+    lib.X509_get_default_cert_file.restype = ctypes.c_void_p
+    lib.X509_get_default_cert_dir_env.restype = ctypes.c_void_p
+    lib.X509_get_default_cert_dir.restype = ctypes.c_void_p
+
+    result = (
+        _decode_fsdefault_or_none(lib.X509_get_default_cert_file_env()),
+        _decode_fsdefault_or_none(lib.X509_get_default_cert_file()),
+        _decode_fsdefault_or_none(lib.X509_get_default_cert_dir_env()),
+        _decode_fsdefault_or_none(lib.X509_get_default_cert_dir()),
+    )
+
+    logger.D(f"got defaults from system libcrypto {soname}")
+    logger.D(f"X509_get_default_cert_file_env() = {result[0]}")
+    logger.D(f"X509_get_default_cert_file() = {result[1]}")
+    logger.D(f"X509_get_default_cert_dir_env() = {result[2]}")
+    logger.D(f"X509_get_default_cert_dir() = {result[3]}")
+
+    return result
+
+
+class WellKnownCALocation(NamedTuple):
+    cafile: str
+    capath: str
+
+
+WELL_KNOWN_CA_LOCATIONS: Final[list[WellKnownCALocation]] = [
+    # Debian-based distros
+    WellKnownCALocation("/usr/lib/ssl/cert.pem", "/usr/lib/ssl/certs"),
+    # RPM-based distros
+    WellKnownCALocation("/etc/pki/tls/cert.pem", "/etc/pki/tls/certs"),
+    # Most others
+    WellKnownCALocation("/etc/ssl/cert.pem", "/etc/ssl/certs"),
+]
+
+
+def probe_fallback_verify_paths() -> ssl.DefaultVerifyPaths:
+    for loc in WELL_KNOWN_CA_LOCATIONS:
+        is_file_present = os.path.isfile(loc.cafile)
+        is_dir_present = os.path.isdir(loc.capath)
+        if not is_file_present and not is_dir_present:
+            continue
+
+        return ssl.DefaultVerifyPaths(
+            loc.cafile if is_file_present else None,  # type: ignore[arg-type]
+            loc.capath if is_dir_present else None,  # type: ignore[arg-type]
+            "SSL_CERT_FILE",
+            loc.cafile,
+            "SSL_CERT_DIR",
+            loc.capath,
+        )
+
+    # fall back to certifi
+    cafile = certifi.where()
+    return ssl.DefaultVerifyPaths(
+        cafile,
+        None,  # type: ignore[arg-type]
+        "SSL_CERT_FILE",
+        cafile,
+        "SSL_CERT_DIR",
+        "/etc/ssl/certs",
+    )
+
+
+ssl.get_default_verify_paths = get_system_ssl_default_verify_paths

ruyi/utils/templating.py

@@ -0,0 +1,34 @@
+import shlex
+from typing import Any, Final, Callable, Tuple
+
+from jinja2 import BaseLoader, Environment, TemplateNotFound
+
+from ..resource_bundle import get_template_str
+
+
+class EmbeddedLoader(BaseLoader):
+    def __init__(self) -> None:
+        pass
+
+    def get_source(
+        self,
+        environment: Environment,
+        template: str,
+    ) -> Tuple[str, str | None, Callable[[], bool] | None]:
+        if payload := get_template_str(template):
+            return payload, None, None
+        raise TemplateNotFound(template)
+
+
+_JINJA_ENV: Final = Environment(
+    loader=EmbeddedLoader(),
+    autoescape=False,  # we're not producing HTML
+    auto_reload=False,  # we're serving statically embedded assets
+    keep_trailing_newline=True,  # to make shells happy
+)
+_JINJA_ENV.filters["sh"] = shlex.quote
+
+
+def render_template_str(template_name: str, data: dict[str, Any]) -> str:
+    tmpl = _JINJA_ENV.get_template(template_name)
+    return tmpl.render(data)

ruyi/utils/toml.py

@@ -0,0 +1,115 @@
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import Iterable
+
+import tomlkit
+from tomlkit.container import Container
+from tomlkit.items import Array, Comment, InlineTable, Item, Table, Trivia, Whitespace
+
+
+def with_indent(item: Item, spaces: int = 2) -> Item:
+    item.indent(spaces)
+    return item
+
+
+def inline_table_with_spaces() -> "InlineTableWithSpaces":
+    return InlineTableWithSpaces(Container(), Trivia(), new=True)
+
+
+class InlineTableWithSpaces(InlineTable, AbstractContextManager[InlineTable]):
+    def __init__(
+        self,
+        value: Container,
+        trivia: Trivia,
+        new: bool = False,
+    ) -> None:
+        super().__init__(value, trivia, new)
+
+    def __enter__(self) -> InlineTable:
+        self.add(tomlkit.ws(" "))
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        self.add(tomlkit.ws(" "))
+        return None
+
+
+def _into_item(x: Item | str) -> Item:
+    if isinstance(x, Item):
+        return x
+    return tomlkit.string(x)
+
+
+def str_array(
+    args: Iterable[Item | str],
+    *,
+    multiline: bool = False,
+    indent: int = 2,
+) -> Array:
+    items = [_into_item(i).indent(indent) for i in args]
+    return Array(items, Trivia(), multiline=multiline)
+
+
+def sorted_table(x: dict[str, str]) -> Table:
+    y = tomlkit.table()
+    for k in sorted(x.keys()):
+        y.add(k, x[k])
+    return y
+
+
+def extract_header_comments(
+    doc: Container,
+) -> list[str]:
+    comments: list[str] = []
+
+    # ignore leading whitespaces
+    is_skipping_leading_ws = True
+    for _key, item in doc.body:
+        if isinstance(item, Whitespace):
+            if is_skipping_leading_ws:
+                continue
+            # this is part of the header comments
+            comments.append(item.as_string())
+        elif isinstance(item, Comment):
+            is_skipping_leading_ws = False
+            comments.append(item.as_string())
+        else:
+            # we reached the first non-comment item
+            break
+    return comments
+
+
+def extract_footer_comments(
+    doc: Container,
+) -> list[str]:
+    comments: list[str] = []
+
+    # ignore trailing whitespaces
+    is_skipping_trailing_ws = True
+    for _key, item in reversed(doc.body):
+        if isinstance(item, Whitespace):
+            if is_skipping_trailing_ws:
+                continue
+            # this is part of the footer comments
+            comments.append(item.as_string())
+        elif isinstance(item, Comment):
+            is_skipping_trailing_ws = False
+            comments.append(item.as_string())
+        else:
+            # we reached the first non-comment item
+            break
+
+    # if the footer comment was preceded by a table, then the comment would be
+    # nested inside the table and invisible in top-level doc.body, so we would
+    # have to check the last item as well
+    if not comments:
+        last_elem = doc.body[-1][1].value
+        if isinstance(last_elem, Container):
+            return extract_footer_comments(last_elem)
+
+    return list(reversed(comments))

ruyi/utils/url.py

@@ -0,0 +1,7 @@
+from urllib import parse
+
+
+def urljoin_for_sure(base: str, url: str) -> str:
+    if base.endswith("/"):
+        return parse.urljoin(base, url)
+    return parse.urljoin(base + "/", url)