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

novel_downloader/utils/fontocr/core.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.fontocr.core
+-----------------------------------
+
+This class provides utility methods for optical character recognition (OCR),
+primarily used for decrypting custom font encryption.
+"""
+
+import io
+import logging
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from fontTools.ttLib import TTFont
+from paddleocr import TextRecognition
+from PIL import Image, ImageDraw, ImageFont
+from PIL.Image import Transpose
+
+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,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize a FontOCR instance.
+
+        :param model_name: If set to None, PP-OCRv5_server_rec is used.
+        :param model_dir: Model storage path.
+        :param input_shape: Input image size for the model in the format (C, H, W).
+        :param device: Device for inference.
+        :param precision: Precision for TensorRT.
+        :param cpu_threads: Number of threads to use for inference on CPUs.
+        :param kwargs: reserved for future extensions
+        """
+        self._ocr_model = TextRecognition(  # takes 5 ~ 12 sec to init
+            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],
+        batch_size: int = 1,
+    ) -> list[tuple[str, float]]:
+        """
+        Run OCR on input images.
+
+        :param images: list of np.ndarray objects to predict
+        :param batch_size: batch size for OCR inference (minimum 1)
+        :return: list of tuple containing (character, score)
+        """
+        return [
+            (pred.get("rec_text"), pred.get("rec_score"))
+            for pred in self._ocr_model.predict(images, batch_size=batch_size)
+        ]
+
+    @staticmethod
+    def render_char_image(
+        char: str,
+        render_font: ImageFont.FreeTypeFont,
+        is_reflect: bool = False,
+        size: int = 64,
+    ) -> Image.Image:
+        """
+        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)
+
+        return img
+
+    @staticmethod
+    def render_char_image_array(
+        char: str,
+        render_font: ImageFont.FreeTypeFont,
+        is_reflect: bool = False,
+        size: int = 64,
+    ) -> np.ndarray:
+        """
+        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)
+
+        return np.array(img)
+
+    @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 load_image_array_from_bytes(data: bytes) -> np.ndarray:
+        """
+        Decode image bytes into an RGB NumPy array.
+
+        Reads common image formats (e.g. PNG/JPEG/WebP) from an
+        in-memory byte buffer using Pillow, converts the image to RGB,
+        and returns a NumPy array suitable for OCR inference.
+
+        :param data: Image file content as raw bytes.
+        :return: NumPy array of shape (H, W, 3), dtype=uint8, in RGB order.
+        :raises PIL.UnidentifiedImageError, OSError: If input bytes cannot be decoded.
+        """
+        with Image.open(io.BytesIO(data)) as im:
+            im = im.convert("RGB")
+            return np.asarray(im)
+
+    @staticmethod
+    def load_render_font(
+        font_path: Path | str, char_size: int = 52
+    ) -> ImageFont.FreeTypeFont:
+        """
+        Load a FreeType font face at the given pixel size for rendering helpers.
+
+        :param font_path: Path to a TTF/OTF font file.
+        :param char_size: Target glyph size in pixels (e.g. 52).
+        :return: A PIL `ImageFont.FreeTypeFont` instance.
+        :raises OSError: If the font file cannot be opened by PIL.
+        """
+        return ImageFont.truetype(str(font_path), char_size)
+
+    @staticmethod
+    def extract_font_charset(font_path: Path | str) -> set[str]:
+        """
+        Extract the set of Unicode characters encoded by a TrueType/OpenType font.
+
+        This reads the font's best available character map (cmap) and returns the
+        corresponding set of characters.
+
+        :param font_path: Path to a TTF/OTF font file.
+        :return: A set of Unicode characters present in the font's cmap.
+        """
+        with TTFont(font_path) as font_ttf:
+            cmap = font_ttf.getBestCmap() or {}
+
+        charset: set[str] = set()
+        for cp in cmap:
+            # guard against invalid/surrogate code points
+            if 0 <= cp <= 0x10FFFF and not (0xD800 <= cp <= 0xDFFF):
+                try:
+                    charset.add(chr(cp))
+                except ValueError:
+                    continue
+        return charset

novel_downloader/utils/fontocr/loader.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.fontocr.loader
+-------------------------------------
+
+Lazily load the FontOCR class.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .core import FontOCR
+
+logger = logging.getLogger(__name__)
+
+_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,
+) -> "FontOCR | None":
+    """
+    Try to initialize and return a singleton FontOCR instance.
+    Returns None if FontOCR or its dependencies are not available.
+    """
+    global _FONT_OCR
+    if _FONT_OCR is None:
+        try:
+            from .core import FontOCR
+
+            _FONT_OCR = FontOCR(
+                model_name=model_name,
+                model_dir=model_dir,
+                input_shape=input_shape,
+            )
+        except ImportError:
+            logger.warning(
+                "FontOCR dependency not available "
+                "(paddleocr / numpy / pillow / fonttools). "
+                "Font decoding will be skipped."
+            )
+            return None
+        except Exception as e:
+            logger.warning("FontOCR initialization failed: %s", e, exc_info=True)
+            return None
+
+    return _FONT_OCR

novel_downloader/utils/logger.py

