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

novel_downloader/core/exporters/esjzone.py

@@ -5,21 +5,18 @@ novel_downloader.core.exporters.esjzone
 
 """
 
+__all__ = ["EsjzoneExporter"]
+
+from novel_downloader.core.exporters.registry import register_exporter
 from novel_downloader.models import ExporterConfig
 
 from .common import CommonExporter
 
 
+@register_exporter(site_keys=["esjzone"])
 class EsjzoneExporter(CommonExporter):
     def __init__(
         self,
         config: ExporterConfig,
     ):
-        super().__init__(
-            config,
-            site="esjzone",
-            chap_folders=["chapters"],
-        )
-
-
-__all__ = ["EsjzoneExporter"]
+        super().__init__(config, site="esjzone")

novel_downloader/core/exporters/linovelib/__init__.py

@@ -5,6 +5,6 @@ novel_downloader.core.exporters.linovelib
 
 """
 
-from .main_exporter import LinovelibExporter
-
 __all__ = ["LinovelibExporter"]
+
+from .main_exporter import LinovelibExporter

novel_downloader/core/exporters/linovelib/epub.py

@@ -8,37 +8,32 @@ Contains the logic for exporting novel content as a single `.epub` file.
 
 from __future__ import annotations
 
-import html
-import json
-import re
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 from novel_downloader.core.exporters.epub_util import (
-    Book,
-    Chapter,
-    StyleSheet,
-    Volume,
+    build_epub_chapter,
+    download_cover,
+    finalize_export,
+    inline_remote_images,
+    prepare_builder,
+)
+from novel_downloader.utils import (
+    download,
+    get_cleaner,
 )
 from novel_downloader.utils.constants import (
-    CSS_MAIN_PATH,
     DEFAULT_HEADERS,
+    DEFAULT_IMAGE_SUFFIX,
+)
+from novel_downloader.utils.epub import (
+    Chapter,
+    Volume,
 )
-from novel_downloader.utils.file_utils import sanitize_filename
-from novel_downloader.utils.network import download_image
 
 if TYPE_CHECKING:
     from .main_exporter import LinovelibExporter
 
-_IMAGE_WRAPPER = (
-    '<div class="duokan-image-single illus"><img src="../Images/{filename}" /></div>'
-)
-_IMG_TAG_PATTERN = re.compile(
-    r'<img\s+[^>]*src=[\'"]([^\'"]+)[\'"][^>]*>', re.IGNORECASE
-)
-_RAW_HTML_RE = re.compile(
-    r'^(<img\b[^>]*?\/>|<div class="duokan-image-single illus">.*?<\/div>)$', re.DOTALL
-)
 _IMG_HEADERS = DEFAULT_HEADERS.copy()
 _IMG_HEADERS["Referer"] = "https://www.linovelib.com/"
 
