Update app.py

app.py

@@ -6,568 +6,407 @@ from moviepy.editor import VideoFileClip
 import whisper
 from openai import OpenAI
 import tempfile
-from scipy.signal import find_peaks
-import gc
 import warnings
 import re
 from contextlib import contextmanager
+import gc
+from concurrent.futures import ThreadPoolExecutor
+import pandas as pd
 
-class SimplifiedAudioAnalyzer:
-    def __init__(self, sr=4000, chunk_size=30):
-        self.sr = sr
-        self.chunk_size = chunk_size
-
+class LightweightAudioAnalyzer:
+    def __init__(self):
+        self.sr = 4000  # Reduced sample rate
+        self.hop_length = 1024  # Increased hop length for faster processing
+        self.n_fft = 2048
+        self.chunk_duration = 120  # Increased chunk size for fewer iterations
+        
+    def _process_chunk(self, audio_path, offset, chunk_duration):
+        """Process a single audio chunk"""
+        y, _ = librosa.load(
+            audio_path,
+            offset=offset,
+            duration=chunk_duration,
+            sr=self.sr,
+            mono=True
+        )
+        
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            stft = librosa.stft(y, n_fft=self.n_fft, hop_length=self.hop_length)
+            rms = librosa.feature.rms(S=np.abs(stft), hop_length=self.hop_length)[0]
+            
+            pitches, _ = librosa.piptrack(
+                S=np.abs(stft), 
+                sr=self.sr,
+                hop_length=self.hop_length,
+                fmin=50,
+                fmax=400
+            )
+            
+            chunk_data = {
+                'rms': rms,
+                'pitch': np.mean(pitches, axis=0)
+            }
+            
+            del y, stft, pitches
+            return chunk_data
+    
     def analyze_audio(self, audio_path):
-        """
-        Simplified audio analysis with key features extraction
+        """Parallel audio analysis with minimal memory usage"""
+        duration = librosa.get_duration(path=audio_path)
+        chunks = range(0, int(duration), self.chunk_duration)
+        
+        pitch_data = []
+        rms_data = []
         
-        Args:
-            audio_path (str): Path to the audio file
+        # Process chunks in parallel
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = []
+            for offset in chunks:
+                chunk_duration = min(self.chunk_duration, duration - offset)
+                futures.append(
+                    executor.submit(self._process_chunk, audio_path, offset, chunk_duration)
+                )
+            
+            # Collect results
+            for future in futures:
+                chunk_data = future.result()
+                rms_data.extend(chunk_data['rms'])
+                pitch_data.extend(chunk_data['pitch'])
         
-        Returns:
-            dict: Audio analysis metrics
-        """
-        # Load audio with minimal processing
-        y, _ = librosa.load(audio_path, sr=self.sr, mono=True)
+        # Calculate pause statistics
+        silence_threshold = np.mean(rms_data) * 0.1
+        silent_frames = np.array(rms_data) < silence_threshold
+        frame_time = self.hop_length / self.sr
         
-        # Basic features
-        rms = np.sqrt(np.mean(y**2))
-        f0 = librosa.yin(y, fmin=librosa.note_to_hz("C2"), fmax=librosa.note_to_hz("C6"))
+        pause_durations = []
+        current_pause = 0
+        for is_silent in silent_frames:
+            if is_silent:
+                current_pause += 1
+            elif current_pause > 0:
+                duration = current_pause * frame_time
+                if duration > 0.3:  # Only count pauses > 300ms
+                    pause_durations.append(duration)
+                current_pause = 0
         
-        # Pause detection
-        amplitude_envelope = np.abs(y)
-        silence_threshold = np.median(amplitude_envelope) * 0.5
-        peaks, _ = find_peaks(-amplitude_envelope, height=-silence_threshold)
-        pause_durations = np.diff(peaks) / self.sr
+        # Compile statistics
+        pitch_stats = {
+            "mean": float(np.nanmean(pitch_data)),
+            "std": float(np.nanstd(pitch_data)),
+            "range": float(np.nanpercentile(pitch_data, 95) - np.nanpercentile(pitch_data, 5))
+        }
         
