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

epub_translator/xml/xml_like.py

@@ -1,10 +1,14 @@
 import io
 import re
+import warnings
 from typing import IO
 from xml.etree.ElementTree import Element, fromstring, tostring
 
+from .self_closing import self_close_void_elements, unclose_void_elements
 from .xml import iter_with_stack
 
+_XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace"
+
 _COMMON_NAMESPACES = {
     "http://www.w3.org/1999/xhtml": "xhtml",
     "http://www.idpf.org/2007/ops": "epub",
@@ -14,6 +18,7 @@ _COMMON_NAMESPACES = {
     "http://www.idpf.org/2007/opf": "opf",
     "http://www.w3.org/2000/svg": "svg",
     "urn:oasis:names:tc:opendocument:xmlns:container": "container",
+    "http://www.w3.org/XML/1998/namespace": "xml",  # Reserved XML namespace
 }
 
 _ROOT_NAMESPACES = {
@@ -27,32 +32,26 @@ _ENCODING_PATTERN = re.compile(r'encoding\s*=\s*["\']([^"\']+)["\']', re.IGNOREC
 _FIRST_ELEMENT_PATTERN = re.compile(r"<(?![?!])[a-zA-Z]")
 _NAMESPACE_IN_TAG = re.compile(r"\{([^}]+)\}")
 
-# HTML 规定了一系列自闭标签，这些标签需要改成非自闭的，因为 EPub 格式不支持
-# https://www.tutorialspoint.com/which-html-tags-are-self-closing
-_EMPTY_TAGS = (
-    "br",
-    "hr",
-    "input",
-    "col",
-    "base",
-    "meta",
-    "area",
-)
-
-_EMPTY_TAG_PATTERN = re.compile(r"<(" + "|".join(_EMPTY_TAGS) + r")(\s[^>]*?)\s*/?>")
-
 
 class XMLLikeNode:
-    def __init__(self, file: IO[bytes]) -> None:
+    def __init__(self, file: IO[bytes], is_html_like: bool = False) -> None:
         raw_content = file.read()
-        self._encoding: str = _detect_encoding(raw_content)
+        self._is_html_like = is_html_like
+        self._encoding: str = self._detect_encoding(raw_content)
         content = raw_content.decode(self._encoding)
-        self._header, xml_content = _extract_header(content)
+        self._header, xml_content = self._extract_header(content)
+        self._namespaces: dict[str, str] = {}
+        self._tag_to_namespace: dict[str, str] = {}
+        self._attr_to_namespace: dict[str, str] = {}
+
         try:
-            self.element = fromstring(xml_content)
+            # 不必判断类型，这是一个防御性极强的函数，可做到 shit >> XML
+            xml_content = self_close_void_elements(xml_content)
+            self.element = self._extract_and_clean_namespaces(
+                element=fromstring(xml_content),
+            )
         except Exception as error:
             raise ValueError("Failed to parse XML-like content") from error
-        self._namespaces: dict[str, str] = _extract_and_clean_namespaces(self.element)
 
     @property
     def encoding(self) -> str:
@@ -62,115 +61,146 @@ class XMLLikeNode:
     def namespaces(self) -> list[str]:
         return list(self._namespaces.keys())
 
-    def save(self, file: IO[bytes], is_html_like: bool = False) -> None:
+    def save(self, file: IO[bytes]) -> None:
         writer = io.TextIOWrapper(file, encoding=self._encoding, write_through=True)
         try:
             if self._header:
                 writer.write(self._header)
 
-            content = _serialize_with_namespaces(element=self.element, namespaces=self._namespaces)
-            if is_html_like:
-                content = re.sub(
-                    pattern=_EMPTY_TAG_PATTERN,
-                    repl=lambda m: f"<{m.group(1)}{m.group(2)}>",
-                    string=content,
-                )
-            else:
-                content = re.sub(
-                    pattern=_EMPTY_TAG_PATTERN,
-                    repl=lambda m: f"<{m.group(1)}{m.group(2)} />",
-                    string=content,
-                )
+            content = self._serialize_with_namespaces(self.element)
+
+            # For non-standard HTML files (text/html), convert back from <br/> to <br>
+            # to maintain compatibility with HTML parsers that don't support XHTML
+            # For XHTML files (application/xhtml+xml), keep self-closing format
+            if self._is_html_like:
+                content = unclose_void_elements(content)
+
             writer.write(content)
 
         finally:
             writer.detach()
 
+    def _detect_encoding(self, raw_content: bytes) -> str:
+        if raw_content.startswith(b"\xef\xbb\xbf"):
+            return "utf-8-sig"
+        elif raw_content.startswith(b"\xff\xfe"):
+            return "utf-16-le"
+        elif raw_content.startswith(b"\xfe\xff"):
+            return "utf-16-be"
+
+        # 尝试从 XML 声明中提取编码：只读取前 1024 字节来查找 XML 声明
+        header_bytes = raw_content[:1024]
+        for try_encoding in ("utf-8", "utf-16-le", "utf-16-be", "iso-8859-1"):
+            try:
+                header_str = header_bytes.decode(try_encoding)
+                match = _ENCODING_PATTERN.search(header_str)
+                if match:
+                    declared_encoding = match.group(1).lower()
+                    try:
+                        raw_content.decode(declared_encoding)
+                        return declared_encoding
+                    except (LookupError, UnicodeDecodeError):
+                        pass
+            except UnicodeDecodeError:
+                continue
 
-def _detect_encoding(raw_content: bytes) -> str:
-    if raw_content.startswith(b"\xef\xbb\xbf"):
-        return "utf-8-sig"
-    elif raw_content.startswith(b"\xff\xfe"):
-        return "utf-16-le"
-    elif raw_content.startswith(b"\xfe\xff"):
-        return "utf-16-be"
-
-    # 尝试从 XML 声明中提取编码：只读取前 1024 字节来查找 XML 声明
-    header_bytes = raw_content[:1024]
-    for try_encoding in ("utf-8", "utf-16-le", "utf-16-be", "iso-8859-1"):
         try:
-            header_str = header_bytes.decode(try_encoding)
-            match = _ENCODING_PATTERN.search(header_str)
-            if match:
-                declared_encoding = match.group(1).lower()
-                try:
-                    raw_content.decode(declared_encoding)
-                    return declared_encoding
-                except (LookupError, UnicodeDecodeError):
-                    pass
+            raw_content.decode("utf-8")
+            return "utf-8"
         except UnicodeDecodeError:
-            continue
-
-    try:
-        raw_content.decode("utf-8")
-        return "utf-8"
-    except UnicodeDecodeError:
-        pass
-    return "iso-8859-1"
-
-
-def _extract_header(content: str) -> tuple[str, str]:
-    match = _FIRST_ELEMENT_PATTERN.search(content)
-    if match:
-        split_pos = match.start()
-        header = content[:split_pos]
-        xml_content = content[split_pos:]
-        return header, xml_content
-    return "", content
-
-
-def _extract_and_clean_namespaces(element: Element):
-    namespaces: dict[str, str] = {}
-    for _, elem in iter_with_stack(element):
-        match = _NAMESPACE_IN_TAG.match(elem.tag)
-        if match:
-            namespace_uri = match.group(1)
-            if namespace_uri not in namespaces:
-                prefix = _COMMON_NAMESPACES.get(namespace_uri, f"ns{len(namespaces)}")
-                namespaces[namespace_uri] = prefix
+            pass
+        return "iso-8859-1"
 
-            tag_name = elem.tag[len(match.group(0)) :]
-            elem.tag = tag_name
-
-        for attr_key in list(elem.attrib.keys()):
-            match = _NAMESPACE_IN_TAG.match(attr_key)
+    def _extract_header(self, content: str) -> tuple[str, str]:
+        match = _FIRST_ELEMENT_PATTERN.search(content)
+        if match:
+            split_pos = match.start()
+            header = content[:split_pos]
+            xml_content = content[split_pos:]
+            return header, xml_content
+        return "", content
+
+    def _extract_and_clean_namespaces(self, element: Element) -> Element:
+        for _, elem in iter_with_stack(element):
+            match = _NAMESPACE_IN_TAG.match(elem.tag)
             if match:
                 namespace_uri = match.group(1)
-                if namespace_uri not in namespaces:
-                    prefix = _COMMON_NAMESPACES.get(namespace_uri, f"ns{len(namespaces)}")
-                    namespaces[namespace_uri] = prefix
-
-                attr_name = attr_key[len(match.group(0)) :]
-                attr_value = elem.attrib.pop(attr_key)
-                elem.attrib[attr_name] = attr_value
-    return namespaces
-
-
-def _serialize_with_namespaces(
-    element: Element,
-    namespaces: dict[str, str],
-) -> str:
-    for namespace_uri, prefix in namespaces.items():
-        if namespace_uri in _ROOT_NAMESPACES:
-            element.attrib["xmlns"] = namespace_uri
-        else:
-            element.attrib[f"xmlns:{prefix}"] = namespace_uri
-    xml_string = tostring(element, encoding="unicode")
-    for namespace_uri, prefix in namespaces.items():
-        if namespace_uri in _ROOT_NAMESPACES:
-            xml_string = xml_string.replace(f"{{{namespace_uri}}}", "")
-        else:
-            xml_string = xml_string.replace(f"{{{namespace_uri}}}", f"{prefix}:")
-        pattern = r'\s+xmlns:(ns\d+)="' + re.escape(namespace_uri) + r'"'
-        xml_string = re.sub(pattern, "", xml_string)
-    return xml_string
+                if namespace_uri not in self._namespaces:
+                    prefix = _COMMON_NAMESPACES.get(namespace_uri, f"ns{len(self._namespaces)}")
+                    self._namespaces[namespace_uri] = prefix
+
+                tag_name = elem.tag[len(match.group(0)) :]
+
+                # Record tag -> namespace mapping (warn if conflict)
+                if tag_name in self._tag_to_namespace and self._tag_to_namespace[tag_name] != namespace_uri:
+                    warnings.warn(
+                        f"Tag '{tag_name}' has multiple namespaces: "
+                        f"{self._tag_to_namespace[tag_name]} and {namespace_uri}. "
+                        f"Using the first one.",
+                        stacklevel=2,
+                    )
+                else:
+                    self._tag_to_namespace[tag_name] = namespace_uri
+
+                # Clean: remove namespace URI completely
+                elem.tag = tag_name
+
+            for attr_key in list(elem.attrib.keys()):
+                match = _NAMESPACE_IN_TAG.match(attr_key)
+                if match:
+                    namespace_uri = match.group(1)
+                    if namespace_uri not in self._namespaces:
+                        prefix = _COMMON_NAMESPACES.get(namespace_uri, f"ns{len(self._namespaces)}")
+                        self._namespaces[namespace_uri] = prefix
+
+                    attr_name = attr_key[len(match.group(0)) :]
+                    attr_value = elem.attrib.pop(attr_key)
+
+                    # Record attr -> namespace mapping (warn if conflict)
+                    if attr_name in self._attr_to_namespace and self._attr_to_namespace[attr_name] != namespace_uri:
+                        warnings.warn(
+                            f"Attribute '{attr_name}' has multiple namespaces: "
+                            f"{self._attr_to_namespace[attr_name]} and {namespace_uri}. "
+                            f"Using the first one.",
+                            stacklevel=2,
+                        )
+                    else:
+                        self._attr_to_namespace[attr_name] = namespace_uri
+
+                    # Clean: remove namespace URI completely
+                    elem.attrib[attr_name] = attr_value
+        return element
+
+    def _serialize_with_namespaces(self, element: Element) -> str:
+        # First, add namespace declarations to root element (before serialization)
+        for namespace_uri, prefix in self._namespaces.items():
+            # Skip the reserved xml namespace - it's implicit
+            if namespace_uri == _XML_NAMESPACE_URI:
+                continue
+            if namespace_uri in _ROOT_NAMESPACES:
+                element.attrib["xmlns"] = namespace_uri
+            else:
+                element.attrib[f"xmlns:{prefix}"] = namespace_uri
+
+        # Serialize the element tree as-is (tags are simple names without prefixes)
+        xml_string = tostring(element, encoding="unicode")
+
+        # Now restore namespace prefixes in the serialized string
+        # For each tag that should have a namespace prefix, wrap it with the prefix
+        for tag_name, namespace_uri in self._tag_to_namespace.items():
+            if namespace_uri not in _ROOT_NAMESPACES:
+                # Get the prefix for this namespace
+                prefix = self._namespaces[namespace_uri]
+                # Replace opening and closing tags
+                xml_string = xml_string.replace(f"<{tag_name} ", f"<{prefix}:{tag_name} ")
+                xml_string = xml_string.replace(f"<{tag_name}>", f"<{prefix}:{tag_name}>")
+                xml_string = xml_string.replace(f"</{tag_name}>", f"</{prefix}:{tag_name}>")
+                xml_string = xml_string.replace(f"<{tag_name}/>", f"<{prefix}:{tag_name}/>")
+
+        # Similarly for attributes (though less common in EPUB)
+        for attr_name, namespace_uri in self._attr_to_namespace.items():
+            if namespace_uri not in _ROOT_NAMESPACES:
+                prefix = self._namespaces[namespace_uri]
+                xml_string = xml_string.replace(f' {attr_name}="', f' {prefix}:{attr_name}="')
+
+        return xml_string

epub_translator/xml_interrupter.py

@@ -0,0 +1,165 @@
+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
+
+_ID_KEY = "__XML_INTERRUPTER_ID"
+_MATH_TAG = "math"
+_EXPRESSION_TAG = "expression"
+
+
+class XMLInterrupter:
+    def __init__(self) -> None:
+        self._next_id: int = 1
+        self._last_interrupted_id: str | None = None
+        self._placeholder2interrupted: dict[int, Element] = {}
+        self._raw_text_segments: dict[str, list[TextSegment]] = {}
+
+    def interrupt_source_text_segments(
+        self, text_segments: Iterable[TextSegment]
+    ) -> Generator[TextSegment, None, None]:
+        for text_segment in text_segments:
+            yield from self._expand_source_text_segment(text_segment)
+
+        if self._last_interrupted_id is not None:
+            merged_text_segment = self._pop_and_merge_from_buffered(self._last_interrupted_id)
+            if merged_text_segment:
+                yield merged_text_segment
+
+    def interrupt_translated_text_segments(
+        self, text_segments: Iterable[TextSegment]
+    ) -> Generator[TextSegment, None, None]:
+        for text_segment in text_segments:
+            yield from self._expand_translated_text_segment(text_segment)
+
+    def interrupt_block_element(self, element: Element) -> Element:
+        interrupted_element = self._placeholder2interrupted.pop(id(element), None)
+        if interrupted_element is None:
+            return element
+        else:
+            return interrupted_element
+
+    def _expand_source_text_segment(self, text_segment: TextSegment):
+        interrupted_index = self._interrupted_index(text_segment)
+        interrupted_id: str | None = None
+
+        if interrupted_index is not None:
+            interrupted_element = text_segment.parent_stack[interrupted_index]
+            interrupted_id = interrupted_element.get(_ID_KEY)
+            if interrupted_id is None:
+                interrupted_id = str(self._next_id)
+                interrupted_element.set(_ID_KEY, interrupted_id)
+                self._next_id += 1
+            text_segments = ensure_list(
+                target=self._raw_text_segments,
+                key=interrupted_id,
+            )
+            text_segments.append(text_segment)
+
+        if self._last_interrupted_id is not None and interrupted_id != self._last_interrupted_id:
+            merged_text_segment = self._pop_and_merge_from_buffered(self._last_interrupted_id)
+            if merged_text_segment:
+                yield merged_text_segment
+
+        self._last_interrupted_id = interrupted_id
+
+        if interrupted_index is None:
+            yield text_segment
+
+    def _pop_and_merge_from_buffered(self, interrupted_id: str) -> TextSegment | None:
+        merged_text_segment: TextSegment | None = None
+        text_segments = self._raw_text_segments.get(interrupted_id, None)
+        if text_segments:
+            text_segment = text_segments[0]
+            interrupted_index = cast(int, self._interrupted_index(text_segment))
+            interrupted_element = text_segment.parent_stack[cast(int, interrupted_index)]
+            placeholder_element = Element(
+                _EXPRESSION_TAG,
+                {
+                    _ID_KEY: cast(str, interrupted_element.get(_ID_KEY)),
+                },
+            )
+            raw_parent_stack = text_segment.parent_stack[:interrupted_index]
+            parent_stack = raw_parent_stack + [placeholder_element]
+            merged_text_segment = TextSegment(
+                text="".join(t.text for t in text_segments),
+                parent_stack=parent_stack,
+                left_common_depth=text_segments[0].left_common_depth,
+                right_common_depth=text_segments[-1].right_common_depth,
+                block_depth=len(parent_stack),
+                position=text_segments[0].position,
+            )
+            self._placeholder2interrupted[id(placeholder_element)] = interrupted_element
+
+            # TODO: 比较难搞，先关了再说
+            # parent_element: Element | None = None
+            # if interrupted_index > 0:
+            #     parent_element = text_segment.parent_stack[interrupted_index - 1]
+
+            # if (
+            #     not self._is_inline_math(interrupted_element)
+            #     or parent_element is None
+            #     or self._has_no_math_texts(parent_element)
+            # ):
+            #     # 区块级公式不必重复出现，出现时突兀。但行内公式穿插在译文中更有利于读者阅读顺畅。
+            #     self._raw_text_segments.pop(interrupted_id, None)
+            # else:
+            #     for text_segment in text_segments:
+            #         # 原始栈退光，仅留下相对 interrupted 元素的栈，这种格式与 translated 要求一致
+            #         text_segment.left_common_depth = max(0, text_segment.left_common_depth - interrupted_index)
+            #         text_segment.right_common_depth = max(0, text_segment.right_common_depth - interrupted_index)
+            #         text_segment.block_depth = 1
+            #         text_segment.parent_stack = text_segment.parent_stack[interrupted_index:]
+            for text_segment in text_segments:
+                # 原始栈退光，仅留下相对 interrupted 元素的栈，这种格式与 translated 要求一致
+                text_segment.left_common_depth = max(0, text_segment.left_common_depth - interrupted_index)
+                text_segment.right_common_depth = max(0, text_segment.right_common_depth - interrupted_index)
+                text_segment.block_depth = 1
+                text_segment.parent_stack = text_segment.parent_stack[interrupted_index:]
+
+        return merged_text_segment
+
+    def _interrupted_index(self, text_segment: TextSegment) -> int | None:
+        interrupted_index: int | None = None
+        for i, parent_element in enumerate(text_segment.parent_stack):
+            if parent_element.tag == _MATH_TAG:
+                interrupted_index = i
+                break
+        return interrupted_index
+
+    def _expand_translated_text_segment(self, text_segment: TextSegment):
+        interrupted_id = text_segment.block_parent.attrib.pop(_ID_KEY, None)
+        if interrupted_id is None:
+            yield text_segment
+            return
+
+        raw_text_segments = self._raw_text_segments.pop(interrupted_id, None)
+        if not raw_text_segments:
+            return
+
+        raw_block = raw_text_segments[0].parent_stack[0]
+        if not self._is_inline_math(raw_block):
+            return
+
+        for raw_text_segment in raw_text_segments:
+            raw_text_segment.block_parent.attrib.pop(_ID_KEY, None)
+            yield raw_text_segment
+
+    def _has_no_math_texts(self, element: Element):
+        if element.tag == _MATH_TAG:
+            return True
+        if element.text and normalize_whitespace(element.text).strip():
+            return False
+        for child_element in element:
+            if not self._has_no_math_texts(child_element):
+                return False
+            if child_element.tail and normalize_whitespace(child_element.tail).strip():
+                return False
+        return True
+
+    def _is_inline_math(self, element: Element) -> bool:
+        if element.tag != _MATH_TAG:
+            return False
+        return element.get("display", "").lower() != "block"

epub_translator/xml_translator/__init__.py

@@ -1,3 +1,2 @@
-from .group import XMLGroupContext
-from .submitter import submit_text_segments
+from .callbacks import FillFailedEvent
 from .translator import XMLTranslator

epub_translator/xml_translator/callbacks.py

@@ -0,0 +1,34 @@
+from collections.abc import Callable, Iterable
+from dataclasses import dataclass
+from xml.etree.ElementTree import Element
+
+from ..segment import TextSegment
+
+
+@dataclass
+class FillFailedEvent:
+    error_message: str
+    retried_count: int
+    over_maximum_retries: bool
+
+
+@dataclass
+class Callbacks:
+    interrupt_source_text_segments: Callable[[Iterable[TextSegment]], Iterable[TextSegment]]
+    interrupt_translated_text_segments: Callable[[Iterable[TextSegment]], Iterable[TextSegment]]
+    interrupt_block_element: Callable[[Element], Element]
+    on_fill_failed: Callable[[FillFailedEvent], None]
+
+
+def warp_callbacks(
+    interrupt_source_text_segments: Callable[[Iterable[TextSegment]], Iterable[TextSegment]] | None,
+    interrupt_translated_text_segments: Callable[[Iterable[TextSegment]], Iterable[TextSegment]] | None,
+    interrupt_block_element: Callable[[Element], Element] | None,
+    on_fill_failed: Callable[[FillFailedEvent], None] | None,
+) -> Callbacks:
+    return Callbacks(
+        interrupt_source_text_segments=interrupt_source_text_segments or (lambda x: x),
+        interrupt_translated_text_segments=interrupt_translated_text_segments or (lambda x: x),
+        interrupt_block_element=interrupt_block_element or (lambda x: x),
+        on_fill_failed=on_fill_failed or (lambda event: None),
+    )

epub_translator/xml_translator/{const.py → common.py}

@@ -1,2 +1 @@
-ID_KEY: str = "id"
 DATA_ORIGIN_LEN_KEY = "data-orig-len"

epub_translator/xml_translator/hill_climbing.py

@@ -0,0 +1,104 @@
+from collections.abc import Generator
+from dataclasses import dataclass
+from xml.etree.ElementTree import Element
+
+from tiktoken import Encoding
+
+from ..segment import BlockSegment, BlockSubmitter, TextSegment, search_text_segments
+from ..xml import plain_text
+from .common import DATA_ORIGIN_LEN_KEY
+from .stream_mapper import InlineSegmentMapping
+from .validation import LEVEL_DEPTH, generate_error_message, nest_as_errors_group, truncate_errors_group
+
+
+@dataclass
+class _BlockStatus:
+    weight: int
+    submitter: BlockSubmitter
+
+
+# 以爬山算法，将 LLM 中提交的内容中挑选出完成度更高的部分。
+# 它通过拒绝每个子部分的相对低完成度提交，锁定每个子部分只能往更高完成度的方向移动
+class HillClimbing:
+    def __init__(
+        self,
+        encoding: Encoding,
+        max_fill_displaying_errors: int,
+        block_segment: BlockSegment,
+    ) -> None:
+        self._encoding: Encoding = encoding
+        self._max_fill_displaying_errors: int = max_fill_displaying_errors
+        self._block_statuses: dict[int, _BlockStatus] = {}
+        self._block_segment: BlockSegment = block_segment
+
+    def request_element(self) -> Element:
+        element = self._block_segment.create_element()
+        for child_element in element:
+            text = plain_text(child_element)
+            tokens = self._encoding.encode(text)
+            child_element.set(DATA_ORIGIN_LEN_KEY, str(len(tokens)))
+        return element
+
+    def gen_mappings(self) -> Generator[InlineSegmentMapping | None, None, None]:
+        for inline_segment in self._block_segment:
+            id = inline_segment.id
+            assert id is not None
+            status = self._block_statuses.get(id, None)
+            text_segments: list[TextSegment] | None = None
+            if status is None:
+                yield None
+            else:
+                submitted_element = status.submitter.submitted_element
+                text_segments = list(search_text_segments(submitted_element))
+                yield inline_segment.parent, text_segments
+
+    def submit(self, element: Element) -> str | None:
+        error_message, block_weights = self._validate_block_weights_and_error_message(element)
+
+        for submitter in self._block_segment.submit(element):
+            weight: int = 0  # 未出现在 block_weights 说明没有错误，已完成
+            if block_weights:
+                weight = block_weights.get(submitter.id, 0)
+            status = self._block_statuses.get(submitter.id, None)
+            if status is None:
+                self._block_statuses[submitter.id] = _BlockStatus(
+                    weight=weight,
+                    submitter=submitter,
+                )
+            elif weight < status.weight:
+                status.weight = weight
+                status.submitter = submitter
+
+        return error_message
+
+    def _validate_block_weights_and_error_message(self, element: Element) -> tuple[str | None, dict[int, int] | None]:
+        errors_group = nest_as_errors_group(
+            errors=self._block_segment.validate(element),
+        )
+        if errors_group is None:
+            return None, None
+
+        block_weights: dict[int, int] = {}
+        for block_group in errors_group.block_groups:
+            block_id = block_group.block_id
+            status = self._block_statuses.get(block_id, None)
+            block_weights[block_id] = block_group.weight
+            if status is not None and status.weight > block_group.weight:
+                # 本轮完成度得到改善（weight 下降）应该排后，让出注意力给完成度尚未改善的部分
+                for child_error in block_group.errors:
+                    child_error.level -= LEVEL_DEPTH
+
+        origin_errors_count = errors_group.errors_count
+        errors_group = truncate_errors_group(
+            errors_group=errors_group,
+            max_errors=self._max_fill_displaying_errors,
+        )
+        if errors_group is None:
+            return None, block_weights
+
+        message = generate_error_message(
+            encoding=self._encoding,
+            errors_group=errors_group,
+            omitted_count=origin_errors_count - errors_group.errors_count,
+        )
+        return message, block_weights