nonebot-plugin-bililive 2.0.1__py3-none-any.whl

bililive/__init__.py

@@ -0,0 +1,35 @@
+from nonebot.plugin import PluginMetadata
+from nonebot.plugin.manager import PluginLoader
+
+from .compat import patch_httpx_compat
+from .config import Config
+
+patch_httpx_compat()
+
+def bootstrap_plugin(force: bool = False):
+    if force or isinstance(globals()["__loader__"], PluginLoader):
+        from .utils import on_startup
+
+        on_startup()
+
+        from . import plugins  # noqa: F401
+
+
+bootstrap_plugin()
+
+from .version import VERSION, __version__  # noqa: F401
+
+__plugin_meta__ = PluginMetadata(
+    name="BiliLive",
+    description="将B站UP主的动态和直播信息推送至QQ",
+    usage="https://github.com/Akiyy-dev/nonebot-plugin-bililive#readme",
+    homepage="https://github.com/Akiyy-dev/nonebot-plugin-bililive",
+    type="application",
+    config=Config,
+    supported_adapters={"~onebot.v11"},
+    extra={
+        "author": "SK-415",
+        "version": __version__,
+        "priority": 1,
+    },
+)

bililive/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

bililive/cli/__init__.py

@@ -0,0 +1,19 @@
+import click
+
+from .utils import create_env
+
+
+@click.group()
+def main():
+    pass
+
+
+@click.command()
+def run():
+    create_env()
+    from .bot import run
+
+    run()
+
+
+main.add_command(run)

bililive/cli/bot.py

@@ -0,0 +1,38 @@
+import sys
+from os import path
+
+import nonebot
+from nonebot.adapters.onebot.v11 import Adapter
+from nonebot.log import default_format, logger
+
+nonebot.init()
+driver = nonebot.get_driver()
+driver.register_adapter(Adapter)
+app = nonebot.get_asgi()
+
+# 删除插件缓存导入，否则 nonebot 导入时会忽略
+for module_name in (
+    "nonebot_plugin_bililive",
+    "bililive",
+):
+    sys.modules.pop(module_name, None)
+nonebot.load_plugin("nonebot_plugin_bililive")
+
+# Modify some config / config depends on loaded configs
+#
+# config = nonebot.get_driver().config
+# do something...
+
+logger.add(
+    path.join("log", "error.log"),
+    rotation="00:00",
+    retention="1 week",
+    diagnose=False,
+    level="ERROR",
+    format=default_format,
+    encoding="utf-8",
+)
+
+
+def run():
+    nonebot.run(app="bililive.cli.bot:app")

bililive/cli/utils.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+
+import click
+import dotenv
+
+env = {
+    "HOST": "127.0.0.1",
+    "PORT": "8080",
+    "SECRET": "",
+    "ACCESS_TOKEN": "",
+    "SUPERUSERS": [],
+    "COMMAND_START": [""],
+    "BILILIVE_DIR": "./data/",
+}
+
+
+def create_env():
+    file_path = Path("./.env.prod").resolve()
+    if file_path.exists():
+        return
+
+    if any(Path.cwd().iterdir()):
+        print("文件夹不为空，请更换空文件夹后重试")
+        import sys
+
+        sys.exit()
+
+    while True:
+        try:
+            superusers = click.prompt(
+                "主人QQ号 (多个使用空格分开)", default="", show_default=False
+            )
+            superusers = [int(superuser) for superuser in superusers.split()]
+            env["SUPERUSERS"] = superusers
+            break
+        except ValueError:
+            print("输入格式有误，请重新输入")
+
+    with open(".env.prod", "w"):
+        pass
+
+    for key, value in env.items():
+        dotenv.set_key(
+            file_path,
+            key,
+            str(value).replace("'", '"').replace(" ", ""),
+            quote_mode="never",
+        )
+
+
+if __name__ == "__main__":
+    create_env()

bililive/compat.py

