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

novel_downloader/core/downloaders/signals.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.downloaders.signals
+-----------------------------------------
+
+Utilities for signaling task termination and reporting async progress.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import Final, final
+
+
+@final
+class StopToken:
+    """Typed sentinel used to end queues."""
+
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return "STOP"
+
+
+STOP: Final[StopToken] = StopToken()
+
+# from typing_extensions import TypeIs
+# def is_stop(x: object) -> TypeIs[StopToken]:
+#     """Type guard so `if is_stop(item)` narrows type to StopToken."""
+#     return isinstance(x, StopToken)
+
+
+class Progress:
+    """Lightweight progress reporter."""
+
+    __slots__ = ("done", "total", "hook")
+
+    def __init__(self, total: int, hook: Callable[[int, int], Awaitable[None]] | None):
+        self.done = 0
+        self.total = total
+        self.hook = hook
+
+    async def bump(self, n: int = 1) -> None:
+        self.done += n
+        if self.hook:
+            await self.hook(self.done, self.total)

novel_downloader/core/exporters/__init__.py

@@ -3,35 +3,17 @@
 novel_downloader.core.exporters
 -------------------------------
 
-This module defines exporter classes for different novel platforms.
-
-Currently supported platforms:
-- biquge (笔趣阁)
-- esjzone (ESJ Zone)
-- linovelib (哔哩轻小说)
-- qianbi (铅笔小说)
-- qidian (起点中文网)
-- sfacg (SF轻小说)
-- yamibo (百合会)
-- common (通用架构)
+Exporter implementations for saving books in various formats across different sources
 """
 
-from .biquge import BiqugeExporter
-from .common import CommonExporter
-from .esjzone import EsjzoneExporter
-from .linovelib import LinovelibExporter
-from .qianbi import QianbiExporter
-from .qidian import QidianExporter
-from .sfacg import SfacgExporter
-from .yamibo import YamiboExporter
-
 __all__ = [
-    "BiqugeExporter",
-    "EsjzoneExporter",
+    "get_exporter",
+    "CommonExporter",
     "LinovelibExporter",
-    "QianbiExporter",
     "QidianExporter",
-    "SfacgExporter",
-    "YamiboExporter",
-    "CommonExporter",
 ]
+
+from .common import CommonExporter
+from .linovelib import LinovelibExporter
+from .qidian import QidianExporter
+from .registry import get_exporter

novel_downloader/core/exporters/base.py

@@ -3,20 +3,20 @@
 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
+import json
 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 ExporterConfig
+from novel_downloader.models import BookInfoDict, ChapterDict, ExporterConfig
+from novel_downloader.utils import ChapterStorage
 
 
 class SafeDict(dict[str, Any]):
@@ -31,6 +31,11 @@ class BaseExporter(ExporterProtocol, abc.ABC):
     such as TXT, EPUB, Markdown, or PDF.
     """
 
+    DEFAULT_SOURCE_ID = 0
+    PRIORITIES_MAP = {
+        DEFAULT_SOURCE_ID: 0,
+    }
+
     def __init__(
         self,
         config: ExporterConfig,
@@ -39,64 +44,66 @@ class BaseExporter(ExporterProtocol, abc.ABC):
         """
         Initialize the exporter with given configuration.
 
-        :param config: A ExporterConfig object that defines
-                        save paths, formats, and options.
+        :param config: Exporter configuration settings.
+        :param site: Identifier for the target website or source.
         """
         self._config = config
         self._site = site
+        self._storage_cache: dict[str, ChapterStorage] = {}
 
-        self._cache_dir = Path(config.cache_dir) / site
         self._raw_data_dir = Path(config.raw_data_dir) / site
         self._output_dir = Path(config.output_dir)
-        self._cache_dir.mkdir(parents=True, exist_ok=True)
         self._output_dir.mkdir(parents=True, exist_ok=True)
 
         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.
 
@@ -106,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.
 
@@ -115,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.
 
@@ -124,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.
 
@@ -160,16 +167,84 @@ class BaseExporter(ExporterProtocol, abc.ABC):
 
         return f"{name}.{ext}"
 
+    @property
+    def site(self) -> str:
+        """
+        Get the site identifier.
+
+        :return: The site string.
+        """
+        return self._site
+
     @property
     def output_dir(self) -> Path:
-        """Access the output directory for saving files."""
+        """
+        Access the output directory for saving files.
+        """
         return self._output_dir
 
     @property
     def filename_template(self) -> str:
-        """Access the filename template."""
+        """
+        Access the filename template.
+        """
         return self._config.filename_template
 
+    def _get_chapter(
+        self,
+        book_id: str,
+        chap_id: str,
+    ) -> ChapterDict | None:
+        if book_id not in self._storage_cache:
+            return None
+        return self._storage_cache[book_id].get_best_chapter(chap_id)
+
+    def _get_chapters(
+        self,
+        book_id: str,
+        chap_ids: list[str],
+    ) -> dict[str, ChapterDict | None]:
+        if book_id not in self._storage_cache:
+            return {}
+        return self._storage_cache[book_id].get_best_chapters(chap_ids)
+
+    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 None
+
+        try:
+            text = info_path.read_text(encoding="utf-8")
+            data: Any = json.loads(text)
+            if not isinstance(data, dict):
+                self.logger.error(
+                    "Invalid JSON structure in %s: expected an object at the top",
+                    info_path,
+                )
+                return None
+            return cast(BookInfoDict, data)
+        except json.JSONDecodeError as e:
+            self.logger.error("Corrupt JSON in %s: %s", info_path, e)
+        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_MAP,
+        )
+        self._storage_cache[book_id].connect()
+
+    def _close_chapter_storages(self) -> None:
+        for storage in self._storage_cache.values():
+            try:
+                storage.close()
+            except Exception as e:
+                self.logger.warning("Failed to close storage %s: %s", storage, e)
+        self._storage_cache.clear()
+
     def _on_close(self) -> None:
         """
         Hook method called at the beginning of close().
@@ -182,6 +257,7 @@ class BaseExporter(ExporterProtocol, abc.ABC):
         Shutdown and clean up the exporter.
         """
         self._on_close()
+        self._close_chapter_storages()
 
     def __enter__(self) -> Self:
         return self

novel_downloader/core/exporters/common/__init__.py

@@ -3,10 +3,9 @@
 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.
 """
 
-from .main_exporter import CommonExporter
-
 __all__ = ["CommonExporter"]
+
+from .main_exporter import CommonExporter