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

novel_downloader/__init__.py

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

novel_downloader/cli/clean.py

@@ -1,15 +1,15 @@
 #!/usr/bin/env python3
 """
 novel_downloader.cli.clean
------------------------------
+--------------------------
 
+CLI subcommands for clean resources.
 """
 
 import shutil
+from argparse import Namespace, _SubParsersAction
 from pathlib import Path
 
-import click
-
 from novel_downloader.utils.constants import (
     CONFIG_DIR,
     DATA_DIR,
@@ -21,18 +21,108 @@ from novel_downloader.utils.constants import (
 from novel_downloader.utils.i18n import t
 
 
-def delete_path(p: Path) -> None:
+def register_clean_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    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:
+    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,
+        ]
+    else:
+        if args.logs:
+            targets.append(LOGGER_DIR)
+        if args.cache:
+            targets.append(JS_SCRIPT_DIR)
+        if args.data:
+            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"))
+        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:
     if p.exists():
         if p.is_file():
             p.unlink()
         else:
             shutil.rmtree(p, ignore_errors=True)
-        click.echo(f"[clean] {t('clean_deleted')}: {p}")
+        print(f"[clean] {t('clean_deleted')}: {p}")
     else:
-        click.echo(f"[clean] {t('clean_not_found')}: {p}")
+        print(f"[clean] {t('clean_not_found')}: {p}")
 
 
-def clean_model_repo_cache(repo_id: str | None = None, all: bool = False) -> bool:
+def _clean_model_repo_cache(
+    repo_id: str | None = None,
+    all: bool = False,
+) -> bool:
     """
     Delete Hugging Face cache for a specific repo.
     """
@@ -53,74 +143,3 @@ def clean_model_repo_cache(repo_id: str | None = None, all: bool = False) -> boo
     print(f"[clean] Will free {strategy.expected_freed_size_str}")
     strategy.execute()
     return True
-
-
-@click.command(name="clean", help=t("help_clean"))  # type: ignore
-@click.option("--logs", is_flag=True, help=t("clean_logs"))  # type: ignore
-@click.option("--cache", is_flag=True, help=t("clean_cache"))  # type: ignore
-@click.option("--data", is_flag=True, help=t("clean_data"))  # type: ignore
-@click.option("--config", is_flag=True, help=t("clean_config"))  # type: ignore
-@click.option("--models", is_flag=True, help=t("clean_models"))  # type: ignore
-@click.option("--hf-cache", is_flag=True, help=t("clean_hf_cache"))  # type: ignore
-@click.option("--hf-cache-all", is_flag=True, help=t("clean_hf_cache_all"))  # type: ignore
-@click.option("--all", is_flag=True, help=t("clean_all"))  # type: ignore
-@click.option("--yes", is_flag=True, help=t("clean_yes"))  # type: ignore
-def clean_cli(
-    logs: bool,
-    cache: bool,
-    data: bool,
-    config: bool,
-    models: bool,
-    hf_cache: bool,
-    hf_cache_all: bool,
-    all: bool,
-    yes: bool,
-) -> None:
-    targets: list[Path] = []
-
-    if all:
-        if not yes:
-            confirm = click.prompt(t("clean_confirm"), default="n")
-            if confirm.lower() != "y":
-                click.echo(t("clean_cancelled"))
-                return
-        targets = [
-            LOGGER_DIR,
-            JS_SCRIPT_DIR,
-            DATA_DIR,
-            CONFIG_DIR,
-            MODEL_CACHE_DIR,
-        ]
-    else:
-        if logs:
-            targets.append(LOGGER_DIR)
-        if cache:
-            targets.append(JS_SCRIPT_DIR)
-        if data:
-            targets.append(DATA_DIR)
-        if config:
-            targets.append(CONFIG_DIR)
-        if models:
-            targets.append(MODEL_CACHE_DIR)
-
-    if hf_cache_all:
-        try:
-            if clean_model_repo_cache(all=True):
-                click.echo(t("clean_hf_cache_all_done"))
-        except Exception as e:
-            click.echo(t("clean_hf_cache_all_fail", err=e))
-    elif hf_cache:
-        try:
-            if clean_model_repo_cache(REC_CHAR_MODEL_REPO):
-                click.echo(t("clean_hf_model_done", repo=REC_CHAR_MODEL_REPO))
-            else:
-                click.echo(t("clean_hf_model_not_found", repo=REC_CHAR_MODEL_REPO))
-        except Exception as e:
-            click.echo(t("clean_hf_model_fail", err=e))
-
-    if not targets and not hf_cache and not hf_cache_all:
-        click.echo(t("clean_nothing"))
-        return
-
-    for path in targets:
-        delete_path(path)

novel_downloader/cli/config.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.cli.config
+---------------------------
+
+CLI subcommands for configuration management.
+"""
+
+import shutil
+from argparse import Namespace, _SubParsersAction
+from importlib.resources import as_file
+from pathlib import Path
+
+from novel_downloader.config import save_config_file, save_rules_as_json
+from novel_downloader.utils.constants import DEFAULT_SETTINGS_PATHS
+from novel_downloader.utils.i18n import t
+from novel_downloader.utils.logger import setup_logging
+from novel_downloader.utils.state import state_mgr
+
+# from novel_downloader.utils.hash_store import img_hash_store
+
+
+def register_config_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    parser = subparsers.add_parser("config", help=t("help_config"))
+    config_subparsers = parser.add_subparsers(dest="subcommand", required=True)
+
+    _register_init(config_subparsers)
+    _register_set_lang(config_subparsers)
+    _register_set_config(config_subparsers)
+    _register_update_rules(config_subparsers)
+    _register_set_cookies(config_subparsers)
+    # _register_add_hash(config_subparsers)
+
+
+def _register_init(subparsers: _SubParsersAction) -> None:  # type: ignore
+    parser = subparsers.add_parser("init", help=t("settings_init_help"))
+    parser.add_argument(
+        "--force", action="store_true", help=t("settings_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.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.add_argument("path", type=str, help="Path to YAML config file")
+    parser.set_defaults(func=_handle_set_config)
+
+
+def _register_update_rules(subparsers: _SubParsersAction) -> None:  # type: ignore
+    parser = subparsers.add_parser("update-rules", help=t("settings_update_rules_help"))
+    parser.add_argument("path", type=str, help="Path to TOML/YAML/JSON rule file")
+    parser.set_defaults(func=_handle_update_rules)
+
+
+def _register_set_cookies(subparsers: _SubParsersAction) -> None:  # type: ignore
+    parser = subparsers.add_parser("set-cookies", help=t("settings_set_cookies_help"))
+    parser.add_argument("site", nargs="?", help="Site identifier")
+    parser.add_argument("cookies", nargs="?", help="Cookies string")
+    parser.set_defaults(func=_handle_set_cookies)
+
+
+# def _register_add_hash(subparsers: _SubParsersAction) -> None:  # type: ignore
+#     parser = subparsers.add_parser("add-hash", help=t("settings_add_hash_help"))
+#     parser.add_argument("--path", type=str, help=t("settings_add_hash_path_help"))
+#     parser.set_defaults(func=_handle_add_hash)
+
+
+def _handle_init(args: Namespace) -> None:
+    setup_logging()
+    cwd = Path.cwd()
+
+    for resource in DEFAULT_SETTINGS_PATHS:
+        target_path = cwd / resource.name
+        should_copy = True
+
+        if target_path.exists():
+            if args.force:
+                print(t("settings_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()
+                )
+                should_copy = resp == "y"
+
+        if not should_copy:
+            print(t("settings_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))
+        except Exception as e:
+            print(t("settings_init_error", filename=resource.name, err=str(e)))
+            raise
+
+
+def _handle_set_lang(args: Namespace) -> None:
+    state_mgr.set_language(args.lang)
+    print(t("settings_set_lang", lang=args.lang))
+
+
+def _handle_set_config(args: Namespace) -> None:
+    try:
+        save_config_file(args.path)
+        print(t("settings_set_config", path=args.path))
+    except Exception as e:
+        print(t("settings_set_config_fail", err=str(e)))
+        raise
+
+
+def _handle_update_rules(args: Namespace) -> None:
+    try:
+        save_rules_as_json(args.path)
+        print(t("settings_update_rules", path=args.path))
+    except Exception as e:
+        print(t("settings_update_rules_fail", err=str(e)))
+        raise
+
+
+def _handle_set_cookies(args: Namespace) -> None:
+    site = args.site or input(t("settings_set_cookies_prompt_site") + ": ").strip()
+    cookies = (
+        args.cookies or input(t("settings_set_cookies_prompt_payload") + ": ").strip()
+    )
+
+    try:
+        state_mgr.set_cookies(site, cookies)
+        print(t("settings_set_cookies_success", site=site))
+    except Exception as e:
+        print(t("settings_set_cookies_fail", err=str(e)))
+        raise
+
+
+# def _handle_add_hash(args: Namespace) -> None:
+#     if args.path:
+#         try:
+#             img_hash_store.add_from_map(args.path)
+#             img_hash_store.save()
+#             print(t("settings_add_hash_loaded", path=args.path))
+#         except Exception as e:
+#             print(t("settings_add_hash_load_fail", err=str(e)))
+#             raise
+#     else:
+#         print(t("settings_add_hash_prompt_tip"))
+#         while True:
+#             img_path = input(t("settings_add_hash_prompt_img") + ": ").strip()
+#             if not img_path or img_path.lower() in {"exit", "quit"}:
+#                 break
+#             if not Path(img_path).exists():
+#                 print(t("settings_add_hash_path_invalid"))
+#                 continue
+
+#             label = input(t("settings_add_hash_prompt_label") + ": ").strip()
+#             if not label or label.lower() in {"exit", "quit"}:
+#                 break
+
+#             try:
+#                 img_hash_store.add_image(img_path, label)
+#                 print(t("settings_add_hash_added", img=img_path, label=label))
+#             except Exception as e:
+#                 print(t("settings_add_hash_failed", err=str(e)))
+
+#         img_hash_store.save()
+#         print(t("settings_add_hash_saved"))

novel_downloader/cli/download.py

@@ -3,126 +3,171 @@
 novel_downloader.cli.download
 -----------------------------
 
-Download full novels by book IDs
-(supports config files, site switching, and localization prompts).
+Download novels from supported sites via CLI.
 """
 
 import asyncio
-
-import click
-from click import Context
+import getpass
+from argparse import Namespace, _SubParsersAction
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
 
 from novel_downloader.config import ConfigAdapter, load_config
 from novel_downloader.core.factory import (
-    get_async_downloader,
-    get_async_requester,
-    # get_downloader,
+    get_downloader,
+    get_exporter,
+    get_fetcher,
     get_parser,
-    # get_requester,
-    get_saver,
-    get_sync_downloader,
-    get_sync_requester,
 )
+from novel_downloader.core.interfaces import FetcherProtocol
+from novel_downloader.models import LoginField
+from novel_downloader.utils.cookies import resolve_cookies
 from novel_downloader.utils.i18n import t
 from novel_downloader.utils.logger import setup_logging
 
 
-@click.command(
-    name="download",
-    help=t("download_help"),
-    short_help=t("download_short_help"),
-)  # type: ignore
-@click.argument("book_ids", nargs=-1)  # type: ignore
-@click.option(
-    "--site",
-    default="qidian",
-    show_default=True,
-    help=t("download_option_site", default="qidian"),
-)  # type: ignore
-@click.pass_context  # type: ignore
-def download_cli(ctx: Context, book_ids: list[str], site: str) -> None:
-    """Download full novels by book IDs."""
-    config_path = ctx.obj.get("config_path")
-
-    click.echo(t("download_using_config", path=config_path))
-    click.echo(t("download_site_info", site=site))
-
-    config_data = load_config(config_path)
-    adapter = ConfigAdapter(config=config_data, site=site)
+def register_download_subcommand(subparsers: _SubParsersAction) -> None:  # type: ignore
+    parser = subparsers.add_parser("download", help=t("help_download"))
+
+    parser.add_argument("book_ids", nargs="*", help=t("download_book_ids"))
+    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_download)
 