@@ -0,0 +1,42 @@
+from collections.abc import Mapping
+from typing import Any
+
+import httpx
+import httpx._types as httpx_types
+
+
+def _normalize_proxy_value(proxies: Any):
+    if proxies is None:
+        return None
+    if isinstance(proxies, Mapping):
+        if "all://" in proxies:
+            return proxies["all://"]
+        for value in proxies.values():
+            if value is not None:
+                return value
+        return None
+    return proxies
+
+
+def patch_httpx_compat():
+    if not hasattr(httpx_types, "ProxiesTypes") and hasattr(httpx_types, "ProxyTypes"):
+        httpx_types.ProxiesTypes = httpx_types.ProxyTypes
+
+    if getattr(httpx.AsyncClient, "__bililive_compat_patch__", False):
+        return
+
+    original_async_client = httpx.AsyncClient
+
+    class CompatAsyncClient(original_async_client):
+        __bililive_compat_patch__ = True
+
+        def __init__(self, *args, proxies=Ellipsis, **kwargs):
+            if proxies is not Ellipsis and "proxy" not in kwargs:
+                kwargs["proxy"] = _normalize_proxy_value(proxies)
+            super().__init__(*args, **kwargs)
+
+    CompatAsyncClient.__name__ = original_async_client.__name__
+    CompatAsyncClient.__qualname__ = original_async_client.__qualname__
+    CompatAsyncClient.__module__ = original_async_client.__module__
+
+    httpx.AsyncClient = CompatAsyncClient

bililive/config.py

