Update app.py

app.py

@@ -6,84 +6,128 @@ from indic_transliteration.detect import detect as detect_script
 from indic_transliteration.sanscript import transliterate
 import langdetect
 import re
-import requests
-import json
-import base64
-from PIL import Image
-import io
-import time
 
 # Initialize clients
 text_client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-SPACE_URL = "https://ijohn07-dalle-4k.hf.space"
+image_client = InferenceClient("ijohn07/DALLE-4K")
 
-# Add image style options
-IMAGE_STYLES = {
-    "3840 x 2160": "3840 x 2160",
-    "2560 x 1440": "2560 x 1440",
-    "Photo": "Photo",
-    "Cinematic": "Cinematic",
-    "Anime": "Anime",
-    "3D Model": "3D Model",
-    "No style": "(No style)"
-}
-
-def generate_image_space(prompt: str, style: str) -> Image.Image:
-    """Generate an image using the DALLE-4K Space with specified style."""
+def detect_language_script(text: str) -> tuple[str, str]:
+    """Detect language and script of the input text.
+    Returns (language_code, script_type)"""
     try:
-        # First get the session hash
-        response = requests.post(f"{SPACE_URL}/queue/join")
-        session_hash = response.json().get('session_hash')
-        
-        # Modify prompt based on style
-        if style != "(No style)":
-            # Format the prompt according to the style
-            if style in ["3840 x 2160", "2560 x 1440"]:
-                # For resolution styles, add the resolution to the prompt
-                prompt = f"{prompt}, {style} resolution"
-            else:
-                # For other styles, append the style to the prompt
-                prompt = f"{prompt}, {style.lower()} style"
-        
-        # Send the generation request
-        response = requests.post(f"{SPACE_URL}/run/predict", json={
-            "data": [
-                prompt,  # Prompt with style
-                "",     # Negative prompt
-                7.5,    # Guidance scale
-                30,     # Steps
-                "DPM++ SDE Karras",  # Scheduler
-                False,  # High resolution
-                False,  # Image to image
-                None,   # Image upload
-                1       # Batch size
-            ],
-            "session_hash": session_hash
-        })
+        # 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
         
-        # Poll for results
-        while True:
-            status_response = requests.post(f"{SPACE_URL}/queue/status", json={
-                "session_hash": session_hash
-            })
-            status_data = status_response.json()
-            
-            if status_data.get('status') == 'complete':
-                # Get the image data
-                image_data = status_data['data']['image']
-                # Convert base64 to PIL Image
-                image_bytes = base64.b64decode(image_data.split(',')[1])
-                image = Image.open(io.BytesIO(image_bytes))
-                return image
-            elif status_data.get('status') == 'error':
-                raise Exception(f"Image generation failed: {status_data.get('error')}")
-            
-            time.sleep(1)  # Wait before polling again
-            
+        script = None
+        try:
+            script = detect_script(text)
+        except:
+            pass
+        return lang, script
+    except:
+        return 'en', None
+
+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
+    ]
+    
+    # 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
+
+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
+    
+    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
+    
+    # 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."""
+    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: str) -> str:
+    """Generate an image using DALLE-4K model."""
+    try:
+        response = image_client.text_to_image(
+            prompt,
+            parameters={
+                "negative_prompt": "blurry, bad quality, nsfw",
+                "num_inference_steps": 30,
+                "guidance_scale": 7.5
+            }
+        )
+        # Save the image and return the path or base64 string
+        # Note: Implementation depends on how you want to handle the image output
+        return response
     except Exception as e:
         print(f"Image generation error: {e}")
         return None
-
 def romanized_to_bengali(text: str) -> str:
     """Convert romanized Bengali text to Bengali script."""
     bengali_mappings = {
@@ -119,7 +163,6 @@ def respond(
     max_tokens,
     temperature,
     top_p,
-    image_style: str,  # New parameter for image style
 ):
     # First check for custom responses
     custom_response = check_custom_responses(message)
@@ -130,10 +173,11 @@ def respond(
     # Check if this is an image generation request
     if is_image_request(message):
         try:
-            image = generate_image_space(message, image_style)
+            image = generate_image(message)
             if image:
-                style_info = f" using {image_style} style" if image_style != "(No style)" else ""
-                yield (image, f"Here's your generated image based on: {message}{style_info}")
+                yield f"Here's your generated image based on: {message}"
+                # You'll need to implement the actual image display logic
+                # depending on your Gradio interface requirements
                 return
             else:
                 yield "Sorry, I couldn't generate the image. Please try again."
@@ -142,11 +186,14 @@ def respond(
             yield f"An error occurred while generating the image: {str(e)}"
             return
 
-    # Rest of the code remains the same...
+    # Handle translation with more conservative approach
     translated_msg, original_lang, was_transliterated = translate_text(message)
+
+    # Prepare conversation history - only translate if necessary
     messages = [{"role": "system", "content": system_message}]
     for val in history:
         if val[0]:
+            # 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})
@@ -157,6 +204,7 @@ def respond(
     
     messages.append({"role": "user", "content": translated_msg})
 
+    # Get response from model
     response = ""
     for message in text_client.chat_completion(
         messages,
@@ -168,6 +216,7 @@ def respond(
         token = message.choices[0].delta.content
         response += token
 
+    # 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)
@@ -178,7 +227,7 @@ def respond(
     else:
         yield response
 
-# Updated Gradio interface with image style selector
+# Updated Gradio interface to handle images
 demo = gr.ChatInterface(
     respond,
     additional_inputs=[
@@ -189,7 +238,7 @@ demo = gr.ChatInterface(
         gr.Slider(
             minimum=1,
             maximum=2048,
-            value=2048,
+            value=512,
             step=1,
             label="Max new tokens"
         ),
@@ -207,12 +256,6 @@ demo = gr.ChatInterface(
             step=0.05,
             label="Top-p (nucleus sampling)"
         ),
-        gr.Radio(
-            choices=list(IMAGE_STYLES.values()),
-            value="3840 x 2160",
-            label="Image Style",
-            info="Select the style for generated images"
-        ),
     ]
 )