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
