epub-translator 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

epub_translator/__init__.py

@@ -1,6 +1,5 @@
-from . import language
 from .llm import LLM
-from .translator import FillFailedEvent, translate
+from .translation import FillFailedEvent, language, translate
 from .xml_translator import SubmitKind
 
 __all__ = [

epub_translator/epub/__init__.py

@@ -1,4 +1,4 @@
 from .metadata import read_metadata, write_metadata
 from .spines import search_spine_paths
-from .toc import read_toc, write_toc
+from .toc import Toc, read_toc, write_toc
 from .zip import Zip

epub_translator/llm/context.py

@@ -1,5 +1,6 @@
 import hashlib
 import json
+import threading
 import uuid
 from pathlib import Path
 from typing import Self
@@ -8,6 +9,9 @@ from .executor import LLMExecutor
 from .increasable import Increasable, Increaser
 from .types import Message, MessageRole
 
+# Global lock for cache file commit operations
+_CACHE_COMMIT_LOCK = threading.Lock()
+
 
 class LLMContext:
     def __init__(
@@ -101,7 +105,12 @@ class LLMContext:
                 # Remove the .[context-id].txt suffix to get permanent name
                 permanent_name = temp_file.name.rsplit(".", 2)[0] + ".txt"
                 permanent_file = temp_file.parent / permanent_name
-                temp_file.rename(permanent_file)
+
+                with _CACHE_COMMIT_LOCK:  # 多线程下的线程安全
+                    if permanent_file.exists():
+                        temp_file.unlink()
+                    else:
+                        temp_file.rename(permanent_file)
 
     def _rollback(self) -> None:
         for temp_file in self._temp_files:

epub_translator/llm/core.py

@@ -1,4 +1,5 @@
 import datetime
+import threading
 from collections.abc import Generator
 from importlib.resources import files
 from logging import DEBUG, FileHandler, Formatter, Logger, getLogger
@@ -14,6 +15,11 @@ from .executor import LLMExecutor
 from .increasable import Increasable
 from .types import Message
 
+# Global state for logger filename generation
+_LOGGER_LOCK = threading.Lock()
+_LAST_TIMESTAMP: str | None = None
+_LOGGER_SUFFIX_ID: int = 1
+
 
 class LLM:
     def __init__(
@@ -95,13 +101,34 @@ class LLM:
         return dir_path.resolve()
 
     def _create_logger(self) -> Logger | None:
+        # pylint: disable=global-statement
+        global _LAST_TIMESTAMP, _LOGGER_SUFFIX_ID
+
         if self._logger_save_path is None:
             return None
 
         now = datetime.datetime.now(datetime.UTC)
-        timestamp = now.strftime("%Y-%m-%d %H-%M-%S %f")
-        file_path = self._logger_save_path / f"request {timestamp}.log"
-        logger = getLogger(f"LLM Request {timestamp}")
+        # Use second-level precision for collision detection
+        timestamp_key = now.strftime("%Y-%m-%d %H-%M-%S")
+
+        with _LOGGER_LOCK:
+            if _LAST_TIMESTAMP == timestamp_key:
+                _LOGGER_SUFFIX_ID += 1
+                suffix_id = _LOGGER_SUFFIX_ID
+            else:
+                _LAST_TIMESTAMP = timestamp_key
+                _LOGGER_SUFFIX_ID = 1
+                suffix_id = 1
+
+        if suffix_id == 1:
+            file_name = f"request {timestamp_key}.log"
+            logger_name = f"LLM Request {timestamp_key}"
+        else:
+            file_name = f"request {timestamp_key}_{suffix_id}.log"
+            logger_name = f"LLM Request {timestamp_key}_{suffix_id}"
+
+        file_path = self._logger_save_path / file_name
+        logger = getLogger(logger_name)
         logger.setLevel(DEBUG)
         handler = FileHandler(file_path, encoding="utf-8")
         handler.setLevel(DEBUG)

epub_translator/segment/inline_segment.py

@@ -47,6 +47,7 @@ def search_inline_segments(text_segments: Iterable[TextSegment]) -> Generator["I
                 inline_segment = _pop_stack_data(stack_data)
                 stack_data = None
                 if inline_segment:
+                    inline_segment.id = 0
                     yield inline_segment
 
         if stack_data is None:
@@ -73,6 +74,7 @@ def search_inline_segments(text_segments: Iterable[TextSegment]) -> Generator["I
     if stack_data is not None:
         inline_segment = _pop_stack_data(stack_data)
         if inline_segment:
+            inline_segment.id = 0
             yield inline_segment
 
 
@@ -115,7 +117,7 @@ class InlineSegment:
         self._child_tag2ids: dict[str, list[int]] = {}
         self._child_tag2count: dict[str, int] = {}
 
-        next_temp_id: int = 0
+        next_temp_id: int = 1
         terms = nest((child.parent.tag, child) for child in children if isinstance(child, InlineSegment))
 
         for tag, child_terms in terms.items():
@@ -162,6 +164,14 @@ class InlineSegment:
             elif isinstance(child, InlineSegment):
                 yield from child
 
+    def clone(self) -> "InlineSegment":
+        cloned_segment = InlineSegment(
+            depth=len(self._parent_stack),
+            children=[child.clone() for child in self._children],
+        )
+        cloned_segment.id = self.id
+        return cloned_segment
+
     def recreate_ids(self, id_generator: IDGenerator) -> None:
         self._child_tag2count.clear()
         self._child_tag2ids.clear()

epub_translator/segment/text_segment.py

@@ -33,10 +33,6 @@ class TextSegment:
     def block_parent(self) -> Element:
         return self.parent_stack[self.block_depth - 1]
 
-    @property
-    def xml_text(self) -> str:
-        return "".join(_expand_xml_texts(self))
-
     def strip_block_parents(self) -> Self:
         self.parent_stack = self.parent_stack[self.block_depth - 1 :]
         self.block_depth = 1

epub_translator/translation/__init__.py

@@ -0,0 +1,2 @@
+from . import language
+from .translator import FillFailedEvent, translate

epub_translator/{epub_transcode.py → translation/epub_transcode.py}

@@ -6,8 +6,8 @@ EPUB 数据结构与 XML 的编码/解码转换
 
 from xml.etree.ElementTree import Element
 
-from .epub.metadata import MetadataField
-from .epub.toc import Toc
+from ..epub import Toc
+from ..epub.metadata import MetadataField
 
 
 def encode_toc(toc: Toc) -> Element:

epub_translator/{punctuation.py → translation/punctuation.py}

@@ -1,6 +1,6 @@
 from xml.etree.ElementTree import Element
 
-from .xml import iter_with_stack
+from ..xml import iter_with_stack
 
 _QUOTE_MAPPING = {
     # 法语引号

epub_translator/{translator.py → translation/translator.py}

@@ -5,7 +5,7 @@ from importlib.metadata import version as get_package_version
 from os import PathLike
 from pathlib import Path
 
-from .epub import (
+from ..epub import (
     Zip,
     read_metadata,
     read_toc,
@@ -13,12 +13,12 @@ from .epub import (
     write_metadata,
     write_toc,
 )
+from ..llm import LLM
+from ..xml import XMLLikeNode, deduplicate_ids_in_element, find_first
+from ..xml_translator import FillFailedEvent, SubmitKind, TranslationTask, XMLTranslator
 from .epub_transcode import decode_metadata, decode_toc_list, encode_metadata, encode_toc_list
-from .llm import LLM
 from .punctuation import unwrap_french_quotes
-from .xml import XMLLikeNode, deduplicate_ids_in_element, find_first
 from .xml_interrupter import XMLInterrupter
-from .xml_translator import FillFailedEvent, SubmitKind, TranslationTask, XMLTranslator
 
 
 class _ElementType(Enum):
@@ -40,7 +40,8 @@ def translate(
     submit: SubmitKind,
     user_prompt: str | None = None,
     max_retries: int = 5,
-    max_group_tokens: int = 1200,
+    max_group_tokens: int = 2600,
+    concurrency: int = 1,
     llm: LLM | None = None,
     translation_llm: LLM | None = None,
     fill_llm: LLM | None = None,
@@ -62,7 +63,7 @@ def translate(
         ignore_translated_error=False,
         max_retries=max_retries,
         max_fill_displaying_errors=10,
-        max_group_tokens=max_group_tokens,
+        max_group_score=max_group_tokens,
         cache_seed_content=f"{_get_version()}:{target_language}",
     )
     with Zip(
@@ -92,6 +93,7 @@ def translate(
         current_progress = 0.0
 
         for translated_elem, context in translator.translate_elements(
+            concurrency=concurrency,
             interrupt_source_text_segments=interrupter.interrupt_source_text_segments,
             interrupt_translated_text_segments=interrupter.interrupt_translated_text_segments,
             interrupt_block_element=interrupter.interrupt_block_element,

epub_translator/{xml_interrupter.py → translation/xml_interrupter.py}

@@ -2,8 +2,8 @@ from collections.abc import Generator, Iterable
 from typing import cast
 from xml.etree.ElementTree import Element
 
-from .segment import TextSegment
-from .utils import ensure_list, normalize_whitespace
+from ..segment import TextSegment
+from ..utils import ensure_list, normalize_whitespace
 
 _ID_KEY = "__XML_INTERRUPTER_ID"
 _MATH_TAG = "math"

epub_translator/xml/__init__.py

@@ -1,6 +1,6 @@
 from .const import *
 from .deduplication import *
-from .firendly import *
+from .friendly import *
 from .inline import *
 from .utils import *
 from .xml import *

epub_translator/xml_translator/concurrency.py

@@ -0,0 +1,52 @@
+from collections import deque
+from collections.abc import Callable, Iterable
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import TypeVar
+
+P = TypeVar("P")
+R = TypeVar("R")
+
+
+def run_concurrency(
+    parameters: Iterable[P],
+    execute: Callable[[P], R],
+    concurrency: int,
+) -> Iterable[R]:
+    assert concurrency >= 1, "the concurrency must be at least 1"
+    # Fast path: concurrency == 1, no thread overhead
+    if concurrency == 1:
+        for param in parameters:
+            yield execute(param)
+        return
+
+    executor = ThreadPoolExecutor(max_workers=concurrency)
+    did_shutdown = False
+    try:
+        futures: deque[Future[R]] = deque()
+        params_iter = iter(parameters)
+        for _ in range(concurrency):
+            try:
+                param = next(params_iter)
+                future = executor.submit(execute, param)
+                futures.append(future)
+            except StopIteration:
+                break
+
+        while futures:
+            future = futures.popleft()
+            yield future.result()
+            try:
+                param = next(params_iter)
+                new_future = executor.submit(execute, param)
+                futures.append(new_future)
+            except StopIteration:
+                pass
+
+    except KeyboardInterrupt:
+        executor.shutdown(wait=False, cancel_futures=True)
+        did_shutdown = True
+        raise
+
+    finally:
+        if not did_shutdown:
+            executor.shutdown(wait=True)

epub_translator/xml_translator/score.py

@@ -0,0 +1,164 @@
+from collections.abc import Generator
+from dataclasses import dataclass
+from enum import Enum, auto
+
+from tiktoken import Encoding
+
+from ..segment import InlineSegment, TextSegment
+from .common import DATA_ORIGIN_LEN_KEY
+
+_ID_WEIGHT = 80
+_ELLIPSIS = "..."
+
+
+@dataclass
+class ScoreSegment:
+    text_segment: TextSegment
+    left_parents: list[InlineSegment]
+    right_parents: list[InlineSegment]
+    text_tokens: list[int]
+    score: int
+
+
+def expand_to_score_segments(encoding: Encoding, inline_segment: InlineSegment) -> Generator[ScoreSegment, None, None]:
+    for i, score_segment in enumerate(_do_expand_inline_segment(inline_segment)):
+        xml_text = "".join(
+            _render_score_segment(
+                score_segment=score_segment,
+                is_first=(i == 0),
+            )
+        )
+        score_segment.text_tokens = encoding.encode(score_segment.text_segment.text)
+        score_segment.score = len(encoding.encode(xml_text)) + sum(
+            _ID_WEIGHT for parent in score_segment.left_parents if parent.id is not None
+        )
+        yield score_segment
+
+
+def truncate_score_segment(
+    encoding: Encoding,
+    score_segment: ScoreSegment,
+    remain_head: bool,
+    remain_score: int,
+):
+    fixed_score = score_segment.score - len(score_segment.text_tokens)
+    if remain_score <= fixed_score:
+        # 裁剪仅能减少 text 部分的 tokens 数。
+        # 而 XML 本身头尾占用的 tokens 数，以及 ID 占用加权分属于 fixed_score 部分，无法裁剪
+        # 当发现将文字删光后才能达标时，不如直接放弃整段内容
+        return None
+
+    remain_text_tokens_count = remain_score - fixed_score
+
+    # remain_text_tokens_count cannot be 0 here
+    if remain_head:
+        remain_text = encoding.decode(score_segment.text_tokens[:remain_text_tokens_count])
+    else:
+        remain_text = encoding.decode(score_segment.text_tokens[-remain_text_tokens_count:])
+
+    if not remain_text.strip():
+        return None
+
+    if remain_head:
+        remain_text = f"{remain_text} {_ELLIPSIS}"
+    else:
+        remain_text = f"{_ELLIPSIS} {remain_text}"
+
+    text_segment = score_segment.text_segment.clone()
+    text_segment.text = remain_text
+
+    return ScoreSegment(
+        text_segment=text_segment,
+        left_parents=score_segment.left_parents,
+        right_parents=score_segment.right_parents,
+        text_tokens=encoding.encode(remain_text),
+        score=remain_text_tokens_count + fixed_score,
+    )
+
+
+def _render_score_segment(score_segment: ScoreSegment, is_first: bool):
+    for i, parent in enumerate(score_segment.left_parents):
+        yield "<"
+        yield parent.parent.tag
+        if parent.id is not None:
+            yield ' id="99"'
+        if is_first and i == 0:
+            yield " "
+            yield DATA_ORIGIN_LEN_KEY
+            yield '="9999"'
+        yield ">"
+
+    yield score_segment.text_segment.text
+
+    for parent in reversed(score_segment.right_parents):
+        yield "</"
+        yield parent.parent.tag
+        yield ">"
+
+
+def _do_expand_inline_segment(inline_segment: InlineSegment):
+    text_segment: TextSegment | None = None
+    left_parents: list[InlineSegment] = []
+    right_parents: list[InlineSegment] = []
+
+    for item in _expand_as_wrapped(inline_segment):
+        if isinstance(item, TextSegment):
+            if text_segment is None:
+                text_segment = item
+            else:
+                yield ScoreSegment(
+                    text_segment=text_segment,
+                    left_parents=left_parents,
+                    right_parents=right_parents,
+                    text_tokens=[],
+                    score=0,
+                )
+                text_segment = item
+                left_parents = []
+                right_parents = []
+
+        elif isinstance(item, tuple):
+            child_inline_segment, orientation = item
+            if orientation == _Orientation.UP:
+                if text_segment is not None:
+                    yield ScoreSegment(
+                        text_segment=text_segment,
+                        left_parents=left_parents,
+                        right_parents=right_parents,
+                        text_tokens=[],
+                        score=0,
+                    )
+                    text_segment = None
+                    left_parents = []
+                    right_parents = []
+                left_parents.append(child_inline_segment)
+
+            elif orientation == _Orientation.DOWN:
+                if text_segment is None:
+                    left_parents.clear()
+                else:
+                    right_parents.append(child_inline_segment)
+
+    if text_segment is not None:
+        yield ScoreSegment(
+            text_segment=text_segment,
+            left_parents=left_parents,
+            right_parents=right_parents,
+            text_tokens=[],
+            score=0,
+        )
+
+
+class _Orientation(Enum):
+    DOWN = auto()
+    UP = auto()
+
+
+def _expand_as_wrapped(inline_segment: InlineSegment):
+    yield (inline_segment, _Orientation.UP)
+    for child in inline_segment.children:
+        if isinstance(child, InlineSegment):
+            yield from _expand_as_wrapped(child)
+        elif isinstance(child, TextSegment):
+            yield child
+    yield (inline_segment, _Orientation.DOWN)

epub_translator/xml_translator/stream_mapper.py

@@ -1,4 +1,5 @@
 from collections.abc import Callable, Generator, Iterable, Iterator
+from typing import TypeVar
 from xml.etree.ElementTree import Element
 
 from resource_segmentation import Group, Resource, Segment, split
@@ -6,11 +7,14 @@ from tiktoken import Encoding
 
 from ..segment import InlineSegment, TextSegment, search_inline_segments, search_text_segments
 from .callbacks import Callbacks
+from .concurrency import run_concurrency
+from .score import ScoreSegment, expand_to_score_segments, truncate_score_segment
 
 _PAGE_INCISION = 0
 _BLOCK_INCISION = 1
+_T = TypeVar("_T")
 
-_ELLIPSIS = "..."
+_ResourcePayload = tuple[InlineSegment, list[ScoreSegment]]
 
 
 InlineSegmentMapping = tuple[Element, list[TextSegment]]
@@ -18,23 +22,33 @@ InlineSegmentGroupMap = Callable[[list[InlineSegment]], list[InlineSegmentMappin
 
 
 class XMLStreamMapper:
-    def __init__(self, encoding: Encoding, max_group_tokens: int) -> None:
+    def __init__(self, encoding: Encoding, max_group_score: int) -> None:
         self._encoding: Encoding = encoding
-        self._max_group_tokens: int = max_group_tokens
+        self._max_group_score: int = max_group_score
 
     def map_stream(
         self,
         elements: Iterator[Element],
         callbacks: Callbacks,
         map: InlineSegmentGroupMap,
+        concurrency: int,
     ) -> Generator[tuple[Element, list[InlineSegmentMapping]], None, None]:
         current_element: Element | None = None
         mapping_buffer: list[InlineSegmentMapping] = []
 
-        for group in self._split_into_serial_groups(elements, callbacks):
+        def execute(group: Group[_ResourcePayload]):
             head, body, tail = self._truncate_and_transform_group(group)
+            head = [segment.clone() for segment in head]
+            tail = [segment.clone() for segment in tail]
             target_body = map(head + body + tail)[len(head) : len(head) + len(body)]
-            for origin, target in zip(body, target_body, strict=False):
+            return zip(body, target_body, strict=False)
+
+        for mapping_pairs in run_concurrency(
+            parameters=self._split_into_serial_groups(elements, callbacks),
+            execute=execute,
+            concurrency=concurrency,
+        ):
+            for origin, target in mapping_pairs:
                 origin_element = origin.head.root
                 if current_element is None:
                     current_element = origin_element
@@ -58,7 +72,7 @@ class XMLStreamMapper:
         def generate():
             for element in elements:
                 yield from split(
-                    max_segment_count=self._max_group_tokens,
+                    max_segment_count=self._max_group_score,
                     border_incision=_PAGE_INCISION,
                     resources=self._expand_to_resources(element, callbacks),
                 )
@@ -79,7 +93,7 @@ class XMLStreamMapper:
             next_sum_body_count = sum(x.count for x in self._expand_resource_segments(next_group.body))
             next_sum_count = sum_count + next_sum_body_count
 
-            if next_sum_count + next_group.tail_remain_count > self._max_group_tokens:
+            if next_sum_count + next_group.tail_remain_count > self._max_group_score:
                 yield group
                 group = next_group
                 sum_count = group.head_remain_count + next_sum_body_count
@@ -91,23 +105,25 @@ class XMLStreamMapper:
 
         yield group
 
-    def _truncate_and_transform_group(self, group: Group[InlineSegment]):
-        head = list(
-            self._truncate_inline_segments(
-                inline_segments=self._expand_inline_segments(group.head),
-                remain_head=False,
-                remain_count=group.head_remain_count,
-            )
+    def _truncate_and_transform_group(
+        self, group: Group[_ResourcePayload]
+    ) -> tuple[list[InlineSegment], list[InlineSegment], list[InlineSegment]]:
+        head = self._truncate_group_gap(
+            gap=group.head,
+            remain_head=False,
+            remain_score=group.head_remain_count,
         )
-        body = list(self._expand_inline_segments(group.body))
-        tail = list(
-            self._truncate_inline_segments(
-                inline_segments=self._expand_inline_segments(group.tail),
-                remain_head=True,
-                remain_count=group.tail_remain_count,
-            )
+        body = self._expand_inline_segments(group.body)
+        tail = self._truncate_group_gap(
+            gap=group.tail,
+            remain_head=True,
+            remain_score=group.tail_remain_count,
+        )
+        return (
+            [r.payload[0] for r in head],
+            [p[0] for p in body],
+            [r.payload[0] for r in tail],
         )
-        return head, body, tail
 
     def _expand_to_resources(self, element: Element, callbacks: Callbacks):
         def expand(element: Element):
@@ -131,123 +147,138 @@ class XMLStreamMapper:
             else:
                 end_incision = _PAGE_INCISION
 
-            yield Resource(
-                count=sum(len(self._encoding.encode(t.xml_text)) for t in inline_segment),
+            yield self._transform_to_resource(
+                inline_segment=inline_segment,
                 start_incision=start_incision,
                 end_incision=end_incision,
-                payload=inline_segment,
             )
             inline_segment = next_inline_segment
             start_incision = end_incision
 
-        yield Resource(
-            count=sum(len(self._encoding.encode(t.xml_text)) for t in inline_segment),
+        yield self._transform_to_resource(
+            inline_segment=inline_segment,
             start_incision=start_incision,
             end_incision=_PAGE_INCISION,
-            payload=inline_segment,
         )
 
-    def _truncate_inline_segments(self, inline_segments: Iterable[InlineSegment], remain_head: bool, remain_count: int):
-        def clone_and_expand(segments: Iterable[InlineSegment]):
-            for segment in segments:
-                for child_segment in segment:
-                    yield child_segment.clone()  # 切割对应的 head 和 tail 会与其他 group 重叠，复制避免互相影响
-
-        truncated_text_segments = self._truncate_text_segments(
-            text_segments=clone_and_expand(inline_segments),
-            remain_head=remain_head,
-            remain_count=remain_count,
+    def _transform_to_resource(
+        self,
+        inline_segment: InlineSegment,
+        start_incision: int,
+        end_incision: int,
+    ) -> Resource[_ResourcePayload]:
+        source_segments = list(
+            expand_to_score_segments(
+                encoding=self._encoding,
+                inline_segment=inline_segment,
+            )
+        )
+        return Resource(
+            count=sum(segment.score for segment in source_segments),
+            start_incision=start_incision,
+            end_incision=end_incision,
+            payload=(inline_segment, source_segments),
         )
-        yield from search_inline_segments(truncated_text_segments)
 
-    def _expand_inline_segments(self, items: list[Resource[InlineSegment] | Segment[InlineSegment]]):
+    def _expand_inline_segments(self, items: list[Resource[_ResourcePayload] | Segment[_ResourcePayload]]):
         for resource in self._expand_resource_segments(items):
             yield resource.payload
 
-    def _expand_resource_segments(self, items: list[Resource[InlineSegment] | Segment[InlineSegment]]):
+    def _expand_resource_segments(self, items: list[Resource[_ResourcePayload] | Segment[_ResourcePayload]]):
         for item in items:
             if isinstance(item, Resource):
                 yield item
             elif isinstance(item, Segment):
                 yield from item.resources
 
-    def _truncate_text_segments(self, text_segments: Iterable[TextSegment], remain_head: bool, remain_count: int):
-        if remain_head:
-            yield from self._filter_and_remain_segments(
-                segments=text_segments,
+    def _truncate_group_gap(
+        self,
+        gap: list[Resource[_ResourcePayload] | Segment[_ResourcePayload]],
+        remain_head: bool,
+        remain_score: int,
+    ):
+        def expand_resource_segments(items: list[Resource[_ResourcePayload] | Segment[_ResourcePayload]]):
+            for item in items:
+                if isinstance(item, Resource):
+                    yield item
+                elif isinstance(item, Segment):
+                    yield from item.resources
+
+        resources, remain_score = _truncate_items(
+            items=expand_resource_segments(gap),
+            score=lambda resource: resource.count,
+            remain_head=remain_head,
+            remain_score=remain_score,
+        )
+        if remain_score > 0:
+            resource = resources.pop() if remain_head else resources.pop(0)
+            inline_segment, score_segments = resource.payload
+            score_segments, remain_score = _truncate_items(
+                items=score_segments,
+                score=lambda score_segment: score_segment.score,
                 remain_head=remain_head,
-                remain_count=remain_count,
+                remain_score=remain_score,
             )
-        else:
-            yield from reversed(
-                list(
-                    self._filter_and_remain_segments(
-                        segments=reversed(list(text_segments)),
-                        remain_head=remain_head,
-                        remain_count=remain_count,
-                    )
+            if remain_score > 0:
+                score_segment = score_segments.pop() if remain_head else score_segments.pop(0)
+                score_segment = truncate_score_segment(
+                    score_segment=score_segment,
+                    encoding=self._encoding,
+                    remain_head=remain_head,
+                    remain_score=remain_score,
+                )
+                if score_segment is not None:
+                    if remain_head:
+                        score_segments.append(score_segment)
+                    else:
+                        score_segments.insert(0, score_segment)
+
+                inline_segment = next(
+                    search_inline_segments(s.text_segment for s in score_segments),
+                    None,
                 )
-            )
 
-    def _filter_and_remain_segments(self, segments: Iterable[TextSegment], remain_head: bool, remain_count: int):
-        for segment in segments:
-            if remain_count <= 0:
-                break
-            raw_xml_text = segment.xml_text
-            tokens = self._encoding.encode(raw_xml_text)
-            tokens_count = len(tokens)
-
-            if tokens_count > remain_count:
-                truncated_segment = self._truncate_text_segment(
-                    segment=segment,
-                    tokens=tokens,
-                    raw_xml_text=raw_xml_text,
-                    remain_head=remain_head,
-                    remain_count=remain_count,
+            if inline_segment is not None:
+                resource = Resource(
+                    count=sum(s.score for s in score_segments),
+                    start_incision=resource.start_incision,
+                    end_incision=resource.end_incision,
+                    payload=(inline_segment, score_segments),
                 )
-                if truncated_segment is not None:
-                    yield truncated_segment
-                break
+                if remain_head:
+                    resources.append(resource)
+                else:
+                    resources.insert(0, resource)
 
-            yield segment
-            remain_count -= tokens_count
+        return resources
 
-    def _truncate_text_segment(
-        self,
-        segment: TextSegment,
-        tokens: list[int],
-        raw_xml_text: str,
-        remain_head: bool,
-        remain_count: int,
-    ) -> TextSegment | None:
-        # 典型的 xml_text: <tag id="99" data-origin-len="999">Some text</tag>
-        # 如果切割点在前缀 XML 区，则整体舍弃
-        # 如果切割点在后缀 XML 区，则整体保留
-        # 只有刚好切割在正文区，才执行文本截断操作
-        remain_text: str
-        xml_text_head_length = raw_xml_text.find(segment.text)
-
-        if remain_head:
-            remain_xml_text = self._encoding.decode(tokens[:remain_count])  # remain_count cannot be 0 here
-            if len(remain_xml_text) <= xml_text_head_length:
-                return None
-            if len(remain_xml_text) >= xml_text_head_length + len(segment.text):
-                return segment
-            remain_text = remain_xml_text[xml_text_head_length:]
-        else:
-            xml_text_tail_length = len(raw_xml_text) - (xml_text_head_length + len(segment.text))
-            remain_xml_text = self._encoding.decode(tokens[-remain_count:])
-            if len(remain_xml_text) <= xml_text_tail_length:
-                return None
-            if len(remain_xml_text) >= xml_text_tail_length + len(segment.text):
-                return segment
-            remain_text = remain_xml_text[: len(remain_xml_text) - xml_text_tail_length]
-
-        if not remain_text.strip():
-            return None
-
-        if remain_head:
-            segment.text = f"{remain_text} {_ELLIPSIS}"
-        else:
-            segment.text = f"{_ELLIPSIS} {remain_text}"
-        return segment
+
+def _truncate_items(items: Iterable[_T], score: Callable[[_T], int], remain_head: bool, remain_score: int):
+    truncated_items = list(items)
+    if not truncated_items:
+        return truncated_items, 0
+
+    if not remain_head:
+        truncated_items.reverse()
+
+    truncated_index: int | None = None
+    for i, item in enumerate(truncated_items):
+        item_score = score(item)
+        remain_score -= item_score
+        if remain_score <= 0:
+            truncated_index = i
+            break
+
+    if truncated_index is not None:
+        while len(truncated_items) > truncated_index + 1:
+            truncated_items.pop()
+
+    if truncated_items and remain_score < 0:
+        remain_score = score(truncated_items[-1]) + remain_score
+    else:
+        remain_score = 0
+
+    if not remain_head:
+        truncated_items.reverse()
+
+    return truncated_items, remain_score

epub_translator/xml_translator/submitter.py

@@ -122,11 +122,17 @@ class _Submitter:
                 last_tail_element = child_element
 
         for text_segments, child_node in node.items:
-            tail_element = tail_elements.get(id(child_node.raw_element), None)
+            anchor_element = _find_anchor_in_parent(node.raw_element, child_node.raw_element)
+            if anchor_element is None:
+                # 防御性编程：理论上 anchor_element 不应该为 None，
+                #           因为 _nest_nodes 已经通过 _check_includes 验证了包含关系。
+                continue
+
+            tail_element = tail_elements.get(id(anchor_element), None)
             items_preserved_elements: list[Element] = []
 
             if self._action == SubmitKind.REPLACE:
-                end_index = index_of_parent(node.raw_element, child_node.raw_element)
+                end_index = index_of_parent(node.raw_element, anchor_element)
                 items_preserved_elements = self._remove_elements_after_tail(
                     node_element=node.raw_element,
                     tail_element=tail_element,
@@ -137,11 +143,11 @@ class _Submitter:
                 node_element=node.raw_element,
                 text_segments=text_segments,
                 tail_element=tail_element,
+                anchor_element=anchor_element,
                 append_to_end=False,
-                ref_element=child_node.raw_element,
             )
             if items_preserved_elements:
-                insert_position = index_of_parent(node.raw_element, child_node.raw_element)
+                insert_position = index_of_parent(node.raw_element, anchor_element)
                 for i, elem in enumerate(items_preserved_elements):
                     node.raw_element.insert(insert_position + i, elem)
 
@@ -166,7 +172,7 @@ class _Submitter:
             node_element=node.raw_element,
             text_segments=node.tail_text_segments,
             tail_element=last_tail_element,
-            ref_element=None,
+            anchor_element=None,
             append_to_end=True,
         )
         if tail_preserved_elements:
@@ -208,7 +214,7 @@ class _Submitter:
         node_element: Element,
         text_segments: list[TextSegment],
         tail_element: Element | None,
-        ref_element: Element | None,
+        anchor_element: Element | None,
         append_to_end: bool,
     ) -> None:
         combined = self._combine_text_segments(text_segments)
@@ -225,14 +231,14 @@ class _Submitter:
                     append_text=combined.text,
                     will_inject_space=will_inject_space,
                 )
-            elif ref_element is None:
+            elif anchor_element is None:
                 node_element.text = self._append_text_in_element(
                     origin_text=node_element.text,
                     append_text=combined.text,
                     will_inject_space=will_inject_space,
                 )
             else:
-                ref_index = index_of_parent(node_element, ref_element)
+                ref_index = index_of_parent(node_element, anchor_element)
                 if ref_index > 0:
                     # 添加到前一个元素的 tail
                     prev_element = node_element[ref_index - 1]
@@ -253,10 +259,10 @@ class _Submitter:
             insert_position = index_of_parent(node_element, tail_element) + 1
         elif append_to_end:
             insert_position = len(node_element)
-        elif ref_element is not None:
+        elif anchor_element is not None:
             # 使用 ref_element 来定位插入位置
             # 如果文本被添加到前一个元素的 tail，则在前一个元素之后插入
-            ref_index = index_of_parent(node_element, ref_element)
+            ref_index = index_of_parent(node_element, anchor_element)
             if ref_index > 0:
                 # 在前一个元素之后插入
                 insert_position = ref_index
@@ -346,6 +352,18 @@ def _nest_nodes(mappings: list[InlineSegmentMapping]) -> Generator[_Node, None,
             yield child_node
 
 
+def _find_anchor_in_parent(parent: Element, descendant: Element) -> Element | None:
+    for child in parent:
+        if child is descendant:
+            return descendant
+
+    for child in parent:
+        if _check_includes(child, descendant):
+            return child
+
+    return None
+
+
 def _fold_top_of_stack(stack: list[_Node]):
     child_node = stack.pop()
     if not stack:

epub_translator/xml_translator/translator.py

@@ -31,7 +31,7 @@ class XMLTranslator:
         ignore_translated_error: bool,
         max_retries: int,
         max_fill_displaying_errors: int,
-        max_group_tokens: int,
+        max_group_score: int,
         cache_seed_content: str | None = None,
     ) -> None:
         self._translation_llm: LLM = translation_llm
@@ -44,12 +44,13 @@ class XMLTranslator:
         self._cache_seed_content: str | None = cache_seed_content
         self._stream_mapper: XMLStreamMapper = XMLStreamMapper(
             encoding=translation_llm.encoding,
-            max_group_tokens=max_group_tokens,
+            max_group_score=max_group_score,
         )
 
     def translate_element(
         self,
         task: TranslationTask[T],
+        concurrency: int = 1,
         interrupt_source_text_segments: Callable[[Iterable[TextSegment]], Iterable[TextSegment]] | None = None,
         interrupt_translated_text_segments: Callable[[Iterable[TextSegment]], Iterable[TextSegment]] | None = None,
         interrupt_block_element: Callable[[Element], Element] | None = None,
@@ -57,6 +58,7 @@ class XMLTranslator:
     ) -> tuple[Element, T]:
         for translated in self.translate_elements(
             tasks=((task),),
+            concurrency=concurrency,
             interrupt_source_text_segments=interrupt_source_text_segments,
             interrupt_translated_text_segments=interrupt_translated_text_segments,
             interrupt_block_element=interrupt_block_element,
@@ -69,6 +71,7 @@ class XMLTranslator:
     def translate_elements(
         self,
         tasks: Iterable[TranslationTask[T]],
+        concurrency: int = 1,
         interrupt_source_text_segments: Callable[[Iterable[TextSegment]], Iterable[TextSegment]] | None = None,
         interrupt_translated_text_segments: Callable[[Iterable[TextSegment]], Iterable[TextSegment]] | None = None,
         interrupt_block_element: Callable[[Element], Element] | None = None,
@@ -90,6 +93,7 @@ class XMLTranslator:
         for element, mappings in self._stream_mapper.map_stream(
             elements=generate_elements(),
             callbacks=callbacks,
+            concurrency=concurrency,
             map=lambda inline_segments: self._translate_inline_segments(
                 inline_segments=inline_segments,
                 callbacks=callbacks,
@@ -117,8 +121,7 @@ class XMLTranslator:
                 inline_segments=inline_segments,
             ),
         )
-        text_segments = (text for inline in inline_segments for text in inline)
-        source_text = "".join(self._render_text_segments(text_segments))
+        source_text = "".join(self._render_source_text_parts(inline_segments))
         translated_text = self._translate_text(source_text)
 
         self._request_and_submit(
@@ -137,21 +140,12 @@ class XMLTranslator:
 
         return mappings
 
-    def _render_text_segments(self, segments: Iterable[TextSegment]):
-        # TODO: 没必要，直接按照新的 inline segment 组织就行了
-        iterator = iter(segments)
-        segment = next(iterator, None)
-        if segment is None:
-            return
-        while True:
-            next_segment = next(iterator, None)
-            if next_segment is None:
-                break
-            yield segment.text
-            if id(segment.block_parent) != id(next_segment.block_parent):
+    def _render_source_text_parts(self, inline_segments: list[InlineSegment]):
+        for i, inline_segment in enumerate(inline_segments):
+            if i > 0:
                 yield "\n\n"
-            segment = next_segment
-        yield segment.text
+            for text_segment in inline_segment:
+                yield text_segment.text
 
     def _translate_text(self, text: str) -> str:
         with self._translation_llm.context(cache_seed_content=self._cache_seed_content) as ctx:

{epub_translator-0.1.4.dist-info → epub_translator-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: epub-translator
-Version: 0.1.4
+Version: 0.1.6
 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
@@ -156,7 +156,8 @@ translate(
     submit: SubmitKind,                # How to insert translations (REPLACE, APPEND_TEXT, or APPEND_BLOCK)
     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
+    max_group_tokens: int = 2600,      # Maximum tokens per translation group
+    concurrency: int = 1,              # Number of concurrent translation tasks (default: 1)
     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)
@@ -238,16 +239,17 @@ translate(
 
 ### Error Handling with `on_fill_failed`
 
-Monitor and handle translation errors using the `on_fill_failed` callback:
+Monitor translation errors using the `on_fill_failed` callback. The system automatically retries failed translations up to `max_retries` times (default: 5). Most errors are recovered during retries and don't affect the final output.
 
 ```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}")
+    # Only log critical errors that will affect the final EPUB
     if event.over_maximum_retries:
-        print("  Maximum retries exceeded!")
+        print(f"Critical error after {event.retried_count} attempts:")
+        print(f"  {event.error_message}")
+        print("  This error will be present in the final EPUB file!")
 
 translate(
     source_path="source.epub",
@@ -259,10 +261,32 @@ translate(
 )
 ```
 
+**Understanding Error Severity:**
+
 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
+- `retried_count: int` - Current retry attempt number (1 to max_retries)
+- `over_maximum_retries: bool` - Whether the error is critical
+
+**Error Categories:**
+
+- **Recoverable errors** (`over_maximum_retries=False`): Errors during retry attempts. The system will continue retrying and may resolve these automatically. Safe to ignore in most cases.
+
+- **Critical errors** (`over_maximum_retries=True`): Errors that persist after all retry attempts. These will appear in the final EPUB file and should be investigated.
+
+**Advanced Usage:**
+
+For verbose logging during translation debugging:
+
+```python
+def handle_fill_error(event: FillFailedEvent):
+    if event.over_maximum_retries:
+        # Critical: affects final output
+        print(f"❌ CRITICAL: {event.error_message}")
+    else:
+        # Informational: system is retrying
+        print(f"⚠️  Retry {event.retried_count}: {event.error_message}")
+```
 
 ### Dual-LLM Architecture
 
@@ -371,6 +395,32 @@ llm = LLM(
 )
 ```
 
+### Concurrent Translation
+
+Speed up translation by processing multiple text segments concurrently. Use the `concurrency` parameter to control how many translation tasks run in parallel:
+
+```python
+translate(
+    source_path="source.epub",
+    target_path="translated.epub",
+    target_language="English",
+    submit=SubmitKind.APPEND_BLOCK,
+    llm=llm,
+    concurrency=4,  # Process 4 segments concurrently
+)
+```
+
+**Performance Tips:**
+
+- Start with `concurrency=4` and adjust based on your API rate limits and system resources
+- Higher concurrency values can significantly reduce translation time for large books
+- The translation order is preserved regardless of concurrency settings
+- Monitor your API provider's rate limits to avoid throttling
+
+**Thread Safety:**
+
+When using `concurrency > 1`, ensure that any custom callback functions (`on_progress`, `on_fill_failed`) are thread-safe. Built-in callbacks are thread-safe by default.
+
 ## Related Projects
 
 ### PDF Craft

{epub_translator-0.1.4.dist-info → epub_translator-0.1.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-epub_translator/__init__.py,sha256=m2uTGNmBmZhRWQjjYQ1TVrjOuFXJhzQnuuTOq5-t29U,234
+epub_translator/__init__.py,sha256=JsiOUPpk5k7q8mXIgnRQWdVVnkJww_KDTg7jXsP7_C4,222
 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
@@ -9,60 +9,63 @@ epub_translator/data/mmltex/scripts.xsl,sha256=f4ei0cDCW3cV-Ra7rC3kC5tRcKdjJxbSp
 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/__init__.py,sha256=aZawPakdkEquL4kRRpyCTdoSQ82l7FGqY4Uw6-ndoGA,154
 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/context.py,sha256=8-0UnrZIaNshR_imy_ed_UpOK7H1a6dOsG-boaYOX8k,4186
+epub_translator/llm/core.py,sha256=wQwt6oG68ZN_iQOaytBiPXOC7sI62XII_A4dOHdAt_s,5979
 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/punctuation.py,sha256=Yrf3b_Pl36FPBaK96LR-EBjnztlcZZTWLSNaYoWIUSc,812
 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=Fos3tTuTcpnm-NmqPftzqov1_Rwr57PBv8AIgjKNYcg,6389
+epub_translator/segment/inline_segment.py,sha256=nrRKoJ-vblsNITJeixrCgIOkVQyUXrchMg0XYU_8pLo,14563
+epub_translator/segment/text_segment.py,sha256=LhGlugp6MeAB3tk2jxd1kBb2EA8G2ruN49mP_IZehA0,6295
 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=SL0Qh49QaZD3bKKkf5xM0hF2MkPqzxKO8uyo8rn9wTQ,6421
+epub_translator/translation/__init__.py,sha256=R0c0ZngocOC-Qczs0a8JYAdAcCu2gv3FLcSrUyhwDMo,74
+epub_translator/translation/epub_transcode.py,sha256=_pRzmQgDrlfsibalkUogVi0F0Qy_uuYfKhZk3nP5pkA,2747
+epub_translator/translation/language.py,sha256=88osG0JNYxOkxBjg5Pm-P0Mhiyxf6GqdxoPW12HW0PE,493
+epub_translator/translation/punctuation.py,sha256=TPCGjEmlAyN3G11VuXdHn-pvUkuWDwWqbTNzw-ij60E,813
+epub_translator/translation/translator.py,sha256=WC4Yqx-ffhxBhqzMAujE_NQG7BsDwgn95UMNG7OkUSo,6487
+epub_translator/translation/xml_interrupter.py,sha256=QxrNpBoR4ZIAvWsa20jz1z_bE_5-G5-nBGjE6IKCTjw,7405
 epub_translator/utils.py,sha256=BfZWrYjzDNQ4cFrgvRNzd4i1CKLtPxS8Z4LBHhqEV78,914
-epub_translator/xml/__init__.py,sha256=1sBLICHtNNw0UNMOXCZzrZ7uGfOwnPf_m4MmmMNzakY,160
+epub_translator/xml/__init__.py,sha256=qluFTfZYlPmOie8nR2C5O0tZ3UbCQEoEoR-Fq-__79c,160
 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/friendly/__init__.py,sha256=I5jhnhFWoHvojLsYXH4jfR4Gi8lKFZ3yQ56ze5hEe1M,74
+epub_translator/xml/friendly/decoder.py,sha256=xRQ5LnSunmYbba_0oT39oUr86-sLYAHYMUGmlseIu2U,2467
+epub_translator/xml/friendly/encoder.py,sha256=evjvw6oE-oCud44IsJ-YZVHn6dtUzjNYX25ljaZP6vY,2417
+epub_translator/xml/friendly/parser.py,sha256=QlMHA0nfPJbNyx6IwRFrYVw7okuvzDB42NXCauIFV-o,6560
+epub_translator/xml/friendly/tag.py,sha256=ahaGoYttuAlnFxLFFgTV51KUZSpUiHho-COZX14nxN8,3308
+epub_translator/xml/friendly/transform.py,sha256=5tG1MJmzrXIR_Z5gmRxwcoKvXBzJBVH0ELeaRsG-8w0,1201
 epub_translator/xml/inline.py,sha256=mwFho6wq2gYWmWcg5Cw6OQeteV-a-i6X9OE63fzblpE,1274
 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=lqts1mJL_WfojDnMAQ5OM7TbT6u9X3H-X4C_avHzvXM,128
 epub_translator/xml_translator/callbacks.py,sha256=IoZrsaivd2W76cHFupwv6auVxgEWHcBN2MHQJYcWoJ8,1324
 epub_translator/xml_translator/common.py,sha256=hSPptgPp7j6dm47imELB5DgmEbzTEyJD6WEeELOOc50,38
+epub_translator/xml_translator/concurrency.py,sha256=ACwoDHNX3xChL0On5yvUSFT8By7aoHoKor94k6A8nuY,1502
 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=udKu0GI_ifdhFFDxH2iwDMQV2RTIrHj8LZbwnrifjEw,13536
-epub_translator/xml_translator/translator.py,sha256=eIvniqKtNoqFFvfvxK4oA-W02y5ZTpmPQ8wFAJlvOUU,9752
+epub_translator/xml_translator/score.py,sha256=TkXDmr-29p8SzuAp68u_vFDE69y1TyId9S20HT1T_xs,5311
+epub_translator/xml_translator/stream_mapper.py,sha256=nk8iRUHAUQA2B35_y-JOCo6il8MSxXikWvyl-WA8WAA,10662
+epub_translator/xml_translator/submitter.py,sha256=6PGQTnEcOgL3zseDpSzDmU5d9Eg3eO5OfPIGmQp2DVY,14155
+epub_translator/xml_translator/translator.py,sha256=7Ja1jFbmjIgHcmI9V6gg_K0t7qb6in9mhRn54a7qhZ8,9497
 epub_translator/xml_translator/validation.py,sha256=-OKlSZuD__sjAiEpGAO93YQme4ZDSPmoPjRsAMOCEjc,16668
-epub_translator-0.1.4.dist-info/LICENSE,sha256=5RF32sL3LtMOJIErdDKp1ZEYPGXS8WPpsiSz_jMBnGI,1066
-epub_translator-0.1.4.dist-info/METADATA,sha256=2MoSuiXT8te4tsIODhdUpcMyaAoFH9jQ_Ka6Ixwt3pY,13525
-epub_translator-0.1.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-epub_translator-0.1.4.dist-info/RECORD,,
+epub_translator-0.1.6.dist-info/LICENSE,sha256=5RF32sL3LtMOJIErdDKp1ZEYPGXS8WPpsiSz_jMBnGI,1066
+epub_translator-0.1.6.dist-info/METADATA,sha256=AcjUb1wmz6cN8PnbwgWJeGlOO9sH445B-qPugLW705M,15638
+epub_translator-0.1.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+epub_translator-0.1.6.dist-info/RECORD,,