Update app.py

app.py

@@ -228,41 +228,67 @@ class ContentAnalyzer:
         self.GPT4_OUTPUT_COST = 0.60 / 1_000_000  # $0.60 per 1M tokens output
         
     def analyze_content(self, transcript: str, progress_callback=None) -> Dict[str, Any]:
-        """Analyze teaching content with retry logic and robust JSON handling"""
+        """Analyze teaching content with more lenient validation and robust JSON handling"""
         for attempt in range(self.retry_count):
             try:
                 if progress_callback:
                     progress_callback(0.2, "Preparing content analysis...")
                 
                 prompt = self._create_analysis_prompt(transcript)
+                logger.info(f"Attempt {attempt + 1}: Sending analysis request")
+                logger.info(f"Transcript length: {len(transcript)} characters")
                 
                 if progress_callback:
                     progress_callback(0.5, "Processing with AI model...")
                 
                 try:
                     response = self.client.chat.completions.create(
-                        model="gpt-4o-mini",
+                        model="gpt-4o-mini",  # Keeping original model
                         messages=[
-                            {"role": "system", "content": """You are a teaching expert providing a structured analysis. 
-                             Analyze the teaching content and provide a detailed assessment in the following format:
+                            {"role": "system", "content": """You are a strict teaching evaluator focusing on core teaching competencies.
+                             Ignore minor transcription errors or verbal stumbles. Focus on substantive teaching quality.
                              
-                             Concept Assessment:
-                             - Subject Matter Accuracy (Score: 0/1, Citations with timestamps)
-                             - First Principles Approach (Score: 0/1, Citations with timestamps)
-                             - Examples and Business Context (Score: 0/1, Citations with timestamps)
-                             - Cohesive Storytelling (Score: 0/1, Citations with timestamps)
-                             - Engagement and Interaction (Score: 0/1, Citations with timestamps)
-                             - Professional Tone (Score: 0/1, Citations with timestamps)
+                             Score of 1 should be given when CORE criteria below are met with clear evidence.
+                             Default to 0 if MAJOR teaching deficiencies are present.
                              
-                             Code Assessment:
-                             - Depth of Explanation (Score: 0/1, Citations with timestamps)
-                             - Output Interpretation (Score: 0/1, Citations with timestamps)
-                             - Breaking down Complexity (Score: 0/1, Citations with timestamps)
+                             Concept Assessment Scoring Criteria:
+                             - Subject Matter Accuracy (Score 1 requires: Core concepts are accurately explained. Ignore minor verbal slips)
+                             - First Principles Approach (Score 1 requires: Clear explanation of fundamentals before advanced concepts)
+                             - Examples and Business Context (Score 1 requires: Multiple relevant examples with clear business impact)
+                             - Cohesive Storytelling (Score 1 requires: Clear logical progression of concepts. Minor verbal transitions can be ignored)
+                             - Engagement and Interaction (Score 1 requires: Regular attempts to engage learners with meaningful questions)
+                             - Professional Tone (Score 1 requires: Overall professional delivery. Ignore occasional filler words)
+                             
+                             Code Assessment Scoring Criteria:
+                             - Depth of Explanation (Score 1 requires: Clear explanation of key implementation aspects)
+                             - Output Interpretation (Score 1 requires: Clear connection between code and business outcomes)
+                             - Breaking down Complexity (Score 1 requires: Systematic breakdown of complex concepts)
+                             
+                             What to Ignore:
+                             - Minor transcription errors
+                             - Occasional verbal stumbles or filler words
+                             - Small grammatical mistakes
+                             - Brief pauses or hesitations
+                             - Minor code syntax errors in verbal explanation
+                             
+                             What to Focus On:
+                             - Accuracy of core technical concepts
+                             - Clarity of fundamental explanations
+                             - Quality of real-world examples
+                             - Overall teaching structure and flow
+                             - Meaningful learner engagement
+                             - Key implementation explanations
+                             
+                             Citations Requirements:
+                             - Include timestamps [MM:SS] where possible
+                             - Focus on substantive teaching moments
+                             - Provide specific examples of effective or ineffective teaching
                              
                              Always respond with valid JSON containing these exact categories."""},
                             {"role": "user", "content": prompt}
                         ],
-                        response_format={"type": "json_object"}
+                        response_format={"type": "json_object"},
+                        temperature=0.4  # Slightly higher temperature for more lenient evaluation
                     )
                     logger.info("API call successful")
                 except Exception as api_error:
@@ -324,7 +350,7 @@ class ContentAnalyzer:
                     raise
                 
             except Exception as e:
-                logger.error(f"Content analysis attempt {attempt + 1} failed: {str(e)}")
+                logger.error(f"Content analysis attempt {attempt + 1} failed: {e}")
                 if attempt == self.retry_count - 1:
                     logger.error("All attempts failed, returning default structure")
                     return {
@@ -663,7 +689,7 @@ class MentorEvaluator:
                 logger.info("Attempting to initialize Whisper model...")
                 # First try to initialize model with downloading allowed
                 self._whisper_model = WhisperModel(
-                    "small",
+                    "medium",
                     device="cpu",
                     compute_type="int8",
                     download_root=self.model_cache_dir,
@@ -676,7 +702,7 @@ class MentorEvaluator:
                 try:
                     logger.info("Attempting to load model from local cache...")
                     self._whisper_model = WhisperModel(
-                        "small",
+                        "medium",
                         device="cpu",
                         compute_type="int8",
                         download_root=self.model_cache_dir,
@@ -1483,9 +1509,10 @@ def main():
         # Add custom CSS for animations and styling
         st.markdown("""
             <style>
+                /* Modern animations */
                 @keyframes fadeIn {
-                    from { opacity: 0; }
-                    to { opacity: 1; }
+                    from { opacity: 0; transform: translateY(20px); }
+                    to { opacity: 1; transform: translateY(0); }
                 }
                 
                 @keyframes slideIn {
@@ -1499,245 +1526,192 @@ def main():
                     100% { transform: scale(1); }
                 }
                 
-                .fade-in {
-                    animation: fadeIn 1s ease-in;
+                @keyframes gradientBG {
+                    0% { background-position: 0% 50%; }
+                    50% { background-position: 100% 50%; }
+                    100% { background-position: 0% 50%; }
                 }
                 
-                .slide-in {
-                    animation: slideIn 0.5s ease-out;
+                /* Modern styling */
+                .stApp {
+                    background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
                 }
                 
-                .pulse {
-                    animation: pulse 2s infinite;
+                .main-title {
+                    text-align: center;
+                    color: #2c3e50;
+                    font-size: 2.5rem;
+                    font-weight: 700;
+                    margin: 2rem 0;
+                    padding: 1rem;
+                    border-radius: 10px;
+                    background: linear-gradient(120deg, #84fab0 0%, #8fd3f4 100%);
+                    animation: fadeIn 1s ease-out;
                 }
                 
-                .metric-card {
-                    background-color: #f0f2f6;
-                    border-radius: 10px;
-                    padding: 20px;
-                    margin: 10px 0;
-                    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+                .card {
+                    background: white;
+                    padding: 1.5rem;
+                    border-radius: 15px;
+                    box-shadow: 0 10px 20px rgba(0,0,0,0.1);
+                    margin: 1rem 0;
+                    animation: fadeIn 0.5s ease-out;
                     transition: transform 0.3s ease;
                 }
                 
-                .metric-card:hover {
+                .card:hover {
                     transform: translateY(-5px);
                 }
                 
+                .metric-card {
+                    background: linear-gradient(120deg, #a1c4fd 0%, #c2e9fb 100%);
+                    color: #1a202c;
+                    padding: 1rem;
+                    border-radius: 10px;
+                    text-align: center;
+                    animation: fadeIn 0.5s ease-out;
+                }
+                
+                .sidebar-content {
+                    background: rgba(255, 255, 255, 0.9);
+                    padding: 1.5rem;
+                    border-radius: 10px;
+                    margin: 1rem 0;
+                }
+                
                 .stButton>button {
+                    background: linear-gradient(120deg, #4facfe 0%, #00f2fe 100%);
+                    color: white;
+                    border: none;
+                    padding: 0.75rem 1.5rem;
+                    border-radius: 25px;
+                    font-weight: 600;
                     transition: all 0.3s ease;
                 }
                 
                 .stButton>button:hover {
-                    transform: scale(1.05);
+                    transform: translateY(-2px);
+                    box-shadow: 0 5px 15px rgba(0,0,0,0.2);
                 }
                 
-                .category-header {
-                    background: linear-gradient(90deg, #1f77b4, #2c3e50);
-                    color: white;
-                    padding: 10px;
-                    border-radius: 5px;
-                    margin: 10px 0;
+                .stProgress > div > div {
+                    background: linear-gradient(90deg, #4facfe 0%, #00f2fe 100%);
                 }
                 
-                .score-badge {
-                    padding: 5px 10px;
-                    border-radius: 15px;
-                    font-weight: bold;
+                /* Status indicators */
+                .status-processing {
+                    background: linear-gradient(120deg, #a1c4fd 0%, #c2e9fb 100%);
+                    padding: 1rem;
+                    border-radius: 10px;
+                    text-align: center;
+                    animation: pulse 2s infinite;
                 }
                 
-                .score-pass {
-                    background-color: #28a745;
-                    color: white;
+                .status-complete {
+                    background: linear-gradient(120deg, #84fab0 0%, #8fd3f4 100%);
+                    padding: 1rem;
+                    border-radius: 10px;
+                    text-align: center;
                 }
                 
-                .score-fail {
-                    background-color: #dc3545;
-                    color: white;
+                /* Expander styling */
+                .streamlit-expanderHeader {
+                    background: linear-gradient(90deg, #f6f9fc 0%, #f0f4f8 100%);
+                    border-radius: 8px;
+                    padding: 0.5rem 1rem;
+                    font-weight: 600;
+                }
+                
+                /* File uploader styling */
+                .uploadedFile {
+                    background: white;
+                    padding: 1rem;
+                    border-radius: 10px;
+                    box-shadow: 0 5px 15px rgba(0,0,0,0.1);
+                }
+                
+                /* Metrics styling */
+                div[data-testid="stMetricValue"] {
+                    font-size: 2rem;
+                    font-weight: 700;
+                    color: #2c3e50;
+                }
+                
+                /* Success/Error message styling */
+                .stSuccess, .stError {
+                    padding: 1rem;
+                    border-radius: 10px;
+                    animation: fadeIn 0.5s ease-out;
                 }
             </style>
+            
+            <div class="fade-in">
+                <h1 class="main-title">
+                    🎓 Mentor Demo Review System
+                </h1>
+            </div>
         """, unsafe_allow_html=True)
 
-        # Sidebar with instructions (only once)
+        # Sidebar with modern styling
         with st.sidebar:
             st.markdown("""
-                <div class="slide-in">
-                    <h2>Instructions</h2>
-                    <ol>
-                        <li>Upload your teaching video</li>
-                        <li>Wait for the analysis</li>
-                        <li>Review the detailed feedback</li>
+                <div class="sidebar-content">
+                    <h2 style='text-align: center; color: #2c3e50;'>📋 Instructions</h2>
+                    <p style='color: #4a5568;'>Follow these steps to evaluate your teaching demo:</p>
+                    <ol style='color: #4a5568;'>
+                        <li>Upload your teaching demo video</li>
+                        <li>Wait for the analysis to complete</li>
+                        <li>Review your detailed evaluation</li>
                         <li>Download the report</li>
                     </ol>
                 </div>
             """, unsafe_allow_html=True)
             
-            # Add file format information separately
-            st.markdown("**Supported formats:** MP4, AVI, MOV")
-            st.markdown("**Maximum file size:** 500MB")
-            
-            st.header("Processing Status")
-            st.info("Upload a video to begin analysis")
-
-        # Main title (only once)
-        st.markdown("""
-            <div class="fade-in">
-                <h1 style='text-align: center; color: #1f77b4;'>
-                    🎓 Mentor Demo Review System
-                </h1>
-            </div>
-        """, unsafe_allow_html=True)
-
-        # Check dependencies with progress
-        with st.status("Checking system requirements...") as status:
-            progress_bar = st.progress(0)
-            
-            status.update(label="Checking FFmpeg installation...")
-            progress_bar.progress(0.3)
-            missing_deps = check_dependencies()
-            
-            progress_bar.progress(0.6)
-            if missing_deps:
-                status.update(label="Missing dependencies detected!", state="error")
-                st.error(f"Missing required dependencies: {', '.join(missing_deps)}")
-                st.markdown("""
-                Please install the missing dependencies:
-                ```bash
-                sudo apt-get update
-                sudo apt-get install ffmpeg
-                ```
-                """)
-                return
-            
-            progress_bar.progress(1.0)
-            status.update(label="System requirements satisfied!", state="complete")
-
-        # Temporary: Add radio button for input type selection
-        input_type = st.radio(
-            "Select Input Type (Temporary Feature)",
-            ["Video Only", "Video + Transcript"],
-            help="Temporary feature: Choose to upload video only or video with transcript"
-        )
-
-        uploaded_file = st.file_uploader(
-            "Upload Teaching Video",
-            type=['mp4', 'avi', 'mov'],
-            help="Upload your teaching video in MP4, AVI, or MOV format"
-        )
-
-        # Temporary: Add transcript uploader if Video + Transcript is selected
-        uploaded_transcript = None
-        if input_type == "Video + Transcript":
-            uploaded_transcript = st.file_uploader(
-                "Upload Transcript (Optional)",
-                type=['txt'],
-                help="Upload your transcript in TXT format"
-            )
+            st.markdown("""
+                <div class="sidebar-content">
+                    <h3 style='color: #2c3e50;'>📁 File Requirements</h3>
+                    <p style='color: #4a5568;'><strong>Supported formats:</strong> MP4, AVI, MOV<br>
+                    <strong>Maximum file size:</strong> 500MB</p>
+                </div>
+            """, unsafe_allow_html=True)
         
         if uploaded_file:
-            # Add a pulsing animation while processing
+            # Add a modern processing animation
             st.markdown("""
-                <div class="pulse" style="text-align: center;">
-                    <h3>Processing your video...</h3>
+                <div class="status-processing">
+                    <h3>🔄 Processing Your Video</h3>
+                    <p>Please wait while we analyze your teaching demo...</p>
                 </div>
             """, unsafe_allow_html=True)
-            
-            # Create temp directory for processing
-            temp_dir = tempfile.mkdtemp()
-            video_path = os.path.join(temp_dir, uploaded_file.name)
-            
-            try:
-                # Save uploaded file with progress
-                with st.status("Saving uploaded file...") as status:
-                    progress_bar = st.progress(0)
-                    
-                    # Save in chunks to show progress
-                    chunk_size = 1024 * 1024  # 1MB chunks
-                    file_size = len(uploaded_file.getbuffer())
-                    chunks = file_size // chunk_size + 1
-                    
-                    with open(video_path, 'wb') as f:
-                        for i in range(chunks):
-                            start = i * chunk_size
-                            end = min(start + chunk_size, file_size)
-                            f.write(uploaded_file.getbuffer()[start:end])
-                            progress = (i + 1) / chunks
-                            status.update(label=f"Saving file: {progress:.1%}")
-                            progress_bar.progress(progress)
-                    
-                    status.update(label="File saved successfully!", state="complete")
-                
-                # Validate file size
-                file_size = os.path.getsize(video_path) / (1024 * 1024 * 1024)  # Size in GB
-                if file_size > 2:
-                    st.error("File size exceeds 2GB limit. Please upload a smaller file.")
-                    return
-                
-                # Store evaluation results in session state
-                if 'evaluation_results' not in st.session_state:
-                    # Process video only if results aren't already in session state
-                    with st.spinner("Processing video"):
-                        evaluator = MentorEvaluator()
-                        
-                        # Temporary: Handle transcript if provided
-                        if uploaded_transcript:
-                            transcript_text = uploaded_transcript.getvalue().decode('utf-8')
-                            # Extract audio features but skip transcription
-                            audio_features = evaluator.feature_extractor.extract_features(video_path)
-                            
-                            # Evaluate speech metrics
-                            speech_metrics = evaluator._evaluate_speech_metrics(
-                                transcript_text,
-                                audio_features
-                            )
-                            
-                            # Analyze content
-                            content_analysis = evaluator.content_analyzer.analyze_content(transcript_text)
-                            
-                            # Generate recommendations
-                            recommendations = evaluator.recommendation_generator.generate_recommendations(
-                                speech_metrics,
-                                content_analysis
-                            )
-                            
-                            # Combine results
-                            st.session_state.evaluation_results = {
-                                "communication": speech_metrics,
-                                "teaching": content_analysis,
-                                "recommendations": recommendations,
-                                "transcript": transcript_text
-                            }
-                        else:
-                            # Original flow: full video evaluation
-                            st.session_state.evaluation_results = evaluator.evaluate_video(video_path)
-                
-                # Display results using stored evaluation
-                st.success("Analysis complete!")
-                display_evaluation(st.session_state.evaluation_results)
-                
-                # Add download button using stored results
-                if st.download_button(
-                    "📥 Download Full Report",
-                    json.dumps(st.session_state.evaluation_results, indent=2),
-                    "evaluation_report.json",
-                    "application/json",
-                    help="Download the complete evaluation report in JSON format"
-                ):
-                    st.success("Report downloaded successfully!")
-                
-                # Debugging code
-                # if st.session_state.evaluation_results:
-                #     st.write("Debug: Teaching Analysis Structure")
-                #     teaching_data = st.session_state.evaluation_results.get("teaching", {})
-                #     st.json(teaching_data)
-                
-            except Exception as e:
-                st.error(f"Error during evaluation: {str(e)}")
-                
-            finally:
-                # Clean up temp files
-                if 'temp_dir' in locals():
-                    shutil.rmtree(temp_dir)
+        
+        # Display results using stored evaluation
+        st.markdown("""
+            <div class="status-complete">
+                <h3>✅ Analysis Complete!</h3>
+                <p>Review your detailed evaluation below</p>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        # Wrap the evaluation display in a card
+        st.markdown('<div class="card">', unsafe_allow_html=True)
+        display_evaluation(st.session_state.evaluation_results)
+        st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Modern download button
+        st.markdown("""
+            <div class="card" style="text-align: center;">
+                <h3 style='color: #2c3e50;'>📥 Download Your Report</h3>
+            </div>
+        """, unsafe_allow_html=True)
+        
+        if st.download_button(
+            "Download Full Report",
+            json.dumps(st.session_state.evaluation_results, indent=2),
+            "evaluation_report.json",
+            "application/json",
+            help="Download the complete evaluation report in JSON format"
+        ):
+            st.success("Report downloaded successfully!")
         
     except Exception as e:
         st.error(f"Application error: {str(e)}")