picaapi 1.0.0__py2.py3-none-any.whl

picaapi/__init__.py

@@ -0,0 +1,23 @@
+''' 这个，不需要了
+
+from .client import *
+from .objects import *
+from .error import * 
+from .downloader import *
+
+
+__all__ = [
+    'Client',
+    'Picture',
+    'ComicPicture',
+    'User',
+    'Profile',
+    'Comic',
+    'ComicDetailed',
+    'Page',
+    'Category',
+    'PicaAPIError',
+    'Downloader'
+]
+
+'''

picaapi/base.py

@@ -0,0 +1,88 @@
+import hashlib
+import random
+import time
+from enum import Enum
+
+
+class Gender(Enum):
+    MALE = 'm'
+    FEMALE = 'f'
+    BOT = 'bot'
+
+
+def random_str(length = 32) -> str:
+    """
+    生成随机的Nonce字串。
+
+    Args:
+        length(str, optional): 字串长度，默认32
+
+    Returns:
+        str: Nonce字串
+    """
+    lib = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678'
+    result = ''
+    for _ in range(0, length):
+        result += lib[int(random.random() * 48)]
+    return result
+
+
+def make_signature(url_dir: str, stime: str, method: str, nonce: str) -> str:
+    """
+    生成哔咔API签名。
+
+    Args:
+        url_dir(str): 请求路径（包含URL参数，没有前导斜杠）
+        stime(str): 以秒计的时间戳
+        method(str): 请求方法
+        nonce(str): 随机密钥
+
+    Returns:
+        str: Signature签名
+    """
+    ready = url_dir + stime + nonce + method + 'C69BAF41DA5ABD1FFEDC6D2FEA56B'
+    rb = ready.lower().encode()
+    key = b'~d}$Q7$eIni=V)9\\RK/P.RM4;9[7|@/CA}b~OW!3?EV`:<>M7pddUBL5n|0/*Cn\0'
+    a = bytes(92 ^ b for b in key)
+    b = bytes(54 ^ b for b in key)
+    c = hashlib.sha256(b + rb).digest()
+    m = hashlib.sha256(a + c)
+    return m.hexdigest()
+
+
+def make_headers(url_dir: str, method: str, authorization: str | None = None, quality: str = 'medium') -> dict:
+    """
+    生成哔咔API请求头。
+
+    Args:
+        url_dir(str): 请求路径（包含URL参数，没有前导斜杠）
+        method(str): 请求方法
+        authorization(str, optional): 登录用户token，默认为None，注意除注册登录外不可为None
+        quality(str, optional): 图像品质，可选项：low, medium, high, original，默认为medium
+
+    Returns:
+        dict: 构造的headers
+    """
+    stime = str(int(time.time()))
+    nonce = random_str()
+    signature = make_signature(url_dir, stime, method, nonce)
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0',
+        'Accept': 'application/vnd.picacomic.com.v1+json',
+        'Accept-Encoding': 'gzip, deflate',
+        'Accept-Language': 'zh-CN, zh; q=0.9, en; q=0.8',
+        'App-Channel': '1',
+        'App-Platform': 'android',
+        'App-Uuid': 'webUUIDv2',
+        'App-Version': '20251017',
+        'Time': stime,
+        'Image-Quality': quality,
+        'Content-Type': 'application/json; charset=UTF-8',
+        'Nonce': nonce,
+        'Signature': signature,
+        'Origin': 'https://manhuabika.com',
+        'Referer': 'https://manhuabika.com/',
+    }
+    if authorization is not None:
+        headers['Authorization'] = authorization
+    return headers

picaapi/client.py

