Update app.py

app.py

@@ -1,8 +1,6 @@
 import gradio as gr
 import requests
 from html import escape
-import time
-import json
 from typing import List, Tuple, Optional
 
 # API endpoints
@@ -38,271 +36,117 @@ css = """
     border-radius: 10px;
     margin: 5px 0;
 }
-.model-selector {
-    padding: 10px;
-    background-color: #f8f9fa;
-    border-radius: 5px;
-}
-.status-message {
-    color: #666;
-    font-size: 0.9em;
-    margin-top: 5px;
-}
-.error-message {
-    color: #d32f2f;
-    font-size: 0.9em;
-    margin-top: 5px;
-}
-.loading-message {
-    color: #1976d2;
-    font-size: 0.9em;
-    margin-top: 5px;
-}
 """
 
-def get_available_models() -> Tuple[List[str], Optional[str]]:
-    """
-    Fetch available models from the API with retry logic
-    Returns tuple of (models_list, error_message)
-    """
-    max_retries = 3
-    retry_delay = 2  # seconds
-    
-    for attempt in range(max_retries):
-        try:
-            response = requests.get(MODELS_URL, timeout=10)
-            response.raise_for_status()
-            
-            data = response.json()
-            
-            # Handle both direct list response and object with data property
-            if isinstance(data, list):
-                models = [model['id'] for model in data if isinstance(model, dict) and 'id' in model]
-            elif isinstance(data, dict) and 'data' in data:
-                models = [model['id'] for model in data['data'] if isinstance(model, dict) and 'id' in model]
-            else:
-                models = []
-            
-            if models:
-                return sorted(models), None
-            else:
-                error_msg = "No models found in API response"
-            
-        except requests.exceptions.RequestException as e:
-            error_msg = f"Request failed: {str(e)}"
-        
-        except json.JSONDecodeError:
-            error_msg = "Invalid JSON response from server"
-        
-        except Exception as e:
-            error_msg = f"Unexpected error: {str(e)}"
-        
-        if attempt < max_retries - 1:
-            time.sleep(retry_delay)
-    
-    return [], error_msg
+def get_available_models() -> List[str]:
+    """Fetch available models from the API."""
+    try:
+        response = requests.get(MODELS_URL)
+        response.raise_for_status()
+        models_data = response.json()
+        return sorted([model['id'] for model in models_data.get('data', [])])
+    except Exception as e:
+        print(f"Error fetching models: {e}")
+        return [
+            "samura-deepseek-r1",
+            "samura-gpt-4o",
+            "samura-claude-3-5-sonnet",
+            "groq-llama3-70b-8192"
+        ]
 
-def convert_latex(text: str) -> str:
-    """Convert LaTeX expressions to HTML for rendering"""
-    if not text:
-        return ""
-    
-    # Handle block equations
-    text = text.replace('$$', '</p><div class="latex-block">')
-    text = text.replace('\\[', '</p><div class="latex-block">')
-    text = text.replace('\\]', '</div><p>')
+def chat_completion(
+    messages: List[dict],
+    model: str,
+) -> dict:
+    """Send chat completion request to the API."""
+    headers = {"Content-Type": "application/json"}
+    data = {
+        "model": model,
+        "messages": messages,
+        "temperature": 0.7,  # Default value
+        "max_tokens": 2000,  # Default value
+    }
     
-    # Handle inline equations
-    text = text.replace('$', '<span class="latex-inline">')
-    text = text.replace('\\(', '<span class="latex-inline">')
-    text = text.replace('\\)', '</span>')
-    
-    return text
+    try:
+        response = requests.post(API_URL, headers=headers, json=data)
+        response.raise_for_status()
+        return response.json()
+    except Exception as e:
+        return {"error": str(e)}
 
-def format_message(message: str, role: str) -> str:
-    """Format message with role-specific styling"""
-    message = escape(message)
-    message = convert_latex(message)
-    return f'<div class="message {role}">{message}</div>'
+def format_message(text: str) -> str:
+    """Format message with HTML for display."""
+    return escape(text).replace("\n", "<br>")
 
-def chat_completion(model: str, message: str, chat_history: list) -> tuple:
-    """Send message to API and get response"""
-    if not message:
+def chat_interface(
+    message: str,
+    chat_history: List[Tuple[str, str]],
+    model: str,
+) -> Tuple[List[Tuple[str, str]], str]:
+    """Handle chat interface interactions."""
+    if not message.strip():
         return chat_history, ""
     
-    # Add user message to history
-    chat_history.append((format_message(message, "user"), ""))
+    chat_history.append((format_message(message), ""))
     
-    try:
-        payload = {
-            "model": model,
-            "messages": [{"role": "user", "content": message}],
-            "temperature": 0.7
-        }
-        
-        response = requests.post(API_URL, json=payload, timeout=30)
-        response.raise_for_status()
-        
-        data = response.json()
-        assistant_message = data['choices'][0]['message']['content']
-        
-        # Update chat history
-        chat_history[-1] = (
-            chat_history[-1][0], 
-            format_message(assistant_message, "assistant")
-        )
-        
-        return chat_history, ""
+    messages = []
+    for user_msg, assistant_msg in chat_history[:-1]:
+        if user_msg:
+            messages.append({"role": "user", "content": user_msg.replace("<br>", "\n")})
+        if assistant_msg:
+            messages.append({"role": "assistant", "content": assistant_msg.replace("<br>", "\n")})
+    messages.append({"role": "user", "content": message})
     
