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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-parsehub
-Version: 1.0.2
+Version: 1.0.4
 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.13,<3.0.0
+Requires-Dist: parsehub>=2.3.14,<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
@@ -168,6 +168,7 @@ plugins = ["nonebot_plugin_parsehub"]
 
 ### 说明
 
+- B 站链接带 `?p=N` 时解析第 N P，不带时默认 P1；时长按该 P 计算
 - 视频被协议端拒绝时只点失败表情，**不会**退回群文件
 - 投递三选一、**互不兜底**：`file` 发本机路径（协议端同机）/ `http` 发中转地址（跨机）/ `base64` 内容内联（请求体约 +1/3）
 - parsehub 全程同步阻塞，插件把所有调用放进 `asyncio.to_thread`；首次导入懒加载，不影响启动

{nonebot_plugin_parsehub-1.0.2 → nonebot_plugin_parsehub-1.0.4}/README.md

@@ -139,6 +139,7 @@ plugins = ["nonebot_plugin_parsehub"]
 
 ### 说明
 
+- B 站链接带 `?p=N` 时解析第 N P，不带时默认 P1；时长按该 P 计算
 - 视频被协议端拒绝时只点失败表情，**不会**退回群文件
 - 投递三选一、**互不兜底**：`file` 发本机路径（协议端同机）/ `http` 发中转地址（跨机）/ `base64` 内容内联（请求体约 +1/3）
 - parsehub 全程同步阻塞，插件把所有调用放进 `asyncio.to_thread`；首次导入懒加载，不影响启动

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

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parsehub"
-version = "1.0.2"
+version = "1.0.4"
 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.13,<3.0.0",
+    "parsehub>=2.3.14,<3.0.0",
     "pillow>=12.1.0,<13.0.0",
     "pydantic>=2.0.0,<3.0.0",
 ]

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

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parsehub"
-version = "1.0.2"
+version = "1.0.4"
 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.13,<3.0.0",
+  "parsehub>=2.3.14,<3.0.0",
   "pillow>=12.1.0,<13.0.0",
   "pydantic>=2.0.0,<3.0.0",
 ]

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