@@ -0,0 +1,313 @@
+from httpx import AsyncClient, Limits
+from urllib import parse
+from datetime import date
+from .error import PicaAPIError
+from .objects import *
+
+
+class Client:
+    """
+    用于执行各项逻辑的PicaAPI客户端，代表一个登录用户。
+
+    Attributes:
+        client(AsyncClient): 异步连接池
+        token(str): 哔咔用户令牌
+        quality(str): 图像品质，可选项：low, medium, high, original
+        DEFAULT_DOMAIN(str, static): 默认哔咔API域名
+        COMMENTS_BOARD(str, static): 哔咔留言板漫画ID
+    """
+
+    DEFAULT_DOMAIN = 'go2778.com'
+    COMMENTS_BOARD = '5822a6e3ad7ede654696e482'
+
+    def __init__(self, domain: str = DEFAULT_DOMAIN, token: str | None = None, quality: str = 'medium', max_conn: int | None = None):
+        """
+        Args:
+            domain(str, optional): 哔咔API域名，默认为DEFAULT_DOMAIN
+            token(str, optional): 用户令牌，默认为None（未登录）
+            quality(str, optional): 图像品质，默认为medium（中等）
+        """
+        self.token = token
+        self.quality = quality
+        self.client: AsyncClient = AsyncClient(base_url='https://picaapi.' + domain + '/', limits=Limits(max_connections=max_conn), timeout=8.0)
+        self.closed = False
+
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, *args):
+        await self.aclose()
+    
+    async def aclose(self) -> None:
+        """
+        关闭我。请避免在关闭后再调用。
+        """
+        if not self.closed:
+            await self.client.aclose()
+            self.closed = True
+
+    async def request(self, method: str, url: str, json = None):
+        """
+        发送一般哔咔API请求。
+
+        Args:
+            method(str): 请求方法
+            url(str): 请求路径（包含URL参数，没有前导斜杠）
+            json(dict, optional): 请求负载，默认为None
+
+        Returns:
+            dict: 返回数据data
+
+        Raises:
+            PicaAPIError: 请求失败
+        """
+        response = await self.client.request(method=method, url=url, json=json, headers=make_headers(url, method, self.token, self.quality))
+        json = response.json()
+        if json['code'] != 200:
+            raise PicaAPIError(response.json()['error'], response.json()['message'])
+        return json.get('data', {})
+
+    async def login(self, email: str, password: str) -> None:
+        """
+        登录哔咔并自动保存token。
+
+        Args:
+            email(str): 邮箱或用户名
+            password(str): 密码
+        """
+        response = await self.request('POST', 'auth/sign-in', { 'email': email, 'password': password })
+        self.token = response['token']
+
+    async def register(self, email: str, password: str, name: str, gender: Gender, birthday: date, question1: str, answer1: str, question2: str, answer2: str, question3: str, answer3: str) -> None:
+        """
+        登录哔咔并自动保存token。
+
+        Args:
+            email(str): 邮箱或用户名
+            password(str): 密码
+            name(str): 昵称
+            gender(Gender): 性别
+            birthday(date): 生日，必须满18
+            question1(str): 安全问题1
+            answer1(str): 安全答案1
+            question2(str): 安全问题2
+            answer2(str): 安全答案2
+            question3(str): 安全问题3
+            answer3(str): 安全答案3
+        """
+        await self.request('POST', 'auth/register', { 'email': email, 'password': password, 'name': name, 'gender': gender.value, 'birthday': str(birthday), 'question1': question1, 'answer1': answer1, 'question2': question2, 'answer2': answer2, 'question3': question3, 'answer3': answer3 })
+
+    async def profile(self) -> User:
+        """
+        获取登录用户信息。
+
+        Returns:
+            User: 登录用户信息
+        """
+        response = await self.request('GET', 'users/profile')
+        return Profile(response)
+
+    async def punch_in(self) -> None:
+        """
+        每日签到（打哔卡）。
+        """
+        await self.request('POST', 'users/punch-in')
+    
+    async def comic(self, comic_id: str) -> DetailedComic:
+        """
+        获取漫画详细信息。
+
+        Args:
+            comic_id(str): 漫画ID
+
+        Returns:
+            DetailedComic: 漫画详细信息
+        """
+        response = await self.request('GET', f'comics/{comic_id}')
+        return DetailedComic(response['comic'])
+    
+    async def advanced_search(self, keyword: str, categories: list[str] | None = None, sort: str = 'dd', page: int = 1) -> Page:
+        """
+        哔咔高级搜索。
+
+        Args:
+            keyword(str): 搜索关键字
+            categories(list[str], optional): 分类
+            sort(str, optional): 排序方式，默认为dd（新到旧）
+            page(int, optional): 分页页码，默认为1
+
+        Returns:
+            Page: 返回结果页，数据类型为Comic
+        """
+        if categories is None:
+            categories = []
+        json_map:dict[str, str|list[str]] = { 'keyword': keyword, 'sort': sort }
+        if categories != []: json_map['categories'] = categories
+        response = await self.request('POST', f'comics/advanced-search?page={page}&s={sort}', json_map)
+        return Page(response['comics'], Comic)
+    
+    async def comments(self, comic_id: str, page: int = 1) -> tuple[Page, list[Comment]]:
+        """
+        查看某漫画的评论。
+
+        Args:
+            comic_id(str): 漫画ID
+            page(int, optional): 分页页码，默认为1
+
+        Returns:
+            Page: 返回结果页，数据类型为Comment
+            list[Comment]: 置顶评论
+        """
+        response = await self.request('GET', f'comics/{comic_id}/comments?page={page}')
+        return Page(response['comments'], Comment), [Comment(com) for com in response['topComments']]
+    
+    async def children(self, comment_id: str, page: int = 1) -> Page:
+        """
+        查看某评论的评论。
+
+        Args:
+            comment_id(str): 评论ID
+            page(int, optional): 分页页码，默认为1
+
+        Returns:
+            Page: 返回结果页，数据类型为Comment
+        """
+        response = await self.request('GET', f'comments/{comment_id}/children?page={page}')
+        return Page(response['comments'], Comment)
+    
+    async def favourite(self, sort: str = 'dd', page: int = 1, limit: int = 20) -> Page:
+        """
+        查看收藏夹。
+
+        Args:
+            sort(str, optional): 排序方式，默认为dd（新到旧）
+            page(int, optional): 分页页码，默认为1
+            limit(int, optional): 单页最大值，默认为20
+
+        Returns:
+            Page: 返回结果页，数据类型为Comic
+        """
+        response = await self.request('GET', f'users/favourite?page={page}&s={sort}&limit={limit}')
+        return Page(response['comics'], Comic)
+
+    async def eps(self, comic_id: str, page: int = 1) -> Page:
+        """
+        查看某漫画的各话信息。
+
+        Args:
+            comic_id(str): 漫画ID
+            page(int, optional): 分页页码，默认为1
+
+        Returns:
+            Page: 返回结果页，数据类型为Eps
+        """
+        response = await self.request('GET', f'comics/{comic_id}/eps?page={page}')
+        return Page(response['eps'], Eps)
+    
+    async def pages(self, comic_id: str, order: int = 1, page: int = 1) -> tuple[Page[ComicPicture], str]:
+        """
+        获取漫画内容的图片路径。
+
+        Args:
+            comic_id(str): 漫画ID
+            order(int, optional): 单话序号，默认为1
+            page(int, optional): 分页页码，默认为1
+
+        Returns:
+            Page: 返回结果页，数据类型为ComicPicture
+            str: 此话标题
+        """
+        response = await self.request('GET', f'comics/{comic_id}/order/{order}/pages?page={page}')
+        return Page(response['pages'], ComicPicture), response['ep']['title']
+
+    async def leaderboard(self, tt: str='H24') -> list[LeaderboardComic]:
+        """
+        获取哔咔排行榜。
+
+        Args:
+            tt(str, optional): 时间，可选H24、D7、D30，默认为H24（近24小时）
+
+        Returns:
+            list[Comic]: 排行榜
+        """
+        response = await self.request('GET', f'comics/leaderboard?tt={tt}&ct=VC')
+        return [LeaderboardComic(comic) for comic in response['comics']]
+
+    async def categories(self) -> list[Category]:
+        """
+        获取哔咔分类。
+
+        Returns:
+            list[Category]: 分类列表
+        """
+        response = await self.request('GET', 'categories')
+        return [Category(cate) for cate in response['categories']]
+
+    async def comics(self, key: str, value: str, sort: str = 'dd', page: int = 1) -> Page[Comic]:
+        """
+        通过分类/标签/作者/汉化/骑士查询漫画
+
+        Args:
+            key(str): 键
+            value(str): 查询值
+            sort(str, optional): 排序方式，默认为dd（旧到新）
+            page(int, optional): 分页页码
+
+        Returns:
+            Page[Comic]: 查询结果
+        """
+        response = await self.request('GET', f'comics?page={page}&s={sort}&{key}={parse.quote(value)}')
+        return Page(response['comics'], Comic)
+
+    async def like_comic(self, comic_id: str) -> None:
+        """
+        点赞漫画。
+
+        Args:
+            comic_id(str): 漫画ID
+        """
+        await self.request('POST', f'comics/{comic_id}/like')
+    
+    async def favourite_comic(self, comic_id: str) -> None:
+        """
+        收藏漫画。
+
+        Args:
+            comic_id(str): 漫画ID
+        """
+        await self.request('POST', f'comics/{comic_id}/favourite')
+
+    async def like_comment(self, comment_id: str) -> None:
+        """
+        点赞评论。
+
+        Args:
+            comment_id(str): 评论ID
+        """
+        await self.request('POST', f'comments/{comment_id}/like')
+
+    async def comment_comic(self, comic_id: str, content: str) -> None:
+        """
+        评论漫画。
+
+        Args:
+            comic_id(str): 漫画ID
+            content(str): 评论内容
+        """
+        await self.request('POST', f'comics/{comic_id}/comments', {'content': content})
+    
+    async def comment_comment(self, comment_id: str, content: str) -> None:
+        """
+        评论评论。
+
+        Args:
+            comment_id(str): 评论ID
+            content(str): 评论内容
+        """
+        await self.request('POST', f'comments/{comment_id}', {'content': content})
+
+    async def status(self) -> None:
+        """
+        检查状态。
+        """
+        await self.request('GET', 'status.json')

picaapi/downloader.py

@@ -0,0 +1,169 @@
+import asyncio
+import aiofiles
+from typing import AsyncIterator, Any
+from httpx import HTTPError
+
+from .client import *
+from .objects import Picture
+
+
+DEFAULT_HEADERS: dict[str, str] = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36 Edg/145.0.0.0',
+    'Accept': 'image/*',
+    'Accept-Encoding': 'gzip, deflate, br',
+    'Accept-Language': 'zh-CN, zh; q=0.9, en; q=0.8',
+    'Referer': 'https://manhuabika.com/',
+}
+DEFAULT_PICTURE_SERVER: list[str] = ['https://storage-b.go2778.com/static/', 'https://storage1.go2778.com/static/']
+
+
+class PictureClient:
+    """
+    图片服务器客户端类。仅可进行简单的图片下载。
+    """
+    def __init__(self, base_url: str, headers: dict[str, str] | None = None, max_conn: int | None = None):
+        """
+        Args:
+            base_url(str): 根目录，注意是否有/static/
+            headers(dict[str, str], optional): 请求头，默认为DEFAULT_HEADERS
+            max_conn(int, optional): 最大连接数，建议10，默认遵循httpx
+        """
+        if headers is None:
+            headers = DEFAULT_HEADERS
+        self.client = AsyncClient(base_url=base_url, headers=headers, limits=Limits(max_connections=max_conn), follow_redirects=True, timeout=(5.0, 30.0, 5.0, 5.0))
+        self.closed = False
+
+    async def aclose(self) -> None:
+        if not self.closed:
+            await self.client.aclose()
+            self.closed = True
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *args):
+        await self.aclose()
+
+    async def fetch(self, path: str) -> bytes:
+        """
+        请求图片。一次性返回bytes。
+
+        Args:
+            path(str): 图片路径
+
+        Returns:
+            bytes: 图片数据
+        """
+        response = await self.client.get(path)
+        response.raise_for_status()
+        return response.content
+
+    async def fetch_stream(self, path: str, chunk_size: int | None = None) -> AsyncIterator[bytes]:
+        """
+        请求图片。流式返回生成器。
+
+        Args:
+            path(str): 图片路径
+            chunk_size(int, optional): 每块大小
+
+        Returns:
+            AsyncIterator[bytes]: 生成器
+        """
+        async with self.client.stream('GET', path) as stream:
+            stream.raise_for_status()
+            async for chunk in stream.aiter_bytes(chunk_size=chunk_size):
+                yield chunk
+
+
+class Downloader:
+    """
+    掌管图片下载类。允许使用多个服务器进行下载。
+    """
+
+    def __init__(self, servers: list[str] | None = None, max_conn: int | None = None):
+        """
+        Args:
+            servers(list[str], optional): 服务器根
+            max_conn(int, optional): 最大连接数
+        """
+        if servers is None:
+            servers = DEFAULT_PICTURE_SERVER
+        self.servers = servers
+        self.clients = [PictureClient(base_url=server, max_conn=max_conn) for server in self.servers]
+        self.closed = False
+
+    async def aclose(self) -> None:
+        """
+        关闭我。请避免在关闭后再调用。
+        """
+        if not self.closed:
+            tasks = [client.aclose() for client in self.clients]
+            await asyncio.gather(*tasks)
+            self.closed = True
+
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, *args):
+        await self.aclose()
+
+    async def download_picture(self, picture: Picture, filename: str | None = None) -> bool:
+        """
+        下载单个图片。
+
+        Args:
+            picture(Picture): 哔咔API图片对象
+            filename(str, optional): 保存文件路径，为空则按照picture的源名称保存
+
+        Returns:
+            bool: 是否成功，成功为True
+        """
+        data = None
+        for i, client in enumerate(self.clients):
+            try:
+                data = await client.fetch(picture.path)
+                break
+            except HTTPError:
+                if i + 1 == len(self.clients):
+                    raise
+        if data is None:
+            return False
+        async with aiofiles.open(picture.originalName if filename is None else filename, 'wb') as f:
+            await f.write(data)
+        return True
+
+    async def download_pictures(self, pictures:list[Picture], filename: Callable[[int, Picture], str | None]) -> tuple[BaseException | Any]:
+        """
+        批量下载图片。
+
+        Args:
+            pictures(list[Picture]): 哔咔API图片列表
+            filename(Callable[[int, Picture], str|None]): 保存文件路径构造器，传入图片的列表索引与其自身，返回路径
+
+        Returns:
+            tuple[BaseException | Any]: 对应于每张图片是否成功下载，会回复下载的错误消息
+        """
+        tasks = [self.download_picture(pic, filename(i, pic)) for i, pic in enumerate(pictures)]
+        return await asyncio.gather(*tasks, return_exceptions=True)
+
+    async def download_eps(self, client: Client, comic_id: str, filename: Callable[[int, Picture], str | None], order: int = 1) -> tuple[BaseException | Any]:
+        """
+        下载单话漫画。
+
+        Args:
+            client(Client): 用于哔咔API请求的客户端实例
+            comic_id(str): 漫画ID
+            filename(Callable[[int, Picture], str|None]): 保存文件路径构造器，传入图片的列表索引与其自身，返回路径
+            order(int, optional): 代表具体的单话编号，默认为1
+        
+        Returns:
+            list[bool | BaseException]: 对应于每张图片是否成功下载，会回复下载的错误消息
+        """
+        
+        p1, title = await client.pages(comic_id, order)
+        picture_list = p1.docs
+        tasks = [client.pages(comic_id, order, i) for i in range(2, p1.pages + 1)]
+        pages = await asyncio.gather(*tasks)
+        for page in pages:
+            picture_list += page.docs
+        return await self.download_pictures(picture_list, filename)

