Update app.py

app.py

@@ -1,12 +1,10 @@
-import gradio as gr
+from flask import Flask, request, jsonify
 import joblib
+import numpy as np
 import json
 import math
-import re
-from deep_translator import GoogleTranslator
-import warnings
 
-warnings.filterwarnings("ignore")
+app = Flask(_name_)
 
 # Load models
 xgb = joblib.load("xgb_model.pkl")
@@ -19,133 +17,158 @@ 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)
 
-def translate(text, lang="en"):
+@app.route('/recommend', methods=['POST'])
+def recommend():
+    """
+    Endpoint for product recommendations
+    Expected JSON payload:
+    {
+        "tile_type": "floor"|"wall",
+        "coverage": float,
+        "area": float,
+        "price_range": [min, max],
+        "preferred_sizes": [size1, size2] (optional)
+    }
+    """
     try:
-        return GoogleTranslator(source="auto", target=lang).translate(text)
+        data = request.get_json()
+        
+        # Validate input
+        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. Use 'floor' or 'wall'"}), 400
+        
+        # Feature engineering for ML prediction
+        features = prepare_features(data)
+        
+        # Get predictions from both models
+        xgb_pred = xgb.predict_proba(features)[0][1]
+        rf_pred = rf.predict_proba(features)[0][1]
+        combined_score = (xgb_pred + rf_pred) / 2
+        
+        # Filter products based on criteria
+        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  # Threshold for recommendation
+        )
+        
+        # Prepare response
+        response = {
+            "recommendation_score": round(float(combined_score), 3),
+            "recommended_products": recommended_products[:5],  # Return top 5
+            "calculation": calculate_requirements(data['area'], data['coverage'])
+        }
+        
+        return jsonify(response)
+    
     except Exception as e:
-        print(f"Translation error: {e}")
-        return text
-
-def extract_tile_area(msg):
-    msg = msg.lower().replace("×", "x").replace("into", "x").replace("*", "x")
-    msg = msg.replace("ft", "").replace("feet", "").replace("mm", "").strip()
-
-    if "x" in msg:
-        parts = msg.split("x")
-        if len(parts) == 2:
-            try:
-                val1 = float(re.sub(r"[^\d.]", "", parts[0]))
-                val2 = float(re.sub(r"[^\d.]", "", parts[1]))
-                if val1 > 20:  # Assuming mm
-                    sqft = (val1 * val2) / 92903.04  # Convert mm² to ft²
-                else:
-                    sqft = val1 * val2  # ft²
-                return round(sqft, 2)
-            except ValueError:
-                return None
-    elif re.match(r'^\d+(\.\d+)?$', msg):
-        try:
-            val = float(msg)
-            if val > 20:  # Assuming mm
-                return round((val * val) / 92903.04, 2)
-            else:
-                return round(val * val, 2)
-        except ValueError:
-            return None
-    return None
-
-def chat_fn(message, history, user_state={}):
-    msg = message.strip().lower()
-
-    # Reset flow on keywords
-    if msg in ["restart", "reset", "start", "floor", "wall"]:
-        user_state.clear()
-
-    if "lang" not in user_state:
-        try:
-            user_state["lang"] = GoogleTranslator(source="auto", target="en").detect(message)
-        except Exception as e:
-            print(f"Language detection error: {e}")
-            user_state["lang"] = "en"
-    lang = user_state["lang"]
-    def reply(text): return translate(text, lang)
-
-    # Step 1: Detect tile type
-    if "step" not in user_state:
-        if msg in ["floor", "wall"]:
-            user_state["tile_type"] = message.capitalize()
-            user_state["step"] = "get_area"
-            return reply(f"✅ You selected {user_state['tile_type']} tiles. What's the total area in sq.ft?"), None, user_state
-        else:
-            return reply("👋 Welcome! Are you planning for Floor or Wall tiles? Type 'Floor' or 'Wall' to begin."), None, user_state
-
-    # Step 2: Get area
-    if user_state["step"] == "get_area":
-        try:
-            user_state["area"] = float(message)
-            user_state["step"] = "get_tile_size"
-            return reply("📏 Now enter the tile size (e.g. 2x2, 600x600 mm, 200 * 200):"), None, user_state
-        except ValueError:
-            return reply("❗ Please enter a valid number for the area (e.g. 120)."), None, user_state
-
-    # Step 3: Get tile size
-    if user_state["step"] == "get_tile_size":
-        area = extract_tile_area(message)
-        if area is None:
-            return reply("❗ I couldn't understand that tile size. Try: 2 x 2, 600x600 mm, 200*200."), None, user_state
-
-        user_state["tile_area"] = area
-        user_state["step"] = "done"
-
-        total_area = user_state["area"]
-        tile_type = user_state["tile_type"]
-        tile_needed = math.ceil((total_area / area) * 1.1)
-
-        # Recommendations
-        recommendations = []
-        for tile in tile_catalog:
-            if tile["type"].lower() == tile_type.lower():
-                per_box = tile["coverage"] / area
-                if per_box > 0:
-                    boxes = math.ceil(tile_needed / per_box)
-                    total_price = boxes * tile["price"]
-                    recommendations.append({
-                        "name": tile["name"],
-                        "size": tile["size"],
-                        "price": tile["price"],
-                        "boxes": boxes,
-                        "total": total_price,
-                        "url": tile["url"]
-                    })
-
-        recommendations.sort(key=lambda x: x["total"])
-        top3 = recommendations[:3]
-
-        result = f"""
-🧱 Tile Type: {tile_type}
-📐 Area to Cover: {total_area} sq.ft
-🧮 Tile Size Area: {round(area, 2)} sq.ft
-🔢 Tiles Needed (with buffer): {tile_needed}
-
-🎯 Top Product Suggestions:
-"""
-        for i, t in enumerate(top3, 1):
-            result += f"{i}. {t['name']} ({t['size']}) - ₹{t['price']}/box\n   ~{t['boxes']} boxes → ₹{int(t['total'])}\n   🔗 {t['url']}\n\n"
-
-        result += "You can type 'Floor' or 'Wall' to estimate again."
-        return reply(result), None, {}
-
-    return reply("Say 'Floor' or 'Wall' to begin."), None, {}
-
-# Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# 🧱 Tilo – Tile Estimator")
-    gr.Markdown("Type 'Floor' or 'Wall' to start. Then give your room size and tile size (e.g. 2x2 ft, 600x600 mm).")
-    gr.ChatInterface(
-        fn=chat_fn,
-        title="Tile Estimator Chat",
-        description="Get estimates for your tiling needs.",
-        type="messages"
-    )
-
-demo.launch()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/calculate', methods=['POST'])
+def calculate():
+    """
+    Endpoint for tile calculation
+    Expected JSON payload:
+    {
+        "tile_type": "floor"|"wall",
+        "area": float,
+        "tile_size": "12x12"|etc (from tile_sizes.json)
+    }
+    """
+    try:
+        data = request.get_json()
+        
+        # Validate input
+        if 'tile_type' not in data or 'area' not in data or 'tile_size' 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
+            
+        if data['tile_size'] not in tile_sizes:
+            return jsonify({"error": "Invalid tile size"}), 400
+            
+        # Perform calculation
+        tile_info = tile_sizes[data['tile_size']]
+        area_per_tile = tile_info['length'] * tile_info['width']
+        num_tiles = math.ceil((data['area'] / area_per_tile) * 1.1)  # 10% buffer
+        num_boxes = math.ceil(num_tiles / tile_info.get('tiles_per_box', 10))
+        
+        # Get matching products
+        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": num_tiles,
+            "boxes_needed": num_boxes,
+            "matching_products": matching_products[:3]  # Return top 3 matches
+        })
+        
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+def prepare_features(data):
+    """Prepare feature vector for ML model prediction"""
+    tile_type_num = 0 if data['tile_type'] == 'floor' else 1
+    price_per_sqft = data['price_range'][1] / data['coverage']  # Using max price
+    budget_efficiency = data['coverage'] / data['price_range'][1]
+    
+    return np.array([[
+        tile_type_num,
+        data['area'],
+        data['coverage'],
+        data['price_range'][0],  # min price
+        data['price_range'][1],  # max price
+        price_per_sqft,
+        budget_efficiency
+    ]])
+
+def filter_products(tile_type, min_price, max_price, preferred_sizes, min_score=0.5):
+    """Filter products based on criteria"""
+    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)):
+            
+            # Calculate a simple score (could be enhanced)
+            price_score = 1 - ((product['price'] - min_price) / (max_price - min_price))
+            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)
+                })
+    
+    # Sort by recommendation score
+    return sorted(filtered, key=lambda x: x['recommendation_score'], reverse=True)
+
+def calculate_requirements(area, coverage):
+    """Calculate basic requirements"""
+    return {
+        "minimum_tiles": math.ceil(area / coverage),
+        "suggested_tiles": math.ceil((area / coverage) * 1.1),  # 10% buffer
+        "estimated_cost_range": [
+            round(area * 3, 2),  # $3/sqft (example)
+            round(area * 10, 2)   # $10/sqft (example)
+        ]
+    }
+
+if _name_ == '_main_':
+    app.run(host='0.0.0.0', port=5000, debug=True)