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

novel_downloader/core/exporters/linovelib/main_exporter.py

@@ -3,18 +3,23 @@
 novel_downloader.core.exporters.linovelib.main_exporter
 -------------------------------------------------------
 
+Exporter implementation for Linovelib novels, supporting TXT and EPUB outputs.
 """
 
-from collections.abc import Mapping
-from typing import Any
+from pathlib import Path
 
 from novel_downloader.core.exporters.base import BaseExporter
+from novel_downloader.core.exporters.registry import register_exporter
 from novel_downloader.models import ExporterConfig
-from novel_downloader.utils.chapter_storage import ChapterStorage
 
+from .epub import (
+    export_by_volume,
+    export_whole_book,
+)
 from .txt import linovelib_export_as_txt
 
 
+@register_exporter(site_keys=["linovelib"])
 class LinovelibExporter(BaseExporter):
     """"""
 
@@ -29,10 +34,8 @@ class LinovelibExporter(BaseExporter):
                         save paths, formats, and options.
         """
         super().__init__(config, "linovelib")
-        self._chapter_storage_cache: dict[str, list[ChapterStorage]] = {}
-        self._chap_folders: list[str] = ["chapters"]
 
-    def export_as_txt(self, book_id: str) -> None:
+    def export_as_txt(self, book_id: str) -> Path | None:
         """
         Compile and export a novel as a single .txt file.
 
@@ -41,23 +44,13 @@ class LinovelibExporter(BaseExporter):
         self._init_chapter_storages(book_id)
         return linovelib_export_as_txt(self, book_id)
 
-    def export_as_epub(self, book_id: str) -> None:
+    def export_as_epub(self, book_id: str) -> Path | None:
         """
         Persist the assembled book as a EPUB (.epub) file.
 
         :param book_id: The book identifier.
         :raises NotImplementedError: If the method is not overridden.
         """
-        try:
-            from .epub import (
-                export_by_volume,
-                export_whole_book,
-            )
-        except ImportError as err:
-            raise NotImplementedError(
-                "EPUB export not supported. Please install 'ebooklib'"
-            ) from err
-
         self._init_chapter_storages(book_id)
 
         exporters = {
@@ -71,57 +64,3 @@ class LinovelibExporter(BaseExporter):
                 f"Unsupported split_mode: {self._config.split_mode!r}"
             ) from err
         return export_fn(self, book_id)
-
-    @property
-    def site(self) -> str:
-        """
-        Get the site identifier.
-
-        :return: The site string.
-        """
-        return self._site
-
-    @site.setter
-    def site(self, value: str) -> None:
-        """
-        Set the site identifier.
-
-        :param value: New site string to set.
-        """
-        self._site = value
-
-    def _get_chapter(
-        self,
-        book_id: str,
-        chap_id: str,
-    ) -> Mapping[str, Any]:
-        for storage in self._chapter_storage_cache[book_id]:
-            data = storage.get(chap_id)
-            if data:
-                return data
-        return {}
-
-    def _init_chapter_storages(self, book_id: str) -> None:
-        if book_id in self._chapter_storage_cache:
-            return
-        raw_base = self._raw_data_dir / book_id
-        self._chapter_storage_cache[book_id] = [
-            ChapterStorage(
-                raw_base=raw_base,
-                namespace=ns,
-                backend_type=self._config.storage_backend,
-            )
-            for ns in self._chap_folders
-        ]
-
-    def _on_close(self) -> None:
-        """
-        Close all ChapterStorage connections in the cache.
-        """
-        for storages in self._chapter_storage_cache.values():
-            for storage in storages:
-                try:
-                    storage.close()
-                except Exception as e:
-                    self.logger.warning("Failed to close storage %s: %s", storage, e)
-        self._chapter_storage_cache.clear()

novel_downloader/core/exporters/linovelib/txt.py

@@ -3,22 +3,20 @@
 novel_downloader.core.exporters.linovelib.txt
 ---------------------------------------------
 
-Contains the logic for exporting novel content as a single `.txt` file.
-
-This module defines `linovelib_export_as_txt` function, which assembles and formats
-a novel based on metadata and chapter files found in the raw data directory.
-It is intended to be used by `LinovelibExporter` as part of the save/export process.
+Defines `linovelib_export_as_txt` to assemble and export a Linovelib novel
+into a single `.txt` file. Intended for use by `LinovelibExporter`.
 """
 
 from __future__ import annotations
 
