epub-generator 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

epub_generator/__init__.py

@@ -1,4 +1,39 @@
-from .gen_epub import generate_epub_file
-from .types import TableRender, LaTeXRender
+from .generation import generate_epub
+from .options import LaTeXRender, TableRender
+from .types import (
+    BookMeta,
+    Chapter,
+    ChapterGetter,
+    ContentBlock,
+    EpubData,
+    Footnote,
+    Formula,
+    Image,
+    Mark,
+    Table,
+    Text,
+    TextKind,
+    TocItem,
+)
 
-__all__ = ["generate_epub_file", "template", "TableRender", "LaTeXRender"]
+__all__ = [
+    # Main API function
+    "generate_epub",
+    # Options
+    "TableRender",
+    "LaTeXRender",
+    # Data types
+    "EpubData",
+    "BookMeta",
+    "TocItem",
+    "Chapter",
+    "ChapterGetter",
+    "ContentBlock",
+    "Text",
+    "TextKind",
+    "Table",
+    "Formula",
+    "Image",
+    "Footnote",
+    "Mark",
+]

epub_generator/context.py

@@ -1,91 +1,141 @@
+from dataclasses import dataclass
+from hashlib import sha256
+from importlib.resources import files
 from pathlib import Path
 from typing import cast
 from zipfile import ZipFile
-from importlib.resources import files
-from jinja2 import Environment, Template as JinjaTemplate
 
+from jinja2 import Environment
+from jinja2 import Template as JinjaTemplate
+
+from .options import LaTeXRender, TableRender
 from .template import create_env
-from .types import TableRender, LaTeXRender
 
 
+@dataclass
+class _AssetNode:
+    file_name: str
+    media_type: str
+    content_hash: str
+
 class Context:
-  def __init__(
+    def __init__(
         self,
         file: ZipFile,
         template: "Template",
-        assets_path: Path | None,
         table_render: TableRender,
         latex_render: LaTeXRender,
-      ) -> None:
-
-    self._assets_path: Path | None = assets_path
-    self._file: ZipFile = file
-    self._template: Template = template
-    self._table_render: TableRender = table_render
-    self._latex_render: LaTeXRender = latex_render
-    self._used_file_names: dict[str, str] = {}
-
-  @property
-  def file(self) -> ZipFile:
-    return self._file
-  
-  @property
-  def template(self) -> "Template":
-    return self._template
-
-  @property
-  def table_render(self) -> TableRender:
-    return self._table_render
-
-  @property
-  def latex_render(self) -> LaTeXRender:
-    return self._latex_render
-
-  def use_asset(self, file_name: str, media_type: str) -> None:
-    self._used_file_names[file_name] = media_type
-
-  def add_asset(self, file_name: str, media_type: str, data: bytes) -> None:
-    if file_name in self._used_file_names:
-      return
-
-    self._used_file_names[file_name] = media_type
-    self._file.writestr(
-      zinfo_or_arcname="OEBPS/assets/" + file_name,
-      data=data,
-    )
-
-  @property
-  def used_files(self) -> list[tuple[str, str]]:
-    used_files: list[tuple[str, str]] = []
-    for file_name in sorted(list(self._used_file_names.keys())):
-      media_type = self._used_file_names[file_name]
-      used_files.append((file_name, media_type))
-    return used_files
-
-  def add_used_asset_files(self) -> None:
-    if self._assets_path is None:
-      return
-    for file in sorted(self._assets_path.iterdir()):
-      if file.name not in self._used_file_names:
-        continue
-      self._file.write(
-        filename=file,
-        arcname="OEBPS/assets/" + file.name,
-      )
+    ) -> None:
+        self._file: ZipFile = file
+        self._template: Template = template
+        self._table_render: TableRender = table_render
+        self._latex_render: LaTeXRender = latex_render
+        self._path_to_node: dict[Path, _AssetNode] = {}  # source_path -> node
+        self._hash_to_node: dict[str, _AssetNode] = {}  # content_hash -> node
+        self._chapters_with_mathml: set[str] = set()  # Track chapters containing MathML
+
+    @property
+    def file(self) -> ZipFile:
+        return self._file
+
+    @property
+    def template(self) -> "Template":
+        return self._template
+
+    @property
+    def table_render(self) -> TableRender:
+        return self._table_render
+
+    @property
+    def latex_render(self) -> LaTeXRender:
+        return self._latex_render
+
+    @property
+    def used_files(self) -> list[tuple[str, str]]:
+        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]
+
+    def mark_chapter_has_mathml(self, chapter_file_name: str) -> None:
+        """Mark a chapter as containing MathML content for EPUB 3.0 manifest properties."""
+        self._chapters_with_mathml.add(chapter_file_name)
+
+    def chapter_has_mathml(self, chapter_file_name: str) -> bool:
+        """Check if a chapter contains MathML content."""
+        return chapter_file_name in self._chapters_with_mathml
+
+    def use_asset(
+        self,
+        source_path: Path,
+        media_type: str,
+        file_ext: str,
+    ) -> str:
+        if source_path in self._path_to_node:
+            return self._path_to_node[source_path].file_name
+
+        if not source_path.exists():
+            raise FileNotFoundError(f"Asset file not found: {source_path}")
+
+        with open(source_path, "rb") as f:
+            content = f.read()
+        content_hash = _sha256_hash(content)
+
+        if content_hash in self._hash_to_node:
+            node = self._hash_to_node[content_hash]
+            self._path_to_node[source_path] = node
+            return node.file_name
+
+        file_name = f"{content_hash}{file_ext}"
+        node = _AssetNode(
+            file_name=file_name,
+            media_type=media_type,
+            content_hash=content_hash,
+        )
+        self._path_to_node[source_path] = node
+        self._hash_to_node[content_hash] = node
+        self._file.write(
+            filename=source_path,
+            arcname="OEBPS/assets/" + file_name,
+        )
+        return file_name
+
+    def add_asset(self, data: bytes, media_type: str, file_ext: str) -> str:
+        content_hash = _sha256_hash(data)
+        if content_hash in self._hash_to_node:
+            return self._hash_to_node[content_hash].file_name
+
+        file_name = f"{content_hash}{file_ext}"
+        node = _AssetNode(
+            file_name=file_name,
+            media_type=media_type,
+            content_hash=content_hash,
+        )
+        self._hash_to_node[content_hash] = node
+
+        self._file.writestr(
+            zinfo_or_arcname="OEBPS/assets/" + file_name,
+            data=data,
+        )
+        return file_name
 
 class Template:
-  def __init__(self):
-    templates_path = cast(Path, files("epub_generator")) / "data"
-    self._env: Environment = create_env(templates_path)
-    self._templates: dict[str, JinjaTemplate] = {}
-
-  def render(self, template: str, **params) -> str:
-    jinja_template: JinjaTemplate = self._template(template)
-    return jinja_template.render(**params)
-
-  def _template(self, name: str) -> JinjaTemplate:
-    template = self._templates.get(name, None)
-    if template is None:
-      template = self._env.get_template(name)
-      self._templates[name] = template
-    return template
+    def __init__(self):
+        templates_path = cast(Path, files("epub_generator")) / "data"
+        self._env: Environment = create_env(templates_path)
+        self._templates: dict[str, JinjaTemplate] = {}
+
+    def render(self, template: str, **params) -> str:
+        jinja_template: JinjaTemplate = self._template(template)
+        return jinja_template.render(**params)
+
+    def _template(self, name: str) -> JinjaTemplate:
+        template = self._templates.get(name, None)
+        if template is None:
+            template = self._env.get_template(name)
+            self._templates[name] = template
+        return template
+
+def _sha256_hash(data: bytes) -> str:
+    hash256 = sha256()
+    hash256.update(data)
+    return hash256.hexdigest()

epub_generator/data/content.opf.jinja

@@ -1,58 +1,60 @@
 <?xml version="1.0" encoding="utf-8"?>
-<package version="2.0" xmlns="http://www.idpf.org/2007/opf" unique-identifier="uid">
-  <metadata xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:opf="http://www.idpf.org/2007/opf">
-    <dc:language>zh</dc:language>
+<package version="3.0" xmlns="http://www.idpf.org/2007/opf" unique-identifier="uid" xml:lang="zh">
+  <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
     <dc:identifier id="uid">{{ ISBN }}</dc:identifier>
-{% if "title" in meta %}
-    <dc:title>{{ meta["title"] }}</dc:title>
+    <dc:language>zh</dc:language>
+{% if meta and meta.title %}
+    <dc:title>{{ meta.title }}</dc:title>
 {% else %}
     <dc:title>{{ i18n.unnamed }}</dc:title>
 {% endif %}
-{% if "description" in meta %}
-    <dc:description>{{ meta["description"] }}</dc:description>
+{% if meta and meta.description %}
+    <dc:description>{{ meta.description }}</dc:description>
 {% endif %}
-{% if "publisher" in meta %}
-    <dc:publisher>{{ meta["publisher"] }}</dc:publisher>
+{% if meta and meta.publisher %}
+    <dc:publisher>{{ meta.publisher }}</dc:publisher>
 {% endif %}
-{% if "authors" in meta %}
-{% for author in meta["authors"] %}
-    <dc:creator opf:role="aut">{{ author }}</dc:creator>
+{% if meta and meta.authors %}
+{% for author in meta.authors %}
+    <dc:creator id="creator{{ loop.index }}">{{ author }}</dc:creator>
+    <meta refines="#creator{{ loop.index }}" property="role" scheme="marc:relators">aut</meta>
 {% endfor %}
 {% endif %}
-{% if "editors" in meta %}
-{% for editor in meta["editors"] %}
-    <dc:creator opf:role="edt">{{ editor }}</dc:creator>
+{% if meta and meta.editors %}
+{% for editor in meta.editors %}
+    <dc:creator id="editor{{ loop.index }}">{{ editor }}</dc:creator>
+    <meta refines="#editor{{ loop.index }}" property="role" scheme="marc:relators">edt</meta>
 {% endfor %}
 {% endif %}
-{% if "translators" in meta %}
-{% for translator in meta["translators"] %}
-    <dc:creator opf:role="trl">{{ translator }}</dc:creator>
+{% if meta and meta.translators %}
+{% for translator in meta.translators %}
+    <dc:creator id="translator{{ loop.index }}">{{ translator }}</dc:creator>
+    <meta refines="#translator{{ loop.index }}" property="role" scheme="marc:relators">trl</meta>
 {% endfor %}
 {% endif %}
+    <meta property="dcterms:modified">{{ modified_timestamp }}</meta>
 {% if has_cover %}
-    <meta name="cover" content="a_cover" />
+    <meta name="cover" content="cover-image" />
 {% endif %}
-    <meta name="output encoding" content="utf-8" />
-    <meta name="primary-writing-mode" content="horizontal-lr" />
   </metadata>
   <manifest>
+    <item id="nav" properties="nav" media-type="application/xhtml+xml" href="nav.xhtml" />
     <item id="a_css" media-type="text/css" href="styles/style.css" />
 {% for asset_file, media_type in asset_files %}
     <item id="a_{{ asset_file|safe }}" media-type="{{ media_type|safe }}" href="assets/{{ asset_file|safe }}" />
-{% endfor%}
+{% endfor %}
 {% if has_cover %}
