nonebot-plugin-picmenu-next 0.1.0.dev1__tar.gz → 0.1.0.dev2__tar.gz

{nonebot_plugin_picmenu_next-0.1.0.dev1 → nonebot_plugin_picmenu_next-0.1.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-picmenu-next
-Version: 0.1.0.dev1
+Version: 0.1.0.dev2
 Summary: Template plugin project
 Author-Email: LgCookie <lgc2333@126.com>
 License: MIT
@@ -8,10 +8,12 @@ Project-URL: homepage, https://github.com/lgc-NB2Dev/nonebot-plugin-picmenu-next
 Requires-Python: <4.0,>=3.9
 Requires-Dist: nonebot2>=2.4.1
 Requires-Dist: nonebot-plugin-alconna>=0.54.2
-Requires-Dist: cookit[jinja,loguru,nonebot-alconna,nonebot-localstore,pw,pyd]>=0.11.2
+Requires-Dist: cookit[jinja,loguru,nonebot-alconna,nonebot-localstore,pw,pyd]>=0.11.5
 Requires-Dist: pypinyin>=0.54.0
 Requires-Dist: jieba>=0.42.1
 Requires-Dist: thefuzz>=0.22.1
+Requires-Dist: markdown-it-py[plugins]>=3.0.0
+Requires-Dist: pygments>=2.19.1
 Description-Content-Type: text/markdown
 
 <!-- markdownlint-disable MD031 MD033 MD036 MD041 -->

{nonebot_plugin_picmenu_next-0.1.0.dev1 → nonebot_plugin_picmenu_next-0.1.0.dev2}/nonebot_plugin_picmenu_next/__init__.py

@@ -4,7 +4,6 @@ from nonebot import get_driver
 from nonebot.plugin import PluginMetadata, inherit_supported_adapters, require
 
 require("nonebot_plugin_alconna")
-require("nonebot_plugin_waiter")
 require("nonebot_plugin_htmlrender")
 
 from . import __main__ as __main__
@@ -12,7 +11,7 @@ from .config import ConfigModel
 from .data_source import refresh_infos
 from .templates import load_builtin_templates
 
-__version__ = "0.1.0.dev1"
+__version__ = "0.1.0.dev2"
 __plugin_meta__ = PluginMetadata(
     name="PicMenu Next",
     description="新一代的图片帮助插件",
@@ -20,10 +19,7 @@ __plugin_meta__ = PluginMetadata(
     type="application",
     homepage="https://github.com/lgc-NB2Dev/nonebot-plugin-picmenu-next",
     config=ConfigModel,
-    supported_adapters=inherit_supported_adapters(
-        "nonebot_plugin_alconna",
-        "nonebot_plugin_waiter",
-    ),
+    supported_adapters=inherit_supported_adapters("nonebot_plugin_alconna"),
     extra={"License": "MIT", "Author": "LgCookie"},
 )
 

{nonebot_plugin_picmenu_next-0.1.0.dev1 → nonebot_plugin_picmenu_next-0.1.0.dev2}/nonebot_plugin_picmenu_next/__main__.py

@@ -1,5 +1,4 @@
 from collections.abc import Sequence
-from contextlib import suppress
 from typing import Optional, TypeVar
 
 from arclet.alconna import Alconna, Arg, Args, CommandMeta, Option, store_true
@@ -8,12 +7,8 @@ from nonebot_plugin_alconna import Query, on_alconna
 from nonebot_plugin_alconna.uniseg import UniMessage
 from thefuzz import process
 
-from .data_source import (
-    PMDataItem,
-    PMNPluginInfo,
-    get_resolved_infos,
-    transform_to_pinyin,
-)
+from .data_source import get_resolved_infos
+from .data_source.models import PinyinChunkSequence, PMDataItem, PMNPluginInfo
 from .templates import detail_templates, func_detail_templates, index_templates
 
 alc = Alconna(
@@ -49,21 +44,24 @@ def get_name_similarities(
     raw_weight: float = 0.6,
     pinyin_weight: float = 0.4,
 ) -> list[float]:
-    similarities: list[float] = []
-    raw_iter = process.extractWithoutOrder(query, choices)
-    pinyin_iter = process.extractWithoutOrder(query_pinyin, choices_pinyin)
-    with suppress(StopIteration):
-        while True:
-            raw_score = next(raw_iter)[1]
-            pinyin_score = next(pinyin_iter)[1]
-            similarities.append(raw_weight * raw_score + pinyin_weight * pinyin_score)
+    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: {}",
-        lambda: query,
-        lambda: "; ".join(
-            f"{choices[i]}: {s}"
-            for i, s in sorted(
-                enumerate(similarities),
+        "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,
             )
@@ -96,12 +94,12 @@ async def query_plugin(
     choices: list[str] = []
     choices_pinyin: list[str] = []
     for info in infos:
-        choices.append(info.name.casefold())
-        choices_pinyin.append(info.name_pinyin.casefold())
+        choices.append(info.casefold_name)
+        choices_pinyin.append(info.name_pinyin.casefold_str)
 
     similarities = get_name_similarities(
         query.casefold(),
-        transform_to_pinyin(query).casefold(),
+        PinyinChunkSequence.from_raw(query).casefold_str,
         choices,
         choices_pinyin,
     )
@@ -122,12 +120,12 @@ async def query_func_detail(
     choices: list[str] = []
     choices_pinyin: list[str] = []
     for data in pm_data:
-        choices.append(data.func.casefold())
-        choices_pinyin.append(data.func_pinyin.casefold())
+        choices.append(data.casefold_func)
+        choices_pinyin.append(data.func_pinyin.casefold_str)
 
     similarities = get_name_similarities(
         query.casefold(),
-        transform_to_pinyin(query).casefold(),
+        PinyinChunkSequence.from_raw(query).casefold_str,
         choices,
         choices_pinyin,
     )
@@ -145,7 +143,7 @@ async def _(
 ):
     infos = await get_resolved_infos()
     if not q_show_hidden.result:
-        infos = [x for x in infos if not x.pmn_v.hidden]
+        infos = [x for x in infos if not x.pmn.hidden]
 
     if not q_plugin.result:
         m = await index_templates.get()(infos)

{nonebot_plugin_picmenu_next-0.1.0.dev1 → nonebot_plugin_picmenu_next-0.1.0.dev2}/nonebot_plugin_picmenu_next/config.py

@@ -11,3 +11,9 @@ class ConfigModel(BaseModel):
 
 
 config: ConfigModel = get_plugin_config(ConfigModel)
+
+
+def version():
+    from . import __version__
+
+    return __version__

nonebot_plugin_picmenu_next-0.1.0.dev2/nonebot_plugin_picmenu_next/data_source/__init__.py

@@ -0,0 +1,31 @@
+import asyncio
+
+from cookit.loguru import warning_suppress as _warning_suppress
+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 _PMNPluginInfo,
+    PMNPluginInfoRaw 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
+
+
+async def get_resolved_infos() -> list[_PMNPluginInfo]:
+    async def _resolve(p: _PMNPluginInfoRaw):
+        with _warning_suppress(f"Failed to resolve plugin info of {p.name}"):
+            return await _PMNPluginInfo.resolve(p)
+
+    r = await asyncio.gather(*(_resolve(x) for x in _infos))
+    return [v for v in r if v]

nonebot_plugin_picmenu_next-0.1.0.dev2/nonebot_plugin_picmenu_next/data_source/collect.py

@@ -0,0 +1,106 @@
+import asyncio
+from collections.abc import Iterable
+from importlib.metadata import Distribution, distribution
+from typing import Literal, Optional, Union
+
+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 .models import PMNDataRaw, PMNPluginExtra, PMNPluginInfoRaw
+
+
+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)
+
+
+async def get_info_from_plugin(plugin: Plugin) -> PMNPluginInfoRaw:
+    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_)
+
+    _dist: Union[Distribution, None, Literal[False]] = False
+
+    def get_dist() -> Optional[Distribution]:
+        nonlocal _dist
+        if _dist is not False:
+            return _dist
+
+        _dist = None
+        module = plugin.module_name
+        while True:
+            with warning_suppress(
+                f"Failed to get info of package {module}",
+                level="DEBUG",
+                debug_stack=False,
+            ):
+                _dist = distribution(module)
+                return _dist
+            if "." not in module:
+                return None
+            module = module.rsplit(".", 1)[0]
+
+    ver = extra.version if extra else None
+    if not ver:
+        ver = getattr(plugin, "__version__", None)
+    if not ver and (dist := get_dist()):
+        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()):
+        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()) else None)
+    )
+
+    pmn = (extra.pmn if extra else None) or PMNDataRaw()
+    if ("hidden" not in pmn.model_fields_set) and meta and meta.type == "library":
+        pmn = PMNDataRaw(hidden=True)
+
+    logger.debug(f"Completed to get info of plugin {plugin.id_}")
+    obj = PMNPluginInfoRaw(
+        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,
+    )
+    obj.plugin = plugin
+    return obj
+
+
+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]
+    logger.success(f"Collected {len(infos)} plugin infos")
+    infos.sort(key=lambda x: x.name_pinyin)
+    return infos

nonebot_plugin_picmenu_next-0.1.0.dev2/nonebot_plugin_picmenu_next/data_source/models.py

@@ -0,0 +1,191 @@
+import asyncio
+from collections.abc import Awaitable
+from functools import cached_property
+from typing import Any, Optional, Union
+from typing_extensions import Self
+from weakref import ref
+
+from cookit.loguru import warning_suppress
+from cookit.pyd import model_validator, type_dump_python
+from nonebot.plugin import Plugin
+from pydantic import BaseModel, Field, PrivateAttr
+
+from ..utils import call_entrypoint
+from .pinyin import PinyinChunkSequence
+
+
+async def resolve_func_hidden(plugin: Plugin, entrypoint: str) -> bool:
+    """should only be called from event handler,
+    so hidden func can get current bot, event, etc."""
+
+    with warning_suppress(
+        f"Failed to resole hidden status `{entrypoint}` from plugin {plugin.id_}",
+    ):
+        return bool(await call_entrypoint(plugin, entrypoint))
+    return False
+
+
+class PMDataItemRaw(BaseModel):
+    func: str
+    trigger_method: str
+    trigger_condition: str
+    brief_des: str
+    detail_des: str
+
+    # extension properties
+    hidden: Union[bool, str] = Field(default=False, alias="pmn_hidden")
+    template: Optional[str] = Field(default=None, alias="pmn_template")
+
+    @cached_property
+    def casefold_func(self) -> str:
+        return self.func.casefold()
+
+    @cached_property
+    def func_pinyin(self) -> PinyinChunkSequence:
+        return PinyinChunkSequence.from_raw(self.func)
+
+
+class PMDataItem(PMDataItemRaw):
+    hidden: bool = Field(default=False, alias="pmn_hidden")  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    @classmethod
+    async def resolve(cls, plugin: Plugin, data: PMDataItemRaw) -> Self:
+        data_dict: dict = type_dump_python(data, exclude_unset=True)
+        if isinstance((hidden := data_dict.get("pmn_hidden")), str):
+            data_dict["pmn_hidden"] = await resolve_func_hidden(plugin, hidden)
+        ins = cls(**data_dict)
+        ins.casefold_func = data.casefold_func
+        ins.func_pinyin = data.func_pinyin
+        return ins
+
+
+class PMNDataRaw(BaseModel):
+    hidden: Union[bool, str] = False
+    markdown: bool = False
+    template: Optional[str] = None
+
+
+class PMNData(PMNDataRaw):
+    hidden: bool = False  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    @classmethod
+    async def resolve(cls, plugin: Plugin, data: PMNDataRaw) -> Self:
+        data_dict: dict = type_dump_python(data, exclude_unset=True)
+        if isinstance((hidden := data_dict.get("hidden")), str):
+            data_dict["hidden"] = await resolve_func_hidden(plugin, hidden)
+        return cls(**data_dict)
+
+
+class PMNPluginExtra(BaseModel):
+    author: Union[str, list[str], None] = None
+    version: Optional[str] = None
+    menu_data: Optional[list[PMDataItemRaw]] = None
+    pmn: Optional[PMNDataRaw] = None
+
+    @model_validator(mode="before")
+    def normalize_input(cls, values: Any):  # noqa: N805
+        if isinstance(values, PMNPluginExtra):
+            values = type_dump_python(values, exclude_unset=True)
+        if not isinstance(values, dict):
+            raise TypeError(f"Expected dict, got {type(values)}")
+        should_normalize_keys = {x for x in values if x.lower() in {"author"}}
+        for key in should_normalize_keys:
+            value = values[key]
+            del values[key]
+            values[key.lower()] = value
+        return values
+
+
+class PMNPluginInfoRaw(BaseModel):
+    name: str
+    author: Optional[str] = None
+    version: Optional[str] = None
+    description: Optional[str] = None
+    usage: Optional[str] = None
+    pm_data: Optional[list[PMDataItemRaw]] = None
+    pmn: PMNDataRaw = PMNDataRaw()
+
+    _plugin_ref: Optional[ref[Plugin]] = PrivateAttr(None)
+    _resolved_pm_data: Optional[list[PMDataItem]] = PrivateAttr(None)
+
+    @cached_property
+    def casefold_name(self) -> str:
+        return self.name.casefold()
+
+    @cached_property
+    def name_pinyin(self) -> PinyinChunkSequence:
+        return PinyinChunkSequence.from_raw(self.name)
+
+    @property
+    def plugin(self) -> Optional[Plugin]:
+        if self._plugin_ref:
+            return self._plugin_ref()
+        return None
+
+    @plugin.setter
+    def plugin(self, plugin: Plugin):
+        self._plugin_ref = ref(plugin)
+
+    @cached_property
+    def subtitle(self) -> str:
+        return " | ".join(
+            x
+            for x in (
+                f"By {self.author}" if self.author else None,
+                f"v{self.version}" if self.version else None,
+            )
+            if x
+        )
+
+    async def resolve_pm_data(self, plugin: Plugin):
+        if self._resolved_pm_data is not None:
+            return self._resolved_pm_data
+        if not self.pm_data:
+            return None
+
+        async def _ts(x: PMDataItemRaw):
+            with warning_suppress(
+                f"Failed to resolve plugin menu item `{x.func}` of {plugin.id_}",
+            ):
+                return await PMDataItem.resolve(plugin, x)
+
+        self._resolved_pm_data = [
+            x for x in await asyncio.gather(*(_ts(x) for x in self.pm_data)) if x
+        ]
+        return self._resolved_pm_data
+
+
+class PMNPluginInfo(PMNPluginInfoRaw):
+    pmn: PMNData = PMNData()  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    @classmethod
+    async def resolve(
+        cls,
+        data: PMNPluginInfoRaw,
+        plugin: Optional[Plugin] = None,
+    ) -> Self:
+        if (not plugin) and (not (plugin := data.plugin)):
+            raise ValueError("Plugin ref is expired, please manually set")
+
+        data_dict: dict = type_dump_python(data, exclude_unset=True)
+        tasks: list[Awaitable] = []
+
+        if pmn := data_dict.get("pmn"):
+
+            async def _t():
+                v = None
+                with warning_suppress(
+                    f"Failed to resolve PicMenu Next data of {plugin.id_}",
+                ):
+                    v = await PMNData.resolve(plugin, pmn)
+                data_dict["pmn"] = v
+
+            tasks.append(_t())
+
+        await asyncio.gather(*tasks)
+
+        ins = cls(**data_dict)
+        ins.casefold_name = data.casefold_name
+        ins.name_pinyin = data.name_pinyin
+        ins.plugin = plugin
+        return ins

nonebot_plugin_picmenu_next-0.1.0.dev2/nonebot_plugin_picmenu_next/data_source/pinyin.py

@@ -0,0 +1,86 @@
+from collections.abc import Iterable, Iterator, Sequence
+from functools import cached_property
+from typing import NamedTuple, Optional, Union, overload
+from typing_extensions import Self, override
+
+import jieba
+from pypinyin import Style, pinyin
+
+
+class _NotCHNStr(str):
+    __slots__ = ()
+
+
+class PinyinChunk(NamedTuple):
+    is_pinyin: bool
+    text: str
+    tone: int = 0
+
+    @classmethod
+    def from_pinyin_res(cls, text: str) -> Self:
+        is_pinyin = not isinstance(text, _NotCHNStr)
+        tone = 0
+        if is_pinyin:
+            tone = int(text[-1])
+            text = text[:-1]
+        return cls(is_pinyin=is_pinyin, text=text, tone=tone)
+
+    @cached_property
+    def casefold_str(self) -> str:
+        return self.text.casefold()
+
+    def __str__(self):
+        return f"{self.text}{self.tone}" if self.is_pinyin else self.text
+
+
+class PinyinChunkSequence(Sequence[PinyinChunk]):
+    def __init__(self, iterable: Optional[Iterable[PinyinChunk]] = None):
+        self.chunks: tuple[PinyinChunk, ...] = tuple(iterable) if iterable else ()
+
+    @classmethod
+    def from_raw(cls, text: str) -> Self:
+        transformed = pinyin(
+            [x.strip() for x in jieba.lcut(text)],
+            style=Style.TONE3,
+            errors=lambda x: _NotCHNStr(x),
+            neutral_tone_with_five=True,
+        )
+        return cls(PinyinChunk.from_pinyin_res(x[0]) for x in transformed)
+
+    @cached_property
+    def casefold_str(self) -> str:
+        return str(self).casefold()
+
+    def __str__(self):
+        return " ".join(str(x) for x in self)
+
+    def __lt__(self, other: "PinyinChunkSequence"):
+        return self.chunks.__lt__(other.chunks)
+
+    def __gt__(self, other: "PinyinChunkSequence"):
+        return self.chunks.__gt__(other.chunks)
+
+    def __eq__(self, other: object):
+        return (
+            self.chunks.__eq__(other.chunks)
+            if isinstance(other, PinyinChunkSequence)
+            else NotImplemented
+        )
+
+    @override
+    def __iter__(self) -> Iterator[PinyinChunk]:
+        return self.chunks.__iter__()
+
+    @override
+    def __len__(self) -> int:
+        return self.chunks.__len__()
+
+    @overload
+    def __getitem__(self, index: int) -> PinyinChunk: ...
+    @overload
+    def __getitem__(self, index: slice) -> Self: ...
+    @override
+    def __getitem__(self, index: Union[int, slice]):
+        if isinstance(index, slice):
+            return type(self)(self.chunks[index])
+        return self.chunks[index]