novel-downloader 1.1.0__py3-none-any.whl

novel_downloader/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader
+----------------
+
+Core package for the Novel Downloader project.
+"""
+
+__version__ = "1.1.0"
+
+__author__ = "Saudade Z"
+__email__ = "saudadez217@gmail.com"
+__license__ = "MIT"

novel_downloader/cli/__init__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.cli
+--------------------
+
+This module exposes the CLI entry point.
+"""
+
+from .main import cli_main
+
+__all__ = [
+    "cli_main",
+]

novel_downloader/cli/clean.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.cli.clean
+-----------------------------
+
+"""
+
+import shutil
+from pathlib import Path
+from typing import List, Optional
+
+import click
+
+from novel_downloader.utils.constants import (
+    CONFIG_DIR,
+    DATA_DIR,
+    JS_SCRIPT_DIR,
+    LOGGER_DIR,
+    MODEL_CACHE_DIR,
+    REC_CHAR_MODEL_REPO,
+    STATE_DIR,
+)
+from novel_downloader.utils.i18n import t
+
+
+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}")
+    else:
+        click.echo(f"[clean] {t('clean_not_found')}: {p}")
+
+
+def clean_model_repo_cache(repo_id: Optional[str] = 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]
+    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
+
+
+@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("--state", is_flag=True, help=t("clean_state"))  # 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,
+    state: 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,
+            STATE_DIR,
+            DATA_DIR,
+            CONFIG_DIR,
+            MODEL_CACHE_DIR,
+        ]
+    else:
+        if logs:
+            targets.append(LOGGER_DIR)
+        if cache:
+            targets.append(JS_SCRIPT_DIR)
+        if state:
+            targets.append(STATE_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/download.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.cli.download
+-----------------------------
+
+Download full novels by book IDs
+(supports config files, site switching, and localization prompts).
+"""
+
+from typing import List
+
+import click
+from click import Context
+
+from novel_downloader.config import ConfigAdapter, load_config
+from novel_downloader.core.factory import (
+    get_async_downloader,
+    get_async_requester,
+    # get_downloader,
+    get_parser,
+    # get_requester,
+    get_saver,
+    get_sync_downloader,
+    get_sync_requester,
+)
+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)
+
+    # 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()
+
+    # 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))
+            return
+
+    # Filter out placeholder/example IDs
+    invalid_ids = {"0000000000"}
+    valid_book_ids = [bid for bid in book_ids if bid not in invalid_ids]
+
+    if not book_ids:
+        click.echo(t("download_no_ids"))
+        return
+
+    if not valid_book_ids:
+        click.echo(t("download_only_example", example="0000000000"))
+        click.echo(t("download_edit_config"))
+        return
+
+    # Initialize the requester, parser, saver, and downloader components
+    if downloader_cfg.mode == "async":
+        import asyncio
+
+        async_requester = get_async_requester(site, requester_cfg)
+        async_parser = get_parser(site, parser_cfg)
+        async_saver = get_saver(site, saver_cfg)
+        setup_logging()
+        async_downloader = get_async_downloader(
+            requester=async_requester,
+            parser=async_parser,
+            saver=async_saver,
+            site=site,
+            config=downloader_cfg,
+        )
+
+        async def async_download_all() -> None:
+            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)
+
+            if requester_cfg.auto_close:
+                input(t("download_prompt_parse"))
+                await async_requester.shutdown()
+
+        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,
+            site=site,
+            config=downloader_cfg,
+        )
+
+        for book_id in book_ids:
+            click.echo(t("download_downloading", book_id=book_id, site=site))
+            sync_downloader.download_one(book_id)
+
+        if requester_cfg.auto_close:
+            input(t("download_prompt_parse"))
+            sync_requester.shutdown()
+
+    return

