Update app.py

app.py

@@ -15,7 +15,13 @@ def detect_language_script(text: str) -> tuple[str, str]:
     Returns (language_code, script_type)
     """
     try:
-        lang = langdetect.detect(text)
+        # Use confidence threshold to avoid false detections
+        lang_detect = langdetect.detect_langs(text)
+        if lang_detect[0].prob > 0.8:  # Only accept high confidence detections
+            lang = lang_detect[0].lang
+        else:
+            lang = 'en'  # Default to English if unsure
+            
         script = None
         try:
             script = detect_script(text)
@@ -28,9 +34,9 @@ def detect_language_script(text: str) -> tuple[str, str]:
 def is_romanized_indic(text: str) -> bool:
     """
     Check if text appears to be romanized Indic language.
-    This is a basic implementation - you may want to enhance the patterns.
+    More strict pattern matching.
     """
-    # Common Bengali romanized patterns
+    # Common Bengali romanized patterns with word boundaries
     bengali_patterns = [
         r'\b(ami|tumi|apni)\b',  # Common pronouns
         r'\b(ache|achen|thako|thaken)\b',  # Common verbs
@@ -38,71 +44,38 @@ def is_romanized_indic(text: str) -> bool:
         r'\b(ki|kothay|keno)\b'  # Common question words
     ]
     
+    # Require multiple matches to confirm it's actually Bengali
     text_lower = text.lower()
-    return any(re.search(pattern, text_lower) for pattern in bengali_patterns)
-
-def romanized_to_bengali(text: str) -> str:
-    """
-    Convert romanized Bengali text to Bengali script.
-    """
-    # Define common Bengali word mappings
-    bengali_mappings = {
-        'ami': 'আমি',
-        'tumi': 'তুমি',
-        'apni': 'আপনি',
-        'kemon': 'কেমন',
-        'achen': 'আছেন',
-        'acchen': 'আছেন',
-        'bhalo': 'ভালো',
-        'achi': 'আছি',
-        'ki': 'কি',
-        'tumi': 'তুমি',
-        'kothay': 'কোথায়',
-        'keno': 'কেন',
-        # Add more mappings as needed
-    }
-    
-    # Convert to lowercase for matching
-    text_lower = text.lower()
-    
-    # Replace words based on mappings
-    for roman, bengali in bengali_mappings.items():
-        text_lower = re.sub(r'\b' + roman + r'\b', bengali, text_lower)
-    
-    # If no direct mapping found, try using transliteration
-    if text_lower == text.lower():
-        try:
-            return transliterate(text, sanscript.ITRANS, sanscript.BENGALI)
-        except:
-            return text
-            
-    return text_lower
+    matches = sum(1 for pattern in bengali_patterns if re.search(pattern, text_lower))
+    return matches >= 2  # Require at least 2 matches to consider it Bengali
 
 def translate_text(text: str, target_lang='en') -> tuple[str, str, bool]:
     """
-    Translate text to target language, handling both script and romanized text.
-    Returns (translated_text, original_lang, is_transliterated)
+    Translate text to target language, with more conservative translation logic.
     """
+    # Skip translation for very short inputs or basic greetings
+    if len(text.split()) <= 2 or text.lower() in ['hello', 'hi', 'hey']:
+        return text, 'en', False
+        
     original_lang, script = detect_language_script(text)
     is_transliterated = False
     
-    # Handle potential romanized Indic text
-    if original_lang == 'en' and is_romanized_indic(text):
-        text = romanized_to_bengali(text)
-        original_lang = 'bn'
-        is_transliterated = True
-    
-    # Only translate if not already in target language
-    if original_lang != target_lang:
+    # Only process if confident it's non-English
+    if original_lang != 'en' and len(text.split()) > 2:
         try:
             translator = GoogleTranslator(source='auto', target=target_lang)
             translated = translator.translate(text)
             return translated, original_lang, is_transliterated
         except Exception as e:
             print(f"Translation error: {e}")
-            return text, original_lang, is_transliterated
+            return text, 'en', False
             
-    return text, original_lang, is_transliterated
+    # Check for romanized Indic text only if it's a longer input
+    if original_lang == 'en' and len(text.split()) > 2 and is_romanized_indic(text):
+        text = romanized_to_bengali(text)
+        return translate_text(text, target_lang)  # Recursive call with Bengali script
+            
+    return text, 'en', False
 
 def check_custom_responses(message: str) -> str:
     """Check for specific patterns and return custom responses."""
@@ -124,19 +97,33 @@ def check_custom_responses(message: str) -> str:
             return response
     return None
 
-def translate_to_original(text: str, original_lang: str, was_transliterated: bool) -> str:
-    """
-    Translate response back to original language and script if needed.
-    """
-    if original_lang != 'en':
+def romanized_to_bengali(text: str) -> str:
+    """Convert romanized Bengali text to Bengali script."""
+    bengali_mappings = {
+        'ami': 'আমি',
+        'tumi': 'তুমি',
+        'apni': 'আপনি',
+        'kemon': 'কেমন',
+        'achen': 'আছেন',
+        'acchen': 'আছেন',
+        'bhalo': 'ভালো',
+        'achi': 'আছি',
+        'ki': 'কি',
+        'kothay': 'কোথায়',
+        'keno': 'কেন',
+    }
+    
+    text_lower = text.lower()
+    for roman, bengali in bengali_mappings.items():
+        text_lower = re.sub(r'\b' + roman + r'\b', bengali, text_lower)
+    
+    if text_lower == text.lower():
         try:
-            translator = GoogleTranslator(source='en', target=original_lang)
-            translated = translator.translate(text)
-            return translated
-        except Exception as e:
-            print(f"Translation error: {e}")
+            return transliterate(text, sanscript.ITRANS, sanscript.BENGALI)
+        except:
             return text
-    return text
+            
+    return text_lower
 
 def respond(
     message, 
@@ -152,16 +139,19 @@ def respond(
         yield custom_response
         return
 
-    # Handle translation and transliteration
+    # Handle translation with more conservative approach
     translated_msg, original_lang, was_transliterated = translate_text(message)
     
-    # Prepare conversation history
+    # Prepare conversation history - only translate if necessary
     messages = [{"role": "system", "content": system_message}]
     for val in history:
         if val[0]:
-            # Translate user message from history
-            trans_user_msg, _, _ = translate_text(val[0])
-            messages.append({"role": "user", "content": trans_user_msg})
+            # Only translate longer messages
+            if len(val[0].split()) > 2:
+                trans_user_msg, _, _ = translate_text(val[0])
+                messages.append({"role": "user", "content": trans_user_msg})
+            else:
+                messages.append({"role": "user", "content": val[0]})
         if val[1]:
             messages.append({"role": "assistant", "content": val[1]})
     
@@ -179,10 +169,14 @@ def respond(
         token = message.choices[0].delta.content
         response += token
         
-        # Translate accumulated response if original message wasn't in English
-        if original_lang != 'en':
-            translated_response = translate_to_original(response, original_lang, was_transliterated)
-            yield translated_response
+        # Only translate back if the original was definitely non-English
+        if original_lang != 'en' and len(message.split()) > 2:
+            try:
+                translator = GoogleTranslator(source='en', target=original_lang)
+                translated_response = translator.translate(response)
+                yield translated_response
+            except:
+                yield response
         else:
             yield response
 
@@ -190,7 +184,7 @@ demo = gr.ChatInterface(
     respond,
     additional_inputs=[
         gr.Textbox(
-            value="You are a friendly Chatbot.",
+            value="You are a friendly Chatbot who always responds in English unless the user specifically uses another language.",
             label="System message"
         ),
         gr.Slider(