tenko-plugin-repeater 0.1.0__py3-none-any.whl

tenko_plugin_repeater/__init__.py

@@ -0,0 +1,155 @@
+"""复读机：群友开始复读时，偶尔跟一句，偶尔打断一下。
+
+判定逻辑在 :mod:`.chain`；这里负责把群消息拆成可比较的内容，并把结果发回群里。
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+import aiohttp
+from arclet.entari import BasicConfModel, MessageCreatedEvent, Session, plugin
+from arclet.entari.config import EntariConfig, model_field
+from loguru import logger
+from satori import Emoji, Image, Text
+from satori.element import Custom, Message
+from tenko_api.accounts import online_accounts
+from tenko_api.context import context_from_session
+from tenko_api.features import declare, feature_required
+from tenko_api.perm import Permission
+
+from .chain import Repeater, Said, Settings
+
+
+class RepeaterConfig(BasicConfModel):
+    """对应 config/tenko.toml 中的 ``[plugin_config.repeater]``。"""
+
+    min_times: int = 2
+    """几个不同的人发了同一句之后，才开始考虑复读。"""
+    repeat_probability: float = 0.15
+    """达到 min_times 时跟一句的概率；之后每多一人复读，“不跟”的概率再乘以 (1 - 它)。"""
+    interrupt_probability: float = 0.05
+    """每次考虑时先判断是否打断：文字打乱字序发出，其他内容发一句打断语。"""
+    cooldown_seconds: int = 600
+    """同一个群出声一次后，这么久之内不再出声。"""
+    max_length: int = 100
+    """超过这个字数的消息不参与复读。"""
+    interrupt_lines: list[str] = model_field(
+        default_factory=lambda: ["打断！", "不许复读！", "复读到此为止~"],
+        description="无法打乱字序时，随机挑一句发出。",
+    )
+
+
+plugin.metadata(
+    "复读机",
+    author=["13"],
+    version="0.1.0",
+    description="群友复读时偶尔跟一句，偶尔打断一下。",
+    urls={
+        "homepage": "https://github.com/g1331/tenko-plugins/tree/main/plugins/repeater",
+        "repository": "https://github.com/g1331/tenko-plugins",
+    },
+    config=RepeaterConfig,
+)
+declare(scope="group", default_enabled=True, level=Permission.ActiveGroup)
+
+config = plugin.get_config(RepeaterConfig)
+
+_IMAGE_LIMIT = 4 * 1024 * 1024
+
+
+async def _digest(src: str) -> str | None:
+    """同一张图被不同人发出时地址不同，只能按内容比较；超时或过大就放弃。"""
+
+    try:
+        timeout = aiohttp.ClientTimeout(total=8)
+        async with aiohttp.ClientSession(timeout=timeout) as client:
+            async with client.get(src) as response:
+                if response.status != 200:
+                    return None
+                hasher, size = hashlib.sha256(), 0
+                async for chunk in response.content.iter_chunked(64 * 1024):
+                    size += len(chunk)
+                    if size > _IMAGE_LIMIT:
+                        return None
+                    hasher.update(chunk)
+                return hasher.hexdigest()
+    except (aiohttp.ClientError, TimeoutError, ValueError) as error:
+        logger.debug("复读机拉取图片失败：{}", type(error).__name__)
+        return None
+
+
+repeater = Repeater(
+    Settings(
+        min_times=max(config.min_times, 2),
+        repeat_probability=config.repeat_probability,
+        interrupt_probability=config.interrupt_probability,
+        cooldown_seconds=config.cooldown_seconds,
+        interrupt_lines=tuple(config.interrupt_lines),
+    ),
+    _digest,
+)
+
+
+def _command_prefixes() -> tuple[str, ...]:
+    try:
+        prefixes = EntariConfig.instance.basic.prefix
+    except AttributeError:
+        prefixes = []
+    return tuple(p for p in prefixes if p) or ("/",)
+
+
+def parse(elements: list, user: str, max_length: int) -> Said | None:
+    """拆出可比较的内容；命令、@、引用、长文和混排图片等不参与复读，返回 None。"""
+
+    key: list[str] = []
+    text: list[str] = []
+    send: list = []
+    images: list[str] = []
+    for element in elements:
+        if isinstance(element, Text):
+            key.append(element.text)
+            text.append(element.text)
+            send.append(element)
+        elif isinstance(element, Emoji):
+            key.append(f"<face:{element.id}>")
+            send.append(element)
+        elif isinstance(element, Image):
+            images.append(element.src)
+        elif isinstance(element, Custom) and element.tag == "onebot:mface":
+            attrs = getattr(element, "_attrs", {})
+            emoji = attrs.get("emojiId")
+            if not emoji or not attrs.get("url"):
+                return None
+            key.append(f"<mface:{attrs.get('emojiPackageId')}:{emoji}>")
+            send.append(Image(src=attrs["url"]))  # 发送端不支持商城表情，以图片发回
+        else:
+            return None
+    content = "".join(text).strip()
+    if images:
+        if len(images) > 1 or content or len(key) != len(text):
+            return None  # 只有“单独一张图”才按图片比较
+        return Said(user, None, [Image(src=images[0])], image=images[0])
+    joined = "".join(key).strip()
+    if not joined or len(content) > max_length or content.startswith(_command_prefixes()):
+        return None
+    return Said(user, joined, send, text=content)
+
+
+@plugin.listen(MessageCreatedEvent)
+@feature_required()
+async def on_message(session: Session[MessageCreatedEvent]):
+    ctx = context_from_session(session)
+    if ctx.chat_type != "group":
+        return
+    # 同一个群里的其他 Tenko 账号发的消息不算群友复读。
+    if ctx.user_id in {str(account.self_id) for account in online_accounts()}:
+        return
+    said = parse(list(session.event.message.message), ctx.user_id, config.max_length)
+    if said is None:
+        repeater.forget(ctx.channel_id)
+        return
+    reply = await repeater.feed(ctx.channel_id, said)
+    if reply:
+        # 复读不引用原消息：宿主只给“对触发消息的回复”补引用，包在独立的 <message> 里就会跳过。
+        await session.send([Message(content=reply)])

tenko_plugin_repeater/chain.py

@@ -0,0 +1,122 @@
+"""复读判定：每个群记住最近一串相同的消息，决定跟一句、打断，还是不出声。
+
+这里不碰 Entari：输入是已经拆好的 :class:`Said`，输出是要发出去的元素。
+"""
+
+from __future__ import annotations
+
+import random
+import time
+from collections.abc import Awaitable, Callable, Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+# 拉取图片并返回内容摘要；拉不到时返回 None，这条消息就不会被当成复读。
+Digest = Callable[[str], Awaitable[str | None]]
+
+
+@dataclass(slots=True)
+class Said:
+    """一条可以参与复读的消息。
+
+    ``key`` 是文字、QQ 表情和商城表情拼成的比较键；纯图片消息的 ``key`` 为空，
+    ``image`` 是图片地址，比较时按图片内容判断。``elements`` 是复读时原样发回的元素。
+    """
+
+    user: str
+    key: str | None
+    elements: Sequence[Any]
+    text: str = ""
+    image: str | None = None
+
+
+@dataclass(slots=True)
+class Run:
+    first: Said
+    users: set[str] = field(default_factory=set)
+    acted: bool = False
+
+
+@dataclass(slots=True)
+class Settings:
+    min_times: int = 2
+    repeat_probability: float = 0.15
+    interrupt_probability: float = 0.05
+    cooldown_seconds: float = 600
+    interrupt_lines: Sequence[str] = ("打断！",)
+
+
+class Repeater:
+    def __init__(
+        self,
+        settings: Settings,
+        digest: Digest,
+        *,
+        rng: random.Random | None = None,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self.settings = settings
+        self.digest = digest
+        self.rng = rng or random.Random()
+        self.clock = clock
+        self.runs: dict[str, Run] = {}
+        self.cooldown_until: dict[str, float] = {}
+        self._digests: dict[str, str | None] = {}
+
+    def forget(self, group: str) -> None:
+        """不能参与复读的消息（命令、长文、转发等）把这一串断开。"""
+
+        self.runs.pop(group, None)
+
+    async def feed(self, group: str, said: Said) -> list[Any] | None:
+        """记下一条消息；需要出声时返回要发送的元素。"""
+
+        run = self.runs.get(group)
+        if run is None or not await self._same(run.first, said):
+            self.runs[group] = Run(said, {said.user})
+            return None
+        if said.user in run.users:
+            return None  # 同一个人连发不算复读
+        run.users.add(said.user)
+        if run.acted or self.clock() < self.cooldown_until.get(group, 0):
+            return None
+        times = len(run.users)
+        if times < self.settings.min_times:
+            return None
+        reply = self._decide(run.first, times)
+        if reply is not None:
+            run.acted = True
+            self.cooldown_until[group] = self.clock() + self.settings.cooldown_seconds
+        return reply
+
+    def _decide(self, said: Said, times: int) -> list[Any] | None:
+        s = self.settings
+        if self.rng.random() < s.interrupt_probability:
+            return self._interrupt(said)
+        # 每多一条复读，“不跟”的概率乘以 (1 - p)：复读越久越容易跟，起步很克制。
+        chance = 1 - (1 - s.repeat_probability) ** (times - s.min_times + 1)
+        if self.rng.random() < chance:
+            return list(said.elements)
+        return None
+
+    def _interrupt(self, said: Said) -> list[Any]:
+        chars = list(said.text)
+        if said.key is not None and len(set(chars)) >= 3:
+            shuffled = chars[:]
+            while shuffled == chars:
+                self.rng.shuffle(shuffled)
+            return ["".join(shuffled)]
+        return [self.rng.choice(list(self.settings.interrupt_lines) or ["打断！"])]
+
+    async def _same(self, a: Said, b: Said) -> bool:
+        if a.image is None or b.image is None:
+            return a.image is None and b.image is None and a.key == b.key
+        first, second = await self._digest(a.image), await self._digest(b.image)
+        return first is not None and first == second
+
+    async def _digest(self, src: str) -> str | None:
+        if src not in self._digests:
+            if len(self._digests) >= 64:  # 只需要记住最近几张图
+                self._digests.pop(next(iter(self._digests)))
+            self._digests[src] = await self.digest(src)
+        return self._digests[src]

tenko_plugin_repeater-0.1.0.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.5
+Name: tenko-plugin-repeater
+Version: 0.1.0
+Summary: Tenko 复读机：群友复读时偶尔跟一句，偶尔打断一下
+Project-URL: Homepage, https://github.com/g1331/tenko-plugins/tree/main/plugins/repeater
+Project-URL: Repository, https://github.com/g1331/tenko-plugins
+License-Expression: GPL-3.0-only
+Requires-Python: <3.14,>=3.11
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: tenko-api<0.3,>=0.2
+Description-Content-Type: text/markdown
+
+# tenko-plugin-repeater
+
+[Tenko](https://github.com/g1331/tenko) 的复读机插件。群友开始复读时，Tenko 偶尔跟着复读一句，偶尔打断一下。
+
+```text
+群友 A：草
+群友 B：草
+Tenko： 草
+```
+
+## 规则
+
+- 连续出现相同内容、并且来自不同的人，才算一串复读；同一个人连发不算。
+- 达到 2 个人后，每多一个人复读就判断一次：先以 5% 的概率打断，否则按递增的概率跟一句。
+  跟读概率从 15% 起步，第 3 个人约 28%，第 4 个人约 39%。
+- 每串复读最多出声一次，出声后这个群冷却 10 分钟。
+- 打断时，文字会被打乱字序发出，其他内容换成一句打断语。
+- 支持文字、QQ 表情、商城表情和单张图片。图片按内容比较，只在连续两条都是单张图片时才会下载比对。
+- 命令、@ 或引用回复的消息、超过 100 字的消息，以及 Tenko 其他账号发的消息都不参与。
+
+插件在新群默认开启，群管理员可以用 `/关闭 复读机` 关掉。
+
+## 安装
+
+在 WebUI 的插件市场安装，或由 Master 在聊天里 `/安装插件 repeater`，启用后重启生效。
+
+## 配置
+
+`config/tenko.toml` 的 `[plugin_config.repeater]`，也可以在 WebUI 的插件配置里修改：
+
+| 配置 | 默认值 | 说明 |
+| --- | --- | --- |
+| `min_times` | `2` | 几个不同的人发了同一句后开始考虑复读，最小为 2 |
+| `repeat_probability` | `0.15` | 达到 `min_times` 时跟一句的概率；之后每多一人，“不跟”的概率再乘以 (1 - 它) |
+| `interrupt_probability` | `0.05` | 每次考虑时打断的概率 |
+| `cooldown_seconds` | `600` | 同一个群出声后的冷却时间 |
+| `max_length` | `100` | 超过这个字数的消息不参与 |
+| `interrupt_lines` | `["打断！", "不许复读！", "复读到此为止~"]` | 无法打乱字序时随机挑一句 |

tenko_plugin_repeater-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+tenko_plugin_repeater/__init__.py,sha256=TD-tlLdcQdpPmIChtGX5Ytyvw0vCRil40Gbj-y6OLZg,5982
+tenko_plugin_repeater/chain.py,sha256=8TgOccsHsJBMUPk4iNSh6s1yiITgDydzpOSdgkH1zEA,4344
+tenko_plugin_repeater-0.1.0.dist-info/METADATA,sha256=fuatb1msOgsyDD2Ui4UpFH0PJthoDTtrlL_SYqzm3g8,2357
+tenko_plugin_repeater-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+tenko_plugin_repeater-0.1.0.dist-info/entry_points.txt,sha256=Mv10JMLLdwl3cJ40me2B71E1OkWeskHJ0qUem5c-5sA,49
+tenko_plugin_repeater-0.1.0.dist-info/RECORD,,

tenko_plugin_repeater-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

tenko_plugin_repeater-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[tenko.plugins]
+repeater = tenko_plugin_repeater