def trading_mode_looper(self): trading_loop_count = 0 while True: # check if reached settlement time if self.trading_mode_now_time > self._settlement_time: self.settlement_handler() break try: # update balance & time self.trading_mode_now_time = int(time.time()) # run trading_mode trading_loop_count += 1 self.run_trading_mode_analysis(trading_loop_count) # log rev ledger info self.log_balance_tracker() # sleep by Trading Mode Loop Interval self.trading_mode_loop_sleep_handler(self.trading_mode_now_time, int(time.time()), self.TRADING_MODE_LOOP_INTERVAL) except Exception as e: log = "Error occured while executing Trade Streamer - Trading mode..\n" + str(e) logging.error(log) Global.send_to_slack_channel(Global.SLACK_STREAM_STATUS_URL, log)
def iyo_result_to_mongo_db(coin_name: str, start_time: int, end_time: int): Global.configure_default_root_logging(should_log_to_file=False, log_level=logging.CRITICAL) SharedMongoClient.initialize(should_use_localhost_db=True) db_client = SharedMongoClient.instance() # convert epoch time to local_time and log local_st = Global.convert_epoch_to_local_datetime(start_time, timezone="kr") local_et = Global.convert_epoch_to_local_datetime(end_time, timezone="kr") # create combination of coin that is injected by validating if the exchange has that coin rfab_combi_list = Global.get_rfab_combination_tuples(coin_name) for _combi in rfab_combi_list: logging.critical( "[%s-%s-%s] IYO conducting -> start_time: %s, end_time: %s" % (coin_name.upper(), str(_combi[0]).upper(), str( _combi[1]).upper(), local_st, local_et)) # draw iyo_config for bal & factor_setting iyo_config = Global.read_iyo_setting_config(coin_name) settings = TradeSettingConfig.get_settings( mm1_name=_combi[0], mm2_name=_combi[1], target_currency=coin_name, start_time=start_time, end_time=end_time, division=iyo_config["division"], depth=iyo_config["depth"], consecution_time=iyo_config["consecution_time"], is_virtual_mm=True) # todo bal_factor_settings = TradeSettingConfig.get_bal_fact_settings( iyo_config["krw_seq_end"], iyo_config["coin_seq_end"]) factor_settings = TradeSettingConfig.get_factor_settings( _combi[0], _combi[1], coin_name, iyo_config["max_trade_coin_end"], iyo_config["threshold_end"], iyo_config["appx_unit_coin_price"]) try: iyo_result = IntegratedYieldOptimizer.run( settings, bal_factor_settings, factor_settings) # finally save to mongoDB if len(iyo_result) > 0: db_client["statistics"]["iyo"].insert_many(iyo_result) else: logging.critical( "There was no oppty!! Skipping to next combination!") continue except TypeError as e: Global.send_to_slack_channel( Global.SLACK_BOT_STATUS_URL, "Something went wrong in IYO Schduler! >> %s" % e) pass
def run(self): # log initial balance logging.info( "========== [ INITIAL BALANCE ] ========================================================" ) logging.info(self.mm1.get_balance()) logging.info(self.mm2.get_balance()) # if not backtesting if not self.is_backtesting: while True: try: self.execute_trade_loop() except Exception as e: Global.send_to_slack_channel( "Something happened to StatArbBot! Now it's dying from ... %s" % e) # stop order watcher stats thread OrderWatcherStats.instance().tear_down() raise e # if backtesting else: # collect historical data from db logging.info("Collecting historical data, please wait...") mm1_data_cursor, mm2_data_cursor = \ self.get_data_from_db(self.mm1_data_col, self.mm2_data_col, self.start_time, self.end_time) # loop through history data for mm1_data, mm2_data in zip(mm1_data_cursor, mm2_data_cursor): self.execute_trade_loop(mm1_data, mm2_data) # log backtesting result self.log_common_stat(log_level=logging.CRITICAL)
def settlement_handler(self): message = "Settlement reached!! now closing Trade Streamer!!" logging.warning(message) Global.send_to_slack_channel(Global.SLACK_STREAM_STATUS_URL, message) # set settle cond True self.cond_instance.is_settlement = True # command Acutal Trader to stop self.update_trade_commander_to_user_mongo()
def send_result_nicely_to_slack(cls, final_sorted_list: list, start_date: str, end_date: str): to_be_sent = str("[OTC start date: %s, end date: %s]\n" % (start_date, end_date)) for result in final_sorted_list: new_percent = (result["new"] / cls.time_dur_to_anal) * 100 rev_percent = (result["rev"] / cls.time_dur_to_anal) * 100 to_be_sent += ("[%s]\n NEW: %.2f%%, REV: %.2f%%\n" % (result["combination"], new_percent, rev_percent)) Global.send_to_slack_channel(Global.SLACK_OTC_SCHEDUELR_URL, to_be_sent)
def run(self): # do nothing if the market of order is not watchable if not self.is_watchable(self.order): return # add in order watcher stats OrderWatcherStats.started(self.order.order_id) # log initial time initial_time = time.time() try: while (self.order.status is not OrderStatus.FILLED) and ( self.order.status is not OrderStatus.CANCELLED): start_time = time.time() self.do_interval() end_time = time.time() # if current time has exceeded the max_wait_sec if not self.is_delayed: time_check = end_time - initial_time if time_check > self.delayed_flag_sec: self.is_delayed = True OrderWatcherStats.delayed(self.order.order_id) message = "Order %s has exceeded delayed flag time! " \ "Counter measures are expected to be executed manually!" % self.order.order_id logging.critical(message) Global.send_to_slack_channel( Global.SLACK_BOT_STATUS_URL, message) # wait for the target interval wait_time = self.interval_sec - (end_time - start_time) if wait_time > 0: time.sleep(wait_time) # if it is filled if self.order.status is OrderStatus.FILLED: OrderWatcherStats.done(self.order.order_id) # if sell, krw as fee # if buy, coin as fee if self.order.is_sell_order(): GlobalFeeAccumulator.add_fee_expenditure( self.order.market, "krw", self.order.fee) else: GlobalFeeAccumulator.add_fee_expenditure( self.order.market, self.order.currency.name.lower(), self.order.fee) elif self.order.status is OrderStatus.CANCELLED: OrderWatcherStats.cancelled(self.order.order_id) except Exception as e: # if there was any error for some unexpected reasons OrderWatcherStats.error(self.order.order_id) logging.error(e)
def settlement_handler(self): logging.critical("Settlement Reached! Stopping RFAB Actual Trader") logging.warning( "========== [ SETTLEMENT BALANCE ] ========================================================") logging.warning(self.mm1.get_balance()) logging.warning(self.mm2.get_balance()) # send to Slack Global.send_to_slack_channel(Global.SLACK_BOT_STATUS_URL, "Settlement Reached! Stopping RFAB Actual Trader") # teardown OrderWatcher OrderWatcherStats.instance().tear_down()
def execute_trade_loop(self, mm1_data=None, mm2_data=None): if not self.is_backtesting: self.trade_loop_start() # refresh cur_trade self.cur_trade = None try: self.actual_trade_loop(mm1_data, mm2_data) except Exception as e: log = "Error occured while executing trade loop.." + str(e) logging.error(log) Global.send_to_slack_channel(Global.SLACK_BOT_STATUS_URL, log) if not self.is_backtesting: self.trade_loop_end()
def trade_handler_when_settlement_reached(self): logging.critical("Bot reached settlement time!! closing trade...") self.streamer_db["fti_setting"].insert({ "no_oppty": False, "settlement": True, "fti_iyo_list": [] }) # reset actual_trader_starter self.reset_acutal_trader_starter() # send to Slack Global.send_to_slack_channel( Global.SLACK_STREAM_STATUS_URL, "Settlement reached for [%s-%s-%s] RFAB! Closing Trade Streamer.." % (self.target_currency.upper(), self.mm1_name.upper(), self.mm2_name.upper()))
def settlement_handler(self): message = "Settlement reached!! now closing Trade Streamer!!" logging.warning(message) Global.send_to_slack_channel(Global.SLACK_STREAM_STATUS_URL, message) # set settle cond True self.cond_instance.is_settlement = True # command Acutal Trader to stop self.post_settlement_commander() # wait until Acutal Trader stops trading (in case actual balance unmatch) time.sleep(self.TRADING_MODE_LOOP_INTERVAL) # post settled balance info to MongoDB self.update_balance(mode_status="settlement") self.update_and_post_all_ledgers(mode_status="settlement")
def run(self, initial_setting_dict: dict): # log initial balance logging.info( "========== [ INITIAL BALANCE ] ========================================================" ) logging.info(self.mm1.get_balance()) logging.info(self.mm2.get_balance()) # launch RFAB Trade Streamer while True: try: self.execute_trade_loop() except Exception as e: Global.send_to_slack_channel( "Something happened to RFAB! Now it's dying from ... %s" % e) # stop order watcher stats thread OrderWatcherStats.instance().tear_down() raise e
def run(self): # log initial balance logging.info( "========== [ INITIAL BALANCE ] ========================================================" ) logging.info(self.mm1.get_balance()) logging.info(self.mm2.get_balance()) # if not backtesting if not self.is_backtesting: while True: try: self.execute_trade_loop() except Exception as e: Global.send_to_slack_channel( "Something happened to StatArbBot! Now it's dying from ... %s" % e) # stop order watcher stats thread OrderWatcherStats.instance().tear_down() raise e # if backtesting else: self.mm1.clear_balance() self.mm2.clear_balance() self.clear_oppty_counter() self.trade_manager.clear_trade_count() print(self.trade_new) # collect historical data from db # If there is no data if not RiskFreeArbBot2.IS_DATA_EXIST: RiskFreeArbBot2.mm1_data_cur, RiskFreeArbBot2.mm2_data_cur = self.get_data_from_db( self.mm1_data_col, self.mm2_data_col, self.start_time, self.end_time) RiskFreeArbBot2.IS_DATA_EXIST = True self.mm1_data_cur = RiskFreeArbBot2.mm1_data_cur.clone() self.mm2_data_cur = RiskFreeArbBot2.mm2_data_cur.clone() # loop through historical data for mm1_data, mm2_data in zip(self.mm1_data_cur, self.mm2_data_cur): self.execute_trade_loop(mm1_data, mm2_data) # log backtesting result if not self.is_init_setting_opt: self.log_common_stat(log_level=logging.CRITICAL) # when initial setting opt else: self.log_common_stat(log_level=logging.CRITICAL) self.total_krw_bal = self.get_krw_total_balance() self.trade_new = self.trade_manager.get_trade_count( TradeTag.NEW) self.trade_rev = self.trade_manager.get_trade_count( TradeTag.REV) last_trade = self.trade_manager.get_last_trade() if last_trade: last_trade_dict = last_trade.to_dict() print("last trade") buy_order = last_trade_dict["orders"][0] sell_order = last_trade_dict["orders"][1] print((sell_order.price - buy_order.price) * buy_order.order_amount)