Included summary based on annualised returns

app.py

@@ -2,23 +2,8 @@ import pandas as pd
 import numpy as np
 from itertools import combinations
 from scipy.optimize import minimize
-
 import numpy as np
-import itertools
-
-
-
-
-
-def filter_top_funds(df, asset_category, n):
-    category_df = df[(df["asset_category"] == asset_category) & df['morningstar_rating'].isin([4,5])].nlargest(n, "annualized_returns_3yr (%)")
-    return category_df
-
-# Function to check if a fund combination has at least two different asset categories
-def has_different_asset_categories(fund_combination):
-    asset_categories = set(fund["asset_category"] for fund in fund_combination)
-    return len(asset_categories) >= 3
-
+from itertools import combinations as itertools_combinations
 
 def complete_fund_data(fund_combinations):
     completed_fund_combinations = []
@@ -38,6 +23,47 @@ def complete_fund_data(fund_combinations):
     print (len(completed_fund_combinations))
     return completed_fund_combinations
 
+
+def has_different_asset_categories(constraints, fund_combination):
+    equity_target = constraints['equity']
+
+    def count_funds_by_category(category):
+        return sum(1 for fund in fund_combination if fund["asset_category"] == category)
+
+    if equity_target > 0.65:
+        num_equity = count_funds_by_category("Equity")
+        num_hybrid = count_funds_by_category("Hybrid")
+        return (
+            all(fund["asset_category"] != "Debt" for fund in fund_combination)
+            and num_hybrid >= 1
+            and num_equity < 3
+        )
+    elif 0.5 <= equity_target <= 0.65:
+        num_debt = count_funds_by_category("Debt")
+        num_equity = count_funds_by_category("Equity")
+        num_hybrid = count_funds_by_category("Hybrid")
+        return (
+            num_debt == 1
+            and num_equity == 2
+            and num_hybrid == 0
+        )
+    else:
+        num_debt = count_funds_by_category("Debt")
+        num_equity = count_funds_by_category("Equity")
+        num_hybrid = count_funds_by_category("Hybrid")
+        return (
+            num_debt == 2
+            and num_equity == 1
+            and num_hybrid == 0
+        )
+
+
+def filter_top_funds(df, asset_category, n):
+    category_df = df[(df["asset_category"] == asset_category) & df['morningstar_rating'].isin([4,5])].nlargest(n, "annualized_returns_3yr (%)")
+    return category_df
+
+
+
 def find_closest_weights(combination, constraints):
     min_difference = float('inf')
     best_weights = None
@@ -67,9 +93,7 @@ def end_goal_achieved(yearly_amount, annualized_returns, years):
     return yearly_amount * (((1 + annualized_returns)**years - 1) / annualized_returns)
 
 
-
-
-
+    
 def calcualte_combined_combo_funds(constraints_cash, constraints_debt, constraints_equity, constraints_others, end_goal, years):
     
     stepwise = int(end_goal/1000)
