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_iyo(cls, settings: dict, bal_factor_settings: dict,
factor_settings: dict, oppty_dur_dict: dict):
db_result = []
for trade_type in ["new", "rev"]:
for time in oppty_dur_dict[trade_type]:
try:
# clone settings, balance factor settings, factor settings with original one
settings_clone = copy.deepcopy(settings)
bal_fact_set_clone = copy.deepcopy(bal_factor_settings)
fact_set_clone = copy.deepcopy(factor_settings)
# apply each oppty duration
settings_clone["start_time"] = time[0]
settings_clone["end_time"] = time[1]
# convert to local time
st_local = Global.convert_epoch_to_local_datetime(
time[0], timezone="kr")
et_local = Global.convert_epoch_to_local_datetime(
time[1], timezone="kr")
logging.error("Now in: [%s] start_time: %s, end_time: %s" %
(trade_type.upper(), st_local, et_local))
# initial dry run -> get new, rev oppty count
new_oppty_count, rev_oppty_count = super().count_oppty_num(
settings_clone, cls.default_initial_setting_dict)
# opt initial settings by oppty
fact_set_clone = cls.opt_factor_settings_by_oppty(
fact_set_clone, new_oppty_count, rev_oppty_count)
# opt balance_settings by oppty
bal_fact_set_clone = cls.opt_balance_settings_by_oppty(
bal_fact_set_clone, new_oppty_count, rev_oppty_count)
# create coin balance proportionate current exchange rate
bal_fact_set_clone = IBO.create_coin_bal_from_krw_bal_by_exchange_rate(
settings_clone, bal_fact_set_clone)
# add init step for balance settings and initial settings
cls.init_initial_step(settings_clone, bal_fact_set_clone,
fact_set_clone)
# run recursive
iyo_opt_result = cls.opt_by_bal_and_init_settings_recursive(
settings_clone, bal_fact_set_clone, fact_set_clone,
settings_clone["depth"])
# append original oppty count to final result
iyo_opt_result["new_oppty_count"] = new_oppty_count
iyo_opt_result["rev_oppty_count"] = rev_oppty_count
db_result.append(iyo_opt_result)
except Exception as e:
logging.error(
"Something went wrong while executing IYO loop!", time,
e)
# finally run IYO Stat appender and return final result
return db_result
def log_init_mode_mctu_info(self):
local_anal_st = Global.convert_epoch_to_local_datetime(
self.ocat_rewind_time, timezone="kr")
local_anal_et = Global.convert_epoch_to_local_datetime(
self.streamer_start_time, timezone="kr")
logging.warning("=========== [MCTU INFO] ==========")
logging.warning("[Anal Duration]: %s - %s" %
(local_anal_st, local_anal_et))
target_dict = self.rec_instance.spread_dict["init"]
for trade_type in target_dict.keys():
logging.warning(
"['%s' SPREAD RECORDER]:\n%s" %
(trade_type.upper(),
self.get_mctu_spread_and_frequency(target_dict[trade_type])))
self.th_instance.NEW["normal"] = float(
input("Decide [NEW] MCTU spread threshold: "))
self.th_instance.NEW["royal"] = float(
input("Decide [NEW] MCTU Royal spread: "))
self.th_instance.REV["normal"] = float(
input("Decide [REV] MCTU spread threshold: "))
self.th_instance.REV["royal"] = float(
input("Decide [REV] MCTU Royal spread: "))
def update_trade_condition_by_mtcu_analyzer(self):
"""mtcu: Min Tradable Coin Unit
"""
mm1_rq = Global.convert_epoch_to_local_datetime(self.mm1_ob["requestTime"], timezone="kr")
mm2_rq = Global.convert_epoch_to_local_datetime(self.mm2_ob["requestTime"], timezone="kr")
logging.warning("[REQUEST TIME] -- mm1: %s, mm2: %s\n" % (mm1_rq, mm2_rq))
# analyze by MCTS
spread_info_dict = MCTSAnalyzer.min_coin_tradable_spread_strategy(self.mm1_ob, self.mm2_ob,
self.mm1.taker_fee,
self.mm2.taker_fee,
self.streamer_min_trading_coin)
new_cond = spread_info_dict["new"].able_to_trade
rev_cond = spread_info_dict["rev"].able_to_trade
logging.warning("========= [OPPTY NOTIFIER] ========")
# if there is no Oppty,
if new_cond is False and rev_cond is False:
self.cond_instance.NEW["is_oppty"] = False
self.cond_instance.NEW["is_royal"] = False
self.cond_instance.REV["is_oppty"] = False
self.cond_instance.REV["is_royal"] = False
logging.error("[WARNING] There is no oppty.. Waiting")
logging.error("=> [NEW] Fail reason: %s" % spread_info_dict["new"].fail_reason)
logging.error("=> [REV] Fail reason: %s\n" % spread_info_dict["rev"].fail_reason)
return
# if oppty (NEW or REV)
for trade_type in spread_info_dict.keys():
if not spread_info_dict[trade_type].able_to_trade:
getattr(self.cond_instance, trade_type.upper())["is_oppty"] = False
getattr(self.cond_instance, trade_type.upper())["is_royal"] = False
continue
logging.critical("[HOORAY] [%s] Oppty detected!!! now evaluating spread infos.." % trade_type.upper())
logging.critical("[SPREAD TO TRADE]: %.4f\n" % spread_info_dict[trade_type].spread_to_trade)
getattr(self.cond_instance, trade_type.upper())["is_oppty"] = True
# if gte royal spread,
if spread_info_dict[trade_type].spread_to_trade >= getattr(self.th_instance, trade_type.upper())["royal"]:
getattr(self.cond_instance, trade_type.upper())["is_royal"] = True
logging.critical("[!CONGRAT!] THIS WAS ROYAL SPREAD!! Now command to trade no matter what!! :D")
else:
getattr(self.cond_instance, trade_type.upper())["is_royal"] = False
# get spread_to_trade list from min_trdble_coin_sprd_list
self.rec_instance.spread_dict["trade"][trade_type].extend(
[{"spread_to_trade": spread_info_dict[trade_type].spread_to_trade,
"sell_amt": spread_info_dict[trade_type].sell_order_amt,
"buy_amt": spread_info_dict[trade_type].buy_order_amt}])
def get_oppty_dur_human_time(oppty_dur_dict: dict, timezone: str):
final_dict = dict()
for key in ["new", "rev"]:
result_list = []
for time_dur in oppty_dur_dict[key]:
human_st = Global.convert_epoch_to_local_datetime(time_dur[0], timezone=timezone)
human_et = Global.convert_epoch_to_local_datetime(time_dur[1], timezone=timezone)
result_list.append([human_st, human_et])
final_dict[key] = result_list
return final_dict
def log_trading_mode_mtcu_info(self, anal_start_time: int, anal_end_time: int):
local_anal_st = Global.convert_epoch_to_local_datetime(anal_start_time, timezone="kr")
local_anal_et = Global.convert_epoch_to_local_datetime(anal_end_time, timezone="kr")
logging.warning("=========== [MCTU INFO] ==========")
logging.warning("[Anal Duration]: %s - %s" % (local_anal_st, local_anal_et))
target_dict = self.rec_instance.spread_dict["trade"]
for trade_type in target_dict.keys():
logging.warning("\n\n[ '%s' SPREAD RECORDER]:\n%s"
% (trade_type.upper(),
self.get_mtcu_spread_and_frequency(target_dict[trade_type])))
def launch_oppty_sliced_iyo(self, anal_start_time: int,
rewinded_time: int):
st_local = Global.convert_epoch_to_local_datetime(rewinded_time,
timezone="kr")
et_local = Global.convert_epoch_to_local_datetime(anal_start_time,
timezone="kr")
logging.critical(
"[%s-%s-%s] Sliced IYO conducting -> , start_time: %s, end_time: %s"
% (self.target_currency.upper(), self.mm1_name.upper(),
self.mm2_name.upper(), st_local, et_local))
# draw iyo_config for bal & factor_setting
sliced_iyo_config = Global.read_sliced_iyo_setting_config(
self.target_currency)
# set settings, bal_fact_settings, factor_settings
settings = TradeSettingConfig.get_settings(
mm1_name=self.mm1_name,
mm2_name=self.mm2_name,
target_currency=self.target_currency,
start_time=rewinded_time,
end_time=anal_start_time,
division=sliced_iyo_config["division"],
depth=sliced_iyo_config["depth"],
consecution_time=sliced_iyo_config["consecution_time"],
is_virtual_mm=True)
bal_factor_settings = TradeSettingConfig.get_bal_fact_settings(
sliced_iyo_config["krw_seq_end"],
sliced_iyo_config["coin_seq_end"])
factor_settings = TradeSettingConfig.get_factor_settings(
self.mm1_name, self.mm2_name, self.target_currency,
sliced_iyo_config["max_trade_coin_end"],
sliced_iyo_config["threshold_end"],
sliced_iyo_config["appx_unit_coin_price"])
try:
slicied_iyo_result = IntegratedYieldOptimizer.run(
settings,
bal_factor_settings,
factor_settings,
is_stat_appender=False,
is_slicing_dur=True,
slicing_interval=sliced_iyo_config["slicing_interval"])
# FIXME: type error는 커서 에러때문에...
except IndexError or TypeError:
slicied_iyo_result = None
return slicied_iyo_result
def _actual_run_in_loop(self):
now_date = int(time.time())
publish_epoch_date_set = self.get_publish_epoch_date_set()
for publish_epoch_date in publish_epoch_date_set:
if (now_date >= publish_epoch_date) \
and (now_date <= publish_epoch_date + (self.interval_time_sec * 2)):
start_time = publish_epoch_date - self.time_dur_to_anal
end_time = publish_epoch_date
logging.critical("OTC activated start_time: %d" % now_date)
# loop through all possible coins and run
final_result = []
for target_currency in list(Global.get_avail_coin_in_list()):
logging.critical("Now conducting %s" %
target_currency.upper())
result_by_one_coin = self.otc_all_mm_comb_by_one_coin(
target_currency, start_time, end_time)
final_result.extend(result_by_one_coin)
# sort by highest to lowest oppty duration
descending_order_result = self.sort_by_logest_oppty_time_to_lowest(
final_result)
top_twenty_descend_order_result = descending_order_result[:20]
# send this final result to slack in form of str
start_local_date = Global.convert_epoch_to_local_datetime(
start_time)
publish_local_date = Global.convert_epoch_to_local_datetime(
publish_epoch_date, timezone="kr")
self.send_result_nicely_to_slack(
top_twenty_descend_order_result, start_local_date,
publish_local_date)
else:
continue
pass
def write_ledger_balance_in_excel(self, target_row: int,
ledger_data: dict):
# write time
self.rfab_ws[
self.LEDGER_COLUMN["time"] +
str(target_row)].value = Global.convert_epoch_to_local_datetime(
ledger_data["time"], timezone="kr")
# write mode_status
self.rfab_ws[self.LEDGER_COLUMN["mode_status"] +
str(target_row)].value = ledger_data["mode_status"]
# write balance
for key1 in ["mm1", "mm2", "total"]:
for key2 in ["krw", "coin"]:
self.rfab_ws[self.LEDGER_COLUMN[key1][key2] +
str(target_row)].value = ledger_data[key1][key2]
import logging
from config.global_conf import Global
from config.shared_mongo_client import SharedMongoClient
from optimizer.integrated_yield_optimizer import IYOStatAppender
Global.configure_default_root_logging(should_log_to_file=False, log_level=logging.INFO)
SharedMongoClient.initialize(should_use_localhost_db=True)
start_time = Global.convert_local_datetime_to_epoch("2018.07.24 11:00:00", timezone="kr")
end_time = Global.convert_local_datetime_to_epoch("2018.07.24 12:00:00", timezone="kr")
db_client = SharedMongoClient.instance()
iyo_col = db_client["statistics"]["iyo"]
iyo_cur = iyo_col.find({
"settings.start_time": {
"$gte": start_time,
"$lte": end_time}}).sort([("start_time", 1)])
for iyo_data in iyo_cur:
logging.critical("Now starting: %s" % Global.convert_epoch_to_local_datetime(iyo_data["settings"]["start_time"]))
stat_result = IYOStatAppender.run(iyo_data=iyo_data)
# append this stat dict to the current IYO_data
db_client["statistics"]["iyo"].update(
{'_id': iyo_data['_id']}, {
'$set': {
'stat': stat_result
}}, upsert=False, multi=False)
logging.critical("Appended Stat result to target IYO_data at MongoDB")
