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