Update app.py

app.py

@@ -5,36 +5,36 @@ import os
 import time
 import numpy as np
 import tempfile
-from io import BytesIO, StringIO
+from io import BytesIO
 from md2pdf.core import md2pdf
 from dotenv import load_dotenv
 from datetime import datetime
-import threading
+import backoff
+import requests
+from requests.exceptions import RequestException
+from typing import Optional, Dict, Any
 from download import download_video_audio, delete_download
+from st_audiorec import st_audiorec  # Import the audio recorder component
 
-# Override the max file size (40MB in bytes)
-MAX_FILE_SIZE = 41943040  # 40MB in bytes
+# Set max file size for audio uploads (40MB)
+MAX_FILE_SIZE = 41943040  # 40MB
 FILE_TOO_LARGE_MESSAGE = "File too large. Maximum size is 40MB."
 
-# Load environment variables in a secure way
+# Load environment variables
 load_dotenv()
 
 # Initialize session states
 if 'api_key' not in st.session_state:
-    # Try to get API key from environment variable first
     st.session_state.api_key = os.environ.get("GROQ_API_KEY", "")
     
-if 'recording' not in st.session_state:
-    st.session_state.recording = False
-    
-if 'audio_data' not in st.session_state:
-    st.session_state.audio_data = None
-    
 if 'transcript' not in st.session_state:
     st.session_state.transcript = ""
     
 if 'groq_client' not in st.session_state:
     st.session_state.groq_client = None
