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