Delete chatbot.py

chatbot.py

@@ -1,453 +0,0 @@
-import requests
-import json
-from sentence_transformers import SentenceTransformer
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-from recommender import CourseRecommender
-import re
-import string
-from difflib import SequenceMatcher
-import random
-import time
-
-class Chatbot:
-    def __init__(self):
-        self.qa_pairs = []
-        self.question_embeddings = []
-        self.model = None
-        self.database_url = "https://database-dhe2.onrender.com"
-        self.recommender = None
-        self.conversation_history = []
-        self.user_context = {}
-        self.load_model()
-        self.load_recommender()
-        self.load_qa_data()
-        self.load_conversational_responses()
-    
-    def load_model(self):
-        """Load the sentence transformer model with error handling"""
-        import time
-        import os
-        
-        # List of models to try in order of preference
-        models_to_try = [
-            'all-MiniLM-L6-v2',
-            'paraphrase-MiniLM-L6-v2',
-            'all-MiniLM-L12-v2'
-        ]
-        
-        for model_name in models_to_try:
-            try:
-                print(f"Loading sentence transformer model: {model_name}...")
-                
-                # Try with cache directory first
-                cache_dir = os.path.join(os.getcwd(), 'model_cache')
-                os.makedirs(cache_dir, exist_ok=True)
-                
-                self.model = SentenceTransformer(model_name, cache_folder=cache_dir)
-                print(f"Model {model_name} loaded successfully")
-                return
-                
-            except Exception as e:
-                print(f"Error loading {model_name}: {str(e)}")
-                continue
-        
-        # If all models fail, try without cache
-        try:
-            print("Trying without cache directory...")
-            self.model = SentenceTransformer('all-MiniLM-L6-v2')
-            print("Model loaded successfully without cache")
-        except Exception as e:
-            print(f"Final attempt failed: {str(e)}")
-            raise Exception("Could not load any sentence transformer model")
-    
-    def load_recommender(self):
-        """Load the course recommender with error handling"""
-        try:
-            print("Loading course recommender...")
-            self.recommender = CourseRecommender()
-            print("Recommender loaded successfully")
-        except Exception as e:
-            print(f"Error loading recommender: {str(e)}")
-            self.recommender = None
-    
-    def load_qa_data(self):
-        """Load Q&A pairs from the faqs table in the database"""
-        try:
-            # The API requires a question parameter, so we can't load all FAQs at once
-            # Instead, we'll use the API for real-time querying and keep fallback data
-            print("Database API requires question parameter - using real-time querying with fallback data")
-            self._load_fallback_data()
-        except Exception as e:
-            print(f"Error loading FAQ data: {str(e)}")
-            self._load_fallback_data()
-    
-    def _load_fallback_data(self):
-        """Load fallback data if database is unavailable"""
-        # No fallback data - rely entirely on database API and conversational responses
-        self.qa_pairs = []
-        self.question_embeddings = []
-        print("No fallback data loaded - using database API and conversational responses only")
-    
-    def load_conversational_responses(self):
-        """Load conversational response templates and patterns"""
-        self.conversational_patterns = {
-            'greetings': [
-                "Hello! How can I help you today?",
-                "Hi there! What can I assist you with?",
-                "Good day! I'm here to help with your questions.",
-                "Hello! I'm your AI assistant. What would you like to know?"
-            ],
-            'farewells': [
-                "Goodbye! Have a great day!",
-                "See you later! Feel free to ask if you need more help.",
-                "Take care! I'm here whenever you need assistance.",
-                "Bye! Don't hesitate to reach out if you have more questions."
-            ],
-            'thanks': [
-                "You're welcome! Is there anything else I can help you with?",
-                "My pleasure! What else would you like to know?",
-                "Happy to help! Any other questions?",
-                "Glad I could assist! Feel free to ask more questions."
-            ],
-            'confusion': [
-                "I'm not sure I understand that. Could you rephrase your question?",
-                "That's an interesting question. Could you provide more details?",
-                "I want to help you better. Can you explain that differently?",
-                "Let me try to understand. Could you ask that in another way?"
-            ],
-            'general_help': [
-                "I can help you with information about the university, courses, admissions, and more. What would you like to know?",
-                "I'm here to assist with university-related questions. What can I help you with?",
-                "I can provide information about courses, admissions, campus locations, and other university topics. What do you need?",
-                "Feel free to ask me about university services, courses, or any other questions you might have!"
-            ],
-            'encouragement': [
-                "That's a great question! Let me help you with that.",
-                "I'm here to help you find the information you need.",
-                "Don't worry, I'll do my best to assist you.",
-                "I understand you're looking for information. Let me help!"
-            ]
-        }
-        
-        # Common question patterns for better understanding
-        self.question_patterns = {
-            'location': ['where', 'location', 'address', 'find', 'located'],
-            'time': ['when', 'time', 'schedule', 'hours', 'open', 'close'],
-            'contact': ['contact', 'phone', 'email', 'call', 'reach'],
-            'admission': ['admission', 'apply', 'application', 'requirements', 'deadline'],
-            'course': ['course', 'program', 'degree', 'study', 'major'],
-            'help': ['help', 'assist', 'support', 'guide', 'how to']
-        }
-        
-        print("Conversational response system loaded")
-
-
-    def detect_conversation_intent(self, user_input):
-        """Detect the type of conversation the user is having"""
-        user_input_lower = user_input.lower().strip()
-        
-        # Greeting detection
-        greetings = ['hello', 'hi', 'hey', 'good morning', 'good afternoon', 'good evening', 'greetings']
-        if any(greeting in user_input_lower for greeting in greetings):
-            return 'greeting'
-        
-        # Farewell detection
-        farewells = ['bye', 'goodbye', 'see you', 'farewell', 'take care', 'later']
-        if any(farewell in user_input_lower for farewell in farewells):
-            return 'farewell'
-        
-        # Thanks detection
-        thanks = ['thank', 'thanks', 'appreciate', 'grateful']
-        if any(thank in user_input_lower for thank in thanks):
-            return 'thanks'
-        
-        # Help request detection
-        help_words = ['help', 'assist', 'support', 'guide', 'how', 'what can you do']
-        if any(help_word in user_input_lower for help_word in help_words):
-            return 'help_request'
-        
-        # Question type detection
-        for category, keywords in self.question_patterns.items():
-            if any(keyword in user_input_lower for keyword in keywords):
-                return f'question_{category}'
-        
-        return 'general_question'
-
-    def generate_conversational_response(self, user_input, intent=None):
-        """Generate a conversational response when no specific answer is found"""
-        if intent is None:
-            intent = self.detect_conversation_intent(user_input)
-        
-        # Store conversation context
-        self.conversation_history.append({
-            'user': user_input,
-            'intent': intent,
-            'timestamp': time.time()
-        })
-        
-        # Keep only last 10 interactions
-        if len(self.conversation_history) > 10:
-            self.conversation_history = self.conversation_history[-10:]
-        
-        # Generate response based on intent
-        if intent in self.conversational_patterns:
-            base_response = random.choice(self.conversational_patterns[intent])
-        else:
-            base_response = random.choice(self.conversational_patterns['general_help'])
-        
-        # Add contextual information based on question type
-        contextual_info = self.get_contextual_help(user_input, intent)
-        
-        if contextual_info:
-            response = f"{base_response}\n\n{contextual_info}"
-        else:
-            response = base_response
-        
-        # Add follow-up suggestions
-        suggestions = self.get_follow_up_suggestions(intent)
-        if suggestions:
-            response += f"\n\nYou might also want to ask about:\n{suggestions}"
-        
-        # Add note about logging the question for improvement
-        if intent not in ['greeting', 'farewell', 'thanks']:
-            response += f"\n\nNote: Your question has been logged to help improve our knowledge base."
-        
-        return response
-
-    def get_contextual_help(self, user_input, intent):
-        """Provide contextual help based on the question type"""
-        user_input_lower = user_input.lower()
-        
-        if intent == 'question_location':
-            return "I can help you find locations on campus. Try asking about specific places like 'admission office', 'library', 'cafeteria', or 'registrar office'."
-        
-        elif intent == 'question_time':
-            return "I can help with schedules and timing. Ask about office hours, class schedules, or event times."
-        
-        elif intent == 'question_contact':
-            return "I can help you find contact information. Ask about specific departments or offices you need to reach."
-        
-        elif intent == 'question_admission':
-            return "I can help with admission-related questions. Ask about requirements, deadlines, application process, or admission office location."
-        
-        elif intent == 'question_course':
-            return "I can help with course information. Ask about specific programs, requirements, or course recommendations."
-        
-        return None
-
-    def get_follow_up_suggestions(self, intent):
-        """Provide follow-up suggestions based on the conversation context"""
-        suggestions = {
-            'greeting': "• University services\n• Course information\n• Admission requirements\n• Campus locations",
-            'question_location': "• Admission office hours\n• Library location\n• Cafeteria hours\n• Parking areas",
-            'question_admission': "• Application deadlines\n• Required documents\n• Admission office location\n• Course requirements",
-            'question_course': "• Available programs\n• Course recommendations\n• Prerequisites\n• Career paths",
-            'help_request': "• Campus locations\n• University services\n• Course information\n• Admission process"
-        }
-        
-        return suggestions.get(intent, "• Campus information\n• University services\n• Course details\n• Admission help")
-
-    def query_database_api(self, user_input):
-        """Query the database API for a real-time answer"""
-        try:
-            faqs_url = f"{self.database_url}/faqs"
-            print(f"Querying database API: {faqs_url} with question: {user_input[:50]}...")
-            
-            response = requests.get(faqs_url, params={'question': user_input}, timeout=10)
-            print(f"Database API response: Status {response.status_code}")
-            
-            if response.status_code == 200:
-                data = response.json()
-                print(f"Database API data: {data}")
-                
-                if data.get('answer') and data.get('source') != 'not_found':
-                    print("Found answer in database")
-                    return {
-                        'question': user_input,
-                        'answer': data.get('answer'),
-                        'source': 'database'
-                    }
-                else:
-                    print("No answer found in database")
-                    # Log unanswered question for future improvement
-                    self.log_unanswered_question(user_input)
-            else:
-                print(f"Database API error: {response.status_code} - {response.text}")
-            return None
-        except requests.exceptions.Timeout:
-            print("Database API timeout")
-            return None
-        except requests.exceptions.ConnectionError:
-            print("Database API connection error")
-            return None
-        except Exception as e:
-            print(f"Error querying database API: {str(e)}")
-            return None
-
-    def log_unanswered_question(self, question):
-        """Log unanswered questions to the database for future reference"""
-        try:
-            unanswered_url = f"{self.database_url}/unanswered_questions"
-            
-            # Prepare data for unanswered question (matching your database server format)
-            unanswered_data = {
-                'question': question.strip()
-            }
-            
-            print(f"Logging unanswered question: {question[:50]}...")
-            
-            # Try to send to database
-            response = requests.post(unanswered_url, json=unanswered_data, timeout=5)
-            
-            if response.status_code == 200:
-                print("Unanswered question logged successfully")
-                return True
-            elif response.status_code == 201:
-                print("Unanswered question created successfully")
-                return True
-            else:
-                print(f"Failed to log unanswered question: {response.status_code} - {response.text[:100]}")
-                return False
-                
-        except requests.exceptions.Timeout:
-            print("Timeout logging unanswered question")
-            return False
-        except requests.exceptions.ConnectionError:
-            print("Connection error logging unanswered question")
-            return False
-        except Exception as e:
-            print(f"Error logging unanswered question: {str(e)}")
-            return False
-            # Don't raise the exception - this shouldn't break the main flow
-
-    def get_unanswered_questions(self):
-        """Get list of unanswered questions from the database"""
-        try:
-            # Note: Your database server doesn't have a GET endpoint for unanswered_questions
-            # This would need to be added to your Flask server
-            print("Note: GET endpoint for unanswered_questions not available in current database server")
-            return []
-                
-        except Exception as e:
-            print(f"Error getting unanswered questions: {str(e)}")
-            return []
-
-    def find_best_match(self, user_input, threshold=0.5):
-        """Find the best matching question using database API only"""
-        # Only try to get answer from database API
-        db_result = self.query_database_api(user_input)
-        if db_result:
-            return db_result, 1.0  # High confidence for database results
-        
-        # No local data to fall back to - return None
-        return None, 0
-    
-    def get_response(self, user_input):
-        """Get response for user input"""
-        if not user_input.strip():
-            return "Please enter a message."
-        
-        # First, try to find a specific answer from database
-        best_match, similarity = self.find_best_match(user_input)
-        
-        if best_match and similarity >= 0.5:  # Only use specific answers if confidence is high enough
-            source = best_match.get('source', 'database')
-            answer = best_match.get('answer', 'No answer found')
-            
-            # Add source indicator for database answers
-            if source == 'database':
-                answer = f"\n{answer}"
-            
-            return {
-                'answer': answer,
-                'confidence': float(similarity),
-                'matched_question': best_match.get('question', ''),
-                'status': 'success',
-                'source': source
-            }
-        else:
-            # Use conversational AI for all other questions
-            conversational_response = self.generate_conversational_response(user_input)
-            
-            return {
-                'answer': conversational_response,
-                'confidence': 0.8,  # High confidence for conversational responses
-                'matched_question': '',
-                'status': 'conversational',
-                'source': 'conversational_ai'
-            }
-    
-    def get_qa_count(self):
-        """Get the number of loaded Q&A pairs"""
-        return len(self.qa_pairs)
-    
-    def get_unanswered_stats(self):
-        """Get statistics about unanswered questions"""
-        try:
-            unanswered_questions = self.get_unanswered_questions()
-            if not unanswered_questions:
-                return "No unanswered questions found."
-            
-            # Count questions by date
-            from collections import defaultdict
-            date_counts = defaultdict(int)
-            for question in unanswered_questions:
-                if isinstance(question, dict) and 'timestamp' in question:
-                    date = question['timestamp'][:10]  # Get just the date part
-                    date_counts[date] += 1
-            
-            stats = f"Unanswered Questions Statistics:\n"
-            stats += f"Total unanswered questions: {len(unanswered_questions)}\n\n"
-            stats += "Questions by date:\n"
-            
-            for date in sorted(date_counts.keys(), reverse=True):
-                stats += f"  {date}: {date_counts[date]} questions\n"
-            
-            return stats
-            
-        except Exception as e:
-            return f"Error getting unanswered statistics: {str(e)}"
-    
-    def get_course_recommendations(self, stanine, gwa, strand, hobbies):
-        """Get course recommendations using the recommender system"""
-        try:
-            # Validate inputs
-            stanine = int(stanine) if isinstance(stanine, str) else stanine
-            gwa = float(gwa) if isinstance(gwa, str) else gwa
-            
-            if not (1 <= stanine <= 9):
-                return "Stanine score must be between 1 and 9"
-            if not (75 <= gwa <= 100):
-                return "GWA must be between 75 and 100"
-            if not strand:
-                return "Please select a strand"
-            if not hobbies or not str(hobbies).strip():
-                return "Please enter your hobbies/interests"
-            
-            if self.recommender is None:
-                return "Course recommendation system is not available at the moment. Please try again later."
-            
-            # Get recommendations
-            recommendations = self.recommender.recommend_courses(
-                stanine=stanine,
-                gwa=gwa,
-                strand=strand,
-                hobbies=str(hobbies)
-            )
-            
-            if not recommendations:
-                return "No recommendations available at the moment."
-            
-            # Format response (without confidence scores)
-            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):
-                response += f"### {i}. {rec['code']} - {rec['name']}\n\n"
-            
-            return response
-            
-        except Exception as e:
-            return f"Error getting recommendations: {str(e)}"