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

novel_downloader/cli/export.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.cli.export
+---------------------------
+
+"""
+
+from argparse import Namespace, _SubParsersAction
+from pathlib import Path
+
+from novel_downloader.config import ConfigAdapter, load_config
+from novel_downloader.core.factory import get_exporter
+from novel_downloader.utils.i18n import t
+
+
+def register_export_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    parser = subparsers.add_parser("export", help=t("help_export"))
+
+    parser.add_argument(
+        "book_ids",
+        nargs="+",
+        help=t("download_book_ids"),
+    )
+    parser.add_argument(
+        "--format",
+        choices=["txt", "epub", "all"],
+        default="all",
+        help=t("export_format_help"),
+    )
+    parser.add_argument(
+        "--site",
+        default="qidian",
+        help=t("download_option_site", default="qidian"),
+    )
+    parser.add_argument(
+        "--config",
+        type=str,
+        help=t("help_config"),
+    )
+
+    parser.set_defaults(func=handle_export)
+
+
+def handle_export(args: Namespace) -> None:
+    site: str = args.site
+    config_path: Path | None = Path(args.config) if args.config else None
+    book_ids: list[str] = args.book_ids
+    export_format: str = args.format
+
+    print(t("download_site_info", site=site))
+
+    try:
+        config_data = load_config(config_path)
+    except Exception as e:
+        print(t("download_config_load_fail", err=str(e)))
+        return
+
+    adapter = ConfigAdapter(config=config_data, site=site)
+    exporter_cfg = adapter.get_exporter_config()
+    exporter = get_exporter(site, exporter_cfg)
+
+    for book_id in book_ids:
+        print(t("export_processing", book_id=book_id, format=export_format))
+
+        if export_format in {"txt", "all"}:
+            try:
+                exporter.export_as_txt(book_id)
+                print(t("export_success_txt", book_id=book_id))
+            except Exception as e:
+                print(t("export_failed_txt", book_id=book_id, err=str(e)))
+
+        if export_format in {"epub", "all"}:
+            try:
+                exporter.export_as_epub(book_id)
+                print(t("export_success_epub", book_id=book_id))
+            except Exception as e:
+                print(t("export_failed_epub", book_id=book_id, err=str(e)))

novel_downloader/cli/main.py

@@ -1,42 +1,35 @@
 #!/usr/bin/env python3
 """
 novel_downloader.cli.main
---------------------------
+-------------------------
 
 Unified CLI entry point. Parses arguments and delegates to parser or interactive.
 """
 
+import argparse
 
-import click
-from click import Context
-
-from novel_downloader.cli import clean, download, interactive, settings
 from novel_downloader.utils.i18n import t
 
+from .clean import register_clean_subcommand
+from .config import register_config_subcommand
+from .download import register_download_subcommand
+from .export import register_export_subcommand
+
+
+def cli_main() -> None:
+    parser = argparse.ArgumentParser(description=t("cli_help"))
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    register_clean_subcommand(subparsers)
+    register_config_subcommand(subparsers)
+    register_download_subcommand(subparsers)
+    register_export_subcommand(subparsers)
 
-@click.group(help=t("cli_help"), invoke_without_command=True)  # type: ignore
-@click.option(
-    "--config",
-    type=click.Path(exists=True, dir_okay=False, resolve_path=True),
-    default=None,
-    help=t("help_config"),
-)  # type: ignore
-@click.pass_context  # type: ignore
-def cli_main(ctx: Context, config: str | None) -> None:
-    """Novel Downloader CLI."""
-    ctx.ensure_object(dict)
-    ctx.obj["config_path"] = config
-
-    if ctx.invoked_subcommand is None:
-        click.echo(t("main_no_command"))
-        ctx.invoke(interactive.interactive_cli)
-
-
-# Register subcommands
-cli_main.add_command(clean.clean_cli)
-cli_main.add_command(download.download_cli)
-cli_main.add_command(interactive.interactive_cli)
-cli_main.add_command(settings.settings_cli)
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        parser.print_help()
 
 
 if __name__ == "__main__":

novel_downloader/config/__init__.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 novel_downloader.config
-------------------------
+-----------------------
 
 Unified interface for loading and adapting configuration files.
 
@@ -13,19 +13,6 @@ This module provides:
 
 from .adapter import ConfigAdapter
 from .loader import load_config, save_config_file
-from .models import (
-    BookInfoRules,
-    DownloaderConfig,
-    FieldRules,
-    ParserConfig,
-    RequesterConfig,
-    RuleStep,
-    SaverConfig,
-    SiteProfile,
-    SiteRules,
-    SiteRulesDict,
-    VolumesRules,
-)
 from .site_rules import (
     load_site_rules,
     save_rules_as_json,
@@ -35,17 +22,6 @@ __all__ = [
     "load_config",
     "save_config_file",
     "ConfigAdapter",
-    "RequesterConfig",
-    "DownloaderConfig",
-    "ParserConfig",
-    "SaverConfig",
-    "FieldRules",
-    "RuleStep",
-    "SiteProfile",
-    "SiteRules",
-    "SiteRulesDict",
-    "VolumesRules",
-    "BookInfoRules",
     "load_site_rules",
     "save_rules_as_json",
 ]

novel_downloader/config/adapter.py

@@ -5,25 +5,18 @@ novel_downloader.config.adapter
 
 Defines ConfigAdapter, which maps a raw configuration dictionary and
 site name into structured dataclass-based config models.
-
-Supported mappings:
-- requests          -> RequesterConfig
-- general+site      -> DownloaderConfig
-- general+site      -> ParserConfig
-- general+output    -> SaverConfig
-- sites[site]       -> book_ids list
 """
 
 from typing import Any
 
