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