def calculate_benchmark(self,
trade_order_df=None,
market_df=None,
trade_order_name=None,
market_resample_freq=None,
market_resample_unit=None,
market_offset_ms=None,
resample_how=None):
# if not (self._check_calculate_benchmark(trade_order_name=trade_order_name)): return trade_order_df, market_df
if market_resample_freq is None:
market_resample_freq = self._market_resample_freq
if market_resample_unit is None:
market_resample_unit = self._market_resample_unit
if market_offset_ms is None: market_offset_ms = self._market_offset_ms
if resample_how is None: resample_how = self._resample_how
if market_offset_ms is not None:
market_df.index = market_df.index + timedelta(
milliseconds=market_offset_ms)
if market_resample_freq is not None and market_resample_unit is not None:
market_df = Mediator.get_time_series_ops().resample_time_series(
market_df,
resample_amount=market_resample_freq,
how=resample_how,
unit=market_resample_unit)
return trade_order_df, market_df
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 = Mediator.get_time_series_ops()
self._util_func = Mediator.get_util_func()
def normalize_trade_data(self, df, dataset, data_request):
if df is None: return None
# For cancelled trades the trade price might be recorded as "zero" or a negative price, which is invalid, make these NaNs
if 'executed_price' in df.columns:
# df['executed_price'][df['executed_price'] <= 0] = np.nan
df.loc[df['executed_price'] <= 0, 'executed_price'] = np.nan
# Rename fields if necessary
if 'executed_notional_currency' in df.columns:
df = df.rename(columns={'executed_notional_currency' : 'notional_currency'})
# Convert buy/sell to -1/+1
# TODO do regex/case insensitive version
# vals_to_replace = {'buy': 1, 'sell' : -1, 'Buy' : 1, 'Sell' : -1, 'BUY' : 1, 'SELL' : -1}
# df['side'] = df['side'].map(vals_to_replace)
df['side'].replace('buy', 1, inplace=True)
df['side'].replace('sell', -1, inplace=True)
df['side'].replace('Buy', 1, inplace=True)
df['side'].replace('Sell', -1, inplace=True)
df['side'].replace('BUY', 1, inplace=True)
df['side'].replace('SELL', -1, inplace=True)
if 'event_type' in df.columns:
df['event_type'].replace('execution', 'trade', inplace=True)
# Also assume selected date columns are UTC (eg. benchmark start and finish dates for the orders)
df = Mediator.get_time_series_ops().localize_cols_as_UTC(df, constants.date_columns, index=True).sort_index()
df = self.offset_data_ms(df, data_request)
return df
def __init__(self, trade_order_list=None):
# self.logger = LoggerManager().getLogger(__name__)
if not (isinstance(trade_order_list,
list)) and trade_order_list is not None:
trade_order_list = [trade_order_list]
self._trade_order_list = trade_order_list
self._time_series_ops = Mediator.get_time_series_ops()
def calculate_benchmark(self,
trade_order_df=None,
market_df=None,
trade_order_name=None,
market_resample_freq=None,
market_resample_unit=None,
market_offset_ms=None,
resample_how=None,
price_field=None,
volume_field=None):
# if not (self._check_calculate_benchmark(trade_order_name=trade_order_name)): return trade_order_df, market_df
if market_resample_freq is None:
market_resample_freq = self._market_resample_freq
if market_resample_unit is None:
market_resample_unit = self._market_resample_unit
if market_offset_ms is None: market_offset_ms = self._market_offset_ms
if resample_how is None: resample_how = self._resample_how
if price_field is None: price_field = self._price_field
if volume_field is None: volume_field = self._volume_field
if market_offset_ms is not None:
market_df.index = market_df.index + timedelta(
milliseconds=market_offset_ms)
if market_resample_freq is not None and market_resample_unit is not None:
if not (isinstance(resample_how, list)):
resample_how = [resample_how]
market_df_list = []
for how in resample_how:
market_df_list.append(
Mediator.get_time_series_ops().resample_time_series(
market_df,
resample_amount=market_resample_freq,
how=how,
unit=market_resample_unit,
price_field=price_field,
volume_field=volume_field))
market_df = Mediator.get_time_series_ops().outer_join(
market_df_list)
return trade_order_df, market_df
def normalize_market_data(self, df, dataset, data_request):
df = Mediator.get_time_series_ops().localize_as_UTC(df)
# For each dataset have a different field mapping (get field mapping for that dataset from stored CSV files)
# Convert vendor specific field names to the Cuemacro names
# Convert vendor specific asset names (eg. GBP=) to Cuemacro standard names (GBPUSD)
# The dataset is very dense, we assume it is stored on disk ordered (Arctic only allows this)
# df = df.sort_index()
return self.offset_data_ms(df, data_request)
def __init__(self, trade_order_list=None, metric_name=None, aggregate_by_field=None, aggregation_metric='mean',
tag_value_combinations={}):
if not(isinstance(trade_order_list, list)) and trade_order_list is not None:
trade_order_list = [trade_order_list]
self._trade_order_list = trade_order_list
self._metric_name = metric_name
self._aggregate_by_field = aggregate_by_field
self._aggregation_metric = aggregation_metric
self._results_summary = ResultsSummary()
self._tag_value_combinations = tag_value_combinations
self._trade_order_filter_tag = TradeOrderFilterTag()
self._util_func = Mediator.get_util_func()
self._time_series_ops = Mediator.get_time_series_ops()
def __init__(self, trade_order_list=None, **kwargs):
# self.logger = LoggerManager().getLogger(__name__)
self._trade_order_list = trade_order_list
self._time_series_ops = Mediator.get_time_series_ops()
def __init__(self, **kwargs):
# self.logger = LoggerManager().getLogger(__name__)
self._time_series_ops = Mediator.get_time_series_ops()
def __init__(self):
self._time_series_ops = Mediator.get_time_series_ops()
self._util_func = Mediator.get_util_func()
def get_dataframe_by_key(self,
key,
combined=True,
start_date=None,
finish_date=None):
"""Gets a specific trade/order and combine it into a single DataFrame.
Parameters
----------
key : str
Which market data ticker or trades/order to return
combined : True
Should we combine all the market data for a specific ticker or trades (or orders) into a single DataFrame before returning?
Returns
-------
DataFrame
"""
if key in self._df_dict.keys():
dataframe_key_list = self._df_dict[key]
if 'df' in key:
try:
df = Mediator.get_volatile_cache(
version=tcapy_version).get_dataframe_handle(
Mediator.get_util_func().flatten_list_of_lists(
dataframe_key_list),
burn_after_reading=True)
except Exception as e:
# print("DATAFRAMEHOLDER ERROR" + str(e))
df = dataframe_key_list
if combined:
df = Mediator.get_time_series_ops().concat_dataframe_list(
df)
if df is not None:
if not (df.empty):
df = df.sort_index()
if start_date is not None and finish_date is not None:
df = Mediator.get_time_series_ops(
).filter_start_finish_dataframe(df, start_date,
finish_date)
return df
# elif 'fig' in key:
# try:
# df = self._volatile_cache.get_dataframe_handle(
# self._util_func.flatten_list_of_lists(dataframe_key_list), burn_after_reading=True)
# except:
# df = dataframe_key_list
#
# if combined:
#
# xy_dict = {}
#
# for fig in df:
# for trace in fig['data']:
# name = trace['name']
#
# xy_dict[name + '_x'] = []
# xy_dict[name + '_y'] = []
# xy_dict['trace_name_list'] = []
#
# for fig in df:
# for trace in fig['data']:
# name = trace['name']
#
# xy_dict[name + '_x'].append(trace['x'])
# xy_dict[name + '_y'].append(trace['y'])
#
# if name not in xy_dict['trace_name_list']:
# xy_dict['trace_name_list'].append(name)
#
# fig = df[0]
#
# # aggregate all the x & y values
# for i in range(0, len(fig['data'])):
# name = fig['data'][i]['name']
#
# for j in range(1, len(xy_dict[name + '_x'])):
# fig['data'][i]['x'].extend(xy_dict[name + '_x'])
# fig['data'][i]['y'].extend(xy_dict[name + '_y'])
#
# return fig
else:
# otherwise different type of metadata (don't attempt to combine it)
try:
df = Mediator.get_volatile_cache(
version=tcapy_version).get_dataframe_handle(
Mediator.get_util_func().flatten_list_of_lists(
dataframe_key_list),
burn_after_reading=True)
except Exception as e:
print(e)
df = dataframe_key_list
if isinstance(df, list):
return df[0]
return df
return None
