Update app.py

app.py

@@ -202,10 +202,33 @@ class AudioFeatureExtractor:
             # Calculate monotone score (0-1, higher means more monotone)
             monotone_score = 0.0
             if pitch_mean > 0:
+                # Normalize each factor to 0-1 range where higher values indicate more monotone speech
                 variation_factor = min(1.0, max(0.0, (15 - pitch_variation_coeff) / 15))
                 range_factor = min(1.0, max(0.0, (30 - (pitch_range / pitch_mean * 100)) / 30))
                 changes_factor = min(1.0, max(0.0, (100 - changes_per_minute) / 100))
-                monotone_score = (variation_factor + range_factor + changes_factor) / 3
+                
+                # Weight the factors (can adjust weights if needed)
+                variation_weight = 0.4
+                range_weight = 0.3  
+                changes_weight = 0.3
+                
+                # Calculate weighted average
+                monotone_score = (
+                    variation_factor * variation_weight +
+                    range_factor * range_weight +
+                    changes_factor * changes_weight
+                )
+                
+                # Add debug logging
+                logger.info(f"""Monotone score calculation:
+                    Pitch variation coeff: {pitch_variation_coeff:.2f}
+                    Pitch range ratio: {(pitch_range / pitch_mean * 100):.2f}%
+                    Changes per minute: {changes_per_minute:.2f}
+                    Variation factor: {variation_factor:.2f}
+                    Range factor: {range_factor:.2f}
+                    Changes factor: {changes_factor:.2f}
+                    Final score: {monotone_score:.2f}
+                """)
             
             # Improved pause detection
             S = np.abs(librosa.stft(audio))
@@ -425,6 +448,55 @@ class ContentAnalyzer:
                                 logger.error(f"Missing Score or Citations in {category}.{subcategory}")
                                 raise ValueError(f"Missing Score or Citations in {category}.{subcategory}")
                     
+                    # Add validation for citations
+                    def validate_citations(citations: List[str]) -> bool:
+                        if not citations:
+                            return False
+                        
+                        for citation in citations:
+                            # Check for timestamp format [MM:SS]
+                            if not re.search(r'\[\d{2}:\d{2}\]', citation):
+                                return False
+                            # Check for meaningful content (at least 10 words)
+                            content = re.sub(r'\[\d{2}:\d{2}\]', '', citation).strip()
+                            if len(content.split()) < 10:
+                                return False
+                        return True
+
+                    # Add validation for each category score
+                    result = json.loads(result_text)
+                    for category in ["Concept Assessment", "Code Assessment"]:
+                        if category in result:
+                            for subcategory, details in result[category].items():
+                                # Validate citations first
+                                if not validate_citations(details.get("Citations", [])):
+                                    details["Score"] = 0  # Force score to 0 if citations are invalid
+                                    details["Citations"].append("[00:00] Invalid or insufficient citation format. Requires specific examples with timestamps.")
+                                
+                                # Additional validation based on subcategory
+                                if subcategory == "Examples and Business Context":
+                                    # Count actual examples in citations
+                                    example_count = sum(1 for citation in details.get("Citations", [])
+                                                      if "example" in citation.lower() or "case" in citation.lower())
+                                    if example_count < 2:
+                                        details["Score"] = 0
+                                        details["Citations"].append("[00:00] Insufficient number of concrete examples. At least 2 required.")
+                                
+                                elif subcategory == "Engagement and Interaction":
+                                    # Count engagement points
+                                    engagement_count = sum(1 for citation in details.get("Citations", [])
+                                                         if any(word in citation.lower() for word in ["question", "ask", "interact", "engage"]))
+                                    if engagement_count < 3:
+                                        details["Score"] = 0
+                                        details["Citations"].append("[00:00] Insufficient engagement points. At least 3 required.")
+                                
+                                # Validate professional tone
+                                elif subcategory == "Professional Tone":
+                                    unprofessional_indicators = ["um", "uh", "like", "you know", "stuff", "things"]
+                                    if any(indicator in ' '.join(details.get("Citations", [])).lower() for indicator in unprofessional_indicators):
+                                        details["Score"] = 0
+                                        details["Citations"].append("[00:00] Unprofessional language detected. Maintain formal teaching tone.")
+                    
                     return result
                     
                 except json.JSONDecodeError as json_error: