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

novel_downloader/utils/__init__.py

@@ -3,45 +3,34 @@
 novel_downloader.utils
 ----------------------
 
+A collection of helper functions and classes.
 """
 
 __all__ = [
     "ChapterStorage",
     "TextCleaner",
-    "resolve_cookies",
-    "parse_cookie_expires",
-    "find_cookie_value",
-    "rc4_crypt",
+    "parse_cookies",
+    "get_cookie_value",
     "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 +41,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,16 +3,17 @@
 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
 import types
 from pathlib import Path
-from typing import Any, Self, cast
+from typing import Any, Self
 
 from novel_downloader.models import ChapterDict
 
@@ -312,8 +313,7 @@ class ChapterStorage:
     @staticmethod
     def _load_dict(data: str) -> dict[str, Any]:
         try:
-            parsed = json.loads(data)
-            return cast(dict[str, Any], parsed)
+            return json.loads(data) or {}
         except Exception:
             return {}
 

novel_downloader/utils/constants.py

@@ -16,14 +16,12 @@ 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
-LOGGER_NAME = PACKAGE_NAME  # Root logger name
 
 # -----------------------------------------------------------------------------
 # Base directories
 # -----------------------------------------------------------------------------
 # Base config directory (e.g. ~/AppData/Local/novel_downloader/)
-BASE_CONFIG_DIR = Path(user_config_path(APP_DIR_NAME, appauthor=False))
+BASE_CONFIG_DIR = user_config_path(PACKAGE_NAME, appauthor=False)
 WORK_DIR = Path.cwd()
 PACKAGE_ROOT: Path = Path(__file__).parent.parent
 LOCALES_DIR: Path = PACKAGE_ROOT / "locales"
@@ -33,20 +31,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 +85,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,61 +6,64 @@ novel_downloader.utils.cookies
 Utility for normalizing cookie input from user configuration.
 """
 
+__all__ = ["parse_cookies", "get_cookie_value"]
+
+import functools
 import json
 from collections.abc import Mapping
-from email.utils import parsedate_to_datetime
-from http.cookies import SimpleCookie
 from pathlib import Path
+from typing import Any
 
 
-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)
     :raises TypeError: If the input is neither string nor dict-like
     """
     if isinstance(cookies, str):
-        filtered = "; ".join(pair for pair in cookies.split(";") if "=" in pair)
-        parsed = SimpleCookie()
-        parsed.load(filtered)
-        return {k: v.value for k, v in parsed.items()}
+        result: dict[str, str] = {}
+        for part in cookies.split(";"):
+            if "=" not in part:
+                continue
+            key, value = part.split("=", 1)
+            key, value = key.strip(), value.strip()
+            if not key:
+                continue
+            result[key] = value
+        return result
     elif isinstance(cookies, Mapping):
         return {str(k).strip(): str(v).strip() for k, v in cookies.items()}
     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:
-                data = json.load(f)
-        except Exception:
-            continue
-
+        mtime = state_file.stat().st_mtime
+        data = load_state_file(state_file, mtime)
         cookies = data.get("cookies", [])
-        for cookie in cookies:
-            if cookie.get("name") != key:
-                continue
-            value = cookie.get("value")
-            if isinstance(value, str):
-                return value
+        value = next(
+            (
+                c.get("value")
+                for c in cookies
+                if c.get("name") == key and isinstance(c.get("value"), str)
+            ),
+            None,
+        )
+        if isinstance(value, str):
+            return value
     return ""
+
+
+@functools.cache
+def load_state_file(state_file: Path, mtime: float = 0.0) -> dict[str, Any]:
+    try:
+        return json.loads(state_file.read_text(encoding="utf-8")) or {}
+    except (OSError, json.JSONDecodeError):
+        return {}

novel_downloader/utils/crypto_utils/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.crypto_utils
+-----------------------------------
+
+Generic cryptographic utilities
+"""

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)