Update app.py

app.py

@@ -1,18 +1,29 @@
 from flask import Flask, request, jsonify
+from flask_cors import CORS
 import joblib
 import numpy as np
 import json
 import math
 import xgboost as xgb
+import logging
 
 app = Flask(__name__)
+CORS(app)  # Allow cross-origin requests (important for frontend integration)
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
 
 # Load models
-rf = joblib.load("rf_model.pkl")
-xgb_model = xgb.Booster()
-xgb_model.load_model("xgb_model.json")  # Load the XGBoost model from JSON
+try:
+    rf = joblib.load("rf_model.pkl")
+    xgb_model = xgb.Booster()
+    xgb_model.load_model("xgb_model.json")
+    app.logger.info("✅ Models loaded successfully.")
+except Exception as e:
+    app.logger.error(f"❌ Error loading models: {e}")
+    raise e
 
-# Load tile catalog and sizes
+# Load tile data
 with open("tile_catalog.json", "r", encoding="utf-8") as f:
     tile_catalog = json.load(f)
 
@@ -34,44 +45,50 @@ def recommend():
     """
     try:
         data = request.get_json()
-        
-        # Validate input
+
         required_fields = ['tile_type', 'coverage', 'area', 'price_range']
         if not all(field in data for field in required_fields):
             return jsonify({"error": "Missing required fields"}), 400
-        
+
         tile_type = data['tile_type'].lower()
         if tile_type not in ['floor', 'wall']:
             return jsonify({"error": "Invalid tile type. Use 'floor' or 'wall'"}), 400
-        
-        # Feature engineering for ML prediction
+
+        # Validate numeric inputs
+        validate_positive_number(data['coverage'], "coverage")
+        validate_positive_number(data['area'], "area")
+        if (not isinstance(data['price_range'], list) or
+            len(data['price_range']) != 2 or
+            data['price_range'][0] < 0 or
+            data['price_range'][1] <= 0 or
+            data['price_range'][0] >= data['price_range'][1]):
+            return jsonify({"error": "Invalid price range"}), 400
+
         features = prepare_features(data)
-        
-        # Get predictions from both models
-        xgb_pred = xgb_model.predict(xgb.DMatrix(features))[0]  # XGBoost prediction
-        rf_pred = rf.predict_proba(features)[0][1]  # Random Forest prediction
+
+        xgb_pred = xgb_model.predict(xgb.DMatrix(features))[0]
+        rf_pred = rf.predict_proba(features)[0][1]
         combined_score = (xgb_pred + rf_pred) / 2
-        
-        # Filter products based on criteria
+
         recommended_products = filter_products(
             tile_type=tile_type,
             min_price=data['price_range'][0],
             max_price=data['price_range'][1],
             preferred_sizes=data.get('preferred_sizes', []),
-            min_score=0.5  # Threshold for recommendation
+            min_score=0.5
         )
-        
-        # Prepare response
+
         response = {
             "recommendation_score": round(float(combined_score), 3),
-            "recommended_products": recommended_products[:5],  # Return top 5
+            "total_matches": len(recommended_products),
+            "recommended_products": recommended_products[:5],
             "calculation": calculate_requirements(data['area'], data['coverage'])
         }
-        
         return jsonify(response)
-    
+
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        app.logger.error(f"Error in /recommend: {str(e)}")
+        return jsonify({"error": "Internal server error"}), 500
 
 @app.route('/calculate', methods=['POST'])
 def calculate():
@@ -81,96 +98,102 @@ def calculate():
     {
         "tile_type": "floor"|"wall",
         "area": float,
-        "tile_size": "12x12"|etc (from tile_sizes.json)
+        "tile_size": "12x12"|etc
     }
     """
     try:
         data = request.get_json()
-        
-        # Validate input
+
         if 'tile_type' not in data or 'area' not in data or 'tile_size' not in data:
             return jsonify({"error": "Missing required fields"}), 400
-            
+
         tile_type = data['tile_type'].lower()
         if tile_type not in ['floor', 'wall']:
             return jsonify({"error": "Invalid tile type"}), 400
-            
+
         if data['tile_size'] not in tile_sizes:
             return jsonify({"error": "Invalid tile size"}), 400
-            
-        # Perform calculation
+
+        validate_positive_number(data['area'], "area")
+
         tile_info = tile_sizes[data['tile_size']]
         area_per_tile = tile_info['length'] * tile_info['width']
-        num_tiles = math.ceil((data['area'] / area_per_tile) * 1.1)  # 10% buffer
-        num_boxes = math.ceil(num_tiles / tile_info.get('tiles_per_box', 10))
-        
-        # Get matching products
+        tiles_needed = math.ceil((data['area'] / area_per_tile) * 1.1)
+        tiles_per_box = tile_info.get('tiles_per_box', 10)
+        boxes_needed = math.ceil(tiles_needed / tiles_per_box)
+
         matching_products = [
-            p for p in tile_catalog 
+            p for p in tile_catalog
             if p['type'].lower() == tile_type and p['size'] == data['tile_size']
         ]
-        
+
         return jsonify({
             "tile_type": tile_type,
             "area": data['area'],
             "tile_size": data['tile_size'],
-            "tiles_needed": num_tiles,
-            "boxes_needed": num_boxes,
-            "matching_products": matching_products[:3]  # Return top 3 matches
+            "tiles_needed": tiles_needed,
+            "boxes_needed": boxes_needed,
+            "matching_products": matching_products[:3],
+            "total_matches": len(matching_products)
         })
-        
+
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        app.logger.error(f"Error in /calculate: {str(e)}")
+        return jsonify({"error": "Internal server error"}), 500
 
 def prepare_features(data):
-    """Prepare feature vector for ML model prediction"""
+    """Prepare feature vector for ML prediction"""
     tile_type_num = 0 if data['tile_type'] == 'floor' else 1
-    price_per_sqft = data['price_range'][1] / data['coverage']  # Using max price
+    price_per_sqft = data['price_range'][1] / data['coverage']
     budget_efficiency = data['coverage'] / data['price_range'][1]
-    
+
     return np.array([[
         tile_type_num,
         data['area'],
         data['coverage'],
-        data['price_range'][0],  # min price
-        data['price_range'][1],  # max price
+        data['price_range'][0],
+        data['price_range'][1],
         price_per_sqft,
         budget_efficiency
     ]])
 
 def filter_products(tile_type, min_price, max_price, preferred_sizes, min_score=0.5):
-    """Filter products based on criteria"""
+    """Filter and score products"""
     filtered = []
-    
     for product in tile_catalog:
         if (product['type'].lower() == tile_type and
             min_price <= product['price'] <= max_price and
             (not preferred_sizes or product['size'] in preferred_sizes)):
-            
-            # Calculate a simple score (could be enhanced)
-            price_score = 1 - ((product['price'] - min_price) / (max_price - min_price))
+
+            price_score = 1 - ((product['price'] - min_price) / (max_price - min_price + 1e-6))
             size_score = 1 if not preferred_sizes or product['size'] in preferred_sizes else 0.5
             product_score = (price_score + size_score) / 2
-            
+
             if product_score >= min_score:
                 filtered.append({
                     **product,
                     "recommendation_score": round(product_score, 2)
                 })
-    
-    # Sort by recommendation score
+
     return sorted(filtered, key=lambda x: x['recommendation_score'], reverse=True)
 
 def calculate_requirements(area, coverage):
-    """Calculate basic requirements"""
+    """Calculate tile quantities and estimated costs"""
+    min_tiles = math.ceil(area / coverage)
+    suggested_tiles = math.ceil(min_tiles * 1.1)
     return {
-        "minimum_tiles": math.ceil(area / coverage),
-        "suggested_tiles": math.ceil((area / coverage) * 1.1),  # 10% buffer
+        "minimum_tiles": min_tiles,
+        "suggested_tiles": suggested_tiles,
         "estimated_cost_range": [
-            round(area * 3, 2),  # $3/sqft (example)
-            round(area * 10, 2)   # $10/sqft (example)
+            round(area * 3, 2),  # example: ₹3 per sqft
+            round(area * 10, 2)  # example: ₹10 per sqft
         ]
     }
 
+def validate_positive_number(value, field):
+    """Raise ValueError if value is not a positive number"""
+    if not isinstance(value, (int, float)) or value <= 0:
+        raise ValueError(f"{field} must be a positive number")
+
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=5000, debug=True)