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

novel_downloader/core/exporters/qidian.py

@@ -8,25 +8,54 @@ Exporter implementation for Qidian novels, supporting plain and encrypted source
 
 __all__ = ["QidianExporter"]
 
-from novel_downloader.core.exporters.registry import register_exporter
-from novel_downloader.models import ExporterConfig
+from typing import Any, ClassVar
 
-from .common import CommonExporter
+from novel_downloader.core.exporters.common import CommonExporter
+from novel_downloader.core.exporters.registry import register_exporter
 
 
 @register_exporter(site_keys=["qidian", "qd"])
 class QidianExporter(CommonExporter):
-    """ """
+    """
+    Exporter for Qidian (起点) novels.
+    """
 
-    DEFAULT_SOURCE_ID = 0
-    ENCRYPTED_SOURCE_ID = 1
-    PRIORITIES_MAP = {
+    DEFAULT_SOURCE_ID: ClassVar[int] = 0
+    ENCRYPTED_SOURCE_ID: ClassVar[int] = 1
+    PRIORITIES_MAP: ClassVar[dict[int, int]] = {
         DEFAULT_SOURCE_ID: 0,
         ENCRYPTED_SOURCE_ID: 1,
     }
 
-    def __init__(
-        self,
-        config: ExporterConfig,
-    ):
-        super().__init__(config, site="qidian")
+    def _render_txt_extras(self, extras: dict[str, Any]) -> str:
+        """
+        render "作者说" for TXT:
+          * Clean content
+          * Strip leading/trailing blanks
+          * Drop multiple blank lines (keep only non-empty lines)
+        """
+        note = self._cleaner.clean_content(extras.get("author_say") or "").strip()
+        if not note:
+            return ""
+
+        # collapse blank lines
+        body = "\n".join(s for line in note.splitlines() if (s := line.strip()))
+        return f"作者说\n\n{body}"
+
+    def _render_epub_extras(self, extras: dict[str, Any]) -> str:
+        """
+        render "作者说" for EPUB:
+          * Clean content
+          * Keep as HTML-safe via _render_html_block
+          * Wrap with `<hr/>` + `<h3>作者说</h3>`
+        """
+        note = self._cleaner.clean_content(extras.get("author_say") or "").strip()
+        if not note:
+            return ""
+
+        parts = [
+            "<hr />",
+            "<h3>作者说</h3>",
+            self._render_html_block(note),
+        ]
+        return "\n".join(parts)

novel_downloader/core/exporters/qqbook.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.qqbook
+--------------------------------------
+
+Exporter implementation for QQ book novels, supporting plain and encrypted sources.
+"""
+
+__all__ = ["QqbookExporter"]
+
+from typing import ClassVar
+
+from novel_downloader.core.exporters.common import CommonExporter
+from novel_downloader.core.exporters.registry import register_exporter
+
+
+@register_exporter(site_keys=["qqbook", "qq"])
+class QqbookExporter(CommonExporter):
+    """
+    Exporter for QQ 阅读 novels.
+    """
+
+    DEFAULT_SOURCE_ID: ClassVar[int] = 0
+    ENCRYPTED_SOURCE_ID: ClassVar[int] = 1
+    PRIORITIES_MAP: ClassVar[dict[int, int]] = {
+        DEFAULT_SOURCE_ID: 0,
+        ENCRYPTED_SOURCE_ID: 1,
+    }

novel_downloader/core/exporters/registry.py

@@ -15,7 +15,7 @@ from novel_downloader.core.exporters.common import CommonExporter
 from novel_downloader.core.interfaces import ExporterProtocol
 from novel_downloader.models import ExporterConfig
 
-ExporterBuilder = Callable[[ExporterConfig], ExporterProtocol]
+ExporterBuilder = Callable[[ExporterConfig, str], ExporterProtocol]
 
 E = TypeVar("E", bound=ExporterProtocol)
 _EXPORTER_MAP: dict[str, ExporterBuilder] = {}
@@ -52,4 +52,4 @@ def get_exporter(site: str, config: ExporterConfig) -> ExporterProtocol:
         exporter_cls = _EXPORTER_MAP[site_key]
     except KeyError:
         return CommonExporter(config, site_key)
-    return exporter_cls(config)
+    return exporter_cls(config, site_key)

novel_downloader/core/fetchers/__init__.py

@@ -12,7 +12,6 @@ __all__ = [
     "BiqugeSession",
     "BiquyueduSession",
     "DxmwxSession",
-    "EightnovelSession",
     "EsjzoneSession",
     "GuidayeSession",
     "HetushuSession",
@@ -21,10 +20,12 @@ __all__ = [
     "Jpxs123Session",
     "LewennSession",
     "LinovelibSession",
+    "N8novelSession",
     "PiaotiaSession",
     "QbtrSession",
     "QianbiSession",
     "QidianSession",
+    "QqbookSession",
     "Quanben5Session",
     "SfacgSession",
     "ShencouSession",
@@ -44,7 +45,6 @@ from .aaatxt import AaatxtSession
 from .b520 import BiqugeSession
 from .biquyuedu import BiquyueduSession
 from .dxmwx import DxmwxSession
-from .eightnovel import EightnovelSession
 from .esjzone import EsjzoneSession
 from .guidaye import GuidayeSession
 from .hetushu import HetushuSession
@@ -53,10 +53,12 @@ from .ixdzs8 import Ixdzs8Session
 from .jpxs123 import Jpxs123Session
 from .lewenn import LewennSession
 from .linovelib import LinovelibSession
+from .n8novel import N8novelSession
 from .piaotia import PiaotiaSession
 from .qbtr import QbtrSession
 from .qianbi import QianbiSession
 from .qidian import QidianSession
+from .qqbook import QqbookSession
 from .quanben5 import Quanben5Session
 from .registry import get_fetcher
 from .sfacg import SfacgSession

novel_downloader/core/fetchers/aaatxt.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,28 +19,16 @@ class AaatxtSession(BaseSession):
     A session class for interacting with the 3A电子书 (www.aaatxt.com) novel website.
     """
 
+    site_name: str = "aaatxt"
+
     BOOK_INFO_URL = "http://www.aaatxt.com/shu/{book_id}.html"
     CHAPTER_URL = "http://www.aaatxt.com/yuedu/{chapter_id}.html"
 
-    def __init__(
-        self,
-        config: FetcherConfig,
-        cookies: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__("aaatxt", 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)]
 
@@ -51,13 +38,6 @@ class AaatxtSession(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(chapter_id=chapter_id)
         return [await self.fetch(url, encoding="gb2312", **kwargs)]
 

novel_downloader/core/fetchers/b520.py

@@ -9,39 +9,26 @@ 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=["biquge", "bqg", "b520"],
+    site_keys=["biquge", "b520"],
 )
 class BiqugeSession(BaseSession):
     """
     A session class for interacting with the 笔趣阁 (www.b520.cc) novel website.
     """
 
+    site_name: str = "b520"
+
     BOOK_INFO_URL = "http://www.b520.cc/{book_id}/"
     CHAPTER_URL = "http://www.b520.cc/{book_id}/{chapter_id}.html"
 
-    def __init__(
-        self,
-        config: FetcherConfig,
-        cookies: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__("biquge", 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)]
 
@@ -51,13 +38,6 @@ class BiqugeSession(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, encoding="gbk", **kwargs)]
 