-import json
+from pathlib import Path
 from typing import TYPE_CHECKING
 
-from novel_downloader.utils.file_utils import save_as_txt
-from novel_downloader.utils.text_utils import (
-    format_chapter,
+from novel_downloader.core.exporters.txt_util import (
+    build_txt_chapter,
+    build_txt_header,
 )
+from novel_downloader.utils import get_cleaner, write_file
 
 if TYPE_CHECKING:
     from .main_exporter import LinovelibExporter
@@ -27,58 +25,71 @@ if TYPE_CHECKING:
 def linovelib_export_as_txt(
     exporter: LinovelibExporter,
     book_id: str,
-) -> None:
+) -> Path | None:
     """
-    将 save_path 文件夹中该小说的所有章节 json 文件合并保存为一个完整的 txt 文件,
-    并保存到 out_path 下
-
-    处理流程：
-      1. 从 book_info.json 中加载书籍信息 (包含书名、作者、简介及卷章节列表)
-      2. 遍历各卷, 每个卷先追加卷标题, 然后依次追加该卷下各章节的标题和内容
-      3. 将书籍元信息 (书名、作者、原文截至、内容简介) 与所有章节内容拼接
-      4. 将最终结果保存到 out_path 下 (例如：`{book_name}.txt`)
-
-    :param book_id: Identifier of the novel (used as subdirectory name).
+    Export a novel as a single text file by merging all chapter data.
+
+    Steps:
+      1. Read metadata from `book_info.json`.
+      2. For each volume:
+        * Clean & append the volume title.
+        * Clean & append optional volume intro.
+        * Batch-fetch all chapters in this volume to minimize SQLite overhead.
+        * For each chapter: clean title & content, then append.
+      3. Build a header block with metadata.
+      4. Concatenate header + all chapter blocks, then save as `{book_name}.txt`.
+
+    :param exporter: The LinovelibExporter instance.
+    :param book_id: Identifier of the novel (subdirectory under raw data).
     """
     TAG = "[exporter]"
     # --- Paths & options ---
-    raw_base = exporter._raw_data_dir / book_id
     out_dir = exporter.output_dir
     out_dir.mkdir(parents=True, exist_ok=True)
+    cleaner = get_cleaner(
+        enabled=exporter._config.clean_text,
+        config=exporter._config.cleaner_cfg,
+    )
 
     # --- Load book_info.json ---
-    info_path = raw_base / "book_info.json"
-    try:
-        info_text = info_path.read_text(encoding="utf-8")
-        book_info = json.loads(info_text)
-    except Exception as e:
-        exporter.logger.error("%s Failed to load %s: %s", TAG, info_path, e)
-        return
+    book_info = exporter._load_book_info(book_id)
+    if not book_info:
+        return None
 
     # --- Compile chapters ---
     parts: list[str] = []
-    volumes = book_info.get("volumes", [])
-
-    for vol in volumes:
-        vol_name = vol.get("volume_name", "").strip()
-        vol_intro = vol.get("volume_intro", "").strip()
-        if vol_name:
-            volume_header = f"\n\n{'=' * 6} {vol_name} {'=' * 6}\n\n"
-            parts.append(volume_header)
-            exporter.logger.info("%s Processing volume: %s", TAG, vol_name)
+
+    for vol in book_info.get("volumes", []):
+        vol_title = cleaner.clean_title(vol.get("volume_name", ""))
+        if vol_title:
+            parts.append(f"\n\n{'=' * 6} {vol_title} {'=' * 6}\n\n")
+            exporter.logger.info("%s Processing volume: %s", TAG, vol_title)
+
+        vol_intro = cleaner.clean_content(vol.get("volume_intro", ""))
         if vol_intro:
             parts.append(f"{vol_intro}\n\n")
