nonebot-plugin-shitbot 0.1.0__py3-none-any.whl

nonebot_plugin_shitbot/__init__.py

@@ -0,0 +1,21 @@
+from os import environ
+
+# During unit tests, skip importing the heavy handler/command modules.
+# These modules pull in the entire NoneBot stack and external plugins
+# (e.g. nonebot_plugin_htmlrender → get_driver()).  Pure-logic modules
+# like parser.py should remain importable without a running NoneBot.
+if not environ.get("PYTEST_RUNNING"):
+    from nonebot.plugin import PluginMetadata
+
+    from . import handlers  # noqa: F401
+    from .config import ShitBotConfig
+
+    __plugin_meta__ = PluginMetadata(
+        name="shitbot",
+        description="个人自用自己手搓框架的多功能bot, 还在开发中",
+        usage="发送/help 查看帮助信息",
+        type="application",
+        homepage="https://github.com/Cmd-GZ/nonebot-plugin-shitbot",
+        config=ShitBotConfig,
+        supported_adapters={"~onebot.v11"},
+    )

nonebot_plugin_shitbot/aux.py

@@ -0,0 +1,71 @@
+import shutil
+from pathlib import Path
+from typing import Any
+
+import httpx
+from nonebot.log import logger
+
+from .config import config
+
+
+def validate_schema(data: Any, schema: Any) -> bool:
+    if schema is Any:
+        return True
+    if schema is None:
+        return False
+    if isinstance(schema, type):
+        return isinstance(data, schema)
+    if isinstance(schema, dict):
+        if not isinstance(data, dict):
+            return False
+        return all(
+            key in data and validate_schema(data[key], subschema)
+            for key, subschema in schema.items()
+        )
+    if isinstance(schema, list):
+        if not isinstance(data, list):
+            return False
+        length = len(schema)
+        if length < 1:
+            return False
+        return all(
+            validate_schema(item, schema[i if i < length else -1])
+            for i, item in enumerate(data)
+        )
+    return False
+
+
+async def rm_path(path: Path):
+    if not path.exists():
+        return
+    if path.is_dir():
+        shutil.rmtree(path)
+    if path.is_file():
+        path.unlink()
+
+
+async def rm_cache(group_id: str, user_id: str, pid: str):
+    cache_path = config.cache / group_id / user_id / pid
+    await rm_path(cache_path)
+    logger.info(f"已删除缓存: {cache_path}")
+
+
+async def stuff_download(
+    client: httpx.AsyncClient,
+    url: str | httpx.URL,
+    output_path: Path,
+    *,
+    referer: str | None = None,
+):
+    try:
+        headers = {"Referer": referer} if referer is not None else {}
+        async with client.stream(
+            "GET", url, headers=headers, follow_redirects=True
+        ) as resp:
+            resp.raise_for_status()
+            with open(output_path, "wb") as f:
+                async for chunk in resp.aiter_bytes():
+                    f.write(chunk)
+    except Exception as e:
+        logger.error(f"下载 {url} 失败: {e}")
+        raise

