Update app.py

app.py

@@ -1,17 +1,18 @@
-# app.py (Working Version without 'every' parameter)
+# app.py (Simplified & Robust Meeting Summarizer)
 import gradio as gr
 import threading
 import queue
 import time
+import wave
+import os
 from datetime import datetime
 from analyzer import MeetingAnalyzer
 from integrations import Notifier
 import config
+import speech_recognition as sr
 
 class MeetingProcessor:
     def __init__(self):
-        self.recognizer = None
-        self.stop_listening = None
         self.analyzer = MeetingAnalyzer()
         self.notifier = Notifier()
         self.running = False
@@ -21,8 +22,8 @@ class MeetingProcessor:
         self.action_items = []
         self.urgent_alerts = []
         self.transcript_queue = queue.Queue()
-        self.ui_update_event = threading.Event()
-        self.last_update = time.time()
+        self.recording_file = None
+        self.recognizer = sr.Recognizer()
         
     def start_processing(self):
         if self.running:
@@ -34,63 +35,68 @@ class MeetingProcessor:
         self.summary = ""
         self.action_items = []
         self.urgent_alerts = []
-        self.ui_update_event.set()  # Trigger UI update
+        
+        # Create a unique filename for this recording
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.recording_file = f"meeting_{timestamp}.wav"
         
         # Start processing threads
         threading.Thread(target=self._audio_capture_thread, daemon=True).start()
-        threading.Thread(target=self._analysis_thread, daemon=True).start()
+        threading.Thread(target=self._transcription_thread, daemon=True).start()
         
         return "Meeting processing started! 🎤"
     
     def _audio_capture_thread(self):
-        import speech_recognition as sr
-        
-        self.recognizer = sr.Recognizer()
-        self.recognizer.energy_threshold = config.ENERGY_THRESHOLD
-        self.recognizer.dynamic_energy_threshold = config.DYNAMIC_ENERGY_THRESHOLD
-        self.recognizer.pause_threshold = config.PAUSE_THRESHOLD
-        
-        with sr.Microphone() as source:
-            print("Adjusting for ambient noise...")
-            self.recognizer.adjust_for_ambient_noise(source, duration=1)
-            print("Microphone ready!")
-            
-            def callback(recognizer, audio):
-                try:
-                    text = recognizer.recognize_google(audio)
-                    self.transcript_queue.put(text)
-                except sr.UnknownValueError:
-                    pass
-                except sr.RequestError as e:
-                    print(f"Speech recognition error: {str(e)}")
-            
-            self.stop_listening = self.recognizer.listen_in_background(
-                source, 
-                callback,
-                phrase_time_limit=config.PHRASE_TIME_LIMIT
-            )
-            
-            # Keep the thread running while processing
-            while self.running:
-                time.sleep(0.1)
+        """Capture audio from microphone and save to file"""
+        try:
+            with sr.Microphone() as source:
+                print("Adjusting for ambient noise...")
+                self.recognizer.adjust_for_ambient_noise(source, duration=1)
+                print("Microphone ready! Recording meeting...")
+                
+                # Start recording
+                audio = self.recognizer.listen(source, timeout=None, phrase_time_limit=300)
+                
+                # Save audio to file
+                with open(self.recording_file, "wb") as f:
+                    f.write(audio.get_wav_data())
+                
+                # Add to queue for processing
+                self.transcript_queue.put(self.recording_file)
+                
+        except Exception as e:
+            print(f"Audio capture error: {str(e)}")
     
-    def _analysis_thread(self):
+    def _transcription_thread(self):
+        """Transcribe audio files as they become available"""
         while self.running:
             try:
-                transcript = self.transcript_queue.get(timeout=1.0)
-                if transcript:
-                    self.transcript_history.append(transcript)
-                    self.analyzer.process_chunk(transcript)
-                    
-                    # Check for urgent items periodically
-                    if len(self.transcript_history) % 5 == 0:
-                        urgent_items = self.analyzer.detect_urgent_action_items()
-                        if urgent_items:
-                            self.urgent_alerts.extend(urgent_items)
-                            self.notifier.send_urgent_alert(urgent_items)
-                    
-                    # Trigger UI update
-                    self.ui_update_event.set()
+                audio_file = self.transcript_queue.get(timeout=1.0)
+                if audio_file:
+                    # Transcribe the audio file
+                    with sr.AudioFile(audio_file) as source:
+                        audio = self.recognizer.record(source)
+                        try:
+                            text = self.recognizer.recognize_google(audio)
+                            self.transcript_history.append(text)
+                            self.analyzer.process_chunk(text)
+                            
+                            # Generate interim summary
+                            if len(self.transcript_history) % 3 == 0:
+                                self.summary = self.analyzer.generate_summary()
+                                self.action_items = self.analyzer.extract_action_items()
+                            
+                            # Check for urgent items
+                            urgent_items = self.analyzer.detect_urgent_action_items()
+                            if urgent_items:
+                                self.urgent_alerts.extend(urgent_items)
+                                self.notifier.send_urgent_alert(urgent_items)
+                                
+                        except sr.UnknownValueError:
+                            print("Speech recognition could not understand audio")
+                        except sr.RequestError as e:
+                            print(f"Speech recognition error: {str(e)}")
+                
             except queue.Empty:
                 continue
     
@@ -100,9 +106,6 @@ class MeetingProcessor:
             
         self.running = False
         
-        if self.stop_listening:
-            self.stop_listening(wait_for_stop=False)
-        
         # Generate final analysis
         self.summary = self.analyzer.generate_summary()
         self.action_items = self.analyzer.extract_action_items()
@@ -116,9 +119,6 @@ class MeetingProcessor:
             recipients=config.NOTIFICATION_RECIPIENTS
         )
         
-        # Trigger final UI update
-        self.ui_update_event.set()
-        
         return "Meeting processing stopped! Report sent. ✅"
     
     def get_current_status(self):
@@ -135,14 +135,14 @@ class MeetingProcessor:
         elapsed = time.time() - self.start_time
         mins, secs = divmod(int(elapsed), 60)
         
-        # Only show last 5 transcript entries
-        recent_transcript = "\n".join(self.transcript_history[-5:])
+        # Only show last 3 transcript entries
+        recent_transcript = "\n".join(self.transcript_history[-3:])
         
         return {
             "status": "Recording",
             "duration": f"{mins:02d}:{secs:02d}",
             "transcript": recent_transcript,
-            "summary": self.summary if self.summary else "Summary will appear after meeting ends",
+            "summary": self.summary if self.summary else "Summary will appear during meeting",
             "action_items": self.action_items,
             "alerts": self.urgent_alerts
         }
@@ -151,25 +151,26 @@ class MeetingProcessor:
 processor = MeetingProcessor()
 
 # Create Gradio interface
-with gr.Blocks(title="Real-Time Meeting Summarizer", theme="soft") as app:
-    gr.Markdown("# 🎙️ Real-Time Meeting Summarizer")
-    gr.Markdown("Start this during any meeting to get live transcription and automatic summaries")
+with gr.Blocks(title="Meeting Notes Generator", theme="soft") as app:
+    gr.Markdown("# 📝 Meeting Notes Generator")
+    gr.Markdown("Start this during any meeting to automatically capture notes and action items")
     
     with gr.Row():
         start_btn = gr.Button("Start Meeting", variant="primary")
         stop_btn = gr.Button("Stop Meeting", variant="stop")
-        status_text = gr.Textbox(label="Status", interactive=False)
-        refresh_btn = gr.Button("Refresh Now", variant="secondary")
+        status_text = gr.Textbox(label="Status", interactive=False, value="Ready to start meeting")
     
     with gr.Row():
         with gr.Column():
             duration_display = gr.Textbox(label="Duration", interactive=False)
-            transcript_box = gr.Textbox(label="Live Transcript", lines=8, interactive=False)
+            transcript_box = gr.Textbox(label="Live Transcript", lines=6, interactive=False)
         
         with gr.Column():
-            alerts_box = gr.Textbox(label="Urgent Alerts", lines=3, interactive=False)
-            summary_box = gr.Textbox(label="Meeting Summary", lines=5, interactive=False)
-            action_items_box = gr.Textbox(label="Action Items", lines=5, interactive=False)
+            summary_box = gr.Textbox(label="Meeting Summary", lines=6, interactive=False)
+    
+    with gr.Row():
+        action_items_box = gr.Textbox(label="Action Items", lines=4, interactive=False)
+        alerts_box = gr.Textbox(label="Urgent Alerts", lines=4, interactive=False)
     
     # Update function for components
     def update_components():
@@ -186,7 +187,7 @@ with gr.Blocks(title="Real-Time Meeting Summarizer", theme="soft") as app:
                 for item in current_status["alerts"]
             ) if current_status["alerts"] else "No urgent alerts",
             current_status["summary"],
-            "Recording" if processor.running else "Stopped"
+            current_status["status"]
         ]
     
     # Button actions
@@ -194,24 +195,17 @@ with gr.Blocks(title="Real-Time Meeting Summarizer", theme="soft") as app:
         fn=processor.start_processing,
         inputs=[],
         outputs=[status_text]
-    ).then(
-        update_components,
-        inputs=[],
-        outputs=[
-            duration_display, 
-            transcript_box,
-            action_items_box,
-            alerts_box,
-            summary_box,
-            status_text
-        ]
     )
     
     stop_btn.click(
         fn=processor.stop_processing,
         inputs=[],
         outputs=[status_text]
-    ).then(
+    )
+    
+    # Manual refresh button
+    refresh_btn = gr.Button("Refresh View", variant="secondary")
+    refresh_btn.click(
         update_components,
         inputs=[],
         outputs=[
@@ -224,8 +218,16 @@ with gr.Blocks(title="Real-Time Meeting Summarizer", theme="soft") as app:
         ]
     )
     
-    # Refresh button action
-    refresh_btn.click(
+    # Instructions
+    gr.Markdown("### How to use:")
+    gr.Markdown("1. Click **Start Meeting** when your meeting begins")
+    gr.Markdown("2. Continue with your meeting as normal")
+    gr.Markdown("3. Click **Stop Meeting** when finished")
+    gr.Markdown("4. View your meeting summary and action items below")
+    gr.Markdown("5. Click **Refresh View** to update the display")
+    
+    # Initialize with current status
+    app.load(
         update_components,
         inputs=[],
         outputs=[
@@ -238,32 +240,5 @@ with gr.Blocks(title="Real-Time Meeting Summarizer", theme="soft") as app:
         ]
     )
     
-    # Auto-refresh thread
-    def auto_refresh():
-        while True:
-            # Wait for update event
-            processor.ui_update_event.wait()
-            processor.ui_update_event.clear()
-            
-            # Update the UI components
-            app.queue().put(
-                update_components,
-                inputs=[],
-                outputs=[
-                    duration_display, 
-                    transcript_box,
-                    action_items_box,
-                    alerts_box,
-                    summary_box,
-                    status_text
-                ]
-            )
-            
-            # Sleep briefly to avoid excessive updates
-            time.sleep(0.5)
-    
-    # Start the auto-refresh thread
-    threading.Thread(target=auto_refresh, daemon=True).start()
-    
 if __name__ == "__main__":
     app.launch()