epub-generator 0.1.5__tar.gz → 0.1.7__tar.gz

{epub_generator-0.1.5 → epub_generator-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: epub-generator
-Version: 0.1.5
+Version: 0.1.7
 Summary: A simple Python EPUB 3.0 generator with a single API call
 License: MIT
 Keywords: epub,epub3,ebook,generator,publishing

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/__init__.py

@@ -17,10 +17,13 @@ from .types import (
     TextKind,
     TocItem,
 )
+from .validate import InvalidUnicodeError
 
 __all__ = [
     # Main API function
     "generate_epub",
+    # Validation
+    "InvalidUnicodeError",
     # Options
     "TableRender",
     "LaTeXRender",

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/context.py

@@ -18,6 +18,7 @@ class _AssetNode:
     media_type: str
     content_hash: str
 
+
 class Context:
     def __init__(
         self,
@@ -55,7 +56,7 @@ class Context:
         nodes = list(self._hash_to_node.values())
         nodes.sort(key=lambda node: node.file_name)
         return [(node.file_name, node.media_type) for node in nodes]
-    
+
     @property
     def chapters_with_mathml(self) -> set[str]:
         return self._chapters_with_mathml
@@ -117,6 +118,7 @@ class Context:
         )
         return file_name
 
+
 class Template:
     def __init__(self):
         templates_path = cast(Path, files("epub_generator")) / "data"
@@ -134,7 +136,8 @@ class Template:
             self._templates[name] = template
         return template
 
+
 def _sha256_hash(data: bytes) -> str:
     hash256 = sha256()
     hash256.update(data)
-    return hash256.hexdigest()
+    return hash256.hexdigest()

epub_generator-0.1.7/epub_generator/generation/__init__.py

@@ -0,0 +1 @@
+from .gen_epub import generate_epub

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/generation/gen_asset.py

@@ -22,13 +22,15 @@ _MEDIA_TYPE_MAP = {
 
 def render_inline_formula(context: Context, formula: Formula) -> Element | None:
     return _render_formula(
-        context=context, 
-        formula=formula, 
+        context=context,
+        formula=formula,
         inline_mode=True,
     )
 
 
-def render_asset_block(context: Context, block: Table | Formula | Image) -> Element | None: 
+def render_asset_block(
+    context: Context, block: Table | Formula | Image
+) -> Element | None:
     element: Element | None = None
     if isinstance(block, Table):
         element = _render_table(context, block)
@@ -44,17 +46,17 @@ def _render_table(context: Context, table: Table) -> Element | None:
         return None
 
     return _wrap_asset_content(
-        context=context, 
-        asset=table, 
+        context=context,
+        asset=table,
         content_element=render_html_tag(context, table.html_content),
     )
 
 
 def _render_formula(
-        context: Context,
-        formula: Formula,
-        inline_mode: bool,
-    ) -> Element | None:
+    context: Context,
+    formula: Formula,
+    inline_mode: bool,
+) -> Element | None:
 
     if context.latex_render == LaTeXRender.CLIPPING:
         return None
@@ -88,7 +90,7 @@ def _render_formula(
 
     return _wrap_asset_content(
         context=context,
-        asset=formula, 
+        asset=formula,
         content_element=content_element,
         inline_mode=inline_mode,
     )
@@ -106,11 +108,12 @@ def _process_image(context: Context, image: Image) -> Element:
     img_element.set("alt", "")  # Empty alt text, use caption instead
 
     return _wrap_asset_content(
-        context=context, 
-        asset=image, 
+        context=context,
+        asset=image,
         content_element=img_element,
     )
 
+
 def _normalize_expression(expression: str) -> str:
     expression = expression.replace("\n", "")
     expression = expression.strip()
@@ -159,7 +162,9 @@ def _latex_formula2svg(latex: str, font_size: int = 12):
         plt.rc("text", usetex=True)
         plt.rc("font", size=font_size)
         fig, ax = plt.subplots()
-        txt = ax.text(0.5, 0.5, f"${latex}$", ha="center", va="center", transform=ax.transAxes)
+        txt = ax.text(
+            0.5, 0.5, f"${latex}$", ha="center", va="center", transform=ax.transAxes
+        )
         ax.axis("off")
         fig.canvas.draw()
         bbox = txt.get_window_extent(cast(Any, fig.canvas).get_renderer())
@@ -174,7 +179,7 @@ def _latex_formula2svg(latex: str, font_size: int = 12):
         return output.getvalue()
     except Exception:
         return None
-    
+
 
 def _wrap_asset_content(
     context: Context,
@@ -182,7 +187,7 @@ def _wrap_asset_content(
     content_element: Element,
     inline_mode: bool = False,
 ) -> Element:
-    
+
     if inline_mode:
         wrapper = Element("span", attrib={"class": "formula-inline"})
     else:

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/generation/gen_chapter.py

@@ -16,7 +16,7 @@ from .gen_asset import render_asset_block
 from .gen_content import render_inline_content
 from .xml_utils import serialize_element, set_epub_type
 
-_MAX_HEADING_LEVEL = 6 # HTML standard defines heading levels from h1 to h6
+_MAX_HEADING_LEVEL = 6  # HTML standard defines heading levels from h1 to h6
 
 
 def generate_chapter(
@@ -28,15 +28,14 @@ def generate_chapter(
         template="part.xhtml",
         i18n=i18n,
         content=[
-            serialize_element(child)
-            for child in _render_contents(context, chapter)
+            serialize_element(child) for child in _render_contents(context, chapter)
         ],
         citations=[
-            serialize_element(child)
-            for child in _render_footnotes(context, chapter)
+            serialize_element(child) for child in _render_footnotes(context, chapter)
         ],
     )
 
+
 def _render_contents(
     context: Context,
     chapter: Chapter,
@@ -46,6 +45,7 @@ def _render_contents(
         if layout is not None:
             yield layout
 
+
 def _render_footnotes(
     context: Context,
     chapter: Chapter,
@@ -115,6 +115,6 @@ def _render_content_block(context: Context, block: ContentBlock) -> Element | No
             return blockquote
 
         return container
-    
+
     else:
         return None

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/generation/gen_content.py

@@ -6,9 +6,7 @@ from .xml_utils import set_epub_type
 
 
 def render_inline_content(
-    context: Context,
-    parent: Element,
-    content: list[str | Mark | Formula | HTMLTag]
+    context: Context, parent: Element, content: list[str | Mark | Formula | HTMLTag]
 ) -> None:
     current_element = parent
     for item in content:
@@ -31,6 +29,7 @@ def render_inline_content(
 
         elif isinstance(item, Formula):
             from .gen_asset import render_inline_formula  # avoid circular import
+
             formula_element = render_inline_formula(context, item)
             if formula_element is not None:
                 parent.append(formula_element)
@@ -56,4 +55,4 @@ def render_html_tag(context: Context, tag: HTMLTag) -> Element:
     for attr, value in tag.attributes:
         element.set(attr, value)
     render_inline_content(context, element, tag.content)
-    return element
+    return element

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/generation/gen_epub.py

@@ -6,13 +6,14 @@ from uuid import uuid4
 from zipfile import ZipFile
 
 from ..context import Context, Template
-from ..html_tag import search_content
 from ..i18n import I18N
 from ..options import LaTeXRender, TableRender
-from ..types import BasicAsset, Chapter, ContentBlock, EpubData, Formula, TextBlock
+from ..types import EpubData
+from ..validate import validate_chapter, validate_epub_data
 from .gen_chapter import generate_chapter
 from .gen_nav import gen_nav
 from .gen_toc import TocPoint, gen_toc, iter_toc
+from .xml_utils import MATHML_NS
 
 
 def generate_epub(
@@ -23,6 +24,9 @@ def generate_epub(
     latex_render: LaTeXRender = LaTeXRender.MATHML,
     assert_not_aborted: Callable[[], None] = lambda: None,
 ) -> None:
+    # Validate epub_data for invalid Unicode characters before processing
+    validate_epub_data(epub_data)
+
     i18n = I18N(lan)
     template = Template()
     epub_file_path = Path(epub_file_path)
@@ -114,12 +118,14 @@ def _write_chapters_from_data(
 ):
     for file_name, get_chapter in _search_chapters(epub_data, toc_points):
         chapter = get_chapter()
+        # Validate chapter content for invalid Unicode characters
+        validate_chapter(chapter, context=f"Chapter '{file_name}'")
         data = generate_chapter(context, chapter, i18n)
         context.file.writestr(
             zinfo_or_arcname="OEBPS/Text/" + file_name,
             data=data.encode("utf-8"),
         )
-        if latex_render == LaTeXRender.MATHML and _chapter_has_formula(chapter):
+        if latex_render == LaTeXRender.MATHML and MATHML_NS in data:
             context.mark_chapter_has_mathml(file_name)
         assert_not_aborted()
 
@@ -131,34 +137,6 @@ def _search_chapters(epub_data: EpubData, toc_points: list[TocPoint]):
         yield ref.file_name, ref.get_chapter
 
 
-def _chapter_has_formula(chapter: Chapter) -> bool:
-    for element in chapter.elements:
-        if _content_block_has_formula(element):
-            return True
-    for footnote in chapter.footnotes:
-        for content_block in footnote.contents:
-            if _content_block_has_formula(content_block):
-                return True
-    return False
-
-
-def _content_block_has_formula(content_block: ContentBlock) -> bool:
-    if isinstance(content_block, Formula):
-        return True
-    if isinstance(content_block, TextBlock):
-        for item in search_content(content_block.content):
-            if isinstance(item, Formula):
-                return True
-    if isinstance(content_block, BasicAsset):
-        for item in search_content(content_block.title):
-            if isinstance(item, Formula):
-                return True
-        for item in search_content(content_block.caption):
-            if isinstance(item, Formula):
-                return True
-    return False
-
-
 def _write_basic_files(
     context: Context,
     i18n: I18N,

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/generation/gen_toc.py

@@ -21,6 +21,7 @@ class TocPoint:
         """是否有对应的 XHTML 文件"""
         return self.ref is not None
 
+
 @dataclass
 class TocPointRef:
     part_id: str
@@ -40,10 +41,7 @@ def gen_toc(epub_data: EpubData) -> list[TocPoint]:
     chapters = epub_data.chapters
 
     toc_point_generation = _TocPointGenerator(
-        chapters_count=(
-            _count_toc_items(prefaces) +
-            _count_toc_items(chapters)
-        ),
+        chapters_count=(_count_toc_items(prefaces) + _count_toc_items(chapters)),
     )
     toc_points: list[TocPoint] = []
     for chapters_list in (prefaces, chapters):
@@ -91,15 +89,12 @@ class _TocPointGenerator:
                 file_name=f"part{part_id}.xhtml",
                 get_chapter=toc_item.get_chapter,
             )
-        order = self._next_order # 确保 order 以中序遍历为顺序
+        order = self._next_order  # 确保 order 以中序遍历为顺序
         self._next_order += 1
 
         return TocPoint(
-            title=toc_item.title, 
+            title=toc_item.title,
             order=order,
-            ref=ref, 
-            children=[
-                self._create_toc_point(child)
-                for child in toc_item.children
-            ],
+            ref=ref,
+            children=[self._create_toc_point(child) for child in toc_item.children],
         )

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/generation/xml_utils.py

@@ -1,19 +1,19 @@
 import re
-from typing import Container
 from xml.etree.ElementTree import Element, tostring
 
+MATHML_NS = "http://www.w3.org/1998/Math/MathML"
 _EPUB_NS = "http://www.idpf.org/2007/ops"
-_MATHML_NS = "http://www.w3.org/1998/Math/MathML"
 
 
 def set_epub_type(element: Element, epub_type: str) -> None:
     element.set(f"{{{_EPUB_NS}}}type", epub_type)
 
+
 def serialize_element(element: Element) -> str:
     xml_string = tostring(element, encoding="unicode")
     for prefix, namespace_uri, keep_xmlns in (
         ("epub", _EPUB_NS, False),  # EPUB namespace: remove xmlns (declared at root)
-        ("m", _MATHML_NS, True),     # MathML namespace: keep xmlns with clean prefix
+        ("m", MATHML_NS, True),  # MathML namespace: keep xmlns with clean prefix
     ):
         xml_string = xml_string.replace(f"{{{namespace_uri}}}", f"{prefix}:")
         pattern = r"xmlns:(ns\d+)=\"" + re.escape(namespace_uri) + r"\""
@@ -22,33 +22,29 @@ def serialize_element(element: Element) -> str:
         for ns_prefix in matches:
             if keep_xmlns:
                 xml_string = xml_string.replace(
-                    f" xmlns:{ns_prefix}=\"{namespace_uri}\"",
-                    f" xmlns:{prefix}=\"{namespace_uri}\""
+                    f' xmlns:{ns_prefix}="{namespace_uri}"',
+                    f' xmlns:{prefix}="{namespace_uri}"',
                 )
             else:
-                xml_string = xml_string.replace(f" xmlns:{ns_prefix}=\"{namespace_uri}\"", "")
+                xml_string = xml_string.replace(
+                    f' xmlns:{ns_prefix}="{namespace_uri}"', ""
+                )
             xml_string = xml_string.replace(f"{ns_prefix}:", f"{prefix}:")
 
     return xml_string
 
-def indent(elem: Element, level: int = 0, skip_tags: Container[str] = ()) -> Element:
+
+def indent(elem: Element, level: int = 0) -> Element:
     indent_str = "  " * level
     next_indent_str = "  " * (level + 1)
-
-    if elem.tag in skip_tags:
-        if level > 0 and (not elem.tail or not elem.tail.strip()):
-            elem.tail = "\n" + indent_str
-        return elem
-
     if len(elem):
         if not elem.text or not elem.text.strip():
             elem.text = "\n" + next_indent_str
         for i, child in enumerate(elem):
-            indent(child, level + 1, skip_tags)
-            if i < len(elem) - 1:
-                child.tail = "\n" + next_indent_str
-            else:
-                child.tail = "\n" + indent_str
-    elif level > 0 and (not elem.tail or not elem.tail.strip()):
-        elem.tail = "\n" + indent_str
+            indent(child, level + 1)
+            if not child.tail or not child.tail.strip():
+                if i == len(elem) - 1:
+                    child.tail = "\n" + indent_str
+                else:
+                    child.tail = "\n" + next_indent_str
     return elem

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/html_tag.py

@@ -3,9 +3,11 @@ from typing import Generator
 from .types import Formula, HTMLTag, Mark
 
 
-def search_content(content: list[str | Mark | Formula | HTMLTag]) -> Generator[str | Mark | Formula, None, None]:
+def search_content(
+    content: list[str | Mark | Formula | HTMLTag],
+) -> Generator[str | Mark | Formula, None, None]:
     for child in content:
         if isinstance(child, HTMLTag):
             yield from search_content(child.content)
         else:
-            yield child
+            yield child

{epub_generator-0.1.5 → epub_generator-0.1.7}/epub_generator/types.py

@@ -24,6 +24,7 @@ class EpubData:
     cover_image_path: Path | None = None
     """Cover image file path (optional, absolute path)"""
 
+
 @dataclass
 class BookMeta:
     """Book metadata information."""
@@ -57,9 +58,11 @@ class BookMeta:
 # Table of Contents structure
 # ============================================================================
 
+
 @dataclass
 class TocItem:
     """Table of contents item with title, content, and optional nested children."""
+
     title: str
     """Chapter title displayed in table of contents"""
 
@@ -69,6 +72,7 @@ class TocItem:
     children: "list[TocItem]" = field(default_factory=list)
     """Nested sub-chapters (recursive, optional)"""
 
+
 class TextKind(Enum):
     BODY = "body"
     """Regular paragraph."""
@@ -77,21 +81,29 @@ class TextKind(Enum):
     QUOTE = "quote"
     """Quoted text."""
 
+
 @dataclass
 class Mark:
     """Citation reference marker."""
+
     id: int
     """Citation ID, matches Footnote.id"""
 
+
 @dataclass
 class BasicAsset:
     """Asset as a base class for other assets."""
 
-    title: list["str | Mark | Formula | HTMLTag"] = field(default_factory=list, kw_only=True)
+    title: list["str | Mark | Formula | HTMLTag"] = field(
+        default_factory=list, kw_only=True
+    )
     """Asset title (before content)"""
-    caption: list["str | Mark | Formula | HTMLTag"] = field(default_factory=list, kw_only=True)
+    caption: list["str | Mark | Formula | HTMLTag"] = field(
+        default_factory=list, kw_only=True
+    )
     """Asset caption (after content)"""
 
+
 @dataclass
 class Table(BasicAsset):
     """Table representation."""
@@ -115,6 +127,7 @@ class Image(BasicAsset):
     path: Path
     """Absolute path to the image file"""
 
+
 @dataclass
 class TextBlock:
     """Text block representation."""
@@ -126,9 +139,11 @@ class TextBlock:
     content: list["str | Mark | Formula | HTMLTag"]
     """Text content with optional citation marks."""
 
+
 @dataclass
 class Footnote:
     """Footnote/citation section."""
+
     id: int
     """Footnote ID"""
 
@@ -142,17 +157,21 @@ class Footnote:
 ContentBlock = TextBlock | Table | Formula | Image
 """Union of all content blocks that appear in main chapter content."""
 
+
 @dataclass
 class Chapter:
     """Complete content of a single chapter."""
+
     elements: list[ContentBlock] = field(default_factory=list)
     """Main content blocks"""
 
     footnotes: list[Footnote] = field(default_factory=list)
     """Footnotes"""
 
+
 ChapterGetter = Callable[[], Chapter]
 
+
 @dataclass
 class HTMLTag:
     """Generic HTML tag representation."""
@@ -164,4 +183,4 @@ class HTMLTag:
     """List of (attribute, value) pairs"""
 
     content: list["str | Mark | Formula | HTMLTag"] = field(default_factory=list)
-    """Inner HTML content"""
+    """Inner HTML content"""

epub_generator-0.1.7/epub_generator/validate.py

@@ -0,0 +1,226 @@
+from .types import (
+    BasicAsset,
+    Chapter,
+    ContentBlock,
+    EpubData,
+    Footnote,
+    Formula,
+    HTMLTag,
+    Image,
+    Mark,
+    Table,
+    TextBlock,
+    TocItem,
+)
+
+
+class InvalidUnicodeError(Exception):
+    """Raised when invalid Unicode characters (surrogates) are detected in EPUB data."""
+
+    def __init__(self, field_path: str, invalid_char_info: str):
+        """Initialize with field path and character information.
+
+        Args:
+            field_path: Dot-separated path to the field containing invalid characters
+            invalid_char_info: Information about the invalid character(s)
+        """
+        self.field_path = field_path
+        self.invalid_char_info = invalid_char_info
+        super().__init__(
+            f"Invalid Unicode character detected in {field_path}: {invalid_char_info}"
+        )
+
+
+def validate_epub_data(epub_data: EpubData) -> None:
+    """Validate an EpubData object for invalid Unicode characters.
+
+    This function checks all string fields in the EPUB data structure including:
+    - Book metadata (title, description, authors, etc.)
+    - Table of contents titles (recursively)
+    - Chapter content is NOT validated here (use validate_chapter separately)
+
+    Args:
+        epub_data: EPUB data to validate
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected in any string field
+    """
+    # Check metadata
+    if epub_data.meta:
+        meta = epub_data.meta
+        _check_string(meta.title, "EpubData.meta.title")
+        _check_string(meta.description, "EpubData.meta.description")
+        _check_string(meta.publisher, "EpubData.meta.publisher")
+        _check_string(meta.isbn, "EpubData.meta.isbn")
+
+        for i, author in enumerate(meta.authors):
+            _check_string(author, f"EpubData.meta.authors[{i}]")
+
+        for i, editor in enumerate(meta.editors):
+            _check_string(editor, f"EpubData.meta.editors[{i}]")
+
+        for i, translator in enumerate(meta.translators):
+            _check_string(translator, f"EpubData.meta.translators[{i}]")
+
+    # Check prefaces TOC
+    for i, preface in enumerate(epub_data.prefaces):
+        _check_toc_item(preface, f"EpubData.prefaces[{i}]")
+
+    # Check chapters TOC
+    for i, chapter_toc in enumerate(epub_data.chapters):
+        _check_toc_item(chapter_toc, f"EpubData.chapters[{i}]")
+
+
+def validate_chapter(chapter: Chapter, context: str = "Chapter") -> None:
+    """Validate a Chapter object for invalid Unicode characters.
+
+    Args:
+        chapter: Chapter to validate
+        context: Context string for error reporting (e.g., "Chapter", "chapters[0]")
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected in any string field
+    """
+    # Check main content elements
+    for i, element in enumerate(chapter.elements):
+        _check_content_block(element, f"{context}.elements[{i}]")
+
+    # Check footnotes
+    for i, footnote in enumerate(chapter.footnotes):
+        _check_footnote(footnote, f"{context}.footnotes[{i}]")
+
+
+def _check_string(value: str | None, field_path: str) -> None:
+    """Check if a string contains surrogate characters.
+
+    Args:
+        value: String to check
+        field_path: Path to the field for error reporting
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected
+    """
+    if value is None:
+        return
+
+    for i, char in enumerate(value):
+        code_point = ord(char)
+        # Check for surrogate pair range (U+D800 to U+DFFF)
+        if 0xD800 <= code_point <= 0xDFFF:
+            raise InvalidUnicodeError(
+                field_path=field_path,
+                invalid_char_info=f"surrogate character U+{code_point:04X} at position {i}",
+            )
+
+
+def _check_string_list(
+    values: list[str | Mark | Formula | HTMLTag], field_path: str
+) -> None:
+    """Recursively check a list that may contain strings, marks, formulas, or HTML tags.
+
+    Args:
+        values: List to check
+        field_path: Path to the field for error reporting
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected
+    """
+    for i, item in enumerate(values):
+        item_path = f"{field_path}[{i}]"
+        if isinstance(item, str):
+            _check_string(item, item_path)
+        elif isinstance(item, Mark):
+            pass  # Mark only contains int ID
+        elif isinstance(item, Formula):
+            _check_string(item.latex_expression, f"{item_path}.latex_expression")
+            _check_string_list(item.title, f"{item_path}.title")
+            _check_string_list(item.caption, f"{item_path}.caption")
+        elif isinstance(item, HTMLTag):
+            _check_html_tag(item, item_path)
+
+
+def _check_html_tag(tag: HTMLTag, field_path: str) -> None:
+    """Check an HTML tag for invalid characters.
+
+    Args:
+        tag: HTML tag to check
+        field_path: Path to the field for error reporting
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected
+    """
+    _check_string(tag.name, f"{field_path}.name")
+
+    for i, (attr_name, attr_value) in enumerate(tag.attributes):
+        _check_string(attr_name, f"{field_path}.attributes[{i}][0]")
+        _check_string(attr_value, f"{field_path}.attributes[{i}][1]")
+
+    _check_string_list(tag.content, f"{field_path}.content")
+
+
+def _check_basic_asset(asset: BasicAsset, field_path: str) -> None:
+    """Check BasicAsset (and subclasses) for invalid characters.
+
+    Args:
+        asset: Asset to check
+        field_path: Path to the field for error reporting
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected
+    """
+    _check_string_list(asset.title, f"{field_path}.title")
+    _check_string_list(asset.caption, f"{field_path}.caption")
+
+    if isinstance(asset, Formula):
+        _check_string(asset.latex_expression, f"{field_path}.latex_expression")
+    elif isinstance(asset, Table):
+        _check_html_tag(asset.html_content, f"{field_path}.html_content")
+    elif isinstance(asset, Image):
+        pass  # Image only contains Path, no string content to check
+
+
+def _check_content_block(block: ContentBlock, field_path: str) -> None:
+    """Check a content block for invalid characters.
+
+    Args:
+        block: Content block to check
+        field_path: Path to the field for error reporting
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected
+    """
+    if isinstance(block, TextBlock):
+        _check_string_list(block.content, f"{field_path}.content")
+    elif isinstance(block, (Table, Formula, Image)):
+        _check_basic_asset(block, field_path)
+
+
+def _check_footnote(footnote: Footnote, field_path: str) -> None:
+    """Check a footnote for invalid characters.
+
+    Args:
+        footnote: Footnote to check
+        field_path: Path to the field for error reporting
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected
+    """
+    for i, content_block in enumerate(footnote.contents):
+        _check_content_block(content_block, f"{field_path}.contents[{i}]")
+
+
+def _check_toc_item(item: TocItem, field_path: str) -> None:
+    """Recursively check a TOC item for invalid characters.
+
+    Args:
+        item: TOC item to check
+        field_path: Path to the field for error reporting
+
+    Raises:
+        InvalidUnicodeError: If surrogate characters are detected
+    """
+    _check_string(item.title, f"{field_path}.title")
+
+    # Check nested children recursively
+    for i, child in enumerate(item.children):
+        _check_toc_item(child, f"{field_path}.children[{i}]")

{epub_generator-0.1.5 → epub_generator-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "epub-generator"
-version = "0.1.5"
+version = "0.1.7"
 description = "A simple Python EPUB 3.0 generator with a single API call"
 authors = ["Tao Zeyu <i@taozeyu.com>"]
 license = "MIT"
@@ -32,6 +32,7 @@ matplotlib = ">=3.10.1,<3.11.0"
 pylint = ">=3.0.0,<4.0.0"
 autopep8 = ">=2.0.0,<3.0.0"
 isort = ">=5.0.0,<6.0.0"
+ruff = "^0.15.0"
 
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]

epub_generator-0.1.5/epub_generator/generation/__init__.py

@@ -1 +0,0 @@
-from .gen_epub import generate_epub