app.py

import gradio as gr
import pandas as pd
import numpy as np
import joblib
import os
from datetime import datetime
import plotly.graph_objects as go
import warnings
warnings.filterwarnings('ignore')

# Try to import the PropertyValuePredictor class
try:
    from train_model import PropertyValuePredictor
    print("✅ Successfully imported PropertyValuePredictor from train_model")
except ImportError as e:
    print(f"❌ Import error: {e}")
    # Fallback: create a simple predictor class
    class PropertyValuePredictor:
        def __init__(self):
            self.model = None
            self.scaler = None
            self.feature_columns = None
            self.label_encoders = {}
            
        def load_model(self, model_path):
            try:
                if os.path.exists(model_path):
                    model_data = joblib.load(model_path)
                    self.model = model_data['model']
                    self.scaler = model_data['scaler']
                    self.feature_columns = model_data['feature_columns']
                    self.label_encoders = model_data.get('label_encoders', {})
                    print(f"✅ Model loaded from {model_path}")
                    return True
                else:
                    print(f"❌ Model file {model_path} not found")
                    return False
            except Exception as e:
                print(f"❌ Error loading model: {e}")
                return False
        
        def predict_future_value(self, property_data):
            if self.model is None:
                return {"error": "Model not loaded"}
            
            try:
                # Convert to DataFrame
                if isinstance(property_data, dict):
                    df = pd.DataFrame([property_data])
                else:
                    df = property_data.copy()
                
                # Feature engineering
                df['property_age'] = 2025 - df['year_built']
                df['price_per_sqft'] = df['current_value'] / df['square_feet']
                df['value_per_bedroom'] = df['current_value'] / df['bedrooms'].replace(0, 1)
                
                # Encode categorical features
                for col, encoder in self.label_encoders.items():
                    if col.replace('_encoded', '') in df.columns:
                        original_col = col.replace('_encoded', '')
                        try:
                            df[col] = encoder.transform(df[original_col].astype(str))
                        except:
                            df[col] = 0
                
                # Select features
                if self.feature_columns:
                    # Ensure all features exist
                    for col in self.feature_columns:
                        if col not in df.columns:
                            df[col] = 0
                    
                    X = df[self.feature_columns]
                else:
                    # Use available numeric columns
                    numeric_cols = df.select_dtypes(include=[np.number]).columns
                    X = df[numeric_cols]
                
                # Scale features
                if self.scaler:
                    X_scaled = self.scaler.transform(X)
                else:
                    X_scaled = X.values
                
                # Predict
                predicted_value = self.model.predict(X_scaled)[0]
                
                # Calculate metrics
                current_value = df['current_value'].iloc[0]
                appreciation = predicted_value - current_value
                appreciation_pct = (appreciation / current_value) * 100
                
                return {
                    'current_value': current_value,
                    'predicted_future_value': predicted_value,
                    'predicted_appreciation': appreciation,
                    'appreciation_percentage': appreciation_pct,
                    'annual_appreciation_rate': appreciation_pct / 5                }
                
            except Exception as e:
                return {"error": f"Prediction error: {str(e)}"}

class PropertyPredictionApp:
    def __init__(self):
        self.predictor = PropertyValuePredictor()
        self.model_loaded = False
        self.load_model()
        
        # State mappings
        self.states = [
            'AL', 'AK', 'AZ', 'AR', 'CA', 'CO', 'CT', 'DE', 'FL', 'GA',
            'HI', 'ID', 'IL', 'IN', 'IA', 'KS', 'KY', 'LA', 'ME', 'MD',
            'MA', 'MI', 'MN', 'MS', 'MO', 'MT', 'NE', 'NV', 'NH', 'NJ',
            'NM', 'NY', 'NC', 'ND', 'OH', 'OK', 'OR', 'PA', 'RI', 'SC',
            'SD', 'TN', 'TX', 'UT', 'VT', 'VA', 'WA', 'WV', 'WI', 'WY', 'DC'
        ]
        
        self.property_types = [
            'Single Family Home', 'Townhouse', 'Condo', 'Multi-Family', 
            'Duplex', 'Ranch', 'Colonial', 'Victorian', 'Modern', 'Split Level'        ]
        
        self.school_ratings = [
            'Excellent', 'Very Good', 'Good', 'Average', 'Below Average'
        ]
    
    def load_model(self):
        """Load the trained model with fallback options"""
        model_files = [
            'simple_property_model.joblib',
            'enhanced_property_model.joblib',
            'property_value_model.joblib'
        ]
        
        for model_file in model_files:
            if os.path.exists(model_file):
                try:
                    success = self.predictor.load_model(model_file)
                    if success:
                        self.model_loaded = True
                        print(f"✅ Successfully loaded model from {model_file}")
                        return
                except Exception as e:
                    print(f"❌ Failed to load {model_file}: {e}")
                    continue
        
        print("❌ No model file found. Using demo mode.")
        self.model_loaded = False
    
    def predict_property_value(self, current_value, year_built, state, property_type,
                             bedrooms, bathrooms, square_feet, lot_size, 
                             school_district_rating, monthly_rent, property_tax, 
                             hoa_monthly):
        """Predict future property value"""
        
        if not self.model_loaded:
            # Demo mode - simple calculation
            base_appreciation = 0.05  # 5% annual
            years = 5
            demo_value = current_value * (1 + base_appreciation) ** years
            
            prediction_text = (
                f"🚨 **Demo Mode** (No model loaded)\n\n"
                f"**Current Property Value:** ${current_value:,.2f}\n\n"
                f"**Estimated 5-Year Value:** ${demo_value:,.2f}\n\n"
                f"**Estimated Appreciation:** ${demo_value - current_value:,.2f} ({((demo_value - current_value) / current_value) * 100:.1f}%)\n\n"
                f"**Annual Appreciation Rate:** {((demo_value / current_value) ** (1/5) - 1) * 100:.1f}%\n\n"
                f"*Note: This is a demo calculation using 5% annual appreciation. Train and upload a model for accurate predictions.*"
            )
            
            chart = self.create_prediction_chart(current_value, None)
            return prediction_text, chart
        
        try:
            # Prepare property data
            property_data = {
                'current_value': current_value,
                'year_built': year_built,
                'state': state,
                'property_type': property_type,
                'bedrooms': bedrooms,
                'bathrooms': bathrooms,
                'square_feet': square_feet,
                'lot_size': lot_size,
                'school_district_rating': school_district_rating,
                'monthly_rent_estimate': monthly_rent,
                'property_tax_annual': property_tax,
                'hoa_monthly': hoa_monthly
            }
            
            # Get prediction
            result = self.predictor.predict_future_value(property_data)
            
            if "error" in result:
                error_text = f"❌ **Error:** {result['error']}"
                chart = self.create_prediction_chart(current_value, None)
                return error_text, chart
            
            # Format results
            current_val = result['current_value']
            future_val = result['predicted_future_value']
            appreciation = result['predicted_appreciation']
            appreciation_pct = result['appreciation_percentage']
            annual_rate = result['annual_appreciation_rate']
            
            prediction_text = (
                f"## 🏠 Property Value Prediction Results\n\n"
                f"**Current Property Value:** ${current_val:,.2f}\n\n"
                f"**Predicted 5-Year Value:** ${future_val:,.2f}\n\n"
                f"**Total Appreciation:** ${appreciation:,.2f}\n\n"
                f"**Appreciation Percentage:** {appreciation_pct:.2f}%\n\n"
                f"**Annual Appreciation Rate:** {annual_rate:.2f}%\n\n"
                f"---\n\n"
                f"📊 **Investment Analysis:**\n"
                f"- Monthly appreciation: ${appreciation/60:,.2f}\n"
                f"- ROI over 5 years: {appreciation_pct:.1f}%\n"
                f"- Estimated monthly rent: ${monthly_rent:,.2f}\n"
                f"- Property tax burden: {(property_tax/current_val)*100:.2f}% of value"            )
            
            # Create chart with actual prediction
            chart = self.create_prediction_chart(current_val, future_val)
            
            return prediction_text, chart
            
        except Exception as e:
            error_text = f"❌ **Prediction Error:** {str(e)}"
            chart = self.create_prediction_chart(current_value, None)
            return error_text, chart
    
    def create_prediction_chart(self, current_value, predicted_value=None):
        """Create a chart showing actual prediction results"""
        years = list(range(0, 6))
        
        if predicted_value is None or not self.model_loaded:
            # Demo mode - use 5% annual appreciation
            values = [current_value * (1.05 ** year) for year in years]
            title = "Demo: Property Value Growth (5% Annual)"
            line_color = '#FFA500'  # Orange for demo
        else:
            # Use actual prediction - interpolate between current and predicted
            annual_rate = (predicted_value / current_value) ** (1/5) - 1
            total_appreciation = ((predicted_value - current_value) / current_value) * 100
            values = [current_value * (1 + annual_rate) ** year for year in years]
            title = f"AI Prediction: {total_appreciation:.1f}% Total Growth ({annual_rate*100:.1f}% Annual)"
            line_color = '#2E86AB'  # Blue for real predictions
        
        fig = go.Figure()
        fig.add_trace(go.Scatter(
            x=years,
            y=values,
            mode='lines+markers',
            name='Property Value',
            line=dict(color=line_color, width=3),
            marker=dict(size=8)
        ))
        
        # Add annotations for key points
        fig.add_annotation(
            x=0, y=values[0],
            text=f"Current: ${values[0]:,.0f}",
            showarrow=True,
            arrowhead=2,
            bgcolor="white",
            bordercolor=line_color
        )
        fig.add_annotation(
            x=5, y=values[5],
            text=f"5-Year: ${values[5]:,.0f}",
            showarrow=True,
            arrowhead=2,
            bgcolor="white",
            bordercolor=line_color
        )
        
        # Add total appreciation annotation for ML predictions
        if predicted_value is not None and self.model_loaded:
            total_appreciation = ((predicted_value - current_value) / current_value) * 100
            fig.add_annotation(
                x=2.5, y=values[2] + (values[5] - values[2]) * 0.3,
                text=f"Total Growth: +{total_appreciation:.1f}%",
                showarrow=False,
                bgcolor="rgba(46, 134, 171, 0.8)",
                bordercolor=line_color,
                font=dict(color="white", size=14, family="Arial Black")
            )
        
        fig.update_layout(
            title=title,
            xaxis_title="Years from Now",
            yaxis_title="Property Value ($)",
            template="plotly_white",
            height=400,
            yaxis=dict(tickformat='$,.0f')
        )
        
        return fig
    
    def create_interface(self):
        """Create the Gradio interface"""
        
        with gr.Blocks(title="🏠 Property Value Predictor", theme=gr.themes.Soft()) as interface:
            gr.Markdown("""
            # 🏠 AI Property Value Predictor
            
            Predict your property's value 5 years from now using advanced machine learning!
            
            **How it works:**
            1. Enter your property details below
            2. Click "Predict Future Value" 
            3. Get instant AI-powered predictions with detailed analysis
            """)
            
            with gr.Row():
                with gr.Column(scale=1):
                    gr.Markdown("### 📊 Property Details")
                    
                    current_value = gr.Number(
                        label="Current Property Value ($)",
                        value=500000,
                        minimum=50000,
                        maximum=10000000,
                        step=10000
                    )
                    
                    year_built = gr.Number(
                        label="Year Built",
                        value=2010,
                        minimum=1800,
                        maximum=2025,
                        step=1
                    )
                    
                    state = gr.Dropdown(
                        choices=self.states,
                        label="State",
                        value="CA"
                    )
                    
                    property_type = gr.Dropdown(
                        choices=self.property_types,
                        label="Property Type",
                        value="Single Family Home"
                    )
                    
                with gr.Column(scale=1):
                    gr.Markdown("### 🏡 Property Features")
                    
                    bedrooms = gr.Number(
                        label="Bedrooms",
                        value=3,
                        minimum=1,
                        maximum=10,
                        step=1
                    )
                    
                    bathrooms = gr.Number(
                        label="Bathrooms",
                        value=2.5,
                        minimum=1,
                        maximum=10,
                        step=0.5
                    )
                    
                    square_feet = gr.Number(
                        label="Square Feet",
                        value=2000,
                        minimum=300,
                        maximum=20000,
                        step=100
                    )
                    
                    lot_size = gr.Number(
                        label="Lot Size (acres)",
                        value=0.25,
                        minimum=0.01,
                        maximum=5.0,
                        step=0.01
                    )
                
                with gr.Column(scale=1):
                    gr.Markdown("### 💰 Financial Details")
                    
                    school_rating = gr.Dropdown(
                        choices=self.school_ratings,
                        label="School District Rating",
                        value="Good"
                    )
                    
                    monthly_rent = gr.Number(
                        label="Estimated Monthly Rent ($)",
                        value=2500,
                        minimum=500,
                        maximum=20000,
                        step=100
                    )
                    
                    property_tax = gr.Number(
                        label="Annual Property Tax ($)",
                        value=6000,
                        minimum=500,
                        maximum=100000,
                        step=500
                    )
                    
                    hoa_monthly = gr.Number(
                        label="Monthly HOA Fee ($)",
                        value=0,
                        minimum=0,
                        maximum=2000,
                        step=50
                    )
            
            with gr.Row():
                predict_btn = gr.Button(
                    "🔮 Predict Future Value", 
                    variant="primary",
                    size="lg"
                )
            
            with gr.Row():
                with gr.Column(scale=2):                    prediction_output = gr.Markdown(
                        label="Prediction Results",
                        value="Enter property details and click 'Predict Future Value' to see AI predictions!"
                    )
                
                with gr.Column(scale=1):
                    chart_output = gr.Plot(label="Value Projection Chart")
            
            # Event handlers
            predict_btn.click(
                fn=self.predict_property_value,
                inputs=[
                    current_value, year_built, state, property_type,
                    bedrooms, bathrooms, square_feet, lot_size,
                    school_rating, monthly_rent, property_tax, hoa_monthly
                ],
                outputs=[prediction_output, chart_output]
            )
            
            # Update chart when current value changes (demo mode only)
            current_value.change(
                fn=lambda val: self.create_prediction_chart(val, None),
                inputs=current_value,
                outputs=chart_output
            )
            
            # Set initial chart
            interface.load(
                fn=lambda: self.create_prediction_chart(500000, None),
                outputs=chart_output
            )
            
            gr.Markdown("""
            ---
            ### 📝 About This Tool
            
            This AI-powered property value predictor uses machine learning to analyze:
            - **Property characteristics** (age, size, type, location)
            - **Market factors** (school ratings, comparable sales)
            - **Financial metrics** (rent potential, taxes, HOA fees)
            - **Historical trends** and regional market patterns
            
            **Disclaimer:** Predictions are estimates based on historical data and should not be considered as professional real estate advice.
            """)
        
        return interface

def main():
    """Main function to create and launch the app"""
    print("🚀 Starting Property Value Predictor App...")
    
    app = PropertyPredictionApp()
    interface = app.create_interface()
    
    # Launch the interface
    interface.launch(
        share=True,
        server_name="0.0.0.0",
        server_port=7860,
        show_error=True
    )

if __name__ == "__main__":
    main()