def _get_strategy_activation_state(with_trading_modes, media_url):
import tentacles.Trading.Mode as modes
import tentacles.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_tentacles_activation()
for key, val in trading_config.items():
config_class = tentacles_management.get_class_from_string(
key, trading_modes.AbstractTradingMode, modes,
tentacles_management.trading_mode_parent_inspection)
if config_class:
strategy_config[TRADING_MODES_KEY][key] = {}
strategy_config[TRADING_MODES_KEY][key][
constants.ACTIVATION_KEY] = val
strategy_config[TRADING_MODES_KEY][key][
DESCRIPTION_KEY] = get_tentacle_documentation(
key, media_url)
strategy_config_classes[TRADING_MODES_KEY][key] = config_class
evaluator_config = _get_evaluators_tentacles_activation()
for key, val in evaluator_config.items():
config_class = tentacles_management.get_class_from_string(
key, evaluators.StrategyEvaluator, strategies,
tentacles_management.evaluator_parent_inspection)
if config_class:
strategy_config[STRATEGIES_KEY][key] = {}
strategy_config[STRATEGIES_KEY][key][
constants.ACTIVATION_KEY] = val
strategy_config[STRATEGIES_KEY][key][
DESCRIPTION_KEY] = get_tentacle_documentation(key, media_url)
strategy_config_classes[STRATEGIES_KEY][key] = config_class
return strategy_config, strategy_config_classes
def __init__(self, config, tentacles_setup_config, strategy_name):
# Lazy import of tentacles to let tentacles manager handle imports
import tentacles.Evaluator as tentacles_Evaluator
self.is_properly_initialized = False
self.logger = common_logging.get_logger(self.get_name())
self.config = config
self.tentacles_setup_config = copy.deepcopy(tentacles_setup_config)
self.trading_mode = trading_modes.get_activated_trading_mode(
tentacles_setup_config)
self.strategy_class = tentacles_management.get_class_from_string(
strategy_name, evaluators.StrategyEvaluator,
tentacles_Evaluator.Strategies,
tentacles_management.evaluator_parent_inspection)
self.run_results = []
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 _update_tentacles_config(self, strategy_evaluator_class,
trading_mode_class):
default_evaluators = strategy_evaluator_class.get_default_evaluators(
self.tentacles_setup_config)
to_update_config = {}
tentacles_activation = tentacles_manager_api.get_tentacles_activation(
self.tentacles_setup_config)
for tentacle_class_name in tentacles_activation[
tentacles_manager_constants.TENTACLES_EVALUATOR_PATH]:
if commons_constants.CONFIG_WILDCARD not in default_evaluators and tentacle_class_name in default_evaluators:
to_update_config[tentacle_class_name] = True
elif tentacles_management.get_class_from_string(
tentacle_class_name, evaluators.StrategyEvaluator,
Strategies, tentacles_management.
evaluator_parent_inspection) is not None:
to_update_config[tentacle_class_name] = False
elif commons_constants.CONFIG_WILDCARD not in default_evaluators:
to_update_config[tentacle_class_name] = False
for tentacle_class_name in tentacles_activation[
tentacles_manager_constants.TENTACLES_TRADING_PATH]:
to_update_config[tentacle_class_name] = False
# Add required elements if missing
to_update_config.update(
{evaluator: True
for evaluator in default_evaluators})
to_update_config[strategy_evaluator_class.get_name()] = True
to_update_config[trading_mode_class.get_name()] = True
tentacles_manager_api.update_activation_configuration(
self.tentacles_setup_config,
to_update_config,
False,
add_missing_elements=True)
def get_tentacle_from_string(name, media_url, with_info=True):
for package, abstract_class, tentacle_type in _get_tentacle_packages():
is_trading_mode = tentacle_type == TRADING_MODE_KEY
parent_inspector = tentacles_management.trading_mode_parent_inspection \
if is_trading_mode else tentacles_management.evaluator_parent_inspection
klass = tentacles_management.get_class_from_string(
name, abstract_class, package, parent_inspector)
if klass:
if with_info:
info = {
DESCRIPTION_KEY:
get_tentacle_documentation(name, media_url),
NAME_KEY: name
}
if is_trading_mode:
_add_trading_mode_requirements_and_default_config(
info, klass)
activation_states = _get_trading_tentacles_activation()
else:
activation_states = _get_evaluators_tentacles_activation()
if tentacle_type == STRATEGY_KEY:
_add_strategy_requirements_and_default_config(
info, klass)
info[constants.ACTIVATION_KEY] = _get_activation_state(
name, activation_states)
return klass, tentacle_type, info
else:
return klass, tentacle_type, None
return None, None, None
def get_evaluators_list(strategy_name):
if strategy_name:
strategy_class = tentacles_management.get_class_from_string(
strategy_name, evaluators.StrategyEvaluator, TentaclesStrategies,
tentacles_management.evaluator_parent_inspection)
found_evaluators = evaluators_api.get_relevant_TAs_for_strategy(
strategy_class,
interfaces_util.get_bot_api().get_tentacles_setup_config())
return set(evaluator.get_name() for evaluator in found_evaluators)
else:
return []
def get_time_frames_list(strategy_name):
if strategy_name:
strategy_class = tentacles_management.get_class_from_string(
strategy_name, evaluators.StrategyEvaluator, TentaclesStrategies,
tentacles_management.evaluator_parent_inspection)
return [
tf.value for tf in strategy_class.get_required_time_frames(
interfaces_util.get_global_config())
]
else:
return []
def _fill_evaluator_config(evaluator_name, activated, eval_type_key,
evaluator_type, detailed_config, media_url, is_strategy=False):
klass = tentacles_management.get_class_from_string(evaluator_name, evaluators.AbstractEvaluator, evaluator_type,
tentacles_management.evaluator_parent_inspection)
if klass:
detailed_config[eval_type_key][evaluator_name] = {}
detailed_config[eval_type_key][evaluator_name][constants.ACTIVATION_KEY] = activated
detailed_config[eval_type_key][evaluator_name][DESCRIPTION_KEY] = get_tentacle_documentation(evaluator_name,
media_url)
detailed_config[eval_type_key][evaluator_name][EVALUATION_FORMAT_KEY] = "float" \
if klass.get_eval_type() == evaluators_constants.EVALUATOR_EVAL_DEFAULT_TYPE else str(klass.get_eval_type())
return True, klass
return False, klass
def _adapt_tentacles_config(self, activated_evaluators):
# Lazy import of tentacles to let tentacles manager handle imports
import tentacles.Evaluator as tentacles_Evaluator
to_update_config = {}
tentacles_activation = tentacles_manager_api.get_tentacles_activation(self.tentacles_setup_config)
for tentacle_class_name in tentacles_activation[tentacles_manager_constants.TENTACLES_EVALUATOR_PATH]:
if tentacle_class_name in activated_evaluators:
to_update_config[tentacle_class_name] = True
elif tentacles_management.get_class_from_string(tentacle_class_name, evaluators.StrategyEvaluator,
tentacles_Evaluator.Strategies,
tentacles_management.evaluator_parent_inspection) is None:
to_update_config[tentacle_class_name] = False
tentacles_manager_api.update_activation_configuration(self.tentacles_setup_config, to_update_config, False)
def _register_only_strategy(self, strategy_evaluator_class):
try:
import tentacles.Evaluator as Evaluator
import octobot_evaluators.evaluators as evaluators
tentacles_activation = tentacles_manager_api.get_tentacles_activation(self.tentacles_setup_config)
for evaluator_name in tentacles_activation[tentacles_manager_constants.TENTACLES_EVALUATOR_PATH]:
if tentacles_management.get_class_from_string(
evaluator_name,
evaluators.StrategyEvaluator,
Evaluator.Strategies,
tentacles_management.evaluator_parent_inspection) is not None:
tentacles_activation[tentacles_manager_constants.TENTACLES_EVALUATOR_PATH][evaluator_name] = False
tentacles_activation[tentacles_manager_constants.TENTACLES_EVALUATOR_PATH][
strategy_evaluator_class.get_name()] = True
except ImportError as e:
self.logger.error(f"Backtesting tests requires OctoBot-Evaluator package installed {e}")
def _is_relevant_evaluation_config(evaluator):
# Lazy import of tentacles to let tentacles manager handle imports
import tentacles.Evaluator as tentacles_Evaluator
return tentacles_management.get_class_from_string(
evaluator, evaluators.TAEvaluator, tentacles_Evaluator.TA,
tentacles_management.evaluator_parent_inspection) is not None
