Refactored the code, and added XIRR

app.py

@@ -1,9 +1,16 @@
+import locale
 import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+import numpy_financial as npf
 import pandas as pd
 import plotly.graph_objects as go
-from datetime import datetime, timedelta
-import requests
-import locale
+import seaborn as sns
+from pandas.tseries.offsets import DateOffset, MonthEnd
+from scipy import optimize
+
+from portfolio import calculate_portfolio_returns
+from utils import get_all_mf_schemes_df,get_mf_scheme_data
 
 js_func = """
 function refresh() {
@@ -18,114 +25,38 @@ function refresh() {
 
 locale.setlocale(locale.LC_MONETARY, 'en_IN')
 
-# def create_pie_chart(schemes):
-#     labels = list(schemes.keys())
-#     values = list(schemes.values())
-    
-#     fig = go.Figure(data=[go.Pie(labels=labels, values=values)])
-#     fig.update_layout(title_text="Scheme Weightages")
-#     return fig
-
-
-def get_nav_data(scheme_code):
-    url = f"https://api.mfapi.in/mf/{scheme_code}"
-    response = requests.get(url)
-    data = response.json()
-    df = pd.DataFrame(data['data'])
-    df['date'] = pd.to_datetime(df['date'], format='%d-%m-%Y')
-    df['nav'] = df['nav'].astype(float)
-    df = df.sort_values('date')
-    inception_date = df['date'].min()
-    return df, inception_date
-
-def calculate_sip_returns(nav_data, sip_amount, upfront_amount, stepup, start_date, end_date, SIP_Date):
-    start_date = pd.Timestamp(start_date)
-    end_date = pd.Timestamp(end_date)
-
-    nav_data_filtered = nav_data[(nav_data['date'] >= start_date) & (nav_data['date'] <= end_date)].copy()
-    nav_data_filtered['date'] = pd.to_datetime(nav_data_filtered['date'])
-    if SIP_Date == 'start':
-        last_dates = nav_data_filtered.groupby([nav_data_filtered['date'].dt.year, nav_data_filtered['date'].dt.month]).head(1)
-    elif SIP_Date == 'end':
-        last_dates = nav_data_filtered.groupby([nav_data_filtered['date'].dt.year, nav_data_filtered['date'].dt.month]).tail(1)
-    else:
-        last_dates = nav_data_filtered.groupby([nav_data_filtered['date'].dt.year, nav_data_filtered['date'].dt.month]).apply(lambda x: x.iloc[len(x)//2])
-
-    total_investment = upfront_amount
-    current_sip_amount = sip_amount
-
-    # do calculation for upfront investment
-    units_bought = upfront_amount / nav_data_filtered.iloc[0]['nav']
-    units_accumulated = units_bought
-    previous_year = start_date.year
-
-    for _, row in last_dates.iloc[:-1].iterrows():
-        # Check if a year has passed and increase SIP amount accordingly
-        if row['date'].year > previous_year:
-            current_sip_amount += current_sip_amount * (stepup / 100)
-            previous_year = row['date'].year
-
-        units_bought = current_sip_amount / row['nav']
-        units_accumulated += units_bought
-        total_investment += current_sip_amount
-
-    final_value = units_accumulated * last_dates.iloc[-1]['nav']
-    total_return = (final_value - total_investment) / total_investment * 100
-
-    return total_return, final_value, total_investment
-
-
-def calculate_portfolio_returns(schemes, sip_amount, upfront_amount, stepup, start_date, end_date, SIP_date, schemes_df):
-    scheme_returns = []
-    total_investment = 0
-    final_value = 0
-    inception_dates = []
-
-    for scheme_name, scheme_weight in schemes.items():
-        scheme_code = schemes_df[schemes_df['schemeName'] == scheme_name]['schemeCode'].values[0]
-        nav_data, inception_date = get_nav_data(scheme_code)
-        inception_dates.append((scheme_name, inception_date))
-        scheme_return, scheme_final_value, scheme_total_investment = calculate_sip_returns(nav_data, sip_amount * scheme_weight / 100, upfront_amount * scheme_weight / 100, stepup, start_date, end_date, SIP_date)
-        scheme_returns.append((scheme_name, scheme_return,scheme_final_value,scheme_total_investment))
-        final_value += scheme_final_value
-        total_investment += scheme_total_investment
-
-    portfolio_return = (final_value - total_investment) / total_investment * 100
-    return portfolio_return, final_value, total_investment, scheme_returns, inception_dates
-
-def update_sip_calculator(*args):
+def get_portfolio_report(*args):
     period = args[0]
     custom_start_date = args[1]
     custom_end_date = args[2]
     SIP_Date = args[3]
     sip_amount = args[4]
-    upfront_amount = args[5]
+    lumpsum_amount = args[5]
     stepup = args[6]
     schemes_df = args[7]
-    schemes = {}
+
+    scheme_name_and_weight = {}
     
-    for i in range(8, len(args) - 1, 2):  # Adjust range to account for use_inception_date
+    for i in range(8, len(args) - 1, 2):
         if args[i] and args[i+1]:
-            schemes[args[i]] = float(args[i+1])
+            scheme_name_and_weight[args[i]] = float(args[i+1])
 
-    use_inception_date = args[-1]  # Get use_inception_date from the last argument
+    use_inception_date = args[-1]
 
-    if not schemes:
+    if not scheme_name_and_weight:
         return "Please add at least one scheme.", None, None, None
-
-    total_weight = sum(schemes.values())
-
-    end_date = datetime.now().date()
+    
+    end_date = pd.Timestamp.now().floor('D')
 
     if use_inception_date:
-        start_date = datetime.strptime(custom_start_date, "%Y-%m-%d").date()
+        start_date = pd.Timestamp(custom_start_date)
     elif period == "Custom":
         if not custom_start_date or not custom_end_date:
             return "Please provide both start and end dates for custom period.", None, None, None
-        start_date = datetime.strptime(custom_start_date, "%Y-%m-%d").date()
-        end_date = datetime.strptime(custom_end_date, "%Y-%m-%d").date()
+        start_date = pd.Timestamp(custom_start_date)
+        end_date = pd.Timestamp(custom_end_date)
     elif period == "YTD":
-        start_date = datetime(end_date.year, 1, 1).date()
+        start_date = pd.Timestamp(f"{end_date.year}-01-01")
     elif not period:
         return "Please select a period, provide custom dates, or use the inception date.", None, None, None
     else:
@@ -135,47 +66,28 @@ def update_sip_calculator(*args):
         
         if 'year' in period_parts[1]:
             years = int(period_parts[0])
-            start_date = end_date - timedelta(days=years*365)
+            start_date = end_date - DateOffset(years=years)
         else:
             months = int(period_parts[0])
-            start_date = end_date - timedelta(days=months*30)
+            start_date = end_date - DateOffset(months=months)
 
-    try:
-        portfolio_return, final_value, total_investment, scheme_returns, inception_dates = calculate_portfolio_returns(schemes, sip_amount, upfront_amount,stepup, start_date, end_date, SIP_Date, schemes_df)
-    except Exception as e:
-        return f"Error: {str(e)}", None, None, None
+    portfolio_return_string, inception_dates, scheme_individual_returns = calculate_portfolio_returns(scheme_name_and_weight, sip_amount, lumpsum_amount, stepup, start_date, end_date, SIP_Date, schemes_df)
 
-    # Check if start_date is before any scheme's inception date
     inception_warnings = []
-    earliest_inception_date = max(inception_date for _, inception_date in inception_dates)
     for scheme_name, inception_date in inception_dates:
-        if start_date < inception_date.date():
-            inception_warnings.append(f"Warning: {scheme_name} inception date ({inception_date.date()}) is after the chosen start date ({start_date}).")
-
-    result = ""
-    if inception_warnings:
-        result += "The following warnings were found:\n"
-        result += "\n".join(inception_warnings) + "\n\n"
-        result += f"Possible start date for all chosen schemes is: {earliest_inception_date.date()}\n\n"
-
-    result += f"Portfolio Absolute return: {portfolio_return:.2f}%\n"
-    result += f"Total investment: {locale.currency(total_investment,grouping=True)}\n"
-    result += f"Final value: {locale.currency(final_value,grouping=True)}\n\n"
-    result += "Individual scheme returns:\n"
-    for scheme_name, scheme_return, scheme_final_value, scheme_total_investment in scheme_returns:
-        result += f"----  {scheme_name}  ----:\n"
-        result += f"Return: {scheme_return:.2f}%\n"
-        result += f"Total investment: {locale.currency(scheme_total_investment,grouping=True)}\n"
-        result += f"Final value: {locale.currency(scheme_final_value,grouping=True)}\n\n"
-    # pie_chart = create_pie_chart(schemes)
-    # return result, pie_chart, final_value, total_investment
-    return result
-
-def fetch_scheme_data():
-    url = "https://api.mfapi.in/mf"
-    response = requests.get(url)
-    schemes = response.json()
-    return pd.DataFrame(schemes)
+        if start_date < inception_date:
+            inception_warnings.append(f"Warning: {scheme_name} inception date ({inception_date.date()}) is after the chosen start date ({start_date.date()}).")
+
+    result_string = f"""
+    {portfolio_return_string}
+    ------------------------------------
+    Individual Scheme Returns
+    ------------------------------------
+    {''.join(scheme_individual_returns)}
+    {''.join(inception_warnings)}
+    """
+    return result_string
+
 
 def quick_search_schemes(query, schemes_df):
     if not query:
@@ -271,9 +183,8 @@ def handle_row_selection(schemes_list, evt: gr.SelectData, table_data):
     return table_data, schemes_list
 
 def create_ui():
-    schemes_df = fetch_scheme_data()
-
-    with gr.Blocks(js=js_func) as app:
+    schemes_df = get_all_mf_schemes_df()
+    with gr.Blocks(js=js_func) as demo:
         gr.Markdown("# Mutual Fund SIP Returns Calculator")
 
         with gr.Row():
@@ -358,7 +269,7 @@ def create_ui():
             inception_dates = []
             for scheme_name, _ in schemes_list:
                 scheme_code = schemes_df[schemes_df['schemeName'] == scheme_name]['schemeCode'].values[0]
-                _, inception_date = get_nav_data(scheme_code)
+                _, inception_date = get_mf_scheme_data(scheme_code)
                 inception_dates.append(inception_date)
             return max(inception_dates).strftime("%Y-%m-%d") if inception_dates else ""
 
@@ -387,14 +298,14 @@ def create_ui():
             return inputs
 
         calculate_button.click(
-            lambda *args: update_sip_calculator(*prepare_inputs_with_inception(*args)),
+            lambda *args: get_portfolio_report(*prepare_inputs_with_inception(*args)),
             inputs=[period, custom_start_date, custom_end_date, SIP_Date, sip_amount,upfront_amount,stepup,schemes_list, gr.State(schemes_df), use_inception_date, inception_date_display],
             outputs=[result]
             # outputs=[result, final_value, total_investment]
             # outputs=[result, pie_chart, final_value, total_investment]
         )
 
-    return app
+    return demo
 
-app = create_ui()
-app.launch()
+demo = create_ui()
+demo.launch(debug=True)

portfolio.py

@@ -0,0 +1,83 @@
+import pandas as pd
+from utils import get_mf_scheme_data
+from returns import get_investment_xirr, get_investment_sip_absolute_returns
+
+def get_portfolio_nav_df(schemes_name_and_weight, start_date, end_date, schemes_df):
+    # start_date = pd.to_datetime(start_date)
+    # end_date = pd.to_datetime(end_date)
+
+    portfolio_nav_df = pd.DataFrame()
+
+    for scheme_name, scheme_weight in schemes_name_and_weight.items():
+        scheme_code = schemes_df[schemes_df['schemeName'] == scheme_name]['schemeCode'].values[0]
+        scheme_nav_df, _ = get_mf_scheme_data(scheme_code= scheme_code)
+        scheme_nav_df = scheme_nav_df[(scheme_nav_df['date'] >= start_date) & (scheme_nav_df['date'] <= end_date)]
+        scheme_nav_df['nav'] = scheme_nav_df['nav'] * scheme_weight / 100
+        if portfolio_nav_df.empty:
+            portfolio_nav_df = scheme_nav_df
+        else:
+            portfolio_nav_df['nav'] += scheme_nav_df['nav']
+
+    return portfolio_nav_df
+
+
+def get_portfolio_xirr_returns(portfolio_df, start_date, end_date, SIP_date, lumpsum_amount, sip_amount):
+    return(get_investment_xirr(portfolio_df, start_date, end_date, SIP_date, lumpsum_amount, sip_amount))
+
+def get_portfolio_absolute_returns(portfolio_df, sip_amount, lumpsum_amount, stepup, start_date, end_date, SIP_date):
+
+    return (get_investment_sip_absolute_returns(portfolio_df, sip_amount, lumpsum_amount, stepup, start_date, end_date, SIP_date))
+
+def get_invdividual_scheme_returns(scheme_df, scheme_name,scheme_sip_amount, scheme_lumpsum_amount, stepup, start_date, end_date, SIP_date):
+    absolute_return, final_value, invested_value = get_investment_sip_absolute_returns(scheme_df, scheme_sip_amount, scheme_lumpsum_amount, stepup, start_date, end_date, SIP_date)
+    xirr = get_investment_xirr(scheme_df, start_date, end_date, SIP_date, scheme_lumpsum_amount, scheme_sip_amount)
+    scheme_string = f"""
+    Scheme: {scheme_name}
+    ------------------------------------
+    Investment: {invested_value}
+    Scheme Final Value: {final_value}
+    Absolute Return: {absolute_return}%
+    XIRR: {xirr}%\n
+    """
+    return (scheme_string)
+
+
+
+def calculate_portfolio_returns(scheme_name_and_weight, sip_amount, lumpsum_amount, stepup, start_date, end_date, SIP_date, schemes_df):
+    inception_dates = []
+    scheme_individual_returns = []
+    portfolio_df = get_portfolio_nav_df(scheme_name_and_weight, start_date, end_date,schemes_df)
+    portfolio_absolute_return, portfolio_final_value, portfolio_invested_value = get_portfolio_absolute_returns(portfolio_df, sip_amount, lumpsum_amount, stepup, start_date, end_date, SIP_date)
+    portfolio_return_string = f"""
+    Portfolio
+    ------------------------------------
+    SIP Amount: {sip_amount}
+    Lumpsum Amount: {lumpsum_amount}
+    Stepup: {stepup}
+    Start Date: {start_date}
+    End Date: {end_date}
+    SIP Date: {SIP_date}
+    Total Investment: {portfolio_invested_value}
+    ------------------------------------
+    Portfolio Returns
+    XIRR = {get_portfolio_xirr_returns(portfolio_df, start_date, end_date, SIP_date, lumpsum_amount, sip_amount)}%
+    Absolute Returns = {portfolio_absolute_return}%
+    Portfolio Final Value = {portfolio_final_value}
+    """
+
+    for scheme_name, scheme_weight in scheme_name_and_weight.items():
+        scheme_code = schemes_df[schemes_df['schemeName'] == scheme_name]['schemeCode'].values[0]
+        scheme_df, scheme_inception_date = get_mf_scheme_data(scheme_code)
+        inception_dates.append((scheme_name, scheme_inception_date))
+        scheme_sip_amount = sip_amount * scheme_weight / 100
+        scheme_lumpsum_amount = lumpsum_amount * scheme_weight / 100
+        scheme_individual_returns.append(get_invdividual_scheme_returns(scheme_df, scheme_name, scheme_sip_amount, scheme_lumpsum_amount, stepup, start_date, end_date, SIP_date))
+
+    return portfolio_return_string, inception_dates, scheme_individual_returns
+    
+
+
+    
+
+
+

returns.py

@@ -0,0 +1,71 @@
+from scipy import optimize
+from utils import get_monthly_sip_nav_df
+
+
+def calculate_xnpv(rate, cashflows):
+    chron_order = sorted(cashflows, key=lambda x: x[0])
+    t0 = chron_order[0][0]
+    return sum([cf/(1+rate)**((t-t0).days/365.0) for (t,cf) in chron_order])
+
+def calculate_xirr(cashflows, guess=0.1):
+    return optimize.newton(lambda r: calculate_xnpv(r,cashflows), guess)
+
+def get_investment_xirr(investment_df, start_date, end_date, SIP_date, lumpsum_amount=0, sip_amount=1000):
+    # Get the monthly NAVs
+    monthly_nav_df = get_monthly_sip_nav_df(investment_df, start_date, end_date, SIP_date)
+    
+    # Initialize lists to store cash flows and their corresponding dates
+    cash_flows = []
+    dates = []
+    
+    # Add the lumpsum investment at the start
+    cash_flows.append(-lumpsum_amount)
+    dates.append(start_date)
+    
+    # Calculate initial units from lumpsum investment
+    initial_units = lumpsum_amount / monthly_nav_df['nav'].iloc[0]
+    total_units = initial_units
+    
+    # Iterate over each row and record the SIP investments
+    for _, row in monthly_nav_df.iterrows():
+        cash_flows.append(-sip_amount)  # SIP investment is negative cash flow
+        dates.append(row['date'])
+        total_units += sip_amount / row['nav']
+    
+    # Add the final value as a positive cash flow
+    final_value = total_units * monthly_nav_df['nav'].iloc[-1]
+    cash_flows.append(final_value)
+    dates.append(monthly_nav_df['date'].iloc[-1])
+
+    portfolio_XIRR = calculate_xirr(list(zip(dates, cash_flows)))
+    
+    return portfolio_XIRR * 100
+
+def get_investment_sip_absolute_returns(investment_df, sip_amount, lumpsum_amount, stepup, start_date, end_date, SIP_Date):
+    # start_date = pd.Timestamp(start_date)
+    # end_date = pd.Timestamp(end_date)
+
+    scheme_df_monthly = get_monthly_sip_nav_df(investment_df, start_date, end_date, SIP_Date)
+
+    total_investment = lumpsum_amount
+    current_sip_amount = sip_amount
+
+    # do calculation for upfront investment
+    units_bought = lumpsum_amount / scheme_df_monthly.iloc[0]['nav']
+    units_accumulated = units_bought
+    previous_year = start_date.year
+
+    for _, row in scheme_df_monthly.iloc[:-1].iterrows():
+        # Check if a year has passed and increase SIP amount accordingly
+        if row['date'].year > previous_year:
+            current_sip_amount += current_sip_amount * (stepup / 100)
+            previous_year = row['date'].year
+
+        units_bought = current_sip_amount / row['nav']
+        units_accumulated += units_bought
+        total_investment += current_sip_amount
+
+    final_value = units_accumulated * scheme_df_monthly.iloc[-1]['nav']
+    total_return = (final_value - total_investment) / total_investment * 100
+
+    return total_return, final_value, total_investment

utils.py

@@ -0,0 +1,37 @@
+import pandas as pd
+import requests
+
+# This function groups the data by month
+# and returns the first, last or middle data of each month
+def get_monthly_sip_nav_df(df, start_date, end_date, SIP_date):
+    df = df.copy()
+    df['date'] = pd.to_datetime(df['date'])
+    df = df[(df['date'] >= start_date) & (df['date'] <= end_date)]
+    if SIP_date == 'start':
+        df = df.groupby([df['date'].dt.year, df['date'].dt.month]).first()
+    elif SIP_date == 'end':
+        df = df.groupby([df['date'].dt.year, df['date'].dt.month]).last()
+    else:
+        df = df.groupby([df['date'].dt.year, df['date'].dt.month]).apply(lambda x: x.iloc[len(x)//2])
+    return df
+
+
+# This function returns the complete list of mutual fund schemes in a DataFrame
+def get_all_mf_schemes_df():
+    url = "https://api.mfapi.in/mf"
+    response = requests.get(url)
+    schemes = response.json()
+    return pd.DataFrame(schemes)
+
+# This function returns the data of a particular mutual fund scheme, and its inception date
+def get_mf_scheme_data(scheme_code):
+    url = f"https://api.mfapi.in/mf/{scheme_code}"
+    response = requests.get(url)
+    data = response.json()
+    df = pd.DataFrame(data['data'])
+    df['date'] = pd.to_datetime(df['date'], format='%d-%m-%Y')
+    df['nav'] = df['nav'].astype(float)
+    df = df.sort_values('date')
+    inception_date = df['date'].min()
+    return df, inception_date
+