chatbot.py

import random
import logging
from bot import MODEL_CONFIG, LANGUAGES, DEFAULT_LANGUAGE
from text_processor import TextProcessor
from intent_manager import IntentManager
from trainer import ModelTrainer

class MultilingualChatbot:
    def __init__(self):
        self.current_language = DEFAULT_LANGUAGE
        self.text_processor = TextProcessor(self.current_language)
        self.intent_manager = IntentManager()
        self.model_trainer = ModelTrainer(self.text_processor, self.intent_manager)
        self.setup_logging()
        
    def setup_logging(self):
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('logs/chatbot.log'),
                logging.StreamHandler()
            ]
        )
        
    def initialize(self):
        logging.info("Initializing multilingual chatbot...")
        
        if not self.intent_manager.load_all_languages():
            logging.error("Failed to load intent data")
            return False
        
        if not self.model_trainer.load_all_models():
            logging.info("No existing models found, training new models...")
            if not self.model_trainer.train_all_languages():
                logging.error("Failed to train models")
                return False
        
        logging.info("Chatbot initialization completed successfully")
        return True
    
    def set_language(self, language_code):
        if language_code in LANGUAGES:
            self.current_language = language_code
            self.text_processor.set_language(language_code)
            logging.info(f"Language set to: {LANGUAGES[language_code]}")
            return True
        else:
            logging.warning(f"Unsupported language: {language_code}")
            return False
    
    def detect_language(self, text):
        if any(char in text for char in 'äöüßÄÖÜ'):
            return 'de'
        if any(char in text for char in 'çğıİöşüÇĞIıÖŞÜ'):
            return 'tr'
        turkish_words = ['merhaba', 'selam', 'nasılsın', 'teşekkürler', 'hoşça']
        if any(word in text.lower() for word in turkish_words):
            return 'tr'   
        german_words = ['hallo', 'guten', 'danke', 'bitte', 'wie']
        if any(word in text.lower() for word in german_words):
            return 'de'
        return 'en'
    
    def predict_intent(self, text, language=None):
        if language is None:
            language = self.current_language
        
        if not self.model_trainer.is_model_available(language):
            logging.warning(f"Model not available for {language}, trying to load...")
            if not self.model_trainer.load_model(language):
                logging.error(f"Could not load model for {language}")
                return None, 0.0
        
        self.text_processor.set_language(language)
        processed_text = self.text_processor.preprocess(text)
        
        if not processed_text.strip():
            logging.warning("Empty text after preprocessing")
            return None, 0.0
        model = self.model_trainer.get_model(language)
        if model is None:
            logging.error(f"No model available for {language}")
            return None, 0.0   
        try:
            predicted_intent = model.predict([processed_text])[0]
            confidence = model.predict_proba([processed_text]).max()
            
            logging.debug(f"Predicted intent: {predicted_intent}, Confidence: {confidence:.3f}")
            return predicted_intent, confidence   
        except Exception as e:
            logging.error(f"Prediction failed: {str(e)}")
            return None, 0.0
    
    def get_response(self, user_input, auto_detect_language=True):
        if not user_input or not user_input.strip():
            return "Please provide a valid input." 
        detected_language = self.current_language
        if auto_detect_language:
            detected_language = self.detect_language(user_input)
            if detected_language != self.current_language:
                self.set_language(detected_language)       
        predicted_intent, confidence = self.predict_intent(user_input, detected_language)        
        if predicted_intent is None:
            return self._get_fallback_response(detected_language)      
        if confidence < MODEL_CONFIG['confidence_threshold']:
            return self._get_low_confidence_response(detected_language)        
        responses = self.intent_manager.get_response(predicted_intent, detected_language)     
        if not responses:
            return self._get_fallback_response(detected_language)        
        return random.choice(responses)
    
    def _get_fallback_response(self, language):
        fallback_responses = {
            'en': "I'm not sure I understand. Could you please rephrase that?",
            'tr': "Tam olarak anlamadım. Lütfen farklı bir şekilde ifade edebilir misiniz?",
            'de': "Ich verstehe nicht ganz. Könnten Sie das bitte anders formulieren?"
        }
        return fallback_responses.get(language, fallback_responses['en'])
    
    def _get_low_confidence_response(self, language):
        low_confidence_responses = {
            'en': "I'm not entirely sure about that. Could you be more specific?",
            'tr': "Bu konuda tam emin değilim. Biraz daha ayrıntılı olabilir misiniz?",
            'de': "Ich bin mir nicht ganz sicher. Könnten Sie etwas spezifischer sein?"
        }
        return low_confidence_responses.get(language, low_confidence_responses['en'])
    
    def retrain_model(self, language=None):
        target_language = language or self.current_language
        
        logging.info(f"Retraining model for {target_language}")
        return self.model_trainer.train_model(target_language)
    
    def get_supported_languages(self):
        return LANGUAGES
    
    def get_current_language(self):
        return self.current_language
    
    def get_statistics(self):
        stats = {
            'supported_languages': len(LANGUAGES),
            'available_models': len(self.model_trainer.get_available_models()),
            'current_language': LANGUAGES.get(self.current_language, 'Unknown'),
            'available_languages': self.intent_manager.get_available_languages()
        }
        return stats