Update app.py

app.py

@@ -1,129 +1,173 @@
-from flask import Flask, render_template, request, jsonify
-import yaml
-from datetime import datetime
-import threading
-import logging
 import os
 import time
+import json
+import logging
+from threading import Event
+from flask import Flask, request, jsonify, render_template
+import yaml
+from datetime import datetime
 import stat
 
+# Initialize Flask app
 app = Flask(__name__)
 
+# Configuration
+CONFIG_PATH = 'config/config.yaml'
+DATA_PATH = 'data/rupeia_document.json'
+CACHE_DIR = '/app/cache'
+
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
-# Sample default documents if file is missing
+# Global state
+models_loaded = False
+loading_event = Event()
+loading_error = None
+app_start_time = time.time()
+
+# Default data
 DEFAULT_DOCUMENTS = [
     {"content": "Rupeia offers investment plans with returns between 5-10%", "category": "investments"},
     {"content": "You can set up savings goals in the mobile app", "category": "goals"}
 ]
 
-# Load configuration
-try:
-    with open('config/config.yaml', 'r') as f:
-        config = yaml.safe_load(f)
-except Exception as e:
-    logger.warning(f"Config load failed: {str(e)}")
-    config = {
-        'quick_replies': [
-            {"title": "Investments", "value": "investment options"},
-            {"title": "Savings", "value": "saving goals"}
-        ]
-    }
+DEFAULT_CONFIG = {
+    'quick_replies': [
+        {"title": "Investments", "value": "investment options"},
+        {"title": "Savings", "value": "saving goals"}
+    ]
+}
 
-# Model loading status
-models_loaded = False
-loading_error = None
+def load_config():
+    """Load configuration with fallback to defaults"""
+    try:
+        with open(CONFIG_PATH, 'r') as f:
+            return yaml.safe_load(f) or DEFAULT_CONFIG
+    except Exception as e:
+        logger.warning(f"Config load failed: {str(e)}")
+        return DEFAULT_CONFIG
 
-def load_models_with_retries(max_retries=3, retry_delay=5, timeout=120):
+config = load_config()
+
+def initialize_data_file():
+    """Ensure data file exists with proper permissions"""
+    try:
+        if not os.path.exists(DATA_PATH):
+            os.makedirs('data', exist_ok=True)
+            with open(DATA_PATH, 'w') as f:
+                json.dump(DEFAULT_DOCUMENTS, f)
+            os.chmod(DATA_PATH, stat.S_IRUSR | stat.S_IWUSR)
+            logger.info(f"Initialized data file at {DATA_PATH}")
+    except Exception as e:
+        logger.error(f"Data file initialization failed: {str(e)}")
+        raise
+
+def load_models():
+    """Synchronously load ML models with proper error handling"""
     global models_loaded, loading_error
-    start_time = time.time()
-    for attempt in range(max_retries):
-        try:
-            logger.info(f"Attempt {attempt + 1}/{max_retries}: Starting model loading...")
-            
-            # Log cache contents for debugging
-            cache_folder = '/app/cache'
-            if os.path.exists(cache_folder):
-                logger.info(f"Cache folder contents: {os.listdir(cache_folder)}")
-            
-            # Import inside function to prevent circular imports
-            from src.retrieval import DocumentRetriever
-            from src.generation import ResponseGenerator
-            
-            # Check if data file exists, create if not
-            data_path = 'data/rupeia_document.json'
-            if not os.path.exists(data_path):
-                os.makedirs('data', exist_ok=True)
-                with open(data_path, 'w') as f:
-                    import json
-                    json.dump(DEFAULT_DOCUMENTS, f)
-                # Set permissions for the file
-                os.chmod(data_path, stat.S_IRUSR | stat.S_IWUSR)
-                logger.info(f"Created default data file with permissions: {oct(os.stat(data_path).st_mode)[-3:]}")
-            
-            # Initialize models with explicit cache directory
-            app.retriever = DocumentRetriever(cache_folder=cache_folder)
-            app.generator = ResponseGenerator(cache_folder=cache_folder)
-            models_loaded = True
-            logger.info(f"Models loaded successfully in {time.time() - start_time:.2f} seconds")
-            return
-        except Exception as e:
-            loading_error = str(e)
-            logger.error(f"Model loading failed: {loading_error}")
-            if attempt < max_retries - 1:
-                logger.info(f"Retrying in {retry_delay} seconds...")
-                time.sleep(retry_delay)
-            if time.time() - start_time > timeout:
-                logger.error("Model loading timed out")
-                break
-    
-    logger.error("All retry attempts failed. Models not loaded.")
-
-# Start loading in background
-threading.Thread(target=load_models_with_retries, daemon=True).start()
+
+    try:
+        logger.info("Starting model initialization...")
+        start_time = time.time()
+
+        # Verify cache accessibility
+        if not os.access(CACHE_DIR, os.W_OK):
+            raise PermissionError(f"Cannot write to cache directory: {CACHE_DIR}")
+
+        # Initialize data file
+        initialize_data_file()
+
+        # Dynamic imports to prevent circular dependencies
+        from src.retrieval import DocumentRetriever
+        from src.generation import ResponseGenerator
+
+        # Initialize models
+        app.retriever = DocumentRetriever(cache_folder=CACHE_DIR)
+        app.generator = ResponseGenerator(cache_folder=CACHE_DIR)
+
+        models_loaded = True
+        logger.info(f"Models loaded successfully in {time.time() - start_time:.2f} seconds")
+
+    except Exception as e:
+        loading_error = str(e)
+        logger.error(f"Model loading failed: {loading_error}")
+        raise
+    finally:
+        loading_event.set()
+
+@app.before_first_request
+def before_first_request():
+    """Ensure models are loading when first request comes in"""
+    if not loading_event.is_set():
+        logger.warning("Models not yet loaded when request received")
+        loading_event.wait()
 
 @app.route('/')
 def home():
-    return render_template('index.html')
+    """Render main interface"""
+    return render_template('index.html', quick_replies=config.get('quick_replies', []))
 
 @app.route('/health')
 def health():
-    """Check if the application is ready to process requests."""
-    status = "ready" if models_loaded else "initializing"
-    return jsonify({
-        "status": status,
-        "error": loading_error if loading_error else None,
-        "uptime": time.time() - app.start_time
-    })
+    """Comprehensive health check endpoint"""
+    status = {
+        "status": "ready" if models_loaded else "initializing",
+        "uptime_seconds": round(time.time() - app_start_time, 2),
+        "models_loaded": models_loaded,
+        "last_error": loading_error,
+        "system": {
+            "cache_accessible": os.access(CACHE_DIR, os.R_OK | os.W_OK),
+            "data_file_exists": os.path.exists(DATA_PATH),
+            "memory_usage_mb": os.sys.getsizeof({}) // (1024 * 1024)  # Placeholder
+        },
+        "timestamp": datetime.utcnow().isoformat()
+    }
+    return jsonify(status), 200 if models_loaded else 503
 
 @app.route('/api/chat', methods=['POST'])
 def chat():
+    """Handle chat requests with proper error handling"""
     if not models_loaded:
-        message = "System is initializing..."
-        if loading_error:
-            message = f"System error: {loading_error}"
         return jsonify({
-            'text': message,
+            'text': loading_error or "System is initializing, please try again shortly",
             'quickReplies': config.get('quick_replies', []),
-            'conversation_id': str(datetime.now().timestamp())
-        })
-    
-    user_message = request.json.get('message', '')
+            'conversation_id': str(datetime.utcnow().timestamp()),
+            'status': 'initializing'
+        }), 503
+
     try:
+        user_message = request.json.get('message', '').strip()
+        if not user_message:
+            raise ValueError("Empty message received")
+
         context = app.retriever.retrieve(user_message)
         response = app.generator.generate(user_message, context)
+
+        return jsonify({
+            'text': response,
+            'quickReplies': config.get('quick_replies', []),
+            'conversation_id': str(datetime.utcnow().timestamp()),
+            'status': 'success'
+        })
+
     except Exception as e:
-        logger.error(f"Error generating response: {str(e)}")
-        response = "Sorry, I encountered an error processing your request"
-    
-    return jsonify({
-        'text': response,
-        'quickReplies': config.get('quick_replies', []),
-        'conversation_id': str(datetime.now().timestamp())
-    })
+        logger.error(f"Chat error: {str(e)}", exc_info=True)
+        return jsonify({
+            'text': "Sorry, I encountered an error processing your request",
+            'quickReplies': config.get('quick_replies', []),
+            'conversation_id': str(datetime.utcnow().timestamp()),
+            'status': 'error',
+            'error': str(e)
+        }), 500
 
 if __name__ == '__main__':
-    app.start_time = time.time()
-    app.run(host='0.0.0.0', port=8000)
+    # Start model loading in main thread for gunicorn compatibility
+    load_models()
+    app.run(host='0.0.0.0', port=8000, threaded=True)
+else:
+    # When running under Gunicorn
+    load_models()