def test_multiple_multi_symbol_backtestings(): symbols = ["BTC/USDT", "NEO/BTC", "ICX/BTC", "VEN/BTC", "XRB/BTC"] config = create_backtesting_config(load_test_config(), symbols) bot = create_backtesting_bot(config) start_backtesting_bot(bot) for _ in range(MULTIPLE_BACKTESTINGS_ITERATIONS): config = create_backtesting_config(load_test_config(), symbols) bot = create_backtesting_bot(config) start_backtesting_bot(bot)
async def test_multiple_backtestings(): config = create_backtesting_config(load_test_config(), ["ICX/BTC"]) bot = create_backtesting_bot(config) previous_profitability, previous_market_profitability = await start_backtesting_bot(bot) for _ in range(MULTIPLE_BACKTESTINGS_ITERATIONS): config = create_backtesting_config(load_test_config(), ["ICX/BTC"]) bot = create_backtesting_bot(config) current_profitability, current_market_profitability = await start_backtesting_bot(bot) assert previous_profitability == current_profitability assert previous_market_profitability == current_market_profitability
async def test_multiple_multi_symbol_backtestings(): symbols = ["BTC/USDT", "NEO/BTC", "ICX/BTC", "VEN/BTC", "XRB/BTC"] config = create_backtesting_config(load_test_config(), symbols) bot = create_backtesting_bot(config) previous_profitability, previous_market_profitability = await start_backtesting_bot(bot) for _ in range(MULTIPLE_BACKTESTINGS_ITERATIONS): config = create_backtesting_config(load_test_config(), symbols) bot = create_backtesting_bot(config) current_profitability, current_market_profitability = await start_backtesting_bot(bot) assert previous_profitability == current_profitability assert previous_market_profitability == current_market_profitability
async def test_backtesting(): config = create_backtesting_config(load_test_config(), ["ICX/BTC"]) bot = create_backtesting_bot(config) previous_profitability, previous_market_profitability = await start_backtesting_bot( bot) config = create_backtesting_config(load_test_config(), ["ICX/BTC"]) bot = create_backtesting_bot(config) current_profitability, current_market_profitability = await start_backtesting_bot( bot) # ensure no randomness in backtesting assert previous_profitability == current_profitability assert previous_market_profitability == current_market_profitability
def init(self, TA_evaluator_class, data_file=None, test_symbols=["BTC/USDT"]): self.evaluator = TA_evaluator_class() self.config = load_test_config() self.test_symbols = test_symbols self.data_bank = DataBank(self.config, data_file, test_symbols) self._assert_init() self.previous_move_stop = None
async def _get_tools(event_loop): symbol = "BTC/USDT" exchange_traders = {} exchange_traders2 = {} config = load_test_config() time_frame = TimeFrames.ONE_HOUR AdvancedManager.create_class_list(config) exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() global_price_updater = GlobalPriceUpdater(exchange_inst) trader_inst = TraderSimulator(config, exchange_inst, 0.3) trader_inst.stop_order_manager() trader_inst2 = TraderSimulator(config, exchange_inst, 0.3) trader_inst2.stop_order_manager() crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", []) symbol_evaluator = SymbolEvaluator(config, symbol, crypto_currency_evaluator) exchange_traders[exchange_inst.get_name()] = trader_inst exchange_traders2[exchange_inst.get_name()] = trader_inst2 symbol_evaluator.set_trader_simulators(exchange_traders) symbol_evaluator.set_traders(exchange_traders2) symbol_evaluator.strategies_eval_lists[exchange_inst.get_name()] = \ EvaluatorCreator.create_strategies_eval_list(config) trading_mode_inst = get_activated_trading_mode(config)(config, exchange_inst) evaluator_task_manager = EvaluatorTaskManager(config, time_frame, global_price_updater, symbol_evaluator, exchange_inst, trading_mode_inst, [], event_loop) trader_inst.portfolio.portfolio["USDT"] = { Portfolio.TOTAL: 2000, Portfolio.AVAILABLE: 2000 } return evaluator_task_manager, time_frame, global_price_updater, symbol_evaluator, symbol
async def init_default(): config = load_test_config() exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() return config, exchange_manager
async def _get_tools(): symbol = "BTC/USDT" exchange_traders = {} exchange_traders2 = {} config = load_test_config() AdvancedManager.create_class_list(config) exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() trader_inst = TraderSimulator(config, exchange_inst, 0.3) await trader_inst.initialize() trader_inst.stop_order_manager() trader_inst2 = TraderSimulator(config, exchange_inst, 0.3) await trader_inst2.initialize() trader_inst2.stop_order_manager() crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", []) symbol_evaluator = SymbolEvaluator(config, symbol, crypto_currency_evaluator) exchange_traders[exchange_inst.get_name()] = trader_inst exchange_traders2[exchange_inst.get_name()] = trader_inst2 symbol_evaluator.set_trader_simulators(exchange_traders) symbol_evaluator.set_traders(exchange_traders2) symbol_evaluator.strategies_eval_lists[exchange_inst.get_name()] = \ EvaluatorCreator.create_strategies_eval_list(config) trading_mode = DailyTradingMode(config, exchange_inst) trading_mode.add_symbol_evaluator(symbol_evaluator) final_evaluator = trading_mode.get_only_decider_key(symbol) trader_inst.portfolio.portfolio["USDT"] = { Portfolio.TOTAL: 2000, Portfolio.AVAILABLE: 2000 } return final_evaluator, trader_inst
def init_default(): config = load_test_config() exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) exchange_inst = exchange_manager.get_exchange() trader_inst = TraderSimulator(config, exchange_inst, 2) order_inst = Order(trader_inst) return config, order_inst, trader_inst, exchange_inst
def _get_tools(): symbol = "BTC/USDT" exchange_traders = {} exchange_traders2 = {} config = load_test_config() time_frame = TimeFrames.ONE_HOUR AdvancedManager.create_class_list(config) symbol_time_frame_updater_thread = SymbolTimeFramesDataUpdaterThread() exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) exchange_inst = exchange_manager.get_exchange() trader_inst = TraderSimulator(config, exchange_inst, 0.3) trader_inst.stop_order_manager() trader_inst2 = TraderSimulator(config, exchange_inst, 0.3) trader_inst2.stop_order_manager() crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", []) symbol_evaluator = SymbolEvaluator(config, symbol, crypto_currency_evaluator) exchange_traders[exchange_inst.get_name()] = trader_inst exchange_traders2[exchange_inst.get_name()] = trader_inst2 symbol_evaluator.set_trader_simulators(exchange_traders) symbol_evaluator.set_traders(exchange_traders2) symbol_evaluator.strategies_eval_lists[exchange_inst.get_name( )] = EvaluatorCreator.create_strategies_eval_list(config) evaluator_thread_manager = EvaluatorThreadsManager( config, time_frame, symbol_time_frame_updater_thread, symbol_evaluator, exchange_inst, []) trader_inst.portfolio.portfolio["USDT"] = { Portfolio.TOTAL: 2000, Portfolio.AVAILABLE: 2000 } symbol_evaluator.add_evaluator_thread_manager(exchange_inst, time_frame, evaluator_thread_manager) return symbol_evaluator, exchange_inst, time_frame, evaluator_thread_manager
async def test_evaluator_factory_with_multiple_currencies(): eth_crypto_currency = "Ethereum" eth_symbols = ["ETH/USDT", "ETH/BTC", "ETH/BNB", "ETH/EOS"] btc_crypto_currency = "Bitcoin" btc_symbols = ["BTC/USDT", "BTC/BNB"] exchange = "binance" config = load_test_config() config[CONFIG_CRYPTO_CURRENCIES] = { eth_crypto_currency: { CONFIG_CRYPTO_PAIRS: eth_symbols }, btc_crypto_currency: { CONFIG_CRYPTO_PAIRS: btc_symbols } } bot = create_bot_with_config(config) await bot.initialize() # ETH/BNB and ETH/EOS not in symbol list --> 2 of 4 perform_evaluator_factory_tests(bot.evaluator_factory, eth_crypto_currency, "ETH/USDT", exchange, 1, 2, 3, 2) perform_evaluator_factory_tests(bot.evaluator_factory, eth_crypto_currency, "ETH/BTC", exchange, 1, 2, 3, 2) # BTC/BNB not in symbol list --> 1 of 2 perform_evaluator_factory_tests(bot.evaluator_factory, btc_crypto_currency, "BTC/USDT", exchange, 1, 2, 3, 1)
async def _get_tools(): config = load_test_config() symbol = "BTC/USDT" exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() trader_inst = TraderSimulator(config, exchange_inst, 0.3) await trader_inst.portfolio.initialize() trader_inst.stop_order_manager() trader_inst.portfolio.portfolio["SUB"] = { Portfolio.TOTAL: 0.000000000000000000005, Portfolio.AVAILABLE: 0.000000000000000000005 } trader_inst.portfolio.portfolio["BNB"] = { Portfolio.TOTAL: 0.000000000000000000005, Portfolio.AVAILABLE: 0.000000000000000000005 } trader_inst.portfolio.portfolio["USDT"] = { Portfolio.TOTAL: 2000, Portfolio.AVAILABLE: 2000 } trading_mode = MarketMakerTradingMode(config, exchange_inst) return config, exchange_inst, trader_inst, symbol, trading_mode
def _get_tools(): config = load_test_config() AdvancedManager.create_class_list(config) evaluator = Evaluator() evaluator.set_config(config) evaluator.set_symbol("BTC/USDT") evaluator.set_time_frame(TimeFrames.ONE_HOUR) return evaluator, config
async def init_default(): config = load_test_config() exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() trader_inst = Trader(config, exchange_inst, 1) order_manager_inst = trader_inst.get_order_manager() return config, exchange_inst, trader_inst, order_manager_inst
def test_create_dispatchers(event_loop): config = load_test_config() dispatchers = DispatcherCreator.create_dispatchers(config, event_loop) assert len( dispatchers ) == 3 # creates all dispatchers but none is ready (no config for associated services) for dispatcher in dispatchers: assert not dispatcher.get_is_setup_correctly()
def init_default(): config = load_test_config() exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) exchange_inst = exchange_manager.get_exchange() trader_inst = TraderSimulator(config, exchange_inst, 1) portfolio_inst = Portfolio(config, trader_inst) trader_inst.stop_order_manager() sub_portfolio_inst = SubPortfolio(config, trader_inst, portfolio_inst, TestSubPortfolio.DEFAULT_PERCENT) return config, portfolio_inst, exchange_inst, trader_inst, sub_portfolio_inst
def init(self, strategy_evaluator_class, config=None): if config is None: self.config = create_backtesting_config(load_test_config(), filter_symbols=False) else: self.config = config self.strategy_evaluator_class = strategy_evaluator_class self._register_only_strategy(strategy_evaluator_class) self._assert_init()
def create_blank_config_using_loaded_one(loaded_config, other_config=None): new_config = other_config if other_config else load_test_config() trading_mode = deepcopy(loaded_config[CONFIG_TRADING][CONFIG_TRADER_MODE]) risk = deepcopy(loaded_config[CONFIG_TRADING][CONFIG_TRADER_RISK]) new_config[CONFIG_TRADING][CONFIG_TRADER_MODE] = trading_mode new_config[CONFIG_TRADING][CONFIG_TRADER_RISK] = risk new_config[CONFIG_EVALUATOR] = deepcopy(loaded_config[CONFIG_EVALUATOR]) add_config_default_backtesting_values(new_config) return new_config
def init_default(): config = load_test_config() exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) exchange_inst = exchange_manager.get_exchange() trader_inst = Trader(config, exchange_inst, 1) trades_manager_inst = trader_inst.get_trades_manager() return config, exchange_inst, trader_inst, trades_manager_inst
async def test_run_bot(event_loop): # launch a bot config = load_test_config() config[CONFIG_CRYPTO_CURRENCIES] = {"Bitcoin": {"pairs": ["BTC/USDT"]}} bot = OctoBot(config) bot.time_frames = [TimeFrames.ONE_MINUTE] await bot.create_exchange_traders(ignore_config=True) bot.create_evaluation_tasks() await asyncio.sleep(5) await asyncio.get_event_loop().run_in_executor(None, bot.stop_threads)
async def test_run_bot(event_loop): # launch a bot config = load_test_config() config[CONFIG_CRYPTO_CURRENCIES] = {"Bitcoin": {"pairs": ["BTC/USDT"]}} bot = OctoBot(config, ignore_config=True) bot.time_frames = [TimeFrames.ONE_MINUTE] await initialize_bot(bot) await call_stop_later(0.3 * 60, event_loop, bot) await start_bot_with_raise(bot)
def init_default(): config = load_test_config() config[CONFIG_BACKTESTING][CONFIG_ENABLED_OPTION] = True exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) 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
def init_default(): config = load_test_config() config[CONFIG_BACKTESTING][CONFIG_ENABLED_OPTION] = True exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) exchange_inst = exchange_manager.get_exchange() exchange_simulator = exchange_inst.get_exchange() trader_inst = TraderSimulator(config, exchange_inst, 1) return config, exchange_inst, exchange_simulator, trader_inst
def initialize(self, strategy_evaluator_class, trading_mode_class=DailyTradingMode, config=None): if config is None: self.config = create_backtesting_config(load_test_config(), filter_symbols=False) else: self.config = config self.strategy_evaluator_class = strategy_evaluator_class self.trading_mode_class = trading_mode_class self._register_evaluators() self._register_only_strategy(strategy_evaluator_class) self._register_only_trading_mode(trading_mode_class) self._assert_init()
def create_backtesting_config(wanted_symbols=["BTC/USDT"], filter_symbols=True): # launch a bot config = load_test_config() if filter_symbols: filter_wanted_symbols(config, wanted_symbols) # setup backtesting config add_config_default_backtesting_values(config) return config
async def init_default(): config = load_test_config() exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() trader_inst = TraderSimulator(config, exchange_inst, 1) portfolio_inst = Portfolio(config, trader_inst) await portfolio_inst.initialize() trader_inst.stop_order_manager() return config, portfolio_inst, exchange_inst, trader_inst
async def initialize(self, TA_evaluator_class, data_file=None, test_symbols=None): if test_symbols is None: test_symbols = ["BTC/USDT"] self.evaluator = TA_evaluator_class() self.config = load_test_config() self.test_symbols = test_symbols self.data_bank = DataBank(self.config, data_file, test_symbols) await self.data_bank.initialize() self._assert_init() self.previous_move_stop = None
async def _get_tools(event_loop): config = load_test_config() symbol = "BTC/USDT" exchange_traders = {} exchange_traders2 = {} time_frame = TimeFrames.FIVE_MINUTES AdvancedManager.create_class_list(config) exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() symbol_time_frame_updater_thread = GlobalPriceUpdater(exchange_inst) trader_inst = TraderSimulator(config, exchange_inst, 0.3) await trader_inst.initialize() trader_inst.stop_order_manager() trader_inst2 = TraderSimulator(config, exchange_inst, 0.3) await trader_inst2.initialize() trader_inst2.stop_order_manager() trader_inst2.set_enabled(False) trader_inst.portfolio.portfolio["SUB"] = { Portfolio.TOTAL: 0.000000000000000000005, Portfolio.AVAILABLE: 0.000000000000000000005 } trader_inst.portfolio.portfolio["BNB"] = { Portfolio.TOTAL: 0.000000000000000000005, Portfolio.AVAILABLE: 0.000000000000000000005 } trader_inst.portfolio.portfolio["USDT"] = { Portfolio.TOTAL: 2000, Portfolio.AVAILABLE: 2000 } crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", []) symbol_evaluator = SymbolEvaluator(config, symbol, crypto_currency_evaluator) exchange_traders[exchange_inst.get_name()] = trader_inst exchange_traders2[exchange_inst.get_name()] = trader_inst2 symbol_evaluator.set_trader_simulators(exchange_traders) symbol_evaluator.set_traders(exchange_traders2) trading_mode_inst = get_activated_trading_mode(config)(config, exchange_inst) _ = EvaluatorTaskManager(config, time_frame, symbol_time_frame_updater_thread, symbol_evaluator, exchange_inst, trading_mode_inst, [], event_loop) trading_mode = HighFrequencyMode(config, exchange_inst) trading_mode.add_symbol_evaluator(symbol_evaluator) decider = trading_mode.get_only_decider_key(symbol) await decider.initialize() return config, exchange_inst, trader_inst, symbol, trading_mode
def test_run_bot(): # launch a bot config = load_test_config() bot = OctoBot(config) bot.time_frames = [TimeFrames.ONE_MINUTE] bot.create_exchange_traders() bot.create_evaluation_threads() bot.start_threads() # let it start time.sleep(5) # stop the bot bot.stop_threads()
async def _get_tools(): symbol = "BTC/USD" exchange_traders = {} exchange_traders2 = {} config = load_test_config() config[CONFIG_EVALUATOR]["FullMixedStrategiesEvaluator"] = False config[CONFIG_EVALUATOR]["StaggeredStrategiesEvaluator"] = True config[CONFIG_TRADING_TENTACLES]["DailyTradingMode"] = False config[CONFIG_TRADING_TENTACLES]["StaggeredOrdersTradingMode"] = True AdvancedManager.create_class_list(config) exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True) await exchange_manager.initialize() exchange_inst = exchange_manager.get_exchange() trader_inst = TraderSimulator(config, exchange_inst, 0.3) await trader_inst.initialize() trader_inst.stop_order_manager() crypto_currency_evaluator = CryptocurrencyEvaluator(config, "Bitcoin", []) symbol_evaluator = SymbolEvaluator(config, symbol, crypto_currency_evaluator) exchange_traders[exchange_inst.get_name()] = trader_inst symbol_evaluator.set_trader_simulators(exchange_traders) symbol_evaluator.set_traders(exchange_traders2) symbol_evaluator.strategies_eval_lists[exchange_inst.get_name()] = \ EvaluatorCreator.create_strategies_eval_list(config) trading_mode = StaggeredOrdersTradingMode(config, exchange_inst) trading_mode.add_symbol_evaluator(symbol_evaluator) final_evaluator = trading_mode.get_only_decider_key(symbol) trader_inst.register_trading_mode(trading_mode) staggered_strategy_evaluator = symbol_evaluator.strategies_eval_lists[ exchange_inst.get_name()][0] trader_inst.portfolio.portfolio["USD"] = { Portfolio.TOTAL: 1000, Portfolio.AVAILABLE: 1000 } trader_inst.portfolio.portfolio["BTC"] = { Portfolio.TOTAL: 10, Portfolio.AVAILABLE: 10 } final_evaluator.lowest_buy = 1 final_evaluator.highest_sell = 10000 final_evaluator.operational_depth = 50 final_evaluator.spread = 0.06 final_evaluator.increment = 0.04 return final_evaluator, trader_inst, staggered_strategy_evaluator
def test_run_bot(): # launch a bot config = load_test_config() bot = CryptoBot(config) bot.time_frames = [TimeFrames.ONE_MINUTE] bot.create_exchange_traders() bot.create_evaluation_threads() bot.start_threads() # let it run 2 minutes: test will fail if an exception is raised # 1.9 to stop threads before the next time frame time.sleep(1.9*60) # stop the bot bot.stop_threads()
def test_create_bot(): # launch a bot config = load_test_config() bot = CryptoBot(config) bot.stop_threads()
def init_default(): config = load_test_config() exchange_inst = ExchangeSimulator(config, ccxt.binance) trader_inst = TraderSimulator(config, exchange_inst) return config, exchange_inst, trader_inst
def init_default(): config = load_test_config() config[CONFIG_BACKTESTING][CONFIG_ENABLED_OPTION] = True exchange_inst = ExchangeSimulator(config, ccxt.binance) return config, exchange_inst