Update app.py

app.py

@@ -156,108 +156,202 @@ def romanized_to_bengali(text: str) -> str:
             
     return text_lower
 
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    # First check for custom responses
-    custom_response = check_custom_responses(message)
-    if custom_response:
-        yield custom_response
-        return
+def create_chat_interface():
+    # Custom CSS for better styling
+    custom_css = """
+    .container {
+        max-width: 850px !important;
+        margin: auto;
+    }
+    .chat-window {
+        height: 600px !important;
+        overflow-y: auto;
+        border-radius: 15px !important;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1) !important;
+    }
+    .chat-message {
+        padding: 1rem !important;
+        margin: 0.5rem !important;
+        border-radius: 10px !important;
+    }
+    .user-message {
+        background-color: #e3f2fd !important;
+    }
+    .bot-message {
+        background-color: #f5f5f5 !important;
+    }
+    .settings-block {
+        padding: 1rem !important;
+        background-color: #ffffff !important;
+        border-radius: 10px !important;
+        margin-top: 1rem !important;
+    }
+    """
 
-    # Check if this is an image generation request
-    if is_image_request(message):
-        try:
-            image = generate_image(message)
-            if image:
-                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."
-                return
-        except Exception as e:
-            yield f"An error occurred while generating the image: {str(e)}"
-            return
+    # Create the interface with custom theme
+    with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
+        # Header
+        with gr.Row():
+            gr.HTML("""
+                <div style="text-align: center; margin-bottom: 1rem">
+                    <h1 style="font-size: 2.5rem; font-weight: 600; color: #1a237e">Xylaria Chat</h1>
+                    <p style="color: #666">Your AI Assistant for Multiple Languages</p>
+                </div>
+            """)
 
-    # Handle translation with more conservative approach
-    translated_msg, original_lang, was_transliterated = translate_text(message)
+        # Main chat interface
+        with gr.Row():
+            with gr.Column(scale=4):
+                chatbot = gr.Chatbot(
+                    height=500,
+                    show_label=False,
+                    container=True,
+                    elem_classes=["chat-window"]
+                )
+                
+                # Input area with buttons
+                with gr.Row():
+                    txt = gr.Textbox(
+                        show_label=False,
+                        placeholder="Type your message here...",
+                        container=False
+                    )
+                    send_btn = gr.Button("Send", variant="primary")
+                    clear_btn = gr.Button("Clear")
 
-    # 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})
-            else:
-                messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-    
-    messages.append({"role": "user", "content": translated_msg})
+                # Additional features bar
+                with gr.Row():
+                    audio_input = gr.Audio(source="microphone", type="filepath", label="Voice Input")
+                    image_output = gr.Image(label="Generated Image", visible=False)
 
-    # Get response from model
-    response = ""
-    for message in text_client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-        response += token
+        # Settings panel (collapsible)
+        with gr.Accordion("Advanced Settings", open=False):
+            with gr.Row():
+                with gr.Column():
+                    system_msg = gr.Textbox(
+                        value="You are a friendly Chatbot who always responds in English unless the user specifically uses another language.",
+                        label="System Message",
+                        lines=2
+                    )
+                    max_tokens = gr.Slider(
+                        minimum=1,
+                        maximum=2048,
+                        value=512,
+                        step=1,
+                        label="Max Tokens"
+                    )
+                with gr.Column():
+                    temperature = gr.Slider(
+                        minimum=0.1,
+                        maximum=4.0,
+                        value=0.7,
+                        step=0.1,
+                        label="Temperature"
+                    )
+                    top_p = gr.Slider(
+                        minimum=0.1,
+                        maximum=1.0,
+                        value=0.95,
+                        step=0.05,
+                        label="Top-p (nucleus sampling)"
+                    )
 
-    # 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
+        # Function to handle sending messages
+        def user_message(message, history):
+            if message:
+                return "", history + [[message, None]]
+            return "", history
 
-# Updated Gradio interface to handle images
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(
-            value="You are a friendly Chatbot who always responds in English unless the user specifically uses another language.",
-            label="System message"
-        ),
-        gr.Slider(
-            minimum=1,
-            maximum=2048,
-            value=512,
-            step=1,
-            label="Max new tokens"
-        ),
-        gr.Slider(
-            minimum=0.1,
-            maximum=4.0,
-            value=0.7,
-            step=0.1,
-            label="Temperature"
-        ),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)"
-        ),
-    ]
-)
+        def bot_response(history, system_msg, max_tokens, temperature, top_p):
+            if len(history) == 0:
+                return history
+            
+            # Get the last user message
+            message = history[-1][0]
+            
+            # Check for custom responses first
+            custom_response = check_custom_responses(message)
+            if custom_response:
+                history[-1][1] = custom_response
+                return history
+            
+            # Check for image generation request
+            if is_image_request(message):
+                try:
+                    image = generate_image(message)
+                    if image:
+                        history[-1][1] = "Here's your generated image!"
+                        # Handle image display logic
+                        return history
+                except Exception as e:
+                    history[-1][1] = f"Sorry, I couldn't generate the image: {str(e)}"
+                    return history
+            
+            # Handle regular text responses
+            try:
+                translated_msg, original_lang, was_transliterated = translate_text(message)
+                response = respond(
+                    translated_msg,
+                    history[:-1],
+                    system_msg,
+                    max_tokens,
+                    temperature,
+                    top_p
+                )
+                
+                # Stream the response
+                partial_response = ""
+                for chunk in response:
+                    partial_response += chunk
+                    history[-1][1] = partial_response
+                    yield history
+                    time.sleep(0.02)  # Add slight delay for smooth streaming
+                
+            except Exception as e:
+                history[-1][1] = f"An error occurred: {str(e)}"
+                yield history
+
+        # Event handlers
+        txt_msg = txt.submit(
+            user_message,
+            [txt, chatbot],
+            [txt, chatbot],
+            queue=False
+        ).then(
+            bot_response,
+            [chatbot, system_msg, max_tokens, temperature, top_p],
+            chatbot
+        )
+
+        send_btn.click(
+            user_message,
+            [txt, chatbot],
+            [txt, chatbot],
+            queue=False
+        ).then(
+            bot_response,
+            [chatbot, system_msg, max_tokens, temperature, top_p],
+            chatbot
+        )
+
+        clear_btn.click(lambda: None, None, chatbot, queue=False)
+
+        # Handle voice input
+        def process_audio(audio_file):
+            # Add your audio transcription logic here
+            return "Audio input received! (Add your transcription logic)"
+
+        audio_input.change(
+            process_audio,
+            inputs=[audio_input],
+            outputs=[txt]
+        )
+
+    return demo
+
+# Create and launch the interface
+demo = create_chat_interface()
 
 if __name__ == "__main__":
     demo.launch(share=True)
+