ruyi 0.39.0__py3-none-any.whl

ruyi/ruyipkg/unpack_method.py

@@ -0,0 +1,91 @@
+import enum
+import re
+import sys
+from typing import Final
+
+RE_TARBALL: Final = re.compile(r"\.tar(?:\.gz|\.bz2|\.lz4|\.xz|\.zst)?$")
+
+
+if sys.version_info >= (3, 11):
+
+    class UnpackMethod(enum.StrEnum):
+        UNKNOWN = ""
+        AUTO = "auto"
+        TAR_AUTO = "tar.auto"
+
+        RAW = "raw"
+        GZ = "gz"
+        BZ2 = "bz2"
+        LZ4 = "lz4"
+        XZ = "xz"
+        ZST = "zst"
+
+        TAR = "tar"
+        TAR_GZ = "tar.gz"
+        TAR_BZ2 = "tar.bz2"
+        TAR_LZ4 = "tar.lz4"
+        TAR_XZ = "tar.xz"
+        TAR_ZST = "tar.zst"
+
+        ZIP = "zip"
+        DEB = "deb"
+
+else:
+
+    class UnpackMethod(str, enum.Enum):
+        UNKNOWN = ""
+        AUTO = "auto"
+        TAR_AUTO = "tar.auto"
+
+        RAW = "raw"
+        GZ = "gz"
+        BZ2 = "bz2"
+        LZ4 = "lz4"
+        XZ = "xz"
+        ZST = "zst"
+
+        TAR = "tar"
+        TAR_GZ = "tar.gz"
+        TAR_BZ2 = "tar.bz2"
+        TAR_LZ4 = "tar.lz4"
+        TAR_XZ = "tar.xz"
+        TAR_ZST = "tar.zst"
+
+        ZIP = "zip"
+        DEB = "deb"
+
+
+class UnrecognizedPackFormatError(Exception):
+    def __init__(self, filename: str) -> None:
+        self.filename = filename
+
+    def __str__(self) -> str:
+        return f"don't know how to unpack file {self.filename}"
+
+
+def determine_unpack_method(
+    filename: str,
+) -> UnpackMethod:
+    filename_lower = filename.lower()
+    if m := RE_TARBALL.search(filename_lower):
+        return UnpackMethod(m.group(0)[1:])
+    if filename_lower.endswith(".deb"):
+        return UnpackMethod.DEB
+    if filename_lower.endswith(".zip"):
+        return UnpackMethod.ZIP
+    if filename_lower.endswith(".gz"):
+        # bare gzip file
+        return UnpackMethod.GZ
+    if filename_lower.endswith(".bz2"):
+        # bare bzip2 file
+        return UnpackMethod.BZ2
+    if filename_lower.endswith(".lz4"):
+        # bare lz4 file
+        return UnpackMethod.LZ4
+    if filename_lower.endswith(".xz"):
+        # bare xz file
+        return UnpackMethod.XZ
+    if filename_lower.endswith(".zst"):
+        # bare zstd file
+        return UnpackMethod.ZST
+    return UnpackMethod.UNKNOWN

ruyi/ruyipkg/update_cli.py

