novel-downloader 1.1.1__py3-none-any.whl

novel_downloader/utils/constants.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.utils.constants
+--------------------------------
+
+Constants and default paths used throughout the NovelDownloader project.
+"""
+
+from importlib.resources import files
+from pathlib import Path
+
+from platformdirs import user_config_dir
+
+# -----------------------------------------------------------------------------
+# Application identity
+# -----------------------------------------------------------------------------
+PACKAGE_NAME = "novel_downloader"  # Python package name
+APP_NAME = "NovelDownloader"  # Display name
+APP_DIR_NAME = "novel_downloader"  # Directory name for platformdirs
+LOGGER_NAME = PACKAGE_NAME  # Root logger name
+
+
+# -----------------------------------------------------------------------------
+# Base directories
+# -----------------------------------------------------------------------------
+# Base config directory (e.g. ~/AppData/Local/novel_downloader/)
+BASE_CONFIG_DIR = Path(user_config_dir(APP_DIR_NAME, appauthor=False))
+PACKAGE_ROOT: Path = Path(__file__).parent.parent
+LOCALES_DIR: Path = PACKAGE_ROOT / "locales"
+
+# Subdirectories under BASE_CONFIG_DIR
+LOGGER_DIR = BASE_CONFIG_DIR / "logs"
+JS_SCRIPT_DIR = BASE_CONFIG_DIR / "scripts"
+STATE_DIR = BASE_CONFIG_DIR / "state"
+DATA_DIR = BASE_CONFIG_DIR / "data"
+CONFIG_DIR = BASE_CONFIG_DIR / "config"
+MODEL_CACHE_DIR = BASE_CONFIG_DIR / "models"
+
+# -----------------------------------------------------------------------------
+# Default file paths
+# -----------------------------------------------------------------------------
+STATE_FILE = STATE_DIR / "state.json"
+HASH_STORE_FILE = DATA_DIR / "image_hashes.json"
+SETTING_FILE = CONFIG_DIR / "settings.json"
+SITE_RULES_FILE = CONFIG_DIR / "site_rules.json"
+DEFAULT_USER_DATA_DIR = DATA_DIR / "browser_data"
+
+
+# -----------------------------------------------------------------------------
+# Default preferences & headers
+# -----------------------------------------------------------------------------
+DEFAULT_USER_PROFILE_NAME = "Profile_1"
+DEFAULT_IMAGE_SUFFIX = ".jpg"
+
+DEFAULT_USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/134.0.0.0 Safari/537.36"
+)
+DEFAULT_HEADERS = {"User-Agent": DEFAULT_USER_AGENT}
+
+DEFAULT_ACCEPT = (
+    "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"
+)
+
+DEFAULT_USER_HEADERS = {
+    "Accept": DEFAULT_ACCEPT,
+    "Accept-Encoding": "gzip, deflate",
+    "Accept-Language": "en,zh;q=0.9,zh-CN;q=0.8",
+    "User-Agent": DEFAULT_USER_AGENT,
+    "Connection": "keep-alive",
+}
+
+# -----------------------------------------------------------------------------
+# Embedded resources (via importlib.resources)
+# -----------------------------------------------------------------------------
+BASE_CONFIG_PATH = files("novel_downloader.resources.config").joinpath("settings.yaml")
+BASE_RULE_PATH = files("novel_downloader.resources.config").joinpath("rules.toml")
+
+DEFAULT_SETTINGS_PATHS = [
+    BASE_CONFIG_PATH,
+    BASE_RULE_PATH,
+]
+
+# CSS Styles
+CSS_MAIN_PATH = files("novel_downloader.resources.css_styles").joinpath("main.css")
+CSS_VOLUME_INTRO_PATH = files("novel_downloader.resources.css_styles").joinpath(
+    "volume-intro.css"
+)
+
+# Images
+VOLUME_BORDER_IMAGE_PATH = files("novel_downloader.resources.images").joinpath(
+    "volume_border.png"
+)
+
+# JSON
+REPLACE_WORD_MAP_PATH = files("novel_downloader.resources.json").joinpath(
+    "replace_word_map.json"
+)
+
+# JavaScript
+QD_DECRYPT_SCRIPT_PATH = files("novel_downloader.resources.js_scripts").joinpath(
+    "qidian_decrypt_node.js"
+)
+
+# Text Files
+BLACKLIST_PATH = files("novel_downloader.resources.text").joinpath("blacklist.txt")
+
+# -----------------------------------------------------------------------------
+# EPUB defaults
+# -----------------------------------------------------------------------------
+EPUB_IMAGE_FOLDER = "Images"
+EPUB_TEXT_FOLDER = "Text"
+
+EPUB_OPTIONS = {
+    # guide 是 EPUB 2 的一个部分, 包含封面, 目录, 索引等重要导航信息
+    "epub2_guide": True,
+    # landmark 是 EPUB 3 用来标识重要页面 (如目录, 封面, 起始页) 的 <nav> 结构
+    "epub3_landmark": True,
+    # EPUB 3 允许提供一个 page list, 让电子书在不同设备上仍然保持相对一致的分页结构
+    "epub3_pages": True,
+    # 这个名字会出现在 EPUB 阅读器的导航栏
+    "landmark_title": "Guide",
+    # 这个名字会显示在 EPUB 阅读器的分页导航栏
+    "pages_title": "Pages",
+    # 是否根据 book.spine 的排列顺序自动设置 EPUB 阅读器的 page-progression-direction
+    "spine_direction": True,
+    # 控制 EPUB 阅读器的默认翻页方向 (LTR 或 RTL)
+    "package_direction": False,
+    # 是否为 EPUB 书籍中的章节 添加播放顺序
+    "play_order": {"enabled": True, "start_from": 1},
+}
+
+# ---------------------------------------------------------------------
+# Pretrained model registry (e.g. used in font recovery or OCR)
+# ---------------------------------------------------------------------
+
+# Hugging Face model repo for character recognition
+REC_CHAR_MODEL_REPO = "saudadez/rec_chinese_char"
+
+# Required files to be downloaded for the model
+REC_CHAR_MODEL_FILES = [
+    "inference.pdmodel",
+    "inference.pdiparams",
+    "rec_custom_keys.txt",
+    "char_freq.json",
+]
+
+REC_CHAR_VECTOR_FILES = [
+    "char_vectors.npy",
+    "char_vectors.txt",
+]
+
+REC_IMAGE_SHAPE_MAP = {
+    "v1.0": "3,32,32",
+    "v2.0": "3,48,48",
+}

novel_downloader/utils/crypto_utils.py

@@ -0,0 +1,144 @@
+"""
+novel_downloader.utils.crypto_utils
+-----------------------------------
+
+Generic cryptographic utilities
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import random
+import time
+from typing import Any, Dict, List
+
+
+def rc4_crypt(
+    key: str,
+    data: str,
+    *,
+    mode: str = "encrypt",
+    encoding: str = "utf-8",
+) -> str:
+    """
+    Encrypt or decrypt data using RC4 and Base64.
+
+    :param key: RC4 key (will be encoded using the specified encoding).
+    :type key: str
+    :param data: Plain-text (for 'encrypt') or Base64 cipher-text (for 'decrypt').
+    :type data: str
+    :param mode: Operation mode, either 'encrypt' or 'decrypt'. Defaults to 'encrypt'.
+    :type mode: str, optional
+    :param encoding: Character encoding for key and returned string. Defaults 'utf-8'.
+    :type encoding: str, optional
+
+    :return: Base64 cipher-text (for encryption) or decoded plain-text (for decryption).
+    :rtype: str
+
+    :raises ValueError: If mode is not 'encrypt' or 'decrypt'.
+    """
+
+    def _rc4(key_bytes: bytes, data_bytes: bytes) -> bytes:
+        # Key-Scheduling Algorithm (KSA)
+        S = list(range(256))
+        j = 0
+        for i in range(256):
+            j = (j + S[i] + key_bytes[i % len(key_bytes)]) % 256
+            S[i], S[j] = S[j], S[i]
+
+        # Pseudo-Random Generation Algorithm (PRGA)
+        i = j = 0
+        out: List[int] = []
+        for char in data_bytes:
+            i = (i + 1) % 256
+            j = (j + S[i]) % 256
+            S[i], S[j] = S[j], S[i]
+            K = S[(S[i] + S[j]) % 256]
+            out.append(char ^ K)
+
+        return bytes(out)
+
+    key_bytes = key.encode(encoding)
+
+    if mode == "encrypt":
+        plain_bytes = data.encode(encoding)
+        cipher_bytes = _rc4(key_bytes, plain_bytes)
+        return base64.b64encode(cipher_bytes).decode(encoding)
+
+    if mode == "decrypt":
+        cipher_bytes = base64.b64decode(data)
+        plain_bytes = _rc4(key_bytes, cipher_bytes)
+        return plain_bytes.decode(encoding, errors="replace")
+
+    raise ValueError("Mode must be 'encrypt' or 'decrypt'.")
+
+
+def _get_key() -> str:
+    encoded = "Lj1qYxMuaXBjMg=="
+    decoded = base64.b64decode(encoded)
+    key = "".join([chr(b ^ 0x5A) for b in decoded])
+    return key
+
+
+def _d(b64str: str) -> str:
+    return base64.b64decode(b64str).decode()
+
+
+def patch_qd_payload_token(
+    enc_token: str,
+    new_uri: str,
+    *,
+    key: str = "",
+) -> str:
+    """
+    Patch a timestamp-bearing token with fresh timing and checksum info.
+
+    :param enc_token: Encrypted token string from a live request.
+    :type enc_token: str
+    :param new_uri: URI used in checksum generation.
+    :type new_uri: str
+    :param key: RC4 key extracted from front-end JavaScript (optional).
+    :type key: str, optional
+
+    :return: Updated token with new timing and checksum values.
+    :rtype: str
+    """
+    if not key:
+        key = _get_key()
+
+    # Step 1 – decrypt --------------------------------------------------
+    decrypted_json: str = rc4_crypt(key, enc_token, mode="decrypt")
+    payload: Dict[str, Any] = json.loads(decrypted_json)
+
+    # Step 2 – rebuild timing fields -----------------------------------
+    loadts = int(time.time() * 1000)  # ms since epoch
+    # Simulate the JS duration: N(600, 150)  pushed into [300, 1000]
+    duration = max(300, min(1000, int(random.normalvariate(600, 150))))
+    timestamp = loadts + duration
+
+    # Step 3 – recalculate ------------------------------------
+    fp_key = _d("ZmluZ2VycHJpbnQ=")
+    ab_key = _d("YWJub3JtYWw=")
+    ck_key = _d("Y2hlY2tzdW0=")
+    lt_key = _d("bG9hZHRz")
+    ts_key = _d("dGltZXN0YW1w")
+
+    fp_val = payload.get(fp_key, "")
+    ab_val = payload.get(ab_key, "0" * 32)
+    comb = f"{new_uri}{loadts}{fp_val}"
+    ck_val = hashlib.md5(comb.encode("utf-8")).hexdigest()
+
+    new_payload = {
+        lt_key: loadts,
+        ts_key: timestamp,
+        fp_key: fp_val,
+        ab_key: ab_val,
+        ck_key: ck_val,
+    }
+
+    # Step 4 – encrypt and return --------------------------------------
+    return rc4_crypt(
+        key, json.dumps(new_payload, separators=(",", ":")), mode="encrypt"
+    )

