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
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 = TraderSimulator(config, exchange_inst, 0.3)
await trader.initialize()
trader.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
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 = DipAnalyserTradingMode(config, exchange_inst)
trader.register_trading_mode(trading_mode)
trading_mode.add_symbol_evaluator(symbol_evaluator)
decider = trading_mode.get_only_decider_key(symbol)
creator_key = trading_mode.get_only_creator_key(symbol)
creator = trading_mode.get_creator(symbol, creator_key)
dip_strategy_evaluator = symbol_evaluator.strategies_eval_lists[
exchange_inst.get_name()][0]
trader.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
return decider, creator, dip_strategy_evaluator, trader
async def create_exchange_traders(self, ignore_config=False):
self.async_loop = asyncio.get_running_loop()
available_exchanges = ccxt.exchanges
for exchange_class_string in self.config[CONFIG_EXCHANGES]:
if exchange_class_string in available_exchanges:
exchange_type = getattr(ccxt, exchange_class_string)
# Backtesting Exchange
if self.backtesting_enabled:
exchange_manager = ExchangeManager(self.config,
exchange_type,
is_simulated=True)
else:
# Real Exchange
exchange_manager = ExchangeManager(
self.config,
exchange_type,
is_simulated=False,
ignore_config=ignore_config)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
self.exchanges_list[exchange_inst.get_name()] = exchange_inst
self.global_updaters_by_exchange[exchange_inst.get_name(
)] = GlobalPriceUpdater(exchange_inst)
# create trader instance for this exchange
exchange_trader = Trader(self.config, exchange_inst)
await exchange_trader.initialize()
self.exchange_traders[
exchange_inst.get_name()] = exchange_trader
# create trader simulator instance for this exchange
exchange_trader_simulator = TraderSimulator(
self.config, exchange_inst)
await exchange_trader_simulator.initialize()
self.exchange_trader_simulators[
exchange_inst.get_name()] = exchange_trader_simulator
if not (exchange_trader_simulator.enabled(self.config)
or exchange_trader.enabled(self.config)):
self.logger.error(
f"No trader simulator nor real trader activated on {exchange_inst.get_name()}"
)
# create trading mode
try:
self.trading_mode = get_activated_trading_mode(
self.config)(self.config, exchange_inst)
self.exchange_trading_modes[
exchange_inst.get_name()] = self.trading_mode
self.logger.debug(
f"Using {self.trading_mode.get_name()} trading mode")
except RuntimeError as e:
self.logger.error(e.args[0])
raise e
# register trading modes on traders
exchange_trader.register_trading_mode(self.trading_mode)
exchange_trader_simulator.register_trading_mode(
self.trading_mode)
else:
self.logger.error(
f"{exchange_class_string} exchange not found")