@@ -0,0 +1,54 @@
+import argparse
+from typing import TYPE_CHECKING
+
+from ..cli.cmd import RootCommand
+
+if TYPE_CHECKING:
+    from ..cli.completion import ArgumentParser
+    from ..config import GlobalConfig
+
+
+class UpdateCommand(
+    RootCommand,
+    cmd="update",
+    help="Update RuyiSDK repo and packages",
+):
+    @classmethod
+    def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
+        pass
+
+    @classmethod
+    def main(cls, cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+        from . import news
+        from .state import BoundInstallationStateStore
+
+        logger = cfg.logger
+        mr = cfg.repo
+        mr.sync()
+
+        # check for upgradable packages
+        bis = BoundInstallationStateStore(cfg.ruyipkg_global_state, mr)
+        upgradable = list(bis.iter_upgradable_pkgs(cfg.include_prereleases))
+
+        if upgradable:
+            logger.stdout(
+                "\nNewer versions are available for some of your installed packages:\n"
+            )
+            for pm, new_ver in upgradable:
+                logger.stdout(
+                    f"  - [bold]{pm.category}/{pm.name}[/]: [yellow]{pm.ver}[/] -> [green]{new_ver}[/]"
+                )
+            logger.stdout(
+                """
+Re-run [yellow]ruyi install[/] to upgrade, and don't forget to re-create any affected
+virtual environments."""
+            )
+
+        # check if there are new newsitems
+        unread_newsitems = mr.news_store().list(True)
+        if unread_newsitems:
+            logger.stdout(f"\nThere are {len(unread_newsitems)} new news item(s):\n")
+            news.print_news_item_titles(logger, unread_newsitems, cfg.lang_code)
+            logger.stdout("\nYou can read them with [yellow]ruyi news read[/].")
+
+        return 0

ruyi/telemetry/aggregate.py

@@ -0,0 +1,72 @@
+from typing import Iterable, TypeAlias, TypedDict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import NotRequired
+
+from .event import TelemetryEvent
+from .node_info import NodeInfo
+
+
+class AggregatedTelemetryEvent(TypedDict):
+    time_bucket: str
+    kind: str
+    params: list[tuple[str, str]]
+    count: int
+
+
+class UploadPayload(TypedDict):
+    fmt: int
+    nonce: str
+    ruyi_version: str
+    installation: "NotRequired[NodeInfo | None]"
+    events: list[AggregatedTelemetryEvent]
+
+
+def stringify_param_val(v: object) -> str:
+    if v is None:
+        return "null"
+    if isinstance(v, bool):
+        return "1" if v else "0"
+    if isinstance(v, bytes):
+        return v.decode("utf-8")
+    if isinstance(v, str):
+        return v
+    return str(v)
+
+
+AggregateKey: TypeAlias = tuple[tuple[str, str], ...]
+
+
+def _make_aggregate_key(ev: TelemetryEvent) -> AggregateKey:
+    param_list = [(k, stringify_param_val(v)) for k, v in ev["params"].items()]
+    param_list.sort()
+    return tuple([("", ev["kind"])] + param_list)
+
+
+def aggregate_events(
+    events: Iterable[TelemetryEvent],
+) -> Iterable[AggregatedTelemetryEvent]:
+    # dict[time_bucket, dict[AggregateKey, count]]
+    buf: dict[str, dict[AggregateKey, int]] = {}
+    for raw_ev in events:
+        time_bucket = raw_ev.get("time_bucket")
+        if time_bucket is None:
+            continue
+        if time_bucket not in buf:
+            buf[time_bucket] = {}
+
+        agg_key = _make_aggregate_key(raw_ev)
+        if agg_key not in buf[time_bucket]:
+            buf[time_bucket][agg_key] = 1
+        else:
+            buf[time_bucket][agg_key] += 1
+
+    for time_bucket in sorted(buf.keys()):
+        bucket_events = buf[time_bucket]
+        for agg_key in sorted(bucket_events.keys()):
+            yield {
+                "time_bucket": time_bucket,
+                "kind": agg_key[0][1],
+                "params": list(agg_key[1:]),
+                "count": bucket_events[agg_key],
+            }

ruyi/telemetry/event.py

@@ -0,0 +1,41 @@
+from typing import TypedDict, TypeGuard, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import NotRequired
+
+
+class TelemetryEvent(TypedDict):
+    fmt: int
+    time_bucket: "NotRequired[str]"  # canonically "YYYYMMDDHHMM"
+    kind: str
+    params: dict[str, object]
+
+
+def is_telemetry_event(x: object) -> TypeGuard[TelemetryEvent]:
+    if not isinstance(x, dict):
+        return False
+
+    if not 3 <= len(x.keys()) <= 4:
+        return False
+
+    try:
+        if not isinstance(x["fmt"], int):
+            return False
+        if not isinstance(x["kind"], str):
+            return False
+        if not isinstance(x["params"], dict):
+            return False
+    except KeyError:
+        return False
+
+    try:
+        if not isinstance(x["time_bucket"], str):
+            return False
+        if len(x["time_bucket"]) != 12:
+            return False
+        if not x["time_bucket"].isdigit():
+            return False
+    except KeyError:
+        pass
+
+    return True

ruyi/telemetry/node_info.py

@@ -0,0 +1,192 @@
+import glob
+import os
+import platform
+import re
+import subprocess
+import sys
+from typing import Final, Mapping, TypedDict, TYPE_CHECKING
+import uuid
+
+if TYPE_CHECKING:
+    from typing_extensions import NotRequired
+
+from ..utils.ci import probe_for_ci
+
+
+class NodeInfo(TypedDict):
+    v: int
+    report_uuid: str
+
+    arch: str
+    ci: str
+    libc_name: str
+    libc_ver: str
+    os: str
+    os_release_id: str
+    os_release_version_id: str
+    shell: str
+
+    riscv_machine: "NotRequired[RISCVMachineInfo]"
+
+
+class RISCVMachineInfo(TypedDict):
+    model_name: str
+    cpu_count: int
+    isa: str
+    uarch: str
+    uarch_csr: str
+    mmu: str
+
+
+def probe_for_libc() -> tuple[str, str]:
+    r = platform.libc_ver()
+    if r[0] and r[1]:
+        return r
+
+    # check for musl ld.so at the upstream standard paths, because
+    # platform.libc_ver() as of Python 3.12 does not know how to handle musl
+    #
+    # see https://wiki.musl-libc.org/guidelines-for-distributions
+    musl_lds = glob.glob("/lib/ld-musl-*.so.1")
+    if musl_lds:
+        # run it and check for "Version *.*.*"
+        # in case of multiple hits (hybrid-architecture sysroot?), hope the
+        # first one that successfully returns something is the native one
+        for p in musl_lds:
+            if ver := _try_get_musl_ver(p):
+                return ("musl", ver)
+
+    return ("unknown", "unknown")
+
+
+_MUSL_VERSION_RE: Final = re.compile(rb"(?m)^Version ([0-9.]+)$")
+
+
+def _try_get_musl_ver(ldso_path: str) -> str | None:
+    res = subprocess.run([ldso_path], stderr=subprocess.PIPE)
+    if m := _MUSL_VERSION_RE.search(res.stderr):
+        return m.group(1).decode("ascii", "ignore")
+    return None
+
+
+def _try_parse_hex(v: str) -> int | None:
+    if not v.startswith("0x"):
+        return None
+    try:
+        return int(v[2:], 16)
+    except ValueError:
+        return None
+
+
+def probe_for_riscv_machine_info(
+    model_name: str | None = None,
+    cpuinfo_data: str | None = None,
+) -> RISCVMachineInfo | None:
+    if model_name is None:
+        try:
+            with open(
+                "/sys/firmware/devicetree/base/model",
+                "r",
+                encoding="utf-8",
+            ) as fp:
+                model_name = fp.read().strip(" \n\t\x00")
+        except Exception:
+            pass
+
+        if not model_name:
+            model_name = "unknown"
+
+    if cpuinfo_data is None:
+        try:
+            with open("/proc/cpuinfo", "r", encoding="utf-8") as fp:
+                cpuinfo_data = fp.read()
+        except Exception:
+            pass
+
+    cpu_count = 0
+    isa, mmu, uarch = "unknown", "unknown", "unknown"
+    mvendorid: int | None = None
+    marchid: int | None = None
+    mimpid: int | None = None
+    if cpuinfo_data is not None:
+        for line in cpuinfo_data.split("\n"):
+            if not line:
+                continue
+
+            try:
+                k, v = line.split(": ", 1)
+            except ValueError:
+                # malformed line: non-empty but no ": "
+                continue
+
+            k = k.strip(" \t")
+            v = v.strip()
+
+            match k:
+                case "processor":
+                    cpu_count += 1
+                case "isa":
+                    isa = v
+                case "mmu":
+                    mmu = v
+                case "uarch":
+                    uarch = v
+                case "mvendorid":
+                    mvendorid = _try_parse_hex(v)
+                case "marchid":
+                    marchid = _try_parse_hex(v)
+                case "mimpid":
+                    mimpid = _try_parse_hex(v)
+                case _:
+                    continue
+
+    if mvendorid is not None and marchid is not None and mimpid is not None:
+        uarch_csr = f"{mvendorid:x}:{marchid:x}:{mimpid:x}"
+    else:
+        uarch_csr = "unknown"
+
+    return {
+        "model_name": model_name,
+        "cpu_count": cpu_count,
+        "isa": isa,
+        "mmu": mmu,
+        "uarch": uarch,
+        "uarch_csr": uarch_csr,
+    }
+
+
+def probe_for_shell(os_environ: Mapping[str, str]) -> str:
+    if x := os_environ.get("SHELL"):
+        return os.path.basename(x)
+    return "unknown"
+
+
+def gather_node_info(report_uuid: uuid.UUID | None = None) -> NodeInfo:
+    arch = platform.machine()
+    libc = probe_for_libc()
+    os_release = platform.freedesktop_os_release()
+
+    os_version = os_release.get("VERSION_CODENAME")  # works on e.g. Debian
+    if not os_version:
+        os_version = os_release.get("VERSION_ID")  # works on e.g. openEuler, Gentoo
+    if not os_version:
+        os_version = "unknown"
+
+    data: NodeInfo = {
+        "v": 1,
+        "report_uuid": report_uuid.hex if report_uuid is not None else uuid.uuid4().hex,
+        "arch": arch,
+        "ci": probe_for_ci(os.environ) or "maybe-not",
+        "libc_name": libc[0],
+        "libc_ver": libc[1],
+        "os": sys.platform,
+        "os_release_id": os_release.get("ID", "unknown"),
+        "os_release_version_id": os_version,
+        "shell": probe_for_shell(os.environ),
+    }
+
+    if arch.startswith("riscv"):
+        if riscv_machine := probe_for_riscv_machine_info():
+            data["riscv_machine"] = riscv_machine
+
+    return data