novel-downloader 1.3.2__py3-none-any.whl → 1.4.0__py3-none-any.whl

novel_downloader/utils/cookies.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.cookies
+------------------------------
+
+Utility for normalizing cookie input from user configuration.
+"""
+
+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]:
+    """
+    Parse cookies from a string or dictionary into a standard dictionary.
+
+    Supports input like:
+        - "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()}
+    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:
+    for state_file in state_files:
+        try:
+            with state_file.open("r", encoding="utf-8") as f:
+                data = json.load(f)
+        except Exception:
+            continue
+
+        cookies = data.get("cookies", [])
+        for cookie in cookies:
+            if cookie.get("name") != key:
+                continue
+            value = cookie.get("value")
+            if isinstance(value, str):
+                return value
+    return ""

novel_downloader/utils/crypto_utils.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 """
 novel_downloader.utils.crypto_utils
 -----------------------------------
@@ -8,11 +9,6 @@ Generic cryptographic utilities
 from __future__ import annotations
 
 import base64
-import hashlib
-import json
-import random
-import time
-from typing import Any
 
 
 def rc4_crypt(
@@ -73,72 +69,3 @@ def rc4_crypt(
         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/io.py

@@ -103,7 +103,7 @@ def _write_file(
             tmp.write(content_to_write)
             tmp_path = Path(tmp.name)
         tmp_path.replace(path)
-        logger.info("[file] '%s' written successfully", path)
+        logger.debug("[file] '%s' written successfully", path)
         return True
     except Exception as exc:
         logger.warning("[file] Error writing %r: %s", path, exc)

novel_downloader/utils/fontocr/ocr_v1.py

@@ -18,6 +18,7 @@ import paddle
 from fontTools.ttLib import TTFont
 from paddleocr import PaddleOCR
 from PIL import Image, ImageDraw, ImageFont
+from PIL.Image import Transpose
 
 from novel_downloader.utils.constants import (
     REC_CHAR_MODEL_FILES,
@@ -142,7 +143,7 @@ class FontOCRV1:
         y = (size - h) // 2 - bbox[1]
         draw.text((x, y), char, fill=0, font=render_font)
         if is_reflect:
-            img = img.transpose(Image.FLIP_LEFT_RIGHT)
+            img = img.transpose(Transpose.FLIP_LEFT_RIGHT)
 
         img_np = np.array(img)
         if np.unique(img_np).size == 1:

novel_downloader/utils/fontocr/ocr_v2.py

@@ -570,7 +570,7 @@ class FontOCRV2:
         else:
             ocr_fallback = raw_ocr
 
-        # Vec‐embedding scores
+        # Vec-embedding scores
         raw_vec: list[tuple[str, float]] | list[list[tuple[str, float]]] = (
             self.match_text_by_embedding(fallback_imgs, top_k=top_k)
             if (self.use_vec and fallback_imgs)
@@ -624,7 +624,7 @@ class FontOCRV2:
             else:
                 fused_batch.append(next(fallback_iter))
 
-        # Unwrap single‐image case
+        # Unwrap single-image case
         return fused_batch[0] if single else fused_batch
 
     def _chunked(self, seq: list[T], size: int) -> Generator[list[T], None, None]:

novel_downloader/utils/hash_store.py

@@ -13,7 +13,6 @@ import logging
 from collections.abc import Callable
 from pathlib import Path
 
-import numpy as np
 from PIL import Image
 
 from .constants import HASH_STORE_FILE
@@ -100,25 +99,21 @@ class ImageHashStore:
         """Load store from disk and rebuild BK-Tree index."""
         if not self._path.exists():
             self._hash.clear()
-            logger.info(
+            logger.debug(
                 "[ImageHashStore] No file found at %s, starting empty.", self._path
             )
             return
-        else:
-            if self._path.suffix == ".npy":
-                arr = np.load(self._path, allow_pickle=True).item()
-                self._hash = {lbl: set(v) for lbl, v in arr.items()}
-            else:
-                txt = self._path.read_text(encoding="utf-8")
-                obj = json.loads(txt) or {}
-                self._hash = {lbl: set(obj.get(lbl, [])) for lbl in obj}
+
+        txt = self._path.read_text(encoding="utf-8")
+        obj = json.loads(txt) or {}
+        self._hash = {lbl: set(obj.get(lbl, [])) for lbl in obj}
 
         # rebuild reverse map and BK-Tree
         self._hash_to_labels.clear()
         for lbl, hs in self._hash.items():
             for h in hs:
                 self._hash_to_labels.setdefault(h, []).append(lbl)
-        logger.info(
+        logger.debug(
             "[ImageHashStore] Loaded hash store from %s with %d hashes",
             self._path,
             sum(len(v) for v in self._hash.values()),
@@ -134,7 +129,7 @@ class ImageHashStore:
                 self._bk_root = _BKNode(h)
             else:
                 self._bk_root.add(h, self._hd)
-        logger.info(
+        logger.debug(
             "[ImageHashStore] BK-tree index built with %d unique hashes",
             len(self._hash_to_labels),
         )
@@ -143,12 +138,9 @@ class ImageHashStore:
         """Persist current store to disk."""
         self._path.parent.mkdir(parents=True, exist_ok=True)
         data = {lbl: list(s) for lbl, s in self._hash.items()}
-        if self._path.suffix == ".npy":
-            np.save(self._path, data)
-        else:
-            txt = json.dumps(data, ensure_ascii=False, indent=2)
-            self._path.write_text(txt, encoding="utf-8")
-        logger.info("[ImageHashStore] Saved hash store to %s", self._path)
+        txt = json.dumps(data, ensure_ascii=False, indent=2)
+        self._path.write_text(txt, encoding="utf-8")
+        logger.debug("[ImageHashStore] Saved hash store to %s", self._path)
 
     def _maybe_save(self) -> None:
         if self._auto:

novel_downloader/utils/hash_utils.py

@@ -16,6 +16,7 @@ Provides:
 """
 
 import numpy as np
