def __init_by_pattern_id__(self, pattern_id_str: str):
# Example: 1_1_1_AAPL_12_2015-12-03_00:00_2016-01-07_00:00
parts = pattern_id_str.split('_')
self.equity_type_id = int(parts[0])
self.period_id = int(parts[1])
self.period = PRD.get_period(self.period_id)
self.aggregation = int(parts[2])
self.ticker_id = parts[3]
self.pattern_type_id = int(parts[4])
self.pattern_type = FT.get_pattern_type(self.pattern_type_id)
self.range_start_date_str = parts[5]
self.range_start_time_str = parts[6]
self.range_end_date_str = parts[7]
self.range_end_time_str = parts[8]
self.date_start = MyDate.get_datetime_object(self.range_start_date_str)
self.date_end = MyDate.get_datetime_object(self.range_end_date_str)
self.range_length = (self.date_end - self.date_start).days
self.range_id = '{}_{}_{}_{}'.format(self.range_start_date_str,
self.range_start_time_str,
self.range_end_date_str,
self.range_end_time_str)
self.ts_from = MyDate.get_epoch_seconds_from_datetime(parts[5])
self.ts_to = MyDate.get_epoch_seconds_from_datetime(parts[7])
self.range_length_days = int(
(self.ts_to - self.ts_from) / (60 * 60 * 24))
self.and_clause = self.__get_search_and_clause__()
def get_forecast_wave_list(self) -> list:
ts_now = MyDate.get_epoch_seconds_from_datetime(
) # new on 10.01.2019 to avoid forecast in the past
return [
wave for wave in self.__max_position_5_wave_dict.values()
if wave.w_5.tick_end.time_stamp > ts_now
]
def is_wave_indicator_for_dash(self, period_aggregation: int) -> bool:
ts_last_tick = self.w_5.tick_end.time_stamp
ts_now = MyDate.get_epoch_seconds_from_datetime()
number_ticks = int(
30 / period_aggregation) # we want to be reminded for 1/2 hour
# number_ticks = 100
return ts_now - ts_last_tick < period_aggregation * 60 * number_ticks
def fill_test_data_for_fibonacci_desc(tc: TradeTestCase):
tc.symbol = 'ETHUSD'
tc.and_clause = "Date BETWEEN '2018-03-01' AND '2018-06-29'"
tc.time_stamp_start = MyDate.get_epoch_seconds_from_datetime('2018-06-29')
mv = 459807 # mean volume
base_list = [
[BT.BREAKOUT, TSTR.LIMIT, TTC.FALSE_BREAKOUT, [470, 380, 370], mv],
[BT.BREAKOUT, TSTR.LIMIT, TTC.BUY_SELL_LIMIT, [470, 484, 485, 600], mv],
[BT.BREAKOUT, TSTR.LIMIT, TTC.BUY_SELL_STOP_LOSS, [470, 480, 470, 300], mv],
[BT.BREAKOUT, TSTR.TRAILING_STOP, TTC.FALSE_BREAKOUT, [470, 380, 370], mv],
[BT.BREAKOUT, TSTR.TRAILING_STOP, TTC.BUY_ADJUST_STOP_LOSS, [470, 480, 490, 520, 530, 550], mv],
[BT.BREAKOUT, TSTR.TRAILING_STOP, TTC.BUY_SELL_STOP_LOSS, [470, 480, 500, 550, 450], mv],
[BT.BREAKOUT, TSTR.TRAILING_STEPPED_STOP, TTC.FALSE_BREAKOUT, [470, 380, 370], mv],
[BT.BREAKOUT, TSTR.TRAILING_STEPPED_STOP, TTC.BUY_ADJUST_STOP_LOSS, [470, 480, 490, 520, 530, 550], mv],
[BT.BREAKOUT, TSTR.TRAILING_STEPPED_STOP, TTC.BUY_SELL_STOP_LOSS, [470, 480, 500, 550, 450], mv],
[BT.BREAKOUT, TSTR.SMA, TTC.FALSE_BREAKOUT, [470, 380, 370], mv],
[BT.BREAKOUT, TSTR.SMA, TTC.BUY_ADJUST_STOP_LOSS, [470, 484, 485, 600], mv],
[BT.BREAKOUT, TSTR.SMA, TTC.BUY_SELL_STOP_LOSS, [470, 490, 495, 490, 5050, 510, 530, 300], mv],
[BT.TOUCH_POINT, TSTR.LIMIT, TTC.ACTIVATE_BREAKOUT, [406, 410], mv],
[BT.TOUCH_POINT, TSTR.LIMIT, TTC.FALSE_BREAKOUT, [406, 410, 400, 399], mv],
[BT.TOUCH_POINT, TSTR.LIMIT, TTC.BUY_SELL_LIMIT, [406, 410, 412, 471, 609, 610], mv],
[BT.TOUCH_POINT, TSTR.LIMIT, TTC.BUY_SELL_STOP_LOSS, [406, 410, 412, 471, 609, 500], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STOP, TTC.FALSE_BREAKOUT, [406, 410, 400, 399], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STOP, TTC.BUY_ADJUST_STOP_LOSS, [406, 410, 412, 471, 609, 610, 700], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STOP, TTC.BUY_SELL_STOP_LOSS, [406, 410, 412, 471, 609, 500], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STEPPED_STOP, TTC.FALSE_BREAKOUT, [406, 410, 400, 399], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STEPPED_STOP, TTC.BUY_ADJUST_STOP_LOSS, [406, 410, 412, 471, 609, 610, 700], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STEPPED_STOP, TTC.BUY_SELL_STOP_LOSS, [406, 410, 412, 471, 609, 500], mv]
]
TradeTestCaseFactory.add_volume_data_to_base_list(base_list, tc.api.volume_increase)
TradeTestCaseFactory.fill_value_list_from_base_list(base_list, tc)
def fill_test_data_for_triangle_down(tc: TradeTestCase):
tc.symbol = 'ETHUSD'
tc.and_clause = "Date BETWEEN '2018-03-01' AND '2018-07-05'"
tc.time_stamp_start = MyDate.get_epoch_seconds_from_datetime('2018-07-05')
mv = 459807 # mean volume
base_list = [
[BT.BREAKOUT, TSTR.LIMIT, TTC.FALSE_BREAKOUT, [470, 380, 370], mv],
[BT.BREAKOUT, TSTR.LIMIT, TTC.BUY_SELL_LIMIT, [470, 484, 485, 600], mv],
[BT.BREAKOUT, TSTR.LIMIT, TTC.BUY_SELL_STOP_LOSS, [470, 480, 470, 300], mv],
[BT.BREAKOUT, TSTR.TRAILING_STOP, TTC.FALSE_BREAKOUT, [470, 380, 370], mv],
[BT.BREAKOUT, TSTR.TRAILING_STOP, TTC.BUY_ADJUST_STOP_LOSS, [470, 480, 490, 520, 530, 550], mv],
[BT.BREAKOUT, TSTR.TRAILING_STOP, TTC.BUY_SELL_STOP_LOSS, [470, 480, 500, 550, 450], mv],
[BT.BREAKOUT, TSTR.TRAILING_STEPPED_STOP, TTC.FALSE_BREAKOUT, [470, 380, 370], mv],
[BT.BREAKOUT, TSTR.TRAILING_STEPPED_STOP, TTC.BUY_ADJUST_STOP_LOSS, [470, 480, 490, 520, 530, 550], mv],
[BT.BREAKOUT, TSTR.TRAILING_STEPPED_STOP, TTC.BUY_SELL_STOP_LOSS, [470, 480, 500, 550, 450], mv],
[BT.BREAKOUT, TSTR.SMA, TTC.FALSE_BREAKOUT, [470, 380, 370], mv],
[BT.BREAKOUT, TSTR.SMA, TTC.BUY_ADJUST_STOP_LOSS,
TradeTestCaseFactory.get_sma_values(470, 20000, 0.1, 800), mv],
[BT.BREAKOUT, TSTR.SMA, TTC.BUY_SELL_STOP_LOSS,
TradeTestCaseFactory.get_sma_values(470, 20000, 0.1, 500), mv],
[BT.TOUCH_POINT, TSTR.LIMIT, TTC.FALSE_BREAKOUT, [388, 380, 370], mv],
[BT.TOUCH_POINT, TSTR.LIMIT, TTC.ACTIVATE_BREAKOUT, [388, 405, 410], mv],
[BT.TOUCH_POINT, TSTR.LIMIT, TTC.BUY_SELL_LIMIT, [388, 405, 410, 420], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STOP, TTC.FALSE_BREAKOUT, [388, 380, 370], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STOP, TTC.BUY_ADJUST_STOP_LOSS, [388, 405, 410, 420, 430, 440, 450], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STOP, TTC.BUY_SELL_STOP_LOSS, [388, 405, 410, 420, 430, 440, 450, 400], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STEPPED_STOP, TTC.FALSE_BREAKOUT, [388, 380, 370], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STEPPED_STOP, TTC.BUY_ADJUST_STOP_LOSS, [388, 405, 410, 420, 430, 440, 450], mv],
[BT.TOUCH_POINT, TSTR.TRAILING_STEPPED_STOP, TTC.BUY_SELL_STOP_LOSS, [388, 405, 410, 430, 440, 450, 400], mv],
]
TradeTestCaseFactory.add_volume_data_to_base_list(base_list, tc.api.volume_increase)
TradeTestCaseFactory.fill_value_list_from_base_list(base_list, tc)
def add_ticker(self, ticker: Ticker):
api = MyCacheObjectApi()
api.valid_until_ts = MyDate.get_epoch_seconds_from_datetime(
) + self._cache_seconds
api.key = ticker.ticker_id
api.object = ticker
self.add_cache_object(api)
def __check_actual_trades_for_trade_handler_online__(
self, n_intervals: int):
if self._selected_trade_type == TP.ONLINE:
if self._check_actual_trades_for_trade_handler_online_n_intervals != n_intervals:
self._check_actual_trades_for_trade_handler_online_n_intervals = n_intervals
if n_intervals % self.exchange_config.check_ticker_after_timer_intervals == 0:
self._time_stamp_last_ticker_refresh = MyDate.get_epoch_seconds_from_datetime(
)
self.trade_handler_online.check_actual_trades()
def __save_balances_to_database__(self):
if len(self._balance_saving_times) == 0: # already all done
return
processed_list = []
ts_now = MyDate.get_epoch_seconds_from_datetime()
for ts_saving in self._balance_saving_times:
if ts_saving <= ts_now:
dt_saving = MyDate.get_date_time_from_epoch_seconds_as_string(ts_saving)
self.__save_balances__(ts_saving, dt_saving)
processed_list.append(ts_saving)
for values in processed_list:
self._balance_saving_times.remove(values)
def init_by_balance_list(self, balances: list, dedicated_symbol=''):
api = MyCacheObjectApi()
api.valid_until_ts = MyDate.get_epoch_seconds_from_datetime(
) + self._cache_seconds
for balance in balances:
api.key = balance.asset
api.object = balance
self.add_cache_object(api)
if dedicated_symbol != '' and self.get_cached_object_by_key(
dedicated_symbol) is None:
api.key = dedicated_symbol
api.object = Balance('exchange', dedicated_symbol, 0, 0)
self.add_cache_object(api)
def get_balance_as_asset_data_frame(self):
if self.balances is None:
return None
ts = MyDate.get_epoch_seconds_from_datetime()
dt_str = MyDate.get_date_time_from_epoch_seconds_as_string(ts)
dict_for_data_frame = {}
for balance in self.balances:
data_dict = AssetDataDictionary(
).get_data_dict_for_target_table_for_balance(balance, ts, dt_str)
for key, value in data_dict.items():
if key not in dict_for_data_frame:
dict_for_data_frame[key] = [value]
else:
dict_for_data_frame[key].append(value)
return pd.DataFrame.from_dict(dict_for_data_frame)
def check_actual_trades_for_replay(self, wave_tick: WaveTick):
self._last_wave_tick_for_test = wave_tick
self._time_stamp_for_actual_check = MyDate.get_epoch_seconds_from_datetime(
)
if self.trade_numbers == 0:
return
self.process = 'Replay'
self.__add_tickers_for_actual_time_stamp_to_pattern_trades__()
self.__adjust_stops_and_limits__()
self.__calculate_wave_tick_values_for_trade_subprocess__()
self.__handle_sell_triggers__()
self.__set_limit_stop_loss_to_replay_values__()
self.__handle_wrong_breakout__()
self.__handle_buy_triggers__()
self.__calculate_xy_values__(
) # ToDo - what if _calculate_xy_values is before???
self.__calculate_replay_status__()
self.process = ''
def __fill_total_assets_dictionaries__(self):
for trade_client in [TRC.BITFINEX, TRC.IBKR]:
df_with_client = self._df_base[self._df_base[DC.LOCATION] ==
trade_client]
if df_with_client.shape[0] == 0:
self._total_assets_start_dict[trade_client] = 0
self._total_assets_latest_dict[trade_client] = 0
self._total_assets_start_timestamp_dict[
trade_client] = MyDate.get_epoch_seconds_from_datetime()
else:
df_with_client.sort_values(by=[DC.VALIDITY_TS])
grouped_series = df_with_client.groupby(
[DC.VALIDITY_TS])[DC.VALUE_TOTAL].sum()
self._total_assets_start_dict[
trade_client] = grouped_series.iloc[0]
self._total_assets_latest_dict[
trade_client] = grouped_series.iloc[grouped_series.shape[0]
- 1]
self._total_assets_start_timestamp_dict[
trade_client] = grouped_series.index[0]
def get_order_status_by_order_for_simulation(
config: BitfinexConfiguration,
order: Order): # it is used for simulations
order_status = BitfinexOrderStatus()
order_status.order_id = MyDate.get_epoch_seconds_from_datetime()
order_status.symbol = order.symbol
order_status.exchange = 'simulation'
order_status.price = order.price
order_status.avg_execution_price = order.price
order_status.side = order.side
order_status.type = order.type
order_status.executed_amount = order.amount
order_status.original_amount = order.amount
order_status.remaining_amount = 0
order_status.is_cancelled = False
order_status.time_stamp = order_status.order_id
order_status.set_fee_amount(
config.buy_fee_pct
if order.side == OS.BUY else config.sell_fee_pct, True)
return order_status
def check_actual_trades(self, last_wave_tick=None):
if last_wave_tick is not None:
self._last_wave_tick_for_test = last_wave_tick
self._time_stamp_for_actual_check = MyDate.get_epoch_seconds_from_datetime(
)
if self.trade_process == TP.ONLINE:
self.__remove_finished_pattern_trades__()
self.__process_trade_candidates__(
) # take care of old patterns in queue
if self.trade_numbers == 0:
return
self.__print_details_for_check_actual_trades__()
self.process = 'Ticker'
self.__add_tickers_for_actual_time_stamp_to_pattern_trades__()
self.__adjust_stops_and_limits__()
self.__calculate_wave_tick_values_for_trade_subprocess__()
self.__handle_sell_triggers__()
self.__handle_wrong_breakout__()
self.__handle_buy_triggers__()
self.__calculate_xy_values__()
self.__update_ticker_lists__() # some entries could be deleted
self.process = ''
def get_time_stamp_after_ticks(
self,
tick_number: int,
ts_set_off=MyDate.get_epoch_seconds_from_datetime()):
return int(ts_set_off +
tick_number * self.get_seconds_for_one_period())
def ts_breakout(self):
breakout_date_str = self._entity_data_dict[DC.BUY_DT]
breakout_time_str = self._entity_data_dict[DC.BUY_TIME]
return MyDate.get_epoch_seconds_from_datetime('{} {}'.format(
breakout_date_str, breakout_time_str))
def __get_time_stamp_end__(self):
ts_now = MyDate.get_epoch_seconds_from_datetime()
# return ts_now + (self._data_dict.get(DC.TS_PATTERN_TICK_LAST) - self._data_dict.get(DC.TS_PATTERN_TICK_FIRST))
return ts_now + (self._data_dict.get(DC.BUY_TIME_STAMP) -
self._data_dict.get(DC.TS_PATTERN_TICK_FIRST))
def stop(self):
self._end_date_time = MyDate.get_date_time_as_string_from_date_time()
self._end_ts = MyDate.get_epoch_seconds_from_datetime()
