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

novel_downloader/utils/__init__.py

@@ -3,45 +3,36 @@
 novel_downloader.utils
 ----------------------
 
+A collection of helper functions and classes.
 """
 
 __all__ = [
     "ChapterStorage",
     "TextCleaner",
-    "resolve_cookies",
-    "parse_cookie_expires",
-    "find_cookie_value",
+    "parse_cookies",
+    "get_cookie_value",
     "rc4_crypt",
     "sanitize_filename",
-    "save_as_json",
-    "save_as_txt",
-    "read_text_file",
-    "read_json_file",
-    "read_binary_file",
+    "write_file",
     "download",
     "get_cleaner",
     "content_prefix",
     "truncate_half_lines",
     "diff_inline_display",
-    "calculate_time_difference",
-    "async_sleep_with_random_delay",
-    "sleep_with_random_delay",
+    "time_diff",
+    "async_jitter_sleep",
+    "jitter_sleep",
 ]
 
 from .chapter_storage import ChapterStorage
 from .cookies import (
-    find_cookie_value,
-    parse_cookie_expires,
-    resolve_cookies,
+    get_cookie_value,
+    parse_cookies,
 )
 from .crypto_utils import rc4_crypt
 from .file_utils import (
-    read_binary_file,
-    read_json_file,
-    read_text_file,
     sanitize_filename,
-    save_as_json,
-    save_as_txt,
+    write_file,
 )
 from .network import download
 from .text_utils import (
@@ -52,7 +43,7 @@ from .text_utils import (
     truncate_half_lines,
 )
 from .time_utils import (
-    async_sleep_with_random_delay,
-    calculate_time_difference,
-    sleep_with_random_delay,
+    async_jitter_sleep,
+    jitter_sleep,
+    time_diff,
 )

novel_downloader/utils/chapter_storage.py

@@ -3,10 +3,11 @@
 novel_downloader.utils.chapter_storage
 --------------------------------------
 
-Storage module for managing novel chapters in
-either JSON file form or an SQLite database.
+Storage module for managing novel chapters in an SQLite database.
 """
 
+__all__ = ["ChapterStorage"]
+
 import contextlib
 import json
 import sqlite3

novel_downloader/utils/constants.py

@@ -16,7 +16,7 @@ from platformdirs import user_config_path
 # -----------------------------------------------------------------------------
 PACKAGE_NAME = "novel_downloader"  # Python package name
 APP_NAME = "NovelDownloader"  # Display name
-APP_DIR_NAME = "novel_downloader"  # Directory name for platformdirs
+APP_DIR_NAME = PACKAGE_NAME  # Directory name for platformdirs
 LOGGER_NAME = PACKAGE_NAME  # Root logger name
 
 # -----------------------------------------------------------------------------
@@ -33,20 +33,17 @@ LOGGER_DIR = WORK_DIR / "logs"
 JS_SCRIPT_DIR = BASE_CONFIG_DIR / "scripts"
 DATA_DIR = BASE_CONFIG_DIR / "data"
 CONFIG_DIR = BASE_CONFIG_DIR / "config"
-MODEL_CACHE_DIR = BASE_CONFIG_DIR / "models"
 
 # -----------------------------------------------------------------------------
 # Default file paths
 # -----------------------------------------------------------------------------
 STATE_FILE = DATA_DIR / "state.json"
 SETTING_FILE = CONFIG_DIR / "settings.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 = (
