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

novel_downloader/__init__.py

@@ -6,7 +6,7 @@ novel_downloader
 Core package for the Novel Downloader project.
 """
 
-__version__ = "1.5.0"
+__version__ = "2.0.1"
 
 __author__ = "Saudade Z"
 __email__ = "saudadez217@gmail.com"

novel_downloader/cli/__init__.py

@@ -6,8 +6,6 @@ novel_downloader.cli
 This module exposes the CLI entry point.
 """
 
-__all__ = [
-    "cli_main",
-]
+__all__ = ["cli_main"]
 
 from .main import cli_main

novel_downloader/cli/clean.py

@@ -6,71 +6,45 @@ novel_downloader.cli.clean
 CLI subcommands for clean resources.
 """
 
+from __future__ import annotations
+
 import shutil
 from argparse import Namespace, _SubParsersAction
 from pathlib import Path
 
+from novel_downloader.cli import ui
 from novel_downloader.utils.constants import (
     CONFIG_DIR,
     DATA_DIR,
     JS_SCRIPT_DIR,
     LOGGER_DIR,
-    MODEL_CACHE_DIR,
-    REC_CHAR_MODEL_REPO,
 )
 from novel_downloader.utils.i18n import t
 
 
 def register_clean_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    """Register the `clean` subcommand and its options."""
     parser = subparsers.add_parser("clean", help=t("help_clean"))
 
     parser.add_argument("--logs", action="store_true", help=t("clean_logs"))
     parser.add_argument("--cache", action="store_true", help=t("clean_cache"))
     parser.add_argument("--data", action="store_true", help=t("clean_data"))
     parser.add_argument("--config", action="store_true", help=t("clean_config"))
-    parser.add_argument("--models", action="store_true", help=t("clean_models"))
     parser.add_argument("--all", action="store_true", help=t("clean_all"))
     parser.add_argument("-y", "--yes", action="store_true", help=t("clean_yes"))
 
-    parser.add_argument("--hf-cache", action="store_true", help=t("clean_hf_cache"))
-    parser.add_argument(
-        "--hf-cache-all", action="store_true", help=t("clean_hf_cache_all")
-    )
-
     parser.set_defaults(func=handle_clean)
 
 
 def handle_clean(args: Namespace) -> None:
+    """Handle the `clean` subcommand."""
     targets: list[Path] = []
 
-    if args.hf_cache_all:
-        try:
-            if _clean_model_repo_cache(all=True):
-                print(t("clean_hf_cache_all_done"))
-        except Exception as e:
-            print(t("clean_hf_cache_all_fail", err=str(e)))
-    elif args.hf_cache:
-        try:
-            if _clean_model_repo_cache(repo_id=REC_CHAR_MODEL_REPO):
-                print(t("clean_hf_model_done", repo=REC_CHAR_MODEL_REPO))
-            else:
-                print(t("clean_hf_model_not_found", repo=REC_CHAR_MODEL_REPO))
-        except Exception as e:
-            print(t("clean_hf_model_fail", err=str(e)))
-
     if args.all:
-        if not args.yes:
-            confirm = prompt(t("clean_confirm"), default="n")
-            if confirm.lower() != "y":
-                print(t("clean_cancelled"))
-                return
-        targets = [
-            LOGGER_DIR,
-            JS_SCRIPT_DIR,
-            DATA_DIR,
-            CONFIG_DIR,
-            MODEL_CACHE_DIR,
-        ]
+        if not args.yes and not ui.confirm(t("clean_confirm"), default=False):
+            ui.warn(t("clean_cancelled"))
+            return
+        targets = [LOGGER_DIR, JS_SCRIPT_DIR, DATA_DIR, CONFIG_DIR]
     else:
         if args.logs:
             targets.append(LOGGER_DIR)
@@ -80,66 +54,25 @@ def handle_clean(args: Namespace) -> None:
             targets.append(DATA_DIR)
         if args.config:
             targets.append(CONFIG_DIR)
-        if args.models:
-            targets.append(MODEL_CACHE_DIR)
 
-    if not targets and not args.hf_cache and not args.hf_cache_all:
-        print(t("clean_nothing"))
+    if not targets:
+        ui.warn(t("clean_nothing"))
         return
 
     for path in targets:
         _delete_path(path)
 
 
-def prompt(message: str, default: str = "n") -> str:
-    """
-    Prompt the user for input with a default option.
-
-    :param message: The prompt message to display to the user.
-    :param default: The default value to use if the user provides no input ("y" or "n").
-    :return: The user's input (lowercased), or the default value if no input is given.
-    """
-    try:
-        full_prompt = f"{message} [{'Y/n' if default.lower() == 'y' else 'y/N'}]: "
-        response = input(full_prompt).strip().lower()
-        return response if response else default.lower()
-    except (KeyboardInterrupt, EOFError):
-        print("\n" + "Cancelled.")
-    return default.lower()
-
-
 def _delete_path(p: Path) -> None:
+    """Delete file or directory at `p`, printing a colored result line."""
     if p.exists():
-        if p.is_file():
-            p.unlink()
-        else:
-            shutil.rmtree(p, ignore_errors=True)
-        print(f"[clean] {t('clean_deleted')}: {p}")
-    else:
-        print(f"[clean] {t('clean_not_found')}: {p}")
-
-
-def _clean_model_repo_cache(
-    repo_id: str | None = None,
-    all: bool = False,
-) -> bool:
-    """
-    Delete Hugging Face cache for a specific repo.
-    """
-    from huggingface_hub import scan_cache_dir
-
-    cache_info = scan_cache_dir()
-
-    if all:
-        targets = cache_info.repos
-    elif repo_id:
-        targets = [r for r in cache_info.repos if r.repo_id == repo_id]
+        try:
+            if p.is_file():
+                p.unlink()
+            else:
+                shutil.rmtree(p, ignore_errors=True)
+            ui.success(f"[clean] {t('clean_deleted')}: {p}")
+        except Exception as e:
+            ui.error(f"[clean] {t('clean_failed', path=p)}: {p} -> {e}")
     else:
-        return False
-
-    strategy = cache_info.delete_revisions(
-        *[rev.commit_hash for r in targets for rev in r.revisions]
-    )
-    print(f"[clean] Will free {strategy.expected_freed_size_str}")
-    strategy.execute()
-    return True
+        ui.warn(f"[clean] {t('clean_not_found')}: {p}")

novel_downloader/cli/config.py

@@ -3,14 +3,17 @@
 novel_downloader.cli.config
 ---------------------------
 
-CLI subcommands for configuration management.
+CLI subcommands for configuration file management.
 """
 
