Update app.py

app.py

@@ -1,183 +1,43 @@
 import gradio as gr
 import os
-import subprocess
-import shutil
-from pathlib import Path
-import tempfile
-from typing import Optional, Tuple
 
-class FileConverter:
-    SUPPORTED_FORMATS = {
-        'Document Formats': ['pdf', 'doc', 'docx', 'odt', 'rtf', 'txt'],
-        'Presentation Formats': ['ppt', 'pptx', 'odp'],
-        'Spreadsheet Formats': ['xls', 'xlsx', 'ods'],
-        'Other Formats': ['html', 'csv']
-    }
-
-    def __init__(self):
-        self.temp_dir = tempfile.mkdtemp()
-
-    def __del__(self):
-        # Cleanup temporary directory
-        if hasattr(self, 'temp_dir') and os.path.exists(self.temp_dir):
-            shutil.rmtree(self.temp_dir)
-
-    @staticmethod
-    def check_libreoffice_installation() -> bool:
-        """Check if LibreOffice is installed and accessible."""
-        try:
-            result = subprocess.run(['soffice', '--version'], 
-                                 capture_output=True, 
-                                 text=True)
-            return result.returncode == 0
-        except FileNotFoundError:
-            return False
-
-    def validate_input_file(self, input_file) -> Tuple[bool, str]:
-        """Validate the input file."""
-        if not input_file:
-            return False, "No file selected."
-        
-        file_extension = Path(input_file.name).suffix[1:].lower()
-        all_formats = [fmt for sublist in self.SUPPORTED_FORMATS.values() 
-                      for fmt in sublist]
-        
-        if file_extension not in all_formats:
-            return False, f"Unsupported input format: {file_extension}"
-        
-        if os.path.getsize(input_file.name) > 100 * 1024 * 1024:  # 100MB limit
-            return False, "File size exceeds 100MB limit."
-            
-        return True, "File is valid."
-
-    def convert_file(self, 
-                    input_file: gr.File, 
-                    output_format: str, 
-                    progress: gr.Progress) -> Optional[str]:
-        """Convert the input file to the specified format."""
-        if not self.check_libreoffice_installation():
-            return "Error: LibreOffice is not installed or accessible."
-
-        # Validate input
-        is_valid, message = self.validate_input_file(input_file)
-        if not is_valid:
-            return message
-
-        try:
-            # Update progress
-            progress(0, desc="Starting conversion...")
-            
-            # Get file paths
-            input_filepath = input_file.name
-            filename = Path(input_filepath).stem
-            output_filename = f"{filename}.{output_format}"
-            output_filepath = os.path.join(self.temp_dir, output_filename)
-
-            # Convert file using LibreOffice
-            progress(0.3, desc="Converting file...")
-            command = [
-                'soffice',
-                '--headless',
-                '--convert-to', output_format,
-                input_filepath,
-                '--outdir', self.temp_dir
-            ]
-            
-            process = subprocess.Popen(
-                command,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
-            )
-            
-            # Wait for conversion to complete
-            stdout, stderr = process.communicate()
-            progress(0.7, desc="Finalizing conversion...")
-
-            if process.returncode == 0 and os.path.exists(output_filepath):
-                # Copy to a new location to avoid temp directory cleanup issues
-                final_output = os.path.join(os.getcwd(), output_filename)
-                shutil.copy2(output_filepath, final_output)
-                progress(1.0, desc="Conversion complete!")
-                return final_output
-            else:
-                error_msg = stderr.decode() if stderr else "Unknown error"
-                return f"Error: Conversion failed. {error_msg}"
-
-        except Exception as e:
-            return f"Error: {str(e)}"
-
-def create_interface():
-    converter = FileConverter()
-    
-    with gr.Blocks(title="Document Converter", 
-                  theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # Document Converter
-        Convert your documents between different formats using LibreOffice.
-        
-        **Supported Format Groups:**
-        """)
-        
-        # Display supported formats
-        for group, formats in FileConverter.SUPPORTED_FORMATS.items():
-            gr.Markdown(f"- **{group}**: {', '.join(formats)}")
-
-        with gr.Row():
-            with gr.Column():
-                file_input = gr.File(
-                    label="Upload File (Max 100MB)",
-                    file_types=list(sum([formats for formats in 
-                                       FileConverter.SUPPORTED_FORMATS.values()], []))
-                )
-                
-                # Create dropdown with format groups
-                format_dropdown = gr.Dropdown(
-                    choices=[fmt for sublist in FileConverter.SUPPORTED_FORMATS.values() 
-                            for fmt in sublist],
-                    label="Select Output Format",
-                    value="pdf"
-                )
-                
-                convert_button = gr.Button("Convert", variant="primary")
-
-            with gr.Column():
-                output_file = gr.File(label="Converted File")
-                status_text = gr.Textbox(label="Status", interactive=False)
-
-        # Handle conversion
+# Function to convert files using LibreOffice (soffice)
+def convert_file(input_file, output_format):
+    # Get the absolute path to the input file
+    input_filepath = input_file.name
+    output_filename = f"{os.path.splitext(os.path.basename(input_filepath))[0]}.{output_format}"
+    output_filepath = os.path.join(os.getcwd(), output_filename)
+
+    # Run the LibreOffice command to convert the file using 'soffice'
+    command = f"soffice --headless --convert-to {output_format} \"{input_filepath}\" --outdir \"{os.getcwd()}\""
+    conversion_status = os.system(command)
+
+    # Check if the conversion was successful
+    if conversion_status == 0 and os.path.exists(output_filepath):
+        return output_filepath
+    else:
+        return "Error: Conversion failed."
+
+# Supported formats from LibreOffice filters
+supported_formats = [
+    "pdf", "doc", "docx", "html", "txt", "odt", "rtf", "ppt", "pptx", "xls", "xlsx"
+]
+
+# Gradio interface
+def gradio_interface():
+    with gr.Blocks() as demo:
+        file_input = gr.File(label="Upload a file")
+        format_dropdown = gr.Dropdown(supported_formats, label="Select Output Format")
+        output_file = gr.File(label="Converted File")
+
+        convert_button = gr.Button("Convert")
         convert_button.click(
-            fn=converter.convert_file,
+            fn=convert_file,
             inputs=[file_input, format_dropdown],
-            outputs=[output_file],
-            show_progress=True
+            outputs=output_file
         )
 
-        # Add example usage
-        gr.Examples(
-            examples=[
-                ["example.docx", "pdf"],
-                ["example.xlsx", "csv"],
-                ["example.pptx", "pdf"]
-            ],
-            inputs=[file_input, format_dropdown],
-        )
-
-        # Add usage instructions
-        gr.Markdown("""
-        ### Instructions:
-        1. Upload your document using the file selector
-        2. Choose your desired output format from the dropdown
-        3. Click 'Convert' and wait for the process to complete
-        4. Download your converted file
-        
-        ### Notes:
-        - Requires LibreOffice to be installed on your system
-        - Maximum file size: 100MB
-        - Conversion time depends on file size and complexity
-        """)
-
     return demo
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()
+    gradio_interface().launch()