epub-translator 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

epub_translator/xml/decoder.py

@@ -0,0 +1,71 @@
+from typing import Generator, Iterable
+from xml.etree.ElementTree import Element
+
+from .tag import Tag, TagKind
+from .parser import parse_tags
+from .transform import tag_to_element
+from .utils import clone
+
+# why implement XML decoding?
+# https://github.com/oomol-lab/pdf-craft/issues/149
+def decode_friendly(chars: Iterable[str], tags: Iterable[str] | str = ()) -> Generator[Element, None, None]:
+  if isinstance(tags, str):
+    tags = set((tags,))
+  else:
+    tags = set(tags)
+
+  for element in _collect_elements(chars):
+    if element.tag in tags or len(tags) == 0:
+      yield clone(element)
+
+def _collect_elements(chars: Iterable[str]) -> Generator[Element, None, None]:
+  opening_stack: list[Element] = []
+  last_closed_element: Element | None = None
+
+  for cell in parse_tags(chars):
+    if isinstance(cell, Tag):
+      tag: Tag = cell
+      element = tag_to_element(tag)
+      if tag.kind == TagKind.CLOSING:
+        popped = _pop_element(tag.name, opening_stack)
+        if popped is not None:
+          yield popped
+          last_closed_element = popped
+        elif last_closed_element is not None:
+          _append_to_tail(last_closed_element, tag.proto)
+      else:
+        if opening_stack:
+          opening_stack[-1].append(element)
+        if tag.kind == TagKind.SELF_CLOSING:
+          yield element
+          last_closed_element = element
+        elif tag.kind == TagKind.OPENING:
+          opening_stack.append(element)
+          last_closed_element = None
+
+    elif last_closed_element is not None:
+      _append_to_tail(last_closed_element, cell)
+
+    elif opening_stack:
+      opening_stack[-1].text = cell
+
+def _append_to_tail(element: Element, text: str) -> None:
+  if element.tail:
+    element.tail += text
+  else:
+    element.tail = text
+
+def _pop_element(tag_name: str, opening_stack: list[Element]) -> Element | None:
+  index = -1
+  for i in range(len(opening_stack) - 1, -1, -1):
+    opening_element = opening_stack[i]
+    if tag_name == opening_element.tag:
+      index = i
+      break
+  if index == -1:
+    return None
+
+  popped: Element | None = None
+  for _ in range(len(opening_stack) - index):
+    popped = opening_stack.pop()
+  return popped

epub_translator/xml/encoder.py

@@ -0,0 +1,95 @@
+from io import StringIO
+from typing import Callable
+from html import escape as escape_html
+from xml.etree.ElementTree import Element
+
+from .tag import Tag, TagKind
+from .parser import parse_tags
+from .transform import element_to_tag
+
+# why implement XML encoding?
+# https://github.com/oomol-lab/pdf-craft/issues/149
+def encode_friendly(element: Element, indent: int = 2) -> str:
+  buffer = StringIO()
+  _encode_element(
+    buffer=buffer,
+    element=element,
+    indent=indent,
+    depth=0,
+    escape=_escape_text,
+  )
+  return buffer.getvalue()
+
+def _escape_text(text: str) -> str:
+  buffer = StringIO()
+  for cell in parse_tags(text):
+    if isinstance(cell, Tag):
+      cell = escape_html(str(cell))
+    buffer.write(cell)
+  return buffer.getvalue()
+
+def encode(element: Element, indent: int = 2) -> str:
+  buffer = StringIO()
+  _encode_element(
+    buffer=buffer,
+    element=element,
+    indent=indent,
+    depth=0,
+    escape=escape_html,
+  )
+  return buffer.getvalue()
+
+_TINY_TEXT_LEN = 35
+
+def _encode_element(
+      buffer: StringIO,
+      element: Element,
+      indent: int,
+      depth: int,
+      escape: Callable[[str], str],
+    ) -> None:
+
+  _write_indent(buffer, indent, depth)
+  if len(element) == 0 and not element.text:
+    tag = element_to_tag(element, TagKind.SELF_CLOSING)
+    buffer.write(str(tag))
+  else:
+    text = (element.text or "").strip()
+    opening_tag = element_to_tag(element, TagKind.OPENING)
+    closing_tag = element_to_tag(element, TagKind.CLOSING)
+    buffer.write(str(opening_tag))
+    is_one_line = (
+      len(text) <= _TINY_TEXT_LEN and
+      len(element) == 0 and
+      "\n" not in text
+    )
+    if text:
+      if not is_one_line:
+        buffer.write("\n")
+        _write_indent(buffer, indent, depth + 1)
+      buffer.write(escape(text))
+
+    for child in element:
+      buffer.write("\n")
+      _encode_element(
+        buffer=buffer,
+        element=child,
+        indent=indent,
+        depth=depth + 1,
+        escape=escape,
+      )
+      child_tail = (child.tail or "").strip()
+      if child_tail:
+        buffer.write("\n")
+        _write_indent(buffer, indent, depth + 1)
+        buffer.write(escape(child_tail))
+
+    if not is_one_line:
+      buffer.write("\n")
+      _write_indent(buffer, indent, depth)
+
+    buffer.write(str(closing_tag))
+
+def _write_indent(buffer: StringIO, indent: int, depth: int) -> None:
+  for _ in range(indent * depth):
+    buffer.write(" ")