@@ -0,0 +1,123 @@
+
+from loguru import logger
+from nonebot import get_driver
+from pydantic import (
+    AliasChoices,
+    BaseModel,
+    ConfigDict,
+    Field,
+    ValidationInfo,
+    field_validator,
+)
+
+
+def compat_field(default, new_name: str, legacy_name: str):
+    return Field(
+        default=default,
+        validation_alias=AliasChoices(new_name, legacy_name),
+    )
+
+
+# 其他地方出现的类似 from .. import config，均是从 __init__.py 导入的 Config 实例
+class Config(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+    fastapi_reload: bool = False
+    bililive_dir: str | None = compat_field(None, "bililive_dir", "haruka_dir")
+    bililive_to_me: bool = compat_field(True, "bililive_to_me", "haruka_to_me")
+    bililive_live_off_notify: bool = compat_field(
+        False,
+        "bililive_live_off_notify",
+        "haruka_live_off_notify",
+    )
+    bililive_proxy: str | None = compat_field(
+        None,
+        "bililive_proxy",
+        "haruka_proxy",
+    )
+    bililive_interval: int = compat_field(10, "bililive_interval", "haruka_interval")
+    bililive_live_interval: int = compat_field(
+        10,
+        "bililive_live_interval",
+        "haruka_live_interval",
+    )
+    bililive_dynamic_interval: int = compat_field(
+        0,
+        "bililive_dynamic_interval",
+        "haruka_dynamic_interval",
+    )
+    bililive_dynamic_at: bool = compat_field(
+        False,
+        "bililive_dynamic_at",
+        "haruka_dynamic_at",
+    )
+    bililive_screenshot_style: str = compat_field(
+        "mobile",
+        "bililive_screenshot_style",
+        "haruka_screenshot_style",
+    )
+    bililive_captcha_address: str = compat_field(
+        "https://captcha-cd.ngworks.cn",
+        "bililive_captcha_address",
+        "haruka_captcha_address",
+    )
+    bililive_captcha_token: str = compat_field(
+        "bililive",
+        "bililive_captcha_token",
+        "haruka_captcha_token",
+    )
+    bililive_browser_ua: str | None = compat_field(
+        None,
+        "bililive_browser_ua",
+        "haruka_browser_ua",
+    )
+    bililive_dynamic_timeout: int = compat_field(
+        30,
+        "bililive_dynamic_timeout",
+        "haruka_dynamic_timeout",
+    )
+    bililive_dynamic_font_source: str = compat_field(
+        "system",
+        "bililive_dynamic_font_source",
+        "haruka_dynamic_font_source",
+    )
+    bililive_dynamic_font: str | None = compat_field(
+        "Noto Sans CJK SC",
+        "bililive_dynamic_font",
+        "haruka_dynamic_font",
+    )
+    bililive_dynamic_big_image: bool = compat_field(
+        False,
+        "bililive_dynamic_big_image",
+        "haruka_dynamic_big_image",
+    )
+    bililive_command_prefix: str = compat_field(
+        "",
+        "bililive_command_prefix",
+        "haruka_command_prefix",
+    )
+
+    @field_validator(
+        "bililive_interval", "bililive_live_interval", "bililive_dynamic_interval"
+    )
+    @classmethod
+    def non_negative(cls, v: int, info: ValidationInfo):
+        """定时器为负返回默认值"""
+        default = cls.model_fields[info.field_name].default
+        return default if v < 1 else v
+
+    @field_validator("bililive_screenshot_style")
+    @classmethod
+    def screenshot_style(cls, v: str):
+        if v != "mobile":
+            logger.warning("截图样式目前只支持 mobile，pc 样式现已被弃用")
+        return "mobile"
+
+
+global_config = get_driver().config
+if hasattr(global_config, "model_dump"):
+    plugin_config = Config.model_validate(global_config.model_dump())
+elif hasattr(global_config, "dict"):
+    plugin_config = Config.model_validate(global_config.dict())
+else:
+    plugin_config = Config.model_validate(global_config)

bililive/database/__init__.py

@@ -0,0 +1 @@
+from .db import DB, dynamic_offset  # noqa: F401

bililive/database/db.py

@@ -0,0 +1,282 @@
+import json
+from pathlib import Path
+
+from nonebot import get_driver
+from nonebot.log import logger
+from packaging.version import Version as version_parser
+from tortoise import Tortoise
+from tortoise.connection import connections
+
+from ..utils import get_path
+from ..version import VERSION as APP_VERSION
+from .models import Group, Sub, User, Version
+
+uid_list = {"live": {"list": [], "index": 0}, "dynamic": {"list": [], "index": 0}}
+dynamic_offset = {}
+
+
+class DB:
+    """数据库交互类，与增删改查无关的部分不应该在这里面实现"""
+
+    @classmethod
+    async def init(cls):
+        """初始化数据库"""
+        config = {
+            "connections": {
+                # "bililive": {
+                #     "engine": "tortoise.backends.sqlite",
+                #     "credentials": {"file_path": get_path("data.sqlite3")},
+                # },
+                "bililive": f"sqlite://{get_path('data.sqlite3')}"
+            },
+            "apps": {
+                "bililive_app": {
+                    "models": ["bililive.database.models"],
+                    "default_connection": "bililive",
+                }
+            },
+        }
+
+        await Tortoise.init(config)
+
+        await Tortoise.generate_schemas()
+        await cls.migrate()
+        await cls.update_uid_list()
+
+    @classmethod
+    async def close(cls):
+        await connections.close_all()
+
+    @classmethod
+    async def get_user(cls, **kwargs):
+        """获取 UP 主信息"""
+        return await User.get(**kwargs).first()
+
+    @classmethod
+    async def get_name(cls, uid) -> str | None:
+        """获取 UP 主昵称"""
+        user = await cls.get_user(uid=uid)
+        if user:
+            return user.name
+        return None
+
+    @classmethod
+    async def add_user(cls, **kwargs):
+        """添加 UP 主信息"""
+        return await User.add(**kwargs)
+
+    @classmethod
+    async def delete_user(cls, uid) -> bool:
+        """删除 UP 主信息"""
+        if await cls.get_sub(uid=uid):
+            # 还存在该 UP 主订阅，不能删除
+            return False
+        await User.delete(uid=uid)
+        return True
+
+    @classmethod
+    async def update_user(cls, uid: int, name: str) -> bool:
+        """更新 UP 主信息"""
+        if await cls.get_user(uid=uid):
+            await User.update({"uid": uid}, name=name)
+            return True
+        return False
+
+    @classmethod
+    async def get_group(cls, **kwargs):
+        """获取群设置"""
+        return await Group.get(**kwargs).first()
+
+    @classmethod
+    async def get_group_admin(cls, group_id) -> bool:
+        """获取指定群权限状态"""
+        group = await cls.get_group(id=group_id)
+        if not group:
+            # TODO 自定义默认状态
+            return True
+        return bool(group.admin)
+
+    @classmethod
+    async def add_group(cls, **kwargs):
+        """创建群设置"""
+        return await Group.add(**kwargs)
+
+    @classmethod
+    async def delete_group(cls, id) -> bool:
+        """删除群设置"""
+        if await cls.get_sub(type="group", type_id=id):
+            # 当前群还有订阅，不能删除
+            return False
+        await Group.delete(id=id)
+        return True
+
+    @classmethod
+    async def set_permission(cls, id, switch) -> bool:
+        """设置指定群组权限"""
+        group = await cls.get_group(id=id)
+        if not group:
+            await cls.add_group(id=id, admin=switch)
+            return True
+        if bool(group.admin) == switch:
+            return False
+        await Group.update({"id": id}, admin=switch)
+        return True
+
+    @classmethod
+    async def get_sub(cls, **kwargs):
+        """获取指定位置的订阅信息"""
+        return await Sub.get(**kwargs).first()
+
+    @classmethod
+    async def get_subs(cls, **kwargs):
+        return await Sub.get(**kwargs)
+
+    @classmethod
+    async def get_push_list(cls, uid, func) -> list[Sub]:
+        """根据类型和 UID 获取需要推送的 QQ 列表"""
+        return await cls.get_subs(uid=uid, **{func: True})
+
+    @classmethod
+    async def get_sub_list(cls, type, type_id) -> list[Sub]:
+        """获取指定位置的推送列表"""
+        return await cls.get_subs(type=type, type_id=type_id)
+
+    @classmethod
+    async def add_sub(cls, *, name, **kwargs) -> bool:
+        """添加订阅"""
+        if not await Sub.add(**kwargs):
+            return False
+        await cls.add_user(uid=kwargs["uid"], name=name)
+        if kwargs["type"] == "group":
+            await cls.add_group(id=kwargs["type_id"], admin=True)
+        await cls.update_uid_list()
+        return True
+
+    @classmethod
+    async def delete_sub(cls, uid, type, type_id) -> bool:
+        """删除指定订阅"""
+        if await Sub.delete(uid=uid, type=type, type_id=type_id):
+            await cls.delete_user(uid=uid)
+            await cls.update_uid_list()
+            return True
+        # 订阅不存在
+        return False
+
+    @classmethod
+    async def delete_sub_list(cls, type, type_id):
+        """删除指定位置的推送列表"""
+        async for sub in Sub.get(type=type, type_id=type_id):
+            await cls.delete_sub(uid=sub.uid, type=sub.type, type_id=sub.type_id)
+        await cls.update_uid_list()
+
+    @classmethod
+    async def set_sub(cls, conf, switch, **kwargs):
+        """开关订阅设置"""
+        return await Sub.update(kwargs, **{conf: switch})
+
+    @classmethod
+    async def get_version(cls):
+        """获取数据库版本"""
+        version = await Version.first()
+        return version_parser(version.version) if version else None
+
+    @classmethod
+    async def migrate(cls):
+        """迁移数据库"""
+        DBVERSION = await cls.get_version()
+        # 新数据库
+        if not DBVERSION:
+            # 检查是否有旧的 json 数据库需要迁移
+            await cls.migrate_from_json()
+            await Version.add(version=str(APP_VERSION))
+            return
+        if DBVERSION != APP_VERSION:
+            # await cls._migrate()
+            await Version.update({}, version=APP_VERSION)
+            return
+
+    @classmethod
+    async def migrate_from_json(cls):
+        """从 TinyDB 的 config.json 迁移数据"""
+        json_path = Path(get_path("config.json"))
+        if not json_path.exists():
+            return
+
+        logger.info("正在从 config.json 迁移数据库")
+        with json_path.open("r", encoding="utf-8") as f:
+            old_db = json.loads(f.read())
+        subs: dict[int, dict] = old_db["_default"]
+        groups: dict[int, dict] = old_db["groups"]
+        for sub in subs.values():
+            await cls.add_sub(
+                uid=sub["uid"],
+                type=sub["type"],
+                type_id=sub["type_id"],
+                bot_id=sub["bot_id"],
+                name=sub["name"],
+                live=sub["live"],
+                dynamic=sub["dynamic"],
+                at=sub["at"],
+            )
+        for group in groups.values():
+            await cls.set_permission(group["group_id"], group["admin"])
+
+        json_path.rename(get_path("config.json.bak"))
+        logger.info("数据库迁移完成")
+
+    @classmethod
+    async def get_uid_list(cls, func) -> list:
+        """根据类型获取需要爬取的 UID 列表"""
+        return uid_list[func]["list"]
+
+    @classmethod
+    async def next_uid(cls, func):
+        """获取下一个要爬取的 UID"""
+        func = uid_list[func]
+        if func["list"] == []:
+            return None
+
+        if func["index"] >= len(func["list"]):
+            func["index"] = 1
+            return func["list"][0]
+        else:
+            index = func["index"]
+            func["index"] += 1
+            return func["list"][index]
+
+    @classmethod
+    async def update_uid_list(cls):
+        """更新需要推送的 UP 主列表"""
+        subs = Sub.all()
+        uid_list["live"]["list"] = list(
+            set([sub.uid async for sub in subs if sub.live])
+        )
+        uid_list["dynamic"]["list"] = list(
+            set([sub.uid async for sub in subs if sub.dynamic])
+        )
+
+        # 清除没有订阅的 offset
+        dynamic_offset_keys = set(dynamic_offset)
+        dynamic_uids = set(uid_list["dynamic"]["list"])
+        for uid in dynamic_offset_keys - dynamic_uids:
+            del dynamic_offset[uid]
+        for uid in dynamic_uids - dynamic_offset_keys:
+            dynamic_offset[uid] = -1
+
+    async def backup(self):
+        """备份数据库"""
+        pass
+
+    @classmethod
+    async def get_login(cls):
+        """获取登录信息"""
+        pass
+
+    @classmethod
+    async def update_login(cls, tokens):
+        """更新登录信息"""
+        pass
+
+
+get_driver().on_startup(DB.init)
+get_driver().on_shutdown(DB.close)

bililive/database/models.py

@@ -0,0 +1,74 @@
+from tortoise.fields.data import BooleanField, CharField, IntField
+from tortoise.models import Model
+
+
+class BaseModel(Model):
+    @classmethod
+    def get_(cls, *args, **kwargs):
+        super().get(*args, **kwargs)
+
+    @classmethod
+    def get(cls, **kwargs):
+        return cls.filter(**kwargs)
+
+    @classmethod
+    async def add(cls, **kwargs):
+        pk_name = cls.describe()["pk_field"]["name"]
+        if pk_name == "id" and pk_name not in kwargs:
+            filters = kwargs
+        else:
+            filters = {pk_name: kwargs[pk_name]}
+        if await cls.get(**filters).exists():
+            return False
+        await cls.create(**kwargs)
+        return True
+
+    @classmethod
+    async def delete(cls, **kwargs):
+        query = cls.get(**kwargs)
+        if await query.exists():
+            await query.delete()
+            return True
+        return False
+
+    @classmethod
+    async def update(cls, q, **kwargs):
+        query = cls.get(**q)
+        if await query.exists():
+            await query.update(**kwargs)
+            return True
+        return False
+
+    class Meta:
+        abstract = True
+
+
+# TODO 自定义默认权限
+class Sub(BaseModel):
+    type = CharField(max_length=10)
+    type_id = IntField()
+    uid = IntField()
+    live = BooleanField()  # default=True
+    dynamic = BooleanField()  # default=True
+    at = BooleanField()  # default=False
+    bot_id = IntField()
+
+
+class User(BaseModel):
+    uid = IntField(pk=True)
+    name = CharField(max_length=20)
+
+
+class Group(BaseModel):
+    id = IntField(pk=True)
+    admin = BooleanField()  # default=True
+
+
+class Version(BaseModel):
+    version = CharField(max_length=30)
+
+
+# class Login(BaseModel):
+#     uid = IntField(pk=True)
+#     data = JSONField()
+#     expireed = IntField()

bililive/libs/__init__.py

@@ -0,0 +1 @@
+from . import dynamic  # noqa