parsehub 2.0.22__tar.gz → 2.0.24__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "parsehub"
-version = "2.0.22"
+version = "2.0.24"
 description = "轻量、异步、开箱即用的社交媒体聚合解析库"
 readme = "README.md"
 requires-python = ">=3.12.0"
@@ -52,6 +52,8 @@ cli = [
 
 [dependency-groups]
 dev = [
+    "mypy>=2.1.0",
+    "pytest>=9.0.3",
     "ruff>=0.14.14",
 ]
 
@@ -79,3 +81,19 @@ ignore = [
     "B008", # 不在参数默认值中执行函数调用
     "C901", # 函数复杂度过高
 ]
+
+[tool.mypy]
+python_version = "3.12"
+files = ["./"]
+exclude = ["test"]
+ignore_missing_imports = true
+warn_return_any = true
+warn_unused_ignores = true
+check_untyped_defs = true
+disallow_untyped_defs = true
+no_implicit_optional = true
+
+[tool.pytest.ini_options]
+testpaths =  ["test"]
+pythonpath = ["src"]
+python_files = ["test_*.py"]

{parsehub-2.0.22 → 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:
@@ -47,9 +47,9 @@ class ParseHub:
     async def download(
         self,
         url: str,
-        path: str | Path = None,
+        path: str | Path | None = None,
         *,
-        callback: ProgressCallback = None,
+        callback: ProgressCallback | None = None,
         callback_args: tuple = (),
         callback_kwargs: dict | None = None,
         proxy: str | None = None,
@@ -169,6 +169,8 @@ class ParseHub:
         :return: 原始链接
         """
         parser = self.get_parser(url)
+        if not parser:
+            raise UnknownPlatform(url)
         try:
             return await parser(proxy=proxy).get_raw_url(url, clean_all=clean_all)
         except Exception as e:
@@ -183,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: 分享文案 / 分享链接
         """
@@ -191,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: 分享文案 / 分享链接
         """
@@ -210,9 +212,10 @@ class ParseHub:
         """
         return [
             {
-                "id": parser.__platform__.id,
-                "name": parser.__platform__.display_name,
+                "id": platform.id,
+                "name": platform.display_name,
                 "supported_types": parser.__supported_type__,
             }
             for parser in self.parsers
+            if (platform := parser.__platform__) is not None
         ]

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

@@ -8,7 +8,7 @@ import unicodedata
 from dataclasses import asdict, is_dataclass
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, NoReturn, cast
 
 if TYPE_CHECKING:
     from .cli_config import AutoCookieStore, PlatformConfig
@@ -20,12 +20,13 @@ _CLI_EXTRA_MODULES = ("argcomplete", "platformdirs")
 class _ChineseArgumentParser(argparse.ArgumentParser):
     def __init__(self, *args: Any, **kwargs: Any):
         kwargs.setdefault("formatter_class", argparse.RawDescriptionHelpFormatter)
-        add_help = kwargs.pop("add_help", True)
-        super().__init__(*args, add_help=False, **kwargs)
+        add_help = bool(kwargs.pop("add_help", True))
+        kwargs["add_help"] = False
+        super().__init__(*args, **kwargs)
         if add_help:
             self.add_argument("-h", "--help", action="help", default=argparse.SUPPRESS, help="显示帮助信息")
 
-    def error(self, message: str) -> None:
+    def error(self, message: str) -> NoReturn:
         self.print_usage(sys.stderr)
         translated = _translate_argparse_error(message)
         hint = _usage_hint(self.prog)
@@ -45,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:
@@ -212,7 +213,7 @@ def _add_set_commands(subparsers: argparse._SubParsersAction) -> None:
 
 def _add_platform_argument(parser: argparse.ArgumentParser) -> None:
     action = parser.add_argument("platform", help="平台 ID，如 xhs")
-    action.completer = _complete_platforms
+    action.completer = _complete_platforms  # type: ignore[attr-defined]
 
 
 def _add_json_options(parser: argparse.ArgumentParser) -> None:
@@ -364,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:
@@ -436,7 +438,7 @@ def _platform_config_row(
 
 
 def _print_json(data: Any, *, pretty: bool) -> None:
-    kwargs = {"ensure_ascii": False}
+    kwargs: dict[str, Any] = {"ensure_ascii": False}
     if pretty:
         kwargs["indent"] = 2
     else:
@@ -547,8 +549,8 @@ def _download_result_to_dict(result: Any) -> dict[str, Any]:
 def _jsonable(value: Any) -> Any:
     if isinstance(value, Path):
         return str(value)
-    if is_dataclass(value):
-        return _jsonable(asdict(value))
+    if is_dataclass(value) and not isinstance(value, type):
+        return _jsonable(asdict(cast(Any, value)))
     if isinstance(value, dict):
         return {str(k): _jsonable(v) for k, v in value.items()}
     if isinstance(value, (list, tuple)):

{parsehub-2.0.22 → 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=True, **kwargs):
+    def __init_subclass__(cls, /, register: bool = True, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
         if register:
             if not cls.__platform__:
@@ -56,7 +57,7 @@ class BaseParser(ABC):
     def match(cls, text: str) -> bool:
         """判断是否匹配该解析器"""
         url = match_url(text)
-        return bool(re.match(cls.__match__, url))
+        return bool(cls.__match__ and re.match(cls.__match__, url))
 
     async def parse(self, url: str) -> AnyParseResult:
         """解析
@@ -66,7 +67,8 @@ class BaseParser(ABC):
         raw_url = await self.get_raw_url(url, clean_all=False)
         result = await self._do_parse(raw_url)
         result.platform = self.__platform__
-        result.raw_url = self._clean_params(raw_url, self.__after_clean_parameters__)
+        raw_url_clean = self._clean_params(raw_url, self.__after_clean_parameters__)
+        result.raw_url = raw_url_clean
         return result
 
     @abstractmethod
@@ -104,7 +106,8 @@ class BaseParser(ABC):
 
         :return:
         """
-        url = match_url(url)
+        matched_url = match_url(url)
+        url = matched_url or url
         if not url.startswith("http"):
             url = f"https://{url}"
         if any(x in url for x in self.__redirect_keywords__):

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

@@ -1,11 +1,13 @@
 import asyncio
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Union
+from typing import Any, cast
 
 from yt_dlp import YoutubeDL
 
 from ...types import (
+    AnyParseResult,
     DownloadError,
     DownloadResult,
     ParseError,
@@ -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
 
@@ -91,7 +95,7 @@ class MonotonicDownloadProgress:
 class YtParser(BaseParser, register=False):
     """yt-dlp解析器"""
 
-    async def _do_parse(self, raw_url: str) -> Union["YtVideoParseResult"]:
+    async def _do_parse(self, raw_url: str) -> AnyParseResult:
         video_info = await self._parse(raw_url)
         return YtVideoParseResult(
             dl=video_info,
@@ -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:
@@ -114,8 +118,8 @@ class YtParser(BaseParser, register=False):
         except Exception as e:
             raise ParseError(f"解析视频信息失败: {str(e)}") from e
 
-        if dl.get("_type") and dl["_type"] == "playlist":  # type: ignore
-            dl = dl["entries"][0]  # type: ignore
+        if dl.get("_type") and dl["_type"] == "playlist":
+            dl = dl["entries"][0]
             url = dl["webpage_url"]
         title = dl["title"]
         duration = dl.get("duration", 0)
@@ -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
@@ -190,17 +194,18 @@ class YtVideoParseResult(VideoParseResult):
     ) -> "DownloadResult":
         if callback_kwargs is None:
             callback_kwargs = {}
+        output_dir_path = Path(output_dir)
 
         paramss = self.dl.paramss.copy()
         if self.dl.proxy:
             paramss["proxy"] = self.dl.proxy
 
-        paramss["outtmpl"] = f"{output_dir.joinpath('ytdlp_%(id)s')}.%(ext)s"
+        paramss["outtmpl"] = f"{output_dir_path.joinpath('ytdlp_%(id)s')}.%(ext)s"
 
         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
                 )
@@ -214,7 +219,11 @@ class YtVideoParseResult(VideoParseResult):
 
         await self._run_download(paramss, proxy=proxy)
 
-        v = list(output_dir.glob("*.mp4")) or list(output_dir.glob("*.mkv")) or list(output_dir.glob("*.webm"))
+        v = (
+            list(output_dir_path.glob("*.mp4"))
+            or list(output_dir_path.glob("*.mkv"))
+            or list(output_dir_path.glob("*.webm"))
+        )
         if not v:
             raise DownloadError("下载失败 -1")
 
@@ -232,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.22 → parsehub-2.0.24}/src/parsehub/parsers/parser/bilibili.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 import re
 from pathlib import Path
-from typing import Union
+from typing import cast
 from urllib.parse import parse_qs, urlparse
 
 from loguru import logger
@@ -29,11 +31,11 @@ class BiliParse(YtParser):
     __reserved_parameters__ = ["p"]
     __redirect_keywords__ = ["b23.tv", "bili2233.cn"]
 
-    async def _do_parse(self, raw_url: str) -> Union["YtVideoParseResult", "BiliVideoParseResult", ImageParseResult]:
+    async def _do_parse(self, raw_url: str) -> YtVideoParseResult | BiliVideoParseResult | ImageParseResult:
         if await self.is_dynamic(raw_url):
             dynamic = await self.get_dynamic_info(raw_url)
             content = self.hashtag_handler(dynamic.content)
-            photos = []
+            photos: list[LivePhotoRef | ImageRef] = []
             if dynamic.images:
                 for i in dynamic.images:
                     if i.live_url:
@@ -56,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:
@@ -77,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
@@ -91,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) -> Union["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)
 
@@ -136,16 +138,16 @@ class BiliParse(YtParser):
             ),
         )
 
-    async def ytp_parse(self, url) -> Union["YtVideoParseResult"]:
-        result = await super()._do_parse(url)
+    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",
@@ -172,7 +174,7 @@ class BiliVideoParseResult(VideoParseResult):
         callback_kwargs: dict | None = None,
         proxy: str | None = None,
         headers: dict | None = None,
-    ) -> "DownloadResult":
+    ) -> DownloadResult:
         headers = {"referer": "https://www.bilibili.com", "User-Agent": GlobalConfig.ua}
         return await super()._do_download(
             output_dir=output_dir,

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

@@ -31,14 +31,14 @@ class CoolapkParser(BaseParser):
             coolapk = await Coolapk.parse(raw_url, proxy=self.proxy)
         except Exception as e:
             raise ParseError(str(e)) from e
-        media = [AniRef(url=i) if ".gif" in i else ImageRef(url=i) for i in coolapk.imgs]
+        media = [AniRef(url=i) if ".gif" in i else ImageRef(url=i) for i in coolapk.imgs or []]
         if coolapk.markdown_content:
             return CoolapkRichTextParseResult(
                 title=coolapk.title,
                 media=media,
                 markdown_content=coolapk.markdown_content,
             )
-        content = self.hashtag_handler(coolapk.text_content)
+        content = self.hashtag_handler(coolapk.text_content or "")
         if any(isinstance(m, AniRef) for m in media):
             return CoolapkMultimediaParseResult(
                 title=coolapk.title,
@@ -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.22 → parsehub-2.0.24}/src/parsehub/parsers/parser/douyin.py

@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
 from typing import Self, Union
@@ -47,6 +47,8 @@ class DouyinParser(BaseParser):
     @staticmethod
     def _build_video_result(result: "DouyinApiResult") -> VideoParseResult:
         """构建视频解析结果"""
+        if result.video is None:
+            raise ParseError("抖音解析失败: 未获取到视频")
         return DouyinVideoParseResult(
             title=result.desc,
             video=result.video,
@@ -134,9 +136,9 @@ class DouyinApiResult:
     """抖音 API 解析结果"""
 
     type: DouyinMediaType
-    video: VideoRef = None
+    video: VideoRef | None = None
     desc: str = ""
-    image_list: list[ImageRef | LivePhotoRef] = None
+    image_list: list[ImageRef | LivePhotoRef] = field(default_factory=list)
 
     @classmethod
     def parse(cls, json_dict: dict) -> Self:
@@ -162,7 +164,7 @@ class DouyinApiResult:
         has_live_photos = any(img.get("video") for img in images)
 
         if has_live_photos:
-            image_list = []
+            image_list: list[ImageRef | LivePhotoRef] = []
             for image in images:
                 if video := image.get("video"):
                     video_info = parse_video_info(video)
@@ -206,7 +208,7 @@ class DouyinApiResult:
     def _parse_image_post_info(cls, image_post_info: dict, desc: str) -> Self:
         """解析新版图片格式 (image_post_info 字段)"""
         images = image_post_info.get("images", [])
-        image_list = []
+        image_list: list[ImageRef | LivePhotoRef] = []
 
         for image in images:
             display_image = image.get("display_image", {})

{parsehub-2.0.22 → 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
 
@@ -15,7 +16,7 @@ class InstagramParser(BaseParser):
     __match__ = r"^(http(s)?://)(www\.|)instagram\.com/(p|reel|share|.*/p|.*/reel)/.*"
     __redirect_keywords__ = ["share"]
 
-    async def _do_parse(self, raw_url: str) -> VideoParseResult | ImageParseResult | MultimediaParseResult | None:
+    async def _do_parse(self, raw_url: str) -> VideoParseResult | ImageParseResult | MultimediaParseResult:
         shortcode = self.get_short_code(raw_url)
         if not shortcode:
             raise ValueError("Instagram帖子链接无效")
@@ -32,7 +33,7 @@ class InstagramParser(BaseParser):
             case "GraphSidecar":
                 media = [
                     VideoRef(url=i.video_url, thumb_url=i.display_url, width=i.width, height=i.height)
-                    if i.is_video
+                    if i.is_video and i.video_url
                     else ImageRef(url=i.display_url, width=i.width, height=i.height)
                     for i in post.get_sidecar_nodes()
                 ]
@@ -44,9 +45,9 @@ class InstagramParser(BaseParser):
             case "GraphVideo":
                 return VideoParseResult(
                     video=VideoRef(
-                        url=post.video_url,
+                        url=post.video_url or post.url,
                         thumb_url=post.url,
-                        duration=int(post.video_duration),
+                        duration=int(post.video_duration or 0),
                         width=width,
                         height=height,
                     ),
@@ -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(
@@ -81,13 +82,13 @@ class InstagramParser(BaseParser):
             if cookie:
                 text = f"Instagram 账号可能已被封禁\n\n使用的Cookie: {cookie_ellipsis(cookie)}"
             else:
-                text = e
+                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.22 → parsehub-2.0.24}/src/parsehub/parsers/parser/pipix.py

@@ -23,9 +23,9 @@ class PipixParser(BaseParser):
                 video=VideoRef(
                     url=ppx.video_url,
                     thumb_url=ppx.video_thumb,
-                    duration=ppx.video_duration,
-                    height=ppx.video_height,
-                    width=ppx.video_width,
+                    duration=ppx.video_duration or 0,
+                    height=ppx.video_height or 0,
+                    width=ppx.video_width or 0,
                 ),
             )
         else:

{parsehub-2.0.22 → parsehub-2.0.24}/src/parsehub/parsers/parser/threads.py

@@ -1,5 +1,5 @@
 from ...provider_api.threads import ThreadsAPI, ThreadsMedia, ThreadsMediaType
-from ...types import ImageRef, MultimediaParseResult, Platform, VideoRef
+from ...types import AnyMediaRef, ImageRef, MultimediaParseResult, Platform, VideoRef
 from ..base.base import BaseParser
 
 
@@ -10,7 +10,7 @@ class ThreadsParser(BaseParser):
 
     async def _do_parse(self, raw_url: str) -> "MultimediaParseResult":
         post = await ThreadsAPI(proxy=self.proxy).parse(raw_url)
-        media = []
+        media: list[AnyMediaRef] = []
         if post.media:
             pm: list[ThreadsMedia] = post.media if isinstance(post.media, list) else [post.media]
             for m in pm: