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

novel_downloader/core/exporters/base.py

@@ -3,9 +3,7 @@
 novel_downloader.core.exporters.base
 ------------------------------------
 
-This module provides an abstract base class `BaseExporter` that defines
-the common interface and reusable logic for saving assembled novel
-content into various output formats.
+Abstract base class providing common structure and utilities for book exporters
 """
 
 import abc
@@ -14,10 +12,10 @@ import logging
 import types
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Self
+from typing import Any, Self, cast
 
 from novel_downloader.core.interfaces import ExporterProtocol
-from novel_downloader.models import ChapterDict, ExporterConfig
+from novel_downloader.models import BookInfoDict, ChapterDict, ExporterConfig
 from novel_downloader.utils import ChapterStorage
 
 
@@ -34,7 +32,7 @@ class BaseExporter(ExporterProtocol, abc.ABC):
     """
 
     DEFAULT_SOURCE_ID = 0
-    DEFAULT_PRIORITIES_MAP = {
+    PRIORITIES_MAP = {
         DEFAULT_SOURCE_ID: 0,
     }
 
@@ -42,20 +40,15 @@ class BaseExporter(ExporterProtocol, abc.ABC):
         self,
         config: ExporterConfig,
         site: str,
-        priorities: dict[int, int] | None = None,
     ):
         """
         Initialize the exporter with given configuration.
 
         :param config: Exporter configuration settings.
         :param site: Identifier for the target website or source.
-        :param priorities: Mapping of source_id to priority value.
-                           Lower numbers indicate higher priority.
-                           E.X. {0: 10, 1: 100} means source 0 is preferred.
         """
         self._config = config
         self._site = site
-        self._priorities = priorities or self.DEFAULT_PRIORITIES_MAP
         self._storage_cache: dict[str, ChapterStorage] = {}
 
         self._raw_data_dir = Path(config.raw_data_dir) / site
@@ -64,50 +57,53 @@ class BaseExporter(ExporterProtocol, abc.ABC):
 
         self.logger = logging.getLogger(f"{self.__class__.__name__}")
 
-    def export(
-        self,
-        book_id: str,
-    ) -> None:
+    def export(self, book_id: str) -> dict[str, Path]:
         """
         Export the book in the formats specified in config.
-        If a method is not implemented or fails, log the error and continue.
 
         :param book_id: The book identifier (used for filename, lookup, etc.)
         """
         TAG = "[Exporter]"
+        results: dict[str, Path] = {}
+
         actions = [
-            ("make_txt", self.export_as_txt),
-            ("make_epub", self.export_as_epub),
-            ("make_md", self.export_as_md),
-            ("make_pdf", self.export_as_pdf),
+            ("make_txt", "txt", self.export_as_txt),
+            ("make_epub", "epub", self.export_as_epub),
+            ("make_md", "md", self.export_as_md),
+            ("make_pdf", "pdf", self.export_as_pdf),
         ]
 
-        for flag_name, export_method in actions:
+        for flag_name, fmt_key, export_method in actions:
             if getattr(self._config, flag_name, False):
                 try:
                     self.logger.info(
                         "%s Attempting to export book_id '%s' as %s...",
                         TAG,
                         book_id,
-                        flag_name,
+                        fmt_key,
                     )
-                    export_method(book_id)
-                    self.logger.info("%s Successfully saved as %s.", TAG, flag_name)
+                    path = export_method(book_id)
+
+                    if isinstance(path, Path):
+                        results[fmt_key] = path
+                        self.logger.info("%s Successfully saved as %s.", TAG, fmt_key)
+
                 except NotImplementedError as e:
                     self.logger.warning(
                         "%s Export method for %s not implemented: %s",
                         TAG,
-                        flag_name,
+                        fmt_key,
                         str(e),
                     )
                 except Exception as e:
                     self.logger.error(
-                        "%s Error while saving as %s: %s", TAG, flag_name, str(e)
+                        "%s Error while saving as %s: %s", TAG, fmt_key, str(e)
                     )
-        return
+
+        return results
 
     @abc.abstractmethod
-    def export_as_txt(self, book_id: str) -> None:
+    def export_as_txt(self, book_id: str) -> Path | None:
         """
         Persist the assembled book as a .txt file.
 
@@ -117,7 +113,7 @@ class BaseExporter(ExporterProtocol, abc.ABC):
         """
         ...
 
-    def export_as_epub(self, book_id: str) -> None:
+    def export_as_epub(self, book_id: str) -> Path | None:
         """
         Optional: Persist the assembled book as a EPUB (.epub) file.
 
@@ -126,7 +122,7 @@ class BaseExporter(ExporterProtocol, abc.ABC):
         """
         raise NotImplementedError("EPUB export not supported by this Exporter.")
 
-    def export_as_md(self, book_id: str) -> None:
+    def export_as_md(self, book_id: str) -> Path | None:
         """
         Optional: Persist the assembled book as a Markdown file.
 
@@ -135,7 +131,7 @@ class BaseExporter(ExporterProtocol, abc.ABC):
         """
         raise NotImplementedError("Markdown export not supported by this Exporter.")
 
-    def export_as_pdf(self, book_id: str) -> None:
+    def export_as_pdf(self, book_id: str) -> Path | None:
         """
         Optional: Persist the assembled book as a PDF file.
 
@@ -212,11 +208,11 @@ class BaseExporter(ExporterProtocol, abc.ABC):
             return {}
         return self._storage_cache[book_id].get_best_chapters(chap_ids)
 
-    def _load_book_info(self, book_id: str) -> dict[str, Any]:
+    def _load_book_info(self, book_id: str) -> BookInfoDict | None:
         info_path = self._raw_data_dir / book_id / "book_info.json"
         if not info_path.is_file():
             self.logger.error("Missing metadata file: %s", info_path)
-            return {}
+            return None
 
         try:
             text = info_path.read_text(encoding="utf-8")
@@ -226,18 +222,18 @@ class BaseExporter(ExporterProtocol, abc.ABC):
                     "Invalid JSON structure in %s: expected an object at the top",
                     info_path,
                 )
-                return {}
-            return data
+                return None
+            return cast(BookInfoDict, data)
         except json.JSONDecodeError as e:
             self.logger.error("Corrupt JSON in %s: %s", info_path, e)
-        return {}
+        return None
 
     def _init_chapter_storages(self, book_id: str) -> None:
         if book_id in self._storage_cache:
             return
         self._storage_cache[book_id] = ChapterStorage(
             raw_base=self._raw_data_dir / book_id,
-            priorities=self._priorities,
+            priorities=self.PRIORITIES_MAP,
         )
         self._storage_cache[book_id].connect()
 

novel_downloader/core/exporters/common/__init__.py

@@ -3,8 +3,7 @@
 novel_downloader.core.exporters.common
 --------------------------------------
 
-This module provides the `CommonExporter` class for
-handling the saving process of novels.
+Shared exporter implementation for producing standard TXT and EPUB outputs.
 """
 
 __all__ = ["CommonExporter"]

novel_downloader/core/exporters/common/epub.py