picaapi/error.py

@@ -0,0 +1,13 @@
+class PicaAPIError(RuntimeError):
+    """
+    用于返回PicaAPI错误信息与错误码
+
+    Attributes:
+        err(str): 哔咔API返回的错误码
+        message(str): 哔咔API返回的错误消息
+    """
+    
+    def __init__(self, err: str, message: str):
+        self.err = err
+        self.message = message
+        super().__init__(f'{err}: {message}')

picaapi/objects.py

@@ -0,0 +1,212 @@
+from datetime import datetime
+from typing import TypeVar, Generic, Callable
+from .base import *
+
+
+T = TypeVar('T')
+
+
+class Page(Generic[T]):
+    """
+    用于存储哔咔API分页返回的信息。
+
+    Attributes:
+        docs(list[T]): 本页内容，具体元素类型与调用方法有关。
+        limit(int): 一页的最大可承载数量
+        page(int): 页码
+        pages(int): 全部页码
+        total(int): 总内容量
+    """
+
+    def __init__(self, info: dict, constructor: Callable[[dict], T]):
+        self.docs: list[T] = [constructor(i) for i in info['docs']]
+        self.page: int = int(info['page']) # 有的返回会出现字符串
+        self.pages: int = info['pages']
+        self.total: int = info['total']
+        self.limit: int = info['limit']
+
+
+class Picture:
+    """
+    用于存储哔咔API返回的图片地址。
+
+    Attributes:
+        fileServer(str): 访问的文件服务器，为URL前缀，不以斜杠结尾，返回的仅供参考
+        originalName(str): 源文件名称
+        path(str): 路径，不以斜杠开头
+    """
+    
+    def __init__(self, info: dict):
+        self.fileServer: str = info['fileServer']
+        self.originalName: str = info['originalName']
+        self.path: str = info['path']
+    
+    def url(self, server: str = '') -> str:
+        """
+        生成指定图片服务器的URL。
+
+        Args:
+            server(str, optional): 指定的图片服务器，如果为空则为默认服务器
+
+        Returns:
+            str: 指定图片服务器的URL
+        """
+
+        if server == '': server = self.fileServer
+        server = server.replace('https://', '').replace('http://', '') + '/static/' + self.path
+        server = 'https://' + server.replace('//', '/')
+        return server
+
+
+class ComicPicture(Picture):
+    """
+    针对漫画页面的图片类。
+
+    Attributes:
+        id(str): 漫画图片ID
+    """
+
+    def __init__(self, info: dict):
+        Picture.__init__(self, info['media'])
+        self.id: str = info['_id']
+
+
+class User:
+    """
+    用户信息。
+    """
+
+    def __init__(self, info: dict):
+        # TODO: 这个不返回avatar的情况怎么办啊
+        self.avatar: Picture | None = Picture(info['avatar']) if 'avatar' in info else None
+        self.characters: list[str] = info['characters']
+        self.exp: int = info['exp']
+        self.gender: Gender = Gender(info['gender'])
+        self.level: int = info['level']
+        self.name: str = info['name']
+        self.role: str = info['role']
+        self.slogan: str = info['slogan'] if 'slogan' in info else ''
+        self.title: str = info['title']
+        self.verified: bool = info.get('verified', False)
+        self.id: str = info['_id']
+
+
+class Profile(User):
+    """
+    当前登录账号的个人信息。
+    """
+
+    def __init__(self, info):
+        User.__init__(self, info)
+        self.isPunched: bool = info['isPunched']
+        self.birthday: float = datetime.fromisoformat(info['birthday']).timestamp()
+        self.created_at: float = datetime.fromisoformat(info['created_at']).timestamp()
+
+
+class Comment:
+    """
+    单条评论。
+    """
+
+    def __init__(self, info: dict):
+        """
+        从API返回的JSON构造。
+
+        Args:
+            info: (dict[str, Any]): 单条comment的JSON字典
+        """
+
+        self.isTop: bool = info['isTop']
+        self.hide: bool = info['hide']
+        self.created_at: float = datetime.fromisoformat(info['created_at']).timestamp()
+        self.id: str = info['_id']
+        self.isLiked: bool = info['isLiked']
+        self.comic: str = info['_comic']
+        self.likes: int = info['likesCount']
+        self.comments: int = info.get('commentsCount', info.get('totalComments', 0))
+        self.content: str = info['content']
+        self.user: User = User(info['_user'])
+
+
+class Comic:
+    """
+    存储漫画基本信息，用于搜索和列表。
+
+    Attributes:
+        id(str): 漫画ID
+        title: 标题
+        author(str): 作者
+        categories(list[str]): 分类
+        tags(list[str]): 标签
+        thumb(Picture): 封面
+        views(int): 浏览次数（绅士指名数）
+        likes(int): 赞数
+        pagesCount(int): 页数
+        epsCount(int): 集数
+        finished(bool): 完结情况
+    """
+
+    def __init__(self, info: dict):
+        self.author: str = info['author']
+        self.categories: list[str] = info['categories']
+        self.finished: bool = info['finished']
+        self.likes: int = info.get('likesCount', info.get('totalLikes', 0))
+        self.tags: list[str] = info.get('tags', [])
+        self.thumb: Picture = Picture(info['thumb'])
+        self.title: str = info['title']
+        self.views: int = info.get('totalViews', 0)
+        self.pagesCount: int = info.get('pagesCount', 0)
+        self.epsCount: int = info.get('epsCount', 0)
+        self.id: str = info['_id']
+
+
+class LeaderboardComic(Comic):
+    """
+    排行榜API的漫画信息。
+    """
+
+    def __init__(self, info: dict):
+        Comic.__init__(self, info)
+        self.leaderboardCount: int = info.get('leaderboardCount', 0)
+
+
+class DetailedComic(Comic):
+    """
+    存储漫画完整信息，用于漫画详情页。
+    """
+
+    def __init__(self, info: dict):
+        Comic.__init__(self, info)
+        self.description: str = info['description']
+        self.creator: User = User(info['_creator'])
+        self.chineseTeam: str = info['chineseTeam']
+        self.updated_at: float = datetime.fromisoformat(info['updated_at']).timestamp()
+        self.created_at: float = datetime.fromisoformat(info['created_at']).timestamp()
+        self.comments: int = info.get('totalComments', 0)
+        self.isFavourite: bool = info['isFavourite']
+        self.isLiked: bool = info['isLiked']
+
+
+class Eps:
+    """
+    存储漫画单话信息。
+    """
+
+    def __init__(self, info: dict):
+        self.id: str = info['_id']
+        self.order: int = info['order']
+        self.title: str = info['title']
+        self.updated_at: float = datetime.fromisoformat(info['updated_at']).timestamp()
+
+
+class Category:
+    """
+    存储分类信息。
+    """
+
+    def __init__(self, info: dict):
+        #self.active: bool = info['active']
+        self.isWeb: bool = info.get('isWeb', False)
+        self.link: str | None = info.get('link', None)
+        self.thumb: Picture = Picture(info['thumb'])
+        self.title: str = info['title']

