Update app.py

app.py

@@ -1,254 +1,120 @@
-#!/usr/bin/env python3
-"""
-MMORPG Application - Refactored Clean Architecture
-Main application entry point using clean architecture principles
-"""
-
-import gradio as gr
-import asyncio
-import threading
-from typing import Optional
-import os
-import uvicorn
-from gradio.routes import App
-
-# Import our clean architecture components
-from src.core.game_engine import GameEngine
-from src.facades.game_facade import GameFacade
-from src.ui.huggingface_ui import HuggingFaceUI
-from src.ui.improved_interface_manager import ImprovedInterfaceManager
-from src.mcp.mcp_tools import GradioMCPTools
-
-class MMORPGApplication:
-    """Main application class that orchestrates the MMORPG game."""
-    
-    def __init__(self):
-        """Initialize the application with all necessary components."""
-        # Initialize core game engine (singleton)
-        self.game_engine = GameEngine()
-          # Initialize game facade for simplified operations
-        self.game_facade = GameFacade()
-        
-        # Initialize UI components
-        self.ui = HuggingFaceUI(self.game_facade)
-        self.interface_manager = ImprovedInterfaceManager(self.game_facade, self.ui)
-        
-        # Initialize MCP tools for AI agent integration
-        self.mcp_tools = GradioMCPTools(self.game_facade)
-        
-        # Gradio interface reference
-        self.gradio_interface: Optional[gr.Blocks] = None
-        
-        # Background tasks
-        self._cleanup_task = None
-        self._auto_refresh_task = None
-        
-    def create_gradio_interface(self) -> gr.Blocks:
-        """Create and configure the Gradio interface."""
-        # Use the ImprovedInterfaceManager to create the complete interface with proper event handling
-        self.gradio_interface = self.interface_manager.create_interface()
-        return self.gradio_interface
-    
-    def start_background_tasks(self):
-        """Start background tasks for game maintenance."""
-        
-        def cleanup_task():
-            """Background task for cleaning up inactive players."""
-            while True:
-                try:
-                    self.game_facade.cleanup_inactive_players()
-                    threading.Event().wait(30)  # Wait 30 seconds
-                except Exception as e:
-                    print(f"Error in cleanup task: {e}")
-                    threading.Event().wait(5)  # Wait before retry
-        
-        def auto_refresh_task():
-            """Background task for auto-refreshing game state."""
-            while True:
-                try:
-                    # Trigger refresh for active sessions
-                    # This would need session tracking for real implementation
-                    threading.Event().wait(2)  # Refresh every 2 seconds
-                except Exception as e:
-                    print(f"Error in auto-refresh task: {e}")
-                    threading.Event().wait(5)  # Wait before retry
-        
-        # Start cleanup task
-        self._cleanup_task = threading.Thread(target=cleanup_task, daemon=True)
-        self._cleanup_task.start()
-        
-        # Start auto-refresh task
-        self._auto_refresh_task = threading.Thread(target=auto_refresh_task, daemon=True)
-        self._auto_refresh_task.start()
-    
-    def run(self, share: bool = False, server_port: int = 7860):
-        """Run the MMORPG application."""
-        print("🎮 Starting MMORPG Application...")
-        print("🏗️  Initializing game engine...")
-          # Initialize game world and services
-        if not self.game_engine.start():
-            print("❌ Failed to start game engine")
-            return
-        
-        print("🎨 Creating user interface...")
-        
-        # Create Gradio interface
-        interface = self.create_gradio_interface()
-        
-        print("🔧 Starting background tasks...")
-        
-        # Start background maintenance tasks
-        self.start_background_tasks()
-        
-        print("🚀 Launching server...")
-        print(f"🌐 Server will be available at: http://localhost:{server_port}")
-        
-        if share:
-            print("🔗 Public URL will be generated...")
-          # Launch the interface
-        interface.launch(
-            share=share,
-            debug=True,
-            server_port=server_port,
-            mcp_server=True,  # Enable MCP server integration
-            show_error=True,
-            quiet=False
-        )
-
-    def launch_with_fallback(self, share: bool = False, server_port: int = 7860):
-        """Launch with multiple fallback options for ASGI errors."""
-        
-        # Get the interface first
-        interface = self.create_gradio_interface()
-        
-        try:
-            # Method 1: Standard MCP launch
-            print("Attempting standard MCP launch...")
-            interface.launch(
-                mcp_server=True,
-                debug=True,
-                share=share,
-                server_port=server_port,
-                show_error=False,  # Reduce error display that can cause ASGI issues
-                prevent_thread_lock=False
-            )
-            
-        except Exception as e:
-            print(f"Standard MCP launch failed: {e}")
-            
-            try:
-                # Method 2: Launch with specific ASGI settings
-                print("Attempting launch with ASGI workarounds...")
-                
-                # Set environment variables for better ASGI handling
-                os.environ['GRADIO_SERVER_NAME'] = '0.0.0.0'
-                os.environ['GRADIO_SERVER_PORT'] = str(server_port)
-                os.environ['GRADIO_DEBUG'] = 'false'
-                
-                interface.launch(
-                    mcp_server=True,
-                    debug=False,
-                    share=share,
-                    auth=None,
-                    max_threads=10
-                )
-                
-            except Exception as e2:
-                print(f"ASGI workaround failed: {e2}")
-                
-                try:
-                    # Method 3: Manual Uvicorn launch
-                    print("Attempting manual Uvicorn launch...")
-                    
-                    # Get the FastAPI app from Gradio
-                    app = interface.app
-                    
-                    # Configure Uvicorn with specific settings for MCP
-                    config = uvicorn.Config(
-                        app=app,
-                        host="0.0.0.0",
-                        port=server_port,
-                        log_level="info",
-                        access_log=False,
-                        server_header=False,
-                        date_header=False,
-                        loop="asyncio",
-                        timeout_keep_alive=30,
-                        timeout_notify=30,
-                        limit_concurrency=100,
-                        limit_max_requests=1000
-                    )
-                    
-                    server = uvicorn.Server(config)
-                    server.run()
-                    
-                except Exception as e3:
-                    print(f"Manual Uvicorn launch failed: {e3}")
-                    
-                    # Method 4: Fallback to regular Gradio (no MCP)
-                    print("Falling back to regular Gradio without MCP...")
-                    interface.launch(
-                        debug=False,
-                        share=share,
-                        server_port=server_port,
-                        show_error=True
-                    )
-
-    def launch_with_threading(self, share: bool = False, server_port: int = 7860):
-        """Launch using threading to avoid asyncio event loop conflicts."""
-        
-        # Get the interface first
-        interface = self.create_gradio_interface()
-        
-        def run_server():
-            try:
-                # Create new event loop for this thread
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                
-                interface.launch(
-                    mcp_server=True,
-                    debug=True,
-                    share=share,
-                    server_port=server_port,
-                    prevent_thread_lock=False
-                )
-            except Exception as e:
-                print(f"Threading launch failed: {e}")
-                # Fallback without MCP
-                interface.launch(debug=False, share=share, server_port=server_port)
-        
-        # Start server in separate thread
-        server_thread = threading.Thread(target=run_server, daemon=True)
-        server_thread.start()
-        server_thread.join()
-
-def main():
-    """Main entry point for the application."""
-    # Create and run the application
-    app = MMORPGApplication()
-    
-    # Check if running on HuggingFace Spaces
-    if os.getenv("SPACE_ID"):
-        print("Running on HuggingFace Spaces")
-        # Use more conservative settings for Spaces
-        try:
-            interface = app.create_gradio_interface()
-            interface.launch(
-                mcp_server=True,
-                debug=True,
-                share=True,
-                show_error=False,
-                server_port=int(os.getenv("PORT", 7860))
-            )
-        except:
-            # Fallback for Spaces
-            interface = app.create_gradio_interface()
-            interface.launch(share=False, debug=False)
-    else:
-        # Local development
-        print("Running locally with enhanced launcher")
-        app.run(share=True, server_port=7869)
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""
+MMORPG Application - HuggingFace Space Version
+Simplified version for HuggingFace deployment with fallback imports
+"""
+
+import gradio as gr
+import asyncio
+import os
+import sys
+from typing import Optional
+
+# Add current directory to Python path for HF Spaces
+current_dir = os.path.dirname(os.path.abspath(__file__))
+if current_dir not in sys.path:
+    sys.path.insert(0, current_dir)
+
+def create_fallback_interface():
+    """Create a fallback interface if main components fail to load."""
+    with gr.Blocks(title="MMORPG - Limited Mode") as interface:
+        gr.Markdown("""
+        # 🎮 MMORPG Application - Limited Mode
+        
+        **Note:** Running in limited mode due to import issues.
+        
+        This is a simplified version that focuses on core functionality.
+        """)
+        
+        with gr.Tab("🔍 SearchHF Oracle"):
+            gr.Markdown("""
+            ## 🔍 SearchHF Oracle
+            
+            Advanced Hugging Face search using MCP integration.
+            """)
+            
+            query_input = gr.Textbox(
+                label="Search Query", 
+                placeholder="e.g., 'text-generation models'"
+            )
+            search_btn = gr.Button("🔍 Search", variant="primary")
+            search_output = gr.Textbox(
+                label="Search Results",
+                lines=10,
+                interactive=False
+            )
+            
+            def simple_search(query):
+                if not query.strip():
+                    return "❌ Please enter a search query"
+                return f"🔍 **Search Results for:** {query}\n\n⚠️ Full MCP integration not available in this environment.\n\nTo use full functionality, please run locally."
+            
+            search_btn.click(
+                simple_search,
+                inputs=[query_input],
+                outputs=[search_output]
+            )
+        
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown("""
+            # About MMORPG Application
+            
+            This is an AI-powered MMORPG with:
+            - **MCP Integration** - Model Context Protocol for AI agents
+            - **Dynamic NPCs** - AI-powered non-player characters  
+            - **Plugin System** - Extensible addon architecture
+            - **Real-time Chat** - Multi-channel communication
+            - **Trading System** - Virtual economy
+            
+            ## 🚀 Full Version
+            
+            For the complete experience with all features, please run the application locally.
+            
+            ## 🔧 Technical Details
+            
+            - **Framework:** Gradio + Python
+            - **AI Integration:** MCP (Model Context Protocol)
+            - **Architecture:** Clean architecture with dependency injection
+            """)
+    
+    return interface
+
+def main():
+    """Main application entry point for HuggingFace Spaces."""
+    try:
+        # Try to import the full application
+        from src.core.game_engine import GameEngine
+        from src.facades.game_facade import GameFacade
+        from src.ui.huggingface_ui import HuggingFaceUI
+        from src.ui.improved_interface_manager import ImprovedInterfaceManager
+        from src.mcp.mcp_tools import GradioMCPTools
+        
+        # Initialize full application
+        game_engine = GameEngine()
+        game_facade = GameFacade()
+        ui = HuggingFaceUI(game_facade)
+        interface_manager = ImprovedInterfaceManager(game_facade, ui)
+        
+        # Create the complete interface
+        interface = interface_manager.create_interface()
+        
+        print("✅ Full MMORPG application loaded successfully!")
+        
+    except Exception as e:
+        print(f"⚠️ Failed to load full application: {e}")
+        print("🔄 Falling back to limited mode...")
+        
+        # Create fallback interface
+        interface = create_fallback_interface()
+    
+    # Launch the interface
+    interface.launch(
+        #server_name="0.0.0.0",
+        #server_port=7860,  # Standard HF port
+        share=True,
+        debug=True,
+       # quiet=False
+    )
+
+if __name__ == "__main__":
+    main()