-    # Retrieve each sub-component's configuration from the adapter
-    requester_cfg = adapter.get_requester_config()
-    downloader_cfg = adapter.get_downloader_config()
-    parser_cfg = adapter.get_parser_config()
-    saver_cfg = adapter.get_saver_config()
 
-    click.echo(t("download_site_mode", mode=downloader_cfg.mode))
+def handle_download(args: Namespace) -> None:
+    setup_logging()
+
+    site: str = args.site
+    config_path: Path | None = Path(args.config) if args.config else None
+    book_ids: list[str] = args.book_ids or []
+
+    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)
 
-    # If no book_ids provided on the command line, try to load them from config
     if not book_ids:
         try:
             book_ids = adapter.get_book_ids()
         except Exception as e:
-            click.echo(t("download_fail_get_ids", err=e))
+            print(t("download_fail_get_ids", err=str(e)))
             return
 
-    # Filter out placeholder/example IDs
     invalid_ids = {"0000000000"}
     valid_book_ids = set(book_ids) - invalid_ids
 
     if not book_ids:
-        click.echo(t("download_no_ids"))
+        print(t("download_no_ids"))
         return
 
     if not valid_book_ids:
-        click.echo(t("download_only_example", example="0000000000"))
-        click.echo(t("download_edit_config"))
+        print(t("download_only_example", example="0000000000"))
+        print(t("download_edit_config"))
         return
 
