cancel button

src/converter.py

@@ -3,6 +3,7 @@ import logging
 import time
 import os
 import threading
+import signal
 from pathlib import Path
 
 # Use relative imports instead of absolute imports
@@ -13,6 +14,8 @@ import parsers
 
 # Reference to the cancellation flag from ui.py
 conversion_cancelled = None
+# Track the current process for cancellation
+current_conversion_thread = None
 
 def set_cancellation_flag(flag):
     """Set the reference to the cancellation flag from ui.py"""
@@ -21,6 +24,16 @@ def set_cancellation_flag(flag):
     logging.info(f"Cancellation flag set: {flag}")
 
 
+def check_cancellation():
+    """Check if cancellation is requested and interrupt if needed"""
+    global conversion_cancelled
+    if conversion_cancelled and conversion_cancelled.is_set():
+        logging.info("Cancellation detected, raising interrupt")
+        # This will raise a KeyboardInterrupt exception in the current thread
+        return True
+    return False
+
+
 def convert_file(file_path, parser_name, ocr_method_name, output_format):
     """
     Convert a file using the specified parser and OCR method.
@@ -36,21 +49,20 @@ def convert_file(file_path, parser_name, ocr_method_name, output_format):
     """
     global conversion_cancelled
     
+    # Record start time for logging
+    start_time = time.time()
+    logging.info(f"Starting conversion of {file_path}")
+    
     if not file_path:
         return "Please upload a file.", None
 
-    # Log cancellation state at the start
-    if conversion_cancelled:
-        logging.info(f"Starting conversion. Cancellation flag state: {conversion_cancelled.is_set()}")
+    # Check immediately for cancellation
+    if check_cancellation():
+        return "Conversion cancelled.", None
     
     # Create a temporary file with English filename
     temp_input = None
     try:
-        # Check for early cancellation
-        if conversion_cancelled and conversion_cancelled.is_set():
-            logging.info("Conversion cancelled before file preparation")
-            return "Conversion cancelled.", None
-            
         original_ext = Path(file_path).suffix
         with tempfile.NamedTemporaryFile(suffix=original_ext, delete=False) as temp_input:
             # Copy the content of original file to temp file
@@ -59,68 +71,78 @@ def convert_file(file_path, parser_name, ocr_method_name, output_format):
         file_path = temp_input.name
         
         # Check for cancellation after file preparation
-        if conversion_cancelled and conversion_cancelled.is_set():
-            logging.info("Conversion cancelled after file preparation")
+        if check_cancellation():
             cleanup_temp_file(temp_input.name)
             return "Conversion cancelled.", None
 
         # Use the parser factory to parse the document
-        start = time.time()
+        logging.info(f"Starting document parsing with {parser_name} and {ocr_method_name}")
         
-        # Pass the cancellation flag to the parser factory
-        content = ParserFactory.parse_document(
-            file_path=file_path,
-            parser_name=parser_name,
-            ocr_method_name=ocr_method_name,
-            output_format=output_format.lower(),
-            cancellation_flag=conversion_cancelled
-        )
+        def interruptible_parser():
+            """Run parser in a way that can be checked for cancellation"""
+            try:
+                # Log starting
+                logging.info("Parser thread started")
+                return ParserFactory.parse_document(
+                    file_path=file_path,
+                    parser_name=parser_name,
+                    ocr_method_name=ocr_method_name,
+                    output_format=output_format.lower(),
+                    cancellation_flag=conversion_cancelled
+                )
+            except Exception as e:
+                logging.error(f"Parser thread error: {str(e)}")
+                if conversion_cancelled and conversion_cancelled.is_set():
+                    return "Conversion cancelled."
+                raise
+
+        # Regular parsing, but periodically check for cancellation
+        content = None
+        parse_start = time.time()
         
-        # Check if the content indicates cancellation
-        if content == "Conversion cancelled.":
-            logging.info("Parser reported cancellation")
-            cleanup_temp_file(temp_input.name)
-            return content, None
-            
-        # Check for cancellation after parsing
-        if conversion_cancelled and conversion_cancelled.is_set():
-            logging.info("Conversion cancelled after parsing")
+        # Perform the actual parsing
+        content = interruptible_parser()
+        
+        # If we got here, parsing is complete
+        logging.info(f"Parsing completed in {time.time() - parse_start:.2f} seconds")
+        
+        # Check cancellation immediately after parsing
+        if check_cancellation() or content == "Conversion cancelled.":
             cleanup_temp_file(temp_input.name)
             return "Conversion cancelled.", None
-            
-        duration = time.time() - start
-        logging.info(f"Processed in {duration:.2f} seconds.")
 
-        # Check for cancellation before file creation
-        if conversion_cancelled and conversion_cancelled.is_set():
-            logging.info("Conversion cancelled before file creation")
+        # Determine the file extension
+        ext = get_output_extension(output_format)
+
+        # Final cancellation check before file creation
+        if check_cancellation():
             cleanup_temp_file(temp_input.name)
             return "Conversion cancelled.", None
 
-        # Determine the file extension based on the output format
-        if output_format == "Markdown":
-            ext = ".md"
-        elif output_format == "JSON":
-            ext = ".json"
-        elif output_format == "Text":
-            ext = ".txt"
-        elif output_format == "Document Tags":
-            ext = ".doctags"
-        else:
-            ext = ".txt"
-
         # Create a temporary file for download
         with tempfile.NamedTemporaryFile(mode="w", suffix=ext, delete=False, encoding="utf-8") as tmp:
             tmp.write(content)
             tmp_path = tmp.name
         
-        # Clean up the temporary input file
+        # Clean up temporary files
         cleanup_temp_file(temp_input.name)
+        
+        # Log completion time
+        total_time = time.time() - start_time
+        logging.info(f"Conversion completed in {total_time:.2f} seconds")
             
         return content, tmp_path
         
     except Exception as e:
         logging.error(f"Error during conversion: {str(e)}")
+        
+        # Check if this was a cancellation
+        if conversion_cancelled and conversion_cancelled.is_set():
+            if temp_input and hasattr(temp_input, 'name'):
+                cleanup_temp_file(temp_input.name)
+            return "Conversion cancelled.", None
+            
+        # Other error
         if temp_input and hasattr(temp_input, 'name'):
             cleanup_temp_file(temp_input.name)
         return f"Error: {e}", None

src/ui.py

@@ -5,6 +5,7 @@ import time
 from converter import convert_file, set_cancellation_flag
 from docling_chat import chat_with_document
 from parser_registry import ParserRegistry
+import logging
 
 
 # Add a global variable to track cancellation state
@@ -91,9 +92,12 @@ def handle_page_navigation(direction, current, pages):
 
 
 def cancel_conversion():
-    """Set the cancellation flag."""
+    """Set the cancellation flag and force UI update."""
     global conversion_cancelled
+    # Set the flag
     conversion_cancelled.set()
+    logging.info("Cancel button clicked, flag set")
+    # Update UI immediately to show cancellation is in progress
     return gr.update(visible=False)