bbdown 0.0.1__py3-none-any.whl

bbdown/__init__.py

@@ -0,0 +1,5 @@
+"""BBDown Python 包。"""
+
+from bbdown._version import __version__
+
+__all__ = ["__version__"]

bbdown/__main__.py

@@ -0,0 +1,5 @@
+"""支持通过 ``python -m bbdown`` 启动命令行。"""
+
+from bbdown.cli import main
+
+raise SystemExit(main())

bbdown/_version.py

@@ -0,0 +1,3 @@
+"""项目版本的单一源码。"""
+
+__version__ = "0.0.1"

bbdown/app_api.py

@@ -0,0 +1,270 @@
+"""APP Proto2 播放请求、gRPC 帧与网页式 DASH 响应转换。"""
+
+from __future__ import annotations
+
+import base64
+import gzip
+import json
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Protocol
+
+os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
+
+from google.protobuf.message import Message
+
+from bbdown.proto import (
+    device_pb2,
+    fawkesreq_pb2,
+    locale_pb2,
+    metadata_pb2,
+    network_pb2,
+    playviewreply_pb2,
+    playviewreq_pb2,
+)
+
+UGC_PLAY_URL = "https://grpc.biliapi.net/bilibili.app.playurl.v1.PlayURL/PlayView"
+PGC_PLAY_URL = "https://app.bilibili.com/bilibili.pgc.gateway.player.v2.PlayURL/PlayView"
+APP_BUILD = 7_320_200
+APP_VERSION = "7.32.0"
+APP_CHANNEL = "xiaomi_cn_tv.danmaku.bili_zm20200902"
+SPMID = "main.ugc-video-detail.0.0"
+FROM_SPMID = "main.my-history.0.0"
+GRPC_HEADER_SIZE = 5
+
+
+class AppHTTPClient(Protocol):
+    """APP 播放层需要的最小二进制 POST 接口。"""
+
+    async def post_bytes(
+        self,
+        url: str,
+        body: bytes,
+        *,
+        headers: Mapping[str, str] | None = None,
+    ) -> bytes:
+        """发送 gRPC 请求并返回原始响应体。"""
+        ...
+
+
+class GRPCFrameError(ValueError):
+    """表示 gRPC message frame 缺失、截断或压缩标志无效。"""
+
+
+@dataclass(frozen=True, slots=True)
+class AppPlayRequest:
+    """APP PlayView 请求的业务字段。"""
+
+    aid: str
+    cid: str
+    episode_id: str
+    bangumi: bool
+    encoding: str
+
+
+async def request_play_view(
+    client: AppHTTPClient,
+    request: AppPlayRequest,
+    *,
+    access_token: str,
+) -> str:
+    """请求 UGC 或 PGC APP 播放接口并返回现有解析器所需 JSON。"""
+    identifier = request.episode_id if request.bangumi else request.aid
+    payload = build_play_payload(
+        int(identifier),
+        int(request.cid),
+        encoding="HEVC" if request.bangumi else request.encoding,
+    )
+    response = await client.post_bytes(
+        PGC_PLAY_URL if request.bangumi else UGC_PLAY_URL,
+        pack_grpc_message(payload),
+        headers=build_app_headers(access_token),
+    )
+    reply = playviewreply_pb2.PlayViewReply()
+    reply.ParseFromString(unpack_grpc_message(response))
+    return play_reply_to_json(reply)
+
+
+def build_play_payload(aid: int, cid: int, *, encoding: str) -> bytes:
+    """序列化原版固定 qn/fnval/host 与编码偏好的 PlayViewReq。"""
+    request = playviewreq_pb2.PlayViewReq(
+        epId=aid,
+        cid=cid,
+        qn=127,
+        fnval=4048,
+        fourk=True,
+        spmid=SPMID,
+        fromSpmid=FROM_SPMID,
+        preferCodecType=_codec_type(encoding),
+        download=0,
+        forceHost=2,
+    )
+    return request.SerializeToString(deterministic=True)
+
+
+def pack_grpc_message(payload: bytes) -> bytes:
+    """将 protobuf wire bytes 压缩并封装为一条 gRPC message。"""
+    compressed = gzip.compress(payload)
+    return b"\x01" + len(compressed).to_bytes(4, "big") + compressed
+
+
+def unpack_grpc_message(frame: bytes) -> bytes:
+    """读取一条压缩或未压缩 gRPC message，并拒绝截断数据。"""
+    if len(frame) < GRPC_HEADER_SIZE:
+        raise GRPCFrameError("gRPC message frame 少于 5 字节")
+    compressed = frame[0]
+    size = int.from_bytes(frame[1:5], "big")
+    payload = frame[GRPC_HEADER_SIZE:]
+    if len(payload) < size:
+        raise GRPCFrameError(f"gRPC message 声明 {size} 字节，实际仅 {len(payload)} 字节")
+    payload = payload[:size]
+    if compressed == 1:
+        try:
+            return gzip.decompress(payload)
+        except (EOFError, OSError) as error:
+            raise GRPCFrameError("gRPC gzip message 无法解压") from error
+    if compressed == 0:
+        return payload
+    raise GRPCFrameError(f"不支持的 gRPC 压缩标志：{compressed}")
+
+
+def build_app_headers(access_token: str) -> dict[str, str]:
+    """构造与原版 AppHelper.GetHeader 相同的 gRPC 元数据。"""
+    return {
+        "Host": "grpc.biliapi.net",
+        "user-agent": (
+            "Dalvik/2.1.0 (Linux; U; Android 11; M2012K11AC Build/RKQ1.200826.002) "
+            f"{APP_VERSION} os/android model/M2012K11AC mobi_app/android "
+            f"build/{APP_BUILD} channel/{APP_CHANNEL} innerVer/{APP_BUILD} osVer/11 "
+            "network/2 grpc-java-cronet/1.36.1"
+        ),
+        "te": "trailers",
+        "x-bili-fawkes-req-bin": _protobuf_header(
+            fawkesreq_pb2.FawkesReq(appkey="android64", env="prod", sessionId="dedf8669")
+        ),
+        "x-bili-metadata-bin": _protobuf_header(
+            metadata_pb2.Metadata(
+                accessKey=access_token,
+                mobiApp="android",
+                build=APP_BUILD,
+                channel=APP_CHANNEL,
+                buvid="",
+                platform="android",
+            )
+        ),
+        "authorization": f"identify_v1 {access_token}",
+        "x-bili-device-bin": _protobuf_header(
+            device_pb2.Device(
+                appId=1,
+                build=APP_BUILD,
+                buvid="",
+                mobiApp="android",
+                platform="android",
+                channel=APP_CHANNEL,
+                brand="M2012K11AC",
+                model="Build/RKQ1.200826.002",
+                osver="11",
+            )
+        ),
+        "x-bili-network-bin": _protobuf_header(
+            network_pb2.Network(type=network_pb2.Network.WIFI, oid="46007")
+        ),
+        "x-bili-restriction-bin": "",
+        "x-bili-locale-bin": _protobuf_header(
+            locale_pb2.Locale(cLocale=locale_pb2.Locale.LocaleIds(language="zh", region="CN"))
+        ),
+        "x-bili-exps-bin": "",
+        "grpc-encoding": "gzip",
+        "grpc-accept-encoding": "identity,gzip",
+        "grpc-timeout": "17996161u",
+    }
+
+
+def play_reply_to_json(reply: playviewreply_pb2.PlayViewReply) -> str:
+    """把 PlayViewReply 映射为原版网页式 DASH JSON。"""
+    video_info = reply.videoInfo
+    duration_seconds = video_info.timelength // 1000
+    videos: list[dict[str, object]] = []
+    for stream in video_info.streamList:
+        if not stream.HasField("dashVideo"):
+            continue
+        video = stream.dashVideo
+        bandwidth = video.size * 8 // duration_seconds
+        videos.append(
+            {
+                "id": stream.streamInfo.quality,
+                "base_url": video.baseUrl,
+                "backup_url": list(video.backupUrl),
+                "bandwidth": bandwidth,
+                "codecid": video.codecid,
+            }
+        )
+
+    audios = [_audio_json(audio, "M4A") for audio in video_info.dashAudio]
+    if video_info.HasField("flac") and video_info.flac.HasField("audio"):
+        audios.append(_audio_json(video_info.flac.audio, "FLAC"))
+    if video_info.HasField("dolby") and video_info.dolby.HasField("audio"):
+        audios.append(_audio_json(video_info.dolby.audio, "E-AC-3"))
+
+    clips = []
+    if reply.HasField("business"):
+        clips = [
+            {"start": clip.start, "end": clip.end, "toastText": clip.toastText}
+            for clip in reply.business.clipInfo
+        ]
+
+    background: list[dict[str, object]] = []
+    roles: list[dict[str, object]] = []
+    if reply.HasField("playExtInfo") and reply.playExtInfo.HasField("playDubbingInfo"):
+        dubbing = reply.playExtInfo.playDubbingInfo
+        if dubbing.HasField("backgroundAudio"):
+            background = [_audio_json(audio, "M4A") for audio in dubbing.backgroundAudio.audio]
+        roles.extend(
+            {
+                "audio_id": material.audioId,
+                "title": material.title,
+                "person_name": material.personName,
+                "audio": [_audio_json(audio, "M4A") for audio in material.audio],
+            }
+            for group in dubbing.roleAudioList
+            for material in group.audioMaterialList
+        )
+
+    document = {
+        "code": 0,
+        "message": "0",
+        "ttl": 1,
+        "data": {
+            "timelength": video_info.timelength,
+            "dash": {"video": videos, "audio": audios},
+            "clip_info_list": clips,
+        },
+        "dubbing_info": {"background_audio": background, "role_audio_list": roles},
+    }
+    return json.dumps(document, ensure_ascii=False, separators=(",", ":"))
+
+
+def _codec_type(encoding: str) -> playviewreq_pb2.PlayViewReq.CodeType:
+    """把 CLI 编码名映射为 PlayViewReq.CodeType，未知值回退 HEVC。"""
+    return {
+        "AVC": playviewreq_pb2.PlayViewReq.CODE264,
+        "HEVC": playviewreq_pb2.PlayViewReq.CODE265,
+        "AV1": playviewreq_pb2.PlayViewReq.CODEAV1,
+    }.get(encoding, playviewreq_pb2.PlayViewReq.CODE265)
+
+
+def _protobuf_header(message: Message) -> str:
+    """将一个 protobuf header message 编码为 gRPC -bin Base64。"""
+    return base64.b64encode(message.SerializeToString(deterministic=True)).decode("ascii")
+
+
+def _audio_json(audio: playviewreply_pb2.DashItem, codec: str) -> dict[str, object]:
+    """把 APP DashItem 转为网页音频字段。"""
+    return {
+        "id": audio.id,
+        "base_url": audio.baseUrl,
+        "backup_url": list(audio.backupUrl),
+        "bandwidth": audio.bandwidth,
+        "codecs": codec,
+    }

bbdown/archives.py

@@ -0,0 +1,52 @@
+"""已下载 aid 归档的兼容读取与线程安全追加。"""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from bbdown.paths import get_state_home, legacy_state_directories
+
+ARCHIVE_FILE_NAME = "BBDown.archives"
+
+
+@dataclass(slots=True)
+class ArchiveStore:
+    """跨新旧位置查重，并始终向新状态目录写入。"""
+
+    state_home: Path = field(default_factory=get_state_home)
+    legacy_directories: tuple[Path, ...] = field(default_factory=legacy_state_directories)
+    _lock: threading.Lock = field(default_factory=threading.Lock, init=False, repr=False)
+
+    @property
+    def output_path(self) -> Path:
+        """返回新归档文件路径。"""
+        return self.state_home / ARCHIVE_FILE_NAME
+
+    def _paths(self) -> tuple[Path, ...]:
+        """返回新目录优先且去重后的归档候选。"""
+        candidates: Iterable[Path] = (
+            self.output_path,
+            *(directory / ARCHIVE_FILE_NAME for directory in self.legacy_directories),
+        )
+        return tuple(dict.fromkeys(path.expanduser().resolve() for path in candidates))
+
+    def contains(self, aid: str) -> bool:
+        """检查任一兼容归档是否包含完整 aid token。"""
+        with self._lock:
+            for path in self._paths():
+                try:
+                    if path.is_file() and aid in path.read_text(encoding="utf-8-sig").split("|"):
+                        return True
+                except OSError:
+                    continue
+        return False
+
+    def append(self, aid: str) -> None:
+        """按原版 ``aid|`` 格式追加到新状态目录。"""
+        with self._lock:
+            self.output_path.parent.mkdir(parents=True, exist_ok=True)
+            with self.output_path.open("a", encoding="utf-8", newline="") as stream:
+                stream.write(f"{aid}|")

