parsehub 2.0.23__tar.gz → 2.0.24__tar.gz

{parsehub-2.0.23/src/parsehub.egg-info → parsehub-2.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parsehub
-Version: 2.0.23
+Version: 2.0.24
 Summary: 轻量、异步、开箱即用的社交媒体聚合解析库
 Author-email: 梓澪 <zilingmio@gmail.com>
 License: MIT

{parsehub-2.0.23 → parsehub-2.0.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "parsehub"
-version = "2.0.23"
+version = "2.0.24"
 description = "轻量、异步、开箱即用的社交媒体聚合解析库"
 readme = "README.md"
 requires-python = ">=3.12.0"
@@ -85,14 +85,15 @@ ignore = [
 [tool.mypy]
 python_version = "3.12"
 files = ["./"]
+exclude = ["test"]
 ignore_missing_imports = true
-warn_return_any = false
+warn_return_any = true
 warn_unused_ignores = true
-check_untyped_defs = false
-disallow_untyped_defs = false
-no_implicit_optional = false
+check_untyped_defs = true
+disallow_untyped_defs = true
+no_implicit_optional = true
 
 [tool.pytest.ini_options]
 testpaths =  ["test"]
 pythonpath = ["src"]
-python_files = ["test_*.py"]
+python_files = ["test_*.py"]

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/__init__.py

@@ -13,7 +13,7 @@ logger.disable(__name__)
 
 
 class ParseHub:
-    def __init__(self):
+    def __init__(self) -> None:
         self.parsers: list[type[BaseParser]] = BaseParser.get_registry()
 
     async def parse(self, url: str, *, proxy: str | None = None, cookie: str | dict | None = None) -> AnyParseResult:
@@ -185,7 +185,7 @@ class ParseHub:
                 return parser
         return None
 
-    def get_parser(self, url) -> type[BaseParser] | None:
+    def get_parser(self, url: str) -> type[BaseParser] | None:
         """获取解析器
         :param url: 分享文案 / 分享链接
         """
@@ -193,7 +193,7 @@ class ParseHub:
             return parser
         return None
 
-    def get_platform(self, url) -> Platform | None:
+    def get_platform(self, url: str) -> Platform | None:
         """获取平台
         :param url: 分享文案 / 分享链接
         """

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/cli.py

@@ -46,7 +46,7 @@ def main(argv: list[str] | None = None) -> int:
     try:
         args = parser.parse_args(_normalize_argv(raw_argv))
         _finalize_output_args(args)
-        return args.func(args)
+        return int(args.func(args))
     except SystemExit as e:
         return _normalize_exit_code(e.code)
     except ValueError as e:
@@ -365,14 +365,15 @@ def _cookie_prompt() -> Any:
 
 def _load_platform_config(platform_id: str | None) -> PlatformConfig:
     if not platform_id:
-        return _platform_config_type()()
-    return _config_store().get_platform(platform_id)
+        return cast("PlatformConfig", _platform_config_type()())
+    return cast("PlatformConfig", _config_store().get_platform(platform_id))
 
 
 def _load_cookie(platform_id: str | None) -> str | None:
     if not platform_id:
         return None
-    return _cookie_store().get(platform_id)
+    value = _cookie_store().get(platform_id)
+    return value if isinstance(value, str) or value is None else str(value)
 
 
 def _detect_platform_id(hub: Any, url_or_text: str) -> str | None:

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/base/base.py

@@ -2,6 +2,7 @@ import importlib
 import pkgutil
 import re
 from abc import ABC, abstractmethod
+from typing import Any
 from urllib.parse import parse_qs, urlencode, urlparse
 
 import httpx
@@ -34,7 +35,7 @@ class BaseParser(ABC):
         self.proxy = proxy
         self.cookie = normalize_cookie(cookie)
 
-    def __init_subclass__(cls, /, register: bool = True, **kwargs):
+    def __init_subclass__(cls, /, register: bool = True, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
         if register:
             if not cls.__platform__:

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/base/ytdlp.py

@@ -1,6 +1,8 @@
 import asyncio
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any, cast
 
 from yt_dlp import YoutubeDL
 
@@ -30,7 +32,7 @@ def switch_ytdlp_proxy(ydl: YoutubeDL, proxy: str | None) -> None:
         director.close()
 
 
-def download_video(yto_params: dict, url: str, proxy: str | None = None) -> None:
+def download_video(yto_params: dict[str, Any], url: str, proxy: str | None = None) -> None:
     """在独立线程中下载视频"""
     try:
         with YoutubeDL(yto_params) as ydl:
@@ -43,14 +45,16 @@ def download_video(yto_params: dict, url: str, proxy: str | None = None) -> None
 
 
 class MonotonicDownloadProgress:
-    def __init__(self, emit, *, start: float = 0.0, end: float = 100.0, min_step: float = 0.1):
+    def __init__(
+        self, emit: Callable[[float], None], *, start: float = 0.0, end: float = 100.0, min_step: float = 0.1
+    ) -> None:
         self.emit = emit
         self.start = start
         self.end = end
         self.min_step = min_step
         self.current = start
 
-    def __call__(self, d: dict):
+    def __call__(self, d: dict[str, Any]) -> None:
         status = d.get("status")
 
         if status == "downloading":
@@ -82,8 +86,8 @@ class MonotonicDownloadProgress:
         # 分片下载有时没有稳定总大小，但有 frag 进度；作为兜底
         frag_index = d.get("fragment_index")
         frag_count = d.get("fragment_count")
-        if frag_index is not None and frag_count:
-            return min(frag_index / frag_count * 100, 100)
+        if isinstance(frag_index, int | float) and isinstance(frag_count, int | float) and frag_count:
+            return min(float(frag_index) / float(frag_count) * 100, 100.0)
 
         return None
 
@@ -106,7 +110,7 @@ class YtParser(BaseParser, register=False):
             ),
         )
 
-    async def _parse(self, url) -> "YtVideoInfo":
+    async def _parse(self, url: str) -> "YtVideoInfo":
         try:
             dl = await asyncio.wait_for(asyncio.to_thread(self._extract_info, url), timeout=30)
         except TimeoutError as e:
@@ -136,20 +140,20 @@ class YtParser(BaseParser, register=False):
             proxy=self.proxy,
         )
 
-    def _extract_info(self, url):
+    def _extract_info(self, url: str) -> dict[str, Any]:
         params = self.params.copy()
         if self.proxy:
             params["proxy"] = self.proxy
 
         try:
             with YoutubeDL(params) as ydl:
-                return ydl.extract_info(url, download=False)
+                return cast(dict[str, Any], ydl.extract_info(url, download=False))
         except Exception as e:
             error_msg = f"{type(e).__name__}: {str(e)}"
             raise RuntimeError(error_msg) from None
 
     @property
-    def params(self) -> dict:
+    def params(self) -> dict[str, Any]:
         params = {
             "format": "mp4+bestvideo[height<=1080]+bestaudio",
             "quiet": True,  # 不输出日志
@@ -170,9 +174,9 @@ class YtVideoParseResult(VideoParseResult):
     def __init__(
         self,
         dl: "YtVideoInfo",
-        title,
-        video=None,
-        content=None,
+        title: str | None,
+        video: VideoRef | None = None,
+        content: str | None = None,
     ):
         """dl: yt-dlp解析结果"""
         self.dl = dl
@@ -201,7 +205,7 @@ class YtVideoParseResult(VideoParseResult):
         if callback:
             loop = asyncio.get_running_loop()
 
-            def _callback(count: float):
+            def _callback(count: float) -> None:
                 asyncio.run_coroutine_threadsafe(
                     callback(int(count), 100, "bytes", *callback_args, **callback_kwargs), loop
                 )
@@ -237,7 +241,7 @@ class YtVideoParseResult(VideoParseResult):
             output_dir,
         )
 
-    async def _run_download(self, paramss: dict, count: int = 0, *, proxy: str | None = None) -> None:
+    async def _run_download(self, paramss: dict[str, Any], count: int = 0, *, proxy: str | None = None) -> None:
         if count > 2:
             raise DownloadError("下载失败 -2")
 

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/parser/bilibili.py

@@ -58,7 +58,7 @@ class BiliParse(YtParser):
                     raise ParseError("Bilibili 解析失败") from e
 
     @staticmethod
-    def _is_bvid(url: str):
+    def _is_bvid(url: str) -> bool:
         if url.lower().startswith("bv"):
             return True
         else:
@@ -79,7 +79,7 @@ class BiliParse(YtParser):
             return await super().get_raw_url(url, clean_all=clean_all)
 
     @staticmethod
-    async def is_dynamic(url) -> str | None:
+    async def is_dynamic(url: str) -> str | None:
         """是动态"""
         if re.search(r"\b\d{18,19}\b", url):
             return url
@@ -93,9 +93,9 @@ class BiliParse(YtParser):
                 if "风控" in str(e):
                     raise ParseError(f"账号风控\n使用的cookie: {cookie_ellipsis(self.cookie)}") from e
                 raise ParseError(str(e)) from e
-        return dynamic_info
+        return cast(BiliDynamic, dynamic_info)
 
-    async def bili_api_parse(self, url) -> BiliVideoParseResult | ImageParseResult:
+    async def bili_api_parse(self, url: str) -> BiliVideoParseResult | ImageParseResult:
         async with BiliAPI(proxy=self.proxy) as bili:
             video_info = await bili.get_video_info(url)
 
@@ -138,16 +138,16 @@ class BiliParse(YtParser):
             ),
         )
 
