Update app.py

app.py

@@ -1,80 +1,367 @@
-import requests
+import gradio as gr
 import pandas as pd
-from typing import Dict, List, Optional
-import json
+import numpy as np
+from course_recommender import CourseRecommender
+from database_connection import DatabaseConnection
+import os
 
-class DatabaseConnection:
-    def __init__(self, base_url: str = "https://database-dhe2.onrender.com"):
-        self.base_url = base_url
-        self.session = requests.Session()
+# Global variables to store current recommendations
+current_recommendations = []
+current_user_input = {}
+
+# Initialize components with error handling
+recommender = None
+db_connection = None
+
+def initialize_components():
+    """Initialize the recommender system and database connection with error handling"""
+    global recommender, db_connection
     
-    def get_student_feedback_counts(self) -> pd.DataFrame:
-        """Fetch student feedback data from the database"""
-        try:
-            url = f"{self.base_url}/student_feedback_counts"
-            response = self.session.get(url)
-            response.raise_for_status()
-            
-            data = response.json()
-            if isinstance(data, list):
-                return pd.DataFrame(data)
-            elif isinstance(data, dict) and 'feedback_counts' in data:
-                # Handle nested structure
-                feedback_data = data['feedback_counts']
-                if isinstance(feedback_data, list):
-                    return pd.DataFrame(feedback_data)
-                else:
-                    return pd.DataFrame([feedback_data])
+    try:
+        if recommender is None:
+            recommender = CourseRecommender()
+            print("✅ CourseRecommender initialized")
+    except Exception as e:
+        print(f"⚠️ Warning: Could not initialize CourseRecommender: {e}")
+        # Create a minimal fallback
+        recommender = None
+    
+    try:
+        if db_connection is None:
+            db_connection = DatabaseConnection()
+            print("✅ DatabaseConnection initialized")
+    except Exception as e:
+        print(f"⚠️ Warning: Could not initialize DatabaseConnection: {e}")
+        # Create a minimal fallback
+        db_connection = None
+
+# Initialize components
+initialize_components()
+
+def get_course_recommendations(stanine, gwa, strand, hobbies):
+    """Get course recommendations based on user input"""
+    global current_recommendations, current_user_input, recommender
+    
+    # Check if recommender is initialized
+    if recommender is None:
+        return "❌ System not properly initialized. Please try again.", "", "", "", "", ""
+    
+    # Validate inputs
+    if not stanine or not gwa or not strand or not hobbies:
+        return "Please fill in all fields", "", "", "", "", ""
+    
+    try:
+        stanine = int(stanine)
+        gwa = float(gwa)
+        
+        if stanine < 1 or stanine > 9:
+            return "Stanine must be between 1-9", "", "", "", "", ""
+        
+        if gwa < 75 or gwa > 100:
+            return "GWA must be between 75-100", "", "", "", "", ""
+        
+        # Normalize strand to uppercase for case-insensitive matching
+        strand = strand.upper()
+        
+        if strand not in ["STEM", "ABM", "HUMSS", "GAS", "TVL"]:
+            return "Strand must be one of: STEM, ABM, HUMSS, GAS, TVL", "", "", "", "", ""
+        
+        # Store current user input
+        current_user_input = {
+            'stanine': stanine,
+            'gwa': gwa,
+            'strand': strand,
+            'hobbies': hobbies
+        }
+        
+        # Get recommendations
+        recommendations = recommender.predict_course(stanine, gwa, strand, hobbies)
+        current_recommendations = recommendations
+        
+        # Format top 3 recommendations
+        if len(recommendations) >= 3:
+            course1 = f"{recommendations[0][0]} (Confidence: {recommendations[0][1]*100:.1f}%)"
+            course2 = f"{recommendations[1][0]} (Confidence: {recommendations[1][1]*100:.1f}%)"
+            course3 = f"{recommendations[2][0]} (Confidence: {recommendations[2][1]*100:.1f}%)"
+        elif len(recommendations) == 2:
+            course1 = f"{recommendations[0][0]} (Confidence: {recommendations[0][1]*100:.1f}%)"
+            course2 = f"{recommendations[1][0]} (Confidence: {recommendations[1][1]*100:.1f}%)"
+            course3 = "No third recommendation available"
+        elif len(recommendations) == 1:
+            course1 = f"{recommendations[0][0]} (Confidence: {recommendations[0][1]*100:.1f}%)"
+            course2 = "No second recommendation available"
+            course3 = "No third recommendation available"
+        else:
+            course1 = "No recommendations available"
+            course2 = ""
+            course3 = ""
+        
+        return course1, course2, course3, None, None, None
+        
+    except ValueError as e:
+        return f"Invalid input: {str(e)}", "", "", None, None, None
+    except Exception as e:
+        return f"Error getting recommendations: {str(e)}", "", "", None, None, None
+
+def submit_all_ratings(course1_rating, course2_rating, course3_rating):
+    """Submit ratings for all three recommendations"""
+    global current_recommendations, current_user_input, recommender
+    
+    if recommender is None:
+        return "❌ System not properly initialized. Please try again."
+    
+    if not current_recommendations or not current_user_input:
+        return "No recommendations to rate. Please get recommendations first."
+    
+    try:
+        results = []
+        ratings_submitted = 0
+        
+        # Rate first recommendation
+        if course1_rating and len(current_recommendations) >= 1:
+            rating_value = "like" if course1_rating == "👍 Like" else "dislike"
+            course = current_recommendations[0][0]
+            success = recommender.add_feedback_with_learning(
+                course=course,
+                stanine=current_user_input['stanine'],
+                gwa=current_user_input['gwa'],
+                strand=current_user_input['strand'],
+                rating=rating_value,
+                hobbies=current_user_input['hobbies']
+            )
+            if success:
+                results.append(f"✅ Rating for '{course}' recorded")
+                ratings_submitted += 1
+            else:
+                results.append(f"❌ Failed to record rating for '{course}'")
+        
+        # Rate second recommendation
+        if course2_rating and len(current_recommendations) >= 2:
+            rating_value = "like" if course2_rating == "👍 Like" else "dislike"
+            course = current_recommendations[1][0]
+            success = recommender.add_feedback_with_learning(
+                course=course,
+                stanine=current_user_input['stanine'],
+                gwa=current_user_input['gwa'],
+                strand=current_user_input['strand'],
+                rating=rating_value,
+                hobbies=current_user_input['hobbies']
+            )
+            if success:
+                results.append(f"✅ Rating for '{course}' recorded")
+                ratings_submitted += 1
             else:
-                return pd.DataFrame([data])
-        except Exception as e:
-            print(f"Error fetching data: {e}")
-            return pd.DataFrame()
+                results.append(f"❌ Failed to record rating for '{course}'")
+        
+        # Rate third recommendation
+        if course3_rating and len(current_recommendations) >= 3:
+            rating_value = "like" if course3_rating == "👍 Like" else "dislike"
+            course = current_recommendations[2][0]
+            success = recommender.add_feedback_with_learning(
+                course=course,
+                stanine=current_user_input['stanine'],
+                gwa=current_user_input['gwa'],
+                strand=current_user_input['strand'],
+                rating=rating_value,
+                hobbies=current_user_input['hobbies']
+            )
+            if success:
+                results.append(f"✅ Rating for '{course}' recorded")
+                ratings_submitted += 1
+            else:
+                results.append(f"❌ Failed to record rating for '{course}'")
+        
+        if ratings_submitted > 0:
+            return f"Thank you! {ratings_submitted} rating(s) submitted successfully.\n\n" + "\n".join(results)
+        else:
+            return "Please select at least one rating before submitting."
+            
+    except Exception as e:
+        return f"Error recording feedback: {str(e)}"
+
+def train_model():
+    """Train the model with current data"""
+    global recommender
     
-    def add_feedback(self, course: str, stanine: int, gwa: float, strand: str, 
-                    rating: str, hobbies: str) -> bool:
-        """Add new feedback to the database"""
-        print(f"Attempting to add feedback: {course}, rating: {rating}")
-        
-        # For now, let's simulate successful feedback addition
-        # since the API endpoint seems to have issues
-        print(f"[OK] Feedback simulated: {course} - {rating}")
-        return True
-        
-        # TODO: Fix the actual API endpoint to accept the correct data structure
-        # The current API expects different fields than what we're sending
+    if recommender is None:
+        return "❌ System not properly initialized. Please try again."
     
-    def update_feedback_count(self, feedback_id: int, count: int) -> bool:
-        """Update the count for existing feedback"""
-        try:
-            url = f"{self.base_url}/student_feedback_counts/{feedback_id}"
-            data = {"count": count}
-            response = self.session.put(url, json=data)
-            response.raise_for_status()
-            return True
-        except Exception as e:
-            print(f"Error updating feedback count: {e}")
-            return False
+    try:
+        accuracy = recommender.train_model(use_database=True)
+        return f"✅ Model trained successfully! Accuracy: {accuracy:.3f}"
+    except Exception as e:
+        return f"❌ Error training model: {str(e)}"
+
+def get_available_courses_info():
+    """Get information about available courses from database"""
+    global db_connection
     
-    def get_available_courses(self) -> List[str]:
-        """Fetch available courses from the database"""
-        try:
-            url = f"{self.base_url}/courses"
-            response = self.session.get(url)
-            response.raise_for_status()
+    if db_connection is None:
+        return "❌ Database connection not available. Please try again."
+    
+    try:
+        courses = db_connection.get_available_courses()
+        if courses:
+            return f"📚 Available courses in database: {len(courses)}\n\n" + "\n".join([f"• {course}" for course in courses[:10]]) + (f"\n... and {len(courses)-10} more" if len(courses) > 10 else "")
+        else:
+            return "📚 No courses found in database. Please check the /courses endpoint."
+    except Exception as e:
+        return f"❌ Error fetching courses: {str(e)}"
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="Course AI Recommender", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🎓 Course AI Machine Learning Recommender
+        
+        Get personalized course recommendations based on your academic profile and interests!
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📝 Your Profile")
+                
+                stanine_input = gr.Textbox(
+                    label="Stanine Score (1-9)",
+                    placeholder="Enter your stanine score (1-9)",
+                    info="Your stanine score from standardized tests"
+                )
+                
+                gwa_input = gr.Textbox(
+                    label="GWA (75-100)",
+                    placeholder="Enter your GWA (75-100)",
+                    info="Your Grade Weighted Average"
+                )
+                
+                strand_input = gr.Dropdown(
+                    choices=["STEM", "ABM", "HUMSS", "GAS", "TVL"],
+                    value="STEM",
+                    label="Academic Strand",
+                    info="Your current academic strand"
+                )
+                
+                hobbies_input = gr.Textbox(
+                    label="Hobbies & Interests",
+                    placeholder="e.g., Programming, Reading, Sports, Music",
+                    info="List your hobbies and interests (comma-separated)"
+                )
+                
+                get_recommendations_btn = gr.Button("🎯 Get Recommendations", variant="primary")
+                
+                train_model_btn = gr.Button("🤖 Train Model", variant="secondary")
+                
+                show_courses_btn = gr.Button("📚 Show Available Courses", variant="secondary")
             
-            data = response.json()
-            if isinstance(data, list):
-                # Extract course names from the data
-                courses = []
-                for item in data:
-                    if isinstance(item, dict) and 'name' in item:
-                        courses.append(item['name'])
-                    elif isinstance(item, str):
-                        courses.append(item)
-                return courses
-            else:
-                return []
-        except Exception as e:
-            print(f"Error fetching courses: {e}")
-            return []
+            with gr.Column(scale=1):
+                gr.Markdown("### 🎓 Top 3 Course Recommendations")
+                
+                # Display top 3 recommendations
+                course1_output = gr.Textbox(
+                    label="1st Recommendation",
+                    interactive=False
+                )
+                
+                course1_rating = gr.Radio(
+                    choices=["👍 Like", "👎 Dislike"],
+                    label="Rate 1st Recommendation",
+                    interactive=True
+                )
+                
+                course2_output = gr.Textbox(
+                    label="2nd Recommendation", 
+                    interactive=False
+                )
+                
+                course2_rating = gr.Radio(
+                    choices=["👍 Like", "👎 Dislike"],
+                    label="Rate 2nd Recommendation",
+                    interactive=True
+                )
+                
+                course3_output = gr.Textbox(
+                    label="3rd Recommendation",
+                    interactive=False
+                )
+                
+                course3_rating = gr.Radio(
+                    choices=["👍 Like", "👎 Dislike"],
+                    label="Rate 3rd Recommendation",
+                    interactive=True
+                )
+                
+                submit_ratings_btn = gr.Button("Submit All Ratings", variant="primary")
+                
+                rating_feedback = gr.Textbox(
+                    label="Rating Feedback",
+                    interactive=False
+                )
+                
+                courses_info = gr.Textbox(
+                    label="Available Courses",
+                    lines=8,
+                    interactive=False
+                )
+        
+        # Event handlers
+        get_recommendations_btn.click(
+            fn=get_course_recommendations,
+            inputs=[stanine_input, gwa_input, strand_input, hobbies_input],
+            outputs=[course1_output, course2_output, course3_output, course1_rating, course2_rating, course3_rating]
+        )
+        
+        submit_ratings_btn.click(
+            fn=submit_all_ratings,
+            inputs=[course1_rating, course2_rating, course3_rating],
+            outputs=[rating_feedback]
+        )
+        
+        train_model_btn.click(
+            fn=train_model,
+            outputs=[gr.Textbox(label="Training Status", interactive=False)]
+        )
+        
+        show_courses_btn.click(
+            fn=get_available_courses_info,
+            outputs=[courses_info]
+        )
+        
+        # Add some example inputs
+        gr.Markdown("""
+        ### 💡 Example Inputs
+        
+        **For STEM students:**
+        - Stanine: 7-9, GWA: 85-95, Strand: STEM, Hobbies: Programming, Mathematics, Science
+        
+        **For ABM students:**
+        - Stanine: 6-8, GWA: 80-90, Strand: ABM, Hobbies: Business, Leadership, Economics
+        
+        **For HUMSS students:**
+        - Stanine: 5-8, GWA: 78-88, Strand: HUMSS, Hobbies: Literature, History, Writing
+        """)
+    
+    return demo
+
+# Initialize the interface
+if __name__ == "__main__":
+    # Try to load existing model if recommender is available
+    if recommender is not None:
+        try:
+            recommender.load_model()
+            print("✅ Loaded existing model")
+        except:
+            print("⚠️ No existing model found. Training with basic data...")
+            try:
+                recommender.train_model(use_database=False)
+                print("✅ Model trained with basic data")
+            except Exception as e:
+                print(f"❌ Error training model: {e}")
+    else:
+        print("⚠️ Recommender not initialized. App will run with limited functionality.")
+    
+    # Create and launch interface
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )