epub-translator 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

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

@@ -4,7 +4,7 @@ from enum import Enum, auto
 from xml.etree.ElementTree import Element
 
 from ..segment import TextSegment, combine_text_segments
-from ..xml import index_of_parent, is_inline_tag, iter_with_stack
+from ..xml import index_of_parent, is_inline_element, iter_with_stack
 from .stream_mapper import InlineSegmentMapping
 
 
@@ -78,7 +78,7 @@ class _Submitter:
         preserved_elements: list[Element] = []
         if self._action == SubmitKind.REPLACE:
             for child in list(node.raw_element):
-                if not is_inline_tag(child.tag):
+                if not is_inline_element(child):
                     child.tail = None
                     preserved_elements.append(child)
 
@@ -87,7 +87,7 @@ class _Submitter:
 
         if combined is not None:
             # 在 APPEND_BLOCK 模式下，如果是 inline tag，则在文本前面加空格
-            if self._action == SubmitKind.APPEND_BLOCK and is_inline_tag(combined.tag) and combined.text:
+            if self._action == SubmitKind.APPEND_BLOCK and is_inline_element(combined) and combined.text:
                 combined.text = " " + combined.text
             parent.insert(index + 1, combined)
             index += 1
@@ -200,7 +200,7 @@ class _Submitter:
         preserved_elements: list[Element] = []
         for i in range(start_index, end_index):
             elem = node_element[i]
-            if not is_inline_tag(elem.tag):
+            if not is_inline_element(elem):
                 elem.tail = None
                 preserved_elements.append(elem)
 
@@ -223,7 +223,7 @@ class _Submitter:
 
         if combined.text:
             will_inject_space = self._action == SubmitKind.APPEND_TEXT or (
-                is_inline_tag(combined.tag) and self._action == SubmitKind.APPEND_BLOCK
+                is_inline_element(combined) and self._action == SubmitKind.APPEND_BLOCK
             )
             if tail_element is not None:
                 tail_element.tail = self._append_text_in_element(

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: