bpi-py 0.3.0__py3-none-any.whl

bpi/__init__.py

@@ -0,0 +1,29 @@
+from .client import AsyncBpiClient
+from .errors import (
+    ApiError,
+    AuthenticationError,
+    BpiError,
+    ClientClosedError,
+    HttpStatusError,
+    InvalidParameterError,
+    MissingDataError,
+    ResponseDecodeError,
+    TransportError,
+    UnsupportedResponseError,
+)
+from .session import Account
+
+__all__ = [
+    "Account",
+    "ApiError",
+    "AsyncBpiClient",
+    "AuthenticationError",
+    "BpiError",
+    "ClientClosedError",
+    "HttpStatusError",
+    "InvalidParameterError",
+    "MissingDataError",
+    "ResponseDecodeError",
+    "TransportError",
+    "UnsupportedResponseError",
+]

bpi/_core/__init__.py

@@ -0,0 +1 @@
+"""Internal request and decoding implementation."""

bpi/_core/params.py

@@ -0,0 +1,21 @@
+"""Shared parameter validation for handwritten and generated read methods."""
+
+import re
+
+from bpi.errors import InvalidParameterError
+
+
+def integer(value: int, name: str, minimum: int = 1) -> str:
+    if type(value) is not int or value < minimum:
+        raise InvalidParameterError(f"{name} must be an integer >= {minimum}")
+    return str(value)
+
+
+def video_id(aid: int | None, bvid: str | None, *, play: bool = False) -> dict[str, str]:
+    if (aid is None) == (bvid is None):
+        raise InvalidParameterError("Provide exactly one of aid or bvid")
+    if aid is not None:
+        return {"avid" if play else "aid": integer(aid, "aid")}
+    if not isinstance(bvid, str) or not re.fullmatch(r"BV[0-9A-Za-z]{10}", bvid):
+        raise InvalidParameterError("bvid must be a 12-character BV identifier")
+    return {"bvid": bvid}

bpi/_core/response.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import json
+from typing import Any, TypeVar
+
+from pydantic import BaseModel, ConfigDict, TypeAdapter, ValidationError
+
+from bpi.errors import ApiError, AuthenticationError, MissingDataError, ResponseDecodeError
+
+T = TypeVar("T")
+
+
+class ResponseModel(BaseModel):
+    model_config = ConfigDict(
+        extra="ignore", strict=True, populate_by_name=True, hide_input_in_errors=True
+    )
+
+
+def envelope(body: bytes, *, allow_anonymous_wbi: bool = False) -> dict[str, Any]:
+    try:
+        raw = json.loads(body)
+    except (ValueError, UnicodeError):
+        raise ResponseDecodeError(body) from None
+    if not isinstance(raw, dict):
+        raise ResponseDecodeError(body)
+    code = raw.get("code", raw.get("errno"))
+    if type(code) is not int:
+        raise ResponseDecodeError(body)
+    if code != 0 and not (allow_anonymous_wbi and code == -101):
+        message = raw.get("message", raw.get("msg", raw.get("showMsg", "")))
+        error_type = AuthenticationError if ApiError(code).requires_login() else ApiError
+        raise error_type(code, message if isinstance(message, str) else "")
+    return raw
+
+
+def decode_payload(
+    body: bytes,
+    adapter: TypeAdapter[T],
+    *,
+    allow_anonymous_wbi: bool = False,
+    allow_missing: bool = False,
+) -> T:
+    raw = envelope(body, allow_anonymous_wbi=allow_anonymous_wbi)
+    value = raw.get("data", raw.get("result"))
+    if value is None and not allow_missing:
+        raise MissingDataError("Successful response has no payload")
+    try:
+        return adapter.validate_python(value)
+    except ValidationError:
+        # Suppress the default chain: ValidationError may contain account or response input.
+        raise ResponseDecodeError(body) from None

bpi/_generated/__init__.py

@@ -0,0 +1 @@
+"""Generated read methods and models; see migration/batch-3.json."""

bpi/_generated/audio_client.py

