Update app.py

app.py

@@ -1,189 +1,200 @@
-import streamlit as st
+import streamlit as st #
 import moviepy.editor as mp
 import speech_recognition as sr
 from pydub import AudioSegment
 import tempfile
 import os
 import io
-import requests
 from transformers import pipeline
 import matplotlib.pyplot as plt
-import librosa
-import numpy as np
-
-# Function to download file from URL
-def download_file(url):
-    try:
-        extension = os.path.splitext(url)[1]
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=extension)
-        with requests.get(url, stream=True) as r:
-            r.raise_for_status()
-            for chunk in r.iter_content(chunk_size=8192):
-                temp_file.write(chunk)
-        temp_file.close()
-        return temp_file.name
-    except Exception as e:
-        st.error(f"Failed to download file: {e}")
-        return None
 
 # Function to convert video to audio
 def video_to_audio(video_file):
+    # Load the video using moviepy
     video = mp.VideoFileClip(video_file)
+    
+    # Extract audio
     audio = video.audio
     temp_audio_path = tempfile.mktemp(suffix=".mp3")
+    
+    # Write the audio to a file
     audio.write_audiofile(temp_audio_path)
     return temp_audio_path
 
-# Function to convert MP3 to WAV
+# Function to convert MP3 audio to WAV
 def convert_mp3_to_wav(mp3_file):
+    # Load the MP3 file using pydub
     audio = AudioSegment.from_mp3(mp3_file)
+    
+    # Create a temporary WAV file
     temp_wav_path = tempfile.mktemp(suffix=".wav")
+    
+    # Export the audio to the temporary WAV file
     audio.export(temp_wav_path, format="wav")
     return temp_wav_path
 
-# Function to transcribe audio with chunking for large files
+# Function to transcribe audio to text
 def transcribe_audio(audio_file):
-    audio = AudioSegment.from_wav(audio_file)
-    duration = len(audio) / 1000  # Duration in seconds
-    chunk_length = 60  # 60-second chunks
+    # Initialize recognizer
     recognizer = sr.Recognizer()
     