@@ -36,7 +36,6 @@ 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` | 只读中转服务 |
@@ -76,8 +75,8 @@ tags: [nonebot, parsehub, module]
 - 第三方依赖全是**硬依赖**：parsehub / Pillow / numpy / opencv / localstore 缺了就是
   装错了，代码里不写 `except ImportError` 兜底，也不往别的目录写；降级只发生在产品层
   （卡片→文字、字体→系统字体、体积探测→未知）。
-- B 站分P由 `bilibili` 收口：解析前去掉 `p`（只解析默认P），解析后用
-  `pages[0].duration` 覆盖 ParseHub 给的分P总时长；查不到就保持原值。
+- B 站分P交给上游 ParseHub（2.3.14 起按 `p` 选分P并返回对应时长）；插件只在
+  `keys.content_key` 里把分P写进作品 key，避免不同 P 撞缓存。
 
 ## Known limitations
 

{nonebot_plugin_parsehub-1.0.2 → nonebot_plugin_parsehub-1.0.4}/src/nonebot_plugin_parsehub/keys.py

@@ -14,7 +14,7 @@
 from __future__ import annotations
 
 import re
-from urllib.parse import urlsplit
+from urllib.parse import parse_qsl, urlsplit
 
 # 预筛白名单：只认这些域名后缀（含子域名）。
 ALLOWED_HOSTS: tuple[str, ...] = (
@@ -88,6 +88,44 @@ _ID_PATTERNS: tuple[tuple[str, re.Pattern[str]], ...] = (
 # 归一化时要去掉的主机名前缀（m.bilibili.com 与 www.bilibili.com 是同一个站）。
 _HOST_PREFIXES = ("www.", "m.", "mobile.")
 
+# B 站短链没有作品 ID，但分P要进 key，否则同一个短链的不同 P 会撞缓存。
+_BILIBILI_SHORT_HOSTS = ("b23.tv", "bili2233.cn")
+
+
+def _bilibili_part(url: str) -> int:
+    """取 B 站链接里的分P序号。
+
+    Args:
+        url: 链接。
+
+    Returns:
+        大于 0 的分P序号；没写或非法时为默认P（1）。
+    """
+    for key, value in parse_qsl(urlsplit(url).query, keep_blank_values=True):
+        if key.lower() != "p":
+            continue
+        try:
+            part = int(value)
+        except (TypeError, ValueError):
+            return 1
+        return part if part > 0 else 1
+    return 1
+
+
+def _is_bilibili_short_host(host: str) -> bool:
+    """判断主机是不是 B 站短链站。
+
+    Args:
+        host: 已小写的主机名。
+
+    Returns:
+        命中返回 True。
+    """
+    return any(
+        host == item or host.endswith("." + item)
+        for item in _BILIBILI_SHORT_HOSTS
+    )
+
 
 def extract_urls(text: str) -> list[str]:
     """从消息文本里挑出可能受支持的链接。
@@ -134,8 +172,8 @@ def content_key(url: str) -> str:
     认得出作品 ID 的平台直接用 ``平台:id``，这样同一个作品的两种写法能对上——比如
     抖音的 ``v.douyin.com/xxx`` 和 ``iesdouyin.com/share/video/<id>``、B 站的
     ``b23.tv/xxx`` 和 ``bilibili.com/video/BVxxxx``（解析结果里的 ``raw_url``
-    已经是短链展开后的地址）。认不出来的退化成「主机 + 路径」，丢掉查询串和末尾
-    斜杠。
+    已经是短链展开后的地址）。B 站带 ``p`` 时把分P也写进 key，避免不同 P
+    撞缓存。认不出来的退化成「主机 + 路径」，丢掉查询串和末尾斜杠。
 
     Args:
         url: 链接，可以是用户发的原始链接，也可以是 ParseHub 给的 ``raw_url``。
@@ -146,7 +184,12 @@ def content_key(url: str) -> str:
     for name, pattern in _ID_PATTERNS:
         match = pattern.search(url)
         if match:
-            return f"{name}:{match.group(1).lower()}"
+            key = f"{name}:{match.group(1).lower()}"
+            if name == "bilibili":
+                part = _bilibili_part(url)
+                if part > 1:
+                    key += f":p{part}"
+            return key
 
     parsed = urlsplit(url)
     host = parsed.netloc.lower()
@@ -154,4 +197,9 @@ def content_key(url: str) -> str:
         if host.startswith(prefix):
             host = host[len(prefix) :]
             break
-    return f"{host}{parsed.path.rstrip('/')}".lower()
+    key = f"{host}{parsed.path.rstrip('/')}".lower()
+    if _is_bilibili_short_host(host):
+        part = _bilibili_part(url)
+        if part > 1:
+            key += f":p{part}"
+    return key

{nonebot_plugin_parsehub-1.0.2 → nonebot_plugin_parsehub-1.0.4}/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 bilibili, errors, feedback, keys, media, platforms
+from . import errors, feedback, keys, media, platforms
 from .budget import Budget
 from .cache import CacheEntry
 from .delivery import MediaReport, Sender
@@ -253,8 +253,6 @@ 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)
@@ -262,7 +260,7 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
         return await _deliver_cached(app, sender, event, cached, pre_key)
 
     try:
-        supported = await app.client.is_supported(parse_url)
+        supported = await app.client.is_supported(url)
     except Exception as exc:  # noqa: BLE001 - 判断失败就交给解析去报错
         logger.warning(
             f"[parsehub] 平台支持判断失败 {url}: {type(exc).__name__}: {exc}"
@@ -278,20 +276,10 @@ 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(parse_url, proxy, cookie)
+            parsed = await app.client.parse(url, proxy, cookie)
     except Exception as exc:  # noqa: BLE001 - parsehub 异常类型很多，统一兜底
         failure = errors.translate(exc)
         logger.warning(
@@ -302,7 +290,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 parse_url)
+    post_key = keys.content_key(getattr(parsed, "raw_url", "") or url)
     all_keys = tuple(dict.fromkeys([pre_key, post_key]))
     # 平台 id 以解析结果为准（client 可能拿不到），时长单位也跟着它。
     platform_id = str(
@@ -323,14 +311,6 @@ 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)
@@ -390,7 +370,7 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
             proxy,
             allow_text=False,
         ),
-        _download(app, parse_url, proxy, cookie, budget, parsed),
+        _download(app, url, proxy, cookie, budget, parsed),
     )
     if files is None:
         return Result(
@@ -428,33 +408,6 @@ 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,

nonebot_plugin_parsehub-1.0.2/src/nonebot_plugin_parsehub/bilibili.py

@@ -1,252 +0,0 @@
-# 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