-    except Exception as e:
-        error_msg = f"Error: {str(e)}"
-        if hasattr(e, 'response') and e.response:
-            try:
-                error_details = e.response.json()
-                error_msg += f"\nDetails: {json.dumps(error_details, indent=2)}"
-            except:
-                error_msg += f"\nStatus: {e.response.status_code}"
-        
-        chat_history.append(("", format_message(error_msg, "assistant")))
-        return chat_history, ""
-
-def update_model_dropdown() -> dict:
-    """Update the model dropdown with current available models"""
-    models, error = get_available_models()
+    response = chat_completion(messages=messages, model=model)
     
-    if error:
-        status = f'<div class="error-message">⚠️ {error}</div>'
-        if not models:
-            return [
-                gr.Dropdown.update(choices=[], value=None),
-                gr.Markdown.update(value=status),
-                gr.Button.update(interactive=False)
-            ]
+    if "error" in response:
+        assistant_message = f"Error: {response['error']}"
     else:
-        status = f'<div class="status-message">✅ Loaded {len(models)} models</div>'
+        assistant_message = response.get("choices", [{}])[0].get("message", {}).get("content", "No response")
     
-    return [
-        gr.Dropdown.update(
-            choices=models,
-            value=models[0] if models else None
-        ),
-        gr.Markdown.update(value=status),
-        gr.Button.update(interactive=bool(models))
-    ]
+    chat_history[-1] = (chat_history[-1][0], format_message(assistant_message))
+    return chat_history, ""
 
-with gr.Blocks(css=css, theme=gr.themes.Default()) as demo:
-    # Title and description
-    gr.Markdown("""
-    # Multi-Model Chat Interface
-    Connect to various AI models through a single interface
-    """)
+def create_interface():
+    """Create Gradio chat interface."""
+    available_models = get_available_models()
     
-    # Model selection
-    with gr.Row():
+    with gr.Blocks(css=css, theme=gr.themes.Default()) as demo:
+        gr.Markdown("# Aham2 API Chat Interface")
+        
         model_dropdown = gr.Dropdown(
-            label="Select Model",
-            choices=[],
-            value=None,
-            interactive=False,
-            elem_classes="model-selector"
-        )
-        refresh_btn = gr.Button(
-            "🔄 Refresh Models",
-            variant="secondary",
-            interactive=False
+            choices=available_models,
+            value=available_models[0] if available_models else "samura-deepseek-r1",
+            label="Select Model"
         )
-    
-    # Status message
-    status_message = gr.Markdown(
-        value='<div class="loading-message">Loading models...</div>',
-        elem_id="status-message"
-    )
-    
-    # Chat interface
-    chatbot = gr.Chatbot(
-        label="Chat History",
-        elem_id="chatbot",
-        height=500,
-        visible=False
-    )
-    
-    # Message input
-    msg = gr.Textbox(
-        label="Your Message",
-        placeholder="Please wait while models load...",
-        lines=3,
-        max_lines=10,
-        interactive=False
-    )
-    
-    # Submit and clear buttons
-    with gr.Row():
-        submit_btn = gr.Button(
-            "Send",
-            variant="primary",
-            interactive=False
+        
+        chatbot = gr.Chatbot(elem_classes=["chatbot"], bubble_full_width=False)
+        
+        with gr.Row():
+            message = gr.Textbox(
+                placeholder="Type your message here...",
+                show_label=False,
+                container=False,
+                scale=7
+            )
+            submit = gr.Button("Send", variant="primary", scale=1)
+        
+        clear = gr.ClearButton([message, chatbot])
+        
+        submit.click(
+            fn=chat_interface,
+            inputs=[message, chatbot, model_dropdown],
+            outputs=[chatbot, message]
         )
-        clear_btn = gr.Button(
-            "Clear Chat",
-            variant="secondary",
-            interactive=False
+        
+        message.submit(
+            fn=chat_interface,
+            inputs=[message, chatbot, model_dropdown],
+            outputs=[chatbot, message]
         )
     
-    def enable_interface(models):
-        """Enable UI components if models are available"""
-        if models:
-            return [
-                gr.Chatbot.update(visible=True),
-                gr.Textbox.update(
-                    placeholder="Type your message here...",
-                    interactive=True
-                ),
-                gr.Button.update(interactive=True),
-                gr.Button.update(interactive=True)
-            ]
-        return [
-            gr.Chatbot.update(visible=False),
-            gr.Textbox.update(
-                placeholder="No models available",
-                interactive=False
-            ),
-            gr.Button.update(interactive=False),
-            gr.Button.update(interactive=False)
-        ]
-    
-    # Initial model load
-    demo.load(
-        lambda: (update_model_dropdown() + enable_interface([])),
-        outputs=[model_dropdown, status_message, refresh_btn] + 
-               [chatbot, msg, submit_btn, clear_btn]
-    )
-    
-    # Event handlers
-    refresh_btn.click(
-        lambda: (update_model_dropdown() + enable_interface([])),
-        outputs=[model_dropdown, status_message, refresh_btn] + 
-               [chatbot, msg, submit_btn, clear_btn]
-    )
-    
-    submit_btn.click(
-        chat_completion,
-        [model_dropdown, msg, chatbot],
-        [chatbot, msg]
-    )
-    
-    msg.submit(
-        chat_completion,
-        [model_dropdown, msg, chatbot],
-        [chatbot, msg]
-    )
-    
-    clear_btn.click(
-        lambda: [],
-        None,
-        chatbot,
-        queue=False
-    )
+    return demo
 
-# Run the demo
 if __name__ == "__main__":
+    demo = create_interface()
     demo.launch()