Update app.py

app.py

@@ -8,8 +8,7 @@ import os
 import xgboost as xgb
 import logging
 
-# === Flask Setup ===
-app = Flask(__name__, static_folder='.', static_url_path='')
+app = Flask(__name__, static_folder=".", static_url_path="")
 CORS(app)
 logging.basicConfig(level=logging.INFO)
 
@@ -30,96 +29,37 @@ with open("tile_catalog.json", "r", encoding="utf-8") as f:
 with open("tile_sizes.json", "r", encoding="utf-8") as f:
     tile_sizes = json.load(f)
 
-# === Serve index.html ===
+# === Serve Frontend ===
 @app.route('/')
 def serve_index():
-    return app.send_static_file('index.html')
+    return send_from_directory('.', 'index.html')
 
-# === Serve static assets (if any JS, CSS, images) ===
 @app.route('/<path:path>')
-def serve_static_files(path):
+def serve_static(path):
     return send_from_directory('.', path)
 
-# === Calculate tiles endpoint ===
-@app.route('/calculate', methods=['POST'])
-def calculate():
+# === Recommend Endpoint ===
+@app.route('/recommend', methods=['POST'])
+def recommend():
     try:
         data = request.get_json()
-        for field in ['tile_type', 'length', 'width', 'tile_size']:
-            if field not in data:
-                return jsonify({"error": f"Missing field: {field}"}), 400
+        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()
-        length = float(data['length'])
-        width = float(data['width'])
-        validate_positive_number(length, "length")
-        validate_positive_number(width, "width")
-
         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
-
-        area = length * width
-        tile_info = tile_sizes[data['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)
-
-        matching_products = [
-            {
-                **p,
-                "link": p.get("url", "#")
-            }
-            for p in tile_catalog
-            if p['type'].lower() == tile_type and p['size'] == data['tile_size']
-        ]
-
-        return jsonify({
-            "tile_type": tile_type,
-            "tile_size": data['tile_size'],
-            "length": round(length, 2),
-            "width": round(width, 2),
-            "area": round(area, 2),
-            "tiles_needed": tiles_needed,
-            "boxes_needed": boxes_needed,
-            "matching_products": matching_products[:5],
-            "total_matches": len(matching_products)
-        })
 
-    except Exception as e:
-        app.logger.error(f"Error in /calculate: {str(e)}")
-        return jsonify({"error": "Internal server error"}), 500
-
-# === Recommend endpoint ===
-@app.route('/recommend', methods=['POST'])
-def recommend():
-    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
+        validate_positive_number(data['coverage'], "coverage")
+        validate_positive_number(data['area'], "area")
 
-        tile_type = data['tile_type'].lower()
-        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:
+        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,
-            "area": area
-        })
-
+        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
@@ -132,25 +72,76 @@ def recommend():
             min_score=0.5
         )
 
-        return jsonify({
+        response = {
             "recommendation_score": round(float(combined_score), 3),
+            "total_matches": len(recommended_products),
             "recommended_products": recommended_products[:5],
-            "calculation": calculate_requirements(area, coverage)
-        })
+            "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
 
-# === Helper Functions ===
+# === Calculate Endpoint ===
+@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['tile_type'].lower()
+        if tile_type not in ['floor', 'wall']:
+            return jsonify({"error": "Invalid tile type"}), 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)
+
+        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']}"
+        ]
+
+        return jsonify({
+            "tile_type": tile_type,
+            "area": data['area'],
+            "tile_length": data['tile_length'],
+            "tile_width": data['tile_width'],
+            "tiles_needed": tiles_needed,
+            "boxes_needed": boxes_needed,
+            "matching_products": matching_products[:3],
+            "total_matches": len(matching_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]])
+    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 = []
@@ -166,8 +157,7 @@ def filter_products(tile_type, min_price, max_price, preferred_sizes, min_score=
             if product_score >= min_score:
                 filtered.append({
                     **product,
-                    "recommendation_score": round(product_score, 2),
-                    "link": product.get("url", "#")
+                    "recommendation_score": round(product_score, 2)
                 })
 
     return sorted(filtered, key=lambda x: x['recommendation_score'], reverse=True)
@@ -188,6 +178,6 @@ def validate_positive_number(value, field):
     if not isinstance(value, (int, float)) or value <= 0:
         raise ValueError(f"{field} must be a positive number")
 
-# === Start the server ===
+# === Run App ===
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860, debug=False)