ruyi 0.39.0__py3-none-any.whl

ruyi/resource_bundle/__main__.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# Regenerates data.py from fresh contents.
+
+import base64
+import pathlib
+from typing import Any
+import zlib
+
+
+def make_payload_from_file(path: pathlib.Path) -> str:
+    with open(path, "rb") as fp:
+        content = fp.read()
+
+    return base64.b64encode(zlib.compress(content, 9)).decode("ascii")
+
+
+def main() -> None:
+    self_path = pathlib.Path(__file__).parent.resolve()
+    bundled_resource_root = self_path / ".." / ".." / "resources" / "bundled"
+
+    resources: dict[str, str] = {}
+    template_names: dict[str, str] = {}
+    for f in bundled_resource_root.iterdir():
+        if not f.is_file():
+            continue
+
+        resources[f.name] = make_payload_from_file(f)
+
+        if f.suffix.lower() == ".jinja":
+            # strip the .jinja suffix for the template name
+            template_names[f.stem] = f.name
+
+    with open(self_path / "data.py", "w", encoding="utf-8") as fp:
+
+        def p(*args: Any) -> None:
+            return print(*args, file=fp)
+
+        p("# NOTE: This file is auto-generated. DO NOT EDIT!")
+        p("# Update by running the __main__.py alongside this file\n")
+
+        p("from typing import Final\n\n")
+
+        p("RESOURCES: Final = {")
+        for filename, payload in sorted(resources.items()):
+            p(f'    "{filename}": b"{payload}",  # fmt: skip')
+        p("}\n")
+
+        p("TEMPLATES: Final = {")
+        for stem, full_filename in sorted(template_names.items()):
+            p(f'    "{stem}": RESOURCES["{full_filename}"],')
+        p("}")
+
+
+if __name__ == "__main__":
+    main()

ruyi/resource_bundle/data.py

@@ -0,0 +1,26 @@
+# NOTE: This file is auto-generated. DO NOT EDIT!
+# Update by running the __main__.py alongside this file
+
+from typing import Final
+
+
+RESOURCES: Final = {
+    "_ruyi_completion": b"eNqlVntP40YQ/z+fYmosCC0h5KpKd7Tmjoc5ogYSxUlPd4FaTryJV9i7kXdNLofoZ++M7TgmmOiutVDYncdvZuexOzsTGc19NoU4WfJabQc6/J6FS/BAxzyKmA++XAh4YLHiUoCcQqD1XB03mzOug2R8iPrNe67CZXLf9OIZwYVMs+Y4lONm5HHxnOqpwM13iHfoN935UgdSNEpS6MUVC+doEgLvgYHPleZiomEesyn/CtNYRqADBjLmMy68ENQk5nMNWoL3ILkPwosYTGQYcvJa0bn6iQAlI6YDLmYHECUIOQOZ6HmiEQhi5vOYTVIqT6HIgs/GyQyUjpkXIYjP5kz4qaJI+Q9emDCKinvaP3cv7LPhx0OUa0/htP/xvHvd69gD2x06tjuwr3uX7Y7tAFegmD6ARDHQLJpPecgUTNGHdu/8sObmEXFLEXEpO/gj6vvwWAP8+BRGI2h8A8N8fNVU48mAu7vfyVORatG3Fd/lQrAYQT8YhULMdBJn+lOe/gvlBIOuM9ctw6xH93SQ/UzHLfvjDC66w4FL7tycXtsonKsZP+ZIZnIifWaZ71PKxNOwRktJcfSCkvoOJinWnmq177BZGeJ1eitjSm7C25PdFrw72X0DrZOmzx6aIglDeEPUP4p9qsJCxV7X3X1XqYSxpwO84n/hdRao9qVjmXu3R61f90rUrE0swyifT9D5vjhX7l9232l3byoPuAr/qnFVwSnRrLpZJ8OGib8G3BYy9FFFuJ32DZXA2fDy0u5XSvS67ZsBipwP+073hUi5tKzWFqbrXNmdjmV8U4GxVWzY6/Vtx3Gd3ul5BeS2cgHzMQvoccN8XMjYV6PW3dPT/v5G1IRUMtZWvYI+9yaszMCUcNXwdCNkntLw2+HbjTzQt8JryHy51s/7c51dTG0pQZRa6x+oj/6+vb3bP4bdXRKIPD0JyPWUObKax3cvCyA3nDnccGBvr9Kq6zOKyZgRcBETo1wlxMn8Hn0gVrYl4HT/skGyaG1k6qh8UEKXeP//Ilc+YgdB0T4VR9nMe9VZqEj6dq/z+bvrulhvL+1iUyk2+NwrsGi9tX5TqU/d/sVZ3z7901nprSn/u4Poxf6RFjKf7/9rQ7XKfZTVsvkefrLgqLo2E4Fv6jplBY+FufKGW5YFLUSiFsjapFBtlPrArDa2qrdGUW+b9ZNe1uUHZNsFuwpECY+WOJV5SZhaoSQU20t4LYjZEFc0zw58QhP4UIYhznHjZTqxfFFBqRtBLRU+3QfIwrFkwfHBwgEHFzrIIYxQer6XaDlNxMSABSFywTVHVBwTkUECiO+hnqGCTCz0NL7eUhyARKPxgit2kAOSE/m8tvDwNmA4QxkNBFAyHYmMfCI1aAaL2QyHP4TCkYycIu0c58UhUvrKofI9WnrtTHwQXLKIQ6jQ7KumQviZfK4YlF6LcjGUPLumVoP09uTkxYF//wJg/FlP",  # fmt: skip
+    "binfmt.conf.jinja": b"eNpNUrlu20AQ7f0VAwgCbECk+wQp06Zwl0oakUNyoD2UvQRC1r/7LUkhrkjuzjuHOzqrG2w6Wo0ddd4NOlLMmvhshAYfKE0a6SPPSkVDymxIHN68s+LS4WVH6ijOMYntm5XrSQO05fSTogidLLtNqu1PC3EvidXEFhR/faY4+Wx6CjIqyAJ5J+QHyFcbxvibuhGYznDgpN69xrdD1Wa68QwOvl6DvwbltPqefYYGuIKecwXQO5yEop0QzPAIjXeS1B0I0+qKvwhoqp7YbDjhFIY5zAtVFDOgAV4GTgF9NP8wd6JbgLKE9uW+X3ThYqy+gkRvivTHehBp/wD57yfx/b7MtfB3NTwfHVuhxwMcDemw3qHmBQXcH49QaeJUrRCb6GnigiNfR4v29VaifF8NFUYZ2GIk4EJ2Sa1s+/KhR3qguZtUQNT5EKRLW/JaVhSUlLSLP+Bgi3Y5UKnwp71WsfX4+gabO2pqqAtC/MKz0CcWuiaCqb6i92s8fCFhU7+2Er79gUes69nDf9gX9HfteA==",  # fmt: skip
+    "meson-cross.ini.jinja": b"eNptkMFqwzAQRO/6ioUQ0tJazaU9FPoLvfUUglDkNV4iS0IrB4eQf69k2ZRCbmI083Z3NvDDCJbO+Ck2YgMDsnfAmMYATWOiZ246sgi3G1zQXVT0PsH9/jYbq0GSI5BSzoBvxJYXzF6+f8j9ixTicCKnIyEfhYEv2GWaMRmzEyaEVZimWbltG+h8hDNeXyHo1AO5ClS6bSmRd9qqFSgp4cBPz7C9iwzJoQxZiHN4RaJrC7XYtkAd8JXnW7JwOI1kU5PH+FDwecsQsaNp4azWiiqknC+5EH3AmOpdgz6jSt5b02tyam5tuezR17rX/1Xys1b8aHLzN1oces9JDdr05PBYcrmHkrLkxqn0OqpOD2SvaxnRG2TOFdTax4d6GaBd5aRkcSd+ATx1t64=",  # fmt: skip
+    "prompt.venv-created.txt.jinja": b"eNp1kTFvwkAMhff7FV7YStjbqWLqwMZSISSOO4dYJOfIvoRGiP9eXwR0KTedbOv5e8/bBmEkyYNvAZP9OHWYMpBC4gsEQZ8xVs598wCdn8CHTKPVgDIcJ1AeJFA6QTYh3/fCvVBp3+eIE2gQ6k0ylSG3Owli2h8p7VZ7iCQYMsv0Bj5FiPjUN3FKI5+L+EGGiZZ/zUPlroslUA06qTBnWNyc+4RaUJtHbdUL1vRTrPhWGYxtJDUgjHeW/5xX7mt270dPrT+25iTPszW3LV8KTe9z8+4c2LubuV6fILeb2ZrpMEUDLGDbFyHPWIE7VLhQbsDCjtOy8xFhvfFnhMzchsYbbU0tupLQBtUiDcKqc7GCdYPh/MoOzFA1iw2w4oezdaWujwiKhhpEymXNoP5kp02aZQjleFq5Xz21xdY=",  # fmt: skip
+    "ruyi-activate.bash.jinja": b"eNp9lN1u2kAQhe/3KSYGqiSVRUnuqIhEGqRESgLCBClKI2uxx/JKZh2t126o6yfqI/QuT9bxH2CHhBvEzpn1d2YO7sDCFxF4IkBYx5GGFUIcoQu/hPbBiMJYOQgrIfsq3giTO1okXKMBp54K17DikX/KOrAJY3C4lKEGFUsQGlyh0NHBhjEmPHgCo5tejq1r25o+zH9MzMyAEZ19M+D5O2gfJQP6oOOHYDzSZQVL9XSdE0aOEi96CD+79XHefPHlrGx8pUeenzNPMFaAulijwvEJpIWoAwoj1BAGLqBMhArlGqWGhCvBVwFGleqIcM3f0E2X4/lXO4Nn6tOxkhFoFSOQHSoAMbnoBFzRsLgGHgRFO1WrfnJszx8eb+zp7ZU9Gy+uh3QZ+YU9w/knL42MblNrbMv4+hIqXai2Z7HMfTQ7imLuvzQhZMID4eYDoKcV7bQhx8ei7tPewFRwdtF3MenLmOg/xbcGH8Bbgya7NXiPbg0+Jq9qNXhZL8rLyf3y0Jk9m0/vZosa94mAiXVQRUqG0sWIFpWvH1vEHbAw8KAWHLWwTA9a4anZMkYhL0VCKQww4Y3gtDPXpGBsCz9K050T+AO0hixj1aB2tllztzTiMhTVj62wT//MYVXbDwr7LAAHl5/28mHuhnw/vpuA2ctYe+4NB6WstpH2TMAgwsN9RveYXhco+Rphz4JxYpSN0iWA3vth1Psu3yNlMnfFqxtrfHk7qURmO6ONpBFCSl8kYtvsvv2d0+5g/8ryquztHzTke2mmRPwHax2J0Q==",  # fmt: skip
+    "ruyi-cache.toml.jinja": b"eNptUs1uhCAYvPsUX2nMtknjoccmve0e9tK9eDOGsIJK1r8CmhjjuxcUF6uexG+GmWHgFX5u4eULwpxLSHnBQH9LUpGMUbj3INqeB3C+GRpcztfwxfOihCQ5o7j7jL3BB57CLytbfOcV+ONz+Q1oGBwyjkhzWUU13R/tvkbUxhMbEqs6AzjxYINOZmkt4PEBHWjJDR5wxUr59q5VtPFDO9oMnTH3ZnezX+P/k6xFFREZU3Iltkq0gFY/9lRdF0lOeGXOSLlYHKPTFjnFUwo3TguSySP+BFj6XFMXIQfLXoq6VijW0XbTIz0LzYr7O9DiWZJgXklFigLrqJP0ZuaEN8Ch7LPobbtJSXHJFKFEEVyS5rjmHQvZwlHsUSZXpzR/S7PT3WDVNvoRuxpWU9epy/cHatoHPQ==",  # fmt: skip
+    "ruyi-venv.toml.jinja": b"eNqLTs7PS8tMj+UqKMpPy8xJVbBVUKquVoDxamuVuKpVFTLTFIori4vy80sUdFVruWBsiFoYD6JWVyE1LwWoHqgMAMZMHuE=",  # fmt: skip
+    "toolchain.cmake.jinja": b"eNqFkVFrwjAUhd/7Ky6IMGF274M9dG2cZWlT0joUhJDVaIuajKQTR+l/X6zOWccwb+F+5+Scmx5MjIBNuRaPTs/pQb7lawGu68Lc3g5nGPiR94pYRgj2x14Ys1GI0VNdw07IHdNKVdA0D5VSm7zgpXSPFnOn7g+hXIL5Mi3Tb64MwzjNPIxZQtEonB4Mf9CmOcmFXFiHs9LGchwjqrujQTpLMxSx2IsQ4FJ+7gd/hwklPkpTQsH6f2iVC2OUti9csj7zSZTYVi2V59fj6bQL7PctUfcv+w1tzF/NKIwDRgnJWOJlY+iUa5UX1YzgOi9gaXMVgi+ENsDlwn7Ku+a6FAZKCVUhoOJ6JSqr3JVaya2Q1X1XbfutNN+eBYUyHfzffCwiATrs6oV6EcToDdHBDRiHz9SjMyAxnt1iw9jHkwCd2G+4PsQk",  # fmt: skip
+}
+
+TEMPLATES: Final = {
+    "binfmt.conf": RESOURCES["binfmt.conf.jinja"],
+    "meson-cross.ini": RESOURCES["meson-cross.ini.jinja"],
+    "prompt.venv-created.txt": RESOURCES["prompt.venv-created.txt.jinja"],
+    "ruyi-activate.bash": RESOURCES["ruyi-activate.bash.jinja"],
+    "ruyi-cache.toml": RESOURCES["ruyi-cache.toml.jinja"],
+    "ruyi-venv.toml": RESOURCES["ruyi-venv.toml.jinja"],
+    "toolchain.cmake": RESOURCES["toolchain.cmake.jinja"],
+}

