Spaces:

Lap1official
/

API

Running

App Files Files Community

Reality123b commited on Nov 3, 2024

Commit

04a9af6

verified ·

1 Parent(s): 65a6bd0

Update app.py

Browse files

Files changed (1) hide show

app.py +97 -224

app.py CHANGED Viewed

@@ -156,236 +156,109 @@ def romanized_to_bengali(text: str) -> str:
     return text_lower
-def create_chat_interface():
-    # Custom CSS for better styling
-    custom_css = """
-    body {
-    font-family: 'Inter', sans-serif;
-}
-.chat-container {
-    padding-top: 0;
-    padding-bottom: 0;
-}
-.chat-messages {
-    scroll-behavior: smooth;
-}
-.input-container {
-    border-top: 1px solid #ccc;
-}
-.input-container textarea {
-    border-radius: 12px 0 0 12px;
-}
-.input-container button {
-    border-radius: 0 12px 12px 0;
-}
-.loading {
-    animation: pulse 1.5s ease-in-out infinite;
-}
-@keyframes pulse {
-    0% { opacity: 1; }
-    50% { opacity: 0.5; }
-    100% { opacity: 1; }
-}
-    """
-    # Create the interface with custom theme
-    with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo:
-        # Header
-        with gr.Row():
-            gr.HTML("""
-                <!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Xylaria Chat</title>
-    <link rel="stylesheet" href="styles.css">
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/full.css">
-    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/vue.js"></script>
-</head>
-<body>
-    <div id="app" class="mx-auto max-w-5xl">
-        <header class="bg-white rounded shadow-lg p-10 text-center mb-10">
-            <h1 class="text-6xl font-bold text-violet-600 mb-5">✨ Xylaria Chat</h1>
-            <p class="text-lg font-medium text-gray-600">Your Intelligent Multilingual Assistant</p>
-        </header>
-        <section class="bg-white rounded shadow-lg p-10 chat-container">
-            <div class="chat-messages overflow-y-auto max-h-screen">
-                <div v-for="(message, index) in messages" :key="index" class="my-4" :class="{ 'flex justify-end': message.type === 'user' }">
-                    <div class="rounded-lg py-4 px-6" :class="{ 'bg-violet-500 text-white': message.type === 'user', 'bg-gray-200': message.type === 'bot' }">{{ message.text }}</div>
-                </div>
-            </div>
-            <div class="input-container flex mt-6">
-                <textarea v-model="inputText" class="w-full p-4 rounded-lg border-2 border-gray-400 resize-y" rows="3" placeholder="Type a message..."></textarea>
-                <button @click="sendMessage" class="bg-violet-500 text-white p-3 rounded-lg ml-4 hover:bg-violet-600 transition duration-300">Send</button>
-            </div>
-        </section>
-    </div>
-    <script src="script.js"></script>
-</body>
-</html>
-            """)
-        # 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")
-                # 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)
-        # 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)"
-                    )
-        # Function to handle sending messages
-        def user_message(message, history):
-            if message:
-                return "", history + [[message, None]]
-            return "", history
-        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)

     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
+    # 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
+    # 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})
+            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})
+    # 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
+    # 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
+# 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)"
+        ),
+    ]
+)
 if __name__ == "__main__":
     demo.launch(share=True)