@@ -54,132 +49,143 @@ def export_whole_book(
       1. Load `book_info.json` for metadata.
       2. Generate introductory HTML and optionally include the cover image.
       3. Initialize the EPUB container.
-      4. Iterate through volumes and chapters, convert each to XHTML.
+      4. Iterate through volumes and chapters in volume-batches, convert each to XHTML.
       5. Assemble the spine, TOC, CSS and write out the final `.epub`.
 
+    :param exporter: The exporter instance, carrying config and path info.
     :param book_id: Identifier of the novel (used as subdirectory name).
     """
     TAG = "[exporter]"
     config = exporter._config
-    # --- Paths & options ---
+
     raw_base = exporter._raw_data_dir / book_id
-    img_dir = exporter._cache_dir / book_id / "images"
+    img_dir = raw_base / "images"
     out_dir = exporter.output_dir
+
     img_dir.mkdir(parents=True, exist_ok=True)
     out_dir.mkdir(parents=True, exist_ok=True)
 
+    cleaner = get_cleaner(
+        enabled=config.clean_text,
+        config=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)
+    book_info = exporter._load_book_info(book_id)
+    if not book_info:
         return
 
     book_name = book_info.get("book_name", book_id)
     book_author = book_info.get("author", "")
+
     exporter.logger.info(
         "%s Starting EPUB generation: %s (ID: %s)", TAG, book_name, book_id
     )
 
     # --- Generate intro + cover ---
-    cover_path: Path | None = None
-    cover_url = book_info.get("cover_url", "")
-    if config.include_cover and cover_url:
-        cover_path = download_image(
-            cover_url,
-            raw_base,
-            target_name="cover",
-            headers=_IMG_HEADERS,
-            on_exist="overwrite",
-        )
-        if not cover_path:
-            exporter.logger.warning("Failed to download cover from %s", cover_url)
+    cover_path = download_cover(
+        book_info.get("cover_url", ""),
+        raw_base,
+        config.include_cover,
+        exporter.logger,
+        TAG,
+        headers=_IMG_HEADERS,
+    )
 
     # --- Initialize EPUB ---
-    book = Book(
+    book, main_css = prepare_builder(
+        site_name=exporter.site,
+        book_id=book_id,
         title=book_name,
         author=book_author,
         description=book_info.get("summary", ""),
-        cover_path=cover_path,
         subject=book_info.get("subject", []),
         serial_status=book_info.get("serial_status", ""),
         word_count=book_info.get("word_count", ""),
-        uid=f"{exporter.site}_{book_id}",
-    )
-    main_css = StyleSheet(
-        id="main_style",
-        content=CSS_MAIN_PATH.read_text(encoding="utf-8"),
-        filename="main.css",
+        cover_path=cover_path,
     )
-    book.add_stylesheet(main_css)
 
     # --- Compile chapters ---
     volumes = book_info.get("volumes", [])
+    if not volumes:
+        exporter.logger.warning("%s No volumes found in metadata.", TAG)
+
     for vol_index, vol in enumerate(volumes, start=1):
-        raw_vol_name = vol.get("volume_name", "")
-        raw_vol_name = raw_vol_name.replace(book_name, "").strip()
-        vol_name = raw_vol_name or f"Volume {vol_index}"
+        raw_name = vol.get("volume_name", "")
+        raw_name = raw_name.replace(book_name, "").strip()
+        vol_name = raw_name or f"Volume {vol_index}"
         exporter.logger.info("Processing volume %d: %s", vol_index, vol_name)
 
-        vol_cover_path: Path | None = None
+        # Batch-fetch chapters for this volume
+        chap_ids = [
+            chap.get("chapterId")
+            for chap in vol.get("chapters", [])
+            if chap.get("chapterId")
+        ]
+        chap_map = exporter._get_chapters(book_id, chap_ids)
+
+        vol_cover: Path | None = None
         vol_cover_url = vol.get("volume_cover", "")
         if vol_cover_url:
-            vol_cover_path = download_image(
+            vol_cover = download(
                 vol_cover_url,
                 img_dir,
                 on_exist="skip",
+                default_suffix=DEFAULT_IMAGE_SUFFIX,
+                headers=_IMG_HEADERS,
             )
 
         curr_vol = Volume(
             id=f"vol_{vol_index}",
             title=vol_name,
-            intro=vol.get("volume_intro", ""),
-            cover=vol_cover_path,
+            intro=cleaner.clean_content(vol.get("volume_intro", "")),
+            cover=vol_cover,
         )
 
-        for chap in vol.get("chapters", []):
-            chap_id = chap.get("chapterId")
-            chap_title = chap.get("title", "")
+        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,
+                    chap_meta,
                 )
                 continue
 
-            chapter_data = exporter._get_chapter(book_id, chap_id)
-            if not chapter_data:
+            chap_title = cleaner.clean_title(chap_meta.get("title", ""))
+            data = chap_map.get(chap_id)
+            if not data:
                 exporter.logger.info(
-                    "%s Missing chapter file: %s (%s), skipping.",
+                    "%s Missing chapter: %s (%s), skipping.",
                     TAG,
                     chap_title,
                     chap_id,
                 )
                 continue
 
-            title = chapter_data.get("title") or chap_id
-            content: str = chapter_data.get("content", "")
-            content, img_paths = _inline_remote_images(content, img_dir)
-            chap_html = _txt_to_html(
-                chapter_title=title,
-                chapter_text=content,
-                extras={
-                    "作者说": chapter_data.get("author_say", ""),
-                },
+            title = cleaner.clean_title(data.get("title", chap_title)) or chap_id
+            content = cleaner.clean_content(data.get("content", ""))
+            content = inline_remote_images(
+                book,
+                content,
+                img_dir,
+                headers=_IMG_HEADERS,
+            )
+
+            chap_html = build_epub_chapter(
+                title=title,
+                paragraphs=content,
+                extras={},
             )
             curr_vol.add_chapter(
                 Chapter(
                     id=f"c_{chap_id}",
+                    filename=f"c{chap_id}.xhtml",
                     title=title,
                     content=chap_html,
                     css=[main_css],
                 )
             )
-            for img_path in img_paths:
-                book.add_image(img_path)
 
         book.add_volume(curr_vol)
 
@@ -189,13 +195,13 @@ def export_whole_book(
         author=book_info.get("author"),
         ext="epub",
     )
-    out_path = out_dir / sanitize_filename(out_name)
-
-    try:
-        book.export(out_path)
-        exporter.logger.info("%s EPUB successfully written to %s", TAG, out_path)
-    except Exception as e:
-        exporter.logger.error("%s Failed to write EPUB to %s: %s", TAG, out_path, e)
+    finalize_export(
+        book=book,
+        out_dir=out_dir,
+        filename=out_name,
+        logger=exporter.logger,
+        tag=TAG,
+    )
     return
 
 
@@ -204,203 +210,142 @@ def export_by_volume(
     book_id: str,
 ) -> None:
     """
-    Export a single novel (identified by `book_id`) to multi EPUB file.
+    Export each volume of a novel as a separate EPUB file.
+
+    Steps:
+      1. Load metadata from `book_info.json`.
+      2. For each volume:
+         a. Clean the volume title and determine output filename.
+         b. Batch-fetch all chapters in this volume to minimize SQLite overhead.
+         c. Initialize an EPUB builder for the volume, including cover and intro.
+         d. For each chapter: clean title & content, inline remote images.
+         e. Finalize and write the volume EPUB.
 
     :param book_id: Identifier of the novel (used as subdirectory name).
     """
     TAG = "[exporter]"
     config = exporter._config
-    # --- Paths & options ---
+
     raw_base = exporter._raw_data_dir / book_id
-    img_dir = exporter._cache_dir / book_id / "images"
+    img_dir = raw_base / "images"
     out_dir = exporter.output_dir
+
     img_dir.mkdir(parents=True, exist_ok=True)
     out_dir.mkdir(parents=True, exist_ok=True)
 
+    cleaner = get_cleaner(
+        enabled=config.clean_text,
+        config=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)
+    book_info = exporter._load_book_info(book_id)
+    if not book_info:
         return
 
     book_name = book_info.get("book_name", book_id)
     book_author = book_info.get("author", "")
     book_summary = book_info.get("summary", "")
+
     exporter.logger.info(
         "%s Starting EPUB generation: %s (ID: %s)", TAG, book_name, book_id
     )
 
-    main_css = StyleSheet(
-        id="main_style",
-        content=CSS_MAIN_PATH.read_text(encoding="utf-8"),
-        filename="main.css",
-    )
-
     # --- Compile columes ---
     volumes = book_info.get("volumes", [])
-    for vol_index, vol in enumerate(volumes, start=1):
-        raw_vol_name = vol.get("volume_name", "")
-        raw_vol_name = raw_vol_name.replace(book_name, "").strip()
-        vol_name = raw_vol_name or f"Volume {vol_index}"
+    if not volumes:
+        exporter.logger.warning("%s No volumes found in metadata.", TAG)
 
-        vol_cover_path: Path | None = None
+    for vol_index, vol in enumerate(volumes, start=1):
+        raw_name = vol.get("volume_name", "")
+        raw_name = cleaner.clean_title(raw_name.replace(book_name, ""))
+        vol_name = raw_name or f"Volume {vol_index}"
+
+        # Batch-fetch chapters for this volume
+        chap_ids = [
+            chap.get("chapterId")
+            for chap in vol.get("chapters", [])
+            if chap.get("chapterId")
+        ]
+        chap_map = exporter._get_chapters(book_id, chap_ids)
+
+        vol_cover: Path | None = None
         vol_cover_url = vol.get("volume_cover", "")
         if config.include_cover and vol_cover_url:
-            vol_cover_path = download_image(
+            vol_cover = download(
                 vol_cover_url,
                 img_dir,
                 headers=_IMG_HEADERS,
                 on_exist="skip",
+                default_suffix=DEFAULT_IMAGE_SUFFIX,
             )
 
-        book = Book(
-            title=vol_name,
+        book, main_css = prepare_builder(
+            site_name=exporter.site,
+            book_id=book_id,
+            title=book_name,
             author=book_author,
             description=vol.get("volume_intro") or book_summary,
-            cover_path=vol_cover_path,
             subject=book_info.get("subject", []),
             serial_status=vol.get("serial_status", ""),
             word_count=vol.get("word_count", ""),
-            uid=f"{exporter.site}_{book_id}_v{vol_index}",
+            cover_path=vol_cover,
         )
-        book.add_stylesheet(main_css)
 
-        for chap in vol.get("chapters", []):
-            chap_id = chap.get("chapterId")
-            chap_title = chap.get("title", "")
+        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,
+                    chap_meta,
                 )
                 continue
 
-            chapter_data = exporter._get_chapter(book_id, chap_id)
-            if not chapter_data:
+            chap_title = cleaner.clean_title(chap_meta.get("title", ""))
+            data = chap_map.get(chap_id)
+            if not data:
                 exporter.logger.info(
-                    "%s Missing chapter file: %s (%s), skipping.",
+                    "%s Missing chapter: %s (%s), skipping.",
                     TAG,
                     chap_title,
                     chap_id,
                 )
                 continue
 
-            title = chapter_data.get("title", "") or chap_id
-            content: str = chapter_data.get("content", "")
-            content, imgs = _inline_remote_images(content, img_dir)
-            chap_html = _txt_to_html(
-                chapter_title=title,
-                chapter_text=content,
+            title = cleaner.clean_title(data.get("title", chap_title)) or chap_id
+            content = cleaner.clean_content(data.get("content", ""))
+            content = inline_remote_images(
+                book,
+                content,
+                img_dir,
+                headers=_IMG_HEADERS,
+            )
+            chap_html = build_epub_chapter(
+                title=title,
+                paragraphs=content,
                 extras={},
             )
             book.add_chapter(
                 Chapter(
                     id=f"c_{chap_id}",
+                    filename=f"c{chap_id}.xhtml",
                     title=title,
                     content=chap_html,
                     css=[main_css],
                 )
             )
-            for img_path in imgs:
-                book.add_image(img_path)
 
         out_name = exporter.get_filename(
             title=vol_name,
             author=book_info.get("author"),
             ext="epub",
         )
-        out_path = out_dir / sanitize_filename(out_name)
-
-        try:
-            book.export(out_path)
-            exporter.logger.info("%s EPUB successfully written to %s", TAG, out_path)
-        except Exception as e:
-            exporter.logger.error("%s Failed to write EPUB to %s: %s", TAG, out_path, e)
+        finalize_export(
+            book=book,
+            out_dir=out_dir,
+            filename=out_name,
+            logger=exporter.logger,
+            tag=TAG,
+        )
     return
-
-
-def _inline_remote_images(
-    content: str,
-    image_dir: str | Path,
-) -> tuple[str, list[Path]]:
-    """
-    Download every remote `<img src="...">` in `content` into `image_dir`,
-    and replace the original tag with _IMAGE_WRAPPER
-    pointing to the local filename.
-
-    :param content: HTML/text of the chapter containing <img> tags.
-    :param image_dir: Directory to save downloaded images into.
-    :return: A tuple (modified_content, list_of_downloaded_image_paths).
-    """
-    downloaded_images: list[Path] = []
-
-    def _replace(match: re.Match[str]) -> str:
-        url = match.group(1)
-        try:
-            # download_image returns a Path or None
-            local_path = download_image(
-                url,
-                image_dir,
-                target_name=None,
-                headers=_IMG_HEADERS,
-                on_exist="skip",
-            )
-            if not local_path:
-                return match.group(0)
-
-            downloaded_images.append(local_path)
-            return _IMAGE_WRAPPER.format(filename=local_path.name)
-        except Exception:
-            return match.group(0)
-
-    modified_content = _IMG_TAG_PATTERN.sub(_replace, content)
-    return modified_content, downloaded_images
-
-
-def _txt_to_html(
-    chapter_title: str,
-    chapter_text: str,
-    extras: dict[str, str] | None = None,
-) -> str:
-    """
-    Convert chapter text and author note to styled HTML.
-
-    :param chapter_title: Title of the chapter.
-    :param chapter_text: Main content of the chapter.
-    :param extras: Optional dict of titles and content, e.g. {"作者说": "text"}.
-    :return: Rendered HTML as a string.
-    """
-
-    def _render_block(text: str) -> str:
-        lines = (line.strip() for line in text.splitlines() if line.strip())
-        out = []
-        for line in lines:
-            # preserve raw HTML, otherwise wrap in <p>
-            if _RAW_HTML_RE.match(line):
-                out.append(line)
-            else:
-                out.append(f"<p>{html.escape(line)}</p>")
-        return "\n".join(out)
-
-    parts = []
-    parts.append(f"<h2>{html.escape(chapter_title)}</h2>")
-    parts.append(_render_block(chapter_text))
-
-    if extras:
-        for title, note in extras.items():
-            note = note.strip()
-            if not note:
-                continue
-            parts.extend(
-                [
-                    "<hr />",
-                    f"<p>{html.escape(title)}</p>",
-                    _render_block(note),
-                ]
-            )
-
-    return "\n".join(parts)

novel_downloader/core/exporters/linovelib/main_exporter.py

@@ -5,16 +5,15 @@ novel_downloader.core.exporters.linovelib.main_exporter
 
 """
 
-from collections.abc import Mapping
-from typing import Any
 
 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 .txt import linovelib_export_as_txt
 
 
+@register_exporter(site_keys=["linovelib"])
 class LinovelibExporter(BaseExporter):
     """"""
 
@@ -29,8 +28,6 @@ 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:
         """
@@ -71,57 +68,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()