nonebot-plugin-bilidyn 0.3.0__py3-none-any.whl

nonebot_plugin_bilidyn/__init__.py

@@ -0,0 +1,36 @@
+from nonebot import require
+from nonebot.plugin import PluginMetadata, inherit_supported_adapters
+
+require("nonebot_plugin_alconna")
+require("nonebot_plugin_apscheduler")
+require("nonebot_plugin_htmlrender")
+require("nonebot_plugin_localstore")
+require("nonebot_plugin_uninfo")
+require("nonebot_plugin_uniref")
+
+USAGE_TEXT = (
+    "bili sub <UID>   - 订阅 UP 主\n"
+    "bili unsub <UID> - 取消当前场景内订阅\n"
+    "bili list        - 查看订阅列表\n"
+    "bili new <UID> [count] - 查看最新动态"
+)
+
+from . import bot as bot
+from .config import Config
+
+__all__ = ("USAGE_TEXT", "__plugin_meta__", "bot")
+
+__plugin_meta__ = PluginMetadata(
+    name="B站动态订阅",
+    description="订阅B站UP主动态和直播通知推送",
+    usage=USAGE_TEXT,
+    type="application",
+    homepage="https://github.com/Misty02600/nonebot-plugin-bilidyn",
+    config=Config,
+    supported_adapters=inherit_supported_adapters(
+        "nonebot_plugin_alconna",
+        "nonebot_plugin_uninfo",
+        "nonebot_plugin_uniref",
+    ),
+    extra={"author": "Misty02600 <Misty02600@gmail.com>"},
+)

nonebot_plugin_bilidyn/application/__init__.py

@@ -0,0 +1 @@
+"""应用用例。"""

nonebot_plugin_bilidyn/application/dynamic_collection.py

