epub-generator 0.0.1__py3-none-any.whl

epub_generator/__init__.py

@@ -0,0 +1,4 @@
+from .gen_epub import generate_epub_file
+from .types import TableRender, LaTeXRender
+
+__all__ = ["generate_epub_file", "template", "TableRender", "LaTeXRender"]

epub_generator/context.py

@@ -0,0 +1,90 @@
+from pathlib import Path
+from zipfile import ZipFile
+from importlib.resources import files
+from jinja2 import Environment, Template as JinjaTemplate
+
+from .template import create_env
+from .types import TableRender, LaTeXRender
+
+
+class Context:
+  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,
+      )
+
+class Template:
+  def __init__(self):
+    templates_path = files("pdf_craft") / "data" / "templates"
+    self._env: Environment = create_env(templates_path)
+    self._templates: dict[str, JinjaTemplate] = {}
+
+  def render(self, template: str, **params) -> str:
+    template: JinjaTemplate = self._template(template)
+    return template.render(**params)
+
+  def _template(self, name: str) -> JinjaTemplate:
+    template: JinjaTemplate = self._templates.get(name, None)
+    if template is None:
+      template = self._env.get_template(name)
+      self._templates[name] = template
+    return template

epub_generator/gen_asset.py

@@ -0,0 +1,133 @@
+import io
+import re
+import matplotlib.pyplot as plt
+
+from xml.etree.ElementTree import fromstring, Element
+from latex2mathml.converter import convert
+from .hash import sha256_hash
+from .types import LaTeXRender
+from .context import Context
+
+
+def try_gen_table(context: Context, element: Element) -> list[Element] | None:
+  if context.table_render == LaTeXRender.CLIPPING:
+    return None
+
+  table_html = _find_child(element, ("html",))
+  children: list[Element] = []
+  if table_html is not None:
+    for child in table_html:
+      children.append(child)
+
+  return children
+
+def try_gen_formula(context: Context, element: Element) -> Element | None:
+  if context.latex_render == LaTeXRender.CLIPPING:
+    return None
+
+  latex = (element.text or "").strip()
+  if not latex:
+    return None
+
+  latex_expr = _normalize_expression(latex)
+  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 = f"{sha256_hash(svg_image)}.svg"
+    img_element = _create_image_element(file_name, element)
+    context.add_asset(file_name, "image/svg+xml", svg_image)
+
+    return img_element
+
+def try_gen_asset(context: Context, element: Element) -> Element | None:
+  hash = element.get("hash", None)
+  if hash is None:
+    return None
+
+  file_name = f"{hash}.png"
+  context.use_asset(file_name, "image/png")
+
+  return _create_image_element(file_name, element)
+
+_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(renderer=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 _create_image_element(file_name: str, origin: Element):
+  img_element = Element("img")
+  img_element.set("src", f"../assets/{file_name}")
+  alt: str | None = None
+
+  if origin.text:
+    alt = origin.text
+  if alt is None:
+    img_element.set("alt", "image")
+  else:
+    img_element.set("alt", alt)
+
+  return img_element
+
+def _find_child(parent: Element, tags: tuple[str, ...]) -> Element | None:
+  for child in parent:
+    if child.tag in tags:
+      return child
+  return None
+
+def _normalize_expression(expression: str) -> str:
+  expression = expression.replace("\n", "")
+  expression = expression.strip()
+  return expression

epub_generator/gen_epub.py

@@ -0,0 +1,178 @@
+import json
+
+from os import PathLike
+from pathlib import Path
+from typing import Literal
+from uuid import uuid4
+from zipfile import ZipFile
+from xml.etree.ElementTree import fromstring, Element
+
+from .types import TableRender, LaTeXRender
+from .gen_part import generate_part
+from .gen_index import gen_index, NavPoint
+from .i18n import I18N
+from .context import Context, Template
+
+
+def generate_epub_file(
+      from_dir_path: PathLike,
+      epub_file_path: PathLike,
+      lan: Literal["zh", "en"] = "zh",
+      table_render: TableRender = TableRender.HTML,
+      latex_render: LaTeXRender = LaTeXRender.MATHML,
+    ) -> None:
+
+  i18n = I18N(lan)
+  template = Template()
+  from_dir_path = Path(from_dir_path)
+  epub_file_path = Path(epub_file_path)
+  index_path = from_dir_path / "index.json"
+  meta_path = from_dir_path / "meta.json"
+  assets_path: Path | None = from_dir_path / "assets"
+  chapters_path: Path = from_dir_path / "chapters"
+  head_chapter_path = chapters_path / "chapter.xml"
+
+  toc_ncx: str
+  nav_points: list[NavPoint] = []
+  meta: dict = {}
+  has_head_chapter: bool = head_chapter_path.exists()
+  has_cover: bool = (from_dir_path / "cover.png").exists()
+
+  if meta_path.exists():
+    with open(meta_path, "r", encoding="utf-8") as f:
+      meta = json.loads(f.read())
+
+  if not assets_path.exists():
+    assets_path = None
+
+  toc_ncx, nav_points = gen_index(
+    template=template,
+    i18n=i18n,
+    meta=meta,
+    index_file_path=index_path,
+    has_cover=has_cover,
+    check_chapter_exits=lambda id: (chapters_path / f"chapter_{id}.xml").exists(),
+  )
+  epub_base_path = epub_file_path.parent
+  epub_base_path.mkdir(parents=True, exist_ok=True)
+
+  with ZipFile(epub_file_path, "w") as file:
+    context = Context(
+      file=file,
+      template=template,
+      assets_path=assets_path,
+      table_render=table_render,
+      latex_render=latex_render,
+    )
+    file.writestr(
+      zinfo_or_arcname="mimetype",
+      data=template.render("mimetype").encode("utf-8"),
+    )
+    file.writestr(
+      zinfo_or_arcname="OEBPS/toc.ncx",
+      data=toc_ncx.encode("utf-8"),
+    )
+    _write_chapters(
+      context=context,
+      i18n=i18n,
+      nav_points=nav_points,
+      chapters_path=chapters_path,
+      has_head_chapter=has_head_chapter,
+      head_chapter_path=head_chapter_path,
+    )
+    _write_basic_files(
+      context=context,
+      i18n=i18n,
+      meta=meta,
+      nav_points=nav_points,
+      has_cover=has_cover,
+      has_head_chapter=has_head_chapter,
+    )
+    _write_assets(
+      context=context,
+      i18n=i18n,
+      from_dir_path=from_dir_path,
+      has_cover=has_cover,
+    )
+
+def _write_assets(
+    context: Context,
+    i18n: I18N,
+    from_dir_path: Path,
+    has_cover: bool,
+  ):
+  context.file.writestr(
+    zinfo_or_arcname="OEBPS/styles/style.css",
+    data=context.template.render("style.css").encode("utf-8"),
+  )
+  if has_cover:
+    context.file.writestr(
+      zinfo_or_arcname="OEBPS/Text/cover.xhtml",
+      data=context.template.render(
+        template="cover.xhtml",
+        i18n=i18n,
+      ).encode("utf-8"),
+    )
+  if has_cover:
+    context.file.write(
+      filename=from_dir_path / "cover.png",
+      arcname="OEBPS/assets/cover.png",
+    )
+  context.add_used_asset_files()
+
+def _write_chapters(
+    context: Context,
+    i18n: I18N,
+    nav_points: list[NavPoint],
+    chapters_path: Path,
+    has_head_chapter: bool,
+    head_chapter_path: Path,
+  ):
+
+  if has_head_chapter:
+    chapter_xml = _read_xml(head_chapter_path)
+    data = generate_part(context, chapter_xml, i18n)
+    context.file.writestr(
+      zinfo_or_arcname="OEBPS/Text/head.xhtml",
+      data=data.encode("utf-8"),
+    )
+  for nav_point in nav_points:
+    chapter_path = chapters_path / f"chapter_{nav_point.index_id}.xml"
+    if chapter_path.exists():
+      chapter_xml = _read_xml(chapter_path)
+      data = generate_part(context, chapter_xml, i18n)
+      context.file.writestr(
+        zinfo_or_arcname="OEBPS/Text/" + nav_point.file_name,
+        data=data.encode("utf-8"),
+      )
+
+def _write_basic_files(
+    context: Context,
+    i18n: I18N,
+    meta: dict,
+    nav_points: list[NavPoint],
+    has_cover: bool,
+    has_head_chapter: bool,
+  ):
+  context.file.writestr(
+    zinfo_or_arcname="META-INF/container.xml",
+    data=context.template.render("container.xml").encode("utf-8"),
+  )
+  content = context.template.render(
+    template="content.opf",
+    meta=meta,
+    i18n=i18n,
+    ISBN=meta.get("ISBN", str(uuid4())),
+    nav_points=nav_points,
+    has_head_chapter=has_head_chapter,
+    has_cover=has_cover,
+    asset_files=context.used_files,
+  )
+  context.file.writestr(
+    zinfo_or_arcname="OEBPS/content.opf",
+    data=content.encode("utf-8"),
+  )
+
+def _read_xml(path: Path) -> Element:
+  with open(path, "r", encoding="utf-8") as file:
+    return fromstring(file.read())

epub_generator/gen_index.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+from json import loads
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+from xml.etree.ElementTree import tostring, Element
+from .i18n import I18N
+from .context import Template
+
+
+@dataclass
+class NavPoint:
+  index_id: int
+  order: int
+  file_name: str
+
+def gen_index(
+    template: Template,
+    i18n: I18N,
+    meta: dict,
+    index_file_path: Path,
+    has_cover: bool,
+    check_chapter_exits: Callable[[int], bool],
+  ) -> tuple[str, list[NavPoint]]:
+
+  nav_elements: list[Element]
+  nav_points: list[NavPoint]
+  depth: int
+
+  if index_file_path.exists():
+    prefaces, chapters = _parse_index(index_file_path)
+    nav_point_generation = _NavPointGeneration(
+      has_cover=has_cover,
+      check_chapter_exits=check_chapter_exits,
+      chapters_count=(
+        _count_chapters(prefaces) +
+        _count_chapters(chapters)
+      ),
+    )
+    nav_elements = []
+    for chapters_list in (prefaces, chapters):
+      for chapter in chapters_list:
+        element = nav_point_generation.generate(chapter)
+        if element is not None:
+          nav_elements.append(element)
+
+    depth = max(
+      _max_depth(prefaces),
+      _max_depth(chapters),
+    )
+    nav_points = nav_point_generation.nav_points
+
+  else:
+    nav_elements = []
+    nav_points = []
+    depth = 0
+
+  toc_ncx = template.render(
+    template="toc.ncx",
+    depth=depth,
+    i18n=i18n,
+    meta=meta,
+    has_cover=has_cover,
+    nav_points=[tostring(p, encoding="unicode") for p in nav_elements],
+  )
+  return toc_ncx, nav_points
+
+def _count_chapters(chapters: list[_Chapter]) -> int:
+  count: int = 0
+  for chapter in chapters:
+    count += 1 + _count_chapters(chapter.children)
+  return count
+
+def _max_depth(chapters: list[_Chapter]) -> int:
+  max_depth: int = 0
+  for chapter in chapters:
+    max_depth = max(
+      max_depth,
+      _max_depth(chapter.children) + 1,
+    )
+  return max_depth
+
+class _NavPointGeneration:
+  def __init__(self, has_cover: bool, chapters_count: int, check_chapter_exits: Callable[[int], bool]):
+    self._nav_points: list[NavPoint] = []
+    self._next_order: int = 2 if has_cover else 1
+    self._digits = len(str(chapters_count))
+    self._check_chapter_exits: Callable[[int], bool] = check_chapter_exits
+
+  @property
+  def nav_points(self) -> list[NavPoint]:
+    return self._nav_points
+
+  def generate(self, chapter: _Chapter) -> Element | None:
+    if not self._check_chapter_exits(chapter.id):
+      return None
+
+    part_id = str(chapter.id).zfill(self._digits)
+    file_name = f"part{part_id}.xhtml"
+    order = self._next_order
+
+    nav_point_xml = Element("navPoint")
+    nav_point_xml.set("id", f"np_{chapter.id}")
+    nav_point_xml.set("playOrder", str(order))
+
+    label_xml = Element("navLabel")
+    label_text_xml = Element("text")
+    label_text_xml.text = chapter.headline
+    label_xml.append(label_text_xml)
+
+    content_xml = Element("content")
+    content_xml.set("src", f"Text/{file_name}")
+
+    nav_point_xml.append(label_xml)
+    nav_point_xml.append(content_xml)
+
+    self._next_order += 1
+    self._nav_points.append(NavPoint(
+      index_id=chapter.id,
+      order=order,
+      file_name=file_name,
+    ))
+    for child in chapter.children:
+      child_xml = self.generate(child)
+      if child_xml is not None:
+        nav_point_xml.append(child_xml)
+
+    return nav_point_xml
+
+@dataclass
+class _Chapter:
+  id: int
+  headline: str
+  children: list[_Chapter]
+
+def _parse_index(file_path: Path) -> tuple[list[_Chapter], list[_Chapter]]:
+  data: dict | list
+  with open(file_path, "r", encoding="utf-8") as file:
+    data = loads(file.read())
+  if isinstance(data, list):
+    return [], _transform_chapters(data)
+  elif isinstance(data, dict):
+    return (
+      _transform_chapters(data["prefaces"]),
+      _transform_chapters(data["chapters"]),
+    )
+
+def _transform_chapters(data_list: list) -> list[_Chapter]:
+  chapters: list[_Chapter] = []
+  for data in data_list:
+    chapters.append(_Chapter(
+      id=int(data["id"]),
+      headline=data["headline"],
+      children=_transform_chapters(data["children"]),
+    ))
+  return chapters

epub_generator/gen_part.py

@@ -0,0 +1,126 @@
+from typing import Generator
+from xml.etree.ElementTree import tostring, Element
+
+from .i18n import I18N
+from .context import Context
+from .gen_asset import try_gen_table, try_gen_formula, try_gen_asset
+
+
+def generate_part(
+      context: Context,
+      chapter_xml: Element,
+      i18n: I18N,
+    ) -> str:
+
+  return context.template.render(
+    template="part.xhtml",
+    i18n=i18n,
+    content=[
+      tostring(child, encoding="unicode")
+      for child in _render_contents(context, chapter_xml)
+    ],
+    citations=[
+      tostring(child, encoding="unicode")
+      for child in _render_footnotes(context, chapter_xml)
+    ],
+  )
+
+_XML2HTML_TAGS: dict[str, str] = {
+  "headline": "h1",
+  "quote": "p",
+  "text": "p",
+}
+
+def _render_contents(context: Context, chapter_element: Element) -> Generator[Element, None, None]:
+  for child in chapter_element:
+    layout = _render_layout(context, child)
+    if layout is not None:
+      yield layout
+
+def _render_footnotes(context: Context, chapter_element: Element):
+  for footnote in chapter_element:
+    if footnote.tag != "footnote":
+      continue
+
+    found_mark = False
+    citation_div = Element("div", attrib={
+      "class": "citation",
+    })
+    for child in footnote:
+      if child.tag == "mark":
+        found_mark = True
+      else:
+        layout = _render_layout(context, child)
+        if layout is not None:
+          citation_div.append(layout)
+
+    if not found_mark or len(citation_div) == 0:
+      continue
+
+    footnote_id = int(footnote.get("id"))
+    ref = Element("a")
+    ref.text = f"[{footnote_id}]"
+    ref.attrib = {
+      "id": f"mark-{footnote_id}",
+      "href": f"#ref-{footnote_id}",
+      "class": "citation",
+    }
+    first_layout = citation_div[0]
+    if first_layout.tag == "p":
+      ref.tail = first_layout.text
+      first_layout.text = None
+      first_layout.insert(0, ref)
+    else:
+      inject_p = Element("p")
+      inject_p.append(ref)
+      citation_div.insert(0, inject_p)
+
+    yield citation_div
+
+def _render_layout(context: Context, raw_layout: Element) -> Element | None:
+  if raw_layout.tag == "footnote":
+    pass
+
+  elif raw_layout.tag in _XML2HTML_TAGS:
+    layout = Element(_XML2HTML_TAGS[raw_layout.tag])
+    layout.text = raw_layout.text
+    for mark in raw_layout:
+      assert mark.tag == "mark"
+      mark_id = int(mark.get("id"))
+      anchor = Element("a")
+      anchor.attrib = {
+        "id": f"ref-{mark_id}",
+        "href": f"#mark-{mark_id}",
+        "class": "super",
+      }
+      layout.append(anchor)
+      anchor.text = f"[{mark_id}]"
+      anchor.tail = mark.tail
+
+    if raw_layout.tag == "quote":
+      blockquote = Element("blockquote")
+      blockquote.append(layout)
+      return blockquote
+    else:
+      return layout
+
+  else:
+    asset_wrapper = Element("div", attrib={
+      "class": "alt-wrapper",
+    })
+    if raw_layout.tag == "table":
+      asset_wrapper.extend(try_gen_table(context, raw_layout))
+    elif raw_layout.tag == "formula":
+      formula = try_gen_formula(context, raw_layout)
+      if formula is not None:
+        asset_wrapper.append(formula)
+
+    if len(asset_wrapper) == 0:
+      asset = try_gen_asset(context, raw_layout)
+      if asset is not None:
+        asset_wrapper.append(asset)
+
+    if len(asset_wrapper) > 0:
+      return asset_wrapper
+
+  return None

epub_generator/hash.py

@@ -0,0 +1,7 @@
+from hashlib import sha256
+
+
+def sha256_hash(data: bytes) -> str:
+  hash256 = sha256()
+  hash256.update(data)
+  return hash256.hexdigest()

epub_generator/i18n.py

@@ -0,0 +1,13 @@
+from typing import Literal
+
+
+class I18N:
+  def __init__(self, lan: Literal["zh", "en"]):
+    if lan == "zh":
+      self.unnamed: str = "未命名"
+      self.cover: str = "封面"
+      self.references: str = "引用"
+    elif lan == "en":
+      self.unnamed: str = "Unnamed"
+      self.cover: str = "Cover"
+      self.references: str = "References"

epub_generator/template.py

@@ -0,0 +1,50 @@
+import re
+
+from typing import Tuple, Callable
+from pathlib import Path
+from jinja2 import select_autoescape, Environment, BaseLoader, TemplateNotFound
+
+
+def create_env(dir_path: Path) -> Environment:
+  return Environment(
+    loader=_DSLoader(dir_path),
+    autoescape=select_autoescape(),
+    trim_blocks=True,
+    keep_trailing_newline=True,
+  )
+
+_LoaderResult = Tuple[str, str | None, Callable[[], bool] | None]
+
+class _DSLoader(BaseLoader):
+  def __init__(self, dir_path: Path):
+    super().__init__()
+    self._dir_path: Path = dir_path
+
+  def get_source(self, _: Environment, template: str) -> _LoaderResult:
+    template = self._norm_template(template)
+    target_path = (self._dir_path / template).resolve()
+
+    if not target_path.exists():
+      raise TemplateNotFound(f"cannot find {template}")
+
+    return self._get_source_with_path(target_path)
+
+  def _norm_template(self, template: str) -> str:
+    if bool(re.match(r"^\.+/", template)):
+      raise TemplateNotFound(f"invalid path {template}")
+
+    template = re.sub(r"^/", "", template)
+    template = re.sub(r"\.jinja$", "", template, flags=re.IGNORECASE)
+    template = f"{template}.jinja"
+
+    return template
+
+  def _get_source_with_path(self, path: Path) -> _LoaderResult:
+    mtime = path.stat().st_mtime
+    with open(path, "r", encoding="utf-8") as f:
+      source = f.read()
+
+    def is_updated() -> bool:
+      return mtime == path.stat().st_mtime
+
+    return source, path, is_updated

epub_generator/types.py

@@ -0,0 +1,11 @@
+from enum import auto, Enum
+
+
+class TableRender(Enum):
+  HTML = auto()
+  CLIPPING = auto()
+
+class LaTeXRender(Enum):
+  MATHML = auto()
+  SVG = auto()
+  CLIPPING = auto()

epub_generator-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Moskize91
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

epub_generator-0.0.1.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.3
+Name: epub-generator
+Version: 0.0.1
+Summary: 
+License: MIT
+Author: Tao Zeyu
+Author-email: i@taozeyu.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
+Requires-Dist: latex2mathml (>=3.77.0,<4.0.0)
+Requires-Dist: matplotlib (>=3.10.1,<3.11.0)
+Description-Content-Type: text/markdown
+
+# epub-generator

epub_generator-0.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+epub_generator/__init__.py,sha256=BTAVO_YqMdArhQQQN1aNsXIiPATpqZzb6OWVuAQyoNI,160
+epub_generator/context.py,sha256=hWauz9eza6b_k0zgjZSA9hhSqYMiRAQ2cZ8H6BIA34k,2626
+epub_generator/gen_asset.py,sha256=52K92RWzioRka2uzU94s1gnL0BqcaFmPrOsKgC77_Nc,3567
+epub_generator/gen_epub.py,sha256=Dvi6AsnQbQ3uOU0fcXfazTM3g9U1mnccWM68VIuJq10,4834
+epub_generator/gen_index.py,sha256=nwyE0pzeVHKKRT0xC7THXuSRsiaiS2mQA84LLjXpkgI,4141
+epub_generator/gen_part.py,sha256=t9XZIqzJdtdxnFZqPGvJpVWqT68jTZNSaQ9T973NEFo,3319
+epub_generator/hash.py,sha256=EUIrpST9vAvSy8-kfPeBqemUfYyNXbZXF90fS1I355E,138
+epub_generator/i18n.py,sha256=zGpM4TpESqMPr57f-WsUlK1UDo3wTdAL6H5o9OhQ6xc,349
+epub_generator/template.py,sha256=GdV3QnypProKFCMH1kBNfdt6wiShygP_-xGnE5EOUwU,1460
+epub_generator/types.py,sha256=zSd6SOytrcjzuOGuRYa49TcnSvGRJmGXO3e7_Im_t9k,170
+epub_generator-0.0.1.dist-info/LICENSE,sha256=9Zt_a4mrzkvR2rc0UbqTgbboIjWuumDFgeQyKos0H2E,1066
+epub_generator-0.0.1.dist-info/METADATA,sha256=9ULGGqSBwFTkXDjWO1rDHXamwlh7-H18_UI4hQvUASU,596
+epub_generator-0.0.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+epub_generator-0.0.1.dist-info/RECORD,,

epub_generator-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any