Update app.py

app.py

@@ -1,16 +1,20 @@
+
+## **Updated app.py for Hugging Face Spaces:**
+
+```python
 import gradio as gr
 import pydub
-import numpy as np
-import os
 import tempfile
 from pathlib import Path
 import time
-import warnings
-warnings.filterwarnings("ignore")
+import os
 
 def convert_mp3_to_flac(mp3_file_path, progress=gr.Progress()):
     """Convert MP3 file to 16-bit FLAC"""
     try:
+        if not mp3_file_path:
+            raise ValueError("No file uploaded")
+        
         progress(0, desc="Starting conversion...")
         
         # Read MP3 file
@@ -28,7 +32,7 @@ def convert_mp3_to_flac(mp3_file_path, progress=gr.Progress()):
         with tempfile.NamedTemporaryFile(suffix='.flac', delete=False) as tmp:
             flac_path = tmp.name
         
-        # Export as FLAC
+        # Export as FLAC with 16-bit PCM
         audio.export(flac_path, format="flac", parameters=["-sample_fmt", "s16"])
         
         progress(1.0, desc="Conversion complete!")
@@ -36,119 +40,138 @@ def convert_mp3_to_flac(mp3_file_path, progress=gr.Progress()):
         return flac_path
     
     except Exception as e:
-        raise gr.Error(f"Conversion failed: {str(e)}")
+        error_msg = f"Conversion failed: {str(e)}"
+        raise gr.Error(error_msg)
+
+def get_file_stats(file_path):
+    """Get statistics about the uploaded file"""
+    if not file_path or not os.path.exists(file_path):
+        return "**File Statistics:** No file uploaded"
+    
+    try:
+        audio = pydub.AudioSegment.from_mp3(file_path)
+        file_size = os.path.getsize(file_path)
+        
+        stats = f"""
+        **File Statistics:**
+        - Duration: {len(audio) / 1000:.2f} seconds
+        - Channels: {'Mono' if audio.channels == 1 else 'Stereo'}
+        - Sample Rate: {audio.frame_rate:,} Hz
+        - Bit Depth: 16-bit (output)
+        - File Size: {file_size / 1024 / 1024:.2f} MB
+        - Format: MP3 → FLAC
+        """
+        return stats
+    except Exception as e:
+        return f"**File Statistics:** Could not read file details - {str(e)}"
 
-def cleanup_temp_files():
-    """Clean up temporary files if needed"""
+def cleanup_old_files():
+    """Clean up temporary files older than 1 hour"""
     temp_dir = tempfile.gettempdir()
-    for file in Path(temp_dir).glob("*.flac"):
-        try:
-            if file.stat().st_mtime < (time.time() - 3600):  # Older than 1 hour
-                file.unlink()
-        except:
-            pass
+    current_time = time.time()
+    
+    for ext in ['.flac', '.mp3']:
+        for file in Path(temp_dir).glob(f"*{ext}"):
+            try:
+                if file.stat().st_mtime < (current_time - 3600):
+                    file.unlink()
+            except:
+                pass
 
 # Create Gradio interface
-with gr.Blocks(title="MP3 to 16-bit FLAC Converter", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(
+    title="MP3 to 16-bit FLAC Converter",
+    theme=gr.themes.Soft()
+) as demo:
+    
     gr.Markdown("# 🎵 MP3 to 16-bit FLAC Converter")
     gr.Markdown("Upload an MP3 file and convert it to 16-bit FLAC format")
     
     with gr.Row():
         with gr.Column(scale=1):
             mp3_input = gr.File(
-                label="Upload MP3 File",
+                label="📁 Upload MP3 File",
                 file_types=[".mp3"],
-                type="filepath"  # Fixed: Changed from 'file' to 'filepath'
+                type="filepath"
             )
-            convert_btn = gr.Button("Convert to FLAC", variant="primary", scale=0)
             
-            with gr.Accordion("Settings", open=False):
-                info_text = gr.Markdown("""
+            convert_btn = gr.Button(
+                "🔄 Convert to FLAC",
+                variant="primary",
+                size="lg"
+            )
+            
+            with gr.Accordion("⚙️ Conversion Settings", open=False):
+                gr.Markdown("""
                 **Default Settings:**
                 - Output format: FLAC
                 - Bit depth: 16-bit
                 - Channels: Preserved from source
                 - Sample rate: Preserved from source
+                - Compression: Lossless
                 """)
         
         with gr.Column(scale=1):
             flac_output = gr.File(
-                label="Download FLAC File",
+                label="💾 Download FLAC File",
                 file_types=[".flac"]
             )
-            info_box = gr.Markdown("""
-            **Conversion Status:** Waiting for file upload...
             
-            **Note:** 
-            - Maximum file size: 200MB
-            - Processing time depends on file size
-            - Download link will appear after conversion
-            """)
-    
-    # Stats display
-    with gr.Row():
-        with gr.Column():
-            stats_text = gr.Markdown("**File Statistics:** No file processed yet")
+            stats_display = gr.Markdown(
+                "**File Statistics:** Upload a file to see details"
+            )
     
-    # Additional info
-    with gr.Accordion("ℹ️ About this converter", open=False):
+    # Info section
+    with gr.Accordion("📚 How to Use & Info", open=False):
         gr.Markdown("""
-        ## Features
-        
-        **Audio Conversion:**
-        - Converts MP3 to FLAC format
-        - Ensures 16-bit depth (CD quality)
-        - Maintains original sample rate and channels
-        - Lossless compression for FLAC output
-        
-        **Technical Specifications:**
-        - Uses pydub (FFmpeg wrapper) for audio processing
-        - FLAC files use 16-bit PCM encoding (signed 16-bit integer)
-        - Original channels (mono/stereo) are preserved
-        - No quality loss in format conversion
-        
-        **Limitations:**
-        - This converts formats, but cannot enhance audio quality
-        - MP3 files are already lossy compressed
-        - Output FLAC will have same perceived quality as input MP3
-        
-        **Supported Formats:** .mp3 → .flac
+        ## Usage Instructions
+        
+        1. **Upload** an MP3 file using the upload button or drag & drop
+        2. **Check** the file statistics to verify your upload
+        3. **Click** the "Convert to FLAC" button
+        4. **Wait** for the conversion to complete (progress bar will show)
+        5. **Download** your converted FLAC file
+        
+        ## Technical Information
+        
+        - **Input**: MP3 files of any bitrate (8-320 kbps)
+        - **Output**: 16-bit FLAC (lossless compression)
+        - **Maximum file size**: 200MB
+        - **Processing time**: ~1-2 seconds per minute of audio
+        
+        ## Important Notes
+        
+        ⚠️ **Converting MP3 to FLAC does NOT improve audio quality**
+        - MP3 is a lossy format - some audio data is permanently removed
+        - FLAC is lossless but cannot restore what was lost in MP3 compression
+        - The FLAC file will have the same perceived quality as the original MP3
+        
+        ## Use Cases
+        
+        - Preparing audio for editing software that prefers FLAC
+        - Archiving music in a lossless format
+        - Compatibility with devices that require FLAC
         """)
     
-    def update_stats(mp3_path):
-        if mp3_path:
-            try:
-                audio = pydub.AudioSegment.from_mp3(mp3_path)
-                stats = f"""
-                **File Statistics:**
-                - Duration: {len(audio) / 1000:.2f} seconds
-                - Channels: {'Mono' if audio.channels == 1 else 'Stereo'}
-                - Sample Rate: {audio.frame_rate} Hz
-                - Bit Depth: 16-bit (output)
-                - File Size: {os.path.getsize(mp3_path) / 1024 / 1024:.2f} MB
-                """
-                return stats
-            except:
-                return "**File Statistics:** Could not read file details"
-        return "**File Statistics:** No file processed yet"
+    # Connect components
+    mp3_input.change(
+        fn=get_file_stats,
+        inputs=[mp3_input],
+        outputs=[stats_display]
+    )
     
-    # Connect the conversion function
     convert_btn.click(
         fn=convert_mp3_to_flac,
         inputs=[mp3_input],
         outputs=[flac_output]
-    )
-    
-    # Update stats when file is uploaded
-    mp3_input.change(
-        fn=update_stats,
-        inputs=[mp3_input],
-        outputs=[stats_text]
+    ).then(
+        fn=lambda: "**Status:** Ready for new conversion",
+        outputs=[stats_display]
     )
 
+# Clean up old files and launch
 if __name__ == "__main__":
-    # Clean up old temp files on startup
-    cleanup_temp_files()
+    cleanup_old_files()
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,