Update app.py

app.py

@@ -10,7 +10,7 @@ import os
 app = Flask(__name__, static_folder='.', static_url_path='/')
 CORS(app)
 
-# Load models
+# Load ML models
 try:
     rf = joblib.load("rf_model.pkl")
     xgb_model = xgb.Booster()
@@ -20,82 +20,85 @@ except Exception as e:
     print(f"❌ Error loading models: {e}")
     raise e
 
-# Load tile catalog and tile size data
+# Load tile data
 with open("tile_catalog.json", "r", encoding="utf-8") as f:
     tile_catalog = json.load(f)
-
 with open("tile_sizes.json", "r", encoding="utf-8") as f:
-    tile_sizes_list = json.load(f)
-    tile_sizes = {item["label"]: item["area_sqft"] for item in tile_sizes_list}
+    tile_sizes = json.load(f)
 
 @app.route("/")
 def index():
     return send_from_directory(".", "index.html")
 
-@app.route("/calculate", methods=["POST"])
-def calculate():
+@app.route("/recommend", methods=["POST"])
+def recommend():
     try:
         data = request.get_json()
         tile_type = data.get("tile_type", "").lower()
-        area = float(data.get("area", 0))
-        tile_size_label = data.get("tile_size", "")
-
-        if tile_size_label not in tile_sizes:
-            return jsonify({"error": "Invalid tile size"}), 400
+        coverage = float(data.get("coverage", 1))
+        area = float(data.get("area", 1))
+        price_range = data.get("price_range", [1, 100])
+        preferred_sizes = data.get("preferred_sizes", [])
 
-        per_tile_area = tile_sizes[tile_size_label]
-        tiles_needed = math.ceil((area / per_tile_area) * 1.1)
-        boxes = math.ceil(tiles_needed / 10)
+        if coverage <= 0 or area <= 0:
+            return jsonify({"error": "Please enter valid positive values for area and coverage."}), 400
 
-        matching_products = [
-            p for p in tile_catalog
-            if p["type"].lower() == tile_type and p["size"] == tile_size_label
-        ]
+        features = prepare_features(tile_type, coverage, area, price_range)
+        xgb_pred = xgb_model.predict(xgb.DMatrix(features))[0]
+        rf_pred = rf.predict_proba(features)[0][1]
+        score = (xgb_pred + rf_pred) / 2
 
+        products = filter_products(tile_type, price_range, preferred_sizes)
         return jsonify({
-            "tile_type": tile_type,
-            "area": area,
-            "tile_size": tile_size_label,
-            "tiles_needed": tiles_needed,
-            "boxes_needed": boxes,
-            "matching_products": matching_products[:3],
-            "total_matches": len(matching_products)
+            "recommendation_score": round(float(score), 3),
+            "recommended_products": products[:4],
+            "total_matches": len(products),
         })
     except Exception as e:
-        print(f"❌ Error in /calculate: {e}")
+        print("❌ Error in /recommend:", str(e))
         return jsonify({"error": "Server error"}), 500
 
-@app.route("/recommend", methods=["POST"])
-def recommend():
+@app.route("/calculate", methods=["POST"])
+def calculate():
     try:
         data = request.get_json()
-        tile_type = data.get("tile_type", "").lower()
+        tile_type = data.get("tile_type", "").strip().lower()
         area = float(data.get("area", 0))
-        coverage = float(data.get("coverage", 1))
-        price_range = data.get("price_range", [1, 100000])
-        preferred_sizes = data.get("preferred_sizes", [])
+        tile_size = data.get("tile_size", "").strip()
 
-        features = prepare_features(tile_type, coverage, area, price_range)
-        xgb_pred = xgb_model.predict(xgb.DMatrix(features))[0]
-        rf_pred = rf.predict_proba(features)[0][1]
-        score = (xgb_pred + rf_pred) / 2
+        if not tile_type:
+            return jsonify({"error": "Please select a tile type (e.g., Floor or Wall)."}), 400
+        if area <= 0:
+            return jsonify({"error": "Area must be a positive number."}), 400
+        if tile_size not in tile_sizes:
+            return jsonify({"error": f"Invalid tile size '{tile_size}'. Please select a valid size."}), 400
+
+        # Fetch tile size info
+        info = tile_sizes[tile_size]
+        per_tile_area = info["area_sqft"]
+        if per_tile_area <= 0:
+            return jsonify({"error": f"Tile size '{tile_size}' has invalid area data."}), 400
+
+        tiles_needed = math.ceil((area / per_tile_area) * 1.1)
+        boxes = math.ceil(tiles_needed / info.get("tiles_per_box", 10))
 
-        recommended_products = filter_products(tile_type, price_range, preferred_sizes)
+        matches = [p for p in tile_catalog if p["type"].lower() == tile_type and p["size"] == tile_size]
 
         return jsonify({
-            "recommendation_score": round(float(score), 3),
-            "recommended_products": recommended_products[:4],
-            "total_matches": len(recommended_products)
+            "tiles_needed": tiles_needed,
+            "boxes_needed": boxes,
+            "matching_products": matches[:3],
+            "total_matches": len(matches)
         })
     except Exception as e:
-        print(f"❌ Error in /recommend: {e}")
-        return jsonify({"error": "Server error"}), 500
+        print("❌ Error in /calculate:", str(e))
+        return jsonify({"error": "Please ensure valid tile type, size, and area are provided."}), 500
 
 def prepare_features(tile_type, coverage, area, price_range):
     tile_type_num = 0 if tile_type == "floor" else 1
     min_price, max_price = price_range
-    price_per_sqft = max_price / coverage if coverage else 0
-    efficiency = coverage / max_price if max_price else 0
+    price_per_sqft = max_price / coverage
+    efficiency = coverage / max_price
     return np.array([[tile_type_num, area, coverage, min_price, max_price, price_per_sqft, efficiency]])
 
 def filter_products(tile_type, price_range, preferred_sizes):
@@ -110,7 +113,7 @@ def filter_products(tile_type, price_range, preferred_sizes):
             continue
 
         price_score = 1 - (product["price"] - min_price) / (max_price - min_price + 1e-6)
-        size_score = 1 if not preferred_sizes else (1 if product["size"] in preferred_sizes else 0.5)
+        size_score = 1 if product["size"] in preferred_sizes else 0.5
         score = round((price_score + size_score) / 2, 2)
         filtered.append({**product, "recommendation_score": score})
     return sorted(filtered, key=lambda x: x["recommendation_score"], reverse=True)