cancel button fix 5

src/converter.py

@@ -12,13 +12,13 @@ from parser_factory import ParserFactory
 import parsers
 
 # Reference to the cancellation flag from ui.py
-# This will be set by the UI when the cancel button is clicked
 conversion_cancelled = None
 
 def set_cancellation_flag(flag):
     """Set the reference to the cancellation flag from ui.py"""
     global conversion_cancelled
     conversion_cancelled = flag
+    logging.info(f"Cancellation flag set: {flag}")
 
 
 def convert_file(file_path, parser_name, ocr_method_name, output_format):
@@ -39,23 +39,35 @@ def convert_file(file_path, parser_name, ocr_method_name, output_format):
     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()}")
+    
     # 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
             with open(file_path, 'rb') as original:
                 temp_input.write(original.read())
         file_path = temp_input.name
-
-        # Early cancellation check
+        
+        # Check for cancellation after file preparation
         if conversion_cancelled and conversion_cancelled.is_set():
+            logging.info("Conversion cancelled after file preparation")
             cleanup_temp_file(temp_input.name)
             return "Conversion cancelled.", None
 
         # Use the parser factory to parse the document
         start = time.time()
+        
+        # Pass the cancellation flag to the parser factory
         content = ParserFactory.parse_document(
             file_path=file_path,
             parser_name=parser_name,
@@ -64,28 +76,52 @@ def convert_file(file_path, parser_name, ocr_method_name, output_format):
             cancellation_flag=conversion_cancelled
         )
         
-        # If conversion was cancelled during parsing
+        # 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")
             cleanup_temp_file(temp_input.name)
             return "Conversion cancelled.", None
-
+            
         duration = time.time() - start
         logging.info(f"Processed in {duration:.2f} seconds.")
 
-        # Determine output file extension
-        ext = get_output_extension(output_format)
+        # Check for cancellation before file creation
+        if conversion_cancelled and conversion_cancelled.is_set():
+            logging.info("Conversion cancelled before file creation")
+            cleanup_temp_file(temp_input.name)
+            return "Conversion cancelled.", None
 
-        # Create download file
+        # 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
-
-        # Cleanup and return
+        
+        # Clean up the temporary input file
         cleanup_temp_file(temp_input.name)
+            
         return content, tmp_path
-
+        
     except Exception as e:
-        if temp_input and temp_input.name:
+        logging.error(f"Error during conversion: {str(e)}")
+        if temp_input and hasattr(temp_input, 'name'):
             cleanup_temp_file(temp_input.name)
         return f"Error: {e}", None
 
@@ -94,8 +130,9 @@ def cleanup_temp_file(file_path):
     """Helper function to clean up temporary files"""
     try:
         os.unlink(file_path)
-    except:
-        pass
+        logging.info(f"Cleaned up temporary file: {file_path}")
+    except Exception as e:
+        logging.error(f"Failed to clean up temporary file {file_path}: {str(e)}")
 
 
 def get_output_extension(output_format):

src/parser_factory.py

@@ -1,6 +1,7 @@
 from typing import Optional, Dict, Any, Union
 from pathlib import Path
 import threading
+import logging
 
 from parser_interface import DocumentParser
 from parser_registry import ParserRegistry
@@ -28,29 +29,59 @@ class ParserFactory:
         return parser_class()
     
     @classmethod
-    def parse_document(cls, file_path: Union[str, Path], parser_name: str, 
-                      ocr_method_name: str, cancellation_flag: Optional[threading.Event] = None,
+    def parse_document(cls, 
+                      file_path: Union[str, Path], 
+                      parser_name: str, 
+                      ocr_method_name: str,
+                      cancellation_flag: Optional[threading.Event] = None,
                       **kwargs) -> str:
-        """Parse a document using the specified parser and OCR method."""
-        # Quick cancellation check
-        if cancellation_flag and cancellation_flag.is_set():
-            return "Conversion cancelled."
-
-        parser = cls.create_parser(parser_name)
-        if not parser:
-            raise ValueError(f"Unknown parser: {parser_name}")
-        
-        # Get the internal OCR method ID
-        ocr_method_id = ParserRegistry.get_ocr_method_id(parser_name, ocr_method_name)
-        if not ocr_method_id:
-            raise ValueError(f"Unknown OCR method: {ocr_method_name} for parser {parser_name}")
-        
-        # Parse the document, passing the cancellation flag
-        kwargs['cancellation_flag'] = cancellation_flag
-        result = parser.parse(file_path, ocr_method=ocr_method_id, **kwargs)
+        """
+        Parse a document using the specified parser and OCR method.
         
-        # Final cancellation check before returning
+        Args:
+            file_path: Path to the document
+            parser_name: Name of the parser to use
+            ocr_method_name: Display name of the OCR method to use
+            cancellation_flag: Optional flag to check for cancellation
+            **kwargs: Additional parser-specific options
+            
+        Returns:
+            str: The parsed content
+        """
+        # Check for cancellation at the start
         if cancellation_flag and cancellation_flag.is_set():
+            logging.info("Conversion cancelled at the start of parsing")
             return "Conversion cancelled."
+
+        try:
+            parser = cls.create_parser(parser_name)
+            if not parser:
+                raise ValueError(f"Unknown parser: {parser_name}")
+            
+            # Get the internal OCR method ID
+            ocr_method_id = ParserRegistry.get_ocr_method_id(parser_name, ocr_method_name)
+            if not ocr_method_id:
+                raise ValueError(f"Unknown OCR method: {ocr_method_name} for parser {parser_name}")
+            
+            # Check for cancellation before parsing
+            if cancellation_flag and cancellation_flag.is_set():
+                logging.info("Conversion cancelled before parsing starts")
+                return "Conversion cancelled."
+            
+            # Parse the document, passing the cancellation flag
+            kwargs['cancellation_flag'] = cancellation_flag
+            result = parser.parse(file_path, ocr_method=ocr_method_id, **kwargs)
+            
+            # Check for cancellation after parsing
+            if cancellation_flag and cancellation_flag.is_set():
+                logging.info("Conversion cancelled after parsing completes")
+                return "Conversion cancelled."
+                
+            return result
             
-        return result 
+        except Exception as e:
+            logging.error(f"Error in parse_document: {str(e)}")
+            # Check if the error was due to cancellation
+            if cancellation_flag and cancellation_flag.is_set():
+                return "Conversion cancelled."
+            raise