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

novel_downloader/utils/epub/utils.py

@@ -10,14 +10,12 @@ Pure utility functions for EPUB assembly, including:
 """
 
 import hashlib
+from html import escape
 from pathlib import Path
 
-from lxml import etree, html
-
 from .constants import (
     CONTAINER_TEMPLATE,
     IMAGE_FOLDER,
-    PRETTY_PRINT_FLAG,
     ROOT_PATH,
 )
 
@@ -67,42 +65,43 @@ def build_book_intro(
 
     :return: A HTML string for inclusion in `intro.xhtml`
     """
-    root = html.Element("div")
-
-    # Main heading
-    h1 = etree.SubElement(root, "h1")
-    h1.text = "书籍简介"
-
-    # Metadata list
-    info_div = etree.SubElement(root, "div", {"class": "intro-info"})
-    ul = etree.SubElement(info_div, "ul")
-    _add_li(ul, "书名", f"《{book_name}》" if book_name else "")
-    _add_li(ul, "作者", author)
-    _add_li(ul, "分类", ", ".join(subject) if subject else "")
-    _add_li(ul, "字数", word_count)
-    _add_li(ul, "状态", serial_status)
-
-    # Summary section
-    if summary:
-        # force page break before summary
-        etree.SubElement(root, "p", {"class": "new-page-after"})
-        h2 = etree.SubElement(root, "h2")
-        h2.text = "简介"
+    lines = []
+
+    lines.append("<div>")
+    lines.append("<h1>书籍简介</h1>")
+    lines.append('<div class="intro-info">')
+    lines.append("<ul>")
+
+    name_val = f"《{book_name}》" if book_name else ""
+    subj_val = ", ".join(subject) if subject else ""
+
+    li_lines = [
+        _li_line("书名", name_val),
+        _li_line("作者", author),
+        _li_line("分类", subj_val),
+        _li_line("字数", word_count),
+        _li_line("状态", serial_status),
+    ]
+    for li in li_lines:
+        if li:
+            lines.append(li)
+
+    lines.append("</ul>")
+    lines.append("</div>")
 
-        summary_div = etree.SubElement(root, "div", {"class": "intro-summary"})
+    if summary:
+        lines.append('<p class="new-page-after"></p>')
+        lines.append("<h2>简介</h2>")
+        lines.append('<div class="intro-summary">')
         for line in summary.splitlines():
-            line = line.strip()
-            if not line:
+            s = line.strip()
+            if not s:
                 continue
-            p = etree.SubElement(summary_div, "p")
-            p.text = line
+            lines.append(f"<p>{escape(s, quote=True)}</p>")
+        lines.append("</div>")
 