@@ -86,6 +110,9 @@ def calcualte_combined_combo_funds(constraints_cash, constraints_debt, constrain
     fund_data_list = []
     unique_fund_ids = top_funds["id"].unique()
 
+    fund_data_list = []
+    unique_fund_ids = top_funds["id"].unique()
+
     for fund_id in unique_fund_ids:
         fund_data = {"fund_id": fund_id, "cash": 0, "debt": 0, "equity": 0, "others": 0}
         fund_rows = df[df["id"] == fund_id]
@@ -97,11 +124,10 @@ def calcualte_combined_combo_funds(constraints_cash, constraints_debt, constrain
 
         fund_data_list.append(fund_data)
 
-
-
-    fund_combinations = list(filter(has_different_asset_categories, combinations(fund_data_list, 3)))
+    fund_combinations = list(filter(lambda x: has_different_asset_categories(constraints, x), combinations(fund_data_list, 3)))
 
     completed_fund_combinations = complete_fund_data(fund_combinations)
+    
 
     fund_combinations_with_weight_and_difference = []
 
@@ -121,9 +147,6 @@ def calcualte_combined_combo_funds(constraints_cash, constraints_debt, constrain
     fund_combinations_with_weight_and_difference.sort(key=lambda x: x[1])
 
 
-
-
-
     fund_combinations_with_goal = []
 
     for fund_combination, difference in fund_combinations_with_weight_and_difference:
@@ -184,36 +207,69 @@ def calcualte_combined_combo_funds(constraints_cash, constraints_debt, constrain
         combined_fund_combinations_updated.append(updated_fund_info)
 
     combined_fund_combinations_updated_df = pd.DataFrame(combined_fund_combinations_updated)
-    # Create a mapping of fund ids to fund names
+
+    # Create a mapping of fund ids to fund names and annualized_returns_3yr
     fund_id_to_name = df.set_index("id")["name"].to_dict()
+    fund_id_to_annualized_returns_3yr = df.set_index("id")["annualized_returns_3yr (%)"].to_dict()
 
-    # Map fund ids to fund names in combined_fund_combinations_updated
+    # Map fund ids to fund names and annualized_returns_3yr in combined_fund_combinations_updated
     for fund_combination_info in combined_fund_combinations_updated:
         fund_combination = fund_combination_info["fund_combination"]
         for i, fund in enumerate(fund_combination):
             fund_name_key = f"fund_{i+1}_name"
+            fund_returns_key = f"fund_{i+1}_annualized_returns_3yr"
             fund_id = fund["fund_id"]
             fund_combination_info[fund_name_key] = fund_id_to_name[fund_id]
+            fund_combination_info[fund_returns_key] = fund_id_to_annualized_returns_3yr[fund_id]
 
-    # Create a new DataFrame with the updated fund combination info
-    combined_fund_combinations_updated_df = pd.DataFrame(combined_fund_combinations_updated)
-    # print(combined_fund_combinations_updated_df)
+    # Add the new columns to the DataFrame
+    combined_fund_combinations_updated_df['fund_1_annualized_returns_3yr'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[0]['annualized_returns_3yr'])
+    combined_fund_combinations_updated_df['fund_2_annualized_returns_3yr'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[1]['annualized_returns_3yr'])
+    combined_fund_combinations_updated_df['fund_3_annualized_returns_3yr'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[2]['annualized_returns_3yr'])
 
-    combined_fund_combinations_updated_df = pd.DataFrame(combined_fund_combinations_updated)
+    fund_id_to_name = dict(zip(df_no_dup['id'], df_no_dup['name']))
+
+    
+    # Sort the DataFrame based on the sum of annualized_returns_3yr for each fund combination and constraints deviation
+    combined_fund_combinations_updated_df['total_annualized_returns_3yr'] = combined_fund_combinations_updated_df['fund_1_annualized_returns_3yr'] + combined_fund_combinations_updated_df['fund_2_annualized_returns_3yr'] + combined_fund_combinations_updated_df['fund_3_annualized_returns_3yr']
+
+    combined_fund_combinations_updated_df['fund_combination'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: add_fund_name(x, fund_id_to_name))
+
+    # Sort by both annualized returns and constraints deviation
+    sorted_df = combined_fund_combinations_updated_df.sort_values(by=['total_annualized_returns_3yr', 'min_deviation_goal'], ascending=[False, True])
+    
+    
+     #Select the top 10 rows
+    top_30_rows_annual_return_sorted = sorted_df[sorted_df['difference']<0.1].head(10)[['difference', 'achieved_end_goal', 'overall_constraints', 'weight_1', 'weight_2', 'weight_3', 'min_deviation_goal']]
+    for i in range(1, 4):
+        top_30_rows_annual_return_sorted[f'fund_{i}_name'] = sorted_df[sorted_df['difference']<0.2]['fund_combination'].apply(lambda x: x[i-1]['name'])
+        top_30_rows_annual_return_sorted[f'invested_yearly_fund{i}'] = sorted_df[sorted_df['difference']<0.2]['fund_combination'].apply(lambda x: x[i-1]['invested_yearly'])
+        top_30_rows_annual_return_sorted[f'fund_{i}_annualized_returns_3yr'] = sorted_df[sorted_df['difference']<0.2]['fund_combination'].apply(lambda x: x[i-1]['annualized_returns_3yr'])
+
+    # Create the output string
+    output_str_annual_return_sorted = ""
+    for index, row in top_30_rows_annual_return_sorted.iterrows():
+        rounded_constraints = {key: round(value, 2) for key, value in row['overall_constraints'].items()}
+        output_str_annual_return_sorted += f"The funds to be invested are {row['weight_1'] * 100:.2f}% in '{row['fund_1_name']}', {row['weight_2'] * 100:.2f}% in '{row['fund_2_name']}', {row['weight_3'] * 100:.2f}% in '{row['fund_3_name']}'.\n"
+        output_str_annual_return_sorted += f"The constraints found closest to given constraints are {rounded_constraints}.\n"
+        output_str_annual_return_sorted += f"Amount to be invested is {row['invested_yearly_fund1']:.2f}, {row['invested_yearly_fund2']:.2f}, {row['invested_yearly_fund3']:.2f} and details are min_deviation_goal: {row['min_deviation_goal']:.2f}, achieved_end_goal: {row['achieved_end_goal']:.2f}, difference: {row['difference']:.2f}.\n\n"
 
-    combined_fund_combinations_updated_df.columns  = ['fund_combination', 'min_deviation_goal (in Rupees)', 'achieved_end_goal',
-           'difference', 'overall_constraints', 'weight_1', 'weight_2', 'weight_3',
-           'fund_1_name', 'fund_2_name', 'fund_3_name']
 
+    combined_fund_combinations_updated_df['fund_1_name'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[0]['name'])
+    combined_fund_combinations_updated_df['fund_2_name'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[1]['name'])
+    combined_fund_combinations_updated_df['fund_3_name'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[2]['name'])
 
-    # Extracting invested_yearly values into separate columns
     combined_fund_combinations_updated_df['invested_yearly_fund1'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[0]['invested_yearly'])
     combined_fund_combinations_updated_df['invested_yearly_fund2'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[1]['invested_yearly'])
     combined_fund_combinations_updated_df['invested_yearly_fund3'] = combined_fund_combinations_updated_df['fund_combination'].apply(lambda x: x[2]['invested_yearly'])
 
+    combined_fund_combinations_updated_df = combined_fund_combinations_updated_df.sort_values(by=['difference'],ascending=[True])
+    # Extract the required columns in top_10_rows
+    top_10_rows = combined_fund_combinations_updated_df.head(10)[['min_deviation_goal', 'achieved_end_goal', 'difference', 'overall_constraints', 'weight_1', 'weight_2', 'weight_3', 'fund_1_name', 'fund_2_name', 'fund_3_name', 'invested_yearly_fund1', 'invested_yearly_fund2', 'invested_yearly_fund3', 'fund_1_annualized_returns_3yr', 'fund_2_annualized_returns_3yr', 'fund_3_annualized_returns_3yr']]
+
 
     # Use the function with your DataFrame:
-    top_10_rows = combined_fund_combinations_updated_df.head(10)[['min_deviation_goal (in Rupees)',
+    top_10_rows = combined_fund_combinations_updated_df.head(25)[['min_deviation_goal',
            'achieved_end_goal', 'difference', 'overall_constraints', 'weight_1',
            'weight_2', 'weight_3', 'fund_1_name', 'fund_2_name', 'fund_3_name',
            'invested_yearly_fund1', 'invested_yearly_fund2',
@@ -226,31 +282,42 @@ def calcualte_combined_combo_funds(constraints_cash, constraints_debt, constrain
         rounded_constraints = {key: round(value, 2) for key, value in row['overall_constraints'].items()}
         output_str += f"The funds to be invested are {row['weight_1'] * 100:.2f}% in '{row['fund_1_name']}', {row['weight_2'] * 100:.2f}% in '{row['fund_2_name']}', {row['weight_3'] * 100:.2f}% in '{row['fund_3_name']}'.\n"
         output_str += f"The constraints found closest to given constraints are {rounded_constraints}.\n"
-        output_str += f"Amount to be invested is {row['invested_yearly_fund1']:.2f}, {row['invested_yearly_fund2']:.2f}, {row['invested_yearly_fund3']:.2f} and details are min_deviation_goal: {row['min_deviation_goal (in Rupees)']:.2f}, achieved_end_goal: {row['achieved_end_goal']:.2f}, difference: {row['difference']:.2f}.\n\n"
+        output_str += f"Amount to be invested is {row['invested_yearly_fund1']:.2f}, {row['invested_yearly_fund2']:.2f}, {row['invested_yearly_fund3']:.2f} and details are min_deviation_goal: {row['min_deviation_goal']:.2f}, achieved_end_goal: {row['achieved_end_goal']:.2f}, difference: {row['difference']:.2f}.\n\n"
 
 
-    return(output_str)
+    return(output_str,output_str_annual_return_sorted)
 
 
 import gradio as gr
 
-# Your code starts here
+import pandas as pd
+from itertools import combinations
+
+
+
+constraints = {
+        'cash': 0.03,
+        'debt': 0.3,
+        'equity': 0.67,
+        'others': 0.01,
+    }
 
 filename = 'funds_growth.csv'
 df = pd.read_csv(filename)
 
 df_no_dup = df.drop_duplicates(subset=['id'], keep='first')
 
+hybrid_check = df[(df['asset_category']=='Hybrid') & (df['holding_type']=='equity')]
+hybrid_check_filter = hybrid_check[hybrid_check['weightage']>65]
 
-top_hybrid = filter_top_funds(df_no_dup, "Hybrid", 30)
+
+top_hybrid_raw = filter_top_funds(df_no_dup, "Hybrid",100)
+top_hybrid = top_hybrid_raw[top_hybrid_raw['id'].isin(hybrid_check_filter.id)]
 top_equity = filter_top_funds(df_no_dup, "Equity", 75)
-top_debt = filter_top_funds(df_no_dup, "Debt", 75)
+top_debt = filter_top_funds(df_no_dup, "Debt", 50)
 
 top_funds = pd.concat([top_hybrid, top_equity, top_debt]).drop_duplicates(subset=['id'], keep='first')
 
-
-
-
 inputs = [
     gr.Slider(0.01, 0.97, value=0.05, label="Constraints Cash (%)"),
     gr.Slider(0.01, 0.97, value=0.3, label="Constraints Debt (%)"),
@@ -262,6 +329,11 @@ inputs = [
 
 output = gr.outputs.Textbox(label="Information Desk",)
 
+output = [
+    gr.outputs.Textbox(label="Summary (sorted on closest constraint)"),
+    gr.outputs.Textbox(label="Summary (sorted on 3yr returns)"),
+]
+
 section4_title = "Reverse Asset Allocation"
 section4_desc = "</b></h3> You tell us how much is your risk appetite, we will tell you whats the best 3 fund combo \n </b></h3> "
 
@@ -270,4 +342,3 @@ gr.Interface(fn=calcualte_combined_combo_funds, inputs=inputs, outputs=output,
 ).launch()
 
 
-