Update app.py

app.py

@@ -5,6 +5,12 @@ import json
 import random
 import os
 from dotenv import load_dotenv
+import langdetect
+from langdetect import detect, DetectorFactory
+from langdetect.lang_detect_exception import LangDetectException
+
+# Set seed for consistent language detection
+DetectorFactory.seed = 0
 
 # Load environment variables
 load_dotenv()
@@ -37,6 +43,49 @@ EMOTION_MODELS = {
     "AnasAlokla/multilingual_go_emotions_V1.1": "Multilingual Go Emotions (V1.1)"
 }
 
+# Language mapping for detection
+SUPPORTED_LANGUAGES = {
+    'en': 'English',
+    'ar': 'Arabic', 
+    'fr': 'French',
+    'es': 'Spanish',
+    'nl': 'Dutch',
+    'tr': 'Turkish'
+}
+
+
+
+def detect_language(text):
+    """Detect the language of the input text."""
+    try:
+        detected_lang = detect(text)
+        if detected_lang in SUPPORTED_LANGUAGES:
+            return detected_lang
+        else:
+            return 'en'  # Default to English if language not supported
+    except LangDetectException:
+        return 'en'  # Default to English if detection fails
+
+def get_language_name(lang_code):
+    """Get the full language name from language code."""
+    return SUPPORTED_LANGUAGES.get(lang_code, 'English')
+
+def categorize_emotion(emotion):
+    """Categorize emotion as positive, negative, or neutral."""
+    positive_emotions = ['admiration', 'amusement', 'approval', 'caring', 'curiosity', 
+                        'desire', 'excitement', 'gratitude', 'joy', 'love', 'optimism', 
+                        'pride', 'relief']
+    negative_emotions = ['anger', 'annoyance', 'confusion', 'disappointment', 'disapproval', 
+                        'disgust', 'embarrassment', 'fear', 'grief', 'nervousness', 
+                        'remorse', 'sadness']
+    
+    if emotion in positive_emotions:
+        return 'positive'
+    elif emotion in negative_emotions:
+        return 'negative'
+    else:
+        return 'neutral'
+
 def generate_text(prompt, context=""):
     """
     Generates text using the Gemini model.
@@ -48,24 +97,66 @@ def generate_text(prompt, context=""):
         print(f"Error generating text: {e}")
         return "I am sorry, I encountered an error while generating the text."
 
-def create_prompt(emotion, topic=None):
+def create_enhanced_prompt(emotion, topic, detected_language, emotion_score):
     """
