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

novel_downloader/utils/crypto_utils.py

@@ -1,71 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.utils.crypto_utils
------------------------------------
-
-Generic cryptographic utilities
-"""
-
-from __future__ import annotations
-
-import base64
-
-
-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'.")

novel_downloader/utils/fontocr/hash_store.py

@@ -1,280 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.utils.fontocr.hash_store
------------------------------------------
-
-Manage a small collection of image perceptual hashes and their labels.
-Supports loading/saving to .json or .npy, and basic CRUD + search.
-"""
-
-import heapq
-import json
-import logging
-from collections.abc import Callable
-from pathlib import Path
-
-from PIL import Image
-
-from ..constants import DATA_DIR
-from .hash_utils import HASH_DISTANCE_THRESHOLD, fast_hamming_distance, phash
-
-logger = logging.getLogger(__name__)
-HASH_STORE_FILE = DATA_DIR / "image_hashes.json"
-
-
-class _BKNode:
-    """
-    A node in a Burkhard-Keller tree (BK-Tree) for distance search.
-    Stores one value and a dict of children keyed by distance.
-    """
-
-    __slots__ = ("value", "children")
-
-    def __init__(self, value: int):
-        self.value = value
-        self.children: dict[int, _BKNode] = {}
-
-    def add(self, h: int, dist_fn: Callable[[int, int], int]) -> None:
-        d = dist_fn(h, self.value)
-        child = self.children.get(d)
-        if child is not None:
-            child.add(h, dist_fn)
-        else:
-            self.children[d] = _BKNode(h)
-
-    def query(
-        self,
-        target: int,
-        threshold: int,
-        dist_fn: Callable[[int, int], int],
-    ) -> list[tuple[int, int]]:
-        """
-        Recursively collect (value, dist) pairs within threshold.
-        """
-        d0 = dist_fn(target, self.value)
-        matches: list[tuple[int, int]] = []
-        if d0 <= threshold:
-            matches.append((self.value, d0))
-        # Only children whose edge-dist \in [d0-threshold, d0+threshold]
-        lower, upper = d0 - threshold, d0 + threshold
-        for edge, child in self.children.items():
-            if lower <= edge <= upper:
-                matches.extend(child.query(target, threshold, dist_fn))
-        return matches
-
-
-class ImageHashStore:
-    """
-    Store and manage image hashes grouped by label, with a BK-Tree index.
-
-    :param path: file path for persistence (".json" or ".npy")
-    :param auto_save: if True, every modification automatically calls save()
-    :param hash_func: function to compute hash from PIL.Image
-    :param ham_dist: function to compute Hamming distance between two hashes
-    """
-
-    def __init__(
-        self,
-        path: str | Path = HASH_STORE_FILE,
-        auto_save: bool = False,
-        hash_func: Callable[[Image.Image], int] = phash,
-        ham_dist: Callable[[int, int], int] = fast_hamming_distance,
-        threshold: int = HASH_DISTANCE_THRESHOLD,
-    ) -> None:
-        self._path = Path(path)
-        self._auto = auto_save
-        self._hf = hash_func
-        self._hd = ham_dist
-        self._th = threshold
-
-        # label -> set of hashes
-        self._hash: dict[str, set[int]] = {}
-        # hash -> list of labels (for reverse lookup)
-        self._hash_to_labels: dict[int, list[str]] = {}
-        # root of BK-Tree (or None if empty)
-        self._bk_root: _BKNode | None = None
-
-        self.load()
-
-    def load(self) -> None:
-        """Load store from disk and rebuild BK-Tree index."""
-        if not self._path.exists():
-            self._hash.clear()
-            logger.debug(
-                "[ImageHashStore] No file found at %s, starting empty.", self._path
-            )
-            return
-
-        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.debug(
-            "[ImageHashStore] Loaded hash store from %s with %d hashes",
-            self._path,
-            sum(len(v) for v in self._hash.values()),
-        )
-
-        self._build_index()
-
-    def _build_index(self) -> None:
-        """Construct a BK-Tree over all stored hashes."""
-        self._bk_root = None
-        for h in self._hash_to_labels:
-            if self._bk_root is None:
-                self._bk_root = _BKNode(h)
-            else:
-                self._bk_root.add(h, self._hd)
-        logger.debug(
-            "[ImageHashStore] BK-tree index built with %d unique hashes",
-            len(self._hash_to_labels),
-        )
-
-    def save(self) -> None:
-        """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()}
-        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:
-            self.save()
-
-    def add_image(self, img_path: str | Path, label: str) -> int:
-        """
-        Compute hash for the given image and add it under `label`.
-        Updates BK-Tree index incrementally.
-        """
-        img = Image.open(img_path).convert("L")
-        h = self._hf(img)
-        self._hash.setdefault(label, set()).add(h)
-        self._hash_to_labels.setdefault(h, []).append(label)
-        # insert into BK-Tree
-        if self._bk_root is None:
-            self._bk_root = _BKNode(h)
-        else:
-            self._bk_root.add(h, self._hd)
-        logger.debug("[ImageHashStore] Added hash %d under label '%s'", h, label)
-        self._maybe_save()
-        return h
-
-    def add_from_map(self, map_path: str | Path) -> None:
-        """
-        Load a JSON file of the form { "image_path": "label", ... }
-        and add each entry.
-        """
-        map_path = Path(map_path)
-        text = map_path.read_text(encoding="utf-8")
-        mapping = json.loads(text)
-        for rel_img_path, lbl in mapping.items():
-            img_path = (map_path.parent / rel_img_path).resolve()
-            try:
-                self.add_image(img_path, lbl)
-            except Exception as e:
-                logger.warning(
-                    "[ImageHashStore] Failed to add image '%s': %s", img_path, str(e)
-                )
-                continue
-
-    def labels(self) -> list[str]:
-        """Return a sorted list of all labels in the store."""
-        return sorted(self._hash.keys())
-
-    def hashes(self, label: str) -> set[int]:
-        """Return the set of hashes for a given `label` (empty set if none)."""
-        return set(self._hash.get(label, ()))
-
-    def remove_label(self, label: str) -> None:
-        """Remove all hashes associated with `label`."""
-        if label in self._hash:
-            del self._hash[label]
-            logger.debug("[ImageHashStore] Removed label '%s'", label)
-            self._maybe_save()
-
-    def remove_hash(self, label: str, this: int | str | Path) -> bool:
-        """
-        Remove a specific hash under `label`.
-        `this` can be:
-         - an integer hash
-         - a Path (image file) -> will compute its hash then remove
-        Returns True if something was removed.
-        """
-        if label not in self._hash:
-            return False
-
-        h = None
-        if isinstance(this, (str | Path)):
-            try:
-                img = Image.open(this).convert("L")
-                h = self._hf(img)
-            except Exception as e:
-                logger.warning(
-                    "[ImageHashStore] Could not open image '%s': %s", this, str(e)
-                )
-                return False
-        else:
-            h = int(this)
-
-        if h in self._hash[label]:
-            self._hash[label].remove(h)
-            logger.debug("[ImageHashStore] Removed hash %d from label '%s'", h, label)
-            self._maybe_save()
-            return True
-        return False
-
-    def query(
-        self,
-        target: int | str | Path | Image.Image,
-        k: int = 1,
-        threshold: int | None = None,
-    ) -> list[tuple[str, float]]:
-        """
-        Find up to `k` distinct labels whose stored hashes are most similar
-        to `target` within `threshold`. Returns a list of (label, score),
-        sorted by descending score. Each label appears at most once.
-
-        :param target: Image path / int hash / PIL.Image
-        :param k: number of labels to return (default=1)
-        :param threshold: Hamming distance cutoff (default=self._th)
-        """
-        if threshold is None:
-            threshold = self._th
-
-        # compute target hash
-        if isinstance(target, Image.Image):
-            img = target.convert("L")
-            thash = self._hf(img)
-        elif isinstance(target, (str | Path)):
-            img = Image.open(target).convert("L")
-            thash = self._hf(img)
-        else:
-            thash = int(target)
-
-        if self._bk_root is None:
-            return []
-
-        # find all (hash,dist) within threshold
-        matches = self._bk_root.query(thash, threshold, self._hd)
-
-        # collapse to one best dist per label
-        best_per_label: dict[str, float] = {}
-        h2l = self._hash_to_labels
-        for h, dist in matches:
-            for lbl in h2l.get(h, ()):
-                score = 1.0 - dist / threshold
-                prev = best_per_label.get(lbl)
-                if prev is None or score > prev:
-                    best_per_label[lbl] = score
-
-        top_k = heapq.nsmallest(k, best_per_label.items(), key=lambda x: x[1])
-        return top_k
-
-
-img_hash_store = ImageHashStore()

novel_downloader/utils/fontocr/hash_utils.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.utils.fontocr.hash_utils
------------------------------------------
-
-Utilities for image perceptual hashing and comparison.
-
-Implements a perceptual hash (pHash) based on DCT, following the method
-described in:
-https://www.hackerfactor.com/blog/index.php?/archives/432-Looks-Like-It.html
-
-Provides:
-- pHash computation via DCT and median thresholding
-- Integer hash representation
-- Fast Hamming distance between hashes
-"""
-
-import numpy as np
-from numpy.typing import NDArray
-from PIL import Image
-from scipy.fft import dct as dct_1d
-
-ANTIALIAS = Image.Resampling.LANCZOS
-HASH_SIZE = 10  # default is 8
-HASH_DISTANCE_THRESHOLD = 5
-
-
-def hash_to_int(hash_array: NDArray[np.bool_]) -> int:
-    """
-    Convert a boolean hash array to an integer.
-
-    :param hash_array: A binary array (dtype=bool) from a hash function.
-    :type hash_array: np.ndarray
-    :return: Integer representation of the binary hash.
-    :rtype: int
-    """
-    result = 0
-    for bit in hash_array:
-        result = (result << 1) | int(bit)
-    return result
-
-
-def fast_hamming_distance(hash_1: int, hash_2: int) -> int:
-    """
-    Compute the Hamming distance between two integer-based image hashes.
-
-    Uses bitwise XOR and bit count for fast comparison.
-
-    :param hash_1: First image hash (as integer).
-    :type hash_1: int
-    :param hash_2: Second image hash (as integer).
-    :type hash_2: int
-    :return: Number of differing bits between the two hashes.
-    :rtype: int
-    """
-    x = hash_1 ^ hash_2
-    count = 0
-    while x:
-        x &= x - 1
-        count += 1
-    return count
-
-
-def _threshold_and_pack(dct_low: NDArray[np.float64]) -> int:
-    """
-    Convert a low-frequency DCT matrix into a binary hash.
-
-    Compares each element to the median, builds a boolean mask,
-    then packs it into an integer.
-    """
-    med = np.median(dct_low)
-    diff = dct_low > med
-    return hash_to_int(diff.flatten())
-
-
-def phash(
-    image: Image.Image, hash_size: int = HASH_SIZE, highfreq_factor: int = 4
-) -> int:
-    """
-    Compute the perceptual hash (pHash) of an image.
-
-    This method applies a Discrete Cosine Transform (DCT) to extract
-    low-frequency features, then compares them to the median to create
-    a binary fingerprint of the image.
-
-    :param image: The input image.
-    :type image: PIL.Image.Image
-    :param hash_size: Size of the resulting hash (NxN).
-    :type hash_size: int
-    :param highfreq_factor: Multiplier for the image resize to preserve detail.
-    :type highfreq_factor: int
-    :return: Integer representation of the perceptual hash.
-    :rtype: int
-    """
-    if hash_size < 2:
-        raise ValueError("Hash size must be greater than or equal to 2")
-
-    img_size = hash_size * highfreq_factor
-    image = image.convert("L").resize((img_size, img_size), ANTIALIAS)
-    pixels = np.asarray(image)
-    dct = dct_1d(dct_1d(pixels, axis=0, norm="ortho"), axis=1, norm="ortho")
-    dctlowfreq = dct[:hash_size, :hash_size]
-    return _threshold_and_pack(dctlowfreq)

