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

novel_downloader/utils/epub/utils.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.epub.utils
+---------------------------------
+
+Pure utility functions for EPUB assembly, including:
+- Computing file hashes
+- Generating META-INF/container.xml
+- Constructing HTML snippets for the book intro and volume intro
+"""
+
+import hashlib
+from pathlib import Path
+
+from lxml import etree, html
+
+from .constants import (
+    CONTAINER_TEMPLATE,
+    IMAGE_FOLDER,
+    PRETTY_PRINT_FLAG,
+    ROOT_PATH,
+)
+
+
+def hash_file(file_path: Path, chunk_size: int = 8192) -> str:
+    """
+    Compute the SHA256 hash of a file.
+
+    :param file_path: The Path object of the file to hash.
+    :param chunk_size: The chunk size to read the file (default: 8192).
+    :return: The SHA256 hash string (lowercase hex) of the file content.
+    """
+    h = hashlib.sha256()
+    with file_path.open("rb") as f:
+        while chunk := f.read(chunk_size):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def build_container_xml(
+    root_path: str = ROOT_PATH,
+) -> str:
+    """
+    Generate the XML content for META-INF/container.xml in an EPUB archive.
+
+    :param root_path: The folder where the OPF file is stored.
+    :return: A string containing the full XML for container.xml.
+    """
+    return CONTAINER_TEMPLATE.format(root_path=root_path)
+
+
+def build_book_intro(
+    book_name: str,
+    author: str,
+    serial_status: str,
+    subject: list[str],
+    word_count: str,
+    summary: str,
+) -> str:
+    """
+    Build the HTML snippet for the overall book introduction.
+
+    This includes:
+      - A main heading ("Book Introduction")
+      - A list of metadata items (title, author, categories, word count, status)
+      - A "Summary" subheading and one or more paragraphs of summary text
+
+    :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 = "简介"
+
+        summary_div = etree.SubElement(root, "div", {"class": "intro-summary"})
+        for line in summary.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            p = etree.SubElement(summary_div, "p")
+            p.text = line
+
+    html_string: str = html.tostring(
+        root,
+        pretty_print=PRETTY_PRINT_FLAG,
+        encoding="unicode",
+    )
+    return html_string
+
+
+def build_volume_intro(
+    volume_title: str,
+    volume_intro_text: str = "",
+) -> str:
+    """
+    Build the HTML snippet for a single-volume introduction.
+
+    This includes:
+      - A decorative border image (top and bottom)
+      - A primary heading (volume main title)
+      - An optional secondary line (subtitle)
+      - One or more paragraphs of intro text
+
+    :param volume_title: e.g. "Volume 1 - The Beginning"
+    :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)
+    if line2:
+        h2 = etree.SubElement(header, "h2", {"class": "vol-title-sub"})
+        h2.text = line2
+
+    # 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"})
+        for line in volume_intro_text.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            p = etree.SubElement(vol_div, "p")
+            p.text = line
+
+    html_string: str = html.tostring(
+        root,
+        pretty_print=PRETTY_PRINT_FLAG,
+        encoding="unicode",
+    )
+    return html_string
+
+
+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 _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": "",
+        },
+    )
+    return div
+
+
+def _split_volume_title(volume_title: str) -> tuple[str, str]:
+    """
+    Split volume title into two parts for better display.
+
+    :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:
+        parts = volume_title.split("-", 1)
+    else:
+        return volume_title, ""
+
+    return parts[0], parts[1]

novel_downloader/utils/file_utils/__init__.py

@@ -17,18 +17,6 @@ Included utilities:
 - read_text_file / read_json_file / read_binary_file: load content from file
 """
 
-from .io import (
-    load_blacklisted_words,
-    load_text_resource,
-    read_binary_file,
-    read_json_file,
-    read_text_file,
-    save_as_json,
-    save_as_txt,
-)
-from .normalize import normalize_txt_line_endings
-from .sanitize import sanitize_filename
-
 __all__ = [
     "sanitize_filename",
     "save_as_json",
@@ -36,7 +24,15 @@ __all__ = [
     "read_text_file",
     "read_json_file",
     "read_binary_file",
-    "load_text_resource",
-    "load_blacklisted_words",
     "normalize_txt_line_endings",
 ]
+
+from .io import (
+    read_binary_file,
+    read_json_file,
+    read_text_file,
+    save_as_json,
+    save_as_txt,
+)
+from .normalize import normalize_txt_line_endings
+from .sanitize import sanitize_filename

novel_downloader/utils/file_utils/io.py

@@ -11,10 +11,17 @@ Includes:
 - Simple helpers for reading files with fallback and logging
 """
 