epub_translator/xml/parser.py

@@ -0,0 +1,172 @@
+from io import StringIO
+from typing import Generator, Iterable
+from enum import auto, Enum
+from .tag import is_valid_name_char, is_valid_value_char, Tag, TagKind
+
+
+_SPACES = (" ", "\n")
+
+class _Phase(Enum):
+  OUTSIDE = auto()
+  LEFT_BRACKET = auto()
+  LEFT_SLASH = auto()
+  TAG_NAME = auto()
+  TAG_GAP = auto()
+  ATTRIBUTE_NAME = auto()
+  ATTRIBUTE_NAME_EQUAL = auto()
+  ATTRIBUTE_VALUE = auto()
+  MUST_CLOSING_SIGN = auto()
+
+class _ParsedResult(Enum):
+  Continue = auto()
+  Success = auto()
+  Failed = auto()
+
+def parse_tags(chars: Iterable[str]) -> Generator[str | Tag, None, None]:
+  yield from _XMLTagsParser().do(chars)
+
+class _XMLTagsParser:
+  def __init__(self):
+    self._outside_buffer: StringIO = StringIO()
+    self._tag_buffer: StringIO = StringIO()
+    self._tag: Tag | None = None
+    self._phase: _Phase = _Phase.OUTSIDE
+
+  def do(self, chars: Iterable[str]) -> Generator[str | Tag, None, None]:
+    for char in chars:
+      parsed_result = self._parse_char(char)
+      yield from self._generate_by_result(parsed_result)
+
+    self._outside_buffer.write(self._tag_buffer.getvalue())
+    outside_text = self._outside_buffer.getvalue()
+    if outside_text != "":
+      yield outside_text
+
+  def _parse_char(self, char: str) -> _ParsedResult:
+    parsed_result: _ParsedResult = _ParsedResult.Continue
+
+    if self._phase == _Phase.OUTSIDE:
+      if char != "<":
+        self._outside_buffer.write(char)
+      else:
+        self._phase = _Phase.LEFT_BRACKET
+        self._tag_buffer.write(char)
+        self._tag = Tag(
+          kind=TagKind.OPENING,
+          name="",
+          proto="",
+          attributes=[],
+        )
+    else:
+      self._tag_buffer.write(char)
+
+      if self._phase == _Phase.LEFT_BRACKET:
+        if char == "/":
+          self._tag.kind = TagKind.CLOSING
+          self._phase = _Phase.LEFT_SLASH
+        elif is_valid_name_char(char):
+          self._tag.name += char
+          self._phase = _Phase.TAG_NAME
+        else:
+          parsed_result = _ParsedResult.Failed
+
+      elif self._phase == _Phase.LEFT_SLASH:
+        if is_valid_name_char(char):
+          self._tag.name += char
+          self._phase = _Phase.TAG_NAME
+        else:
+          parsed_result = _ParsedResult.Failed
+
+      elif self._phase == _Phase.TAG_NAME:
+        if char in _SPACES:
+          self._phase = _Phase.TAG_GAP
+        elif is_valid_name_char(char):
+          self._tag.name += char
+        elif char == ">":
+          parsed_result = _ParsedResult.Success
+        elif char == "/" and self._tag.kind == TagKind.OPENING:
+          self._tag.kind = TagKind.SELF_CLOSING
+          self._phase = _Phase.MUST_CLOSING_SIGN
+        else:
+          parsed_result = _ParsedResult.Failed
+
+      elif self._phase == _Phase.TAG_GAP:
+        if char in _SPACES:
+          pass
+        elif is_valid_name_char(char):
+          self._tag.attributes.append((char, ""))
+          self._phase = _Phase.ATTRIBUTE_NAME
+        elif char == ">":
+          parsed_result = _ParsedResult.Success
+        elif char == "/" and self._tag.kind == TagKind.OPENING:
+          self._tag.kind = TagKind.SELF_CLOSING
+          self._phase = _Phase.MUST_CLOSING_SIGN
+        else:
+          parsed_result = _ParsedResult.Failed
+
+      elif self._phase == _Phase.ATTRIBUTE_NAME:
+        if is_valid_name_char(char):
+          attr_name, attr_value = self._tag.attributes[-1]
+          attr_name = attr_name + char
+          self._tag.attributes[-1] = (attr_name, attr_value)
+        elif char == "=":
+          self._phase = _Phase.ATTRIBUTE_NAME_EQUAL
+        else:
+          parsed_result = _ParsedResult.Failed
+
+      elif self._phase == _Phase.ATTRIBUTE_NAME_EQUAL:
+        if char == "\"":
+          self._phase = _Phase.ATTRIBUTE_VALUE
+        else:
+          parsed_result = _ParsedResult.Failed
+
+      elif self._phase == _Phase.ATTRIBUTE_VALUE:
+        if is_valid_value_char(char):
+          attr_name, attr_value = self._tag.attributes[-1]
+          attr_value = attr_value + char
+          self._tag.attributes[-1] = (attr_name, attr_value)
+        elif char == "\"":
+          self._phase = _Phase.TAG_GAP
+        else:
+          parsed_result = _ParsedResult.Failed
+
+      elif self._phase == _Phase.MUST_CLOSING_SIGN:
+        if char == ">":
+          parsed_result = _ParsedResult.Success
+        else:
+          parsed_result = _ParsedResult.Failed
+
+    return parsed_result
+
+  def _generate_by_result(self, parsed_result: _ParsedResult) -> Generator[str | Tag, None, None]:
+    if parsed_result == _ParsedResult.Success:
+      assert self._tag is not None
+      if self._is_tag_valid(self._tag):
+        outside_text = self._outside_buffer.getvalue()
+        self._clear_buffer(self._outside_buffer)
+        self._clear_buffer(self._tag_buffer)
+        if outside_text != "":
+          yield outside_text
+        yield self._tag
+      else:
+        self._tag.proto = self._tag_buffer.getvalue()
+        self._outside_buffer.write(self._tag.proto)
+        self._clear_buffer(self._tag_buffer)
+      self._tag = None
+      self._phase = _Phase.OUTSIDE
+
+    elif parsed_result == _ParsedResult.Failed:
+      self._outside_buffer.write(self._tag_buffer.getvalue())
+      self._clear_buffer(self._tag_buffer)
+      self._phase = _Phase.OUTSIDE
+
+  def _is_tag_valid(self, tag: Tag) -> bool:
+    if tag.kind == TagKind.CLOSING and len(tag.attributes) > 0:
+      return False
+    if tag.find_invalid_name() is not None:
+      return False
+    return True
+
+  def _clear_buffer(self, buffer: StringIO):
+    buffer.truncate(0)
+    buffer.seek(0)

