nonebot-plugin-picmenu-next 0.1.0__py3-none-any.whl

nonebot_plugin_picmenu_next/__init__.py

@@ -0,0 +1,33 @@
+# ruff: noqa: E402
+
+from nonebot import get_driver
+from nonebot.plugin import PluginMetadata, inherit_supported_adapters, require
+
+require("nonebot_plugin_alconna")
+require("nonebot_plugin_htmlrender")
+
+from . import __main__ as __main__
+from .config import ConfigModel
+from .data_source import refresh_infos
+from .templates import load_builtin_templates
+
+__version__ = "0.1.0"
+__plugin_meta__ = PluginMetadata(
+    name="PicMenu Next",
+    description="新一代的图片帮助插件",
+    usage="发送“帮助”查看所有所有插件功能",
+    type="application",
+    homepage="https://github.com/lgc-NB2Dev/nonebot-plugin-picmenu-next",
+    config=ConfigModel,
+    supported_adapters=inherit_supported_adapters("nonebot_plugin_alconna"),
+    extra={"License": "MIT", "Author": "LgCookie"},
+)
+
+load_builtin_templates()
+
+driver = get_driver()
+
+
+@driver.on_startup
+async def _():
+    await refresh_infos()

nonebot_plugin_picmenu_next/__main__.py

