Update app.py

app.py

@@ -4,9 +4,7 @@ import os
 import traceback
 import gradio as gr
 import logging
-import asyncio
 import torch
-from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
@@ -16,15 +14,15 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
 
 try:
-    from src.components.ai_core import AICore
-    from src.aegis_integration import AegisBridge
-    from src.aegis_integration.config import AEGIS_CONFIG
+    from components.ai_core import AICore
+    from components.aegis_integration import AegisBridge
+    from components.aegis_integration.config import AEGIS_CONFIG
     from components.search_engine import SearchEngine
 except ImportError:
     # Fallback for container environment
     from src.components.ai_core import AICore
-    from src.aegis_integration import AegisBridge
-    from src.aegis_integration.config import AEGIS_CONFIG
+    from src.components.aegis_integration import AegisBridge
+    from src.components.aegis_integration.config import AEGIS_CONFIG
     from src.components.search_engine import SearchEngine
 
 # Configure logging
@@ -118,7 +116,7 @@ except Exception as e:
     logger.error(f"Error initializing model: {e}")
     sys.exit(1)
 
-async def process_message(message: str, history: list) -> tuple:
+def process_message(message: str, history: list) -> tuple:
     """Process chat messages with improved context management"""
     try:
         # Clean input
@@ -127,18 +125,8 @@ async def process_message(message: str, history: list) -> tuple:
             return "", history
             
         try:
-            # Get response from AI core asynchronously
-            if hasattr(ai_core, 'generate_text_async'):
-                response = await ai_core.generate_text_async(message)
-            else:
-                # Fallback to sync version in ThreadPoolExecutor
-                loop = asyncio.get_event_loop()
-                with ThreadPoolExecutor() as pool:
-                    response = await loop.run_in_executor(
-                        pool, 
-                        ai_core.generate_text, 
-                        message
-                    )
+            # Get response from AI core
+            response = ai_core.generate_text(message)
             
             # Clean and validate response
             if response is None:
@@ -267,81 +255,35 @@ with gr.Blocks(title="Codette") as iface:
             # Set up search event handlers
             search_btn.click(sync_search, search_input, search_output)
             search_input.submit(sync_search, search_input, search_output)
-# Run the Gradio interface with proper async handling
-async def shutdown():
-    """Cleanup function for graceful shutdown"""
-    try:
-        # Save final quantum state if available
-        if hasattr(ai_core, 'cocoon_manager') and ai_core.cocoon_manager:
-            try:
-                ai_core.cocoon_manager.save_cocoon({
-                    "type": "shutdown",
-                    "quantum_state": ai_core.quantum_state
-                })
-                logger.info("Final quantum state saved")
-            except Exception as e:
-                logger.error(f"Error saving final quantum state: {e}")
-        
-        # Shutdown AI core
-        try:
-            await ai_core.shutdown()
-            logger.info("AI Core shutdown complete")
-        except Exception as e:
-            logger.error(f"Error shutting down AI Core: {e}")
-            
-        # Clear CUDA cache if GPU was used
-        if torch.cuda.is_available():
-            try:
-                torch.cuda.empty_cache()
-                logger.info("CUDA cache cleared")
-            except Exception as e:
-                logger.error(f"Error clearing CUDA cache: {e}")
-                
-    except Exception as e:
-        logger.error(f"Error during shutdown: {e}")
-        raise
 
+# Run the Gradio interface
 if __name__ == "__main__":
     try:
-        # Set up exception handling
-        def handle_exception(loop, context):
-            msg = context.get("exception", context["message"])
-            logger.error(f"Caught exception: {msg}")
-            
-        # Set up asyncio event loop with proper error handling
-        loop = asyncio.new_event_loop()
-        loop.set_exception_handler(handle_exception)
-        asyncio.set_event_loop(loop)
-        
-        # Launch Gradio interface
+        # Launch Gradio interface - let Gradio handle event loop
         iface.queue().launch(
-            prevent_thread_lock=True,
             share=False,
-            server_name="127.0.0.1",
+            server_name="0.0.0.0",
+            server_port=7860,
             show_error=True,
             theme=gr.themes.Soft()
         )
-        
-        try:
-            # Keep the main loop running
-            loop.run_forever()
-        except Exception as e:
-            logger.error(f"Error in main loop: {e}")
-            traceback.print_exc()
     except KeyboardInterrupt:
         logger.info("Shutting down gracefully...")
         try:
-            loop.run_until_complete(shutdown())
+            # Save final quantum state if available
+            if hasattr(ai_core, 'cocoon_manager') and ai_core.cocoon_manager:
+                try:
+                    ai_core.cocoon_manager.save_cocoon({
+                        "type": "shutdown",
+                        "quantum_state": ai_core.quantum_state
+                    })
+                    logger.info("Final quantum state saved")
+                except Exception as e:
+                    logger.error(f"Error saving final quantum state: {e}")
         except Exception as e:
             logger.error(f"Error during shutdown: {e}")
-    finally:
-        try:
-            tasks = asyncio.all_tasks(loop)
-            for task in tasks:
-                task.cancel()
-            loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
-            loop.close()
-        except Exception as e:
-            logger.error(f"Error closing loop: {e}")
-            sys.exit(1)
-        sys.exit(0)
+        sys.exit(0)
+    except Exception as e:
+        logger.error(f"Error launching Gradio interface: {e}")
+        traceback.print_exc()
+        sys.exit(1)