+from numpy.typing import NDArray
 from PIL import Image
 from scipy.fft import dct as dct_1d
 
@@ -24,7 +25,7 @@ HASH_SIZE = 10  # default is 8
 HASH_DISTANCE_THRESHOLD = 5
 
 
-def hash_to_int(hash_array: np.ndarray) -> int:
+def hash_to_int(hash_array: NDArray[np.bool_]) -> int:
     """
     Convert a boolean hash array to an integer.
 
@@ -60,7 +61,7 @@ def fast_hamming_distance(hash_1: int, hash_2: int) -> int:
     return count
 
 
-def _threshold_and_pack(dct_low: np.ndarray) -> int:
+def _threshold_and_pack(dct_low: NDArray[np.float64]) -> int:
     """
     Convert a low-frequency DCT matrix into a binary hash.
 

novel_downloader/utils/logger.py

@@ -11,11 +11,10 @@ import logging
 from datetime import datetime
 from logging.handlers import TimedRotatingFileHandler
 from pathlib import Path
-from typing import Literal
 
-from .constants import LOGGER_DIR, LOGGER_NAME
+from novel_downloader.models import LogLevel
 
-LogLevel = Literal["DEBUG", "INFO", "WARNING", "ERROR"]
+from .constants import LOGGER_DIR, LOGGER_NAME
 
 LOG_LEVELS: dict[LogLevel, int] = {
     "DEBUG": logging.DEBUG,

novel_downloader/utils/network.py

@@ -16,7 +16,7 @@ from urllib.parse import unquote, urlparse
 import requests
 
 from .constants import DEFAULT_HEADERS, DEFAULT_IMAGE_SUFFIX
-from .file_utils.io import _get_non_conflicting_path, _write_file, read_binary_file
+from .file_utils.io import _get_non_conflicting_path, _write_file
 
 logger = logging.getLogger(__name__)
 
@@ -84,28 +84,29 @@ def image_url_to_filename(url: str) -> str:
     return filename
 
 
-def download_image_as_bytes(
+def download_image(
     url: str,
     target_folder: str | Path | None = None,
+    target_name: str | None = None,
     *,
     timeout: int = 10,
     retries: int = 3,
     backoff: float = 0.5,
+    headers: dict[str, str] | None = None,
     on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
-) -> bytes | None:
+) -> Path | None:
     """
-    Download an image from a given URL and return its content as bytes.
-
-    If on_exist='skip' and the file already exists, it will be read from disk
-    instead of being downloaded again.
+    Download an image from `url` and save it to `target_folder`, returning the Path.
+    Can override the filename via `target_name`.
 
     :param url: Image URL. Can start with 'http', '//', or without protocol.
-    :param target_folder: Optional folder to save the image (str or Path).
+    :param target_folder: Directory to save into (defaults to cwd).
+    :param target_name: Optional filename (with or without extension).
     :param timeout: Request timeout in seconds.
     :param retries: Number of retry attempts.
     :param backoff: Base delay between retries (exponential backoff).
     :param on_exist: What to do if file exists: 'overwrite', 'skip', or 'rename'.
-    :return: Image content as bytes, or None if failed.
+    :return: Path to the saved image, or `None` on any failure.
     """
     # Normalize URL
     if url.startswith("//"):
@@ -113,42 +114,55 @@ def download_image_as_bytes(
     elif not url.startswith("http"):
         url = "https://" + url
 
-    save_path = None
-    if target_folder:
-        target_folder = Path(target_folder)
-        filename = image_url_to_filename(url)
-        save_path = target_folder / filename
-
-        if on_exist == "skip" and save_path.exists():
-            logger.info(
-                "[image] '%s' exists, skipping download and reading from disk.",
-                save_path,
-            )
-            return read_binary_file(save_path)
+    folder = Path(target_folder) if target_folder else Path.cwd()
+    folder.mkdir(parents=True, exist_ok=True)
+
+    if target_name:
+        name = target_name
+        if not Path(name).suffix:
+            # infer ext from URL-derived name
+            name += Path(image_url_to_filename(url)).suffix
+    else:
+        name = image_url_to_filename(url)
+    save_path = folder / name
+
+    # Handle existing file
+    if save_path.exists():
+        if on_exist == "skip":
+            logger.debug("Skipping download; file exists: %s", save_path)
+            return save_path
+        if on_exist == "rename":
+            save_path = _get_non_conflicting_path(save_path)
 
     # Proceed with download
-    response = http_get_with_retry(
+    resp = http_get_with_retry(
         url,
         retries=retries,
         timeout=timeout,
         backoff=backoff,
-        headers=DEFAULT_HEADERS,
+        headers=headers or DEFAULT_HEADERS,
         stream=False,
     )
 
-    if response and response.ok:
-        content = response.content
-
-        if save_path:
-            _write_file(
-                content=content,
-                filepath=save_path,
-                mode="wb",
-                on_exist=on_exist,
-            )
-
-        return content
+    if not (resp and resp.ok):
+        logger.warning(
+            "Failed to download %s (status=%s)",
+            url,
+            getattr(resp, "status_code", None),
+        )
+        return None
 
+    # Write to disk
+    try:
+        _write_file(
+            content=resp.content,
+            filepath=save_path,
+            mode="wb",
+            on_exist=on_exist,
+        )
+        return save_path
+    except Exception:
+        logger.exception("Error saving image to %s", save_path)
     return None
 
 
@@ -191,7 +205,7 @@ def download_font_file(
 
     # If skip and file exists -> return immediately
     if on_exist == "skip" and font_path.exists():
-        logger.info("[font] File exists, skipping download: %s", font_path)
+        logger.debug("[font] File exists, skipping download: %s", font_path)
         return font_path
 
     # Retry download with exponential backoff
@@ -214,7 +228,7 @@ def download_font_file(
                     if chunk:
                         f.write(chunk)
 
-            logger.info("[font] Font saved to: %s", font_path)
+            logger.debug("[font] Font saved to: %s", font_path)
             return font_path
 
         except Exception as e:
@@ -258,7 +272,7 @@ def download_js_file(
     save_path = target_folder / filename
 
     if on_exist == "skip" and save_path.exists():
-        logger.info("[js] File exists, skipping download: %s", save_path)
+        logger.debug("[js] File exists, skipping download: %s", save_path)
         return save_path
 
     response = http_get_with_retry(
@@ -278,7 +292,7 @@ def download_js_file(
 
         try:
             _write_file(content=content, filepath=save_path, mode="wb")
-            logger.info("[js] JS file saved to: %s", save_path)
+            logger.debug("[js] JS file saved to: %s", save_path)
             return save_path
         except Exception as e:
             logger.error("[js] Error writing JS to disk: %s", e)

novel_downloader/utils/text_utils/chapter_formatting.py

@@ -6,13 +6,17 @@ novel_downloader.utils.text_utils.chapter_formatting
 Format chapter content with title, paragraph blocks, and optional author notes.
 """
 
+import re
+
+_IMG_TAG_RE = re.compile(r"<img[^>]*>")
+
 
 def format_chapter(title: str, paragraphs: str, author_say: str | None = None) -> str:
     """
     Build a formatted chapter string with title, paragraphs, and optional author note.
 
     :param title:       The chapter title.
-    :param paragraphs:  Raw multi‐line string; lines are treated as paragraphs.
+    :param paragraphs:  Raw multi-line string; lines are treated as paragraphs.
     :param author_say:  Optional author comment to append at the end.
     :return:            A single string where title, paragraphs, and author note
                         are separated by blank lines.
@@ -20,6 +24,7 @@ def format_chapter(title: str, paragraphs: str, author_say: str | None = None) -
     parts: list[str] = [title.strip()]
 
     # add each nonempty paragraph line
+    paragraphs = _IMG_TAG_RE.sub("", paragraphs)
     for ln in paragraphs.splitlines():
         line = ln.strip()
         if line:

novel_downloader/utils/text_utils/font_mapping.py

@@ -18,7 +18,7 @@ def apply_font_mapping(text: str, font_map: dict[str, str]) -> str:
 
     :param text:    The input string, possibly containing obfuscated font chars.
     :param font_map: A dict mapping obfuscated chars to real chars.
-    :return:        The de‐obfuscated text.
+    :return:        The de-obfuscated text.
     """
     return "".join(font_map.get(ch, ch) for ch in text)
 

novel_downloader/utils/text_utils/text_cleaning.py

@@ -37,7 +37,7 @@ def clean_chapter_title(title: str) -> str:
 
 def is_promotional_line(line: str) -> bool:
     """
-    Check if a line of text likely contains promotional or ad‐like content.
+    Check if a line of text likely contains promotional or ad-like content.
 
     :param line: A single line of text.
     :return:     True if it contains promo keywords or a '###k' vote count pattern.

novel_downloader/utils/time_utils/datetime_utils.py

@@ -106,9 +106,9 @@ def calculate_time_difference(
     """
     Calculate the difference between two datetime values.
 
-    :param from_time_str: Date‐time string "YYYY-MM-DD HH:MM:SS" for the start.
+    :param from_time_str: Date-time string "YYYY-MM-DD HH:MM:SS" for the start.
     :param tz_str:        Timezone of from_time_str, e.g. 'UTC+8'. Defaults to 'UTC'.
-    :param to_time_str:   Optional date‐time string for the end; if None, uses now().
+    :param to_time_str:   Optional date-time string for the end; if None, uses now().
     :param to_tz_str:     Timezone of to_time_str. Defaults to 'UTC'.
     :return:              Tuple (days, hours, minutes, seconds).
     """
@@ -138,7 +138,7 @@ def calculate_time_difference(
 
     except Exception as e:
         logger.warning("[time] Failed to calculate time difference: %s", e)
-        return 999, 23, 59, 59
+        return 0, 0, 0, 0
 
 
 __all__ = [

novel_downloader/utils/time_utils/sleep_utils.py

@@ -56,7 +56,7 @@ def sleep_with_random_delay(
     if max_sleep is not None:
         duration = min(duration, max_sleep)
 
-    logger.info("[time] Sleeping for %.2f seconds", duration)
+    logger.debug("[time] Sleeping for %.2f seconds", duration)
     time.sleep(duration)
     return
 
@@ -82,7 +82,7 @@ async def async_sleep_with_random_delay(
     :param mul_spread: Maximum multiplier factor for base; drawn from [1.0, mul_spread].
     :param max_sleep: Optional upper limit for the final sleep duration.
     """
-    if base < 0 or add_spread < 0 or mul_spread < 0:
+    if base < 0 or add_spread < 0 or mul_spread < 1.0:
         logger.warning(
             "[async sleep] Invalid parameters: base=%s, add_spread=%s, mul_spread=%s",
             base,
@@ -98,7 +98,7 @@ async def async_sleep_with_random_delay(
     if max_sleep is not None:
         duration = min(duration, max_sleep)
 
-    logger.info("[async time] Sleeping for %.2f seconds", duration)
+    logger.debug("[async time] Sleeping for %.2f seconds", duration)
     await asyncio.sleep(duration)