novel_downloader/core/fetchers/base.py

@@ -16,27 +16,24 @@ from typing import Any, Self
 import aiohttp
 from aiohttp import ClientResponse, ClientSession, ClientTimeout, TCPConnector
 
-from novel_downloader.core.interfaces import FetcherProtocol
 from novel_downloader.models import FetcherConfig, LoginField
-from novel_downloader.utils import (
-    async_jitter_sleep,
-)
-from novel_downloader.utils.constants import (
-    DATA_DIR,
-    DEFAULT_USER_HEADERS,
-)
+from novel_downloader.utils import async_jitter_sleep
+from novel_downloader.utils.constants import DATA_DIR, DEFAULT_USER_HEADERS
 
 from .rate_limiter import TokenBucketRateLimiter
 
 
-class BaseSession(FetcherProtocol, abc.ABC):
+class BaseSession(abc.ABC):
     """
     BaseSession wraps basic HTTP operations using aiohttp.ClientSession.
     """
 
+    site_name: str
+    BASE_URL_MAP: dict[str, str] = {}
+    DEFAULT_BASE_URL: str = ""
+
     def __init__(
         self,
-        site: str,
         config: FetcherConfig,
         cookies: dict[str, str] | None = None,
         **kwargs: Any,
@@ -47,26 +44,59 @@ class BaseSession(FetcherProtocol, abc.ABC):
         :param config: Configuration object for session behavior
         :param cookies: Optional initial cookies to set on the session.
         """
-        self._site = site
-        self._config = config
+        self._base_url = self._resolve_base_url(config.locale_style)
+        self._backoff_factor = config.backoff_factor
+        self._request_interval = config.request_interval
+        self._retry_times = config.retry_times
+        self._timeout = config.timeout
+        self._max_connections = config.max_connections
+        self._verify_ssl = config.verify_ssl
+        self._init_cookies = cookies or {}
+        self._is_logged_in = False
 
-        self._state_file = DATA_DIR / site / "session_state.cookies"
-        self._state_file.parent.mkdir(parents=True, exist_ok=True)
+        self._state_file = DATA_DIR / self.site_name / "session_state.cookies"
 
-        self._is_logged_in = False
         self._headers = (
-            config.headers.copy() if config.headers else DEFAULT_USER_HEADERS.copy()
+            config.headers.copy()
+            if config.headers is not None
+            else DEFAULT_USER_HEADERS.copy()
         )
         if config.user_agent:
             self._headers["User-Agent"] = config.user_agent
-        self._cookies = cookies or {}
+
         self._session: ClientSession | None = None
-        self._rate_limiter: TokenBucketRateLimiter | None = None
+        self._rate_limiter: TokenBucketRateLimiter | None = (
+            TokenBucketRateLimiter(config.max_rps) if config.max_rps > 0 else None
+        )
 
-        if config.max_rps > 0:
-            self._rate_limiter = TokenBucketRateLimiter(config.max_rps)
+        self.logger = logging.getLogger(f"{__name__}.{self.__class__.__name__}")
 
-        self.logger = logging.getLogger(f"{self.__class__.__name__}")
+    async def init(
+        self,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Set up the aiohttp.ClientSession with timeout, connector, headers.
+        """
+        timeout = ClientTimeout(total=self._timeout)
+        connector = TCPConnector(
+            ssl=self._verify_ssl,
+            limit_per_host=self._max_connections,
+        )
+        self._session = ClientSession(
+            timeout=timeout,
+            connector=connector,
+            headers=self._headers,
+            cookies=self._init_cookies,
+        )
+
+    async def close(self) -> None:
+        """
+        Shutdown and clean up any resources.
+        """
+        if self._session and not self._session.closed:
+            await self._session.close()
+        self._session = None
 
     async def login(
         self,
@@ -113,47 +143,16 @@ class BaseSession(FetcherProtocol, abc.ABC):
         """
         ...
 
-    async def get_bookcase(
-        self,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Optional: Retrieve the HTML content of the authenticated user's bookcase page.
-        Subclasses that support user login/bookcase should override this.
-
-        :return: The HTML of the bookcase page.
-        """
-        raise NotImplementedError(
-            "Bookcase fetching is not supported by this session type. "
-            "Override get_bookcase() in your subclass to enable it."
-        )
-
-    async def init(
-        self,
-        **kwargs: Any,
-    ) -> None:
+    @property
+    def is_logged_in(self) -> bool:
         """
-        Set up the aiohttp.ClientSession with timeout, connector, headers.
+        Indicates whether the requester is currently authenticated.
         """
-        timeout = ClientTimeout(total=self.timeout)
-        connector = TCPConnector(
-            ssl=self._config.verify_ssl,
-            limit_per_host=self.max_connections,
-        )
-        self._session = ClientSession(
-            timeout=timeout,
-            connector=connector,
-            headers=self._headers,
-            cookies=self._cookies,
-        )
+        return self._is_logged_in
 
-    async def close(self) -> None:
-        """
-        Shutdown and clean up any resources.
-        """
-        if self._session and not self._session.closed:
-            await self._session.close()
-        self._session = None
+    @property
+    def login_fields(self) -> list[LoginField]:
+        return []
 
     async def fetch(
         self,
@@ -172,17 +171,17 @@ class BaseSession(FetcherProtocol, abc.ABC):
         if self._rate_limiter:
             await self._rate_limiter.wait()
 
-        for attempt in range(self.retry_times + 1):
+        for attempt in range(self._retry_times + 1):
             try:
                 async with self.session.get(url, **kwargs) as resp:
                     resp.raise_for_status()
                     return await self._response_to_str(resp, encoding)
             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
@@ -304,7 +303,6 @@ class BaseSession(FetcherProtocol, abc.ABC):
 
         :param cookies: A dictionary of cookie key-value pairs.
         """
-        self._cookies.update(cookies)
         if self._session:
             self._session.cookie_jar.update_cookies(cookies)
 
@@ -326,21 +324,6 @@ class BaseSession(FetcherProtocol, abc.ABC):
         """
         return False
 
-    @property
-    def site(self) -> str:
-        return self._site
-
-    @property
-    def is_logged_in(self) -> bool:
-        """
-        Indicates whether the requester is currently authenticated.
-        """
-        return self._is_logged_in
-
-    @property
-    def login_fields(self) -> list[LoginField]:
-        return []
-
     @property
     def session(self) -> ClientSession:
         """
@@ -352,25 +335,13 @@ class BaseSession(FetcherProtocol, abc.ABC):
             raise RuntimeError("Session is not initialized or has been shut down.")
         return self._session
 
-    @property
-    def backoff_factor(self) -> float:
-        return self._config.backoff_factor
-
-    @property
-    def retry_times(self) -> int:
-        return self._config.retry_times
-
-    @property
-    def request_interval(self) -> float:
-        return self._config.request_interval
-
-    @property
-    def timeout(self) -> float:
-        return self._config.timeout
-
-    @property
-    def max_connections(self) -> int:
-        return self._config.max_connections
+    async def _sleep(self) -> None:
+        if self._request_interval > 0:
+            await async_jitter_sleep(
+                self._request_interval,
+                mul_spread=1.1,
+                max_sleep=self._request_interval + 2,
+            )
 
     @property
     def headers(self) -> dict[str, str]:
@@ -400,11 +371,12 @@ class BaseSession(FetcherProtocol, abc.ABC):
         encoding: str | None = None,
     ) -> str:
         """
-        Read the full body of resp as text. First try the declared charset,
-        then on UnicodeDecodeError fall back to a lenient utf-8 decode.
+        Read the full body of resp as text. Try the provided encoding,
+        response charset, and common fallbacks. On failure, fall back
+        to utf-8 with errors ignored.
         """
         data: bytes = await resp.read()
-        encodings = [
+        encodings: list[str | None] = [
             encoding,
             resp.charset,
             "gb2312",
@@ -412,14 +384,17 @@ class BaseSession(FetcherProtocol, abc.ABC):
             "gbk",
             "utf-8",
         ]
-        encodings_list: list[str] = [e for e in encodings if e]
-        for enc in encodings_list:
+
+        for enc in (e for e in encodings if e is not None):
             try:
                 return data.decode(enc)
             except UnicodeDecodeError:
                 continue
-        encoding = encoding or "utf-8"
-        return data.decode(encoding, errors="ignore")
+        return data.decode(encoding or "utf-8", errors="ignore")
+
+    def _resolve_base_url(self, locale_style: str) -> str:
+        key = locale_style.strip().lower()
+        return self.BASE_URL_MAP.get(key, self.DEFAULT_BASE_URL)
 
     async def __aenter__(self) -> Self:
         if self._session is None or self._session.closed:

novel_downloader/core/fetchers/biquyuedu.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,28 +19,16 @@ class BiquyueduSession(BaseSession):
     A session class for interacting with the 精彩小说 (biquyuedu.com) novel website.
     """
 
+    site_name: str = "biquyuedu"
+
     BOOK_INFO_URL = "https://biquyuedu.com/novel/{book_id}.html"
     CHAPTER_URL = "https://biquyuedu.com/novel/{book_id}/{chapter_id}.html"
 
-    def __init__(
-        self,
-        config: FetcherConfig,
-        cookies: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__("biquyuedu", 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)]
 
@@ -51,13 +38,6 @@ class BiquyueduSession(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/dxmwx.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,21 +20,17 @@ class DxmwxSession(BaseSession):
     A session class for interacting with the 大熊猫文学网 (www.dxmwx.org) novel website.
     """
 
+    site_name: str = "dxmwx"
+    BASE_URL_MAP: dict[str, str] = {
+        "simplified": "www.dxmwx.org",
+        "traditional": "tw.dxmwx.org",
+    }
+    DEFAULT_BASE_URL: str = "www.dxmwx.org"
+
     BOOK_INFO_URL = "https://{base_url}/book/{book_id}.html"
     BOOK_CATALOG_URL = "https://{base_url}/chapter/{book_id}.html"
     CHAPTER_URL = "https://{base_url}/read/{book_id}_{chapter_id}.html"
 
-    def __init__(
-        self,
-        config: FetcherConfig,
-        cookies: dict[str, str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__("dxmwx", config, cookies, **kwargs)
-        self.base_url = (
-            "www.dxmwx.org" if config.locale_style == "simplified" else "tw.dxmwx.org"
-        )
-
     async def get_book_info(
         self,
         book_id: str,
@@ -49,8 +44,8 @@ class DxmwxSession(BaseSession):
         :param book_id: The book identifier.
         :return: The page content as string list.
         """
-        info_url = self.book_info_url(base_url=self.base_url, book_id=book_id)
-        catalog_url = self.book_catalog_url(base_url=self.base_url, book_id=book_id)
+        info_url = self.book_info_url(base_url=self._base_url, book_id=book_id)
+        catalog_url = self.book_catalog_url(base_url=self._base_url, book_id=book_id)
 
         info_html, catalog_html = await asyncio.gather(
             self.fetch(info_url, **kwargs),
@@ -64,15 +59,8 @@ class DxmwxSession(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)]