+    
+if 'transcription_error' not in st.session_state:
+    st.session_state.transcription_error = None
 
 # Set page configuration
 st.set_page_config(
@@ -48,17 +48,41 @@ st.set_page_config(
 LLM_MODEL = "deepseek-r1-distill-llama-70b"
 TRANSCRIPTION_MODEL = "distil-whisper-large-v3-en"
 
-# Initialize Groq client function
-def initialize_groq_client(api_key):
+# Configure exponential backoff for API retries
+MAX_RETRIES = 5
+INITIAL_WAIT = 0.5
+MAX_WAIT = 30
+
+# Initialize Groq client with improved error handling
+def initialize_groq_client(api_key: str) -> Optional[Groq]:
     """Initialize Groq client with the provided API key"""
     if not api_key:
         return None
+        
     try:
-        return Groq(api_key=api_key)
+        client = Groq(api_key=api_key)
+        # Perform a simple test call to validate the API key
+        client.models.list()
+        return client
     except Exception as e:
-        st.error(f"Failed to initialize Groq client: {e}")
+        error_msg = str(e)
+        if "401" in error_msg:
+            st.error("❌ Invalid API key: Authentication failed")
+        elif "403" in error_msg:
+            st.error("❌ API key doesn't have permission to access Groq API")
+        else:
+            st.error(f"❌ Failed to initialize Groq client: {error_msg}")
         return None
 
+# Define custom exception for Groq API errors
+class GroqAPIError(Exception):
+    """Custom exception for Groq API errors"""
+    def __init__(self, message, status_code=None, response=None):
+        self.message = message
+        self.status_code = status_code
+        self.response = response
+        super().__init__(self.message)
+
 class GenerationStatistics:
     def __init__(self, input_time=0, output_time=0, input_tokens=0, output_tokens=0, total_time=0, model_name=LLM_MODEL):
         self.input_time = input_time
@@ -168,67 +192,88 @@ class NoteSection:
                 markdown_content += self.get_markdown_content(content, level + 1)
         return markdown_content
 
-# Audio recorder functionality
-class AudioRecorder:
-    def __init__(self, sample_rate=44100):
-        self.sample_rate = sample_rate
-        self.recording = False
-        self.audio_data = []
-        self.thread = None
-    
-    def start_recording(self):
-        self.recording = True
-        self.audio_data = []
-        self.thread = threading.Thread(target=self._record_audio)
-        self.thread.start()
-        
-    def _record_audio(self):
-        import sounddevice as sd
-        with sd.InputStream(callback=self._audio_callback, channels=1, samplerate=self.sample_rate):
-            while self.recording:
-                time.sleep(0.1)
-    
-    def _audio_callback(self, indata, frames, time, status):
-        if status:
-            print(f"Status: {status}")
-        self.audio_data.append(indata.copy())
+# Add backoff decorator for retrying transcription
+@backoff.on_exception(
+    backoff.expo,
+    (RequestException, GroqAPIError),
+    max_tries=MAX_RETRIES,
+    factor=INITIAL_WAIT,
+    max_value=MAX_WAIT,
+    jitter=backoff.full_jitter,
+    on_backoff=lambda details: st.info(f"Retrying transcription... (Attempt {details['tries']}/{MAX_RETRIES})")
+)
+def transcribe_audio_with_groq(audio_data) -> str:
+    """
+    Transcribe audio file using Groq's transcription API with retry capability
     
-    def stop_recording(self):
-        self.recording = False
-        if self.thread:
-            self.thread.join()
+    Args:
+        audio_data: Either file path string or binary audio data
         
-        if not self.audio_data:
-            return None
-            
-        # Concatenate all audio chunks
-        import numpy as np
-        import soundfile as sf
-        audio = np.concatenate(self.audio_data, axis=0)
-        
-        # Save to a temporary file
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".m4a")
-        sf.write(temp_file.name, audio, self.sample_rate)
+    Returns:
+        Transcribed text
         
-        return temp_file.name
-
-def transcribe_audio_with_groq(audio_file_path):
-    """Transcribe audio file using Groq's transcription API"""
+    Raises:
+        GroqAPIError: For API-related errors
+        ValueError: For invalid input
+    """
     if not st.session_state.groq_client:
-        st.error("Groq client is not initialized. Please check your API key.")
-        return ""
+        raise ValueError("Groq client is not initialized. Please check your API key.")
     
     try:
+        # Save audio data to a temporary file if it's binary data
+        if isinstance(audio_data, bytes):
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
+                tmp_file.write(audio_data)
+                audio_file_path = tmp_file.name
+        else:
+            # Assume it's a file path
+            audio_file_path = audio_data
+            if not os.path.exists(audio_file_path):
+                raise ValueError(f"Audio file not found: {audio_file_path}")
+        
+        # Check file size before sending
+        file_size = os.path.getsize(audio_file_path)
+        if file_size > MAX_FILE_SIZE:
+            raise ValueError(f"Audio file size ({file_size/1048576:.2f}MB) exceeds 40MB limit")
+        
         with open(audio_file_path, "rb") as file:
+            # Display a progress message since transcription can take time
+            progress_placeholder = st.empty()
+            progress_placeholder.info("Processing audio... This may take a minute.")
+            
             transcription = st.session_state.groq_client.audio.transcriptions.create(
                 file=(audio_file_path, file.read()),
                 model=TRANSCRIPTION_MODEL,
                 response_format="verbose_json"
             )
+            
+            # Clear the progress message when done
+            progress_placeholder.empty()
+            
+            if not hasattr(transcription, 'text') or not transcription.text:
+                raise GroqAPIError("Empty transcription result returned")
+                
+            # Delete temp file if we created one
+            if isinstance(audio_data, bytes) and os.path.exists(audio_file_path):
+                os.unlink(audio_file_path)
+                
             return transcription.text
+            
     except Exception as e:
-        st.error(f"Error transcribing audio with Groq: {e}")
-        return ""
+        error_msg = str(e)
+        
+        # Handle specific error cases
+        if "401" in error_msg:
+            raise GroqAPIError("Authentication failed. Please check your API key.", 401)
+        elif "429" in error_msg:
+            raise GroqAPIError("Rate limit exceeded. Please try again later.", 429)
+        elif "413" in error_msg:
+            raise GroqAPIError("Audio file too large for processing.", 413)
+        elif "500" in error_msg or "502" in error_msg or "503" in error_msg or "504" in error_msg:
+            raise GroqAPIError("Groq server error. Please try again later.", int(error_msg[:3]))
+        else:
+            # Re-raise as a GroqAPIError for consistent handling
+            raise GroqAPIError(f"Error transcribing audio: {error_msg}")
 
 def process_transcript(transcript):
     """Process transcript with Groq's DeepSeek model for highly structured notes"""
@@ -472,71 +517,58 @@ def main():
     # Input methods tabs
     input_method = st.radio("Choose input method:", ["Live Recording", "Upload Audio", "YouTube URL", "Text Input"])
     
-    audio_recorder = AudioRecorder()
-    
     if input_method == "Live Recording":
-        col1, col2 = st.columns(2)
+        st.markdown("### Record Audio")
+        st.markdown("Click the microphone button below to start recording. Click it again to stop.")
         
-        with col1:
-            if not st.session_state.recording:
-                if st.button("Start Recording 🎤", key="start_rec"):
-                    st.session_state.recording = True
-                    audio_recorder.start_recording()
-                    st.rerun()
-            else:
-                if st.button("Stop Recording ⏹️", key="stop_rec"):
-                    audio_file = audio_recorder.stop_recording()
-                    st.session_state.recording = False
-                    
-                    if audio_file:
-                        st.session_state.audio_data = audio_file
-                        st.success("Recording saved!")
-                        
-                        # Auto-transcribe using Groq
-                        with st.spinner("Transcribing audio with Groq..."):
-                            transcript = transcribe_audio_with_groq(audio_file)
-                            if transcript:
-                                st.session_state.transcript = transcript
-                                st.success("Transcription complete!")
-                    st.rerun()
+        # Use the streamlit-audiorec component for recording
+        wav_audio_data = st_audiorec()
         
-        with col2:
-            if st.session_state.recording:
-                st.markdown("#### 🔴 Recording in progress...")
-                
-                # Animated recording indicator
-                progress_bar = st.progress(0)
-                for i in range(100):
-                    time.sleep(0.05)
-                    progress_bar.progress((i + 1) % 101)
-                    
-                    # Break if recording stopped
-                    if not st.session_state.recording:
-                        break
-                st.rerun()
+        # If audio data is returned, display and process it
+        if wav_audio_data is not None:
+            # Reset any previous transcription errors
+            st.session_state.transcription_error = None
             
-        if st.session_state.audio_data:
-            st.audio(st.session_state.audio_data)
+            # Display the audio
+            st.audio(wav_audio_data, format='audio/wav')
             
-            if st.session_state.transcript:
-                if st.button("Generate Structured Notes", key="generate_live"):
-                    with st.spinner("Creating highly structured notes..."):
-                        notes = process_transcript(st.session_state.transcript)
-                        
-                        if notes:
-                            st.success("Notes generated successfully!")
+            # Add a button to transcribe the recorded audio
+            if st.button("Transcribe Recording", key="transcribe_rec"):
+                with st.spinner("Transcribing audio with Groq..."):
+                    try:
+                        transcript = transcribe_audio_with_groq(wav_audio_data)
+                        if transcript:
+                            st.session_state.transcript = transcript
+                            st.success("✅ Transcription complete!")
                             
-                            # Export options
-                            col1, col2 = st.columns(2)
-                            with col1:
-                                if st.button("Export as Markdown", key="md_live"):
-                                    export_notes(notes, "markdown")
-                            with col2:
-                                if st.button("Export as PDF", key="pdf_live"):
-                                    export_notes(notes, "pdf")
+                            with st.expander("View Transcript", expanded=True):
+                                st.markdown(transcript)
+                                
+                            if st.button("Generate Structured Notes", key="generate_live"):
+                                with st.spinner("Creating highly structured notes..."):
+                                    notes = process_transcript(transcript)
+                                    
+                                    if notes:
+                                        st.success("Notes generated successfully!")
+                                        
+                                        # Export options
+                                        col1, col2 = st.columns(2)
+                                        with col1:
+                                            if st.button("Export as Markdown", key="md_live"):
+                                                export_notes(notes, "markdown")
+                                        with col2:
+                                            if st.button("Export as PDF", key="pdf_live"):
+                                                export_notes(notes, "pdf")
+                    except (ValueError, GroqAPIError) as e:
+                        st.session_state.transcription_error = str(e)
+                        st.error(f"❌ Transcription failed: {str(e)}")
     
     elif input_method == "Upload Audio":
-        uploaded_file = st.file_uploader("Upload an audio file (max 40MB)", type=["mp3", "wav", "m4a", "ogg"])
+        uploaded_file = st.file_uploader(
+            "Upload an audio file (max 40MB)", 
+            type=["mp3", "wav", "m4a", "ogg"],
+            help="Supported formats: MP3, WAV, M4A, OGG. Maximum size: 40MB"
+        )
         
         if uploaded_file:
             file_size = uploaded_file.size
@@ -551,32 +583,56 @@ def main():
                 st.audio(uploaded_file)
                 
                 if st.button("Transcribe and Generate Notes", key="transcribe_upload"):
+                    # Reset any previous transcription errors
+                    st.session_state.transcription_error = None
+                    
                     with st.spinner("Transcribing audio with Groq..."):
-                        transcript = transcribe_audio_with_groq(audio_file_path)
-                        
-                        if transcript:
-                            st.session_state.transcript = transcript
-                            
-                            with st.spinner("Creating highly structured notes..."):
-                                notes = process_transcript(transcript)
+                        try:
+                            transcript = transcribe_audio_with_groq(audio_file_path)
+                            if transcript:
+                                st.session_state.transcript = transcript
+                                st.success("✅ Transcription complete!")
                                 
-                                if notes:
-                                    st.success("Notes generated successfully!")
+                                with st.expander("View Transcript", expanded=True):
+                                    st.markdown(transcript)
+                                
+                                with st.spinner("Creating highly structured notes..."):
+                                    notes = process_transcript(transcript)
                                     
-                                    # Export options
-                                    col1, col2 = st.columns(2)
-                                    with col1:
-                                        if st.button("Export as Markdown", key="md_upload"):
-                                            export_notes(notes, "markdown")
-                                    with col2:
-                                        if st.button("Export as PDF", key="pdf_upload"):
-                                            export_notes(notes, "pdf")
+                                    if notes:
+                                        st.success("Notes generated successfully!")
+                                        
+                                        # Export options
+                                        col1, col2 = st.columns(2)
+                                        with col1:
+                                            if st.button("Export as Markdown", key="md_upload"):
+                                                export_notes(notes, "markdown")
+                                        with col2:
+                                            if st.button("Export as PDF", key="pdf_upload"):
+                                                export_notes(notes, "pdf")
+                        except (ValueError, GroqAPIError) as e:
+                            st.session_state.transcription_error = str(e)
+                            st.error(f"❌ Transcription failed: {str(e)}")
+                            
+                            # Provide helpful suggestions based on error type
+                            if "Audio file too large" in str(e) or "exceeds" in str(e):
+                                st.info("💡 Try trimming your audio file or uploading a shorter segment.")
+                            elif "API key" in str(e) or "Authentication" in str(e):
+                                st.info("💡 Check that your Groq API key is correct and has access to the transcription API.")
+                            elif "Rate limit" in str(e):
+                                st.info("💡 You've hit Groq's rate limits. Please wait a few minutes before trying again.")
             
     elif input_method == "YouTube URL":
-        youtube_url = st.text_input("Enter YouTube URL:")
+        youtube_url = st.text_input(
+            "Enter YouTube URL:",
+            help="Enter the full URL of a YouTube video (e.g., https://www.youtube.com/watch?v=example)"
+        )
         
         if youtube_url:
             if st.button("Process YouTube Content", key="process_yt"):
+                # Reset any previous errors
+                st.session_state.transcription_error = None
+                
                 with st.spinner("Downloading YouTube content..."):
                     try:
                         audio_path = download_video_audio(youtube_url)
@@ -586,26 +642,34 @@ def main():
                             st.audio(audio_path)
                             
                             with st.spinner("Transcribing audio with Groq..."):
-                                transcript = transcribe_audio_with_groq(audio_path)
-                                
-                                if transcript:
-                                    st.session_state.transcript = transcript
-                                    
-                                    with st.spinner("Creating highly structured notes..."):
-                                        notes = process_transcript(transcript)
+                                try:
+                                    transcript = transcribe_audio_with_groq(audio_path)
+                                    if transcript:
+                                        st.session_state.transcript = transcript
+                                        st.success("✅ Transcription complete!")
+                                        
+                                        with st.expander("View Transcript", expanded=True):
+                                            st.markdown(transcript)
                                         
-                                        if notes:
-                                            st.success("Notes generated successfully!")
+                                        with st.spinner("Creating highly structured notes..."):
+                                            notes = process_transcript(transcript)
                                             
-                                            # Export options
-                                            col1, col2 = st.columns(2)
-                                            with col1:
-                                                if st.button("Export as Markdown", key="md_yt"):
-                                                    export_notes(notes, "markdown")
-                                            with col2:
-                                                if st.button("Export as PDF", key="pdf_yt"):
-                                                    export_notes(notes, "pdf")
-                                    
+                                            if notes:
+                                                st.success("Notes generated successfully!")
+                                                
+                                                # Export options
+                                                col1, col2 = st.columns(2)
+                                                with col1:
+                                                    if st.button("Export as Markdown", key="md_yt"):
+                                                        export_notes(notes, "markdown")
+                                                with col2:
+                                                    if st.button("Export as PDF", key="pdf_yt"):
+                                                        export_notes(notes, "pdf")
+                                
+                                except (ValueError, GroqAPIError) as e:
+                                    st.session_state.transcription_error = str(e)
+                                    st.error(f"❌ Transcription failed: {str(e)}")
+                                                
                             # Clean up downloaded files
                             delete_download(audio_path)
                     
@@ -616,7 +680,11 @@ def main():
                             st.error(f"Error processing YouTube video: {e}")
     
     else:  # Text Input
-        transcript = st.text_area("Enter transcript text:", height=300)
+        transcript = st.text_area(
+            "Enter transcript text:", 
+            height=300,
+            help="Paste or type your transcript text here for generating structured notes"
+        )
         
         if transcript:
             st.session_state.transcript = transcript