ruyi 0.39.0__py3-none-any.whl

ruyi/ruyipkg/list.py

@@ -0,0 +1,126 @@
+from itertools import chain
+
+from ..config import GlobalConfig
+from ..log import RuyiLogger
+from ..utils.porcelain import PorcelainOutput
+from .augmented_pkg import AugmentedPkg
+from .list_filter import ListFilter
+from .pkg_manifest import BoundPackageManifest
+
+
+def do_list(
+    cfg: GlobalConfig,
+    filters: ListFilter,
+    verbose: bool,
+) -> int:
+    logger = cfg.logger
+
+    if not filters:
+        if cfg.is_porcelain:
+            # we don't want to print message for humans in case of porcelain
+            # mode, but we don't want to retain the old behavior of listing
+            # all packages either
+            return 1
+
+        logger.F("no filter specified for list operation")
+        logger.I(
+            "for the old behavior of listing all packages, try [yellow]ruyi list --name-contains ''[/]"
+        )
+        return 1
+
+    augmented_pkgs = list(AugmentedPkg.yield_from_repo(cfg, cfg.repo, filters))
+
+    if cfg.is_porcelain:
+        return _do_list_porcelain(augmented_pkgs)
+
+    if not verbose:
+        return _do_list_non_verbose(logger, augmented_pkgs)
+
+    for i, ver in enumerate(chain(*(ap.versions for ap in augmented_pkgs))):
+        if i > 0:
+            logger.stdout("\n")
+
+        _print_pkg_detail(logger, ver.pm, cfg.lang_code)
+
+    return 0
+
+
+def _do_list_non_verbose(
+    logger: RuyiLogger,
+    augmented_pkgs: list[AugmentedPkg],
+) -> int:
+    logger.stdout("List of available packages:\n")
+
+    for ap in augmented_pkgs:
+        logger.stdout(f"* [bold green]{ap.category}/{ap.name}[/]")
+        for ver in ap.versions:
+            if ver.remarks:
+                comments_str = (
+                    f" ({', '.join(r.as_rich_markup() for r in ver.remarks)})"
+                )
+            else:
+                comments_str = ""
+            slug_str = f" slug: [yellow]{ver.pm.slug}[/]" if ver.pm.slug else ""
+            logger.stdout(f"  - [blue]{ver.pm.semver}[/]{comments_str}{slug_str}")
+
+    return 0
+
+
+def _do_list_porcelain(augmented_pkgs: list[AugmentedPkg]) -> int:
+    with PorcelainOutput() as po:
+        for ap in augmented_pkgs:
+            po.emit(ap.to_porcelain())
+
+    return 0
+
+
+def _print_pkg_detail(
+    logger: RuyiLogger,
+    pm: BoundPackageManifest,
+    lang_code: str,
+) -> None:
+    logger.stdout(f"[bold]## [green]{pm.category}/{pm.name}[/] [blue]{pm.ver}[/][/]\n")
+
+    if pm.slug is not None:
+        logger.stdout(f"* Slug: [yellow]{pm.slug}[/]")
+    else:
+        logger.stdout("* Slug: (none)")
+    logger.stdout(f"* Package kind: {sorted(pm.kind)}")
+    logger.stdout(f"* Vendor: {pm.vendor_name}")
+    if upstream_ver := pm.upstream_version:
+        logger.stdout(f"* Upstream version number: {upstream_ver}")
+    else:
+        logger.stdout("* Upstream version number: (undeclared)")
+    logger.stdout("")
+
+    sv = pm.service_level
+    if sv.has_known_issues:
+        logger.stdout("\nPackage has known issue(s):\n")
+        for x in sv.render_known_issues(pm.repo.messages, lang_code):
+            logger.stdout(x, end="\n\n")
+
+    df = pm.distfiles
+    logger.stdout(f"Package declares {len(df)} distfile(s):\n")
+    for dd in df.values():
+        logger.stdout(f"* [green]{dd.name}[/]")
+        logger.stdout(f"    - Size: [yellow]{dd.size}[/] bytes")
+        for kind, csum in dd.checksums.items():
+            logger.stdout(f"    - {kind.upper()}: [yellow]{csum}[/]")
+
+    if bm := pm.binary_metadata:
+        logger.stdout("\n### Binary artifacts\n")
+        for host, data in bm.data.items():
+            logger.stdout(f"* Host [green]{host}[/]:")
+            logger.stdout(f"    - Distfiles: {data['distfiles']}")
+            if cmds := data.get("commands"):
+                logger.stdout("    - Available command(s):")
+                for k in sorted(cmds.keys()):
+                    logger.stdout(f"        - [green]{k}[/]")
+
+    if tm := pm.toolchain_metadata:
+        logger.stdout("\n### Toolchain metadata\n")
+        logger.stdout(f"* Target: [bold green]{tm.target}[/]")
+        logger.stdout(f"* Quirks: {tm.quirks}")
+        logger.stdout("* Components:")
+        for tc in tm.components:
+            logger.stdout(f'    - {tc["name"]} [bold green]{tc["version"]}[/]')

