.

Author: hydropix

src/core/adapters/translate_file.py

@@ -163,9 +163,12 @@ async def translate_file(
             stats_callback=stats_callback,
             prompt_options=prompt_options,
             max_retries=1,
-            context_manager=None
+            context_manager=None,
+            check_interruption_callback=check_interruption_callback,
+            checkpoint_manager=checkpoint_manager,
+            translation_id=translation_id
         )
-        return result['success']
+        return result.get('success', False)
 
     # Map file extensions to adapters
     adapter_map = {

src/core/common/translation_orchestrator.py

@@ -299,7 +299,8 @@ async def translate(
             context_manager=context_manager,
             placeholder_format=placeholder_format,
             log_callback=log_callback,
-            stats_callback=stats_callback
+            stats_callback=stats_callback,
+            check_interruption_callback=check_interruption_callback
         )
 
         # 5. Refinement (optional)

src/core/docx/docx_translation_adapter.py

@@ -200,3 +200,171 @@ def finalize_output(
             log_callback("docx_rebuilt", f"DOCX document reconstructed ({len(docx_bytes)} bytes)")
 
         return docx_bytes
+
+    async def translate_content(
+        self,
+        raw_content: Any,
+        structure_map: Dict[str, Any],
+        context: Dict[str, Any],
+        source_language: str,
+        target_language: str,
+        model_name: str,
+        llm_client: Any,
+        max_tokens_per_chunk: int,
+        log_callback: Optional[Callable] = None,
+        context_manager: Optional[Any] = None,
+        max_retries: int = 1,
+        prompt_options: Optional[Dict] = None,
+        stats_callback: Optional[Callable] = None,
+        checkpoint_manager: Optional[Any] = None,
+        translation_id: Optional[str] = None,
+        file_href: Optional[str] = None,
+        check_interruption_callback: Optional[Callable] = None,
+        resume_state: Optional[Any] = None,
+        **kwargs
+    ) -> Tuple[bytes, Any]:
+        """
+        Translate DOCX content with checkpoint support.
+
+        This method bypasses the generic orchestrator to use _translate_all_chunks_with_checkpoint
+        for chunk-level interruption and resume support.
+
+        Args:
+            raw_content: DOCX file path (str)
+            structure_map: Not used (kept for interface compatibility)
+            context: Context dict with preservation info
+            source_language: Source language
+            target_language: Target language
+            model_name: Model name
+            llm_client: LLM client
+            max_tokens_per_chunk: Max tokens per chunk
+            log_callback: Logging callback
+            context_manager: Context manager
+            max_retries: Max retries
+            prompt_options: Prompt options
+            stats_callback: Stats callback
+            checkpoint_manager: Checkpoint manager for partial state
+            translation_id: Translation ID for checkpointing
+            file_href: File identifier for checkpointing (use filename for DOCX)
+            check_interruption_callback: Interruption check callback
+            resume_state: Resume state for partial translation
+            **kwargs: Additional arguments
+
+        Returns:
+            (docx_bytes, stats)
+        """
+        from ..epub.xhtml_translator import _translate_all_chunks_with_checkpoint
+        from ..epub.translation_metrics import TranslationMetrics
+
+        source_path = raw_content  # DOCX file path
+
+        # Use filename as file_href if not provided
+        if not file_href:
+            import os
+            file_href = os.path.basename(source_path)
+
+        # === RESUME FROM PARTIAL STATE ===
+        if resume_state:
+            if log_callback:
+                log_callback("docx_resume_partial",
+                    f"📂 Resuming DOCX translation from chunk {resume_state.current_chunk_index}/{len(resume_state.chunks)}")
+
+            # Restore state from checkpoint
+            chunks = resume_state.chunks
+            global_tag_map = resume_state.global_tag_map
+            placeholder_format = resume_state.placeholder_format
+            translated_chunks = resume_state.translated_chunks.copy()
+            start_chunk_index = resume_state.current_chunk_index
+            html_content = resume_state.original_body_html
+
+            # Restore statistics
+            stats = TranslationMetrics.from_dict(resume_state.stats) if resume_state.stats else TranslationMetrics()
+
+            # Restore tag_preserver
+            tag_preserver = self.tag_preserver
+            tag_preserver.placeholder_format.prefix = placeholder_format[0]
+            tag_preserver.placeholder_format.suffix = placeholder_format[1]
+
+            # Restore context
+            metadata = resume_state.doc_metadata
+            context = {
+                'metadata': metadata,
+                'preserver': tag_preserver,
+                'source_path': source_path
+            }
+
+        else:
+            # === NORMAL INITIALIZATION (NO RESUME) ===
+            # 1. Extract content
+            html_content, context = self.extract_content(source_path, log_callback)
+
+            # 2. Preserve structure
+            text_with_placeholders, global_tag_map, placeholder_format = \
+                self.preserve_structure(html_content, context, log_callback)
+
+            # 3. Create chunks
+            chunks = self.create_chunks(
+                text_with_placeholders,
+                global_tag_map,
+                max_tokens_per_chunk,
+                log_callback
+            )
+
+            # Initialize variables for new translation
+            translated_chunks = []
+            start_chunk_index = 0
+            stats = TranslationMetrics()
+            stats.total_chunks = len(chunks)
+            tag_preserver = self.tag_preserver
+            metadata = context['metadata']
+
+        # 4. Translation with checkpoint support
+        translated_chunks, stats, was_interrupted = await _translate_all_chunks_with_checkpoint(
+            chunks=chunks,
+            source_language=source_language,
+            target_language=target_language,
+            model_name=model_name,
+            llm_client=llm_client,
+            max_retries=max_retries,
+            context_manager=context_manager,
+            placeholder_format=placeholder_format,
+            log_callback=log_callback,
+            stats_callback=stats_callback,
+            checkpoint_manager=checkpoint_manager,
+            translation_id=translation_id,
+            file_href=file_href,
+            file_path=source_path,
+            check_interruption_callback=check_interruption_callback,
+            start_chunk_index=start_chunk_index,
+            translated_chunks=translated_chunks,
+            global_tag_map=global_tag_map,
+            stats=stats,
+            prompt_options=prompt_options,
+        )
+
+        # If interrupted, save state and return partial result
+        if was_interrupted:
+            if log_callback:
+                log_callback("docx_interrupted", "DOCX translation interrupted - state saved")
+            # Return empty bytes to indicate incomplete translation
+            return b'', stats
+
+        # 5. Reconstruct content
+        if log_callback:
+            log_callback("reconstruct_start", "Reconstructing DOCX content")
+
+        reconstructed_html = self.reconstruct_content(
+            translated_chunks,
+            global_tag_map,
+            context
+        )
+
+        # 6. Finalize output
+        docx_bytes = self.finalize_output(
+            reconstructed_html,
+            source_path,
+            context,
+            log_callback
+        )
+
+        return docx_bytes, stats

src/core/docx/translator.py

@@ -23,6 +23,9 @@ async def translate_docx_file(
     prompt_options: Optional[Dict] = None,
     max_retries: int = 1,
     context_manager: Optional[Any] = None,
+    check_interruption_callback: Optional[Callable] = None,
+    checkpoint_manager: Optional[Any] = None,
+    translation_id: Optional[str] = None,
     **kwargs
 ) -> Dict[str, Any]:
     """
@@ -45,20 +48,36 @@ async def translate_docx_file(
         model_name: LLM model name
         llm_client: LLM client instance
         max_tokens_per_chunk: Max tokens per chunk
-        log_callback: Logging callback function        stats_callback: Statistics callback function (called after each chunk)
+        log_callback: Logging callback function
+        stats_callback: Statistics callback function (called after each chunk)
         prompt_options: Prompt options (refinement, etc.)
         max_retries: Max translation retries
         context_manager: Adaptive context manager (optional)
+        check_interruption_callback: Callback to check for interruption (optional)
+        checkpoint_manager: Checkpoint manager for partial state (optional)
+        translation_id: Translation ID for checkpointing (optional)
         **kwargs: Additional arguments
 
     Returns:
         Dict with success, stats, output_path
     """
+    import os
+
     # Create adapter and orchestrator
     adapter = DocxTranslationAdapter()
     orchestrator = GenericTranslationOrchestrator(adapter)
 
-    # Translate using generic pipeline
+    # Use filename as file_href for checkpointing
+    file_href = os.path.basename(input_filepath)
+
+    # Check for resume state
+    resume_state = None
+    if checkpoint_manager and translation_id:
+        resume_state = checkpoint_manager.load_xhtml_partial_state(translation_id, file_href)
+        if resume_state and log_callback:
+            log_callback("docx_resume_detected", f"Found checkpoint at chunk {resume_state.current_chunk_index}")
+
+    # Translate using generic pipeline with checkpoint support
     docx_bytes, stats = await orchestrator.translate(
         source=input_filepath,
         source_language=source_language,
@@ -70,9 +89,25 @@ async def translate_docx_file(
         context_manager=context_manager,
         max_retries=max_retries,
         prompt_options=prompt_options,
-        stats_callback=stats_callback
+        stats_callback=stats_callback,
+        check_interruption_callback=check_interruption_callback,
+        checkpoint_manager=checkpoint_manager,
+        translation_id=translation_id,
+        file_href=file_href,
+        resume_state=resume_state
     )
 
+    # Check if translation was interrupted
+    if not docx_bytes:
+        if log_callback:
+            log_callback("docx_incomplete", "DOCX translation interrupted - partial state saved")
+        return {
+            'success': False,
+            'stats': stats.to_dict(),
+            'output_path': None,
+            'interrupted': True
+        }
+
     # Save to output file
     with open(output_filepath, 'wb') as f:
         f.write(docx_bytes)

src/core/epub/xhtml_translator.py

@@ -888,7 +888,8 @@ async def _translate_all_chunks(
     context_manager: Optional[AdaptiveContextManager],
     placeholder_format: Tuple[str, str],
     log_callback: Optional[Callable] = None,
-    stats_callback: Optional[Callable] = None
+    stats_callback: Optional[Callable] = None,
+    check_interruption_callback: Optional[Callable] = None
 ) -> Tuple[List[str], TranslationMetrics]:
     """Translate all chunks with fallback.
 
@@ -901,7 +902,9 @@ async def _translate_all_chunks(
         max_retries: Maximum retry attempts per chunk
         context_manager: Optional context window manager
         placeholder_format: Tuple of (prefix, suffix) for placeholders
-        log_callback: Optional callback for progress        stats_callback: Optional callback for stats updates
+        log_callback: Optional callback for progress
+        stats_callback: Optional callback for stats updates
+        check_interruption_callback: Optional callback to check for interruption
 
     Returns:
         Tuple of (translated_chunks, statistics)
@@ -918,6 +921,14 @@ async def _translate_all_chunks(
         stats_callback(stats.to_dict())
 
     for i, chunk in enumerate(chunks):
+        # Check for interruption before processing chunk
+        if check_interruption_callback:
+            should_stop = check_interruption_callback()
+            if should_stop:
+                if log_callback:
+                    log_callback("translation_interrupted", f"Translation interrupted at chunk {i}/{len(chunks)}")
+                break
+
         translated = await translate_chunk_with_fallback(
             chunk_text=chunk['text'],
             local_tag_map=chunk['local_tag_map'],