Update app.py

app.py

@@ -25,7 +25,6 @@ import sys
 import multiprocessing
 import concurrent.futures
 import hashlib
-import plotly.express as px
 
 # Set up logging
 logging.basicConfig(
@@ -292,12 +291,9 @@ class ContentAnalyzer:
                 if progress_callback:
                     progress_callback(0.2, "Preparing content analysis...")
                 
-                # Extract transcript text from transcript data structure
-                transcript_text = transcript.get("transcript", "") if isinstance(transcript, dict) else transcript
-                
                 # Remove any truncation of transcript - pass full text to API
-                prompt = self._create_analysis_prompt(transcript_text)
-                logger.info(f"Sending full transcript of length: {len(transcript_text)} characters")
+                prompt = self._create_analysis_prompt(transcript)
+                logger.info(f"Sending full transcript of length: {len(transcript)} characters")
                 
                 if progress_callback:
                     progress_callback(0.5, "Processing with AI model...")
@@ -535,40 +531,37 @@ Important:
 
     def _evaluate_speech_metrics(self, transcript: str, audio_features: Dict[str, float], 
                            progress_callback=None) -> Dict[str, Any]:
-        """Evaluate speech metrics with stricter error thresholds"""
+        """Evaluate speech metrics with improved accuracy"""
         try:
             if progress_callback:
                 progress_callback(0.2, "Calculating speech metrics...")
 
-            # Extract transcript text from transcript data structure
-            transcript_text = transcript.get("transcript", "") if isinstance(transcript, dict) else transcript
-            
             # Calculate words and duration
-            words = len(transcript_text.split())
+            words = len(transcript.split())
             duration_minutes = float(audio_features.get('duration', 0)) / 60
             
-            # Calculate words per minute (130-160 WPM is ideal for teaching)
+            # Calculate words per minute with updated range (130-160 WPM is ideal for teaching)
             words_per_minute = float(words / duration_minutes if duration_minutes > 0 else 0)
             
-            # Stricter filler word detection (max 1-2 per minute is acceptable)
+            # Improved filler word detection (2-3 per minute is acceptable)
             filler_words = re.findall(r'\b(um|uh|like|you\s+know|basically|actually|literally)\b', 
-                                    transcript_text.lower())
+                                    transcript.lower())
             fillers_count = len(filler_words)
             fillers_per_minute = float(fillers_count / duration_minutes if duration_minutes > 0 else 0)
             
-            # Stricter error detection (max 1 per minute is acceptable)
-            repeated_words = len(re.findall(r'\b(\w+)\s+\1\b', transcript_text.lower()))
-            incomplete_sentences = len(re.findall(r'[a-zA-Z]+\s*\.\.\.|\b[a-zA-Z]+\s*-\s+', transcript_text))
+            # Improved error detection (1-2 per minute is acceptable)
+            repeated_words = len(re.findall(r'\b(\w+)\s+\1\b', transcript.lower()))
+            incomplete_sentences = len(re.findall(r'[a-zA-Z]+\s*\.\.\.|\b[a-zA-Z]+\s*-\s+', transcript))
             errors_count = repeated_words + incomplete_sentences
             errors_per_minute = float(errors_count / duration_minutes if duration_minutes > 0 else 0)
 
-            # Updated stricter thresholds
-            max_errors = 1.0  # Reduced from 2.0
-            max_fillers = 2.0  # Reduced from 3.0
-            threshold_explanation = "Using strict thresholds for professional teaching"
+            # Set default thresholds if analysis fails
+            max_errors = 2.0
+            max_fillers = 3.0
+            threshold_explanation = "Using standard thresholds"
             grammatical_errors = []
 
-            # Calculate fluency score based on stricter thresholds
+            # Calculate fluency score based on both errors and fillers
             fluency_score = 1 if (errors_per_minute <= max_errors and fillers_per_minute <= max_fillers) else 0
             
             return {
@@ -579,7 +572,7 @@ Important:
                     "duration_minutes": duration_minutes
                 },
                 "fluency": {
-                    "score": fluency_score,
+                    "score": fluency_score,  # Add explicit fluency score
                     "errorsPerMin": errors_per_minute,
                     "fillersPerMin": fillers_per_minute,
                     "maxErrorsThreshold": max_errors,
@@ -1069,8 +1062,8 @@ class MentorEvaluator:
                 progress.empty()
             raise RuntimeError(f"Analysis failed: {str(e)}")
 
-    def _transcribe_audio(self, audio_path: str, progress_callback=None) -> Dict[str, Any]:
-        """Transcribe audio with accent detection and detailed progress tracking"""
+    def _transcribe_audio(self, audio_path: str, progress_callback=None) -> str:
+        """Transcribe audio with optimized segment detection and detailed progress tracking"""
         try:
             if progress_callback:
                 progress_callback(0.1, "Loading transcription model...")
@@ -1107,7 +1100,7 @@ class MentorEvaluator:
             # Initialize model with optimized settings and proper error handling
             try:
                 model = WhisperModel(
-                    "small",  # Using larger model for better accent detection
+                    "small",
                     device=device,
                     compute_type=compute_type,
                     download_root=self.model_cache_dir,
@@ -1120,14 +1113,14 @@ class MentorEvaluator:
                 raise RuntimeError(f"Failed to initialize transcription model: {str(e)}")
 
             if progress_callback:
-                progress_callback(0.3, "Starting transcription and accent analysis...")
+                progress_callback(0.3, "Starting transcription...")
 
             # Get audio duration for progress calculation
             total_duration = audio_info.duration
 
-            # Transcribe with accent detection
+            # Transcribe with optimized VAD settings and error handling
             try:
-                segments, info = model.transcribe(
+                segments, _ = model.transcribe(
                     audio_path,
                     beam_size=5,
                     word_timestamps=True,
@@ -1138,14 +1131,8 @@ class MentorEvaluator:
                         threshold=0.3,
                         min_speech_duration_ms=250
                     ),
-                    language='en',
-                    task='transcribe'
+                    language='en'
                 )
-                
-                # Perform accent classification
-                accent_probs = self._classify_accent(model, audio_path)
-                detected_accent = max(accent_probs.items(), key=lambda x: x[1])
-                
             except Exception as e:
                 logger.error(f"Error during transcription: {e}")
                 raise RuntimeError(f"Transcription failed: {str(e)}")
@@ -1187,23 +1174,13 @@ class MentorEvaluator:
             if not transcript.strip():
                 raise ValueError("Transcription produced empty result")
 
-            # Prepare result with accent information
-            result = {
-                "transcript": transcript,
-                "accent_analysis": {
-                    "detected_accent": detected_accent[0],
-                    "confidence": detected_accent[1],
-                    "accent_probabilities": accent_probs
-                }
-            }
-
             # Cache the result
-            st.session_state[cache_key] = result
+            st.session_state[cache_key] = transcript
 
             if progress_callback:
-                progress_callback(1.0, "Transcription and accent analysis complete!")
+                progress_callback(1.0, "Transcription complete!")
 
-            return result
+            return transcript
 
         except Exception as e:
             logger.error(f"Error in transcription: {e}")
@@ -1211,152 +1188,6 @@ class MentorEvaluator:
                 progress_callback(1.0, "Error in transcription", str(e))
             raise
 
-    def _classify_accent(self, model: WhisperModel, audio_path: str) -> Dict[str, float]:
-        """Classify accent using both acoustic features and Whisper ASR confidence"""
-        try:
-            # Load audio once and limit duration for faster processing
-            audio, sr = librosa.load(audio_path, sr=16000, duration=30)
-            
-            # 1. Get Whisper ASR confidence scores for different English accents
-            whisper_scores = {}
-            accent_langs = {
-                "Indian": "en",
-                "American": "en",
-                "British": "en-GB",
-                "Australian": "en-AU"
-            }
-            
-            # Run Whisper inference once with language detection
-            segments, info = model.transcribe(
-                audio_path,
-                language=None,  # Let Whisper detect language
-                beam_size=3,
-                word_timestamps=False,  # Disable for speed
-                condition_on_previous_text=False,
-                vad_filter=True,
-                vad_parameters=dict(
-                    min_silence_duration_ms=500,
-                    threshold=0.3
-                )
-            )
-            
-            # Get language confidence from Whisper
-            detected_language = info.language
-            language_probability = info.language_probability
-            
-            # Assign scores based on detected language
-            for accent, lang_code in accent_langs.items():
-                if lang_code == detected_language:
-                    whisper_scores[accent] = float(language_probability)
-                else:
-                    # Give other English variants a smaller baseline score
-                    whisper_scores[accent] = float(language_probability * 0.5)
-            
-            # 2. Extract key acoustic features
-            features = {}
-            
-            # Pitch features using faster implementation
-            hop_length = 512
-            f0, voiced_flag, _ = librosa.pyin(
-                audio,
-                sr=sr,
-                fmin=70,
-                fmax=400,
-                frame_length=2048,
-                hop_length=hop_length,
-                fill_na=0.0
-            )
-            
-            valid_f0 = f0[voiced_flag == 1]
-            features['pitch_mean'] = float(np.mean(valid_f0)) if len(valid_f0) > 0 else 0.0
-            features['pitch_std'] = float(np.std(valid_f0)) if len(valid_f0) > 0 else 0.0
-            
-            # Rhythm features using window='hann' instead of hamming
-            onset_env = librosa.onset.onset_strength(
-                y=audio, 
-                sr=sr,
-                hop_length=hop_length,
-                window='hann'  # Changed from 'hamming' to 'hann'
-            )
-            tempo, _ = librosa.beat.beat_track(
-                onset_envelope=onset_env,
-                sr=sr,
-                hop_length=hop_length
-            )
-            features['rhythm_regularity'] = float(tempo)
-            
-            # Efficient spectral feature extraction with hann window
-            mfcc = librosa.feature.mfcc(
-                y=audio, 
-                sr=sr, 
-                n_mfcc=13,
-                hop_length=hop_length,
-                window='hann'  # Changed from 'hamming' to 'hann'
-            )
-            features['spectral_variance'] = float(np.mean(np.std(mfcc, axis=1)))
-            
-            # 3. Combine acoustic and ASR features for classification
-            accent_scores = {}
-            
-            for accent in accent_langs.keys():
-                score = 0.0
-                
-                # Weight from Whisper ASR confidence (40%)
-                score += 0.4 * whisper_scores.get(accent, 0.0)
-                
-                # Weight from acoustic features (60%)
-                pitch_range = features['pitch_std'] / features['pitch_mean'] if features['pitch_mean'] > 0 else 0
-                
-                if accent == "Indian":
-                    score += 0.6 * (
-                        0.3 * (0.1 <= pitch_range <= 0.2) +
-                        0.3 * (features['rhythm_regularity'] > 120) +
-                        0.4 * (features['spectral_variance'] > 2.0)
-                    )
-                
-                elif accent == "American":
-                    score += 0.6 * (
-                        0.3 * (0.15 <= pitch_range <= 0.25) +
-                        0.3 * (90 <= features['rhythm_regularity'] <= 110) +
-                        0.4 * (1.5 <= features['spectral_variance'] <= 2.0)
-                    )
-                
-                elif accent == "British":
-                    score += 0.6 * (
-                        0.3 * (0.12 <= pitch_range <= 0.22) +
-                        0.3 * (100 <= features['rhythm_regularity'] <= 120) +
-                        0.4 * (1.8 <= features['spectral_variance'] <= 2.2)
-                    )
-                
-                elif accent == "Australian":
-                    score += 0.6 * (
-                        0.3 * (0.14 <= pitch_range <= 0.24) +
-                        0.3 * (95 <= features['rhythm_regularity'] <= 115) +
-                        0.4 * (1.7 <= features['spectral_variance'] <= 2.1)
-                    )
-                
-                accent_scores[accent] = float(score)
-            
-            # Normalize scores
-            total_score = sum(accent_scores.values())
-            if total_score > 0:
-                accent_scores = {k: v/total_score for k, v in accent_scores.items()}
-            
-            # Apply confidence threshold
-            threshold = 0.25
-            accent_scores = {k: v for k, v in accent_scores.items() if v > threshold}
-            
-            if not accent_scores:
-                # Return highest scoring accent if none pass threshold
-                max_score = max(accent_scores.values())
-                accent_scores = {k: v for k, v in accent_scores.items() if v == max_score}
-            
-            return accent_scores
-            
-        except Exception as e:
-            logger.error(f"Error in hybrid accent classification: {e}")
-            raise RuntimeError(f"Accent classification failed: {str(e)}")
-
     def _merge_transcripts(self, transcripts: List[str]) -> str:
         """Merge transcripts with overlap deduplication"""
         if not transcripts:
@@ -1397,40 +1228,37 @@ class MentorEvaluator:
 
     def _evaluate_speech_metrics(self, transcript: str, audio_features: Dict[str, float], 
                                progress_callback=None) -> Dict[str, Any]:
-        """Evaluate speech metrics with stricter error thresholds"""
+        """Evaluate speech metrics with improved accuracy"""
         try:
             if progress_callback:
                 progress_callback(0.2, "Calculating speech metrics...")
 
-            # Extract transcript text from transcript data structure
-            transcript_text = transcript.get("transcript", "") if isinstance(transcript, dict) else transcript
-            
             # Calculate words and duration
-            words = len(transcript_text.split())
+            words = len(transcript.split())
             duration_minutes = float(audio_features.get('duration', 0)) / 60
             
-            # Calculate words per minute (130-160 WPM is ideal for teaching)
+            # Calculate words per minute with updated range (130-160 WPM is ideal for teaching)
             words_per_minute = float(words / duration_minutes if duration_minutes > 0 else 0)
             
-            # Stricter filler word detection (max 1-2 per minute is acceptable)
+            # Improved filler word detection (2-3 per minute is acceptable)
             filler_words = re.findall(r'\b(um|uh|like|you\s+know|basically|actually|literally)\b', 
-                                    transcript_text.lower())
+                                    transcript.lower())
             fillers_count = len(filler_words)
             fillers_per_minute = float(fillers_count / duration_minutes if duration_minutes > 0 else 0)
             
-            # Stricter error detection (max 1 per minute is acceptable)
-            repeated_words = len(re.findall(r'\b(\w+)\s+\1\b', transcript_text.lower()))
-            incomplete_sentences = len(re.findall(r'[a-zA-Z]+\s*\.\.\.|\b[a-zA-Z]+\s*-\s+', transcript_text))
+            # Improved error detection (1-2 per minute is acceptable)
+            repeated_words = len(re.findall(r'\b(\w+)\s+\1\b', transcript.lower()))
+            incomplete_sentences = len(re.findall(r'[a-zA-Z]+\s*\.\.\.|\b[a-zA-Z]+\s*-\s+', transcript))
             errors_count = repeated_words + incomplete_sentences
             errors_per_minute = float(errors_count / duration_minutes if duration_minutes > 0 else 0)
 
-            # Updated stricter thresholds
-            max_errors = 1.0  # Reduced from 2.0
-            max_fillers = 2.0  # Reduced from 3.0
-            threshold_explanation = "Using strict thresholds for professional teaching"
+            # Set default thresholds if analysis fails
+            max_errors = 2.0
+            max_fillers = 3.0
+            threshold_explanation = "Using standard thresholds"
             grammatical_errors = []
 
-            # Calculate fluency score based on stricter thresholds
+            # Calculate fluency score based on both errors and fillers
             fluency_score = 1 if (errors_per_minute <= max_errors and fillers_per_minute <= max_fillers) else 0
             
             return {
@@ -1441,7 +1269,7 @@ class MentorEvaluator:
                     "duration_minutes": duration_minutes
                 },
                 "fluency": {
-                    "score": fluency_score,
+                    "score": fluency_score,  # Add explicit fluency score
                     "errorsPerMin": errors_per_minute,
                     "fillersPerMin": fillers_per_minute,
                     "maxErrorsThreshold": max_errors,
@@ -1515,79 +1343,15 @@ def display_evaluation(evaluation: Dict[str, Any]):
         with tabs[0]:
             st.header("Communication Metrics")
             
-            # Add Accent Analysis section
-            with st.expander("🗣️ Accent Analysis", expanded=True):
-                # Safely handle transcript data structure
-                transcript_data = evaluation.get("transcript", {})
-                if isinstance(transcript_data, (str, bytes)):
-                    # Handle case where transcript is direct text
-                    accent_data = {}
-                    transcript_text = str(transcript_data)
-                elif isinstance(transcript_data, dict):
-                    # Handle case where transcript is a dictionary
-                    accent_data = transcript_data.get("accent_analysis", {})
-                    transcript_text = transcript_data.get("transcript", "")
-                else:
-                    # Handle unexpected data type
-                    accent_data = {}
-                    transcript_text = ""
-                    logger.warning(f"Unexpected transcript data type: {type(transcript_data)}")
-                
-                if accent_data:
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        detected_accent = accent_data.get("detected_accent", "Unknown")
-                        confidence = accent_data.get("confidence", 0.0)
-                        
-                        st.metric("Detected Accent", str(detected_accent))
-                        st.metric("Confidence", f"{float(confidence)*100:.1f}%")
-                    
-                    with col2:
-                        # Display accent probability distribution
-                        accent_probs = accent_data.get("accent_probabilities", {})
-                        if accent_probs:
-                            # Ensure all values are properly converted to float
-                            df = pd.DataFrame(
-                                [(k, float(v)) for k, v in accent_probs.items()],
-                                columns=['Accent', 'Probability']
-                            ).sort_values('Probability', ascending=False)
-                            
-                            fig = px.bar(
-                                df,
-                                x='Accent',
-                                y='Probability',
-                                title='Accent Probability Distribution'
-                            )
-                            fig.update_layout(
-                                xaxis_tickangle=-45,
-                                showlegend=False
-                            )
-                            st.plotly_chart(fig, use_container_width=True)
-                
-                    # Add explanation card
-                    st.markdown("""
-                        <div class="metric-explanation-card">
-                            <h4>🌍 Understanding Accent Analysis</h4>
-                            <ul>
-                                <li><strong>Detected Accent:</strong> The most probable accent based on speech patterns</li>
-                                <li><strong>Confidence:</strong> Model's confidence in the accent classification</li>
-                                <li><strong>Distribution:</strong> Probability scores across different accent possibilities</li>
-                            </ul>
-                        </div>
-                    """, unsafe_allow_html=True)
-                else:
-                    st.warning("Accent analysis data not available")
-
             # Get audio features and ensure we have the required metrics
             audio_features = evaluation.get("audio_features", {})
             
-            # Ensure all metrics are properly converted to appropriate types
-            speech_metrics = evaluation.get("speech_metrics", {})
-            
             # Speed Metrics
             with st.expander("🏃 Speed", expanded=True):
+                # Fix: Calculate WPM using total words and duration
+                speech_metrics = evaluation.get("speech_metrics", {})
                 speed_data = speech_metrics.get("speed", {})
-                words_per_minute = float(speed_data.get("wpm", 0))
+                words_per_minute = speed_data.get("wpm", 0)  # Get WPM from speech metrics
                 
                 col1, col2 = st.columns(2)
                 with col1:
@@ -1608,14 +1372,14 @@ def display_evaluation(evaluation: Dict[str, Any]):
                 
                 col1, col2 = st.columns(2)
                 with col1:
-                    st.metric("Score", "✅ Pass" if fillers_per_minute <= 2 and errors_per_minute <= 1 else "❌ Needs Improvement")
+                    st.metric("Score", "✅ Pass" if fillers_per_minute <= 3 and errors_per_minute <= 2 else "❌ Needs Improvement")
                     st.metric("Fillers per Minute", f"{fillers_per_minute:.1f}")
                     st.metric("Errors per Minute", f"{errors_per_minute:.1f}")
                 with col2:
                     st.info("""
                     **Acceptable Ranges:**
-                    - Fillers per Minute: <2
-                    - Errors per Minute: <1
+                    - Fillers per Minute: <3
+                    - Errors per Minute: <2
                     """)
 
             # Flow Metrics
@@ -1977,18 +1741,336 @@ def display_evaluation(evaluation: Dict[str, Any]):
             """, unsafe_allow_html=True)
 
         with tabs[3]:
-            st.header("Transcript")
-            # Safely display transcript
-            if isinstance(transcript_text, (str, bytes)):
-                st.text_area("Full Transcript", str(transcript_text), height=300)
-            else:
-                st.warning("Transcript data not available in expected format")
+            st.header("Transcript with Timestamps")
+            transcript = evaluation.get("transcript", "")
+            
+            # Split transcript into sentences and add timestamps
+            sentences = re.split(r'(?<=[.!?])\s+', transcript)
+            for i, sentence in enumerate(sentences):
+                # Calculate approximate timestamp based on words and average speaking rate
+                words_before = len(' '.join(sentences[:i]).split())
+                timestamp = words_before / 150  # Assuming 150 words per minute
+                minutes = int(timestamp)
+                seconds = int((timestamp - minutes) * 60)
+                
+                st.markdown(f"**[{minutes:02d}:{seconds:02d}]** {sentence}")
+
+            # Comment out original transcript display
+            # st.text(evaluation.get("transcript", "Transcript not available"))
 
     except Exception as e:
-        logger.error(f"Error displaying evaluation results: {e}")
+        logger.error(f"Error displaying evaluation: {e}")
         st.error(f"Error displaying results: {str(e)}")
-        # Log the evaluation data structure for debugging
-        logger.debug(f"Evaluation data structure: {evaluation}")
+        st.error("Please check the evaluation data structure and try again.")
+
+    # Add these styles to the existing CSS in the main function
+    st.markdown("""
+        <style>
+        /* ... existing styles ... */
+        
+        .citation-box {
+            background-color: #f8f9fa;
+            border-left: 3px solid #6c757d;
+            padding: 10px;
+            margin: 5px 0;
+            border-radius: 0 4px 4px 0;
+        }
+        
+        .recommendation-card {
+            background-color: #ffffff;
+            border-left: 4px solid #1f77b4;
+            padding: 15px;
+            margin: 10px 0;
+            border-radius: 4px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+        
+        .recommendation-card h4 {
+            color: #1f77b4;
+            margin: 0 0 10px 0;
+        }
+        
+        .rigor-card {
+            background-color: #ffffff;
+            border: 1px solid #e0e0e0;
+            padding: 20px;
+            margin: 10px 0;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        }
+        
+        .score-badge {
+            display: inline-block;
+            padding: 4px 12px;
+            border-radius: 15px;
+            font-weight: bold;
+            margin: 10px 0;
+        }
+        
+        .green-score {
+            background-color: #28a745;
+            color: white;
+        }
+        
+        .orange-score {
+            background-color: #fd7e14;
+            color: white;
+        }
+        
+        .metric-container {
+            background-color: #f8f9fa;
+            padding: 15px;
+            border-radius: 8px;
+            margin: 10px 0;
+        }
+        
+        .profile-guide {
+            background-color: #f8f9fa;
+            padding: 15px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            border-left: 4px solid #1f77b4;
+        }
+        
+        .profile-card {
+            background-color: #ffffff;
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            padding: 20px;
+            margin: 10px 0;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+            transition: all 0.3s ease;
+        }
+        
+        .profile-card.recommended {
+            border-left: 4px solid #28a745;
+        }
+        
+        .profile-header {
+            margin-bottom: 15px;
+        }
+        
+        .profile-badge {
+            display: inline-block;
+            padding: 4px 12px;
+            border-radius: 15px;
+            font-size: 0.9em;
+            margin-top: 5px;
+            background-color: #f8f9fa;
+        }
+        
+        .profile-content ul {
+            margin: 10px 0;
+            padding-left: 20px;
+        }
+        
+        .recommendation-status {
+            margin-top: 15px;
+            padding: 10px;
+            border-radius: 4px;
+            background-color: #f8f9fa;
+            font-weight: bold;
+        }
+        
+        .recommendation-status small {
+            display: block;
+            margin-top: 5px;
+            font-weight: normal;
+            color: #666;
+        }
+        
+        .recommendation-status.recommended {
+            background-color: #d4edda;
+            border-color: #c3e6cb;
+            color: #155724;
+        }
+        
+        .recommendation-status:not(.recommended) {
+            background-color: #fff3cd;
+            border-color: #ffeeba;
+            color: #856404;
+        }
+        
+        .profile-card.recommended {
+            border-left: 4px solid #28a745;
+            box-shadow: 0 2px 8px rgba(40, 167, 69, 0.1);
+        }
+        
+        .profile-card:not(.recommended) {
+            border-left: 4px solid #ffc107;
+            opacity: 0.8;
+        }
+        
+        .profile-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+        }
+        
+        .progress-metric {
+            background: linear-gradient(135deg, #f6f8fa 0%, #ffffff 100%);
+            padding: 10px 15px;
+            border-radius: 8px;
+            border-left: 4px solid #1f77b4;
+            margin: 5px 0;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+            transition: transform 0.2s ease;
+        }
+        
+        .progress-metric:hover {
+            transform: translateX(5px);
+        }
+        
+        .progress-metric b {
+            color: #1f77b4;
+        }
+        
+        /* Enhanced status messages */
+        .status-message {
+            padding: 10px;
+            border-radius: 8px;
+            margin: 5px 0;
+            animation: fadeIn 0.5s ease;
+        }
+        
+        .status-processing {
+            background: linear-gradient(135deg, #f0f7ff 0%, #e5f0ff 100%);
+            border-left: 4px solid #1f77b4;
+        }
+        
+        .status-complete {
+            background: linear-gradient(135deg, #f0fff0 0%, #e5ffe5 100%);
+            border-left: 4px solid #28a745;
+        }
+        
+        .status-error {
+            background: linear-gradient(135deg, #fff0f0 0%, #ffe5e5 100%);
+            border-left: 4px solid #dc3545;
+        }
+        
+        /* Progress bar enhancement */
+        .stProgress > div > div {
+            background-image: linear-gradient(
+                to right,
+                rgba(31, 119, 180, 0.8),
+                rgba(31, 119, 180, 1)
+            );
+            transition: width 0.3s ease;
+        }
+        
+        /* Batch indicator animation */
+        @keyframes pulse {
+            0% { transform: scale(1); }
+            50% { transform: scale(1.05); }
+            100% { transform: scale(1); }
+        }
+        
+        .batch-indicator {
+            display: inline-block;
+            padding: 4px 8px;
+            background: #1f77b4;
+            color: white;
+            border-radius: 4px;
+            animation: pulse 1s infinite;
+        }
+        
+        .metric-box {
+            background: linear-gradient(135deg, #f8f9fa 0%, #ffffff 100%);
+            padding: 10px;
+            border-radius: 8px;
+            margin: 5px;
+            border-left: 4px solid #1f77b4;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+            transition: transform 0.2s ease;
+        }
+        
+        .metric-box:hover {
+            transform: translateX(5px);
+        }
+        
+        .metric-box.batch {
+            border-left-color: #28a745;
+        }
+        
+        .metric-box.time {
+            border-left-color: #dc3545;
+        }
+        
+        .metric-box.progress {
+            border-left-color: #ffc107;
+        }
+        
+        .metric-box.segment {
+            border-left-color: #17a2b8;
+        }
+        
+        .metric-box b {
+            color: #1f77b4;
+        }
+        
+        <style>
+        .metric-explanation-card {
+            background: linear-gradient(135deg, #f8f9fa 0%, #ffffff 100%);
+            padding: 15px;
+            border-radius: 8px;
+            margin-top: 15px;
+            border-left: 4px solid #17a2b8;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        }
+        
+        .metric-explanation-card h4 {
+            color: #17a2b8;
+            margin-bottom: 10px;
+        }
+        
+        .metric-explanation-card ul {
+            list-style-type: none;
+            padding-left: 0;
+        }
+        
+        .metric-explanation-card li {
+            margin-bottom: 12px;
+            padding-left: 15px;
+            border-left: 2px solid #e9ecef;
+        }
+        
+        .metric-explanation-card li:hover {
+            border-left: 2px solid #17a2b8;
+        }
+        </style>
+        
+        <style>
+        /* ... existing styles ... */
+        
+        .suggestions-box {
+            background-color: #f8f9fa;
+            padding: 10px 15px;
+            margin-top: 15px;
+            border-radius: 8px;
+            border-left: 4px solid #ffc107;
+        }
+        
+        .suggestions-box h4 {
+            color: #856404;
+            margin: 0;
+            padding: 5px 0;
+        }
+        
+        .suggestion-item {
+            padding: 5px 15px;
+            color: #666;
+            border-left: 2px solid #ffc107;
+            margin: 5px 0;
+            background-color: #fff;
+            border-radius: 0 4px 4px 0;
+        }
+        
+        .suggestion-item:hover {
+            background-color: #fff9e6;
+            transform: translateX(5px);
+            transition: all 0.2s ease;
+        }
+        </style>
+    """, unsafe_allow_html=True)
 
 def check_dependencies() -> List[str]:
     """Check if required dependencies are installed"""