Fix: Simplified Gradio interface for v3.x compatibility

app.py

@@ -1,239 +1,112 @@
 import gradio as gr
-import requests
-import json
-import time
 import os
 import sys
-from typing import List, Tuple
+import asyncio
 
 # Add backend to path for imports
 backend_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'backend')
 sys.path.insert(0, backend_path)
 
 from backend.models.character_manager import CharacterManager
-from backend.config import settings
 
-class RoleplayChatInterface:
+class RoleplayChatApp:
     def __init__(self):
-        """Initialize the Roleplay Chat Interface"""
+        """Initialize the Roleplay Chat App"""
         self.character_manager = None
-        self.available_characters = ["moses", "samsung_employee", "jinx"]
-        self.character_info = {
-            "moses": {
-                "name": "Moses",
-                "description": "📚 Wise biblical figure offering guidance and wisdom",
-                "avatar": "👨‍🏫"
-            },
-            "samsung_employee": {
-                "name": "Samsung Employee", 
-                "description": "💼 Professional tech support specialist",
-                "avatar": "👨‍💼"
-            },
-            "jinx": {
-                "name": "Jinx",
-                "description": "🎭 Chaotic and energetic character from Arcane",
-                "avatar": "🔮"
-            }
-        }
         
-    async def initialize_models(self):
-        """Initialize the character manager"""
+    def initialize_models(self):
+        """Initialize the character manager synchronously"""
         try:
+            print("🔄 Initializing character manager...")
             self.character_manager = CharacterManager()
-            await self.character_manager.initialize()
-            return "✅ Models loaded successfully!"
-        except Exception as e:
-            return f"❌ Failed to load models: {str(e)}"
-    
-    def initialize_models_sync(self):
-        """Synchronous wrapper for model initialization"""
-        import asyncio
-        try:
+            
+            # Use sync initialization
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
-            result = loop.run_until_complete(self.initialize_models())
+            loop.run_until_complete(self.character_manager.initialize())
             loop.close()
-            return result
+            
+            print("✅ Models loaded successfully!")
+            return "✅ Models loaded successfully!"
         except Exception as e:
+            print(f"❌ Failed to load models: {str(e)}")
             return f"❌ Failed to load models: {str(e)}"
     
-    def get_character_response(self, message: str, character_id: str, history: List[Tuple[str, str]]) -> Tuple[List[Tuple[str, str]], str]:
-        """Generate character response and update chat history"""
-        if not self.character_manager:
-            return history + [(message, "⚠️ Models are still loading. Please try again in a moment...")], ""
-        
+    def chat_fn(self, message, character_id, history):
+        """Handle chat functionality"""
         if not message.strip():
             return history, ""
         
+        if not self.character_manager:
+            self.initialize_models()
+        
         try:
-            # Convert Gradio history to conversation format
+            # Convert history for context
             conversation_history = []
-            for user_msg, assistant_msg in history[-3:]:  # Last 3 exchanges for context
+            for user_msg, bot_msg in history[-3:]:
                 conversation_history.append({"role": "user", "content": user_msg})
-                if assistant_msg:
-                    conversation_history.append({"role": "assistant", "content": assistant_msg})
+                if bot_msg:
+                    conversation_history.append({"role": "assistant", "content": bot_msg})
             
-            # Generate response using character manager (correct method signature)
+            # Generate response
             response = self.character_manager.generate_response(
                 character_id=character_id,
                 user_message=message,
                 conversation_history=conversation_history
             )
             
-            # Update chat history
-            new_history = history + [(message, response)]
-            return new_history, ""
+            # Update history
+            history.append((message, response))
+            return history, ""
             
         except Exception as e:
-            error_response = f"❌ Error generating response: {str(e)}"
-            new_history = history + [(message, error_response)]
-            return new_history, ""
+            error_msg = f"❌ Error: {str(e)}"
+            history.append((message, error_msg))
+            return history, ""
+
+def create_interface():
+    """Create a simple Gradio interface"""
+    app = RoleplayChatApp()
     
-    def get_character_options(self):
-        """Get character dropdown options"""
-        options = []
-        for char_id in self.available_characters:
-            info = self.character_info[char_id]
-            label = f"{info['avatar']} {info['name']}"
-            options.append((label, char_id))
-        return options
+    # Simple function-based interface
+    def chat_with_character(message, character, history):
+        return app.chat_fn(message, character, history)
     
-    def create_interface(self):
-        """Create the Gradio interface"""
+    def clear_chat():
+        return []
+    
+    # Create simple interface
+    with gr.Blocks() as demo:
+        gr.Markdown("# 🎭 Roleplay Chat Box")
+        gr.Markdown("Chat with AI characters!")
         
-        with gr.Blocks(
-            title="🎭 Roleplay Chat Box",
-            theme=gr.themes.Soft(primary_hue="purple"),
-            css="""
-            .character-info {
-                background: linear-gradient(45deg, #667eea 0%, #764ba2 100%);
-                color: white;
-                padding: 1rem;
-                border-radius: 10px;
-                margin-bottom: 1rem;
-            }
-            .chat-container {
-                max-height: 500px;
-                overflow-y: auto;
-            }
-            """) as iface:
-            
-            gr.Markdown("# 🎭 Roleplay Chat Box")
-            gr.Markdown("Chat with different AI characters, each with unique personalities and expertise!")
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    # Character Selection
-                    gr.Markdown("## 👥 Choose Your Character")
-                    character_dropdown = gr.Dropdown(
-                        choices=self.get_character_options(),
-                        value="moses",
-                        label="Select Character",
-                        interactive=True
-                    )
-                    
-                    # Character Info Display
-                    character_info_display = gr.HTML(
-                        value=self._get_character_info_html("moses"),
-                        elem_classes=["character-info"]
-                    )
-                    
-                    # Update character info when dropdown changes
-                    def update_character_info(character_id):
-                        return self._get_character_info_html(character_id)
-                    
-                    character_dropdown.change(
-                        fn=update_character_info,
-                        inputs=[character_dropdown],
-                        outputs=[character_info_display]
-                    )
-                
-                with gr.Column(scale=2):
-                    # Chat Interface
-                    gr.Markdown("## 💬 Chat")
-                    chatbot = gr.Chatbot(
-                        height=400,
-                        show_label=False,
-                        container=True,
-                        elem_classes=["chat-container"]
-                    )
-                    
-                    with gr.Row():
-                        msg_input = gr.Textbox(
-                            placeholder="Type your message here...",
-                            show_label=False,
-                            scale=4,
-                            lines=1
-                        )
-                        send_btn = gr.Button("Send 📨", scale=1, variant="primary")
-                        clear_btn = gr.Button("Clear 🗑️", scale=1)
-            
-            # Initialize models on startup
-            gr.Markdown("### 🔄 Status")
-            status_display = gr.Textbox(value="Loading models...", label="System Status", interactive=False)
-            
-            # Chat functionality
-            def respond_and_clear(message, character_id, history):
-                new_history, _ = self.get_character_response(message, character_id, history)
-                return new_history, ""
-            
-            # Send message on button click or Enter
-            send_btn.click(
-                fn=respond_and_clear,
-                inputs=[msg_input, character_dropdown, chatbot],
-                outputs=[chatbot, msg_input]
-            )
-            
-            msg_input.submit(
-                fn=respond_and_clear,
-                inputs=[msg_input, character_dropdown, chatbot], 
-                outputs=[chatbot, msg_input]
-            )
-            
-            # Clear chat
-            clear_btn.click(
-                fn=lambda: ([], "Chat cleared!"),
-                outputs=[chatbot, status_display]
-            )
-            
-            # Initialize models when interface loads
-            def init_models():
-                if not self.character_manager:
-                    return self.initialize_models_sync()
-                else:
-                    return "✅ Models already loaded!"
-            
-            iface.load(
-                fn=init_models,
-                outputs=[status_display]
-            )
+        # Character selector
+        character_selector = gr.Radio(
+            choices=[
+                "moses", 
+                "samsung_employee", 
+                "jinx"
+            ],
+            value="moses",
+            label="Choose Character"
+        )
         
-        return iface
-    
-    def _get_character_info_html(self, character_id: str) -> str:
-        """Generate HTML for character information"""
-        if character_id not in self.character_info:
-            return "<div>Character not found</div>"
+        # Chat interface
+        chatbot = gr.Chatbot()
+        msg = gr.Textbox(label="Your Message", placeholder="Type here...")
+        clear = gr.Button("Clear Chat")
         
