app.py

from flask import Flask, request, jsonify
import joblib
import numpy as np
import json
import math

app = Flask(_name_)

# Load models
xgb = joblib.load("xgb_model.pkl")
rf = joblib.load("rf_model.pkl")

# Load tile catalog and sizes
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('/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:
        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:
        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)