Update app.py

app.py

@@ -1,34 +1,108 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
-from googletrans import Translator
-from langdetect import detect
+from deep_translator import GoogleTranslator
+from indic_transliteration import sanscript
+from indic_transliteration.detect import detect as detect_script
+from indic_transliteration.sanscript import transliterate
+import langdetect
+import re
 
 client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-translator = Translator()
 
-def detect_and_translate(text: str, target_lang='en') -> tuple[str, str]:
+def detect_language_script(text: str) -> tuple[str, str]:
     """
-    Detect language and translate to target language if needed.
-    Returns tuple of (translated_text, detected_language)
+    Detect language and script of the input text.
+    Returns (language_code, script_type)
     """
     try:
-        detected_lang = detect(text)
-        if detected_lang != target_lang:
-            translation = translator.translate(text, dest=target_lang)
-            return translation.text, detected_lang
-        return text, detected_lang
+        lang = langdetect.detect(text)
+        script = None
+        try:
+            script = detect_script(text)
+        except:
+            pass
+        return lang, script
     except:
-        return text, 'en'  # Fallback to original text if translation fails
+        return 'en', None
 
-def translate_to_original(text: str, original_lang: str) -> str:
-    """Translate response back to original language if needed"""
-    if original_lang != 'en':
+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.
+    """
+    # Common Bengali romanized patterns
+    bengali_patterns = [
+        r'\b(ami|tumi|apni)\b',  # Common pronouns
+        r'\b(ache|achen|thako|thaken)\b',  # Common verbs
+        r'\b(kemon|bhalo|kharap)\b',  # Common adjectives
+        r'\b(ki|kothay|keno)\b'  # Common question words
+    ]
+    
+    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:
-            translation = translator.translate(text, dest=original_lang)
-            return translation.text
+            return transliterate(text, sanscript.ITRANS, sanscript.BENGALI)
         except:
             return text
-    return text
+            
+    return text_lower
+
+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)
+    """
+    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:
+        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, original_lang, is_transliterated
 
 def check_custom_responses(message: str) -> str:
     """Check for specific patterns and return custom responses."""
@@ -50,6 +124,20 @@ 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':
+        try:
+            translator = GoogleTranslator(source='en', target=original_lang)
+            translated = translator.translate(text)
+            return translated
+        except Exception as e:
+            print(f"Translation error: {e}")
+            return text
+    return text
+
 def respond(
     message, 
     history: list[tuple[str, str]], 
@@ -64,15 +152,15 @@ def respond(
         yield custom_response
         return
 
-    # Detect language and translate to English if needed
-    translated_msg, detected_lang = detect_and_translate(message)
+    # Handle translation and transliteration
+    translated_msg, original_lang, was_transliterated = translate_text(message)
     
     # Prepare conversation history
     messages = [{"role": "system", "content": system_message}]
     for val in history:
         if val[0]:
-            # Translate user message from history if needed
-            trans_user_msg, _ = detect_and_translate(val[0])
+            # Translate user message from history
+            trans_user_msg, _, _ = translate_text(val[0])
             messages.append({"role": "user", "content": trans_user_msg})
         if val[1]:
             messages.append({"role": "assistant", "content": val[1]})
@@ -92,8 +180,8 @@ def respond(
         response += token
         
         # Translate accumulated response if original message wasn't in English
-        if detected_lang != 'en':
-            translated_response = translate_to_original(response, detected_lang)
+        if original_lang != 'en':
+            translated_response = translate_to_original(response, original_lang, was_transliterated)
             yield translated_response
         else:
             yield response