def __init__(self, config, crypto_currency, dispatchers_list):
self.crypto_currency = crypto_currency
self.trader_simulator = None
self.config = config
self.traders = None
self.trader_simulators = None
self.finalize_enabled = False
self.dispatchers_list = dispatchers_list
self.evaluator_threads = []
self.matrix = EvaluatorMatrix()
self.social_eval_list = EvaluatorCreator.create_social_eval(
self.config, self.crypto_currency, self.dispatchers_list)
self.social_not_threaded_list = EvaluatorCreator.create_social_not_threaded_list(
self.social_eval_list)
self.strategies_eval_list = EvaluatorCreator.create_strategies_eval_list(
self.config)
self.social_evaluator_refresh = SocialEvaluatorNotThreadedUpdateThread(
self.social_not_threaded_list)
self.global_social_updater = SocialGlobalUpdaterThread(self)
self.evaluator_order_creator = EvaluatorOrderCreator()
self.final_evaluator = FinalEvaluator(self)
def __init__(self,
config,
crypto_currency,
dispatchers_list,
relevant_evaluators=None):
if relevant_evaluators is None:
relevant_evaluators = CONFIG_EVALUATORS_WILDCARD
self.config = config
self.crypto_currency = crypto_currency
self.dispatchers_list = dispatchers_list
self.symbol_evaluator_list = {}
if Backtesting.enabled(self.config):
self.social_eval_list = []
self.social_not_tasked_list = []
else:
self.social_eval_list = EvaluatorCreator.create_social_eval(
self.config, self.crypto_currency, self.dispatchers_list,
relevant_evaluators)
self.social_not_tasked_list = EvaluatorCreator.create_social_not_tasked_list(
self.social_eval_list)
self.social_evaluator_refresh_task = SocialEvaluatorNotTaskedUpdateTask(
self.social_not_tasked_list)
def __init__(self, config):
self.start_time = time.time()
self.config = config
self.startup_config = copy.deepcopy(config)
self.edited_config = copy.deepcopy(config)
self.ready = False
self.watcher = None
# tools: used for alternative operations on a bot on the fly (ex: backtesting started from web interface)
self.tools = {
BOT_TOOLS_BACKTESTING: None,
BOT_TOOLS_STRATEGY_OPTIMIZER: None,
BOT_TOOLS_RECORDER: None,
}
# Logger
self.logger = get_logger(self.__class__.__name__)
# Advanced
AdvancedManager.init_advanced_classes_if_necessary(self.config)
# Debug tools
self.performance_analyser = None
if CONFIG_DEBUG_OPTION_PERF in self.config and self.config[
CONFIG_DEBUG_OPTION_PERF]:
self.performance_analyser = PerformanceAnalyser()
# Init time frames using enabled strategies
EvaluatorCreator.init_time_frames_from_strategies(self.config)
self.time_frames = TimeFrameManager.get_config_time_frame(self.config)
# Init relevant evaluator names list using enabled strategies
self.relevant_evaluators = EvaluatorCreator.get_relevant_evaluators_from_strategies(
self.config)
# Backtesting
self.backtesting_enabled = Backtesting.enabled(self.config)
# Add services to self.config[CONFIG_CATEGORY_SERVICES]
ServiceCreator.create_services(self.config, self.backtesting_enabled)
# Notifier
self.config[CONFIG_NOTIFICATION_INSTANCE] = Notification(self.config)
# Notify starting
if self.config[CONFIG_NOTIFICATION_INSTANCE].enabled(
CONFIG_NOTIFICATION_GLOBAL_INFO):
self.config[CONFIG_NOTIFICATION_INSTANCE].notify_with_all(
NOTIFICATION_STARTING_MESSAGE, False)
self.symbol_threads_manager = {}
self.exchange_traders = {}
self.exchange_trader_simulators = {}
self.trading_mode = None
self.exchange_trading_modes = {}
self.exchanges_list = {}
self.symbol_evaluator_list = {}
self.crypto_currency_evaluator_list = {}
self.dispatchers_list = []
self.symbol_time_frame_updater_threads = []
def test_create_social_not_threaded_list():
evaluator, config = _get_tools()
so_list = EvaluatorCreator.create_social_eval(config, evaluator.symbol, [],
CONFIG_EVALUATORS_WILDCARD)
not_thread_so_list = EvaluatorCreator.create_social_not_threaded_list(
so_list)
for evalator in not_thread_so_list:
assert not evalator.is_threaded
def __init__(self, config):
self.start_time = time.time()
self.config = config
self.startup_config = copy.deepcopy(config)
self.edited_config = copy.deepcopy(config)
self.ready = False
self.watcher = None
self.current_loop_thread = None
# tools: used for alternative operations on a bot on the fly (ex: backtesting started from web interface)
self.tools = {
BOT_TOOLS_BACKTESTING: None,
BOT_TOOLS_STRATEGY_OPTIMIZER: None,
BOT_TOOLS_RECORDER: None,
}
# Logger
self.logger = get_logger(self.__class__.__name__)
# Advanced
AdvancedManager.init_advanced_classes_if_necessary(self.config)
# Debug tools
self.performance_analyser = None
if CONFIG_DEBUG_OPTION_PERF in self.config and self.config[
CONFIG_DEBUG_OPTION_PERF]:
self.performance_analyser = PerformanceAnalyser()
# Init time frames using enabled strategies
EvaluatorCreator.init_time_frames_from_strategies(self.config)
self.time_frames = TimeFrameManager.get_config_time_frame(self.config)
# Init relevant evaluator names list using enabled strategies
self.relevant_evaluators = EvaluatorCreator.get_relevant_evaluators_from_strategies(
self.config)
# Backtesting
self.backtesting_enabled = Backtesting.enabled(self.config)
# Notifier
self.config[CONFIG_NOTIFICATION_INSTANCE] = Notification(self.config)
self.symbol_tasks_manager = {}
self.exchange_traders = {}
self.exchange_trader_simulators = {}
self.trading_mode = None
self.exchange_trading_modes = {}
self.exchanges_list = {}
self.symbol_evaluator_list = {}
self.crypto_currency_evaluator_list = {}
self.dispatchers_list = []
self.global_updaters_by_exchange = {}
self.async_loop = None
self.social_eval_tasks = []
self.real_time_eval_tasks = []
self.main_task_group = None
def _init_time_frames(self):
# Init time frames using enabled strategies
EvaluatorCreator.init_time_frames_from_strategies(self.octobot.get_config())
self.time_frames = copy.copy(TimeFrameManager.get_config_time_frame(self.octobot.get_config()))
# Init display time frame
config_time_frames = TimeFrameManager.get_config_time_frame(self.octobot.get_config())
if TimeFrames.ONE_HOUR not in config_time_frames and not backtesting_enabled(self.octobot.get_config()):
config_time_frames.append(TimeFrames.ONE_HOUR)
TimeFrameManager.sort_config_time_frames(self.octobot.get_config())
def __init__(self, config):
self.start_time = time.time()
self.config = config
self.ready = False
# Logger
self.logger = logging.getLogger(self.__class__.__name__)
# Advanced
AdvancedManager.create_class_list(self.config)
# Debug tools
self.performance_analyser = None
if CONFIG_DEBUG_OPTION_PERF in self.config and self.config[
CONFIG_DEBUG_OPTION_PERF]:
self.performance_analyser = PerformanceAnalyser()
# Init time frames using enabled strategies
EvaluatorCreator.init_time_frames_from_strategies(self.config)
self.time_frames = TimeFrameManager.get_config_time_frame(self.config)
# Init relevant evaluator names list using enabled strategies
self.relevant_evaluators = EvaluatorCreator.get_relevant_evaluators_from_strategies(
self.config)
# Add services to self.config[CONFIG_CATEGORY_SERVICES]
ServiceCreator.create_services(self.config)
# Notifier
self.config[CONFIG_NOTIFICATION_INSTANCE] = Notification(self.config)
# Notify starting
if self.config[CONFIG_NOTIFICATION_INSTANCE].enabled(
CONFIG_NOTIFICATION_GLOBAL_INFO):
self.config[CONFIG_NOTIFICATION_INSTANCE].notify_with_all(
NOTIFICATION_STARTING_MESSAGE)
# Backtesting
self.backtesting_enabled = None
self.symbol_threads_manager = {}
self.exchange_traders = {}
self.exchange_trader_simulators = {}
self.exchanges_list = {}
self.symbol_evaluator_list = {}
self.crypto_currency_evaluator_list = {}
self.dispatchers_list = []
self.symbol_time_frame_updater_threads = []
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 _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 _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 _create_symbol_threads_managers(self, exchange, symbol_evaluator):
if Backtesting.enabled(self.config):
real_time_ta_eval_list = []
else:
# Create real time TA evaluators
real_time_ta_eval_list = EvaluatorCreator.create_real_time_ta_evals(
self.config, exchange, symbol_evaluator.get_symbol(),
self.relevant_evaluators)
symbol_time_frame_updater_thread = SymbolTimeFramesDataUpdaterThread()
for time_frame in self.time_frames:
if exchange.get_exchange_manager().time_frame_exists(
time_frame.value, symbol_evaluator.get_symbol()):
self.symbol_threads_manager[
time_frame] = EvaluatorThreadsManager(
self.config, time_frame,
symbol_time_frame_updater_thread, symbol_evaluator,
exchange,
self.exchange_trading_modes[exchange.get_name()],
real_time_ta_eval_list, self.relevant_evaluators)
else:
self.logger.warning(
f"{exchange.get_name()} exchange is not supporting the required time frame: "
f"'{time_frame.value}' for {symbol_evaluator.get_symbol()}."
)
self.symbol_time_frame_updater_threads.append(
symbol_time_frame_updater_thread)
def _create_symbol_threads_managers(self, exchange, symbol_evaluator,
global_price_updater):
if Backtesting.enabled(self.config):
real_time_ta_eval_list = []
else:
# Create real time TA evaluators
real_time_ta_eval_list = EvaluatorCreator.create_real_time_ta_evals(
self.config, exchange, symbol_evaluator.get_symbol(),
self.relevant_evaluators)
self.real_time_eval_tasks = self.real_time_eval_tasks + real_time_ta_eval_list
for time_frame in self.time_frames:
if exchange.get_exchange_manager().time_frame_exists(
time_frame.value, symbol_evaluator.get_symbol()):
self.symbol_tasks_manager[time_frame] = \
EvaluatorTaskManager(self.config,
time_frame,
global_price_updater,
symbol_evaluator,
exchange,
self.exchange_trading_modes[exchange.get_name()],
real_time_ta_eval_list,
self.async_loop,
self.relevant_evaluators)
else:
self.logger.warning(
f"{exchange.get_name()} exchange is not supporting the required time frame: "
f"'{time_frame.value}' for {symbol_evaluator.get_symbol()}."
)
def add_evaluator_instance_to_strategy_instances_list(self, evaluator, exchange):
exchange_name = exchange.get_exchange().get_name()
for strategy in self.evaluator_instances_by_strategies[exchange_name].keys():
if EvaluatorCreator.is_relevant_evaluator(evaluator, strategy.get_required_evaluators(self.config)):
evaluator_parents = evaluator.get_parent_evaluator_classes()
for evaluator_type in self.evaluator_instances_by_strategies[exchange_name][strategy].keys():
if evaluator_type in evaluator_parents:
self.evaluator_instances_by_strategies[exchange_name][strategy][evaluator_type].add(evaluator)
def get_evaluators_list(strategy_name):
if strategy_name:
strategy_class = get_class_from_string(strategy_name, StrategiesEvaluator,
Strategies, evaluator_parent_inspection)
evaluators = EvaluatorCreator.get_relevant_TAs_for_strategy(strategy_class, get_bot().get_config())
return set(evaluator.get_name() for evaluator in evaluators)
else:
return []
def add_evaluator_thread_manager(self, exchange, symbol, time_frame, evaluator_thread):
if exchange.get_name() in self.evaluator_thread_managers:
self.evaluator_thread_managers[exchange.get_name()][time_frame] = evaluator_thread
else:
self.evaluator_thread_managers[exchange.get_name()] = {time_frame: evaluator_thread}
self.final_evaluators[exchange.get_name()] = FinalEvaluator(self, exchange, symbol)
self.matrices[exchange.get_name()] = EvaluatorMatrix(self.config)
self.strategies_eval_lists[exchange.get_name()] = EvaluatorCreator.create_strategies_eval_list(self.config)
self.finalize_enabled_list[exchange.get_name()] = False
def __init__(self, config, crypto_currency, dispatchers_list):
self.config = config
self.crypto_currency = crypto_currency
self.dispatchers_list = dispatchers_list
self.symbol_evaluator_list = {}
if Backtesting.enabled(self.config):
self.social_eval_list = []
self.social_not_threaded_list = []
else:
self.social_eval_list = EvaluatorCreator.create_social_eval(self.config,
self.crypto_currency,
self.dispatchers_list)
self.social_not_threaded_list = EvaluatorCreator.create_social_not_threaded_list(self.social_eval_list)
self.social_evaluator_refresh = SocialEvaluatorNotThreadedUpdateThread(self.social_not_threaded_list)
def __init__(self, config, crypto_currency, dispatchers_list):
self.config = config
self.crypto_currency = crypto_currency
self.dispatchers_list = dispatchers_list
self.symbol_evaluator_list = {}
if Backtesting.enabled(self.config):
self.social_eval_list = []
self.social_not_threaded_list = []
else:
self.social_eval_list = EvaluatorCreator.create_social_eval(
self.config, self.crypto_currency, self.dispatchers_list)
self.social_not_threaded_list = EvaluatorCreator.create_social_not_threaded_list(
self.social_eval_list)
self.social_evaluator_refresh = SocialEvaluatorNotThreadedUpdateThread(
self.social_not_threaded_list)
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()
def create_symbol_threads_managers(self, symbol, exchange,
symbol_evaluator):
# Create real time TA evaluators
real_time_ta_eval_list = EvaluatorCreator.create_real_time_ta_evals(
self.config, exchange, symbol)
for time_frame in self.time_frames:
if exchange.time_frame_exists(time_frame.value):
self.symbols_threads_manager.append(
EvaluatorThreadsManager(self.config, symbol, time_frame,
symbol_evaluator, exchange,
real_time_ta_eval_list))
def add_evaluator_thread_manager(self, exchange, time_frame, trading_mode, evaluator_thread):
if exchange.get_name() in self.evaluator_thread_managers:
self.evaluator_thread_managers[exchange.get_name()][time_frame] = evaluator_thread
else:
self.evaluator_thread_managers[exchange.get_name()] = {time_frame: evaluator_thread}
self.matrices[exchange.get_name()] = EvaluatorMatrix(self.config)
self.strategies_eval_lists[exchange.get_name()] = EvaluatorCreator.create_strategies_eval_list(self.config)
self.finalize_enabled_list[exchange.get_name()] = False
self.init_evaluator_instances_by_strategies()
self.trading_mode_instances[exchange.get_name()] = trading_mode
trading_mode.add_symbol_evaluator(self)
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_symbol_threads_managers(self, symbol, exchange,
symbol_evaluator):
# Create real time TA evaluators
real_time_ta_eval_list = EvaluatorCreator.create_real_time_ta_evals(
self.config, exchange, symbol)
symbol_time_frame_updater_thread = SymbolTimeFramesDataUpdaterThread()
for time_frame in self.time_frames:
if exchange.time_frame_exists(time_frame.value):
self.symbol_threads_manager[
time_frame] = EvaluatorThreadsManager(
self.config, symbol, time_frame,
symbol_time_frame_updater_thread, symbol_evaluator,
exchange, real_time_ta_eval_list)
self.symbol_time_frame_updater_threads.append(
symbol_time_frame_updater_thread)
def add_evaluator_thread_manager(self, exchange, symbol, time_frame,
evaluator_thread):
if exchange.get_name() in self.evaluator_thread_managers:
self.evaluator_thread_managers[
exchange.get_name()][time_frame] = evaluator_thread
else:
self.evaluator_thread_managers[exchange.get_name()] = {
time_frame: evaluator_thread
}
self.final_evaluators[exchange.get_name()] = FinalEvaluator(
self, exchange, symbol)
self.matrices[exchange.get_name()] = EvaluatorMatrix(self.config)
self.strategies_eval_lists[exchange.get_name(
)] = EvaluatorCreator.create_strategies_eval_list(self.config)
self.finalize_enabled_list[exchange.get_name()] = False
def __init__(self):
self.config = None
self.symbol = None
self.time_frame = None
self.history_time = None
self.data = None
self.symbol = None
self.exchange = None
self.symbol_evaluator = None
self.data_changed = False
self.social_eval_list = []
self.ta_eval_list = []
self.real_time_eval_list = []
self.creator = EvaluatorCreator()
def _create_symbol_threads_managers(self, symbol, exchange, symbol_evaluator):
# Create real time TA evaluators
real_time_ta_eval_list = EvaluatorCreator.create_real_time_ta_evals(self.config,
exchange,
symbol)
symbol_time_frame_updater_thread = SymbolTimeFramesDataUpdaterThread()
for time_frame in self.time_frames:
if exchange.time_frame_exists(time_frame.value):
self.symbol_threads_manager[time_frame] = EvaluatorThreadsManager(self.config,
symbol,
time_frame,
symbol_time_frame_updater_thread,
symbol_evaluator,
exchange,
real_time_ta_eval_list)
self.symbol_time_frame_updater_threads.append(symbol_time_frame_updater_thread)
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 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 symbol evaluator
symbol_evaluator = Symbol_Evaluator(self.config, crypto_currency,
self.dispatchers_list)
symbol_evaluator.set_traders(self.exchange_traders)
symbol_evaluator.set_trader_simulators(
self.exchange_trader_simulators)
self.symbol_evaluator_list.append(symbol_evaluator)
# create TA evaluators
for symbol in crypto_currency_data[CONFIG_CRYPTO_PAIRS]:
for exchange_type in self.exchanges:
exchange = self.exchanges_list[exchange_type.__name__]
if exchange.enabled():
# Verify that symbol exists on this exchange
if exchange.symbol_exists(symbol):
self.create_symbol_threads_managers(
symbol, exchange, symbol_evaluator)
# notify that exchange doesn't support this symbol
else:
self.logger.warning(
"{0} doesn't support {1}".format(
exchange_type.__name__, symbol))
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))
def test_create_strategies_eval_list():
evaluator, config = _get_tools()
strat_list = EvaluatorCreator.create_strategies_eval_list(config)
_assert_created_instances(strat_list, StrategiesEvaluator, config)
def test_create_social_eval_list():
evaluator, config = _get_tools()
so_list = EvaluatorCreator.create_social_eval(config, evaluator.symbol, [], CONFIG_EVALUATORS_WILDCARD)
_assert_created_instances(so_list, SocialEvaluator, config)
def test_create_ta_eval_list():
evaluator, config = _get_tools()
ta_list = EvaluatorCreator.create_ta_eval_list(evaluator, CONFIG_EVALUATORS_WILDCARD)
_assert_created_instances(ta_list, TAEvaluator, config)
def test_create_dispatchers():
_, config = _get_tools()
dispatchers = EvaluatorCreator.create_dispatchers(config)
assert len(dispatchers) == 0 # no dispatcher created because no config for associated services
def _create_real_time_ta_evaluators(self, exchange, symbol_evaluator):
return EvaluatorCreator.create_real_time_ta_evals(
self.octobot.get_config(), exchange, symbol_evaluator.get_symbol(),
self.octobot.get_relevant_evaluators(), self.dispatchers_list)
def _init_relevant_evaluators(self):
# Init relevant evaluator names list using enabled strategies
self.relevant_evaluators = EvaluatorCreator.get_relevant_evaluators_from_strategies(
self.octobot.get_config())
