Update app.py

app.py

@@ -5,9 +5,11 @@ import nemo.collections.asr as nemo_asr
 import soundfile as sf
 import tempfile
 import os
-from pydub import AudioSegment
-import moviepy.editor as mp
 import time
+import magic  # for file type detection
+import ffmpeg
+import subprocess
+from pathlib import Path
 
 # Custom CSS for gloomy elegant styling
 st.markdown("""
@@ -154,12 +156,42 @@ st.markdown("""
     </style>
 """, unsafe_allow_html=True)
 
-# Support common audio + video file extensions. Streamlit's file_uploader uses these
-SUPPORTED_TYPES = ['wav', 'mp3', 'ogg', 'flac', 'm4a', 'aac', 'wma',
-                   # video types
-                   'mp4', 'mov', 'mkv', 'avi', 'webm']
+# Check if ffmpeg is available
+def check_ffmpeg():
+    try:
+        subprocess.run(['ffmpeg', '-version'], capture_output=True, check=True)
+        return True
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return False
+
+if not check_ffmpeg():
+    st.error("FFmpeg is not installed or not found in PATH. Please install FFmpeg to use this application.")
+    st.markdown("""
+    ### How to install FFmpeg:
+    
+    **Windows (using Chocolatey):**
+    ```
+    choco install ffmpeg
+    ```
+    
+    **Windows (manual):**
+    1. Download from [ffmpeg.org](https://ffmpeg.org/download.html)
+    2. Extract and add the bin folder to your system PATH
+    
+    **After installing**, restart this application.
+    """)
+    st.stop()
+
+# Accept any file - we'll detect type server-side
+AUDIO_MIMETYPES = {
+    'audio/wav', 'audio/x-wav', 'audio/mpeg', 'audio/ogg', 'audio/flac',
+    'audio/x-m4a', 'audio/aac', 'audio/x-ms-wma'
+}
 
-VIDEO_TYPES = {'mp4', 'mov', 'mkv', 'avi', 'webm'}
+VIDEO_MIMETYPES = {
+    'video/mp4', 'video/quicktime', 'video/x-matroska', 'video/x-msvideo',
+    'video/webm', 'video/x-ms-wmv'
+}
 
 # Load NeMo model once
 @st.cache_resource
@@ -175,73 +207,88 @@ def load_model():
 
 model = load_model()
 
-# Helper: Convert any audio to 16kHz mono WAV
+def detect_file_type(file_data):
+    """Detect the MIME type of a file using python-magic"""
+    mime = magic.from_buffer(file_data, mime=True)
+    return mime
+
 def convert_audio(uploaded_file, target_sample_rate=16000):
     """
-    Convert an uploaded audio or video file to a 16kHz mono WAV file and return the
-    temporary file path. Supports video files by extracting the audio track first.
-
-    uploaded_file can be a Streamlit UploadedFile-like object or a path-like object.
+    Convert any audio or video file to a 16kHz mono WAV using FFmpeg.
+    Returns the path to the converted temporary WAV file.
+    
+    Args:
+        uploaded_file: A Streamlit UploadedFile or path-like object
+        target_sample_rate: Output sample rate (default 16000 Hz)
+    
+    Returns:
+        str: Path to the converted temporary WAV file
     """
-    # Determine filename/extension
-    filename = getattr(uploaded_file, "name", None)
-    if filename is None:
-        # fallback name
-        filename = "uploaded"
-
-    ext = filename.split('.')[-1].lower()
-
-    # Save the raw upload to a temporary file first (moviepy / pydub operate on paths)
-    with tempfile.NamedTemporaryFile(delete=False, suffix=f".{ext}") as tmp_in:
-        try:
-            # uploaded_file may be a BytesIO-like with .read()
-            data = uploaded_file.read()
-        except Exception:
-            # If it's already a path string, just copy
-            with open(uploaded_file, 'rb') as fsrc:
-                data = fsrc.read()
-        tmp_in.write(data)
-        tmp_in_path = tmp_in.name
-
-    # If it's a video type, extract audio using moviepy
     try:
-        if ext in VIDEO_TYPES:
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_out:
-                try:
-                    clip = mp.VideoFileClip(tmp_in_path)
-                    # moviepy will write a WAV; we can ensure sample rate later with pydub
-                    clip.audio.write_audiofile(tmp_out.name, fps=target_sample_rate, logger=None)
-                    clip.close()
-                except Exception:
-                    # fallback: try to open as audio via pydub
-                    audio = AudioSegment.from_file(tmp_in_path)
-                    audio = audio.set_frame_rate(target_sample_rate).set_channels(1)
-                    audio.export(tmp_out.name, format="wav")
-                finally:
-                    # cleanup input video file
-                    try:
-                        os.remove(tmp_in_path)
-                    except Exception:
-                        pass
-                return tmp_out.name
+        # Read the file data
+        if hasattr(uploaded_file, 'read'):
+            file_data = uploaded_file.read()
+            uploaded_file.seek(0)  # Reset position for later use
         else:
-            # It's an audio file - use pydub to convert to wav 16k mono
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_out:
-                audio = AudioSegment.from_file(tmp_in_path)
-                audio = audio.set_frame_rate(target_sample_rate).set_channels(1)
-                audio.export(tmp_out.name, format="wav")
-                try:
-                    os.remove(tmp_in_path)
-                except Exception:
-                    pass
-                return tmp_out.name
-    except Exception as e:
-        # Attempt to clean up and re-raise as RuntimeError with context
+            with open(uploaded_file, 'rb') as f:
+                file_data = f.read()
+        
+        # Detect file type
+        mime_type = detect_file_type(file_data)
+        
+        # Save to temporary input file
+        suffix = '.tmp'
+        if mime_type in AUDIO_MIMETYPES:
+            suffix = '.audio' + suffix
+        elif mime_type in VIDEO_MIMETYPES:
+            suffix = '.video' + suffix
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_in:
+            if hasattr(uploaded_file, 'read'):
+                uploaded_file.seek(0)
+                tmp_in.write(uploaded_file.read())
+            else:
+                tmp_in.write(file_data)
+            tmp_in_path = tmp_in.name
+        
+        # Create output WAV file
+        output_path = tempfile.mktemp(suffix='.wav')
+        
         try:
-            os.remove(tmp_in_path)
-        except Exception:
-            pass
-        raise RuntimeError(f"Failed to convert uploaded file to WAV: {e}")
+            # Build the ffmpeg conversion pipeline
+            stream = ffmpeg.input(tmp_in_path)
+            
+            # Extract audio from video if needed
+            if mime_type in VIDEO_MIMETYPES:
+                stream = stream.audio
+            
+            # Convert to 16kHz mono WAV
+            stream = ffmpeg.output(
+                stream,
+                output_path,
+                acodec='pcm_s16le',  # 16-bit PCM
+                ac=1,                 # mono
+                ar=target_sample_rate,# sample rate
+                loglevel='error'      # reduce ffmpeg output
+            )
+            
+            # Run the conversion
+            ffmpeg.run(stream, overwrite_output=True)
+            
+            return output_path
+            
+        except ffmpeg.Error as e:
+            raise RuntimeError(f"FFmpeg error during conversion: {e.stderr.decode()}")
+            
+        finally:
+            # Clean up input temp file
+            try:
+                os.remove(tmp_in_path)
+            except Exception:
+                pass
+                
+    except Exception as e:
+        raise RuntimeError(f"Failed to convert file to WAV: {str(e)}")
 
 # App UI
 st.markdown("""
@@ -265,7 +312,8 @@ st.markdown("""
     </div>
 """, unsafe_allow_html=True)
 
-uploaded_file = st.file_uploader("Drag and drop audio file here", type=SUPPORTED_TYPES)
+uploaded_file = st.file_uploader("Drag and drop any audio or video file here", type=None, 
+    help="Supports any audio or video format that FFmpeg can handle")
 
 if uploaded_file is not None:
     # Basic size check (Streamlit UploadedFile has .size in bytes)