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()