-    async def ytp_parse(self, url) -> YtVideoParseResult:
+    async def ytp_parse(self, url: str) -> YtVideoParseResult:
         result = cast(YtVideoParseResult, await super()._do_parse(url))
         return YtVideoParseResult(
             title=result.title,
             dl=result.dl,
-            video=result.media,
+            video=cast(VideoRef | None, result.media),
         )
 
     @staticmethod
-    def change_source(url: str):
+    def change_source(url: str) -> str:
         return re.sub(
             r"upos-.*.(bilivideo.com|mirrorakam.akamaized.net)",
             "upos-sz-upcdnbda2.bilivideo.com",

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/parser/coolapk.py

@@ -52,7 +52,7 @@ class CoolapkParser(BaseParser):
         )
 
     @staticmethod
-    def hashtag_handler(desc: str):
+    def hashtag_handler(desc: str) -> str:
         hashtags = re.findall(r" ?#[^#]+# ?", desc)
         for hashtag in hashtags:
             desc = desc.replace(hashtag, f" {hashtag.strip().removesuffix('#')} ")
@@ -64,11 +64,11 @@ class CoolapkParseResult(ParseResult):
         self,
         *,
         output_dir: str | Path,
-        callback: ProgressCallback = None,
+        callback: ProgressCallback | None = None,
         callback_args: tuple = (),
         callback_kwargs: dict | None = None,
         proxy: str | None = None,