-        # Pitch patterns
-        pitch_valid = f0[np.isfinite(f0)]
+        energy_stats = {
+            "mean": float(np.mean(rms_data)),
+            "std": float(np.std(rms_data)),
+            "range": float(np.percentile(rms_data, 95) - np.percentile(rms_data, 5))
+        }
+        
+        pause_stats = {
+            "total_pauses": len(pause_durations),
+            "mean_duration": float(np.mean(pause_durations)) if pause_durations else 0.0,
+            "pauses_per_minute": len(pause_durations) / (duration / 60)
+        }
         
         return {
-            "pitch_analysis": {
-                "statistics": {
-                    "mean": float(np.nanmean(pitch_valid)) if len(pitch_valid) > 0 else 0,
-                    "std": float(np.nanstd(pitch_valid)) if len(pitch_valid) > 0 else 0,
-                    "range": float(np.nanmax(pitch_valid) - np.nanmin(pitch_valid)) if len(pitch_valid) > 0 else 0
-                },
-                "patterns": {
-                    "rising_count": int(np.sum(np.diff(pitch_valid) > 0)),
-                    "falling_count": int(np.sum(np.diff(pitch_valid) < 0))
-                }
-            },
-            "rhythm_analysis": {
-                "pause_stats": {
-                    "total_pauses": len(peaks),
-                    "mean_pause_duration": float(np.mean(pause_durations)) if len(pause_durations) > 0 else 0
-                }
-            },
-            "energy_dynamics": {
-                "rms_energy_mean": float(rms),
-                "rms_energy_std": float(np.std(y)),
-                "energy_range": float(np.percentile(y, 95) - np.percentile(y, 5))
-            },
-            "spectral_centroid_mean": float(librosa.feature.spectral_centroid(y=y, sr=self.sr)[0].mean())
+            "pitch_analysis": {"statistics": pitch_stats},
+            "energy_dynamics": energy_stats,
+            "pause_analysis": pause_stats
         }
 
-class CPUMentorEvaluator:
+class OptimizedMentorEvaluator:
     def __init__(self):
-        """Initialize the evaluator for CPU usage."""
-        self.api_key = st.secrets.get("OPENAI_API_KEY")
-        if not self.api_key:
-            raise ValueError("OpenAI API key not found in secrets")
-        
+        self.api_key = st.secrets["OPENAI_API_KEY"]
         self.client = OpenAI(api_key=self.api_key)
         self.whisper_model = None
-
-    def _clear_memory(self):
-        """Clear memory and run garbage collection."""
-        if hasattr(self, 'whisper_model') and self.whisper_model is not None:
-            del self.whisper_model
-            self.whisper_model = None
-        gc.collect()
-
-    @contextmanager
-    def load_whisper_model(self):
-        """Load Whisper model with proper memory management."""
-        try:
-            self._clear_memory()
-            self.whisper_model = whisper.load_model("tiny", device="cpu")
-            yield self.whisper_model
-        finally:
-            if self.whisper_model is not None:
-                del self.whisper_model
-                self.whisper_model = None
-            gc.collect()
-
+    
     def extract_audio(self, video_path):
-        """Extract audio from video file with optimized settings."""
-        temp_audio = None
-        video = None
+        """Optimized audio extraction"""
+        temp_audio = tempfile.NamedTemporaryFile(delete=False, suffix='.wav')
         try:
-            self._clear_memory()
-            temp_audio = tempfile.NamedTemporaryFile(delete=False, suffix='.wav')
-            video = VideoFileClip(video_path, audio=True, target_resolution=(360,None), verbose=False)
-            video.audio.write_audiofile(temp_audio.name, fps=8000, verbose=False, logger=None)
+            video = VideoFileClip(
+                video_path,
+                audio=True,
+                target_resolution=(240, None),
+                fps_source="tbr"
+            )
+            video.audio.write_audiofile(
+                temp_audio.name,
+                fps=8000,
+                nbytes=2,
+                codec='pcm_s16le',
+                verbose=False,
+                logger=None
+            )
+            video.close()
             return temp_audio.name
         except Exception as e:
-            if temp_audio and os.path.exists(temp_audio.name):
+            if os.path.exists(temp_audio.name):
                 os.unlink(temp_audio.name)
-            raise Exception(f"Audio extraction failed: {str(e)}")
-        finally:
-            if video:
-                video.close()
-            self._clear_memory()
+            raise e
 
-    def analyze_audio_features(self, audio_path):
-        """Simplified audio features analysis."""
-        analyzer = SimplifiedAudioAnalyzer()
-        return analyzer.analyze_audio(audio_path)
+    def transcribe_audio(self, audio_path):
+        """Optimized transcription"""
+        try:
+            model = whisper.load_model("tiny", device="cpu")
+            result = model.transcribe(
+                audio_path,
+                fp16=False,
+                language="en",
+                task="transcribe",
+                beam_size=3
+            )
+            return result["text"]
+        finally:
+            del model
+            gc.collect()
 
-    def calculate_speech_metrics(self, transcript, audio_duration):
-        """Calculate words per minute and other speech metrics."""
+    def _analyze_speaking_patterns(self, transcript):
+        """Analyze speaking patterns and filler words"""
+        filler_words = len(re.findall(r'\b(um|uh|like|you know|basically)\b', transcript.lower()))
         words = len(transcript.split())
-        minutes = audio_duration / 60
+        
         return {
-            'words_per_minute': words / minutes if minutes > 0 else 0,
-            'total_words': words,
-            'duration_minutes': minutes
+            "filler_word_count": filler_words,
+            "total_words": words,
+            "filler_word_rate": filler_words / words if words > 0 else 0
         }
 
-    def _analyze_voice_quality(self, transcript, audio_features):
-        """Analyze voice quality with simplified GPT-4o-mini interaction."""
+    def analyze_content(self, transcript):
+        """Comprehensive content analysis"""
         try:
-            prompt = f"""Analyze the following voice metrics for teaching quality:
-Transcript excerpt: {transcript[:]}...
-Voice Metrics:
-- Pitch Mean: {audio_features['pitch_analysis']['statistics']['mean']:.1f}Hz
-- Pitch Variation: {audio_features['pitch_analysis']['statistics']['std']:.1f}Hz
-- Energy Dynamics: {audio_features['energy_dynamics']['rms_energy_mean']:.2f}
-Evaluate voice quality focusing on:
-1. Clarity and projection
-2. Emotional engagement
-3. Professional tone
-"""
-            response = self.client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {"role": "system", "content": "You are an expert in voice analysis."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=500
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            return f"Voice quality analysis failed: {str(e)}"
+            prompt = f"""Analyze this teaching transcript (3 sentences max for each category):
+1. Content Clarity (0-1):
+2. Examples Usage (0-1):
+3. Technical Accuracy (0-1):
+4. Areas for Improvement:
 
-    def _analyze_teaching_content(self, transcript):
-        """Analyze teaching content for accuracy, principles, and examples."""
-        try:
-            prompt = f"""Analyze this teaching transcript for:
-1. Subject Matter Accuracy:
-  - Identify any factual errors, wrong assumptions, or incorrect correlations
-  - Rate accuracy on a scale of 0-1
-2. First Principles Approach:
-  - Evaluate if concepts are built from fundamentals before introducing technical terms
-  - Rate approach on a scale of 0-1
-3. Examples and Business Context:
-  - Assess use of business examples and practical context
-  - Rate contextual relevance on a scale of 0-1
-Transcript: {transcript}...
-Provide specific citations for any identified issues.
-"""
-            response = self.client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {"role": "system", "content": "You are an expert in pedagogical assessment."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=500
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            return f"Teaching content analysis failed: {str(e)}"
+Transcript: {transcript[:2000]}..."""
 
-    def _analyze_code_explanation(self, transcript):
-        """Analyze code explanation quality."""
-        try:
-            prompt = f"""Analyze the code explanation in this transcript for:
-1. Depth of Explanation:
-  - Evaluate coverage of syntax, libraries, functions, and methods
-  - Rate depth on a scale of 0-1
-2. Output Interpretation:
-  - Assess business context interpretation of results
-  - Rate interpretation on a scale of 0-1
-3. Complexity Breakdown:
-  - Evaluate explanation of code modules and logical flow
-  - Rate breakdown quality on a scale of 0-1
-Transcript: {transcript}...
-Provide specific citations for any identified issues.
-"""
             response = self.client.chat.completions.create(
-                model="gpt-4o-mini",
+                model="gpt-3.5-turbo",
                 messages=[
-                    {"role": "system", "content": "You are an expert in code review and teaching."},
+                    {"role": "system", "content": "You are a teaching expert. Be concise."},
                     {"role": "user", "content": prompt}
                 ],
-                max_tokens=500
+                max_tokens=300,
+                temperature=0.7
             )
             return response.choices[0].message.content
         except Exception as e:
-            return f"Code explanation analysis failed: {str(e)}"
+            return f"Analysis failed: {str(e)}"
 
-    def generate_enhanced_report(self, video_path):
-        """Generate structured evaluation report."""
+    def generate_report(self, video_path):
+        """Generate comprehensive report"""
         audio_path = None
         try:
+            # Extract and analyze audio
             audio_path = self.extract_audio(video_path)
-
-            with self.load_whisper_model() as model:
-                result = model.transcribe(audio_path)
-                transcript = result["text"]
-
-            audio_features = self.analyze_audio_features(audio_path)
-            audio_duration = librosa.get_duration(path=audio_path)
-            speech_metrics = self.calculate_speech_metrics(transcript, audio_duration)
-
-            wpm = speech_metrics['words_per_minute']
-            wpm_score = 1 if 120 <= wpm <= 160 else 0
-
-            filler_words = len(re.findall(r'\b(um|uh|like|you know|basically)\b', transcript.lower()))
-            fpm = (filler_words / speech_metrics['duration_minutes'])
-
-            ppm = audio_features['rhythm_analysis']['pause_stats']['total_pauses'] / speech_metrics['duration_minutes']
-            pause_score = 1 if 2 <= ppm <= 8 else 0
-
-            energy_values = audio_features['energy_dynamics']
-            energy_summary = {
-                'min': np.percentile([energy_values['rms_energy_mean']], 0),
-                'q1': np.percentile([energy_values['rms_energy_mean']], 25),
-                'median': np.percentile([energy_values['rms_energy_mean']], 50),
-                'q3': np.percentile([energy_values['rms_energy_mean']], 75),
-                'max': np.percentile([energy_values['rms_energy_mean']], 100)
+            analyzer = LightweightAudioAnalyzer()
+            
+            with st.status("Analyzing audio..."):
+                audio_features = analyzer.analyze_audio(audio_path)
+            
+            with st.status("Transcribing speech..."):
+                transcript = self.transcribe_audio(audio_path)
+            
+            # Calculate metrics
+            duration = librosa.get_duration(path=audio_path)
+            speaking_patterns = self._analyze_speaking_patterns(transcript)
+            wpm = (speaking_patterns["total_words"] / duration) * 60
+            
+            with st.status("Analyzing content..."):
+                content_analysis = self.analyze_content(transcript)
+            
+            # Compile report
+            report = {
+                "speech_metrics": {
+                    "wpm": wpm,
+                    "duration_minutes": duration / 60,
+                    "total_words": speaking_patterns["total_words"],
+                    "filler_word_rate": speaking_patterns["filler_word_rate"]
+                },
+                "audio_analysis": audio_features,
+                "content_analysis": content_analysis,
+                "transcript": transcript
             }
-
-            teaching_analysis = self._analyze_teaching_content(transcript)
-            code_analysis = self._analyze_code_explanation(transcript)
-            voice_quality = self._analyze_voice_quality(transcript, audio_features)
-
-            intonation_score = 1 if (audio_features['pitch_analysis']['patterns']['rising_count'] +
-                                   audio_features['pitch_analysis']['patterns']['falling_count']) / speech_metrics['duration_minutes'] > 5 else 0
-
-            energy_score = 1 if (energy_values['rms_energy_std'] / energy_values['rms_energy_mean']) > 0.2 else 0
-
-            report = f"""REPORT
-1. COMMUNICATION
-    1. Speech Speed:
-        - Words per Minute: {wpm:.1f}
-        - Score: {wpm_score} (Acceptable range: 120-160 WPM)
-    2. Voice Quality:
-        {voice_quality}
-    3. Fluency:
-        - Fillers per Minute: {fpm:.1f}
-        - Score: {1 if fpm < 3 else 0}
-    4. Break/Flow:
-        - Pauses per Minute: {ppm:.1f}
-        - Score: {pause_score}
-    5. Intonation:
-        - Rising patterns: {audio_features['pitch_analysis']['patterns']['rising_count']}
-        - Falling patterns: {audio_features['pitch_analysis']['patterns']['falling_count']}
-        - Score: {intonation_score}
-    6. Energy:
-        Five-point summary:
-        - Min: {energy_summary['min']:.2f}
-        - Q1: {energy_summary['q1']:.2f}
-        - Median: {energy_summary['median']:.2f}
-        - Q3: {energy_summary['q3']:.2f}
-        - Max: {energy_summary['max']:.2f}
-        - Score: {energy_score}
-2. TEACHING
-    1. Content Analysis:
-        {teaching_analysis}
-    2. Code Explanation:
-        {code_analysis}
-Full Transcript:
-{transcript}
-"""
+            
             return report
 
-        except Exception as e:
-            raise Exception(f"Report generation failed: {str(e)}")
         finally:
             if audio_path and os.path.exists(audio_path):
                 os.unlink(audio_path)
-            self._clear_memory()
+            gc.collect()
 
-def create_temp_directory():
-    """Create a temporary directory for file processing."""
-    temp_dir = tempfile.mkdtemp()
-    return temp_dir
+def create_metrics_display(metrics):
+    """Create formatted metrics display"""
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric(
+            "Speaking Rate",
+            f"{metrics['speech_metrics']['wpm']:.1f} WPM",
+            delta="Good" if 120 <= metrics['speech_metrics']['wpm'] <= 160 else "Review",
+            delta_color="normal"
+        )
+    
+    with col2:
+        filler_rate = metrics['speech_metrics']['filler_word_rate'] * 100
+        st.metric(
+            "Filler Words",
+            f"{filler_rate:.1f}%",
+            delta="Good" if filler_rate < 5 else "Review",
+            delta_color="normal"
+        )
+    
+    with col3:
+        pauses = metrics['audio_analysis']['pause_analysis']['pauses_per_minute']
+        st.metric(
+            "Pauses/Minute",
+            f"{pauses:.1f}",
+            delta="Good" if 2 <= pauses <= 8 else "Review",
+            delta_color="normal"
+        )
+
+def create_downloadable_report(metrics):
+    """Create formatted report for download"""
+    report = f"""MENTOR DEMO ANALYSIS REPORT
+Generated on: {pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+1. SPEECH METRICS
+----------------
+Speaking Rate: {metrics['speech_metrics']['wpm']:.1f} WPM
+Duration: {metrics['speech_metrics']['duration_minutes']:.1f} minutes
+Total Words: {metrics['speech_metrics']['total_words']}
+Filler Word Rate: {metrics['speech_metrics']['filler_word_rate']*100:.1f}%
+
+2. AUDIO ANALYSIS
+----------------
+Pitch Statistics:
+- Mean: {metrics['audio_analysis']['pitch_analysis']['statistics']['mean']:.1f} Hz
+- Variation: {metrics['audio_analysis']['pitch_analysis']['statistics']['std']:.1f} Hz
+
+Energy Dynamics:
+- Mean: {metrics['audio_analysis']['energy_dynamics']['mean']:.2f}
+- Variation: {metrics['audio_analysis']['energy_dynamics']['std']:.2f}
+
+Pause Analysis:
+- Total Pauses: {metrics['audio_analysis']['pause_analysis']['total_pauses']}
+- Average Duration: {metrics['audio_analysis']['pause_analysis']['mean_duration']:.2f}s
+- Pauses per Minute: {metrics['audio_analysis']['pause_analysis']['pauses_per_minute']:.1f}
+
+3. CONTENT ANALYSIS
+-----------------
+{metrics['content_analysis']}
+
+4. TRANSCRIPT
+-----------
+{metrics['transcript']}
+"""
+    return report
 
 def main():
-    st.set_page_config(
-        page_title="Mentor Demo Review Tool",
-        page_icon="🎓",
-        layout="wide"
-    )
-
-    # Custom CSS for better styling
+    st.set_page_config(page_title="Mentor Review Tool", layout="wide")
+    
+    # Custom CSS
     st.markdown("""
         <style>
-        .metric-value {
-            font-size: 24px;
-            font-weight: bold;
-            color: #1f77b4;
-        }
-        .metric-label {
-            font-size: 14px;
-            color: #666;
-        }
-        .section-card {
-            background-color: white;
-            padding: 20px;
-            border-radius: 10px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-            margin-bottom: 20px;
-        }
-        .score-good { color: #28a745; }
-        .score-warning { color: #ffc107; }
-        .score-poor { color: #dc3545; }
-        .analysis-section {
-            margin-top: 20px;
-            padding: 15px;
-            border-left: 3px solid #1f77b4;
-            background-color: #f8f9fa;
-        }
+        .metric-value { font-size: 24px; font-weight: bold; color: #1f77b4; }
+        .metric-label { font-size: 14px; color: #666; }
+        .stTabs > div > div { padding-top: 20px; }
         </style>
     """, unsafe_allow_html=True)
-
+    
     st.title("🎓 Mentor Demo Review Tool")
-
-    # Sidebar with instructions
+    
+    # Sidebar
     with st.sidebar:
         st.header("Instructions")
         st.markdown("""
         1. Upload your teaching video
-        2. Wait for analysis to complete
-        3. Review the detailed feedback
-        4. Download the full report
+        2. Wait for analysis (~5-10 minutes)
+        3. Review the feedback
+        4. Download the report
         
         **Supported Formats:**
         - MP4
         - AVI
         - MOV
-        - MKV
-        
-        **Analysis Includes:**
-        - Speech metrics
-        - Teaching quality
-        - Voice analysis
-        - Content evaluation
         """)
         
         st.markdown("---")
-        st.markdown("### Privacy Note")
-        st.info("Videos are processed securely and deleted immediately after analysis.")
-
-    # Main content
-    uploaded_file = st.file_uploader("Upload your teaching video", type=['mp4', 'avi', 'mov', 'mkv'])
-
+        st.markdown("### Processing Time")
+        st.info("Analysis typically takes 5-10 minutes for a 15-minute video.")
+    
+    uploaded_file = st.file_uploader("Upload your teaching video", type=['mp4', 'avi', 'mov'])
+    
     if uploaded_file:
         try:
-            if not st.session_state.get('analysis_complete', False):
-                with st.status("Analyzing video...", expanded=True) as status:
-                    st.write("Saving video file...")
-                    temp_dir = create_temp_directory()
-                    temp_video_path = os.path.join(temp_dir, uploaded_file.name)
-                    
-                    with open(temp_video_path, 'wb') as f:
-                        f.write(uploaded_file.getbuffer())
-
-                    st.write("Initializing analysis...")
-                    evaluator = CPUMentorEvaluator()
-                    
-                    st.write("Generating report...")
-                    report = evaluator.generate_enhanced_report(temp_video_path)
-                    st.session_state.report_data = report
-                    st.session_state.analysis_complete = True
-                    
-                    status.update(label="Analysis complete!", state="complete", expanded=False)
-
-            if st.session_state.get('analysis_complete', False):
-                report = st.session_state.report_data
+            with st.spinner("Processing video..."):
+                # Save uploaded file
+                temp_dir = tempfile.mkdtemp()
+                temp_video_path = os.path.join(temp_dir, uploaded_file.name)
                 
-                # Create tabs for organized display
-                comm_tab, teach_tab, trans_tab = st.tabs([
-                    "📊 Communication Analysis", 
-                    "📝 Teaching Evaluation", 
-                    "📄 Transcript"
-                ])
+                with open(temp_video_path, 'wb') as f:
+                    f.write(uploaded_file.getbuffer())
                 
-                with comm_tab:
-                    st.markdown("## 🎯 Communication Analysis")
-                    
-                    # Speech Metrics Section
-                    st.markdown("### Speech Metrics")
-                    col1, col2, col3 = st.columns(3)
-                    
-                    # Extract and display all communication metrics
-                    speech_section = re.search(r"1\. COMMUNICATION(.*?)2\. TEACHING", report, re.DOTALL)
-                    if speech_section:
-                        speech_text = speech_section.group(1)
-                        
-                        # Speech Speed
-                        wpm_match = re.search(r"Words per Minute: (\d+\.?\d*)", speech_text)
-                        if wpm_match:
-                            wpm = float(wpm_match.group(1))
-                            with col1:
-                                st.markdown("#### Speech Speed")
-                                color = "good" if 120 <= wpm <= 160 else "warning"
-                                st.markdown(f'<div class="metric-value score-{color}">{wpm:.1f} WPM</div>', unsafe_allow_html=True)
-                                st.markdown('<div class="metric-label">Target: 120-160 WPM</div>', unsafe_allow_html=True)
-                        
-                        # Fluency
-                        fpm_match = re.search(r"Fillers per Minute: (\d+\.?\d*)", speech_text)
-                        if fpm_match:
-                            fpm = float(fpm_match.group(1))
-                            with col2:
-                                st.markdown("#### Fluency")
-                                color = "good" if fpm < 3 else "poor"
-                                st.markdown(f'<div class="metric-value score-{color}">{fpm:.1f} FPM</div>', unsafe_allow_html=True)
-                                st.markdown('<div class="metric-label">Fillers per Minute</div>', unsafe_allow_html=True)
-                        
-                        # Pauses
-                        ppm_match = re.search(r"Pauses per Minute: (\d+\.?\d*)", speech_text)
-                        if ppm_match:
-                            ppm = float(ppm_match.group(1))
-                            with col3:
-                                st.markdown("#### Strategic Pauses")
-                                color = "good" if 2 <= ppm <= 8 else "warning"
-                                st.markdown(f'<div class="metric-value score-{color}">{ppm:.1f} PPM</div>', unsafe_allow_html=True)
-                                st.markdown('<div class="metric-label">Pauses per Minute</div>', unsafe_allow_html=True)
-
-                    # Voice Quality Analysis
-                    st.markdown("### 🎤 Voice Quality Analysis")
-                    voice_section = re.search(r"Voice Quality:(.*?)3\. Fluency:", report, re.DOTALL)
-                    if voice_section:
-                        with st.expander("Detailed Voice Analysis", expanded=True):
-                            st.markdown(voice_section.group(1).strip())
-                    
-                    # Intonation Analysis
-                    st.markdown("### 📈 Intonation Patterns")
-                    intonation_section = re.search(r"5\. Intonation:(.*?)6\. Energy:", report, re.DOTALL)
-                    if intonation_section:
-                        with st.expander("Intonation Analysis", expanded=True):
-                            st.markdown(intonation_section.group(1).strip())
-                    
-                    # Energy Analysis
-                    st.markdown("### ⚡ Energy Profile")
-                    energy_section = re.search(r"6\. Energy:(.*?)2\. TEACHING", report, re.DOTALL)
-                    if energy_section:
-                        with st.expander("Energy Analysis", expanded=True):
-                            st.markdown(energy_section.group(1).strip())
+                # Generate report
+                evaluator = OptimizedMentorEvaluator()
+                metrics = evaluator.generate_report(temp_video_path)
+                
+                # Display results
+                st.success("Analysis complete!")
+                
+                # Create tabs for organization
+                tabs = st.tabs(["📊 Metrics", "🎙️ Audio Analysis", "📝 Content", "📄 Transcript"])
                 
-                with teach_tab:
-                    st.markdown("## 📚 Teaching Analysis")
+                with tabs[0]:
+                    st.header("Key Metrics")
+                    create_metrics_display(metrics)
+                
+                with tabs[1]:
+                    st.header("Audio Analysis")
+                    col1, col2 = st.columns(2)
                     
-                    # Content Analysis
-                    st.markdown("### Content Analysis")
-                    content_section = re.search(r"Content Analysis:(.*?)Code Explanation:", report, re.DOTALL)
-                    if content_section:
-                        with st.expander("Detailed Content Analysis", expanded=True):
-                            content_analysis = content_section.group(1).strip()
-                            
-                            # Parse and display scores
-                            accuracy_score = re.search(r"Rate accuracy.*?(\d+\.?\d*)", content_analysis)
-                            principles_score = re.search(r"Rate approach.*?(\d+\.?\d*)", content_analysis)
-                            context_score = re.search(r"Rate contextual.*?(\d+\.?\d*)", content_analysis)
-                            
-                            col1, col2, col3 = st.columns(3)
-                            if accuracy_score:
-                                with col1:
-                                    score = float(accuracy_score.group(1))
-                                    color = "good" if score >= 0.8 else "warning" if score >= 0.6 else "poor"
-                                    st.markdown("#### Content Accuracy")
-                                    st.markdown(f'<div class="metric-value score-{color}">{score:.2f}</div>', unsafe_allow_html=True)
-                            
-                            if principles_score:
-                                with col2:
-                                    score = float(principles_score.group(1))
-                                    color = "good" if score >= 0.8 else "warning" if score >= 0.6 else "poor"
-                                    st.markdown("#### First Principles")
-                                    st.markdown(f'<div class="metric-value score-{color}">{score:.2f}</div>', unsafe_allow_html=True)
-                            
-                            if context_score:
-                                with col3:
-                                    score = float(context_score.group(1))
-                                    color = "good" if score >= 0.8 else "warning" if score >= 0.6 else "poor"
-                                    st.markdown("#### Business Context")
-                                    st.markdown(f'<div class="metric-value score-{color}">{score:.2f}</div>', unsafe_allow_html=True)
-                            
-                            st.markdown("#### Detailed Analysis")
-                            st.markdown(content_analysis)
+                    with col1:
+                        st.subheader("Pitch Analysis")
+                        pitch_stats = metrics['audio_analysis']['pitch_analysis']['statistics']
+                        st.write(f"Mean Pitch: {pitch_stats['mean']:.1f} Hz")
+                        st.write(f"Pitch Variation: {pitch_stats['std']:.1f} Hz")
                     
-                    # Code Explanation Analysis
-                    st.markdown("### 💻 Code Explanation Quality")
-                    code_section = re.search(r"Code Explanation:(.*?)Full Transcript:", report, re.DOTALL)
-                    if code_section:
-                        with st.expander("Code Teaching Analysis", expanded=True):
-                            code_analysis = code_section.group(1).strip()
-                            
-                            # Parse and display scores
-                            depth_score = re.search(r"Rate depth.*?(\d+\.?\d*)", code_analysis)
-                            interpretation_score = re.search(r"Rate interpretation.*?(\d+\.?\d*)", code_analysis)
-                            breakdown_score = re.search(r"Rate breakdown.*?(\d+\.?\d*)", code_analysis)
-                            
-                            col1, col2, col3 = st.columns(3)
-                            if depth_score:
-                                with col1:
-                                    score = float(depth_score.group(1))
-                                    color = "good" if score >= 0.8 else "warning" if score >= 0.6 else "poor"
-                                    st.markdown("#### Explanation Depth")
-                                    st.markdown(f'<div class="metric-value score-{color}">{score:.2f}</div>', unsafe_allow_html=True)
-                            
-                            if interpretation_score:
-                                with col2:
-                                    score = float(interpretation_score.group(1))
-                                    color = "good" if score >= 0.8 else "warning" if score >= 0.6 else "poor"
-                                    st.markdown("#### Output Interpretation")
-                                    st.markdown(f'<div class="metric-value score-{color}">{score:.2f}</div>', unsafe_allow_html=True)
-                            
-                            if breakdown_score:
-                                with col3:
-                                    score = float(breakdown_score.group(1))
-                                    color = "good" if score >= 0.8 else "warning" if score >= 0.6 else "poor"
-                                    st.markdown("#### Complexity Breakdown")
-                                    st.markdown(f'<div class="metric-value score-{color}">{score:.2f}</div>', unsafe_allow_html=True)
-                            
-                            st.markdown("#### Detailed Analysis")
-                            st.markdown(code_analysis)
+                    with col2:
+                        st.subheader("Energy Analysis")
+                        energy_stats = metrics['audio_analysis']['energy_dynamics']
+                        st.write(f"Mean Energy: {energy_stats['mean']:.2f}")
+                        st.write(f"Energy Variation: {energy_stats['std']:.2f}")
+                
+                with tabs[2]:
+                    st.header("Content Analysis")
+                    st.write(metrics['content_analysis'])
                 
-                with trans_tab:
-                    st.markdown("## 📝 Full Transcript")
-                    transcript_section = re.search(r"Full Transcript:(.*?)(?=\Z)", report, re.DOTALL)
-                    if transcript_section:
-                        st.markdown(transcript_section.group(1).strip())
+                with tabs[3]:
+                    st.header("Transcript")
+                    st.write(metrics['transcript'])
                 
                 # Download button
+                report = create_downloadable_report(metrics)
                 st.download_button(
-                    label="📥 Download Full Report",
-                    data=report,
-                    file_name="mentor_analysis_report.txt",
-                    mime="text/plain",
-                    help="Download the complete analysis report including all metrics and recommendations"
+                    "📥 Download Full Report",
+                    report,
+                    "mentor_analysis_report.txt",
+                    "text/plain"
                 )
-
+                
         except Exception as e:
-            st.error(f"An error occurred during analysis: {str(e)}")
-            st.error("Please try uploading the video again or contact support if the issue persists.")
-
+            st.error(f"Error: {str(e)}")
+            
         finally:
             # Cleanup
-            if 'temp_dir' in locals() and os.path.exists(temp_dir):
+            if 'temp_dir' in locals():
                 import shutil
                 shutil.rmtree(temp_dir)
             gc.collect()
 
 if __name__ == "__main__":
-    main()
+    main()