cancel button fix 3

src/converter.py

@@ -39,11 +39,8 @@ def convert_file(file_path, parser_name, ocr_method_name, output_format):
     if not file_path:
         return "Please upload a file.", None
 
-    # Check for cancellation
-    if conversion_cancelled and conversion_cancelled.is_set():
-        return "Conversion cancelled.", None
-
     # Create a temporary file with English filename
+    temp_input = None
     try:
         original_ext = Path(file_path).suffix
         with tempfile.NamedTemporaryFile(suffix=original_ext, delete=False) as temp_input:
@@ -51,92 +48,64 @@ def convert_file(file_path, parser_name, ocr_method_name, output_format):
             with open(file_path, 'rb') as original:
                 temp_input.write(original.read())
         file_path = temp_input.name
-    except Exception as e:
-        return f"Error creating temporary file: {e}", None
 
-    # Check for cancellation again
-    if conversion_cancelled and conversion_cancelled.is_set():
-        # Clean up temp file
-        try:
-            os.unlink(temp_input.name)
-        except:
-            pass
-        return "Conversion cancelled.", None
+        # Early cancellation check
+        if conversion_cancelled and conversion_cancelled.is_set():
+            cleanup_temp_file(temp_input.name)
+            return "Conversion cancelled.", None
 
-    try:
         # Use the parser factory to parse the document
         start = time.time()
-        
-        # We need to modify the parsing process to check for cancellation
-        # This requires changes to the parser implementation, but we can add a hook here
-        
-        # 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  # Pass the flag to parsers
+            cancellation_flag=conversion_cancelled
         )
         
-        duration = time.time() - start
-        logging.info(f"Processed in {duration:.2f} seconds.")
-        
-        # Check for cancellation after processing
+        # If conversion was cancelled during parsing
         if conversion_cancelled and conversion_cancelled.is_set():
-            # Clean up temp file
-            try:
-                os.unlink(temp_input.name)
-            except:
-                pass
+            cleanup_temp_file(temp_input.name)
             return "Conversion cancelled.", None
-            
-    except Exception as e:
-        # Clean up temp file
-        try:
-            os.unlink(temp_input.name)
-        except:
-            pass
-        return f"Error: {e}", 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"
-
-    # Check for cancellation again
-    if conversion_cancelled and conversion_cancelled.is_set():
-        # Clean up temp file
-        try:
-            os.unlink(temp_input.name)
-        except:
-            pass
-        return "Conversion cancelled.", None
+        duration = time.time() - start
+        logging.info(f"Processed in {duration:.2f} seconds.")
 
-    try:
-        # Create a temporary file for download
+        # Determine output file extension
+        ext = get_output_extension(output_format)
+
+        # Create download file
         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
-        try:
-            os.unlink(temp_input.name)
-        except:
-            pass
-            
+
+        # Cleanup and return
+        cleanup_temp_file(temp_input.name)
         return content, tmp_path
+
     except Exception as e:
-        # Clean up temp file
-        try:
-            os.unlink(temp_input.name)
-        except:
-            pass
+        if temp_input and temp_input.name:
+            cleanup_temp_file(temp_input.name)
         return f"Error: {e}", None
+
+
+def cleanup_temp_file(file_path):
+    """Helper function to clean up temporary files"""
+    try:
+        os.unlink(file_path)
+    except:
+        pass
+
+
+def get_output_extension(output_format):
+    """Helper function to get the appropriate file extension"""
+    if output_format == "Markdown":
+        return ".md"
+    elif output_format == "JSON":
+        return ".json"
+    elif output_format == "Text":
+        return ".txt"
+    elif output_format == "Document Tags":
+        return ".doctags"
+    return ".txt"

src/parser_factory.py

@@ -28,25 +28,14 @@ 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.
-        
-        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
-        """
+        """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}")
@@ -56,10 +45,12 @@ class ParserFactory:
         if not ocr_method_id:
             raise ValueError(f"Unknown OCR method: {ocr_method_name} for parser {parser_name}")
         
