Multichem commited on
Commit
c9cda4a
·
1 Parent(s): 7451b99

Update app.py

Browse files
Files changed (1) hide show
  1. app.py +498 -523
app.py CHANGED
@@ -873,7 +873,7 @@ with tab2:
873
  Contest_Size = 5000
874
  elif contest_var1 == 'Large':
875
  Contest_Size = 10000
876
- linenum_var1 = 1000
877
  strength_var1 = st.selectbox("How sharp is the field in the contest?", ('Not Very', 'Average', 'Very'))
878
  if strength_var1 == 'Not Very':
879
  sharp_split = .33
@@ -887,544 +887,519 @@ with tab2:
887
  sharp_split = .75
888
  Strength_var = .01
889
  scaling_var = 15
890
- sim_done = 0
891
- seed_depth1 = 10
892
- Total_Runs = 1000000
893
- if Contest_Size <= 1000:
894
- strength_grow = .01
895
- elif Contest_Size > 1000 and Contest_Size <= 2500:
896
- strength_grow = .025
897
- elif Contest_Size > 2500 and Contest_Size <= 5000:
898
- strength_grow = .05
899
- elif Contest_Size > 5000 and Contest_Size <= 20000:
900
- strength_grow = .075
901
- elif Contest_Size > 20000:
902
- strength_grow = .1
903
-
904
- field_growth = 100 * strength_grow
905
-
906
- Sort_function = 'Median'
907
- if Sort_function == 'Median':
908
- Sim_function = 'Projection'
909
- elif Sort_function == 'Own':
910
- Sim_function = 'Own'
911
- Sim_Winner_Frame = pd.DataFrame()
912
- player_freq = pd.DataFrame()
913
- Sim_Winner_Export = pd.DataFrame()
914
- qb_freq = pd.DataFrame()
915
- rb_freq = pd.DataFrame()
916
- wr_freq = pd.DataFrame()
917
- te_freq = pd.DataFrame()
918
- flex_freq = pd.DataFrame()
919
- dst_freq = pd.DataFrame()
920
 
921
  with col2:
922
- player_split_var2 = st.radio("Are you wanting to isolate any lineups with specific players?", ('Full Players', 'Specific Players'))
923
- if player_split_var2 == 'Specific Players':
924
- find_var2 = st.multiselect('Which players must be included in the lineups?', options = player_freq['Player'].unique())
925
- elif player_split_var2 == 'Full Players':
926
- find_var2 = static_exposure.Player.values.tolist()
927
- if player_split_var2 == 'Specific Players':
928
- Sim_Winner_Frame = Sim_Winner_Frame[np.equal.outer(Sim_Winner_Frame.to_numpy(copy=False), find_var2).any(axis=1).all(axis=1)]
929
- elif player_split_var2 == 'Full Players':
930
- Sim_Winner_Frame = Sim_Winner_Frame
931
-
932
- with st.container():
933
- display_winner_dataframe = Sim_Winner_Frame.copy()
934
- st.dataframe(display_winner_dataframe.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Own']).format(precision=2), use_container_width = True)
935
-
936
- st.download_button(
937
- label="Export Tables",
938
- data=convert_df_to_csv(Sim_Winner_Export),
939
- file_name='NFL_consim_export.csv',
940
- mime='text/csv',
941
- )
942
-
943
- with st.container():
944
- freq_container = st.empty()
945
- tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs(['Overall Exposures', 'QB Exposures', 'RB Exposures', 'WR Exposures', 'TE Exposures', 'FLEX Exposures', 'DST Exposures'])
946
- with tab1:
947
- st.dataframe(player_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
948
- st.download_button(
949
- label="Export Exposures",
950
- data=convert_df_to_csv(player_freq),
951
- file_name='player_freq_export.csv',
952
- mime='text/csv',
953
- )
954
- with tab2:
955
- st.dataframe(qb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
956
- st.download_button(
957
- label="Export Exposures",
958
- data=convert_df_to_csv(qb_freq),
959
- file_name='qb_freq_export.csv',
960
- mime='text/csv',
961
- )
962
- with tab3:
963
- st.dataframe(rb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
964
- st.download_button(
965
- label="Export Exposures",
966
- data=convert_df_to_csv(rb_freq),
967
- file_name='rb_freq_export.csv',
968
- mime='text/csv',
969
- )
970
- with tab4:
971
- st.dataframe(wr_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
972
- st.download_button(
973
- label="Export Exposures",
974
- data=convert_df_to_csv(wr_freq),
975
- file_name='wr_freq_export.csv',
976
- mime='text/csv',
977
- )
978
- with tab5:
979
- st.dataframe(te_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
980
- st.download_button(
981
- label="Export Exposures",
982
- data=convert_df_to_csv(te_freq),
983
- file_name='te_freq_export.csv',
984
- mime='text/csv',
985
- )
986
- with tab6:
987
- st.dataframe(flex_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
988
- st.download_button(
989
- label="Export Exposures",
990
- data=convert_df_to_csv(flex_freq),
991
- file_name='flex_freq_export.csv',
992
- mime='text/csv',
993
- )
994
- with tab7:
995
- st.dataframe(dst_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
996
- st.download_button(
997
- label="Export Exposures",
998
- data=convert_df_to_csv(dst_freq),
999
- file_name='dst_freq_export.csv',
1000
- mime='text/csv',
1001
- )
1002
-
1003
  if st.button("Simulate Contest"):
 
 
 
 
 
 
 
 
 
 
 
 
1004
  with st.container():
1005
- sim_done = 0
1006
- try:
1007
- del dst_freq
1008
- del flex_freq
1009
- del te_freq
1010
- del wr_freq
1011
- del rb_freq
1012
- del qb_freq
1013
- del player_freq
1014
- del Sim_Winner_Export
1015
- del Sim_Winner_Frame
1016
- except:
1017
- pass
1018
- with st.container():
1019
- st.write('Contest Simulation Starting')
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1020
 
1021
- if slate_var1 == 'User':
1022
- OwnFrame = proj_dataframe
1023
- if contest_var1 == 'Small':
1024
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (10 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
1025
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
1026
- OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
1027
- OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
1028
- if contest_var1 == 'Medium':
1029
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (6 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
1030
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
1031
- OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
1032
- OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
1033
- if contest_var1 == 'Large':
1034
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
1035
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (1.5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
1036
- OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
1037
- OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
1038
- Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1039
 
1040
- del OwnFrame
 
 
1041
 
1042
- elif slate_var1 != 'User':
1043
- initial_proj = raw_baselines
1044
- drop_frame = initial_proj.drop_duplicates(subset = 'Player',keep = 'first')
1045
- OwnFrame = drop_frame[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
1046
- if contest_var1 == 'Small':
1047
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (10 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
1048
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
1049
- OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
1050
- OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
1051
- if contest_var1 == 'Medium':
1052
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (6 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
1053
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
1054
- OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
1055
- OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
1056
- if contest_var1 == 'Large':
1057
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
1058
- OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (1.5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
1059
- OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
1060
- OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
1061
- Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
1062
 
1063
- del initial_proj
1064
- del drop_frame
1065
- del OwnFrame
 
 
 
 
 
 
 
 
1066
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1067
  if insert_port == 1:
1068
- UserPortfolio = portfolio_dataframe[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
1069
  elif insert_port == 0:
1070
- UserPortfolio = pd.DataFrame(columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
1071
-
1072
- Overall_Proj.replace('', np.nan, inplace=True)
1073
- Overall_Proj = Overall_Proj.dropna(subset=['Median'])
1074
- Overall_Proj = Overall_Proj.assign(Value=lambda x: (x.Median / (x.Salary / 1000)))
1075
- Overall_Proj['Sort_var'] = (Overall_Proj['Median'].rank(ascending=False) + Overall_Proj['Value'].rank(ascending=False)) / 2
1076
- Overall_Proj = Overall_Proj.sort_values(by='Sort_var', ascending=False)
1077
- Overall_Proj['Own'] = np.where((Overall_Proj['Median'] > 0) & (Overall_Proj['Own'] == 0), 1, Overall_Proj['Own'])
1078
- Overall_Proj = Overall_Proj.loc[Overall_Proj['Own'] > 0]
1079
-
1080
- Overall_Proj['Floor'] = np.where(Overall_Proj['Position'] == 'QB', Overall_Proj['Median'] * .5, Overall_Proj['Median'] * .25)
1081
- Overall_Proj['Ceiling'] = np.where(Overall_Proj['Position'] == 'WR', Overall_Proj['Median'] + Overall_Proj['Median'], Overall_Proj['Median'] + Overall_Proj['Floor'])
1082
- Overall_Proj['STDev'] = Overall_Proj['Median'] / 4
1083
-
1084
- Teams_used = Overall_Proj['Team'].drop_duplicates().reset_index(drop=True)
1085
- Teams_used = Teams_used.reset_index()
1086
- Teams_used['team_item'] = Teams_used['index'] + 1
1087
- Teams_used = Teams_used.drop(columns=['index'])
1088
- Teams_used_dictraw = Teams_used.drop(columns=['team_item'])
1089
- Teams_used_dict = Teams_used_dictraw.to_dict()
1090
-
1091
- del Teams_used_dictraw
1092
-
1093
- team_list = Teams_used['Team'].to_list()
1094
- item_list = Teams_used['team_item'].to_list()
1095
-
1096
- FieldStrength_raw = Strength_var + ((30 - len(Teams_used)) * .01)
1097
- FieldStrength = FieldStrength_raw - (FieldStrength_raw * (20000 / Contest_Size))
1098
-
1099
- del FieldStrength_raw
1100
-
1101
- if FieldStrength < 0:
1102
- FieldStrength = Strength_var
1103
- field_split = Strength_var
1104
-
1105
- for checkVar in range(len(team_list)):
1106
- Overall_Proj['Team'] = Overall_Proj['Team'].replace(team_list, item_list)
1107
-
1108
- qbs_raw = Overall_Proj[Overall_Proj.Position == 'QB']
1109
- qbs_raw.dropna(subset=['Median']).reset_index(drop=True)
1110
- qbs_raw = qbs_raw.reset_index(drop=True)
1111
- qbs_raw = qbs_raw.sort_values(by=['Median'], ascending=False)
1112
-
1113
- qbs = qbs_raw.head(round(len(qbs_raw)))
1114
- qbs = qbs.assign(Var = range(0,len(qbs)))
1115
- qb_dict = pd.Series(qbs.Player.values, index=qbs.Var).to_dict()
1116
-
1117
- defs_raw = Overall_Proj[Overall_Proj.Position.str.contains("D")]
1118
- defs_raw.dropna(subset=['Median']).reset_index(drop=True)
1119
- defs_raw = defs_raw.reset_index(drop=True)
1120
- defs_raw = defs_raw.sort_values(by=['Own', 'Value'], ascending=False)
1121
-
1122
- defs = defs_raw.head(round(len(defs_raw)))
1123
- defs = defs.assign(Var = range(0,len(defs)))
1124
- def_dict = pd.Series(defs.Player.values, index=defs.Var).to_dict()
1125
-
1126
- rbs_raw = Overall_Proj[Overall_Proj.Position == 'RB']
1127
- rbs_raw.dropna(subset=['Median']).reset_index(drop=True)
1128
- rbs_raw = rbs_raw.reset_index(drop=True)
1129
- rbs_raw = rbs_raw.sort_values(by=['Own', 'Value'], ascending=False)
1130
-
1131
- wrs_raw = Overall_Proj[Overall_Proj.Position == 'WR']
1132
- wrs_raw.dropna(subset=['Median']).reset_index(drop=True)
1133
- wrs_raw = wrs_raw.reset_index(drop=True)
1134
- wrs_raw = wrs_raw.sort_values(by=['Own', 'Median'], ascending=False)
1135
-
1136
- tes_raw = Overall_Proj[Overall_Proj.Position == 'TE']
1137
- tes_raw.dropna(subset=['Median']).reset_index(drop=True)
1138
- tes_raw = tes_raw.reset_index(drop=True)
1139
- tes_raw = tes_raw.sort_values(by=['Own', 'Value'], ascending=False)
1140
-
1141
- pos_players = pd.concat([rbs_raw, wrs_raw, tes_raw])
1142
- pos_players.dropna(subset=['Median']).reset_index(drop=True)
1143
- pos_players = pos_players.reset_index(drop=True)
1144
-
1145
- del qbs_raw
1146
- del defs_raw
1147
- del rbs_raw
1148
- del wrs_raw
1149
- del tes_raw
1150
-
1151
- if insert_port == 1:
1152
- try:
1153
- # Initialize an empty DataFrame for Raw Portfolio
1154
- Raw_Portfolio = pd.DataFrame()
1155
-
1156
- # Loop through each position and split the data accordingly
1157
- positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
1158
- for pos in positions:
1159
- temp_df = UserPortfolio[pos].str.split("(", n=1, expand=True)
1160
- temp_df.columns = [pos, 'Drop']
1161
- Raw_Portfolio = pd.concat([Raw_Portfolio, temp_df], axis=1)
1162
-
1163
- # Select only necessary columns and strip white spaces
1164
- CleanPortfolio = Raw_Portfolio[positions].apply(lambda x: x.str.strip())
1165
- CleanPortfolio.reset_index(inplace=True)
1166
- CleanPortfolio['User/Field'] = CleanPortfolio['index'] + 1
1167
- CleanPortfolio.drop(columns=['index'], inplace=True)
1168
-
1169
- CleanPortfolio.replace('', np.nan, inplace=True)
1170
- CleanPortfolio.dropna(subset=['QB'], inplace=True)
1171
-
1172
- # Create frequency table for players
1173
- cleaport_players = pd.DataFrame(
1174
- np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:9].values, return_counts=True)),
1175
- columns=['Player', 'Freq']
1176
- ).sort_values('Freq', ascending=False).reset_index(drop=True)
1177
- cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
1178
-
1179
- # Merge and update nerf_frame
1180
- nerf_frame = pd.merge(cleaport_players, Overall_Proj, on='Player', how='left')
1181
- for col in ['Median', 'Floor', 'Ceiling', 'STDev']:
1182
- nerf_frame[col] *= 0.90
1183
- del Raw_Portfolio
1184
- except:
1185
- CleanPortfolio = UserPortfolio.reset_index()
1186
- CleanPortfolio['User/Field'] = CleanPortfolio['index'] + 1
1187
- CleanPortfolio.drop(columns=['index'], inplace=True)
1188
-
1189
- # Replace empty strings and drop rows with NaN in 'QB' column
1190
- CleanPortfolio.replace('', np.nan, inplace=True)
1191
- CleanPortfolio.dropna(subset=['QB'], inplace=True)
1192
-
1193
- # Create frequency table for players
1194
- cleaport_players = pd.DataFrame(
1195
- np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:9].values, return_counts=True)),
1196
- columns=['Player', 'Freq']
1197
- ).sort_values('Freq', ascending=False).reset_index(drop=True)
1198
- cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
1199
-
1200
- # Merge and update nerf_frame
1201
- nerf_frame = pd.merge(cleaport_players, Overall_Proj, on='Player', how='left')
1202
- for col in ['Median', 'Floor', 'Ceiling', 'STDev']:
1203
- nerf_frame[col] *= 0.90
1204
-
1205
- elif insert_port == 0:
1206
- CleanPortfolio = UserPortfolio
1207
- cleaport_players = pd.DataFrame(np.column_stack(np.unique(CleanPortfolio.iloc[:,0:9].values, return_counts=True)),
1208
- columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1209
- cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
1210
- nerf_frame = Overall_Proj
1211
 
1212
- ref_dict = {
1213
- 'pos':['RB', 'WR', 'TE', 'FLEX'],
1214
- 'pos_dfs':['RB_Table', 'WR_Table', 'TE_Table', 'FLEX_Table'],
1215
- 'pos_dicts':['rb_dict', 'wr_dict', 'te_dict', 'flex_dict']
1216
- }
 
 
1217
 
1218
- maps_dict = {
1219
- 'Floor_map':dict(zip(Overall_Proj.Player,Overall_Proj.Floor)),
1220
- 'Projection_map':dict(zip(Overall_Proj.Player,Overall_Proj.Median)),
1221
- 'Ceiling_map':dict(zip(Overall_Proj.Player,Overall_Proj.Ceiling)),
1222
- 'Salary_map':dict(zip(Overall_Proj.Player,Overall_Proj.Salary)),
1223
- 'Pos_map':dict(zip(Overall_Proj.Player,Overall_Proj.Position)),
1224
- 'Own_map':dict(zip(Overall_Proj.Player,Overall_Proj.Own)),
1225
- 'Team_map':dict(zip(Overall_Proj.Player,Overall_Proj.Team)),
1226
- 'STDev_map':dict(zip(Overall_Proj.Player,Overall_Proj.STDev)),
1227
- 'team_check_map':dict(zip(Overall_Proj.Player,Overall_Proj.Team))
1228
- }
1229
-
1230
- up_dict = {
1231
- 'Floor_map':dict(zip(cleaport_players.Player,nerf_frame.Floor)),
1232
- 'Projection_map':dict(zip(cleaport_players.Player,nerf_frame.Median)),
1233
- 'Ceiling_map':dict(zip(cleaport_players.Player,nerf_frame.Ceiling)),
1234
- 'Salary_map':dict(zip(cleaport_players.Player,nerf_frame.Salary)),
1235
- 'Pos_map':dict(zip(cleaport_players.Player,nerf_frame.Position)),
1236
- 'Own_map':dict(zip(cleaport_players.Player,nerf_frame.Own)),
1237
- 'Team_map':dict(zip(cleaport_players.Player,nerf_frame.Team)),
1238
- 'STDev_map':dict(zip(cleaport_players.Player,nerf_frame.STDev)),
1239
- 'team_check_map':dict(zip(cleaport_players.Player,nerf_frame.Team))
1240
- }
1241
-
1242
- del cleaport_players
1243
- del Overall_Proj
1244
- del nerf_frame
1245
-
1246
- st.write('Seed frame creation')
1247
- FinalPortfolio, maps_dict = run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_Runs)
1248
-
1249
- Sim_size = linenum_var1
1250
- SimVar = 1
1251
- Sim_Winners = []
1252
- fp_array = FinalPortfolio.values
1253
-
1254
  if insert_port == 1:
1255
- up_array = CleanPortfolio.values
1256
-
1257
- # Pre-vectorize functions
1258
- vec_projection_map = np.vectorize(maps_dict['Projection_map'].__getitem__)
1259
- vec_stdev_map = np.vectorize(maps_dict['STDev_map'].__getitem__)
1260
-
1261
- if insert_port == 1:
1262
- vec_up_projection_map = np.vectorize(up_dict['Projection_map'].__getitem__)
1263
- vec_up_stdev_map = np.vectorize(up_dict['STDev_map'].__getitem__)
1264
-
1265
- st.write('Simulating contest on frames')
1266
-
1267
- while SimVar <= Sim_size:
1268
- if insert_port == 1:
1269
- fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size-len(CleanPortfolio))]
1270
- elif insert_port == 0:
1271
- fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size)]
1272
-
1273
- sample_arrays1 = np.c_[
1274
- fp_random,
1275
  np.sum(np.random.normal(
1276
- loc=vec_projection_map(fp_random[:, :-5]),
1277
- scale=vec_stdev_map(fp_random[:, :-5])),
1278
  axis=1)
1279
  ]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1280
 
1281
- if insert_port == 1:
1282
- sample_arrays2 = np.c_[
1283
- up_array,
1284
- np.sum(np.random.normal(
1285
- loc=vec_up_projection_map(up_array[:, :-5]),
1286
- scale=vec_up_stdev_map(up_array[:, :-5])),
1287
- axis=1)
1288
- ]
1289
- sample_arrays = np.vstack((sample_arrays1, sample_arrays2))
1290
- else:
1291
- sample_arrays = sample_arrays1
1292
 
1293
- final_array = sample_arrays[sample_arrays[:, 10].argsort()[::-1]]
1294
- best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
1295
- Sim_Winners.append(best_lineup)
1296
- SimVar += 1
1297
-
1298
-
1299
- # del smple_arrays
1300
- # del smple_arrays1
1301
- # del smple_arrays2
1302
- # del final_array
1303
- # del best_lineup
1304
- st.write('Contest simulation complete')
1305
- # Initial setup
1306
- Sim_Winner_Frame = pd.DataFrame(np.concatenate(Sim_Winners), columns=FinalPortfolio.columns.tolist() + ['Fantasy'])
1307
- Sim_Winner_Frame['GPP_Proj'] = (Sim_Winner_Frame['Projection'] + Sim_Winner_Frame['Fantasy']) / 2
1308
-
1309
- # Type Casting
1310
- type_cast_dict = {'Salary': int, 'Projection': np.float16, 'Fantasy': np.float16, 'GPP_Proj': np.float16}
1311
- Sim_Winner_Frame = Sim_Winner_Frame.astype(type_cast_dict)
1312
-
1313
- # Sorting
1314
- Sim_Winner_Frame = Sim_Winner_Frame.sort_values(by='GPP_Proj', ascending=False)
1315
-
1316
- # Data Copying
1317
- Sim_Winner_Export = Sim_Winner_Frame.copy()
1318
-
1319
- sim_done = 1
1320
-
1321
- # Conditional Replacement
1322
- columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
1323
-
1324
- if site_var1 == 'Draftkings':
1325
- replace_dict = dkid_dict
1326
- elif site_var1 == 'Fanduel':
1327
- replace_dict = fdid_dict
1328
-
1329
- for col in columns_to_replace:
1330
- Sim_Winner_Export[col].replace(replace_dict, inplace=True)
1331
-
1332
-
1333
- player_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:9].values, return_counts=True)),
1334
- columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1335
- player_freq['Freq'] = player_freq['Freq'].astype(int)
1336
- player_freq['Position'] = player_freq['Player'].map(maps_dict['Pos_map'])
1337
- player_freq['Salary'] = player_freq['Player'].map(maps_dict['Salary_map'])
1338
- player_freq['Proj Own'] = player_freq['Player'].map(maps_dict['Own_map']) / 100
1339
- player_freq['Exposure'] = player_freq['Freq']/(Sim_size)
1340
- player_freq['Edge'] = player_freq['Exposure'] - player_freq['Proj Own']
1341
- player_freq['Team'] = player_freq['Player'].map(maps_dict['Team_map'])
1342
- for checkVar in range(len(team_list)):
1343
- player_freq['Team'] = player_freq['Team'].replace(item_list, team_list)
1344
-
1345
- player_freq = player_freq[['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1346
-
1347
- qb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:1].values, return_counts=True)),
1348
- columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1349
- qb_freq['Freq'] = qb_freq['Freq'].astype(int)
1350
- qb_freq['Position'] = qb_freq['Player'].map(maps_dict['Pos_map'])
1351
- qb_freq['Salary'] = qb_freq['Player'].map(maps_dict['Salary_map'])
1352
- qb_freq['Proj Own'] = qb_freq['Player'].map(maps_dict['Own_map']) / 100
1353
- qb_freq['Exposure'] = qb_freq['Freq']/(Sim_size)
1354
- qb_freq['Edge'] = qb_freq['Exposure'] - qb_freq['Proj Own']
1355
- qb_freq['Team'] = qb_freq['Player'].map(maps_dict['Team_map'])
1356
- for checkVar in range(len(team_list)):
1357
- qb_freq['Team'] = qb_freq['Team'].replace(item_list, team_list)
1358
-
1359
- qb_freq = qb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1360
-
1361
- rb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[1, 2]].values, return_counts=True)),
1362
- columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1363
- rb_freq['Freq'] = rb_freq['Freq'].astype(int)
1364
- rb_freq['Position'] = rb_freq['Player'].map(maps_dict['Pos_map'])
1365
- rb_freq['Salary'] = rb_freq['Player'].map(maps_dict['Salary_map'])
1366
- rb_freq['Proj Own'] = rb_freq['Player'].map(maps_dict['Own_map']) / 100
1367
- rb_freq['Exposure'] = rb_freq['Freq']/Sim_size
1368
- rb_freq['Edge'] = rb_freq['Exposure'] - rb_freq['Proj Own']
1369
- rb_freq['Team'] = rb_freq['Player'].map(maps_dict['Team_map'])
1370
- for checkVar in range(len(team_list)):
1371
- rb_freq['Team'] = rb_freq['Team'].replace(item_list, team_list)
1372
-
1373
- rb_freq = rb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1374
-
1375
- wr_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
1376
- columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1377
- wr_freq['Freq'] = wr_freq['Freq'].astype(int)
1378
- wr_freq['Position'] = wr_freq['Player'].map(maps_dict['Pos_map'])
1379
- wr_freq['Salary'] = wr_freq['Player'].map(maps_dict['Salary_map'])
1380
- wr_freq['Proj Own'] = wr_freq['Player'].map(maps_dict['Own_map']) / 100
1381
- wr_freq['Exposure'] = wr_freq['Freq']/Sim_size
1382
- wr_freq['Edge'] = wr_freq['Exposure'] - wr_freq['Proj Own']
1383
- wr_freq['Team'] = wr_freq['Player'].map(maps_dict['Team_map'])
1384
- for checkVar in range(len(team_list)):
1385
- wr_freq['Team'] = wr_freq['Team'].replace(item_list, team_list)
1386
-
1387
- wr_freq = wr_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1388
-
1389
- te_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
1390
- columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1391
- te_freq['Freq'] = te_freq['Freq'].astype(int)
1392
- te_freq['Position'] = te_freq['Player'].map(maps_dict['Pos_map'])
1393
- te_freq['Salary'] = te_freq['Player'].map(maps_dict['Salary_map'])
1394
- te_freq['Proj Own'] = te_freq['Player'].map(maps_dict['Own_map']) / 100
1395
- te_freq['Exposure'] = te_freq['Freq']/Sim_size
1396
- te_freq['Edge'] = te_freq['Exposure'] - te_freq['Proj Own']
1397
- te_freq['Team'] = te_freq['Player'].map(maps_dict['Team_map'])
1398
- for checkVar in range(len(team_list)):
1399
- te_freq['Team'] = te_freq['Team'].replace(item_list, team_list)
1400
-
1401
- te_freq = te_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1402
-
1403
- flex_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
1404
- columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1405
- flex_freq['Freq'] = flex_freq['Freq'].astype(int)
1406
- flex_freq['Position'] = flex_freq['Player'].map(maps_dict['Pos_map'])
1407
- flex_freq['Salary'] = flex_freq['Player'].map(maps_dict['Salary_map'])
1408
- flex_freq['Proj Own'] = flex_freq['Player'].map(maps_dict['Own_map']) / 100
1409
- flex_freq['Exposure'] = flex_freq['Freq']/Sim_size
1410
- flex_freq['Edge'] = flex_freq['Exposure'] - flex_freq['Proj Own']
1411
- flex_freq['Team'] = flex_freq['Player'].map(maps_dict['Team_map'])
1412
- for checkVar in range(len(team_list)):
1413
- flex_freq['Team'] = flex_freq['Team'].replace(item_list, team_list)
1414
-
1415
- flex_freq = flex_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1416
-
1417
- dst_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,8:9].values, return_counts=True)),
1418
- columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1419
- dst_freq['Freq'] = dst_freq['Freq'].astype(int)
1420
- dst_freq['Position'] = dst_freq['Player'].map(maps_dict['Pos_map'])
1421
- dst_freq['Salary'] = dst_freq['Player'].map(maps_dict['Salary_map'])
1422
- dst_freq['Proj Own'] = dst_freq['Player'].map(maps_dict['Own_map']) / 100
1423
- dst_freq['Exposure'] = dst_freq['Freq']/Sim_size
1424
- dst_freq['Edge'] = dst_freq['Exposure'] - dst_freq['Proj Own']
1425
- dst_freq['Team'] = dst_freq['Player'].map(maps_dict['Team_map'])
1426
- for checkVar in range(len(team_list)):
1427
- dst_freq['Team'] = dst_freq['Team'].replace(item_list, team_list)
1428
-
1429
- dst_freq = dst_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1430
-
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
873
  Contest_Size = 5000
