|
import matplotlib.pyplot as plt |
|
import numpy_financial as npf |
|
import streamlit as st |
|
import pandas as pd |
|
import numpy as np |
|
|
|
def calculate_loan_shift_savings(current_balance, current_rate, new_rate, remaining_term, processing_fee): |
|
|
|
monthly_current_rate = current_rate / 12 / 100 |
|
monthly_new_rate = new_rate / 12 / 100 |
|
|
|
|
|
current_monthly_payment = npf.pmt(monthly_current_rate, remaining_term, -current_balance) |
|
new_monthly_payment = npf.pmt(monthly_new_rate, remaining_term, -current_balance) |
|
|
|
|
|
total_current_payment = current_monthly_payment * remaining_term |
|
total_new_payment = new_monthly_payment * remaining_term + processing_fee |
|
|
|
|
|
savings = total_current_payment - total_new_payment |
|
return savings |
|
|
|
def loan_shift_decision_tab(): |
|
st.header("Should I Shift My Loan Calculator") |
|
|
|
current_balance = st.number_input("Current Loan Balance", min_value=0.0) |
|
current_rate = st.number_input("Current Interest Rate (Annual %)", min_value=0.0) |
|
new_rate = st.number_input("New Interest Rate (Annual %)", min_value=0.0) |
|
remaining_term = st.number_input("Remaining Term of Loan (Months)", min_value=1) |
|
processing_fee = st.number_input("Processing Fee for New Loan", min_value=0.0) |
|
|
|
if st.button("Calculate Savings"): |
|
savings = calculate_loan_shift_savings(current_balance, current_rate, new_rate, remaining_term, processing_fee) |
|
if savings > 0: |
|
st.success(f"Shifting your loan saves you ${savings:,.2f} over the remaining term of the loan.") |
|
else: |
|
st.error(f"Shifting your loan does not save money. It costs you an additional ${-savings:,.2f}.") |
|
|
|
|
|
def calculate_real_future_values(principal, interest_rate, inflation_rate, years): |
|
return np.array([principal * ((1 + interest_rate / 100) ** year) / ((1 + inflation_rate / 100) ** year) for year in np.arange(1, years + 1)]) |
|
|
|
def inflation_calculator_tab(): |
|
st.header("Multiple Investments Growth Calculator with Inflation") |
|
st.write("Calculate and compare the real value growth of multiple investments considering inflation.") |
|
|
|
|
|
entries = [] |
|
n_entries = st.number_input("Number of Investments", min_value=1, max_value=10, value=1, step=1) |
|
for i in range(n_entries): |
|
col1, col2 = st.columns(2) |
|
with col1: |
|
amount = st.number_input(f"Amount {i+1}", min_value=0.0, value=1000.0, format="%.2f") |
|
with col2: |
|
rate = st.number_input(f"Interest Rate {i+1} (%)", min_value=0.0, value=5.0, format="%.2f") |
|
entries.append((amount, rate)) |
|
|
|
inflation_rate = st.number_input("Annual Inflation Rate (%)", min_value=0.0, value=2.0, format="%.2f") |
|
years = st.number_input("Number of Years:", min_value=1, max_value=100, step=1) |
|
|
|
if st.button('Calculate and Plot'): |
|
plt.figure(figsize=(10, 6)) |
|
combined_future_value = np.zeros(years) |
|
|
|
for i, (amount, rate) in enumerate(entries): |
|
real_future_values = calculate_real_future_values(amount, rate, inflation_rate, years) |
|
combined_future_value += real_future_values |
|
plt.plot(range(1, years + 1), real_future_values, label=f'Investment {i+1}') |
|
|
|
plt.plot(range(1, years + 1), combined_future_value, label='Combined Investment (Adjusted for Inflation)', color='black', linestyle='--') |
|
plt.title('Investment Real Value Growth Over Time Considering Inflation') |
|
plt.xlabel('Years') |
|
plt.ylabel('Real Future Value') |
|
plt.legend() |
|
st.pyplot(plt) |
|
|
|
|
|
def calculate_emi(principal, annual_interest_rate, tenure_years): |
|
monthly_interest_rate = annual_interest_rate / (12 * 100) |
|
total_payments = tenure_years * 12 |
|
emi = principal * monthly_interest_rate / (1 - (1 + monthly_interest_rate) ** -total_payments) |
|
return emi |
|
|
|
def emi_breakdown(principal, annual_interest_rate, tenure_years): |
|
monthly_interest_rate = annual_interest_rate / (12 * 100) |
|
total_payments = tenure_years * 12 |
|
emi = calculate_emi(principal, annual_interest_rate, tenure_years) |
|
balance = principal |
|
emi_data = [] |
|
|
|
for month in range(1, total_payments + 1): |
|
interest = balance * monthly_interest_rate |
|
principal_payment = emi - interest |
|
balance -= principal_payment |
|
emi_data.append([month, emi, principal_payment, interest, balance]) |
|
|
|
return pd.DataFrame(emi_data, columns=["Month", "EMI", "Principal", "Interest", "Balance"]) |
|
|
|
def plot_emi_data(emi_df): |
|
plt.figure(figsize=(10, 5)) |
|
plt.plot(emi_df['Month'], emi_df['Principal'], label='Principal Component') |
|
plt.plot(emi_df['Month'], emi_df['Interest'], label='Interest Component') |
|
plt.xlabel('Month') |
|
plt.ylabel('Amount') |
|
plt.title('EMI Components Over Time') |
|
plt.legend() |
|
st.pyplot(plt) |
|
|
|
plt.figure(figsize=(10, 5)) |
|
plt.plot(emi_df['Month'], emi_df['Balance'], label='Remaining Balance') |
|
plt.xlabel('Month') |
|
plt.ylabel('Amount') |
|
plt.title('Loan Balance Over Time') |
|
plt.legend() |
|
st.pyplot(plt) |
|
|
|
def emi_calculator_tab(): |
|
st.header("EMI Calculator") |
|
loan_amount = st.number_input("Loan Amount", min_value=0.0, value=100000.0, step=1000.0) |
|
annual_interest_rate = st.number_input("Annual Interest Rate (%)", min_value=0.0, value=8.0, step=0.1) |
|
tenure_years = st.number_input("Tenure (Years)", min_value=1, value=10, step=1) |
|
|
|
if st.button('Calculate EMI'): |
|
emi = calculate_emi(loan_amount, annual_interest_rate, tenure_years) |
|
st.success(f"Monthly EMI: ₹ {emi:.2f}") |
|
|
|
emi_df = emi_breakdown(loan_amount, annual_interest_rate, tenure_years) |
|
plot_emi_data(emi_df) |
|
st.write(emi_df) |
|
|
|
def calculate_compound_interest(principal, annual_rate, compounding_frequency, years): |
|
""" |
|
Calculate the compound interest based on the given parameters. |
|
""" |
|
factor = { |
|
"Monthly": 12, |
|
"Quarterly": 4, |
|
"Yearly": 1 |
|
} |
|
n = factor[compounding_frequency] |
|
amount = principal * ((1 + annual_rate/(100 * n)) ** (n * years)) |
|
return amount |
|
|
|
def plot_growth(principal, annual_rate, compounding_frequency, years): |
|
""" |
|
Plot the returns of the investment over time. |
|
""" |
|
factor = { |
|
"Monthly": 12, |
|
"Quarterly": 4, |
|
"Yearly": 1 |
|
} |
|
n = factor[compounding_frequency] |
|
times = np.linspace(0, years, years * n + 1) |
|
future_values = principal * ((1 + annual_rate/(100 * n)) ** (n * times)) |
|
returns = future_values - principal |
|
|
|
plt.figure(figsize=(10, 6)) |
|
plt.plot(times, returns, color='purple', linestyle='-', linewidth=2, label='Investment Returns') |
|
plt.fill_between(times, returns, color='blue', alpha=0.3) |
|
plt.title('Investment Returns Over Time') |
|
plt.xlabel('Years') |
|
plt.ylabel('Returns (Future Value - Principal)') |
|
plt.legend() |
|
st.pyplot(plt) |
|
|
|
|
|
def plot_growth_old(principal, annual_rate, compounding_frequency, years): |
|
""" |
|
Plot the growth of the investment over time. |
|
""" |
|
factor = { |
|
"Monthly": 12, |
|
"Quarterly": 4, |
|
"Yearly": 1 |
|
} |
|
n = factor[compounding_frequency] |
|
times = np.linspace(0, years, years * n + 1) |
|
values = principal * ((1 + annual_rate/(100 * n)) ** (n * times)) |
|
|
|
plt.figure(figsize=(10, 6)) |
|
plt.plot(times, values, color='purple', linestyle='-', linewidth=2, label='Investment Growth') |
|
plt.fill_between(times, values, color='blue', alpha=0.3) |
|
plt.title('Compound Interest Growth Over Time') |
|
plt.xlabel('Years') |
|
plt.ylabel('Future Value') |
|
plt.legend() |
|
st.pyplot(plt) |
|
|
|
def compound_interest_calculator(): |
|
st.header("Compound Interest Calculator") |
|
st.write("Calculate the future value of your investment with compound interest.") |
|
|
|
principal = st.number_input("Enter the principal amount:", min_value=0.0, value=10000.0, format="%.2f") |
|
annual_rate = st.number_input("Enter the annual interest rate (%):", min_value=0.0, value=5.0, format="%.2f") |
|
compounding_frequency = st.selectbox("Select the compounding frequency:", ["Monthly", "Quarterly", "Yearly"]) |
|
years = st.number_input("Enter the number of years:", min_value=1, max_value=50, value=10, step=1) |
|
|
|
if st.button('Calculate and Plot'): |
|
future_value = calculate_compound_interest(principal, annual_rate, compounding_frequency, years) |
|
st.success(f"The future value of your investment is: ₹ {future_value:.2f}") |
|
|
|
plot_growth(principal, annual_rate, compounding_frequency, years) |
|
|
|
def calculate_fire_number(monthly_expenses, withdrawal_rate): |
|
""" |
|
Calculate the FIRE Number based on monthly expenses and withdrawal rate. |
|
Annual expenses are derived by multiplying monthly expenses by 12. |
|
""" |
|
annual_expenses = monthly_expenses * 12 |
|
fire_number = annual_expenses / (withdrawal_rate / 100) |
|
return fire_number |
|
|
|
def fire_number_calculator(): |
|
st.header("FIRE Number Calculator") |
|
st.write("Calculate the amount you need to achieve Financial Independence and Retire Early (FIRE) based on your monthly expenses.") |
|
|
|
monthly_expenses = st.number_input("Enter your monthly expenses:", min_value=0.0, value=5000.0, format="%.2f") |
|
withdrawal_rate = st.number_input("Enter your desired withdrawal rate (%):", min_value=1.0, max_value=10.0, value=4.0, format="%.2f") |
|
|
|
if st.button('Calculate FIRE Number'): |
|
fire_number = calculate_fire_number(monthly_expenses, withdrawal_rate) |
|
st.success(f"Your FIRE Number is: ₹ {fire_number:.2f}") |
|
|
|
def project_fd_value(principal, annual_rate, years): |
|
return np.array([principal * ((1 + annual_rate) ** year) for year in range(1, years + 1)]) |
|
|
|
def plot_projections_with_fd(years, best_case_values, worst_case_values, fd_values): |
|
plt.figure(figsize=(10, 6)) |
|
plt.plot(range(1, years + 1), best_case_values, label='Best Case', color='#1f77b4') |
|
plt.plot(range(1, years + 1), worst_case_values, label='Worst Case', color='#ff7f0e') |
|
plt.plot(range(1, years + 1), fd_values, label='FD Return', color='#2ca02c') |
|
plt.xlabel('Years') |
|
plt.ylabel('Projected Value (₹)') |
|
plt.yscale('log') |
|
plt.title('Investment Projections Over Time (Log Scale)') |
|
plt.legend() |
|
st.pyplot(plt) |
|
|
|
def investment_projections(investment_amount, risk_appetite, years): |
|
|
|
if risk_appetite >= 75: |
|
best_case_rate = 0.15 |
|
worst_case_rate = -0.05 |
|
elif 25 < risk_appetite < 75: |
|
best_case_rate = 0.10 |
|
worst_case_rate = 0.00 |
|
else: |
|
best_case_rate = 0.05 |
|
worst_case_rate = 0.01 |
|
|
|
|
|
best_case_value = project_future_value(investment_amount, best_case_rate, years) |
|
worst_case_value = project_future_value(investment_amount, worst_case_rate, years) |
|
|
|
return best_case_value, worst_case_value |
|
|
|
def plot_projections(years, best_case_values, worst_case_values): |
|
plt.figure(figsize=(10, 6)) |
|
plt.plot(range(1, years + 1), best_case_values, label='Best Case', color='#1f77b4') |
|
plt.plot(range(1, years + 1), worst_case_values, label='Worst Case', color='#ff7f0e') |
|
plt.xlabel('Years') |
|
plt.ylabel('Projected Value (₹)') |
|
plt.title('Investment Projections Over Time') |
|
plt.legend() |
|
st.pyplot(plt) |
|
|
|
def project_future_value(principal, annual_rate, years): |
|
return np.array([principal * ((1 + annual_rate) ** year) for year in range(1, years + 1)]) |
|
|
|
def investment_advice(income, expenses, age, risk_appetite): |
|
|
|
disposable_income = income - expenses |
|
|
|
|
|
emergency_fund = expenses * 6 |
|
|
|
|
|
retirement_savings = disposable_income * 0.15 |
|
|
|
|
|
if risk_appetite >= 75: |
|
stocks = disposable_income * 0.5 |
|
bonds = disposable_income * 0.2 |
|
mutual_funds = disposable_income * 0.3 |
|
elif 25 < risk_appetite < 75: |
|
stocks = disposable_income * 0.3 |
|
bonds = disposable_income * 0.4 |
|
mutual_funds = disposable_income * 0.3 |
|
else: |
|
stocks = disposable_income * 0.1 |
|
bonds = disposable_income * 0.6 |
|
mutual_funds = disposable_income * 0.3 |
|
|
|
return { |
|
"Emergency Fund": emergency_fund, |
|
"Retirement Savings": retirement_savings, |
|
"Stocks": stocks, |
|
"Bonds": bonds, |
|
"Mutual Funds": mutual_funds |
|
} |
|
|
|
def investment_advisor(): |
|
st.title("Smart Income Investment Advisor") |
|
|
|
income = st.number_input("Enter your monthly income:", min_value=0.0, format="%.2f") |
|
expenses = st.number_input("Enter your monthly expenses:", min_value=0.0, format="%.2f") |
|
age = st.number_input("Enter your age:", min_value=18, max_value=100, step=1) |
|
risk_appetite = st.slider("Select your risk appetite (0 = Low, 100 = High):", 0, 100, 50) |
|
|
|
fd_rate = st.number_input("Enter FD Interest Rate:", min_value = 0.1, max_value = 10.0, format="%.2f") |
|
|
|
years = st.number_input("Investment Time Horizon (Years):", min_value=1, max_value=30, step=1) |
|
|
|
if st.button("Get Investment Advice"): |
|
advice = investment_advice(income, expenses, age, risk_appetite) |
|
st.write(advice) |
|
|
|
total_investment = advice["Stocks"] + advice["Bonds"] + advice["Mutual Funds"] |
|
best_case_values, worst_case_values = investment_projections(total_investment, risk_appetite, years) |
|
|
|
fd_values = project_fd_value(total_investment, fd_rate / 100, years) |
|
|
|
st.write("Projection for your total investment:") |
|
st.write(f"Best-case scenario (in {years} years): ₹ {best_case_values[-1]:.2f}") |
|
st.write(f"Worst-case scenario (in {years} years): ₹ {worst_case_values[-1]:.2f}") |
|
st.write(f"Fixed Deposit scenario (in {years} years): ₹ {fd_values[-1]:.2f}") |
|
|
|
|
|
plot_projections_with_fd(years, best_case_values, worst_case_values, fd_values) |
|
|
|
def calculate_sip_returns(sip_amount, duration_years, rd_fd_rate, mf_rate, index_fund_rate): |
|
|
|
monthly_rd_fd_rate = rd_fd_rate / 12 / 100 |
|
monthly_mf_rate = mf_rate / 12 / 100 |
|
monthly_index_fund_rate = index_fund_rate / 12 / 100 |
|
|
|
|
|
total_months = duration_years * 12 |
|
|
|
|
|
rd_fd_total = 0 |
|
for month in range(total_months): |
|
rd_fd_total *= (1 + monthly_rd_fd_rate) |
|
rd_fd_total += sip_amount |
|
|
|
|
|
mf_total = 0 |
|
index_fund_total = 0 |
|
for month in range(total_months): |
|
mf_total *= (1 + monthly_mf_rate) |
|
mf_total += sip_amount |
|
index_fund_total *= (1 + monthly_index_fund_rate) |
|
index_fund_total += sip_amount |
|
|
|
return rd_fd_total, mf_total, index_fund_total |
|
|
|
def sip_return_comparator_tab(): |
|
st.header("SIP Return Comparator") |
|
st.write("Compare the returns from different investment options based on your SIP.") |
|
|
|
sip_amount = st.number_input("Enter your monthly SIP amount:", min_value=500.0, value=5000.0, format="%.2f") |
|
duration_years = st.number_input("Enter the investment duration (in years):", min_value=1, max_value=30, value=5, step=1) |
|
|
|
|
|
rd_fd_rate = st.number_input("Enter RD/FD Interest Rate (% per annum):", min_value=0.0, value=6.0, format="%.2f") |
|
mf_rate = st.number_input("Enter Mutual Funds Return Rate (% per annum):", min_value=0.0, value=12.0, format="%.2f") |
|
index_fund_rate = st.number_input("Enter Index Funds Return Rate (% per annum):", min_value=0.0, value=10.0, format="%.2f") |
|
|
|
if st.button('Calculate SIP Returns'): |
|
rd_fd_returns, mf_returns, index_fund_returns = calculate_sip_returns(sip_amount, duration_years, rd_fd_rate, mf_rate, index_fund_rate) |
|
st.success(f"RD/FD Returns: ₹ {rd_fd_returns:.2f}\nMutual Funds Returns: ₹ {mf_returns:.2f}\nIndex Funds Returns: ₹ {index_fund_returns:.2f}") |
|
|
|
|
|
labels = ['RD/FD', 'Mutual Funds', 'Index Funds'] |
|
returns = [rd_fd_returns, mf_returns, index_fund_returns] |
|
colors = [(0.1, 0.2, 0.5, 0.7), (0.2, 0.6, 0.2, 0.7), (1.0, 0.5, 0.0, 0.7)] |
|
plt.figure(figsize=(10, 6)) |
|
plt.bar(labels, returns, color=colors) |
|
plt.title('SIP Returns Comparison') |
|
plt.ylabel('Total Returns in ₹') |
|
st.pyplot(plt) |
|
|
|
|
|
def calculate_emi(principal, interest_rate, years): |
|
monthly_interest_rate = interest_rate / (12 * 100) |
|
total_payments = years * 12 |
|
emi = principal * monthly_interest_rate * ((1 + monthly_interest_rate) ** total_payments) / ((1 + monthly_interest_rate) ** total_payments - 1) |
|
return emi |
|
|
|
def calculate_loan_eligibility(net_monthly_income, other_emis, interest_rate, tenure_years, income_multiplier=5): |
|
|
|
max_emi_allowed = net_monthly_income * 0.5 - other_emis |
|
monthly_interest_rate = interest_rate / (12 * 100) |
|
total_payments = tenure_years * 12 |
|
max_loan_amount = max_emi_allowed / (monthly_interest_rate * ((1 + monthly_interest_rate) ** total_payments) / ((1 + monthly_interest_rate) ** total_payments - 1)) |
|
return max_loan_amount * income_multiplier |
|
|
|
def estimate_tax_savings(interest_paid_annually, principal_paid_annually, income_tax_slab, co_purchaser): |
|
max_deduction_interest = 200000 |
|
max_deduction_principal = 150000 |
|
interest_deduction = min(interest_paid_annually, max_deduction_interest) |
|
principal_deduction = min(principal_paid_annually, max_deduction_principal) |
|
tax_savings = (interest_deduction + principal_deduction) * income_tax_slab / 100 |
|
if co_purchaser == "Yes": |
|
tax_savings *= 2 |
|
return tax_savings |
|
|
|
def calculate_profit_timeline(total_loan_amount, emi, tax_savings, initial_investment, rental_income, rental_increase_rate, inflation_rate, property_appreciation_rate, years): |
|
monthly_rental_income = rental_income |
|
cumulative_rental_income = 0 |
|
cumulative_investment = initial_investment |
|
property_value = total_loan_amount + initial_investment |
|
profit_timeline = [] |
|
|
|
for year in range(1, years + 1): |
|
annual_rental_income = 0 |
|
property_value *= (1 + property_appreciation_rate) |
|
|
|
for month in range(1, 13): |
|
adjusted_rental_income = monthly_rental_income / ((1 + inflation_rate) ** (year - 1)) |
|
annual_rental_income += adjusted_rental_income |
|
cumulative_rental_income += adjusted_rental_income |
|
cumulative_investment += emi - tax_savings / 12 |
|
|
|
|
|
monthly_rental_income *= (1 + rental_increase_rate) |
|
|
|
|
|
profit_timeline.append((year, cumulative_rental_income, cumulative_investment, property_value)) |
|
|
|
return pd.DataFrame(profit_timeline, columns=["Year", "Cumulative Rental Income", "Cumulative Investment", "Estimated Property Value"]) |
|
|
|
|
|
def loan_eligibility_calculator(): |
|
st.header("Loan Eligibility Calculator") |
|
st.write("Calculate your loan eligibility based on your monthly income and other factors.") |
|
|
|
net_monthly_income = st.number_input("Enter your net monthly income:", min_value=0.0, value=50000.0, format="%.2f") |
|
other_emis = st.number_input("Enter total EMI of other existing loans (if any):", min_value=0.0, value=0.0, format="%.2f") |
|
interest_rate = st.number_input("Expected loan interest rate (%):", min_value=0.0, value=8.0, format="%.2f") |
|
tenure_years = st.number_input("Expected loan tenure (years):", min_value=1, max_value=30, value=20, step=1) |
|
|
|
if st.button('Calculate Loan Eligibility'): |
|
loan_eligibility = calculate_loan_eligibility(net_monthly_income, other_emis, interest_rate, tenure_years) |
|
st.success(f"Based on the provided details, your estimated loan eligibility is: ₹ {loan_eligibility:.2f}") |
|
|
|
def emi_rental_profit_calculator(): |
|
|
|
cost_of_property = st.number_input("Enter the cost of the property:", min_value=100000.0, value=5000000.0, format="%.2f") |
|
renovation_cost = st.number_input("Enter the renovation cost:", min_value=0.0, value=500000.0, format="%.2f") |
|
down_payment = st.number_input("Enter the down payment:", min_value=0.0, value=1000000.0, format="%.2f") |
|
loan_amount = cost_of_property + renovation_cost - down_payment |
|
st.text(f"Total Loan Amount: {loan_amount}") |
|
|
|
interest_rate = st.number_input("Enter the home loan interest rate (%):", min_value=0.0, value=8.0, format="%.2f") |
|
years = st.number_input("Enter the number of years for the loan:", min_value=1, max_value=30, value=20, step=1) |
|
co_purchaser = st.selectbox("Is there a co-purchaser?", ["No", "Yes"]) |
|
income_tax_slab = st.number_input("Enter your income tax slab rate (%):", min_value=0.0, max_value=30.0, value=10.0, format="%.2f") |
|
initial_rental_income = st.number_input("Enter initial monthly rental income:", min_value=0.0, value=20000.0, format="%.2f") |
|
rental_increase_rate = st.number_input("Enter annual rental increase rate (%):", min_value=0.0, max_value=10.0, value=5.0, format="%.2f") / 100 |
|
inflation_rate = st.number_input("Enter annual inflation rate (%):", min_value=0.0, max_value=10.0, value=4.0, format="%.2f") / 100 |
|
property_appreciation_rate = st.number_input("Enter annual property value appreciation rate (%):", min_value=0.0, max_value=10.0, value=3.0, format="%.2f") / 100 |
|
|
|
|
|
if st.button('Calculate'): |
|
emi = calculate_emi(loan_amount, interest_rate, years) |
|
st.text(f"Monthly EMI: {emi:.2f}") |
|
|
|
|
|
annual_emi = emi * 12 |
|
tax_savings = estimate_tax_savings(annual_emi, annual_emi, income_tax_slab, co_purchaser) |
|
st.text(f"Annual Tax Savings: {tax_savings:.2f}") |
|
|
|
|
|
profit_df = calculate_profit_timeline(loan_amount, emi, tax_savings, down_payment, initial_rental_income, rental_increase_rate, inflation_rate, property_appreciation_rate, years) |
|
st.write(profit_df) |
|
|
|
|
|
plt.figure(figsize=(10, 4)) |
|
plt.plot(profit_df['Year'], profit_df['Cumulative Rental Income'], label='Cumulative Rental Income') |
|
plt.plot(profit_df['Year'], profit_df['Cumulative Investment'], label='Cumulative Investment') |
|
plt.plot(profit_df['Year'], profit_df['Estimated Property Value'], label='Estimated Property Value') |
|
plt.xlabel('Year') |
|
plt.ylabel('Amount') |
|
plt.title('Profit Timeline') |
|
plt.legend() |
|
st.pyplot(plt) |
|
|
|
def main(): |
|
st.title("Personal Finance Assistance") |
|
|
|
|
|
st.sidebar.title("Navigation") |
|
|
|
options = ["Personal Finance Assistance Tools", "Loan Eligibility Calculator", "EMI and Rental Profit Calculator", "SIP Return Comparator", "How to invest my income?", "FIRE Number Calculator", "Compound Interest Calculator", "Loan EMI Calculator"] |
|
options.append("Debt Payoff Calculator") |
|
options.append("How are my investments changing over time considering inflation ?") |
|
options.append("Should I Shift My Loan Calculator") |
|
|
|
choice = st.sidebar.radio("Choose a Calculator:", options) |
|
|
|
if choice == "Personal Finance Assistance Tools": |
|
st.text("This Space container various tools to clarify few personal finances.") |
|
st.text("Choose from left sidebar and proceed.") |
|
st.text("Suggestion are welcome, please contact at [email protected] for collaboration!") |
|
elif choice == "Loan Eligibility Calculator": |
|
loan_eligibility_calculator() |
|
elif choice == "EMI and Rental Profit Calculator": |
|
emi_rental_profit_calculator() |
|
elif choice == "SIP Return Comparator": |
|
sip_return_comparator_tab() |
|
elif choice == "How to invest my income?": |
|
investment_advisor() |
|
elif choice == "FIRE Number Calculator": |
|
fire_number_calculator() |
|
elif choice == "Compound Interest Calculator": |
|
compound_interest_calculator() |
|
elif choice == "Loan EMI Calculator": |
|
emi_calculator_tab() |
|
elif choice == "How are my investments changing over time considering inflation ?": |
|
inflation_calculator_tab() |
|
elif choice == "Should I Shift My Loan Calculator": |
|
loan_shift_decision_tab() |
|
|
|
|
|
if __name__ == "__main__": |
|
main() |