nonebot_plugin_shitbot/command.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent
+
+from .msgutils import send_msg
+from .parser import BotArgParser
+from .permissions import permissions
+
+if TYPE_CHECKING:
+    from .session import BotSession
+
+
+# Base class of all the commands
+class BotCommand:
+    # class fields:
+    #    _name: command name
+    #    _sentinel: used to prevent from calling __init__ directly
+    # fields:
+    #    _bot: bot
+    #    _session: the command's session
+    #    _argv: current arguments of the command, which is also represented as the command's state
+    #    _parser: arguments parser used to parse arguments
+    #    _pid: command's id in its session
+    _argv: list[str] | None
+    _sentinel = object()
+    _name = "otherwise"
+
+    # Use make() instead of this
+    def __init__(self, bot: Bot, session: BotSession, *, _pid: int, _internal=None):
+        if _internal is not self._sentinel:
+            raise TypeError("Please use BotCommand.make() instead of BotCommand()")
+        self._bot = bot
+        self._session = session
+        self._argv = None
+        self._parser = self._init_parser()
+        self._pid = _pid
+        session.commands[_pid] = self
+
+    @classmethod
+    def make(
+        cls, bot: Bot, session: BotSession, *, _pid: int | None = None
+    ) -> BotCommand | None:
+        if _pid is None:
+            _pid = session.curpid
+        if session.commands.get(_pid):
+            return None
+        return cls(bot, session, _pid=_pid, _internal=cls._sentinel)
+
+    @classmethod
+    def get_name(cls):
+        return cls._name
+
+    @property
+    def bot(self):
+        return self._bot
+
+    @property
+    def session(self):
+        return self._session
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def argv(self):
+        return self._argv
+
+    @property
+    def pid(self):
+        return self._pid
+
+    def _init_parser(self):
+        return BotArgParser()
+
+    async def _send_format_error(self):
+        tip = f"命令格式错误:\n{self._parser.err}\n"
+        tip += f"输入 /help {self.name} 查看使用方法."
+        await self.send_msg(tip)
+
+    # Judge if the arguments are legal based on the parser and send msg if it's illegal
+    async def _legal_case(self, argv: list[str]):
+        if self._parser.is_valid(argv):
+            return True
+        await self._send_format_error()
+        return False
+
+    async def _guard_state(self):
+        if self._argv is not None:
+            if (
+                self._session is None
+                or (command := self._session.commands.get(self._pid)) is None
+            ):
+                return False
+            tip = "错误：会话被占用\n"
+            tip += f"命令 {command.name} 正在运行，进行下一步前请先终止它或等待其完成。"
+            await self.send_msg(tip)
+            return False
+        return True
+
+    async def send_msg(
+        self,
+        msg: str | Message,
+        *,
+        group_id: str | None = None,
+        user_id: str | None = None,
+    ):
+        if not self.session:
+            return
+        gid, uid = group_id, user_id
+        if gid is None:
+            gid = self.session.group_id
+        if uid is None:
+            uid = self.session.user_id
+        if gid == "public":
+            return
+        if gid == "private":
+            gid = None
+            uid = int(uid)
+        else:
+            gid = int(gid)
+            uid = None
+        await send_msg(bot=self.bot, group_id=gid, user_id=uid, msg=msg)
+
+    def _check_perm(self, entry_name: str):
+        if not self.session:
+            return False
+        return permissions.check_permission(
+            entry_name, self.session.group_id, self.session.user_id
+        )
+
+    async def roger(self, event: MessageEvent):
+        pass
+
+    # Main function
+    async def run(self, args: Message):
+        if not self.session:
+            self.unlock()
+            return
+        if not self._check_perm("otherwise"):
+            self.unlock()
+            return
+        await self.send_msg("无效命令，请输入/help获取帮助。")
+        self.unlock()
+
+    # Disconnect with the session, you should call in run() before return
+    def unlock(self):
+        if self._session is None:
+            return
+        self._session.commands.pop(self._pid, None)
+        self._session.release()
+        self._session = None

nonebot_plugin_shitbot/commands/__init__.py

@@ -0,0 +1,27 @@
+from ..command import BotCommand
+from .advrandpic_cmd import BotCommandAdvrandpic
+from .autoreply_cmd import BotCommandAutoreply
+from .autoreply_main_cmd import BotCommandAutoReplyMain
+from .convert_cmd import BotCommandConvert
+from .help_cmd import BotCommandHelp
+from .md2pic_cmd import BotCommandMd2pic
+from .perm_cmd import BotCommandPerm
+from .pixiv_cmd import BotCommandPixiv
+from .randpic_cmd import BotCommandRandpic
+from .session_cmd import BotCommandSession
+from .shitpost_cmd import BotCommandShitpost
+
+__all__ = [
+    "BotCommand",
+    "BotCommandAdvrandpic",
+    "BotCommandAutoReplyMain",
+    "BotCommandAutoreply",
+    "BotCommandConvert",
+    "BotCommandHelp",
+    "BotCommandMd2pic",
+    "BotCommandPerm",
+    "BotCommandPixiv",
+    "BotCommandRandpic",
+    "BotCommandSession",
+    "BotCommandShitpost",
+]

