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

novel_downloader/core/exporters/linovelib/txt.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.linovelib.txt
+---------------------------------------------
+
+Contains the logic for exporting novel content as a single `.txt` file.
+
+This module defines `linovelib_export_as_txt` function, which assembles and formats
+a novel based on metadata and chapter files found in the raw data directory.
+It is intended to be used by `LinovelibExporter` as part of the save/export process.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from novel_downloader.utils.file_utils import save_as_txt
+from novel_downloader.utils.text_utils import (
+    format_chapter,
+)
+
+if TYPE_CHECKING:
+    from .main_exporter import LinovelibExporter
+
+
+def linovelib_export_as_txt(
+    exporter: LinovelibExporter,
+    book_id: str,
+) -> None:
+    """
+    将 save_path 文件夹中该小说的所有章节 json 文件合并保存为一个完整的 txt 文件,
+    并保存到 out_path 下
+
+    处理流程：
+      1. 从 book_info.json 中加载书籍信息 (包含书名、作者、简介及卷章节列表)
+      2. 遍历各卷, 每个卷先追加卷标题, 然后依次追加该卷下各章节的标题和内容
+      3. 将书籍元信息 (书名、作者、原文截至、内容简介) 与所有章节内容拼接
+      4. 将最终结果保存到 out_path 下 (例如：`{book_name}.txt`)
+
+    :param book_id: Identifier of the novel (used as subdirectory name).
+    """
+    TAG = "[exporter]"
+    # --- Paths & options ---
+    raw_base = exporter._raw_data_dir / book_id
+    out_dir = exporter.output_dir
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # --- 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
+
+    # --- Compile chapters ---
+    parts: list[str] = []
+    volumes = book_info.get("volumes", [])
+
+    for vol in volumes:
+        vol_name = vol.get("volume_name", "").strip()
+        vol_intro = vol.get("volume_intro", "").strip()
+        if vol_name:
+            volume_header = f"\n\n{'=' * 6} {vol_name} {'=' * 6}\n\n"
+            parts.append(volume_header)
+            exporter.logger.info("%s Processing volume: %s", TAG, vol_name)
+        if vol_intro:
+            parts.append(f"{vol_intro}\n\n")
+        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)
+                continue
+
+            chapter_data = exporter._get_chapter(book_id, chap_id)
+            if not chapter_data:
+                exporter.logger.info(
+                    "%s Missing chapter file in: %s (%s), skipping.",
+                    TAG,
+                    chap_title,
+                    chap_id,
+                )
+                continue
+
+            # Extract structured fields
+            title = chapter_data.get("title", chap_title).strip()
+            content = chapter_data.get("content", "").strip()
+
+            parts.append(format_chapter(title, content, ""))
+
+    # --- Build header ---
+    name = book_info.get("book_name")
+    author = book_info.get("author")
+    words = book_info.get("word_count")
+    updated = book_info.get("update_time")
+    summary = book_info.get("summary")
+
+    fields = [
+        ("书名", name),
+        ("作者", author),
+        ("总字数", words),
+        ("更新日期", updated),
+    ]
+    header_lines = [f"{label}: {value}" for label, value in fields if value]
+
+    if summary:
+        header_lines.append("内容简介:")
+        header_lines.append(summary)
+
+    header_lines += ["", "-" * 10, ""]
+
+    header = "\n".join(header_lines)
+
+    final_text = header + "\n\n" + "\n\n".join(parts).strip()
+
+    # --- Determine output file path ---
+    out_name = exporter.get_filename(title=name, author=author, ext="txt")
+    out_path = out_dir / out_name
+
+    # --- Save final text ---
+    try:
+        save_as_txt(content=final_text, filepath=out_path)
+        exporter.logger.info("%s Novel saved to: %s", TAG, out_path)
+    except Exception as e:
+        exporter.logger.error("%s Failed to save file: %s", TAG, e)
+    return

novel_downloader/core/exporters/qianbi.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.qianbi
+--------------------------------------
+
+"""
+
+from novel_downloader.models import ExporterConfig
+
+from .common import CommonExporter
+
+
+class QianbiExporter(CommonExporter):
+    def __init__(
+        self,
+        config: ExporterConfig,
+    ):
+        super().__init__(
+            config,
+            site="qianbi",
+            chap_folders=["chapters"],
+        )
+
+
+__all__ = ["QianbiExporter"]

novel_downloader/core/{savers → exporters}/qidian.py

@@ -1,22 +1,22 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.savers.qidian
------------------------------------
+novel_downloader.core.exporters.qidian
+--------------------------------------
 
-This module provides the `QidianSaver` class for handling the saving process
+This module provides the `QidianExporter` class for handling the saving process
 of novels sourced from Qidian (起点中文网). It implements the platform-specific
 logic required to structure and export novel content into desired formats.
 """
 