novel_downloader/cli/interactive.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.cli.interactive
+--------------------------------
+
+Interactive CLI mode for novel_downloader.
+Supports multilingual prompt, input validation, and quit control.
+"""
+
+import click
+from click import Context
+
+from novel_downloader.cli.download import download_cli
+from novel_downloader.utils.i18n import t
+
+
+@click.group(  # type: ignore
+    name="interactive", help=t("interactive_help"), invoke_without_command=True
+)
+@click.pass_context  # type: ignore
+def interactive_cli(ctx: Context) -> None:
+    """Interactive mode for novel selection and preview."""
+    if ctx.invoked_subcommand is None:
+        click.echo(t("interactive_no_sub"))
+
+        options = [
+            t("interactive_option_download"),
+            t("interactive_option_browse"),
+            t("interactive_option_preview"),
+            t("interactive_option_exit"),
+        ]
+        for idx, opt in enumerate(options, 1):
+            click.echo(f"{idx}. {opt}")
+
+        choice = click.prompt(t("interactive_prompt_choice"), type=int)
+
+        if choice == 1:
+            default_site = "qidian"
+            site: str = click.prompt(
+                t("download_option_site", default=default_site),
+                default_site,
+            )
+            ids_input: str = click.prompt(t("interactive_prompt_book_ids"))
+            book_ids = ids_input.strip().split()
+            ctx.invoke(download_cli, book_ids=book_ids, site=site)
+        elif choice == 2:
+            ctx.invoke(browse)
+        elif choice == 3:
+            ctx.invoke(preview)
+        else:
+            click.echo(t("interactive_exit"))
+            return
+
+
+@interactive_cli.command(help=t("interactive_browse_help"))  # type: ignore
+@click.pass_context  # type: ignore
+def browse(ctx: Context) -> None:
+    """Browse available novels interactively."""
+    click.echo(t("interactive_browse_start"))
+
+
+@interactive_cli.command(help=t("interactive_preview_help"))  # type: ignore
+@click.pass_context  # type: ignore
+def preview(ctx: Context) -> None:
+    """Preview chapters before downloading."""
+    click.echo(t("interactive_preview_start"))

novel_downloader/cli/main.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.cli.main
+--------------------------
+
+Unified CLI entry point. Parses arguments and delegates to parser or interactive.
+"""
+
+from typing import Optional
+
+import click
+from click import Context
+
+from novel_downloader.cli import clean, download, interactive, settings
+from novel_downloader.utils.i18n import t
+
+
+@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: Optional[str]) -> 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)
+
+
+if __name__ == "__main__":
+    cli_main()