epub_translator/xml/tag.py

@@ -0,0 +1,93 @@
+from io import StringIO
+from enum import auto, Enum
+from typing import Generator
+from dataclasses import dataclass
+
+
+class TagKind(Enum):
+  OPENING = auto()
+  CLOSING = auto()
+  SELF_CLOSING = auto()
+
+@dataclass
+class Tag:
+  kind: TagKind
+  name: str
+  proto: str
+  attributes: list[tuple[str, str]]
+
+  def __str__(self):
+    buffer = StringIO()
+    buffer.write("<")
+    if self.kind == TagKind.CLOSING:
+      buffer.write("/")
+    buffer.write(self.name)
+    if len(self.attributes) > 0:
+      buffer.write(" ")
+      for i, (attr_name, attr_value) in enumerate(self.attributes):
+        buffer.write(attr_name)
+        buffer.write("=")
+        buffer.write("\"")
+        buffer.write(attr_value)
+        buffer.write("\"")
+        if i < len(self.attributes) - 1:
+          buffer.write(" ")
+    if self.kind == TagKind.SELF_CLOSING:
+      buffer.write("/>")
+    else:
+      buffer.write(">")
+    return buffer.getvalue()
+
+  def find_invalid_name(self) -> str | None:
+    for name in self._iter_tag_names():
+      if not all(is_valid_value_char(c) for c in name):
+        return name
+      # https://www.w3schools.com/xml/xml_elements.asp
+      # The following logic enforces a subset of XML naming rules:
+      # - Names must not be empty.
+      # - Names must start with a letter (a-z, A-Z) or an underscore (_).
+      if name == "":
+        return name
+      char = name[0]
+      if char == "_":
+        continue
+      if "a" <= char <= "z" or "A" <= char <= "Z":
+        continue
+      return name
+
+    return None
+
+  def find_invalid_attr_value(self) -> tuple[str, str] | None:
+    for attr_name, attr_value in self.attributes:
+      if not all(is_valid_value_char(c) for c in attr_value):
+        return attr_name, attr_value
+    return None
+
+  def _iter_tag_names(self) -> Generator[str, None, None]:
+    yield self.name
+    for attr_name, _ in self.attributes:
+      yield attr_name
+
+def is_valid_value_char(char: str) -> bool:
+  if is_valid_name_char(char):
+    return True
+  if char == ",":
+    return True
+  if char == ".":
+    return True
+  if char == "/":
+    return True
+  return False
+
+def is_valid_name_char(char: str) -> bool:
+  if "a" <= char <= "z":
+    return True
+  if "A" <= char <= "Z":
+    return True
+  if "0" <= char <= "9":
+    return True
+  if char == "_":
+    return True
+  if char == "-":
+    return True
+  return False

epub_translator/xml/transform.py

@@ -0,0 +1,34 @@
+from xml.etree.ElementTree import Element
+from .tag import Tag, TagKind
+
+
+def tag_to_element(tag: Tag) -> Element:
+  element = Element(tag.name)
+  for attr_name, attr_value in tag.attributes:
+    element.set(attr_name, attr_value)
+  return element
+
+def element_to_tag(element: Element, kind: TagKind, proto: str = "") -> Tag:
+  tag = Tag(
+    kind=kind,
+    name=element.tag,
+    proto=proto,
+    attributes=[],
+  )
+  if kind != TagKind.CLOSING:
+    for attr_name in sorted(list(element.keys())):
+      attr_value = element.get(attr_name, "")
+      tag.attributes.append((attr_name, attr_value))
+
+  # To make LLM easier to understand, the naming here is restricted in a more strict way.
+  # https://github.com/oomol-lab/pdf-craft/issues/149
+  invalid_name = tag.find_invalid_name()
+  if invalid_name is not None:
+    raise ValueError(f"find invalid tag name or attribute name: {invalid_name}")
+
+  invalid_attr_pair = tag.find_invalid_attr_value()
+  if invalid_attr_pair is not None:
+    attr_name, attr_value = invalid_attr_pair
+    raise ValueError(f"find invalid attribute value: {attr_name}=\"{attr_value}\"")
+
+  return tag

epub_translator/xml/utils.py

@@ -0,0 +1,12 @@
+from xml.etree.ElementTree import Element
+
+def clone(element: Element) -> Element:
+  new_element = Element(element.tag)
+  for attr_name, attr_value in element.items():
+    new_element.set(attr_name, attr_value)
+  new_element.text = element.text
+  for child in element:
+    new_child = clone(child)
+    new_element.append(new_child)
+    new_child.tail = child.tail
+  return new_element

epub_translator/zip_context.py

@@ -0,0 +1,74 @@
+import zipfile
+
+from typing import Generator, Callable
+from pathlib import Path
+from lxml.etree import parse
+from .epub import EpubContent, HTMLFile
+
+
+class ZipContext:
+  def __init__(self, epub_path: Path, temp_dir: Path):
+    with zipfile.ZipFile(epub_path, "r") as zip_ref:
+      for member in zip_ref.namelist():
+        target_path = temp_dir / member
+        if member.endswith("/"):
+          target_path.mkdir(parents=True, exist_ok=True)
+        else:
+          target_path.parent.mkdir(parents=True, exist_ok=True)
+          with zip_ref.open(member) as source:
+            with open(target_path, "wb") as file:
+              file.write(source.read())
+
+    self._temp_dir: Path = temp_dir
+    self._epub_content: EpubContent = EpubContent(temp_dir)
+
+  def archive(self, saved_path: Path):
+    with zipfile.ZipFile(saved_path, "w") as zip_file:
+      for file_path in self._temp_dir.rglob("*"):
+        if not file_path.is_file():
+          continue
+        relative_path = file_path.relative_to(self._temp_dir)
+        zip_file.write(
+          filename=file_path,
+          arcname=str(relative_path),
+        )
+
+  def search_spine_paths(self) -> Generator[Path, None, None]:
+    for spine in self._epub_content.spines:
+      if spine.media_type == "application/xhtml+xml":
+        yield Path(spine.path)
+
+  def read_spine_file(self, spine_path: Path) -> HTMLFile:
+    with open(spine_path, "r", encoding="utf-8") as file:
+      return HTMLFile(file.read())
+
+  def write_spine_file(self, spine_path: Path, file: HTMLFile):
+    with open(spine_path, "w", encoding="utf-8") as f:
+      f.write(file.file_content)
+
+  def replace_ncx(self, replace: Callable[[list[str]], list[str]]):
+    ncx_path = self._epub_content.ncx_path
+    if ncx_path is None:
+      return
+
+    tree = parse(ncx_path)
+    root = tree.getroot()
+    namespaces={ "ns": root.nsmap.get(None) }
+    text_doms = []
+    text_list = []
+
+    for text_dom in root.xpath("//ns:text", namespaces=namespaces):
+      text_doms.append(text_dom)
+      text_list.append(text_dom.text or "")
+
+    for index, text in enumerate(replace(text_list)):
+      text_dom = text_doms[index]
+      text_dom.text = self._link_translated(text_dom.text, text)
+
+    tree.write(ncx_path, pretty_print=True)
+
+  def _link_translated(self, origin: str, target: str) -> str:
+    if origin == target:
+      return origin
+    else:
+      return f"{origin} - {target}"

{epub_translator-0.0.1.dist-info → epub_translator-0.0.3.dist-info}/METADATA

@@ -1,8 +1,9 @@
 Metadata-Version: 2.3
 Name: epub-translator
-Version: 0.0.1
+Version: 0.0.3
 Summary: Translate the epub book using LLM. The translated book will retain the original text and list the translated text side by side with the original text.
 License: MIT
+Keywords: epub,llm,translation,translator
 Author: Tao Zeyu
 Author-email: i@taozeyu.com
 Maintainer: Tao Zeyu
@@ -13,14 +14,11 @@ 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: langchain (==0.3.23)
-Requires-Dist: langchain-openai (==0.3.13)
-Requires-Dist: langid (>=1.1.6,<2.0.0)
+Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
+Requires-Dist: langchain[openai] (>=0.3.21,<0.4.0)
 Requires-Dist: lxml (>=6.0.0,<7.0.0)
-Requires-Dist: resource-segmentation (==0.0.1)
-Requires-Dist: spacy (>=3.8.7,<4.0.0)
+Requires-Dist: resource-segmentation (==0.0.2)
 Requires-Dist: tiktoken (>=0.9.0,<0.10.0)
-Requires-Dist: tqdm (>=4.67.1,<5.0.0)
 Project-URL: Homepage, https://hub.oomol.com/package/book-translator
 Project-URL: Repository, https://github.com/oomol-flows/books-translator
 Description-Content-Type: text/markdown

epub_translator-0.0.3.dist-info/RECORD