-from novel_downloader.config.models import SaverConfig
+from novel_downloader.models import ExporterConfig
 
-from .common import CommonSaver
+from .common import CommonExporter
 
 
-class QidianSaver(CommonSaver):
+class QidianExporter(CommonExporter):
     def __init__(
         self,
-        config: SaverConfig,
+        config: ExporterConfig,
     ):
         super().__init__(
             config,
@@ -25,4 +25,4 @@ class QidianSaver(CommonSaver):
         )
 
 
-__all__ = ["QidianSaver"]
+__all__ = ["QidianExporter"]

novel_downloader/core/exporters/sfacg.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.sfacg
+-------------------------------------
+
+"""
+
+from novel_downloader.models import ExporterConfig
+
+from .common import CommonExporter
+
+
+class SfacgExporter(CommonExporter):
+    def __init__(
+        self,
+        config: ExporterConfig,
+    ):
+        super().__init__(
+            config,
+            site="sfacg",
+            chap_folders=["chapters"],
+        )
+
+
+__all__ = ["SfacgExporter"]

novel_downloader/core/exporters/yamibo.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.exporters.yamibo
+--------------------------------------
+
+"""
+
+from novel_downloader.models import ExporterConfig
+
+from .common import CommonExporter
+
+
+class YamiboExporter(CommonExporter):
+    def __init__(
+        self,
+        config: ExporterConfig,
+    ):
+        super().__init__(
+            config,
+            site="yamibo",
+            chap_folders=["chapters"],
+        )
+
+
+__all__ = ["YamiboExporter"]

novel_downloader/core/factory/__init__.py

@@ -7,26 +7,14 @@ This package provides factory methods for dynamically retrieving components
 based on runtime parameters such as site name or content type.
 """
 
-from .downloader import (
-    get_async_downloader,
-    get_downloader,
-    get_sync_downloader,
-)
+from .downloader import get_downloader
+from .exporter import get_exporter
+from .fetcher import get_fetcher
 from .parser import get_parser
-from .requester import (
-    get_async_requester,
-    get_requester,
-    get_sync_requester,
-)
-from .saver import get_saver
 
 __all__ = [
-    "get_async_downloader",
     "get_downloader",
-    "get_sync_downloader",
+    "get_exporter",
+    "get_fetcher",
     "get_parser",
-    "get_async_requester",
-    "get_requester",
-    "get_sync_requester",
-    "get_saver",
 ]

novel_downloader/core/factory/downloader.py

@@ -1,60 +1,42 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.factory.downloader_factory
-------------------------------------------------
+novel_downloader.core.factory.downloader
+----------------------------------------
 
 This module implements a factory function for creating downloader instances
 based on the site name and parser mode specified in the configuration.
 """
 
 from collections.abc import Callable
-from typing import cast
 
-from novel_downloader.config import DownloaderConfig, load_site_rules
+from novel_downloader.config import load_site_rules
 from novel_downloader.core.downloaders import (
-    BiqugeAsyncDownloader,
     BiqugeDownloader,
-    CommonAsyncDownloader,
     CommonDownloader,
-    EsjzoneAsyncDownloader,
     EsjzoneDownloader,
-    QianbiAsyncDownloader,
+    LinovelibDownloader,
     QianbiDownloader,
     QidianDownloader,
-    SfacgAsyncDownloader,
     SfacgDownloader,
-    YamiboAsyncDownloader,
     YamiboDownloader,
 )
 from novel_downloader.core.interfaces import (
-    AsyncDownloaderProtocol,
-    AsyncRequesterProtocol,
+    DownloaderProtocol,
+    ExporterProtocol,
+    FetcherProtocol,
     ParserProtocol,
-    SaverProtocol,
-    SyncDownloaderProtocol,
-    SyncRequesterProtocol,
 )
+from novel_downloader.models import DownloaderConfig
 
-AsyncDownloaderBuilder = Callable[
-    [AsyncRequesterProtocol, ParserProtocol, SaverProtocol, DownloaderConfig],
-    AsyncDownloaderProtocol,
+DownloaderBuilder = Callable[
+    [FetcherProtocol, ParserProtocol, ExporterProtocol, DownloaderConfig],
+    DownloaderProtocol,
 ]
 
-SyncDownloaderBuilder = Callable[
-    [SyncRequesterProtocol, ParserProtocol, SaverProtocol, DownloaderConfig],
-    SyncDownloaderProtocol,
-]
-
-_async_site_map: dict[str, AsyncDownloaderBuilder] = {
-    "biquge": BiqugeAsyncDownloader,
-    "esjzone": EsjzoneAsyncDownloader,
-    "qianbi": QianbiAsyncDownloader,
-    "sfacg": SfacgAsyncDownloader,
-    "yamibo": YamiboAsyncDownloader,
-}
-_sync_site_map: dict[str, SyncDownloaderBuilder] = {
+_site_map: dict[str, DownloaderBuilder] = {
     "biquge": BiqugeDownloader,
     "esjzone": EsjzoneDownloader,
+    "linovelib": LinovelibDownloader,
     "qianbi": QianbiDownloader,
     "qidian": QidianDownloader,
     "sfacg": SfacgDownloader,
@@ -62,117 +44,33 @@ _sync_site_map: dict[str, SyncDownloaderBuilder] = {
 }
 
 
-def get_async_downloader(
-    requester: AsyncRequesterProtocol,
-    parser: ParserProtocol,
-    saver: SaverProtocol,
-    site: str,
-    config: DownloaderConfig,
-) -> AsyncDownloaderProtocol:
-    """
-    Returns an AsyncDownloaderProtocol for the given site.
-
-    :param requester: Requester implementation
-    :param parser: Parser implementation
-    :param saver: Saver implementation
-    :param site: Site name (e.g., 'qidian')
-    :param config: Downloader configuration
-
-    :return: An instance of a downloader class
-
-    :raises ValueError: If a site-specific downloader does not support async mode.
-    :raises TypeError: If the provided requester does not match the required protocol.
-    """
-    site_key = site.lower()
-
-    if not isinstance(requester, AsyncRequesterProtocol):
-        raise TypeError("Async mode requires an AsyncRequesterProtocol")
-
-    # site-specific
-    if site_key in _async_site_map:
-        return _async_site_map[site_key](requester, parser, saver, config)
-
-    # fallback
-    site_rules = load_site_rules()
-    site_rule = site_rules.get(site_key)
-    if site_rule is None:
-        raise ValueError(f"Unsupported site: {site}")
-
-    return CommonAsyncDownloader(requester, parser, saver, config, site_key)
-
-
-def get_sync_downloader(
-    requester: SyncRequesterProtocol,
+def get_downloader(
+    fetcher: FetcherProtocol,
     parser: ParserProtocol,
-    saver: SaverProtocol,
+    exporter: ExporterProtocol,
     site: str,
     config: DownloaderConfig,
-) -> SyncDownloaderProtocol:
+) -> DownloaderProtocol:
     """
-    Returns a DownloaderProtocol for the given site.
-    First tries a site-specific downloader (e.g. QidianDownloader),
-    otherwise falls back to CommonDownloader.
+    Returns an DownloaderProtocol for the given site.
 
-    :param requester: Requester implementation
+    :param fetcher: Fetcher implementation
     :param parser: Parser implementation
-    :param saver: Saver implementation
+    :param exporter: Exporter implementation
     :param site: Site name (e.g., 'qidian')
     :param config: Downloader configuration
 
     :return: An instance of a downloader class
-
-    :raises ValueError: If a site-specific downloader does not support async mode.
-    :raises TypeError: If the provided requester does not match the required protocol.
     """
     site_key = site.lower()
 
-    if not isinstance(requester, SyncRequesterProtocol):
-        raise TypeError("Sync mode requires a RequesterProtocol")
-
     # site-specific
-    if site_key in _sync_site_map:
-        return _sync_site_map[site_key](requester, parser, saver, config)
+    if site_key in _site_map:
+        return _site_map[site_key](fetcher, parser, exporter, config)
 
     # fallback
     site_rules = load_site_rules()
-    site_rule = site_rules.get(site_key)
-    if site_rule is None:
+    if site_key not in site_rules:
         raise ValueError(f"Unsupported site: {site}")
 
-    return CommonDownloader(requester, parser, saver, config, site_key)
-
-
-def get_downloader(
-    requester: AsyncRequesterProtocol | SyncRequesterProtocol,
-    parser: ParserProtocol,
-    saver: SaverProtocol,
-    site: str,
-    config: DownloaderConfig,
-) -> AsyncDownloaderProtocol | SyncDownloaderProtocol:
-    """
-    Dispatches to get_async_downloader if config.mode == 'async',
-    otherwise to get_sync_downloader.
-
-    :param requester: Requester implementation
-    :param parser: Parser implementation
-    :param saver: Saver implementation
-    :param site: Site name (e.g., 'qidian')
-    :param config: Downloader configuration
-
-    :return: An instance of a downloader class
-
-    :raises ValueError: If a site-specific downloader does not support async mode.
-    :raises TypeError: If the provided requester does not match the required protocol.
-    """
-    if requester.is_async():
-        if config.mode.lower() != "async":
-            raise TypeError("Requester is async, but config.mode is not 'async'")
-        async_requester = cast(AsyncRequesterProtocol, requester)
-        return get_async_downloader(async_requester, parser, saver, site, config)
-    else:
-        if config.mode.lower() not in ("browser", "session"):
-            raise TypeError(
-                "Requester is sync, but config.mode is not 'browser' or 'session'"
-            )
-        sync_requester = cast(SyncRequesterProtocol, requester)
-        return get_sync_downloader(sync_requester, parser, saver, site, config)
+    return CommonDownloader(fetcher, parser, exporter, config, site_key)

novel_downloader/core/factory/exporter.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.factory.exporter
+--------------------------------------
+
+This module implements a factory function for creating exporter instances
+based on the site name.
+"""
+
+from collections.abc import Callable
+
+from novel_downloader.config import load_site_rules
+from novel_downloader.core.exporters import (
+    BiqugeExporter,
+    CommonExporter,
+    EsjzoneExporter,
+    LinovelibExporter,
+    QianbiExporter,
+    QidianExporter,
+    SfacgExporter,
+    YamiboExporter,
+)
+from novel_downloader.core.interfaces import ExporterProtocol
+from novel_downloader.models import ExporterConfig
+
+ExporterBuilder = Callable[[ExporterConfig], ExporterProtocol]
+
+_site_map: dict[str, ExporterBuilder] = {
+    "biquge": BiqugeExporter,
+    "esjzone": EsjzoneExporter,
+    "linovelib": LinovelibExporter,
+    "qianbi": QianbiExporter,
+    "qidian": QidianExporter,
+    "sfacg": SfacgExporter,
+    "yamibo": YamiboExporter,
+}
+
+
+def get_exporter(site: str, config: ExporterConfig) -> ExporterProtocol:
+    """
+    Returns a site-specific exporter instance.
+
+    :param site: Site name (e.g., 'qidian')
+    :param config: Configuration for the exporter
+    :return: An instance of a exporter class
+    """
+    site_key = site.lower()
+
+    # site-specific
+    if site_key in _site_map:
+        return _site_map[site_key](config)
+
+    # Fallback
+    site_rules = load_site_rules()
+    if site_key not in site_rules:
+        raise ValueError(f"Unsupported site: {site}")
+
+    return CommonExporter(config, site_key)

novel_downloader/core/factory/fetcher.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.factory.fetcher
+-------------------------------------
+
+This module implements a factory function for retrieving fetcher instances
+based on the target novel platform (site).
+"""
+
+from collections.abc import Callable
+
+from novel_downloader.config import load_site_rules
+from novel_downloader.core.fetchers import (
+    BiqugeBrowser,
+    BiqugeSession,
+    CommonBrowser,
+    CommonSession,
+    EsjzoneBrowser,
+    EsjzoneSession,
+    LinovelibBrowser,
+    LinovelibSession,
+    QianbiBrowser,
+    QianbiSession,
+    QidianBrowser,
+    QidianSession,
+    SfacgBrowser,
+    SfacgSession,
+    YamiboBrowser,
+    YamiboSession,
+)
+from novel_downloader.core.interfaces import FetcherProtocol
+from novel_downloader.models import FetcherConfig
+
+FetcherBuilder = Callable[[FetcherConfig], FetcherProtocol]
+
+_site_map: dict[str, dict[str, FetcherBuilder]] = {
+    "biquge": {
+        "browser": BiqugeBrowser,
+        "session": BiqugeSession,
+    },
+    "esjzone": {
+        "browser": EsjzoneBrowser,
+        "session": EsjzoneSession,
+    },
+    "linovelib": {
+        "browser": LinovelibBrowser,
+        "session": LinovelibSession,
+    },
+    "qianbi": {
+        "browser": QianbiBrowser,
+        "session": QianbiSession,
+    },
+    "qidian": {
+        "browser": QidianBrowser,
+        "session": QidianSession,
+    },
+    "sfacg": {
+        "browser": SfacgBrowser,
+        "session": SfacgSession,
+    },
+    "yamibo": {
+        "browser": YamiboBrowser,
+        "session": YamiboSession,
+    },
+}
+
+
+def get_fetcher(
+    site: str,
+    config: FetcherConfig,
+) -> FetcherProtocol:
+    """
+    Returns an FetcherProtocol for the given site.
+
+    :param site: Site name (e.g., 'qidian')
+    :param config: Configuration for the requester
+    :return: An instance of a requester class
+    """
+    site_key = site.lower()
+    mode = config.mode
+
+    # site-specific
+    fetcher_cls = _site_map.get(site_key, {}).get(mode)
+    if fetcher_cls is not None:
+        return fetcher_cls(config)
+
+    # fallback: use Common based on mode
+    site_rules = load_site_rules()
+    site_rule = site_rules.get(site_key)
+    if site_rule is None:
+        raise ValueError(f"Unsupported site: {site}")
+    profile = site_rule["profile"]
+
+    if mode == "browser":
+        return CommonBrowser(site_key, profile, config)
+    return CommonSession(site_key, profile, config)