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

novel_downloader/core/exporters/common/epub.py

@@ -8,41 +8,35 @@ 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,
+    build_epub_chapter,
+    download_cover,
+    finalize_export,
+    inline_remote_images,
+    prepare_builder,
+    remove_all_images,
+)
+from novel_downloader.utils import (
+    download,
+    get_cleaner,
+)
+from novel_downloader.utils.constants import DEFAULT_IMAGE_SUFFIX
+from novel_downloader.utils.epub import (
     Chapter,
-    StyleSheet,
     Volume,
 )
-from novel_downloader.utils.constants import CSS_MAIN_PATH
-from novel_downloader.utils.file_utils import sanitize_filename
-from novel_downloader.utils.network import download_image
-from novel_downloader.utils.text_utils import clean_chapter_title
 
 if TYPE_CHECKING:
     from .main_exporter import CommonExporter
 
-_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
-)
-
 
 def common_export_as_epub(
     exporter: CommonExporter,
     book_id: str,
-) -> None:
+) -> Path | None:
     """
     Export a single novel (identified by `book_id`) to an EPUB file.
 
@@ -50,132 +44,142 @@ def common_export_as_epub(
       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 saver: The saver instance, carrying config and path info.
+    :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)
-        return
+    book_info = exporter._load_book_info(book_id)
+    if not book_info:
+        return None
 
     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",
-            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,
+    )
 
     # --- 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", []),
+        subject=book_info.get("tags", []),
         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", [])
-    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}"
-        exporter.logger.info("Processing volume %d: %s", vol_index, vol_name)
+    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}"
+        exporter.logger.info("%s Processing volume %d: %s", TAG, vol_index, vol_name)
+
+        # 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)
+
+        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,
             )
 
         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 = 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 = clean_chapter_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", ""))
+            extra = data.get("extra", {})
+            author_note = cleaner.clean_content(extra.get("author_say", ""))
+            content = (
+                inline_remote_images(book, content, img_dir)
+                if config.include_picture
+                else remove_all_images(content)
+            )
+            extras = {"作者说": author_note} if author_note else {}
+
+            chap_html = build_epub_chapter(
+                title=title,
+                paragraphs=content,
+                extras=extras,
             )
-            curr_vol.add_chapter(
+            curr_vol.chapters.append(
                 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)
 
@@ -185,93 +189,10 @@ def common_export_as_epub(
         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)
-    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,
-                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)
+    return finalize_export(
+        book=book,
+        out_dir=out_dir,
+        filename=out_name,
+        logger=exporter.logger,
+        tag=TAG,
+    )

novel_downloader/core/exporters/common/main_exporter.py

@@ -3,40 +3,27 @@
 novel_downloader.core.exporters.common.main_exporter
 ----------------------------------------------------
 
-This module implements the `CommonExporter` class, a concrete exporter for handling
-novel data. It defines the logic to compile, structure, and export novel content
-in plain text format based on the platform's metadata and chapter files.
+Common exporter implementation for saving novels as TXT and EPUB files.
 """
 
-from collections.abc import Mapping
-from typing import Any
+from pathlib import Path
 
 from novel_downloader.core.exporters.base import BaseExporter
-from novel_downloader.models import ExporterConfig
-from novel_downloader.utils.chapter_storage import ChapterStorage
 
+from .epub import common_export_as_epub
 from .txt import common_export_as_txt
 
 
 class CommonExporter(BaseExporter):
     """
     CommonExporter is a exporter that processes and exports novels.
+
     It extends the BaseExporter interface and provides
     logic for exporting full novels as plain text (.txt) files
     and EPUB (.epub) files.
     """
 
-    def __init__(
-        self,
-        config: ExporterConfig,
-        site: str,
-        chap_folders: list[str] | None = None,
-    ):
-        super().__init__(config, site)
-        self._chapter_storage_cache: dict[str, list[ChapterStorage]] = {}
-        self._chap_folders: list[str] = chap_folders or ["chapters"]
-
-    def export_as_txt(self, book_id: str) -> None:
+    def export_as_txt(self, book_id: str) -> Path | None:
         """
         Compile and export a complete novel as a single .txt file.
 
@@ -51,67 +38,27 @@ class CommonExporter(BaseExporter):
 
         :param book_id: The book identifier (used to locate raw data)
         """
+        book_id = self._normalize_book_id(book_id)
         self._init_chapter_storages(book_id)
         return common_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 common_export_as_epub
-        except ImportError as err:
-            raise NotImplementedError(
-                "EPUB export not supported. Please install 'ebooklib'"
-            ) from err
-
+        book_id = self._normalize_book_id(book_id)
         self._init_chapter_storages(book_id)
         return common_export_as_epub(self, book_id)
 
-    @property
-    def site(self) -> str:
-        """
-        Get the site identifier.
-
-        :return: The site string.
+    @staticmethod
+    def _normalize_book_id(book_id: str) -> str:
         """
-        return self._site
-
-    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 {}
+        Normalize a book identifier.
 
-    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.
+        Subclasses may override this method to transform the book ID
+        into their preferred format.
         """
-        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()
+        return book_id.replace("/", "-")