novel-downloader 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

novel_downloader/core/fetchers/qidian.py

@@ -18,10 +18,8 @@ import aiohttp
 from novel_downloader.core.fetchers.base import BaseSession
 from novel_downloader.core.fetchers.registry import register_fetcher
 from novel_downloader.models import FetcherConfig, LoginField
-from novel_downloader.utils import (
-    async_jitter_sleep,
-    rc4_crypt,
-)
+from novel_downloader.utils import async_jitter_sleep
+from novel_downloader.utils.crypto_utils.rc4 import rc4_init, rc4_stream
 
 
 @register_fetcher(
@@ -32,6 +30,8 @@ class QidianSession(BaseSession):
     A session class for interacting with the 起点中文网 (www.qidian.com) novel website.
     """
 
+    site_name: str = "qidian"
+
     HOMEPAGE_URL = "https://www.qidian.com/"
     BOOKCASE_URL = "https://my.qidian.com/bookcase/"
     BOOK_INFO_URL = "https://www.qidian.com/book/{book_id}/"
@@ -40,10 +40,7 @@ class QidianSession(BaseSession):
     LOGIN_URL = "https://passport.qidian.com/"
 
     _cookie_keys: ClassVar[list[str]] = [
-        "X2NzcmZUb2tlbg==",
         "eXdndWlk",
-        "eXdvcGVuaWQ=",
-        "eXdrZXk=",
         "d190c2Zw",
     ]
 
@@ -53,7 +50,9 @@ class QidianSession(BaseSession):
         cookies: dict[str, str] | None = None,
         **kwargs: Any,
     ) -> None:
-        super().__init__("qidian", config, cookies, **kwargs)
+        super().__init__(config, cookies, **kwargs)
+        self._s_init = rc4_init(self._d2("dGcwOUl0Myo5aA=="))
+        self._cookie_key = self._d("d190c2Zw")
         self._fp_key = self._d("ZmluZ2VycHJpbnQ=")
         self._ab_key = self._d("YWJub3JtYWw=")
         self._ck_key = self._d("Y2hlY2tzdW0=")
@@ -85,12 +84,6 @@ class QidianSession(BaseSession):
         book_id: str,
         **kwargs: Any,
     ) -> list[str]:
-        """
-        Fetch the raw HTML of the book info page asynchronously.
-
-        :param book_id: The book identifier.
-        :return: The page content as string list.
-        """
         url = self.book_info_url(book_id=book_id)
         return [await self.fetch(url, **kwargs)]
 
@@ -100,13 +93,6 @@ class QidianSession(BaseSession):
         chapter_id: str,
         **kwargs: Any,
     ) -> list[str]:
-        """
-        Fetch the raw HTML of a single chapter asynchronously.
-
-        :param book_id: The book identifier.
-        :param chapter_id: The chapter identifier.
-        :return: The page content as string list.
-        """
         url = self.chapter_url(book_id=book_id, chapter_id=chapter_id)
         return [await self.fetch(url, **kwargs)]
 
@@ -122,18 +108,6 @@ class QidianSession(BaseSession):
         url = self.bookcase_url()
         return [await self.fetch(url, **kwargs)]
 
-    async def get_homepage(
-        self,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Retrieve the site home page.
-
-        :return: The HTML markup of the home page.
-        """
-        url = self.homepage_url()
-        return [await self.fetch(url, **kwargs)]
-
     @property
     def login_fields(self) -> list[LoginField]:
         return [
@@ -165,23 +139,21 @@ class QidianSession(BaseSession):
         if self._rate_limiter:
             await self._rate_limiter.wait()
 
-        cookie_key = self._d("d190c2Zw")
-
-        for attempt in range(self.retry_times + 1):
+        for attempt in range(self._retry_times + 1):
             try:
                 refreshed_token = self._build_payload_token(url)
-                self.update_cookies({cookie_key: refreshed_token})
+                self.update_cookies({self._cookie_key: refreshed_token})
 
                 async with self.session.get(url, **kwargs) as resp:
                     resp.raise_for_status()
                     text: str = await resp.text(encoding=encoding)
                     return text
             except aiohttp.ClientError:
-                if attempt < self.retry_times:
+                if attempt < self._retry_times:
                     await async_jitter_sleep(
-                        self.backoff_factor,
+                        self._backoff_factor,
                         mul_spread=1.1,
-                        max_sleep=self.backoff_factor + 2,
+                        max_sleep=self._backoff_factor + 2,
                     )
                     continue
                 raise
@@ -227,40 +199,30 @@ class QidianSession(BaseSession):
         """
         return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
 
-    def _update_fp_val(
-        self,
-        *,
-        key: str = "",
-    ) -> None:
-        """"""
-        enc_token = self._get_cookie_value(self._d("d190c2Zw"))
+    def _update_fp_val(self) -> None:
+        """
+        Decrypt the payload from cookie and update `_fp_val` and `_ab_val`.
+        """
+        enc_token = self._get_cookie_value(self._cookie_key)
         if not enc_token:
             return
-        if not key:
-            key = self._get_key()
-        decrypted_json: str = rc4_crypt(key, enc_token, mode="decrypt")
+
+        cipher_bytes = base64.b64decode(enc_token)
+        plain_bytes = rc4_stream(self._s_init, cipher_bytes)
+        decrypted_json = plain_bytes.decode("utf-8", errors="replace")
         payload: dict[str, Any] = json.loads(decrypted_json)
         self._fp_val = payload.get(self._fp_key, "")
         self._ab_val = payload.get(self._ab_key, "0" * 32)
 
-    def _build_payload_token(
-        self,
-        new_uri: str,
-        *,
-        key: str = "",
-    ) -> str:
+    def _build_payload_token(self, new_uri: str) -> str:
         """
         Patch a timestamp-bearing token with fresh timing and checksum info.
 
         :param new_uri: URI used in checksum generation.
-        :param key: RC4 key extracted from front-end JavaScript (optional).
-
         :return: Updated token with new timing and checksum values.
         """
         if not self._fp_val or not self._ab_val:
             self._update_fp_val()
-        if not key:
-            key = self._get_key()
 
         # rebuild timing fields
         loadts = int(time.time() * 1000)  # ms since epoch
@@ -278,9 +240,9 @@ class QidianSession(BaseSession):
             self._ab_key: self._ab_val,
             self._ck_key: ck_val,
         }
-        return rc4_crypt(
-            key, json.dumps(new_payload, separators=(",", ":")), mode="encrypt"
-        )
+        plain_bytes = json.dumps(new_payload, separators=(",", ":")).encode("utf-8")
+        cipher_bytes = rc4_stream(self._s_init, plain_bytes)
+        return base64.b64encode(cipher_bytes).decode("utf-8")
 
     async def _check_login_status(self) -> bool:
         """
@@ -335,8 +297,5 @@ class QidianSession(BaseSession):
         return base64.b64decode(b).decode()
 
     @staticmethod
-    def _get_key() -> str:
-        encoded = "Lj1qYxMuaXBjMg=="
-        decoded = base64.b64decode(encoded)
-        key = "".join([chr(b ^ 0x5A) for b in decoded])
-        return key
+    def _d2(b: str) -> bytes:
+        return base64.b64decode(b)

novel_downloader/core/fetchers/qqbook.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.fetchers.qqbook
+-------------------------------------
+
+"""
+
+import asyncio
+from typing import Any
+
+from novel_downloader.core.fetchers.base import BaseSession
+from novel_downloader.core.fetchers.registry import register_fetcher
+from novel_downloader.models import LoginField
+
+
+@register_fetcher(
+    site_keys=["qqbook", "qq"],
+)
+class QqbookSession(BaseSession):
+    """
+    A session class for interacting with the QQ 阅读 (book.qq.com) novel website.
+    """
+
+    site_name: str = "qqbook"
+
+    HOMEPAGE_URL = "https://book.qq.com/"
+    BOOKCASE_URL = "https://book.qq.com/book-shelf"
+    BOOK_INFO_URL = "https://book.qq.com/book-detail/{book_id}"
+    BOOK_CATALOG_URL = "https://book.qq.com/api/book/detail/chapters?bid={book_id}"
+    CHAPTER_URL = "https://book.qq.com/book-read/{book_id}/{chapter_id}/"
+
+    USER_HOMEPAGE_API_URL = "https://book.qq.com/api/user/homepage"
+
+    async def login(
+        self,
+        username: str = "",
+        password: str = "",
+        cookies: dict[str, str] | None = None,
+        attempt: int = 1,
+        **kwargs: Any,
+    ) -> bool:
+        """
+        Restore cookies persisted by the session-based workflow.
+        """
+        if not cookies:
+            return False
+        self.update_cookies(cookies)
+
+        self._is_logged_in = await self._check_login_status()
+        return self._is_logged_in
+
+    async def get_book_info(
+        self,
+        book_id: str,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Fetch the raw HTML of the book info page asynchronously.
+
+        Order: [info, catalog]
+
+        :param book_id: The book identifier.
+        :return: The page content as string list.
+        """
+        info_url = self.book_info_url(book_id=book_id)
+        catalog_url = self.book_catalog_url(book_id=book_id)
+
+        info_html, catalog_html = await asyncio.gather(
+            self.fetch(info_url, **kwargs),
+            self.fetch(catalog_url, **kwargs),
+        )
+        return [info_html, catalog_html]
+
+    async def get_book_chapter(
+        self,
+        book_id: str,
+        chapter_id: str,
+        **kwargs: Any,
+    ) -> list[str]:
+        url = self.chapter_url(book_id=book_id, chapter_id=chapter_id)
+        return [await self.fetch(url, **kwargs)]
+
+    async def get_bookcase(
+        self,
+        **kwargs: Any,
+    ) -> list[str]:
+        """
+        Retrieve the user's *bookcase* page.
+
+        :return: The HTML markup of the bookcase page.
+        """
+        url = self.bookcase_url()
+        return [await self.fetch(url, **kwargs)]
+
+    @property
+    def login_fields(self) -> list[LoginField]:
+        return [
+            LoginField(
+                name="cookies",
+                label="Cookie",
+                type="cookie",
+                required=True,
+                placeholder="请输入你的登录 Cookie",
+                description="可以通过浏览器开发者工具复制已登录状态下的 Cookie",
+            ),
+        ]
+
+    @classmethod
+    def homepage_url(cls) -> str:
+        """
+        Construct the URL for the site home page.
+
+        :return: Fully qualified URL of the home page.
+        """
+        return cls.HOMEPAGE_URL
+
+    @classmethod
+    def bookcase_url(cls) -> str:
+        """
+        Construct the URL for the user's bookcase page.
+
+        :return: Fully qualified URL of the bookcase.
+        """
+        return cls.BOOKCASE_URL
+
+    @classmethod
+    def book_info_url(cls, book_id: str) -> str:
+        """
+        Construct the URL for fetching a book's info page.
+
+        :param book_id: The identifier of the book.
+        :return: Fully qualified URL for the book info page.
+        """
+        return cls.BOOK_INFO_URL.format(book_id=book_id)
+
+    @classmethod
+    def book_catalog_url(cls, book_id: str) -> str:
+        """
+        Construct the URL for fetching a book's catalog page.
+
+        :param book_id: The identifier of the book.
+        :return: Fully qualified catalog page URL.
+        """
+        return cls.BOOK_CATALOG_URL.format(book_id=book_id)
+
+    @classmethod
+    def chapter_url(cls, book_id: str, chapter_id: str) -> str:
+        """
+        Construct the URL for fetching a specific chapter.
+
+        :param book_id: The identifier of the book.
+        :param chapter_id: The identifier of the chapter.
+        :return: Fully qualified chapter URL.
+        """
+        return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
+
+    async def _check_login_status(self) -> bool:
+        """
+        Check whether the user is currently logged in by
+        inspecting the user home page api content.
+
+        :return: True if the user is logged in, False otherwise.
+        """
+        try:
+            resp = await self.get(self.USER_HOMEPAGE_API_URL)
+            resp.raise_for_status()
+            payload = await resp.json(encoding="utf-8")
+            if payload.get("code") == 0:
+                return True
+            self.logger.info(
+                "login invalid (code=%s): %s",
+                payload.get("code"),
+                payload.get("msg"),
+            )
+        except Exception as e:
+            self.logger.info("login check failed: %s", e)
+        return False

novel_downloader/core/fetchers/quanben5.py

@@ -9,7 +9,6 @@ from typing import Any
 
 from novel_downloader.core.fetchers.base import BaseSession
 from novel_downloader.core.fetchers.registry import register_fetcher
-from novel_downloader.models import FetcherConfig
 
 
 @register_fetcher(
@@ -20,34 +19,22 @@ class Quanben5Session(BaseSession):
     A session class for interacting with the 全本小说网 (quanben5.com) novel website.
     """
 
+    site_name: str = "quanben5"
+    BASE_URL_MAP: dict[str, str] = {
+        "simplified": "quanben5.com",
+        "traditional": "big5.quanben5.com",
+    }
+    DEFAULT_BASE_URL: str = "quanben5.com"
+
     BOOK_INFO_URL = "https://{base_url}/n/{book_id}/xiaoshuo.html"
     CHAPTER_URL = "https://{base_url}/n/{book_id}/{chapter_id}.html"
 
-    def __init__(
-        self,
-        config: FetcherConfig,
-        cookies: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__("quanben5", config, cookies, **kwargs)
-        self.base_url = (
-            "quanben5.com"
-            if config.locale_style == "simplified"
-            else "big5.quanben5.com"
-        )
-
     async def get_book_info(
         self,
         book_id: str,
         **kwargs: Any,
     ) -> list[str]:
-        """
-        Fetch the raw HTML of the book info page asynchronously.
-
-        :param book_id: The book identifier.
-        :return: The page content as string list.
-        """
-        url = self.book_info_url(base_url=self.base_url, book_id=book_id)
+        url = self.book_info_url(base_url=self._base_url, book_id=book_id)
         return [await self.fetch(url, **kwargs)]
 
     async def get_book_chapter(
@@ -56,15 +43,8 @@ class Quanben5Session(BaseSession):
         chapter_id: str,
         **kwargs: Any,
     ) -> list[str]:
-        """
-        Fetch the raw HTML of a single chapter asynchronously.
-
-        :param book_id: The book identifier.
-        :param chapter_id: The chapter identifier.
-        :return: The page content as string list.
-        """
         url = self.chapter_url(
-            base_url=self.base_url, book_id=book_id, chapter_id=chapter_id
+            base_url=self._base_url, book_id=book_id, chapter_id=chapter_id
         )
         return [await self.fetch(url, **kwargs)]
 

novel_downloader/core/fetchers/rate_limiter.py

@@ -3,6 +3,7 @@
 novel_downloader.core.fetchers.rate_limiter
 -------------------------------------------
 
+An asyncio-compatible token bucket rate limiter.
 """
 
 import asyncio
@@ -10,45 +11,6 @@ import random
 import time
 
 
-class RateLimiter:
-    """
-    Simple async token-bucket rate limiter:
-    ensures no more than rate_per_sec
-    requests are started per second, across all coroutines.
-    """
-
-    def __init__(self, rate_per_sec: float):
-        self._interval = 1.0 / rate_per_sec
-        self._lock = asyncio.Lock()
-        self._last = time.monotonic()
-
-    async def wait(self) -> None:
-        async with self._lock:
-            now = time.monotonic()
-            elapsed = now - self._last
-            delay = self._interval - elapsed
-            if delay > 0:
-                jitter = random.uniform(0, 0.3)
-                await asyncio.sleep(delay + jitter)
-            self._last = time.monotonic()
-
-
-class RateLimiterV2:
-    def __init__(self, rate_per_sec: float):
-        self._interval = 1.0 / rate_per_sec
-        self._lock = asyncio.Lock()
-        self._next_allowed_time = time.monotonic()
-
-    async def wait(self) -> None:
-        async with self._lock:
-            now = time.monotonic()
-            if now < self._next_allowed_time:
-                delay = self._next_allowed_time - now
-                jitter = random.uniform(0, 0.05 * self._interval)
-                await asyncio.sleep(delay + jitter)
-            self._next_allowed_time = max(now, self._next_allowed_time) + self._interval
-
-
 class TokenBucketRateLimiter:
     def __init__(
         self,
@@ -56,9 +18,16 @@ class TokenBucketRateLimiter:
         burst: int = 10,
         jitter_strength: float = 0.3,
     ):
+        """
+        A simple asyncio-compatible token bucket rate limiter.
+
+        :param rate: Tokens added per second.
+        :param burst: Maximum bucket size (burst capacity).
+        :param jitter_strength: Jitter range in seconds (+/-).
+        """
         self.rate = rate
         self.capacity = burst
-        self.tokens = burst
+        self.tokens = float(burst)
         self.timestamp = time.monotonic()
         self.lock = asyncio.Lock()
         self.jitter_strength = jitter_strength
@@ -68,19 +37,19 @@ class TokenBucketRateLimiter:
             now = time.monotonic()
             elapsed = now - self.timestamp
 
-            self.tokens = min(self.capacity, int(self.tokens + elapsed * self.rate))
+            self.tokens = min(self.capacity, self.tokens + elapsed * self.rate)
             self.timestamp = now
 
-            if self.tokens >= 1:
-                self.tokens -= 1
-                jitter = random.uniform(-self.jitter_strength, self.jitter_strength)
-                if jitter > 0:
-                    await asyncio.sleep(jitter)
+            if self.tokens >= 1.0:
+                self.tokens -= 1.0
                 return
-            else:
-                wait_time = (1 - self.tokens) / self.rate
-                jitter = random.uniform(-self.jitter_strength, self.jitter_strength)
-                total_wait = max(0.0, wait_time + jitter)
-                await asyncio.sleep(total_wait)
-                self.timestamp = time.monotonic()
-                self.tokens = max(0, self.tokens - 1)
+
+            wait_time = (1.0 - self.tokens) / self.rate
+            jitter = random.uniform(-self.jitter_strength, self.jitter_strength)
+            total_wait = max(0.0, wait_time + jitter)
+
+        await asyncio.sleep(total_wait)
+
+        async with self.lock:
+            self.timestamp = time.monotonic()
+            self.tokens = max(0.0, self.tokens - 1.0)

novel_downloader/core/fetchers/sfacg.py

@@ -9,7 +9,7 @@ from typing import Any
 
 from novel_downloader.core.fetchers.base import BaseSession
 from novel_downloader.core.fetchers.registry import register_fetcher
-from novel_downloader.models import FetcherConfig, LoginField
+from novel_downloader.models import LoginField
 
 
 @register_fetcher(
@@ -20,20 +20,14 @@ class SfacgSession(BaseSession):
     A session class for interacting with the SF轻小说 (m.sfacg.com) novel website.
     """
 
+    site_name: str = "sfacg"
+
     LOGIN_URL = "https://m.sfacg.com/login"
     BOOKCASE_URL = "https://m.sfacg.com/sheets/"
     BOOK_INFO_URL = "https://m.sfacg.com/b/{book_id}/"
     BOOK_CATALOG_URL = "https://m.sfacg.com/i/{book_id}/"
     CHAPTER_URL = "https://m.sfacg.com/c/{chapter_id}/"
 
-    def __init__(
-        self,
-        config: FetcherConfig,
-        cookies: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__("sfacg", config, cookies, **kwargs)
-
     async def login(
         self,
         username: str = "",
@@ -83,13 +77,6 @@ class SfacgSession(BaseSession):
         chapter_id: str,
         **kwargs: Any,
     ) -> list[str]:
-        """
-        Fetch the raw HTML of a single chapter asynchronously.
-
-        :param book_id: The book identifier.
-        :param chapter_id: The chapter identifier.
-        :return: The page content as string list.
-        """
         url = self.chapter_url(book_id=book_id, chapter_id=chapter_id)
         return [await self.fetch(url, **kwargs)]
 

novel_downloader/core/fetchers/shencou.py

@@ -10,7 +10,6 @@ from typing import Any
 
 from novel_downloader.core.fetchers.base import BaseSession
 from novel_downloader.core.fetchers.registry import register_fetcher
-from novel_downloader.models import FetcherConfig
 
 
 @register_fetcher(
@@ -21,18 +20,12 @@ class ShencouSession(BaseSession):
     A session class for interacting with the 神凑轻小说 (www.shencou.com) novel website.
     """
 
+    site_name: str = "shencou"
+
     BOOK_INFO_URL = "https://www.shencou.com/books/read_{book_id}.html"
     BOOK_CATALOG_URL = "https://www.shencou.com/read/{book_id}/index.html"
     CHAPTER_URL = "https://www.shencou.com/read/{book_id}/{chapter_id}.html"
 
-    def __init__(
-        self,
-        config: FetcherConfig,
-        cookies: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__("shencou", config, cookies, **kwargs)
-
     async def get_book_info(
         self,
         book_id: str,
@@ -62,13 +55,6 @@ class ShencouSession(BaseSession):
         chapter_id: str,
         **kwargs: Any,
     ) -> list[str]:
-        """
-        Fetch the raw HTML of a single chapter asynchronously.
-
-        :param book_id: The book identifier.
-        :param chapter_id: The chapter identifier.
-        :return: The page content as string list.
-        """
         book_id = book_id.replace("-", "/")
         url = self.chapter_url(book_id=book_id, chapter_id=chapter_id)
         return [await self.fetch(url, **kwargs)]

novel_downloader/core/fetchers/shuhaige.py

@@ -9,7 +9,6 @@ from typing import Any
 
 from novel_downloader.core.fetchers.base import BaseSession
 from novel_downloader.core.fetchers.registry import register_fetcher
-from novel_downloader.models import FetcherConfig
 
 
 @register_fetcher(
@@ -21,28 +20,16 @@ class ShuhaigeSession(BaseSession):
     书海阁小说网 (www.shuhaige.net) novel website.
     """
 
+    site_name: str = "shuhaige"
+
     BOOK_INFO_URL = "https://www.shuhaige.net/{book_id}/"
     CHAPTER_URL = "https://www.shuhaige.net/{book_id}/{chapter_id}.html"
 
-    def __init__(
-        self,
-        config: FetcherConfig,
-        cookies: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__("shuhaige", config, cookies, **kwargs)
-
     async def get_book_info(
         self,
         book_id: str,
         **kwargs: Any,
     ) -> list[str]:
-        """
-        Fetch the raw HTML of the book info page asynchronously.
-
-        :param book_id: The book identifier.
-        :return: The page content as string list.
-        """
         url = self.book_info_url(book_id=book_id)
         return [await self.fetch(url, **kwargs)]
 
@@ -52,13 +39,6 @@ class ShuhaigeSession(BaseSession):
         chapter_id: str,
         **kwargs: Any,
     ) -> list[str]:
-        """
-        Fetch the raw HTML of a single chapter asynchronously.
-
-        :param book_id: The book identifier.
-        :param chapter_id: The chapter identifier.
-        :return: The page content as string list.
-        """
         url = self.chapter_url(book_id=book_id, chapter_id=chapter_id)
         return [await self.fetch(url, **kwargs)]