ruyi/ruyipkg/list_cli.py

@@ -0,0 +1,79 @@
+import argparse
+from typing import TYPE_CHECKING
+
+from ..cli.cmd import RootCommand
+from .list_filter import ListFilter, ListFilterAction
+
+if TYPE_CHECKING:
+    from ..cli.completion import ArgumentParser
+    from ..config import GlobalConfig
+
+
+class ListCommand(
+    RootCommand,
+    cmd="list",
+    has_subcommands=True,
+    is_subcommand_required=False,
+    has_main=True,
+    help="List available packages in configured repository",
+):
+    @classmethod
+    def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
+        p.add_argument(
+            "--verbose",
+            "-v",
+            action="store_true",
+            help="Also show details for every package",
+        )
+
+        # filter expressions
+        p.add_argument(
+            "--is-installed",
+            action=ListFilterAction,
+            nargs=1,
+            dest="filters",
+            help="Match packages that are installed (y/true/1) or not installed (n/false/0)",
+        )
+        p.add_argument(
+            "--category-contains",
+            action=ListFilterAction,
+            nargs=1,
+            dest="filters",
+            help="Match packages from categories whose names contain the given string",
+        )
+        p.add_argument(
+            "--category-is",
+            action=ListFilterAction,
+            nargs=1,
+            dest="filters",
+            help="Match packages from the given category",
+        )
+        p.add_argument(
+            "--name-contains",
+            action=ListFilterAction,
+            nargs=1,
+            dest="filters",
+            help="Match packages whose names contain the given string",
+        )
+
+        if gc.is_experimental:
+            p.add_argument(
+                "--related-to-entity",
+                action=ListFilterAction,
+                nargs=1,
+                dest="filters",
+                help="Match packages related to the given entity",
+            )
+
+    @classmethod
+    def main(cls, cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+        from .list import do_list
+
+        verbose: bool = args.verbose
+        filters: ListFilter = args.filters
+
+        return do_list(
+            cfg,
+            filters=filters,
+            verbose=verbose,
+        )

ruyi/ruyipkg/list_filter.py

@@ -0,0 +1,173 @@
+import argparse
+import enum
+from typing import Any, Callable, Iterable, NamedTuple, Sequence, TypeVar, TYPE_CHECKING
+
+from ..cli.completion import ArgcompleteAction
+from ..utils.global_mode import TRUTHY_ENV_VAR_VALUES
+
+if TYPE_CHECKING:
+    from ..config import GlobalConfig
+    from .repo import MetadataRepo
+
+_T = TypeVar("_T")
+
+
+class ListFilterOpKind(enum.Enum):
+    UNKNOWN = 0
+    CATEGORY_CONTAINS = 1
+    CATEGORY_IS = 2
+    NAME_CONTAINS = 3
+    RELATED_TO_ENTITY = 4
+    IS_INSTALLED = 5
+
+
+class ListFilterOp(NamedTuple):
+    op: ListFilterOpKind
+    arg: str
+
+
+class ListFilterExecCtx(NamedTuple):
+    cfg: "GlobalConfig"
+    mr: "MetadataRepo"
+    category: str
+    pkg_name: str
+
+
+def _execute_filter_op(op: ListFilterOp, ctx: ListFilterExecCtx) -> bool:
+    match op.op:
+        case ListFilterOpKind.CATEGORY_CONTAINS:
+            return op.arg in ctx.category
+        case ListFilterOpKind.CATEGORY_IS:
+            return op.arg == ctx.category
+        case ListFilterOpKind.NAME_CONTAINS:
+            return op.arg in ctx.pkg_name
+        case ListFilterOpKind.RELATED_TO_ENTITY:
+            es = ctx.mr.entity_store
+            return es.is_entity_related_to(
+                f"pkg:{ctx.category}/{ctx.pkg_name}",
+                op.arg,
+                transitive=True,
+                unidirectional=False,
+            )
+        case ListFilterOpKind.IS_INSTALLED:
+            asks_for_installed = op.arg.lower() in TRUTHY_ENV_VAR_VALUES
+
+            # We need to check all versions of this package to see if any are installed
+            # For now, we'll use a simple heuristic - check if ANY version is installed
+            installed_packages = ctx.cfg.ruyipkg_global_state.list_installed_packages()
+            is_installed = any(
+                pkg.category == ctx.category and pkg.name == ctx.pkg_name
+                for pkg in installed_packages
+            )
+            return not (is_installed ^ asks_for_installed)
+        case _:
+            return False
+
+
+class ListFilter:
+    def __init__(self) -> None:
+        self.ops: list[ListFilterOp] = []
+
+    def __bool__(self) -> bool:
+        return len(self.ops) > 0
+
+    def __repr__(self) -> str:
+        return f"<ListFilter ops={self.ops!r}>"
+
+    def append(self, op: ListFilterOp) -> None:
+        self.ops.append(op)
+
+    def check_pkg_name(
+        self,
+        cfg: "GlobalConfig",
+        mr: "MetadataRepo",
+        category: str,
+        pkg_name: str,
+    ) -> bool:
+        ctx = ListFilterExecCtx(cfg, mr, category, pkg_name)
+        return all(_execute_filter_op(op, ctx) for op in self.ops)
+
+
+class ListFilterAction(ArgcompleteAction):
+    def __init__(
+        self,
+        option_strings: Sequence[str],
+        dest: str,
+        nargs: int | str | None = None,
+        const: _T | None = None,
+        default: _T | str | None = None,
+        type: Callable[[str], _T] | argparse.FileType | None = None,
+        choices: Iterable[_T] | None = None,
+        required: bool = False,
+        help: str | None = None,
+        metavar: str | tuple[str, ...] | None = None,
+    ) -> None:
+        # for now let's just support unary filter ops
+        if nargs != 1:
+            raise ValueError("nargs != 1 not supported")
+        if const is not None:
+            raise ValueError("const not supported")
+        if default is not None:
+            raise ValueError("default not supported")
+        if type is not None:
+            raise ValueError("type not supported")
+        if choices is not None:
+            raise ValueError("choices not supported")
+        if required:
+            raise ValueError("required not supported")
+        if metavar is None:
+            metavar = "STR"
+
+        super().__init__(
+            option_strings,
+            dest,
+            nargs,
+            const,
+            default,
+            type,
+            choices,
+            required,
+            help,
+            metavar,
+        )
+
+        self.filter_op_kind: ListFilterOpKind
+        match option_strings[0].lstrip("-"):
+            case "category-contains":
+                self.filter_op_kind = ListFilterOpKind.CATEGORY_CONTAINS
+            case "category-is":
+                self.filter_op_kind = ListFilterOpKind.CATEGORY_IS
+            case "name-contains":
+                self.filter_op_kind = ListFilterOpKind.NAME_CONTAINS
+            case "related-to-entity":
+                self.filter_op_kind = ListFilterOpKind.RELATED_TO_ENTITY
+            case "is-installed":
+                self.filter_op_kind = ListFilterOpKind.IS_INSTALLED
+            case _:
+                # should never happen
+                self.filter_op_kind = ListFilterOpKind.UNKNOWN
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: str | Sequence[Any] | None,
+        option_string: str | None = None,
+    ) -> None:
+        dest: ListFilter | None = getattr(namespace, self.dest, None)
+        if not dest:
+            dest = ListFilter()
+            setattr(namespace, self.dest, dest)
+
+        val: str
+        if isinstance(values, str):
+            val = values
+        elif isinstance(values, list):
+            val = values[0]
+        else:
+            # should never happen
+            # XXX: no easy way to wire to the global logger instance here
+            # log.D(f"unexpected values type: {type(values)}")
+            val = ""
+
+        dest.append(ListFilterOp(self.filter_op_kind, val))

ruyi/ruyipkg/msg.py

@@ -0,0 +1,99 @@
+from typing import Callable, TypedDict, TypeGuard, cast
+
+from jinja2 import BaseLoader, Environment, TemplateNotFound
+
+from ..utils.l10n import match_lang_code
+
+
+RepoMessagesV1Type = TypedDict(
+    "RepoMessagesV1Type",
+    {
+        "ruyi-repo-messages": str,
+        # lang_code: message_content
+    },
+)
+
+
+def validate_repo_messages_v1(x: object) -> TypeGuard[RepoMessagesV1Type]:
+    if not isinstance(x, dict):
+        return False
+    x = cast(dict[str, object], x)
+    if x.get("ruyi-repo-messages", "") != "v1":
+        return False
+    return True
+
+
+def group_messages_by_lang_code(decl: RepoMessagesV1Type) -> dict[str, dict[str, str]]:
+    obj = cast(dict[str, dict[str, str]], decl)
+
+    result: dict[str, dict[str, str]] = {}
+    for msgid, msg_decl in obj.items():
+        # skip the file type marker
+        if msgid == "ruyi-repo-messages":
+            continue
+
+        for lang_code, msg in msg_decl.items():
+            if lang_code not in result:
+                result[lang_code] = {}
+            result[lang_code][msgid] = msg
+
+    return result
+
+
+class RepoMessageStore:
+    def __init__(self, decl: RepoMessagesV1Type) -> None:
+        self._msgs_by_lang_code = group_messages_by_lang_code(decl)
+        self._cached_envs_by_lang_code: dict[str, Environment] = {}
+
+    @classmethod
+    def from_object(cls, obj: object) -> "RepoMessageStore":
+        if not validate_repo_messages_v1(obj):
+            # TODO: more detail in the error message
+            raise RuntimeError("malformed v1 repo messages definition")
+        return cls(obj)
+
+    def get_message_template(self, msgid: str, lang_code: str) -> str | None:
+        resolved_lang_code = match_lang_code(lang_code, self._msgs_by_lang_code.keys())
+        return self._msgs_by_lang_code[resolved_lang_code].get(msgid)
+
+    def get_jinja(self, lang_code: str) -> Environment:
+        if lang_code in self._cached_envs_by_lang_code:
+            return self._cached_envs_by_lang_code[lang_code]
+
+        env = Environment(
+            loader=RepoMessageLoader(self, lang_code),
+            autoescape=False,  # we're not producing HTML
+            auto_reload=False,  # we're serving static assets
+        )
+        self._cached_envs_by_lang_code[lang_code] = env
+        return env
+
+    def render_message(
+        self,
+        msgid: str,
+        lang_code: str,
+        params: dict[str, str],
+        add_trailing_newline: bool = False,
+    ) -> str:
+        env = self.get_jinja(lang_code)
+        tmpl = env.get_template(msgid)
+        result = tmpl.render(params)
+        if add_trailing_newline and not result.endswith("\n"):
+            return result + "\n"
+        return result
+
+
+class RepoMessageLoader(BaseLoader):
+    def __init__(self, store: RepoMessageStore, lang_code: str) -> None:
+        self.store = store
+        self.lang_code = lang_code
+
+    def get_source(
+        self,
+        environment: Environment,
+        template: str,
+    ) -> tuple[str, (str | None), (Callable[[], bool] | None)]:
+        result = self.store.get_message_template(template, self.lang_code)
+        if result is None:
+            raise TemplateNotFound(template)
+        return result, None, None

