Update db/helpers.py

db/helpers.py

@@ -495,21 +495,21 @@ def get_advanced_research_metrics():
     """Get comprehensive research metrics including user types, levels, etc. - FIXED VERSION"""
     with next(get_db()) as db:
         try:
-            # Initialize metrics structure
+            # Initialize metrics structure with default values
             metrics = {
                 'models': {
                     'groq': {
                         'user_types': {},
                         'student_levels': {},
                         'complexity_distribution': {},
-                        'comment_analysis': {},
+                        'comment_analysis': {'avg_length': 0, 'high_quality_count': 0},
                         'regeneration_types': {}
                     },
                     'phi3': {
                         'user_types': {},
                         'student_levels': {},
                         'complexity_distribution': {},
-                        'comment_analysis': {},
+                        'comment_analysis': {'avg_length': 0, 'high_quality_count': 0},
                         'regeneration_types': {}
                     }
                 },
@@ -521,106 +521,130 @@ def get_advanced_research_metrics():
             }
 
             # Database summary - FIXED QUERIES
-            total_users = db.query(User).count()
-            total_content = db.query(ContentHistory).count()
-            total_feedback = db.query(Feedback).count()
-            
-            metrics['database_summary'] = {
-                'total_users': total_users,
-                'total_content': total_content,
-                'total_feedback': total_feedback
-            }
-
-            # User type analysis - FIXED
-            user_type_query = db.query(
-                ContentHistory.user_type,
-                ContentHistory.generated_model,
-                func.count(Feedback.id).label('count'),
-                func.avg(Feedback.clarity).label('avg_clarity'),
-                func.avg(Feedback.depth).label('avg_depth')
-            ).join(Feedback, ContentHistory.id == Feedback.content_id).group_by(
-                ContentHistory.user_type, ContentHistory.generated_model
-            ).all()
-
-            for row in user_type_query:
-                user_type, model, count, avg_clarity, avg_depth = row
-                if model in metrics['models']:
-                    metrics['models'][model]['user_types'][user_type] = {
-                        'count': count,
-                        'avg_clarity': float(avg_clarity) if avg_clarity else 0,
-                        'avg_depth': float(avg_depth) if avg_depth else 0
-                    }
-
-            # Student level analysis - FIXED
-            level_query = db.query(
-                ContentHistory.student_level,
-                ContentHistory.generated_model,
-                func.count(Feedback.id).label('count'),
-                func.avg(Feedback.clarity).label('avg_clarity')
-            ).join(Feedback, ContentHistory.id == Feedback.content_id).group_by(
-                ContentHistory.student_level, ContentHistory.generated_model
-            ).all()
-
-            for row in level_query:
-                level, model, count, avg_clarity = row
-                if model in metrics['models']:
-                    metrics['models'][model]['student_levels'][level] = {
-                        'count': count,
-                        'avg_clarity': float(avg_clarity) if avg_clarity else 0
-                    }
+            try:
+                total_users = db.query(User).count()
+                total_content = db.query(ContentHistory).count()
+                total_feedback = db.query(Feedback).count()
+                
+                metrics['database_summary'] = {
+                    'total_users': total_users,
+                    'total_content': total_content,
+                    'total_feedback': total_feedback
+                }
+            except Exception as e:
+                print(f"⚠️ Database summary error: {e}")
+                # Use fallback values
+                metrics['database_summary'] = {
+                    'total_users': 0,
+                    'total_content': 0,
+                    'total_feedback': 0
+                }
 
-            # Complexity distribution - FIXED
-            complexity_query = db.query(
-                ContentHistory.generated_model,
-                Feedback.complexity,
-                func.count(Feedback.id).label('count')
-            ).join(Feedback, ContentHistory.id == Feedback.content_id).filter(
-                Feedback.complexity.isnot(None)
-            ).group_by(
-                ContentHistory.generated_model, Feedback.complexity
-            ).all()
+            # User type analysis - FIXED with error handling
+            try:
+                user_type_query = db.query(
+                    ContentHistory.user_type,
+                    ContentHistory.generated_model,
+                    func.count(Feedback.id).label('count'),
+                    func.avg(Feedback.clarity).label('avg_clarity'),
+                    func.avg(Feedback.depth).label('avg_depth')
+                ).join(Feedback, ContentHistory.id == Feedback.content_id).group_by(
+                    ContentHistory.user_type, ContentHistory.generated_model
+                ).all()
+
+                for row in user_type_query:
+                    user_type, model, count, avg_clarity, avg_depth = row
+                    if model in metrics['models']:
+                        metrics['models'][model]['user_types'][user_type] = {
+                            'count': count,
+                            'avg_clarity': float(avg_clarity) if avg_clarity else 0,
+                            'avg_depth': float(avg_depth) if avg_depth else 0
+                        }
+            except Exception as e:
+                print(f"⚠️ User type analysis error: {e}")
 
-            for row in complexity_query:
-                model, complexity, count = row
-                if model in metrics['models']:
-                    metrics['models'][model]['complexity_distribution'][complexity] = count
-
-            # Comment analysis - FIXED
-            comment_query = db.query(
-                ContentHistory.generated_model,
-                func.avg(func.length(Feedback.comments)).label('avg_length'),
-                func.count().filter(
-                    Feedback.clarity >= 4, 
-                    Feedback.depth >= 4,
-                    func.length(Feedback.comments) > 25
-                ).label('high_quality_count')
-            ).join(Feedback, ContentHistory.id == Feedback.content_id).group_by(
-                ContentHistory.generated_model
-            ).all()
+            # Student level analysis - FIXED with error handling
+            try:
+                level_query = db.query(
+                    ContentHistory.student_level,
+                    ContentHistory.generated_model,
+                    func.count(Feedback.id).label('count'),
+                    func.avg(Feedback.clarity).label('avg_clarity')
+                ).join(Feedback, ContentHistory.id == Feedback.content_id).group_by(
+                    ContentHistory.student_level, ContentHistory.generated_model
+                ).all()
+
+                for row in level_query:
+                    level, model, count, avg_clarity = row
+                    if model in metrics['models']:
+                        metrics['models'][model]['student_levels'][level] = {
+                            'count': count,
+                            'avg_clarity': float(avg_clarity) if avg_clarity else 0
+                        }
+            except Exception as e:
+                print(f"⚠️ Student level analysis error: {e}")
 
-            for row in comment_query:
-                model, avg_length, hq_count = row
-                if model in metrics['models']:
-                    metrics['models'][model]['comment_analysis'] = {
-                        'avg_length': float(avg_length) if avg_length else 0,
-                        'high_quality_count': hq_count or 0
-                    }
+            # Complexity distribution - FIXED with error handling
+            try:
+                complexity_query = db.query(
+                    ContentHistory.generated_model,
+                    Feedback.complexity,
+                    func.count(Feedback.id).label('count')
+                ).join(Feedback, ContentHistory.id == Feedback.content_id).filter(
+                    Feedback.complexity.isnot(None)
+                ).group_by(
+                    ContentHistory.generated_model, Feedback.complexity
+                ).all()
+
+                for row in complexity_query:
+                    model, complexity, count = row
+                    if model in metrics['models']:
+                        metrics['models'][model]['complexity_distribution'][complexity] = count
+            except Exception as e:
+                print(f"⚠️ Complexity distribution error: {e}")
 
-            # Regeneration type analysis - FIXED
-            regeneration_query = db.query(
-                ContentHistory.generated_model,
-                Feedback.regeneration_type,
-                func.count(Feedback.id).label('count')
-            ).join(Feedback, ContentHistory.id == Feedback.content_id).filter(
-                Feedback.regeneration_type.isnot(None)
-            ).group_by(
-                ContentHistory.generated_model, Feedback.regeneration_type
-            ).all()
+            # Comment analysis - FIXED with error handling
+            try:
+                comment_query = db.query(
+                    ContentHistory.generated_model,
+                    func.avg(func.length(Feedback.comments)).label('avg_length'),
+                    func.count().filter(
+                        Feedback.clarity >= 4, 
+                        Feedback.depth >= 4,
+                        func.length(Feedback.comments) > 25
+                    ).label('high_quality_count')
+                ).join(Feedback, ContentHistory.id == Feedback.content_id).group_by(
+                    ContentHistory.generated_model
+                ).all()
+
+                for row in comment_query:
+                    model, avg_length, hq_count = row
+                    if model in metrics['models']:
+                        metrics['models'][model]['comment_analysis'] = {
+                            'avg_length': float(avg_length) if avg_length else 0,
+                            'high_quality_count': hq_count or 0
+                        }
+            except Exception as e:
+                print(f"⚠️ Comment analysis error: {e}")
 
-            for row in regeneration_query:
-                model, regeneration_type, count = row
-                if model in metrics['models']:
-                    metrics['models'][model]['regeneration_types'][regeneration_type] = count
+            # Regeneration type analysis - FIXED with error handling
+            try:
+                regeneration_query = db.query(
+                    ContentHistory.generated_model,
+                    Feedback.regeneration_type,
+                    func.count(Feedback.id).label('count')
+                ).join(Feedback, ContentHistory.id == Feedback.content_id).filter(
+                    Feedback.regeneration_type.isnot(None)
+                ).group_by(
+                    ContentHistory.generated_model, Feedback.regeneration_type
+                ).all()
+
+                for row in regeneration_query:
+                    model, regeneration_type, count = row
+                    if model in metrics['models']:
+                        metrics['models'][model]['regeneration_types'][regeneration_type] = count
+            except Exception as e:
+                print(f"⚠️ Regeneration type analysis error: {e}")
 
             print(f"✅ Advanced metrics loaded: {total_users} users, {total_content} content, {total_feedback} feedback")
             return metrics