Update app.py

app.py

@@ -4,180 +4,116 @@ import joblib
 import numpy as np
 import json
 import math
-import os
 import xgboost as xgb
-import logging
+import os
 
-app = Flask(__name__, static_folder=".", static_url_path="")
+app = Flask(__name__, static_folder='.', static_url_path='/')
 CORS(app)
-logging.basicConfig(level=logging.INFO)
 
-# === Load models ===
+# Load models
 try:
     rf = joblib.load("rf_model.pkl")
     xgb_model = xgb.Booster()
     xgb_model.load_model("xgb_model.json")
-    app.logger.info("✅ Models loaded successfully.")
+    print("✅ Models loaded successfully.")
 except Exception as e:
-    app.logger.error(f"❌ Error loading models: {e}")
+    print(f"❌ Error loading models: {e}")
     raise e
 
-# === Load data ===
+# Load tile catalog and tile size 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 = 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)
-
-# === Recommend Endpoint ===
-@app.route('/recommend', methods=['POST'])
-def recommend():
-    try:
-        data = request.get_json()
-        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_sizes_list = json.load(f)
+    tile_sizes = {item["label"]: item["area_sqft"] for item in tile_sizes_list}
 
-        tile_type = data['tile_type'].lower()
-        if tile_type not in ['floor', 'wall']:
-            return jsonify({"error": "Invalid tile type"}), 400
-
-        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)
-        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
-        )
-
-        response = {
-            "recommendation_score": round(float(combined_score), 3),
-            "total_matches": len(recommended_products),
-            "recommended_products": recommended_products[:5],
-            "calculation": calculate_requirements(data['area'], data['coverage'])
-        }
-        return jsonify(response)
-
-    except Exception as e:
-        app.logger.error(f"Error in /recommend: {str(e)}")
-        return jsonify({"error": "Internal server error"}), 500
+@app.route("/")
+def index():
+    return send_from_directory(".", "index.html")
 
-# === Calculate Endpoint ===
-@app.route('/calculate', methods=['POST'])
+@app.route("/calculate", methods=["POST"])
 def calculate():
     try:
         data = request.get_json()
-        if 'tile_type' not in data or 'area' not in data or 'tile_length' not in data or 'tile_width' not in data:
-            return jsonify({"error": "Missing required fields"}), 400
+        tile_type = data.get("tile_type", "").lower()
+        area = float(data.get("area", 0))
+        tile_size_label = data.get("tile_size", "")
 
-        tile_type = data['tile_type'].lower()
-        if tile_type not in ['floor', 'wall']:
-            return jsonify({"error": "Invalid tile type"}), 400
+        if tile_size_label not in tile_sizes:
+            return jsonify({"error": "Invalid tile size"}), 400
 
-        validate_positive_number(data['area'], "area")
-        validate_positive_number(data['tile_length'], "tile_length")
-        validate_positive_number(data['tile_width'], "tile_width")
-
-        # Calculate area per tile
-        area_per_tile = data['tile_length'] * data['tile_width']
-        tiles_needed = math.ceil((data['area'] / area_per_tile) * 1.1)  # 10% buffer
-        tiles_per_box = 10  # Assuming 10 tiles per box
-        boxes_needed = math.ceil(tiles_needed / tiles_per_box)
+        per_tile_area = tile_sizes[tile_size_label]
+        tiles_needed = math.ceil((area / per_tile_area) * 1.1)
+        boxes = math.ceil(tiles_needed / 10)
 
         matching_products = [
             p for p in tile_catalog
-            if p['type'].lower() == tile_type and p['size'] == f"{data['tile_length']}x{data['tile_width']}"
+            if p["type"].lower() == tile_type and p["size"] == tile_size_label
         ]
 
         return jsonify({
             "tile_type": tile_type,
-            "area": data['area'],
-            "tile_length": data['tile_length'],
-            "tile_width": data['tile_width'],
+            "area": area,
+            "tile_size": tile_size_label,
             "tiles_needed": tiles_needed,
-            "boxes_needed": boxes_needed,
+            "boxes_needed": boxes,
             "matching_products": matching_products[:3],
             "total_matches": len(matching_products)
         })
+    except Exception as e:
+        print(f"❌ Error in /calculate: {e}")
+        return jsonify({"error": "Server error"}), 500
+
+@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))
+        coverage = float(data.get("coverage", 1))
+        price_range = data.get("price_range", [1, 100000])
+        preferred_sizes = data.get("preferred_sizes", [])
 
+        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
+
+        recommended_products = filter_products(tile_type, price_range, preferred_sizes)
+
+        return jsonify({
+            "recommendation_score": round(float(score), 3),
+            "recommended_products": recommended_products[:4],
+            "total_matches": len(recommended_products)
+        })
     except Exception as e:
-        app.logger.error(f"Error in /calculate: {str(e)}")
-        return jsonify({"error": "Internal server error"}), 500
-
-# === Utils ===
-
-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):
+        print(f"❌ Error in /recommend: {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
+    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
+    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):
+    min_price, max_price = price_range
     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)):
-
-            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)
-                })
-
-    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")
-
-# === Run App ===
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, debug=False)
+        if product["type"].lower() != tile_type:
+            continue
+        if not (min_price <= product["price"] <= max_price):
+            continue
+        if preferred_sizes and product["size"] not in 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)
+        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)
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860)