class TableResultsForm(ResultsForm):
"""Takes in trade/orders and then creates aggregated metrics which are likely to be displayed as a table. Can also
sort by best/worst metrics, rounding numbers etc.
"""
def __init__(self,
trade_order_list=None,
metric_name=None,
filter_by=['all'],
tag_value_combinations={},
keep_fields=['executed_notional', 'side'],
replace_text={},
round_figures_by=1,
scalar=1.0,
weighting_field=constants.table_weighting_field,
exclude_fields_from_avg=[]):
self._trade_order_list = trade_order_list
self._metric_name = metric_name
self._results_summary = ResultsSummary()
self._keep_fields = keep_fields
self._filter_by = filter_by
self._replace_text = replace_text
self._round_figures_by = round_figures_by
self._weighting_field = weighting_field
self._scalar = scalar
self._exclude_fields_from_avg = exclude_fields_from_avg
self._tag_value_combinations = tag_value_combinations
self._trade_order_filter_tag = TradeOrderFilterTag()
self._results_form_tag = 'table'
self._util_func = UtilFunc()
self._time_series_ops = TimeSeriesOps()
def aggregate_results(self,
trade_order_df=None,
market_df=None,
filter_by=[],
trade_order_name=None,
metric_name=None,
ticker=None,
filter_nan=True,
weighting_field=None,
tag_value_combinations={},
keep_fields=[],
remove_fields=[],
replace_text={},
round_figures_by=None,
scalar=None,
exclude_fields_from_avg=None):
if not (self._check_calculate_results(trade_order_name)):
return [None, None]
if metric_name is None: metric_name = self._metric_name
if keep_fields == []: keep_fields = self._keep_fields
if filter_by == []: filter_by = self._filter_by
if round_figures_by is None: round_figures_by = self._round_figures_by
if replace_text == {}: replace_text = self._replace_text
if weighting_field is None: weighting_field = self._weighting_field
if tag_value_combinations == {}:
tag_value_combinations = self._tag_value_combinations
if scalar is None: scalar = self._scalar
if exclude_fields_from_avg is None:
exclude_fields_from_avg = self._exclude_fields_from_avg
if not (isinstance(metric_name, list)): metric_name = [metric_name]
if not (isinstance(filter_by, list)): filter_by = [filter_by]
trade_order_df = self._trade_order_filter_tag.filter_trade_order(
trade_order_df, tag_value_combinations=tag_value_combinations)
results = []
for filt in filter_by:
for met in metric_name:
if met not in trade_order_df.columns:
results.append(None)
elif weighting_field is not None and weighting_field not in trade_order_df.columns:
results.append(None)
else:
metric_fields_to_filter = [
x for x in trade_order_df.columns if met in x
]
columns_to_keep = self._util_func.flatten_list_of_lists(
[keep_fields, metric_fields_to_filter])
results_df = trade_order_df[columns_to_keep]
# Apply filter
if 'worst' in filt:
ordinal = filt.split('worst_')[1]
results_df = results_df.sort_values(by=met,
ascending=True)
if ordinal != 'all':
results_df = results_df.head(int(ordinal))
elif 'best' in filt:
ordinal = filt.split('worst_')[1]
results_df = results_df.sort_values(by=met,
ascending=False)
if ordinal != 'all':
results_df = results_df.head(ordinal)
# Weighting field for average!
results_df = self._time_series_ops.weighted_average_of_each_column(
results_df,
weighting_field,
append=True,
exclude_fields_from_avg=exclude_fields_from_avg)
results_df = self._time_series_ops.multiply_scalar_dataframe(
results_df, scalar=scalar)
results_df = self._time_series_ops.round_dataframe(
results_df,
round_figures_by,
columns_to_keep=columns_to_keep)
results_df = self._util_func.replace_text_in_cols(
results_df, replace_text)
results.append(
(results_df, self._results_form_tag + '_' +
trade_order_name + '_' + met + '_by_' + filt))
return results
class JoinTables(object):
"""Takes in DataFrames which are joined together according to user preferences
"""
def __init__(self, tables_dict={}, scalar=1, round_figures_by=None):
self._tables_dict = tables_dict
self._scalar = scalar
self._round_figures_by = round_figures_by
self._time_series_ops = TimeSeriesOps()
self._util_func = UtilFunc()
def aggregate_tables(self,
df_dict={},
tables_dict={},
round_figures_by=None,
scalar=None):
if tables_dict == {}: tables_dict = self._tables_dict
if round_figures_by is None: round_figures_by = self._round_figures_by
if scalar is None: scalar = self._scalar
joined_results = []
table_name = tables_dict['table_name']
table_list = tables_dict['table_list']
column_list = None
replace_text = None
if 'column_list' in tables_dict.keys():
column_list = tables_dict['column_list']
if 'replace_text' in tables_dict.keys():
replace_text = tables_dict['replace_text']
agg_results = []
for i in range(0, len(table_list)):
table = table_list[i]
if table in df_dict.keys():
df = df_dict[table].copy()
if column_list is not None and column_list != []:
df.columns = [x + ' ' + column_list[i] for x in df.columns]
df = self._util_func.replace_text_in_cols(df, replace_text)
if df is not None:
df = self._time_series_ops.multiply_scalar_dataframe(
df, scalar=scalar)
df = self._time_series_ops.round_dataframe(
df, round_figures_by)
agg_results.append(df)
if agg_results != []:
if len(agg_results) > 1:
df_joined = self._time_series_ops.outer_join(agg_results)
else:
df_joined = agg_results[0]
joined_results.append((df_joined, table_name))
return joined_results