ruyi/ruyipkg/news.py

@@ -0,0 +1,123 @@
+from rich import box
+from rich.table import Table
+
+from ..config import GlobalConfig
+from ..log import RuyiLogger
+from ..utils.markdown import RuyiStyledMarkdown
+from ..utils.porcelain import PorcelainOutput
+from .news_store import NewsItem, NewsItemContent, NewsItemStore
+
+
+def print_news_item_titles(
+    logger: RuyiLogger,
+    newsitems: list[NewsItem],
+    lang: str,
+) -> None:
+    tbl = Table(box=box.SIMPLE, show_edge=False)
+    tbl.add_column("No.")
+    tbl.add_column("ID")
+    tbl.add_column("Title")
+
+    for ni in newsitems:
+        unread = not ni.is_read
+        ord = f"[bold green]{ni.ordinal}[/]" if unread else f"{ni.ordinal}"
+        id = f"[bold green]{ni.id}[/]" if unread else ni.id
+
+        tbl.add_row(
+            ord,
+            id,
+            ni.get_content_for_lang(lang).display_title,
+        )
+
+    logger.stdout(tbl)
+
+
+def do_news_list(
+    cfg: GlobalConfig,
+    only_unread: bool,
+) -> int:
+    logger = cfg.logger
+    store = cfg.repo.news_store()
+    newsitems = store.list(only_unread)
+
+    if cfg.is_porcelain:
+        with PorcelainOutput() as po:
+            for ni in newsitems:
+                po.emit(ni.to_porcelain())
+        return 0
+
+    logger.stdout("[bold green]News items:[/]\n")
+    if not newsitems:
+        logger.stdout("  (no unread item)" if only_unread else "  (no item)")
+        return 0
+
+    print_news_item_titles(logger, newsitems, cfg.lang_code)
+
+    return 0
+
+
+def do_news_read(
+    cfg: GlobalConfig,
+    quiet: bool,
+    items_strs: list[str],
+) -> int:
+    logger = cfg.logger
+    store = cfg.repo.news_store()
+
+    # filter out requested news items
+    items = filter_news_items_by_specs(logger, store, items_strs)
+    if items is None:
+        return 1
+
+    if cfg.is_porcelain:
+        with PorcelainOutput() as po:
+            for ni in items:
+                po.emit(ni.to_porcelain())
+    elif not quiet:
+        # render the items
+        if items:
+            for ni in items:
+                print_news(logger, ni.get_content_for_lang(cfg.lang_code))
+        else:
+            logger.stdout("No news to display.")
+
+    # record read statuses
+    store.mark_as_read(*(ni.id for ni in items))
+
+    return 0
+
+
+def filter_news_items_by_specs(
+    logger: RuyiLogger,
+    store: NewsItemStore,
+    specs: list[str],
+) -> list[NewsItem] | None:
+    if not specs:
+        # all unread items
+        return store.list(True)
+
+    all_ni = store.list(False)
+    items: list[NewsItem] = []
+    ni_by_ord = {ni.ordinal: ni for ni in all_ni}
+    ni_by_id = {ni.id: ni for ni in all_ni}
+    for i in specs:
+        try:
+            ni_ord = int(i)
+            if ni_ord not in ni_by_ord:
+                logger.F(f"there is no news item with ordinal {ni_ord}")
+                return None
+            items.append(ni_by_ord[ni_ord])
+        except ValueError:
+            # treat i as id
+            if i not in ni_by_id:
+                logger.F(f"there is no news item with ID '{i}'")
+                return None
+            items.append(ni_by_id[i])
+
+    return items
+
+
+def print_news(logger: RuyiLogger, nic: NewsItemContent) -> None:
+    md = RuyiStyledMarkdown(nic.content)
+    logger.stdout(md)
+    logger.stdout("")

