@sophiacyl/dsh-plugin-waves 0.0.0-stage → 0.1.0-beta.1

package/service/rover/utils/database/models.py

@@ -0,0 +1,80 @@
+from typing import List, Union, Optional
+
+from sqlmodel import Field, Index
+
+from rover.logger import logger
+from rover.models import Message
+from rover.message_models import ButtonType
+
+from .base_models import BaseModel
+
+
+class Subscribe(BaseModel, table=True):
+    __table_args__ = (
+        Index(
+            "ix_subscribe_task_name_uid",
+            "task_name",
+            "uid",
+        ),
+        {"extend_existing": True},
+    )
+
+    WS_BOT_ID: Optional[str] = Field(title="WS机器人ID", default=None)
+    group_id: Optional[str] = Field(title="群ID", default=None, index=True)
+    task_name: str = Field(title="任务名称", default=None, index=True)
+    bot_self_id: str = Field(title="机器人自身ID", default=None)
+    user_type: str = Field(title="发送类型", default=None)
+    extra_message: Optional[str] = Field(title="额外消息", default=None)
+    uid: Optional[str] = Field(title="账户ID", default=None, index=True)
+    extra_data: Optional[str] = Field(title="额外消息2", default=None)
+    msg_id: Optional[str] = Field(title="消息ID", default=None)
+
+    async def send(
+        self,
+        reply: Optional[
+            Union[
+                Message,
+                List[Message],
+                List[str],
+                str,
+                bytes,
+            ]
+        ] = None,
+        option_list: Optional[ButtonType] = None,
+        unsuported_platform: bool = False,
+        sep: str = "\n",
+        command_tips: str = "请输入以下命令之一:",
+        command_start_text: str = "",
+        force_direct: bool = False,
+    ):
+        from rover.gss import gss
+
+        if reply is None:
+            return -1
+
+        user_type = "direct" if force_direct else self.user_type
+        target_id = self.group_id if user_type == "group" else self.user_id
+
+        bot = None
+        if self.WS_BOT_ID:
+            bot = gss.active_bot.get(self.WS_BOT_ID)
+        if bot is None:
+            for _bot in gss.active_bot.values():
+                if getattr(_bot, "bot_id", None) == self.bot_id:
+                    bot = _bot
+                    break
+        if bot is None:
+            bot = next(iter(gss.active_bot.values()), None)
+
+        if bot is None:
+            logger.error(f"[订阅] 无可用连接, 该消息无法发送! task_name={self.task_name}")
+            return -1
+
+        await bot.target_send(
+            reply,
+            user_type,
+            target_id,
+            self.bot_id,
+            self.bot_self_id,
+            "",
+        )

package/service/rover/utils/database/startup.py

@@ -0,0 +1,60 @@
+import importlib
+from typing import List
+
+from sqlmodel import SQLModel
+from sqlalchemy.sql import text
+
+from rover.logger import logger
+
+from . import base_models
+from .base_models import init_database
+
+CORE_DATABASE_MODEL_MODULES = ("rover.utils.database.models",)
+
+# 插件在导入时 extend 本列表, 因此必须是模块级可变 list
+exec_list: List[str] = [
+    "ALTER TABLE Subscribe ADD COLUMN uid TEXT DEFAULT NULL;",
+    "ALTER TABLE Subscribe ADD COLUMN WS_BOT_ID TEXT DEFAULT NULL;",
+    "ALTER TABLE Subscribe ADD COLUMN extra_data TEXT DEFAULT NULL;",
+    "ALTER TABLE Subscribe ADD COLUMN msg_id TEXT DEFAULT NULL;",
+    "CREATE INDEX ix_subscribe_task_name ON Subscribe (task_name);",
+    "CREATE INDEX ix_subscribe_uid ON Subscribe (uid);",
+    "CREATE INDEX ix_subscribe_task_name_uid ON Subscribe (task_name, uid);",
+]
+
+
+def import_database_models() -> None:
+    """导入表模型, 确保 create_all 能看到完整 metadata。"""
+    for module_name in CORE_DATABASE_MODEL_MODULES:
+        try:
+            importlib.import_module(module_name)
+        except Exception as e:
+            logger.warning(f"[数据库] 导入模型模块失败: {module_name}, 跳过对应表创建: {e}")
+
+
+async def create_core_tables() -> None:
+    import_database_models()
+    async with base_models.engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+    logger.info("[数据库] 核心数据库表创建成功!")
+
+
+async def trans_adapter() -> None:
+    async with base_models.async_maker() as session:
+        for _t in exec_list:
+            try:
+                await session.execute(text(_t))
+                await session.commit()
+            except Exception:  # noqa: E722
+                pass
+
+
+async def init_all() -> None:
+    """建库建表并补齐历史列。
+
+    插件模块在导入时会绑定 base_models.engine 并 extend exec_list,
+    因此需要先 await init_database() 再导入插件, 最后调用本函数。
+    """
+    await init_database()
+    await create_core_tables()
+    await trans_adapter()

