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 AdvancedManager.get_class(config,
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 _update_activation_config(to_update_data, current_config,
config_file_path, config_file,
deactivate_others):
from tentacles_management.class_inspector import get_class_from_string, evaluator_parent_inspection
something_changed = False
for element_name, activated in to_update_data.items():
if element_name in current_config:
active = activated if isinstance(
activated, bool) else activated.lower() == "true"
current_activation = current_config[element_name]
if current_activation != active:
get_logger().info(
f"{config_file} updated: {element_name} "
f"{'activated' if active else 'deactivated'}")
current_config[element_name] = active
something_changed = True
if deactivate_others:
import evaluator.Strategies as strategies
for element_name, activated in current_config.items():
if element_name not in to_update_data:
if current_config[element_name]:
# do not deactivate strategies
config_class = get_class_from_string(
element_name, strategies.StrategiesEvaluator,
strategies, evaluator_parent_inspection)
if config_class is None:
get_logger().info(
f"{config_file} updated: {element_name} "
f"{'deactivated'}")
current_config[element_name] = False
something_changed = True
if something_changed:
with open(config_file_path, "w+") as config_file_w:
config_file_w.write(ConfigManager.dump_json(current_config))
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_tentacle_from_string(name, with_info=True):
for package, abstract_class, tentacle_type in _get_tentacle_packages():
is_trading_mode = tentacle_type == TRADING_MODE_KEY
parent_inspector = trading_mode_parent_inspection if is_trading_mode else evaluator_parent_inspection
klass = get_class_from_string(name, abstract_class, package, parent_inspector)
if klass:
if with_info:
info = dict()
info[DESCRIPTION_KEY] = klass.get_description()
info[NAME_KEY] = name
for parent_class in klass.__bases__:
if hasattr(parent_class, "get_name"):
advanced_details = _get_advanced_class_details(parent_class.get_name(), parent_class,
is_strategy=(tentacle_type == STRATEGY_KEY))
if advanced_details:
info[ADVANCED_CLASS_KEY] = advanced_details
info[EVALUATOR_ACTIVATION] = _get_activation_state(name, info, is_trading_mode)
if is_trading_mode:
_add_trading_mode_requirements_and_default_config(info, klass)
elif tentacle_type == STRATEGY_KEY:
_add_strategy_requirements_and_default_config(info, klass, get_bot().get_config())
return klass, tentacle_type, info
else:
return klass, tentacle_type, None
return None, None, None
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 _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 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 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 _fill_evaluator_config(evaluator_name, activated, eval_type_key,
evaluator_type, detailed_config, is_strategy=False):
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][EVALUATOR_ACTIVATION] = activated
detailed_config[eval_type_key][evaluator_name][DESCRIPTION_KEY] = klass.get_description()
detailed_config[eval_type_key][evaluator_name][EVALUATION_FORMAT_KEY] = "float" \
if klass.get_eval_type() == EVALUATOR_EVAL_DEFAULT_TYPE else str(klass.get_eval_type())
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 _get_strategy_activation_state(with_trading_modes):
import trading.trader.modes as modes
import evaluator.Strategies as strategies
strategy_config = {TRADING_MODES_KEY: {}, STRATEGIES_KEY: {}}
strategy_config_classes = {TRADING_MODES_KEY: {}, STRATEGIES_KEY: {}}
if with_trading_modes:
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_MODES_KEY][key] = {}
strategy_config[TRADING_MODES_KEY][key][
EVALUATOR_ACTIVATION] = val
strategy_config[TRADING_MODES_KEY][key][
DESCRIPTION_KEY] = config_class.get_description()
strategy_config[TRADING_MODES_KEY][key][ADVANCED_CLASS_KEY] = \
_get_advanced_class_details(key, config_class, is_trading_mode=True)
strategy_config_classes[TRADING_MODES_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][EVALUATOR_ACTIVATION] = val
strategy_config[STRATEGIES_KEY][key][
DESCRIPTION_KEY] = 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 _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 _is_relevant_evaluation_config(evaluator):
return get_class_from_string(evaluator, TAEvaluator, TA,
evaluator_parent_inspection) is not None
