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
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
def _create_symbol_evaluator(self, symbol, crypto_currency_evaluator) -> SymbolEvaluator:
symbol_evaluator = SymbolEvaluator(self.octobot.get_config(), symbol, crypto_currency_evaluator)
symbol_evaluator.set_traders(self.octobot.get_exchange_traders())
symbol_evaluator.set_trader_simulators(self.octobot.get_exchange_trader_simulators())
crypto_currency_evaluator.add_symbol_evaluator(symbol, symbol_evaluator)
self.symbol_evaluator_list[symbol] = symbol_evaluator
return symbol_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_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 create_evaluation_tasks(self):
self.logger.info("Evaluation threads creation...")
# create dispatchers
self.dispatchers_list = EvaluatorCreator.create_dispatchers(
self.config, self.async_loop)
# create Social and TA evaluators
for crypto_currency, crypto_currency_data in self.config[
CONFIG_CRYPTO_CURRENCIES].items():
# create crypto_currency evaluator
crypto_currency_evaluator = CryptocurrencyEvaluator(
self.config, crypto_currency, self.dispatchers_list,
self.relevant_evaluators)
self.crypto_currency_evaluator_list[
crypto_currency] = crypto_currency_evaluator
self.social_eval_tasks = self.social_eval_tasks + crypto_currency_evaluator.get_social_tasked_eval_list(
)
# create TA evaluators
for symbol in crypto_currency_data[CONFIG_CRYPTO_PAIRS]:
# create symbol evaluator
symbol_evaluator = SymbolEvaluator(self.config, symbol,
crypto_currency_evaluator)
symbol_evaluator.set_traders(self.exchange_traders)
symbol_evaluator.set_trader_simulators(
self.exchange_trader_simulators)
crypto_currency_evaluator.add_symbol_evaluator(
symbol, symbol_evaluator)
self.symbol_evaluator_list[symbol] = symbol_evaluator
for exchange in self.exchanges_list.values():
global_price_updater = self.global_updaters_by_exchange[
exchange.get_name()]
if exchange.get_exchange_manager().enabled():
# Verify that symbol exists on this exchange
if symbol in exchange.get_exchange_manager(
).get_traded_pairs():
self._create_symbol_threads_managers(
exchange, symbol_evaluator,
global_price_updater)
# notify that exchange doesn't support this symbol
else:
if not self.backtesting_enabled:
self.logger.warning(
f"{exchange.get_name()} doesn't support {symbol}"
)
self._check_required_evaluators()
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
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 create_evaluation_threads(self):
self.logger.info("Evaluation threads creation...")
# create dispatchers
self.dispatchers_list = EvaluatorCreator.create_dispatchers(
self.config)
# create Social and TA evaluators
for crypto_currency, crypto_currency_data in self.config[
CONFIG_CRYPTO_CURRENCIES].items():
# create crypto_currency evaluator
crypto_currency_evaluator = CryptocurrencyEvaluator(
self.config, crypto_currency, self.dispatchers_list,
self.relevant_evaluators)
self.crypto_currency_evaluator_list[
crypto_currency] = crypto_currency_evaluator
# create TA evaluators
for symbol in crypto_currency_data[CONFIG_CRYPTO_PAIRS]:
# create symbol evaluator
symbol_evaluator = SymbolEvaluator(self.config, symbol,
crypto_currency_evaluator)
symbol_evaluator.set_traders(self.exchange_traders)
symbol_evaluator.set_trader_simulators(
self.exchange_trader_simulators)
crypto_currency_evaluator.add_symbol_evaluator(
symbol, symbol_evaluator)
self.symbol_evaluator_list[symbol] = symbol_evaluator
for exchange in self.exchanges_list.values():
if exchange.get_exchange_manager().enabled():
# Verify that symbol exists on this exchange
if symbol in exchange.get_exchange_manager(
).get_traded_pairs():
self._create_symbol_threads_managers(
exchange, symbol_evaluator)
# notify that exchange doesn't support this symbol
else:
if not self.backtesting_enabled:
self.logger.warning(
"{0} doesn't support {1}".format(
exchange.get_name(), symbol))
def _get_tools():
config = load_test_config()
symbol = "BTC/USDT"
exchange_traders = {}
exchange_traders2 = {}
time_frame = TimeFrames.FIVE_MINUTES
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()
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 = OctoBot.get_trading_mode_class(config)(config,
exchange_inst)
_ = EvaluatorThreadsManager(config, time_frame,
symbol_time_frame_updater_thread,
symbol_evaluator, exchange_inst,
trading_mode_inst, [])
trading_mode = HighFrequencyMode(config, exchange_inst)
trading_mode.add_symbol_evaluator(symbol_evaluator)
return config, exchange_inst, trader_inst, symbol, trading_mode
def create_evaluation_threads(self):
self.logger.info("Evaluation threads creation...")
# create dispatchers
self.dispatchers_list = EvaluatorCreator.create_dispatchers(self.config)
# create Social and TA evaluators
for crypto_currency, crypto_currency_data in self.config[CONFIG_CRYPTO_CURRENCIES].items():
# create crypto_currency evaluator
crypto_currency_evaluator = CryptocurrencyEvaluator(self.config, crypto_currency, self.dispatchers_list)
self.crypto_currency_evaluator_list[crypto_currency] = crypto_currency_evaluator
# create TA evaluators
for symbol in crypto_currency_data[CONFIG_CRYPTO_PAIRS]:
# create symbol evaluator
symbol_evaluator = SymbolEvaluator(self.config, symbol, crypto_currency_evaluator)
symbol_evaluator.set_traders(self.exchange_traders)
symbol_evaluator.set_trader_simulators(self.exchange_trader_simulators)
crypto_currency_evaluator.add_symbol_evaluator(symbol, symbol_evaluator)
self.symbol_evaluator_list[symbol] = symbol_evaluator
for exchange in self.exchanges_list.values():
if exchange.enabled():
# Verify that symbol exists on this exchange
if symbol in exchange.get_traded_pairs():
self._create_symbol_threads_managers(symbol,
exchange,
symbol_evaluator)
# notify that exchange doesn't support this symbol
else:
if not self.backtesting_enabled:
self.logger.warning("{0} doesn't support {1}".format(exchange.get_name(), symbol))