@@ -0,0 +1,217 @@
+# Generated by tools.migration.generate; edit migration/batch-*.json or the generator.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import ConfigDict, TypeAdapter
+
+from bpi._core.params import integer
+from bpi.errors import InvalidParameterError
+
+from .audio_models import (
+    AudioCollection,
+    AudioCollectionsListData,
+    AudioHotMenuData,
+    AudioInfoData,
+    AudioMemberType,
+    AudioRankDetailData,
+    AudioRankMenuData,
+    AudioRankMusicListData,
+    AudioRankPeriodData,
+    AudioStatusNumberData,
+    AudioStreamUrlData,
+    AudioStreamUrlWebData,
+    AudioTag,
+)
+
+if TYPE_CHECKING:
+    from bpi.client import AsyncBpiClient
+
+_INFO = TypeAdapter(AudioInfoData)
+_TAGS = TypeAdapter(list[AudioTag])
+_MEMBERS = TypeAdapter(list[AudioMemberType])
+_LYRIC = TypeAdapter(str, config=ConfigDict(strict=True))
+_STATUS_NUMBER = TypeAdapter(AudioStatusNumberData)
+_COLLECTION_STATUS = TypeAdapter(bool, config=ConfigDict(strict=True))
+_COIN_COUNT = TypeAdapter(int, config=ConfigDict(strict=True))
+_STREAM_URL_WEB = TypeAdapter(AudioStreamUrlWebData)
+_STREAM_URL = TypeAdapter(AudioStreamUrlData)
+_COLLECTIONS_LIST = TypeAdapter(AudioCollectionsListData)
+_COLLECTION_INFO: TypeAdapter[AudioCollection | None] = TypeAdapter(AudioCollection | None)
+_HOT_MENU = TypeAdapter(AudioHotMenuData)
+_RANK_MENU = TypeAdapter(AudioRankMenuData)
+_RANK_PERIOD = TypeAdapter(AudioRankPeriodData)
+_RANK_DETAIL = TypeAdapter(AudioRankDetailData)
+_RANK_MUSIC_LIST = TypeAdapter(AudioRankMusicListData)
+
+
+class AudioReadMethods:
+    def __init__(self, client: AsyncBpiClient) -> None:
+        self._client = client
+
+    async def info(self, *, sid: int) -> AudioInfoData:
+        """audio.info; public-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/song/info", params, _INFO, host="www.bilibili.com"
+        )
+
+    async def tags(self, *, sid: int) -> list[AudioTag]:
+        """audio.tags; public-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/tag/song", params, _TAGS, host="www.bilibili.com"
+        )
+
+    async def members(self, *, sid: int) -> list[AudioMemberType]:
+        """audio.members; public-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/member/song", params, _MEMBERS, host="www.bilibili.com"
+        )
+
+    async def lyric(self, *, sid: int) -> str:
+        """audio.lyric; public-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/song/lyric", params, _LYRIC, host="www.bilibili.com"
+        )
+
+    async def status_number(self, *, sid: int) -> AudioStatusNumberData:
+        """audio.status_number; public-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/stat/song", params, _STATUS_NUMBER, host="www.bilibili.com"
+        )
+
+    async def collection_status(self, *, sid: int) -> bool:
+        """audio.collection_status; authenticated-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/collections/songs-coll",
+            params,
+            _COLLECTION_STATUS,
+            host="www.bilibili.com",
+        )
+
+    async def coin_count(self, *, sid: int) -> int:
+        """audio.coin_count; authenticated-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/coin/audio", params, _COIN_COUNT, host="www.bilibili.com"
+        )
+
+    async def stream_url_web(
+        self, *, sid: int, quality: int = 2, privilege: int = 2
+    ) -> AudioStreamUrlWebData:
+        """audio.stream_url_web; public-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        params["quality"] = integer(quality, "quality", 0)
+        if quality not in [0, 1, 2, 3]:
+            raise InvalidParameterError("Unsupported quality")
+        params["privilege"] = integer(privilege, "privilege", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/url", params, _STREAM_URL_WEB, host="www.bilibili.com"
+        )
+
+    async def stream_url(
+        self,
+        *,
+        song_id: int,
+        quality: int,
+        privilege: int = 2,
+        mid: int = 2,
+        platform: str = "android",
+    ) -> AudioStreamUrlData:
+        """audio.stream_url; public-read."""
+        params: dict[str, str] = {}
+        params["songid"] = integer(song_id, "song_id", 1)
+        params["quality"] = integer(quality, "quality", 0)
+        if quality not in [0, 1, 2, 3]:
+            raise InvalidParameterError("Unsupported quality")
+        params["privilege"] = integer(privilege, "privilege", 1)
+        params["mid"] = integer(mid, "mid", 1)
+        if not isinstance(platform, str):
+            raise InvalidParameterError("platform must be a string")
+        params["platform"] = platform
+        params["platform"] = platform.strip()
+        if not params["platform"]:
+            raise InvalidParameterError("platform cannot be blank")
+        return await self._client._get_payload("/audio/music-service-c/url", params, _STREAM_URL)
+
+    async def collections_list(self, *, page: int, page_size: int) -> AudioCollectionsListData:
+        """audio.collections_list; authenticated-read."""
+        params: dict[str, str] = {}
+        params["pn"] = integer(page, "page", 1)
+        params["ps"] = integer(page_size, "page_size", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/collections/list",
+            params,
+            _COLLECTIONS_LIST,
+            host="www.bilibili.com",
+        )
+
+    async def collection_info(self, *, sid: int) -> AudioCollection | None:
+        """audio.collection_info; authenticated-read."""
+        params: dict[str, str] = {}
+        params["sid"] = integer(sid, "sid", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/collections/info",
+            params,
+            _COLLECTION_INFO,
+            host="www.bilibili.com",
+            optional=True,
+        )
+
+    async def hot_menu(self, *, page: int, page_size: int) -> AudioHotMenuData:
+        """audio.hot_menu; public-read."""
+        params: dict[str, str] = {}
+        params["pn"] = integer(page, "page", 1)
+        params["ps"] = integer(page_size, "page_size", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/menu/hit", params, _HOT_MENU, host="www.bilibili.com"
+        )
+
+    async def rank_menu(self, *, page: int, page_size: int) -> AudioRankMenuData:
+        """audio.rank_menu; public-read."""
+        params: dict[str, str] = {}
+        params["pn"] = integer(page, "page", 1)
+        params["ps"] = integer(page_size, "page_size", 1)
+        return await self._client._get_payload(
+            "/audio/music-service-c/web/menu/rank", params, _RANK_MENU, host="www.bilibili.com"
+        )
+
+    async def rank_period(self, *, list_type: int) -> AudioRankPeriodData:
+        """audio.rank_period; public-read."""
+        params: dict[str, str] = {}
+        params["list_type"] = integer(list_type, "list_type", 1)
+        params["csrf"] = self._client._csrf(host="api.bilibili.com", optional=True)
+        return await self._client._get_payload(
+            "/x/copyright-music-publicity/toplist/all_period", params, _RANK_PERIOD
+        )
+
+    async def rank_detail(self, *, list_id: int) -> AudioRankDetailData:
+        """audio.rank_detail; public-read."""
+        params: dict[str, str] = {}
+        params["list_id"] = integer(list_id, "list_id", 1)
+        params["csrf"] = self._client._csrf(host="api.bilibili.com", optional=True)
+        return await self._client._get_payload(
+            "/x/copyright-music-publicity/toplist/detail", params, _RANK_DETAIL
+        )
+
+    async def rank_music_list(self, *, list_id: int) -> AudioRankMusicListData:
+        """audio.rank_music_list; public-read."""
+        params: dict[str, str] = {}
+        params["list_id"] = integer(list_id, "list_id", 1)
+        params["csrf"] = self._client._csrf(host="api.bilibili.com", optional=True)
+        return await self._client._get_payload(
+            "/x/copyright-music-publicity/toplist/music_list", params, _RANK_MUSIC_LIST
+        )