-        info = self.character_info[character_id]
-        return f"""
-        <div style="text-align: center;">
-            <div style="font-size: 3rem; margin-bottom: 0.5rem;">{info['avatar']}</div>
-            <h3 style="margin: 0.5rem 0; color: white;">{info['name']}</h3>
-            <p style="margin: 0; opacity: 0.9;">{info['description']}</p>
-        </div>
-        """
-
-# Create and launch the interface
-def create_demo():
-    chat_interface = RoleplayChatInterface()
-    return chat_interface.create_interface()
+        # Setup interactions
+        msg.submit(
+            chat_with_character, 
+            [msg, character_selector, chatbot], 
+            [chatbot, msg]
+        )
+        
+        clear.click(clear_chat, outputs=chatbot)
+    
+    return demo
 
-# For Hugging Face Spaces
 if __name__ == "__main__":
-    demo = create_demo()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False  # Not supported on Hugging Face Spaces
-    )
+    demo = create_interface()
+    demo.launch()

app_fixed.py

@@ -0,0 +1,113 @@
+import gradio as gr
+import os
+import sys
+import asyncio
+from typing import List, Tuple
+
+# Add backend to path for imports
+backend_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'backend')
+sys.path.insert(0, backend_path)
+
+from backend.models.character_manager import CharacterManager
+
+class RoleplayChatApp:
+    def __init__(self):
+        """Initialize the Roleplay Chat App"""
+        self.character_manager = None
+        
+    def initialize_models(self):
+        """Initialize the character manager synchronously"""
+        try:
+            print("🔄 Initializing character manager...")
+            self.character_manager = CharacterManager()
+            
+            # Use sync initialization
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(self.character_manager.initialize())
+            loop.close()
+            
+            print("✅ Models loaded successfully!")
+            return "✅ Models loaded successfully!"
+        except Exception as e:
+            print(f"❌ Failed to load models: {str(e)}")
+            return f"❌ Failed to load models: {str(e)}"
+    
+    def chat_fn(self, message, character_id, history):
+        """Handle chat functionality"""
+        if not message.strip():
+            return history, ""
+        
+        if not self.character_manager:
+            self.initialize_models()
+        
+        try:
+            # Convert history for context
+            conversation_history = []
+            for user_msg, bot_msg in history[-3:]:
+                conversation_history.append({"role": "user", "content": user_msg})
+                if bot_msg:
+                    conversation_history.append({"role": "assistant", "content": bot_msg})
+            
+            # Generate response
+            response = self.character_manager.generate_response(
+                character_id=character_id,
+                user_message=message,
+                conversation_history=conversation_history
+            )
+            
+            # Update history
+            history.append((message, response))
+            return history, ""
+            
+        except Exception as e:
+            error_msg = f"❌ Error: {str(e)}"
+            history.append((message, error_msg))
+            return history, ""
+
+def create_interface():
+    """Create a simple Gradio interface"""
+    app = RoleplayChatApp()
+    
+    # Simple function-based interface
+    def chat_with_character(message, character, history):
+        return app.chat_fn(message, character, history)
+    
+    def clear_chat():
+        return []
+    
+    # Create simple interface
+    with gr.Blocks() as demo:
+        gr.Markdown("# 🎭 Roleplay Chat Box")
+        gr.Markdown("Chat with AI characters!")
+        
+        # Character selector
+        character_selector = gr.Radio(
+            choices=[
+                "moses", 
+                "samsung_employee", 
+                "jinx"
+            ],
+            value="moses",
+            label="Choose Character"
+        )
+        
+        # Chat interface
+        chatbot = gr.Chatbot()
+        msg = gr.Textbox(label="Your Message", placeholder="Type here...")
+        clear = gr.Button("Clear Chat")
+        
+        # Setup interactions
+        msg.submit(
+            chat_with_character, 
+            [msg, character_selector, chatbot], 
+            [chatbot, msg]
+        )
+        
+        clear.click(clear_chat, outputs=chatbot)
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()

requirements.txt

@@ -7,8 +7,8 @@ datasets>=2.14.0
 huggingface-hub>=0.19.0
 safetensors>=0.4.0
 
-# Gradio for Hugging Face Spaces - use older stable version to avoid schema bugs
-gradio==4.20.0
+# Gradio for Hugging Face Spaces - use much older stable version
+gradio==3.50.0
 
 # Backend API
 fastapi>=0.104.0