@@ -4,101 +4,117 @@ novel_downloader.utils.logger
 -----------------------------
 
 Provides a configurable logging setup for Python applications.
-Log files are rotated daily and named with the given logger name and current date.
 """
 
+from __future__ import annotations
+
 __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
+from .constants import LOGGER_DIR, PACKAGE_NAME
 
-LOG_LEVELS: dict[LogLevel, int] = {
+LOG_LEVELS: dict[str, int] = {
     "DEBUG": logging.DEBUG,
     "INFO": logging.INFO,
     "WARNING": logging.WARNING,
     "ERROR": logging.ERROR,
 }
+_MUTE_LOGGERS: set[str] = {
+    "fontTools.ttLib.tables._p_o_s_t",
+}
+
+
+def _normalize_level(level: int | str) -> int:
+    if isinstance(level, int):
+        return level
+    if isinstance(level, str):
+        lvl = LOG_LEVELS.get(level.upper())
+        if isinstance(lvl, int):
+            return lvl
+    return logging.INFO
 
 
 def setup_logging(
-    log_filename_prefix: str | None = None,
-    log_level: LogLevel | None = None,
+    log_filename: str | None = None,
+    console_level: int | str = "INFO",
+    file_level: int | str = "DEBUG",
     log_dir: str | Path | None = None,
+    *,
+    console: bool = True,
+    file: bool = True,
+    backup_count: int = 7,
+    when: str = "midnight",
 ) -> logging.Logger:
     """
-    Create and configure a logger for both console and rotating file output.
+    Create and configure a package logger with optional console and file handlers.
 
-    :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_filename: Base log file name (without date suffix).
+    :param console_level: Minimum level for the console handler (string or int).
+    :param file_level: Minimum level for the file handler (string or int).
     :param log_dir: Directory where log files will be saved.
-                    Defaults to "./logs" if not specified.
-    :return: A fully configured logger instance.
+    :param console: Add a console handler.
+    :param file: Add a file handler.
+    :param backup_count: How many rotated files to keep.
+    :param when: Rotation interval for TimedRotatingFileHandler (e.g., "midnight").
+    :return: The configured logger.
     """
-    ft_logger = logging.getLogger("fontTools.ttLib.tables._p_o_s_t")
-    ft_logger.setLevel(logging.ERROR)
-    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())}"
-        )
-
-    # Resolve log file path
-    log_path = Path(log_dir) if log_dir else LOGGER_DIR
-    log_path.mkdir(parents=True, exist_ok=True)
+    # Tame noisy third-party loggers
+    for name in _MUTE_LOGGERS:
+        ml = logging.getLogger(name)
+        ml.setLevel(logging.ERROR)
+        ml.propagate = False
 
-    # Resolve log file name
-    if not log_filename_prefix:
-        log_filename_prefix = LOGGER_NAME
-    date_str = datetime.now().strftime("%Y-%m-%d")
-    log_filename = log_path / f"{log_filename_prefix}_{date_str}.log"
-
-    # Create or retrieve logger
-    logger = logging.getLogger()
-    logger.setLevel(logging.DEBUG)  # Capture everything, filter by handlers
+    logger = logging.getLogger(PACKAGE_NAME)
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False  # otherwise may affected by PaddleOCR
 
     # Clear existing handlers to avoid duplicate logs
     if logger.hasHandlers():
         logger.handlers.clear()
 
-    # File handler: rotates at midnight, keeps 7 days of logs
-    file_handler = TimedRotatingFileHandler(
-        filename=str(log_filename),
-        when="midnight",
-        interval=1,
-        backupCount=7,
-        encoding="utf-8",
-        utc=False,
-    )
-    file_formatter = logging.Formatter(
-        fmt="%(asctime)s [%(levelname)s] %(name)s.%(funcName)s: %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
-    )
-    file_handler.setFormatter(file_formatter)
-    file_handler.setLevel(logging.DEBUG)
-    logger.addHandler(file_handler)
+    # File handler (rotates daily)
+    if file:
+        file_level = _normalize_level(file_level)
+
+        base_dir = Path(log_dir) if log_dir else LOGGER_DIR
+        base_dir.mkdir(parents=True, exist_ok=True)
+        base_name = log_filename or PACKAGE_NAME
+        log_path = base_dir / f"{base_name}.log"
+
+        fh = TimedRotatingFileHandler(
+            filename=log_path,
+            when=when,
+            interval=1,
+            backupCount=backup_count,
+            encoding="utf-8",
+            utc=False,
+            delay=True,
+        )
+
+        file_formatter = logging.Formatter(
+            fmt="%(asctime)s [%(levelname)s] %(name)s.%(funcName)s: %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+        fh.setFormatter(file_formatter)
+        fh.setLevel(file_level)
+        logger.addHandler(fh)
+
+        print(f"Logging to {log_path}")
 
     # Console handler
-    console_handler = logging.StreamHandler()
-    console_formatter = logging.Formatter(
-        fmt="%(asctime)s [%(levelname)s] %(message)s", datefmt="%H:%M:%S"
-    )
-    console_handler.setFormatter(console_formatter)
-    console_handler.setLevel(console_level)
-    logger.addHandler(console_handler)
-
-    print(f"Logging to {log_path}")
+    if console:
+        console_level = _normalize_level(console_level)
+
+        console_handler = logging.StreamHandler()
+        console_formatter = logging.Formatter(
+            fmt="%(asctime)s [%(levelname)s] %(message)s",
+            datefmt="%H:%M:%S",
+        )
+        console_handler.setFormatter(console_formatter)
+        console_handler.setLevel(console_level)
+        logger.addHandler(console_handler)
 
     return logger

novel_downloader/utils/network.py

@@ -8,7 +8,6 @@ Utilities for handling HTTP requests and downloading remote resources.
 
 __all__ = ["download"]
 
-import logging
 from pathlib import Path
 from typing import Literal
 from urllib.parse import unquote, urlparse
@@ -19,10 +18,7 @@ from urllib3.util.retry import Retry
 
 from .constants import DEFAULT_HEADERS
 from .file_utils import sanitize_filename
-from .file_utils.io import _get_non_conflicting_path, _write_file
-
-logger = logging.getLogger(__name__)
-_DEFAULT_CHUNK_SIZE = 8192  # 8KB per chunk for streaming downloads
+from .file_utils.io import _unique_path, write_file
 
 
 def _normalize_url(url: str) -> str:
@@ -37,8 +33,8 @@ def _normalize_url(url: str) -> str:
 
 
 def _build_filepath(
-    folder: Path,
     url: str,
+    folder: Path,
     filename: str | None,
     default_suffix: str,
     on_exist: Literal["overwrite", "skip", "rename"],
@@ -48,20 +44,18 @@ def _build_filepath(
 
     raw_name = filename or url_path.name or "unnamed"
     name = sanitize_filename(raw_name)
-    suffix = default_suffix or url_path.suffix
-    if suffix and not suffix.startswith("."):
-        suffix = "." + suffix
 
-    file_path = folder / name
-    if not file_path.suffix and suffix:
-        file_path = file_path.with_suffix(suffix)
+    if "." not in name and (url_path.suffix or default_suffix):
+        name += url_path.suffix or default_suffix
 
+    file_path = folder / name
     if on_exist == "rename":
-        file_path = _get_non_conflicting_path(file_path)
+        file_path = _unique_path(file_path)
+
     return file_path
 
 
-def _make_session(
+def _new_session(
     retries: int,
     backoff: float,
     headers: dict[str, str] | None,
@@ -72,7 +66,7 @@ def _make_session(
     retry = Retry(
         total=retries,
         backoff_factor=backoff,
-        status_forcelist=[429, 500, 502, 503, 504],
+        status_forcelist=[413, 429, 500, 502, 503, 504],
         allowed_methods={"GET", "HEAD", "OPTIONS"},
     )
     adapter = HTTPAdapter(max_retries=retry)
@@ -90,10 +84,8 @@ def download(
     retries: int = 3,
     backoff: float = 0.5,
     headers: dict[str, str] | None = None,
-    stream: bool = False,
     on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
     default_suffix: str = "",
-    chunk_size: int = _DEFAULT_CHUNK_SIZE,
 ) -> Path | None:
     """
     Download a URL to disk, with retries, optional rename/skip, and cleanup on failure.
