nonebot-plugin-parsehub 1.0.1__tar.gz → 1.0.2__tar.gz

{nonebot_plugin_parsehub-1.0.1 → nonebot_plugin_parsehub-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-parsehub
-Version: 1.0.1
+Version: 1.0.2
 Summary: 基于 ParseHub 的社交媒体链接解析插件：群里出现分享链接时自动解析并发送媒体
 Keywords: nonebot,nonebot2,plugin,parsehub,parser,media,onebot
 Author: ByteColtX
@@ -18,7 +18,7 @@ Requires-Dist: nonebot-plugin-localstore>=0.7.4,<1.0.0
 Requires-Dist: nonebot2>=2.5.0,<3.0.0
 Requires-Dist: numpy>=2.0.0,<3.0.0
 Requires-Dist: opencv-python-headless>=4.13.0.92
-Requires-Dist: parsehub>=2.3.10,<3.0.0
+Requires-Dist: parsehub>=2.3.13,<3.0.0
 Requires-Dist: pillow>=12.1.0,<13.0.0
 Requires-Dist: pydantic>=2.0.0,<3.0.0
 Requires-Python: >=3.12

{nonebot_plugin_parsehub-1.0.1 → nonebot_plugin_parsehub-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parsehub"
-version = "1.0.1"
+version = "1.0.2"
 description = "基于 ParseHub 的社交媒体链接解析插件：群里出现分享链接时自动解析并发送媒体"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -29,7 +29,7 @@ dependencies = [
     "nonebot2>=2.5.0,<3.0.0",
     "numpy>=2.0.0,<3.0.0",
     "opencv-python-headless>=4.13.0.92",
-    "parsehub>=2.3.10,<3.0.0",
+    "parsehub>=2.3.13,<3.0.0",
     "pillow>=12.1.0,<13.0.0",
     "pydantic>=2.0.0,<3.0.0",
 ]

{nonebot_plugin_parsehub-1.0.1 → nonebot_plugin_parsehub-1.0.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parsehub"
-version = "1.0.1"
+version = "1.0.2"
 description = "基于 ParseHub 的社交媒体链接解析插件：群里出现分享链接时自动解析并发送媒体"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -23,7 +23,7 @@ dependencies = [
   # 卡片渐变遮罩与视频抽帧是代码里直接 import 的，必须显式声明
   "numpy>=2.0.0,<3.0.0",
   "opencv-python-headless>=4.13.0.92",
-  "parsehub>=2.3.10,<3.0.0",
+  "parsehub>=2.3.13,<3.0.0",
   "pillow>=12.1.0,<13.0.0",
   "pydantic>=2.0.0,<3.0.0",
 ]

{nonebot_plugin_parsehub-1.0.1 → nonebot_plugin_parsehub-1.0.2}/src/nonebot_plugin_parsehub/SPEC.md

@@ -36,6 +36,7 @@ tags: [nonebot, parsehub, module]
 | `delivery.py` | `Sender` 协议、三种上传模式、合并转发、`MediaReport` |
 | `feedback.py` | `Reaction` 与全部提示文案 |
 | `parsehub_client.py` | 懒加载客户端、cookie 读取 |
+| `bilibili.py` | B 站默认P归一与单P时长查询 |
 | `cache.py` | 作品级媒体缓存（原子写、TTL、容量） |
 | `dedupe.py` | 会话级去重 |
 | `relay.py` | 只读中转服务 |
@@ -75,6 +76,8 @@ tags: [nonebot, parsehub, module]
 - 第三方依赖全是**硬依赖**：parsehub / Pillow / numpy / opencv / localstore 缺了就是
   装错了，代码里不写 `except ImportError` 兜底，也不往别的目录写；降级只发生在产品层
   （卡片→文字、字体→系统字体、体积探测→未知）。
+- B 站分P由 `bilibili` 收口：解析前去掉 `p`（只解析默认P），解析后用
+  `pages[0].duration` 覆盖 ParseHub 给的分P总时长；查不到就保持原值。
 
 ## Known limitations
 

{nonebot_plugin_parsehub-1.0.1 → nonebot_plugin_parsehub-1.0.2}/src/nonebot_plugin_parsehub/__init__.py

@@ -29,7 +29,7 @@ from .app import App
 from .config import Config, Settings, plugin_config
 
 __plugin_meta__ = PluginMetadata(
-    name="ParseHub 链接解析",
+    name="轻量、异步、开箱即用的社交媒体聚合解析插件",
     description=(
         "群里出现受支持的分享链接时，用 ParseHub 自动解析并发送媒体"
         "（视频 / 图集 / 正文）。"

nonebot_plugin_parsehub-1.0.2/src/nonebot_plugin_parsehub/bilibili.py

@@ -0,0 +1,252 @@
+# Copyright 2026 ByteColtX
+# SPDX-License-Identifier: MIT
+
+"""B 站分P兼容：只解析默认P，并按默认P的时长判断。
+
+ParseHub 的 B 站解析器在 ``p=1`` 时直接取 ``View.duration``，而 B 站这个字段
+是**所有分P的时长总和**；分P越多，插件越容易误判成超长视频。这里在解析前后各
+补一刀：
+
+1. 解析前去掉 ``p`` 参数，让 ParseHub 始终解析默认P；
+2. 解析后向 B 站查一次 ``pages[0].duration``，覆盖结果里的总时长。
+
+第 2 步失败时保持原样（退化成旧行为），不影响解析和下载。
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+import httpx
+from nonebot import logger
+
+# B 站视频 ID。BV 号大小写敏感，av 号只在路径或参数里认。
+_BV_PATTERN = re.compile(r"(BV[0-9A-Za-z]{10})")
+_AV_PATTERN = re.compile(r"(?:/|=)av(\d+)", re.IGNORECASE)
+_AID_PATTERN = re.compile(r"[?&]aid=(\d+)")
+
+# 需要做默认P归一的主机。短链没有 ID，但同样可能带 p 参数。
+_VIDEO_HOSTS = ("bilibili.com", "b23.tv", "bili2233.cn")
+_SHORT_HOSTS = ("b23.tv", "bili2233.cn")
+
+_VIEW_API = "https://api.bilibili.com/x/web-interface/view"
+_USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36"
+)
+_TIMEOUT_SECONDS = 5.0
+
+
+def _video_params(url: str) -> dict[str, str] | None:
+    """从链接里取出 B 站视频 ID。
+
+    Args:
+        url: 可能是完整链或短链展开后的链接。
+
+    Returns:
+        ``{"bvid": ...}`` 或 ``{"aid": ...}``；认不出来时返回 None。
+    """
+    match = _BV_PATTERN.search(url)
+    if match:
+        return {"bvid": match.group(1)}
+    match = _AV_PATTERN.search(url)
+    if match:
+        return {"aid": match.group(1)}
+    match = _AID_PATTERN.search(url)
+    if match:
+        return {"aid": match.group(1)}
+    return None
+
+
+def _is_video_host(host: str) -> bool:
+    """判断主机是不是 B 站视频站（含短链站）。
+
+    Args:
+        host: 已小写的主机名。
+
+    Returns:
+        命中返回 True。
+    """
+    return any(
+        host == item or host.endswith("." + item) for item in _VIDEO_HOSTS
+    )
+
+
+def _is_short_host(host: str) -> bool:
+    """判断主机是不是 B 站短链站。
+
+    Args:
+        host: 已小写的主机名。
+
+    Returns:
+        命中返回 True。
+    """
+    return any(
+        host == item or host.endswith("." + item) for item in _SHORT_HOSTS
+    )
+
+
+def default_part_url(url: str) -> str:
+    """去掉 B 站视频链接里的 ``p`` 参数。
+
+    去掉后 ParseHub 会解析默认P（P1）；对短链也先去掉，展开后即使带 ``p``
+    也不会被保留。
+
+    Args:
+        url: 待解析的链接。
+
+    Returns:
+        去掉 ``p`` 后的链接；非 B 站视频链接原样返回。
+    """
+    parsed = urlsplit(url)
+    host = (parsed.hostname or "").lower()
+    if not _is_video_host(host):
+        return url
+    if not _is_short_host(host) and _video_params(url) is None:
+        return url
+    query = [
+        (key, value)
+        for key, value in parse_qsl(parsed.query, keep_blank_values=True)
+        if key.lower() != "p"
+    ]
+    return urlunsplit(parsed._replace(query=urlencode(query)))
+
+
+async def resolve_default_part_url(url: str, proxy: str = "") -> str:
+    """展开短链后再去掉 ``p``，确保短链也只解析默认P。
+
+    短链本身没有 ID，ParseHub 展开时会把重定向目标里的 ``p`` 保留下来；这里先
+    自己展开一次，拿到完整链后统一去掉 ``p``。展开失败就退回原链接。
+
+    Args:
+        url: 用户发的链接。
+        proxy: 展开短链用的代理。
+
+    Returns:
+        指向默认P的完整链；非 B 站短链原样返回。
+    """
+    parsed = urlsplit(url)
+    host = (parsed.hostname or "").lower()
+    if not _is_short_host(host):
+        return default_part_url(url)
+    try:
+        async with _client(proxy) as client:
+            response = await client.get(
+                url,
+                headers={"User-Agent": _USER_AGENT},
+                follow_redirects=True,
+            )
+            response.raise_for_status()
+            resolved = str(response.url)
+    except Exception as exc:  # noqa: BLE001 - 展开失败交给 ParseHub 自己处理
+        logger.debug(
+            f"[parsehub] 展开 B 站短链失败: {type(exc).__name__}: {exc}"
+        )
+        return default_part_url(url)
+    # 重定向到非视频页时把短链还给 ParseHub，让它按原链接选解析器。
+    if _video_params(resolved) is None:
+        return default_part_url(url)
+    return default_part_url(resolved)
+
+
+def default_page_seconds(data: Any) -> int:  # noqa: ANN401 - B 站接口 JSON
+    """从 B 站 ``view`` 接口的 ``data`` 里取默认P时长。
+
+    Args:
+        data: 接口返回的 ``data`` 字段。
+
+    Returns:
+        默认P（``pages[0]``）的秒数；拿不到时退回总时长，再拿不到返回 0。
+    """
+    if not isinstance(data, dict):
+        return 0
+    pages = data.get("pages")
+    if isinstance(pages, list) and pages and isinstance(pages[0], dict):
+        try:
+            return max(int(pages[0].get("duration") or 0), 0)
+        except (TypeError, ValueError):
+            pass
+    try:
+        return max(int(data.get("duration") or 0), 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _client(proxy: str) -> httpx.AsyncClient:
+    """构造查接口用的 HTTP 客户端（测试里替换成不联网的假实现）。
+
+    Args:
+        proxy: 代理地址，空字符串表示直连。
+
+    Returns:
+        异步 HTTP 客户端。
+    """
+    return httpx.AsyncClient(
+        proxy=proxy or None,
+        timeout=_TIMEOUT_SECONDS,
+        follow_redirects=True,
+    )
+
+
+async def default_part_seconds(
+    url: str,
+    proxy: str = "",
+    cookie: str = "",
+) -> int:
+    """查询 B 站视频默认P的时长。
+
+    Args:
+        url: 视频链接（完整链或已展开的短链）。
+        proxy: 解析代理，空字符串表示直连。
+        cookie: 登录态 cookie，空字符串表示不带。
+
+    Returns:
+        默认P的秒数；不是 B 站视频或请求失败时返回 0。
+    """
+    params = _video_params(url)
+    if params is None:
+        return 0
+    headers = {
+        "User-Agent": _USER_AGENT,
+        "Referer": "https://www.bilibili.com/",
+    }
+    if cookie:
+        headers["Cookie"] = cookie
+    try:
+        async with _client(proxy) as client:
+            response = await client.get(
+                _VIEW_API, params=params, headers=headers
+            )
+            response.raise_for_status()
+            payload = response.json()
+    except Exception as exc:  # noqa: BLE001 - 查时长失败不能影响解析
+        logger.debug(
+            f"[parsehub] 查询 B 站默认P时长失败: {type(exc).__name__}: {exc}"
+        )
+        return 0
+    data = payload.get("data") if isinstance(payload, dict) else None
+    return default_page_seconds(data)
+
+
+def apply_duration(result: Any, seconds: int) -> None:  # noqa: ANN401 - parsehub 结果
+    """把默认P时长写回解析结果里的第一个媒体。
+
+    卡片和时长上限都从 ``result.media[].duration`` 读，改这里两边一起生效。
+
+    Args:
+        result: ParseHub 的解析结果。
+        seconds: 默认P的秒数。
+    """
+    if seconds <= 0:
+        return
+    media = getattr(result, "media", None)
+    items = list(media) if isinstance(media, (list, tuple)) else [media]
+    for item in items:
+        if item is not None and hasattr(item, "duration"):
+            try:
+                item.duration = seconds
+            except (AttributeError, TypeError):
+                pass
+            return

{nonebot_plugin_parsehub-1.0.1 → nonebot_plugin_parsehub-1.0.2}/src/nonebot_plugin_parsehub/service.py

@@ -31,7 +31,7 @@ from typing import TYPE_CHECKING, Any
 from nonebot import logger
 from nonebot.adapters.onebot.v11 import GroupMessageEvent, MessageEvent
 
-from . import errors, feedback, keys, media, platforms
+from . import bilibili, errors, feedback, keys, media, platforms
 from .budget import Budget
 from .cache import CacheEntry
 from .delivery import MediaReport, Sender
@@ -253,6 +253,8 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
         本次处理的结局。
     """
     settings = app.settings
+    # B 站只解析默认P：去掉 p 参数，避免用户发的 ?p=2 被当成这次要发的分P。
+    parse_url = bilibili.default_part_url(url)
 
     # 本地已经有这个作品的媒体就直接发，省掉解析、下载和画卡。
     cached = await asyncio.to_thread(app.cache.get, pre_key)
@@ -260,7 +262,7 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
         return await _deliver_cached(app, sender, event, cached, pre_key)
 
     try:
-        supported = await app.client.is_supported(url)
+        supported = await app.client.is_supported(parse_url)
     except Exception as exc:  # noqa: BLE001 - 判断失败就交给解析去报错
         logger.warning(
             f"[parsehub] 平台支持判断失败 {url}: {type(exc).__name__}: {exc}"
@@ -276,10 +278,20 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
     cookie = await asyncio.to_thread(platform_cookie, platform, settings.cookie)
     logger.debug(f"[parsehub] {platform} 代理={proxy or '直连'}")
 
+    # 短链展开后可能带 p，必须在解析前再归一一次；展开失败就用原链接。
+    try:
+        async with budget.timeout():
+            parse_url = await bilibili.resolve_default_part_url(url, proxy)
+    except Exception as exc:  # noqa: BLE001 - 展开失败交给 ParseHub 自己处理
+        logger.debug(
+            f"[parsehub] 归一 B 站默认P失败: {type(exc).__name__}: {exc}"
+        )
+        parse_url = bilibili.default_part_url(url)
+
     started = time.monotonic()
     try:
         async with budget.timeout():
-            parsed = await app.client.parse(url, proxy, cookie)
+            parsed = await app.client.parse(parse_url, proxy, cookie)
     except Exception as exc:  # noqa: BLE001 - parsehub 异常类型很多，统一兜底
         failure = errors.translate(exc)
         logger.warning(
@@ -290,7 +302,7 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
             notice = feedback.failure_notice(exc)
         return Result(Outcome.PARSE_FAILED, notice=notice, keys=(pre_key,))
 
-    post_key = keys.content_key(getattr(parsed, "raw_url", "") or url)
+    post_key = keys.content_key(getattr(parsed, "raw_url", "") or parse_url)
     all_keys = tuple(dict.fromkeys([pre_key, post_key]))
     # 平台 id 以解析结果为准（client 可能拿不到），时长单位也跟着它。
     platform_id = str(
@@ -311,6 +323,14 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
         logger.info(f"[parsehub] {post_key} 在本会话刚发过，跳过发送")
         return Result(Outcome.DUPLICATE, keys=all_keys)
 
+    # ParseHub 的 B 站结果里 duration 是所有分P的总和，这里用默认P的时长覆盖。
+    if platform_id.lower() == "bilibili":
+        lookup_url = getattr(parsed, "raw_url", "") or parse_url
+        page_seconds = await _bilibili_seconds(
+            lookup_url, proxy, cookie, budget
+        )
+        bilibili.apply_duration(parsed, page_seconds)
+
     refs = media.refs_from(parsed)
     seconds = platforms.duration_seconds(
         platform_id, (ref.duration for ref in refs)
@@ -370,7 +390,7 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
             proxy,
             allow_text=False,
         ),
-        _download(app, url, proxy, cookie, budget, parsed),
+        _download(app, parse_url, proxy, cookie, budget, parsed),
     )
     if files is None:
         return Result(
@@ -408,6 +428,33 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
     return Result(outcome, report=report, keys=all_keys)
 
 
+async def _bilibili_seconds(
+    url: str,
+    proxy: str,
+    cookie: str,
+    budget: Budget,
+) -> int:
+    """查询 B 站默认P的时长，失败时返回 0。
+
+    Args:
+        url: 已展开的 B 站视频链接。
+        proxy: 解析代理。
+        cookie: 登录态 cookie。
+        budget: 本次工作的超时预算。
+
+    Returns:
+        默认P的秒数；查询失败或不是视频时返回 0。
+    """
+    try:
+        async with budget.timeout():
+            return await bilibili.default_part_seconds(url, proxy, cookie)
+    except Exception as exc:  # noqa: BLE001 - 查时长失败不能影响主流程
+        logger.debug(
+            f"[parsehub] 查询 B 站默认P时长失败: {type(exc).__name__}: {exc}"
+        )
+        return 0
+
+
 async def _deliver_cached(
     app: App,
     sender: Sender,