def __init__(self, config, strategy_name):
self.is_properly_initialized = False
self.logger = get_logger(self.get_name())
AdvancedManager.init_advanced_classes_if_necessary(config)
self.trading_mode = get_activated_trading_mode(config)
self.config = create_blank_config_using_loaded_one(config)
self.strategy_class = get_class_from_string(
strategy_name, StrategiesEvaluator, Strategies,
evaluator_parent_inspection)
self.run_results = []
self.results_report = []
self.sorted_results_by_time_frame = {}
self.sorted_results_through_all_time_frame = {}
self.all_time_frames = []
self.all_TAs = []
self.risks = []
self.current_test_suite = None
self.errors = set()
self.is_computing = False
self.run_id = 0
self.total_nb_runs = 0
if not self.strategy_class:
self.logger.error(
f"Impossible to find a strategy matching class name: {strategy_name} in installed "
f"strategies. Please make sure to enter the name of the class, "
f"ex: FullMixedStrategiesEvaluator")
else:
self.is_properly_initialized = True
def get_activated_trading_mode(config):
if CONFIG_TRADING_TENTACLES in config:
try:
trading_modes = [
class_str for class_str, activated in
config[CONFIG_TRADING_TENTACLES].items() if activated
and get_class_from_string(class_str,
AbstractTradingMode,
modes,
error_when_not_found=True)
]
if len(trading_modes) > 1:
raise ConfigTradingError(
f"More than one activated trading mode found in your {CONFIG_TRADING_FILE_PATH} file, "
f"please activate only one")
elif trading_modes:
trading_mode_class = get_deep_class_from_string(
trading_modes[0], modes)
if trading_mode_class is not None:
return trading_mode_class
except ModuleNotFoundError as e:
get_logger("get_activated_trading_mode").error(
f"Error when loading a trading mode: {e} "
f"referenced in {CONFIG_TRADING_FILE_PATH} file")
raise ConfigTradingError(
f"Please ensure your {CONFIG_TRADING_FILE_PATH} file is valid and at least one trading "
f"mode is activated")
def get_time_frames_list(strategy_name):
if strategy_name:
strategy_class = get_class_from_string(strategy_name, StrategiesEvaluator,
Strategies, evaluator_parent_inspection)
return [tf.value for tf in strategy_class.get_required_time_frames(get_bot().get_config())]
else:
return []
def _register_only_strategy(self, strategy_evaluator_class):
for evaluator_name in self.config[CONFIG_EVALUATOR]:
if get_class_from_string(evaluator_name, StrategiesEvaluator,
Strategies,
evaluator_parent_inspection) is not None:
self.config[CONFIG_EVALUATOR][evaluator_name] = False
self.config[CONFIG_EVALUATOR][
strategy_evaluator_class.get_name()] = True
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 _register_only_trading_mode(self, trading_mode_class):
for trading_mode_name in self.config[CONFIG_TRADING_TENTACLES]:
if get_class_from_string(
trading_mode_name, AbstractTradingMode, modes,
trading_mode_parent_inspection) is not None:
self.config[CONFIG_TRADING_TENTACLES][
trading_mode_name] = False
self.config[CONFIG_TRADING_TENTACLES][
trading_mode_class.get_name()] = True
def _check_required_evaluators(self):
if self.symbol_tasks_manager:
etm = next(iter(self.symbol_tasks_manager.values()))
ta_list = etm.get_evaluator().get_ta_eval_list()
if self.octobot.get_relevant_evaluators() != CONFIG_EVALUATORS_WILDCARD:
for required_eval in self.octobot.get_relevant_evaluators():
required_class = get_class_from_string(required_eval, TAEvaluator, TA, evaluator_parent_inspection)
if required_class and not self._class_is_in_list(ta_list, required_class):
self.logger.error(f"Missing technical analysis evaluator {required_class.get_name()} for "
f"current strategy. Activate it in OctoBot advanced configuration interface "
f"to allow activated strategy(ies) to work properly.")
def _get_strategy_activation_state():
import trading.trader.modes as modes
import evaluator.Strategies as strategies
trading_mode_key = "trading-modes"
strategies_key = "strategies"
activation = "activation"
description = "description"
advanced_class_key = "advanced_class"
strategy_config = {
trading_mode_key: {},
strategies_key: {}
}
strategy_config_classes = {
trading_mode_key: {},
strategies_key: {}
}
trading_config = _get_trading_config()
for key, val in trading_config.items():
config_class = get_class_from_string(key, modes.AbstractTradingMode, modes, trading_mode_parent_inspection)
if config_class:
strategy_config[trading_mode_key][key] = {}
strategy_config[trading_mode_key][key][activation] = val
strategy_config[trading_mode_key][key][description] = config_class.get_description()
strategy_config[trading_mode_key][key][advanced_class_key] = \
_get_advanced_class_details(key, config_class, is_trading_mode=True)
strategy_config_classes[trading_mode_key][key] = config_class
evaluator_config = _get_evaluator_config()
for key, val in evaluator_config.items():
config_class = get_class_from_string(key, strategies.StrategiesEvaluator,
strategies, evaluator_parent_inspection)
if config_class:
strategy_config[strategies_key][key] = {}
strategy_config[strategies_key][key][activation] = val
strategy_config[strategies_key][key][description] = config_class.get_description()
strategy_config[strategies_key][key][advanced_class_key] = \
_get_advanced_class_details(key, config_class, is_strategy=True)
strategy_config_classes[strategies_key][key] = config_class
return strategy_config, strategy_config_classes
def _fill_evaluator_config(evaluator_name, activated, eval_type_key,
evaluator_type, detailed_config, is_strategy=False):
activation = "activation"
description = "description"
advanced_class_key = "advanced_class"
klass = get_class_from_string(evaluator_name, AbstractEvaluator, evaluator_type, evaluator_parent_inspection)
if klass:
detailed_config[eval_type_key][evaluator_name] = {}
detailed_config[eval_type_key][evaluator_name][activation] = activated
detailed_config[eval_type_key][evaluator_name][description] = klass.get_description()
detailed_config[eval_type_key][evaluator_name][advanced_class_key] = \
_get_advanced_class_details(evaluator_name, klass, is_strategy=is_strategy)
return True, klass
return False, klass
def _is_relevant_evaluation_config(evaluator):
return get_class_from_string(evaluator, TAEvaluator, TA,
evaluator_parent_inspection) is not None
