Test

app.py

@@ -1,202 +1,78 @@
-import streamlit as st
-import tempfile
 import os
+import tempfile
+import json
 import librosa
 import numpy as np
-from transformers import pipeline
-import torch
 import soundfile as sf
-import json  # For JSON response
-
-# Page configuration
-st.set_page_config(page_title="Audio Processing App", layout="wide")
-st.title("Audio Lecture Processing App")
+import torch
+from flask import Flask, request, jsonify
+from transformers import pipeline
 
-# Initialize session state
-if 'models_loaded' not in st.session_state:
-    st.session_state.models_loaded = False
+# Initialize Flask app
+app = Flask(__name__)
 
-@st.cache_resource
-def load_models():
-    """Load ML models with proper error handling"""
-    try:
-        # Check for CUDA availability
-        device = 0 if torch.cuda.is_available() else -1
-        
-        models = {
-            'transcriber': pipeline("automatic-speech-recognition", 
-                                     model="openai/whisper-tiny.en", 
-                                     device=device,
-                                     chunk_length_s=30),  # Process in 30-second chunks
-            'summarizer': pipeline("summarization", 
-                                   model="sshleifer/distilbart-cnn-12-6", 
-                                   device=device)
-        }
-        return models, None
-    except Exception as e:
-        return None, f"Error loading models: {str(e)}"
+# Load models globally to avoid reloading on every request
+device = 0 if torch.cuda.is_available() else -1
+models = {
+    'transcriber': pipeline("automatic-speech-recognition", model="openai/whisper-tiny.en", device=device, chunk_length_s=30),
+    'summarizer': pipeline("summarization", model="sshleifer/distilbart-cnn-12-6", device=device)
+}
 
 def load_and_convert_audio(audio_path):
     """Load audio using librosa and convert to WAV format"""
-    try:
-        # Load audio with librosa (handles many formats)
-        audio_data, sample_rate = librosa.load(audio_path, sr=16000)  # Whisper expects 16kHz
-        
-        # Convert to float32
-        audio_data = audio_data.astype(np.float32)
-        
-        # Create a temporary WAV file
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_wav:
-            sf.write(temp_wav.name, audio_data, sample_rate, format='WAV')
-            return temp_wav.name
-    except Exception as e:
-        raise Exception(f"Error converting audio: {str(e)}")
+    audio_data, sample_rate = librosa.load(audio_path, sr=16000)  # Whisper expects 16kHz
+    audio_data = audio_data.astype(np.float32)
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_wav:
+        sf.write(temp_wav.name, audio_data, sample_rate, format='WAV')
+        return temp_wav.name
 
-def process_audio(audio_path, models):
-    """Process audio file with progress tracking"""
+def process_audio(audio_path):
+    """Process audio file and return transcription and summary"""
     results = {}
-    temp_wav_path = None
-    
-    try:
-        # Convert audio to compatible format
-        with st.spinner('Converting audio format...'):
-            temp_wav_path = load_and_convert_audio(audio_path)
-        
-        # Transcription with progress bar
-        with st.spinner('Transcribing audio...'):
-            # Use return_timestamps=True for long audio files
-            transcription = models['transcriber'](
-                temp_wav_path,
-                return_timestamps=True  # Remove task specification for English-only model
-            )
-            
-            # Extract full text from chunks
-            if isinstance(transcription, dict):
-                results['transcription'] = transcription['text']
-            else:
-                # Combine chunks maintaining order
-                results['transcription'] = ' '.join([chunk['text'] for chunk in transcription])
-        
-        # Summarization with chunking for long text
-        with st.spinner('Generating summary...'):
-            text = results['transcription']
-            
-            # Split long text into chunks of ~1000 words for summarization
-            words = text.split()
-            chunk_size = 1000
-            chunks = [' '.join(words[i:i + chunk_size]) 
-                     for i in range(0, len(words), chunk_size)]
-            
-            # Summarize each chunk
-            summaries = []
-            progress_text = st.empty()
-            for i, chunk in enumerate(chunks):
-                progress_text.text(f"Summarizing chunk {i+1} of {len(chunks)}")
-                
-                summary = models['summarizer'](
-                    chunk,
-                    max_length=200,
-                    min_length=50,
-                    truncation=True
-                )
-                summaries.append(summary[0]['summary_text'])
-            
-            # Combine summaries
-            combined_summary = ' '.join(summaries)
-            
-            # Final summarization if multiple chunks exist
-            if len(summaries) > 1:
-                progress_text.text("Creating final summary...")
-                combined_summary = models['summarizer'](
-                    combined_summary,
-                    max_length=200,
-                    min_length=50,
-                    truncation=True
-                )[0]['summary_text']
-            
-            progress_text.empty()
-            results['summary'] = combined_summary
-            
-            # Clean up summary
-            if not results['summary'].endswith((".", "!", "?")):
-                last_period_index = results['summary'].rfind(".")
-                if last_period_index != -1:
-                    results['summary'] = results['summary'][:last_period_index + 1]
-                    
-    except Exception as e:
-        st.error(f"Error processing audio: {str(e)}")
-        return None
+    temp_wav_path = load_and_convert_audio(audio_path)
+
+    # Transcription
+    transcription = models['transcriber'](temp_wav_path, return_timestamps=True)
+    if isinstance(transcription, dict):
+        results['transcription'] = transcription['text']
+    else:
+        results['transcription'] = ' '.join([chunk['text'] for chunk in transcription])
+
+    # Summarization
+    text = results['transcription']
+    words = text.split()
+    chunk_size = 1000
+    chunks = [' '.join(words[i:i + chunk_size]) for i in range(0, len(words), chunk_size)]
     
-    finally:
-        # Clean up temporary WAV file
-        if temp_wav_path and os.path.exists(temp_wav_path):
-            try:
-                os.unlink(temp_wav_path)
-            except:
-                pass
+    summaries = []
+    for chunk in chunks:
+        summary = models['summarizer'](chunk, max_length=200, min_length=50, truncation=True)
+        summaries.append(summary[0]['summary_text'])
     
-    return results
+    combined_summary = ' '.join(summaries)
+    results['summary'] = combined_summary
 
-# Main app
-def main():
-    # Load models
-    if not st.session_state.models_loaded:
-        with st.spinner('Loading models... This may take a few minutes...'):
-            models, error = load_models()
-            if error:
-                st.error(error)
-                return
-            st.session_state.models_loaded = True
-            st.session_state.models = models
-    
-    # Check if an audio file was uploaded via API
-    query_params = st.experimental_get_query_params()
-    if "file" in query_params:
-        audio_file_path = query_params["file"][0]  # This should be the path to the uploaded audio file
+    # Clean up temporary WAV file
+    if os.path.exists(temp_wav_path):
+        os.unlink(temp_wav_path)
 
-        # Process the audio
-        results = process_audio(audio_file_path, st.session_state.models)
+    return results
 
-        if results:
-            # Return the results as JSON
-            st.json(results)
-        return  # Exit the function early to avoid further processing in the UI
+@app.route('/process-audio', methods=['POST'])
+def process_audio_endpoint():
+    """API endpoint to process audio file"""
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file part'}), 400
 
-    # Normal Streamlit UI flow for file upload
-    st.write("Upload an audio file of your lecture (supported formats: WAV, MP3, M4A, FLAC)")
-    st.write("Note: Processing long audio files may take several minutes.")
-    
-    uploaded_file = st.file_uploader("Choose a file", type=["wav", "mp3", "m4a", "flac"])
-    
-    if uploaded_file is not None:
-        # Create a temporary file for the uploaded content
-        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{uploaded_file.name.split('.')[-1]}") as temp_audio_file:
-            temp_audio_file.write(uploaded_file.getbuffer())
-            temp_audio_path = temp_audio_file.name
-        
-        try:
-            # Process the audio
-            results = process_audio(temp_audio_path, st.session_state.models)
-            
-            if results:
-                # Display results in organized sections
-                st.subheader("📝 Transcription")
-                with st.expander("Show full transcription"):
-                    st.write(results['transcription'])
-                
-                st.subheader("📌 Summary")
-                st.write(results['summary'])
+    audio_file = request.files['file']
+    temp_audio_path = os.path.join(tempfile.gettempdir(), audio_file.filename)
+    audio_file.save(temp_audio_path)
+
+    results = process_audio(temp_audio_path)
+    os.remove(temp_audio_path)  # Clean up the temporary audio file
 
-        except Exception as e:
-            st.error(f"An unexpected error occurred: {str(e)}")
-        
-        finally:
-            # Cleanup original uploaded file
-            if os.path.exists(temp_audio_path):
-                try:
-                    os.unlink(temp_audio_path)
-                except:
-                    pass
+    return jsonify(results)
 
 if __name__ == "__main__":
-    main()
+    app.run(host='0.0.0.0', port=5000)

requirements.txt

@@ -1,6 +1,6 @@
-streamlit
-transformers
-torch
-soundfile
-numpy
-librosa
+Flask==2.2.3
+torch==1.12.1
+transformers==4.20.1
+librosa==0.9.2
+soundfile==0.10.3.post1
+numpy==1.21.6