ruyi/ruyipkg/admin_checksum.py

@@ -0,0 +1,88 @@
+import os
+import sys
+from typing import Any, TypeGuard
+
+from tomlkit import document, table
+from tomlkit.items import AoT, Table
+from tomlkit.toml_document import TOMLDocument
+
+from ..log import RuyiLogger
+from . import checksum
+from .pkg_manifest import DistfileDeclType, RestrictKind
+
+
+def do_admin_checksum(
+    logger: RuyiLogger,
+    files: list[os.PathLike[Any]],
+    format: str,
+    restrict: list[str],
+) -> int:
+    if not validate_restrict_kinds(restrict):
+        logger.F(f"invalid restrict kinds given: {restrict}")
+        return 1
+
+    entries = [gen_distfile_entry(logger, f, restrict) for f in files]
+    if format == "toml":
+        doc = emit_toml_distfiles_section(entries)
+        logger.D(f"{doc}")
+        sys.stdout.write(doc.as_string())
+        return 0
+
+    raise RuntimeError("unrecognized output format; should never happen")
+
+
+def validate_restrict_kinds(input: list[str]) -> TypeGuard[list[RestrictKind]]:
+    for x in input:
+        match x:
+            case "fetch" | "mirror":
+                pass
+            case _:
+                return False
+    return True
+
+
+def gen_distfile_entry(
+    logger: RuyiLogger,
+    path: os.PathLike[Any],
+    restrict: list[RestrictKind],
+) -> DistfileDeclType:
+    logger.D(f"generating distfile entry for {path}")
+    with open(path, "rb") as fp:
+        filesize = os.stat(fp.fileno()).st_size
+        c = checksum.Checksummer(fp, {})
+        checksums = c.compute(kinds=checksum.SUPPORTED_CHECKSUM_KINDS)
+
+    obj: DistfileDeclType = {
+        "name": os.path.basename(path),
+        "size": filesize,
+        "checksums": checksums,
+    }
+
+    if restrict:
+        obj["restrict"] = restrict
+
+    return obj
+
+
+def emit_toml_distfiles_section(x: list[DistfileDeclType]) -> TOMLDocument:
+    doc = document()
+
+    arr: list[Table] = []
+    for dd in x:
+        t = table()
+        t.add("name", dd["name"])
+        t.add("size", dd["size"])
+        if r := dd.get("restrict"):
+            t.add("restrict", r)
+        t.add("checksums", emit_toml_checksums(dd["checksums"]))
+        arr.append(t)
+
+    doc.add("distfiles", AoT(arr))
+    return doc
+
+
+def emit_toml_checksums(x: dict[str, str]) -> Table:
+    t = table()
+    for k in sorted(x.keys()):
+        t.add(k, x[k])
+    return t

ruyi/ruyipkg/admin_cli.py

@@ -0,0 +1,83 @@
+import argparse
+import pathlib
+from typing import TYPE_CHECKING, cast
+
+from ..cli.cmd import AdminCommand
+
+if TYPE_CHECKING:
+    from ..cli.completion import ArgumentParser
+    from ..config import GlobalConfig
+
+
+class AdminChecksumCommand(
+    AdminCommand,
+    cmd="checksum",
+    help="Generate a checksum section for a manifest file for the distfiles given",
+):
+    @classmethod
+    def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
+        p.add_argument(
+            "--format",
+            "-f",
+            type=str,
+            choices=["toml"],
+            default="toml",
+            help="Format of checksum section to generate in",
+        )
+        p.add_argument(
+            "--restrict",
+            type=str,
+            default="",
+            help="the 'restrict' field to use for all mentioned distfiles, separated with comma",
+        )
+        p.add_argument(
+            "file",
+            type=str,
+            nargs="+",
+            help="Path to the distfile(s) to checksum",
+        )
+
+    @classmethod
+    def main(cls, cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+        from .admin_checksum import do_admin_checksum
+
+        logger = cfg.logger
+        files = args.file
+        format = args.format
+        restrict_str = cast(str, args.restrict)
+        restrict = restrict_str.split(",") if restrict_str else []
+
+        return do_admin_checksum(logger, files, format, restrict)
+
+
+class AdminFormatManifestCommand(
+    AdminCommand,
+    cmd="format-manifest",
+    help="Format the given package manifests into canonical TOML representation",
+):
+    @classmethod
+    def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
+        p.add_argument(
+            "file",
+            type=str,
+            nargs="+",
+            help="Path to the distfile(s) to generate manifest for",
+        )
+
+    @classmethod
+    def main(cls, cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+        from .canonical_dump import dumps_canonical_package_manifest_toml
+        from .pkg_manifest import PackageManifest
+
+        files = args.file
+
+        for f in files:
+            p = pathlib.Path(f)
+            pm = PackageManifest.load_from_path(p)
+            d = dumps_canonical_package_manifest_toml(pm)
+
+            dest_path = p.with_suffix(".toml")
+            with open(dest_path, "w", encoding="utf-8") as fp:
+                fp.write(d)
+
+        return 0

ruyi/ruyipkg/atom.py

@@ -0,0 +1,184 @@
+import abc
+import re
+from typing import Final, Iterator, Literal, Tuple
+
+import semver
+
+from .pkg_manifest import BoundPackageManifest, is_prerelease
+from .protocols import ProvidesPackageManifests
+
+
+AtomKind = Literal["name"] | Literal["expr"] | Literal["slug"]
+
+RE_ATOM_EXPR: Final = re.compile(r"^([^:(]+)\((.+)\)$")
+RE_ATOM_NAME: Final = re.compile(r"^[^:()]+$")
+
+
+class Atom(abc.ABC):
+    def __init__(self, s: str, kind: AtomKind) -> None:
+        self._s = s
+        self._kind: AtomKind = kind
+
+    @property
+    def input_str(self) -> str:
+        return self._s
+
+    @property
+    def kind(self) -> AtomKind:
+        return self._kind
+
+    @classmethod
+    def parse(cls, s: str) -> "SlugAtom | NameAtom | ExprAtom":
+        if s.startswith("slug:"):
+            return SlugAtom(s)
+
+        if s.startswith("name:"):
+            return NameAtom(s, s[5:])  # strip the "name:" prefix
+
+        if match := RE_ATOM_EXPR.match(s):
+            return ExprAtom(s, match[1], match[2])
+
+        # fallback
+        if match := RE_ATOM_NAME.match(s):
+            return NameAtom(s, s)
+
+        raise ValueError(f"invalid atom: '{s}'")
+
+    @abc.abstractmethod
+    def match_in_repo(
+        self,
+        repo: ProvidesPackageManifests,
+        include_prerelease_vers: bool,
+    ) -> BoundPackageManifest | None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def iter_in_repo(
+        self,
+        repo: ProvidesPackageManifests,
+        include_prerelease_vers: bool,
+    ) -> Iterator[BoundPackageManifest]:
+        raise NotImplementedError
+
+
+def split_category(name: str) -> Tuple[str | None, str]:
+    fragments = name.split("/", 1)
+    if len(fragments) == 2:
+        return (fragments[0], fragments[1])
+    return (None, name)
+
+
+class NameAtom(Atom):
+    def __init__(self, s: str, name: str) -> None:
+        super().__init__(s, "name")
+
+        self.category, self.name = split_category(name)
+
+    def match_in_repo(
+        self,
+        repo: ProvidesPackageManifests,
+        include_prerelease_vers: bool,
+    ) -> BoundPackageManifest | None:
+        # return the latest version of the package named self.name in the given repo
+        try:
+            return repo.get_pkg_latest_ver(
+                self.name,
+                self.category,
+                include_prerelease_vers,
+            )
+        except KeyError:
+            return None
+
+    def iter_in_repo(
+        self,
+        repo: ProvidesPackageManifests,
+        include_prerelease_vers: bool,
+    ) -> Iterator[BoundPackageManifest]:
+        # return all versions of the package named self.name in the given repo
+        for pm in repo.iter_pkg_vers(self.name, self.category):
+            if not is_prerelease(pm.semver) or include_prerelease_vers:
+                yield pm
+
+
+def fix_version_matcher_for_semver2(match_expr: str) -> str:
+    # equivalent of https://github.com/python-semver/python-semver/pull/362
+    # for semver 2.x
+    if match_expr and match_expr[0] in "0123456789":
+        return f"=={match_expr}"
+    return match_expr
+
+
+class ExprAtom(Atom):
+    def __init__(self, s: str, name: str, expr: str) -> None:
+        super().__init__(s, "expr")
+        self.exprs = expr.split(",")
+
+        if semver.__version__ < "3":
+            self.exprs = list(map(fix_version_matcher_for_semver2, self.exprs))
+
+        self.category, self.name = split_category(name)
+
+    def _is_pm_matching_my_exprs(self, pm: BoundPackageManifest) -> bool:
+        for e in self.exprs:
+            if not pm.semver.match(e):
+                return False
+        return True
+
+    def match_in_repo(
+        self,
+        repo: ProvidesPackageManifests,
+        include_prerelease_vers: bool,
+    ) -> BoundPackageManifest | None:
+        matching_pms = {
+            pm.ver: pm
+            for pm in repo.iter_pkg_vers(self.name, self.category)
+            if self._is_pm_matching_my_exprs(pm)
+        }
+        if not matching_pms:
+            return None
+
+        semvers = [pm.semver for pm in matching_pms.values()]
+        if not include_prerelease_vers:
+            semvers = [sv for sv in semvers if not is_prerelease(sv)]
+        if not semvers:
+            return None
+        latest_ver = max(semvers)
+        return matching_pms[str(latest_ver)]
+
+    def iter_in_repo(
+        self,
+        repo: ProvidesPackageManifests,
+        include_prerelease_vers: bool,
+    ) -> Iterator[BoundPackageManifest]:
+        for pm in repo.iter_pkg_vers(self.name, self.category):
+            if self._is_pm_matching_my_exprs(pm):
+                if not is_prerelease(pm.semver) or include_prerelease_vers:
+                    yield pm
+
+
+class SlugAtom(Atom):
+    def __init__(self, s: str) -> None:
+        super().__init__(s, "slug")
+        self.slug = s[5:]  # strip the "slug:" prefix
+
+    def match_in_repo(
+        self,
+        repo: ProvidesPackageManifests,
+        include_prerelease_vers: bool,
+    ) -> BoundPackageManifest | None:
+        pm = repo.get_pkg_by_slug(self.slug)
+        if pm and is_prerelease(pm.semver):
+            return pm if include_prerelease_vers else None
+        return pm
+
+    def iter_in_repo(
+        self,
+        repo: ProvidesPackageManifests,
+        include_prerelease_vers: bool,
+    ) -> Iterator[BoundPackageManifest]:
+        pm = repo.get_pkg_by_slug(self.slug)
+        if pm is None:
+            return None
+
+        if is_prerelease(pm.semver) and include_prerelease_vers:
+            yield pm

ruyi/ruyipkg/augmented_pkg.py

@@ -0,0 +1,212 @@
+import enum
+import sys
+from typing import Iterable, TypedDict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+from ..config import GlobalConfig
+from ..utils.porcelain import PorcelainEntity, PorcelainEntityType
+from .distfile import Distfile
+from .host import get_native_host
+from .list_filter import ListFilter
+from .pkg_manifest import BoundPackageManifest, PackageManifestType
+from .repo import MetadataRepo
+
+
+if sys.version_info >= (3, 11):
+
+    class PkgRemark(enum.StrEnum):
+        Latest = "latest"
+        LatestPreRelease = "latest-prerelease"
+        NoBinaryForCurrentHost = "no-binary-for-current-host"
+        PreRelease = "prerelease"
+        HasKnownIssue = "known-issue"
+        Downloaded = "downloaded"
+        Installed = "installed"
+
+        def as_rich_markup(self) -> str:
+            match self:
+                case self.Latest:
+                    return "latest"
+                case self.LatestPreRelease:
+                    return "latest-prerelease"
+                case self.NoBinaryForCurrentHost:
+                    return "[red]no binary for current host[/]"
+                case self.PreRelease:
+                    return "prerelease"
+                case self.HasKnownIssue:
+                    return "[yellow]has known issue[/]"
+                case self.Downloaded:
+                    return "[green]downloaded[/]"
+                case self.Installed:
+                    return "[green]installed[/]"
+            return ""
+
+else:
+
+    class PkgRemark(str, enum.Enum):
+        Latest = "latest"
+        LatestPreRelease = "latest-prerelease"
+        NoBinaryForCurrentHost = "no-binary-for-current-host"
+        PreRelease = "prerelease"
+        HasKnownIssue = "known-issue"
+        Downloaded = "downloaded"
+        Installed = "installed"
+
+        def as_rich_markup(self) -> str:
+            match self:
+                case self.Latest:
+                    return "latest"
+                case self.LatestPreRelease:
+                    return "latest-prerelease"
+                case self.NoBinaryForCurrentHost:
+                    return "[red]no binary for current host[/]"
+                case self.PreRelease:
+                    return "prerelease"
+                case self.HasKnownIssue:
+                    return "[yellow]has known issue[/]"
+                case self.Downloaded:
+                    return "[green]downloaded[/]"
+                case self.Installed:
+                    return "[green]installed[/]"
+            return ""
+
+
+class AugmentedPkgManifest:
+    def __init__(
+        self,
+        pm: BoundPackageManifest,
+        remarks: list[PkgRemark],
+    ) -> None:
+        self.pm = pm
+        self.remarks = remarks
+        self._is_downloaded = PkgRemark.Downloaded in remarks
+        self._is_installed = PkgRemark.Installed in remarks
+
+    def to_porcelain(self) -> "PorcelainPkgVersionV1":
+        return {
+            "semver": str(self.pm.semver),
+            "pm": self.pm.to_raw(),
+            "remarks": self.remarks,
+            "is_downloaded": self._is_downloaded,
+            "is_installed": self._is_installed,
+        }
+
+
+class AugmentedPkg:
+    def __init__(self) -> None:
+        self.versions: list[AugmentedPkgManifest] = []
+
+    def add_version(self, v: AugmentedPkgManifest) -> None:
+        if self.versions:
+            if v.pm.category != self.category or v.pm.name != self.name:
+                raise ValueError("cannot add a version of a different pkg")
+        self.versions.append(v)
+
+    @property
+    def category(self) -> str | None:
+        return self.versions[0].pm.category if self.versions else None
+
+    @property
+    def name(self) -> str | None:
+        return self.versions[0].pm.name if self.versions else None
+
+    @classmethod
+    def yield_from_repo(
+        cls,
+        cfg: GlobalConfig,
+        mr: MetadataRepo,
+        filters: ListFilter,
+        *,
+        ensure_repo: bool = True,
+    ) -> "Iterable[Self]":
+        rgs = cfg.ruyipkg_global_state
+        native_host = str(get_native_host())
+
+        for category, pkg_name, pkg_vers in mr.iter_pkgs(ensure_repo=ensure_repo):
+            if not filters.check_pkg_name(cfg, mr, category, pkg_name):
+                continue
+
+            pkg = cls()
+
+            semvers = [pm.semver for pm in pkg_vers.values()]
+            semvers.sort(reverse=True)
+            found_latest = False
+            for i, sv in enumerate(semvers):
+                # TODO: support filter ops against individual versions
+
+                pm = pkg_vers[str(sv)]
+
+                latest = False
+                latest_prerelease = i == 0
+                prerelease = pm.is_prerelease
+                if not found_latest and not prerelease:
+                    latest = True
+                    found_latest = True
+
+                remarks: list[PkgRemark] = []
+                if latest or latest_prerelease or prerelease:
+                    if prerelease:
+                        remarks.append(PkgRemark.PreRelease)
+                    if latest:
+                        remarks.append(PkgRemark.Latest)
+                    if latest_prerelease and not latest:
+                        remarks.append(PkgRemark.LatestPreRelease)
+                if pm.service_level.has_known_issues:
+                    remarks.append(PkgRemark.HasKnownIssue)
+                if bm := pm.binary_metadata:
+                    if not bm.is_available_for_current_host:
+                        remarks.append(PkgRemark.NoBinaryForCurrentHost)
+                if _is_pkg_fully_downloaded(pm):
+                    remarks.append(PkgRemark.Downloaded)
+
+                host = native_host if bm is not None else ""
+                is_installed = rgs.is_package_installed(
+                    pm.repo_id,
+                    pm.category,
+                    pm.name,
+                    str(sv),
+                    host,
+                )
+                if is_installed:
+                    remarks.append(PkgRemark.Installed)
+
+                pkg.add_version(AugmentedPkgManifest(pm, remarks))
+
+            yield pkg
+
+    def to_porcelain(self) -> "PorcelainPkgListOutputV1":
+        return {
+            "ty": PorcelainEntityType.PkgListOutputV1,
+            "category": self.category or "",
+            "name": self.name or "",
+            "vers": [x.to_porcelain() for x in self.versions],
+        }
+
+
+class PorcelainPkgVersionV1(TypedDict):
+    semver: str
+    pm: PackageManifestType
+    remarks: list[PkgRemark]
+    is_downloaded: bool
+    is_installed: bool
+
+
+class PorcelainPkgListOutputV1(PorcelainEntity):
+    category: str
+    name: str
+    vers: list[PorcelainPkgVersionV1]
+
+
+def _is_pkg_fully_downloaded(pm: BoundPackageManifest) -> bool:
+    dfs = pm.distfiles
+    if not dfs:
+        return True
+
+    for df_decl in dfs.values():
+        df = Distfile(df_decl, pm.repo)
+        if not df.is_downloaded():
+            return False
+
+    return True