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

novel_downloader/utils/epub/utils.py

@@ -4,20 +4,18 @@ 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
+  * Computing file hashes
+  * Generating META-INF/container.xml
+  * Constructing HTML snippets for the book intro and volume intro
 """
 
 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,
 )
 
@@ -61,48 +59,49 @@ def build_book_intro(
     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
+      * 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 = "简介"
+    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(
@@ -113,86 +112,54 @@ def build_volume_intro(
     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
+      * 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)
+    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,214 +3,79 @@
 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
 import tempfile
 from pathlib import Path
-from typing import Any, Literal
+from typing import Literal
 
 from .sanitize import sanitize_filename
 
-logger = logging.getLogger(__name__)
-
-_JSON_INDENT_THRESHOLD = 50 * 1024  # bytes
-
-
-def _get_non_conflicting_path(path: Path) -> Path:
-    """
-    If the path exists, generate a new one by appending _1, _2, etc.
-    """
-    counter = 1
-    new_path = path
-    while new_path.exists():
-        stem = path.stem
-        suffix = path.suffix
-        new_path = path.with_name(f"{stem}_{counter}{suffix}")
-        counter += 1
-    return new_path
-
-
-def _write_file(
-    content: str | bytes | dict[Any, Any] | list[Any] | Any,
-    filepath: str | Path,
-    write_mode: str = "w",
-    *,
-    on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
-    dump_json: bool = False,
-    encoding: str = "utf-8",
-) -> Path | None:
-    """
-    Write content to a file safely with optional atomic behavior
-    and JSON serialization.
-
-    :param content: The content to write; can be text, bytes, or a
-        JSON-serializable object.
-    :param filepath: Destination path (str or Path).
-    :param mode: File mode ('w', 'wb'). Auto-determined if None.
-    :param on_exist: Behavior if file exists: 'overwrite', 'skip',
-        or 'rename'.
-    :param dump_json: If True, serialize content as JSON.
-    :param encoding: Text encoding for writing.
-    :return: Path if writing succeeds, None otherwise.
-    """
-    path = Path(filepath)
-    path = path.with_name(sanitize_filename(path.name))
-    path.parent.mkdir(parents=True, exist_ok=True)
-
-    if path.exists():
-        if on_exist == "skip":
-            logger.debug("[file] '%s' exists, skipping", path)
-            return path
-        if on_exist == "rename":
-            path = _get_non_conflicting_path(path)
-            logger.debug("[file] Renaming target to avoid conflict: %s", path)
-        else:
-            logger.debug("[file] '%s' exists, will overwrite", path)
-
-    # Prepare content and write mode
-    content_to_write: str | bytes
-    if dump_json:
-        # Serialize original object to JSON string
-        json_str = json.dumps(content, ensure_ascii=False, indent=2)
-        if len(json_str.encode(encoding)) > _JSON_INDENT_THRESHOLD:
-            json_str = json.dumps(content, ensure_ascii=False, separators=(",", ":"))
-        content_to_write = json_str
-        write_mode = "w"
-    else:
-        if isinstance(content, (str | bytes)):
-            content_to_write = content
-        else:
-            raise TypeError("Non-JSON content must be str or bytes.")
-        write_mode = "wb" if isinstance(content, bytes) else "w"
-
-    try:
-        with tempfile.NamedTemporaryFile(
-            mode=write_mode,
-            encoding=None if "b" in write_mode else encoding,
-            newline=None if "b" in write_mode else "\n",
-            delete=False,
-            dir=path.parent,
-        ) as tmp:
-            tmp.write(content_to_write)
-            tmp_path = Path(tmp.name)
-        tmp_path.replace(path)
-        logger.debug("[file] '%s' written successfully", path)
-        return path
-    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:
+def _unique_path(path: Path, max_tries: int = 100) -> Path:
     """
-    Save plain text content to the given file path.
+    Return a unique file path by appending _1, _2, ... if needed.
 
-    :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.
+    Falls back to a UUID suffix if all attempts fail.
     """
-    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.
+    if not path.exists():
+        return 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,
-    )
+    stem = path.stem
+    suffix = path.suffix
 
+    for counter in range(1, max_tries + 1):
+        candidate = path.with_name(f"{stem}_{counter}{suffix}")
+        if not candidate.exists():
+            return candidate
 
-def read_text_file(filepath: str | Path, encoding: str = "utf-8") -> str | None:
-    """
-    Read a UTF-8 text file.
+    # fallback: append a random/unique suffix
+    import uuid
 
-    :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
+    return path.with_name(f"{stem}_{uuid.uuid4().hex}{suffix}")
 
 
-def read_json_file(filepath: str | Path, encoding: str = "utf-8") -> Any | None:
+def write_file(
+    content: str | bytes,
+    filepath: str | Path,
+    *,
+    on_exist: Literal["overwrite", "skip", "rename"] = "overwrite",
+    encoding: str = "utf-8",
+) -> Path:
     """
-    Read a JSON file and parse it into Python objects.
+    Write content to a file safely with atomic replacement.
 
-    :param filepath: Path to file.
-    :param encoding: Encoding to use.
-    :return: Python object or None on failure.
+    :param content: The content to write; can be text or bytes.
+    :param filepath: Destination path.
+    :param on_exist: Behavior if file exists.
+    :param encoding: Text encoding for writing.
+    :return: The final path where the content was written.
+    :raise: Any I/O error such as PermissionError or OSError
     """
     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.
+    path = path.with_name(sanitize_filename(path.name))
+    path.parent.mkdir(parents=True, exist_ok=True)
 
-    :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
+    if path.exists():
+        match on_exist:
+            case "skip":
+                return path
+            case "rename":
+                path = _unique_path(path)
+
+    write_mode = "wb" if isinstance(content, bytes) else "w"
+
+    with tempfile.NamedTemporaryFile(
+        mode=write_mode,
+        encoding=None if "b" in write_mode else encoding,
+        newline=None if "b" in write_mode else "\n",
+        delete=False,
+        dir=path.parent,
+    ) as tmp:
+        tmp.write(content)
+        tmp_path = Path(tmp.name)
+    tmp_path.replace(path)
+    return path

novel_downloader/utils/file_utils/normalize.py

@@ -14,8 +14,6 @@ __all__ = ["normalize_txt_line_endings"]
 import logging
 from pathlib import Path
 
-logger = logging.getLogger(__name__)
-
 
 def normalize_txt_line_endings(folder_path: str | Path) -> None:
     """
@@ -28,7 +26,6 @@ def normalize_txt_line_endings(folder_path: str | Path) -> None:
     """
     path = Path(folder_path).resolve()
     if not path.exists() or not path.is_dir():
-        logger.warning("[file] Invalid folder: %s", path)
         return
 
     count_success, count_fail = 0, 0
@@ -38,13 +35,10 @@ def normalize_txt_line_endings(folder_path: str | Path) -> None:
             content = txt_file.read_text(encoding="utf-8")
             normalized = content.replace("\r\n", "\n").replace("\r", "\n")
             txt_file.write_text(normalized, encoding="utf-8", newline="\n")
-            logger.debug("[file] Normalized: %s", txt_file)
             count_success += 1
-        except (OSError, UnicodeDecodeError) as e:
-            logger.warning("[file] Failed: %s | %s", txt_file, e)
+        except (OSError, UnicodeDecodeError):
             count_fail += 1
 
-    logger.info("[file] Completed. Success: %s, Failed: %s", count_success, count_fail)
     return
 
 

novel_downloader/utils/file_utils/sanitize.py

@@ -5,21 +5,13 @@ 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
 
-logger = logging.getLogger(__name__)
-
-# Windows 保留名称列表 (忽略大小写)
 _WIN_RESERVED_NAMES = {
     "CON",
     "PRN",
@@ -40,8 +32,8 @@ def sanitize_filename(filename: str, max_length: int | None = 255) -> str:
 
     This function checks the operating system environment and applies the appropriate
     filtering rules:
-      - On Windows, it replaces characters: <>:"/\\|?*
-      - On POSIX systems, it replaces the forward slash '/'
+      * On Windows, it replaces characters: <>:"/\\|?*
+      * On POSIX systems, it replaces the forward slash '/'
 
     :param filename: The input filename to sanitize.
     :param max_length: Optional maximum length of the output filename. Defaults to 255.
@@ -51,7 +43,7 @@ def sanitize_filename(filename: str, max_length: int | None = 255) -> str:
 
     name = pattern.sub("_", filename).strip(" .")
 
-    stem, dot, ext = name.partition(".")
+    stem, dot, ext = name.rpartition(".")
     if os.name == "nt" and stem.upper() in _WIN_RESERVED_NAMES:
         stem = f"_{stem}"
     cleaned = f"{stem}{dot}{ext}" if ext else stem
@@ -63,7 +55,4 @@ def sanitize_filename(filename: str, max_length: int | None = 255) -> str:
         else:
             cleaned = cleaned[:max_length]
 
-    if not cleaned:
-        cleaned = "_untitled"
-    logger.debug("[file] Sanitized filename: %r -> %r", filename, cleaned)
-    return cleaned
+    return cleaned or "_untitled"

novel_downloader/utils/fontocr/__init__.py

@@ -3,20 +3,11 @@
 novel_downloader.utils.fontocr
 ------------------------------
 
-Utilities for font-based OCR, primarily used to decode custom font obfuscation
-
-Supports:
-- Font rendering and perceptual hash matching
-- PaddleOCR-based character recognition
-- Frequency-based scoring for ambiguous results
-- Debugging and font mapping persistence
-
-Exposes the selected OCR engine version via `FontOCR`.
+Lazy-loading interface for FontOCR. Provides a safe entry point
+to obtain an OCR utility instance if optional dependencies are available.
 """
 
-__all__ = ["FontOCR"]
-__version__ = "3.0"
+__all__ = ["get_font_ocr"]
+__version__ = "4.0"
 
-# from .ocr_v1 import FontOCRV1 as FontOCR
-# from .ocr_v2 import FontOCRV2 as FontOCR
-from .ocr_v3 import FontOCRV3 as FontOCR
+from .loader import get_font_ocr