-        # Check for cancellation
-        if cancellation_flag and cancellation_flag.is_set():
-            return "Conversion cancelled."
-        
         # Parse the document, passing the cancellation flag
         kwargs['cancellation_flag'] = cancellation_flag
-        return parser.parse(file_path, ocr_method=ocr_method_id, **kwargs) 
+        result = parser.parse(file_path, ocr_method=ocr_method_id, **kwargs)
+        
+        # Final cancellation check before returning
+        if cancellation_flag and cancellation_flag.is_set():
+            return "Conversion cancelled."
+            
+        return result 

src/ui.py

@@ -63,24 +63,21 @@ def handle_convert(file_path, parser_name, ocr_method_name, output_format):
     """Handle file conversion."""
     global conversion_cancelled
     
-    # Check if cancelled
-    if conversion_cancelled.is_set():
-        conversion_cancelled.clear()
-        return "Conversion cancelled.", None, [], 1, "", gr.update(visible=False), gr.update(visible=False)
-    
-    # Perform the conversion
-    content, download_file = convert_file(file_path, parser_name, ocr_method_name, output_format)
-    
-    # Check if cancelled after conversion
-    if conversion_cancelled.is_set():
-        conversion_cancelled.clear()
-        return "Conversion cancelled.", None, [], 1, "", gr.update(visible=False), gr.update(visible=False)
-    
-    # Process results
-    pages = split_content_into_pages(str(content))
-    page_info = f"Page 1/{len(pages)}"
-    
-    return str(pages[0]) if pages else "", download_file, pages, 1, page_info, gr.update(visible=True), gr.update(visible=False)
+    try:
+        # Perform the conversion
+        content, download_file = convert_file(file_path, parser_name, ocr_method_name, output_format)
+        
+        # If conversion was cancelled, return early
+        if content == "Conversion cancelled.":
+            return content, None, [], 1, "", gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
+        
+        # Process results
+        pages = split_content_into_pages(str(content))
+        page_info = f"Page 1/{len(pages)}"
+        
+        return str(pages[0]) if pages else "", download_file, pages, 1, page_info, gr.update(visible=True), gr.update(visible=True), gr.update(visible=False)
+    except Exception as e:
+        return f"Error: {str(e)}", None, [], 1, "", gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
 
 
 def handle_page_navigation(direction, current, pages):
@@ -107,7 +104,7 @@ def create_ui():
         .page-info { display: inline-block; margin: 0 1rem; }
         .processing-controls { display: flex; justify-content: center; gap: 10px; margin-top: 10px; }
     """) as demo:
-        gr.Markdown("Doc2Md: Convert any documents to Markdown")
+        gr.Markdown("Markit: Convert any documents to Markdown")
 
         with gr.Tabs():
             with gr.Tab("Upload and Convert"):
@@ -177,25 +174,24 @@ def create_ui():
             outputs=[ocr_dropdown]
         )
 
-        # Show cancel button when conversion starts
+        # Show/hide appropriate buttons when conversion starts
         convert_button.click(
-            lambda: gr.update(visible=True),
+            fn=lambda: (gr.update(visible=False), gr.update(visible=True)),
             inputs=[],
-            outputs=[cancel_button]
-        )
-        
-        # Main conversion process
-        convert_button.click(
+            outputs=[convert_button, cancel_button],
+            queue=False  # Execute immediately
+        ).then(  # Chain the conversion process after button update
             fn=handle_convert,
             inputs=[file_input, provider_dropdown, ocr_dropdown, output_format],
-            outputs=[file_display, file_download, content_pages, current_page, page_info, navigation_row, cancel_button]
+            outputs=[file_display, file_download, content_pages, current_page, page_info, navigation_row, convert_button, cancel_button]
         )
         
         # Handle cancel button click
         cancel_button.click(
-            fn=cancel_conversion,
+            fn=lambda: (gr.update(visible=True), gr.update(visible=False)),
             inputs=[],
-            outputs=[cancel_button]
+            outputs=[convert_button, cancel_button],
+            queue=False  # Execute immediately
         )
 
         prev_btn.click(