bbdown/bv.py

@@ -0,0 +1,47 @@
+"""Bilibili AV 号与新版 BV 号之间的可逆转换。"""
+
+from __future__ import annotations
+
+XOR_CODE = 23_442_827_791_579
+MASK_CODE = (1 << 51) - 1
+MAX_AID = MASK_CODE + 1
+MIN_AID = 1
+BASE = 58
+BV_PAYLOAD_LENGTH = 9
+ALPHABET = "FcwAPNKTMug3GV5Lj7EJnHpWsx4tb8haYeviqBz6rkCy12mUSDQX9RdoZf"
+REVERSE_ALPHABET = {character: index for index, character in enumerate(ALPHABET)}
+
+
+def encode_bv(avid: int) -> str:
+    """把有效 AV 数字编码为包含 ``BV1`` 前缀的 BV 号。"""
+    if avid < MIN_AID:
+        raise ValueError(f"Av {avid} is smaller than {MIN_AID}")
+    if avid >= MAX_AID:
+        raise ValueError(f"Av {avid} is bigger than {MAX_AID}")
+
+    encoded = (MAX_AID | avid) ^ XOR_CODE
+    payload: list[str] = []
+    for _ in range(BV_PAYLOAD_LENGTH):
+        payload.append(ALPHABET[encoded % BASE])
+        encoded //= BASE
+    payload.reverse()
+    payload[0], payload[6] = payload[6], payload[0]
+    payload[1], payload[4] = payload[4], payload[1]
+    return "BV1" + "".join(payload)
+
+
+def decode_bv(bvid: str) -> int:
+    """把完整 BV 号解码为 AV 数字，并拒绝长度或字符无效的输入。"""
+    if len(bvid) != BV_PAYLOAD_LENGTH + 3 or bvid[:3].lower() != "bv1":
+        raise ValueError(f"Bv {bvid} must be 12 characters and start with BV1")
+
+    payload = list(bvid[3:])
+    payload[0], payload[6] = payload[6], payload[0]
+    payload[1], payload[4] = payload[4], payload[1]
+    avid = 0
+    try:
+        for character in payload:
+            avid = avid * BASE + REVERSE_ALPHABET[character]
+    except KeyError as error:
+        raise ValueError(f"Bv {bvid} contains an invalid character") from error
+    return (avid & MASK_CODE) ^ XOR_CODE

bbdown/cli.py

@@ -0,0 +1,181 @@
+"""BBDown 命令行入口。"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from collections.abc import Sequence
+from dataclasses import replace
+
+from bbdown._version import __version__
+from bbdown.config import load_config, resolve_config_path
+from bbdown.doctor import collect_diagnostics, diagnostics_succeeded, render_diagnostics
+from bbdown.login import run_login
+from bbdown.options import DownloadOptions, add_download_arguments, parse_download_options
+from bbdown.server import DEFAULT_LISTEN_URL, run_server
+from bbdown.workflow import run_download
+
+DESCRIPTION = "BBDown是一个免费且便捷高效的哔哩哔哩下载/解析软件."
+
+
+def development_preview_message(version: str) -> str | None:
+    """仅为含预发布标识的版本生成开发中提示。"""
+    if not any(character.isalpha() for character in version):
+        return None
+    return f"BBDown {version} 开发预览版：功能仍在持续验证中。"
+
+
+PREVIEW_MESSAGE = development_preview_message(__version__)
+
+
+def _add_question_mark_help(parser: argparse.ArgumentParser) -> None:
+    """添加 System.CommandLine 默认提供的 ``-?`` 帮助别名。"""
+    parser.add_argument("-?", action="help", help="show this help message and exit")
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """创建具有原版下载参数和别名的顶层参数解析器。"""
+    parser = argparse.ArgumentParser(
+        prog="BBDown",
+        description=DESCRIPTION,
+        epilog=(
+            "Commands:\n"
+            "  login    通过APP扫描二维码以登录您的WEB账号\n"
+            "  logintv  通过APP扫描二维码以登录您的TV账号\n"
+            "  serve    以服务器模式运行"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    _add_question_mark_help(parser)
+    add_download_arguments(parser)
+    parser.add_argument("--version", action="version", version=f"BBDown {__version__}")
+    return parser
+
+
+def create_doctor_parser() -> argparse.ArgumentParser:
+    """创建 ``doctor`` 子命令解析器。"""
+    parser = argparse.ArgumentParser(prog="BBDown doctor", description="检查 BBDown 运行环境")
+    _add_question_mark_help(parser)
+    return parser
+
+
+def create_serve_parser() -> argparse.ArgumentParser:
+    """创建兼容原版监听参数并提供可选安全增强的服务端解析器。"""
+    parser = argparse.ArgumentParser(prog="BBDown serve", description="以服务器模式运行")
+    _add_question_mark_help(parser)
+    parser.add_argument(
+        "-l",
+        "--listen",
+        default=DEFAULT_LISTEN_URL,
+        help=f"监听 URL（默认：{DEFAULT_LISTEN_URL}）",
+    )
+    parser.add_argument("--token", help="要求客户端使用 Bearer Token")
+    parser.add_argument(
+        "--cors-origin",
+        action="append",
+        dest="cors_origins",
+        help="允许的 CORS 来源，可重复指定",
+    )
+    return parser
+
+
+def _parse_with_config(
+    parser: argparse.ArgumentParser,
+    arguments: list[str],
+) -> DownloadOptions:
+    """载入配置选项，同时丢弃配置中的旧式位置参数。"""
+    command_options = parse_download_options(parser, arguments)
+    config_path = resolve_config_path(explicit_path=command_options.config_file)
+    loaded = load_config(config_path)
+    if loaded.error is not None or not loaded.arguments:
+        return command_options
+    config_parser = argparse.ArgumentParser(add_help=False)
+    add_download_arguments(config_parser, url_required=False)
+    try:
+        config_options = parse_download_options(config_parser, list(loaded.arguments))
+    except SystemExit:
+        return command_options
+    config_destinations = _specified_option_destinations(config_parser, loaded.arguments)
+    command_destinations = _specified_option_destinations(parser, arguments)
+    overrides = {
+        destination: getattr(config_options, destination)
+        for destination in config_destinations - command_destinations
+    }
+    return replace(command_options, **overrides)
+
+
+def _specified_option_destinations(
+    parser: argparse.ArgumentParser,
+    arguments: Sequence[str],
+) -> set[str]:
+    """返回参数序列显式出现的选项目标，不把位置参数算作配置。"""
+    actions = parser._option_string_actions
+    destinations: set[str] = set()
+    for argument in arguments:
+        option = argument.split("=", maxsplit=1)[0]
+        action = actions.get(option)
+        if action is not None:
+            destinations.add(action.dest)
+    return destinations
+
+
+def _run_login_command(mode: str) -> int:
+    """运行二维码登录，并把成功、过期或取消映射为稳定退出码。"""
+    try:
+        result = asyncio.run(run_login(mode))
+    except KeyboardInterrupt:
+        print("登录已取消", file=sys.stderr)
+        return 130
+    except Exception as error:
+        print(str(error), file=sys.stderr)
+        return 1
+    return 0 if result.succeeded else 1
+
+
+def main(argv: Sequence[str] | None = None) -> int:  # noqa: PLR0911
+    """运行 BBDown 命令行并返回进程退出码。"""
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    if arguments and arguments[0] == "doctor":
+        create_doctor_parser().parse_args(arguments[1:])
+        results = collect_diagnostics()
+        print(render_diagnostics(results))
+        return 0 if diagnostics_succeeded(results) else 1
+    if arguments == ["login"]:
+        return _run_login_command("web")
+    if arguments == ["logintv"]:
+        return _run_login_command("tv")
+    if arguments and arguments[0] == "serve":
+        serve_options = create_serve_parser().parse_args(arguments[1:])
+        try:
+            run_server(
+                serve_options.listen,
+                token=serve_options.token,
+                cors_origins=serve_options.cors_origins,
+            )
+        except KeyboardInterrupt:
+            print("服务已停止", file=sys.stderr)
+            return 130
+        except (OSError, ValueError) as error:
+            print(str(error), file=sys.stderr)
+            return 1
+        return 0
+
+    if not arguments:
+        print("Required argument missing for command: 'BBDown'.", file=sys.stderr)
+        print("请使用 BBDown --help 查看帮助", file=sys.stderr)
+        return 1
+
+    parser = create_parser()
+    options = _parse_with_config(parser, arguments)
+    if PREVIEW_MESSAGE is not None:
+        print(PREVIEW_MESSAGE, file=sys.stderr)
+    try:
+        asyncio.run(run_download(options, arguments))
+    except KeyboardInterrupt:
+        print("任务已取消", file=sys.stderr)
+        return 130
+    except Exception as error:
+        print(str(error), file=sys.stderr)
+        return 1
+    return 0

bbdown/config.py

@@ -0,0 +1,63 @@
+"""BBDown 配置文件的发现与 token 解析。"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+from bbdown.paths import get_state_home, legacy_state_directories
+
+CONFIG_FILE_NAME = "BBDown.config"
+
+
+@dataclass(frozen=True, slots=True)
+class LoadedConfig:
+    """表示一次不会抛出文件系统异常的配置读取结果。"""
+
+    path: Path | None
+    arguments: tuple[str, ...]
+    error: OSError | None = None
+
+
+def resolve_config_path(
+    *,
+    explicit_path: str | Path | None = None,
+    state_home: Path | None = None,
+    legacy_directories: Iterable[Path] | None = None,
+) -> Path | None:
+    """按显式路径、新状态目录、原版目录的优先级寻找配置文件。"""
+    if explicit_path is not None:
+        return Path(explicit_path).expanduser()
+
+    home = get_state_home() if state_home is None else state_home
+    legacy = legacy_state_directories() if legacy_directories is None else legacy_directories
+    candidates = (home / CONFIG_FILE_NAME, *(path / CONFIG_FILE_NAME for path in legacy))
+    return next((path for path in candidates if path.is_file()), None)
+
+
+def parse_config_lines(lines: Iterable[str]) -> tuple[str, ...]:
+    """按原版规则把每行配置展开为命令行 token。"""
+    arguments: list[str] = []
+    for line in lines:
+        line_without_newline = line.rstrip("\r\n")
+        if not line_without_newline or line_without_newline.startswith("#"):
+            continue
+        trimmed = line_without_newline.strip()
+        if trimmed.startswith("-") and " " in trimmed:
+            option, value = trimmed.split(" ", maxsplit=1)
+            arguments.extend((option, value.strip(" ").strip('"')))
+        else:
+            arguments.append(trimmed.strip('"'))
+    return tuple(arguments)
+
+
+def load_config(path: Path | None) -> LoadedConfig:
+    """读取配置；文件不存在或读取失败时返回可检查的结果。"""
+    if path is None or not path.is_file():
+        return LoadedConfig(path=path, arguments=())
+    try:
+        lines = path.read_text(encoding="utf-8-sig").splitlines()
+    except OSError as error:
+        return LoadedConfig(path=path, arguments=(), error=error)
+    return LoadedConfig(path=path, arguments=parse_config_lines(lines))