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

novel_downloader/core/parsers/qidian/utils/__init__.py

@@ -6,25 +6,6 @@ novel_downloader.core.parsers.qidian.utils
 Utility functions and helpers for parsing and decrypting Qidian novel pages
 """
 
-__all__ = [
-    "find_ssr_page_context",
-    "extract_chapter_info",
-    "is_restricted_page",
-    "vip_status",
-    "can_view_chapter",
-    "is_encrypted",
-    "is_duplicated",
-    "QidianNodeDecryptor",
-    "get_decryptor",
-]
+__all__ = ["get_decryptor"]
 
-from .helpers import (
-    can_view_chapter,
-    extract_chapter_info,
-    find_ssr_page_context,
-    is_duplicated,
-    is_encrypted,
-    is_restricted_page,
-    vip_status,
-)
-from .node_decryptor import QidianNodeDecryptor, get_decryptor
+from .node_decryptor import get_decryptor

novel_downloader/core/parsers/qidian/utils/node_decryptor.py

@@ -36,10 +36,10 @@ class QidianNodeDecryptor:
       3. Download the remote Fock module JS if not already present.
 
     Calling `decrypt()` will:
-      - Write a temp JSON input file with [ciphertext, chapter_id, fkp, fuid].
-      - Spawn `node qidian_decrypt_node.js <in> <out>`.
-      - Read and return the decrypted text.
-      - Clean up the temp files.
+      * Write a temp JSON input file with [ciphertext, chapter_id, fkp, fuid].
+      * Spawn `node qidian_decrypt_node.js <in> <out>`.
+      * Read and return the decrypted text.
+      * Clean up the temp files.
     """
 
     QIDIAN_FOCK_JS_URL: str = (

novel_downloader/core/parsers/xiguashuwu.py

@@ -29,6 +29,7 @@ from novel_downloader.utils.constants import (
     XIGUASHUWU_FONT_MAP_PATH,
 )
 from novel_downloader.utils.crypto_utils.aes_util import aes_cbc_decrypt
+from novel_downloader.utils.fontocr import get_font_ocr
 
 logger = logging.getLogger(__name__)
 
@@ -292,26 +293,19 @@ class XiguashuwuParser(BaseParser):
         :return: The recognized character (top-1) if OCR succeeds, otherwise None.
         """
         try:
-            import io
-
-            import numpy as np
-            from PIL import Image
-
-            from novel_downloader.utils.fontocr import get_font_ocr
+            ocr = get_font_ocr()
+            if not ocr:
+                return None
 
             resp = requests.get(url, headers=DEFAULT_USER_HEADERS, timeout=15)
             resp.raise_for_status()
 
-            im = Image.open(io.BytesIO(resp.content)).convert("RGB")
-            img_np = np.asarray(im)
+            img_np = ocr.load_image_array_from_bytes(resp.content)
 
-            ocr = get_font_ocr(batch_size=1)
-            char, score = ocr.predict([img_np], top_k=1)[0][0]
+            char, score = ocr.predict([img_np])[0]
 
             return char if score >= cls._CONF_THRESHOLD else None
 
-        except ImportError:
-            logger.warning("[Parser] FontOCR not available, font decoding will skip")
         except Exception as e:
             logger.warning("[Parser] Failed to ocr glyph image %s: %s", url, e)
         return None

novel_downloader/locales/en.json

@@ -39,9 +39,9 @@
   "login_description": "Description",
   "login_hint": "Hint",
   "login_use_config": "Using value from config.",
-  "login_enter_password": "Enter password: ",
-  "login_enter_cookie": "Enter cookies: ",
-  "login_enter_value": "Enter value: ",
+  "login_enter_password": "Enter password",
+  "login_enter_cookie": "Enter cookies",
+  "login_enter_value": "Enter value",
   "login_required_field": "This field is required. Please enter a value.",
 
   "clean_logs": "Clean log directory",

novel_downloader/locales/zh.json

@@ -39,9 +39,9 @@
   "login_description": "说明",
   "login_hint": "提示",
   "login_use_config": "使用配置中的默认值",
-  "login_enter_password": "请输入密码: ",
-  "login_enter_cookie": "请输入 Cookie: ",
-  "login_enter_value": "请输入值: ",
+  "login_enter_password": "请输入密码",
+  "login_enter_cookie": "请输入 Cookie",
+  "login_enter_value": "请输入值",
   "login_required_field": "该字段是必填项, 请重新输入",
 
   "clean_failed": "删除失败: {path}",

novel_downloader/utils/__init__.py

@@ -11,7 +11,6 @@ __all__ = [
     "TextCleaner",
     "parse_cookies",
     "get_cookie_value",
-    "rc4_crypt",
     "sanitize_filename",
     "write_file",
     "download",
@@ -29,7 +28,6 @@ from .cookies import (
     get_cookie_value,
     parse_cookies,
 )
-from .crypto_utils import rc4_crypt
 from .file_utils import (
     sanitize_filename,
     write_file,

novel_downloader/utils/chapter_storage.py

@@ -13,7 +13,7 @@ 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
 
@@ -313,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 = PACKAGE_NAME  # 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"

novel_downloader/utils/cookies.py

@@ -8,10 +8,11 @@ Utility for normalizing cookie input from user configuration.
 
 __all__ = ["parse_cookies", "get_cookie_value"]
 
+import functools
 import json
 from collections.abc import Mapping
-from http.cookies import SimpleCookie
 from pathlib import Path
+from typing import Any
 
 
 def parse_cookies(cookies: str | Mapping[str, str]) -> dict[str, str]:
@@ -27,10 +28,16 @@ def parse_cookies(cookies: str | Mapping[str, str]) -> dict[str, str]:
     :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")
@@ -38,17 +45,25 @@ def parse_cookies(cookies: str | Mapping[str, str]) -> dict[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

@@ -5,9 +5,3 @@ novel_downloader.utils.crypto_utils
 
 Generic cryptographic utilities
 """
-
-__all__ = [
-    "rc4_crypt",
-]
-
-from .rc4 import rc4_crypt

novel_downloader/utils/crypto_utils/rc4.py

@@ -3,62 +3,52 @@
 novel_downloader.utils.crypto_utils.rc4
 ---------------------------------------
 
-RC4 stream cipher for simple text encryption and decryption.
+Minimal RC4 stream cipher implementation.
 """
 
-import base64
 
-
-def rc4_crypt(
-    key: str,
-    data: str,
-    *,
-    mode: str = "encrypt",
-    encoding: str = "utf-8",
-) -> str:
+def rc4_init(key: bytes) -> list[int]:
     """
-    Encrypt or decrypt data using RC4 and Base64.
-
-    :param key: RC4 key (will be encoded using the specified encoding).
-    :param data: Plain-text (for 'encrypt') or Base64 cipher-text (for 'decrypt').
-    :param mode: Operation mode, either 'encrypt' or 'decrypt'. Defaults to 'encrypt'.
-    :param encoding: Character encoding for key and returned string. Defaults 'utf-8'.
-
-    :return: Base64 cipher-text (for encryption) or decoded plain-text (for decryption).
-
-    :raises ValueError: If mode is not 'encrypt' or 'decrypt'.
+    Key-Scheduling Algorithm (KSA)
     """
+    S = list(range(256))
+    j = 0
+    klen = len(key)
+    for i in range(256):
+        j = (j + S[i] + key[i % klen]) & 0xFF
+        S[i], S[j] = S[j], S[i]
+    return S
 
-    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)
+def rc4_stream(S_init: list[int], data: bytes) -> bytes:
+    """
+    Pseudo-Random Generation Algorithm (PRGA)
+    """
+    # make a copy of S since it mutates during PRGA
+    S = S_init.copy()
+    i = 0
+    j = 0
+    out = bytearray(len(data))
+    for idx, ch in enumerate(data):
+        i = (i + 1) & 0xFF
+        j = (j + S[i]) & 0xFF
+        S[i], S[j] = S[j], S[i]
+        K = S[(S[i] + S[j]) & 0xFF]
+        out[idx] = ch ^ K
+
+    return bytes(out)
+
+
+def rc4_cipher(key: bytes, data: bytes) -> bytes:
+    """
+    RC4 stream cipher.
 
-    if mode == "decrypt":
-        cipher_bytes = base64.b64decode(data)
-        plain_bytes = _rc4(key_bytes, cipher_bytes)
-        return plain_bytes.decode(encoding, errors="replace")
+    It performs the standard Key-Scheduling Algorithm (KSA) and
+    Pseudo-Random Generation Algorithm (PRGA) to produce the RC4 keystream.
 
-    raise ValueError("Mode must be 'encrypt' or 'decrypt'.")
+    :param key: RC4 key as bytes (must not be empty)
+    :param data: plaintext or ciphertext as bytes
+    :return: XORed bytes (encrypt/decrypt are identical)
+    """
+    S = rc4_init(key)
+    return rc4_stream(S, data)

novel_downloader/utils/epub/__init__.py

@@ -6,9 +6,8 @@ novel_downloader.utils.epub
 Top-level package for EPUB export utilities.
 
 Key components:
-
-- EpubBuilder : orchestrates metadata, manifest, spine, navigation, and resources
-- Chapter, Volume : represent and render content sections and volume intros
+  * EpubBuilder : orchestrates metadata, manifest, spine, navigation, and resources
+  * Chapter, Volume : represent and render content sections and volume intros
 
 Usage example:
 

novel_downloader/utils/epub/builder.py

@@ -4,14 +4,14 @@ novel_downloader.utils.epub.builder
 -----------------------------------
 
 Orchestrates the end-to-end EPUB build process by:
-- Managing metadata (title, author, description, language, etc.)
-- Collecting and deduplicating resources (chapters, images, stylesheets)
-- Registering everything in the OPF manifest and spine
-- Generating nav.xhtml, toc.ncx, content.opf, and the zipped .epub file
+  * Managing metadata (title, author, description, language, etc.)
+  * Collecting and deduplicating resources (chapters, images, stylesheets)
+  * Registering everything in the OPF manifest and spine
+  * Generating nav.xhtml, toc.ncx, content.opf, and the zipped .epub file
 
 Provides:
-- methods to add chapters, volumes, images, and styles
-- a clean `export()` entry point that writes the final EPUB archive
+  * methods to add chapters, volumes, images, and styles
+  * a clean `export()` entry point that writes the final EPUB archive
 """
 
 import zipfile

novel_downloader/utils/epub/constants.py

@@ -4,11 +4,11 @@ novel_downloader.utils.epub.constants
 -------------------------------------
 
 EPUB-specific constants used by the builder, including:
-- Directory names for OEBPS structure
-- XML namespace URIs
-- Package attributes and document-type declarations
-- Media type mappings for images
-- Template strings for container.xml and cover image HTML
+  * Directory names for OEBPS structure
+  * XML namespace URIs
+  * Package attributes and document-type declarations
+  * Media type mappings for images
+  * Template strings for container.xml and cover image HTML
 """
 
 ROOT_PATH = "OEBPS"

novel_downloader/utils/epub/documents.py

@@ -4,9 +4,9 @@ novel_downloader.utils.epub.documents
 -------------------------------------
 
 Defines the classes that render EPUB navigation and packaging documents:
-- NavDocument: builds the XHTML nav.xhtml (EPUB 3)
-- NCXDocument: builds the NCX XML navigation map (EPUB 2)
-- OpfDocument: builds the content.opf package document
+  * NavDocument: builds the XHTML nav.xhtml (EPUB 3)
+  * NCXDocument: builds the NCX XML navigation map (EPUB 2)
+  * OpfDocument: builds the content.opf package document
 """
 
 from collections.abc import Sequence
@@ -234,10 +234,10 @@ class OpfDocument(EpubResource):
         Generate the content.opf XML, which defines metadata, manifest, and spine.
 
         This function outputs a complete OPF package document that includes:
-        - <metadata>: title, author, language, identifiers, etc.
-        - <manifest>: all resource entries
-        - <spine>: the reading order of the content
-        - <guide>: optional references like cover page
+          * <metadata>: title, author, language, identifiers, etc.
+          * <manifest>: all resource entries
+          * <spine>: the reading order of the content
+          * <guide>: optional references like cover page
 
         :return: A string containing the full OPF XML content.
         """

novel_downloader/utils/epub/models.py

@@ -4,14 +4,14 @@ novel_downloader.utils.epub.models
 ----------------------------------
 
 Defines the core EPUB data models and resource classes used by the builder:
-- Typed entries for table of contents (ChapterEntry, VolumeEntry)
-- Manifest and spine record types (ManifestEntry, SpineEntry)
-- Hierarchical NavPoint for NCX navigation
-- Base resource class (EpubResource) and specializations:
-    - StyleSheet
-    - ImageResource
-    - Chapter (with XHTML serialization)
-- Volume container for grouping chapters with optional intro and cover
+  * Typed entries for table of contents (ChapterEntry, VolumeEntry)
+  * Manifest and spine record types (ManifestEntry, SpineEntry)
+  * Hierarchical NavPoint for NCX navigation
+  * Base resource class (EpubResource) and specializations:
+    * StyleSheet
+    * ImageResource
+    * Chapter (with XHTML serialization)
+  * Volume container for grouping chapters with optional intro and cover
 """
 
 from __future__ import annotations

novel_downloader/utils/epub/utils.py

@@ -4,9 +4,9 @@ novel_downloader.utils.epub.utils
 ---------------------------------
 
 Pure utility functions for EPUB assembly, including:
-- Computing file hashes
-- Generating META-INF/container.xml
-- Constructing HTML snippets for the book intro and volume intro
+  * Computing file hashes
+  * Generating META-INF/container.xml
+  * Constructing HTML snippets for the book intro and volume intro
 """
 
 import hashlib
@@ -59,9 +59,9 @@ def build_book_intro(
     Build the HTML snippet for the overall book introduction.
 
     This includes:
-      - A main heading ("Book Introduction")
-      - A list of metadata items (title, author, categories, word count, status)
-      - A "Summary" subheading and one or more paragraphs of summary text
+      * A main heading ("Book Introduction")
+      * A list of metadata items (title, author, categories, word count, status)
+      * A "Summary" subheading and one or more paragraphs of summary text
 
     :return: A HTML string for inclusion in `intro.xhtml`
     """
@@ -112,10 +112,10 @@ def build_volume_intro(
     Build the HTML snippet for a single-volume introduction.
 
     This includes:
-      - A decorative border image (top and bottom)
-      - A primary heading (volume main title)
-      - An optional secondary line (subtitle)
-      - One or more paragraphs of intro text
+      * A decorative border image (top and bottom)
+      * A primary heading (volume main title)
+      * An optional secondary line (subtitle)
+      * One or more paragraphs of intro text
 
     :param volume_title: e.g. "Volume 1 - The Beginning"
     :param volume_intro_text: multiline intro text for this volume

novel_downloader/utils/file_utils/io.py

@@ -8,99 +8,74 @@ File I/O utilities for reading and writing data.
 
 __all__ = ["write_file"]
 
-import json
-import logging
 import tempfile
 from pathlib import Path
-from typing import Any, Literal
+from typing import Literal
 
 from .sanitize import sanitize_filename
 
-logger = logging.getLogger(__name__)
 
-_JSON_INDENT_THRESHOLD = 50 * 1024  # bytes
-
-
-def _get_non_conflicting_path(path: Path) -> Path:
+def _unique_path(path: Path, max_tries: int = 100) -> Path:
     """
-    If the path exists, generate a new one by appending _1, _2, etc.
+    Return a unique file path by appending _1, _2, ... if needed.
+
+    Falls back to a UUID suffix if all attempts fail.
     """
-    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
+    if not path.exists():
+        return path
+
+    stem = path.stem
+    suffix = path.suffix
+
+    for counter in range(1, max_tries + 1):
+        candidate = path.with_name(f"{stem}_{counter}{suffix}")
+        if not candidate.exists():
+            return candidate
+
+    # fallback: append a random/unique suffix
+    import uuid
+
+    return path.with_name(f"{stem}_{uuid.uuid4().hex}{suffix}")
 
 
 def write_file(
-    content: str | bytes | dict[Any, Any] | list[Any] | Any,
+    content: str | bytes,
     filepath: str | Path,
-    write_mode: str = "w",
     *,
     on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
-    dump_json: bool = False,
     encoding: str = "utf-8",
-) -> Path | None:
+) -> Path:
     """
-    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.
+    Write content to a file safely with atomic replacement.
+
+    :param content: The content to write; can be text or bytes.
+    :param filepath: Destination path.
+    :param on_exist: Behavior if file exists.
     :param encoding: Text encoding for writing.
-    :return: Path if writing succeeds, None otherwise.
+    :return: The final path where the content was written.
+    :raise: Any I/O error such as PermissionError or OSError
     """
     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 path
-        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: 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.debug("[file] '%s' written successfully", path)
-        return path
-    except Exception as exc:
-        logger.warning("[file] Error writing %r: %s", path, exc)
-        return None
+        match on_exist:
+            case "skip":
+                return path
+            case "rename":
+                path = _unique_path(path)
+
+    write_mode = "wb" if isinstance(content, bytes) else "w"
+
+    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)
+        tmp_path = Path(tmp.name)
+    tmp_path.replace(path)
+    return path