-    <item id="a_cover" media-type="image/png" href="assets/cover.png" />
+    <item id="cover-image" properties="cover-image" media-type="image/png" href="assets/cover.png" />
     <item id="x_cover.xhtml" media-type="application/xhtml+xml" href="Text/cover.xhtml" />
 {% endif %}
 {% if has_head_chapter %}
     <item id="x_head.xhtml" media-type="application/xhtml+xml" href="Text/head.xhtml" />
 {% endif %}
 {% for nav_point in nav_points %}
-    <item id="x_{{ nav_point.file_name|safe }}" media-type="application/xhtml+xml" href="Text/{{ nav_point.file_name|safe }}" />
+    <item id="x_{{ nav_point.file_name|safe }}" media-type="application/xhtml+xml" href="Text/{{ nav_point.file_name|safe }}"{% if nav_point.file_name in chapters_with_mathml %} properties="mathml"{% endif %} />
 {% endfor %}
-    <item id="ncx" media-type="application/x-dtbncx+xml" href="toc.ncx" />
   </manifest>
-  <spine toc="ncx">
+  <spine>
 {% if has_cover %}
     <itemref idref="x_cover.xhtml" linear="no" />
 {% endif %}

epub_generator/data/cover.xhtml.jinja

@@ -1,8 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh">
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" xml:lang="zh" lang="zh">
 
 <head>
+  <meta charset="utf-8"/>
   <title>{{ i18n.cover }}</title>
 </head>
 

epub_generator/data/nav.xhtml.jinja

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" xml:lang="zh" lang="zh">
+<head>
+  <meta charset="utf-8"/>
+  <title>{{ i18n.table_of_contents }}</title>
+  <link href="styles/style.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+  <nav epub:type="toc" id="toc" role="doc-toc">
+    <h1>{{ i18n.table_of_contents }}</h1>
+    <ol>
+{% if has_cover %}
+      <li>
+        <a href="Text/cover.xhtml">{{ i18n.cover }}</a>
+      </li>
+{% endif %}
+{% if has_head_chapter %}
+      <li>
+        <a href="Text/head.xhtml">{{ head_chapter_title }}</a>
+      </li>
+{% endif %}
+{{ toc_list|safe }}
+    </ol>
+  </nav>
+
+  <nav epub:type="landmarks" id="landmarks" hidden="hidden">
+    <h2>{{ i18n.landmarks }}</h2>
+    <ol>
+{% if has_cover %}
+      <li>
+        <a epub:type="cover" href="Text/cover.xhtml">{{ i18n.cover }}</a>
+      </li>
+{% endif %}
+{% if first_chapter_file %}
+      <li>
+        <a epub:type="bodymatter" href="Text/{{ first_chapter_file }}">{{ i18n.start_of_content }}</a>
+      </li>
+{% endif %}
+    </ol>
+  </nav>
+</body>
+</html>

epub_generator/data/part.xhtml.jinja

@@ -1,9 +1,10 @@
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml">
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" xml:lang="zh" lang="zh">
 
 <head>
-  <title></title>
+  <meta charset="utf-8"/>
+  <title>Chapter</title>
   <link href="../styles/style.css" rel="stylesheet" type="text/css"/>
 </head>
 
@@ -12,10 +13,11 @@
   {{ item|safe }}
   {% endfor %}
   {% if citations %}
-  <h2>{{ i18n.references }}</h2>
-  {% for item in citations %}
-  {{ item|safe }}
-  {% endfor %}
+  <section epub:type="footnotes" role="doc-endnotes">
+    {% for item in citations %}
+    {{ item|safe }}
+    {% endfor %}
+  </section>
   {% endif %}
 </body>
 

epub_generator/generation/__init__.py

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

epub_generator/generation/gen_asset.py

@@ -0,0 +1,142 @@
+import io
+import re
+from typing import Any, cast
+from xml.etree.ElementTree import Element, fromstring
+
+import matplotlib.pyplot as plt
+from latex2mathml.converter import convert
+
+from ..context import Context
+from ..options import LaTeXRender, TableRender
+from ..types import Formula, Image, Table
+
+_MEDIA_TYPE_MAP = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+}
+
+def process_table(context: Context, table: Table) -> Element | None:
+    if context.table_render == TableRender.CLIPPING:
+        return None
+    try:
+        wrapped_html = f"<div>{table.html_content}</div>"
+        parsed = fromstring(wrapped_html)
+        wrapper = Element("div", attrib={"class": "alt-wrapper"})
+
+        for child in parsed:
+            wrapper.append(child)
+
+        return wrapper if len(wrapper) > 0 else None
+    except Exception:
+        return None
+
+
+def process_formula(context: Context, formula: Formula) -> Element | None:
+    if context.latex_render == LaTeXRender.CLIPPING:
+        return None
+
+    latex_expr = _normalize_expression(formula.latex_expression)
+    if not latex_expr:
+        return None
+
+    if context.latex_render == LaTeXRender.MATHML:
+        return _latex2mathml(latex_expr)
+
+    elif context.latex_render == LaTeXRender.SVG:
+        svg_image = _latex_formula2svg(latex_expr)
+        if svg_image is None:
+            return None
+        file_name = context.add_asset(
+            data=svg_image, 
+            media_type="image/svg+xml", 
+            file_ext=".svg",
+        )
+        img_element = Element("img")
+        img_element.set("src", f"../assets/{file_name}")
+        img_element.set("alt", "formula")
+
+        wrapper = Element("div", attrib={"class": "alt-wrapper"})
+        wrapper.append(img_element)
+        return wrapper
+
+    return None
+
+def process_image(context: Context, image: Image) -> Element | None:
+    file_ext = image.path.suffix or ".png"
+    file_name = context.use_asset(
+        source_path=image.path, 
+        media_type=_MEDIA_TYPE_MAP.get(file_ext.lower(), "image/png"), 
+        file_ext=file_ext,
+    )
+    img_element = Element("img")
+    img_element.set("src", f"../assets/{file_name}")
+    img_element.set("alt", image.alt_text)
+
+    wrapper = Element("div", attrib={"class": "alt-wrapper"})
+    wrapper.append(img_element)
+    return wrapper
+
+
+_ESCAPE_UNICODE_PATTERN = re.compile(r"&#x([0-9A-Fa-f]{5});")
+
+
+def _latex2mathml(latex: str) -> None | Element:
+    try:
+        html_latex = convert(latex)
+    except Exception:
+        return None
+
+    # latex2mathml 转义会带上一个奇怪的 `&` 前缀，这显然是多余的
+    # 不得已，在这里用正则表达式处理以修正这个错误
+    def repl(match):
+        hex_code = match.group(1)
+        char = chr(int(hex_code, 16))
+        if char == "<":
+            return "&lt;"
+        elif char == ">":
+            return "&gt;"
+        else:
+            return char
+
+    mathml = re.sub(
+        pattern=_ESCAPE_UNICODE_PATTERN,
+        repl=repl,
+        string=html_latex,
+    )
+    try:
+        return fromstring(mathml)
+    except Exception:
+        return None
+
+
+def _latex_formula2svg(latex: str, font_size: int = 12):
+    # from https://www.cnblogs.com/qizhou/p/18170083
+    try:
+        output = io.BytesIO()
+        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)
+        ax.axis("off")
+        fig.canvas.draw()
+        bbox = txt.get_window_extent(cast(Any, fig.canvas).get_renderer())
+        fig.set_size_inches(bbox.width / fig.dpi, bbox.height / fig.dpi)
+        plt.savefig(
+            output,
+            format="svg",
+            transparent=True,
+            bbox_inches="tight",
+            pad_inches=0,
+        )
+        return output.getvalue()
+    except Exception:
+        return None
+
+
+def _normalize_expression(expression: str) -> str:
+    expression = expression.replace("\n", "")
+    expression = expression.strip()
+    return expression