@@ -0,0 +1,307 @@
+"""动态来源的分页收集与追赶边界。"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+
+from ..core.data_models import coerce_int
+
+CATCHUP_WINDOW_SECONDS = 6 * 60 * 60
+MAX_DYNAMIC_PAGES = 50
+_REQUEST_INTERVAL_SECONDS = 1.0
+
+DynamicPageFetcher = Callable[..., Awaitable[dict | None]]
+
+
+class DynamicFetchError(Exception):
+    """携带失败前已完成页数的动态请求异常。"""
+
+    def __init__(self, pages: int, cause: Exception):
+        super().__init__(str(cause))
+        self.pages = pages
+        self.cause = cause
+
+
+@dataclass(slots=True)
+class DynamicCollection:
+    """一次完整或中止的动态收集结果。"""
+
+    baselines: dict[int, int]
+    effective_cutoffs: dict[int, int]
+    candidates_by_uid: dict[int, list[dict]] = field(default_factory=dict)
+    latest_seen_ts: dict[int, int] = field(default_factory=dict)
+    latest_item_by_uid: dict[int, dict] = field(default_factory=dict)
+    received_by_uid: dict[int, int] = field(default_factory=dict)
+    discarded_by_uid: dict[int, int] = field(default_factory=dict)
+    pages: int = 0
+    stop_reason: str = "not_started"
+    complete: bool = False
+
+
+def _effective_cutoff(baseline: int, cycle_started_ts: int) -> int:
+    if baseline <= 0:
+        return cycle_started_ts
+    return max(baseline, cycle_started_ts - CATCHUP_WINDOW_SECONDS)
+
+
+def _new_collection(
+    baselines: dict[int, int],
+    cycle_started_ts: int,
+) -> DynamicCollection:
+    normalized = {uid: coerce_int(value) for uid, value in baselines.items()}
+    return DynamicCollection(
+        baselines=normalized,
+        effective_cutoffs={
+            uid: _effective_cutoff(value, cycle_started_ts)
+            for uid, value in normalized.items()
+        },
+    )
+
+
+def _response_items(result: dict | None) -> list[dict]:
+    if not result:
+        return []
+    items = result.get("items")
+    if not isinstance(items, list):
+        return []
+    return [item for item in items if isinstance(item, dict)]
+
+
+def _item_author_uid(item: dict) -> int:
+    return coerce_int(item.get("modules", {}).get("module_author", {}).get("mid", 0))
+
+
+def _item_pub_ts(item: dict) -> int:
+    return coerce_int(item.get("modules", {}).get("module_author", {}).get("pub_ts", 0))
+
+
+def _item_key(item: dict) -> tuple[object, ...]:
+    dynamic_id = str(item.get("id_str") or "").strip()
+    if dynamic_id:
+        return ("id", dynamic_id)
+    return (
+        "fallback",
+        _item_author_uid(item),
+        _item_pub_ts(item),
+        str(item.get("type") or ""),
+    )
+
+
+def _record_item(
+    collection: DynamicCollection,
+    item: dict,
+    expected_uids: set[int],
+    *,
+    forced_uid: int | None = None,
+) -> None:
+    uid = forced_uid if forced_uid is not None else _item_author_uid(item)
+    if uid not in expected_uids:
+        return
+
+    collection.received_by_uid[uid] = collection.received_by_uid.get(uid, 0) + 1
+    pub_ts = _item_pub_ts(item)
+    if pub_ts <= 0:
+        return
+
+    if pub_ts > collection.latest_seen_ts.get(uid, 0):
+        collection.latest_seen_ts[uid] = pub_ts
+        collection.latest_item_by_uid[uid] = item
+
+    baseline = collection.baselines[uid]
+    cutoff = collection.effective_cutoffs[uid]
+    if pub_ts > cutoff:
+        collection.candidates_by_uid.setdefault(uid, []).append(item)
+    elif cutoff > baseline and pub_ts > baseline:
+        collection.discarded_by_uid[uid] = collection.discarded_by_uid.get(uid, 0) + 1
+
+
+def _page_tail_ts(items: list[dict]) -> int:
+    timestamps = [timestamp for item in items if (timestamp := _item_pub_ts(item)) > 0]
+    return timestamps[-1] if timestamps else 0
+
+
+def _normalize_feed_offset(value: object) -> int | None:
+    if isinstance(value, bool):
+        return None
+    offset = coerce_int(value)
+    return offset if offset > 0 else None
+
+
+async def collect_user_dynamic_pages(
+    uid: int,
+    baseline: int,
+    cycle_started_ts: int,
+    credential: object,
+    fetch_page: DynamicPageFetcher,
+    *,
+    request_interval: float = _REQUEST_INTERVAL_SECONDS,
+) -> DynamicCollection:
+    """按单个 UID 的游标读取动态，直到安全停止边界。
+
+    Args:
+        uid: 订阅目标 UID。
+        baseline: 周期开始时该 UID 的持久化水位。
+        cycle_started_ts: 本轮检测开始的秒级时间戳。
+        credential: 透传给 SDK 适配函数的登录凭据。
+        fetch_page: 接受 ``uid``、``credential`` 和 ``offset`` 的分页函数。
+        request_interval: 同一 UID 连续翻页之间的等待秒数。
+
+    Returns:
+        DynamicCollection: 候选、最新观察时间和分页完整性。
+
+    Raises:
+        DynamicFetchError: 请求失败时携带失败前已经完成的页数。
+    """
+    collection = _new_collection({uid: baseline}, cycle_started_ts)
+    expected_uids = {uid}
+    cutoff = collection.effective_cutoffs[uid]
+    offset = ""
+    seen_offsets = {offset}
+    seen_items: set[tuple[object, ...]] = set()
+
+    for page_number in range(1, MAX_DYNAMIC_PAGES + 1):
+        try:
+            result = await fetch_page(uid, credential, offset=offset)
+        except Exception as exc:
+            raise DynamicFetchError(collection.pages, exc) from exc
+
+        collection.pages = page_number
+        items = _response_items(result)
+        if not items:
+            collection.complete = True
+            collection.stop_reason = "empty"
+            return collection
+
+        new_item_count = 0
+        for item in items:
+            key = _item_key(item)
+            if key in seen_items:
+                continue
+            seen_items.add(key)
+            new_item_count += 1
+            _record_item(collection, item, expected_uids, forced_uid=uid)
+
+        if baseline <= 0:
+            collection.complete = True
+            collection.stop_reason = "missing_baseline"
+            return collection
+
+        page_tail_ts = _page_tail_ts(items)
+        if page_tail_ts > 0 and page_tail_ts <= cutoff:
+            collection.complete = True
+            collection.stop_reason = "catchup_cutoff"
+            return collection
+
+        if not bool(result and result.get("has_more")):
+            collection.complete = True
+            collection.stop_reason = "end_of_feed"
+            return collection
+
+        next_offset = str(result.get("offset") or "").strip() if result else ""
+        if not next_offset:
+            collection.stop_reason = "empty_offset"
+            return collection
+        if next_offset in seen_offsets:
+            collection.stop_reason = "repeated_offset"
+            return collection
+        if new_item_count == 0:
+            collection.stop_reason = "no_progress"
+            return collection
+
+        offset = next_offset
+        seen_offsets.add(offset)
+        if request_interval > 0:
+            await asyncio.sleep(request_interval)
+
+    collection.stop_reason = "max_pages"
+    return collection
+
+
+async def collect_followed_dynamic_pages(
+    baselines: dict[int, int],
+    cycle_started_ts: int,
+    credential: object,
+    fetch_page: DynamicPageFetcher,
+    *,
+    request_interval: float = _REQUEST_INTERVAL_SECONDS,
+) -> DynamicCollection:
+    """从聚合关注流第一页开始按响应游标收集本地目标动态。
+
+    Args:
+        baselines: 本轮所有聚合目标 UID 及其周期开始水位。
+        cycle_started_ts: 本轮检测开始的秒级时间戳。
+        credential: 透传给 SDK 适配函数的登录凭据。
+        fetch_page: 接受 ``credential`` 和 ``offset`` 的聚合分页函数。
+        request_interval: 聚合流连续翻页之间的等待秒数。
+
+    Returns:
+        DynamicCollection: 已按本地 UID 过滤的候选和分页完整性。
+
+    Raises:
+        DynamicFetchError: 请求失败时携带失败前已经完成的页数。
+    """
+    collection = _new_collection(baselines, cycle_started_ts)
+    expected_uids = set(baselines)
+    if not expected_uids:
+        collection.complete = True
+        collection.stop_reason = "no_targets"
+        return collection
+
+    global_cutoff = min(collection.effective_cutoffs.values())
+    offset: int | None = None
+    seen_offsets: set[int] = set()
+    seen_items: set[tuple[object, ...]] = set()
+
+    for page_number in range(1, MAX_DYNAMIC_PAGES + 1):
+        try:
+            result = await fetch_page(credential, offset=offset)
+        except Exception as exc:
+            raise DynamicFetchError(collection.pages, exc) from exc
+
+        collection.pages = page_number
+        items = _response_items(result)
+        if not items:
+            collection.complete = True
+            collection.stop_reason = "empty"
+            return collection
+
+        new_item_count = 0
+        for item in items:
+            key = _item_key(item)
+            if key in seen_items:
+                continue
+            seen_items.add(key)
+            new_item_count += 1
+            _record_item(collection, item, expected_uids)
+
+        page_tail_ts = _page_tail_ts(items)
+        if page_tail_ts > 0 and page_tail_ts <= global_cutoff:
+            collection.complete = True
+            collection.stop_reason = "catchup_cutoff"
+            return collection
+
+        if not bool(result and result.get("has_more")):
+            collection.complete = True
+            collection.stop_reason = "end_of_feed"
+            return collection
+
+        next_offset = _normalize_feed_offset(result.get("offset") if result else None)
+        if next_offset is None:
+            collection.stop_reason = "empty_offset"
+            return collection
+        if next_offset in seen_offsets or next_offset == offset:
+            collection.stop_reason = "repeated_offset"
+            return collection
+        if new_item_count == 0:
+            collection.stop_reason = "no_progress"
+            return collection
+
+        offset = next_offset
+        seen_offsets.add(offset)
+        if request_interval > 0:
+            await asyncio.sleep(request_interval)
+
+    collection.stop_reason = "max_pages"
+    return collection

nonebot_plugin_bilidyn/application/follow_sync.py

@@ -0,0 +1,95 @@
+"""B 站关注关系同步用例。"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Literal
+
+from bilibili_api import Credential
+from nonebot import logger
+from nonebot_plugin_uniref import UserRef
+
+from ..config import DynamicMode
+from ..core.data_models import CredentialData
+from ..infra.auth import (
+    is_login_invalid_error,
+    reset_login_invalid_notify_state,
+)
+from ..infra.bili_client import build_credential, ensure_user_followed
+from ..infra.data_manager import data_manager
+
+FollowSyncTrigger = Literal["startup", "qr_login"]
+
+
+async def sync_followed_targets(
+    credential: Credential | None,
+    *,
+    dynamic_mode: DynamicMode,
+    trigger: FollowSyncTrigger,
+) -> None:
+    """在关注流模式下尝试补齐已有目标的关注关系。
+
+    Args:
+        credential: 用于查询和修改关注关系的 B 站凭据。
+        dynamic_mode: 当前动态获取路线。
+        trigger: 发起同步的运行阶段，用于区分启动和二维码换号日志。
+    """
+    if dynamic_mode != "follow_feed":
+        return
+
+    trigger_label = "启动" if trigger == "startup" else "二维码登录"
+    targets = data_manager.get_all_targets()
+    if not targets:
+        return
+    if credential is None:
+        logger.warning(
+            f"{trigger_label}关注同步缺少有效凭据，跳过补关注: "
+            "dynamic_mode=follow_feed, "
+            f"trigger={trigger}, "
+            f"uids={sorted(target.uid for target in targets)}, "
+            "stop_reason=missing_credential, action=skip_follow_sync"
+        )
+        return
+
+    for index, target in enumerate(targets):
+        try:
+            followed = await ensure_user_followed(target.uid, credential)
+            if followed:
+                logger.info(
+                    f"{trigger_label}关注同步已关注 {target.name}({target.uid}): "
+                    f"dynamic_mode=follow_feed, trigger={trigger}, "
+                    f"uid={target.uid}, action=follow"
+                )
+        except Exception as exc:
+            if is_login_invalid_error(exc):
+                logger.warning(
+                    f"{trigger_label}关注同步发现 B 站登录已失效，停止补关注: "
+                    f"dynamic_mode=follow_feed, trigger={trigger}, uid={target.uid}, "
+                    "stop_reason=login_invalid, action=stop_follow_sync"
+                )
+                break
+            logger.warning(
+                f"{trigger_label}关注同步失败，{target.name}({target.uid}) 仍使用关注流: "
+                f"dynamic_mode=follow_feed, trigger={trigger}, uid={target.uid}, "
+                "stop_reason=follow_failed, action=continue_follow_feed, "
+                f"error={exc!r}"
+            )
+
+        if index + 1 < len(targets):
+            await asyncio.sleep(1)
+
+
+async def activate_login_credential(
+    credential: CredentialData,
+    *,
+    dynamic_mode: DynamicMode,
+    notice_ref: UserRef,
+) -> None:
+    """先同步新账号关注，再持久化凭据及登录场景。"""
+    await sync_followed_targets(
+        build_credential(credential),
+        dynamic_mode=dynamic_mode,
+        trigger="qr_login",
+    )
+    data_manager.save_login_credential(credential, notice_ref)
+    reset_login_invalid_notify_state()