874
  elif contest_var1 == 'Large':
875
  Contest_Size = 10000
876
+ linenum_var1 = 2500
877
  strength_var1 = st.selectbox("How sharp is the field in the contest?", ('Not Very', 'Average', 'Very'))
878
  if strength_var1 == 'Not Very':
879
  sharp_split = .33
 
887
  sharp_split = .75
888
  Strength_var = .01
889
  scaling_var = 15
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
890
 
891
  with col2:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
892
  if st.button("Simulate Contest"):
893
+ try:
894
+ del dst_freq
895
+ del flex_freq
896
+ del te_freq
897
+ del wr_freq
898
+ del rb_freq
899
+ del qb_freq
900
+ del player_freq
901
+ del Sim_Winner_Export
902
+ del Sim_Winner_Frame
903
+ except:
904
+ pass
905
  with st.container():
906
+ st.write('Contest Simulation Starting')
907
+ seed_depth1 = 10
908
+ Total_Runs = 1000000
909
+ if Contest_Size <= 1000:
910
+ strength_grow = .01
911
+ elif Contest_Size > 1000 and Contest_Size <= 2500:
912
+ strength_grow = .025
913
+ elif Contest_Size > 2500 and Contest_Size <= 5000:
914
+ strength_grow = .05
915
+ elif Contest_Size > 5000 and Contest_Size <= 20000:
916
+ strength_grow = .075
917
+ elif Contest_Size > 20000:
918
+ strength_grow = .1
919
+
920
+ field_growth = 100 * strength_grow
921
+
922
+ Sort_function = 'Median'
923
+ if Sort_function == 'Median':
924
+ Sim_function = 'Projection'
925
+ elif Sort_function == 'Own':
926
+ Sim_function = 'Own'
927
+
928
+ if slate_var1 == 'User':
929
+ OwnFrame = proj_dataframe
930
+ if contest_var1 == 'Small':
931
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (10 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
932
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
933
+ OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
934
+ OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
935
+ if contest_var1 == 'Medium':
936
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (6 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
937
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
938
+ OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
939
+ OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
940
+ if contest_var1 == 'Large':
941
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
942
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (1.5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
943
+ OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
944
+ OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
945
+ Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
946
+
947
+ del OwnFrame
948
 
949
+ elif slate_var1 != 'User':
950
+ initial_proj = raw_baselines
951
+ drop_frame = initial_proj.drop_duplicates(subset = 'Player',keep = 'first')
952
+ OwnFrame = drop_frame[['Player', 'Team', 'Position', 'Median', 'Own', 'Floor', 'Ceiling', 'Salary']]
953
+ if contest_var1 == 'Small':
954
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (10 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
955
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
956
+ OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
957
+ OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
958
+ if contest_var1 == 'Medium':
959
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (6 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
960
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
961
+ OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
962
+ OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
963
+ if contest_var1 == 'Large':
964
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] == 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (3 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] == 'QB', 'Own'].mean(), OwnFrame['Own'])
965
+ OwnFrame['Own%'] = np.where((OwnFrame['Position'] != 'QB') & (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean() >= 0), OwnFrame['Own'] * (1.5 * (OwnFrame['Own'] - OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean())/100) + OwnFrame.loc[OwnFrame['Position'] != 'QB', 'Own'].mean(), OwnFrame['Own%'])
966
+ OwnFrame['Own%'] = np.where(OwnFrame['Own%'] > 75, 75, OwnFrame['Own%'])
967
+ OwnFrame['Own'] = OwnFrame['Own%'] * (900 / OwnFrame['Own%'].sum())
968
+ Overall_Proj = OwnFrame[['Player', 'Team', 'Position', 'Median', 'Own', 'Salary']]
969
+
970
+ del initial_proj
971
+ del drop_frame
972
+ del OwnFrame
973
+
974
+ if insert_port == 1:
975
+ UserPortfolio = portfolio_dataframe[['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']]
976
+ elif insert_port == 0:
977
+ UserPortfolio = pd.DataFrame(columns = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST'])
978
+
979
+ Overall_Proj.replace('', np.nan, inplace=True)
980
+ Overall_Proj = Overall_Proj.dropna(subset=['Median'])
981
+ Overall_Proj = Overall_Proj.assign(Value=lambda x: (x.Median / (x.Salary / 1000)))
982
+ Overall_Proj['Sort_var'] = (Overall_Proj['Median'].rank(ascending=False) + Overall_Proj['Value'].rank(ascending=False)) / 2
983
+ Overall_Proj = Overall_Proj.sort_values(by='Sort_var', ascending=False)
984
+ Overall_Proj['Own'] = np.where((Overall_Proj['Median'] > 0) & (Overall_Proj['Own'] == 0), 1, Overall_Proj['Own'])
985
+ Overall_Proj = Overall_Proj.loc[Overall_Proj['Own'] > 0]
986
+
987
+ Overall_Proj['Floor'] = np.where(Overall_Proj['Position'] == 'QB', Overall_Proj['Median'] * .5, Overall_Proj['Median'] * .25)
988
+ Overall_Proj['Ceiling'] = np.where(Overall_Proj['Position'] == 'WR', Overall_Proj['Median'] + Overall_Proj['Median'], Overall_Proj['Median'] + Overall_Proj['Floor'])
989
+ Overall_Proj['STDev'] = Overall_Proj['Median'] / 4
990
+
991
+ Teams_used = Overall_Proj['Team'].drop_duplicates().reset_index(drop=True)
992
+ Teams_used = Teams_used.reset_index()
993
+ Teams_used['team_item'] = Teams_used['index'] + 1
994
+ Teams_used = Teams_used.drop(columns=['index'])
995
+ Teams_used_dictraw = Teams_used.drop(columns=['team_item'])
996
+ Teams_used_dict = Teams_used_dictraw.to_dict()
997
+
998
+ del Teams_used_dictraw
999
+
1000
+ team_list = Teams_used['Team'].to_list()
1001
+ item_list = Teams_used['team_item'].to_list()
1002
+
1003
+ FieldStrength_raw = Strength_var + ((30 - len(Teams_used)) * .01)
1004
+ FieldStrength = FieldStrength_raw - (FieldStrength_raw * (20000 / Contest_Size))
1005
+
1006
+ del FieldStrength_raw
1007
+
1008
+ if FieldStrength < 0:
1009
+ FieldStrength = Strength_var
1010
+ field_split = Strength_var
1011
+
1012
+ for checkVar in range(len(team_list)):
1013
+ Overall_Proj['Team'] = Overall_Proj['Team'].replace(team_list, item_list)
1014
+
1015
+ qbs_raw = Overall_Proj[Overall_Proj.Position == 'QB']
1016
+ qbs_raw.dropna(subset=['Median']).reset_index(drop=True)
1017
+ qbs_raw = qbs_raw.reset_index(drop=True)
1018
+ qbs_raw = qbs_raw.sort_values(by=['Median'], ascending=False)
1019
+
1020
+ qbs = qbs_raw.head(round(len(qbs_raw)))
1021
+ qbs = qbs.assign(Var = range(0,len(qbs)))
1022
+ qb_dict = pd.Series(qbs.Player.values, index=qbs.Var).to_dict()
1023
+
1024
+ defs_raw = Overall_Proj[Overall_Proj.Position.str.contains("D")]
1025
+ defs_raw.dropna(subset=['Median']).reset_index(drop=True)
1026
+ defs_raw = defs_raw.reset_index(drop=True)
1027
+ defs_raw = defs_raw.sort_values(by=['Own', 'Value'], ascending=False)
1028
+
1029
+ defs = defs_raw.head(round(len(defs_raw)))
1030
+ defs = defs.assign(Var = range(0,len(defs)))
1031
+ def_dict = pd.Series(defs.Player.values, index=defs.Var).to_dict()
1032
+
1033
+ rbs_raw = Overall_Proj[Overall_Proj.Position == 'RB']
1034
+ rbs_raw.dropna(subset=['Median']).reset_index(drop=True)
1035
+ rbs_raw = rbs_raw.reset_index(drop=True)
1036
+ rbs_raw = rbs_raw.sort_values(by=['Own', 'Value'], ascending=False)
1037
+
1038
+ wrs_raw = Overall_Proj[Overall_Proj.Position == 'WR']
1039
+ wrs_raw.dropna(subset=['Median']).reset_index(drop=True)
1040
+ wrs_raw = wrs_raw.reset_index(drop=True)
1041
+ wrs_raw = wrs_raw.sort_values(by=['Own', 'Median'], ascending=False)
1042
+
1043
+ tes_raw = Overall_Proj[Overall_Proj.Position == 'TE']
1044
+ tes_raw.dropna(subset=['Median']).reset_index(drop=True)
1045
+ tes_raw = tes_raw.reset_index(drop=True)
1046
+ tes_raw = tes_raw.sort_values(by=['Own', 'Value'], ascending=False)
1047
+
1048
+ pos_players = pd.concat([rbs_raw, wrs_raw, tes_raw])
1049
+ pos_players.dropna(subset=['Median']).reset_index(drop=True)
1050
+ pos_players = pos_players.reset_index(drop=True)
1051
+
1052
+ del qbs_raw
1053
+ del defs_raw
1054
+ del rbs_raw
1055
+ del wrs_raw
1056
+ del tes_raw
1057
+
1058
+ if insert_port == 1:
1059
+ try:
1060
+ # Initialize an empty DataFrame for Raw Portfolio
1061
+ Raw_Portfolio = pd.DataFrame()
1062
+
1063
+ # Loop through each position and split the data accordingly
1064
+ positions = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
1065
+ for pos in positions:
1066
+ temp_df = UserPortfolio[pos].str.split("(", n=1, expand=True)
1067
+ temp_df.columns = [pos, 'Drop']
1068
+ Raw_Portfolio = pd.concat([Raw_Portfolio, temp_df], axis=1)
1069
+
1070
+ # Select only necessary columns and strip white spaces
1071
+ CleanPortfolio = Raw_Portfolio[positions].apply(lambda x: x.str.strip())
1072
+ CleanPortfolio.reset_index(inplace=True)
1073
+ CleanPortfolio['User/Field'] = CleanPortfolio['index'] + 1
1074
+ CleanPortfolio.drop(columns=['index'], inplace=True)
1075
+
1076
+ CleanPortfolio.replace('', np.nan, inplace=True)
1077
+ CleanPortfolio.dropna(subset=['QB'], inplace=True)
1078
+
1079
+ # Create frequency table for players
1080
+ cleaport_players = pd.DataFrame(
1081
+ np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:9].values, return_counts=True)),
1082
+ columns=['Player', 'Freq']
1083
+ ).sort_values('Freq', ascending=False).reset_index(drop=True)
1084
+ cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
1085
+
1086
+ # Merge and update nerf_frame
1087
+ nerf_frame = pd.merge(cleaport_players, Overall_Proj, on='Player', how='left')
1088
+ for col in ['Median', 'Floor', 'Ceiling', 'STDev']:
1089
+ nerf_frame[col] *= 0.90
1090
+ del Raw_Portfolio
1091
+ except:
1092
+ CleanPortfolio = UserPortfolio.reset_index()
1093
+ CleanPortfolio['User/Field'] = CleanPortfolio['index'] + 1
1094
+ CleanPortfolio.drop(columns=['index'], inplace=True)
1095
 
1096
+ # Replace empty strings and drop rows with NaN in 'QB' column
1097
+ CleanPortfolio.replace('', np.nan, inplace=True)
1098
+ CleanPortfolio.dropna(subset=['QB'], inplace=True)
1099
 
1100
+ # Create frequency table for players
1101
+ cleaport_players = pd.DataFrame(
1102
+ np.column_stack(np.unique(CleanPortfolio.iloc[:, 0:9].values, return_counts=True)),
1103
+ columns=['Player', 'Freq']
1104
+ ).sort_values('Freq', ascending=False).reset_index(drop=True)
1105
+ cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1106
 
1107
+ # Merge and update nerf_frame
1108
+ nerf_frame = pd.merge(cleaport_players, Overall_Proj, on='Player', how='left')
1109
+ for col in ['Median', 'Floor', 'Ceiling', 'STDev']:
1110
+ nerf_frame[col] *= 0.90
1111
+
1112
+ elif insert_port == 0:
1113
+ CleanPortfolio = UserPortfolio
1114
+ cleaport_players = pd.DataFrame(np.column_stack(np.unique(CleanPortfolio.iloc[:,0:9].values, return_counts=True)),
1115
+ columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1116
+ cleaport_players['Freq'] = cleaport_players['Freq'].astype(int)
1117
+ nerf_frame = Overall_Proj
1118
 
1119
+ ref_dict = {
1120
+ 'pos':['RB', 'WR', 'TE', 'FLEX'],
1121
+ 'pos_dfs':['RB_Table', 'WR_Table', 'TE_Table', 'FLEX_Table'],
1122
+ 'pos_dicts':['rb_dict', 'wr_dict', 'te_dict', 'flex_dict']
1123
+ }
1124
+
1125
+ maps_dict = {
1126
+ 'Floor_map':dict(zip(Overall_Proj.Player,Overall_Proj.Floor)),
1127
+ 'Projection_map':dict(zip(Overall_Proj.Player,Overall_Proj.Median)),
1128
+ 'Ceiling_map':dict(zip(Overall_Proj.Player,Overall_Proj.Ceiling)),
1129
+ 'Salary_map':dict(zip(Overall_Proj.Player,Overall_Proj.Salary)),
1130
+ 'Pos_map':dict(zip(Overall_Proj.Player,Overall_Proj.Position)),
1131
+ 'Own_map':dict(zip(Overall_Proj.Player,Overall_Proj.Own)),
1132
+ 'Team_map':dict(zip(Overall_Proj.Player,Overall_Proj.Team)),
1133
+ 'STDev_map':dict(zip(Overall_Proj.Player,Overall_Proj.STDev)),
1134
+ 'team_check_map':dict(zip(Overall_Proj.Player,Overall_Proj.Team))
1135
+ }
1136
+
1137
+ up_dict = {
1138
+ 'Floor_map':dict(zip(cleaport_players.Player,nerf_frame.Floor)),
1139
+ 'Projection_map':dict(zip(cleaport_players.Player,nerf_frame.Median)),
1140
+ 'Ceiling_map':dict(zip(cleaport_players.Player,nerf_frame.Ceiling)),
1141
+ 'Salary_map':dict(zip(cleaport_players.Player,nerf_frame.Salary)),
1142
+ 'Pos_map':dict(zip(cleaport_players.Player,nerf_frame.Position)),
1143
+ 'Own_map':dict(zip(cleaport_players.Player,nerf_frame.Own)),
1144
+ 'Team_map':dict(zip(cleaport_players.Player,nerf_frame.Team)),
1145
+ 'STDev_map':dict(zip(cleaport_players.Player,nerf_frame.STDev)),
1146
+ 'team_check_map':dict(zip(cleaport_players.Player,nerf_frame.Team))
1147
+ }
1148
+
1149
+ del cleaport_players
1150
+ del Overall_Proj
1151
+ del nerf_frame
1152
+
1153
+ st.write('Seed frame creation')
1154
+ FinalPortfolio, maps_dict = run_seed_frame(seed_depth1, Strength_var, strength_grow, Teams_used, Total_Runs)
1155
+
1156
+ Sim_size = linenum_var1
1157
+ SimVar = 1
1158
+ Sim_Winners = []
1159
+ fp_array = FinalPortfolio.values
1160
+
1161
+ if insert_port == 1:
1162
+ up_array = CleanPortfolio.values
1163
+
1164
+ # Pre-vectorize functions
1165
+ vec_projection_map = np.vectorize(maps_dict['Projection_map'].__getitem__)
1166
+ vec_stdev_map = np.vectorize(maps_dict['STDev_map'].__getitem__)
1167
+
1168
+ if insert_port == 1:
1169
+ vec_up_projection_map = np.vectorize(up_dict['Projection_map'].__getitem__)
1170
+ vec_up_stdev_map = np.vectorize(up_dict['STDev_map'].__getitem__)
1171
+
1172
+ st.write('Simulating contest on frames')
1173
+
1174
+ while SimVar <= Sim_size:
1175
  if insert_port == 1:
1176
+ fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size-len(CleanPortfolio))]
1177
  elif insert_port == 0:
1178
+ fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size)]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1179
 
1180
+ sample_arrays1 = np.c_[
1181
+ fp_random,
1182
+ np.sum(np.random.normal(
1183
+ loc=vec_projection_map(fp_random[:, :-5]),
1184
+ scale=vec_stdev_map(fp_random[:, :-5])),
1185
+ axis=1)
1186
+ ]
1187
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1188
  if insert_port == 1:
1189
+ sample_arrays2 = np.c_[
1190
+ up_array,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1191
  np.sum(np.random.normal(
1192
+ loc=vec_up_projection_map(up_array[:, :-5]),
1193
+ scale=vec_up_stdev_map(up_array[:, :-5])),
1194
  axis=1)
1195
  ]
1196
+ sample_arrays = np.vstack((sample_arrays1, sample_arrays2))
1197
+ else:
1198
+ sample_arrays = sample_arrays1
1199
+
1200
+ final_array = sample_arrays[sample_arrays[:, 10].argsort()[::-1]]
1201
+ best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
1202
+ Sim_Winners.append(best_lineup)
1203
+ SimVar += 1
1204
+
1205
+
1206
+ # del smple_arrays
1207
+ # del smple_arrays1
1208
+ # del smple_arrays2
1209
+ # del final_array
1210
+ # del best_lineup
1211
+ st.write('Contest simulation complete')
1212
+ # Initial setup
1213
+ Sim_Winner_Frame = pd.DataFrame(np.concatenate(Sim_Winners), columns=FinalPortfolio.columns.tolist() + ['Fantasy'])
1214
+ Sim_Winner_Frame['GPP_Proj'] = (Sim_Winner_Frame['Projection'] + Sim_Winner_Frame['Fantasy']) / 2
1215
 
1216
+ # Type Casting
1217
+ type_cast_dict = {'Salary': int, 'Projection': np.float16, 'Fantasy': np.float16, 'GPP_Proj': np.float16}
1218
+ Sim_Winner_Frame = Sim_Winner_Frame.astype(type_cast_dict)
 
 
 
 
 
 
 
 
1219
 
1220
+ # Sorting
1221
+ Sim_Winner_Frame = Sim_Winner_Frame.sort_values(by='GPP_Proj', ascending=False)
1222
+
1223
+ # Data Copying
1224
+ Sim_Winner_Export = Sim_Winner_Frame.copy()
1225
+
1226
+ # Conditional Replacement
1227
+ columns_to_replace = ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX', 'DST']
1228
+
1229
+ if site_var1 == 'Draftkings':
1230
+ replace_dict = dkid_dict
1231
+ elif site_var1 == 'Fanduel':
1232
+ replace_dict = fdid_dict
1233
+
1234
+ for col in columns_to_replace:
1235
+ Sim_Winner_Export[col].replace(replace_dict, inplace=True)
1236
+
1237
+
1238
+ player_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:9].values, return_counts=True)),
1239
+ columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1240
+ player_freq['Freq'] = player_freq['Freq'].astype(int)
1241
+ player_freq['Position'] = player_freq['Player'].map(maps_dict['Pos_map'])
1242
+ player_freq['Salary'] = player_freq['Player'].map(maps_dict['Salary_map'])
1243
+ player_freq['Proj Own'] = player_freq['Player'].map(maps_dict['Own_map']) / 100
1244
+ player_freq['Exposure'] = player_freq['Freq']/(Sim_size)
1245
+ player_freq['Edge'] = player_freq['Exposure'] - player_freq['Proj Own']
1246
+ player_freq['Team'] = player_freq['Player'].map(maps_dict['Team_map'])
1247
+ for checkVar in range(len(team_list)):
1248
+ player_freq['Team'] = player_freq['Team'].replace(item_list, team_list)
1249
+
1250
+ player_freq = player_freq[['Player', 'Position', 'Team', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1251
+
1252
+ qb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,0:1].values, return_counts=True)),
1253
+ columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1254
+ qb_freq['Freq'] = qb_freq['Freq'].astype(int)
1255
+ qb_freq['Position'] = qb_freq['Player'].map(maps_dict['Pos_map'])
1256
+ qb_freq['Salary'] = qb_freq['Player'].map(maps_dict['Salary_map'])
1257
+ qb_freq['Proj Own'] = qb_freq['Player'].map(maps_dict['Own_map']) / 100
1258
+ qb_freq['Exposure'] = qb_freq['Freq']/(Sim_size)
1259
+ qb_freq['Edge'] = qb_freq['Exposure'] - qb_freq['Proj Own']
1260
+ qb_freq['Team'] = qb_freq['Player'].map(maps_dict['Team_map'])
1261
+ for checkVar in range(len(team_list)):
1262
+ qb_freq['Team'] = qb_freq['Team'].replace(item_list, team_list)
1263
+
1264
+ qb_freq = qb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1265
+
1266
+ rb_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[1, 2]].values, return_counts=True)),
1267
+ columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1268
+ rb_freq['Freq'] = rb_freq['Freq'].astype(int)
1269
+ rb_freq['Position'] = rb_freq['Player'].map(maps_dict['Pos_map'])
1270
+ rb_freq['Salary'] = rb_freq['Player'].map(maps_dict['Salary_map'])
1271
+ rb_freq['Proj Own'] = rb_freq['Player'].map(maps_dict['Own_map']) / 100
1272
+ rb_freq['Exposure'] = rb_freq['Freq']/Sim_size
1273
+ rb_freq['Edge'] = rb_freq['Exposure'] - rb_freq['Proj Own']
1274
+ rb_freq['Team'] = rb_freq['Player'].map(maps_dict['Team_map'])
1275
+ for checkVar in range(len(team_list)):
1276
+ rb_freq['Team'] = rb_freq['Team'].replace(item_list, team_list)
1277
+
1278
+ rb_freq = rb_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1279
+
1280
+ wr_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[3, 4, 5]].values, return_counts=True)),
1281
+ columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1282
+ wr_freq['Freq'] = wr_freq['Freq'].astype(int)
1283
+ wr_freq['Position'] = wr_freq['Player'].map(maps_dict['Pos_map'])
1284
+ wr_freq['Salary'] = wr_freq['Player'].map(maps_dict['Salary_map'])
1285
+ wr_freq['Proj Own'] = wr_freq['Player'].map(maps_dict['Own_map']) / 100
1286
+ wr_freq['Exposure'] = wr_freq['Freq']/Sim_size
1287
+ wr_freq['Edge'] = wr_freq['Exposure'] - wr_freq['Proj Own']
1288
+ wr_freq['Team'] = wr_freq['Player'].map(maps_dict['Team_map'])
1289
+ for checkVar in range(len(team_list)):
1290
+ wr_freq['Team'] = wr_freq['Team'].replace(item_list, team_list)
1291
+
1292
+ wr_freq = wr_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1293
+
1294
+ te_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[6]].values, return_counts=True)),
1295
+ columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1296
+ te_freq['Freq'] = te_freq['Freq'].astype(int)
1297
+ te_freq['Position'] = te_freq['Player'].map(maps_dict['Pos_map'])
1298
+ te_freq['Salary'] = te_freq['Player'].map(maps_dict['Salary_map'])
1299
+ te_freq['Proj Own'] = te_freq['Player'].map(maps_dict['Own_map']) / 100
1300
+ te_freq['Exposure'] = te_freq['Freq']/Sim_size
1301
+ te_freq['Edge'] = te_freq['Exposure'] - te_freq['Proj Own']
1302
+ te_freq['Team'] = te_freq['Player'].map(maps_dict['Team_map'])
1303
+ for checkVar in range(len(team_list)):
1304
+ te_freq['Team'] = te_freq['Team'].replace(item_list, team_list)
1305
+
1306
+ te_freq = te_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1307
+
1308
+ flex_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,[7]].values, return_counts=True)),
1309
+ columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1310
+ flex_freq['Freq'] = flex_freq['Freq'].astype(int)
1311
+ flex_freq['Position'] = flex_freq['Player'].map(maps_dict['Pos_map'])
1312
+ flex_freq['Salary'] = flex_freq['Player'].map(maps_dict['Salary_map'])
1313
+ flex_freq['Proj Own'] = flex_freq['Player'].map(maps_dict['Own_map']) / 100
1314
+ flex_freq['Exposure'] = flex_freq['Freq']/Sim_size
1315
+ flex_freq['Edge'] = flex_freq['Exposure'] - flex_freq['Proj Own']
1316
+ flex_freq['Team'] = flex_freq['Player'].map(maps_dict['Team_map'])
1317
+ for checkVar in range(len(team_list)):
1318
+ flex_freq['Team'] = flex_freq['Team'].replace(item_list, team_list)
1319
+
1320
+ flex_freq = flex_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1321
+
1322
+ dst_freq = pd.DataFrame(np.column_stack(np.unique(Sim_Winner_Frame.iloc[:,8:9].values, return_counts=True)),
1323
+ columns=['Player','Freq']).sort_values('Freq', ascending=False).reset_index(drop=True)
1324
+ dst_freq['Freq'] = dst_freq['Freq'].astype(int)
1325
+ dst_freq['Position'] = dst_freq['Player'].map(maps_dict['Pos_map'])
1326
+ dst_freq['Salary'] = dst_freq['Player'].map(maps_dict['Salary_map'])
1327
+ dst_freq['Proj Own'] = dst_freq['Player'].map(maps_dict['Own_map']) / 100
1328
+ dst_freq['Exposure'] = dst_freq['Freq']/Sim_size
1329
+ dst_freq['Edge'] = dst_freq['Exposure'] - dst_freq['Proj Own']
1330
+ dst_freq['Team'] = dst_freq['Player'].map(maps_dict['Team_map'])
1331
+ for checkVar in range(len(team_list)):
1332
+ dst_freq['Team'] = dst_freq['Team'].replace(item_list, team_list)
1333
+
1334
+ dst_freq = dst_freq[['Player', 'Team', 'Position', 'Salary', 'Proj Own', 'Exposure', 'Edge']]
1335
+
1336
+ with st.container():
1337
+ simulate_container = st.empty()
1338
+ st.dataframe(Sim_Winner_Frame.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Own']).format(precision=2), use_container_width = True)
1339
+
1340
+ st.download_button(
1341
+ label="Export Tables",
1342
+ data=convert_df_to_csv(Sim_Winner_Export),
1343
+ file_name='NFL_consim_export.csv',
1344
+ mime='text/csv',
1345
+ )
1346
+
1347
+ with st.container():
1348
+ freq_container = st.empty()
1349
+ tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs(['Overall Exposures', 'QB Exposures', 'RB Exposures', 'WR Exposures', 'TE Exposures', 'FLEX Exposures', 'DST Exposures'])
1350
+ with tab1:
1351
+ st.dataframe(player_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
1352
+ st.download_button(
1353
+ label="Export Exposures",
1354
+ data=convert_df_to_csv(player_freq),
1355
+ file_name='player_freq_export.csv',
1356
+ mime='text/csv',
1357
+ )
1358
+ with tab2:
1359
+ st.dataframe(qb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
1360
+ st.download_button(
1361
+ label="Export Exposures",
1362
+ data=convert_df_to_csv(qb_freq),
1363
+ file_name='qb_freq_export.csv',
1364
+ mime='text/csv',
1365
+ )
1366
+ with tab3:
1367
+ st.dataframe(rb_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
1368
+ st.download_button(
1369
+ label="Export Exposures",
1370
+ data=convert_df_to_csv(rb_freq),
1371
+ file_name='rb_freq_export.csv',
1372
+ mime='text/csv',
1373
+ )
1374
+ with tab4:
1375
+ st.dataframe(wr_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
1376
+ st.download_button(
1377
+ label="Export Exposures",
1378
+ data=convert_df_to_csv(wr_freq),
1379
+ file_name='wr_freq_export.csv',
1380
+ mime='text/csv',
1381
+ )
1382
+ with tab5:
1383
+ st.dataframe(te_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
1384
+ st.download_button(
1385
+ label="Export Exposures",
1386
+ data=convert_df_to_csv(te_freq),
1387
+ file_name='te_freq_export.csv',
1388
+ mime='text/csv',
1389
+ )
1390
+ with tab6:
1391
+ st.dataframe(flex_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
1392
+ st.download_button(
1393
+ label="Export Exposures",
1394
+ data=convert_df_to_csv(flex_freq),
1395
+ file_name='flex_freq_export.csv',
1396
+ mime='text/csv',
1397
+ )
1398
+ with tab7:
1399
+ st.dataframe(dst_freq.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(freq_format, precision=2), use_container_width = True)
1400
+ st.download_button(
1401
+ label="Export Exposures",
1402
+ data=convert_df_to_csv(dst_freq),
1403
+ file_name='dst_freq_export.csv',
1404
+ mime='text/csv',
1405
+ )