bpi/_generated/audio_models.py

@@ -0,0 +1,320 @@
+# Generated by tools.migration.generate; edit migration/batch-*.json or the generator.
+from __future__ import annotations
+
+import builtins
+
+from pydantic import Field, JsonValue
+
+from bpi._core.response import ResponseModel
+
+
+class AudioStatistic(ResponseModel):
+    """Source: src/audio/info.rs:66:AudioStatistic."""
+
+    sid: int
+    play: int
+    collect: int
+    comment: int
+    share: int
+
+
+class AudioVipInfo(ResponseModel):
+    """Source: src/audio/info.rs:81:AudioVipInfo."""
+
+    type: int
+    status: int
+    due_date: int
+    vip_pay_type: int
+
+
+class AudioInfoData(ResponseModel):
+    """Source: src/audio/info.rs:9:AudioInfoData."""
+
+    id: int
+    uid: int
+    uname: str
+    author: str
+    title: str
+    cover: str
+    intro: str
+    lyric: str
+    crtype: int
+    duration: int
+    passtime: int
+    curtime: int
+    aid: int
+    bvid: str
+    cid: int
+    msid: int
+    attr: int
+    limit: int
+    activity_id: int = Field(alias="activityId")
+    limitdesc: str
+    ctime: JsonValue | None = Field(default=None)
+    statistic: AudioStatistic
+    vip_info: AudioVipInfo = Field(alias="vipInfo")
+    collect_ids: list[int] = Field(alias="collectIds")
+    coin_num: int
+
+
+class AudioTag(ResponseModel):
+    """Source: src/audio/info.rs:94:AudioTag."""
+
+    type: str
+    subtype: int
+    key: int
+    info: str
+
+
+class AudioMember(ResponseModel):
+    """Source: src/audio/info.rs:116:AudioMember."""
+
+    mid: int
+    name: str
+    member_id: int
+
+
+class AudioMemberType(ResponseModel):
+    """Source: src/audio/info.rs:107:AudioMemberType."""
+
+    list: builtins.list[AudioMember]
+    type: int
+
+
+class AudioStatusNumberData(ResponseModel):
+    """Source: src/audio/status_number.rs:7:AudioStatusNumberData."""
+
+    sid: int
+    play: int
+    collect: int
+    comment: int
+    share: int
+
+
+class AudioStreamUrlWebData(ResponseModel):
+    """Source: src/audio/musicstream_url.rs:26:AudioStreamUrlWebData."""
+
+    sid: int
+    type: int
+    info: str
+    timeout: int
+    size: int
+    cdns: list[str]
+    qualities: JsonValue | None = Field(default=None)
+    title: str
+    cover: str
+
+
+class AudioQualityInfo(ResponseModel):
+    """Source: src/audio/musicstream_url.rs:52:AudioQualityInfo."""
+
+    type: int
+    desc: str
+    size: int
+    bps: str
+    tag: str
+    require: int
+    requiredesc: str
+
+
+class AudioStreamUrlData(ResponseModel):
+    """Source: src/audio/musicstream_url.rs:39:AudioStreamUrlData."""
+
+    sid: int
+    type: int
+    info: str
+    timeout: int
+    size: int
+    cdns: list[str]
+    qualities: list[AudioQualityInfo]
+    title: str
+    cover: str
+
+
+class AudioCollectionStatistic(ResponseModel):
+    """Source: src/audio/music_list.rs:42:AudioCollectionStatistic."""
+
+    sid: int
+    play: int
+    collect: int
+    comment: int | None = Field(default=None)
+    share: int
+
+
+class AudioCollection(ResponseModel):
+    """Source: src/audio/music_list.rs:24:AudioCollection."""
+
+    id: int
+    uid: int
+    uname: str
+    title: str
+    type: int
+    published: int
+    cover: str
+    ctime: int
+    song: int
+    desc: str
+    sids: list[int]
+    menu_id: int = Field(alias="menuId")
+    statistic: AudioCollectionStatistic
+
+
+class AudioCollectionsListData(ResponseModel):
+    """Source: src/audio/music_list.rs:7:AudioCollectionsListData."""
+
+    cur_page: int = Field(alias="curPage")
+    page_count: int = Field(alias="pageCount")
+    total_size: int = Field(alias="totalSize")
+    page_size: int = Field(alias="pageSize")
+    data: list[AudioCollection]
+
+
+class AudioHotMenuStatistic(ResponseModel):
+    """Source: src/audio/music_list.rs:104:AudioHotMenuStatistic."""
+
+    sid: int
+    play: int
+    collect: int
+    comment: int
+    share: int
+
+
+class AudioHotMenu(ResponseModel):
+    """Source: src/audio/music_list.rs:68:AudioHotMenu."""
+
+    menu_id: int = Field(alias="menuId")
+    uid: int
+    uname: str
+    title: str
+    cover: str
+    intro: str
+    type: int
+    off: int
+    ctime: int
+    curtime: int
+    statistic: AudioHotMenuStatistic
+    snum: int
+    attr: int
+    is_default: int = Field(alias="isDefault")
+    collection_id: int = Field(alias="collectionId")
+
+
+class AudioHotMenuData(ResponseModel):
+    """Source: src/audio/music_list.rs:51:AudioHotMenuData."""
+
+    cur_page: int = Field(alias="curPage")
+    page_count: int = Field(alias="pageCount")
+    total_size: int = Field(alias="totalSize")
+    page_size: int = Field(alias="pageSize")
+    data: list[AudioHotMenu]
+
+
+class AudioRankMenuStatistic(ResponseModel):
+    """Source: src/audio/music_list.rs:168:AudioRankMenuStatistic."""
+
+    sid: int
+    play: int
+    collect: int
+    comment: int
+    share: int
+
+
+class AudioRankItem(ResponseModel):
+    """Source: src/audio/music_list.rs:177:AudioRankItem."""
+
+    id: int
+    title: str
+    duration: int
+
+
+class AudioRankMenu(ResponseModel):
+    """Source: src/audio/music_list.rs:130:AudioRankMenu."""
+
+    menu_id: int = Field(alias="menuId")
+    uid: int
+    uname: str
+    title: str
+    cover: str
+    intro: str
+    type: int
+    off: int
+    ctime: int
+    curtime: int
+    statistic: AudioRankMenuStatistic
+    snum: int
+    attr: int
+    is_default: int = Field(alias="isDefault")
+    collection_id: int = Field(alias="collectionId")
+    audios: list[AudioRankItem]
+
+
+class AudioRankMenuData(ResponseModel):
+    """Source: src/audio/music_list.rs:113:AudioRankMenuData."""
+
+    cur_page: int = Field(alias="curPage")
+    page_count: int = Field(alias="pageCount")
+    total_size: int = Field(alias="totalSize")
+    page_size: int = Field(alias="pageSize")
+    data: list[AudioRankMenu]
+
+
+class AudioRankPeriod(ResponseModel):
+    """Source: src/audio/rank.rs:20:AudioRankPeriod."""
+
+    id: int = Field(alias="ID")
+    priod: int
+    publish_time: int
+
+
+class AudioRankPeriodData(ResponseModel):
+    """Source: src/audio/rank.rs:15:AudioRankPeriodData."""
+
+    list: dict[str, list[AudioRankPeriod]]
+
+
+class AudioRankDetailData(ResponseModel):
+    """Source: src/audio/rank.rs:28:AudioRankDetailData."""
+
+    listen_fid: int
+    all_fid: int
+    fav_mid: int
+    cover_url: str
+    is_subscribe: bool
+    listen_count: int
+
+
+class AudioRankMusicItem(ResponseModel):
+    """Source: src/audio/rank.rs:43:AudioRankMusicItem."""
+
+    music_id: str
+    music_title: str
+    singer: str
+    album: str
+    mv_aid: int
+    mv_bvid: str
+    mv_cover: str
+    heat: int
+    rank: int
+    can_listen: bool
+    recommendation: str
+    creation_aid: int
+    creation_bvid: str
+    creation_cover: str
+    creation_title: str
+    creation_up: int
+    creation_nickname: str
+    creation_duration: int
+    creation_play: int
+    creation_reason: str
+    achievements: list[str]
+    material_id: int
+    material_use_num: int
+    material_duration: int
+    material_show: int
+    song_type: int
+
+
+class AudioRankMusicListData(ResponseModel):
+    """Source: src/audio/rank.rs:38:AudioRankMusicListData."""
+
+    list: builtins.list[AudioRankMusicItem]