picaapi-1.0.0.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.5
+Name: picaapi
+Version: 1.0.0
+Summary: API for PicACG
+Author-email: TalkDe <1160480410@qq.com>
+License-Expression: GPL-3.0-or-later
+Keywords: bikabika,comic,dojin,manga,picacg
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Dist: brotli
+Requires-Dist: httpx
+Description-Content-Type: text/markdown
+
+# picaapi
+
+![GitHub License](https://img.shields.io/github/license/TalkDeBPD/picaapi)
+
+## 简介
+
+基于httpx的便捷的哔咔漫画API的Python调用库，允许手动设置API服务器和图片服务器。支持异步调用，支持并发下载图片。
+
+## 开发进度
+
+> 这个还没有开发完呢！
+> 
+> 下载漫画的异常处理方面尚有缺陷！
+
+- [x] API调用签名验证
+- [x] 登录和打哔卡
+- [x] 搜索漫画、查看分类、查看收藏
+- [x] 查看漫画、下载漫画
+- [x] 点赞、收藏、评论
+- [ ] 骑士榜
+- [ ] 游戏区
+- [ ] 举报违规评论
+
+## 安装方法
+
+`pip install picaapi`
+
+## 示例
+
+打哔卡
+``` Python
+import asyncio
+from picaapi.client import Client
+async def main():
+    async with Client() as client:
+        await client.login(input('用户名：'), input('密码：'))
+        await client.punchin()
+asyncio.run(main())
+```
+
+## 注意事项
+
+爱护哔咔服务器，严禁滥用，禁止将该项目用于商用。

picaapi-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+picaapi/__init__.py,sha256=X20LzGY-409LRSV8GKwRZy-xzwsIZQ0wYdZ5dh5mt9I,337
+picaapi/base.py,sha256=Lpb8HHD_abYfA0RyGuv0BME4JIIwtUJEK0IJk9X2GFc,2806
+picaapi/client.py,sha256=JyzJ8tBdFAPcquIj7hExdF0jrFt0HfF-DRt_XlzyMto,11112
+picaapi/downloader.py,sha256=WANk3Ytrc88XOR16kPUGoIY4OCcgmEqT26vnvPR-4eQ,6246
+picaapi/error.py,sha256=Ebf6SnjDHMz-tevsFHOt_qa1-1X2PrGAVElzKC8c0yY,380
+picaapi/objects.py,sha256=4dDAB3qbTGfhz5j0pR6fZm01nYaLe7aNSeZmt6S6yH8,6644
+picaapi-1.0.0.dist-info/METADATA,sha256=RMRt-ePGtEW3C3FkFsl2OKBbHrmCBJfBNC2jptYNU7c,1522
+picaapi-1.0.0.dist-info/WHEEL,sha256=65OZpnqn5Q1e9Q6d3rS1FnhyYsWCXoZHnlzG_20Jla0,105
+picaapi-1.0.0.dist-info/RECORD,,

picaapi-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any