async def _get_tools(): symbol = "BTC/USDT" config = load_test_config() config[CONFIG_SIMULATOR][CONFIG_STARTING_PORTFOLIO][ "SUB"] = 0.000000000000000000005 config[CONFIG_SIMULATOR][CONFIG_STARTING_PORTFOLIO][ "BNB"] = 0.000000000000000000005 config[CONFIG_SIMULATOR][CONFIG_STARTING_PORTFOLIO]["USDT"] = 2000 exchange_manager = ExchangeManager(config, "binance") # use backtesting not to spam exchanges apis exchange_manager.is_simulated = True exchange_manager.is_backtesting = True # no backtesting file provided, except ValueError from initialize with pytest.raises(ValueError): await exchange_manager.initialize() trader = TraderSimulator(config, exchange_manager) await trader.initialize() mode = AbstractTradingMode(config, exchange_manager) consumer = AbstractTradingModeConsumer(mode) return exchange_manager, symbol, consumer
async def test_add_exchange(self): config = await self.init_default() exchange_manager_binance = ExchangeManager(config, "binance") await exchange_manager_binance.initialize() Exchanges.instance().add_exchange(exchange_manager_binance, "") exchange_manager_bitmex = ExchangeManager(config, "bitmex") await exchange_manager_bitmex.initialize() Exchanges.instance().add_exchange(exchange_manager_bitmex, "") exchange_manager_poloniex = ExchangeManager(config, "poloniex") await exchange_manager_poloniex.initialize() Exchanges.instance().add_exchange(exchange_manager_poloniex, "") assert "binance" in Exchanges.instance().exchanges assert "bitmex" in Exchanges.instance().exchanges assert "poloniex" in Exchanges.instance().exchanges assert "test" not in Exchanges.instance().exchanges await exchange_manager_binance.stop() await exchange_manager_bitmex.stop() await exchange_manager_poloniex.stop() cancel_ccxt_throttle_task() # let updaters gracefully shutdown await wait_asyncio_next_cycle()
async def _get_tools(): symbol = "BTC/USDT" config = load_test_config() config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO]["SUB"] = \ 0.000000000000000000005 config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO]["BNB"] = \ 0.000000000000000000005 config[commons_constants.CONFIG_SIMULATOR][ commons_constants.CONFIG_STARTING_PORTFOLIO]["USDT"] = 2000 exchange_manager = ExchangeManager(config, "binance") # use backtesting not to spam exchanges apis exchange_manager.is_simulated = True exchange_manager.is_backtesting = True exchange_manager.backtesting = Backtesting(None, [exchange_manager.id], None, []) await exchange_manager.initialize() trader = TraderSimulator(config, exchange_manager) await trader.initialize() mode = AbstractTradingMode(config, exchange_manager) consumer = AbstractTradingModeConsumer(mode) return exchange_manager, symbol, consumer
async def test_get_exchange(self): config = await self.init_default() exchange_manager_binance = ExchangeManager(config, "binance") await exchange_manager_binance.initialize() Exchanges.instance().add_exchange(exchange_manager_binance, "") exchange_manager_bitmex = ExchangeManager(config, "bitmex") await exchange_manager_bitmex.initialize() Exchanges.instance().add_exchange(exchange_manager_bitmex, "") exchange_manager_poloniex = ExchangeManager(config, "poloniex") await exchange_manager_poloniex.initialize() Exchanges.instance().add_exchange(exchange_manager_poloniex, "") assert Exchanges.instance().get_exchanges_list( "binance")[0].exchange_manager is exchange_manager_binance assert Exchanges.instance().get_exchanges_list( "bitmex")[0].exchange_manager is exchange_manager_bitmex assert Exchanges.instance().get_exchanges_list( "poloniex")[0].exchange_manager is exchange_manager_poloniex with pytest.raises(KeyError): assert Exchanges.instance().get_exchanges_list("test") await exchange_manager_binance.stop() await exchange_manager_bitmex.stop() await exchange_manager_poloniex.stop() cancel_ccxt_throttle_task() # let updaters gracefully shutdown await wait_asyncio_next_cycle()
async def test_get_exchange(self): config = await self.init_default() exchange_manager_binance = ExchangeManager(config, "binance") await exchange_manager_binance.initialize() Exchanges.instance().add_exchange(exchange_manager_binance, "") exchange_manager_bitmex = ExchangeManager(config, "bitmex") await exchange_manager_bitmex.initialize() Exchanges.instance().add_exchange(exchange_manager_bitmex, "") exchange_manager_poloniex = ExchangeManager(config, "poloniex") await exchange_manager_poloniex.initialize() Exchanges.instance().add_exchange(exchange_manager_poloniex, "") assert Exchanges.instance().get_exchanges_list( "binance")[0].exchange_manager is exchange_manager_binance assert Exchanges.instance().get_exchanges_list( "bitmex")[0].exchange_manager is exchange_manager_bitmex assert Exchanges.instance().get_exchanges_list( "poloniex")[0].exchange_manager is exchange_manager_poloniex with pytest.raises(KeyError): assert Exchanges.instance().get_exchanges_list("test") await exchange_manager_binance.stop() await exchange_manager_bitmex.stop() await exchange_manager_poloniex.stop()
async def test_del_exchange(self): config = await self.init_default() exchange_manager_binance = ExchangeManager(config, "binance") await exchange_manager_binance.initialize() Exchanges.instance().add_exchange(exchange_manager_binance, "") exchange_manager_bitmex = ExchangeManager(config, "bitmex") await exchange_manager_bitmex.initialize() Exchanges.instance().add_exchange(exchange_manager_bitmex, "") exchange_manager_poloniex = ExchangeManager(config, "poloniex") await exchange_manager_poloniex.initialize() Exchanges.instance().add_exchange(exchange_manager_poloniex, "") Exchanges.instance().del_exchange("binance", exchange_manager_binance.id) assert "binance" not in Exchanges.instance().exchanges Exchanges.instance().del_exchange("bitmex", exchange_manager_bitmex.id) assert "bitmex" not in Exchanges.instance().exchanges Exchanges.instance().del_exchange("poloniex", exchange_manager_poloniex.id) assert "poloniex" not in Exchanges.instance().exchanges Exchanges.instance().del_exchange("test", "") # should not raise assert Exchanges.instance().exchanges == {} await exchange_manager_binance.stop() await exchange_manager_bitmex.stop() await exchange_manager_poloniex.stop()
async def simulated_exchange_manager(request): config = load_test_config() exchange_name = "binance" if hasattr(request, "param"): config, exchange_name = request.param exchange_manager_instance = ExchangeManager(config, exchange_name) exchange_manager_instance.is_simulated = True await exchange_manager_instance.initialize() yield exchange_manager_instance await exchange_manager_instance.stop()
async def future_exchange_manager(): exchange_manager_instance = ExchangeManager(load_test_config(), DEFAULT_EXCHANGE_NAME) exchange_manager_instance.is_spot_only = False exchange_manager_instance.is_future = True await exchange_manager_instance.initialize() yield exchange_manager_instance cancel_ccxt_throttle_task() await exchange_manager_instance.stop() # let updaters gracefully shutdown await wait_asyncio_next_cycle()
async def init_default(simulated=True): config = load_test_config() exchange_manager = ExchangeManager( config, TestTrader.EXCHANGE_MANAGER_CLASS_STRING) exchange_manager.is_simulated = simulated await exchange_manager.initialize() trader = TraderSimulator(config, exchange_manager) await trader.initialize() return config, exchange_manager, trader
async def init_default(): config = load_test_config() config[CONFIG_BACKTESTING][CONFIG_ENABLED_OPTION] = True exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() exchange_simulator = exchange_inst.get_exchange() exchange_simulator.init_candles_offset([TimeFrames.ONE_HOUR, TimeFrames.FOUR_HOURS, TimeFrames.ONE_DAY], TestExchangeSimulator.DEFAULT_SYMBOL) trader_inst = TraderSimulator(config, exchange_inst, 1) return config, exchange_inst, exchange_simulator, trader_inst
async def init_default(config=None, simulated=True): if not config: config = load_test_config() exchange_manager = ExchangeManager(config, TestExchangeManager.EXCHANGE_NAME) exchange_manager.is_simulated = simulated exchange_manager.is_backtesting = False exchange_manager.rest_only = True await exchange_manager.initialize() return config, exchange_manager
async def backtesting_exchange_manager(request, backtesting_config, fake_backtesting): config = backtesting_config exchange_name = "binance" if hasattr(request, "param"): config, exchange_name = request.param exchange_manager_instance = ExchangeManager(config, exchange_name) exchange_manager_instance.is_backtesting = True exchange_manager_instance.backtesting = fake_backtesting exchange_manager_instance.backtesting.time_manager = TimeManager(config) await exchange_manager_instance.initialize() yield exchange_manager_instance await exchange_manager_instance.stop()
async def init_default(simulated=True): config = load_test_config() exchange_manager = ExchangeManager(config, TestTrader.EXCHANGE_MANAGER_CLASS_STRING) exchange_manager.is_simulated = simulated await exchange_manager.initialize() trader = TraderSimulator(config, exchange_manager) await trader.initialize() # set afterwards backtesting attribute to force orders instant initialization exchange_manager.is_backtesting = True return config, exchange_manager, trader
async def simulated_exchange_manager(request): config = load_test_config() exchange_name = "binance" if hasattr(request, "param"): config, exchange_name = request.param exchange_manager_instance = ExchangeManager(config, exchange_name) exchange_manager_instance.is_simulated = True await exchange_manager_instance.initialize() yield exchange_manager_instance cancel_ccxt_throttle_task() await exchange_manager_instance.stop() # let updaters gracefully shutdown await wait_asyncio_next_cycle()
async def init_default(): config = load_test_config() config[CONFIG_TRADER][CONFIG_ENABLED_OPTION] = True exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() trader_real_inst = Trader(config, exchange_inst, 1) trader_simulator_inst = TraderSimulator(config, exchange_inst, 1) order_manager_inst = trader_real_inst.get_order_manager() order_manager_simulator_inst = trader_simulator_inst.get_order_manager( ) return config, exchange_inst, trader_real_inst, order_manager_inst, trader_simulator_inst, \ order_manager_simulator_inst
def __init__(self, config, exchange_name, is_simulated=False, is_backtesting=False, rest_only=False, is_sandboxed=False, is_collecting=False, exchange_only=False, backtesting_files=None): self.logger = get_logger(self.__class__.__name__) self.config = config self.exchange_name = exchange_name self.is_simulated = is_simulated self.is_backtesting = is_backtesting self.rest_only = rest_only self.is_sandboxed = is_sandboxed self.is_collecting = is_collecting self.backtesting_files = backtesting_files self.exchange_only = exchange_only self.exchange_manager = ExchangeManager( config, exchange_name, is_simulated=is_simulated, is_backtesting=is_backtesting, rest_only=rest_only, is_collecting=is_collecting, exchange_only=exchange_only, backtesting_files=backtesting_files) self.trader: Trader = None
async def init_default(config=None): if not config: config = load_test_config() exchange_manager = ExchangeManager(config, TestExchangeConfig.EXCHANGE_NAME) await exchange_manager.initialize() return config, exchange_manager
async def init_default(): config = load_test_config() exchange_manager = ExchangeManager( config, TestOrderFactory.EXCHANGE_MANAGER_CLASS_STRING) await exchange_manager.initialize() trader = TraderSimulator(config, exchange_manager) await trader.initialize() return config, exchange_manager, trader
async def exchange_manager(request): config = None exchange_name = "binance" if hasattr(request, "param"): config, exchange_name = request.param exchange_manager_instance = ExchangeManager(config if config is not None else load_test_config(), exchange_name) await exchange_manager_instance.initialize() yield exchange_manager_instance await exchange_manager_instance.stop()
async def exchange_manager(request): config = None exchange_name = DEFAULT_EXCHANGE_NAME is_spot = True is_margin = False is_future = False if hasattr(request, "param"): config, exchange_name, is_spot, is_margin, is_future = request.param exchange_manager_instance = ExchangeManager(config if config is not None else load_test_config(), exchange_name) exchange_manager_instance.is_spot_only = is_spot exchange_manager_instance.is_margin = is_margin exchange_manager_instance.is_future = is_future await exchange_manager_instance.initialize() yield exchange_manager_instance cancel_ccxt_throttle_task() await exchange_manager_instance.stop() # let updaters gracefully shutdown await wait_asyncio_next_cycle()
def __init__(self, config, exchange_name): self.logger = get_logger(self.__class__.__name__) self.config: dict = config self.exchange_name: str = exchange_name self.exchange_manager: ExchangeManager = ExchangeManager( self.config, self.exchange_name) self._is_using_trading_modes: bool = True self._matrix_id: str = None self._tentacles_setup_config = None
async def get_exchange_manager(exchange_name, config=None): config = config or load_test_config() if exchange_name not in config[CONFIG_EXCHANGES]: config[CONFIG_EXCHANGES][exchange_name] = {} exchange_manager_instance = ExchangeManager(config, exchange_name) await exchange_manager_instance.initialize() try: yield exchange_manager_instance finally: await exchange_manager_instance.stop() cancel_ccxt_throttle_task() # let updaters gracefully shutdown await wait_asyncio_next_cycle()
async def symbol_data(time_frame): symbol_candles = CandlesManager() await symbol_candles.initialize() symbol_candles.replace_all_candles(_get_candles()) symbol_kline = KlineManager() await symbol_kline.initialize() symbol_kline.kline_update(_get_candle(11)) manager = ExchangeManager({}, "binance") symbol_data = ExchangeSymbolData(manager, "BTC/USDT") tf = TimeFrames(time_frame) symbol_data.symbol_candles[tf] = symbol_candles symbol_data.symbol_klines[tf] = symbol_kline return symbol_data
async def test_get_all_exchanges(self): config = await self.init_default() exchange_manager_binance = ExchangeManager(config, "binance") await exchange_manager_binance.initialize() Exchanges.instance().add_exchange(exchange_manager_binance, "") exchange_manager_bitmex = ExchangeManager(config, "bitmex") await exchange_manager_bitmex.initialize() Exchanges.instance().add_exchange(exchange_manager_bitmex, "") exchange_manager_poloniex = ExchangeManager(config, "poloniex") await exchange_manager_poloniex.initialize() Exchanges.instance().add_exchange(exchange_manager_poloniex, "") exchanges = Exchanges.instance().get_all_exchanges() assert exchanges[0].exchange_manager is exchange_manager_binance assert exchanges[1].exchange_manager is exchange_manager_bitmex assert exchanges[2].exchange_manager is exchange_manager_poloniex await exchange_manager_binance.stop() await exchange_manager_bitmex.stop() await exchange_manager_poloniex.stop()
async def test_add_exchange(self): config = await self.init_default() exchange_manager_binance = ExchangeManager(config, "binance") await exchange_manager_binance.initialize() Exchanges.instance().add_exchange(exchange_manager_binance, "") exchange_manager_bitmex = ExchangeManager(config, "bitmex") await exchange_manager_bitmex.initialize() Exchanges.instance().add_exchange(exchange_manager_bitmex, "") exchange_manager_poloniex = ExchangeManager(config, "poloniex") await exchange_manager_poloniex.initialize() Exchanges.instance().add_exchange(exchange_manager_poloniex, "") assert "binance" in Exchanges.instance().exchanges assert "bitmex" in Exchanges.instance().exchanges assert "poloniex" in Exchanges.instance().exchanges assert "test" not in Exchanges.instance().exchanges await exchange_manager_binance.stop() await exchange_manager_bitmex.stop() await exchange_manager_poloniex.stop()
async def exchange_manager(request): config = None exchange_name = "binance" if hasattr(request, "param"): config, exchange_name = request.param exchange_manager_instance = ExchangeManager( config if config is not None else load_test_config(), exchange_name) await exchange_manager_instance.initialize() yield exchange_manager_instance await exchange_manager_instance.stop() cancel_ccxt_throttle_task() # let updaters gracefully shutdown await wait_asyncio_next_cycle()
def __init__(self, data_file=None): super().__init__() self.data_file = data_file if data_file else "tests/static/AbstractExchangeHistoryCollector_1586017993.616272.data" self.exchange_name = None self.data_importer = ExchangeDataImporter({}, self.data_file) self.default_symbol = "BTC/USDT" self.origin_ohlcv_by_symbol = {} self.candles_managers_by_time_frame = {} self.current_init_indexes_by_time_frame = {} self.current_data = None self.data_by_symbol_by_data_frame = None self.manager = ExchangeManager({}, "binance") self.symbol_data = exchange_data.ExchangeSymbolData( self.manager, self.default_symbol) self.symbol_data.symbol_candles = self.candles_managers_by_time_frame
async def test_ms_timestamp_operations(self): config = await self.init_default() exchange_manager_bitmex = ExchangeManager(config, "bitmex") await exchange_manager_bitmex.initialize() await exchange_manager_bitmex.stop() if os.getenv('CYTHON_IGNORE'): return exchange = exchange_manager_bitmex.exchange with patch.object(exchange, 'get_exchange_current_time', new=get_constant_ms_timestamp): expected_ms_timestamp = MS_TIMESTAMP - TimeFramesMinutes[ TimeFrames.ONE_HOUR] * MSECONDS_TO_MINUTE * 200 assert exchange.get_candle_since_timestamp( TimeFrames.ONE_HOUR, count=200) == expected_ms_timestamp expected_ms_timestamp = MS_TIMESTAMP - TimeFramesMinutes[ TimeFrames.ONE_WEEK] * MSECONDS_TO_MINUTE * 200 assert exchange.get_candle_since_timestamp( TimeFrames.ONE_WEEK, count=200) == expected_ms_timestamp expected_ms_timestamp = MS_TIMESTAMP - TimeFramesMinutes[ TimeFrames.ONE_MONTH] * MSECONDS_TO_MINUTE * 2000 assert exchange.get_candle_since_timestamp( TimeFrames.ONE_MONTH, count=2000) == expected_ms_timestamp expected_ms_timestamp = MS_TIMESTAMP - TimeFramesMinutes[ TimeFrames.ONE_MINUTE] * MSECONDS_TO_MINUTE * 10 assert exchange.get_candle_since_timestamp( TimeFrames.ONE_MINUTE, count=10) == expected_ms_timestamp expected_ms_timestamp = MS_TIMESTAMP - TimeFramesMinutes[ TimeFrames.ONE_MINUTE] * MSECONDS_TO_MINUTE * 0 assert exchange.get_candle_since_timestamp( TimeFrames.ONE_MINUTE, count=0) == expected_ms_timestamp # 2000 months into the future expected_ms_timestamp = MS_TIMESTAMP + TimeFramesMinutes[ TimeFrames.ONE_MONTH] * MSECONDS_TO_MINUTE * 2000 assert exchange.get_candle_since_timestamp( TimeFrames.ONE_MONTH, count=-2000) == expected_ms_timestamp
async def backtesting_exchange_manager(request, backtesting_config, fake_backtesting): config = None exchange_name = DEFAULT_EXCHANGE_NAME is_spot = True is_margin = False is_future = False if hasattr(request, "param"): config, exchange_name, is_spot, is_margin, is_future = request.param if config is None: config = backtesting_config exchange_manager_instance = ExchangeManager(config, exchange_name) exchange_manager_instance.is_backtesting = True exchange_manager_instance.is_spot_only = is_spot exchange_manager_instance.is_margin = is_margin exchange_manager_instance.is_future = is_future exchange_manager_instance.backtesting = fake_backtesting exchange_manager_instance.backtesting.time_manager = backtesting_time.TimeManager(config) await exchange_manager_instance.initialize() yield exchange_manager_instance await exchange_manager_instance.stop()
async def exchange_manager(config=None, exchange_name="binance"): exchange_manager_instance = ExchangeManager(config if config is not None else load_test_config(), exchange_name) await exchange_manager_instance.initialize() yield exchange_manager_instance await exchange_manager_instance.stop()