package/service/rover/utils/download_resource/download_core.py

@@ -0,0 +1,164 @@
+"""资源批量下载。目录索引解析 + 按大小比对增量下载。"""
+
+import asyncio
+import os
+from pathlib import Path
+from typing import Dict, Optional
+from urllib.parse import unquote
+
+import httpx
+from bs4 import BeautifulSoup, Tag
+
+from rover.logger import logger
+
+from .download_file import download
+
+
+async def _get_url(url: str, client: httpx.AsyncClient) -> bytes:
+    try:
+        response = await client.get(url)
+        response.raise_for_status()
+        return response.read()
+    except httpx.HTTPStatusError as exc:
+        logger.warning(f"[资源下载] HTTP 错误: {url} {exc}")
+        return b""
+    except httpx.ConnectError as exc:
+        logger.warning(f"[资源下载] 连接错误: {url} {exc}")
+        return b""
+    except httpx.UnsupportedProtocol as exc:
+        logger.warning(f"[资源下载] 协议不支持: {url} {exc}")
+        return b""
+    except httpx.RequestError as exc:
+        logger.warning(f"[资源下载] 请求错误: {url} {exc}")
+        return b""
+
+
+async def download_atag_file(
+    PLUGIN_RES: str,
+    endpoint: str,
+    EPATH_MAP: Dict[str, Path],
+    client: httpx.AsyncClient,
+    TAG: str,
+    plugin_name: str,
+):
+    TASKS = []
+    url = f"{PLUGIN_RES}/{endpoint}"
+    if not url.endswith("/"):
+        url += "/"
+
+    if endpoint not in EPATH_MAP:
+        # 仅当用户填了尾斜杠时才裁掉, 避免 EPATH_MAP 误匹
+        _endpoint = endpoint[:-1] if endpoint.endswith("/") else endpoint
+        _et = _endpoint.rsplit("/", 1)
+        _e = _et[0]
+        _t = _et[1]
+        if _e in EPATH_MAP:
+            path = EPATH_MAP[_e] / _t
+        else:
+            return
+    else:
+        path = EPATH_MAP[endpoint]
+
+    if not path.exists():
+        path.mkdir(parents=True)
+
+    base_data = await _get_url(url, client)
+    content_bs = BeautifulSoup(base_data, "lxml")
+    pre_data_list = content_bs.find_all("pre")
+    if not pre_data_list:
+        logger.warning(f"{TAG} {endpoint} 目录索引解析失败")
+        return
+    pre_data = pre_data_list[0]
+
+    if not isinstance(pre_data, Tag):
+        logger.warning(f"{TAG} {endpoint} 目录索引解析失败")
+        return
+    data_list = pre_data.find_all("a")
+    size_list = [i for i in content_bs.strings]
+
+    logger.trace(f"{TAG} {endpoint} 共 {len(data_list)} 个条目")
+
+    temp_num = 0
+    size_temp = 0
+    for index, data in enumerate(data_list):
+        if data["href"] == "../":  # type: ignore
+            continue
+        file_url = f"{url}{data['href']}"  # type: ignore
+        name: str = unquote(file_url.split("/")[-1])
+        size = size_list[index * 2 + 6].split(" ")[-1]
+        _size: str = size.replace("\r", "")
+        _size = _size.replace("\n", "")
+
+        if _size == "-" or _size == "-\n":
+            await download_atag_file(
+                PLUGIN_RES,
+                f"{endpoint}/{data['href']}",  # type: ignore
+                EPATH_MAP,
+                client,
+                TAG,
+                plugin_name,
+            )
+            continue
+
+        if _size.isdigit():
+            size = int(_size)
+        else:
+            continue
+
+        file_path = path / name
+
+        if file_path.exists():
+            is_diff = size == os.stat(file_path).st_size
+        else:
+            is_diff = True
+
+        if not file_path.exists() or not os.stat(file_path).st_size or not is_diff:
+            logger.info(f"{TAG} {plugin_name} {endpoint} 下载 {name}")
+            temp_num += 1
+            size_temp += size
+            TASK = asyncio.create_task(download(file_url, path, name, client, TAG))
+            TASKS.append(TASK)
+            if size_temp >= 1500000 or len(TASKS) >= 4:
+                await asyncio.gather(*TASKS)
+                TASKS.clear()
+                size_temp = 0
+    else:
+        await asyncio.gather(*TASKS)
+        TASKS.clear()
+
+    if temp_num == 0:
+        logger.trace(f"{TAG} {endpoint} 无需更新")
+    else:
+        logger.success(f"{TAG} {endpoint} 下载 {temp_num} 个文件完成")
+    temp_num = 0
+
+
+async def download_all_file(
+    plugin_name: str,
+    EPATH_MAP: Dict[str, Path],
+    URL: Optional[str] = None,
+    TAG: Optional[str] = None,
+):
+    # 资源站由调用方测速后给出, 缺失时直接跳过
+    if not URL:
+        logger.warning(f"[资源下载] {plugin_name} 无可用资源站, 跳过")
+        return
+
+    TAG = TAG or "[Unknown]"
+    PLUGIN_RES = f"{URL}/{plugin_name}"
+
+    async with httpx.AsyncClient(timeout=httpx.Timeout(200.0)) as client:
+        n = 0
+        for endpoint in EPATH_MAP:
+            await download_atag_file(
+                PLUGIN_RES,
+                endpoint,
+                EPATH_MAP,
+                client,
+                TAG,
+                plugin_name,
+            )
+            n += 1
+
+        if n == len(EPATH_MAP):
+            logger.success(f"[资源下载] {plugin_name} 资源下载完成")

package/service/rover/utils/download_resource/download_file.py

@@ -0,0 +1,46 @@
+"""资源文件下载。"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Union
+
+import aiofiles
+import httpx
+
+from rover.logger import logger
+
+if TYPE_CHECKING:
+    from aiohttp.client import ClientSession
+
+
+async def download(
+    url: str,
+    path: Path,
+    name: str,
+    sess: Union["ClientSession", httpx.AsyncClient, None] = None,
+    tag: str = "",
+):
+    logger.info(f"{tag} 开始下载: {name}")
+    logger.info(f"{tag} 下载地址: {url}")
+    if sess is None:
+        sess = httpx.AsyncClient()
+
+    try:
+        if isinstance(sess, httpx.AsyncClient):
+            res = await sess.get(url)
+            content = res.read()
+            retcode = res.status_code
+        else:
+            async with sess.get(url) as resp:
+                content = await resp.read()
+                retcode = resp.status
+
+        if retcode == 200:
+            async with aiofiles.open(path / name, "wb") as f:
+                await f.write(content)
+            logger.success(f"{tag} 下载完成: {name}")
+        else:
+            logger.warning(f"{tag} 下载失败: {name}, 状态码 {retcode}")
+        return retcode
+    except Exception as e:
+        logger.error(e)
+        logger.warning(f"{tag} 下载出错: {name}")

package/service/rover/utils/fonts/fonts.py

@@ -0,0 +1,33 @@
+"""内置字体。优先用系统中文字体, 缺失时退回 PIL 默认字体。"""
+
+from functools import lru_cache
+from pathlib import Path
+from typing import Optional
+
+from PIL import ImageFont
+
+FONT_PATH = Path(__file__).parent
+
+_CANDIDATES = (
+    FONT_PATH / "rover_font.ttf",
+    Path("/usr/share/fonts/truetype/wqy/wqy-microhei.ttc"),
+    Path("/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc"),
+    Path("/usr/share/fonts/truetype/arphic/gbsn00lp.ttf"),
+    Path("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"),
+)
+
+
+@lru_cache(maxsize=1)
+def _font_file() -> Optional[Path]:
+    for path in _CANDIDATES:
+        if path.exists():
+            return path
+    return None
+
+
+@lru_cache(maxsize=64)
+def core_font(size: int) -> ImageFont.FreeTypeFont:
+    path = _font_file()
+    if path is None:
+        return ImageFont.load_default(size)  # type: ignore[return-value]
+    return ImageFont.truetype(str(path), size)

package/service/rover/utils/image/convert.py

@@ -0,0 +1,51 @@
+"""图片格式转换。"""
+
+import os
+from base64 import b64encode
+from io import BytesIO
+from pathlib import Path
+from typing import Union
+
+from PIL import Image
+
+from rover.logger import logger
+from rover.pool import to_thread
+
+pic_quality: int = int(os.getenv("ROVER_PIC_QUALITY", "92"))
+
+
+async def convert_img(
+    img: Union[Image.Image, str, Path, bytes],
+    is_base64: bool = False,
+):
+    """图片转 bytes 或 base64。is_base64 只对 PIL 对象生效, 其余一律返回 base64 串。"""
+    return await _convert_img(img, is_base64)
+
+
+@to_thread
+def _convert_img(
+    img: Union[Image.Image, str, Path, bytes],
+    is_base64: bool = False,
+):
+    logger.info("[图片] 开始处理图片...")
+
+    if isinstance(img, Image.Image):
+        result_buffer = BytesIO()
+        if img.format == "GIF":
+            img.save(result_buffer, format="GIF")
+        else:
+            img.convert("RGB").save(result_buffer, format="JPEG", quality=pic_quality)
+
+        res = result_buffer.getvalue()
+        if is_base64:
+            res = "base64://" + b64encode(res).decode()
+        return res
+    elif isinstance(img, bytes):
+        pass
+    else:
+        with open(Path(img), "rb") as fp:
+            img = fp.read()
+
+    logger.success("[图片] 处理完成!")
+
+    return f"base64://{b64encode(img).decode()}"

package/service/rover/utils/image/image_tools.py

@@ -0,0 +1,30 @@
+"""图片处理工具。"""
+
+import math
+
+from PIL import Image
+
+__all__ = ["crop_center_img"]
+
+
+def crop_center_img(img: Image.Image, based_w: int, based_h: int) -> Image.Image:
+    # 确定图片的长宽
+    based_scale = "%.3f" % (based_w / based_h)
+    w, h = img.size
+    scale_f = "%.3f" % (w / h)
+    new_w = math.ceil(based_h * float(scale_f))
+    new_h = math.ceil(based_w / float(scale_f))
+    if scale_f > based_scale:
+        resize_img = img.resize((new_w, based_h), Image.Resampling.LANCZOS)
+        x1 = int(new_w / 2 - based_w / 2)
+        y1 = 0
+        x2 = int(new_w / 2 + based_w / 2)
+        y2 = based_h
+    else:
+        resize_img = img.resize((based_w, new_h), Image.Resampling.LANCZOS)
+        x1 = 0
+        y1 = int(new_h / 2 - based_h / 2)
+        x2 = based_w
+        y2 = int(new_h / 2 + based_h / 2)
+    crop_img = resize_img.crop((x1, y1, x2, y2))
+    return crop_img

package/service/rover/utils/image/utils.py

@@ -0,0 +1,70 @@
+"""图片网络请求。"""
+
+import asyncio
+import hashlib
+import os
+import time
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from rover.data_store import get_res_path
+from rover.logger import logger
+
+_SGET_CONNECT_TIMEOUT: float = 3.0
+_SGET_READ_TIMEOUT: float = 8.0
+_SGET_WRITE_TIMEOUT: float = 3.0
+_SGET_POOL_TIMEOUT: float = 3.0
+_SGET_TOTAL_TIMEOUT: float = 12.0
+_SGET_CACHE_TTL: float = 172800.0  # 2 天
+
+_URL_CACHE_DIR: Path = get_res_path(["IMAGE_CACHE", "sget"])
+
+
+def _url_cache_path(url: str) -> Path:
+    key = hashlib.sha256(url.encode("utf-8")).hexdigest()
+    return _URL_CACHE_DIR / f"{key}.bin"
+
+
+async def _read_cached(url: str) -> Optional[httpx.Response]:
+    path = _url_cache_path(url)
+    if not path.exists():
+        return None
+    if time.time() - path.stat().st_mtime > _SGET_CACHE_TTL:
+        return None
+    content = await asyncio.to_thread(path.read_bytes)
+    request = httpx.Request("GET", url)
+    return httpx.Response(200, content=content, request=request)
+
+
+async def _write_cache(url: str, content: bytes) -> None:
+    path = _url_cache_path(url)
+    tmp_path = path.with_suffix(".tmp")
+    await asyncio.to_thread(tmp_path.write_bytes, content)
+    await asyncio.to_thread(os.replace, tmp_path, path)
+
+
+async def sget(url: str, use_cache: bool = False) -> httpx.Response:
+    if use_cache:
+        cached = await _read_cached(url)
+        if cached is not None:
+            return cached
+
+    logger.info(f"[图片] 开始下载: {url}")
+    timeout = httpx.Timeout(
+        connect=_SGET_CONNECT_TIMEOUT,
+        read=_SGET_READ_TIMEOUT,
+        write=_SGET_WRITE_TIMEOUT,
+        pool=_SGET_POOL_TIMEOUT,
+    )
+    async with asyncio.timeout(_SGET_TOTAL_TIMEOUT):
+        async with httpx.AsyncClient(
+            timeout=timeout,
+            follow_redirects=True,
+        ) as client:
+            resp = await client.get(url=url)
+            resp.raise_for_status()
+            if use_cache:
+                await _write_cache(url, resp.content)
+            return resp