def test_get_previous_time_frame(): assert get_previous_time_frame(get_config_time_frame(load_test_config()), TimeFrames.ONE_DAY, TimeFrames.ONE_DAY) == TimeFrames.FOUR_HOURS assert get_previous_time_frame( get_config_time_frame(load_test_config()), TimeFrames.ONE_MINUTE, TimeFrames.ONE_MINUTE) == TimeFrames.ONE_MINUTE assert get_previous_time_frame(get_config_time_frame(load_test_config()), TimeFrames.ONE_HOUR, TimeFrames.ONE_HOUR) == TimeFrames.ONE_HOUR assert get_previous_time_frame(get_config_time_frame(load_test_config()), TimeFrames.ONE_MONTH, TimeFrames.ONE_MONTH) == TimeFrames.ONE_DAY
async def test_traded_pairs_with_wildcard(self): config = load_test_config() config[CONFIG_CRYPTO_CURRENCIES] = { "Bitcoin": { "pairs": "*", "quote": "BTC" } } _, exchange_manager = await self.init_default(config=config) assert "ICX/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies[ "Bitcoin"] assert "NEO/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies[ "Bitcoin"] assert "VEN/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies[ "Bitcoin"] assert "XLM/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies[ "Bitcoin"] assert "ONT/BTC" in exchange_manager.exchange_config.traded_cryptocurrencies[ "Bitcoin"] assert "BTC/USDT" not in exchange_manager.exchange_config.traded_cryptocurrencies[ "Bitcoin"] assert "ETH/USDT" not in exchange_manager.exchange_config.traded_cryptocurrencies[ "Bitcoin"] assert "NEO/BNB" not in exchange_manager.exchange_config.traded_cryptocurrencies[ "Bitcoin"] cancel_ccxt_throttle_task() await exchange_manager.stop()
def test_is_in_dev_mode(): config = load_test_config() assert not is_in_dev_mode(config) config[CONFIG_DEBUG_OPTION] = False assert not is_in_dev_mode(config) config[CONFIG_DEBUG_OPTION] = True assert is_in_dev_mode(config)
async def test_traded_pairs_with_invalid_wildcard(self): config = load_test_config() # missing quote key config[CONFIG_CRYPTO_CURRENCIES] = { "Bitcoin": { "pairs": ["*"] }, "Ethereum": { "enabled": True, "pairs": ["*"], "quote": "ETH" } } _, exchange_manager = await self.init_default(config=config) assert "ETC/ETH" in exchange_manager.exchange_config.traded_symbol_pairs assert "ADA/ETH" in exchange_manager.exchange_config.traded_symbol_pairs assert "BNB/ETH" in exchange_manager.exchange_config.all_config_symbol_pairs assert "ADA/ETH" in exchange_manager.exchange_config.all_config_symbol_pairs assert "Ethereum" in exchange_manager.exchange_config.traded_cryptocurrencies # invalid BTC wildcard config assert "Bitcoin" not in exchange_manager.exchange_config.traded_cryptocurrencies cancel_ccxt_throttle_task() await exchange_manager.stop()
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 run_independent_backtesting(data_files, timeout=10, use_loggers=True, run_on_common_part_only=True): independent_backtesting = None try: config_to_use = load_test_config() if use_loggers: init_logger() independent_backtesting = create_independent_backtesting( config_to_use, load_test_tentacles_config(), data_files, "", run_on_common_part_only=run_on_common_part_only) await initialize_and_run_independent_backtesting( independent_backtesting, log_errors=False) await independent_backtesting.join_backtesting_updater(timeout) return independent_backtesting except MissingTimeFrame: # ignore this exception: is due to missing of the only required time frame return independent_backtesting except asyncio.TimeoutError as e: get_logger().exception( e, True, f"Timeout after waiting for backtesting for {timeout} seconds.") # stop backtesting to prevent zombie tasks await stop_independent_backtesting(independent_backtesting) raise except Exception as e: get_logger().exception(e, True, str(e)) # stop backtesting to prevent zombie tasks await stop_independent_backtesting(independent_backtesting) raise
async def _get_tools(symbol="BTC/USDT"): config = test_config.load_test_config() config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO]["USDT"] = 1000 exchange_manager = exchanges.ExchangeManager(config, "binance") exchange_manager.tentacles_setup_config = test_utils_config.get_tentacles_setup_config() # use backtesting not to spam exchanges apis exchange_manager.is_simulated = True exchange_manager.is_backtesting = True backtesting = await backtesting_api.initialize_backtesting( config, exchange_ids=[exchange_manager.id], matrix_id=None, data_files=[ os.path.join(test_config.TEST_CONFIG_FOLDER, "AbstractExchangeHistoryCollector_1586017993.616272.data")]) exchange_manager.exchange = exchanges.ExchangeSimulator(exchange_manager.config, exchange_manager, backtesting) await exchange_manager.exchange.initialize() for exchange_channel_class_type in [exchanges_channel.ExchangeChannel, exchanges_channel.TimeFrameExchangeChannel]: await channel_util.create_all_subclasses_channel(exchange_channel_class_type, exchanges_channel.set_chan, exchange_manager=exchange_manager) trader = exchanges.TraderSimulator(config, exchange_manager) await trader.initialize() mode = Mode.DailyTradingMode(config, exchange_manager) await mode.initialize() # add mode to exchange manager so that it can be stopped and freed from memory exchange_manager.trading_modes.append(mode) # set BTC/USDT price at 1000 USDT trading_api.force_set_mark_price(exchange_manager, symbol, 1000) return mode.producers[0], mode.consumers[0], trader
async def test_traded_pairs_with_add(self): config = load_test_config() config[CONFIG_CRYPTO_CURRENCIES] = { "Bitcoin": { "pairs": "*", "quote": "BTC", "add": ["BTC/USDT"] } } _, exchange_manager = await self.init_default(config=config) assert "ICX/BTC" in exchange_manager.exchange_config.traded_crypto_currencies_pairs[ "Bitcoin"] assert "NEO/BTC" in exchange_manager.exchange_config.traded_crypto_currencies_pairs[ "Bitcoin"] assert "VEN/BTC" in exchange_manager.exchange_config.traded_crypto_currencies_pairs[ "Bitcoin"] assert "XLM/BTC" in exchange_manager.exchange_config.traded_crypto_currencies_pairs[ "Bitcoin"] assert "ONT/BTC" in exchange_manager.exchange_config.traded_crypto_currencies_pairs[ "Bitcoin"] assert "BTC/USDT" in exchange_manager.exchange_config.traded_crypto_currencies_pairs[ "Bitcoin"] assert "ETH/USDT" not in exchange_manager.exchange_config.traded_crypto_currencies_pairs[ "Bitcoin"] assert "NEO/BNB" not in exchange_manager.exchange_config.traded_crypto_currencies_pairs[ "Bitcoin"] await exchange_manager.stop()
async def test_traded_pairs(self): config = load_test_config() config[CONFIG_CRYPTO_CURRENCIES] = { "Neo": { "pairs": ["NEO/BTC"] }, "Ethereum": { "enabled": True, "pairs": ["ETH/USDT"] }, "Icon": { "enabled": False, "pairs": ["ICX/BTC"] } } _, exchange_manager = await self.init_default(config=config) assert exchange_manager.exchange_config.traded_cryptocurrencies == { "Ethereum": ["ETH/USDT"], "Neo": ["NEO/BTC"] } all_pairs = sorted(["NEO/BTC", "ETH/USDT", "ICX/BTC"]) all_enabled_pairs = sorted(["NEO/BTC", "ETH/USDT"]) assert sorted(exchange_manager.exchange_config.traded_symbol_pairs ) == all_enabled_pairs assert sorted(exchange_manager.exchange_config.all_config_symbol_pairs ) == all_pairs cancel_ccxt_throttle_task() await exchange_manager.stop()
async def test_run_independent_backtestings_with_memory_check(): tentacles_setup_config = tentacles_manager_api.create_tentacles_setup_config_with_tentacles( Mode.DailyTradingMode, Strategies.SimpleStrategyEvaluator, Evaluator.RSIMomentumEvaluator, Evaluator.DoubleMovingAverageTrendEvaluator) await memory_check_util.run_independent_backtestings_with_memory_check( test_config.load_test_config(), tentacles_setup_config)
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 init_default(): config = load_test_config() exchange_builder = create_exchange_builder(config, TestExchangeFactory.EXCHANGE_NAME) \ .is_simulated() \ .is_rest_only() return config, exchange_builder
async def test_run_bot(): # avoid web interface in this test WebInterface.enabled = False bot = OctoBot(load_test_config(dict_only=False), ignore_config=True) bot.task_manager.init_async_loop() await start_bot(bot, init_logger()) await asyncio.sleep(10) await stop_bot(bot)
async def init_default(): config = load_test_config() exchange_manager = ExchangeManager(config, TestTradeFactory.EXCHANGE_MANAGER_CLASS_STRING) await exchange_manager.initialize() trader = TraderSimulator(config, exchange_manager) await trader.initialize() return config, exchange_manager, trader
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 test_run_independent_backtestings_with_memory_check(): """ Should always be called first here to avoid other tests' related memory check issues """ staggered_orders_trading.StaggeredOrdersTradingModeProducer.SCHEDULE_ORDERS_CREATION_ON_START = True tentacles_setup_config = tentacles_manager_api.create_tentacles_setup_config_with_tentacles( grid_trading.GridTradingMode ) await memory_check_util.run_independent_backtestings_with_memory_check(test_config.load_test_config(), tentacles_setup_config)
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 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 exchange_builder(request): config = None exchange_name = DEFAULT_EXCHANGE_NAME if hasattr(request, "param"): config, exchange_name = request.param exchange_builder_instance = create_exchange_builder( config if config is not None else load_test_config(), exchange_name).is_simulated().is_rest_only() yield exchange_builder_instance await exchange_builder_instance.exchange_manager.stop()
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): if not config: config = load_test_config() exchange_builder = ExchangeBuilder(config, TestPortfolio.EXCHANGE_NAME).\ is_rest_only().\ is_simulated().\ disable_trading_mode() exchange_manager = await exchange_builder.build() return config, exchange_manager, \ exchange_manager.exchange_personal_data.portfolio_manager, exchange_manager.trader
async def init_default(config=None, simulated=True): if not config: config = load_test_config() exchange_manager = ExchangeManager(config, TestExchangeManager.EXCHANGE_NAME, is_simulated=simulated, is_backtesting=False, rest_only=True) await exchange_manager.initialize() return config, exchange_manager
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 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 test_run_independent_backtestings_with_memory_check(): """ Should always be called first here to avoid other tests' related memory check issues """ tentacles_setup_config = tentacles_manager_api.create_tentacles_setup_config_with_tentacles( Mode.DipAnalyserTradingMode, Strategies.DipAnalyserStrategyEvaluator, TA.KlingerOscillatorReversalConfirmationMomentumEvaluator, TA.RSIWeightMomentumEvaluator) config = test_config.load_test_config() config[commons_constants.CONFIG_TIME_FRAME] = [ commons_enum.TimeFrames.FOUR_HOURS ] await memory_check_util.run_independent_backtestings_with_memory_check( config, tentacles_setup_config)
async def create_minimalist_unconnected_octobot(): # import here to prevent later web interface import issues octobot_instance = octobot.OctoBot(test_config.load_test_config(dict_only=False)) octobot_instance.initialized = True tentacles_config = test_utils_config.load_test_tentacles_config() loaders.reload_tentacle_by_tentacle_class() octobot_instance.task_manager.async_loop = asyncio.get_event_loop() octobot_instance.task_manager.create_pool_executor() octobot_instance.tentacles_setup_config = tentacles_config octobot_instance.configuration_manager.add_element(octobot_constants.TENTACLES_SETUP_CONFIG_KEY, tentacles_config) octobot_instance.exchange_producer = trading_producers.ExchangeProducer(None, octobot_instance, None, False) octobot_instance.evaluator_producer = octobot_producers.EvaluatorProducer(None, octobot_instance) octobot_instance.evaluator_producer.matrix_id = await evaluator_api.initialize_evaluators(octobot_instance.config, tentacles_config) return octobot_instance
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()
async def exchange(exchange_name, backtesting=None, symbol="BTC/USDT"): exchange_manager = None try: config = test_config.load_test_config() config[commons_constants.CONFIG_SIMULATOR][commons_constants.CONFIG_STARTING_PORTFOLIO]["USDT"] = 2000 exchange_manager = exchanges.ExchangeManager(config, exchange_name) # use backtesting not to spam exchanges apis exchange_manager.is_simulated = True exchange_manager.is_backtesting = True backtesting = backtesting or await backtesting_api.initialize_backtesting( config, exchange_ids=[exchange_manager.id], matrix_id=None, data_files=[os.path.join(test_config.TEST_CONFIG_FOLDER, "AbstractExchangeHistoryCollector_1586017993.616272.data")]) exchange_manager.exchange = exchanges.ExchangeSimulator(exchange_manager.config, exchange_manager, backtesting) await exchange_manager.exchange.initialize() for exchange_channel_class_type in [exchanges_channel.ExchangeChannel, exchanges_channel.TimeFrameExchangeChannel]: await channel_util.create_all_subclasses_channel(exchange_channel_class_type, exchanges_channel.set_chan, exchange_manager=exchange_manager) trader = exchanges.TraderSimulator(config, exchange_manager) await trader.initialize() mode = modes.ArbitrageTradingMode(config, exchange_manager) mode.symbol = None if mode.get_is_symbol_wildcard() else symbol await mode.initialize() # add mode to exchange manager so that it can be stopped and freed from memory exchange_manager.trading_modes.append(mode) # set BTC/USDT price at 1000 USDT trading_api.force_set_mark_price(exchange_manager, symbol, 1000) # force triggering_price_delta_ratio equivalent to a 0.2% setting in minimal_price_delta_percent delta_percent = 2 mode.producers[0].inf_triggering_price_delta_ratio = 1 - delta_percent / 100 mode.producers[0].sup_triggering_price_delta_ratio = 1 + delta_percent / 100 yield mode.producers[0], mode.consumers[0], exchange_manager finally: if exchange_manager is not None: for importer in backtesting_api.get_importers(exchange_manager.exchange.backtesting): await backtesting_api.stop_importer(importer) if exchange_manager.exchange.backtesting.time_updater is not None: await exchange_manager.exchange.backtesting.stop() await exchange_manager.stop()