nonebot_plugin_bilidyn/application/live_room_sync.py

@@ -0,0 +1,40 @@
+"""历史订阅直播间信息补全。"""
+
+import asyncio
+
+from bilibili_api import Credential
+from nonebot import logger
+
+from ..core.profile import extract_live_room_id_from_user_info
+from ..infra.auth import is_login_invalid_error
+from ..infra.bili_client import get_user_info
+from ..infra.data_manager import data_manager
+
+
+async def refresh_missing_live_room_ids(
+    credential: Credential | None = None,
+) -> None:
+    """为缺少直播间 ID 的已有订阅补全数据。"""
+    targets = [
+        target for target in data_manager.get_all_targets() if not target.live_room_id
+    ]
+
+    for target in targets:
+        try:
+            info = await get_user_info(target.uid, credential)
+            live_room_id = extract_live_room_id_from_user_info(info)
+            if live_room_id is None:
+                logger.debug(f"{target.name}({target.uid}) 没有可用的直播间")
+            else:
+                data_manager.update_target(target.uid, live_room_id=live_room_id)
+                logger.info(
+                    f"启动时已补全 {target.name}({target.uid}) 的直播间 ID: "
+                    f"{live_room_id}"
+                )
+        except Exception as exc:
+            if is_login_invalid_error(exc):
+                logger.warning("启动补全直播间信息时发现 B 站登录已失效，跳过本轮补全")
+                return
+            logger.exception(f"启动补全 {target.name}({target.uid}) 直播间信息失败")
+
+        await asyncio.sleep(1)

