Update app.py

app.py

@@ -1,7 +1,5 @@
-
 import os
 import json
-import math
 import requests
 import pandas as pd
 import gradio as gr
@@ -9,17 +7,15 @@ import gradio as gr
 APP_NAME = "StayWise AI"
 
 DATA_FILE = "synthetic_airbnb_project_data.csv"
-OUTPUT_FILE = "airbnb_recommendation_output.csv"
-
-# Optional: set this in Hugging Face Space Secrets as N8N_WEBHOOK_URL
 N8N_WEBHOOK_URL = os.getenv("N8N_WEBHOOK_URL", "").strip()
 
+
 def load_data():
-    data = pd.read_csv(DATA_FILE)
-    output = pd.read_csv(OUTPUT_FILE) if os.path.exists(OUTPUT_FILE) else data.copy()
-    return data, output
+    return pd.read_csv(DATA_FILE)
+
+
+df = load_data()
 
-df, output_df = load_data()
 
 def safe_mean(series, default=0):
     series = pd.to_numeric(series, errors="coerce").dropna()
@@ -27,79 +23,130 @@ def safe_mean(series, default=0):
         return default
     return float(series.mean())
 
+
 def get_choices(column):
-    if column in df.columns:
-        return sorted([str(x) for x in df[column].dropna().unique().tolist()])
-    return []
+    return sorted(df[column].dropna().astype(str).unique().tolist())
+
 
 neighbourhood_groups = get_choices("neighbourhood_group")
-room_types = get_choices("room_type")
 neighbourhoods = get_choices("neighbourhood")
-seasons = get_choices("season") if "season" in df.columns else ["Low Season", "Shoulder Season", "High Season"]
+room_types = get_choices("room_type")
+seasons = get_choices("season") if "season" in df.columns else ["Low Season", "Medium Season", "High Season"]
+
+
+def call_n8n(payload):
+    if not N8N_WEBHOOK_URL:
+        return {
+            "status": "not_configured",
+            "insight": "n8n webhook is not configured yet.",
+            "next_step": "Add N8N_WEBHOOK_URL in Hugging Face Space secrets.",
+            "log": "Pipeline ran locally only."
+        }
+
+    try:
+        response = requests.post(N8N_WEBHOOK_URL, json=payload, timeout=15)
 
-def estimate_pipeline(neighbourhood_group, neighbourhood, room_type, price, availability_365, season, local_event_score, synthetic_rating, customer_sentiment_score, send_to_n8n):
+        if response.status_code >= 200 and response.status_code < 300:
+            try:
+                data = response.json()
+                return {
+                    "status": data.get("status", "success"),
+                    "insight": data.get("insight", "n8n processed the recommendation."),
+                    "next_step": data.get("next_step", "Review the generated automation output."),
+                    "log": data.get("log", "Automation completed.")
+                }
+            except Exception:
+                return {
+                    "status": "success",
+                    "insight": "n8n received the data.",
+                    "next_step": "Check your n8n workflow output.",
+                    "log": response.text[:500]
+                }
+
+        return {
+            "status": "error",
+            "insight": f"n8n returned status code {response.status_code}.",
+            "next_step": "Check your webhook and Respond to Webhook node.",
+            "log": response.text[:500]
+        }
+
+    except Exception as e:
+        return {
+            "status": "error",
+            "insight": "The app could not reach n8n.",
+            "next_step": "Check that the n8n production webhook is active.",
+            "log": str(e)
+        }
+
+
+def run_pipeline(
+    neighbourhood_group,
+    neighbourhood,
+    room_type,
+    price,
+    availability_365,
+    season,
+    local_event_score,
+    rating,
+    sentiment_score,
+    send_to_n8n
+):
     price = float(price)
     availability_365 = float(availability_365)
     local_event_score = float(local_event_score)
-    synthetic_rating = float(synthetic_rating)
-    customer_sentiment_score = float(customer_sentiment_score)
+    rating = float(rating)
+    sentiment_score = float(sentiment_score)
 
     comparable = df.copy()
 
-    if "neighbourhood_group" in comparable.columns:
-        comparable = comparable[comparable["neighbourhood_group"].astype(str) == str(neighbourhood_group)]
+    comparable = comparable[
+        (comparable["neighbourhood_group"].astype(str) == str(neighbourhood_group)) &
+        (comparable["room_type"].astype(str) == str(room_type))
+    ]
 
-    if "room_type" in comparable.columns:
-        comparable = comparable[comparable["room_type"].astype(str) == str(room_type)]
+    local_comparable = comparable[comparable["neighbourhood"].astype(str) == str(neighbourhood)]
 