@@ -0,0 +1,203 @@
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Optional, TypeVar
+
+from arclet.alconna import Alconna, Arg, Args, CommandMeta, Option, store_true
+from loguru import logger
+from nonebot.adapters import Bot as BaseBot, Event as BaseEvent
+from nonebot.permission import SUPERUSER
+from nonebot_plugin_alconna import Query, on_alconna
+from nonebot_plugin_alconna.uniseg import UniMessage
+from thefuzz import process
+
+from .config import config
+from .data_source import get_infos
+from .data_source.mixin import resolve_detail_mixin, resolve_main_mixin
+from .data_source.models import PinyinChunkSequence, PMDataItem, PMNPluginInfo
+from .templates import detail_templates, func_detail_templates, index_templates
+
+RES_DIR = Path(__file__).parent / "res"
+TIP_IMG_PATH = RES_DIR / "gan_shen_me.jpg"
+
+alc = Alconna(
+    "help",
+    Args(
+        Arg("plugin?", str, notice="插件序号或名称"),
+        Arg("function?", str, notice="插件功能序号或名称"),
+    ),
+    Option(
+        "-H|--show-hidden",
+        action=store_true,
+        help_text="显示隐藏的插件",
+    ),
+    meta=CommandMeta(
+        description="新一代的图片帮助插件",
+        author="LgCookie",
+    ),
+)
+m_cls = on_alconna(
+    alc,
+    aliases={"帮助", "菜单"},
+    skip_for_unmatch=False,
+    auto_send_output=True,
+    use_cmd_start=True,
+)
+
+
+def get_name_similarities(
+    query: str,
+    query_pinyin: str,
+    choices: list[str],
+    choices_pinyin: list[str],
+    raw_weight: float = 0.6,
+    pinyin_weight: float = 0.4,
+) -> list[float]:
+    raw_scores = [x[1] for x in process.extractWithoutOrder(query, choices)]
+    pinyin_scores = [
+        x[1] for x in process.extractWithoutOrder(query_pinyin, choices_pinyin)
+    ]
+    similarities = [
+        raw_weight * raw + pinyin_weight * pinyin
+        for raw, pinyin in zip(raw_scores, pinyin_scores)
+    ]
+    logger.opt(lazy=True).debug(
+        "Query: {}, similarities:\n{}",
+        lambda: f"{query} ({query_pinyin})",
+        lambda: ";\n".join(
+            (
+                f"{choices[i]} ({choices_pinyin[i]})"
+                f": ({raw} * {raw_weight}) + ({pin} * {pinyin_weight}) = {sim}"
+            )
+            for i, (raw, pin, sim) in sorted(
+                enumerate(zip(raw_scores, pinyin_scores, similarities)),
+                key=lambda x: x[1],
+                reverse=True,
+            )
+        ),
+    )
+    return similarities
+
+
+T = TypeVar("T")
+
+
+def handle_query_index(query: str, infos: Sequence[T]) -> Optional[tuple[int, T]]:
+    if query.isdigit() and query.strip("0"):
+        return (
+            ((i := qn - 1), infos[i])
+            if (1 <= (qn := int(query)) <= len(infos))
+            else None
+        )
+    return None
+
+
+async def query_plugin(
+    infos: list[PMNPluginInfo],
+    query: str,
+    score_cutoff: float = 60,
+) -> Optional[tuple[int, PMNPluginInfo]]:
+    if r := handle_query_index(query, infos):
+        return r
+
+    choices: list[str] = []
+    choices_pinyin: list[str] = []
+    for info in infos:
+        choices.append(info.casefold_name)
+        choices_pinyin.append(info.name_pinyin.casefold_str)
+
+    similarities = get_name_similarities(
+        query.casefold(),
+        PinyinChunkSequence.from_raw(query).casefold_str,
+        choices,
+        choices_pinyin,
+    )
+    i, s = max(enumerate(similarities), key=lambda x: x[1])
+    if s >= score_cutoff:
+        return i, infos[i]
+    return None
+
+
+async def query_func_detail(
+    pm_data: list[PMDataItem],
+    query: str,
+    score_cutoff: float = 60,
+) -> Optional[tuple[int, PMDataItem]]:
+    if r := handle_query_index(query, pm_data):
+        return r
+
+    choices: list[str] = []
+    choices_pinyin: list[str] = []
+    for data in pm_data:
+        choices.append(data.casefold_func)
+        choices_pinyin.append(data.func_pinyin.casefold_str)
+
+    similarities = get_name_similarities(
+        query.casefold(),
+        PinyinChunkSequence.from_raw(query).casefold_str,
+        choices,
+        choices_pinyin,
+    )
+    i, s = max(enumerate(similarities), key=lambda x: x[1])
+    if s >= score_cutoff:
+        return i, pm_data[i]
+    return None
+
+
+@m_cls.handle()
+async def _(
+    bot: BaseBot,
+    ev: BaseEvent,
+    q_plugin: Query[Optional[str]] = Query("~plugin", None),
+    q_function: Query[Optional[str]] = Query("~function", None),
+    q_show_hidden: Query[bool] = Query("~show-hidden.value", default=False),
+):
+    show_hidden = q_show_hidden.result
+    if (
+        show_hidden
+        and config.only_superuser_see_hidden
+        and (not await SUPERUSER(bot, ev))
+    ):
+        await (
+            UniMessage.image(raw=TIP_IMG_PATH.read_bytes())
+            .text("别想看咱藏起来的东西！")
+            .finish(reply_to=True)
+        )
+
+    infos = await resolve_main_mixin(get_infos())
+    if not show_hidden:
+        infos = [x for x in infos if not x.pmn.hidden]
+
+    if not q_plugin.result:
+        m = await index_templates.get()(infos, show_hidden)
+        await m.finish()
+
+    r = await query_plugin(infos, q_plugin.result)
+    if not r:
+        await UniMessage.text("好像没有找到对应插件呢……").finish(reply_to=True)
+    info_index, info = r
+    if not q_function.result:
+        m = await detail_templates.get(
+            info.pmn.template,
+        )(info, info_index, show_hidden)
+        await m.finish()
+
+    info = await resolve_detail_mixin(info)
+    pm_data = info.pm_data
+    if pm_data and (not show_hidden):
+        pm_data = [x for x in pm_data if not x.hidden]
+
+    if not pm_data:
+        await UniMessage.text(
+            f"插件 `{info.name}` 没有详细功能介绍哦",
+        ).finish(reply_to=True)
+
+    r = await query_func_detail(pm_data, q_function.result)
+    if not r:
+        await UniMessage.text(
+            f"好像没有找到插件 `{info.name}` 的对应功能呢……",
+        ).finish(reply_to=True)
+    func_index, func = r
+    m = await func_detail_templates.get(
+        func.template,
+    )(info, info_index, func, func_index, show_hidden)
+    await m.finish()

nonebot_plugin_picmenu_next/config.py

@@ -0,0 +1,20 @@
+from cookit.pyd import model_with_alias_generator
+from nonebot import get_plugin_config
+from pydantic import BaseModel
+
+
+@model_with_alias_generator(lambda x: f"pmn_{x}")
+class ConfigModel(BaseModel):
+    index_template: str = "default"
+    detail_template: str = "default"
+    func_detail_template: str = "default"
+    only_superuser_see_hidden: bool = False
+
+
+config: ConfigModel = get_plugin_config(ConfigModel)
+
+
+def version():
+    from . import __version__
+
+    return __version__

nonebot_plugin_picmenu_next/data_source/__init__.py

@@ -0,0 +1,16 @@
+from nonebot import get_loaded_plugins as _get_loaded_plugins
+
+from .collect import collect_plugin_infos as _collect_plugin_infos
+from .models import PMNPluginInfo as _PMNPluginInfoRaw
+
+_infos: list[_PMNPluginInfoRaw] = []
+
+
+def get_infos() -> list[_PMNPluginInfoRaw]:
+    return _infos
+
+
+async def refresh_infos() -> list[_PMNPluginInfoRaw]:
+    global _infos
+    _infos = await _collect_plugin_infos(_get_loaded_plugins())
+    return _infos

nonebot_plugin_picmenu_next/data_source/collect.py

@@ -0,0 +1,126 @@
+import asyncio
+import importlib
+from collections.abc import Iterable
+from contextlib import suppress
+from functools import lru_cache
+from importlib.metadata import Distribution, PackageNotFoundError, distribution
+from typing import Optional
+
+from cookit.loguru import warning_suppress
+from cookit.pyd import type_validate_python
+from nonebot import logger
+from nonebot.plugin import Plugin
+
+from ..utils import normalize_plugin_name
+from .mixin import chain_mixins, plugin_collect_mixins
+from .models import PMNData, PMNPluginExtra, PMNPluginInfo
+
+
+def normalize_metadata_user(info: str, allow_multi: bool = False) -> str:
+    infos = info.split(",")
+    if not allow_multi:
+        infos = infos[:1]
+    return " & ".join(x.split("<")[0].strip().strip("'\"") for x in infos)
+
+
+@lru_cache
+def get_dist(module_name: str) -> Optional[Distribution]:
+    with warning_suppress(f"Unexpected error happened when getting info of package {module_name}"),\
+        suppress(PackageNotFoundError):  # fmt: skip
+        return distribution(module_name)
+    if "." not in module_name:
+        return None
+    module_name = module_name.rsplit(".", 1)[0]
+    return get_dist(module_name)
+
+
+@lru_cache
+def get_version_attr(module_name: str) -> Optional[str]:
+    with warning_suppress(f"Unexpected error happened when importing {module_name}"),\
+        suppress(ImportError):  # fmt: skip
+        m = importlib.import_module(module_name)
+        if ver := getattr(m, "__version__", None):
+            return ver
+    if "." not in module_name:
+        return None
+    module_name = module_name.rsplit(".", 1)[0]
+    return get_version_attr(module_name)
+
+
+async def get_info_from_plugin(plugin: Plugin) -> PMNPluginInfo:
+    meta = plugin.metadata
+    extra: Optional[PMNPluginExtra] = None
+    if meta:
+        with warning_suppress(f"Failed to parse plugin metadata of {plugin.id_}"):
+            extra = type_validate_python(PMNPluginExtra, meta.extra)
+
+    name = normalize_plugin_name(meta.name if meta else plugin.id_)
+
+    ver = extra.version if extra else None
+    if not ver:
+        ver = get_version_attr(plugin.module_name)
+    if not ver and (dist := get_dist(plugin.module_name)):
+        ver = dist.version
+
+    author = (
+        (" & ".join(extra.author) if isinstance(extra.author, list) else extra.author)
+        if extra
+        else None
+    )
+    if not author and (dist := get_dist(plugin.module_name)):
+        if author := dist.metadata.get("Author") or dist.metadata.get("Maintainer"):
+            author = normalize_metadata_user(author)
+        elif author := dist.metadata.get("Author-Email") or dist.metadata.get(
+            "Maintainer-Email",
+        ):
+            author = normalize_metadata_user(author, allow_multi=True)
+
+    description = (
+        meta.description
+        if meta
+        else (
+            dist.metadata.get("Summary")
+            if (dist := get_dist(plugin.module_name))
+            else None
+        )
+    )
+
+    pmn = (extra.pmn if extra else None) or PMNData()
+    if ("hidden" not in pmn.model_fields_set) and meta and meta.type == "library":
+        pmn = PMNData(hidden=True)
+
+    logger.debug(f"Completed to get info of plugin {plugin.id_}")
+    return PMNPluginInfo(
+        plugin_id=plugin.id_,
+        name=name,
+        author=author,
+        version=ver,
+        description=description,
+        usage=meta.usage if meta else None,
+        pm_data=extra.menu_data if extra else None,
+        pmn=pmn,
+    )
+
+
+async def collect_plugin_infos(plugins: Iterable[Plugin]):
+    async def _get(p: Plugin):
+        with warning_suppress(f"Failed to get plugin info of {p.id_}"):
+            return await get_info_from_plugin(p)
+
+    infos = await asyncio.gather(
+        *(_get(plugin) for plugin in plugins),
+    )
+    infos = [x for x in infos if x]
+
+    async def final_mixin(infos: list[PMNPluginInfo]):
+        return infos
+
+    mixin_chain = chain_mixins(plugin_collect_mixins.data, final_mixin)
+    infos = await mixin_chain(infos)
+
+    infos.sort(key=lambda x: x.name_pinyin)
+    logger.success(f"Collected {len(infos)} plugin infos")
+
+    get_dist.cache_clear()
+    get_version_attr.cache_clear()
+    return infos