nonebot_plugin_bilidyn/bot/__init__.py

@@ -0,0 +1,7 @@
+"""NoneBot 命令、生命周期与主动任务接入层。"""
+
+from . import handlers as handlers
+from . import lifecycle as lifecycle
+from . import matcher as matcher
+
+__all__ = ("handlers", "lifecycle", "matcher")

nonebot_plugin_bilidyn/bot/group_cleanup.py

@@ -0,0 +1,185 @@
+"""群订阅归属的可达性检测与显式清理。"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import TypeAlias
+
+from nonebot import get_bots, logger
+from nonebot.adapters import Bot
+from nonebot_plugin_uninfo import SceneType, get_interface
+from nonebot_plugin_uniref import (
+    SceneRef,
+    TargetUnavailableError,
+    encode_ref,
+    ref_to_target,
+)
+
+from ..infra.data_manager import data_manager
+
+_BotIdentity: TypeAlias = tuple[str, str]
+
+
+@dataclass(slots=True)
+class GroupReachabilityScan:
+    """群订阅归属的可达性扫描结果。"""
+
+    stale_refs: list[SceneRef]
+    checked_refs: list[SceneRef]
+    skipped_refs: list[SceneRef]
+
+
+def _iter_active_bots() -> list[Bot]:
+    return list(get_bots().values())
+
+
+def _bot_identity(bot: Bot) -> _BotIdentity:
+    return bot.adapter.get_name(), str(bot.self_id)
+
+
+def _bot_can_route(ref: SceneRef, bot: Bot) -> bool:
+    """判断在线 Bot 是否位于该 Ref 允许的路由范围内。"""
+    try:
+        ref_to_target(ref, bot=bot)
+    except (TargetUnavailableError, TypeError, ValueError):
+        return False
+    return True
+
+
+async def _fetch_group_ids_for_bot(
+    bot: Bot,
+    *,
+    force_refresh: bool = False,
+) -> set[str] | None:
+    interface = get_interface(bot)
+    if interface is None:
+        return None
+    if force_refresh:
+        interface.fetcher.clean()
+    try:
+        return {
+            scene.id
+            async for scene in interface.fetcher.query_scenes(bot, SceneType.GROUP)
+        }
+    except NotImplementedError:
+        return None
+    except Exception:
+        logger.exception(f"读取 Bot {bot.self_id} 的群场景列表失败，本轮改用逐群检查")
+        return None
+
+
+async def _check_group_reachability(
+    bot: Bot,
+    group_id: str,
+) -> tuple[bool, bool | None]:
+    interface = get_interface(bot)
+    if interface is None:
+        return False, None
+    try:
+        scene = await interface.fetcher.query_scene(bot, SceneType.GROUP, group_id)
+    except NotImplementedError:
+        return False, None
+    except Exception:
+        logger.exception(
+            f"查询 Bot {bot.self_id} 下群 {group_id} 的可达性失败，本轮将跳过该群"
+        )
+        return True, None
+    return True, scene is not None
+
+
+def _configured_group_refs(refs: Iterable[SceneRef] | None) -> list[SceneRef]:
+    if refs is None:
+        result = [ref for ref, _ in data_manager.list_group_destinations()]
+    else:
+        result = [ref for ref in refs if data_manager.get_destination(ref) is not None]
+    return sorted(result, key=encode_ref)
+
+
+async def scan_stale_group_refs(
+    refs: Iterable[SceneRef] | None = None,
+    *,
+    force_refresh: bool = False,
+) -> GroupReachabilityScan:
+    """扫描当前配置中能够确认失效的群订阅归属。
+
+    同一 Ref 可能由多个在线 Bot 路由。只有所有兼容 Bot 都能完成检查且均不再
+    访问该群时，才把它判定为失效；任一兼容 Bot 可访问或无法检查都会阻止误删。
+    """
+    configured_refs = _configured_group_refs(refs)
+    active_bots = _iter_active_bots()
+    compatible_bots_by_ref = {
+        ref: [bot for bot in active_bots if _bot_can_route(ref, bot)]
+        for ref in configured_refs
+    }
+    compatible_bots = {
+        _bot_identity(bot): bot
+        for bots in compatible_bots_by_ref.values()
+        for bot in bots
+    }
+    group_ids_by_bot = {
+        _bot_identity(bot): await _fetch_group_ids_for_bot(
+            bot,
+            force_refresh=force_refresh,
+        )
+        for bot in compatible_bots.values()
+    }
+
+    stale_refs: list[SceneRef] = []
+    checked_refs: list[SceneRef] = []
+    skipped_refs: list[SceneRef] = []
+
+    for ref in configured_refs:
+        ref_bots = compatible_bots_by_ref[ref]
+        if not ref_bots:
+            skipped_refs.append(ref)
+            continue
+
+        reachable = False
+        uncertain = False
+        checked_any = False
+        for bot in ref_bots:
+            group_ids = group_ids_by_bot[_bot_identity(bot)]
+            if group_ids is not None:
+                checked_any = True
+                if ref.id in group_ids:
+                    reachable = True
+                    break
+                continue
+
+            supported, exists = await _check_group_reachability(bot, ref.id)
+            if not supported or exists is None:
+                uncertain = True
+                continue
+            checked_any = True
+            if exists:
+                reachable = True
+                break
+
+        if reachable:
+            checked_refs.append(ref)
+        elif uncertain or not checked_any:
+            skipped_refs.append(ref)
+        else:
+            checked_refs.append(ref)
+            stale_refs.append(ref)
+
+    return GroupReachabilityScan(
+        stale_refs=stale_refs,
+        checked_refs=checked_refs,
+        skipped_refs=skipped_refs,
+    )
+
+
+def cleanup_stale_groups(refs: Iterable[SceneRef]) -> tuple[int, int]:
+    """删除失效群订阅归属，并返回归属数与订阅数。"""
+    removed_groups = 0
+    removed_subscriptions = 0
+    for ref in refs:
+        destination = data_manager.get_destination(ref)
+        if destination is None:
+            continue
+        removed_subscriptions += len(destination.subscriptions)
+        if data_manager.delete_destination(ref):
+            removed_groups += 1
+    return removed_groups, removed_subscriptions

nonebot_plugin_bilidyn/bot/handlers/__init__.py

@@ -0,0 +1,9 @@
+"""按功能注册 Bili 命令处理器。"""
+
+from . import cleanup as cleanup
+from . import dynamics as dynamics
+from . import help as help
+from . import login as login
+from . import subscriptions as subscriptions
+
+__all__ = ("cleanup", "dynamics", "help", "login", "subscriptions")