novel_downloader/utils/file_utils/__init__.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.utils.file_utils
+---------------------------------
+
+High-level file I/O utility re-exports for convenience.
+
+This module aggregates commonly used low-level file utilities such as:
+- Path sanitization (for safe filenames)
+- Text normalization (e.g. Windows/Linux line endings)
+- JSON, plain text, and binary file reading/writing
+
+Included utilities:
+- sanitize_filename: remove invalid characters from filenames
+- normalize_txt_line_endings: standardize line endings in text files
+- save_as_json / save_as_txt: write dict or text to file
+- read_text_file / read_json_file / read_binary_file: load content from file
+"""
+
+from .io import (
+    load_blacklisted_words,
+    load_text_resource,
+    read_binary_file,
+    read_json_file,
+    read_text_file,
+    save_as_json,
+    save_as_txt,
+)
+from .normalize import normalize_txt_line_endings
+from .sanitize import sanitize_filename
+
+__all__ = [
+    "sanitize_filename",
+    "save_as_json",
+    "save_as_txt",
+    "read_text_file",
+    "read_json_file",
+    "read_binary_file",
+    "load_text_resource",
+    "load_blacklisted_words",
+    "normalize_txt_line_endings",
+]

novel_downloader/utils/file_utils/io.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.utils.file_utils.io
+------------------------------------
+
+File I/O utilities for reading and writing text, JSON, and binary data.
+
+Includes:
+- Safe, atomic file saving with optional overwrite and auto-renaming
+- JSON pretty-printing with size-aware formatting
+- Simple helpers for reading files with fallback and logging
+"""
+
+import json
+import logging
+import tempfile
+from importlib.resources import files
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Set, Union
+
+from .sanitize import sanitize_filename
+
+logger = logging.getLogger(__name__)
+
+_JSON_INDENT_THRESHOLD = 50 * 1024  # bytes
+
+
+def _get_non_conflicting_path(path: Path) -> Path:
+    """
+    If the path exists, generate a new one by appending _1, _2, etc.
+    """
+    counter = 1
+    new_path = path
+    while new_path.exists():
+        stem = path.stem
+        suffix = path.suffix
+        new_path = path.with_name(f"{stem}_{counter}{suffix}")
+        counter += 1
+    return new_path
+
+
+def _write_file(
+    content: Union[str, bytes, Dict[Any, Any], List[Any], Any],
+    filepath: Union[str, Path],
+    mode: Optional[str] = None,
+    *,
+    on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
+    dump_json: bool = False,
+    encoding: str = "utf-8",
+) -> bool:
+    """
+    Write content to a file safely with optional atomic behavior
+    and JSON serialization.
+
+    :param content: The content to write; can be text, bytes, or a
+        JSON-serializable object.
+    :param filepath: Destination path (str or Path).
+    :param mode: File mode ('w', 'wb'). Auto-determined if None.
+    :param on_exist: Behavior if file exists: 'overwrite', 'skip',
+        or 'rename'.
+    :param dump_json: If True, serialize content as JSON.
+    :param encoding: Text encoding for writing.
+    :return: True if writing succeeds, False otherwise.
+    """
+    path = Path(filepath)
+    path = path.with_name(sanitize_filename(path.name))
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if path.exists():
+        if on_exist == "skip":
+            logger.debug("[file] '%s' exists, skipping", path)
+            return False
+        if on_exist == "rename":
+            path = _get_non_conflicting_path(path)
+            logger.debug("[file] Renaming target to avoid conflict: %s", path)
+        else:
+            logger.debug("[file] '%s' exists, will overwrite", path)
+
+    # Prepare content and write mode
+    content_to_write: Union[str, bytes]
+    if dump_json:
+        # Serialize original object to JSON string
+        json_str = json.dumps(content, ensure_ascii=False, indent=2)
+        if len(json_str.encode(encoding)) > _JSON_INDENT_THRESHOLD:
+            json_str = json.dumps(content, ensure_ascii=False, separators=(",", ":"))
+        content_to_write = json_str
+        write_mode = "w"
+    else:
+        if isinstance(content, (str, bytes)):
+            content_to_write = content
+        else:
+            raise TypeError("Non-JSON content must be str or bytes.")
+        write_mode = "wb" if isinstance(content, bytes) else "w"
+
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode=write_mode,
+            encoding=None if "b" in write_mode else encoding,
+            newline=None if "b" in write_mode else "\n",
+            delete=False,
+            dir=path.parent,
+        ) as tmp:
+            tmp.write(content_to_write)
+            tmp_path = Path(tmp.name)
+        tmp_path.replace(path)
+        logger.info("[file] '%s' written successfully", path)
+        return True
+    except Exception as exc:
+        logger.warning("[file] Error writing %r: %s", path, exc)
+        return False
+
+
+def save_as_txt(
+    content: str,
+    filepath: Union[str, Path],
+    *,
+    encoding: str = "utf-8",
+    on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
+) -> bool:
+    """
+    Save plain text content to the given file path.
+
+    :param content: Text content to write.
+    :param filepath: Destination file path.
+    :param encoding: Text encoding to use (default: 'utf-8').
+    :param on_exist: How to handle existing files: 'overwrite', 'skip', or 'rename'.
+    :return: True if successful, False otherwise.
+    """
+    return _write_file(
+        content=content,
+        filepath=filepath,
+        mode="w",
+        on_exist=on_exist,
+        dump_json=False,
+        encoding=encoding,
+    )
+
+
+def save_as_json(
+    content: Any,
+    filepath: Union[str, Path],
+    *,
+    encoding: str = "utf-8",
+    on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
+) -> bool:
+    """
+    Save JSON-serializable content to the given file path.
+
+    :param content: Data to write as JSON.
+    :param filepath: Destination file path.
+    :param encoding: Text encoding to use (default: 'utf-8').
+    :param on_exist: How to handle existing files: 'overwrite', 'skip', or 'rename'.
+    :return: True if successful, False otherwise.
+    """
+    return _write_file(
+        content=content,
+        filepath=filepath,
+        mode="w",
+        on_exist=on_exist,
+        dump_json=True,
+        encoding=encoding,
+    )
+
+
+def read_text_file(
+    filepath: Union[str, Path], encoding: str = "utf-8"
+) -> Optional[str]:
+    """
+    Read a UTF-8 text file.
+
+    :param filepath: Path to file.
+    :param encoding: Encoding to use.
+    :return: Text content or None on failure.
+    """
+    path = Path(filepath)
+    try:
+        return path.read_text(encoding=encoding)
+    except Exception as e:
+        logger.warning("[file] Failed to read %r: %s", path, e)
+        return None
+
+
+def read_json_file(
+    filepath: Union[str, Path], encoding: str = "utf-8"
+) -> Optional[Any]:
+    """
+    Read a JSON file and parse it into Python objects.
+
+    :param filepath: Path to file.
+    :param encoding: Encoding to use.
+    :return: Python object or None on failure.
+    """
+    path = Path(filepath)
+    try:
+        return json.loads(path.read_text(encoding=encoding))
+    except Exception as e:
+        logger.warning("[file] Failed to read %r: %s", path, e)
+        return None
+
+
+def read_binary_file(filepath: Union[str, Path]) -> Optional[bytes]:
+    """
+    Read a binary file and return its content as bytes.
+
+    :param filepath: Path to file.
+    :return: Bytes or None on failure.
+    """
+    path = Path(filepath)
+    try:
+        return path.read_bytes()
+    except Exception as e:
+        logger.warning("[file] Failed to read %r: %s", path, e)
+        return None
+
+
+def load_text_resource(
+    filename: str,
+    package: str = "novel_downloader.resources.text",
+) -> str:
+    """
+    Load and return the contents of a text resource.
+
+    :param filename: Name of the text file (e.g. "blacklist.txt").
+    :param package: Package path where resources live (default: text resources).
+                    For other resource types, point to the appropriate subpackage
+                    (e.g. "novel_downloader.resources.css").
+    :return: File contents as a string.
+    """
+    resource_path = files(package).joinpath(filename)
+    return resource_path.read_text(encoding="utf-8")
+
+
+def load_blacklisted_words() -> Set[str]:
+    """
+    Convenience loader for the blacklist.txt in the text resources.
+
+    :return: A set of non-empty, stripped lines from blacklist.txt.
+    """
+    text = load_text_resource("blacklist.txt")
+    return {line.strip() for line in text.splitlines() if line.strip()}
+
+
+__all__ = [
+    "save_as_txt",
+    "save_as_json",
+    "read_text_file",
+    "read_json_file",
+    "read_binary_file",
+    "load_text_resource",
+    "load_blacklisted_words",
+]