-    if "neighbourhood" in comparable.columns and neighbourhood:
-        local_comp = comparable[comparable["neighbourhood"].astype(str) == str(neighbourhood)]
-        if len(local_comp) >= 5:
-            comparable = local_comp
+    if len(local_comparable) >= 5:
+        comparable = local_comparable
 
     if len(comparable) < 5:
-        comparable = df[df["room_type"].astype(str) == str(room_type)] if "room_type" in df.columns else df.copy()
+        comparable = df[df["room_type"].astype(str) == str(room_type)]
 
-    competitor_avg_price = safe_mean(comparable.get("price", pd.Series(dtype=float)), default=price)
-    avg_occupancy = safe_mean(comparable.get("occupancy_rate", pd.Series(dtype=float)), default=0.50)
-    avg_demand = safe_mean(comparable.get("demand_score", pd.Series(dtype=float)), default=50)
-    avg_revenue = safe_mean(comparable.get("monthly_revenue", pd.Series(dtype=float)), default=price * 15)
+    competitor_avg_price = safe_mean(comparable["price"], price)
+    avg_occupancy = safe_mean(comparable["occupancy_rate"], 0.5)
+    avg_demand = safe_mean(comparable["demand_score"], 50)
 
-    if competitor_avg_price == 0:
-        price_vs_competitor_pct = 0
-    else:
-        price_vs_competitor_pct = ((price - competitor_avg_price) / competitor_avg_price) * 100
+    price_gap_pct = ((price - competitor_avg_price) / competitor_avg_price) * 100 if competitor_avg_price else 0
 
-    # Occupancy estimate: base from comparable listings, adjusted for price gap, events, season, rating and sentiment
     season_boost = {
-        "Low": -0.08,
         "Low Season": -0.08,
+        "Medium Season": 0.00,
+        "High Season": 0.08,
+        "Low": -0.08,
         "Medium": 0.00,
-        "Shoulder Season": 0.00,
         "High": 0.08,
-        "High Season": 0.08,
-        "Peak": 0.12,
-        "Peak Season": 0.12
+        "Peak": 0.12
     }.get(str(season), 0.00)
 
-    price_penalty = max(min(price_vs_competitor_pct / 100, 0.35), -0.35) * 0.30
+    price_penalty = max(min(price_gap_pct / 100, 0.35), -0.35) * 0.30
     event_boost = (local_event_score / 100) * 0.12
-    rating_boost = (synthetic_rating - 4.0) * 0.06
-    sentiment_boost = customer_sentiment_score * 0.08
+    rating_boost = (rating - 4.0) * 0.06
+    sentiment_boost = sentiment_score * 0.08
 
-    occupancy_estimate = avg_occupancy + season_boost + event_boost + rating_boost + sentiment_boost - price_penalty
-    occupancy_estimate = max(0.05, min(0.95, occupancy_estimate))
+    occupancy = avg_occupancy + season_boost + event_boost + rating_boost + sentiment_boost - price_penalty
+    occupancy = max(0.05, min(0.95, occupancy))
 
-    booked_nights_month = round(occupancy_estimate * 30)
-    monthly_revenue = round(price * booked_nights_month, 2)
+    booked_nights = round(occupancy * 30)
+    monthly_revenue = round(price * booked_nights, 2)
 
     demand_score = (
-        0.45 * avg_demand
-        + 0.25 * (occupancy_estimate * 100)
-        + 0.15 * local_event_score
-        + 0.10 * ((synthetic_rating / 5) * 100)
-        + 0.05 * ((customer_sentiment_score + 1) / 2 * 100)
+        0.45 * avg_demand +
+        0.25 * (occupancy * 100) +
+        0.15 * local_event_score +
+        0.10 * ((rating / 5) * 100) +
+        0.05 * ((sentiment_score + 1) / 2 * 100)
     )
+
     demand_score = round(max(0, min(100, demand_score)), 1)
 
     if demand_score >= 70:
@@ -109,37 +156,31 @@ def estimate_pipeline(neighbourhood_group, neighbourhood, room_type, price, avai
     else:
         demand_level = "Low"
 
-    if price_vs_competitor_pct > 15 and demand_level != "High":
+    if price_gap_pct > 15 and demand_level != "High":
         pricing_recommendation = "Consider lowering price"
         suggested_price = round(competitor_avg_price * 1.05, 2)
-    elif price_vs_competitor_pct < -10 and demand_level in ["Medium", "High"]:
+        insight = "The listing appears overpriced compared with similar properties."
+        next_step = f"Test a lower price around ${suggested_price} to improve occupancy."
+    elif price_gap_pct < -10 and demand_level in ["Medium", "High"]:
         pricing_recommendation = "Consider raising price"
         suggested_price = round(min(competitor_avg_price * 0.98, price * 1.12), 2)
+        insight = "The listing appears underpriced relative to comparable demand."
+        next_step = f"Consider increasing the price toward ${suggested_price}."
     else:
         pricing_recommendation = "Keep price stable"
         suggested_price = round(price, 2)
+        insight = "The current price is aligned with comparable listings."
+        next_step = "Keep price stable and focus on visibility, reviews, and conversion."
 
     opportunity_score = round(
-        (demand_score * 0.45)
-        + (occupancy_estimate * 100 * 0.25)
-        + (synthetic_rating / 5 * 100 * 0.15)
-        + ((customer_sentiment_score + 1) / 2 * 100 * 0.15),
+        demand_score * 0.45 +
+        occupancy * 100 * 0.25 +
+        rating / 5 * 100 * 0.15 +
+        ((sentiment_score + 1) / 2 * 100) * 0.15,
         2
     )
 
-    if pricing_recommendation == "Consider lowering price":
-        insight = "The listing appears overpriced compared with similar properties, which may limit occupancy."
-        next_step = f"Test a lower price around ${suggested_price} and monitor occupancy changes."
-    elif pricing_recommendation == "Consider raising price":
-        insight = "The listing appears underpriced relative to demand and comparable properties."
-        next_step = f"Consider increasing the price toward ${suggested_price} while maintaining review quality."
-    else:
-        insight = "The current price is broadly aligned with the comparable market."
-        next_step = "Keep the price stable and focus on improving visibility, reviews, and conversion."
-
-    final_recommendation = f"{pricing_recommendation}. {next_step}"
-
-    result = {
+    payload = {
         "app_name": APP_NAME,
         "neighbourhood_group": neighbourhood_group,
         "neighbourhood": neighbourhood,
@@ -147,168 +188,183 @@ def estimate_pipeline(neighbourhood_group, neighbourhood, room_type, price, avai
         "current_price": price,
         "suggested_price": suggested_price,
         "competitor_avg_price": round(competitor_avg_price, 2),
-        "price_vs_competitor_pct": round(price_vs_competitor_pct, 2),
-        "occupancy_estimate": round(occupancy_estimate, 3),
-        "booked_nights_month": booked_nights_month,
+        "price_vs_competitor_pct": round(price_gap_pct, 2),
+        "occupancy_estimate": round(occupancy, 3),
+        "booked_nights_month": booked_nights,
         "monthly_revenue": monthly_revenue,
         "demand_score": demand_score,
         "demand_level": demand_level,
         "opportunity_score": opportunity_score,
         "pricing_recommendation": pricing_recommendation,
         "insight": insight,
-        "next_step": next_step,
-        "final_recommendation": final_recommendation
+        "next_step": next_step
     }
 
-    n8n_result = call_n8n(result) if send_to_n8n else {
-        "status": "not_sent",
-        "insight": "n8n automation was not triggered.",
-        "next_step": "Turn on the checkbox and add your N8N_WEBHOOK_URL secret to activate automation.",
-        "log": "Local pipeline only."
-    }
+    if send_to_n8n:
+        n8n_response = call_n8n(payload)
+    else:
+        n8n_response = {
+            "status": "not_sent",
+            "insight": "n8n automation was not triggered.",
+            "next_step": "Tick the n8n checkbox to send this result to the workflow.",
+            "log": "Local pipeline only."
+        }
 
-    summary_md = f"""
-# {APP_NAME} — Pipeline Result
+    result_text = f"""
+# StayWise AI Pipeline Result
 
-## Pricing recommendation
+## Recommendation
 **{pricing_recommendation}**
 
-| Metric | Result |
-|---|---:|
-| Current price | ${price:,.2f} |
-| Suggested price | ${suggested_price:,.2f} |
-| Comparable average price | ${competitor_avg_price:,.2f} |
-| Price vs competitors | {price_vs_competitor_pct:.2f}% |
-| Estimated occupancy | {occupancy_estimate * 100:.1f}% |
-| Estimated booked nights/month | {booked_nights_month} |
-| Estimated monthly revenue | ${monthly_revenue:,.2f} |
-| Demand score | {demand_score}/100 |
-| Demand level | {demand_level} |
-| Opportunity score | {opportunity_score}/100 |
-
-## Business insight
+## Key Metrics
+
+- Current price: **${price:,.2f}**
+- Suggested price: **${suggested_price:,.2f}**
+- Competitor average price: **${competitor_avg_price:,.2f}**
+- Price vs competitors: **{price_gap_pct:.2f}%**
+- Estimated occupancy: **{occupancy * 100:.1f}%**
+- Estimated booked nights per month: **{booked_nights}**
+- Estimated monthly revenue: **${monthly_revenue:,.2f}**
+- Demand score: **{demand_score}/100**
+- Demand level: **{demand_level}**
+- Opportunity score: **{opportunity_score}/100**
+
+## Business Insight
 {insight}
 
-## Next step
+## Next Step
 {next_step}
 """
 
-    n8n_md = f"""
-# Automation Output
-
-**Status:** {n8n_result.get("status", "unknown")}
+    automation_text = f"""
+# n8n Automation Output
 
-**Insight:** {n8n_result.get("insight", "No insight returned.")}
-
-**Next step:** {n8n_result.get("next_step", "No next step returned.")}
-
-**Log:** {n8n_result.get("log", "No log returned.")}
+- Status: **{n8n_response.get("status", "unknown")}**
+- Insight: {n8n_response.get("insight", "No insight returned.")}
+- Next step: {n8n_response.get("next_step", "No next step returned.")}
+- Log: {n8n_response.get("log", "No log returned.")}
 """
 
-    comp_cols = [c for c in ["id", "name", "neighbourhood_group", "neighbourhood", "room_type", "price", "occupancy_rate", "monthly_revenue", "demand_score", "demand_level", "pricing_recommendation"] if c in comparable.columns]
-    comparable_preview = comparable[comp_cols].head(10).copy() if comp_cols else comparable.head(10).copy()
+    cols = [
+        "id",
+        "name",
+        "neighbourhood_group",
+        "neighbourhood",
+        "room_type",
+        "price",
+        "occupancy_rate",
+        "monthly_revenue",
+        "demand_score",
+        "demand_level",
+        "pricing_recommendation"
+    ]
 
-    return summary_md, n8n_md, comparable_preview, json.dumps(result, indent=2)
+    available_cols = [c for c in cols if c in comparable.columns]
+    comparable_table = comparable[available_cols].head(10)
 
-def call_n8n(payload):
-    if not N8N_WEBHOOK_URL:
-        return {
-            "status": "not_configured",
-            "insight": "No n8n webhook URL has been configured in the Space secrets.",
-            "next_step": "Add N8N_WEBHOOK_URL in Hugging Face Space Settings → Secrets.",
-            "log": "Pipeline calculated locally, but automation was not sent."
-        }
+    json_output = json.dumps(payload, indent=2)
 
-    try:
-        response = requests.post(N8N_WEBHOOK_URL, json=payload, timeout=15)
-        if response.status_code >= 200 and response.status_code < 300:
-            try:
-                data = response.json()
-                return {
-                    "status": data.get("status", "success"),
-                    "insight": data.get("insight", "n8n received and processed the recommendation."),
-                    "next_step": data.get("next_step", "Review the stored record or report generated by n8n."),
-                    "log": data.get("log", "Automation completed.")
-                }
-            except Exception:
-                return {
-                    "status": "success",
-                    "insight": "n8n received the recommendation.",
-                    "next_step": "Check the connected output in n8n.",
-                    "log": response.text[:500]
-                }
+    return result_text, automation_text, comparable_table, json_output
 
-        return {
-            "status": "error",
-            "insight": f"n8n returned HTTP {response.status_code}.",
-            "next_step": "Check the webhook URL and the Respond to Webhook node.",
-            "log": response.text[:500]
-        }
 
-    except Exception as e:
-        return {
-            "status": "error",
-            "insight": "The app could not reach the n8n workflow.",
-            "next_step": "Verify that the production webhook URL is active and public.",
-            "log": str(e)
-        }
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        # 🏠 StayWise AI
 
-custom_css = """
-.gradio-container {
-    max-width: 1200px !important;
-    margin: auto !important;
-}
-#hero {
-    background: linear-gradient(135deg, #0f172a 0%, #1e3a8a 55%, #0284c7 100%);
-    padding: 28px;
-    border-radius: 22px;
-    color: white;
-    margin-bottom: 20px;
-}
-#hero h1 {
-    font-size: 42px;
-    margin-bottom: 6px;
-}
-#hero p {
-    font-size: 17px;
-    opacity: 0.92;
-}
-.card {
-    border-radius: 18px;
-}
-"""
+        **AI-powered pricing and performance optimization for short-term rentals.**
 
-with gr.Blocks(css=custom_css, title=APP_NAME, theme=gr.themes.Soft()) as demo:
-    gr.HTML(f"""
-    <div id="hero">
-        <h1>{APP_NAME}</h1>
-        <p>AI-powered pricing and performance optimization for short-term rentals.</p>
-    </div>
-    """)
+        Enter listing details, run the full pipeline, compare with similar listings, and optionally send the result to n8n.
+        """
+    )
 
     with gr.Row():
-        with gr.Column(scale=1):
+        with gr.Column():
             gr.Markdown("## Property Inputs")
-            neighbourhood_group = gr.Dropdown(neighbourhood_groups, label="Neighbourhood Group", value=neighbourhood_groups[0] if neighbourhood_groups else None)
-            neighbourhood = gr.Dropdown(neighbourhoods, label="Neighbourhood", value=neighbourhoods[0] if neighbourhoods else None)
-            room_type = gr.Dropdown(room_types, label="Room Type", value=room_types[0] if room_types else None)
-            price = gr.Slider(20, 1000, value=150, step=5, label="Current Nightly Price ($)")
-            availability_365 = gr.Slider(0, 365, value=180, step=1, label="Availability per Year")
-            season = gr.Dropdown(seasons, label="Season", value=seasons[0] if seasons else None)
-            local_event_score = gr.Slider(0, 100, value=50, step=1, label="Local Event Demand Score")
-            synthetic_rating = gr.Slider(1, 5, value=4.4, step=0.1, label="Guest Rating")
-            customer_sentiment_score = gr.Slider(-1, 1, value=0.2, step=0.05, label="Customer Sentiment Score")
-            send_to_n8n = gr.Checkbox(label="Send pipeline output to n8n", value=False)
-            run_btn = gr.Button("Run Full Pipeline", variant="primary")
-
-        with gr.Column(scale=2):
-            pipeline_output = gr.Markdown(label="Pipeline Result")
-            n8n_output = gr.Markdown(label="Automation Output")
-            comparable_table = gr.Dataframe(label="Comparable Listings", interactive=False)
-            json_output = gr.Code(label="Pipeline JSON Output", language="json")
-
-    run_btn.click(
-        estimate_pipeline,
+
+            neighbourhood_group = gr.Dropdown(
+                choices=neighbourhood_groups,
+                label="Neighbourhood Group",
+                value=neighbourhood_groups[0]
+            )
+
+            neighbourhood = gr.Dropdown(
+                choices=neighbourhoods,
+                label="Neighbourhood",
+                value=neighbourhoods[0]
+            )
+
+            room_type = gr.Dropdown(
+                choices=room_types,
+                label="Room Type",
+                value=room_types[0]
+            )
+
+            price = gr.Slider(
+                minimum=20,
+                maximum=1000,
+                value=150,
+                step=5,
+                label="Current Nightly Price ($)"
+            )
+
+            availability_365 = gr.Slider(
+                minimum=0,
+                maximum=365,
+                value=180,
+                step=1,
+                label="Availability per Year"
+            )
+
+            season = gr.Dropdown(
+                choices=seasons,
+                label="Season",
+                value=seasons[0]
+            )
+
+            local_event_score = gr.Slider(
+                minimum=0,
+                maximum=100,
+                value=50,
+                step=1,
+                label="Local Event Demand Score"
+            )
+
+            rating = gr.Slider(
+                minimum=1,
+                maximum=5,
+                value=4.4,
+                step=0.1,
+                label="Guest Rating"
+            )
+
+            sentiment_score = gr.Slider(
+                minimum=-1,
+                maximum=1,
+                value=0.2,
+                step=0.05,
+                label="Customer Sentiment Score"
+            )
+
+            send_to_n8n = gr.Checkbox(
+                label="Send output to n8n",
+                value=False
+            )
+
+            run_button = gr.Button("Run Full Pipeline")
+
+        with gr.Column():
+            result_output = gr.Markdown()
+            automation_output = gr.Markdown()
+
+    gr.Markdown("## Comparable Listings")
+    comparable_output = gr.Dataframe()
+
+    gr.Markdown("## JSON Pipeline Output")
+    json_output = gr.Code(language="json")
+
+    run_button.click(
+        fn=run_pipeline,
         inputs=[
             neighbourhood_group,
             neighbourhood,
@@ -317,15 +373,17 @@ with gr.Blocks(css=custom_css, title=APP_NAME, theme=gr.themes.Soft()) as demo:
             availability_365,
             season,
             local_event_score,
-            synthetic_rating,
-            customer_sentiment_score,
+            rating,
+            sentiment_score,
             send_to_n8n
         ],
-        outputs=[pipeline_output, n8n_output, comparable_table, json_output]
+        outputs=[
+            result_output,
+            automation_output,
+            comparable_output,
+            json_output
+        ]
     )
 
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+
+demo.launch()