novel-downloader 1.4.0__py3-none-any.whl → 1.4.2__py3-none-any.whl

novel_downloader/core/exporters/common/epub.py

@@ -8,25 +8,19 @@ 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 ebooklib import epub
-
-from novel_downloader.core.exporters.epub_utils import (
-    add_images_from_dir,
-    chapter_txt_to_html,
-    create_css_items,
-    create_volume_intro,
-    generate_book_intro_html,
-    init_epub,
-    inline_remote_images,
-)
-from novel_downloader.utils.constants import (
-    EPUB_OPTIONS,
-    EPUB_TEXT_FOLDER,
+from novel_downloader.core.exporters.epub_util import (
+    Book,
+    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
@@ -34,6 +28,16 @@ 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,
@@ -71,12 +75,12 @@ def common_export_as_epub(
         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 ---
-    intro_html = generate_book_intro_html(book_info)
     cover_path: Path | None = None
     cover_url = book_info.get("cover_url", "")
     if config.include_cover and cover_url:
@@ -90,49 +94,56 @@ def common_export_as_epub(
             exporter.logger.warning("Failed to download cover from %s", cover_url)
 
     # --- Initialize EPUB ---
-    book, spine, toc_list = init_epub(
-        book_info=book_info,
-        book_id=book_id,
-        intro_html=intro_html,
-        book_cover_path=cover_path,
-        include_toc=config.include_toc,
+    book = Book(
+        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",
     )
-    for css in create_css_items(
-        include_main=True,
-        include_volume=True,
-    ):
-        book.add_item(css)
+    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", "").strip()
-        vol_name = clean_chapter_title(raw_vol_name) or f"Unknown Volume {vol_index}"
+        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)
 
-        # Volume intro
-        vol_intro = epub.EpubHtml(
+        vol_cover_path: Path | None = None
+        vol_cover_url = vol.get("volume_cover", "")
+        if vol_cover_url:
+            vol_cover_path = download_image(
+                vol_cover_url,
+                img_dir,
+                on_exist="skip",
+            )
+
+        curr_vol = Volume(
+            id=f"vol_{vol_index}",
             title=vol_name,
-            file_name=f"{EPUB_TEXT_FOLDER}/volume_intro_{vol_index}.xhtml",
-            lang="zh",
+            intro=vol.get("volume_intro", ""),
+            cover=vol_cover_path,
         )
-        vol_intro.content = create_volume_intro(vol_name, vol.get("volume_intro", ""))
-        vol_intro.add_link(
-            href="../Styles/volume-intro.css",
-            rel="stylesheet",
-            type="text/css",
-        )
-        book.add_item(vol_intro)
-        spine.append(vol_intro)
-
-        section = epub.Section(vol_name, vol_intro.file_name)
-        chapter_items: list[epub.EpubHtml] = []
 
         for chap in vol.get("chapters", []):
             chap_id = chap.get("chapterId")
             chap_title = chap.get("title", "")
             if not chap_id:
-                exporter.logger.warning("%s Missing chapterId, skipping: %s", TAG, chap)
+                exporter.logger.warning(
+                    "%s Missing chapterId, skipping: %s",
+                    TAG,
+                    chap,
+                )
                 continue
 
             chapter_data = exporter._get_chapter(book_id, chap_id)
@@ -147,36 +158,28 @@ def common_export_as_epub(
 
             title = clean_chapter_title(chapter_data.get("title", "")) or chap_id
             content: str = chapter_data.get("content", "")
-            content = inline_remote_images(content, img_dir)
-            chap_html = chapter_txt_to_html(
+            content, img_paths = _inline_remote_images(content, img_dir)
+            chap_html = _txt_to_html(
                 chapter_title=title,
                 chapter_text=content,
-                author_say=chapter_data.get("author_say", ""),
+                extras={
+                    "作者说": chapter_data.get("author_say", ""),
+                },
             )
-
-            chap_path = f"{EPUB_TEXT_FOLDER}/{chap_id}.xhtml"
-            item = epub.EpubHtml(title=chap_title, file_name=chap_path, lang="zh")
-            item.content = chap_html
-            item.add_link(
-                href="../Styles/main.css",
-                rel="stylesheet",
-                type="text/css",
+            curr_vol.add_chapter(
+                Chapter(
+                    id=f"c_{chap_id}",
+                    title=title,
+                    content=chap_html,
+                    css=[main_css],
+                )
             )
-            book.add_item(item)
-            spine.append(item)
-            chapter_items.append(item)
-
-        toc_list.append((section, chapter_items))
+            for img_path in img_paths:
+                book.add_image(img_path)
 
-    book = add_images_from_dir(book, img_dir)
+        book.add_volume(curr_vol)
 
     # --- 5. Finalize EPUB ---
-    exporter.logger.info("%s Building TOC and spine...", TAG)
-    book.toc = toc_list
-    book.spine = spine
-    book.add_item(epub.EpubNcx())
-    book.add_item(epub.EpubNav())
-
     out_name = exporter.get_filename(
         title=book_name,
         author=book_info.get("author"),
@@ -185,8 +188,90 @@ def common_export_as_epub(
     out_path = out_dir / sanitize_filename(out_name)
 
     try:
-        epub.write_epub(out_path, book, EPUB_OPTIONS)
+        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)