novel_downloader/cli/settings.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.cli.settings
+-----------------------------
+
+Commands to configure novel downloader settings.
+"""
+
+import shutil
+from importlib.resources import as_file
+from pathlib import Path
+from typing import Optional
+
+import click
+from click import Context
+
+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
+
+
+@click.group(name="settings", help=t("settings_help"))  # type: ignore
+def settings_cli() -> None:
+    """Configure downloader settings."""
+    setup_logging()
+    pass
+
+
+@settings_cli.command(name="init", help=t("settings_init_help"))  # type: ignore
+@click.option("--force", is_flag=True, help=t("settings_init_force_help"))  # type: ignore
+def init_settings(force: bool) -> None:
+    """Initialize default settings and rules in the current directory."""
+    cwd = Path.cwd()
+
+    for resource in DEFAULT_SETTINGS_PATHS:
+        target_path = cwd / resource.name
+        should_copy = True
+
+        if target_path.exists():
+            if force:
+                should_copy = True
+                click.echo(t("settings_init_overwrite", filename=resource.name))
+            else:
+                click.echo(t("settings_init_exists", filename=resource.name))
+                should_copy = click.confirm(
+                    t("settings_init_confirm_overwrite", filename=resource.name),
+                    default=False,
+                )
+
+        if not should_copy:
+            click.echo(t("settings_init_skip", filename=resource.name))
+            continue
+
+        try:
+            with as_file(resource) as actual_path:
+                shutil.copy(actual_path, target_path)
+                click.echo(t("settings_init_copy", filename=resource.name))
+        except Exception as e:
+            raise click.ClickException(
+                t("settings_init_error", filename=resource.name, err=e)
+            )
+
+
+@settings_cli.command(name="set-lang", help=t("settings_set_lang_help"))  # type: ignore
+@click.argument("lang", type=click.Choice(["zh", "en"]))  # type: ignore
+@click.pass_context  # type: ignore
+def set_language(ctx: Context, lang: str) -> None:
+    """Switch language between Chinese and English."""
+    state_mgr.set_language(lang)
+    click.echo(t("settings_set_lang", lang=lang))
+
+
+@settings_cli.command(name="set-config", help=t("settings_set_config_help"))  # type: ignore
+@click.argument("path", type=click.Path(exists=True, dir_okay=False, resolve_path=True))  # type: ignore
+def set_config(path: str) -> None:
+    """Set and save a custom YAML configuration file."""
+    try:
+        save_config_file(path)
+        click.echo(t("settings_set_config", path=path))
+    except Exception as e:
+        raise click.ClickException(t("settings_set_config_fail", err=e))
+
+
+@settings_cli.command(name="update-rules", help=t("settings_update_rules_help"))  # type: ignore
+@click.argument("path", type=click.Path(exists=True, dir_okay=False, resolve_path=True))  # type: ignore
+def update_rules(path: str) -> None:
+    """Update site rules from a TOML/YAML/JSON file."""
+    try:
+        save_rules_as_json(path)
+        click.echo(t("settings_update_rules", path=path))
+    except Exception as e:
+        raise click.ClickException(t("settings_update_rules_fail", err=e))
+
+
+@settings_cli.command(
+    name="set-cookies", help=t("settings_set_cookies_help")
+)  # type: ignore
+@click.argument("site", required=False)  # type: ignore
+@click.argument("cookies", required=False)  # type: ignore
+@click.pass_context  # type: ignore
+def set_cookies(ctx: Context, site: str, cookies: str) -> None:
+    """
+    Set or update cookies for a site.
+
+    :param site: Site identifier (e.g. 'qidian', 'bqg').
+                 If omitted, you will be prompted to enter it.
+    :param cookies: Cookie payload. Can be a JSON string (e.g. '{"k":"v"}')
+                    or a browser-style string 'k1=v1; k2=v2'.
+                    If omitted, you will be prompted to enter it.
+    """
+    if not site:
+        site = click.prompt(t("settings_set_cookies_prompt_site"), type=str)
+    if not cookies:
+        cookies = click.prompt(t("settings_set_cookies_prompt_payload"), type=str)
+
+    try:
+        state_mgr.set_cookies(site, cookies)
+        click.echo(t("settings_set_cookies_success", site=site))
+    except Exception as e:
+        raise click.ClickException(t("settings_set_cookies_fail", err=e))
+
+
+@settings_cli.command(name="add-hash", help=t("settings_add_hash_help"))  # type: ignore
+@click.option(
+    "--path",
+    type=click.Path(exists=True, dir_okay=False),
+    help=t("settings_add_hash_path_help"),
+)  # type: ignore
+def add_image_hashes(path: Optional[str]) -> None:
+    """
+    Add image hashes to internal store for matching.
+    Can be run in interactive mode (no --path), or with a JSON file.
+    """
+    from novel_downloader.utils.hash_store import img_hash_store
+
+    if path:
+        try:
+            img_hash_store.add_from_map(path)
+            img_hash_store.save()
+            click.echo(t("settings_add_hash_loaded", path=path))
+        except Exception as e:
+            raise click.ClickException(t("settings_add_hash_load_fail", err=str(e)))
+    else:
+        click.echo(t("settings_add_hash_prompt_tip"))
+        while True:
+            img_path = click.prompt(
+                t("settings_add_hash_prompt_img"),
+                type=str,
+                default="",
+                show_default=False,
+            ).strip()
+            if not img_path or img_path.lower() in {"exit", "quit"}:
+                break
+            if not Path(img_path).exists():
+                click.echo(t("settings_add_hash_path_invalid"))
+                continue
+
+            label = click.prompt(
+                t("settings_add_hash_prompt_label"),
+                type=str,
+                default="",
+                show_default=False,
+            ).strip()
+            if not label or label.lower() in {"exit", "quit"}:
+                break
+
+            try:
+                img_hash_store.add_image(img_path, label)
+                click.echo(t("settings_add_hash_added", img=img_path, label=label))
+            except Exception as e:
+                click.echo(t("settings_add_hash_failed", err=str(e)))
+
+        img_hash_store.save()
+        click.echo(t("settings_add_hash_saved"))

novel_downloader/config/__init__.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+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 .models import (
+    BookInfoRules,
+    DownloaderConfig,
+    FieldRules,
+    ParserConfig,
+    RequesterConfig,
+    RuleStep,
+    SaverConfig,
+    SiteProfile,
+    SiteRules,
+    SiteRulesDict,
+    VolumesRules,
+)
+from .site_rules import (
+    load_site_rules,
+    save_rules_as_json,
+)
+
+__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",
+]