Update app.py

app.py

@@ -27,145 +27,113 @@ text_client = InferenceClient(
 API_URL = "https://api-inference.huggingface.co/models/SG161222/RealVisXL_V4.0"
 headers = {"Authorization": f"Bearer {HF_TOKEN}"}
 
-def detect_language_script(text: str) -> tuple[str, str]:
-    """Detect language and script of the input text.
-    Returns (language_code, script_type)"""
+def detect_language(text):
+    """Detect the language of input text"""
     try:
-        # 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)
-        except:
-            pass
-        return lang, script
+        return langdetect.detect(text)
+    except:
+        return 'en'
+
+def detect_and_transliterate(text):
+    """Detect script and transliterate if needed"""
+    try:
+        script = detect_script(text)
+        if script:
+            # Transliterate to Latin script if the text is in another script
+            return transliterate(text, script, sanscript.IAST)
     except:
-        return 'en', None
+        pass
+    return text
 
-def is_romanized_indic(text: str) -> bool:
-    """Check if text appears to be romanized Indic language.
-    More strict pattern matching."""
-    # 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
-        r'\b(kemon|bhalo|kharap)\b',  # Common adjectives
-        r'\b(ki|kothay|keno)\b'  # Common question words
+def translate_to_english(text):
+    """Translate text to English if not already in English"""
+    try:
+        lang = detect_language(text)
+        if lang != 'en':
+            translator = GoogleTranslator(source=lang, target='en')
+            return translator.translate(text)
+    except:
+        pass
+    return text
+
+def check_for_image_generation(message):
+    """Check if message contains image generation commands"""
+    image_triggers = [
+        r"generate (?:an? )?image",
+        r"create (?:an? )?image",
+        r"draw",
+        r"show me",
+        r"visualize",
+        r"make (?:an? )?picture"
     ]
     
-    # Require multiple matches to confirm it's actually Bengali
-    text_lower = 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
+    for trigger in image_triggers:
+        if re.search(trigger, message.lower()):
+            return True
+    return False
 
-def translate_text(text: str, target_lang='en') -> tuple[str, str, bool]:
-    """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
+def user_message(message, history):
+    """Handle user messages"""
+    if message is None or message == "":
+        return "", history
     
-    original_lang, script = detect_language_script(text)
-    is_transliterated = False
-    
-    # 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, 'en', False
+    # Add user message to history
+    history = history + [(message, None)]
+    return "", history
+
+def bot_response(history, system_msg, max_tokens, temperature, top_p):
+    """Generate bot response"""
+    if not history:
+        return history, None
     
-    # 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
+    last_user_message = history[-1][0]
     
-    return text, 'en', False
-
-def check_custom_responses(message: str) -> str:
-    """Check for specific patterns and return custom responses."""
-    message_lower = message.lower()
-    custom_responses = {
-        "what is ur name?": "xylaria",
-        "what is your name?": "xylaria",
-        "what's your name?": "xylaria",
-        "whats your name": "xylaria",
-        "how many 'r' is in strawberry?": "3",
-        "who is your developer?": "sk md saad amin",
-        "how many r is in strawberry": "3",
-        "who is ur dev": "sk md saad amin",
-        "who is ur developer": "sk md saad amin",
-    }
-    for pattern, response in custom_responses.items():
-        if pattern in message_lower:
-            return response
-    return None
-
-def is_image_request(message: str) -> bool:
-    """Detect if the message is requesting image generation."""
-    image_triggers = [
-        "generate an image",
-        "create an image",
-        "draw",
-        "make a picture",
-        "generate a picture",
-        "create a picture",
-        "generate art",
-        "create art",
-        "make art",
-        "visualize",
-        "show me",
-    ]
-    message_lower = message.lower()
-    return any(trigger in message_lower for trigger in image_triggers)
-
-def generate_image(prompt):
-    """Generate image using HuggingFace inference API"""
     try:
-        response = requests.post(API_URL, headers=headers, json={"inputs": prompt})
-        image = Image.open(io.BytesIO(response.content))
-        return image
-    except Exception as e:
-        print(f"Image generation error: {e}")
-        return None
+        # Process the message for language and script
+        processed_message = detect_and_transliterate(last_user_message)
+        translated_message = translate_to_english(processed_message)
         
-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)
+        # Check for image generation request
+        if check_for_image_generation(translated_message):
+            # Generate image based on the message
+            image = generate_image(translated_message)
+            # Update history with a confirmation message
+            history[-1] = (history[-1][0], "I've generated an image based on your request.")
+            return history, image
+        
+        # Prepare chat messages for the model
+        messages = [
+            {"role": "system", "content": system_msg},
+        ]
+        
+        # Add conversation history
+        for msg in history[:-1]:  # Exclude the last message pair
+            if msg[0]:  # User message
+                messages.append({"role": "user", "content": msg[0]})
+            if msg[1]:  # Assistant message
+                messages.append({"role": "assistant", "content": msg[1]})
+        
+        # Add the last user message
+        messages.append({"role": "user", "content": translated_message})
+        
+        # Get model response
+        response = text_client.text_generation(
+            prompt=str(messages),
+            max_new_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            repetition_penalty=1.1,
+        )
+        
+        # Update history with bot response
+        history[-1] = (history[-1][0], response)
+        
+    except Exception as e:
+        # Handle errors gracefully
+        error_message = f"I apologize, but I encountered an error: {str(e)}"
+        history[-1] = (history[-1][0], error_message)
     
-    if text_lower == text.lower():
-        try:
-            return transliterate(text, sanscript.ITRANS, sanscript.BENGALI)
-        except:
-            return text
-            
-    return text_lower
-
-
+    return history, None
 
 def create_chat_interface():
     # Custom CSS for better styling with Inter font and animations