+__all__ = [
+    "save_as_txt",
+    "save_as_json",
+    "read_text_file",
+    "read_json_file",
+    "read_binary_file",
+]
+
 import json
 import logging
 import tempfile
-from importlib.resources import files
 from pathlib import Path
 from typing import Any, Literal
 
@@ -42,12 +49,12 @@ def _get_non_conflicting_path(path: Path) -> Path:
 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 +67,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 +76,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,10 +111,10 @@ 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
+        return None
 
 
 def save_as_txt(
@@ -116,7 +123,7 @@ def save_as_txt(
     *,
     encoding: str = "utf-8",
     on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
-) -> bool:
+) -> Path | None:
     """
     Save plain text content to the given file path.
 
@@ -124,12 +131,12 @@ def save_as_txt(
     :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: Path if writing succeeds, None otherwise.
     """
     return _write_file(
         content=content,
         filepath=filepath,
-        mode="w",
+        write_mode="w",
         on_exist=on_exist,
         dump_json=False,
         encoding=encoding,
@@ -142,7 +149,7 @@ def save_as_json(
     *,
     encoding: str = "utf-8",
     on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
-) -> bool:
+) -> Path | None:
     """
     Save JSON-serializable content to the given file path.
 
@@ -150,12 +157,12 @@ def save_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: Path if writing succeeds, None otherwise.
     """
     return _write_file(
         content=content,
         filepath=filepath,
-        mode="w",
+        write_mode="w",
         on_exist=on_exist,
         dump_json=True,
         encoding=encoding,
@@ -207,41 +214,3 @@ def read_binary_file(filepath: str | Path) -> bytes | None:
     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

@@ -11,6 +11,8 @@ 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 +67,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/__init__.py

@@ -14,9 +14,9 @@ Supports:
 Exposes the selected OCR engine version via `FontOCR`.
 """
 
-# from .ocr_v1 import FontOCRV1 as FontOCR
-from .ocr_v2 import FontOCRV2 as FontOCR
-
-__version__ = "v2"
-
 __all__ = ["FontOCR"]
+__version__ = "3.0"
+
+# from .ocr_v1 import FontOCRV1 as FontOCR
+# from .ocr_v2 import FontOCRV2 as FontOCR
+from .ocr_v3 import FontOCRV3 as FontOCR

novel_downloader/utils/{hash_store.py → fontocr/hash_store.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.utils.hash_store
----------------------------------
+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.
@@ -15,10 +15,11 @@ from pathlib import Path
 
 from PIL import Image
 
-from .constants import HASH_STORE_FILE
+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:

novel_downloader/utils/{hash_utils.py → fontocr/hash_utils.py}

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.utils.hash_utils
----------------------------------
+novel_downloader.utils.fontocr.hash_utils
+-----------------------------------------
 
 Utilities for image perceptual hashing and comparison.
 

novel_downloader/utils/fontocr/ocr_v1.py

@@ -24,8 +24,8 @@ from novel_downloader.utils.constants import (
     REC_CHAR_MODEL_FILES,
     REC_IMAGE_SHAPE_MAP,
 )
-from novel_downloader.utils.hash_store import img_hash_store
 
+from .hash_store import img_hash_store
 from .model_loader import get_rec_chinese_char_model_dir
 
 logger = logging.getLogger(__name__)
@@ -301,3 +301,15 @@ class FontOCRV1:
             logger.error("[FontOCR] Failed to save fixed map: %s", e)
 
         return mapping_result
+
+    @staticmethod
+    def apply_font_mapping(text: str, font_map: dict[str, str]) -> str:
+        """
+        Replace each character in `text` using `font_map`,
+        leaving unmapped characters unchanged.
+
+        :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 "".join(font_map.get(ch, ch) for ch in text)

novel_downloader/utils/fontocr/ocr_v2.py

@@ -35,8 +35,8 @@ from novel_downloader.utils.constants import (
     REC_CHAR_MODEL_FILES,
     REC_IMAGE_SHAPE_MAP,
 )
-from novel_downloader.utils.hash_store import img_hash_store
 
+from .hash_store import img_hash_store
 from .model_loader import (
     get_rec_char_vector_dir,
     get_rec_chinese_char_model_dir,
@@ -750,3 +750,15 @@ class FontOCRV2:
             logger.error("[FontOCR] Failed to save fixed map: %s", e)
 
         return mapping_result
+
+    @staticmethod
+    def apply_font_mapping(text: str, font_map: dict[str, str]) -> str:
+        """
+        Replace each character in `text` using `font_map`,
+        leaving unmapped characters unchanged.
+
+        :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 "".join(font_map.get(ch, ch) for ch in text)