-from novel_downloader.utils.constants import SUPPORTED_SITES
-
-from .models import (
+from novel_downloader.models import (
     DownloaderConfig,
+    ExporterConfig,
+    FetcherConfig,
     ParserConfig,
-    RequesterConfig,
-    SaverConfig,
 )
+from novel_downloader.utils.constants import SUPPORTED_SITES
+
 from .site_rules import load_site_rules
 
 
@@ -70,28 +63,29 @@ class ConfigAdapter:
 
         return {}
 
-    def get_requester_config(self) -> RequesterConfig:
+    def get_fetcher_config(self) -> FetcherConfig:
         """
-        从 config["requests"] 中读取通用请求配置 (含 DrissionPage 设置)
-        返回 RequesterConfig 实例
+        从 config["requests"] 中读取通用请求配置
+        返回 FetcherConfig 实例
         """
+        gen = self._config.get("general", {})
         req = self._config.get("requests", {})
         site_cfg = self._get_site_cfg()
-        return RequesterConfig(
+        return FetcherConfig(
+            request_interval=gen.get("request_interval", 2.0),
             retry_times=req.get("retry_times", 3),
             backoff_factor=req.get("backoff_factor", 2.0),
             timeout=req.get("timeout", 30.0),
             max_connections=req.get("max_connections", 10),
             max_rps=req.get("max_rps", None),
-            headless=req.get("headless", True),
-            user_data_folder=req.get("user_data_folder", "./user_data"),
-            profile_name=req.get("profile_name", "Profile_1"),
-            auto_close=req.get("auto_close", True),
-            disable_images=req.get("disable_images", True),
-            mute_audio=req.get("mute_audio", True),
+            headless=req.get("headless", False),
+            disable_images=req.get("disable_images", False),
             mode=site_cfg.get("mode", "session"),
-            username=site_cfg.get("username", ""),
-            password=site_cfg.get("password", ""),
+            proxy=req.get("proxy", None),
+            user_agent=req.get("user_agent", None),
+            headers=req.get("headers", None),
+            browser_type=req.get("browser_type", "chromium"),
+            verify_ssl=req.get("verify_ssl", True),
         )
 
     def get_downloader_config(self) -> DownloaderConfig:
@@ -100,21 +94,26 @@ class ConfigAdapter:
         返回 DownloaderConfig 实例
         """
         gen = self._config.get("general", {})
+        req = self._config.get("requests", {})
         debug = gen.get("debug", {})
         site_cfg = self._get_site_cfg()
         return DownloaderConfig(
-            request_interval=gen.get("request_interval", 5.0),
+            request_interval=gen.get("request_interval", 2.0),
+            retry_times=req.get("retry_times", 3),
+            backoff_factor=req.get("backoff_factor", 2.0),
             raw_data_dir=gen.get("raw_data_dir", "./raw_data"),
             cache_dir=gen.get("cache_dir", "./novel_cache"),
-            download_workers=gen.get("download_workers", 4),
-            parser_workers=gen.get("parser_workers", 4),
-            use_process_pool=gen.get("use_process_pool", True),
+            download_workers=gen.get("download_workers", 2),
+            parser_workers=gen.get("parser_workers", 2),
             skip_existing=gen.get("skip_existing", True),
             login_required=site_cfg.get("login_required", False),
             save_html=debug.get("save_html", False),
             mode=site_cfg.get("mode", "session"),
             storage_backend=gen.get("storage_backend", "json"),
             storage_batch_size=gen.get("storage_batch_size", 1),
+            username=site_cfg.get("username", ""),
+            password=site_cfg.get("password", ""),
+            cookies=site_cfg.get("cookies", ""),
         )
 
     def get_parser_config(self) -> ParserConfig:
@@ -141,17 +140,18 @@ class ConfigAdapter:
             mode=site_cfg.get("mode", "session"),
         )
 
-    def get_saver_config(self) -> SaverConfig:
+    def get_exporter_config(self) -> ExporterConfig:
         """
         从 config["general"] 与 config["output"] 中读取存储器相关配置,
-        返回 SaverConfig 实例
+        返回 ExporterConfig 实例
         """
         gen = self._config.get("general", {})
         out = self._config.get("output", {})
         fmt = out.get("formats", {})
         naming = out.get("naming", {})
         epub_opts = out.get("epub", {})
-        return SaverConfig(
+        site_cfg = self._get_site_cfg()
+        return ExporterConfig(
             cache_dir=gen.get("cache_dir", "./novel_cache"),
             raw_data_dir=gen.get("raw_data_dir", "./raw_data"),
             output_dir=gen.get("output_dir", "./downloads"),
@@ -166,6 +166,7 @@ class ConfigAdapter:
             include_cover=epub_opts.get("include_cover", True),
             include_toc=epub_opts.get("include_toc", False),
             include_picture=epub_opts.get("include_picture", False),
+            split_mode=site_cfg.get("split_mode", "book"),
         )
 
     def get_book_ids(self) -> list[str]:

novel_downloader/config/loader.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 novel_downloader.config.loader
---------------------------------
+------------------------------
 
 Provides functionality to load Toml configuration files into Python
 dictionaries, with robust error handling and fallback support.
@@ -120,9 +120,9 @@ def load_config(
     config_path: str | Path | None = None,
 ) -> dict[str, Any]:
     """
-    Load configuration data from a YAML file.
+    Load configuration data from a Toml file.
 
-    :param config_path: Optional path to the YAML configuration file.
+    :param config_path: Optional path to the Toml configuration file.
     :return:            Parsed configuration as a dict.
     """
     path = resolve_file_path(

novel_downloader/config/site_rules.py

@@ -14,12 +14,11 @@ import json
 import logging
 from pathlib import Path
 
+from novel_downloader.models import SiteRulesDict
 from novel_downloader.utils.cache import cached_load_config
 from novel_downloader.utils.constants import SITE_RULES_FILE
 from novel_downloader.utils.file_utils import save_as_json
 
-from .models import SiteRulesDict
-
 logger = logging.getLogger(__name__)
 
 

novel_downloader/core/__init__.py

@@ -10,15 +10,12 @@ downloading and processing online novel content, including:
 
 - Downloader: Handles the full download lifecycle of a book or a batch of books.
 - Parser: Extracts structured data from HTML or SSR content.
-- Requester: Sends HTTP requests and manages sessions, including login if required.
-- Saver: Responsible for exporting downloaded data into various output formats.
+- Fetcher: Sends HTTP requests and manages sessions, including login if required.
+- Exporter: Responsible for exporting downloaded data into various output formats.
 """
 
-from .factory import get_downloader, get_parser, get_requester, get_saver
+from .factory import get_parser
 
 __all__ = [
-    "get_downloader",
     "get_parser",
-    "get_requester",
-    "get_saver",
 ]

novel_downloader/core/downloaders/__init__.py

@@ -12,6 +12,7 @@ of retrieving, parsing, and saving novel content for a given source.
 Currently supported platforms:
 - biquge (笔趣阁)
 - esjzone (ESJ Zone)
+- linovelib (哔哩轻小说)
 - qianbi (铅笔小说)
 - qidian (起点中文网)
 - sfacg (SF轻小说)
@@ -19,26 +20,22 @@ Currently supported platforms:
 - common (通用架构)
 """
 
-from .biquge import BiqugeAsyncDownloader, BiqugeDownloader
-from .common import CommonAsyncDownloader, CommonDownloader
-from .esjzone import EsjzoneAsyncDownloader, EsjzoneDownloader
-from .qianbi import QianbiAsyncDownloader, QianbiDownloader
+from .biquge import BiqugeDownloader
+from .common import CommonDownloader
+from .esjzone import EsjzoneDownloader
+from .linovelib import LinovelibDownloader
+from .qianbi import QianbiDownloader
 from .qidian import QidianDownloader
-from .sfacg import SfacgAsyncDownloader, SfacgDownloader
-from .yamibo import YamiboAsyncDownloader, YamiboDownloader
+from .sfacg import SfacgDownloader
+from .yamibo import YamiboDownloader
 
 __all__ = [
-    "BiqugeAsyncDownloader",
     "BiqugeDownloader",
-    "CommonAsyncDownloader",
-    "CommonDownloader",
-    "EsjzoneAsyncDownloader",
     "EsjzoneDownloader",
-    "QianbiAsyncDownloader",
+    "LinovelibDownloader",
     "QianbiDownloader",
     "QidianDownloader",
-    "SfacgAsyncDownloader",
     "SfacgDownloader",
-    "YamiboAsyncDownloader",
     "YamiboDownloader",
+    "CommonDownloader",
 ]

novel_downloader/core/downloaders/base.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.downloaders.base
+--------------------------------------
+
+Defines the abstract base class `BaseDownloader`, which provides a
+common interface and reusable logic for all downloader implementations.
+"""
+
+import abc
+import logging
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Any
+
+from novel_downloader.core.interfaces import (
+    DownloaderProtocol,
+    ExporterProtocol,
+    FetcherProtocol,
+    ParserProtocol,
+)
+from novel_downloader.models import DownloaderConfig
+
+
+class BaseDownloader(DownloaderProtocol, abc.ABC):
+    """
+    Abstract downloader that defines the initialization interface
+    and the general batch download flow.
+
+    Subclasses must implement the logic for downloading a single book.
+    """
+
+    def __init__(
+        self,
+        fetcher: FetcherProtocol,
+        parser: ParserProtocol,
+        exporter: ExporterProtocol,
+        config: DownloaderConfig,
+        site: str,
+    ):
+        self._fetcher = fetcher
+        self._parser = parser
+        self._exporter = exporter
+        self._config = config
+        self._site = site
+
+        self._raw_data_dir = Path(config.raw_data_dir) / site
+        self._cache_dir = Path(config.cache_dir) / site
+        self._raw_data_dir.mkdir(parents=True, exist_ok=True)
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+
+        self.logger = logging.getLogger(f"{self.__class__.__name__}")
+
+    async def download_many(
+        self,
+        book_ids: list[str],
+        *,
+        progress_hook: Callable[[int, int], Awaitable[None]] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Download multiple books with pre-download hook and error handling.
+
+        :param book_ids: A list of book identifiers to download.
+        :param progress_hook: (optional) Called after each chapter;
+                                args: completed_count, total_count.
+        """
+        if not await self._ensure_ready():
+            self.logger.warning(
+                "[%s] login failed, skipping download of %s",
+                self._site,
+                book_ids,
+            )
+            return
+
+        for book_id in book_ids:
+            try:
+                await self._download_one(
+                    book_id,
+                    progress_hook=progress_hook,
+                    **kwargs,
+                )
+            except Exception as e:
+                self._handle_download_exception(book_id, e)
+
+        await self._finalize()
+
+    async def download(
+        self,
+        book_id: str,
+        *,
+        progress_hook: Callable[[int, int], Awaitable[None]] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Download a single book with pre-download hook and error handling.
+
+        :param book_id: The identifier of the book to download.
+        :param progress_hook: (optional) Called after each chapter;
+                                args: completed_count, total_count.
+        """
+        if not await self._ensure_ready():
+            self.logger.warning(
+                "[%s] login failed, skipping download of %s",
+                self._site,
+                book_id,
+            )
+            return
+
+        try:
+            await self._download_one(
+                book_id,
+                progress_hook=progress_hook,
+                **kwargs,
+            )
+        except Exception as e:
+            self._handle_download_exception(book_id, e)
+
+        await self._finalize()
+
+    @abc.abstractmethod
+    async def _download_one(
+        self,
+        book_id: str,
+        *,
+        progress_hook: Callable[[int, int], Awaitable[None]] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Subclasses must implement this to define how to download a single book.
+        """
+        ...
+
+    async def _prepare(self) -> None:
+        """
+        Optional hook called before downloading.
+
+        Subclasses can override this method to perform pre-download setup.
+        """
+        return
+
+    async def _finalize(self) -> None:
+        """
+        Optional hook called after downloading is complete.
+
+        Subclasses can override this method to perform post-download tasks,
+        such as saving state or releasing resources.
+        """
+        return
+
+    @property
+    def fetcher(self) -> FetcherProtocol:
+        return self._fetcher
+
+    @property
+    def parser(self) -> ParserProtocol:
+        return self._parser
+
+    @property
+    def exporter(self) -> ExporterProtocol:
+        return self._exporter
+
+    @property
+    def config(self) -> DownloaderConfig:
+        return self._config
+
+    @property
+    def raw_data_dir(self) -> Path:
+        return self._raw_data_dir
+
+    @property
+    def cache_dir(self) -> Path:
+        return self._cache_dir
+
+    @property
+    def site(self) -> str:
+        return self._site
+
+    @property
+    def save_html(self) -> bool:
+        return self._config.save_html
+
+    @property
+    def skip_existing(self) -> bool:
+        return self._config.skip_existing
+
+    @property
+    def login_required(self) -> bool:
+        return self._config.login_required
+
+    @property
+    def request_interval(self) -> float:
+        return self._config.request_interval
+
+    @property
+    def retry_times(self) -> int:
+        return self._config.retry_times
+
+    @property
+    def backoff_factor(self) -> float:
+        return self._config.backoff_factor
+
+    @property
+    def parser_workers(self) -> int:
+        return self._config.parser_workers
+
+    @property
+    def download_workers(self) -> int:
+        return self._config.download_workers
+
+    def _handle_download_exception(self, book_id: str, error: Exception) -> None:
+        """
+        Handle download errors in a consistent way.
+
+        This method can be overridden or extended to implement retry logic, etc.
+
+        :param book_id: The ID of the book that failed.
+        :param error: The exception raised during download.
+        """
+        self.logger.warning(
+            "[%s] Failed to download %r: %s",
+            self.__class__.__name__,
+            book_id,
+            error,
+        )
+
+    async def _ensure_ready(self) -> bool:
+        """
+        Run pre-download preparation and check login if needed.
+        """
+        await self._prepare()
+
+        return self.fetcher.is_logged_in if self.login_required else True

novel_downloader/core/downloaders/biquge.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.downloaders.biquge
+----------------------------------------
+
+"""
+
+from novel_downloader.core.downloaders.common import CommonDownloader
+from novel_downloader.core.interfaces import (
+    ExporterProtocol,
+    FetcherProtocol,
+    ParserProtocol,
+)
+from novel_downloader.models import DownloaderConfig
+
+
+class BiqugeDownloader(CommonDownloader):
+    """"""
+
+    def __init__(
+        self,
+        fetcher: FetcherProtocol,
+        parser: ParserProtocol,
+        exporter: ExporterProtocol,
+        config: DownloaderConfig,
+    ):
+        super().__init__(fetcher, parser, exporter, config, "biquge")