+from __future__ import annotations
+
 import shutil
 from argparse import Namespace, _SubParsersAction
 from importlib.resources import as_file
 from pathlib import Path
 
+from novel_downloader.cli import ui
 from novel_downloader.config import save_config_file
 from novel_downloader.utils.constants import DEFAULT_SETTINGS_PATHS
 from novel_downloader.utils.i18n import t
@@ -18,6 +21,7 @@ from novel_downloader.utils.state import state_mgr
 
 
 def register_config_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    """Register `config` with `init`, `set-lang`, and `set-config` subcommands."""
     parser = subparsers.add_parser("config", help=t("help_config"))
     config_subparsers = parser.add_subparsers(dest="subcommand", required=True)
 
@@ -27,26 +31,30 @@ def register_config_subcommand(subparsers: _SubParsersAction) -> None:  # type:
 
 
 def _register_init(subparsers: _SubParsersAction) -> None:  # type: ignore
-    parser = subparsers.add_parser("init", help=t("settings_init_help"))
+    parser = subparsers.add_parser("init", help=t("config_init_help"))
     parser.add_argument(
-        "--force", action="store_true", help=t("settings_init_force_help")
+        "--force", action="store_true", help=t("config_init_force_help")
     )
     parser.set_defaults(func=_handle_init)
 
 
 def _register_set_lang(subparsers: _SubParsersAction) -> None:  # type: ignore
-    parser = subparsers.add_parser("set-lang", help=t("settings_set_lang_help"))
+    parser = subparsers.add_parser("set-lang", help=t("config_set_lang_help"))
     parser.add_argument("lang", choices=["zh", "en"], help="Language code")
     parser.set_defaults(func=_handle_set_lang)
 
 
 def _register_set_config(subparsers: _SubParsersAction) -> None:  # type: ignore
-    parser = subparsers.add_parser("set-config", help=t("settings_set_config_help"))
+    parser = subparsers.add_parser("set-config", help=t("config_set_config_help"))
     parser.add_argument("path", type=str, help="Path to YAML config file")
     parser.set_defaults(func=_handle_set_config)
 
 
 def _handle_init(args: Namespace) -> None:
+    """
+    Copy template settings files from package resources into the current working dir.
+    If the target file exists, optionally confirm overwrite (unless --force).
+    """
     cwd = Path.cwd()
 
     for resource in DEFAULT_SETTINGS_PATHS:
@@ -55,41 +63,38 @@ def _handle_init(args: Namespace) -> None:
 
         if target_path.exists():
             if args.force:
-                print(t("settings_init_overwrite", filename=resource.name))
+                ui.warn(t("config_init_overwrite", filename=resource.name))
             else:
-                print(t("settings_init_exists", filename=resource.name))
-                resp = (
-                    input(
-                        t("settings_init_confirm_overwrite", filename=resource.name)
-                        + " [y/N]: "
-                    )
-                    .strip()
-                    .lower()
+                ui.info(t("config_init_exists", filename=resource.name))
+                should_copy = ui.confirm(
+                    t("config_init_confirm_overwrite", filename=resource.name),
+                    default=False,
                 )
-                should_copy = resp == "y"
 
         if not should_copy:
-            print(t("settings_init_skip", filename=resource.name))
+            ui.warn(t("config_init_skip", filename=resource.name))
             continue
 
         try:
             with as_file(resource) as actual_path:
                 shutil.copy(actual_path, target_path)
-                print(t("settings_init_copy", filename=resource.name))
+                ui.success(t("config_init_copy", filename=resource.name))
         except Exception as e:
-            print(t("settings_init_error", filename=resource.name, err=str(e)))
+            ui.error(t("config_init_error", filename=resource.name, err=str(e)))
             raise
 
 
 def _handle_set_lang(args: Namespace) -> None:
+    """Set the UI language and persist in state manager."""
     state_mgr.set_language(args.lang)
-    print(t("settings_set_lang", lang=args.lang))
+    ui.success(t("config_set_lang", lang=args.lang))
 
 
 def _handle_set_config(args: Namespace) -> None:
+    """Persist a user-supplied TOML config path into the app config."""
     try:
         save_config_file(args.path)
-        print(t("settings_set_config", path=args.path))
+        ui.success(t("config_set_config", path=args.path))
     except Exception as e:
-        print(t("settings_set_config_fail", err=str(e)))
+        ui.error(t("config_set_config_fail", err=str(e)))
         raise

novel_downloader/cli/download.py

@@ -3,32 +3,28 @@
 novel_downloader.cli.download
 -----------------------------
 
-Download novels from supported sites via CLI.
+Download novels from supported sites via the CLI.
 """
 
+from __future__ import annotations
+
 import asyncio
-import getpass
 from argparse import Namespace, _SubParsersAction
 from collections.abc import Iterable
-from dataclasses import asdict
 from pathlib import Path
 from typing import Any
 
+from novel_downloader.cli import ui
 from novel_downloader.config import ConfigAdapter, load_config
-from novel_downloader.core import (
-    FetcherProtocol,
-    get_downloader,
-    get_exporter,
-    get_fetcher,
-    get_parser,
-)
+from novel_downloader.core import get_downloader, get_exporter, get_fetcher, get_parser
 from novel_downloader.models import BookConfig, LoginField
-from novel_downloader.utils.cookies import resolve_cookies
+from novel_downloader.utils.cookies import parse_cookies
 from novel_downloader.utils.i18n import t
 from novel_downloader.utils.logger import setup_logging
 
 
 def register_download_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    """Register the `download` subcommand and its options."""
     parser = subparsers.add_parser("download", help=t("help_download"))
 
     parser.add_argument("book_ids", nargs="*", help=t("download_book_ids"))
@@ -40,24 +36,30 @@ def register_download_subcommand(subparsers: _SubParsersAction) -> None:  # type
     parser.add_argument("--start", type=str, help=t("download_option_start"))
     parser.add_argument("--end", type=str, help=t("download_option_end"))
 
+    parser.add_argument(
+        "--no-export",
+        action="store_true",
+        help=t("download_option_no_export"),
+    )
+
     parser.set_defaults(func=handle_download)
 
 
 def handle_download(args: Namespace) -> None:
+    """Handle the `download` subcommand."""
     site: str = args.site
     config_path: Path | None = Path(args.config) if args.config else None
     book_ids: list[BookConfig] = _cli_args_to_book_configs(
-        args.book_ids,
-        args.start,
-        args.end,
+        args.book_ids, args.start, args.end
     )
+    no_export: bool = getattr(args, "no_export", False)
 
-    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)
@@ -66,21 +68,21 @@ def handle_download(args: Namespace) -> None:
         try:
             book_ids = adapter.get_book_ids()
         except Exception as e:
-            print(t("download_fail_get_ids", err=str(e)))
+            ui.error(t("download_fail_get_ids", err=str(e)))
             return
 
     valid_books = _filter_valid_book_configs(book_ids)
 
     if not book_ids:
-        print(t("download_no_ids"))
+        ui.warn(t("download_no_ids"))
         return
 
     if not valid_books:
-        print(t("download_only_example", example="0000000000"))
-        print(t("download_edit_config"))
+        ui.warn(t("download_only_example", example="0000000000"))
+        ui.info(t("download_edit_config"))
         return
 
-    asyncio.run(_download(adapter, site, valid_books))
+    asyncio.run(_download(adapter, site, valid_books, no_export=no_export))
 
 
 def _cli_args_to_book_configs(
@@ -89,14 +91,13 @@ def _cli_args_to_book_configs(
     end_id: str | None,
 ) -> list[BookConfig]:
     """
-    Convert CLI book_ids and optional --start/--end into a list of BookConfig.
-    Only the first book_id uses start/end; others are minimal.
+    Convert CLI arguments into a list of `BookConfig`.
+    Only the first book_id takes `start_id`/`end_id`.
     """
     if not book_ids:
         return []
 
     result: list[BookConfig] = []
-
     first: BookConfig = {"book_id": book_ids[0]}
     if start_id:
         first["start_id"] = start_id
@@ -115,9 +116,11 @@ def _filter_valid_book_configs(
     invalid_ids: Iterable[str] = ("0000000000",),
 ) -> list[BookConfig]:
     """
-    Filter a list of BookConfig:
-    - Removes entries with invalid or placeholder book_ids
-    - Deduplicates based on book_id while preserving order
+    Filter out placeholder or duplicate book IDs, preserving order.
+
+    :param books: The list to filter.
+    :param invalid_ids: A set/iterable of IDs to treat as invalid.
+    :return: De-duplicated, valid list.
     """
     seen = set(invalid_ids)
     result: list[BookConfig] = []
@@ -136,88 +139,96 @@ async def _download(
     adapter: ConfigAdapter,
     site: str,
     valid_books: list[BookConfig],
+    *,
+    no_export: bool = False,
 ) -> None:
+    """
+    Perform the download flow:
+      * Init components
+      * Login if required
+      * Download each requested book
+      * Export with configured exporter
+    """
     downloader_cfg = adapter.get_downloader_config()
     fetcher_cfg = adapter.get_fetcher_config()
     parser_cfg = adapter.get_parser_config()
     exporter_cfg = adapter.get_exporter_config()
+    login_cfg = adapter.get_login_config()
     log_level = adapter.get_log_level()
+    setup_logging(console_level=log_level)
 
     parser = get_parser(site, parser_cfg)
-    exporter = get_exporter(site, exporter_cfg)
-    setup_logging(log_level=log_level)
+    exporter = None
+    if not no_export:
+        exporter = get_exporter(site, exporter_cfg)
+    else:
+        ui.info(t("download_export_skipped"))
 
     async with get_fetcher(site, fetcher_cfg) as fetcher:
         if downloader_cfg.login_required and not await fetcher.load_state():
-            login_data = await _prompt_login_fields(
-                fetcher, fetcher.login_fields, downloader_cfg
-            )
+            login_data = await _prompt_login_fields(fetcher.login_fields, login_cfg)
             if not await fetcher.login(**login_data):
-                print(t("download_login_failed"))
+                ui.error(t("download_login_failed"))
                 return
             await fetcher.save_state()
 
         downloader = get_downloader(
-            fetcher=fetcher,
-            parser=parser,
-            site=site,
-            config=downloader_cfg,
+            fetcher=fetcher, parser=parser, site=site, config=downloader_cfg
         )
 
         for book in valid_books:
-            print(t("download_downloading", book_id=book["book_id"], site=site))
-            await downloader.download(
-                book,
-                progress_hook=_print_progress,
-            )
-            await asyncio.to_thread(exporter.export, book["book_id"])
+            ui.info(t("download_downloading", book_id=book["book_id"], site=site))
+            await downloader.download(book, progress_hook=_print_progress)
+
+            if not no_export and exporter is not None:
+                await asyncio.to_thread(exporter.export, book["book_id"])
 
         if downloader_cfg.login_required and fetcher.is_logged_in:
             await fetcher.save_state()
 
 
 async def _prompt_login_fields(
-    fetcher: FetcherProtocol,
     fields: list[LoginField],
-    cfg: Any = None,
+    login_config: dict[str, str] | None = None,
 ) -> dict[str, Any]:
+    """
+    Prompt for required login fields, honoring defaults and config-provided values.
+
+    :param fields: Field descriptors from the fetcher (name/label/type/etc.).
+    :param login_config: Optional values already configured by the user.
+    :return: A dict suitable to pass to `fetcher.login(**kwargs)`.
+    """
+    login_config = login_config or {}
     result: dict[str, Any] = {}
-    cfg_dict = asdict(cfg) if cfg else {}
 
     for field in fields:
-        print(f"\n{field.label} ({field.name})")
+        ui.info(f"\n{field.label} ({field.name})")
         if field.description:
-            print(f"{t('login_description')}: {field.description}")
+            ui.info(f"{t('login_description')}: {field.description}")
         if field.placeholder:
-            print(f"{t('login_hint')}: {field.placeholder}")
+            ui.info(f"{t('login_hint')}: {field.placeholder}")
 
-        if field.type == "manual_login":
-            await fetcher.set_interactive_mode(True)
-            input(t("login_manual_prompt"))
-            await fetcher.set_interactive_mode(False)
-            continue
-
-        existing_value = cfg_dict.get(field.name, "").strip()
+        existing_value = login_config.get(field.name, "").strip()
         if existing_value:
             result[field.name] = existing_value
-            print(t("login_use_config"))
+            ui.info(t("login_use_config"))
             continue
 
-        value: str | dict[str, str]
-        while True:
+        value: str | dict[str, str] = ""
+        for _ in range(5):
             if field.type == "password":
-                value = getpass.getpass(t("login_enter_password"))
+                value = ui.prompt_password(t("login_enter_password"))
             elif field.type == "cookie":
-                value = input(t("login_enter_cookie"))
-                value = resolve_cookies(value)
+                value = ui.prompt(t("login_enter_cookie"))
+                value = parse_cookies(value)
             else:
-                value = input(t("login_enter_value"))
+                value = ui.prompt(t("login_enter_value"))
 
             if not value and field.default:
                 value = field.default
 
             if not value and field.required:
-                print(t("login_required_field"))
+                ui.warn(t("login_required_field"))
             else:
                 break
 
@@ -227,5 +238,7 @@ async def _prompt_login_fields(
 
 
 async def _print_progress(done: int, total: int) -> None:
-    percent = done / total * 100
-    print(f"下载进度: {done}/{total} 章 ({percent:.2f}%)")
+    """Progress hook passed into the downloader."""
+    ui.print_progress(
+        done, total, prefix=t("download_progress_prefix"), unit="chapters"
+    )

novel_downloader/cli/export.py

@@ -3,11 +3,15 @@
 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 import get_exporter
 from novel_downloader.utils.i18n import t
@@ -15,13 +19,10 @@ 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"],
@@ -29,52 +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)
+    setup_logging(console_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)))