-        headers: dict = None,
+        headers: dict | None = None,
     ) -> "DownloadResult":
         headers = {
             "Accept": (

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/parser/instagram.py

@@ -1,5 +1,6 @@
 import asyncio
 import re
+from typing import Any, cast
 
 from instaloader import BadResponseException
 
@@ -56,7 +57,7 @@ class InstagramParser(BaseParser):
             case _:
                 raise ParseError("不支持的类型")
 
-    async def _parse(self, url, shortcode, cookie=None) -> MyPost:
+    async def _parse(self, url: str, shortcode: str, cookie: dict[str, Any] | None = None) -> MyPost:
         try:
             post = await asyncio.wait_for(
                 asyncio.to_thread(
@@ -84,10 +85,10 @@ class InstagramParser(BaseParser):
                 text = str(e)
             raise ParseError(f"无法获取帖子内容: {text}") from e
         else:
-            return post
+            return cast(MyPost, post)
 
     @staticmethod
-    def get_short_code(url: str):
+    def get_short_code(url: str) -> str | None:
         url = url.removesuffix("/")
         shortcode = re.search(r"/(share|p|reel|.*/p|.*/reel)/(.*)", url)
         return shortcode.group(2).split("/")[0] if shortcode else None

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/parser/tiktok.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Self, Union
+from typing import Any, Self, Union
 
 from ... import ProgressCallback
 from ...provider_api.tiktok import TikTokWebCrawler
@@ -110,7 +110,7 @@ def preferred_video_url(data: dict | str | list | None) -> str | None:
     return next((url for url in urls if "aweme" in url), None) or (urls[0] if urls else None)
 
 
-def as_int(value) -> int:
+def as_int(value: Any) -> int:
     try:
         return int(value or 0)
     except (TypeError, ValueError):

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/parser/twitter.py

@@ -26,7 +26,7 @@ class TwitterParser(BaseParser):
     __supported_type__ = ["视频", "图文"]
     __match__ = r"^(http(s)?://)?.+(twitter|fixupx|x).com/.*/status/\d+"
 
-    async def _do_parse(self, raw_url: str) -> "MultimediaParseResult":
+    async def _do_parse(self, raw_url: str) -> MultimediaParseResult | RichTextParseResult:
         tweet = await self._parse(raw_url)
         return await self.media_parse(tweet)
 
@@ -34,7 +34,7 @@ class TwitterParser(BaseParser):
         url = await super().get_raw_url(url, clean_all=clean_all)
         return str(urlunparse(urlparse(url)._replace(netloc="x.com")))
 
-    async def _parse(self, url: str):
+    async def _parse(self, url: str) -> TwitterTweet:
         x = Twitter(self.proxy, cookie=None)
         try:
             tweet = await x.fetch_tweet(url)
@@ -55,7 +55,7 @@ class TwitterParser(BaseParser):
         return tweet
 
     @staticmethod
-    async def media_parse(tweet: TwitterTweet):
+    async def media_parse(tweet: TwitterTweet) -> MultimediaParseResult | RichTextParseResult:
         media: list[AnyMediaRef] = []
         if tweet.media:
             for m in tweet.media:

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/parser/weibo.py

@@ -17,7 +17,7 @@ from ..base.base import BaseParser
 class WeiboParser(BaseParser):
     __platform__ = Platform.WEIBO
     __supported_type__ = ["视频", "图文"]
-    __match__ = r"^(http(s)?://)(m\.|)weibo.(com|cn)/(?!(u/)).+"
+    __match__ = r"^(http(s)?://)((m\.|)weibo\.(com|cn)/(?!(u/)).+|mapp\.api\.weibo\.cn/fx/.+)"
 
     async def _do_parse(self, raw_url: str) -> MultimediaParseResult | VideoParseResult | ImageParseResult:
         weibo = await WeiboAPI(self.proxy).parse(raw_url)
@@ -91,7 +91,7 @@ class WeiboParser(BaseParser):
         return text.strip()
 
     @staticmethod
-    def hashtag_handler(desc: str):
+    def hashtag_handler(desc: str) -> str:
         hashtags = re.findall(r" ?#[^#]+# ?", desc)
         for hashtag in hashtags:
             desc = desc.replace(hashtag, f" {hashtag.strip().removesuffix('#')} ")

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/parser/xhs.py

@@ -31,6 +31,8 @@ class XHSParser(BaseParser):
         desc = self.hashtag_handler(result.desc)
         match result.type:
             case XHSPostType.VIDEO:
+                if not result.media:
+                    raise ParseError("未获取到视频")
                 v: XHSMedia = result.media[0]
                 return VideoParseResult(
                     video=VideoRef(
@@ -40,10 +42,13 @@ class XHSParser(BaseParser):
                     content=desc,
                 )
             case XHSPostType.IMAGE:
+                media_list = result.media or []
                 photos: list[ImageRef | LivePhotoRef] = []
-                for i in result.media:
+                for i in media_list:
                     if i.type == XHSMediaType.LIVE_PHOTO:
-                        photos.append(LivePhotoRef(url=i.thumb_url, video_url=i.url, width=i.width, height=i.height))
+                        photos.append(
+                            LivePhotoRef(url=i.thumb_url or "", video_url=i.url, width=i.width, height=i.height)
+                        )
                     else:
                         # 小红书图片格式: "png" | "webp" | "jpeg" | "heic" | "avif"
                         ext = await self.get_ext_by_url(i.url)
@@ -61,7 +66,7 @@ class XHSParser(BaseParser):
             case _:
                 raise ParseError("不支持的类型")
 
-    async def get_ext_by_url(self, url: str):
+    async def get_ext_by_url(self, url: str) -> str:
         async with httpx.AsyncClient(proxy=self.proxy) as client:
             try:
                 response = await client.head(url, follow_redirects=True)
@@ -72,12 +77,12 @@ class XHSParser(BaseParser):
                 media_type = content_type.split(";")[0].strip()
                 if "/" in media_type:
                     extension = media_type.split("/")[-1]
-                    return extension
+                    return str(extension)
 
             return ""
 
     @staticmethod
-    def hashtag_handler(desc: str | None):
+    def hashtag_handler(desc: str | None) -> str:
         if not desc:
             return ""
         hashtags = re.findall(r" ?#[^#\[\]]+\[话题]# ?", desc)

parsehub-2.0.24/src/parsehub/parsers/parser/xiaoheihe.py

@@ -0,0 +1,60 @@
+from ...parsers.base import BaseParser
+from ...provider_api.xiaoheihe import XiaoHeiHeAPI, XiaoHeiHeMediaType, XiaoHeiHePost, XiaoHeiHePostType
+from ...types import (
+    AniRef,
+    AnyParseResult,
+    ImageParseResult,
+    ImageRef,
+    MultimediaParseResult,
+    ParseError,
+    Platform,
+    RichTextParseResult,
+    VideoParseResult,
+    VideoRef,
+)
+
+
+class XiaoHeiHeParser(BaseParser):
+    __platform__ = Platform.XIAOHEIHE
+    __supported_type__ = ["视频", "图文"]
+    __match__ = r"^(http(s)?://)?.+xiaoheihe.cn/(v3|app)/bbs/(app|link).+"
+    __redirect_keywords__ = ["api.xiaoheihe"]
+
+    async def _do_parse(self, raw_url: str) -> AnyParseResult:
+        xhh = await XiaoHeiHeAPI(proxy=self.proxy).parse(raw_url)
+        match xhh.type:
+            case XiaoHeiHePostType.VIDEO:
+                return VideoParseResult(
+                    video=self.__parse_video(xhh),
+                    title=xhh.title,
+                    content=xhh.content,
+                )
+            case XiaoHeiHePostType.IMAGE:
+                media = self.__parse_images(xhh)
+                if not media or all(isinstance(m, ImageRef) for m in media):
+                    return ImageParseResult(photo=media, title=xhh.title, content=xhh.content)
+                return MultimediaParseResult(media=media, title=xhh.title, content=xhh.content)
+            case XiaoHeiHePostType.ARTICLE:
+                return RichTextParseResult(
+                    title=xhh.title,
+                    media=self.__parse_images(xhh),
+                    markdown_content=xhh.content,
+                )
+        raise ParseError("不支持的类型")
+
+    @staticmethod
+    def __parse_video(xhh: XiaoHeiHePost) -> VideoRef:
+        if not xhh.media:
+            raise ParseError("未获取到视频")
+        media = xhh.media[0]
+        return VideoRef(url=media.url, thumb_url=media.thumb_url)
+
+    @staticmethod
+    def __parse_images(xhh: XiaoHeiHePost) -> list[ImageRef | AniRef]:
+        images: list[ImageRef | AniRef] = []
+        for media in xhh.media or []:
+            if media.type == XiaoHeiHeMediaType.IMAGE:
+                images.append(ImageRef(url=media.url, width=media.width or 0, height=media.height or 0))
+            else:
+                images.append(AniRef(url=media.url, width=media.width or 0, height=media.height or 0))
+        return images

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/parsers/parser/youtube.py

@@ -13,7 +13,7 @@ class YtbParse(YtParser):
     __reserved_parameters__ = ["v", "list", "index"]
 
     @property
-    def params(self):
+    def params(self) -> dict[str, Any]:
         sub: dict[str, Any] = {
             # "writesubtitles": True, # 下载字幕
             # "writeautomaticsub": True, # 下载自动生成的字幕

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/provider_api/bilibili.py

@@ -1,3 +1,4 @@
+# mypy: disable-error-code=no-untyped-def
 import asyncio
 import re
 import time
@@ -7,7 +8,7 @@ from dataclasses import dataclass
 from enum import Enum
 from functools import reduce
 from hashlib import md5
-from typing import Any
+from typing import Any, cast
 
 import httpx
 
@@ -70,7 +71,7 @@ class BiliAPI:
                     raise Exception("动态不可见")
                 case _:
                     raise Exception(f"获取动态信息失败: {mj}")
-        return BiliDynamic.parse(data)
+        return BiliDynamic.parse(cast(dict[str, Any], data))
 
     async def get_video_info(self, url: str):
         """获取视频详细信息"""
@@ -117,7 +118,7 @@ class BiliAPI:
             params=params,
             cookies=cookies,
         )
-        return response.json()
+        return cast(dict[str, Any], response.json())
 
     async def get_buvid(self):
         """获取 buvid"""
@@ -135,7 +136,7 @@ class BiliAPI:
         wbi = await BiliWbiSigner().wbi(bvid=bvid, cid=cid, up_mid=up_mid)
         return await self.get_ai_summary(bvid, cid, up_mid, wbi["w_rid"], wbi["wts"])
 
-    async def get_ai_summary(self, bvid: str, cid: int, up_mid: int, w_rid: str, wts: int):
+    async def get_ai_summary(self, bvid: str, cid: int, up_mid: int, w_rid: str, wts: int) -> "AISummaryResult":
         url = "https://api.bilibili.com/x/web-interface/view/conclusion/get"
         result = await self._get_client().get(
             url,
@@ -249,7 +250,7 @@ class BiliDynamic:
     images: list[BiliImage] | None = None
 
     @classmethod
-    def parse(cls, data: dict):
+    def parse(cls, data: dict) -> "BiliDynamic":
         module_dynamic: dict = data["item"]["modules"]["module_dynamic"]
         major: dict | None = module_dynamic.get("major", None)
         if not major:
@@ -258,7 +259,7 @@ class BiliDynamic:
             return cls._parse_major(module_dynamic, major)
 
     @classmethod
-    def _parse_major(cls, module_dynamic: dict, major: dict):
+    def _parse_major(cls, module_dynamic: dict, major: dict) -> "BiliDynamic":
         major_type = major["type"]
         major_parsers: dict[MajorType, Callable[[dict, dict], BiliDynamic]] = {
             MajorType.MAJOR_TYPE_MEDIALIST: cls._parse_medialist,
@@ -278,12 +279,12 @@ class BiliDynamic:
         return major_parser(module_dynamic, major)
 
     @classmethod
-    def _parse_pgc_union(cls, _, major: dict):
+    def _parse_pgc_union(cls, _: dict, major: dict) -> "BiliDynamic":
         pgc = major["pgc"]
         return cls(title=pgc["title"], images=[BiliImage(url=pgc["cover"])])
 
     @classmethod
-    def _parse_forward(cls, module_dynamic: dict):
+    def _parse_forward(cls, module_dynamic: dict) -> "BiliDynamic":
         return cls(content=cls._get_desc_text(module_dynamic))
 
     @classmethod
@@ -301,7 +302,7 @@ class BiliDynamic:
         return cls(title=music["title"], images=cls._get_major_cover(music))
 
     @classmethod
-    def _parse_opus(cls, _, major: dict):
+    def _parse_opus(cls, _: dict, major: dict) -> "BiliDynamic":
         opus = major["opus"]
         images = None
         if pics := opus["pics"]:
@@ -362,7 +363,7 @@ class BiliDynamic:
     @staticmethod
     def _get_desc_text(module_dynamic: dict) -> str | None:
         if desc := module_dynamic["desc"]:
-            return desc["text"].strip()
+            return str(desc["text"]).strip()
         return None
 
     @staticmethod

{parsehub-2.0.23 → parsehub-2.0.24}/src/parsehub/provider_api/coolapk.py

@@ -16,7 +16,7 @@ class Coolapk:
     imgs: list[str] | None = None
 
     @classmethod
-    async def parse(cls, url: str, proxy: str = None) -> "Coolapk":
+    async def parse(cls, url: str, proxy: str | None = None) -> "Coolapk":
         async with httpx.AsyncClient(headers={"User-Agent": GlobalConfig.ua}, proxy=proxy) as client:
             result = await client.get(url)
         soup = BeautifulSoup(result.text, "lxml")