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