Coverage for src / pages / main_page.py: 0%

1from io import StringIO 

2 

3import dash_bootstrap_components as dbc 

4import pandas as pd 

5from dash import html, Output, Input, dash_table, dcc, State 

6from dash.exceptions import PreventUpdate 

7 

8from src import analyse 

9from src.configuration import store 

10from src.pages.card_pages import card 

11from src.pages.filter_pages import filter_user, filter_card_type, filter_rarity, filter_element, \ 

12 filter_editions, filter_ids, filter_sort_by, filter_group_levels, filter_battle_format, \ 

13 filter_ruleset, filter_season, filter_mana_cap, filter_battle_count, filter_match_type, filter_abilities 

14from src.pages.main_dash import app 

15from src.utils.trace_logging import measure_duration 

16 

17layout = dbc.Container([ 

18 dbc.Row([ 

19 html.H1('Statistics battles'), 

20 html.P('Your battle statistics of your summoners and monster'), 

21 dbc.Col(html.H4('Filter')), 

22 ]), 

23 dbc.Row([ 

24 dbc.Col(filter_user.layout, md=4), 

25 ]), 

26 dbc.Row([ 

27 dbc.Col(filter_battle_format.layout), 

28 dbc.Col(filter_card_type.layout), 

29 dbc.Col(filter_match_type.layout), 

30 dbc.Col(filter_rarity.layout), 

31 dbc.Col(filter_element.layout), 

32 dbc.Col(filter_editions.layout), 

33 ], className='mb-3'), 

34 dbc.Row([ 

35 dbc.Col(filter_season.layout), 

36 dbc.Col(filter_mana_cap.layout), 

37 ]), 

38 dbc.Row([ 

39 dbc.Col(filter_battle_count.layout), 

40 dbc.Col(filter_ruleset.layout), 

41 dbc.Col(filter_abilities.layout), 

42 ]), 

43 

44 dbc.Row([ 

45 dbc.Col(filter_group_levels.layout), 

46 dbc.Col(filter_sort_by.layout), 

47 ]), 

48 

49 dbc.Row(id='top-cards'), 

50 dbc.Row([ 

51 dbc.Accordion( 

52 dbc.AccordionItem(html.Div(id='main-table-div', className='dbc'), 

53 title='Complete table', 

54 id='complete-table-accordion-item' 

55 ), 

56 start_collapsed=True, 

57 id='accordion', 

58 ) 

59 ]), 

60 html.Div(id='redirect-div'), 

61 dcc.Store(id='filtered-battle-df'), 

62 dcc.Store(id=filter_ids.filter_settings, data={}), 

63 

64]) 

65 

66 

67@app.callback( 

68 Output('main-table-div', 'children'), 

69 Input('filtered-battle-df', 'data'), 

70) 

71@measure_duration 

72def update_main_table(filtered_df): 

73 if not filtered_df: 

74 raise PreventUpdate 

75 

76 filtered_df = pd.read_json(StringIO(filtered_df), orient='split') 

77 

78 if not filtered_df.empty: 

79 return dash_table.DataTable(id='top-cards-table', 

80 # columns=[{'name': i, 'id': i} for i in df.columns], 

81 columns=[ 

82 {'id': 'url_markdown', 'name': 'Card', 'presentation': 'markdown'}, 

83 {'id': 'card_name', 'name': 'Name'}, 

84 {'id': 'level', 'name': 'Level'}, 

85 # {'id': 'win_to_loss_ratio', 'name': 'win_to_loss_ratio'}, 

86 {'id': 'battles', 'name': 'Battles'}, 

87 # {'id': 'win_ratio', 'name': 'win_ratio'}, 

88 {'id': 'win_percentage', 'name': 'Win Percentage'}, 

89 ], 

90 data=filtered_df.to_dict('records'), 

91 row_selectable=False, 

92 row_deletable=False, 

93 editable=False, 

94 filter_action='native', 

95 sort_action='native', 

96 style_table={'overflowX': 'auto'}, 

97 style_cell_conditional=[{'if': {'column_id': 'url'}, 'width': '200px'}, ], 

98 page_size=10, 

99 ), 

100 else: 

101 return dash_table.DataTable(id='top-cards-table-empty') 

102 

103 

104@app.callback( 

105 Output('redirect-div', 'children'), 

106 Input('top-cards-table', 'active_cell'), 

107 State('top-cards-table', 'derived_virtual_data'), 

108 State(filter_ids.filter_settings, 'data') 

109) 

110@measure_duration 

111def redirect_to_page(active_cell, data, stored_filter_settings): 

112 if active_cell: 

113 return dcc.Location( 

114 href='card?card_id=' + str(data[active_cell['row']]['card_detail_id']) 

115 + '#account=' + str(stored_filter_settings['account']), 

116 id='url-redirect') 

117 

118 

119@app.callback( 

120 Output('top-cards', 'children'), 

121 Input('filtered-battle-df', 'data'), 

122 State(filter_ids.filter_settings, 'data') 

123) 

124@measure_duration 

125def update_top_cards(filtered_df, stored_filter_settings): 

126 if not filtered_df: 

127 raise PreventUpdate 

128 

129 account_name = stored_filter_settings['account'] 

130 

131 filtered_df = pd.read_json(StringIO(filtered_df), orient='split') 

132 

133 result_layout = [] 

134 if not filtered_df.empty: 

135 result_layout = card.get_card_columns(filtered_df, 5, account=account_name) 

136 

137 return result_layout 

138 

139 

140@app.callback( 

141 Output('filtered-battle-df', 'data'), 

142 Input(filter_ids.filter_settings, 'data'), 

143) 

144@measure_duration 

145def filter_battle_df(filter_settings): 

146 if filter_settings is {} or 'account' not in filter_settings: 

147 raise PreventUpdate 

148 

149 # Filter before processing is done 

150 df = analyse.filter_battles(store.battle_big, filter_account=filter_settings['account']) 

151 df = analyse.filter_date(df, filter_settings) 

152 df = analyse.filter_mana_cap(df, filter_settings) 

153 df = analyse.filter_rule_sets(df, filter_settings) 

154 df = analyse.filter_format(df, filter_settings) 

155 df = analyse.filter_match_type(df, filter_settings) 

156 

157 # Processing 

158 group_levels = True 

159 if 'group_levels' in filter_settings: 

160 group_levels = filter_settings['group_levels'] 

161 

162 df = analyse.process_battles_win_percentage(df, 

163 group_levels=group_levels) 

164 

165 # Filter after processing is done 

166 df = analyse.filter_element(df, filter_settings) 

167 df = analyse.filter_edition(df, filter_settings) 

168 df = analyse.filter_card_type(df, filter_settings) 

169 df = analyse.filter_rarity(df, filter_settings) 

170 df = analyse.filter_battle_count(df, filter_settings) 

171 df = analyse.filter_abilities(df, filter_settings) 

172 df = analyse.sort_by(df, filter_settings) 

173 

174 return df.to_json(date_format='iso', orient='split')