novel_downloader/utils/file_utils/normalize.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+novel_downloader.utils.file_utils.normalize
+-------------------------------------------
+
+Utilities for normalizing the contents of text files for consistency
+across platforms or output formats.
+
+Currently includes line-ending normalization for .txt files.
+"""
+
+import logging
+from pathlib import Path
+from typing import Union
+
+logger = logging.getLogger(__name__)
+
+
+def normalize_txt_line_endings(folder_path: Union[str, Path]) -> None:
+    """
+    Convert all .txt files in the given folder (recursively)
+    to use Unix-style LF (\\n) line endings.
+
+    :param folder_path: Path to the folder containing .txt files.
+                        Can be a str or Path.
+    :return: None
+    """
+    path = Path(folder_path).resolve()
+    if not path.exists() or not path.is_dir():
+        logger.warning("[file] Invalid folder: %s", path)
+        return
+
+    count_success, count_fail = 0, 0
+
+    for txt_file in path.rglob("*.txt"):
+        try:
+            content = txt_file.read_text(encoding="utf-8")
+            normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+            txt_file.write_text(normalized, encoding="utf-8", newline="\n")
+            logger.debug("[file] Normalized: %s", txt_file)
+            count_success += 1
+        except (OSError, UnicodeDecodeError) as e:
+            logger.warning("[file] Failed: %s | %s", txt_file, e)
+            count_fail += 1
+
+    logger.info("[file] Completed. Success: %s, Failed: %s", count_success, count_fail)
+    return
+
+
+__all__ = ["normalize_txt_line_endings"]
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+
+    logging.basicConfig(
+        level=logging.INFO, format="[%(asctime)s] [%(levelname)s] %(name)s: %(message)s"
+    )
+
+    parser = argparse.ArgumentParser(
+        description="Normalize line endings of .txt files in a folder to LF."
+    )
+    parser.add_argument(
+        "folder", type=str, help="Path to the folder containing .txt files."
+    )
+    args = parser.parse_args()
+
+    normalize_txt_line_endings(args.folder)