Upload 2 files

app.py

@@ -0,0 +1,213 @@
+
+import gradio as gr
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import random
+
+# Constants
+regions = ["Riyadh", "Makkah", "Eastern", "Madinah", "Qassim", "Asir", "Tabuk", "Hail", "Northern",
+           "Jazan", "Najran", "Bahah", "Jawf"]
+income_bands = ["Low", "Mid", "High"]
+property_types = ["Land", "Off-plan", "Ready", "Self-build"]
+
+def default_subsidy_values():
+    base = 300_000
+    factor = 0.5
+    return {(r, i, p): int((base - 100_000 * income_bands.index(i)) * factor)
+            for r in regions for i in income_bands for p in property_types}
+
+def default_supply_cost_values():
+    return {(p, r): {"Supply": random.randint(1000, 10000), "Discount (SAR)": random.randint(50_000, 300_000)}
+            for p in ["Land", "Off-plan"] for r in regions}
+
+def monte_carlo_optimization(subsidies, budget_limit, target_contracts, supply_dict, interest_rate, demand_increase, n_trials=10000):
+    keys = list(subsidies.keys())
+    best_result = None
+    best_score = float('-inf')
+    fairness_penalty_weight = 10_000_000
+
+    demand_multiplier = 1 + (demand_increase / 100)
+    cost_multiplier = 1 + (interest_rate / 100)
+
+    for _ in range(n_trials):
+        contracts = {}
+        total_budget = 0
+        total_contracts = 0
+        shuffled_subs = {k: int(random.randint(150000, 400000) * cost_multiplier) for k in keys}
+        available_supply = {(r, p): supply_dict.get((p, r), 0) for (p, r) in supply_dict}
+
+        for k in keys:
+            r, i, p = k
+            max_supply = available_supply.get((r, p), 10000)
+            max_demand = int(max_supply * demand_multiplier)
+            max_possible_contracts = int(min((budget_limit - total_budget) // shuffled_subs[k], max_demand)) if shuffled_subs[k] > 0 else 0
+            c = random.randint(0, max_possible_contracts) if max_possible_contracts > 0 else 0
+            contracts[k] = c
+            total_budget += shuffled_subs[k] * c
+            total_contracts += c
+
+        if total_budget > budget_limit:
+            continue
+
+        achieved_regions = set(r for (r, i, p) in contracts if contracts[(r, i, p)] > 0)
+        achieved_income = set(i for (r, i, p) in contracts if contracts[(r, i, p)] > 0)
+        achieved_props = set(p for (r, i, p) in contracts if contracts[(r, i, p)] > 0)
+        fairness_penalty = (
+            len(regions) - len(achieved_regions) +
+            len(income_bands) - len(achieved_income) +
+            len(property_types) - len(achieved_props)
+        ) * fairness_penalty_weight
+
+        score = total_contracts - fairness_penalty
+
+        if score > best_score:
+            best_score = score
+            best_result = (contracts, total_budget, total_contracts, shuffled_subs)
+
+    return best_result if best_result else ({}, 0, 0, subsidies)
+
+def create_gauge_chart(value, title, max_value=100):
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=value,
+        gauge={
+            'axis': {'range': [0, max_value]},
+            'bar': {'color': "darkblue"},
+            'steps': [
+                {'range': [0, max_value * 0.5], 'color': "lightgray"},
+                {'range': [max_value * 0.5, max_value], 'color': "lightgreen"}
+            ]
+        },
+        title={'text': title}
+    ))
+    fig.update_layout(height=350, width=450, margin=dict(t=40, b=40, l=40, r=40))
+    return fig
+
+def build_app():
+    supply_costs = default_supply_cost_values()
+
+    with gr.Blocks() as app:
+        gr.Markdown("# 🏨 Strategic Gears Housing Simulator – Auto Optimization")
+
+        with gr.Tab("Inputs"):
+            with gr.Row():
+                with gr.Column():
+                    ir = gr.Slider(0, 10, 5, label="Interest Rate (%)")
+                    dp = gr.Slider(0, 100, 10, label="Demand Increase (%)")
+                    n = gr.Slider(100, 10000, 1000, step=100, label="Number of Simulations")
+                    budget_limit = gr.Slider(10_000_000, 1_000_000_000, 500_000_000, step=10_000_000, label="Budget Limit (SAR)")
+                    target_contracts = gr.Slider(1000, 20000, 5000, step=100, label="Target Contracts")
+                    supply_inputs = {}
+
+                    with gr.Accordion("Supply Inputs by Region and Property Type", open=False):
+                        for p in ["Land", "Off-plan"]:
+                            with gr.Accordion(p, open=False):
+                                for r in regions:
+                                    supply_inputs[(p, r)] = gr.Slider(minimum=1, maximum=10000,
+                                                                      value=supply_costs[(p, r)]["Supply"],
+                                                                      step=1,
+                                                                      label=f"{r} {p} Supply")
+                    run = gr.Button("Run Simulation")
+
+        with gr.Tab("Outputs"):
+            summary = gr.Markdown("Optimization summary will appear here.")
+
+            with gr.Row():
+                with gr.Column():
+                    df_subsidy_policy = gr.Dataframe(label="1️⃣ Recommended Subsidy Support (SAR)")
+                    subsidy_by_income_bar = gr.Plot(label="Average Subsidy by Income Band")
+                with gr.Column():
+                    df_contract_summary = gr.Dataframe(label="2️⃣ Contract Distribution")
+                    contracts_by_region_bar = gr.Plot(label="Contracts by Region")
+
+            with gr.Row():
+                with gr.Column():
+                    df_budget_summary = gr.Dataframe(label="3️⃣ Budget Distribution")
+                    budget_util_gauge = gr.Plot(label="Budget Utilization (%)")
+                with gr.Column():
+                    df_discount_table = gr.Dataframe(label="4️⃣ Discount Table")
+                    contracts_by_property_pie = gr.Plot(label="Contract Distribution by Property Type")
+                    target_achievement_gauge = gr.Plot(label="Target Achievement (%)")
+                    total_contracts_gauge = gr.Plot(label="Total Contracts (Scaled to Target)")
+
+        def run_sim(interest, demand, sims, budget, target, *supplies):
+            supply_dict = {(p, r): supplies[i] for i, (p, r) in enumerate(supply_inputs)}
+            result, total_bgt, total_con, final_subs = monte_carlo_optimization(
+                default_subsidy_values(), budget, target, supply_dict, interest, demand, sims
+            )
+
+            df = pd.DataFrame([{
+                "Region": r, "Income Band": i, "Property Type": p,
+                "Contracts": result.get((r, i, p), 0),
+                "Subsidy (SAR)": final_subs[(r, i, p)],
+                "Budget (SAR)": result.get((r, i, p), 0) * final_subs[(r, i, p)]
+            } for (r, i, p) in final_subs])
+
+            subsidy_df = df[["Region", "Income Band", "Property Type", "Subsidy (SAR)"]].sort_values(by="Subsidy (SAR)", ascending=False)
+            contract_df = df[["Region", "Income Band", "Property Type", "Contracts"]].sort_values(by="Contracts", ascending=False)
+            budget_df = df[["Region", "Income Band", "Property Type", "Budget (SAR)"]].sort_values(by="Budget (SAR)", ascending=False)
+
+            df_discount = pd.DataFrame([{
+                "Region": r, "Property Type": p,
+                "Discount (SAR)": random.randint(50_000, 300_000)
+            } for p in ["Land", "Off-plan"] for r in regions])
+
+            summary_text = f"""
+**Optimization Summary:**
+- Total Budget Used: {total_bgt:,.0f} SAR
+- Budget Utilization: {(total_bgt / budget) * 100:.1f}%
+- Total Contracts: {total_con:,}
+- Target Achievement: {(total_con / target) * 100:.1f}%
+"""
+
+            # Gauges
+            budget_util_pct = (total_bgt / budget) * 100
+            target_achieved_pct = (total_con / target) * 100
+            total_contracts_scaled = min(100, (total_con / target) * 100)
+
+            gauge_budget = create_gauge_chart(budget_util_pct, "Budget Utilization (%)")
+            gauge_target = create_gauge_chart(target_achieved_pct, "Target Achievement (%)")
+            gauge_contracts = create_gauge_chart(total_contracts_scaled, "Contracts (Scaled to Target %)")
+
+            # Contracts by Region Bar
+            contracts_region = df.groupby("Region")["Contracts"].sum().reset_index()
+            bar_contract_region = px.bar(contracts_region, x="Region", y="Contracts", title="Contracts by Region")
+            min_y = 10
+            max_y = contracts_region["Contracts"].max() * 1.1
+            bar_contract_region.update_layout(
+                height=350, width=450,
+                yaxis=dict(title="Contracts", tickformat=",d", range=[min_y, max_y]),
+                margin=dict(t=50, b=40, l=60, r=40)
+            )
+
+            # Subsidy by Income Band
+            subsidy_income = df.groupby("Income Band")["Subsidy (SAR)"].mean().reset_index()
+            bar_subsidy_income = px.bar(subsidy_income, x="Income Band", y="Subsidy (SAR)", title="Average Subsidy by Income Band")
+            bar_subsidy_income.update_layout(
+                height=350, width=450,
+                yaxis=dict(tickprefix="SAR ", tickformat="~s"),
+                margin=dict(t=50, b=40, l=60, r=40)
+            )
+
+            # Property Type Pie
+            contracts_property = df.groupby("Property Type")["Contracts"].sum().reset_index()
+            pie_property = px.pie(contracts_property, names="Property Type", values="Contracts", title="Contract Distribution by Property Type")
+            pie_property.update_layout(height=350, width=450, margin=dict(t=50, b=40, l=40, r=40))
+
+            return summary_text, subsidy_df, contract_df, budget_df, df_discount,                    gauge_budget, gauge_target, gauge_contracts, bar_contract_region, bar_subsidy_income, pie_property
+
+        run.click(
+            fn=run_sim,
+            inputs=[ir, dp, n, budget_limit, target_contracts] + list(supply_inputs.values()),
+            outputs=[
+                summary, df_subsidy_policy, df_contract_summary, df_budget_summary, df_discount_table,
+                budget_util_gauge, target_achievement_gauge, total_contracts_gauge,
+                contracts_by_region_bar, subsidy_by_income_bar, contracts_by_property_pie
+            ]
+        )
+
+    return app
+
+app = build_app()
+app.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+pandas
+plotly