Update app.py

app.py

@@ -1,11 +1,12 @@
 import streamlit as st
 from pyannote.audio import Pipeline
-import whisper  
+import whisper
 import tempfile
 import os
 import torch
 from transformers import pipeline as tf_pipeline
 from pydub import AudioSegment
+import io
 
 @st.cache_resource
 def load_models():
@@ -14,15 +15,12 @@ def load_models():
             "pyannote/speaker-diarization",
             use_auth_token=st.secrets["hf_token"]
         )
-        
-        transcriber = whisper.load_model("turbo")  
-        
+        transcriber = whisper.load_model("base")  # Changed from turbo to base as it's more stable
         summarizer = tf_pipeline(
-            "summarization", 
+            "summarization",
             model="facebook/bart-large-cnn",
             device=0 if torch.cuda.is_available() else -1
         )
-        
         return diarization, transcriber, summarizer
     except Exception as e:
         st.error(f"Error loading models: {str(e)}")
@@ -30,44 +28,58 @@ def load_models():
 
 def process_audio(audio_file, max_duration=600):  # limit to 5 minutes initially
     try:
+        # First, read the uploaded file into BytesIO
+        audio_bytes = io.BytesIO(audio_file.getvalue())
         
-
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
-            # Convert MP3 to WAV if needed
-            if audio_file.name.endswith('.mp3'):
-                audio = AudioSegment.from_mp3(audio_file)
-            else:
-                audio = AudioSegment.from_wav(audio_file)
-            
-            # Export as WAV
-            audio.export(tmp.name, format="wav")
-            tmp_path = tmp.name
-        
+            try:
+                # Convert audio to standard format
+                if audio_file.name.lower().endswith('.mp3'):
+                    audio = AudioSegment.from_mp3(audio_bytes)
+                else:
+                    audio = AudioSegment.from_wav(audio_bytes)
+                
+                # Standardize audio format
+                audio = audio.set_frame_rate(16000)  # Set sample rate to 16kHz
+                audio = audio.set_channels(1)        # Convert to mono
+                audio = audio.set_sample_width(2)    # Set to 16-bit
+                
+                # Export with specific parameters
+                audio.export(
+                    tmp.name,
+                    format="wav",
+                    parameters=["-ac", "1", "-ar", "16000"]
+                )
+                tmp_path = tmp.name
+                
+            except Exception as e:
+                st.error(f"Error converting audio: {str(e)}")
+                return None
 
-        # Get cached models
-        diarization, transcriber, summarizer = load_models()
-        if not all([diarization, transcriber, summarizer]):
-            return "Model loading failed"
+            # Get cached models
+            diarization, transcriber, summarizer = load_models()
+            if not all([diarization, transcriber, summarizer]):
+                return "Model loading failed"
 
-        # Process with progress bar
-        with st.spinner("Identifying speakers..."):
-            diarization_result = diarization(tmp_path)
-        
-        with st.spinner("Transcribing audio..."):
-            transcription = transcriber.transcribe(tmp_path)
+            # Process with progress bar
+            with st.spinner("Identifying speakers..."):
+                diarization_result = diarization(tmp_path)
             
-        with st.spinner("Generating summary..."):
-            summary = summarizer(transcription["text"], max_length=130, min_length=30)
+            with st.spinner("Transcribing audio..."):
+                transcription = transcriber.transcribe(tmp_path)
+                
+            with st.spinner("Generating summary..."):
+                summary = summarizer(transcription["text"], max_length=130, min_length=30)
 
-        # Cleanup
-        os.unlink(tmp_path)
-        
-        return {
-            "diarization": diarization_result,
-            "transcription": transcription["text"],
-            "summary": summary[0]["summary_text"]
-        }
-        
+            # Cleanup
+            os.unlink(tmp_path)
+            
+            return {
+                "diarization": diarization_result,
+                "transcription": transcription["text"],
+                "summary": summary[0]["summary_text"]
+            }
+            
     except Exception as e:
         st.error(f"Error processing audio: {str(e)}")
         return None
@@ -79,27 +91,35 @@ def main():
     uploaded_file = st.file_uploader("Choose a file", type=["mp3", "wav"])
 
     if uploaded_file:
+        # Display file info
+        file_size = len(uploaded_file.getvalue()) / (1024 * 1024)  # Convert to MB
+        st.write(f"File size: {file_size:.2f} MB")
+        
+        # Display audio player
         st.audio(uploaded_file, format='audio/wav')
         
         if st.button("Analyze Audio"):
-            results = process_audio(uploaded_file)
-            
-            if results:
-                # Display results in tabs
-                tab1, tab2, tab3 = st.tabs(["Speakers", "Transcription", "Summary"])
-                
-                with tab1:
-                    st.write("Speaker Segments:")
-                    for turn, _, speaker in results["diarization"].itertracks(yield_label=True):
-                        st.write(f"{speaker}: {turn.start:.1f}s → {turn.end:.1f}s")
-                
-                with tab2:
-                    st.write("Transcription:")
-                    st.write(results["transcription"])
+            if file_size > 200:
+                st.error("File size exceeds 200MB limit")
+            else:
+                results = process_audio(uploaded_file)
                 
-                with tab3:
-                    st.write("Summary:")
-                    st.write(results["summary"])
+                if results:
+                    # Display results in tabs
+                    tab1, tab2, tab3 = st.tabs(["Speakers", "Transcription", "Summary"])
+                    
+                    with tab1:
+                        st.write("Speaker Segments:")
+                        for turn, _, speaker in results["diarization"].itertracks(yield_label=True):
+                            st.write(f"{speaker}: {turn.start:.1f}s → {turn.end:.1f}s")
+                    
+                    with tab2:
+                        st.write("Transcription:")
+                        st.write(results["transcription"])
+                    
+                    with tab3:
+                        st.write("Summary:")
+                        st.write(results["summary"])
 
 if __name__ == "__main__":
     main()