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

epub_translator/llm/core.py

@@ -1,11 +1,13 @@
 import datetime
 import hashlib
 import json
+import uuid
 from collections.abc import Callable, Generator
 from importlib.resources import files
 from logging import DEBUG, FileHandler, Formatter, Logger, getLogger
 from os import PathLike
 from pathlib import Path
+from typing import Self
 
 from jinja2 import Environment, Template
 from tiktoken import Encoding, get_encoding
@@ -16,6 +18,89 @@ from .increasable import Increasable
 from .types import Message, MessageRole, R
 
 
+class LLMContext:
+    """Context manager for LLM requests with transactional caching."""
+
+    def __init__(
+        self,
+        executor: LLMExecutor,
+        cache_path: Path | None,
+    ) -> None:
+        self._executor = executor
+        self._cache_path = cache_path
+        self._context_id = uuid.uuid4().hex[:12]
+        self._temp_files: list[Path] = []
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        if exc_type is None:
+            # Success: commit all temporary cache files
+            self._commit()
+        else:
+            # Failure: rollback (delete) all temporary cache files
+            self._rollback()
+
+    def request(
+        self,
+        input: str | list[Message],
+        parser: Callable[[str], R] = lambda x: x,
+        max_tokens: int | None = None,
+    ) -> R:
+        messages: list[Message]
+        if isinstance(input, str):
+            messages = [Message(role=MessageRole.USER, message=input)]
+        else:
+            messages = input
+
+        cache_key: str | None = None
+        if self._cache_path is not None:
+            cache_key = self._compute_messages_hash(messages)
+            permanent_cache_file = self._cache_path / f"{cache_key}.txt"
+            if permanent_cache_file.exists():
+                cached_content = permanent_cache_file.read_text(encoding="utf-8")
+                return parser(cached_content)
+
+            temp_cache_file = self._cache_path / f"{cache_key}.{self._context_id}.txt"
+            if temp_cache_file.exists():
+                cached_content = temp_cache_file.read_text(encoding="utf-8")
+                return parser(cached_content)
+
+        # Make the actual request
+        response = self._executor.request(
+            messages=messages,
+            parser=lambda x: x,
+            max_tokens=max_tokens,
+        )
+
+        # Save to temporary cache if cache_path is set
+        if self._cache_path is not None and cache_key is not None:
+            temp_cache_file = self._cache_path / f"{cache_key}.{self._context_id}.txt"
+            temp_cache_file.write_text(response, encoding="utf-8")
+            self._temp_files.append(temp_cache_file)
+
+        return parser(response)
+
+    def _compute_messages_hash(self, messages: list[Message]) -> str:
+        messages_dict = [{"role": msg.role.value, "message": msg.message} for msg in messages]
+        messages_json = json.dumps(messages_dict, ensure_ascii=False, sort_keys=True)
+        return hashlib.sha512(messages_json.encode("utf-8")).hexdigest()
+
+    def _commit(self) -> None:
+        for temp_file in self._temp_files:
+            if temp_file.exists():
+                # 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)
+
+    def _rollback(self) -> None:
+        for temp_file in self._temp_files:
+            if temp_file.exists():
+                temp_file.unlink()
+
+
 class LLM:
     def __init__(
         self,
@@ -30,7 +115,7 @@ class LLM:
         retry_times: int = 5,
         retry_interval_seconds: float = 6.0,
         log_dir_path: PathLike | None = None,
-    ):
+    ) -> None:
         prompts_path = Path(str(files("epub_translator"))) / "data"
         self._templates: dict[str, Template] = {}
         self._encoding: Encoding = get_encoding(token_encoding)
@@ -68,41 +153,20 @@ class LLM:
     def encoding(self) -> Encoding:
         return self._encoding
 
+    def context(self) -> LLMContext:
+        return LLMContext(
+            executor=self._executor,
+            cache_path=self._cache_path,
+        )
+
     def request(
         self,
         input: str | list[Message],
         parser: Callable[[str], R] = lambda x: x,
         max_tokens: int | None = None,
     ) -> R:
-        messages: list[Message]
-        if isinstance(input, str):
-            messages = [Message(role=MessageRole.USER, message=input)]
-        else:
-            messages = input
-
-        # Check cache if cache_path is set
-        if self._cache_path is not None:
-            cache_key = self._compute_messages_hash(messages)
-            cache_file = self._cache_path / f"{cache_key}.txt"
-
-            if cache_file.exists():
-                cached_content = cache_file.read_text(encoding="utf-8")
-                return parser(cached_content)
-
-        # Make the actual request
-        response = self._executor.request(
-            messages=messages,
-            parser=lambda x: x,
-            max_tokens=max_tokens,
-        )
-
-        # Save to cache if cache_path is set
-        if self._cache_path is not None:
-            cache_key = self._compute_messages_hash(messages)
-            cache_file = self._cache_path / f"{cache_key}.txt"
-            cache_file.write_text(response, encoding="utf-8")
-
-        return parser(response)
+        with self.context() as ctx:
+            return ctx.request(input=input, parser=parser, max_tokens=max_tokens)
 
     def template(self, template_name: str) -> Template:
         template = self._templates.get(template_name, None)
