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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-parsehub
-Version: 1.0.2
+Version: 1.0.3
 Summary: 基于 ParseHub 的社交媒体链接解析插件：群里出现分享链接时自动解析并发送媒体
 Keywords: nonebot,nonebot2,plugin,parsehub,parser,media,onebot
 Author: ByteColtX
@@ -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.3}/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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parsehub"
-version = "1.0.2"
+version = "1.0.3"
 description = "基于 ParseHub 的社交媒体链接解析插件：群里出现分享链接时自动解析并发送媒体"
 readme = "README.md"
 requires-python = ">=3.12"

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

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parsehub"
-version = "1.0.2"
+version = "1.0.3"
 description = "基于 ParseHub 的社交媒体链接解析插件：群里出现分享链接时自动解析并发送媒体"
 readme = "README.md"
 requires-python = ">=3.12"

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

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

{nonebot_plugin_parsehub-1.0.2 → nonebot_plugin_parsehub-1.0.3}/src/nonebot_plugin_parsehub/bilibili.py

@@ -1,14 +1,14 @@
 # Copyright 2026 ByteColtX
 # SPDX-License-Identifier: MIT
 
-"""B 站分P兼容：只解析默认P，并按默认P的时长判断。
+"""B 站分P兼容：按链接指定的 P 解析，未指定时用默认P。
 
 ParseHub 的 B 站解析器在 ``p=1`` 时直接取 ``View.duration``，而 B 站这个字段
 是**所有分P的时长总和**；分P越多，插件越容易误判成超长视频。这里在解析前后各
 补一刀：
 
-1. 解析前去掉 ``p`` 参数，让 ParseHub 始终解析默认P；
-2. 解析后向 B 站查一次 ``pages[0].duration``，覆盖结果里的总时长。
+1. 解析前归一 ``p``：带 ``p=N`` 就保留第 N P，不带就按默认P（P1）；
+2. 解析后向 B 站查一次对应分P的 ``duration``，覆盖结果里的总时长。
 
 第 2 步失败时保持原样（退化成旧行为），不影响解析和下载。
 """
@@ -27,7 +27,7 @@ _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 参数。
+# 需要做分P归一的主机。短链没有 ID，但同样可能带 p 参数。
 _VIDEO_HOSTS = ("bilibili.com", "b23.tv", "bili2233.cn")
 _SHORT_HOSTS = ("b23.tv", "bili2233.cn")
 
@@ -88,49 +88,85 @@ def _is_short_host(host: str) -> bool:
     )
 
 
-def default_part_url(url: str) -> str:
-    """去掉 B 站视频链接里的 ``p`` 参数。
-
-    去掉后 ParseHub 会解析默认P（P1）；对短链也先去掉，展开后即使带 ``p``
-    也不会被保留。
+def requested_part(url: str) -> int:
+    """取链接里指定的分P，没写或非法时按默认P（P1）。
 
     Args:
         url: 待解析的链接。
 
     Returns:
-        去掉 ``p`` 后的链接；非 B 站视频链接原样返回。
+        大于 0 的分P序号。
+    """
+    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 _set_part(url: str, part: int) -> str:
+    """把链接的 ``p`` 参数改写成指定分P。
+
+    Args:
+        url: 待改写的链接。
+        part: 分P序号，1 表示默认P（不写 ``p``）。
+
+    Returns:
+        改写后的链接。
     """
     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"
     ]
+    if part > 1:
+        query.append(("p", str(part)))
     return urlunsplit(parsed._replace(query=urlencode(query)))
 
 
-async def resolve_default_part_url(url: str, proxy: str = "") -> str:
-    """展开短链后再去掉 ``p``，确保短链也只解析默认P。
+def part_url(url: str) -> str:
+    """归一 B 站视频链接的分P参数。
+
+    带 ``p=N`` 就保留第 N P；不带、非法或 ``p=1`` 都按默认P处理（去掉 ``p``）。
+
+    Args:
+        url: 待解析的链接。
+
+    Returns:
+        归一后的链接；非 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
+    return _set_part(url, requested_part(url))
+
+
+async def resolve_part_url(url: str, proxy: str = "") -> str:
+    """展开短链后归一 ``p``，确保短链也按目标分P解析。
 
     短链本身没有 ID，ParseHub 展开时会把重定向目标里的 ``p`` 保留下来；这里先
-    自己展开一次，拿到完整链后统一去掉 ``p``。展开失败就退回原链接。
+    自己展开一次，拿到完整链后统一归一。展开失败就退回原链接。
 
     Args:
         url: 用户发的链接。
         proxy: 展开短链用的代理。
 
     Returns:
-        指向默认P的完整链；非 B 站短链原样返回。
+        指向目标分P的完整链；非 B 站短链原样返回。
     """
     parsed = urlsplit(url)
     host = (parsed.hostname or "").lower()
     if not _is_short_host(host):
-        return default_part_url(url)
+        return part_url(url)
+    part = requested_part(url)
     try:
         async with _client(proxy) as client:
             response = await client.get(
@@ -144,30 +180,51 @@ async def resolve_default_part_url(url: str, proxy: str = "") -> str:
         logger.debug(
             f"[parsehub] 展开 B 站短链失败: {type(exc).__name__}: {exc}"
         )
-        return default_part_url(url)
+        return part_url(url)
     # 重定向到非视频页时把短链还给 ParseHub，让它按原链接选解析器。
     if _video_params(resolved) is None:
-        return default_part_url(url)
-    return default_part_url(resolved)
+        return part_url(url)
+    target = part_url(resolved)
+    # 短链自己带了 p，而重定向目标没带：保留用户指定的分P。
+    if part > 1 and requested_part(target) == 1:
+        target = _set_part(target, part)
+    return target
 
 
-def default_page_seconds(data: Any) -> int:  # noqa: ANN401 - B 站接口 JSON
-    """从 B 站 ``view`` 接口的 ``data`` 里取默认P时长。
+def page_seconds(data: Any, part: int = 1) -> int:  # noqa: ANN401 - B 站接口 JSON
+    """从 B 站 ``view`` 接口的 ``data`` 里取指定分P时长。
 
     Args:
         data: 接口返回的 ``data`` 字段。
+        part: 分P序号，1 表示默认P。
 
     Returns:
-        默认P（``pages[0]``）的秒数；拿不到时退回总时长，再拿不到返回 0。
+        该分P的秒数；找不到时退回第一个分P，再拿不到退回总时长，最后返回 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
+    if isinstance(pages, list) and pages:
+        chosen: dict | None = None
+        for item in pages:
+            if not isinstance(item, dict):
+                continue
+            try:
+                page_no = int(item.get("page") or 0)
+            except (TypeError, ValueError):
+                continue
+            if page_no == part:
+                chosen = item
+                break
+        if chosen is None:
+            chosen = next(
+                (item for item in pages if isinstance(item, dict)), None
+            )
+        if chosen is not None:
+            try:
+                return max(int(chosen.get("duration") or 0), 0)
+            except (TypeError, ValueError):
+                pass
     try:
         return max(int(data.get("duration") or 0), 0)
     except (TypeError, ValueError):
@@ -190,12 +247,12 @@ def _client(proxy: str) -> httpx.AsyncClient:
     )
 
 
