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)