@@ -111,17 +175,11 @@ class LLM:
             self._templates[template_name] = template
         return template
 
-    def _compute_messages_hash(self, messages: list[Message]) -> str:
-        """Compute SHA-512 hash of m·essages for cache key."""
-        messages_dict = [{"role": msg.role.value, "message": msg.message} for msg in messages]
-        messages_json = json.dumps(messages_dict, ensure_ascii=False, sort_keys=True)
-        return hashlib.sha512(messages_json.encode("utf-8")).hexdigest()
-
     def _create_logger(self) -> Logger | None:
         if self._logger_save_path is None:
             return None
 
-        now = datetime.datetime.now(datetime.timezone.utc)
+        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}")

epub_translator/translator.py

@@ -71,7 +71,7 @@ def translate(
             placeholder.recover()
             deduplicate_ids_in_element(xml.element)
             with zip.replace(chapter_path) as target_file:
-                xml.save(target_file, is_html_like=True)
+                xml.save(target_file)
 
             # Update progress after each chapter
             processed_chapters += 1
@@ -198,7 +198,10 @@ def _count_chapters(zip: Zip) -> int:
 def _search_chapter_items(zip: Zip):
     for chapter_path in search_spine_paths(zip):
         with zip.read(chapter_path) as chapter_file:
-            xml = XMLLikeNode(chapter_file)
+            xml = XMLLikeNode(
+                file=chapter_file,
+                is_html_like=chapter_path.suffix.lower() in (".html", ".htm"),
+            )
         body_element = find_first(xml.element, "body")
         if body_element is not None:
             placeholder = Placeholder(body_element)

epub_translator/xml/xml_like.py

@@ -1,10 +1,13 @@
 import io
 import re
+import warnings
 from typing import IO
 from xml.etree.ElementTree import Element, fromstring, tostring
 
 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 +17,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,8 +31,8 @@ _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
+# Some non-standard EPUB generators use HTML-style tags without self-closing syntax
+# We need to convert them to XML-compatible format before parsing
 _EMPTY_TAGS = (
     "br",
     "hr",
@@ -39,20 +43,38 @@ _EMPTY_TAGS = (
     "area",
 )
 
-_EMPTY_TAG_PATTERN = re.compile(r"<(" + "|".join(_EMPTY_TAGS) + r")(\s[^>]*?)\s*/?>")
+# For reading: match tags like <br> or <br class="x"> (but not <br/> or <body>)
+_EMPTY_TAG_OPEN_PATTERN = re.compile(r"<(" + "|".join(_EMPTY_TAGS) + r")(\s[^/>]*)>")
+
+# For saving: match self-closing tags like <br />
+_EMPTY_TAG_CLOSE_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._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] = {}
+
+        # For non-standard HTML files, convert <br> to <br/> before parsing
+        self._is_html_like = is_html_like
+        if is_html_like:
+            xml_content = re.sub(
+                pattern=_EMPTY_TAG_OPEN_PATTERN,
+                repl=lambda m: f"<{m.group(1)}{m.group(2)} />",
+                string=xml_content,
+            )
+
         try:
-            self.element = fromstring(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 +84,148 @@ 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 = self._serialize_with_namespaces(self.element)
+
+            # For non-standard HTML files, convert back from <br/> to <br>
+            if self._is_html_like:
                 content = re.sub(
-                    pattern=_EMPTY_TAG_PATTERN,
+                    pattern=_EMPTY_TAG_CLOSE_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,
-                )
+
             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_translator/translator.py

@@ -126,53 +126,54 @@ class XMLTranslator:
         conversation_history: list[Message] = []
         latest_error: ValidationError | None = None
 
-        for _ in range(self._max_retries):
-            # Request LLM response
-            response = self._llm.request(
-                input=fixed_messages + conversation_history,
-            )
-
-            try:
-                # Extract XML from response
-                validated_element = _extract_xml_element(response)
-
-                # Validate with progressive locking
-                is_complete, error_message, newly_locked = validator.validate_with_locking(
-                    template_ele=fill.request_element,
-                    validated_ele=validated_element,
-                    errors_limit=self._max_fill_displaying_errors,
+        with self._llm.context() as llm_context:
+            for _ in range(self._max_retries):
+                # Request LLM response
+                response = llm_context.request(
+                    input=fixed_messages + conversation_history,
                 )
 
-                if is_complete:
-                    # All nodes locked, fill successful
-                    fill._fill_submitted_texts(  # pylint: disable=protected-access
-                        generated_ids_stack=[],
-                        element=validated_element,
+                try:
+                    # Extract XML from response
+                    validated_element = _extract_xml_element(response)
+
+                    # Validate with progressive locking
+                    is_complete, error_message, newly_locked = validator.validate_with_locking(
+                        template_ele=fill.request_element,
+                        validated_ele=validated_element,
+                        errors_limit=self._max_fill_displaying_errors,
                     )
-                    return validated_element
-
-                # Not complete yet, construct error message with progress info
-                progress_msg = f"Progress: {len(validator.locked_ids)} nodes locked"
-                if newly_locked:
-                    progress_msg += f", {len(newly_locked)} newly locked this round"
-
-                full_error_message = f"{progress_msg}\n\n{error_message}"
-
-                conversation_history = [
-                    Message(role=MessageRole.ASSISTANT, message=response),
-                    Message(role=MessageRole.USER, message=full_error_message),
-                ]
-
-            except ValidationError as error:
-                # XML extraction or basic validation failed
-                latest_error = error
-                conversation_history = [
-                    Message(role=MessageRole.ASSISTANT, message=response),
-                    Message(role=MessageRole.USER, message=str(error)),
-                ]
-
-        message = f"Failed to get valid XML structure after {self._max_retries} attempts"
-        if latest_error is None:
-            raise ValueError(message)
-        else:
-            raise ValueError(message) from latest_error
+
+                    if is_complete:
+                        # All nodes locked, fill successful
+                        fill._fill_submitted_texts(  # pylint: disable=protected-access
+                            generated_ids_stack=[],
+                            element=validated_element,
+                        )
+                        return validated_element
+
+                    # Not complete yet, construct error message with progress info
+                    progress_msg = f"Progress: {len(validator.locked_ids)} nodes locked"
+                    if newly_locked:
+                        progress_msg += f", {len(newly_locked)} newly locked this round"
+
+                    full_error_message = f"{progress_msg}\n\n{error_message}"
+
+                    conversation_history = [
+                        Message(role=MessageRole.ASSISTANT, message=response),
+                        Message(role=MessageRole.USER, message=full_error_message),
+                    ]
+
+                except ValidationError as error:
+                    # XML extraction or basic validation failed
+                    latest_error = error
+                    conversation_history = [
+                        Message(role=MessageRole.ASSISTANT, message=response),
+                        Message(role=MessageRole.USER, message=str(error)),
+                    ]
+
+            message = f"Failed to get valid XML structure after {self._max_retries} attempts"
+            if latest_error is None:
+                raise ValueError(message)
+            else:
+                raise ValueError(message) from latest_error

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: epub-translator
-Version: 0.1.0
+Version: 0.1.1
 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

{epub_translator-0.1.0.dist-info → epub_translator-0.1.1.dist-info}/RECORD

@@ -19,7 +19,7 @@ epub_translator/epub/zip.py,sha256=CUE50LrrVNeQVecNm2ZFionJz4k_vMTXTi8an7BiQ_c,2
 epub_translator/iter_sync.py,sha256=56m-bRPqc731alGenqLvCIM99J8NzNuie86FDGtJj8k,588
 epub_translator/language.py,sha256=88osG0JNYxOkxBjg5Pm-P0Mhiyxf6GqdxoPW12HW0PE,493
 epub_translator/llm/__init__.py,sha256=QcAuTQpH0T7IMf-J3bRdtf8Tvyu6Z2CAe-wSzLJRLLw,43
-epub_translator/llm/core.py,sha256=YSc89c3BRFjJ7bDzrbfVBe1fX-AeBm9EJVcl2ihF_14,6155
+epub_translator/llm/core.py,sha256=nRNAVDQD7kxSl2EN7m5OQ7CvlBL4ENbzQThUcJSzMsk,8123
 epub_translator/llm/error.py,sha256=4efAIQL14DFSvAnSTUfgdAbZRqaWBqOfUGsSfvxa5zM,1503
 epub_translator/llm/executor.py,sha256=Oax07rwivDbB0T3i_waLAvXvfQoR9dnWPTvw475C9vQ,6081
 epub_translator/llm/increasable.py,sha256=vQka-bysKuFR-Vu-GziGZfQCasLn9q2GxGEoV2RiCec,1289
@@ -29,7 +29,7 @@ epub_translator/serial/chunk.py,sha256=FrTaHikVOd6bLYumnEriTaAQ_DIDLjHm16gh-wBVR
 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=e7rnMWXi4Ctkr10gg_oGDHYGAhc1Ofk8YXyz0xdmBjM,6880
+epub_translator/translator.py,sha256=vEccCEFc-mArX4DzvUz09W_WFOxUv6dlQkwWDkbbVFs,6976
 epub_translator/utils.py,sha256=7lBWHNyv4GQiutqqqUhbAxc8gqVIkhS7B4rkL1EKOFs,144
 epub_translator/xml/__init__.py,sha256=te8vIRgG-2n1fEcTmNzCLc-WH9G0JUr_lJncJQvRbgw,96
 epub_translator/xml/deduplication.py,sha256=Vc7BtXXnAMQHNtE--o2Qkm_sYrjnJSh33reKFh9YUjo,1143
@@ -40,7 +40,7 @@ epub_translator/xml/firendly/parser.py,sha256=QlMHA0nfPJbNyx6IwRFrYVw7okuvzDB42N
 epub_translator/xml/firendly/tag.py,sha256=ahaGoYttuAlnFxLFFgTV51KUZSpUiHho-COZX14nxN8,3308
 epub_translator/xml/firendly/transform.py,sha256=5tG1MJmzrXIR_Z5gmRxwcoKvXBzJBVH0ELeaRsG-8w0,1201
 epub_translator/xml/xml.py,sha256=7NPinMOFGBeOHCG-hw0iQjL-p-_I4DmYL8lq0Ar8rag,1498
-epub_translator/xml/xml_like.py,sha256=UVx-Dvs4dXOnBcLX_qLOwyedj6fisZrrl1N_IibYHX8,6181
+epub_translator/xml/xml_like.py,sha256=tgzqDQFfql9-QMSRbLf9SVlNsvyZXJTCEWmksxd3TuI,9489
 epub_translator/xml_translator/__init__.py,sha256=yNgwIermFXaRfAfnqXaNFCEf5I95cBVUDxha-6xkLq0,117
 epub_translator/xml_translator/const.py,sha256=Q9pmLplUR71TqF4MN5oLtPNl_pBRWoOJwsC5eIQOOWE,57
 epub_translator/xml_translator/fill.py,sha256=LxkPxlfbDDB3gP1rciXEBFyi1QRj5vXWzdca5SBcd5o,4839
@@ -50,9 +50,9 @@ epub_translator/xml_translator/group.py,sha256=2GxJl3RojyHyMuTZ5cn5PITT-F2fdaBlv
 epub_translator/xml_translator/progressive_locking.py,sha256=2eoCzVNeV4e4TziYTk4UgKmBUGuFQFj7X24ejO75lUA,9613
 epub_translator/xml_translator/submitter.py,sha256=bIoxhUIDMScgnxnqfCKR8d3u1DaISXqIM2WuHzrNU7M,4022
 epub_translator/xml_translator/text_segment.py,sha256=Aue5XHKYKzTuinFExcdu0CqGY5TiuJoIIhbP9t5ubPg,7673
-epub_translator/xml_translator/translator.py,sha256=ZQlcVbF7kLbsi1UHwdwh7H-yO4p6B3heTzOlDhA0Lrg,6844
+epub_translator/xml_translator/translator.py,sha256=FGSXo2UWtcoIOWGzkI4emyqp1Q2Z8EoOBCBmdtty18A,7063
 epub_translator/xml_translator/utils.py,sha256=AIJOcB7Btad0yxxLwD3UC9NTk2gOPEM8qqx7sNO6tDc,626
-epub_translator-0.1.0.dist-info/LICENSE,sha256=5RF32sL3LtMOJIErdDKp1ZEYPGXS8WPpsiSz_jMBnGI,1066
-epub_translator-0.1.0.dist-info/METADATA,sha256=JEUwAD6kLkFbFZ-2GKaNK5f_U3prxY65k5s7DCOK7W4,9655
-epub_translator-0.1.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-epub_translator-0.1.0.dist-info/RECORD,,
+epub_translator-0.1.1.dist-info/LICENSE,sha256=5RF32sL3LtMOJIErdDKp1ZEYPGXS8WPpsiSz_jMBnGI,1066
+epub_translator-0.1.1.dist-info/METADATA,sha256=BJDV44wO93Nw7e1hqBV33HXK8KUa_JO2XJ1qQ22RGmc,9655
+epub_translator-0.1.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+epub_translator-0.1.1.dist-info/RECORD,,