Update app.py

app.py

@@ -4,108 +4,178 @@ import joblib
 import numpy as np
 import json
 import math
-import xgboost as xgb
 import os
+import xgboost as xgb
+import logging
 
-app = Flask(__name__, static_folder='.', static_url_path='/')
+app = Flask(__name__, static_folder=".", static_url_path="")
 CORS(app)
 
-# Load ML models
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+
+# Load models
 try:
     rf = joblib.load("rf_model.pkl")
     xgb_model = xgb.Booster()
     xgb_model.load_model("xgb_model.json")
-    print("✅ Models loaded successfully.")
+    app.logger.info("✅ Models loaded successfully.")
 except Exception as e:
-    print(f"❌ Error loading models: {e}")
+    app.logger.error(f"❌ Error loading models: {e}")
     raise e
 
 # 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 = json.load(f)
 
-@app.route("/")
-def index():
-    return send_from_directory(".", "index.html")
+# Serve the frontend
+@app.route('/')
+def serve_index():
+    return send_from_directory('.', 'index.html')
 
-@app.route("/recommend", methods=["POST"])
+# Product recommendation endpoint
+@app.route('/recommend', methods=['POST'])
 def recommend():
     try:
         data = request.get_json()
-        tile_type = data.get("tile_type", "").lower()
-        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", [])
+        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"}), 400
+
+        validate_positive_number(data['coverage'], "coverage")
+        validate_positive_number(data['area'], "area")
 
-        features = prepare_features(tile_type, coverage, area, price_range)
+        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]
-        score = (xgb_pred + rf_pred) / 2
+        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)
 
-        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.logger.error(f"Error in /recommend: {str(e)}")
+        return jsonify({"error": "Internal server error"}), 500
 
-@app.route("/calculate", methods=["POST"])
+# Tile calculation endpoint
+@app.route('/calculate', methods=['POST'])
 def calculate():
     try:
         data = request.get_json()
-        tile_type = data.get("tile_type", "").lower()
-        area = float(data.get("area", 0))
-        tile_size = data.get("tile_size", "")
+        if 'tile_type' not in data or 'area' not in data or 'tile_size' not in data:
+            return jsonify({"error": "Missing required fields"}), 400
 
-        if tile_size not in tile_sizes:
+        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
 
-        info = tile_sizes[tile_size]
-        per_tile_area = info["length"] * info["width"]
-        tiles_needed = math.ceil((area / per_tile_area) * 1.1)
-        boxes = math.ceil(tiles_needed / info.get("tiles_per_box", 10))
+        validate_positive_number(data['area'], "area")
+
+        tile_info = tile_sizes[data['tile_size']]
+        area_per_tile = tile_info['length'] * tile_info['width']
+        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)
 
-        matches = [p for p in tile_catalog if p["type"].lower() == tile_type and p["size"] == tile_size]
+        matching_products = [
+            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": tiles_needed,
-            "boxes_needed": boxes,
-            "matching_products": matches[:3],
-            "total_matches": len(matches)
+            "boxes_needed": boxes_needed,
+            "matching_products": matching_products[:3],
+            "total_matches": len(matching_products)
         })
+
     except Exception as e:
-        print("❌ Error in /calculate:", str(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
-    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):
-    min_price, max_price = price_range
+        app.logger.error(f"Error in /calculate: {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:
-            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 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)
+        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)