Create app.py

app.py

@@ -0,0 +1,269 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.ticker import FuncFormatter
+import polars as pl
+import gradio as gr
+
+def calculate_mortgage(principal, annual_interest_rate, years, compound_yearly=True):
+    if compound_yearly:
+        # Convert annual rate to monthly effective rate for yearly compounding
+        monthly_interest_rate = (1 + annual_interest_rate) ** (1/12) - 1
+    else:
+        monthly_interest_rate = annual_interest_rate / 12
+    
+    months = years * 12
+    if monthly_interest_rate == 0:
+        return principal / months
+        
+    mortgage_payment = (
+        principal * monthly_interest_rate * (1 + monthly_interest_rate) ** months
+    ) / ((1 + monthly_interest_rate) ** months - 1)
+    return mortgage_payment
+
+def generate_amortization_schedule(principal, annual_interest_rate, years):
+    monthly_payment = calculate_mortgage(principal, annual_interest_rate, years)
+    monthly_rate = annual_interest_rate / 12
+    months = years * 12
+    schedule = []
+    remaining_balance = principal
+
+    for month in range(1, months + 1):
+        interest_payment = remaining_balance * monthly_rate
+        principal_payment = monthly_payment - interest_payment
+        remaining_balance -= principal_payment
+        schedule.append({
+            "month": month,
+            "remaining_balance": remaining_balance,
+            "payment": monthly_payment,
+            "principal": principal_payment,
+            "interest": interest_payment,
+        })
+    return schedule
+
+class FlatInvestmentParameters:
+    flat_price = 2000000
+    one_time_payment = 100000
+    yearly_interest_rate = 0.05
+    mortgage_years = 30
+    initial_rent = 12000
+    yearly_rent_increase = 0.05
+    yearly_flat_appreciation = 0.07
+    down_payment_percentage = 0.1 
+
+def calculate_flat_investment(flatInvestmentParameters: FlatInvestmentParameters):
+    flat_price = flatInvestmentParameters.flat_price
+    one_time_payment = flatInvestmentParameters.one_time_payment
+    interest_rate = flatInvestmentParameters.yearly_interest_rate
+    mortgage_years = flatInvestmentParameters.mortgage_years
+    rent_current = flatInvestmentParameters.initial_rent
+    rent_increase = flatInvestmentParameters.yearly_rent_increase
+    flat_appreciation = flatInvestmentParameters.yearly_flat_appreciation
+    down_payment_percentage = flatInvestmentParameters.down_payment_percentage 
+
+    down_payment = flat_price * down_payment_percentage
+    initial_investment = down_payment + one_time_payment
+    loan_amount = flat_price * (1 - down_payment_percentage)
+
+    amortization = generate_amortization_schedule(loan_amount, interest_rate, mortgage_years)
+    total_months = mortgage_years * 12
+
+    months = []
+    net_worth = []
+    cash_balance = [-initial_investment]  
+    rent_received = []
+    cash_flow = []
+
+    for i, month_data in enumerate(amortization):
+        current_month = i + 1
+        current_year = (current_month - 1) // 12
+        current_year_float = (current_month - 1) / 12
+
+        current_rent = rent_current * (1 + rent_increase) ** current_year  # Removed *0.9
+        current_flat_price = flat_price * (1 + flat_appreciation) ** current_year_float
+        rent_received.append(current_rent)
+
+        new_cash = cash_balance[-1] + current_rent - month_data["payment"]
+        cash_flow_this_month = current_rent - month_data["payment"]
+        cash_flow.append(cash_flow_this_month)
+        cash_balance.append(new_cash)
+
+        months.append(current_month)
+        current_net_worth = (current_flat_price - month_data["remaining_balance"]) + cash_balance[-1]
+        net_worth.append(current_net_worth)
+
+    debt = [month["remaining_balance"] for month in amortization]
+    cash_flow_cumulative = np.cumsum(cash_flow)
+
+    monthly_roi = []
+    for month in range(1, total_months + 1):
+        total_cashflow = sum(cash_flow[:month])
+        mortgage_current = debt[month-1]
+        flat_price_current = flat_price * (1 + flat_appreciation) ** ((month - 1) / 12)  # Corrected
+        roi = (total_cashflow - mortgage_current + flat_price_current - initial_investment) / initial_investment
+        monthly_roi.append(roi)
+
+    values = [{
+        "month": i,
+        "rent": rent_received[i],
+        "payment": amortization[i]["payment"],
+        "cash_flow": cash_flow[i],
+        "debt": debt[i],
+        "cash_flow_cumulative": cash_flow_cumulative[i],
+        "flat_price": flat_price * (1 + flat_appreciation) ** (i / 12),
+        "net_worth": net_worth[i],
+        "roi": monthly_roi[i],
+    } for i in range(total_months)]
+    return values
+
+
+def create_plots(investment_history, mortgage_years):
+    # Create formatter function
+    def currency(x, pos):
+        return f"{x/1000000:,.0f}M CZK"
+
+    # Create figure with 3 subplots
+    fig = plt.figure(figsize=(15, 12))
+    
+    # First subplot - Yearly view
+    ax1 = plt.subplot(311)
+    months = investment_history["month"].to_numpy()
+    debt = investment_history["debt"].to_numpy()
+    flat_price = investment_history["flat_price"].to_numpy()
+    cash_flow_cumulative = investment_history["cash_flow_cumulative"].to_numpy()
+    net_worth = investment_history["net_worth"].to_numpy()
+    
+    yearly_mask = [i % 12 == 11 for i in range(len(months))]
+    ax1.plot(months[yearly_mask] / 12, debt[yearly_mask], label="Debt")
+    ax1.plot(months[yearly_mask] / 12, flat_price[yearly_mask], label="Flat Price")
+    ax1.plot(months[yearly_mask] / 12, cash_flow_cumulative[yearly_mask], label="Total Cash Flow")
+    ax1.plot(months[yearly_mask] / 12, net_worth[yearly_mask], label="Net Worth")
+    ax1.set_title("Yearly View")
+    ax1.set_xlabel("Years")
+    ax1.legend()
+    ax1.yaxis.set_major_formatter(FuncFormatter(currency))
+    ax1.grid(True)
+
+    # Second subplot - Monthly view
+    ax2 = plt.subplot(312)
+    ax2.plot(months, debt, label="Debt")
+    ax2.plot(months, flat_price, label="Flat Price")
+    ax2.plot(months, cash_flow_cumulative, label="Total Cash Flow")
+    ax2.plot(months, net_worth, label="Net Worth")
+    ax2.set_title("Monthly View")
+    ax2.set_xlabel("Months")
+    ax2.legend()
+    ax2.yaxis.set_major_formatter(FuncFormatter(currency))
+    ax2.grid(True)
+
+    # Third subplot - ROI
+    ax3 = plt.subplot(313)
+    ax3.plot(range(1, mortgage_years + 1), investment_history["roi"].to_numpy()[yearly_mask])
+    ax3.set_title("Yearly ROI")
+    ax3.set_xlabel("Years")
+    ax3.set_ylabel("ROI")
+    ax3.yaxis.set_major_formatter(FuncFormatter(lambda x, _: f"{x:.0%}"))
+    ax3.grid(True)
+
+    plt.tight_layout()
+    return fig  
+
+def calculate_investment(
+    flat_price: float,
+    one_time_payment: float,
+    yearly_interest_rate: float,
+    mortgage_years: int,
+    initial_rent: float,
+    yearly_rent_increase: float,
+    yearly_flat_appreciation: float,
+    down_payment_percentage: float
+):
+    params = FlatInvestmentParameters()
+    params.flat_price = flat_price
+    params.one_time_payment = one_time_payment
+    params.yearly_interest_rate = yearly_interest_rate
+    params.mortgage_years = mortgage_years
+    params.initial_rent = initial_rent
+    params.yearly_rent_increase = yearly_rent_increase
+    params.yearly_flat_appreciation = yearly_flat_appreciation
+    params.down_patment_percentage = down_payment_percentage
+    
+    # Calculate initial investment components
+    down_payment = flat_price * down_payment_percentage
+    initial_investment = down_payment + one_time_payment
+    monthly_payment = calculate_mortgage(flat_price * (1 - down_payment_percentage), yearly_interest_rate, mortgage_years)
+    
+    investment_summary = [
+        ["Down Payment", f"{down_payment:,.0f} CZK"],
+        ["One Time Payment", f"{one_time_payment:,.0f} CZK"],
+        ["Total Initial Investment", f"{initial_investment:,.0f} CZK"],
+        ["Monthly Payment", f"{monthly_payment:,.0f} CZK"]
+    ]
+    
+    investment_history = calculate_flat_investment(params)
+    investment_df = pl.DataFrame(investment_history)
+    
+    plot = create_plots(investment_df, mortgage_years)
+    
+    display_df = investment_df.select([
+        pl.col("month"),
+        pl.col("rent").round(0),
+        pl.col("payment").round(0),
+        pl.col("cash_flow").round(0),
+        pl.col("debt").round(0),
+        pl.col("cash_flow_cumulative").round(0),
+        pl.col("flat_price").round(0),
+        pl.col("net_worth").round(0),
+        pl.col("roi").round(2).map_elements(lambda x: f"{x:.0%}")
+    ])
+    
+    return plot, display_df.to_pandas(), investment_summary
+
+def create_gradio_interface():
+    with gr.Blocks() as app:
+        gr.Markdown("# Flat Investment Calculator")
+        
+        with gr.Row():
+            with gr.Column():
+                flat_price = gr.Number(value=2000000, label="Flat Price (CZK)")
+                one_time_payment = gr.Number(value=100000, label="One Time Payment (CZK)")
+                yearly_interest_rate = gr.Slider(minimum=0, maximum=0.15, value=0.05, step=0.001, label="Yearly Interest Rate")
+                mortgage_years = gr.Slider(minimum=5, maximum=40, value=30, step=1, label="Mortgage Years")
+            with gr.Column():
+                initial_rent = gr.Number(value=12000, label="Initial Monthly Rent (CZK)")
+                yearly_rent_increase = gr.Slider(minimum=0, maximum=0.15, value=0.05, step=0.001, label="Yearly Rent Increase")
+                yearly_flat_appreciation = gr.Slider(minimum=0, maximum=0.15, value=0.07, step=0.001, label="Yearly Flat Appreciation")
+                down_payment_percentage = gr.Slider(minimum=0.1, maximum=1.0, value=0.1, step=0.05, label="Down Payment Percentage")
+
+        calculate_btn = gr.Button("Calculate")
+        
+        with gr.Row():
+            investment_summary = gr.Dataframe(
+                headers=["Item", "Amount"],
+                label="Investment Summary",
+                value=[["", ""]],  # Initial empty value
+                interactive=False,
+                wrap=True
+            )
+        
+        output_plot = gr.Plot()
+        output_table = gr.DataFrame()
+        
+        calculate_btn.click(
+            calculate_investment,
+            inputs=[
+                flat_price,
+                one_time_payment,
+                yearly_interest_rate,
+                mortgage_years,
+                initial_rent,
+                yearly_rent_increase,
+                yearly_flat_appreciation,
+                down_payment_percentage
+            ],
+            outputs=[output_plot, output_table, investment_summary]
+        )
+    return app
+
+if __name__ == "__main__":
+    app = create_gradio_interface()
+    app.launch()