ruyi/ruyipkg/news_cli.py

@@ -0,0 +1,78 @@
+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 NewsCommand(
+    RootCommand,
+    cmd="news",
+    has_subcommands=True,
+    help="List and read news items from configured repository",
+):
+    @classmethod
+    def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
+        pass
+
+
+class NewsListCommand(
+    NewsCommand,
+    cmd="list",
+    help="List news items",
+):
+    @classmethod
+    def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
+        p.add_argument(
+            "--new",
+            action="store_true",
+            help="List unread news items only",
+        )
+
+    @classmethod
+    def main(cls, cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+        from .news import do_news_list
+
+        only_unread: bool = args.new
+        return do_news_list(
+            cfg,
+            only_unread,
+        )
+
+
+class NewsReadCommand(
+    NewsCommand,
+    cmd="read",
+    help="Read news items",
+    description="Outputs news item(s) to the console and mark as already read. Defaults to reading all unread items if no item is specified.",
+):
+    @classmethod
+    def configure_args(cls, gc: "GlobalConfig", p: "ArgumentParser") -> None:
+        p.add_argument(
+            "--quiet",
+            "-q",
+            action="store_true",
+            help="Do not output anything and only mark as read",
+        )
+        p.add_argument(
+            "item",
+            type=str,
+            nargs="*",
+            help="Ordinal or ID of the news item(s) to read",
+        )
+
+    @classmethod
+    def main(cls, cfg: "GlobalConfig", args: argparse.Namespace) -> int:
+        from .news import do_news_read
+
+        quiet: bool = args.quiet
+        items_strs: list[str] = args.item
+
+        return do_news_read(
+            cfg,
+            quiet,
+            items_strs,
+        )