Update app.py

app.py

@@ -11,130 +11,44 @@ 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"
 
-def detect_language_script(text: str) -> tuple[str, str]:
-    """Detect language and script of the input text.
-    Returns (language_code, script_type)"""
-    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
-    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_space(prompt: str) -> Image.Image:
-    """Generate an image using the DALLE-4K Space."""
+# 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."""
     try:
         # First get the session hash
         response = requests.post(f"{SPACE_URL}/queue/join")
         session_hash = response.json().get('session_hash')
         
-        # Send the generation request
-        payload = {
-            "prompt": prompt,
-            "negative_prompt": "blurry, bad quality, nsfw",
-            "num_inference_steps": 30,
-            "guidance_scale": 7.5,
-            "session_hash": 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
+                prompt,  # Prompt with style
                 "",     # Negative prompt
                 7.5,    # Guidance scale
                 30,     # Steps
@@ -205,6 +119,7 @@ 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)
@@ -215,9 +130,10 @@ def respond(
     # Check if this is an image generation request
     if is_image_request(message):
         try:
-            image = generate_image_space(message)
+            image = generate_image_space(message, image_style)
             if image:
-                yield (image, f"Here's your generated image based on: {message}")
+                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}")
                 return
             else:
                 yield "Sorry, I couldn't generate the image. Please try again."
@@ -226,14 +142,11 @@ def respond(
             yield f"An error occurred while generating the image: {str(e)}"
             return
 
-    # Handle translation with more conservative approach
+    # Rest of the code remains the same...
     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})
@@ -244,7 +157,6 @@ def respond(
     
     messages.append({"role": "user", "content": translated_msg})
 
-    # Get response from model
     response = ""
     for message in text_client.chat_completion(
         messages,
@@ -256,7 +168,6 @@ 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)
@@ -267,7 +178,7 @@ def respond(
     else:
         yield response
 
-# Updated Gradio interface to handle images
+# Updated Gradio interface with image style selector
 demo = gr.ChatInterface(
     respond,
     additional_inputs=[
@@ -278,7 +189,7 @@ demo = gr.ChatInterface(
         gr.Slider(
             minimum=1,
             maximum=2048,
-            value=512,
+            value=2048,
             step=1,
             label="Max new tokens"
         ),
@@ -296,6 +207,12 @@ 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"
+        ),
     ]
 )