-    # Initialize the requester, parser, saver, and downloader components
-    if downloader_cfg.mode == "async":
-        setup_logging()
-
-        async def async_download_all() -> None:
-            async_requester = get_async_requester(site, requester_cfg)
-            async_parser = get_parser(site, parser_cfg)
-            async_saver = get_saver(site, saver_cfg)
-            async_downloader = get_async_downloader(
-                requester=async_requester,
-                parser=async_parser,
-                saver=async_saver,
-                site=site,
-                config=downloader_cfg,
-            )
+    asyncio.run(_download(adapter, site, valid_book_ids))
+
+
+async def _download(
+    adapter: ConfigAdapter,
+    site: str,
+    valid_book_ids: set[str],
+) -> None:
+    downloader_cfg = adapter.get_downloader_config()
+    fetcher_cfg = adapter.get_fetcher_config()
+    parser_cfg = adapter.get_parser_config()
+    exporter_cfg = adapter.get_exporter_config()
+
+    parser = get_parser(site, parser_cfg)
+    exporter = get_exporter(site, exporter_cfg)
+    setup_logging()
 
-            prepare = getattr(async_downloader, "prepare", None)
-            if prepare and asyncio.iscoroutinefunction(prepare):
-                await prepare()
-
-            for book_id in valid_book_ids:
-                click.echo(t("download_downloading", book_id=book_id, site=site))
-                await async_downloader.download_one(book_id)
-
-            await async_requester.close()
-
-        asyncio.run(async_download_all())
-    else:
-        sync_requester = get_sync_requester(site, requester_cfg)
-        sync_parser = get_parser(site, parser_cfg)
-        sync_saver = get_saver(site, saver_cfg)
-        setup_logging()
-        sync_downloader = get_sync_downloader(
-            requester=sync_requester,
-            parser=sync_parser,
-            saver=sync_saver,
+    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
+            )
+            if not await fetcher.login(**login_data):
+                print(t("download_login_failed"))
+                return
+            await fetcher.save_state()
+
+        downloader = get_downloader(
+            fetcher=fetcher,
+            parser=parser,
+            exporter=exporter,
             site=site,
             config=downloader_cfg,
         )
 
         for book_id in valid_book_ids:
-            click.echo(t("download_downloading", book_id=book_id, site=site))
-            sync_downloader.download_one(book_id)
-
-        sync_requester.close()
-
-    return
+            print(t("download_downloading", book_id=book_id, site=site))
+            await downloader.download(book_id, progress_hook=_print_progress)
+
+        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,
+) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    cfg_dict = asdict(cfg) if cfg else {}
+
+    for field in fields:
+        print(f"\n{field.label} ({field.name})")
+        if field.description:
+            print(f"{t('login_description')}: {field.description}")
+        if field.placeholder:
+            print(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()
+        if existing_value:
+            result[field.name] = existing_value
+            print(t("login_use_config"))
+            continue
+
+        value: str | dict[str, str]
+        while True:
+            if field.type == "password":
+                value = getpass.getpass(t("login_enter_password"))
+            elif field.type == "cookie":
+                value = input(t("login_enter_cookie"))
+                value = resolve_cookies(value)
+            else:
+                value = input(t("login_enter_value"))
+
+            if not value and field.default:
+                value = field.default
+
+            if not value and field.required:
+                print(t("login_required_field"))
+            else:
+                break
+
+        result[field.name] = value
+
+    return result
+
+
+async def _print_progress(done: int, total: int) -> None:
+    percent = done / total * 100
+    print(f"下载进度: {done}/{total} 章 ({percent:.2f}%)")