@@ -0,0 +1,36 @@
+epub_translator/__init__.py,sha256=69k-70xbqxLgTvLyJE_MPFyymmPgyUAFg4mCSfEn49k,106
+epub_translator/data/format.jinja,sha256=1dXiMAhznuHWA2vpDx-968pm95FCXCRV3cKVmy3EXYA,3710
+epub_translator/data/translate.jinja,sha256=XWiMgeQS3tKCnh9cC6p1KQs9kqb1GO6m_j_cNeDq8lQ,1768
+epub_translator/epub/__init__.py,sha256=vqD29XWxgcfHw8LFCHQxupQeJufEEoS5_KHNphwfEYU,73
+epub_translator/epub/content_parser.py,sha256=Y-2fEcACCAl_ucA6VwwOoQ95BMHr9f-hryuxnsYNONM,4403
+epub_translator/epub/html/__init__.py,sha256=Yyg0TrWjecolaJP6qLzDnOlhi7SrkW0Is7wh9Fr0-Bg,26
+epub_translator/epub/html/dom_operator.py,sha256=Ryayv6hG0jEXv7RkXrZTbIP54P0fyPTbMVbymMtBUnU,1935
+epub_translator/epub/html/empty_tags.py,sha256=GSSe-CV4YkUhWv4F0fiiRsf2vz0ZBAsC21Ovnqo5oIA,601
+epub_translator/epub/html/file.py,sha256=AqUV-Tmptk5J2EYmw3oRVsLjGSqEMNz5rItnoRbGstc,2477
+epub_translator/epub/html/texts_searcher.py,sha256=vamO99pki6_sX2PeKCJk7mPwHdApZq1sOgSYDTPckx8,1376
+epub_translator/llm/__init__.py,sha256=wMBWLgh5iLNQBioniSOmWC83NS7RLM41hIs1V1uZiWI,21
+epub_translator/llm/error.py,sha256=fG0A3z69YoSNu0MNVWVFMtHCB_4fpOvAEb0Kajn9OHc,1401
+epub_translator/llm/executor.py,sha256=vwHqtlvCDHjDXLcvvKstlcQ5MfAGNPz1RKbq8W6WwKs,4378
+epub_translator/llm/increasable.py,sha256=Dpu5z4JK5h1OtLorZgsOAdRFeTH2LOkdroasgmCWAIo,1136
+epub_translator/llm/node.py,sha256=IKgdWoBwiejHOJ7akv8AiXUpyFlv2U4fGllt7ZLE3M0,5970
+epub_translator/template.py,sha256=GdV3QnypProKFCMH1kBNfdt6wiShygP_-xGnE5EOUwU,1460
+epub_translator/translation/__init__.py,sha256=mudXLDVSIG0XTLoHUIos0-wtQCnL9ZreuHsTHcVKjnE,73
+epub_translator/translation/chunk.py,sha256=obrkx_yCeGMeikinfIx0NRvMo2kQBwXVbCdJbeT-ERA,3576
+epub_translator/translation/splitter.py,sha256=xOaP1p3lqY95CR0vDXdeGUMHYObiqs3y093EUAxJ-jI,2676
+epub_translator/translation/store.py,sha256=1FmksPAUj0mt3tN8Jdb_L1ovaI1p_5OhTWgxbIDl0SI,1133
+epub_translator/translation/translation.py,sha256=_qiw6s_z_Tv4VmIP1U-_YhDYNiKEDNfigHIIGKa41fU,5734
+epub_translator/translation/types.py,sha256=vDW5bVqYwngW_YUgf0SgfZ5zIFWUxcbBGO1U9Dsxc0o,499
+epub_translator/translation/utils.py,sha256=G6Gqq6mot3lgFA-jqUD0UqtDS0GC1wrb9DnK7rTxJNs,223
+epub_translator/translator.py,sha256=oh7PdCijUSGU6f72hzc6doJdMWnAqg6zHRFIj3aeTjc,5332
+epub_translator/xml/__init__.py,sha256=o2_qwUYU_MUcyfmfKkiOQ-cKUQyl4PiRL8YHVzCTAZU,106
+epub_translator/xml/decoder.py,sha256=UlqgmEKQDzxt3lvBeNGHgZP6jznmnq_1HLJuAe5X0C4,2181
+epub_translator/xml/encoder.py,sha256=p4A7GRSOM2i0WOh1lLtEdTTg2gXSQrxDdzMgUqbiV18,2428
+epub_translator/xml/parser.py,sha256=3JuFLFLX4w98pzME72ywdpq0JzSBgzwZMFbH8IfB9T4,5545
+epub_translator/xml/tag.py,sha256=QLZImF0PtYyiASI7swrB8DL_qUwcYpU6cL68jEXDnvg,2353
+epub_translator/xml/transform.py,sha256=vS_a4d_o2Qqf9B6k2CovQVLUknp6TyUi3FyLOu21Vio,1126
+epub_translator/xml/utils.py,sha256=KDNGWHwaIiFKS27sjZF0e-bBSjeTxzceae_aeuj4wzI,384
+epub_translator/zip_context.py,sha256=7_05kycmADb4-vxHkw_DX__vkKOxT4zo9pr2a8F4L_U,2409
+epub_translator-0.0.3.dist-info/LICENSE,sha256=5RF32sL3LtMOJIErdDKp1ZEYPGXS8WPpsiSz_jMBnGI,1066
+epub_translator-0.0.3.dist-info/METADATA,sha256=HuD7ogzPi96e8ZKjAJyTARhSeR4xmu3vZt0Q3Vmg0Hk,2342
+epub_translator-0.0.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+epub_translator-0.0.3.dist-info/RECORD,,

epub_translator/epub/types.py

@@ -1,4 +0,0 @@
-from typing import Callable
-
-ReportProgress = Callable[[float], None]
-Translate=Callable[[list[str], ReportProgress], list[str]]