-    Chooses a random prompt from the template list.
+    Creates an enhanced emotional prompt based on detected language and emotion intensity.
     """
+    # Get base template from emotion_templates.json
     templates = data["emotion_templates"][emotion]
-    prompt = random.choice(templates)
+    base_prompt = random.choice(templates)
+    
+    # Replace placeholders
     if topic:
-        # Replace various placeholders in the prompt
         placeholders = ["[topic/person]", "[topic]", "[person]", "[object]", "[outcome]"]
         for placeholder in placeholders:
-            prompt = prompt.replace(placeholder, topic)
+            base_prompt = base_prompt.replace(placeholder, topic)
+    
+    # Get language name
+    language_name = get_language_name(detected_language)
+    
+    # Get emotion category
+    emotion_category = categorize_emotion(emotion)
+    
+    # Get emotional enhancers from JSON file
+    emotional_enhancers = data.get("emotional_enhancers", {})
+    language_enhancers = emotional_enhancers.get(detected_language, emotional_enhancers.get('en', {}))
+    emotion_enhancer = ""
+    
+    if language_enhancers and emotion_category in language_enhancers:
+        emotion_enhancer = random.choice(language_enhancers[emotion_category])
     
-    subfix_prompt = "Make the generated text in the same language as the topic.\n"
-    subfix_prompt += "Make the generated text short.\n"
+    # Calculate emotion intensity
+    intensity = "high" if emotion_score > 0.7 else "moderate" if emotion_score > 0.4 else "low"
     
-    prefix_prompt = "## topic\n" + topic
-    prompt = subfix_prompt + prompt + prefix_prompt
-    return prompt
+    # Create enhanced prompt
+    enhanced_prompt = f"""
+You are an emotionally intelligent AI assistant. Respond with genuine {emotion} emotion at {intensity} intensity.
+
+Language Instructions:
+- Respond ONLY in {language_name}
+- Use natural, native-speaker expressions
+- Match the emotional tone of a {language_name} speaker
+
+Emotional Guidelines:
+- The detected emotion is: {emotion} (confidence: {emotion_score:.2f})
+- Emotion category: {emotion_category}
+- Use emotionally resonant words like: {emotion_enhancer}
+- Express {emotion} authentically and appropriately
+- Make your response feel genuinely {emotion_category}
+
+Context: {base_prompt}
+
+Topic to respond about: {topic}
+
+Requirements:
+- Keep response concise but emotionally expressive (2-4 sentences)
+- Use appropriate emotional language for {emotion}
+- Sound natural in {language_name}
+- Show empathy and understanding
+- Match the emotional intensity of the user's input
+"""
+    
+    return enhanced_prompt
 
 @st.cache_resource
 def load_emotion_classifier(model_name):
@@ -80,25 +171,24 @@ def load_emotion_classifier(model_name):
         st.error(f"Error loading model {model_name}: {str(e)}")
         return None
 
-def get_ai_response(user_input, emotion_predictions):
-    """Generates AI response based on user input and detected emotions."""
+def get_ai_response(user_input, emotion_predictions, detected_language):
+    """Generates AI response based on user input, detected emotions, and language."""
     dominant_emotion = None
     max_score = 0
-    responses = None
     
     for prediction in emotion_predictions:
         if prediction['score'] > max_score:
             max_score = prediction['score']
             dominant_emotion = prediction['label']
     
-    prompt_text = create_prompt(dominant_emotion, user_input)
-    responses = generate_text(prompt_text)
-    
-    # Handle cases where no specific emotion is clear
     if dominant_emotion is None:
-        return "Error for response"
-    else:
-        return responses
+        return "Error: No emotion detected for response generation."
+    
+    # Create enhanced prompt with language and emotion context
+    prompt_text = create_enhanced_prompt(dominant_emotion, user_input, detected_language, max_score)
+    response = generate_text(prompt_text)
+    
+    return response
 
 def display_top_predictions(emotion_predictions, selected_language, num_predictions=10):
     """Display top emotion predictions in sidebar."""
@@ -123,6 +213,21 @@ def display_top_predictions(emotion_predictions, selected_language, num_predicti
         st.sidebar.markdown(f"Score: {percentage:.1f}%")
         st.sidebar.markdown("---")
 
+def display_language_info(detected_language, confidence_scores=None):
+    """Display detected language information."""
+    language_name = get_language_name(detected_language)
+    
+    st.sidebar.markdown("---")
+    st.sidebar.subheader("🌐 Language Detection")
+    st.sidebar.success(f"**Detected:** {language_name} ({detected_language.upper()})")
+    
+    if confidence_scores:
+        st.sidebar.markdown("**Detection Confidence:**")
+        for lang, score in confidence_scores.items():
+            if lang in SUPPORTED_LANGUAGES:
+                lang_name = SUPPORTED_LANGUAGES[lang]
+                st.sidebar.markdown(f"• {lang_name}: {score:.2f}")
+
 def main():
     # Sidebar configurations
     st.sidebar.header("⚙️ Configuration")
@@ -151,6 +256,19 @@ def main():
         step=1
     )
     
+    # Language detection settings
+    st.sidebar.markdown("---")
+    st.sidebar.subheader("🔍 Language Detection")
+    auto_detect = st.sidebar.checkbox("Auto-detect input language", value=True)
+    
+    if not auto_detect:
+        manual_language = st.sidebar.selectbox(
+            "Select input language manually:",
+            list(SUPPORTED_LANGUAGES.keys()),
+            format_func=lambda x: SUPPORTED_LANGUAGES[x],
+            index=0
+        )
+    
     # Load the selected emotion classifier
     emotion_classifier = load_emotion_classifier(selected_model_key)
     
@@ -163,21 +281,34 @@ def main():
     st.sidebar.success(f"✅ Current Model: {EMOTION_MODELS[selected_model_key]}")
     
     # Display Image
-    st.image('chatBot_image.jpg', channels='RGB')
+    if os.path.exists('chatBot_image.jpg'):
+        st.image('chatBot_image.jpg', channels='RGB')
     
     # Set page title and header based on selected language
     st.title(LANGUAGES[selected_language]['title'])
     st.markdown(f"### 💬 {LANGUAGES[selected_language]['analyze_subtitle']}")
     
+    # Add language support info
+    st.info("🌍 **Supported Languages:** English, Arabic, French, Spanish, Dutch, Turkish")
+    
     # Input Text Box
     user_input = st.text_area(
         LANGUAGES[selected_language]['input_placeholder'],
         "",
         height=100,
-        help="Type your message here to analyze emotions"
+        help="Type your message here to analyze emotions and get an emotionally appropriate response"
     )
     
     if user_input:
+        # Language Detection
+        if auto_detect:
+            detected_language = detect_language(user_input)
+        else:
+            detected_language = manual_language
+        
+        # Display language detection results
+        display_language_info(detected_language)
+        
         # Emotion Detection
         with st.spinner("Analyzing emotions..."):
             emotion_predictions = emotion_classifier(user_input)
@@ -197,28 +328,48 @@ def main():
             score = prediction['score']
             percentage = score * 100
             
+            # Add emotion category indicator
+            emotion_category = categorize_emotion(emotion)
+            category_emoji = "😊" if emotion_category == "positive" else "😔" if emotion_category == "negative" else "😐"
+            
             if i % 2 == 0:
                 with col1:
                     st.metric(
-                        label=emotion.title(),
+                        label=f"{category_emoji} {emotion.title()}",
                         value=f"{percentage:.1f}%",
                         delta=None
                     )
             else:
                 with col2:
                     st.metric(
-                        label=emotion.title(),
+                        label=f"{category_emoji} {emotion.title()}",
                         value=f"{percentage:.1f}%",
                         delta=None
                     )
         
-        # Get AI Response
-        with st.spinner("Generating response..."):
-            ai_response = get_ai_response(user_input, emotion_predictions)
+        # Get AI Response with enhanced emotional intelligence
+        with st.spinner("Generating emotionally intelligent response..."):
+            ai_response = get_ai_response(user_input, emotion_predictions, detected_language)
         
         # Display AI Response
         st.subheader(LANGUAGES[selected_language]['response_header'])
-        st.write(ai_response)
+        
+        # Show dominant emotion and response language
+        dominant_emotion = max(emotion_predictions, key=lambda x: x['score'])
+        language_name = get_language_name(detected_language)
+        
+        st.markdown(f"**Responding with:** {dominant_emotion['label'].title()} emotion in {language_name}")
+        st.markdown("---")
+        
+        # Display the response in a nice container
+        with st.container():
+            st.markdown(f"**🤖 AI Response:**")
+            st.write(ai_response)
+        
+        # Add emotion intensity indicator
+        emotion_score = dominant_emotion['score']
+        intensity = "High" if emotion_score > 0.7 else "Moderate" if emotion_score > 0.4 else "Low"
+        st.caption(f"Emotion Intensity: {intensity} ({emotion_score:.2f})")
 
 # Run the main function
 if __name__ == "__main__":