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

novel_downloader/cli/export.py

@@ -3,24 +3,26 @@
 novel_downloader.cli.export
 ---------------------------
 
+Export existing books into TXT/EPUB formats.
 """
 
+from __future__ import annotations
+
 from argparse import Namespace, _SubParsersAction
 from pathlib import Path
 
+from novel_downloader.cli import ui
 from novel_downloader.config import ConfigAdapter, load_config
-from novel_downloader.core.factory import get_exporter
+from novel_downloader.core import get_exporter
 from novel_downloader.utils.i18n import t
+from novel_downloader.utils.logger import setup_logging
 
 
 def register_export_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    """Register the `export` subcommand and its options."""
     parser = subparsers.add_parser("export", help=t("help_export"))
 
-    parser.add_argument(
-        "book_ids",
-        nargs="+",
-        help=t("download_book_ids"),
-    )
+    parser.add_argument("book_ids", nargs="+", help=t("download_book_ids"))
     parser.add_argument(
         "--format",
         choices=["txt", "epub", "all"],
@@ -28,50 +30,47 @@ def register_export_subcommand(subparsers: _SubParsersAction) -> None:  # type:
         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"),
+        "--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:
+    """Handle the `export` subcommand."""
     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))
+    ui.info(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)))
+        ui.error(t("download_config_load_fail", err=str(e)))
         return
 
     adapter = ConfigAdapter(config=config_data, site=site)
     exporter_cfg = adapter.get_exporter_config()
+    log_level = adapter.get_log_level()
     exporter = get_exporter(site, exporter_cfg)
+    setup_logging(log_level=log_level)
 
     for book_id in book_ids:
-        print(t("export_processing", book_id=book_id, format=export_format))
+        ui.info(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))
+                ui.success(t("export_success_txt", book_id=book_id))
             except Exception as e:
-                print(t("export_failed_txt", book_id=book_id, err=str(e)))
+                ui.error(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))
+                ui.success(t("export_success_epub", book_id=book_id))
             except Exception as e:
-                print(t("export_failed_epub", book_id=book_id, err=str(e)))
+                ui.error(t("export_failed_epub", book_id=book_id, err=str(e)))

novel_downloader/cli/main.py

@@ -14,16 +14,18 @@ from .clean import register_clean_subcommand
 from .config import register_config_subcommand
 from .download import register_download_subcommand
 from .export import register_export_subcommand
+from .search import register_search_subcommand
 
 
 def cli_main() -> None:
-    parser = argparse.ArgumentParser(description=t("cli_help"))
+    parser = argparse.ArgumentParser(description=t("help_cli"))
     subparsers = parser.add_subparsers(dest="command", required=True)
 
     register_clean_subcommand(subparsers)
     register_config_subcommand(subparsers)
     register_download_subcommand(subparsers)
     register_export_subcommand(subparsers)
+    register_search_subcommand(subparsers)
 
     args = parser.parse_args()
     if hasattr(args, "func"):

novel_downloader/cli/search.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+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
+from novel_downloader.models import BookConfig, SearchResult
+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("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(
+        "--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("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:
+    """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:
+        ui.error(t("download_config_load_fail", err=str(e)))
+        return
+
+    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:
+            return
+
+        adapter = ConfigAdapter(config=config_data, site=chosen["site"])
+        books: list[BookConfig] = [{"book_id": chosen["book_id"]}]
+        await _download(adapter, chosen["site"], books)
+
+    asyncio.run(_run())
+
+
+def _prompt_user_select(results: Sequence[SearchResult]) -> SearchResult | None:
+    """
+    Show a Rich table of results and ask the user to pick one by index.
+
+    :param results: A sequence of SearchResult dicts.
+    :return: The chosen SearchResult, or None if cancelled/no results.
+    """
+    if not results:
+        ui.warn(t("no_results"))
+        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,24 +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
-- Configuration dataclasses: RequesterConfig, DownloaderConfig, etc.
 """
 
-from .adapter import ConfigAdapter
-from .loader import load_config, save_config_file
-from .site_rules import (
-    load_site_rules,
-    save_rules_as_json,
-)
-
 __all__ = [
+    "get_config_value",
     "load_config",
+    "save_config",
     "save_config_file",
     "ConfigAdapter",
-    "load_site_rules",
-    "save_rules_as_json",
 ]
+
+from .adapter import ConfigAdapter
+from .file_io import (
+    get_config_value,
+    load_config,
+    save_config,
+    save_config_file,
+)