Upload 3 files

app.py

@@ -0,0 +1,82 @@
+import streamlit as st
+from io import StringIO
+import pandas as pd
+
+
+from returns_gen import returns_set
+#from plot_simulations import plot_sims,histogram
+from maximum_dd import max_dd
+import numpy as np
+st. set_page_config(page_title='Monte Carlo Simulator ',layout="centered")
+
+st.header('Monte Carlo Simulator for 10000 iterations')
+
+from matplotlib import pyplot as plt
+
+
+def plot_sims(sims_list):
+    global generated_plots
+
+    # sims_list=sims_list[:10]
+    fig, ax = plt.subplots()
+    for sl in sims_list:
+        ax.plot(sl)
+    number_of_sims=len(sims_list)
+    ax.set_title(f'Monte Carlo Paths of Nifty returns for {number_of_sims} simulations')
+    ax.set_ylabel('returns %')
+    ax.set_xlabel('count')
+    st.pyplot(fig)
+   
+def histogram(lis):
+    lis.sort()
+    print(min(lis),max(lis))
+    print(int(min(lis)),int(max(lis)))
+
+    bin_width=0.5
+    max_val=int(max(lis))+1
+    min_val=int(min(lis))-1
+    bins=[min_val+k*bin_width for k in range(int((max_val-min_val)/bin_width))]
+    fig,ax=plt.subplots()
+    ax.hist(lis,bins=bins,align='left')
+    #ax.xlim(max_val,min_val)
+    ax.axis(xmin=min_val,xmax=max_val)
+    ax.set_title('Drawdown from Monte Carlo iterations')
+    ax.set_ylabel('count')
+    ax.set_xlabel('Maxx DD %')
+    st.pyplot(fig)
+
+def clean_returns(ret_lis):
+    return [float(str(k).replace(',','').replace('%','').replace(' ','')) for k in returns_list]
+
+uploaded_file=st.file_uploader('DataFile', type=['csv'])
+if uploaded_file:
+    stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
+    df=pd.read_csv(stringio)
+   
+    df_cols=df.columns
+    
+    default_col=0
+    for i in range(len(df_cols)):
+        dcol=df_cols[i]
+        if 'return' in dcol.lower():
+            default_col=i
+            break
+    returns_column=st.selectbox('returns column', df_cols,index=default_col)
+  
+   
+    returns_list=df[returns_column].tolist()
+    returns_list=clean_returns(returns_list)
+
+
+    returns=returns_set(returns_list)
+
+
+    cum_rets_dd=[max_dd(k) for k in returns]
+    cum_rets=[k[0] for k in cum_rets_dd]
+    dd_list=[k[1] for k in cum_rets_dd]
+    percentile_95=np.percentile(dd_list,95)
+    st.write(f'95 percentile Max DD is {percentile_95} %')
+    plot_sims(cum_rets)
+    histogram(dd_list)
+
+    

maximum_dd.py

@@ -0,0 +1,26 @@
+"""
+given a list of returns, returns the maximum drawdown of the returns
+
+drawdown is calculated by taking the highest cumulative return so far, and calculating the difference of the current cumulative return from 
+the peak
+
+the minimum  of the drawdowns is max drawdown
+"""
+
+def max_dd(returns_list):
+    #returns are in the form of % ex: 1.5%, 2% etc. without the % sign
+    cumulative_returns=[]
+    drawdown=[]
+    cum_ret=0
+    for i in returns_list:
+        cum_ret=cum_ret+i
+        cumulative_returns.append(cum_ret)
+        dd=cum_ret-max(cumulative_returns)
+      
+        drawdown.append(dd)
+    return cumulative_returns,min(drawdown)
+
+if __name__=='__main__':
+    test_dd=max_dd([1.1,1.1,-2,-7,25,34,-4,-3,-3,-5,1.2,-6])
+    print(test_dd)
+    

returns_gen.py

@@ -0,0 +1,25 @@
+import random
+
+def dummy_returns(n=67):
+    #a return can vary between 100% and -100% i.e 2 and -1 
+    #we will generate a random number between -100 and 200 and divide by hundred to get the dummy %return
+    return [random.randint(-100,200)/100 for _ in range(n)]
+
+def randomise_returns(returns_list):
+    return random.sample(returns_list,len(returns_list))
+
+def returns_set(original_returns_list,n=10000):
+    collected_returns=[]
+    while len(collected_returns)<n:
+        new_list=randomise_returns(original_returns_list)
+        if new_list not in collected_returns:
+            collected_returns.append(new_list)
+    return collected_returns
+
+def dummy_sims():
+    return returns_set(dummy_returns())
+if __name__=='__main__':
+    dum_rets=dummy_returns()
+    paths=returns_set(dum_rets)
+    for p in paths:
+        print(p,sum(p))