novel-downloader 1.5.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

novel_downloader/core/fetchers/qbtr.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.fetchers.qbtr
+-----------------------------------
+
+"""
+
+from typing import Any
+
+from lxml import html
+
+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(
+    site_keys=["qbtr"],
+)
+class QbtrSession(BaseSession):
+    """
+    A session class for interacting with the 全本同人小说 (www.qbtr.cc) novel website.
+    """
+
+    BASE_URL = "https://www.qbtr.cc"
+    BOOK_INFO_URL = "https://www.qbtr.cc/{book_id}.html"
+    CHAPTER_URL = "https://www.qbtr.cc/{book_id}/{chapter_id}.html"
+
+    def __init__(
+        self,
+        config: FetcherConfig,
+        cookies: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__("qbtr", 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.
+
+        Order: [info, download]
+
+        :param book_id: The book identifier.
+        :return: The page content as string list.
+        """
+        book_id = book_id.replace("-", "/")
+        url = self.book_info_url(book_id=book_id)
+        info_html = await self.fetch(url, **kwargs)
+        try:
+            info_tree = html.fromstring(info_html)
+            txt_link = info_tree.xpath(
+                '//div[@class="booktips"]/h3/a[contains(text(), "txt下载")]/@href'
+            )
+            download_url = f"{self.BASE_URL}{txt_link[0]}" if txt_link else None
+        except Exception:
+            download_url = None
+
+        download_html = await self.fetch(download_url, **kwargs) if download_url else ""
+        return [info_html, download_html]
+
+    async def get_book_chapter(
+        self,
+        book_id: str,
+        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)]
+
+    @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 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)

novel_downloader/core/fetchers/{qianbi/session.py → qianbi.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.fetchers.qianbi.session
----------------------------------------------
+novel_downloader.core.fetchers.qianbi
+-------------------------------------
 
 """
 
@@ -15,11 +15,10 @@ from novel_downloader.models import FetcherConfig
 
 @register_fetcher(
     site_keys=["qianbi"],
-    backends=["session"],
 )
 class QianbiSession(BaseSession):
     """
-    A session class for interacting with the Qianbi (www.23qb.com) novel website.
+    A session class for interacting with the 铅笔小说 (www.23qb.com) novel website.
     """
 
     BASE_URLS = [
@@ -50,7 +49,7 @@ class QianbiSession(BaseSession):
         Order: [info, catalog]
 
         :param book_id: The book identifier.
-        :return: The page content as a string.
+        :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)
@@ -72,7 +71,7 @@ class QianbiSession(BaseSession):
 
         :param book_id: The book identifier.
         :param chapter_id: The chapter identifier.
-        :return: The chapter content as a string.
+        :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)]
@@ -107,7 +106,3 @@ class QianbiSession(BaseSession):
         :return: Fully qualified chapter URL.
         """
         return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
-
-    @property
-    def hostname(self) -> str:
-        return "www.23qb.com"

novel_downloader/core/fetchers/{qidian/session.py → qidian.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.fetchers.qidian.session
----------------------------------------------
+novel_downloader.core.fetchers.qidian
+-------------------------------------
 
 """
 
@@ -10,6 +10,7 @@ import hashlib
 import json
 import random
 import time
+from collections.abc import Mapping
 from typing import Any, ClassVar
 
 import aiohttp
@@ -17,24 +18,20 @@ 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_sleep_with_random_delay,
-    rc4_crypt,
-)
+from novel_downloader.utils import async_jitter_sleep
+from novel_downloader.utils.crypto_utils.rc4 import rc4_init, rc4_stream
 
 
 @register_fetcher(
     site_keys=["qidian", "qd"],
-    backends=["session"],
 )
 class QidianSession(BaseSession):
     """
-    A session class for interacting with the Qidian (www.qidian.com) novel website.
+    A session class for interacting with the 起点中文网 (www.qidian.com) novel website.
     """
 
     HOMEPAGE_URL = "https://www.qidian.com/"
     BOOKCASE_URL = "https://my.qidian.com/bookcase/"
-    # BOOK_INFO_URL = "https://book.qidian.com/info/{book_id}/"
     BOOK_INFO_URL = "https://www.qidian.com/book/{book_id}/"
     CHAPTER_URL = "https://www.qidian.com/chapter/{book_id}/{chapter_id}/"
 
@@ -55,11 +52,13 @@ class QidianSession(BaseSession):
         **kwargs: Any,
     ) -> None:
         super().__init__("qidian", config, cookies, **kwargs)
-        self._fp_key = _d("ZmluZ2VycHJpbnQ=")
-        self._ab_key = _d("YWJub3JtYWw=")
-        self._ck_key = _d("Y2hlY2tzdW0=")
-        self._lt_key = _d("bG9hZHRz")
-        self._ts_key = _d("dGltZXN0YW1w")
+        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=")
+        self._lt_key = self._d("bG9hZHRz")
+        self._ts_key = self._d("dGltZXN0YW1w")
         self._fp_val: str = ""
         self._ab_val: str = ""
 
@@ -90,7 +89,7 @@ class QidianSession(BaseSession):
         Fetch the raw HTML of the book info page asynchronously.
 
         :param book_id: The book identifier.
-        :return: The page content as a string.
+        :return: The page content as string list.
         """
         url = self.book_info_url(book_id=book_id)
         return [await self.fetch(url, **kwargs)]
@@ -106,7 +105,7 @@ class QidianSession(BaseSession):
 
         :param book_id: The book identifier.
         :param chapter_id: The chapter identifier.
-        :return: The chapter content as a string.
+        :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)]
@@ -159,19 +158,17 @@ class QidianSession(BaseSession):
         a cookie-based token used for request validation.
 
         The method:
-        1. Reads the existing cookie (if any);
-        2. Generates a new value tied to *url*;
-        3. Updates the live ``requests.Session``;
+          1. Reads the existing cookie (if any);
+          2. Generates a new value tied to *url*;
+          3. Updates the live ``requests.Session``;
         """
         if self._rate_limiter:
             await self._rate_limiter.wait()
 
-        cookie_key = _d("d190c2Zw")
-
         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()
@@ -179,7 +176,7 @@ class QidianSession(BaseSession):
                     return text
             except aiohttp.ClientError:
                 if attempt < self.retry_times:
-                    await async_sleep_with_random_delay(
+                    await async_jitter_sleep(
                         self.backoff_factor,
                         mul_spread=1.1,
                         max_sleep=self.backoff_factor + 2,
@@ -228,47 +225,30 @@ class QidianSession(BaseSession):
         """
         return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
 
-    @property
-    def hostname(self) -> str:
-        return "www.qidian.com"
-
-    def _update_fp_val(
-        self,
-        *,
-        key: str = "",
-    ) -> None:
-        """"""
-        enc_token = self.get_cookie_value(_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 = _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.
-        :type new_uri: str
-        :param key: RC4 key extracted from front-end JavaScript (optional).
-        :type key: str, optional
-
         :return: Updated token with new timing and checksum values.
-        :rtype: str
         """
         if not self._fp_val or not self._ab_val:
             self._update_fp_val()
-        if not key:
-            key = _get_key()
 
         # rebuild timing fields
         loadts = int(time.time() * 1000)  # ms since epoch
@@ -286,9 +266,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:
         """
@@ -311,25 +291,37 @@ class QidianSession(BaseSession):
         """
         Check if the provided cookies contain all required keys.
 
-        Logs any missing keys as warnings.
-
         :param cookies: The cookie dictionary to validate.
         :return: True if all required keys are present, False otherwise.
         """
-        required = {_d(k) for k in self._cookie_keys}
+        required = {self._d(k) for k in self._cookie_keys}
         actual = set(cookies)
         missing = required - actual
         if missing:
             self.logger.warning("Missing required cookies: %s", ", ".join(missing))
         return not missing
 
+    def _get_cookie_value(self, key: str) -> str | None:
+        for cookie in self.session.cookie_jar:
+            if cookie.key == key:
+                return str(cookie.value)
+        return None
+
+    @staticmethod
+    def _filter_cookies(
+        raw_cookies: list[Mapping[str, Any]],
+    ) -> dict[str, str]:
+        ALLOWED_DOMAINS = {".qidian.com", "www.qidian.com", ""}
+        return {
+            c["name"]: c["value"]
+            for c in raw_cookies
+            if c.get("domain", "") in ALLOWED_DOMAINS
+        }
 
-def _d(b: str) -> str:
-    return base64.b64decode(b).decode()
-
+    @staticmethod
+    def _d(b: str) -> str:
+        return base64.b64decode(b).decode()
 
-def _get_key() -> str:
-    encoded = "Lj1qYxMuaXBjMg=="
-    decoded = base64.b64decode(encoded)
-    key = "".join([chr(b ^ 0x5A) for b in decoded])
-    return key
+    @staticmethod
+    def _d2(b: str) -> bytes:
+        return base64.b64decode(b)

novel_downloader/core/fetchers/quanben5.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.fetchers.quanben5
+---------------------------------------
+
+"""
+
+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(
+    site_keys=["quanben5"],
+)
+class Quanben5Session(BaseSession):
+    """
+    A session class for interacting with the 全本小说网 (quanben5.com) novel website.
+    """
+
+    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)
+        return [await self.fetch(url, **kwargs)]
+
+    async def get_book_chapter(
+        self,
+        book_id: str,
+        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
+        )
+        return [await self.fetch(url, **kwargs)]
+
+    @classmethod
+    def book_info_url(cls, base_url: str, 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(base_url=base_url, book_id=book_id)
+
+    @classmethod
+    def chapter_url(cls, base_url: str, 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(
+            base_url=base_url, book_id=book_id, chapter_id=chapter_id
+        )

novel_downloader/core/fetchers/{base/rate_limiter.py → rate_limiter.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.fetchers.base.rate_limiter
-------------------------------------------------
+novel_downloader.core.fetchers.rate_limiter
+-------------------------------------------
 
 """
 

novel_downloader/core/fetchers/registry.py

@@ -3,6 +3,7 @@
 novel_downloader.core.fetchers.registry
 ---------------------------------------
 
+Registry and factory helpers for creating site-specific fetchers.
 """
 
 __all__ = ["register_fetcher", "get_fetcher"]
@@ -16,27 +17,24 @@ from novel_downloader.models import FetcherConfig
 FetcherBuilder = Callable[[FetcherConfig], FetcherProtocol]
 
 F = TypeVar("F", bound=FetcherProtocol)
-_FETCHER_MAP: dict[str, dict[str, FetcherBuilder]] = {}
+_FETCHER_MAP: dict[str, FetcherBuilder] = {}
 
 
 def register_fetcher(
     site_keys: Sequence[str],
-    backends: Sequence[str],
 ) -> Callable[[type[F]], type[F]]:
     """
     Decorator to register a fetcher class under given keys.
 
     :param site_keys: Sequence of site identifiers
-    :param backends:  Sequence of backend types
+    :param backends: Sequence of backend types
     :return: A class decorator that populates _FETCHER_MAP.
     """
 
     def decorator(cls: type[F]) -> type[F]:
         for site in site_keys:
             site_lower = site.lower()
-            bucket = _FETCHER_MAP.setdefault(site_lower, {})
-            for backend in backends:
-                bucket[backend] = cls
+            _FETCHER_MAP[site_lower] = cls
         return cls
 
     return decorator
@@ -55,17 +53,8 @@ def get_fetcher(
     """
     site_key = site.lower()
     try:
-        backend_map = _FETCHER_MAP[site_key]
+        fetcher_cls = _FETCHER_MAP[site_key]
     except KeyError as err:
         raise ValueError(f"Unsupported site: {site!r}") from err
 
-    mode = config.mode
-    try:
-        fetcher_cls = backend_map[mode]
-    except KeyError as err:
-        raise ValueError(
-            f"Unsupported fetcher mode {mode!r} for site {site!r}. "
-            f"Available modes: {list(backend_map)}"
-        ) from err
-
     return fetcher_cls(config)

novel_downloader/core/fetchers/{sfacg/session.py → sfacg.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.fetchers.sfacg.session
---------------------------------------------
+novel_downloader.core.fetchers.sfacg
+------------------------------------
 
 """
 
@@ -14,11 +14,10 @@ from novel_downloader.models import FetcherConfig, LoginField
 
 @register_fetcher(
     site_keys=["sfacg"],
-    backends=["session"],
 )
 class SfacgSession(BaseSession):
     """
-    A session class for interacting with the Sfacg (m.sfacg.com) novel website.
+    A session class for interacting with the SF轻小说 (m.sfacg.com) novel website.
     """
 
     LOGIN_URL = "https://m.sfacg.com/login"
@@ -65,8 +64,10 @@ class SfacgSession(BaseSession):
         """
         Fetch the raw HTML of the book info page asynchronously.
 
+        Order: [info, catalog]
+
         :param book_id: The book identifier.
-        :return: The page content as a string.
+        :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)
@@ -87,7 +88,7 @@ class SfacgSession(BaseSession):
 
         :param book_id: The book identifier.
         :param chapter_id: The chapter identifier.
-        :return: The chapter content as a string.
+        :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)]
@@ -157,10 +158,6 @@ class SfacgSession(BaseSession):
         """
         return cls.CHAPTER_URL.format(chapter_id=chapter_id)
 
-    @property
-    def hostname(self) -> str:
-        return "m.sfacg.com"
-
     async def _check_login_status(self) -> bool:
         """
         Check whether the user is currently logged in by