tenko-plugin-repeater 0.1.0__tar.gz

tenko_plugin_repeater-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+build/
+.pytest_cache/
+.ruff_cache/
+.tenko/

tenko_plugin_repeater-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,38 @@
+# 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/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "tenko-plugin-repeater"
+version = "0.1.0"
+description = "Tenko 复读机：群友复读时偶尔跟一句，偶尔打断一下"
+readme = "README.md"
+license = "GPL-3.0-only"
+requires-python = ">=3.11,<3.14"
+dependencies = [
+    "tenko-api>=0.2,<0.3",
+    "aiohttp>=3.9",
+]
+
+[project.urls]
+Homepage = "https://github.com/g1331/tenko-plugins/tree/main/plugins/repeater"
+Repository = "https://github.com/g1331/tenko-plugins"
+
+[project.entry-points."tenko.plugins"]
+repeater = "tenko_plugin_repeater"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/tenko_plugin_repeater"]

tenko_plugin_repeater-0.1.0/src/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-0.1.0/src/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/tests/conftest.py

@@ -0,0 +1,36 @@
+"""用真实的 Tenko 宿主加载复读机插件，不启动网络服务。"""
+
+import json
+import os
+from types import SimpleNamespace
+
+import pytest
+import pytest_asyncio
+from arclet.entari import Entari
+from arclet.entari.config import EntariConfig
+from tenko.host.plugins import PluginRuntime
+
+
+@pytest.fixture(scope="session")
+def host(tmp_path_factory):
+    root = tmp_path_factory.mktemp("tenko-host")
+    previous = os.getcwd()
+    os.chdir(root)
+    EntariConfig(root / "entari.yml")
+    Entari(ignore_self_message=True)
+    (root / "state.json").write_text(json.dumps({"enabled": ["repeater"]}))
+    yield SimpleNamespace(root=root)
+    os.chdir(previous)
+
+
+@pytest_asyncio.fixture(scope="session", loop_scope="session")
+async def runtime(host):
+    runtime = PluginRuntime(host.root / "no-builtin", state_file=host.root / "state.json")
+    await runtime.load_all(external_configs={"repeater": {"cooldown_seconds": 60}})
+    yield runtime
+    runtime.unload("repeater")
+
+
+@pytest.fixture(scope="session")
+def module(runtime):
+    return runtime.loaded_plugins["repeater"].module

tenko_plugin_repeater-0.1.0/tests/test_repeater.py

