Update recommender.py

recommender.py

@@ -8,10 +8,11 @@ import os
 import requests
 
 class CourseRecommender:
-    def __init__(self):
+    def __init__(self, database_url="https://database-dhe2.onrender.com"):
         self.model = None
         self.label_encoders = {}
         self.scaler = StandardScaler()
+        self.database_url = database_url
         self.courses = self.get_courses()
         self.training_data = self.get_training_data()
         self.train_model()
@@ -58,17 +59,92 @@ class CourseRecommender:
         }
 
     def save_student_data(self, stanine, gwa, strand, course, rating, hobbies=None):
-        """Save student feedback to in-memory storage (for demonstration purposes)"""
-        try:
-            # In a real implementation, you could save this to a file or external storage
-            print(f"Student feedback saved: Stanine={stanine}, GWA={gwa}, Strand={strand}, Course={course}, Rating={rating}, Hobbies={hobbies}")
+        """Save student feedback (disabled - read-only mode)"""
+        print(f"Student feedback (read-only mode): Stanine={stanine}, GWA={gwa}, Strand={strand}, Course={course}, Rating={rating}, Hobbies={hobbies}")
             return True
-        except Exception as e:
-            print(f"Error saving student feedback: {e}")
-            return False
 
     def get_training_data(self):
-        """Get training data for the provided courses only (including GAS, TVL)"""
+        """Get training data from database, fallback to static data"""
+        try:
+            # Try to get data from database first
+            db_data = self.get_training_data_from_database()
+            if db_data is not None and not db_data.empty:
+                print(f"Loaded {len(db_data)} training records from database")
+                return db_data
+            else:
+                print("No database data available, using static training data")
+                return self.get_static_training_data()
+        except Exception as e:
+            print(f"Error loading database data: {e}, using static training data")
+            return self.get_static_training_data()
+
+    def get_training_data_from_database(self):
+        """Fetch training data from database using existing endpoints"""
+        try:
+            print(f"Attempting to fetch data from database: {self.database_url}/student_feedback_counts")
+            
+            # Try to get student feedback data from your existing endpoint
+            response = requests.get(f"{self.database_url}/student_feedback_counts", timeout=10)
+            
+            print(f"Database response status: {response.status_code}")
+            
+            if response.status_code == 200:
+                data = response.json()
+                print(f"Response data keys: {list(data.keys())}")
+                
+                feedback_counts = data.get('feedback_counts', [])
+                print(f"Number of records in database: {len(feedback_counts)}")
+                
+                if not feedback_counts:
+                    print("No student feedback data found in database")
+                    return None
+                
+                # Convert database data to training format
+                training_data = []
+                valid_records = 0
+                
+                for i, record in enumerate(feedback_counts):
+                    print(f"Processing record {i+1}: {record}")
+                    
+                    # Check if record has the required fields
+                    if all(key in record for key in ['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies']):
+                        training_data.append((
+                            int(record['stanine']),
+                            float(record['gwa']), 
+                            str(record['strand']),
+                            str(record['course']),
+                            int(record['rating']),
+                            str(record['hobbies'] or '')
+                        ))
+                        valid_records += 1
+                    else:
+                        missing_fields = [key for key in ['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies'] if key not in record]
+                        print(f"Record {i+1} missing fields: {missing_fields}")
+                
+                print(f"Valid records processed: {valid_records}/{len(feedback_counts)}")
+                
+                if training_data:
+                    print(f"Successfully loaded {len(training_data)} records from database")
+                    return pd.DataFrame(training_data, columns=['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies'])
+                else:
+                    print("No valid training records found in database")
+                    return None
+            else:
+                print(f"Database endpoint returned status {response.status_code}")
+                print(f"Response text: {response.text}")
+                return None
+            
+        except requests.exceptions.ConnectionError:
+            print("Cannot connect to database - using static data")
+            return None
+        except Exception as e:
+            print(f"Error fetching training data from database: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+
+    def get_static_training_data(self):
+        """Get static training data for the provided courses only (including GAS, TVL)"""
         training_data = [
             # CASTECH - Agriculture Science and Technology
             (8, 92, 'STEM', 'BSA', 5, 'farming, agriculture, plants, environment'),
@@ -103,6 +179,12 @@ class CourseRecommender:
             (9, 94, 'STEM', 'BSMath', 4, 'mathematics, problem solving, logic'),
             (7, 82, 'HUMSS', 'BAELS', 3, 'english, language, communication'),
             (6, 80, 'HUMSS', 'BSDevComm', 3, 'communication, media, development'),
+            
+            # HUMSS students with programming interests
+            (8, 90, 'HUMSS', 'BSIT', 5, 'programming, computers, technology, coding'),
+            (7, 85, 'HUMSS', 'BSCpE', 4, 'programming, computer engineering, hardware'),
+            (8, 88, 'HUMSS', 'BSDevComm', 4, 'programming, media, communication, technology'),
+            (6, 80, 'HUMSS', 'BSIT', 3, 'programming, computers, ict'),
 
             # GAS - General Academic Strand (broad interests)
             (7, 85, 'GAS', 'BAELS', 4, 'communication, language, writing, literature'),
@@ -187,11 +269,65 @@ class CourseRecommender:
             
             print("Model trained successfully")
             print(f"Model classes: {self.model.classes_}")
+            print(f"Training data size: {len(training_data)} records")
             
         except Exception as e:
             print(f"Error training model: {e}")
             self.model = None
 
+    def refresh_training_data(self):
+        """Refresh training data from database (read-only mode)"""
+        try:
+            print("Refreshing training data from database...")
+            self.training_data = self.get_training_data()
+            self.train_model()
+            return True
+        except Exception as e:
+            print(f"Error refreshing training data: {e}")
+            return False
+
+    def test_database_connection(self):
+        """Test database connection and show detailed info"""
+        print("=== DATABASE CONNECTION TEST ===")
+        try:
+            response = requests.get(f"{self.database_url}/student_feedback_counts", timeout=10)
+            print(f"Database URL: {self.database_url}")
+            print(f"Response Status: {response.status_code}")
+            
+            if response.status_code == 200:
+                data = response.json()
+                print(f"Response Keys: {list(data.keys())}")
+                
+                if 'feedback_counts' in data:
+                    records = data['feedback_counts']
+                    print(f"Number of Records: {len(records)}")
+                    
+                    if len(records) > 0:
+                        print(f"Sample Record: {records[0]}")
+                        
+                        # Check required fields
+                        required_fields = ['stanine', 'gwa', 'strand', 'course', 'rating', 'hobbies']
+                        sample_record = records[0]
+                        missing_fields = [field for field in required_fields if field not in sample_record]
+                        
+                        if missing_fields:
+                            print(f"Missing Required Fields: {missing_fields}")
+                            print(f"Available Fields: {list(sample_record.keys())}")
+                        else:
+                            print("All required fields present")
+                    else:
+                        print("Database is empty")
+                else:
+                    print("'feedback_counts' key not found in response")
+            else:
+                print(f"Database Error: {response.status_code}")
+                print(f"Response: {response.text}")
+                
+        except Exception as e:
+            print(f"Connection Error: {e}")
+            import traceback
+            traceback.print_exc()
+
     def get_default_recommendations(self, stanine, gwa, strand, hobbies: str = ""):
         """Provide default recommendations based on basic rules when no training data is available"""
         courses = self.courses
@@ -212,7 +348,14 @@ class CourseRecommender:
             else:
                 priority_courses = ['BSHM', 'BSEntrep', 'BSAgribus']
         elif strand == 'HUMSS':
-            if stanine >= 8 and gwa >= 90:
+            # HUMSS students with programming interests should get tech courses
+            if any(k in hobbies_lc for k in ['programming', 'computer', 'ict', 'tech', 'coding']):
+                priority_courses = ['BSIT', 'BSCpE', 'BSDevComm']
+            elif any(k in hobbies_lc for k in ['teaching', 'education', 'helping', 'children']):
+                priority_courses = ['BSED', 'BEED', 'BTLEd']
+            elif any(k in hobbies_lc for k in ['communication', 'media', 'writing', 'language']):
+                priority_courses = ['BAELS', 'BSDevComm', 'BSHM']
+            elif stanine >= 8 and gwa >= 90:
                 priority_courses = ['BSED', 'BEED', 'BAELS', 'BSDevComm', 'BPE']
             else:
                 priority_courses = ['BSED', 'BEED', 'BAELS', 'BTLEd']
@@ -279,9 +422,18 @@ class CourseRecommender:
                 if col in input_data.columns and col in self.label_encoders:
                     value = input_data[col].iloc[0]
                     if value not in self.label_encoders[col].classes_:
-                        # Use default encoding for unseen values
-                        print(f"Warning: Unseen value '{value}' in {col}, using default encoding")
-                        input_data[col] = 0  # Default to first encoded value
+                        # For hobbies, try to find a similar existing hobby
+                        if col == 'hobbies':
+                            similar_hobby = self._find_similar_hobby(value)
+                            if similar_hobby:
+                                print(f"Warning: Unseen hobby '{value}', using similar: '{similar_hobby}'")
+                                input_data[col] = self.label_encoders[col].transform([similar_hobby])[0]
+                            else:
+                                print(f"Warning: Unseen hobby '{value}', using default encoding")
+                                input_data[col] = 0
+                        else:
+                            print(f"Warning: Unseen value '{value}' in {col}, using default encoding")
+                            input_data[col] = 0
                     else:
                         input_data[col] = self.label_encoders[col].transform([value])[0]
             
@@ -308,11 +460,11 @@ class CourseRecommender:
                 
                 # Only include courses with meaningful probabilities
                 if confidence > 0.01:  # Threshold for meaningful recommendations
-                    recommendations.append({
-                        'code': code,
-                        'name': course_map.get(code, code),
-                        'rating': round(confidence * 100, 1)
-                    })
+                recommendations.append({
+                    'code': code,
+                    'name': course_map.get(code, code),
+                    'rating': round(confidence * 100, 1)
+                })
             
             # If no meaningful recommendations, fall back to default
             if not recommendations:
@@ -325,6 +477,33 @@ class CourseRecommender:
             print(f"Error recommending courses: {e}")
             return self.get_default_recommendations(stanine, gwa, strand, hobbies or "")
 
+    def _find_similar_hobby(self, hobby):
+        """Find a similar hobby from training data"""
+        hobby_lower = hobby.lower()
+        
+        # Define keyword mappings for similar hobbies
+        keyword_mappings = {
+            'programming': ['programming', 'computers', 'technology', 'coding', 'ict'],
+            'computers': ['programming', 'computers', 'technology', 'coding', 'ict'],
+            'technology': ['programming', 'computers', 'technology', 'coding', 'ict'],
+            'teaching': ['teaching', 'education', 'helping', 'children'],
+            'business': ['business', 'entrepreneurship', 'management', 'leadership'],
+            'hospitality': ['hospitality', 'tourism', 'service', 'events'],
+            'agriculture': ['farming', 'agriculture', 'plants', 'environment'],
+            'communication': ['communication', 'media', 'writing', 'language']
+        }
+        
+        # Check if any keyword matches
+        for key, keywords in keyword_mappings.items():
+            if any(keyword in hobby_lower for keyword in keywords):
+                # Find the most similar training hobby
+                training_hobbies = self.label_encoders['hobbies'].classes_
+                for training_hobby in training_hobbies:
+                    if any(keyword in training_hobby.lower() for keyword in keywords):
+                        return training_hobby
+        
+        return None
+
     def _get_recommendation_reason(self, course, stanine, gwa, strand, hobbies, interests, personality_type, learning_style, career_goals):
         """Generate personalized reason for recommendation"""
         reasons = []
@@ -416,19 +595,19 @@ def get_course_recommendations_ui(recommender: "CourseRecommender", stanine, gwa
         try:
             stanine = int(stanine.strip()) if isinstance(stanine, str) else int(stanine)
         except (ValueError, TypeError, AttributeError):
-            return "❌ Stanine score must be a valid number between 1 and 9"
+            return "Stanine score must be a valid number between 1 and 9"
         try:
             gwa = float(gwa.strip()) if isinstance(gwa, str) else float(gwa)
         except (ValueError, TypeError, AttributeError):
-            return "❌ GWA must be a valid number between 75 and 100"
+            return "GWA must be a valid number between 75 and 100"
         if not (1 <= stanine <= 9):
-            return "❌ Stanine score must be between 1 and 9"
+            return "Stanine score must be between 1 and 9"
         if not (75 <= gwa <= 100):
-            return "❌ GWA must be between 75 and 100"
+            return "GWA must be between 75 and 100"
         if not strand:
-            return "❌ Please select a strand"
+            return "Please select a strand"
         if not hobbies or not str(hobbies).strip():
-            return "❌ Please enter your hobbies/interests"
+            return "Please enter your hobbies/interests"
 
         recommendations = recommender.recommend_courses(
             stanine=stanine,
@@ -438,7 +617,7 @@ def get_course_recommendations_ui(recommender: "CourseRecommender", stanine, gwa
         )
         if not recommendations:
             return "No recommendations available at the moment."
-        response = f"## 🎯 Course Recommendations for You\n\n"
+        response = f"## Course Recommendations for You\n\n"
         response += f"**Profile:** Stanine {stanine}, GWA {gwa}, {strand} Strand\n"
         response += f"**Interests:** {hobbies}\n\n"
         for i, rec in enumerate(recommendations, 1):
@@ -446,7 +625,7 @@ def get_course_recommendations_ui(recommender: "CourseRecommender", stanine, gwa
             response += f"**Match Score:** {rec.get('rating', rec.get('probability', 0)):.1f}%\n\n"
         return response
     except Exception as e:
-        return f"❌ Error getting recommendations: {str(e)}"
+        return f"Error getting recommendations: {str(e)}"
 
 # Example usage
 if __name__ == "__main__":