-    if duration <= chunk_length:
-        with sr.AudioFile(audio_file) as source:
-            audio_data = recognizer.record(source)
-        try:
-            text = recognizer.recognize_google(audio_data)
-            return text
-        except sr.UnknownValueError:
-            return "Audio could not be understood."
-        except sr.RequestError:
-            return "Could not request results from Google Speech Recognition service."
-    else:
-        num_chunks = int(duration // chunk_length) + 1
-        transcriptions = []
-        for i in range(num_chunks):
-            start_time = i * chunk_length * 1000  # in milliseconds
-            end_time = min((i + 1) * chunk_length * 1000, len(audio))
-            chunk = audio[start_time:end_time]
-            frame_data = chunk.raw_data
-            sample_rate = audio.frame_rate
-            sample_width = audio.sample_width
-            audio_data = sr.AudioData(frame_data, sample_rate, sample_width)
-            try:
-                text = recognizer.recognize_google(audio_data)
-                transcriptions.append(text)
-            except sr.UnknownValueError:
-                transcriptions.append("[Audio could not be understood.]")
-            except sr.RequestError:
-                transcriptions.append("[Could not request results.]")
-        return " ".join(transcriptions)
-
-# Function to detect emotions
+    # Load the audio file using speech_recognition
+    audio = sr.AudioFile(audio_file)
+    
+    with audio as source:
+        audio_data = recognizer.record(source)
+    
+    try:
+        # Transcribe the audio data to text using Google Web Speech API
+        text = recognizer.recognize_google(audio_data)
+        return text
+    except sr.UnknownValueError:
+        return "Audio could not be understood."
+    except sr.RequestError:
+        return "Could not request results from Google Speech Recognition service."
+
+# Function to perform emotion detection using Hugging Face transformers
 def detect_emotion(text):
+    # Load emotion detection pipeline
     emotion_pipeline = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base", return_all_scores=True)
+    
+    # Get the emotion predictions
     result = emotion_pipeline(text)
+    
+    # Extract the emotion with the highest score
     emotions = {emotion['label']: emotion['score'] for emotion in result[0]}
     return emotions
 
-# Function to plot audio waveform
-def plot_waveform(audio_data, duration=10):
-    audio_data.seek(0)
-    y, sr = librosa.load(audio_data, sr=None, duration=duration)
-    plt.figure(figsize=(10, 4))
-    time = np.linspace(0, len(y)/sr, len(y))
-    plt.plot(time, y)
-    plt.title(f"Audio Waveform (first {duration} seconds)")
-    plt.xlabel("Time (s)")
-    plt.ylabel("Amplitude")
-    st.pyplot(plt)
-
 # Streamlit app layout
 st.title("Video and Audio to Text Transcription with Emotion Detection and Visualization")
-st.write("Upload a video or audio file, or provide a URL to a large file (up to 1GB).")
-st.write("**Note:** Direct file uploads are limited to 200MB. For larger files, please provide a URL.")
+st.write("Upload a video or audio file to convert it to transcription, detect emotions, and visualize the audio waveform.")
 
-tab = st.selectbox("Select file type", ["Video", "Audio"])
+# Create tabs to separate video and audio uploads
+tab = st.selectbox("Select the type of file to upload", ["Video", "Audio"])
 
 if tab == "Video":
-    method = st.radio("Choose how to provide the video file:", ["Upload file", "Provide URL"])
-    if method == "Upload file":
-        uploaded_file = st.file_uploader("Upload Video", type=["mp4", "mov", "avi"])
-    elif method == "Provide URL":
-        url = st.text_input("Enter video URL")
-    if st.button("Analyze Video"):
-        if method == "Upload file" and uploaded_file:
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
-                tmp_file.write(uploaded_file.read())
-                file_path = tmp_file.name
-        elif method == "Provide URL" and url:
-            with st.spinner("Downloading video... This may take a while for large files."):
-                file_path = download_file(url)
-                if file_path is None:
-                    st.error("Failed to download the file. Please check the URL and try again.")
-                    st.stop()
-        else:
-            st.error("Please provide a file or URL.")
-            st.stop()
-        # Process the video file
-        with st.spinner("Processing video..."):
-            audio_file = video_to_audio(file_path)
-            wav_audio_file = convert_mp3_to_wav(audio_file)
-            transcription = transcribe_audio(wav_audio_file)
-            st.text_area("Transcription", transcription, height=300)
-            emotions = detect_emotion(transcription)
-            st.write(f"Detected Emotions: {emotions}")
-            with open(wav_audio_file, "rb") as f:
-                audio_data = io.BytesIO(f.read())
-                st.session_state.wav_audio_file = audio_data
-            plot_waveform(st.session_state.wav_audio_file)
-            # Cleanup
-            os.remove(file_path)
-            os.remove(audio_file)
-            os.remove(wav_audio_file)
-    if 'wav_audio_file' in st.session_state:
+    # File uploader for video
+    uploaded_video = st.file_uploader("Upload Video", type=["mp4", "mov", "avi"])
+
+    if uploaded_video is not None:
+        # Save the uploaded video file temporarily
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_video:
+            tmp_video.write(uploaded_video.read())
+            tmp_video_path = tmp_video.name
+
+        # Add an "Analyze Video" button
+        if st.button("Analyze Video"):
+            with st.spinner("Processing video... Please wait."):
+
+                # Convert video to audio
+                audio_file = video_to_audio(tmp_video_path)
+                
+                # Convert the extracted MP3 audio to WAV
+                wav_audio_file = convert_mp3_to_wav(audio_file)
+                
+                # Transcribe audio to text
+                transcription = transcribe_audio(wav_audio_file)
+
+                # Show the transcription
+                st.text_area("Transcription", transcription, height=300)
+
+                # Emotion detection
+                emotions = detect_emotion(transcription)
+                st.write(f"Detected Emotions: {emotions}")
+
+                # Store transcription and audio file in session state
+                st.session_state.transcription = transcription
+                
+                # Store the audio file as a BytesIO object in memory
+                with open(wav_audio_file, "rb") as f:
+                    audio_data = f.read()
+                    st.session_state.wav_audio_file = io.BytesIO(audio_data)
+
+                # Cleanup temporary files
+                os.remove(tmp_video_path)
+                os.remove(audio_file)
+
+    # Check if transcription and audio file are stored in session state
+    if 'transcription' in st.session_state and 'wav_audio_file' in st.session_state:
+        # Provide the audio file to the user for download
         st.audio(st.session_state.wav_audio_file, format='audio/wav')
-        st.download_button("Download Transcription", transcription, "transcription.txt", "text/plain")
-        st.download_button("Download Audio", st.session_state.wav_audio_file, "converted_audio.wav", "audio/wav")
+        
+        # Add download buttons for the transcription and audio
+        # Downloadable transcription file
+        st.download_button(
+            label="Download Transcription",
+            data=st.session_state.transcription,
+            file_name="transcription.txt",
+            mime="text/plain"
+        )
+        
+        # Downloadable audio file
+        st.download_button(
+            label="Download Audio",
+            data=st.session_state.wav_audio_file,
+            file_name="converted_audio.wav",
+            mime="audio/wav"
+        )
 
 elif tab == "Audio":
-    method = st.radio("Choose how to provide the audio file:", ["Upload file", "Provide URL"])
-    if method == "Upload file":
-        uploaded_file = st.file_uploader("Upload Audio", type=["wav", "mp3"])
-    elif method == "Provide URL":
-        url = st.text_input("Enter audio URL")
-    if st.button("Analyze Audio"):
-        if method == "Upload file" and uploaded_file:
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3' if uploaded_file.type == "audio/mpeg" else '.wav') as tmp_file:
-                tmp_file.write(uploaded_file.read())
-                file_path = tmp_file.name
-        elif method == "Provide URL" and url:
-            with st.spinner("Downloading audio... This may take a while for large files."):
-                file_path = download_file(url)
-                if file_path is None:
-                    st.error("Failed to download the file. Please check the URL and try again.")
-                    st.stop()
-        else:
-            st.error("Please provide a file or URL.")
-            st.stop()
-        # Process the audio file
-        with st.spinner("Processing audio..."):
-            if file_path.endswith('.mp3'):
-                wav_audio_file = convert_mp3_to_wav(file_path)
-            else:
-                wav_audio_file = file_path
-            transcription = transcribe_audio(wav_audio_file)
-            st.text_area("Transcription", transcription, height=300)
-            emotions = detect_emotion(transcription)
-            st.write(f"Detected Emotions: {emotions}")
-            with open(wav_audio_file, "rb") as f:
-                audio_data = io.BytesIO(f.read())
-                st.session_state.wav_audio_file_audio = audio_data
-            plot_waveform(st.session_state.wav_audio_file_audio)
-            # Cleanup
-            if file_path != wav_audio_file:
-                os.remove(file_path)
-            os.remove(wav_audio_file)
-    if 'wav_audio_file_audio' in st.session_state:
-        st.audio(st.session_state.wav_audio_file_audio, format='audio/wav')
-        st.download_button("Download Transcription", transcription, "transcription_audio.txt", "text/plain")
-        st.download_button("Download Audio", st.session_state.wav_audio_file_audio, "converted_audio_audio.wav", "audio/wav")
+    # File uploader for audio
+    uploaded_audio = st.file_uploader("Upload Audio", type=["wav", "mp3"])
+
+    if uploaded_audio is not None:
+        # Save the uploaded audio file temporarily
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_audio:
+            tmp_audio.write(uploaded_audio.read())
+            tmp_audio_path = tmp_audio.name
+
+        # Add an "Analyze Audio" button
+        if st.button("Analyze Audio"):
+            with st.spinner("Processing audio... Please wait."):
+
+                # Convert audio to WAV if it's in MP3 format
+                if uploaded_audio.type == "audio/mpeg":
+                    wav_audio_file = convert_mp3_to_wav(tmp_audio_path)
+                else:
+                    wav_audio_file = tmp_audio_path
+                
+                # Transcribe audio to text
+                transcription = transcribe_audio(wav_audio_file)
+
+                # Show the transcription
+                st.text_area("Transcription", transcription, height=300)
+
+                # Emotion detection
+                emotions = detect_emotion(transcription)
+                st.write(f"Detected Emotions: {emotions}")
+
+                # Store transcription in session state
+                st.session_state.transcription_audio = transcription
+                
+                # Store the audio file as a BytesIO object in memory
+                with open(wav_audio_file, "rb") as f:
+                    audio_data = f.read()
+                    st.session_state.wav_audio_file_audio = io.BytesIO(audio_data)
+
+                # Cleanup temporary audio file
+                os.remove(tmp_audio_path)
+
+        # Check if transcription and audio file are stored in session state
+        if 'transcription_audio' in st.session_state and 'wav_audio_file_audio' in st.session_state:
+            # Provide the audio file to the user for download
+            st.audio(st.session_state.wav_audio_file_audio, format='audio/wav')
+            
+            # Add download buttons for the transcription and audio
+            # Downloadable transcription file
+            st.download_button(
+                label="Download Transcription",
+                data=st.session_state.transcription_audio,
+                file_name="transcription_audio.txt",
+                mime="text/plain"
+            )
+            
+            # Downloadable audio file
+            st.download_button(
+                label="Download Audio",
+                data=st.session_state.wav_audio_file_audio,
+                file_name="converted_audio_audio.wav",
+                mime="audio/wav"
+            )