@@ -17,6 +17,7 @@ from novel_downloader.core.exporters.epub_util import (
     finalize_export,
     inline_remote_images,
     prepare_builder,
+    remove_all_images,
 )
 from novel_downloader.utils import (
     download,
@@ -35,7 +36,7 @@ if TYPE_CHECKING:
 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.
 
@@ -67,7 +68,7 @@ def common_export_as_epub(
     # --- Load book_info.json ---
     book_info = exporter._load_book_info(book_id)
     if not book_info:
-        return
+        return None
 
     book_name = book_info.get("book_name", book_id)
     book_author = book_info.get("author", "")
@@ -91,7 +92,7 @@ def common_export_as_epub(
         title=book_name,
         author=book_author,
         description=book_info.get("summary", ""),
-        subject=book_info.get("subject", []),
+        subject=book_info.get("tags", []),
         serial_status=book_info.get("serial_status", ""),
         word_count=book_info.get("word_count", ""),
         cover_path=cover_path,
@@ -110,7 +111,7 @@ def common_export_as_epub(
 
         # Batch-fetch chapters for this volume
         chap_ids = [
-            chap.get("chapterId")
+            chap["chapterId"]
             for chap in vol.get("chapters", [])
             if chap.get("chapterId")
         ]
@@ -143,7 +144,7 @@ def common_export_as_epub(
                 )
                 continue
 
-            chap_title = cleaner.clean_title(chap_meta.get("title", ""))
+            chap_title = chap_meta.get("title", "")
             data = chap_map.get(chap_id)
             if not data:
                 exporter.logger.info(
@@ -158,14 +159,19 @@ def common_export_as_epub(
             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)
+            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={"作者说": author_note},
+                extras=extras,
             )
-            curr_vol.add_chapter(
+            curr_vol.chapters.append(
                 Chapter(
                     id=f"c_{chap_id}",
                     filename=f"c{chap_id}.xhtml",
@@ -183,11 +189,10 @@ def common_export_as_epub(
         author=book_info.get("author"),
         ext="epub",
     )
-    finalize_export(
+    return finalize_export(
         book=book,
         out_dir=out_dir,
         filename=out_name,
         logger=exporter.logger,
         tag=TAG,
     )
-    return

novel_downloader/core/exporters/common/main_exporter.py

@@ -3,25 +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 pathlib import Path
+
 from novel_downloader.core.exporters.base import BaseExporter
 
+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 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.
 
@@ -36,22 +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)
+
+    @staticmethod
+    def _normalize_book_id(book_id: str) -> str:
+        """
+        Normalize a book identifier.
+
+        Subclasses may override this method to transform the book ID
+        into their preferred format.
+        """
+        return book_id.replace("/", "-")

novel_downloader/core/exporters/common/txt.py

@@ -9,13 +9,14 @@ into a single `.txt` file. Intended for use by `CommonExporter`.
 
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from novel_downloader.core.exporters.txt_util import (
     build_txt_chapter,
     build_txt_header,
 )
-from novel_downloader.utils import get_cleaner, save_as_txt
+from novel_downloader.utils import get_cleaner, write_file
 
 if TYPE_CHECKING:
     from .main_exporter import CommonExporter
@@ -24,13 +25,12 @@ if TYPE_CHECKING:
 def common_export_as_txt(
     exporter: CommonExporter,
     book_id: str,
-) -> None:
+) -> Path | None:
     """
     Export a novel as a single text file by merging all chapter data.
 
     Steps:
-      1. Load book metadata (title, author, summary, word count, update time,
-         volumes, and chapters).
+      1. Load book metadata.
       2. For each volume:
          a. Append the volume title.
          b. Batch-fetch all chapters in that volume to minimize SQLite calls.
@@ -55,7 +55,7 @@ def common_export_as_txt(
     # --- Load book_info.json ---
     book_info = exporter._load_book_info(book_id)
     if not book_info:
-        return
+        return None
 
     # --- Compile chapters ---
     parts: list[str] = []
@@ -70,7 +70,7 @@ def common_export_as_txt(
 
         # Batch-fetch chapters for this volume
         chap_ids = [
-            chap.get("chapterId")
+            chap["chapterId"]
             for chap in vol.get("chapters", [])
             if chap.get("chapterId")
         ]
@@ -84,7 +84,7 @@ def common_export_as_txt(
                 )
                 continue
 
-            chap_title = cleaner.clean_title(chap_meta.get("title", ""))
+            chap_title = chap_meta.get("title", "")
             data = chap_map.get(chap_id)
             if not data:
                 exporter.logger.info(
@@ -133,9 +133,14 @@ def common_export_as_txt(
     out_path = out_dir / out_name
 
     # --- Save final text ---
-    result = save_as_txt(content=final_text, filepath=out_path)
-    if result:
+    try:
+        result = write_file(
+            content=final_text,
+            filepath=out_path,
+            on_exist="overwrite",
+        )
         exporter.logger.info("%s Novel saved to: %s", TAG, out_path)
-    else:
-        exporter.logger.error("%s Failed to write novel to %s", TAG, out_path)
-    return
+    except Exception as e:
+        exporter.logger.error("%s Failed to write novel to %s: %s", TAG, out_path, e)
+        return None
+    return result

novel_downloader/core/exporters/epub_util.py

@@ -11,12 +11,13 @@ __all__ = [
     "prepare_builder",
     "finalize_export",
     "inline_remote_images",
+    "remove_all_images",
     "build_epub_chapter",
 ]
 
-import html
 import logging
 import re
+from html import escape
 from pathlib import Path
 
 from novel_downloader.utils import download, sanitize_filename
@@ -27,14 +28,11 @@ from novel_downloader.utils.constants import (
 )
 from novel_downloader.utils.epub import EpubBuilder, StyleSheet
 
-_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
+_IMAGE_WRAPPER = '<div class="duokan-image-single illus">{img}</div>'
+_IMG_TAG_RE = re.compile(r"<img[^>]*>", re.IGNORECASE)
+_IMG_SRC_RE = re.compile(
+    r'<img[^>]*\bsrc=["\'](https?://[^"\']+)["\'][^>]*>',
+    re.IGNORECASE,
 )
 
 
@@ -94,13 +92,15 @@ def finalize_export(
     filename: str,
     logger: logging.Logger,
     tag: str,
-) -> None:
+) -> Path | None:
     out_path = out_dir / sanitize_filename(filename)
     try:
         book.export(out_path)
         logger.info("%s EPUB successfully written to %s", tag, out_path)
+        return out_path
     except OSError as e:
         logger.error("%s Failed to write EPUB to %s: %s", tag, out_path, e)
+        return None
 
 
 def inline_remote_images(
@@ -111,15 +111,15 @@ def inline_remote_images(
 ) -> str:
     """
     Download every remote `<img src="...">` in `content` into `image_dir`,
-    and replace the original tag with _IMAGE_WRAPPER.
+    and replace the original url with local path.
 
     :param content: HTML/text of the chapter containing <img> tags.
     :param image_dir: Directory to save downloaded images into.
     :return: modified_content.
     """
 
-    def _replace(match: re.Match[str]) -> str:
-        url = match.group(1)
+    def _replace(m: re.Match[str]) -> str:
+        url = m.group(1)
         try:
             local_path = download(
                 url,
@@ -129,14 +129,22 @@ def inline_remote_images(
                 default_suffix=DEFAULT_IMAGE_SUFFIX,
             )
             if not local_path:
-                return match.group(0)
+                return m.group(0)
             filename = book.add_image(local_path)
-            return _IMAGE_WRAPPER.format(filename=filename)
+            return f'<img src="../Images/{filename}" />'
         except Exception:
-            return match.group(0)
+            return m.group(0)
+
+    return _IMG_SRC_RE.sub(_replace, content)
 
-    modified_content = _IMG_TAG_PATTERN.sub(_replace, content)
-    return modified_content
+
+def remove_all_images(content: str) -> str:
+    """
+    Remove all <img> tags from the given content.
+
+    :param content: HTML/text of the chapter containing <img> tags.
+    """
+    return _IMG_TAG_RE.sub("", content)
 
 
 def build_epub_chapter(
@@ -148,25 +156,47 @@ def build_epub_chapter(
     Build a formatted chapter epub HTML including title, body paragraphs,
     and optional extra sections.
 
-    :param title:      Chapter title.
+    :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 HTML include title, paragraphs, and extras.
+    :param extras: Optional dict mapping section titles to multi-line strings.
+    :return: A HTML include title, paragraphs, and extras.
     """
 
     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: list[str] = []
+        for raw in text.splitlines():
+            line = raw.strip()
+            if not line:
+                continue
+
+            # case 1: already wrapped in a <div>...</div>
+            if line.startswith("<div") and line.endswith("</div>"):
                 out.append(line)
+                continue
+
+            # case 2: single <img> line
+            if _IMG_TAG_RE.fullmatch(line):
+                out.append(_IMAGE_WRAPPER.format(img=line))
+                continue
+
+            # case 3: inline <img> in text -> escape other text, preserve <img>
+            if "<img " in line:
+                pieces = []
+                last = 0
+                for m in _IMG_TAG_RE.finditer(line):
+                    pieces.append(escape(line[last : m.start()]))
+                    pieces.append(m.group(0))
+                    last = m.end()
+                pieces.append(escape(line[last:]))
+                out.append("<p>" + "".join(pieces) + "</p>")
             else:
-                out.append(f"<p>{html.escape(line)}</p>")
+                # plain text line
+                out.append(f"<p>{escape(line)}</p>")
+
         return "\n".join(out)
 
     parts = []
-    parts.append(f"<h2>{html.escape(title)}</h2>")
+    parts.append(f"<h2>{escape(title)}</h2>")
     parts.append(_render_block(paragraphs))
 
     if extras:
@@ -177,7 +207,7 @@ def build_epub_chapter(
             parts.extend(
                 [
                     "<hr />",
-                    f"<h3>{html.escape(title)}</h3>",
+                    f"<h3>{escape(title)}</h3>",
                     _render_block(note),
                 ]
             )

novel_downloader/core/exporters/linovelib/__init__.py

@@ -3,6 +3,7 @@
 novel_downloader.core.exporters.linovelib
 -----------------------------------------
 
+Exporter implementation for handling Linovelib novels.
 """
 
 __all__ = ["LinovelibExporter"]