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

novel_downloader/utils/file_utils/io.py

@@ -3,18 +3,14 @@
 novel_downloader.utils.file_utils.io
 ------------------------------------
 
-File I/O utilities for reading and writing text, JSON, and binary data.
-
-Includes:
-- Safe, atomic file saving with optional overwrite and auto-renaming
-- JSON pretty-printing with size-aware formatting
-- Simple helpers for reading files with fallback and logging
+File I/O utilities for reading and writing data.
 """
 
+__all__ = ["write_file"]
+
 import json
 import logging
 import tempfile
-from importlib.resources import files
 from pathlib import Path
 from typing import Any, Literal
 
@@ -39,15 +35,15 @@ def _get_non_conflicting_path(path: Path) -> Path:
     return new_path
 
 
-def _write_file(
+def write_file(
     content: str | bytes | dict[Any, Any] | list[Any] | Any,
     filepath: str | Path,
-    mode: str | None = None,
+    write_mode: str = "w",
     *,
     on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
     dump_json: bool = False,
     encoding: str = "utf-8",
-) -> bool:
+) -> Path | None:
     """
     Write content to a file safely with optional atomic behavior
     and JSON serialization.
@@ -60,7 +56,7 @@ def _write_file(
         or 'rename'.
     :param dump_json: If True, serialize content as JSON.
     :param encoding: Text encoding for writing.
-    :return: True if writing succeeds, False otherwise.
+    :return: Path if writing succeeds, None otherwise.
     """
     path = Path(filepath)
     path = path.with_name(sanitize_filename(path.name))
@@ -69,7 +65,7 @@ def _write_file(
     if path.exists():
         if on_exist == "skip":
             logger.debug("[file] '%s' exists, skipping", path)
-            return False
+            return path
         if on_exist == "rename":
             path = _get_non_conflicting_path(path)
             logger.debug("[file] Renaming target to avoid conflict: %s", path)
@@ -104,144 +100,7 @@ def _write_file(
             tmp_path = Path(tmp.name)
         tmp_path.replace(path)
         logger.debug("[file] '%s' written successfully", path)
-        return True
+        return path
     except Exception as exc:
         logger.warning("[file] Error writing %r: %s", path, exc)
-        return False
-
-
-def save_as_txt(
-    content: str,
-    filepath: str | Path,
-    *,
-    encoding: str = "utf-8",
-    on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
-) -> bool:
-    """
-    Save plain text content to the given file path.
-
-    :param content: Text content to write.
-    :param filepath: Destination file path.
-    :param encoding: Text encoding to use (default: 'utf-8').
-    :param on_exist: How to handle existing files: 'overwrite', 'skip', or 'rename'.
-    :return: True if successful, False otherwise.
-    """
-    return _write_file(
-        content=content,
-        filepath=filepath,
-        mode="w",
-        on_exist=on_exist,
-        dump_json=False,
-        encoding=encoding,
-    )
-
-
-def save_as_json(
-    content: Any,
-    filepath: str | Path,
-    *,
-    encoding: str = "utf-8",
-    on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
-) -> bool:
-    """
-    Save JSON-serializable content to the given file path.
-
-    :param content: Data to write as JSON.
-    :param filepath: Destination file path.
-    :param encoding: Text encoding to use (default: 'utf-8').
-    :param on_exist: How to handle existing files: 'overwrite', 'skip', or 'rename'.
-    :return: True if successful, False otherwise.
-    """
-    return _write_file(
-        content=content,
-        filepath=filepath,
-        mode="w",
-        on_exist=on_exist,
-        dump_json=True,
-        encoding=encoding,
-    )
-
-
-def read_text_file(filepath: str | Path, encoding: str = "utf-8") -> str | None:
-    """
-    Read a UTF-8 text file.
-
-    :param filepath: Path to file.
-    :param encoding: Encoding to use.
-    :return: Text content or None on failure.
-    """
-    path = Path(filepath)
-    try:
-        return path.read_text(encoding=encoding)
-    except Exception as e:
-        logger.warning("[file] Failed to read %r: %s", path, e)
         return None
-
-
-def read_json_file(filepath: str | Path, encoding: str = "utf-8") -> Any | None:
-    """
-    Read a JSON file and parse it into Python objects.
-
-    :param filepath: Path to file.
-    :param encoding: Encoding to use.
-    :return: Python object or None on failure.
-    """
-    path = Path(filepath)
-    try:
-        return json.loads(path.read_text(encoding=encoding))
-    except Exception as e:
-        logger.warning("[file] Failed to read %r: %s", path, e)
-        return None
-
-
-def read_binary_file(filepath: str | Path) -> bytes | None:
-    """
-    Read a binary file and return its content as bytes.
-
-    :param filepath: Path to file.
-    :return: Bytes or None on failure.
-    """
-    path = Path(filepath)
-    try:
-        return path.read_bytes()
-    except Exception as e:
-        logger.warning("[file] Failed to read %r: %s", path, e)
-        return None
-
-
-def load_text_resource(
-    filename: str,
-    package: str = "novel_downloader.resources.text",
-) -> str:
-    """
-    Load and return the contents of a text resource.
-
-    :param filename: Name of the text file (e.g. "blacklist.txt").
-    :param package: Package path where resources live (default: text resources).
-                    For other resource types, point to the appropriate subpackage
-                    (e.g. "novel_downloader.resources.css").
-    :return: File contents as a string.
-    """
-    resource_path = files(package).joinpath(filename)
-    return resource_path.read_text(encoding="utf-8")
-
-
-def load_blacklisted_words() -> set[str]:
-    """
-    Convenience loader for the blacklist.txt in the text resources.
-
-    :return: A set of non-empty, stripped lines from blacklist.txt.
-    """
-    text = load_text_resource("blacklist.txt")
-    return {line.strip() for line in text.splitlines() if line.strip()}
-
-
-__all__ = [
-    "save_as_txt",
-    "save_as_json",
-    "read_text_file",
-    "read_json_file",
-    "read_binary_file",
-    "load_text_resource",
-    "load_blacklisted_words",
-]

novel_downloader/utils/file_utils/normalize.py

@@ -9,6 +9,8 @@ across platforms or output formats.
 Currently includes line-ending normalization for .txt files.
 """
 
+__all__ = ["normalize_txt_line_endings"]
+
 import logging
 from pathlib import Path
 
@@ -46,8 +48,6 @@ def normalize_txt_line_endings(folder_path: str | Path) -> None:
     return
 
 
-__all__ = ["normalize_txt_line_endings"]
-
 if __name__ == "__main__":  # pragma: no cover
     import argparse
 

novel_downloader/utils/file_utils/sanitize.py

@@ -5,12 +5,10 @@ novel_downloader.utils.file_utils.sanitize
 
 Utility functions for cleaning and validating filenames for safe use
 on different operating systems.
-
-This module provides a cross-platform `sanitize_filename` function
-that replaces or removes illegal characters from filenames, trims
-lengths, and avoids reserved names on Windows systems.
 """
 
+__all__ = ["sanitize_filename"]
+
 import logging
 import os
 import re
@@ -65,6 +63,3 @@ def sanitize_filename(filename: str, max_length: int | None = 255) -> str:
         cleaned = "_untitled"
     logger.debug("[file] Sanitized filename: %r -> %r", filename, cleaned)
     return cleaned
-
-
-__all__ = ["sanitize_filename"]

novel_downloader/utils/fontocr.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.fontocr
+------------------------------
+
+This class provides utility methods for optical character recognition (OCR),
+primarily used for decrypting custom font encryption.
+"""
+
+__all__ = [
+    "FontOCR",
+    "get_font_ocr",
+]
+__version__ = "4.0"
+
+import logging
+from collections.abc import Generator
+from typing import Any, TypeVar
+
+import numpy as np
+from paddleocr import TextRecognition  # takes 5 ~ 12 sec to init
+from PIL import Image, ImageDraw, ImageFont
+from PIL.Image import Transpose
+
+T = TypeVar("T")
+logger = logging.getLogger(__name__)
+
+
+class FontOCR:
+    """
+    Version 4 of the FontOCR utility.
+    """
+
+    def __init__(
+        self,
+        model_name: str | None = None,
+        model_dir: str | None = None,
+        input_shape: tuple[int, int, int] | None = None,
+        device: str | None = None,
+        precision: str = "fp32",
+        cpu_threads: int = 10,
+        batch_size: int = 32,
+        threshold: float = 0.0,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize a FontOCR instance.
+
+        :param batch_size: batch size for OCR inference (minimum 1)
+        :param ocr_weight: weight factor for OCR-based prediction scores
+        :param vec_weight: weight factor for vector-based similarity scores
+        :param threshold: minimum confidence threshold for predictions [0.0-1.0]
+        :param kwargs: reserved for future extensions
+        """
+        self._batch_size = batch_size
+        self._threshold = threshold
+        self._ocr_model = TextRecognition(
+            model_name=model_name,
+            model_dir=model_dir,
+            input_shape=input_shape,
+            device=device,
+            precision=precision,
+            cpu_threads=cpu_threads,
+        )
+
+    def predict(
+        self,
+        images: list[np.ndarray],
+        top_k: int = 1,
+    ) -> list[list[tuple[str, float]]]:
+        """
+        Run OCR on input images.
+
+        :param images: list of np.ndarray objects to predict
+        :param top_k: number of top candidates to return per image
+        :return: list of lists containing (character, score)
+        """
+        return [
+            [(pred.get("rec_text"), pred.get("rec_score"))]
+            for pred in self._ocr_model.predict(images, batch_size=self._batch_size)
+        ]
+
+    @staticmethod
+    def render_char_image(
+        char: str,
+        render_font: ImageFont.FreeTypeFont,
+        is_reflect: bool = False,
+        size: int = 64,
+    ) -> Image.Image | None:
+        """
+        Render a single character into an RGB square image.
+
+        :param char: character to render
+        :param render_font: FreeTypeFont instance to render with
+        :param is_reflect: if True, flip the image horizontally
+        :param size: output image size (width and height in pixels)
+        :return: rendered PIL.Image in RGB or None if blank
+        """
+        # img = Image.new("L", (size, size), color=255)
+        img = Image.new("RGB", (size, size), color=(255, 255, 255))
+        draw = ImageDraw.Draw(img)
+        bbox = draw.textbbox((0, 0), char, font=render_font)
+        w, h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        x = (size - w) // 2 - bbox[0]
+        y = (size - h) // 2 - bbox[1]
+        draw.text((x, y), char, fill=0, font=render_font)
+        if is_reflect:
+            img = img.transpose(Transpose.FLIP_LEFT_RIGHT)
+
+        img_np = np.array(img)
+        if np.unique(img_np).size == 1:
+            return None
+
+        return img
+
+    @staticmethod
+    def render_char_image_array(
+        char: str,
+        render_font: ImageFont.FreeTypeFont,
+        is_reflect: bool = False,
+        size: int = 64,
+    ) -> np.ndarray | None:
+        """
+        Render a single character into an RGB square image.
+
+        :param char: character to render
+        :param render_font: FreeTypeFont instance to render with
+        :param is_reflect: if True, flip the image horizontally
+        :param size: output image size (width and height in pixels)
+        :return: rendered image as np.ndarray in RGB or None if blank
+        """
+        # img = Image.new("L", (size, size), color=255)
+        img = Image.new("RGB", (size, size), color=(255, 255, 255))
+        draw = ImageDraw.Draw(img)
+        bbox = draw.textbbox((0, 0), char, font=render_font)
+        w, h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        x = (size - w) // 2 - bbox[0]
+        y = (size - h) // 2 - bbox[1]
+        draw.text((x, y), char, fill=0, font=render_font)
+        if is_reflect:
+            img = img.transpose(Transpose.FLIP_LEFT_RIGHT)
+
+        img_np = np.array(img)
+        if np.unique(img_np).size == 1:
+            return None
+
+        return img_np
+
+    @staticmethod
+    def render_text_image(
+        text: str,
+        font: ImageFont.FreeTypeFont,
+        cell_size: int = 64,
+        chars_per_line: int = 16,
+    ) -> Image.Image:
+        """
+        Render a string into a image.
+        """
+        # import textwrap
+        # lines = textwrap.wrap(text, width=chars_per_line) or [""]
+        lines = [
+            text[i : i + chars_per_line] for i in range(0, len(text), chars_per_line)
+        ] or [""]
+        img_w = cell_size * chars_per_line
+        img_h = cell_size * len(lines)
+
+        # img = Image.new("L", (img_w, img_h), color=255)
+        img = Image.new("RGB", (img_w, img_h), color=(255, 255, 255))
+        draw = ImageDraw.Draw(img)
+        for row, line in enumerate(lines):
+            for col, ch in enumerate(line):
+                x = (col + 0.5) * cell_size
+                y = (row + 0.5) * cell_size
+                draw.text((x, y), ch, font=font, fill=0, anchor="mm")
+
+        return img
+
+    @staticmethod
+    def _chunked(seq: list[T], size: int) -> Generator[list[T], None, None]:
+        """
+        Yield successive chunks of `seq` of length `size`.
+        """
+        for i in range(0, len(seq), size):
+            yield seq[i : i + size]
+
+
+_font_ocr: FontOCR | None = None
+
+
+def get_font_ocr(
+    model_name: str | None = None,
+    model_dir: str | None = None,
+    input_shape: tuple[int, int, int] | None = None,
+    batch_size: int = 32,
+) -> FontOCR:
+    """
+    Return the singleton FontOCR, initializing it on first use.
+    """
+    global _font_ocr
+    if _font_ocr is None:
+        _font_ocr = FontOCR(
+            model_name=model_name,
+            model_dir=model_dir,
+            input_shape=input_shape,
+            batch_size=batch_size,
+        )
+    return _font_ocr

novel_downloader/utils/i18n.py

@@ -6,6 +6,8 @@ novel_downloader.utils.i18n
 Multilingual text dictionary and utility for CLI and interactive mode.
 """
 
+__all__ = ["t"]
+
 import json
 from typing import Any
 

novel_downloader/utils/logger.py

@@ -7,16 +7,16 @@ Provides a configurable logging setup for Python applications.
 Log files are rotated daily and named with the given logger name and current date.
 """
 
+__all__ = ["setup_logging"]
+
 import logging
 from datetime import datetime
 from logging.handlers import TimedRotatingFileHandler
 from pathlib import Path
 
-from novel_downloader.models import LogLevel
-
 from .constants import LOGGER_DIR, LOGGER_NAME
 
-LOG_LEVELS: dict[LogLevel, int] = {
+LOG_LEVELS: dict[str, int] = {
     "DEBUG": logging.DEBUG,
     "INFO": logging.INFO,
     "WARNING": logging.WARNING,
@@ -26,19 +26,16 @@ LOG_LEVELS: dict[LogLevel, int] = {
 
 def setup_logging(
     log_filename_prefix: str | None = None,
-    log_level: LogLevel | None = None,
+    log_level: str | None = None,
     log_dir: str | Path | None = None,
 ) -> logging.Logger:
     """
     Create and configure a logger for both console and rotating file output.
 
     :param log_filename_prefix: Prefix for the log file name.
-                                If None, will use the last part of `logger_name`.
-    :param log_level: Minimum log level to show in console:
-                      "DEBUG", "INFO", "WARNING", or "ERROR".
-                      Defaults to "INFO" if not specified.
+    :param log_level: Minimum log level to show in console
+                        ("DEBUG", "INFO", "WARNING", "ERROR")
     :param log_dir: Directory where log files will be saved.
-                    Defaults to "./logs" if not specified.
     :return: A fully configured logger instance.
     """
     ft_logger = logging.getLogger("fontTools.ttLib.tables._p_o_s_t")
@@ -46,12 +43,8 @@ def setup_logging(
     ft_logger.propagate = False
 
     # Determine console level (default INFO)
-    level_str: LogLevel = log_level or "INFO"
-    console_level = LOG_LEVELS.get(level_str)
-    if console_level is None:
-        raise ValueError(
-            f"Invalid log level: {level_str}. Must be one of {list(LOG_LEVELS.keys())}"
-        )
+    level_str: str = log_level or "INFO"
+    console_level: int = LOG_LEVELS.get(level_str) or logging.INFO
 
     # Resolve log file path
     log_path = Path(log_dir) if log_dir else LOGGER_DIR
@@ -64,8 +57,9 @@ def setup_logging(
     log_filename = log_path / f"{log_filename_prefix}_{date_str}.log"
 
     # Create or retrieve logger
-    logger = logging.getLogger()
+    logger = logging.getLogger(LOGGER_NAME)
     logger.setLevel(logging.DEBUG)  # Capture everything, filter by handlers
+    logger.propagate = False
 
     # Clear existing handlers to avoid duplicate logs
     if logger.hasHandlers():