nonebot_plugin_picmenu_next/data_source/mixin.py

@@ -0,0 +1,225 @@
+from collections import defaultdict
+from collections.abc import Coroutine, Sequence
+from dataclasses import dataclass
+from typing import Any, Callable, Generic, Optional, TypeVar
+from typing_extensions import Concatenate, ParamSpec, TypeAlias
+
+from cookit import DecoListCollector
+from cookit.loguru.common import warning_suppress
+from nonebot.matcher import MatcherSource
+from nonebot.plugin.on import get_matcher_source
+
+from .models import PMNPluginInfo
+
+T = TypeVar("T")
+K = TypeVar("K")
+V = TypeVar("V")
+
+P = ParamSpec("P")
+
+Co: TypeAlias = Coroutine[Any, Any, T]
+MixinFunc: TypeAlias = Callable[
+    Concatenate[
+        Callable[P, T],
+        P,
+    ],
+    T,
+]
+
+PluginCollectMixinNext: TypeAlias = Callable[
+    [list[PMNPluginInfo]],
+    Co[list[PMNPluginInfo]],
+]
+PluginCollectMixin: TypeAlias = MixinFunc[
+    [list[PMNPluginInfo]],
+    Co[list[PMNPluginInfo]],
+]
+
+SelfMixinNext: TypeAlias = Callable[
+    [PMNPluginInfo],
+    Co[PMNPluginInfo],
+]
+SelfMixin: TypeAlias = MixinFunc[
+    [PMNPluginInfo],
+    Co[PMNPluginInfo],
+]
+
+PluginMixinNext: TypeAlias = Callable[
+    [list[PMNPluginInfo]],
+    Co[list[PMNPluginInfo]],
+]
+PluginMixin: TypeAlias = MixinFunc[
+    [list[PMNPluginInfo]],
+    Co[list[PMNPluginInfo]],
+]
+
+PluginDetailMixinNext: TypeAlias = Callable[
+    [PMNPluginInfo],
+    Co[PMNPluginInfo],
+]
+PluginDetailMixin: TypeAlias = MixinFunc[
+    [PMNPluginInfo],
+    Co[PMNPluginInfo],
+]
+
+
+@dataclass
+class MixinInfo(Generic[T]):
+    func: T
+    priority: int
+    source: Optional[MatcherSource]
+
+
+class MixinCollector(DecoListCollector[MixinInfo[T]]):
+    def __call__(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        priority: int = 5,
+        _depth: int = 0,
+        _matcher_source: Optional[MatcherSource] = None,
+    ):
+        def deco(func: T) -> T:
+            self.data.append(
+                MixinInfo(
+                    func=func,
+                    priority=priority,
+                    source=get_matcher_source(_depth + 1),
+                ),
+            )
+            self.data.sort(key=lambda x: x.priority)
+            return func
+
+        return deco
+
+
+class SelfMixinCollector(defaultdict[str, MixinCollector[T]]):
+    def __init__(self) -> None:
+        super().__init__(MixinCollector)
+
+    def __call__(
+        self,
+        priority: int = 1,
+        _depth: int = 0,
+        _matcher_source: Optional[MatcherSource] = None,
+    ):
+        def deco(f: T) -> T:
+            s = _matcher_source or get_matcher_source()
+            if (not s) or not (pid := s.plugin_id):
+                raise ValueError("Self plugin not found")
+            self[pid](priority, _depth + 1, s)(f)
+            return f
+
+        return deco
+
+
+plugin_collect_mixins: MixinCollector[PluginCollectMixin] = MixinCollector()
+
+self_mixins: SelfMixinCollector[SelfMixin] = SelfMixinCollector()
+self_detail_mixins: SelfMixinCollector[PluginDetailMixin] = SelfMixinCollector()
+
+plugin_mixins = MixinCollector[PluginMixin]()
+plugin_detail_mixins = MixinCollector[PluginDetailMixin]()
+
+
+def format_source_warn_msg(info: MixinInfo) -> str:
+    if (not (s := info.source)) or not s.plugin_id:
+        return "Failed to run mixin from unknown source"
+    return (
+        f"Failed to run mixin from plugin {s.plugin_id}"
+        f" at module {s.module_name or 'unknown'}, line {s.lineno or 'unknown'}"
+    )
+
+
+def chain_mixins(
+    mixins: Sequence[MixinInfo[MixinFunc[P, Co[T]]]],
+    final_mixin: Callable[P, Co[T]],
+) -> Callable[P, Co[T]]:
+    """
+    将一系列中间件函数链接起来，形成一个调用链。
+
+    Args:
+        mixins: 中间件函数列表，每个函数接收下一个调用函数和其他参数。
+        final_mixin: 最终执行的函数，只接收其他参数。
+
+    Returns:
+        链接后的函数，接收与 final_mixin 相同的参数。
+    """
+
+    # 如果没有中间件，直接返回最终函数
+    if not mixins:
+        return final_mixin
+
+    # 从后向前构建调用链
+    chain = final_mixin
+
+    # 使用函数工厂避免闭包中的变量绑定问题
+    def create_wrapper(
+        current_mixin: MixinInfo[MixinFunc[P, Co[T]]],
+        next_chain: Callable[P, Co[T]],
+    ) -> Callable[P, Co[T]]:
+        async def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
+            with warning_suppress(lambda _: format_source_warn_msg(current_mixin)):
+                return await current_mixin.func(next_chain, *args, **kwargs)
+            return await next_chain(*args, **kwargs)
+
+        return wrapped
+
+    # 从后向前应用每个中间件
+    for mixin in reversed(mixins):
+        chain = create_wrapper(mixin, chain)
+
+    return chain
+
+
+async def resolve_main_mixin(infos: list[PMNPluginInfo]):
+    if not infos:
+        return infos
+
+    infos = infos.copy()
+
+    if plugin_mixins.data:
+
+        async def last_external_mixin(infos: list[PMNPluginInfo]):
+            return infos
+
+        external_mixin_chain = chain_mixins(
+            plugin_mixins.data,
+            last_external_mixin,
+        )
+        infos = await external_mixin_chain(infos)
+
+    for i in range(len(infos)):
+        x = infos[i]
+        if (not x.plugin_id) or (x.plugin_id not in self_mixins):
+            continue
+
+        async def last_mixin(info: PMNPluginInfo):
+            return info
+
+        self_mixin_chain = chain_mixins(
+            self_mixins[x.plugin_id].data,
+            last_mixin,
+        )
+        infos[i] = await self_mixin_chain(x)
+
+    return infos
+
+
+async def resolve_detail_mixin(info: PMNPluginInfo):
+    async def last_mixin(info: PMNPluginInfo):
+        return info
+
+    if plugin_detail_mixins.data:
+        mixin_chain = chain_mixins(
+            plugin_detail_mixins.data,
+            last_mixin,
+        )
+        info = await mixin_chain(info)
+
+    if info.plugin_id and info.plugin_id in self_detail_mixins:
+        mixin_chain = chain_mixins(
+            self_detail_mixins[info.plugin_id].data,
+            last_mixin,
+        )
+        info = await mixin_chain(info)
+
+    return info