-        for chap in vol.get("chapters", []):
-            chap_id = chap.get("chapterId")
-            chap_title = chap.get("title", "")
+
+        # Batch-fetch chapters for this volume
+        chap_ids = [
+            chap["chapterId"]
+            for chap in vol.get("chapters", [])
+            if chap.get("chapterId")
+        ]
+        chap_map = exporter._get_chapters(book_id, chap_ids)
+
+        for chap_meta in vol.get("chapters", []):
+            chap_id = chap_meta.get("chapterId")
             if not chap_id:
-                exporter.logger.warning("%s Missing chapterId, skipping: %s", TAG, chap)
+                exporter.logger.warning(
+                    "%s Missing chapterId, skipping: %s", TAG, chap_meta
+                )
                 continue
 
-            chapter_data = exporter._get_chapter(book_id, chap_id)
-            if not chapter_data:
+            chap_title = chap_meta.get("title", "")
+            data = chap_map.get(chap_id)
+            if not data:
                 exporter.logger.info(
-                    "%s Missing chapter file in: %s (%s), skipping.",
+                    "%s Missing chapter: %s (%s), skipping.",
                     TAG,
                     chap_title,
                     chap_id,
@@ -86,33 +97,27 @@ def linovelib_export_as_txt(
                 continue
 
             # Extract structured fields
-            title = chapter_data.get("title", chap_title).strip()
-            content = chapter_data.get("content", "").strip()
+            title = cleaner.clean_title(data.get("title", chap_title))
+            content = cleaner.clean_content(data.get("content", ""))
 
-            parts.append(format_chapter(title, content, ""))
+            parts.append(build_txt_chapter(title=title, paragraphs=content, extras={}))
 
     # --- Build header ---
-    name = book_info.get("book_name")
-    author = book_info.get("author")
-    words = book_info.get("word_count")
-    updated = book_info.get("update_time")
-    summary = book_info.get("summary")
+    name = book_info.get("book_name") or ""
+    author = book_info.get("author") or ""
+    words = book_info.get("word_count") or ""
+    updated = book_info.get("update_time") or ""
+    summary = book_info.get("summary") or ""
 
-    fields = [
+    header_fields = [
         ("书名", name),
         ("作者", author),
         ("总字数", words),
         ("更新日期", updated),
+        ("内容简介", summary),
     ]
-    header_lines = [f"{label}: {value}" for label, value in fields if value]
-
-    if summary:
-        header_lines.append("内容简介:")
-        header_lines.append(summary)
-
-    header_lines += ["", "-" * 10, ""]
 
-    header = "\n".join(header_lines)
+    header = build_txt_header(header_fields)
 
     final_text = header + "\n\n" + "\n\n".join(parts).strip()
 
@@ -121,9 +126,14 @@ def linovelib_export_as_txt(
     out_path = out_dir / out_name
 
     # --- Save final text ---
-    try:
-        save_as_txt(content=final_text, filepath=out_path)
+    result = write_file(
+        content=final_text,
+        filepath=out_path,
+        write_mode="w",
+        on_exist="overwrite",
+    )
+    if result:
         exporter.logger.info("%s Novel saved to: %s", TAG, out_path)
-    except Exception as e:
-        exporter.logger.error("%s Failed to save file: %s", TAG, e)
-    return
+    else:
+        exporter.logger.error("%s Failed to write novel to %s", TAG, out_path)
+    return result

novel_downloader/core/exporters/qidian.py

@@ -3,26 +3,30 @@
 novel_downloader.core.exporters.qidian
 --------------------------------------
 
-This module provides the `QidianExporter` class for handling the saving process
-of novels sourced from Qidian (起点中文网). It implements the platform-specific
-logic required to structure and export novel content into desired formats.
+Exporter implementation for Qidian novels, supporting plain and encrypted sources.
 """
 
+__all__ = ["QidianExporter"]
+
+from novel_downloader.core.exporters.registry import register_exporter
 from novel_downloader.models import ExporterConfig
 
 from .common import CommonExporter
 
 
+@register_exporter(site_keys=["qidian", "qd"])
 class QidianExporter(CommonExporter):
+    """ """
+
+    DEFAULT_SOURCE_ID = 0
+    ENCRYPTED_SOURCE_ID = 1
+    PRIORITIES_MAP = {
+        DEFAULT_SOURCE_ID: 0,
+        ENCRYPTED_SOURCE_ID: 1,
+    }
+
     def __init__(
         self,
         config: ExporterConfig,
     ):
-        super().__init__(
-            config,
-            site="qidian",
-            chap_folders=["chapters", "encrypted_chapters"],
-        )
-
-
-__all__ = ["QidianExporter"]
+        super().__init__(config, site="qidian")

novel_downloader/core/exporters/registry.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.registry
+----------------------------------------
+
+Registry and factory helpers for creating site-specific or common exporters.
+"""
+
+__all__ = ["register_exporter", "get_exporter"]
+
+from collections.abc import Callable, Sequence
+from typing import TypeVar
+
+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]
+
+E = TypeVar("E", bound=ExporterProtocol)
+_EXPORTER_MAP: dict[str, ExporterBuilder] = {}
+
+
+def register_exporter(
+    site_keys: Sequence[str],
+) -> Callable[[type[E]], type[E]]:
+    """
+    Decorator to register a exporter class under given keys.
+
+    :param site_keys: Sequence of site identifiers
+    :return: A class decorator that populates _EXPORTER_MAP.
+    """
+
+    def decorator(cls: type[E]) -> type[E]:
+        for key in site_keys:
+            _EXPORTER_MAP[key.lower()] = cls
+        return cls
+
+    return decorator
+
+
+def get_exporter(site: str, config: ExporterConfig) -> ExporterProtocol:
+    """
+    Returns a site-specific exporter instance.
+
+    :param site: Site name (e.g., 'qidian')
+    :param config: Configuration for the exporter
+    :return: An instance of a exporter class
+    """
+    site_key = site.lower()
+    try:
+        exporter_cls = _EXPORTER_MAP[site_key]
+    except KeyError:
+        return CommonExporter(config, site_key)
+    return exporter_cls(config)

novel_downloader/core/exporters/txt_util.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.txt_util
+----------------------------------------
+
+Utilities for generating plain-text exports of novel content.
+"""
+
+__all__ = [
+    "build_txt_header",
+    "build_txt_chapter",
+]
+
+import re
+
+_IMG_TAG_RE = re.compile(r"<img[^>]*>", re.IGNORECASE)
+
+
+def build_txt_header(fields: list[tuple[str, str]]) -> str:
+    """
+    Build a simple text header from label-value pairs, followed by a dashed separator.
+
+    :param fields: List of (label, value) pairs.
+    :return: A single string containing the formatted header.
+    """
+    header_lines = [f"{label}: {value}" for label, value in fields if value]
+    header_lines += ["", "-" * 10, ""]
+    return "\n".join(header_lines)
+
+
+def build_txt_chapter(
+    title: str,
+    paragraphs: str,
+    extras: dict[str, str] | None = None,
+) -> str:
+    """
+    Build a formatted chapter text block including title, body paragraphs,
+    and optional extra sections.
+
+      * Strips any `<img...>` tags from paragraphs.
+      * Title appears first (stripped of surrounding whitespace).
+      * Each non-blank line in `paragraphs` becomes its own paragraph.
+
+    :param title: Chapter title.
+    :param paragraphs: Raw multi-line string. Blank lines are ignored.
+    :param extras: Optional dict mapping section titles to multi-line strings.
+    :return: A string where title, paragraphs, and extras are joined by lines.
+    """
+    parts: list[str] = [title.strip()]
+
+    # add each nonempty paragraph line
+    paragraphs = _IMG_TAG_RE.sub("", paragraphs)
+    for ln in paragraphs.splitlines():
+        line = ln.strip()
+        if line:
+            parts.append(line)
+
+    if extras:
+        for title, text in extras.items():
+            lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
+            if not lines:
+                continue
+            parts.append("---")
+            parts.append(title.strip())
+            parts.extend(lines)
+
+    return "\n\n".join(parts)

novel_downloader/core/fetchers/__init__.py

@@ -3,70 +3,71 @@
 novel_downloader.core.fetchers
 ------------------------------
 
-This package provides fetcher implementations for different novel platforms.
-Each submodule corresponds to a specific site and encapsulates the logic needed
-to perform network interactions, such as logging in, sending requests,
-or interacting with browser/session-based sources.
-
-Subpackages:
-- biquge (笔趣阁)
-- esjzone (ESJ Zone)
-- linovelib (哔哩轻小说)
-- qianbi (铅笔小说)
-- qidian (起点中文网)
-- sfacg (SF轻小说)
-- yamibo (百合会)
-- common (通用架构)
+Fetcher implementations for retrieving raw data and HTML from various novel sources
 """
 
-from .biquge import (
-    BiqugeBrowser,
-    BiqugeSession,
-)
-from .common import (
-    CommonBrowser,
-    CommonSession,
-)
-from .esjzone import (
-    EsjzoneBrowser,
-    EsjzoneSession,
-)
-from .linovelib import (
-    LinovelibBrowser,
-    LinovelibSession,
-)
-from .qianbi import (
-    QianbiBrowser,
-    QianbiSession,
-)
-from .qidian import (
-    QidianBrowser,
-    QidianSession,
-)
-from .sfacg import (
-    SfacgBrowser,
-    SfacgSession,
-)
-from .yamibo import (
-    YamiboBrowser,
-    YamiboSession,
-)
-
 __all__ = [
-    "BiqugeBrowser",
+    "get_fetcher",
+    "AaatxtSession",
     "BiqugeSession",
-    "CommonBrowser",
-    "CommonSession",
-    "EsjzoneBrowser",
+    "BiquyueduSession",
+    "DxmwxSession",
+    "EightnovelSession",
     "EsjzoneSession",
-    "LinovelibBrowser",
+    "GuidayeSession",
+    "HetushuSession",
+    "I25zwSession",
+    "Ixdzs8Session",
+    "Jpxs123Session",
+    "LewennSession",
     "LinovelibSession",
-    "QianbiBrowser",
+    "PiaotiaSession",
+    "QbtrSession",
     "QianbiSession",
-    "QidianBrowser",
     "QidianSession",
-    "SfacgBrowser",
+    "Quanben5Session",
     "SfacgSession",
-    "YamiboBrowser",
+    "ShencouSession",
+    "ShuhaigeSession",
+    "TongrenquanSession",
+    "TtkanSession",
+    "WanbengoSession",
+    "XiaoshuowuSession",
+    "XiguashuwuSession",
+    "Xs63bSession",
+    "XshbookSession",
     "YamiboSession",
+    "YibigeSession",
 ]
+
+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
+from .i25zw import I25zwSession
+from .ixdzs8 import Ixdzs8Session
+from .jpxs123 import Jpxs123Session
+from .lewenn import LewennSession
+from .linovelib import LinovelibSession
+from .piaotia import PiaotiaSession
+from .qbtr import QbtrSession
+from .qianbi import QianbiSession
+from .qidian import QidianSession
+from .quanben5 import Quanben5Session
+from .registry import get_fetcher
+from .sfacg import SfacgSession
+from .shencou import ShencouSession
+from .shuhaige import ShuhaigeSession
+from .tongrenquan import TongrenquanSession
+from .ttkan import TtkanSession
+from .wanbengo import WanbengoSession
+from .xiaoshuowu import XiaoshuowuSession
+from .xiguashuwu import XiguashuwuSession
+from .xs63b import Xs63bSession
+from .xshbook import XshbookSession
+from .yamibo import YamiboSession
+from .yibige import YibigeSession