-async def default_part_seconds(
+async def part_seconds(
     url: str,
     proxy: str = "",
     cookie: str = "",
 ) -> int:
-    """查询 B 站视频默认P的时长。
+    """查询 B 站视频指定分P的时长。
 
     Args:
         url: 视频链接（完整链或已展开的短链）。
@@ -203,7 +260,7 @@ async def default_part_seconds(
         cookie: 登录态 cookie，空字符串表示不带。
 
     Returns:
-        默认P的秒数；不是 B 站视频或请求失败时返回 0。
+        指定分P的秒数；不是 B 站视频或请求失败时返回 0。
     """
     params = _video_params(url)
     if params is None:
@@ -223,21 +280,21 @@ async def default_part_seconds(
             payload = response.json()
     except Exception as exc:  # noqa: BLE001 - 查时长失败不能影响解析
         logger.debug(
-            f"[parsehub] 查询 B 站默认P时长失败: {type(exc).__name__}: {exc}"
+            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)
+    return page_seconds(data, requested_part(url))
 
 
 def apply_duration(result: Any, seconds: int) -> None:  # noqa: ANN401 - parsehub 结果
-    """把默认P时长写回解析结果里的第一个媒体。
+    """把分P时长写回解析结果里的第一个媒体。
 
     卡片和时长上限都从 ``result.media[].duration`` 读，改这里两边一起生效。
 
     Args:
         result: ParseHub 的解析结果。
-        seconds: 默认P的秒数。
+        seconds: 分P的秒数。
     """
     if seconds <= 0:
         return

{nonebot_plugin_parsehub-1.0.2 → nonebot_plugin_parsehub-1.0.3}/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.3}/src/nonebot_plugin_parsehub/service.py

@@ -253,8 +253,8 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
         本次处理的结局。
     """
     settings = app.settings
-    # B 站只解析默认P：去掉 p 参数，避免用户发的 ?p=2 被当成这次要发的分P。
-    parse_url = bilibili.default_part_url(url)
+    # B 站分P：带 ?p=N 就解析第 N P，不带就按默认P（P1）。
+    parse_url = bilibili.part_url(url)
 
     # 本地已经有这个作品的媒体就直接发，省掉解析、下载和画卡。
     cached = await asyncio.to_thread(app.cache.get, pre_key)
@@ -281,12 +281,12 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
     # 短链展开后可能带 p，必须在解析前再归一一次；展开失败就用原链接。
     try:
         async with budget.timeout():
-            parse_url = await bilibili.resolve_default_part_url(url, proxy)
+            parse_url = await bilibili.resolve_part_url(url, proxy)
     except Exception as exc:  # noqa: BLE001 - 展开失败交给 ParseHub 自己处理
         logger.debug(
-            f"[parsehub] 归一 B 站默认P失败: {type(exc).__name__}: {exc}"
+            f"[parsehub] 归一 B 站分P失败: {type(exc).__name__}: {exc}"
         )
-        parse_url = bilibili.default_part_url(url)
+        parse_url = bilibili.part_url(url)
 
     started = time.monotonic()
     try:
@@ -323,7 +323,7 @@ async def _deliver(  # noqa: C901 - 顺序编排本身就是一条长流水线
         logger.info(f"[parsehub] {post_key} 在本会话刚发过，跳过发送")
         return Result(Outcome.DUPLICATE, keys=all_keys)
 
-    # ParseHub 的 B 站结果里 duration 是所有分P的总和，这里用默认P的时长覆盖。
+    # ParseHub 的 B 站结果里 duration 是所有分P的总和，这里用目标P的时长覆盖。
     if platform_id.lower() == "bilibili":
         lookup_url = getattr(parsed, "raw_url", "") or parse_url
         page_seconds = await _bilibili_seconds(
@@ -434,7 +434,7 @@ async def _bilibili_seconds(
     cookie: str,
     budget: Budget,
 ) -> int:
-    """查询 B 站默认P的时长，失败时返回 0。
+    """查询 B 站目标分P的时长，失败时返回 0。
 
     Args:
         url: 已展开的 B 站视频链接。
@@ -443,11 +443,11 @@ async def _bilibili_seconds(
         budget: 本次工作的超时预算。
 
     Returns:
-        默认P的秒数；查询失败或不是视频时返回 0。
+        目标分P的秒数；查询失败或不是视频时返回 0。
     """
     try:
         async with budget.timeout():
-            return await bilibili.default_part_seconds(url, proxy, cookie)
+            return await bilibili.part_seconds(url, proxy, cookie)
     except Exception as exc:  # noqa: BLE001 - 查时长失败不能影响主流程
         logger.debug(
             f"[parsehub] 查询 B 站默认P时长失败: {type(exc).__name__}: {exc}"