-    html_string: str = html.tostring(
-        root,
-        pretty_print=PRETTY_PRINT_FLAG,
-        encoding="unicode",
-    )
-    return html_string
+    lines.append("</div>")
+    return "\n".join(lines)
 
 
 def build_volume_intro(
@@ -122,77 +121,45 @@ def build_volume_intro(
     :param volume_intro_text: multiline intro text for this volume
     :return: A HTML string for inclusion in `vol_<n>.xhtml`
     """
-    root = html.Element("div")
-
-    # Break the title into two lines if possible
     line1, line2 = _split_volume_title(volume_title)
 
-    header = etree.SubElement(root, "div", {"class": "vol-header"})
-
-    # Top decorative border
-    header.append(_make_vol_border_img(flip=False))
-
-    # Main title
-    h1 = etree.SubElement(header, "h1", {"class": "vol-title-main"})
-    h1.text = line1
-
-    # Bottom decorative border (flipped)
-    header.append(_make_vol_border_img(flip=True))
-
-    # Subtitle (if any)
+    lines = []
+    lines.append("<div>")
+    lines.append('<div class="vol-header">')
+    lines.append(_vol_border_div_str(flip=False))
+    lines.append(f'<h1 class="vol-title-main">{escape(line1, quote=True)}</h1>')
+    lines.append(_vol_border_div_str(flip=True))
     if line2:
-        h2 = etree.SubElement(header, "h2", {"class": "vol-title-sub"})
-        h2.text = line2
+        lines.append(f'<h2 class="vol-title-sub">{escape(line2, quote=True)}</h2>')
+    lines.append("</div>")
 
-    # Intro text paragraphs
     if volume_intro_text:
-        etree.SubElement(root, "p", {"class": "new-page-after"})
-
-        vol_div = etree.SubElement(root, "div", {"class": "vol-intro-text"})
+        lines.append('<p class="new-page-after"></p>')
+        lines.append('<div class="vol-intro-text">')
         for line in volume_intro_text.splitlines():
-            line = line.strip()
-            if not line:
+            s = line.strip()
+            if not s:
                 continue
-            p = etree.SubElement(vol_div, "p")
-            p.text = line
+            lines.append(f"<p>{escape(s, quote=True)}</p>")
+        lines.append("</div>")
 
-    html_string: str = html.tostring(
-        root,
-        pretty_print=PRETTY_PRINT_FLAG,
-        encoding="unicode",
-    )
-    return html_string
+    lines.append("</div>")
+    return "\n".join(lines)
 
 
-def _add_li(ul: etree._Element, label: str, value: str) -> None:
-    """
-    Append a `<li>` with 'label: value' if value is nonempty.
-    """
-    if value:
-        li = etree.SubElement(ul, "li")
-        li.text = f"{label}: {value}"
+def _li_line(label: str, value: str) -> str:
+    if not value:
+        return ""
+    return f"<li>{escape(label, quote=True)}: {escape(value, quote=True)}</li>"
 
 
-def _make_vol_border_img(flip: bool = False) -> html.HtmlElement:
-    """
-    Return a `<div>` containing the `volume_border.png` image,
-    styled by the given class name.
-    """
-    classes = ["vol-border"]
-    if flip:
-        classes.append("flip")
-    cls = " ".join(classes)
-
-    div = html.Element("div", {"class": cls})
-    etree.SubElement(
-        div,
-        "img",
-        {
-            "src": f"../{IMAGE_FOLDER}/volume_border.png",
-            "alt": "",
-        },
+def _vol_border_div_str(flip: bool = False) -> str:
+    classes = "vol-border" + (" flip" if flip else "")
+    return (
+        f'<div class="{classes}">'
+        f'<img src="../{IMAGE_FOLDER}/volume_border.png" alt="">'
+        f"</div>"
     )
-    return div
 
 
 def _split_volume_title(volume_title: str) -> tuple[str, str]:
@@ -202,10 +169,10 @@ def _split_volume_title(volume_title: str) -> tuple[str, str]:
     :param volume_title: Original volume title string.
     :return: Tuple of (line1, line2)
     """
-    if " " in volume_title:
-        parts = volume_title.split(" ", 1)
-    elif "-" in volume_title:
+    if "-" in volume_title:
         parts = volume_title.split("-", 1)
+    elif " " in volume_title:
+        parts = volume_title.split(" ", 1)
     else:
         return volume_title, ""
 

novel_downloader/utils/file_utils/__init__.py

@@ -4,35 +4,14 @@ novel_downloader.utils.file_utils
 ---------------------------------
 
 High-level file I/O utility re-exports for convenience.
-
-This module aggregates commonly used low-level file utilities such as:
-- Path sanitization (for safe filenames)
-- Text normalization (e.g. Windows/Linux line endings)
-- JSON, plain text, and binary file reading/writing
-
-Included utilities:
-- sanitize_filename: remove invalid characters from filenames
-- normalize_txt_line_endings: standardize line endings in text files
-- save_as_json / save_as_txt: write dict or text to file
-- read_text_file / read_json_file / read_binary_file: load content from file
 """
 
 __all__ = [
     "sanitize_filename",
-    "save_as_json",
-    "save_as_txt",
-    "read_text_file",
-    "read_json_file",
-    "read_binary_file",
+    "write_file",
     "normalize_txt_line_endings",
 ]
 
-from .io import (
-    read_binary_file,
-    read_json_file,
-    read_text_file,
-    save_as_json,
-    save_as_txt,
-)
+from .io import write_file
 from .normalize import normalize_txt_line_endings
 from .sanitize import sanitize_filename

novel_downloader/utils/file_utils/io.py

@@ -3,21 +3,10 @@
 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__ = [
-    "save_as_txt",
-    "save_as_json",
-    "read_text_file",
-    "read_json_file",
-    "read_binary_file",
-]
+__all__ = ["write_file"]
 
 import json
 import logging
@@ -46,7 +35,7 @@ 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,
     write_mode: str = "w",
@@ -115,102 +104,3 @@ def _write_file(
     except Exception as exc:
         logger.warning("[file] Error writing %r: %s", path, exc)
         return None
-
-
-def save_as_txt(
-    content: str,
-    filepath: str | Path,
-    *,
-    encoding: str = "utf-8",
-    on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
-) -> Path | None:
-    """
-    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: Path if writing succeeds, None otherwise.
-    """
-    return _write_file(
-        content=content,
-        filepath=filepath,
-        write_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",
-) -> Path | None:
-    """
-    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: Path if writing succeeds, None otherwise.
-    """
-    return _write_file(
-        content=content,
-        filepath=filepath,
-        write_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

novel_downloader/utils/file_utils/sanitize.py

@@ -5,10 +5,6 @@ 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"]

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/logger.py

@@ -14,11 +14,9 @@ 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,
@@ -28,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")
@@ -48,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
@@ -66,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():

novel_downloader/utils/network.py

@@ -19,7 +19,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
+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
@@ -150,7 +150,7 @@ def download(
                 save_path.unlink(missing_ok=True)
                 return None
         else:
-            return _write_file(
+            return write_file(
                 content=resp.content,
                 filepath=save_path,
                 write_mode="wb",