novel_downloader/utils/fontocr/model_loader.py

@@ -1,69 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.utils.fontocr.model_loader
--------------------------------------------
-
-Utility functions for managing pre-trained model downloads.
-
-Currently supports:
-- Character recognition model for single Chinese character inference
-"""
-
-from pathlib import Path
-
-from huggingface_hub import hf_hub_download
-from huggingface_hub.errors import LocalEntryNotFoundError
-
-from novel_downloader.utils.constants import (
-    MODEL_CACHE_DIR,
-    REC_CHAR_MODEL_FILES,
-    REC_CHAR_MODEL_REPO,
-    REC_CHAR_VECTOR_FILES,
-)
-
-
-def get_rec_chinese_char_model_dir(version: str = "v1.0") -> Path:
-    """
-    Ensure model files are downloaded, return the directory path.
-    """
-    model_dir = MODEL_CACHE_DIR / "rec_chinese_char"
-
-    model_dir.mkdir(parents=True, exist_ok=True)
-
-    for fname in REC_CHAR_MODEL_FILES:
-        try:
-            hf_hub_download(
-                repo_id=REC_CHAR_MODEL_REPO,
-                filename=fname,
-                revision=version,
-                local_dir=model_dir,
-            )
-        except LocalEntryNotFoundError as err:
-            raise RuntimeError(
-                f"[model] Missing model file '{fname}' and no internet connection."
-            ) from err
-    return model_dir
-
-
-def get_rec_char_vector_dir(version: str = "v1.0") -> Path:
-    """
-    Ensure vector files are downloaded into a 'vector' subfolder under model directory.
-    Return the directory path.
-    """
-    vector_dir = MODEL_CACHE_DIR / "rec_chinese_char"
-    vector_dir.mkdir(parents=True, exist_ok=True)
-
-    for fname in REC_CHAR_VECTOR_FILES:
-        try:
-            hf_hub_download(
-                repo_id=REC_CHAR_MODEL_REPO,
-                filename=fname,
-                revision=version,
-                local_dir=vector_dir,
-            )
-        except LocalEntryNotFoundError as err:
-            raise RuntimeError(
-                f"[vector] Missing vector file '{fname}' and no internet connection."
-            ) from err
-
-    return vector_dir