@@ -105,10 +97,8 @@ def download(
     :param retries: GET retry count.
     :param backoff: exponential backoff base.
     :param headers: optional headers.
-    :param stream: Whether to stream the response.
     :param on_exist: if 'skip', return filepath; if 'rename', auto-rename.
     :param default_suffix: used if no suffix in URL or filename.
-    :param chunk_size: streaming chunk size.
     :return: path to the downloaded file.
     """
     url = _normalize_url(url)
@@ -117,8 +107,8 @@ def download(
     folder.mkdir(parents=True, exist_ok=True)
 
     save_path = _build_filepath(
-        folder,
         url,
+        folder,
         filename,
         default_suffix,
         on_exist,
@@ -126,34 +116,20 @@ def download(
 
     # Handle existing file
     if save_path.exists() and on_exist == "skip":
-        logger.debug("Skipping download; file exists: %s", save_path)
         return save_path
 
-    with _make_session(retries, backoff, headers) as session:
+    with _new_session(retries, backoff, headers) as session:
         try:
-            resp = session.get(url, timeout=timeout, stream=stream)
+            resp = session.get(url, timeout=timeout)
             resp.raise_for_status()
-        except Exception as e:
-            logger.warning("[download] request failed: %s", e)
-            return None
 
-        # Write to disk
-        if stream:
-            try:
-                with open(save_path, "wb") as f:
-                    for chunk in resp.iter_content(chunk_size=chunk_size):
-                        if chunk:
-                            f.write(chunk)
-                return save_path
-            except Exception as e:
-                logger.warning("[download] write failed: %s", e)
-                save_path.unlink(missing_ok=True)
-                return None
-        else:
-            return _write_file(
+            # Write to disk
+            return write_file(
                 content=resp.content,
                 filepath=save_path,
-                write_mode="wb",
                 on_exist=on_exist,
             )
+        except Exception:
+            return None
+
     return None