epub-translator 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

epub_translator/xml_translator/validation.py

@@ -0,0 +1,458 @@
+from collections.abc import Generator, Iterable
+from dataclasses import dataclass
+from typing import Generic, TypeVar, cast
+from xml.etree.ElementTree import Element
+
+from tiktoken import Encoding
+
+from ..segment import (
+    BlockContentError,
+    BlockError,
+    BlockExpectedIDsError,
+    BlockUnexpectedIDError,
+    BlockWrongTagError,
+    FoundInvalidIDError,
+    InlineError,
+    InlineExpectedIDsError,
+    InlineLostIDError,
+    InlineUnexpectedIDError,
+    InlineWrongTagCountError,
+)
+from ..utils import ensure_list
+from ..xml import plain_text
+
+_LEVEL_WEIGHT = 3
+_MAX_TEXT_HINT_TOKENS_COUNT = 6
+
+
+_BLOCK_EXPECTED_IDS_LEVEL = 6
+_BLOCK_WRONG_TAG_LEVEL = 5
+_BLOCK_FOUND_INVALID_ID_LEVEL = 4
+_BLOCK_UNEXPECTED_ID_LEVEL = 3
+
+_INLINE_EXPECTED_IDS_LEVEL = 3
+_INLINE_LOST_ID_LEVEL = 2
+_INLINE_FOUND_INVALID_ID_LEVEL = 1
+_INLINE_WRONG_TAG_COUNT_LEVEL = 0
+_INLINE_UNEXPECTED_ID_LEVEL = 0
+
+ERROR = TypeVar("ERROR")
+LEVEL_DEPTH = 7
+
+
+@dataclass
+class ErrorItem(Generic[ERROR]):
+    error: ERROR
+    index1: int
+    index2: int
+    level: int
+    weight: int
+
+
+@dataclass
+class BlockErrorsGroup:
+    block_id: int
+    block_element: Element
+    errors: list[ErrorItem[BlockError | FoundInvalidIDError] | ErrorItem[InlineError | FoundInvalidIDError]]
+
+    @property
+    def weight(self) -> int:
+        return sum(e.weight for e in self.errors)
+
+
+@dataclass
+class ErrorsGroup:
+    upper_errors: list[ErrorItem[BlockError | FoundInvalidIDError]]
+    block_groups: list[BlockErrorsGroup]
+
+    @property
+    def errors_count(self) -> int:
+        count = len(self.upper_errors)
+        for block_group in self.block_groups:
+            count += len(block_group.errors)
+        return count
+
+
+def nest_as_errors_group(errors: Iterable[BlockError | FoundInvalidIDError]) -> ErrorsGroup | None:
+    return _create_errors_group(
+        error_items=_transform_errors_to_items(errors),
+    )
+
+
+def truncate_errors_group(errors_group: ErrorsGroup, max_errors: int) -> ErrorsGroup | None:
+    errors_items = list(_flatten_errors_group(errors_group))
+    if len(errors_items) <= max_errors:
+        return errors_group
+
+    errors_items.sort(key=lambda item: (-item[1].level, item[1].index1, item[1].index2))
+    errors_items = errors_items[:max_errors]
+
+    return _create_errors_group(
+        error_items=errors_items,
+    )
+
+
+def generate_error_message(encoding: Encoding, errors_group: ErrorsGroup, omitted_count: int = 0) -> None | str:
+    message_lines: list[str] = []
+    for upper_error in errors_group.upper_errors:
+        message_lines.append(_format_block_error(upper_error.error))
+    if message_lines:
+        message_lines.append("")
+
+    for i, block_group in enumerate(errors_group.block_groups):
+        if i == 0:
+            message_lines.append("")
+
+        block_tag = block_group.block_element.tag
+        error_count = len(block_group.errors)
+        count_suffix = f" ({error_count} error{'s' if error_count != 1 else ''})"
+        message_lines.append(f"In {block_tag}#{block_group.block_id}:{count_suffix}")
+
+        for block_error in block_group.errors:
+            message: str
+            if isinstance(block_error.error, BlockError):
+                message = _format_block_error(block_error.error)
+            elif isinstance(block_error.error, InlineError):
+                message = _format_inline_error(encoding, block_error.error, block_group.block_id)
+            else:
+                raise RuntimeError()
+            message_lines.append(f"  - {message}")
+
+    if not message_lines:
+        return None
+
+    header = (
+        f"Found {errors_group.errors_count} error(s). Fix them and return "
+        "the COMPLETE corrected XML (not just the changed parts):"
+    )
+    message_lines.insert(0, "")
+    message_lines.insert(0, header)
+
+    if omitted_count > 0:
+        message_lines.append("")
+        message_lines.append(
+            f"... and {omitted_count} more error(s) omitted. "
+            f"Fix the above errors first, then resubmit for remaining issues."
+        )
+        message_lines.append("")
+        message_lines.append("Remember: Return the entire <xml>...</xml> block with all corrections applied.")
+    else:
+        message_lines.append("")
+        message_lines.append("Return the entire <xml>...</xml> block with corrections.")
+
+    return "\n".join(message_lines)
+
+
+@dataclass
+class _Block:
+    id: int
+    element: Element
+
+
+def _transform_errors_to_items(errors: Iterable[BlockError | FoundInvalidIDError]):
+    for i, block_error in enumerate(errors):
+        if isinstance(block_error, BlockContentError):
+            block = _Block(
+                id=block_error.id,
+                element=block_error.element,
+            )
+            for j, inline_error in enumerate(block_error.errors):
+                level = _get_inline_error_level(inline_error)
+                weight = _calculate_error_weight(inline_error, level)
+                yield (
+                    block,
+                    ErrorItem(
+                        error=inline_error,
+                        index1=i,
+                        index2=j,
+                        level=level,
+                        weight=weight,
+                    ),
+                )
+        else:
+            level = _get_block_error_level(block_error)
+            weight = _calculate_error_weight(block_error, level)
+            error_item: ErrorItem[BlockError | FoundInvalidIDError] = ErrorItem(
+                error=block_error,
+                index1=i,
+                index2=0,
+                level=level,
+                weight=weight,
+            )
+            block: _Block | None = None
+            if isinstance(block_error, BlockWrongTagError) and block_error.block is not None:
+                block = _Block(
+                    id=block_error.block[0],
+                    element=block_error.block[1],
+                )
+            yield block, error_item
+
+
+def _flatten_errors_group(
+    errors_group: ErrorsGroup,
+) -> Generator[
+    tuple[
+        _Block | None,
+        ErrorItem[BlockError | FoundInvalidIDError] | ErrorItem[InlineError | FoundInvalidIDError],
+    ],
+    None,
+    None,
+]:
+    for error in errors_group.upper_errors:
+        yield None, error
+
+    for block_group in errors_group.block_groups:
+        block = _Block(
+            id=block_group.block_id,
+            element=block_group.block_element,
+        )
+        for error in block_group.errors:
+            yield block, error
+
+
+def _create_errors_group(
+    error_items: Iterable[
+        tuple[
+            _Block | None,
+            ErrorItem[BlockError | FoundInvalidIDError] | ErrorItem[InlineError | FoundInvalidIDError],
+        ]
+    ],
+) -> ErrorsGroup | None:
+    upper_errors: list[ErrorItem[BlockError | FoundInvalidIDError]] = []
+    block_elements: dict[int, Element] = {}
+    block_errors_dict: dict[
+        int, list[ErrorItem[BlockError | FoundInvalidIDError] | ErrorItem[InlineError | FoundInvalidIDError]]
+    ] = {}
+
+    for block, error in error_items:
+        if block is None:
+            upper_errors.append(cast(ErrorItem[BlockError | FoundInvalidIDError], error))
+        else:
+            block_errors = ensure_list(block_errors_dict, block.id)
+            block_errors.append(error)
+            block_elements[block.id] = block.element
+
+    if not upper_errors and not block_errors_dict:
+        return None
+
+    block_errors_groups: list[BlockErrorsGroup] = []
+    for block_id, block_errors in block_errors_dict.items():
+        block_element = block_elements.get(block_id)
+        if block_element is None:
+            continue
+
+        block_error_group = BlockErrorsGroup(
+            block_id=block_id,
+            block_element=block_element,
+            errors=sorted(block_errors, key=lambda e: (-e.weight, e.index1, e.index2)),
+        )
+        block_errors_groups.append(block_error_group)
+
+    upper_errors.sort(key=lambda e: (-e.level, e.index1, e.index2))
+    block_errors_groups.sort(key=lambda g: -g.weight)
+
+    return ErrorsGroup(
+        upper_errors=upper_errors,
+        block_groups=block_errors_groups,
+    )
+
+
+def _calculate_error_weight(error: BlockError | InlineError | FoundInvalidIDError, level: int) -> int:
+    # BlockExpectedIDsError 和 InlineExpectedIDsError 的权重乘以 id2element 数量
+    if isinstance(error, (BlockExpectedIDsError, InlineExpectedIDsError)):
+        return (_LEVEL_WEIGHT**level) * len(error.id2element)
+    else:
+        return _LEVEL_WEIGHT**level
+
+
+def _get_block_error_level(error: BlockError | FoundInvalidIDError) -> int:
+    if isinstance(error, BlockWrongTagError):
+        return _BLOCK_WRONG_TAG_LEVEL
+    elif isinstance(error, BlockExpectedIDsError):
+        return _BLOCK_EXPECTED_IDS_LEVEL
+    elif isinstance(error, BlockUnexpectedIDError):
+        return _BLOCK_UNEXPECTED_ID_LEVEL
+    elif isinstance(error, FoundInvalidIDError):
+        return _BLOCK_FOUND_INVALID_ID_LEVEL
+    else:
+        return 0
+
+
+def _get_inline_error_level(error: InlineError | FoundInvalidIDError) -> int:
+    if isinstance(error, InlineLostIDError):
+        return _INLINE_LOST_ID_LEVEL
+    elif isinstance(error, InlineExpectedIDsError):
+        return _INLINE_EXPECTED_IDS_LEVEL
+    elif isinstance(error, InlineUnexpectedIDError):
+        return _INLINE_UNEXPECTED_ID_LEVEL
+    elif isinstance(error, InlineWrongTagCountError):
+        return _INLINE_WRONG_TAG_COUNT_LEVEL
+    elif isinstance(error, FoundInvalidIDError):
+        return _INLINE_FOUND_INVALID_ID_LEVEL
+    else:
+        return 0
+
+
+def _format_block_error(error: BlockError | FoundInvalidIDError) -> str:
+    if isinstance(error, BlockWrongTagError):
+        if error.block is None:
+            return (
+                f"Root tag mismatch: expected `<{error.expected_tag}>`, but found `<{error.instead_tag}>`. "
+                f"Fix: Change the root tag to `<{error.expected_tag}>`."
+            )
+        else:
+            return (
+                f"Wrong tag for block at `{error.instead_tag}#{error.block[0]}`: "
+                f'expected `<{error.expected_tag} id="{error.block[0]}">`, '
+                f'but found `<{error.instead_tag} id="{error.block[0]}">`. '
+                f"Fix: Change the tag to `<{error.expected_tag}>`."
+            )
+    elif isinstance(error, BlockExpectedIDsError):
+        # Add context hints with original text content
+        context_hints: list[str] = []
+        for id, elem in sorted(error.id2element.items()):
+            original_text = plain_text(elem).strip()
+            if original_text:
+                # Truncate to first 30 chars for block-level hints
+                text_preview = original_text[:30] + "..." if len(original_text) > 30 else original_text
+                context_hints.append(f'  - `<{elem.tag} id="{id}">`: "{text_preview}"')
+
+        if context_hints:
+            message = "Missing block elements (find translation and wrap):\n" + "\n".join(context_hints)
+        else:
+            # Fallback if no text hints available
+            missing_elements = [f'<{elem.tag} id="{id}">' for id, elem in sorted(error.id2element.items())]
+            elements_str = ", ".join(missing_elements)
+            message = f"Missing expected blocks: {elements_str}. Fix: Add these missing blocks with the correct IDs."
+
+        return message
+
+    elif isinstance(error, BlockUnexpectedIDError):
+        selector = f"{error.element.tag}#{error.id}"
+        return f"Unexpected block found at `{selector}`. Fix: Remove this unexpected block."
+
+    elif isinstance(error, FoundInvalidIDError):
+        if error.invalid_id is None:
+            example = f"<{error.element.tag}>"
+        else:
+            example = f'<{error.element.tag} id="{error.invalid_id}">'
+        return f"Invalid or missing ID attribute: {example}. Fix: Ensure all blocks have valid numeric IDs."
+    else:
+        return "Unknown block error. Fix: Review the block structure."
+
+
+def _format_inline_error(encoding: Encoding, error: InlineError | FoundInvalidIDError, block_id: int) -> str:
+    if isinstance(error, InlineLostIDError):
+        selector = _build_inline_selector(encoding, error.stack, block_id, element=error.element)
+        return f"Element at `{selector}` is missing an ID attribute. Fix: Add the required ID attribute."
+
+    elif isinstance(error, InlineExpectedIDsError):
+        # Add context hints with original text content
+        context_hints: list[str] = []
+        for id, elem in sorted(error.id2element.items()):
+            original_text = plain_text(elem).strip()
+            if original_text:
+                text_hint = _extract_text_hint(encoding, elem)
+                context_hints.append(f'  - `<{elem.tag} id="{id}">`: "{text_hint}"')
+
+        if context_hints:
+            message = "Missing inline elements (find translation and wrap):\n" + "\n".join(context_hints)
+        else:
+            # Fallback if no text hints available
+            missing_elements = [f'<{elem.tag} id="{id}">' for id, elem in sorted(error.id2element.items())]
+            elements_str = ", ".join(missing_elements)
+            message = f"Missing expected inline elements: {elements_str}. Fix: Add these missing inline elements."
+
+        return message
+
+    elif isinstance(error, InlineUnexpectedIDError):
+        selector = f"{error.element.tag}#{error.id}"
+        return f"Unexpected inline element at `{selector}`. Fix: Remove this unexpected element."
+
+    elif isinstance(error, InlineWrongTagCountError):
+        tag = error.found_elements[0].tag if error.found_elements else "unknown"
+        selector = _build_inline_selector(encoding, error.stack, block_id, tag=tag)
+        expected = error.expected_count
+        found = len(error.found_elements)
+
+        if expected == 0 and found > 0:
+            # 情况1: 不应该有，但发现了
+            return (
+                f"Found unexpected `<{tag}>` elements at `{selector}`. "
+                f"There should be none, but {found} were found. "
+                f"Fix: Remove all `<{tag}>` elements from this location."
+            )
+        elif expected > 0 and found == 0:
+            # 情况2: 应该有，但没找到
+            return (
+                f"Missing `<{tag}>` elements at `{selector}`. "
+                f"Expected {expected}, but none were found. "
+                f"Fix: Add {expected} `<{tag}>` element(s) to this location."
+            )
+        elif found > expected:
+            # 情况3: 数量过多
+            extra = found - expected
+            return (
+                f"Too many `<{tag}>` elements at `{selector}`. "
+                f"Expected {expected}, but found {found} ({extra} extra). "
+                f"Fix: Remove {extra} `<{tag}>` element(s)."
+            )
+        else:
+            # 情况4: 数量过少
+            missing = expected - found
+            return (
+                f"Too few `<{tag}>` elements at `{selector}`. "
+                f"Expected {expected}, but only found {found} ({missing} missing). "
+                f"Fix: Add {missing} more `<{tag}>` element(s)."
+            )
+    elif isinstance(error, FoundInvalidIDError):
+        if error.invalid_id is None:
+            example = f"<{error.element.tag}>"
+        else:
+            example = f'<{error.element.tag} id="{error.invalid_id}">'
+        return f"Invalid inline ID: {example}. Fix: Ensure inline elements have valid numeric IDs."
+    else:
+        return "Unknown inline error. Fix: Review the inline structure."
+
+
+def _build_inline_selector(
+    encoding: Encoding,
+    stack: list[Element],
+    block_id: int,
+    element: Element | None = None,
+    tag: str | None = None,
+) -> str:
+    if element is not None:
+        element_id = element.get("id")
+        if element_id is not None:
+            # 能用 ID 直接定位，就不必用路径定位
+            return f"{element.tag}#{element_id}"
+        tag = element.tag
+
+    # 路径：block#id > parent > ... > tag
+    block_tag = stack[0].tag if stack else "unknown"
+    path_parts = [f"{block_tag}#{block_id}"]
+
+    for parent in stack[1:]:
+        path_parts.append(parent.tag)
+
+    if tag:
+        path_parts.append(tag)
+
+    selector = " > ".join(path_parts)
+
+    if element is not None:
+        text_hint = _extract_text_hint(encoding, element)
+        if text_hint:
+            selector += f' (contains text: "{text_hint}")'
+    return selector
+
+
+def _extract_text_hint(encoding: Encoding, element: Element) -> str:
+    text = plain_text(element).strip()
+    if text:
+        tokens = encoding.encode(text)
+        if len(tokens) > _MAX_TEXT_HINT_TOKENS_COUNT:
+            tokens = tokens[:_MAX_TEXT_HINT_TOKENS_COUNT]
+            text = encoding.decode(tokens).strip() + " ..."
+    return text

{epub_translator-0.1.1.dist-info → epub_translator-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: epub-translator
-Version: 0.1.1
+Version: 0.1.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
@@ -91,10 +91,10 @@ llm = LLM(
 
 # Translate EPUB file using language constants
 translate(
-    llm=llm,
     source_path=Path("source.epub"),
     target_path=Path("translated.epub"),
     target_language=language.ENGLISH,
+    llm=llm,
 )
 ```
 
@@ -113,10 +113,10 @@ with tqdm(total=100, desc="Translating", unit="%") as pbar:
         last_progress = progress
 
     translate(
-        llm=llm,
         source_path=Path("source.epub"),
         target_path=Path("translated.epub"),
         target_language="English",
+        llm=llm,
         on_progress=on_progress,
     )
 ```
@@ -149,17 +149,22 @@ Translate an EPUB file:
 
 ```python
 translate(
-    llm: LLM,                          # LLM instance
-    source_path: Path,                 # Source EPUB file path
-    target_path: Path,                 # Output EPUB file path
+    source_path: PathLike | str,       # Source EPUB file path
+    target_path: PathLike | str,       # Output EPUB file path
     target_language: str,              # Target language (e.g., "English", "Chinese")
     user_prompt: str | None = None,    # Custom translation instructions
     max_retries: int = 5,              # Maximum retries for failed translations
     max_group_tokens: int = 1200,      # Maximum tokens per translation group
+    llm: LLM | None = None,            # Single LLM instance for both translation and filling
+    translation_llm: LLM | None = None,  # LLM instance for translation (overrides llm)
+    fill_llm: LLM | None = None,       # LLM instance for XML filling (overrides llm)
     on_progress: Callable[[float], None] | None = None,  # Progress callback (0.0-1.0)
+    on_fill_failed: Callable[[FillFailedEvent], None] | None = None,  # Error callback
 )
 ```
 
+**Note**: Either `llm` or both `translation_llm` and `fill_llm` must be provided. Using separate LLMs allows for task-specific optimization.
+
 #### Language Constants
 
 EPUB Translator provides predefined language constants for convenience. You can use these constants instead of writing language names as strings:
@@ -169,18 +174,76 @@ from epub_translator import language
 
 # Usage example:
 translate(
-    llm=llm,
     source_path=Path("source.epub"),
     target_path=Path("translated.epub"),
     target_language=language.ENGLISH,
+    llm=llm,
 )
 
 # You can also use custom language strings:
 translate(
-    llm=llm,
     source_path=Path("source.epub"),
     target_path=Path("translated.epub"),
     target_language="Icelandic",  # For languages not in the constants
+    llm=llm,
+)
+```
+
+### Error Handling with `on_fill_failed`
+
+Monitor and handle translation errors using the `on_fill_failed` callback:
+
+```python
+from epub_translator import FillFailedEvent
+
+def handle_fill_error(event: FillFailedEvent):
+    print(f"Translation error (attempt {event.retried_count}):")
+    print(f"  {event.error_message}")
+    if event.over_maximum_retries:
+        print("  Maximum retries exceeded!")
+
+translate(
+    source_path=Path("source.epub"),
+    target_path=Path("translated.epub"),
+    target_language=language.ENGLISH,
+    llm=llm,
+    on_fill_failed=handle_fill_error,
+)
+```
+
+The `FillFailedEvent` contains:
+- `error_message: str` - Description of the error
+- `retried_count: int` - Current retry attempt number
+- `over_maximum_retries: bool` - Whether max retries has been exceeded
+
+### Dual-LLM Architecture
+
+Use separate LLM instances for translation and XML structure filling with different optimization parameters:
+
+```python
+# Create two LLM instances with different temperatures
+translation_llm = LLM(
+    key="your-api-key",
+    url="https://api.openai.com/v1",
+    model="gpt-4",
+    token_encoding="o200k_base",
+    temperature=0.8,  # Higher temperature for creative translation
+)
+
+fill_llm = LLM(
+    key="your-api-key",
+    url="https://api.openai.com/v1",
+    model="gpt-4",
+    token_encoding="o200k_base",
+    temperature=0.3,  # Lower temperature for structure preservation
+)
+
+translate(
+    source_path=Path("source.epub"),
+    target_path=Path("translated.epub"),
+    target_language=language.ENGLISH,
+    translation_llm=translation_llm,
+    fill_llm=fill_llm,
 )
 ```
 
@@ -236,10 +299,10 @@ Provide specific translation instructions:
 
 ```python
 translate(
-    llm=llm,
     source_path=Path("source.epub"),
     target_path=Path("translated.epub"),
     target_language="English",
+    llm=llm,
     user_prompt="Use formal language and preserve technical terminology",
 )
 ```

epub_translator-0.1.3.dist-info/RECORD

@@ -0,0 +1,66 @@
+epub_translator/__init__.py,sha256=2FZPJyQdTgy_X7oOCxDpSqCZCGEcFqlulmhztLWuCIk,158
+epub_translator/data/fill.jinja,sha256=zSytA8Vhp2i6YBZ09F1z9iPJq1-jUaiphoXqTNZwnvo,6964
+epub_translator/data/mmltex/README.md,sha256=wwhe5yW1U_7_YZIFKnQVnCOmUl7Mu3gsr3lNnDSJ5Qs,2953
+epub_translator/data/mmltex/cmarkup.xsl,sha256=DkhimAATM0XSCfVOfY41-qTPoddqzOHjZ00Pynr4zQE,37707
+epub_translator/data/mmltex/entities.xsl,sha256=TYZ5iGg0u9XlDDBBGuZiHL7MsxKc-3OsTIBAVM1GDek,107742
+epub_translator/data/mmltex/glayout.xsl,sha256=Ztc7N1wiHaYZlo9u9iuROrIl3uIIIoo1VFIuojXq7TM,6879
+epub_translator/data/mmltex/mmltex.xsl,sha256=BVXFbApz-9W2qRKKtBTxptK5vxG2bfB8tv9W1MP5iBI,1384
+epub_translator/data/mmltex/scripts.xsl,sha256=f4ei0cDCW3cV-Ra7rC3kC5tRcKdjJxbSpCeQLoohtgo,13697
+epub_translator/data/mmltex/tables.xsl,sha256=RxtNo8qDtVAg8_6BuYsafraB_0z7YDAB9D__fT9gmWs,4327
+epub_translator/data/mmltex/tokens.xsl,sha256=j3JZRcBhAiiY8o5K3640phfLwxO8JVspCFlSttwBzJk,12373
+epub_translator/data/translate.jinja,sha256=93d8kschm5HV-EfXd1kFSIVMObDqTMdoUrwDfce2bhU,820
+epub_translator/epub/__init__.py,sha256=ZddRHrLNVzgaSVrYflGnrq8tffmlKPhBbz9ok7sp8PY,149
+epub_translator/epub/common.py,sha256=4-SpTe8iot9hMfyXILmlUFvYVNYqPAHL5hn1fr2wgis,1180
+epub_translator/epub/math.py,sha256=-Q2LJQxxjgQZQUe_WlJA9tjzLqgqtw2ZmbGbHsPRp2U,5422
+epub_translator/epub/metadata.py,sha256=DXSimY2iZNBA2juIaKtB-4CHHSYJiDK7PPhfenV4dto,3511
+epub_translator/epub/spines.py,sha256=bP2IsobZm7zs4z10iXGc9SmgAFSIq9pJc8HE-V0aW9Y,1331
+epub_translator/epub/toc.py,sha256=TKJfyDT4svFkXd6JCNZk2ZEYc9q-5DXnV3zY2UKo8nE,14891
+epub_translator/epub/zip.py,sha256=-3LI8f-ksgU8xCy28NjBOKyQPE8PhPEUPqIKZE1p8dw,2364
+epub_translator/epub_transcode.py,sha256=NzuvXXEZfAhIoMOSrgQRF0DPtaSpz4OY-NMSdC0Y2RM,2749
+epub_translator/language.py,sha256=88osG0JNYxOkxBjg5Pm-P0Mhiyxf6GqdxoPW12HW0PE,493
+epub_translator/llm/__init__.py,sha256=YcFYYnXmXyX0RUyC-PDbj5k7Woygp_XOpTI3vDiNSPM,75
+epub_translator/llm/context.py,sha256=73paN3V66LQ6muKUSMCKEHEmMYBylK-dXOF8LmaQo5M,3885
+epub_translator/llm/core.py,sha256=AorV4ss4Hr-IbAk8FmGhV2hgI2tKxQmW2Vz2WwUd0Ms,5110
+epub_translator/llm/error.py,sha256=4efAIQL14DFSvAnSTUfgdAbZRqaWBqOfUGsSfvxa5zM,1503
+epub_translator/llm/executor.py,sha256=A0IjQ-s9wBJuhAZAAydneb9zBXWnu2J9inR2Q8F-GDE,5533
+epub_translator/llm/increasable.py,sha256=8XkKeI1hiHlpMHj8dQ4fW0BkViSx4hH8QfbQsy-5SDw,1297
+epub_translator/llm/types.py,sha256=c-dMAIvlG4R3la3mUTWEw5xei-sIYKmQeBja7mirxcI,219
+epub_translator/segment/__init__.py,sha256=UYTv_IKQbEB0DzhFeiuqCvjoJLvB-7XRwlaFS90KmIw,573
+epub_translator/segment/block_segment.py,sha256=psNKA_HMIcwZtoug8AtnAcV9_mQ2WXLnXqFsekHzt2g,4570
+epub_translator/segment/common.py,sha256=gGWYQaJ0tGnWCuF1me9TOo-Q_DrZVakCu2patyFIOs0,714
+epub_translator/segment/inline_segment.py,sha256=_ZgSlZmGxzIvaPs01hreoUfnaXz8Yq7naksT34dGfds,14221
+epub_translator/segment/text_segment.py,sha256=qKp646lAqsrI7CP7KYyXgRD2bY0dCR78i6TMBCzklrM,7614
+epub_translator/segment/utils.py,sha256=qMqUt33pDRN5Tnuydkodzu2gaQrwTzAnQmXpDuHen1o,1036
+epub_translator/serial/__init__.py,sha256=b3IMVmWcUwEqHKcGmey88b057pyz5ct946CaUZi4LB4,67
+epub_translator/serial/chunk.py,sha256=FrTaHikVOd6bLYumnEriTaAQ_DIDLjHm16gh-wBVR9k,1495
+epub_translator/serial/segment.py,sha256=uEz-ke1KcYrON-68FaUEzMG2CzHlMjvbC11F3ZT4yH0,446
+epub_translator/serial/splitter.py,sha256=Nq0sxPXos8ez7QBG01sOKjnYKbeBWUBHflZGtqenVm8,1726
+epub_translator/template.py,sha256=0CqRmj3nTtPshw0NmTr2ECqelops2MMyX94fMrE-HKs,1587
+epub_translator/translator.py,sha256=Uy1dRBPA9hoNh3BE40M2XukK2VvcWRCvMvGwvhQtIaA,6212
+epub_translator/utils.py,sha256=BfZWrYjzDNQ4cFrgvRNzd4i1CKLtPxS8Z4LBHhqEV78,914
+epub_translator/xml/__init__.py,sha256=pxSRKPBQ7D8BCIzXceSad_1MFgN1Dou0BZz9trK47wU,138
+epub_translator/xml/const.py,sha256=Re2TYmpwG7-jVVgSq3R_K-uYhvAYzcXcRmLFkwCPD9Y,19
+epub_translator/xml/deduplication.py,sha256=TaMbzeA70VvUQV0X1wcQFVbuMEPJUtj9Hq6iWlUmtAQ,1152
+epub_translator/xml/firendly/__init__.py,sha256=I5jhnhFWoHvojLsYXH4jfR4Gi8lKFZ3yQ56ze5hEe1M,74
+epub_translator/xml/firendly/decoder.py,sha256=xRQ5LnSunmYbba_0oT39oUr86-sLYAHYMUGmlseIu2U,2467
+epub_translator/xml/firendly/encoder.py,sha256=evjvw6oE-oCud44IsJ-YZVHn6dtUzjNYX25ljaZP6vY,2417
+epub_translator/xml/firendly/parser.py,sha256=QlMHA0nfPJbNyx6IwRFrYVw7okuvzDB42NXCauIFV-o,6560
+epub_translator/xml/firendly/tag.py,sha256=ahaGoYttuAlnFxLFFgTV51KUZSpUiHho-COZX14nxN8,3308
+epub_translator/xml/firendly/transform.py,sha256=5tG1MJmzrXIR_Z5gmRxwcoKvXBzJBVH0ELeaRsG-8w0,1201
+epub_translator/xml/self_closing.py,sha256=41ofGUdss9yU51IVwI4It6hKfzh8YcxIR_j-ohD19LE,5240
+epub_translator/xml/utils.py,sha256=7tQ6L5P0_JXhxONeG64hEeeL5mKjA6NKS1H1Q9B1Cac,1062
+epub_translator/xml/xml.py,sha256=qQ5Wk1-KVVHE4TX25zGOR7fINsGkXnoq-qyKKNl5no4,1675
+epub_translator/xml/xml_like.py,sha256=jBK4UUgXXWRYnfYlCH1MUAjGHWBQAbUj8HsYqvTTWvA,8890
+epub_translator/xml_interrupter.py,sha256=IGLATr7zTIdhE54Gnroab4Xu_vLJ7kzPiQgk7WMXKTc,7403
+epub_translator/xml_translator/__init__.py,sha256=7aswnFGtuj97l7RQd4ka976WCKC7OPs2gFnJFdS74Ug,77
+epub_translator/xml_translator/callbacks.py,sha256=IoZrsaivd2W76cHFupwv6auVxgEWHcBN2MHQJYcWoJ8,1324
+epub_translator/xml_translator/common.py,sha256=hSPptgPp7j6dm47imELB5DgmEbzTEyJD6WEeELOOc50,38
+epub_translator/xml_translator/hill_climbing.py,sha256=1jvilOkTLzwljJA4Nrel8yU2XGvOXpueUJTK7RAp-XY,4272
+epub_translator/xml_translator/stream_mapper.py,sha256=tbMc2vyPUn9zEkJZ7-OVYuKaYyn2pPPwjcAdQ8HLzNs,10179
+epub_translator/xml_translator/submitter.py,sha256=Ihp6DvvVMLNZLJkRccYppt_2I2CM7wvkkSAam9B2o2s,2268
+epub_translator/xml_translator/translator.py,sha256=3Lu56vRkAbbnsWK5fOYkVoO-7b6TXCrFYSVYLOjqhw0,9169
+epub_translator/xml_translator/validation.py,sha256=-OKlSZuD__sjAiEpGAO93YQme4ZDSPmoPjRsAMOCEjc,16668
+epub_translator-0.1.3.dist-info/LICENSE,sha256=5RF32sL3LtMOJIErdDKp1ZEYPGXS8WPpsiSz_jMBnGI,1066
+epub_translator-0.1.3.dist-info/METADATA,sha256=ruyJKZI669xCDIYL6YKoc8ojBsqbO_7Ebe15KkTjLS0,11699
+epub_translator-0.1.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+epub_translator-0.1.3.dist-info/RECORD,,