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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-parsehub
-Version: 1.0.1
+Version: 1.0.3
 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
@@ -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.1 → 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.1 → nonebot_plugin_parsehub-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parsehub"
-version = "1.0.1"
+version = "1.0.3"
 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.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-parsehub"
-version = "1.0.1"
+version = "1.0.3"
 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.3}/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,9 @@ tags: [nonebot, parsehub, module]
 - 第三方依赖全是**硬依赖**：parsehub / Pillow / numpy / opencv / localstore 缺了就是
   装错了，代码里不写 `except ImportError` 兜底，也不往别的目录写；降级只发生在产品层
   （卡片→文字、字体→系统字体、体积探测→未知）。
+- B 站分P由 `bilibili` 收口：链接带 `p=N` 就解析第 N P，不带时用默认P（P1）；
+  解析后用对应 `pages` 项的 `duration` 覆盖 ParseHub 给的分P总时长，查不到就保持原值。
+  分P会写进作品 key，避免不同 P 撞缓存。
 
 ## Known limitations
 

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

@@ -0,0 +1,309 @@
+# Copyright 2026 ByteColtX
+# SPDX-License-Identifier: MIT
+
+"""B 站分P兼容：按链接指定的 P 解析，未指定时用默认P。
+
+ParseHub 的 B 站解析器在 ``p=1`` 时直接取 ``View.duration``，而 B 站这个字段
+是**所有分P的时长总和**；分P越多，插件越容易误判成超长视频。这里在解析前后各
+补一刀：
+
+1. 解析前归一 ``p``：带 ``p=N`` 就保留第 N P，不带就按默认P（P1）；
+2. 解析后向 B 站查一次对应分P的 ``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 requested_part(url: str) -> int:
+    """取链接里指定的分P，没写或非法时按默认P（P1）。
+
+    Args:
+        url: 待解析的链接。
+
+    Returns:
+        大于 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)
+    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)))
+
+
+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`` 保留下来；这里先
+    自己展开一次，拿到完整链后统一归一。展开失败就退回原链接。
+
+    Args:
+        url: 用户发的链接。
+        proxy: 展开短链用的代理。
+
+    Returns:
+        指向目标分P的完整链；非 B 站短链原样返回。
+    """
+    parsed = urlsplit(url)
+    host = (parsed.hostname or "").lower()
+    if not _is_short_host(host):
+        return part_url(url)
+    part = requested_part(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 part_url(url)
+    # 重定向到非视频页时把短链还给 ParseHub，让它按原链接选解析器。
+    if _video_params(resolved) is None:
+        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 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的秒数；找不到时退回第一个分P，再拿不到退回总时长，最后返回 0。
+    """
+    if not isinstance(data, dict):
+        return 0
+    pages = data.get("pages")
+    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):
+        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 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 page_seconds(data, requested_part(url))
+
+
+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.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.1 → nonebot_plugin_parsehub-1.0.3}/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=N 就解析第 N P，不带就按默认P（P1）。
+    parse_url = bilibili.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_part_url(url, proxy)
+    except Exception as exc:  # noqa: BLE001 - 展开失败交给 ParseHub 自己处理
+        logger.debug(
+            f"[parsehub] 归一 B 站分P失败: {type(exc).__name__}: {exc}"
+        )
+        parse_url = bilibili.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.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,