@@ -90,33 +87,11 @@ VOLUME_BORDER_IMAGE_PATH = files("novel_downloader.resources.images").joinpath(
 LINOVELIB_FONT_MAP_PATH = files("novel_downloader.resources.json").joinpath(
     "linovelib_font_map.json"
 )
+XIGUASHUWU_FONT_MAP_PATH = files("novel_downloader.resources.json").joinpath(
+    "xiguashuwu.json"
+)
 
 # JavaScript
 QD_DECRYPT_SCRIPT_PATH = files("novel_downloader.resources.js_scripts").joinpath(
     "qidian_decrypt_node.js"
 )
-
-# ---------------------------------------------------------------------
-# 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/cookies.py

@@ -6,20 +6,21 @@ novel_downloader.utils.cookies
 Utility for normalizing cookie input from user configuration.
 """
 
+__all__ = ["parse_cookies", "get_cookie_value"]
+
 import json
 from collections.abc import Mapping
-from email.utils import parsedate_to_datetime
 from http.cookies import SimpleCookie
 from pathlib import Path
 
 
-def resolve_cookies(cookies: str | Mapping[str, str]) -> dict[str, str]:
+def parse_cookies(cookies: str | Mapping[str, str]) -> dict[str, str]:
     """
     Parse cookies from a string or dictionary into a standard dictionary.
 
     Supports input like:
-        - "key1=value1; key2=value2"
-        - {"key1": "value1", "key2": "value2"}
+      * `"key1=value1; key2=value2"`
+      * `{"key1": "value1", "key2": "value2"}`
 
     :param cookies: Cookie string or dict-like object (e.g., from config)
     :return: A normalized cookie dictionary (key -> value)
@@ -35,20 +36,7 @@ def resolve_cookies(cookies: str | Mapping[str, str]) -> dict[str, str]:
     raise TypeError("Unsupported cookie format: must be str or dict-like")
 
 
-def parse_cookie_expires(value: str | None) -> int:
-    if not value:
-        return -1
-    try:
-        return int(value)
-    except (ValueError, TypeError):
-        try:
-            dt = parsedate_to_datetime(value)
-            return int(dt.timestamp())
-        except Exception:
-            return -1
-
-
-def find_cookie_value(state_files: list[Path], key: str) -> str:
+def get_cookie_value(state_files: list[Path], key: str) -> str:
     for state_file in state_files:
         try:
             with state_file.open("r", encoding="utf-8") as f:

novel_downloader/utils/crypto_utils/__init__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.crypto_utils
+-----------------------------------
+
+Generic cryptographic utilities
+"""
+
+__all__ = [
+    "rc4_crypt",
+]
+
+from .rc4 import rc4_crypt

novel_downloader/utils/crypto_utils/aes_util.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.crypto_utils.aes_util
+--------------------------------------------
+
+AES decrypt functions.
+"""
+
+from __future__ import annotations
+
+__all__ = ["aes_cbc_decrypt"]
+
+from typing import Any
+
+_BLOCK = 16
+_VALID_KEY_SIZES = (16, 24, 32)
+
+
+def _as_bytes(name: str, b: Any) -> bytes:
+    if isinstance(b, bytes):
+        return b
+    if isinstance(b, bytearray | memoryview):
+        return bytes(b)
+    raise TypeError(f"{name} must be bytes-like, got {type(b).__name__}")
+
+
+def _validate_inputs(key: bytes, iv: bytes, data: bytes) -> None:
+    if len(iv) != _BLOCK:
+        raise ValueError(f"iv must be {_BLOCK} bytes, got {len(iv)}")
+    if len(key) not in _VALID_KEY_SIZES:
+        raise ValueError(
+            f"key length must be one of {_VALID_KEY_SIZES} bytes, got {len(key)}"
+        )
+    if len(data) % _BLOCK != 0:
+        raise ValueError(
+            f"ciphertext length must be a multiple of {_BLOCK} bytes, got {len(data)}"
+        )
+
+
+try:
+    from Crypto.Cipher import AES as _PyAES
+    from Crypto.Util.Padding import unpad as _py_unpad
+
+    def aes_cbc_decrypt(
+        key: bytes, iv: bytes, data: bytes, block_size: int = _BLOCK
+    ) -> bytes:
+        """
+        AES-CBC decrypt + PKCS#7 unpad (PyCryptodome).
+
+        :param key: AES key (16/24/32 bytes)
+        :param iv: Initialization vector (16 bytes)
+        :param data: Ciphertext, length multiple of 16
+        :return: Plaintext bytes (unpadded)
+        :raises TypeError, ValueError: on invalid inputs
+        """
+        key_b = _as_bytes("key", key)
+        iv_b = _as_bytes("iv", iv)
+        data_b = _as_bytes("data", data)
+        if not data_b:
+            return b""
+        _validate_inputs(key_b, iv_b, data_b)
+        pt = _PyAES.new(key_b, _PyAES.MODE_CBC, iv_b).decrypt(data_b)
+        return _py_unpad(pt, block_size, style="pkcs7")  # type: ignore[no-any-return]
+
+except ImportError:
+    print(
+        "[crypto_utils] Falling back to pure-Python AES_CBC.\n"
+        "Tip: pip install pycryptodome for ~800x faster speed."
+    )
+    from novel_downloader.utils.crypto_utils.aes_v2 import AES_CBC
+
+    def aes_cbc_decrypt(
+        key: bytes, iv: bytes, data: bytes, block_size: int = _BLOCK
+    ) -> bytes:
+        """
+        AES-CBC decrypt + PKCS#7 unpad (handled by AES_CBC internally).
+
+        :param key: AES key (16/24/32 bytes)
+        :param iv: Initialization vector (16 bytes)
+        :param data: Ciphertext, length multiple of 16
+        :return: Plaintext bytes (unpadded)
+        :raises TypeError, ValueError: on invalid inputs
+        """
+        key_b = _as_bytes("key", key)
+        iv_b = _as_bytes("iv", iv)
+        data_b = _as_bytes("data", data)
+        if not data_b:
+            return b""
+        _validate_inputs(key_b, iv_b, data_b)
+        return AES_CBC(key_b, iv_b).decrypt_padded(data_b, block_size)