def main(coin_name: str, mm1_name: str, mm2_name: str):
Global.configure_default_root_logging(should_log_to_file=False,
log_level=logging.INFO)
SharedMongoClient.initialize(should_use_localhost_db=False)
start_time = Global.convert_local_datetime_to_epoch("2018.08.20 09:00:00",
timezone="kr")
end_time = Global.convert_local_datetime_to_epoch("2018.08.20 13:00:00",
timezone="kr")
iyo_config = Global.read_iyo_setting_config(coin_name)
# set settings // fix manually if you need to
settings = TradeSettingConfig.get_settings(
mm1_name=mm1_name,
mm2_name=mm2_name,
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)
bal_factor_settings = TradeSettingConfig.get_bal_fact_settings(
iyo_config["krw_seq_end"], iyo_config["coin_seq_end"])
ibo_result = InitialBalanceOptimizer.run(settings, bal_factor_settings)
print(ibo_result)
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 fill_empty_orderbook_entry(a_db: str, a_col: str, start_time: int,
end_time: int):
db_client = SharedMongoClient.instance()
a_target_col = db_client[a_db][a_col]
a_cursor = a_target_col.find({
"requestTime": {
"$gte": start_time,
"$lte": end_time
}
}).sort([("requestTime", 1)])
prev_item = None
for item in a_cursor:
if len(item["asks"]) == 0 or len(item["bids"]) == 0:
print(item["requestTime"])
if prev_item is None:
raise Exception("At least first item should not be None")
else:
item["asks"] = prev_item["asks"]
item["bids"] = prev_item["bids"]
SharedMongoClient._async_update(
a_target_col, {"requestTime": item["requestTime"]},
{"$set": item})
prev_item = item
def __init__(self,
target_currency: str,
target_interval_in_sec: int = 5,
should_db_logging: bool = True,
is_backtesting: bool = False,
start_time: int = None,
end_time: int = None):
# init virtual mm when backtesting
v_mm1 = VirtualMarketManager(Market.VIRTUAL_CO, 0.001, 4000000, 0.04,
target_currency)
v_mm2 = VirtualMarketManager(Market.VIRTUAL_GP, 0.00075, 400000, 0.4,
target_currency)
super().__init__(v_mm1, v_mm2, target_currency, target_interval_in_sec,
should_db_logging, is_backtesting, start_time,
end_time)
self.COIN_TRADING_UNIT = 0.0005
self.NEW_SPREAD_THRESHOLD = 0
self.REV_SPREAD_THRESHOLD = 0
self.MARGIN_KRW_THRESHOLD = 0
self.SLIPPAGE_HEDGE = 0 # 향후에 거래량을 보고 결정할 parameter, 0.01로 거래한다는 가정하에 0.03으로 설정
self.REV_FACTOR = 1
# init mongo related
self.mm1_data_col = SharedMongoClient.get_coinone_db()[
self.target_currency + "_orderbook"]
self.mm2_data_col = SharedMongoClient.get_gopax_db()[
self.target_currency + "_orderbook"]
self.mm1_buy_coin_trading_unit = self.mm1.calc_actual_coin_need_to_buy(
self.COIN_TRADING_UNIT)
self.mm2_buy_coin_trading_unit = self.mm2.calc_actual_coin_need_to_buy(
self.COIN_TRADING_UNIT)
def get_orderbook_cursor(cls, mm1: str, mm2: str, coin_name: str,
start_time: int, end_time: int):
db_client = SharedMongoClient.instance()
mm1_col = db_client[mm1][coin_name + "_orderbook"]
mm2_col = db_client[mm2][coin_name + "_orderbook"]
return SharedMongoClient.get_data_from_db(mm1_col, mm2_col, start_time,
end_time)
def main(target_currency: str, mm1_name: str, mm2_name: str, st_local: str,
et_local: str):
Global.configure_default_root_logging(should_log_to_file=False)
SharedMongoClient.initialize(should_use_localhost_db=False)
start_time = Global.convert_local_datetime_to_epoch(st_local,
timezone="kr")
end_time = Global.convert_local_datetime_to_epoch(et_local, timezone="kr")
mm1_taker_fee = Global.read_market_fee(mm1_name, True)
mm1_maker_fee = Global.read_market_fee(mm1_name, False)
mm2_taker_fee = Global.read_market_fee(mm2_name, True)
mm2_maker_fee = Global.read_market_fee(mm2_name, False)
mm1_market = getattr(Market, "VIRTUAL_%s" % mm1_name.upper())
mm2_market = getattr(Market, "VIRTUAL_%s" % mm2_name.upper())
bal_setting = {
'mm1': {
'krw_balance': 0,
'coin_balance': 0.04475666666666667
},
'mm2': {
'krw_balance': 333333.3333333333,
'coin_balance': 0.0
}
}
initial_setting_dict = {
'max_trading_coin': 0.005,
'min_trading_coin': 0,
'new': {
'threshold': 0,
'factor': 1
},
'rev': {
'threshold': 0,
'factor': 1
}
}
mm1 = VirtualMarketManager(mm1_market, mm1_taker_fee, mm1_maker_fee,
bal_setting["mm1"]["krw_balance"],
bal_setting["mm1"]["coin_balance"],
target_currency, True)
mm2 = VirtualMarketManager(mm2_market, mm2_taker_fee, mm2_maker_fee,
bal_setting["mm2"]["krw_balance"],
bal_setting["mm2"]["coin_balance"],
target_currency, True)
mm1_col = SharedMongoClient.get_target_col(mm1_market, target_currency)
mm2_col = SharedMongoClient.get_target_col(mm2_market, target_currency)
mm1_data_cursor, mm2_data_cursor = SharedMongoClient.get_data_from_db(
mm1_col, mm2_col, start_time, end_time)
RfabBacktester(mm1, mm2,
target_currency).run(mm1_data_cursor,
mm2_data_cursor,
initial_setting_dict,
is_running_in_optimizer=False)
def main(target_currency: str, mm1_name: str, mm2_name: str):
Global.configure_default_root_logging(should_log_to_file=False, log_level=logging.INFO)
SharedMongoClient.initialize(should_use_localhost_db=True)
mm1 = Global.get_market_manager(mm1_name)
mm2 = Global.get_market_manager(mm2_name)
RiskFreeArbBotV4(target_currency, mm1, mm2, is_test=True).run()
def get_history_data(settings: dict):
target_currency = settings["target_currency"]
mm1_col = SharedMongoClient.get_target_db(
settings["mm1"]["market_tag"])[target_currency + "_orderbook"]
mm2_col = SharedMongoClient.get_target_db(
settings["mm2"]["market_tag"])[target_currency + "_orderbook"]
return SharedMongoClient.get_data_from_db(mm1_col, mm2_col,
settings["start_time"],
settings["end_time"])
def main(target_currency: str, mm1_name: str, mm2_name: str):
Global.configure_default_root_logging(should_log_to_file=True, log_level=logging.INFO)
SharedMongoClient.initialize(should_use_localhost_db=True)
mm1 = Global.get_market_manager(mm1_name)
mm2 = Global.get_market_manager(mm2_name)
# run TradeStreamer
TradeStreamerV2(mm1=mm1, mm2=mm2, target_currency=target_currency, is_test=False).run()
def main(target_currency: str, mm1: MarketManager, mm2: MarketManager,
mm1_name: str, mm2_name: str, mm1_krw_bal: float, mm1_coin_bal: float,
mm2_krw_bal: float, mm2_coin_bal: float):
Global.configure_default_root_logging(should_log_to_file=False,
log_level=logging.WARNING)
SharedMongoClient.initialize(should_use_localhost_db=False)
trade_streamer = TestTradeStreamer(target_currency, mm1, mm2, mm1_name,
mm2_name, mm1_krw_bal, mm1_coin_bal,
mm2_krw_bal, mm2_coin_bal)
trade_streamer.real_time_streamer()
def main(coin_name: str, mm1_name: str, mm2_name: str, start_time: str,
end_time: str, slicing_interval: int):
Global.configure_default_root_logging(should_log_to_file=False,
log_level=logging.INFO)
SharedMongoClient.initialize(should_use_localhost_db=False)
logging.warning("Nohup conducting -> start_time: %s, end_time: %s" %
(start_time, end_time))
# Global.send_to_slack_channel("IYO Initiated!! start_time: %s, end_time: %s" % (prev_time, cur_time))
start_time = Global.convert_local_datetime_to_epoch(start_time,
timezone="kr")
end_time = Global.convert_local_datetime_to_epoch(end_time, timezone="kr")
# draw iyo_config for bal & factor_setting
iyo_config = Global.read_sliced_iyo_setting_config(coin_name)
logging.critical(
"[%s-%s-%s] IYO conducting -> start_time: %s, end_time: %s" %
(coin_name.upper(), mm1_name.upper(), mm2_name.upper(), start_time,
end_time))
# set settings, bal_fact_settings, factor_settings
settings = TradeSettingConfig.get_settings(
mm1_name=mm1_name,
mm2_name=mm2_name,
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)
bal_factor_settings = TradeSettingConfig.get_bal_fact_settings(
iyo_config["krw_seq_end"], iyo_config["coin_seq_end"])
factor_settings = TradeSettingConfig.get_factor_settings(
mm1_name, mm2_name, coin_name, iyo_config["max_trade_coin_end"],
iyo_config["threshold_end"], iyo_config["appx_unit_coin_price"])
iyo_result = IntegratedYieldOptimizer.run(
settings,
bal_factor_settings,
factor_settings,
is_stat_appender=False,
is_slicing_dur=True,
slicing_interval=slicing_interval)
logging.critical("Final IYO result: %s" % iyo_result)
return iyo_result
def initiate_market_mongo_settings(settings: dict):
target_currency = settings["target_currency"]
mm1 = VirtualMarketManager(settings["mm1"]["market_tag"], settings["mm1"]["min_trading_coin"],
settings["mm1"]["krw_balance"], settings["mm1"]["coin_balance"],
target_currency)
mm2 = VirtualMarketManager(settings["mm2"]["market_tag"], settings["mm2"]["min_trading_coin"],
settings["mm2"]["krw_balance"], settings["mm2"]["coin_balance"],
target_currency)
mm1_col = SharedMongoClient.get_target_col(settings["mm1"]["market_tag"], target_currency)
mm2_col = SharedMongoClient.get_target_col(settings["mm2"]["market_tag"], target_currency)
mm1_data_cursor, mm2_data_cursor = SharedMongoClient.get_data_from_db(mm1_col, mm2_col, settings["start_time"],
settings["end_time"])
return mm1, mm2, mm1_data_cursor, mm2_data_cursor
def get_past_mtcu_spread_info_init_mode(self, anal_start_time: int, anal_end_time: int):
"""mtcu: Min Tradable Coin Unit
"""
logging.warning("Now analyzing past spread infos..plz wait!!\n")
# get OTC from determined combination
otc_result_dict = self.get_otc_result_init_mode(anal_start_time, anal_end_time)
# get mm1, mm2 collection by target_currency
mm1_col = getattr(SharedMongoClient, "get_%s_db" % self.mm1_name)()[self.target_currency + "_orderbook"]
mm2_col = getattr(SharedMongoClient, "get_%s_db" % self.mm2_name)()[self.target_currency + "_orderbook"]
# loop through sliced_oppty_dur and launch backtesting
for trade_type in ["new", "rev"]:
for sliced_time_list in otc_result_dict[trade_type]:
start_time = sliced_time_list[0]
end_time = sliced_time_list[1]
mm1_cursor, mm2_cursor = SharedMongoClient.get_data_from_db(mm1_col, mm2_col, start_time, end_time)
for mm1_data, mm2_data in zip(mm1_cursor, mm2_cursor):
spread_info_dict = MCTSAnalyzer.min_coin_tradable_spread_strategy(
mm1_data, mm2_data, self.mm1.taker_fee, self.mm2.taker_fee, self.streamer_min_trading_coin)
target_spread_info = spread_info_dict[trade_type]
if (target_spread_info.able_to_trade is False) or (target_spread_info.spread_to_trade < 0):
continue
self.rec_instance.spread_dict["init"][trade_type].append({
"spread_to_trade": target_spread_info.spread_to_trade,
"sell_amt": target_spread_info.sell_order_amt,
"buy_amt": target_spread_info.buy_order_amt})
return
def get_latest_orderbook(self):
# get mm1, mm2 collection by target_currency
mm1_col = getattr(SharedMongoClient, "get_%s_db" % self.mm1_name)()[self.target_currency + "_orderbook"]
mm2_col = getattr(SharedMongoClient, "get_%s_db" % self.mm2_name)()[self.target_currency + "_orderbook"]
# get latest db
self.mm1_ob, self.mm2_ob = SharedMongoClient.get_latest_data_from_db(mm1_col, mm2_col)
def calc_krw_coin_exchange_ratio_during_oppty_dur(settings: dict):
mm1_col = SharedMongoClient.get_target_col(
settings["mm1"]["market_tag"], settings["target_currency"])
mm2_col = SharedMongoClient.get_target_col(
settings["mm2"]["market_tag"], settings["target_currency"])
mm1_cursor, mm2_cursor = SharedMongoClient.get_data_from_db(
mm1_col, mm2_col, settings["start_time"], settings["end_time"])
# get average mid exchange krw price in terms of unit coin during designated time_dur
mid_price_list = []
for mm1_data, mm2_data in zip(mm1_cursor, mm2_cursor):
mm1_mid_price, _, _, = BasicAnalyzer.get_orderbook_mid_price(
mm1_data)
mm2_mid_price, _, _, = BasicAnalyzer.get_orderbook_mid_price(
mm2_data)
combined_mid_price = (mm1_mid_price + mm2_mid_price) / 2
mid_price_list.append(combined_mid_price)
return sum(mid_price_list) / len(mid_price_list)
def __init__(self, target_currency: str, mm1: MarketManager,
mm2: MarketManager, is_test: bool):
mm1_name = mm1.get_market_name().lower()
mm2_name = mm2.get_market_name().lower()
if is_test:
self.trade_commander_col = SharedMongoClient.get_test_streamer_db(
)["trade_commander"]
self.balance_commander_col = SharedMongoClient.get_test_streamer_db(
)["balance_commander"]
if not is_test:
self.trade_commander_col = SharedMongoClient.get_streamer_db(
target_currency, mm1_name, mm2_name)["trade_commander"]
self.balance_commander_col = SharedMongoClient.get_streamer_db(
target_currency, mm1_name, mm2_name)["balance_commander"]
self.trade_strategy = MCTSAnalyzer.min_coin_tradable_spread_strategy
super().__init__(mm1, mm2, target_currency)
def __init__(self,
target_currency: str,
target_interval_in_sec: int = 5,
should_db_logging: bool = True,
is_backtesting: bool = False,
is_init_setting_opt: bool = False,
start_time: int = None,
end_time: int = None):
if not is_backtesting:
mm1 = CoinoneMarketManager()
mm2 = GopaxMarketManager()
else:
mm1 = VirtualMarketManager(Market.VIRTUAL_CO, 0.001, 5000000, 0.5,
target_currency)
mm2 = VirtualMarketManager(Market.VIRTUAL_GP, 0.00075, 500000, 5,
target_currency)
super().__init__(mm1, mm2, target_currency, target_interval_in_sec,
should_db_logging, is_backtesting, start_time,
end_time)
self.MAX_COIN_TRADING_UNIT = 1
self.MIN_COIN_TRADING_UNIT = 0
self.MAX_OB_INDEX_NUM = 1
self.NEW_SPREAD_THRESHOLD = 0
self.REV_SPREAD_THRESHOLD = 0
self.NEW_FACTOR = 1
self.REV_FACTOR = 1
self.mm1_data_cur = None
self.mm2_data_cur = None
self.trade_new = 0
self.trade_rev = 0
# init mongo related
self.mm1_data_col = SharedMongoClient.get_coinone_db()[
self.target_currency + "_orderbook"]
self.mm2_data_col = SharedMongoClient.get_gopax_db()[
self.target_currency + "_orderbook"]
self.is_init_setting_opt = is_init_setting_opt
def __init__(self, target_currency: str, mm1: MarketManager, mm2: MarketManager, is_test: bool):
# make instance of handler ref
self.th_instance = Threshold()
self.cond_instance = Condition()
self.rec_instance = Recorder()
# MARKET relevant
self.mm1 = mm1
self.mm2 = mm2
self.is_test = is_test
self.target_currency = target_currency
self.mm1_name = self.mm1.get_market_name().lower()
self.mm2_name = self.mm2.get_market_name().lower()
self.mm1_krw_bal = float(self.mm1.balance.get_available_coin("krw"))
self.mm2_krw_bal = float(self.mm2.balance.get_available_coin("krw"))
self.mm1_coin_bal = float(self.mm1.balance.get_available_coin(target_currency))
self.mm2_coin_bal = float(self.mm2.balance.get_available_coin(target_currency))
# steamer init relevant
if is_test:
self.streamer_db = SharedMongoClient.get_test_streamer_db()
if not is_test:
self.streamer_db = SharedMongoClient.get_streamer_db(self.target_currency, self.mm1_name, self.mm2_name)
# MCTU relevant
self.mm1_ob = None
self.mm2_ob = None
self.streamer_min_trading_coin = None
# TIME relevant
self.streamer_start_time = int(time.time())
self.ocat_rewind_time = None
self._bot_start_time = None
self._settlement_time = None
self.trading_mode_now_time = None
def __init__(self, target_currency: str, mm1: MarketManager,
mm2: MarketManager, is_initiation_mode: bool,
is_trading_mode: bool):
self.streamer_db = SharedMongoClient.get_streamer_db()
self.is_initiation_mode = is_initiation_mode
self.is_trading_mode = is_trading_mode
self.ocat_final_result = None
self.mm1 = mm1
self.mm2 = mm2
self.mm1_name = self.mm1.get_market_name().lower()
self.mm2_name = self.mm2.get_market_name().lower()
self.mm1_krw_bal = float(self.mm1.balance.get_available_coin("krw"))
self.mm2_krw_bal = float(self.mm2.balance.get_available_coin("krw"))
self.mm1_coin_bal = float(
self.mm1.balance.get_available_coin(target_currency))
self.mm2_coin_bal = float(
self.mm2.balance.get_available_coin(target_currency))
self.target_currency = target_currency
self.slicing_interval = Global.read_sliced_iyo_setting_config(
self.target_currency)["slicing_interval"]
self.streamer_start_time = int(time.time())
self.init_s_iyo_rewined_time = int(self.streamer_start_time -
self.INITIATION_REWEIND_TIME)
self.trading_mode_start_time = None
self.trading_mode_s_iyo_rewined_time = None
self._settlement_time = None
self.cur_exhaust_ctrl_stage = 0
self.init_exhaust_ctrl_currency_bal = None
self.cur_exhaust_ctrl_currency_bal = None
def check_empty_data_by_rq_time(db_name: str, col_name: str,
start_time: int, end_time: int):
db_client = SharedMongoClient.instance()
target_col = db_client[db_name][col_name]
target_data_set = target_col.find({
"requestTime": {
"$gte": start_time,
"$lte": end_time
}
}).sort([("requestTime", 1)])
pre_data = None
for data in target_data_set:
if pre_data is None:
pre_data = data
continue
rq_diff = (data["requestTime"] - pre_data["requestTime"])
if rq_diff <= 7:
pre_data = data
else:
logging.info(
"RequestTime Difference observed! requestTime_diff: %d Current: %d, Before: %d"
% (rq_diff, data["requestTime"], pre_data["requestTime"]))
pre_data = data
def __init__(self, target_currency: str, mm1_name: str, mm2_name: str,
start_time: int, end_time: int, is_test: bool):
self.mm1_name = mm1_name
self.mm2_name = mm2_name
self.target_currency = target_currency
self.start_time = start_time
self.end_time = end_time
if is_test:
self.rfab_ledger_col = SharedMongoClient.get_test_streamer_db(
)["rfab_ledger"]
self.transfer_ledger_col = SharedMongoClient.get_test_streamer_db(
)["transfer_ledger"]
self.invest_ledger_col = SharedMongoClient.get_test_streamer_db(
)["invest_ledger"]
else:
self.rfab_ledger_col = SharedMongoClient.get_streamer_db(
target_currency, mm1_name, mm2_name)["rfab_ledger"]
self.transfer_ledger_col = SharedMongoClient.get_streamer_db(
target_currency, mm1_name, mm2_name)["transfer_ledger"]
self.invest_ledger_col = SharedMongoClient.get_streamer_db(
target_currency, mm1_name, mm2_name)["invest_ledger"]
try:
self.file_dir = self.DEFAULT_DIR + '%s_%s_%s_ledger.xlsx' % (
self.target_currency, self.mm1_name, self.mm2_name)
# set workbook
self.target_wb: Workbook = load_workbook(self.file_dir)
# set worksheet
self.rfab_ws: Worksheet = self.target_wb.get_sheet_by_name("rfab")
self.transfer_ws: Worksheet = self.target_wb.get_sheet_by_name(
"transfer")
self.invest_ws: Worksheet = self.target_wb.get_sheet_by_name(
"investment")
except FileNotFoundError:
logging.error(
"Filed Not Found!! Now creating New RFAB ledger xlsx!")
self.write_new_ledger()
def main(coin_name: str, init_time: str, final_time: str):
Global.configure_default_root_logging(should_log_to_file=False,
log_level=logging.INFO)
SharedMongoClient.initialize(should_use_localhost_db=False)
db_client = SharedMongoClient.instance()
time_list = make_time_list(init_time, final_time)
prev_time = None
for cur_time in time_list:
if prev_time is None:
prev_time = cur_time
continue
logging.warning("Nohup conducting -> start_time: %s, end_time: %s" %
(prev_time, cur_time))
# Global.send_to_slack_channel("IYO Initiated!! start_time: %s, end_time: %s" % (prev_time, cur_time))
start_time = Global.convert_local_datetime_to_epoch(prev_time,
timezone="kr")
end_time = Global.convert_local_datetime_to_epoch(cur_time,
timezone="kr")
# draw iyo_config for bal & factor_setting
iyo_config = Global.read_iyo_setting_config(coin_name)
# FIXME: 빗썸 등등 거래소 생긴 날부터는 밑에 주석 쓰기
# rfab_combi_list = Global.get_rfab_combination_list(coin_name)
rfab_combi_list = list(it.combinations(["okcoin", "coinnest"], 2))
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(), start_time, end_time))
# set settings, bal_fact_settings, factor_settings
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)
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"])
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
logging.warning("Nohup done, now conducting next time set!!")
prev_time = cur_time
def add_missing_item_with_plain_copy_prev(a_db: str, a_col: str, b_db: str,
b_col: str, start_time: int,
end_time: int):
db_client = SharedMongoClient.instance()
a_target_col = db_client[a_db][a_col]
b_target_col = db_client[b_db][b_col]
redefined_start_time = start_time
while True:
retry_flag = False
a_cursor = a_target_col.find({
"requestTime": {
"$gte": redefined_start_time,
"$lte": end_time
}
}).sort([("requestTime", 1)])
b_cursor = b_target_col.find({
"requestTime": {
"$gte": redefined_start_time,
"$lte": end_time
}
}).sort([("requestTime", 1)])
a_count = a_cursor.count()
b_count = b_cursor.count()
logging.info("Cursor count: a %d, b %d" % (a_count, b_count))
last_a_item = None
last_b_item = None
for a_item, b_item in zip_longest(a_cursor, b_cursor):
a_rt = a_item["requestTime"]
try:
b_rt = b_item["requestTime"]
except TypeError:
print(b_item)
b_rt = 0
if a_rt != b_rt:
logging.info("Diff: a_rt %d, b_rt %d " % (a_rt, b_rt))
if last_a_item is None or last_b_item is None:
raise Exception(
"At least the first occurrence should be a valid pair!"
)
is_b_older = a_rt > b_rt
if is_b_older:
last_a_item["requestTime"] = b_rt
logging.info("Adding %d item in a_col..." % b_rt)
a_target_col.insert_one(last_a_item)
else:
# if a is older
last_b_item["requestTime"] = a_rt
logging.info("Adding %d item in b_col..." % a_rt)
b_target_col.insert_one(last_b_item)
# redefine start time for cursor re-request
redefined_start_time = min(a_rt, b_rt)
retry_flag = True
break
else:
last_a_item = dict(a_item)
del last_a_item["_id"]
last_b_item = dict(b_item)
del last_b_item["_id"]
if retry_flag:
a_cursor.close()
b_cursor.close()
continue
else:
break
import logging
from config.global_conf import Global
from trader.market_manager.okcoin_market_manager import OkcoinMarketManager
from trader.market_manager.bithumb_market_manager import BithumbMarketManager
from config.shared_mongo_client import SharedMongoClient
from temp.arbbot_ideas.risk_free_arb_bot_v3 import RiskFreeArbBotV3
Global.configure_default_root_logging(should_log_to_file=True, log_level=logging.WARNING)
SharedMongoClient.initialize(should_use_localhost_db=True)
RiskFreeArbBotV3(
target_currency="xrp",
mm1=BithumbMarketManager(),
mm2=OkcoinMarketManager(),
streamer_db=SharedMongoClient.get_streamer_db()
).run()
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")
def _log_order(self, order: Order):
logging.info("[ORDER RESULT]:", order)
if self.should_db_logging:
SharedMongoClient.async_order_insert(order.to_dict())
def _log_trade(self, trade: Trade):
logging.critical("[TRADE RESULT]: ", trade)
if self.should_db_logging:
SharedMongoClient.async_trade_insert(trade.to_dict())
def __init__(self):
Global.configure_default_root_logging(should_log_to_file=True,
log_level=logging.CRITICAL)
SharedMongoClient.initialize(should_use_localhost_db=True)
super().__init__()
import logging
from config.global_conf import Global
from config.trade_setting_config import TradeSettingConfig
from config.shared_mongo_client import SharedMongoClient
from optimizer.initial_setting_optimizer import InitialSettingOptimizer
Global.configure_default_root_logging(should_log_to_file=False, log_level=logging.INFO)
SharedMongoClient.initialize(should_use_localhost_db=False)
start_time = Global.convert_local_datetime_to_epoch("2018.07.11 09:00:00", timezone="kr")
end_time = Global.convert_local_datetime_to_epoch("2018.07.11 14:00:00", timezone="kr")
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)
factor_settings = TradeSettingConfig.get_factor_settings(max_trade_coin_end=0.1,
threshold_end=2500,
appx_unit_coin_price=800000)
ISO_result = InitialSettingOptimizer().run(settings, factor_settings)
print(ISO_result)
def main(mm1: MarketManager, mm2: MarketManager, target_currency: str):
Global.configure_default_root_logging(should_log_to_file=True,
log_level=logging.WARNING)
SharedMongoClient.initialize(should_use_localhost_db=True)
# run TradeStreamer
TradeStreamer(mm1=mm1, mm2=mm2, target_currency=target_currency).run()