nonebot_plugin_shitbot/commands/advrandpic_cmd.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import httpx
+from nonebot.adapters.onebot.v11 import Bot, Message, MessageSegment
+from nonebot.log import logger
+
+from ..command import BotCommand
+from ..parser import BotArgParser
+
+if TYPE_CHECKING:
+    from ..session import BotSession
+
+
+class BotCommandAdvrandpic(BotCommand):
+    _name = "advrandpic"
+
+    def __init__(self, bot: Bot, session: BotSession, *, _pid: int, _internal=None):
+        super().__init__(bot, session, _pid=_pid, _internal=_internal)
+        self._r18 = 0
+        self._num = 1
+        self._tag = None
+        self._size = "regular"
+
+    def _init_parser(self):
+        parser = BotArgParser()
+        parser.set_rule(max=0)
+        parser.add_opt(
+            "-r", required=True, choice=["off", "on", "only"], default=["off"]
+        )
+        parser.add_opt(
+            "-s", required=True, choice=["original", "regular"], default=["regular"]
+        )
+        parser.add_opt("-t", required=True)
+        parser.add_opt("-n", required=True, type=int, default=[1])
+        return parser
+
+    async def run(self, args: Message):
+        if not self.session:
+            return
+
+        new_argv = args.extract_plain_text().strip().split()
+        if not await self._legal_case(new_argv):
+            if self._argv is None:
+                self.unlock()
+            return
+
+        if not await self._guard_state():
+            return
+
+        self._argv = new_argv
+        self._parser.parse_argv(self._argv)
+
+        r18 = self._parser.opts_value["-r"][0]
+
+        if r18 == "off":
+            self._r18 = 0
+        if r18 == "on":
+            self._r18 = 2
+        if r18 == "only":
+            self._r18 = 1
+
+        tags = self._parser.opts_value["-t"]
+        if len(tags) > 0:
+            self._tag = tags[0].split("&")
+
+        self._num = self._parser.opts_value["-n"][0]
+        self._num = max(self._num, 1)
+        self._num = min(self._num, 10)
+        if not self._check_perm("multisetu"):
+            self._num = 1
+
+        self._size = self._parser.opts_value["-s"][0]
+
+        if not self._check_perm("advrandpic"):
+            await self.send_msg("权限不足")
+            self.unlock()
+            return
+
+        if self._r18 and not self._check_perm("nsfw"):
+            await self.send_msg("权限不足")
+            self.unlock()
+            return
+
+        api = "https://api.lolicon.app/setu/v2"
+        payload: dict[str, Any] = {
+            "r18": self._r18,
+            "num": self._num,
+            "size": self._size,
+        }
+        if self._tag is not None:
+            payload["tag"] = self._tag
+        headers = {"Content-Type": "application/json"}
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(api, headers=headers, json=payload)
+        if response.status_code != 200:
+            logger.error(f"api调用失败, 状态码{response.status_code}")
+            self.unlock()
+            return
+
+        data = response.json()
+
+        if len(data["data"]) < self._num:
+            await self.send_msg(f"未找到指定数量的图片，仅找到 {len(data['data'])} 张")
+
+        for pic in data["data"]:
+            pid = str(pic["pid"])
+            title = pic["title"]
+            author = pic["author"]
+            url = pic["urls"][self._size]
+            text = f"标题: {title}\n作者: {author}\nPID:  {pid}"
+            try:
+                msg = Message(
+                    [
+                        MessageSegment("text", {"text": text}),
+                        MessageSegment("image", {"url": url}),
+                    ]
+                )
+                msg[0].data["summary"] = "我的新自拍喵[图片]"
+                await self.send_msg(msg)
+                logger.info("发送图片成功")
+            except Exception as e:
+                logger.error(f"发送图片失败: {e}")
+                text += f"\n图片发送失败, 大概率被河蟹了, 请尝试私聊使用该命令\n{e}"
+                await self.send_msg(text)
+
+        self.unlock()

