Update app.py

app.py

@@ -2,15 +2,13 @@ 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 xgboost as xgb
-import re
+import math
 
 app = Flask(__name__, static_folder='.', static_url_path='/')
 CORS(app)
 
-# Load ML models
+# Load models
 try:
     rf = joblib.load("rf_model.pkl")
     xgb_model = xgb.Booster()
@@ -20,7 +18,7 @@ except Exception as e:
     print(f"❌ Error loading models: {e}")
     raise e
 
-# Tile product catalog (hardcoded, replacing tile_catalog.json)
+# Hardcoded product catalog
 tile_catalog = [
     {"name": "Travertino Light Beige", "type": "Floor", "price": 780, "coverage": 15.5, "size": "1200x1200 MM", "url": "https://arqonz.ae/products/6775"},
     {"name": "Marquina Glossy Black", "type": "Wall", "price": 620, "coverage": 12.0, "size": "600x600 MM", "url": "https://arqonz.ae/products/6776"},
@@ -36,7 +34,6 @@ tile_catalog = [
     {"name": "Classic White Glossy", "type": "Wall", "price": 580, "coverage": 12.0, "size": "600x600 MM", "url": "https://arqonz.ae/products/89"},
     {"name": "Dark Stone Matte", "type": "Floor", "price": 830, "coverage": 15.0, "size": "1200x600 MM", "url": "https://arqonz.ae/products/107"},
     {"name": "Polished Statuario", "type": "Wall", "price": 810, "coverage": 10.5, "size": "600x1200 MM", "url": "https://arqonz.ae/products/116"}
-    # NOTE: Truncated for brevity — continue adding your full product list here
 ]
 
 @app.route("/")
@@ -50,70 +47,27 @@ def recommend():
         tile_type = data.get("tile_type", "").strip().lower()
         coverage = float(data.get("coverage", 1))
         area = float(data.get("area", 1))
-        price_range = data.get("price_range", [1, 10000])
+        price_range = data.get("price_range", [3, 10000])
         preferred_sizes = data.get("preferred_sizes", [])
 
         if area <= 0 or coverage <= 0:
-            return jsonify({"error": "Please enter valid area and coverage values."}), 400
+            return jsonify({"error": "Invalid area or coverage"}), 400
 
         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({
-            "recommendation_score": round(float(score), 3),
-            "recommended_products": products[:4],
-            "total_matches": len(products),
-        })
-    except Exception as e:
-        print("❌ Error in /recommend:", str(e))
-        return jsonify({"error": "Server error"}), 500
-
-@app.route("/calculate", methods=["POST"])
-def calculate():
-    try:
-        data = request.get_json()
-        tile_type = data.get("tile_type", "").strip().lower()
-        area = float(data.get("area", 0))
-        tile_size_raw = data.get("tile_size", "").strip()
-
-        if not tile_type:
-            return jsonify({"error": "Please select a tile type (e.g., floor, wall)."}), 400
-        if area <= 0:
-            return jsonify({"error": "Area must be greater than 0."}), 400
-
-        match = re.match(r"(\d+(\.\d+)?)\s*(ft|feet)?\s*[xX×*]\s*(\d+(\.\d+)?)\s*(ft|feet)?", tile_size_raw)
-        if not match:
-            return jsonify({"error": f"Invalid tile size format: '{tile_size_raw}'. Please enter like '2 x 2 ft'."}), 400
-
-        length_ft = float(match.group(1))
-        width_ft = float(match.group(4))
-        if length_ft <= 0 or width_ft <= 0:
-            return jsonify({"error": "Tile dimensions must be greater than 0."}), 400
-
-        tile_area = length_ft * width_ft
-        tiles_needed = math.ceil((area / tile_area) * 1.1)
-        boxes = math.ceil(tiles_needed / 10)
-
-        matches = [
-            p for p in tile_catalog
-            if p["type"].lower() == tile_type
-        ]
+        matches = filter_products(tile_type, price_range, preferred_sizes)
 
         return jsonify({
-            "tile_type": tile_type,
-            "area_sqft": area,
-            "tile_size": f"{length_ft:.2f} ft x {width_ft:.2f} ft",
-            "tiles_needed": tiles_needed,
-            "boxes_needed": boxes,
-            "matching_products": matches[:3],
+            "recommendation_score": round(float(score), 3),
+            "recommended_products": matches[:4],
             "total_matches": len(matches)
         })
     except Exception as e:
-        print("❌ Error in /calculate:", str(e))
-        return jsonify({"error": "An error occurred. Please check your input values."}), 500
+        print("❌ /recommend error:", e)
+        return jsonify({"error": "Server error"}), 500
 
 def prepare_features(tile_type, coverage, area, price_range):
     tile_type_num = 0 if tile_type == "floor" else 1
@@ -125,18 +79,31 @@ def prepare_features(tile_type, coverage, area, price_range):
 def filter_products(tile_type, price_range, preferred_sizes):
     min_price, max_price = price_range
     filtered = []
-    for product in tile_catalog:
-        if product["type"].lower() != tile_type:
+    for p in tile_catalog:
+        if p["type"].lower() != tile_type:
             continue
-        if not (min_price <= product["price"] <= max_price):
+        if not (min_price <= p["price"] <= max_price):
             continue
-        if preferred_sizes and product["size"] not in preferred_sizes:
+
+        size_match = False
+        for size in preferred_sizes:
+            if similar_size(p["size"], size):
+                size_match = True
+                break
+        if not size_match:
             continue
-        price_score = 1 - (product["price"] - min_price) / (max_price - min_price + 1e-6)
-        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})
+
+        price_score = 1 - (p["price"] - min_price) / (max_price - min_price + 1e-6)
+        filtered.append({**p, "recommendation_score": round(price_score, 2)})
     return sorted(filtered, key=lambda x: x["recommendation_score"], reverse=True)
 
+def similar_size(size_a, size_b, tolerance=10):
+    try:
+        w1, h1 = map(int, size_a.lower().replace("mm", "").split("x"))
+        w2, h2 = map(int, size_b.lower().replace("mm", "").split("x"))
+        return abs(w1 - w2) <= tolerance and abs(h1 - h2) <= tolerance
+    except:
+        return False
+
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860)