Update app.py

app.py

@@ -1,75 +1,201 @@
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, send_from_directory
+from flask_cors import CORS
+import joblib
+import numpy as np
 import json
 import math
-import joblib
+import os
 import xgboost as xgb
+import logging
 
-app = Flask(__name__)
+app = Flask(__name__, static_folder=".", static_url_path="")
+CORS(app)
+logging.basicConfig(level=logging.INFO)
 
-# Load ML models
+# === Load models ===
 try:
-    rf_model = joblib.load("rf_model.pkl")
+    rf = joblib.load("rf_model.pkl")
     xgb_model = xgb.Booster()
     xgb_model.load_model("xgb_model.json")
-    print("✅ Models loaded")
+    app.logger.info("✅ Models loaded successfully.")
 except Exception as e:
-    print(f"❌ Model loading failed: {e}")
-    rf_model = None
-    xgb_model = None
+    app.logger.error(f"❌ Error loading models: {e}")
+    raise e
 
-# Load product catalog
-with open("tile_catalog.json") as f:
+# === Load data ===
+with open("tile_catalog.json", "r", encoding="utf-8") as f:
     tile_catalog = json.load(f)
 
-@app.route("/api/calculate", methods=["POST"])
-def calculate_tiles():
-    data = request.json
+with open("tile_sizes.json", "r", encoding="utf-8") as f:
+    tile_sizes = json.load(f)
+
+# === Serve Frontend ===
+@app.route('/')
+def serve_index():
+    return send_from_directory('.', 'index.html')
+
+@app.route('/<path:path>')
+def serve_static(path):
+    return send_from_directory('.', path)
+
+# === Calculate tile requirement ===
+@app.route('/calculate', methods=['POST'])
+def calculate():
     try:
-        length = float(data.get("length", 0))
-        width = float(data.get("width", 0))
-        tile_length = float(data.get("tile_length", 0))
-        tile_width = float(data.get("tile_width", 0))
+        data = request.get_json()
+        required_fields = ['tile_type', 'length', 'width', 'tile_size']
+        for field in required_fields:
+            if field not in data:
+                return jsonify({"error": f"Missing field: {field}"}), 400
+
+        tile_type = data['tile_type'].lower()
+        if tile_type not in ['floor', 'wall']:
+            return jsonify({"error": "Invalid tile type"}), 400
 
-        if not all([length, width, tile_length, tile_width]):
-            return jsonify({"error": "All dimensions must be provided"}), 400
+        tile_size = data['tile_size']
+        if tile_size not in tile_sizes:
+            return jsonify({"error": "Invalid tile size"}), 400
 
+        # Validate and compute area
+        length = float(data['length'])
+        width = float(data['width'])
+        validate_positive_number(length, "length")
+        validate_positive_number(width, "width")
         area = length * width
-        tile_area = tile_length * tile_width
-        tiles_needed = math.ceil((area / tile_area) * 1.1)  # 10% buffer
-        boxes_needed = math.ceil(tiles_needed / 10)  # Assume 10 tiles/box
+        validate_positive_number(area, "area")
+
+        # Calculate tile needs
+        tile_info = tile_sizes[tile_size]
+        area_per_tile = tile_info['length'] * tile_info['width']
+        tiles_needed = math.ceil((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)
+
+        # Find matching products
+        matching_products = [
+            {
+                **p,
+                "link": p.get("url", "#")
+            }
+            for p in tile_catalog
+            if p['type'].lower() == tile_type and p['size'] == tile_size
+        ]
 
         return jsonify({
-            "area": area,
-            "tile_area": tile_area,
+            "tile_type": tile_type,
+            "tile_size": tile_size,
+            "length": round(length, 2),
+            "width": round(width, 2),
+            "area": round(area, 2),
             "tiles_needed": tiles_needed,
-            "boxes_needed": boxes_needed
+            "boxes_needed": boxes_needed,
+            "matching_products": matching_products[:5],
+            "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
 
-@app.route("/recommend", methods=["POST"])
+# === Recommendation endpoint ===
+@app.route('/recommend', methods=['POST'])
 def recommend():
-    data = request.json
-    tile_type = data.get("tile_type", "").lower()
-    area = float(data.get("area_range", 0))
+    try:
+        data = request.get_json()
+        required_fields = ['tile_type', 'coverage', 'length', 'width', 'price_range']
+        for field in required_fields:
+            if field not in data:
+                return jsonify({"error": f"Missing field: {field}"}), 400
 
-    if not tile_catalog:
-        return jsonify({"result": "❌ No catalog available"})
+        tile_type = data['tile_type'].lower()
+        if tile_type not in ['floor', 'wall']:
+            return jsonify({"error": "Invalid tile type"}), 400
 
-    suggestions = []
+        length = float(data['length'])
+        width = float(data['width'])
+        validate_positive_number(length, "length")
+        validate_positive_number(width, "width")
+        area = length * width
+        validate_positive_number(area, "area")
+        coverage = float(data['coverage'])
+        validate_positive_number(coverage, "coverage")
+
+        if not isinstance(data['price_range'], list) or len(data['price_range']) != 2:
+            return jsonify({"error": "Invalid price range"}), 400
+
+        # Prepare features
+        features = prepare_features({
+            **data,
+            "area": area
+        })
+
+        xgb_pred = xgb_model.predict(xgb.DMatrix(features))[0]
+        rf_pred = rf.predict_proba(features)[0][1]
+        combined_score = (xgb_pred + rf_pred) / 2
+
+        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
+        )
+
+        return jsonify({
+            "recommendation_score": round(float(combined_score), 3),
+            "recommended_products": recommended_products[:5],
+            "calculation": calculate_requirements(area, coverage)
+        })
+
+    except Exception as e:
+        app.logger.error(f"Error in /recommend: {str(e)}")
+        return jsonify({"error": "Internal server error"}), 500
+
+# === Utility Functions ===
+def prepare_features(data):
+    tile_type_num = 0 if data['tile_type'] == 'floor' else 1
+    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], data['price_range'][1],
+                      price_per_sqft, budget_efficiency]])
+
+def filter_products(tile_type, min_price, max_price, preferred_sizes, min_score=0.5):
+    filtered = []
     for product in tile_catalog:
-        if product["type"].lower() == tile_type:
-            if product.get("area_range_min", 0) <= area <= product.get("area_range_max", float("inf")):
-                suggestions.append({
-                    "name": product.get("name", "Tile Product"),
-                    "price": product.get("price", "₹0"),
-                    "link": product.get("link", "#")
+        if (product['type'].lower() == tile_type and
+            min_price <= product['price'] <= max_price and
+            (not preferred_sizes or product['size'] in preferred_sizes)):
+
+            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),
+                    "link": product.get("url", "#")
                 })
 
-    if suggestions:
-        return jsonify({"result": "✅ Recommended", "suggestions": suggestions[:4]})
-    else:
-        return jsonify({"result": "❌ No matching products", "suggestions": []})
+    return sorted(filtered, key=lambda x: x['recommendation_score'], reverse=True)
+
+def calculate_requirements(area, coverage):
+    min_tiles = math.ceil(area / coverage)
+    suggested_tiles = math.ceil(min_tiles * 1.1)
+    return {
+        "minimum_tiles": min_tiles,
+        "suggested_tiles": suggested_tiles,
+        "estimated_cost_range": [
+            round(area * 3, 2),
+            round(area * 10, 2)
+        ]
+    }
+
+def validate_positive_number(value, field):
+    if not isinstance(value, (int, float)) or value <= 0:
+        raise ValueError(f"{field} must be a positive number")
 
-if __name__ == "__main__":
-    app.run(debug=True)
+# === Run the App ===
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860, debug=False)