nonebot_plugin_shitbot/commands/autoreply_cmd.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from nonebot.adapters.onebot.v11 import Bot, Message
+
+from ..command import BotCommand
+from ..parser import BotArgParser
+from ..session import BotSession
+from .autoreply_main_cmd import BotCommandAutoReplyMain
+
+
+class BotCommandAutoreply(BotCommand):
+    def __init__(self, bot: Bot, session: BotSession, *, _pid: int, _internal=None):
+        super().__init__(bot, session, _pid=_pid, _internal=_internal)
+
+    def _init_parser(self):
+        parser = BotArgParser()
+        parser.set_rule(max=0, need_subcmd=True)
+        start = parser.add_subparser("start")
+        stop = parser.add_subparser("stop")
+        start.set_rule(max=0)
+        stop.set_rule(max=0)
+        return parser
+
+    async def run(self, args: Message):
+        if not self.session:
+            return
+        new_argv = args.extract_plain_text().strip().split()
+
+        if not await self._legal_case(new_argv):
+            if self._argv is None:
+                self.unlock()
+            return
+
+        if not await self._guard_state():
+            return
+
+        self._argv = new_argv
+        self._parser.parse_argv(self._argv)
+        subcmd = self._parser.subcmd
+
+        if not self._check_perm("autoreplymanager"):
+            await self.send_msg("权限不足")
+            self.unlock()
+            return
+
+        if subcmd == "start":
+            autoreply_session = BotSession.make("public", "autoreply")
+            main_command = BotCommandAutoReplyMain.make(
+                self.bot, autoreply_session, _pid=autoreply_session.curpid
+            )
+            if main_command is None:
+                await self.send_msg("警告: 自动回复正在运行中")
+            await self.send_msg("自动回复已开启")
+            self.unlock()
+
+        elif subcmd == "stop":
+
+            async def _exe():
+                autoreply_session = BotSession.get_obj("public", "autoreply")
+                if autoreply_session is None:
+                    await self.send_msg("警告: 自动回复未开启")
+                    return
+                main_command = autoreply_session.commands.get(autoreply_session.curpid)
+                if main_command is None:
+                    await self.send_msg("警告: 自动回复未开启")
+                    return
+                main_command.unlock()
+
+            await _exe()
+            await self.send_msg("自动回复已关闭")
+            self.unlock()

nonebot_plugin_shitbot/commands/autoreply_main_cmd.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from nonebot.adapters.onebot.v11 import Bot, Message, MessageEvent, MessageSegment
+
+from ..command import BotCommand
+from ..config import config
+
+if TYPE_CHECKING:
+    from ..session import BotSession
+
+
+# Simple auto reply, just for fun :). May be further reconstructed in future.
+class BotCommandAutoReplyMain(BotCommand):
+    _name = "autoreply_main"
+
+    def __init__(self, bot: Bot, session: BotSession, *, _pid: int, _internal=None):
+        super().__init__(bot, session, _pid=_pid, _internal=_internal)
+
+    async def roger(self, event: MessageEvent):
+        group_id = str(getattr(event, "group_id", "private"))
+        if event.message_type == "private":
+            group_id = "private"
+        user_id = str(event.user_id)
+
+        for seg in event.get_message():
+            if seg.type != "text":
+                continue
+            text = seg.data.get("text", "")
+            cleaned_text = (
+                text.replace("!", "")
+                .replace(" ", "")
+                .replace("！", "")
+                .replace("w", "")
+                .replace("我", "")
+            )
+            if cleaned_text in [
+                "csn",
+                "草死你",
+                "操死你",
+                "🌿死你",
+                "艹死你",
+                "zjsncsn",
+            ]:
+                wcsn_path = config.client_base / "data" / "wcsn.jpg"
+                msg = Message(MessageSegment.image(f"file://{wcsn_path}"))
+                msg[0].data["sub_type"] = 1
+                msg[0].data["summary"] = "喵呜~"
+                await self.send_msg(msg, group_id=group_id, user_id=user_id)
+                return
+            cleaned = text.replace("?", "").replace(" ", "").replace("？", "")
+            if cleaned in ["这是你吗", "zsnm", "是你吗"]:
+                zsnm_path = config.client_base / "data" / "zsnm.jpg"
+                msg = Message(
+                    [
+                        MessageSegment.image(f"file://{zsnm_path}"),
+                        MessageSegment.text("是我。"),
+                    ]
+                )
+                msg[0].data["sub_type"] = 1
+                msg[0].data["summary"] = "喵呜~"
+                await self.send_msg(msg, group_id=group_id, user_id=user_id)
+                return
+
+    async def run(self, args: Message):
+        return