parsehub 2.3.3__tar.gz → 2.3.5__tar.gz

{parsehub-2.3.3/src/parsehub.egg-info → parsehub-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parsehub
-Version: 2.3.3
+Version: 2.3.5
 Summary: 轻量、异步、开箱即用的社交媒体聚合解析库
 Author-email: 梓澪 <zilingmio@gmail.com>
 License: MIT
@@ -37,6 +37,7 @@ Requires-Dist: cryptography>=49.0.0
 Requires-Dist: gmssl>=3.2.2
 Requires-Dist: signerpy>=0.12.0
 Requires-Dist: curl-cffi>=0.13
+Requires-Dist: xhshow>=0.2.0
 Provides-Extra: cli
 Requires-Dist: argcomplete>=3.6.3; extra == "cli"
 Requires-Dist: platformdirs>=4.5.1; extra == "cli"

{parsehub-2.3.3 → parsehub-2.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "parsehub"
-version = "2.3.3"
+version = "2.3.5"
 description = "轻量、异步、开箱即用的社交媒体聚合解析库"
 readme = "README.md"
 requires-python = ">=3.12.0"
@@ -40,6 +40,7 @@ dependencies = [
     "gmssl>=3.2.2",
     "signerpy>=0.12.0",
     "curl-cffi>=0.13",
+    "xhshow>=0.2.0",
 ]
 
 [project.scripts]

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/__init__.py

@@ -2,6 +2,10 @@ from pathlib import Path
 
 from loguru import logger
 
+from .errors import ContentUnavailableError as ContentUnavailableError
+from .errors import ContentUnavailableFallbackError as ContentUnavailableFallbackError
+from .errors import FallbackAttempt as FallbackAttempt
+from .errors import FallbackError as FallbackError
 from .errors import ParseError, UnknownPlatform
 from .parsers.base import BaseParser
 from .types import Platform
@@ -182,7 +186,7 @@ class ParseHub:
         except ParseError:
             raise
         except Exception as e:
-            raise ParseError from e
+            raise ParseError(str(e)) from e
 
     def _select_parser(self, url: str) -> type[BaseParser] | None:
         """选择解析器

parsehub-2.3.5/src/parsehub/errors.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+
+
+class ParseHubError(Exception):
+    MSG = __doc__
+
+    def __init__(self, msg: str = ""):
+        super().__init__(self.MSG if not msg else f"{self.MSG}: {msg}")
+
+
+class ParseError(ParseHubError):
+    """解析错误"""
+
+    MSG = __doc__
+
+
+class ContentUnavailableError(ParseError):
+    """作品不可用"""
+
+    MSG = __doc__
+
+
+@dataclass(frozen=True)
+class FallbackAttempt:
+    name: str
+    error: Exception
+    cookie: bool = False
+
+
+def format_attempts(attempts: list[FallbackAttempt], indent: int = 0) -> str:
+    lines = []
+    for attempt in attempts:
+        prefix = "  " * indent + f"- {attempt.name}"
+        if isinstance(attempt.error, FallbackError):
+            lines.append(f"{prefix}:")
+            lines.append(format_attempts(attempt.error.attempts, indent + 1))
+        else:
+            error = attempt.error
+            text = str(error) if isinstance(error, ParseHubError) else f"{type(error).__name__}: {error}"
+            lines.append(f"{prefix}: {text}")
+    return "\n".join(lines)
+
+
+class FallbackError(ParseError):
+    """所有解析方式均失败"""
+
+    MSG = __doc__
+
+    def __init__(self, attempts: list[FallbackAttempt]):
+        self.attempts = attempts
+        Exception.__init__(self, f"{self.MSG}:\n{format_attempts(attempts)}")
+
+
+class ContentUnavailableFallbackError(FallbackError, ContentUnavailableError):
+    """作品不可用"""
+
+    MSG = __doc__
+
+
+class DownloadError(ParseHubError):
+    """下载错误"""
+
+    MSG = __doc__
+
+
+class DeleteError(ParseHubError):
+    """删除文件错误"""
+
+    MSG = __doc__
+
+
+class UnknownPlatform(ParseHubError):
+    """不支持的平台"""
+
+    MSG = __doc__

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/base/base.py

@@ -2,16 +2,39 @@ import importlib
 import pkgutil
 import re
 from abc import ABC, abstractmethod
-from typing import Any
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
 from urllib.parse import parse_qs, urlencode, urlparse
 
 import httpx
+from loguru import logger
 
 from ... import parsers
-from ...types import AnyParseResult, ParseError
+from ...types import (
+    AnyParseResult,
+    ContentUnavailableError,
+    ContentUnavailableFallbackError,
+    FallbackAttempt,
+    FallbackError,
+    ParseError,
+)
 from ...types.platform import Platform
 from ...utils.helpers import UA, SecretCookie, match_url
 
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class FallbackStage(Generic[T]):  # noqa: UP046
+    name: str
+    func: Callable[[], Awaitable[T]]
+    cookie: bool = False
+
+
+def is_content_unavailable(e: Exception) -> bool:
+    return isinstance(e, ContentUnavailableError)
+
 
 class BaseParser(ABC):
     _registry: list[type["BaseParser"]] = []
@@ -33,6 +56,7 @@ class BaseParser(ABC):
     def __init__(self, *, proxy: str | None = None, cookie: SecretCookie = SecretCookie()):
         self.proxy = proxy
         self.cookie = cookie
+        self._fallback_attempts: list[FallbackAttempt] = []
 
     def __init_subclass__(cls, /, register: bool = True, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
@@ -63,13 +87,41 @@ class BaseParser(ABC):
         :param url: 分享文案 / 分享链接
         :return: 解析结果
         """
+        self._fallback_attempts = []
         raw_url = await self.get_raw_url(url, clean_all=False)
         result = await self._do_parse(raw_url)
+        result.fallback_errors = list(self._fallback_attempts)
         result.platform = self.__platform__
         raw_url_clean = self._clean_params(raw_url, self.__after_clean_parameters__)
         result.raw_url = raw_url_clean
         return result
 
+    async def _fallback(
+        self,
+        *stages: FallbackStage[T],
+        stop: Callable[[Exception], bool] = is_content_unavailable,
+    ) -> T:
+        attempts: list[FallbackAttempt] = []
+        for stage in stages:
+            try:
+                result = await stage.func()
+            except Exception as e:
+                logger.opt(exception=e).debug(f"{self.__platform__} {stage.name} 解析失败")
+                if stop(e):
+                    raise
+                attempts.append(FallbackAttempt(stage.name, e, stage.cookie))
+            else:
+                self._fallback_attempts.extend(attempts)
+                return result
+
+        if len(attempts) == 1:
+            raise attempts[0].error
+        last_error = attempts[-1].error
+        error_type = (
+            ContentUnavailableFallbackError if isinstance(last_error, ContentUnavailableError) else FallbackError
+        )
+        raise error_type(attempts) from last_error
+
     @abstractmethod
     async def _do_parse(self, raw_url: str) -> AnyParseResult:
         """解析

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/base/ytdlp.py

@@ -410,7 +410,7 @@ class YtParser(BaseParser, register=False):
             url = dl.get("webpage_url") or url
         title = dl["title"]
         duration = dl.get("duration", 0)
-        thumbnail = dl["thumbnail"]
+        thumbnail = dl.get("thumbnail")
         description = dl["description"]
         width = dl.get("width", 0)
         height = dl.get("height", 0)
@@ -548,7 +548,7 @@ class YtVideoInfo:
 
     title: str
     description: str
-    thumbnail: str
+    thumbnail: str | None
     url: str
     info_json: dict[str, Any]
     duration: int = 0

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/parser/bilibili.py

@@ -5,8 +5,6 @@ from pathlib import Path
 from typing import Any, cast
 from urllib.parse import parse_qs, parse_qsl, urlencode, urlparse
 
-from loguru import logger
-
 from ...provider_api.bilibili import BiliAPI, BiliDynamic
 from ...types import (
     ContentUnavailableError,
@@ -21,7 +19,7 @@ from ...types import (
     VideoRef,
 )
 from ...utils.helpers import UA
-from ..base.base import BaseParser
+from ..base.base import BaseParser, FallbackStage
 from ..base.ytdlp import YtParser, YtVideoParseResult
 
 
@@ -33,6 +31,8 @@ class BiliParse(BaseParser):
     __redirect_keywords__ = ["b23.tv", "bili2233.cn"]
 
     async def _do_parse(self, raw_url: str) -> YtVideoParseResult | BiliVideoParseResult | ImageParseResult:
+        if urlparse(raw_url).path.startswith("/bangumi/"):
+            raise ParseError("不支持解析番剧和影视")
         if await self.is_dynamic(raw_url):
             dynamic = await self.get_dynamic_info(raw_url)
             content = self.hashtag_handler(dynamic.content or "")
@@ -49,14 +49,11 @@ class BiliParse(BaseParser):
                 photo=photos,
             )
         else:
-            try:
-                return await self.bili_api_parse(raw_url)
-            except Exception as e:
-                logger.opt(exception=e).warning("Bilibili API 解析失败, 尝试 yt-dlp 解析")
-                try:
-                    return await self.ytp_parse(raw_url)
-                except Exception as e:
-                    raise ParseError("Bilibili 解析失败") from e
+            return await self._fallback(
+                FallbackStage("API", lambda: self.bili_api_parse(raw_url)),
+                FallbackStage("yt-dlp", lambda: self.ytp_parse(raw_url)),
+                stop=lambda e: False,
+            )
 
     @staticmethod
     def _is_bvid(url: str) -> bool:

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/parser/douyin.py

@@ -18,7 +18,7 @@ from ...types import (
     VideoParseResult,
     VideoRef,
 )
-from ..base.base import BaseParser
+from ..base.base import BaseParser, FallbackStage
 
 
 class DouyinParser(BaseParser):
@@ -41,30 +41,22 @@ class DouyinParser(BaseParser):
         """获取并解析抖音 API 结果"""
         web_cookie = self.cookie.get_value() or {}
 
-        web_error: ParseError | None = None
-        if web_cookie:
-            try:
-                web_crawler = DouyinWebCrawler(proxy=self.proxy, cookie=web_cookie)
-                response = await web_crawler.parse(raw_url)
-                return DouyinApiResult.parse(response)
-            except ContentUnavailableError:
-                raise
-            except ParseError as e:
-                web_error = e
-
-        try:
+        async def fetch_web() -> "DouyinApiResult":
+            web_crawler = DouyinWebCrawler(proxy=self.proxy, cookie=web_cookie)
+            response = await web_crawler.parse(raw_url)
+            return DouyinApiResult.parse(response)
+
+        async def fetch_mobile() -> "DouyinApiResult":
             mobile_device = DouyinMobileDevice.resolve()
             app_crawler = DouyinMobileCrawler(proxy=self.proxy, device=mobile_device)
             response = await app_crawler.parse(raw_url)
             return DouyinApiResult.parse(response)
-        except ParseError as e:
-            mobile_error = e
-
-        if isinstance(mobile_error, ContentUnavailableError):
-            raise mobile_error
-        if web_error:
-            raise ParseError(f"{web_error}；移动端解析也失败: {mobile_error}") from mobile_error
-        raise mobile_error
+
+        stages: list[FallbackStage[DouyinApiResult]] = []
+        if web_cookie:
+            stages.append(FallbackStage("网页端", fetch_web, cookie=True))
+        stages.append(FallbackStage("移动端", fetch_mobile))
+        return await self._fallback(*stages)
 
     @staticmethod
     def _build_video_result(result: "DouyinApiResult") -> VideoParseResult:

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/parser/facebook.py

@@ -6,6 +6,7 @@ class FacebookParse(YtParser):
     __platform__ = Platform.FACEBOOK
     __supported_type__ = ["视频"]
     __match__ = r"^(http(s)?://)?.+facebook.com/(watch\?v|share/[v,r]|.+/videos/|reel/).*"
+    __reserved_parameters__ = ["v"]
 
 
 __all__ = ["FacebookParse"]

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/parser/instagram.py

@@ -61,7 +61,7 @@ class InstagramParser(BaseParser):
                     else:
                         raise ParseError("受限视频无法解析: 你必须年满 18 周岁才能观看这个视频") from e
                 case _:
-                    raise ParseError("无法获取帖子内容") from e
+                    raise ParseError(f"无法获取帖子内容: {e}") from e
         except Exception as e:
             if cookie:
                 text = f"Instagram 账号可能已被封禁\n\n使用的Cookie: {cookie}"

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/parser/kuaishou.py

@@ -1,9 +1,15 @@
-from loguru import logger
-
 from ...provider_api.kuaishou import KuaiShouAPI, KuaishouParser
-from ...types import ImageParseResult, ImageRef, ParseError, Platform, VideoParseResult, VideoRef
+from ...types import (
+    ContentUnavailableError,
+    ImageParseResult,
+    ImageRef,
+    ParseError,
+    Platform,
+    VideoParseResult,
+    VideoRef,
+)
 from ...utils.helpers import SecretCookie
-from ..base.base import BaseParser
+from ..base.base import BaseParser, FallbackStage
 
 COOKIE = SecretCookie(
     "kpf=PC_WEB; clientid=3; did=web_bfbcdb2f5b3dc663a745deabafcf61e6; kwpsecproductname=kuaishou-"
@@ -28,25 +34,24 @@ COOKIE = SecretCookie(
 class KuaiShouParser(BaseParser):
     __platform__ = Platform.KUAISHOU
     __supported_type__ = ["视频", "图文"]
-    __match__ = r"^(http(s)?://)?(www|v|live|v\.m)\.(kuaishou|chenzhongtech).com/.+"
+    __match__ = r"^(http(s)?://)?(www|v|live|v\.m|[a-z0-9]+\.m)\.(kuaishou|chenzhongtech).com/.+"
     __redirect_keywords__ = ["v.kuaishou", "/f/"]
 
     async def _do_parse(self, raw_url: str) -> VideoParseResult | ImageParseResult:
         ksp = await KuaishouParser.create(
             raw_url, proxy=self.proxy, cookie=self.cookie.get_value() or COOKIE.get_value()
         )
-        cover = ksp.get_cover_photo_url()
+        if ksp.page_type == "UNKNOWN" and ksp.error_result in (223, 20113):
+            raise ContentUnavailableError(f"{ksp.error_result} {ksp.error_msg}")
         if (
             ksp.page_type == "VIDEO" or "/short-video/" in raw_url
         ):  # 地区风控导致获取到的 page_type 可能为 ATLAS 但实际为视频
-            try:
+            async def parse_html() -> VideoParseResult:
                 content = ksp.get_title_content()
                 video = ksp.get_real_video_url()
-            except Exception as e:
-                logger.error(f"快手 HTML 解析失败, 尝试 API 解析: {e}")
-            else:
                 if not video:
                     raise ParseError("-1 快手解析失败")
+                cover = ksp.get_cover_photo_url()
 
                 return VideoParseResult(
                     title=content,
@@ -59,12 +64,9 @@ class KuaiShouParser(BaseParser):
                     ),
                 )
 
-            ks = KuaiShouAPI(self.cookie.get_value() or COOKIE.get_value(), self.proxy)
-            try:
+            async def parse_api() -> VideoParseResult:
+                ks = KuaiShouAPI(self.cookie.get_value() or COOKIE.get_value(), self.proxy)
                 result = await ks.get_video_info(raw_url)
-            except Exception as e:
-                raise ParseError(f"-2 快手解析失败: {e}") from e
-            else:
                 return VideoParseResult(
                     title=result.title,
                     video=VideoRef(
@@ -75,7 +77,13 @@ class KuaiShouParser(BaseParser):
                         width=result.width,
                     ),
                 )
+
+            return await self._fallback(
+                FallbackStage("HTML", parse_html),
+                FallbackStage("API", parse_api),
+            )
         else:
+            cover = ksp.get_cover_photo_url()
             content = ksp.get_title_content()
             img = ksp.get_image_list()
             if img:

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/parser/twitter.py

@@ -11,7 +11,6 @@ from ...provider_api.twitter import (
 from ...types import (
     AniRef,
     AnyMediaRef,
-    ContentUnavailableError,
     ImageRef,
     MultimediaParseResult,
     ParseError,
@@ -19,7 +18,7 @@ from ...types import (
     RichTextParseResult,
     VideoRef,
 )
-from ..base.base import BaseParser
+from ..base.base import BaseParser, FallbackStage, is_content_unavailable
 
 
 class TwitterParser(BaseParser):
@@ -36,26 +35,26 @@ class TwitterParser(BaseParser):
         return str(urlunparse(urlparse(url)._replace(netloc="x.com")))
 
     async def _parse(self, url: str) -> TwitterTweet:
-        x = Twitter(self.proxy, cookie=None)
-        try:
-            tweet = await x.fetch_tweet(url)
-        except ContentUnavailableError:
-            raise
-        except Exception as e:
-            if any(s in str(e) for s in ("error -2", "error -3")):
-                if cookie := self.cookie.get_value():
-                    x2 = Twitter(self.proxy, cookie=cookie)
-                    try:
-                        tweet = await x2.fetch_tweet(url)
-                    except ContentUnavailableError:
-                        raise
-                    except Exception as e2:
-                        raise ParseError(f"Twitter 账号无权限或已被封禁\n\n使用的 Cookie: {self.cookie}") from e2
-                else:
-                    raise ParseError(str(e)) from e
-            else:
-                raise ParseError(str(e)) from e
-        return tweet
+        stages: list[FallbackStage[TwitterTweet]] = [
+            FallbackStage("匿名", lambda: Twitter(self.proxy, cookie=None).fetch_tweet(url))
+        ]
+        if cookie := self.cookie.get_value():
+
+            async def fetch_cookie() -> TwitterTweet:
+                try:
+                    return await Twitter(self.proxy, cookie=cookie).fetch_tweet(url)
+                except Exception as e2:
+                    raise ParseError(
+                        f"Twitter 账号无权限或已被封禁: {e2}\n\n使用的 Cookie: {self.cookie}"
+                    ) from e2
+
+            stages.append(FallbackStage("cookie", fetch_cookie, cookie=True))
+
+        return await self._fallback(
+            *stages,
+            stop=lambda e: is_content_unavailable(e)
+            or not any(s in str(e) for s in ("error -2", "error -3")),
+        )
 
     @staticmethod
     async def media_parse(tweet: TwitterTweet) -> MultimediaParseResult | RichTextParseResult:

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/parsers/parser/xhs.py

@@ -3,7 +3,7 @@ from typing import Union
 
 import httpx
 
-from ...provider_api.xhs import XHSAPI, XHSMedia, XHSMediaType, XHSPostType
+from ...provider_api.xhs import MOBILE_HEADERS, PC_HEADERS, XHSAPI, XHSMedia, XHSMediaType, XHSPost, XHSPostType
 from ...types import (
     ContentUnavailableError,
     ImageParseResult,
@@ -15,8 +15,7 @@ from ...types import (
     VideoParseResult,
     VideoRef,
 )
-from ...utils.helpers import UA
-from ..base import BaseParser
+from ..base.base import BaseParser, FallbackStage
 
 
 class XHSParser(BaseParser):
@@ -24,24 +23,41 @@ class XHSParser(BaseParser):
     __supported_type__ = ["视频", "图文"]
     __match__ = r"^(http(s)?://)?.+(xiaohongshu|xhslink).(com|cn)/.+"
     __redirect_keywords__ = ["xhslink"]
-    __after_clean_parameters__ = ["xsec_token"]
+    __after_clean_parameters__ = ["xsec_token", "xsec_source"]
 
     async def get_raw_url(self, url: str, *, clean_all: bool = False, headers: dict | None = None) -> str:
-        headers = {
-            "User-Agent": UA,
-            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,"
-            "*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-        }
-        url = await super().get_raw_url(url, clean_all=clean_all, headers=headers)
+        url = await super().get_raw_url(url, clean_all=clean_all, headers=MOBILE_HEADERS)
         if "/login" in url:
             raise ParseError("该帖子需要登录后查看")
+        elif "/404/sec" in url:
+            raise ParseError("被小红书风控拦截")
         elif "/404" in url:
             raise ContentUnavailableError("帖子不存在")
         return url
 
     async def _do_parse(self, raw_url: str) -> Union["VideoParseResult", "ImageParseResult", "MultimediaParseResult"]:
-        xhs = XHSAPI(proxy=self.proxy, cookie=self.cookie.get_value())
-        result = await xhs.extract(raw_url)
+        xhs = XHSAPI(proxy=self.proxy)
+        stages: list[FallbackStage[XHSPost]] = []
+        if cookie := self.cookie.get_value():
+
+            async def parse_cookie() -> XHSPost:
+                return await xhs.extract(raw_url, PC_HEADERS, cookie)
+
+            stages.append(FallbackStage("cookie", parse_cookie, cookie=True))
+
+        async def parse_session() -> XHSPost:
+            return await xhs.extract(raw_url, PC_HEADERS, await xhs.new_session())
+
+        async def parse_mobile() -> XHSPost:
+            return await xhs.extract(raw_url, MOBILE_HEADERS)
+
+        stages.extend(
+            [
+                FallbackStage("游客 session", parse_session),
+                FallbackStage("移动端", parse_mobile),
+            ]
+        )
+        result = await self._fallback(*stages, stop=lambda e: False)
 
         desc = self.hashtag_handler(result.desc)
         match result.type:

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/provider_api/douyin.py

@@ -10,6 +10,7 @@ import random
 import re
 import time
 import uuid
+from collections import Counter
 from dataclasses import dataclass
 from random import choice, randint
 from typing import Any, ClassVar, cast
@@ -1156,7 +1157,7 @@ class DouyinMobileCrawler:
         return self.device
 
     async def fetch_one_video(self, aweme_id: str) -> dict:
-        last_error = "unknown"
+        errors: Counter[str] = Counter()
         async with httpx.AsyncClient(proxy=self.proxy, timeout=20, follow_redirects=True) as client:
             for _ in range(8):
                 await self._select_device(client)
@@ -1171,10 +1172,10 @@ class DouyinMobileCrawler:
                             response = await client.get(url, headers=headers)
                             content = response.content
                         except Exception as e:
-                            last_error = str(e)
+                            errors[str(e)] += 1
                             continue
                         if not content:
-                            last_error = f"{host} returned empty body"
+                            errors[f"{host} returned empty body"] += 1
                             if not self._fixed_device:
                                 if self.device is not None:
                                     self.__class__._evict_device(self.device)
@@ -1184,18 +1185,19 @@ class DouyinMobileCrawler:
                         try:
                             payload = response.json()
                         except Exception:
-                            last_error = f"{host} returned non-json body"
+                            errors[f"{host} returned non-json body"] += 1
                             continue
                         if payload.get("aweme_detail"):
                             await self._attach_story_default_play(payload["aweme_detail"])
                             return cast(dict[str, Any], payload)
                         if payload.get("filter_detail"):
                             return cast(dict[str, Any], payload)
-                        last_error = f"{host} missing aweme_detail: {payload.get('status_msg') or payload}"
+                        errors[f"{host} missing aweme_detail: {payload.get('status_msg') or payload}"] += 1
                     if replace_device:
                         break
                 await asyncio.sleep(0.15)
-        raise ParseError(f"获取抖音作品失败: {last_error}")
+        error_summary = "; ".join(f"{msg}×{count}" for msg, count in errors.most_common()) or "unknown"
+        raise ParseError(f"获取抖音作品失败: {error_summary}")
 
     async def parse(self, raw_url: str) -> dict:
         aweme_id = await self.get_aweme_id(raw_url)

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/provider_api/kuaishou.py

@@ -212,6 +212,8 @@ class KuaishouParser:
         self.page_type = "UNKNOWN"
         self.structured_data: dict = {}
         self.client: dict = {}
+        self.error_result: int | None = None
+        self.error_msg: str | None = None
 
     @classmethod
     async def create(cls, real_url, proxy: str | None = None, cookie: dict | None = None):
@@ -319,8 +321,10 @@ class KuaishouParser:
             return False
         if default_client.get("VisionVideoSetRepresentation:1"):
             return True
-        for key in default_client.keys():
-            if "visionVideoDetail" in key or "VisionVideoDetailPhoto:" in key:
+        for key, value in default_client.items():
+            if "visionVideoDetail" in key and isinstance(value, dict) and value.get("photo"):
+                return True
+            if "VisionVideoDetailPhoto:" in key:
                 return True
         return False
 
@@ -333,6 +337,10 @@ class KuaishouParser:
         page_type, structured_data = self._identify_and_parse_data()
         if page_type == "UNKNOWN" or not structured_data:
             return False
+        error_payload = self._find_nested_dict(structured_data, ("result", "error_msg"))
+        if error_payload and error_payload["result"] != 1 and error_payload["error_msg"]:
+            self.error_result = error_payload["result"]
+            self.error_msg = error_payload["error_msg"]
         if not self._is_valid_video_state(page_type, structured_data):
             logger.warning(f"Kuaishou route {candidate_url} returned incomplete video state, trying fallback")
             return False

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/provider_api/twitter.py

@@ -91,6 +91,13 @@ class Twitter:
         if not legacy:
             if result.get("__typename") == "TweetTombstone":
                 raise Exception("error -2: 该推文开启了限制, 匿名用户无法查看")
+            match result.get("reason"):
+                case "Suspended":
+                    raise ContentUnavailableError("error -5: 这个帖子来自一个被冻结的账号")
+                case "BounceDeleted":
+                    raise ContentUnavailableError("error -5: 这个帖子违反了 X 规则")
+                case "Protected":
+                    raise Exception("error -3: 你无法查看这个帖子，因为该账号所有者限制了可以查看其帖子的用户")
             raise Exception(f"error -3: {result.get('reason')}")
 
         if article := result.get("article", {}):

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/provider_api/xhs.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import base64
 import json
+import os
 import re
 from dataclasses import dataclass
 from enum import Enum
@@ -9,33 +11,71 @@ from typing import Any, cast
 
 import httpx
 from bs4 import BeautifulSoup
+from xhshow import Xhshow
 
 from ..errors import ContentUnavailableError, ParseError
 from ..utils.helpers import UA
 
+PC_HEADERS = {
+    "User-Agent": UA,
+    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp"
+    ",image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+}
+# 手机 UA 配 Chrome 的 accept 会被跳到验证码页
+MOBILE_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 "
+    "(KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1",
+    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+}
+ACTIVATE_URI = "/api/sns/web/v1/login/activate"
+
 
 class XHSAPI:
-    def __init__(self, proxy: str | None = None, cookie: dict | None = None):
+    def __init__(self, proxy: str | None = None):
         self.proxy = proxy
-        self.cookie = cookie
-
-    async def __fetch_html(self, url: str) -> str:
-        async with httpx.AsyncClient(proxy=self.proxy, cookies=self.cookie, follow_redirects=True) as client:
-            result = await client.get(
-                url,
-                headers={
-                    "User-Agent": UA,
-                    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp"
-                    ",image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-                },
-                timeout=30,
-            )
+        self.xhshow = Xhshow()
+
+    async def __fetch_html(self, url: str, headers: dict[str, str], cookie: dict | None = None) -> str:
+        async with httpx.AsyncClient(proxy=self.proxy, cookies=cookie, follow_redirects=True) as client:
+            try:
+                result = await client.get(url, headers=headers, timeout=30)
+            except httpx.HTTPError as e:
+                raise ParseError(f"请求失败: {e!r}") from e
             if "/login" in str(result.url):
                 raise ParseError("该帖子需要登录后查看")
+            elif "/404/sec" in str(result.url):
+                raise ParseError("被小红书风控拦截")
             elif "/404" in str(result.url):
                 raise ContentUnavailableError("帖子不存在")
             return result.text
 
+    async def new_session(self) -> dict[str, str]:
+        """获取游客 web_session"""
+        a1 = self.xhshow.generate_a1()
+        cookies = {"a1": a1, "webId": self.xhshow.generate_web_id(a1), "xsecappid": "xhs-pc-web"}
+        payload = {"client_public_key_base64": base64.b64encode(os.urandom(32)).decode()}
+        headers = self.xhshow.sign_headers_post(ACTIVATE_URI, cookies, payload=payload)
+        headers.update(
+            {
+                "User-Agent": UA,
+                "Content-Type": "application/json;charset=UTF-8",
+                "Origin": "https://www.xiaohongshu.com",
+                "Referer": "https://www.xiaohongshu.com/",
+            }
+        )
+        async with httpx.AsyncClient(proxy=self.proxy, cookies=cookies, timeout=30) as client:
+            try:
+                result = await client.post(
+                    f"https://edith.xiaohongshu.com{ACTIVATE_URI}",
+                    headers=headers,
+                    content=self.xhshow.build_json_body(payload),
+                )
+            except httpx.HTTPError as e:
+                raise ParseError(f"获取游客 session 失败: {e!r}") from e
+        if not (web_session := result.cookies.get("web_session")):
+            raise ParseError(f"获取游客 session 失败: {result.status_code} {result.text}")
+        return {"web_session": web_session}
+
     @staticmethod
     async def __extract_data(html: str) -> dict[str, Any]:
         soup = BeautifulSoup(html, "lxml")
@@ -51,10 +91,12 @@ class XHSAPI:
         return cast(dict[str, Any], data)
 
     def __parse(self, data: dict[str, Any]) -> XHSPost:
-        if not data.get("note"):
+        if h5_data := data.get("noteData"):
+            note = (h5_data.get("data") or {}).get("noteData")
+        elif pc_data := data.get("note"):
+            note = (pc_data["noteDetailMap"].get(pc_data["firstNoteId"]) or {}).get("note")
+        else:
             raise ParseError("该帖子需要登录后查看")
-        first_note_id = data["note"]["firstNoteId"]
-        note = data["note"]["noteDetailMap"][first_note_id]["note"]
         if not note:
             raise ParseError("未获取到内容, 该帖子可能需要登录后查看")
 
@@ -86,6 +128,18 @@ class XHSAPI:
             return cast(list[dict[str, Any]], stream["h266"])
         return None
 
+    @staticmethod
+    def __image_url(image: dict[str, Any]) -> str:
+        return cast(str, image.get("urlDefault") or image["url"])
+
+    def __image_thumb_url(self, image: dict[str, Any]) -> str:
+        if url := image.get("urlPre"):
+            return cast(str, url)
+        for info in image.get("infoList") or []:
+            if info.get("imageScene") == "H5_PRV":
+                return cast(str, info["url"])
+        return self.__image_url(image)
+
     def __parse_media(self, note: dict[str, Any]) -> list[XHSMedia]:
         media_list = []
         il = note.get("imageList") or []
@@ -104,7 +158,7 @@ class XHSAPI:
                     duration=stream["duration"],
                     height=stream["height"],
                     width=stream["width"],
-                    thumb_url=il[0]["urlDefault"],
+                    thumb_url=self.__image_url(il[0]),
                 )
             )
         else:
@@ -116,7 +170,7 @@ class XHSAPI:
                     stream = selected_stream[0]
                     image = XHSMedia(
                         XHSMediaType.LIVE_PHOTO,
-                        thumb_url=self.get_raw_image_url(i["urlDefault"]),
+                        thumb_url=self.get_raw_image_url(self.__image_url(i)),
                         url=stream["masterUrl"],
                         width=i["width"],
                         height=i["height"],
@@ -124,16 +178,16 @@ class XHSAPI:
                 else:
                     image = XHSMedia(
                         XHSMediaType.IMAGE,
-                        url=self.get_raw_image_url(i["urlDefault"]),
-                        thumb_url=i["urlPre"],
+                        url=self.get_raw_image_url(self.__image_url(i)),
+                        thumb_url=self.__image_thumb_url(i),
                         width=i["width"],
                         height=i["height"],
                     )
                 media_list.append(image)
         return media_list
 
-    async def extract(self, url: str) -> XHSPost:
-        html = await self.__fetch_html(url)
+    async def extract(self, url: str, headers: dict[str, str], cookie: dict | None = None) -> XHSPost:
+        html = await self.__fetch_html(url, headers, cookie)
         return self.__parse(await self.__extract_data(html))
 
     @staticmethod
@@ -187,6 +241,6 @@ if __name__ == "__main__":
     async def main() -> None:
         url = ""
         xhs = XHSAPI()
-        print(await xhs.extract(url))
+        print(await xhs.extract(url, PC_HEADERS))
 
     asyncio.run(main())

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/types/__init__.py

@@ -1,4 +1,11 @@
-from ..errors import ContentUnavailableError, DownloadError, ParseError
+from ..errors import (
+    ContentUnavailableError,
+    ContentUnavailableFallbackError,
+    DownloadError,
+    FallbackAttempt,
+    FallbackError,
+    ParseError,
+)
 from .callback import ProgressCallback, ProgressUnit
 from .media_file import AniFile, AnyMediaFile, ImageFile, LivePhotoFile, MediaFile, VideoFile
 from .media_ref import AniRef, AnyMediaRef, ImageRef, LivePhotoRef, MediaRef, VideoRef
@@ -18,6 +25,9 @@ __all__ = [
     "DownloadError",
     "ParseError",
     "ContentUnavailableError",
+    "FallbackAttempt",
+    "FallbackError",
+    "ContentUnavailableFallbackError",
     "MediaRef",
     "AniRef",
     "VideoRef",

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub/types/result.py

@@ -13,7 +13,7 @@ from markdown import markdown as md_to_html
 from slugify import slugify
 
 from ..config import GlobalConfig
-from ..errors import DeleteError, DownloadError
+from ..errors import DeleteError, DownloadError, FallbackAttempt
 from ..utils.downloader import download
 from ..utils.helpers import run_sync
 from .callback import ProgressCallback
@@ -42,6 +42,7 @@ class ParseResult(ABC):  # noqa: B024
         :param platform: 平台
         """
         self.raw_url: str = ""
+        self.fallback_errors: list[FallbackAttempt] = []
         self.title = title.strip()
         self.content = content.strip()
         self.media = media

{parsehub-2.3.3 → parsehub-2.3.5/src/parsehub.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: parsehub
-Version: 2.3.3
+Version: 2.3.5
 Summary: 轻量、异步、开箱即用的社交媒体聚合解析库
 Author-email: 梓澪 <zilingmio@gmail.com>
 License: MIT
@@ -37,6 +37,7 @@ Requires-Dist: cryptography>=49.0.0
 Requires-Dist: gmssl>=3.2.2
 Requires-Dist: signerpy>=0.12.0
 Requires-Dist: curl-cffi>=0.13
+Requires-Dist: xhshow>=0.2.0
 Provides-Extra: cli
 Requires-Dist: argcomplete>=3.6.3; extra == "cli"
 Requires-Dist: platformdirs>=4.5.1; extra == "cli"

{parsehub-2.3.3 → parsehub-2.3.5}/src/parsehub.egg-info/requires.txt

@@ -20,6 +20,7 @@ cryptography>=49.0.0
 gmssl>=3.2.2
 signerpy>=0.12.0
 curl-cffi>=0.13
+xhshow>=0.2.0
 
 [cli]
 argcomplete>=3.6.3

parsehub-2.3.3/src/parsehub/errors.py

@@ -1,35 +0,0 @@
-class ParseHubError(Exception):
-    MSG = __doc__
-
-    def __init__(self, msg: str = ""):
-        super().__init__(self.MSG if not msg else f"{self.MSG}: {msg}")
-
-
-class ParseError(ParseHubError):
-    """解析错误"""
-
-    MSG = __doc__
-
-
-class ContentUnavailableError(ParseError):
-    """作品不可用"""
-
-    MSG = __doc__
-
-
-class DownloadError(ParseHubError):
-    """下载错误"""
-
-    MSG = __doc__
-
-
-class DeleteError(ParseHubError):
-    """删除文件错误"""
-
-    MSG = __doc__
-
-
-class UnknownPlatform(ParseHubError):
-    """不支持的平台"""
-
-    MSG = __doc__