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

novel_downloader/cli/search.py

@@ -3,13 +3,18 @@
 novel_downloader.cli.search
 ---------------------------
 
+Search across supported sites, let the user pick one result, then
+hand off to the download flow.
 """
 
+from __future__ import annotations
+
 import asyncio
 from argparse import Namespace, _SubParsersAction
 from collections.abc import Sequence
 from pathlib import Path
 
+from novel_downloader.cli import ui
 from novel_downloader.cli.download import _download
 from novel_downloader.config import ConfigAdapter, load_config
 from novel_downloader.core import search
@@ -18,106 +23,98 @@ from novel_downloader.utils.i18n import t
 
 
 def register_search_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    """Register the `search` subcommand and its options."""
     parser = subparsers.add_parser("search", help=t("help_search"))
 
     parser.add_argument(
-        "--site",
-        "-s",
-        action="append",
-        metavar="SITE",
-        help=t("help_search_sites"),
-    )
-    parser.add_argument(
-        "keyword",
-        help=t("help_search_keyword"),
+        "--site", "-s", action="append", metavar="SITE", help=t("search_sites_help")
     )
+    parser.add_argument("keyword", help=t("search_keyword_help"))
+    parser.add_argument("--config", type=str, help=t("help_config"))
     parser.add_argument(
-        "--config",
-        type=str,
-        help=t("help_config"),
-    )
-    parser.add_argument(
-        "--limit",
-        "-l",
-        type=int,
-        default=10,
-        metavar="N",
-        help=t("help_search_limit"),
+        "--limit", "-l", type=int, default=20, metavar="N", help=t("search_limit_help")
     )
     parser.add_argument(
         "--site-limit",
         type=int,
         default=5,
         metavar="M",
-        help=t("help_search_site_limit"),
+        help=t("search_site_limit_help"),
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=5.0,
+        metavar="SECS",
+        help=t("search_timeout_help", secs="5.0"),
     )
 
     parser.set_defaults(func=handle_search)
 
 
 def handle_search(args: Namespace) -> None:
-    """
-    Handler for the `search` subcommand. Loads config, runs the search,
-    prompts the user to pick one result, then kicks off download.
-    """
+    """Handle the `search` subcommand."""
     sites: Sequence[str] | None = args.site or None
     keyword: str = args.keyword
     overall_limit = max(1, args.limit)
     per_site_limit = max(1, args.site_limit)
+    timeout = max(0.1, float(args.timeout))
     config_path: Path | None = Path(args.config) if args.config else None
 
     try:
         config_data = load_config(config_path)
     except Exception as e:
-        print(t("download_config_load_fail", err=str(e)))
+        ui.error(t("download_config_load_fail", err=str(e)))
         return
 
-    results = search(
-        keyword=keyword,
-        sites=sites,
-        limit=overall_limit,
-        per_site_limit=per_site_limit,
-    )
+    async def _run() -> None:
+        results = await search(
+            keyword=keyword,
+            sites=sites,
+            limit=overall_limit,
+            per_site_limit=per_site_limit,
+            timeout=timeout,
+        )
 
-    chosen = _prompt_user_select(results)
-    if chosen is None:
-        # user cancelled or no valid choice
-        return
+        chosen = _prompt_user_select(results)
+        if chosen is None:
+            return
+
+        adapter = ConfigAdapter(config=config_data, site=chosen["site"])
+        books: list[BookConfig] = [{"book_id": chosen["book_id"]}]
+        await _download(adapter, chosen["site"], books)
 
-    adapter = ConfigAdapter(config=config_data, site=chosen["site"])
-    books: list[BookConfig] = [{"book_id": chosen["book_id"]}]
-    asyncio.run(_download(adapter, chosen["site"], books))
+    asyncio.run(_run())
 
 
-def _prompt_user_select(
-    results: Sequence[SearchResult],
-    max_attempts: int = 3,
-) -> SearchResult | None:
+def _prompt_user_select(results: Sequence[SearchResult]) -> SearchResult | None:
     """
-    Display a numbered list of results and prompt the user to pick one.
+    Show a Rich table of results and ask the user to pick one by index.
 
-    :param results:      A list of SearchResult dicts.
-    :param max_attempts: How many bad inputs to tolerate before giving up.
-    :return:             The chosen SearchResult, or None if cancelled/failed.
+    :param results: A sequence of SearchResult dicts.
+    :return: The chosen SearchResult, or None if cancelled/no results.
     """
     if not results:
-        print(t("no_results"))
+        ui.warn(t("no_results"))
         return None
 
-    # Show choices
-    for i, r in enumerate(results, start=1):
-        print(f"[{i}] {r['title']} - {r['author']} ({r['site']}, id: {r['book_id']})")
-
-    attempts = 0
-    while attempts < max_attempts:
-        choice = input(t("prompt_select_index")).strip()
-        if choice == "":
-            return None
-        if choice.isdigit():
-            idx = int(choice)
-            if 1 <= idx <= len(results):
-                return results[idx - 1]
-        print(t("invalid_selection"))
-        attempts += 1
-
-    return None
+    columns = ["#", "Title", "Author", "Latest", "Updated", "Site", "Book ID"]
+    rows = []
+    for i, r in enumerate(results, 1):
+        rows.append(
+            [
+                str(i),
+                r["title"],
+                r["author"],
+                r["latest_chapter"],
+                r["update_date"],
+                r["site"],
+                r["book_id"],
+            ]
+        )
+    ui.render_table("Search Results", columns, rows)
+
+    idx = ui.select_index(t("prompt_select_index"), len(results))
+    if idx is None:
+        return None
+    return results[idx - 1]

novel_downloader/cli/ui.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.cli.ui
+-----------------------
+
+A small set of Rich-based helpers to keep CLI presentation and prompts
+consistent across subcommands.
+
+Public API:
+- info, success, warn, error
+- confirm
+- prompt, prompt_password
+- render_table
+- select_index
+- print_progress
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+_CONSOLE = Console()
+
+
+def info(message: str) -> None:
+    """Print a neutral informational message."""
+    _CONSOLE.print(message)
+
+
+def success(message: str) -> None:
+    """Print a success message in a friendly color."""
+    _CONSOLE.print(f"[green]{message}[/]")
+
+
+def warn(message: str) -> None:
+    """Print a warning message."""
+    _CONSOLE.print(f"[yellow]{message}[/]")
+
+
+def error(message: str) -> None:
+    """Print an error message."""
+    _CONSOLE.print(f"[red]{message}[/]")
+
+
+def confirm(message: str, *, default: bool = False) -> bool:
+    """
+    Ask a yes/no question.
+
+    :param message: The question to display (without [y/N] suffix).
+    :param default: Default choice (pressing Enter = Yes if True, No if False).
+    :return: True if user confirms (Yes), otherwise False.
+    """
+    try:
+        result: bool = Confirm.ask(f"[bold]{message}[/bold]", default=default)
+        return result
+    except (KeyboardInterrupt, EOFError):
+        warn("Cancelled.")
+        return False
+
+
+def prompt(message: str, *, default: str | None = None) -> str:
+    """
+    Prompt user for a line of text.
+
+    :param message: Prompt message.
+    :param default: Default value if the user presses Enter.
+    :return: The user's input.
+    """
+    try:
+        result: str = Prompt.ask(message, default=default or "")
+        return result
+    except (KeyboardInterrupt, EOFError):
+        warn("Cancelled.")
+        return default or ""
+
+
+def prompt_password(message: str) -> str:
+    """
+    Prompt user for a password/secret value (no echo).
+
+    :param message: Prompt message.
+    :return: The user's input (may be empty).
+    """
+    try:
+        result: str = Prompt.ask(message, password=True)
+        return result
+    except (KeyboardInterrupt, EOFError):
+        warn("Cancelled.")
+        return ""
+
+
+def render_table(
+    title: str,
+    columns: Sequence[str],
+    rows: Iterable[Sequence[str]],
+) -> None:
+    """
+    Render a simple full-width table.
+
+    :param title: Table title.
+    :param columns: Column names.
+    :param rows: Row data; each row must have the same length as `columns`.
+    """
+    table = Table(title=title, show_lines=True, expand=True)
+    for col in columns:
+        table.add_column(col, overflow="fold")
+    for row in rows:
+        table.add_row(*[str(x) for x in row])
+    _CONSOLE.print(table)
+
+
+def select_index(prompt_text: str, total: int) -> int | None:
+    """
+    Prompt user to select an index in [1..total]. Empty input cancels.
+
+    :param prompt_text: Displayed prompt (e.g., 'Select index').
+    :param total: Maximum valid index (minimum is 1).
+    :return: Selected 1-based index, or None if user cancels.
+    """
+    if total <= 0:
+        return None
+    valid_choices = [str(i) for i in range(1, total + 1)]
+    choice = Prompt.ask(
+        prompt_text,
+        choices=valid_choices + [""],
+        show_choices=False,
+        default="",
+        show_default=False,
+    ).strip()
+    if not choice:
+        return None
+    return int(choice)
+
+
+def print_progress(
+    done: int,
+    total: int,
+    *,
+    prefix: str = "Progress",
+    unit: str = "item",
+) -> None:
+    """
+    Print a lightweight progress line.
+
+    :param done: Completed count.
+    :param total: Total count.
+    :param prefix: Text prefix shown before numbers.
+    :param unit: Logical unit name (e.g., 'item').
+    """
+    total = max(1, total)
+    pct = done / total * 100.0
+    _CONSOLE.print(f"[dim]{prefix}[/] {done}/{total} {unit} ({pct:.2f}%)")

novel_downloader/config/__init__.py

@@ -4,17 +4,20 @@ novel_downloader.config
 -----------------------
 
 Unified interface for loading and adapting configuration files.
-
-This module provides:
-- load_config: loads YAML config from file path with fallback support
-- ConfigAdapter: maps raw config + site name to structured config models
 """
 
 __all__ = [
+    "get_config_value",
     "load_config",
+    "save_config",
     "save_config_file",
     "ConfigAdapter",
 ]
 
 from .adapter import ConfigAdapter
-from .loader import load_config, save_config_file
+from .file_io import (
+    get_config_value,
+    load_config,
+    save_config,
+    save_config_file,
+)

novel_downloader/config/adapter.py

@@ -8,18 +8,19 @@ site name into structured dataclass-based config models.
 """
 
 import json
-from typing import Any, cast
+from typing import Any, TypeVar, cast
 
 from novel_downloader.models import (
     BookConfig,
     DownloaderConfig,
     ExporterConfig,
     FetcherConfig,
-    LogLevel,
     ParserConfig,
     TextCleanerConfig,
 )
 
+T = TypeVar("T")
+
 
 class ConfigAdapter:
     """
@@ -27,129 +28,78 @@ class ConfigAdapter:
     into structured dataclass configuration models.
     """
 
-    _ALLOWED_LOG_LEVELS: tuple[LogLevel, ...] = (
-        "DEBUG",
-        "INFO",
-        "WARNING",
-        "ERROR",
-    )
-
     def __init__(self, config: dict[str, Any], site: str):
         """
         Initialize the adapter.
 
         :param config: The fully loaded configuration dictionary.
-        :param site:   The current site name (e.g. "qidian").
+        :param site: The current site name (e.g. "qidian").
         """
         self._config = config
         self._site = site
+        self._site_cfg: dict[str, Any] = self._get_site_cfg()
+        self._gen_cfg: dict[str, Any] = config.get("general") or {}
 
     def get_fetcher_config(self) -> FetcherConfig:
         """
         Build a FetcherConfig from the raw configuration.
 
-        Reads from:
-          - config["general"] for global defaults (e.g. request_interval)
-          - config["requests"] for HTTP-specific settings (timeouts, retries, etc.)
-          - site-specific overrides under config["sites"][site]
-
         :return: A FetcherConfig instance with all fields populated.
         """
-        gen = self._config.get("general", {})
-        req = self._config.get("requests", {})
-        site_cfg = self._get_site_cfg()
         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", False),
-            disable_images=req.get("disable_images", False),
-            mode=site_cfg.get("mode", "session"),
-            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),
+            request_interval=self._get_gen_cfg("request_interval", 2.0),
+            retry_times=self._get_gen_cfg("retry_times", 3),
+            backoff_factor=self._get_gen_cfg("backoff_factor", 2.0),
+            timeout=self._get_gen_cfg("timeout", 30.0),
+            max_connections=self._get_gen_cfg("max_connections", 10),
+            max_rps=self._get_gen_cfg("max_rps", 1000.0),
+            user_agent=self._get_gen_cfg("user_agent", None),
+            headers=self._get_gen_cfg("headers", None),
+            verify_ssl=self._get_gen_cfg("verify_ssl", True),
+            locale_style=self._get_gen_cfg("locale_style", "simplified"),
         )
 
     def get_downloader_config(self) -> DownloaderConfig:
         """
         Build a DownloaderConfig using both general and site-specific settings.
 
-        Reads from:
-          - config["general"] for download directories, worker counts, etc.
-          - config["requests"] for retry and backoff settings
-          - config["general"]["debug"] for debug toggles (e.g. save_html)
-          - config["sites"][site] for login credentials and mode
-
         :return: A DownloaderConfig instance with all fields populated.
         """
         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", 2.0),
-            retry_times=req.get("retry_times", 3),
-            backoff_factor=req.get("backoff_factor", 2.0),
+            request_interval=self._get_gen_cfg("request_interval", 2.0),
+            retry_times=self._get_gen_cfg("retry_times", 3),
+            backoff_factor=self._get_gen_cfg("backoff_factor", 2.0),
+            workers=self._get_gen_cfg("workers", 2),
+            skip_existing=self._get_gen_cfg("skip_existing", True),
+            login_required=self._site_cfg.get("login_required", False),
+            save_html=debug.get("save_html", False),
             raw_data_dir=gen.get("raw_data_dir", "./raw_data"),
             cache_dir=gen.get("cache_dir", "./novel_cache"),
-            workers=gen.get("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_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:
         """
         Build a ParserConfig from general, OCR, and site-specific settings.
 
-        Reads from:
-          - config["general"]["cache_dir"] for where to cache intermediate parses
-          - config["general"]["font_ocr"] for font-decoding and OCR options
-          - config["sites"][site] for parsing mode and truncation behavior
-
         :return: A ParserConfig instance with all fields populated.
         """
         gen = self._config.get("general", {})
         font_ocr = gen.get("font_ocr", {})
-        site_cfg = self._get_site_cfg()
         return ParserConfig(
             cache_dir=gen.get("cache_dir", "./novel_cache"),
-            use_truncation=site_cfg.get("use_truncation", True),
+            use_truncation=self._site_cfg.get("use_truncation", True),
             decode_font=font_ocr.get("decode_font", False),
-            use_freq=font_ocr.get("use_freq", False),
-            use_ocr=font_ocr.get("use_ocr", True),
-            use_vec=font_ocr.get("use_vec", False),
-            ocr_version=font_ocr.get("ocr_version", "v1.0"),
             save_font_debug=font_ocr.get("save_font_debug", False),
             batch_size=font_ocr.get("batch_size", 32),
-            gpu_mem=font_ocr.get("gpu_mem", 500),
-            gpu_id=font_ocr.get("gpu_id", None),
-            ocr_weight=font_ocr.get("ocr_weight", 0.6),
-            vec_weight=font_ocr.get("vec_weight", 0.4),
-            mode=site_cfg.get("mode", "session"),
         )
 
     def get_exporter_config(self) -> ExporterConfig:
         """
         Build an ExporterConfig from output and general settings.
 
-        Reads from:
-          - config["general"] for cache and raw data directories
-          - config["output"]["formats"] for which formats to generate
-          - config["output"]["naming"] for filename templates
-          - config["output"]["epub"] for EPUB-specific options
-          - config["sites"][site] for export split mode
-
         :return: An ExporterConfig instance with all fields populated.
         """
         gen = self._config.get("general", {})
@@ -158,13 +108,12 @@ class ConfigAdapter:
         fmt = out.get("formats", {})
         naming = out.get("naming", {})
         epub_opts = out.get("epub", {})
-        site_cfg = self._get_site_cfg()
         cleaner_cfg = self._dict_to_cleaner_cfg(cln)
         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"),
-            clean_text=out.get("clean_text", True),
+            clean_text=cln.get("clean_text", True),
             make_txt=fmt.get("make_txt", True),
             make_epub=fmt.get("make_epub", False),
             make_md=fmt.get("make_md", False),
@@ -172,20 +121,34 @@ class ConfigAdapter:
             append_timestamp=naming.get("append_timestamp", True),
             filename_template=naming.get("filename_template", "{title}_{author}"),
             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"),
+            include_picture=epub_opts.get("include_picture", True),
+            split_mode=self._site_cfg.get("split_mode", "book"),
             cleaner_cfg=cleaner_cfg,
         )
 
+    def get_login_config(self) -> dict[str, str]:
+        """
+        Return the subset of login fields present in current site config:
+            * `username`
+            * `password`
+            * `cookies`
+        """
+        out: dict[str, str] = {}
+        for key in ("username", "password", "cookies"):
+            val = self._site_cfg.get(key, "")
+            val = val.strip()
+            if val:
+                out[key] = val
+        return out
+
     def get_book_ids(self) -> list[BookConfig]:
         """
         Extract the list of target books from the site configuration.
 
         The site config may specify book_ids as:
-          - a single string or integer
-          - a dict with book_id and optional start_id, end_id, ignore_ids
-          - a list of the above types
+          * a single string or integer
+          * a dict with book_id and optional start_id, end_id, ignore_ids
+          * a list of the above types
 
         :return: A list of BookConfig dicts.
         :raises ValueError: if the raw book_ids is neither a str/int, dict, nor list.
@@ -216,20 +179,14 @@ class ConfigAdapter:
 
         return result
 
-    def get_log_level(self) -> LogLevel:
+    def get_log_level(self) -> str:
         """
         Retrieve the logging level from [general.debug].
 
-        Reads from config["general"]["debug"]["log_level"], defaulting to "INFO"
-        if not set or invalid.
-
-        :return: The configured LogLevel literal ("DEBUG", "INFO", "WARNING", "ERROR").
+        :return: The configured log level ("DEBUG", "INFO", "WARNING", "ERROR").
         """
         debug_cfg = self._config.get("general", {}).get("debug", {})
-        raw = debug_cfg.get("log_level") or "INFO"
-        if raw in self._ALLOWED_LOG_LEVELS:
-            return cast(LogLevel, raw)
-        return "INFO"
+        return debug_cfg.get("log_level") or "INFO"
 
     @property
     def site(self) -> str:
@@ -246,8 +203,12 @@ class ConfigAdapter:
         :param value: The new site key in config["sites"] to use.
         """
         self._site = value
+        self._site_cfg = self._get_site_cfg()
+
+    def _get_gen_cfg(self, key: str, default: T) -> T:
+        return self._site_cfg.get(key) or self._gen_cfg.get(key) or default
 
-    def _get_site_cfg(self, site: str | None = None) -> dict[str, Any]:
+    def _get_site_cfg(self) -> dict[str, Any]:
         """
         Retrieve the configuration for a specific site.
 
@@ -259,13 +220,12 @@ class ConfigAdapter:
         :param site: Optional override of the site name; defaults to self._site.
         :return: The site-specific or common configuration dict.
         """
-        site = site or self._site
-        sites_cfg = self._config.get("sites", {}) or {}
+        sites_cfg = self._config.get("sites") or {}
 
-        if site in sites_cfg:
-            return sites_cfg[site] or {}
+        if self._site in sites_cfg:
+            return sites_cfg[self._site] or {}
 
-        return sites_cfg.get("common", {}) or {}
+        return sites_cfg.get("common") or {}
 
     @staticmethod
     def _dict_to_book_cfg(data: dict[str, Any]) -> BookConfig:
@@ -306,10 +266,10 @@ class ConfigAdapter:
         title_repl = title_section.get("replace", {})
 
         title_ext = title_section.get("external", {})
-        title_ext_en = title_ext.get("enabled", False)
-        title_ext_rm_p = title_ext.get("remove_patterns", "")
-        title_ext_rp_p = title_ext.get("replace", "")
-        if title_ext_en:
+        if title_ext.get("enabled", False):
+            title_ext_rm_p = title_ext.get("remove_patterns", "")
+            title_ext_rp_p = title_ext.get("replace", "")
+
             title_remove_ext = cls._load_str_list(title_ext_rm_p)
             title_remove += title_remove_ext
 
@@ -322,11 +282,11 @@ class ConfigAdapter:
         content_repl = content_section.get("replace", {})
 
         content_ext = content_section.get("external", {})
-        content_ext_en = content_ext.get("enabled", False)
-        content_ext_rm_p = content_ext.get("remove_patterns", "")
-        content_ext_rp_p = content_ext.get("replace", "")
 
-        if content_ext_en:
+        if content_ext.get("enabled", False):
+            content_ext_rm_p = content_ext.get("remove_patterns", "")
+            content_ext_rp_p = content_ext.get("replace", "")
+
             content_remove_ext = cls._load_str_list(content_ext_rm_p)
             content_remove += content_remove_ext