@@ -0,0 +1,144 @@
+import random
+from datetime import datetime
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+from satori import (
+    At,
+    Channel,
+    ChannelType,
+    EventType,
+    Guild,
+    Image,
+    Login,
+    MessageObject,
+    Text,
+    User,
+)
+from satori.element import Custom
+from satori.model import Event, Member
+
+
+class Scripted(random.Random):
+    """按顺序给出 random() 的结果；shuffle 固定为倒序，便于断言。"""
+
+    def __init__(self, *values: float) -> None:
+        super().__init__()
+        self.values = list(values)
+
+    def random(self) -> float:
+        return self.values.pop(0)
+
+    def shuffle(self, x) -> None:
+        x.reverse()
+
+
+@pytest.fixture
+def chain(module):
+    return module.chain
+
+
+def make(chain, rng, *, digest=None, now=None):
+    clock = now or [0.0]
+    return chain.Repeater(
+        chain.Settings(cooldown_seconds=600, interrupt_lines=("打断！",)),
+        digest or AsyncMock(return_value=None),
+        rng=rng,
+        clock=lambda: clock[0],
+    ), clock
+
+
+def said(chain, user, text="草"):
+    return chain.Said(user, text, [text], text=text)
+
+
+async def test_plugin_loads_and_is_on_by_default_in_new_groups(runtime, module):
+    from tenko.host.features import feature_service
+
+    metadata = runtime.loaded_plugins["repeater"].metadata
+    assert metadata.feature_scope == "group"
+    assert "repeater" not in feature_service.plugin_defaults  # 没有声明“新群默认关闭”
+    assert module.config.cooldown_seconds == 60
+
+
+async def test_repeats_once_per_run_ignores_same_user_and_cools_down(chain):
+    # 第 2 人：不打断(0.9)、跟读(0.1 < 0.15)
+    repeater, clock = make(chain, Scripted(0.9, 0.1, 0.9, 0.1))
+    assert await repeater.feed("g", said(chain, "a")) is None
+    assert await repeater.feed("g", said(chain, "a")) is None  # 同一个人不算
+    assert await repeater.feed("g", said(chain, "b")) == ["草"]
+    assert await repeater.feed("g", said(chain, "c")) is None  # 这一串已经出过声
+
+    await repeater.feed("g", said(chain, "a", "好"))
+    assert await repeater.feed("g", said(chain, "b", "好")) is None  # 冷却中
+    clock[0] = 601
+    await repeater.feed("g", said(chain, "a", "行"))
+    assert await repeater.feed("g", said(chain, "b", "行")) == ["行"]
+
+
+async def test_chance_grows_with_each_extra_repeater(chain):
+    # 第 2 人 0.2 > 15% 不跟；第 3 人 0.2 < 1 - 0.85² ≈ 27.75% 跟
+    repeater, _ = make(chain, Scripted(0.9, 0.2, 0.9, 0.2))
+    for user in "ab":
+        assert await repeater.feed("g", said(chain, user)) is None
+    assert await repeater.feed("g", said(chain, "c")) == ["草"]
+
+
+async def test_interrupt_shuffles_text_or_falls_back_to_a_line(chain):
+    # 子类只覆盖 random() 时，choice 也会取一次 random()
+    repeater, clock = make(chain, Scripted(0.01, 0.01, 0.0))
+    await repeater.feed("g", said(chain, "a", "复读机"))
+    assert await repeater.feed("g", said(chain, "b", "复读机")) == ["机读复"]
+    clock[0] = 601
+    await repeater.feed("h", said(chain, "a", "草"))
+    assert await repeater.feed("h", said(chain, "b", "草")) == ["打断！"]
+
+
+async def test_images_compare_by_content_not_url(chain):
+    digest = AsyncMock(side_effect=lambda src: "same")
+    repeater, _ = make(chain, Scripted(0.9, 0.1), digest=digest)
+    first = chain.Said("a", None, ["img1"], image="https://cdn/1")
+    second = chain.Said("b", None, ["img2"], image="https://cdn/2")
+    await repeater.feed("g", said(chain, "a"))
+    await repeater.feed("g", first)
+    digest.assert_not_called()  # 前一条是文字，不用下载
+    assert await repeater.feed("g", second) == ["img1"]
+
+
+def test_parse_skips_commands_mentions_long_text_and_mixed_images(module):
+    parse = module.parse
+    assert parse([Text("/帮助")], "a", 100) is None
+    assert parse([At("1"), Text("草")], "a", 100) is None
+    assert parse([Text("长" * 101)], "a", 100) is None
+    assert parse([Text("看"), Image(src="https://x")], "a", 100) is None
+    mface = Custom("onebot:mface", {"emojiId": "e1", "emojiPackageId": "9", "url": "https://m"})
+    parsed = parse([mface], "a", 100)
+    assert parsed.key == "<mface:9:e1>" and parsed.elements[0].src == "https://m"
+
+
+async def test_listener_sends_the_repeat_to_the_group(module, monkeypatch):
+    monkeypatch.setattr(module.repeater, "rng", Scripted(0.9, 0.1))
+    monkeypatch.setattr(module.repeater, "runs", {})
+    monkeypatch.setattr(module.repeater, "cooldown_until", {})
+    sends = []
+
+    def session(user):
+        event = Event(
+            type=EventType.MESSAGE_CREATED,
+            timestamp=datetime.now(),
+            login=Login(platform="onebot", user=User("10001")),
+            channel=Channel("40001", ChannelType.TEXT),
+            guild=Guild("40001", "群"),
+            member=Member(user=User(user)),
+            user=User(user),
+            message=MessageObject(id=f"m{user}", content="草"),
+        )
+        return SimpleNamespace(
+            event=SimpleNamespace(_origin=event, message=event.message),
+            send=AsyncMock(side_effect=sends.append),
+        )
+
+    await module.on_message.callable_target(session("20001"))
+    await module.on_message.callable_target(session("20002"))
+    assert [str(x) for x in sends[0]] == ["<message>草</message>"]