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 __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_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
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():
config = load_test_config()
AdvancedManager.create_class_list(config)
evaluator = Evaluator()
evaluator.set_config(config)
evaluator.set_symbol("BTC/USDT")
evaluator.set_time_frame(TimeFrames.ONE_HOUR)
return evaluator, config
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
async def _get_tools(event_loop):
config = load_test_config()
symbol = "BTC/USDT"
exchange_traders = {}
exchange_traders2 = {}
time_frame = TimeFrames.FIVE_MINUTES
AdvancedManager.create_class_list(config)
exchange_manager = ExchangeManager(config, ccxt.binance, is_simulated=True)
await exchange_manager.initialize()
exchange_inst = exchange_manager.get_exchange()
symbol_time_frame_updater_thread = GlobalPriceUpdater(exchange_inst)
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()
trader_inst2.set_enabled(False)
trader_inst.portfolio.portfolio["SUB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["BNB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
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)
trading_mode_inst = get_activated_trading_mode(config)(config,
exchange_inst)
_ = EvaluatorTaskManager(config, time_frame,
symbol_time_frame_updater_thread,
symbol_evaluator, exchange_inst,
trading_mode_inst, [], event_loop)
trading_mode = HighFrequencyMode(config, exchange_inst)
trading_mode.add_symbol_evaluator(symbol_evaluator)
decider = trading_mode.get_only_decider_key(symbol)
await decider.initialize()
return config, exchange_inst, trader_inst, symbol, trading_mode
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 __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 = []
def _init_strategies_instances(self, symbol, all_strategy_instances):
all_strategy_classes = [s.__class__ for s in all_strategy_instances]
required_strategies, required_strategies_min_count = self.get_required_strategies()
missing_strategies = []
found_strategy_count = 0
for required_class in required_strategies:
if required_class in all_strategy_classes:
self.strategy_instances_by_classes[symbol][required_class] = \
all_strategy_instances[all_strategy_classes.index(required_class)]
found_strategy_count += 1
else:
subclass = AdvancedManager.get_class(self.config, required_class)
if subclass in all_strategy_classes:
self.strategy_instances_by_classes[symbol][required_class] = \
all_strategy_instances[all_strategy_classes.index(subclass)]
found_strategy_count += 1
if required_class not in self.strategy_instances_by_classes[symbol]:
missing_strategies.append(required_class)
if found_strategy_count < required_strategies_min_count:
for missing_strategy in missing_strategies:
get_logger(self.get_name()).error(f"No instance of {missing_strategy.__name__} "
f"or advanced equivalent found, {self.get_name()} trading "
"mode can't work properly ! Maybe this strategy is disabled in"
f" tentacles/Evaluator/evaluator_config.json (missing "
f"{required_strategies_min_count-found_strategy_count} out of "
f"{required_strategies_min_count} minimum required strategies).")
def _get_advanced_class_details(class_name,
klass,
is_trading_mode=False,
is_strategy=False):
from evaluator.Util.advanced_manager import AdvancedManager
name = "name"
description = "description"
requirements = "requirements"
requirements_count_key = "requirements-min-count"
default_config_key = "default-config"
details = {}
config = get_bot().get_config()
advanced_class = AdvancedManager.get_class(config, klass)
if advanced_class and advanced_class.get_name() != class_name:
details[name] = advanced_class.get_name()
details[description] = advanced_class.get_description()
if is_trading_mode:
required_strategies, required_strategies_count = klass.get_required_strategies_names_and_count(
)
details[requirements] = [
strategy for strategy in required_strategies
]
details[requirements_count_key] = required_strategies_count
elif is_strategy:
details[requirements] = [
evaluator
for evaluator in advanced_class.get_required_evaluators(config)
]
details[default_config_key] = [
evaluator
for evaluator in advanced_class.get_default_evaluators(config)
]
return details
def create_social_eval(config, symbol, dispatchers_list):
social_eval_list = []
for social_eval_class in AdvancedManager.create_advanced_evaluator_types_list(SocialEvaluator, config):
social_eval_class_instance = social_eval_class()
social_eval_class_instance.set_config(config)
if social_eval_class_instance.get_is_enabled():
is_evaluator_to_be_used = True
social_eval_class_instance.set_logger(logging.getLogger(social_eval_class.get_name()))
social_eval_class_instance.set_symbol(symbol)
social_eval_class_instance.prepare()
# If evaluator is a dispatcher client --> check if dispatcher exists
# else warn and pass this evaluator
if social_eval_class.get_is_dispatcher_client():
client_found_dispatcher = EvaluatorCreator.set_social_eval_dispatcher(social_eval_class_instance,
dispatchers_list)
if not client_found_dispatcher:
is_evaluator_to_be_used = False
logging.getLogger(EvaluatorCreator.get_name()).warning(
"No dispatcher found for evaluator: {0} for symbol: {1}, evaluator has been disabled."
.format(social_eval_class_instance.get_name(), symbol))
# start refreshing thread if the thread is not manage by dispatcher
elif is_evaluator_to_be_used and social_eval_class_instance.get_is_threaded():
social_eval_class_instance.start()
if is_evaluator_to_be_used:
social_eval_list.append(social_eval_class_instance)
return social_eval_list
def _get_advanced_class_details(class_name,
klass,
is_trading_mode=False,
is_strategy=False):
from evaluator.Util.advanced_manager import AdvancedManager
name = "name"
description = "description"
requirements = "requirements"
details = {}
config = get_bot().get_config()
advanced_class = AdvancedManager.get_class(config, klass)
if advanced_class and advanced_class.get_name() != class_name:
details[name] = advanced_class.get_name()
details[description] = advanced_class.get_description()
if is_trading_mode:
details[requirements] = [
strategy.get_name()
for strategy in advanced_class.get_required_strategies()
]
elif is_strategy:
details[requirements] = [
evaluator
for evaluator in advanced_class.get_required_evaluators(config)
]
return details
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 create_social_eval(config, symbol, dispatchers_list):
social_eval_list = []
for social_eval_class in AdvancedManager.create_advanced_evaluator_types_list(
SocialEvaluator, config):
social_eval_class_instance = social_eval_class()
social_eval_class_instance.set_config(config)
if social_eval_class_instance.get_is_enabled():
is_evaluator_to_be_used = True
social_eval_class_instance.set_logger(
logging.getLogger(social_eval_class.get_name()))
social_eval_class_instance.set_symbol(symbol)
social_eval_class_instance.prepare()
# If evaluator is a dispatcher client --> check if dispatcher exists
# else warn and pass this evaluator
if social_eval_class.get_is_dispatcher_client():
client_found_dispatcher = EvaluatorCreator.set_social_eval_dispatcher(
social_eval_class_instance, dispatchers_list)
if not client_found_dispatcher:
is_evaluator_to_be_used = False
logging.getLogger(EvaluatorCreator.get_name()).warning(
"No dispatcher found for evaluator: {0} for symbol: {1}, evaluator has been disabled."
.format(social_eval_class_instance.get_name(),
symbol))
# start refreshing thread if the thread is not manage by dispatcher
elif is_evaluator_to_be_used and social_eval_class_instance.get_is_threaded(
):
social_eval_class_instance.start()
if is_evaluator_to_be_used:
social_eval_list.append(social_eval_class_instance)
return social_eval_list
def get_strategies_list():
try:
config = get_bot().get_config()
classes = AdvancedManager.get_all_classes(StrategiesEvaluator, config)
return set(strategy.get_name() for strategy in classes)
except Exception:
return []
def _assert_created_instances(instances_list, super_class, config):
class_list = [instance.__class__ for instance in instances_list]
for eval_class in AdvancedManager.create_advanced_evaluator_types_list(super_class, config):
eval_instance = eval_class()
eval_instance.set_config(config)
if eval_instance.get_is_enabled():
assert eval_class in class_list
def create_advanced_evaluators(evaluator_class, config):
evaluator_advanced_eval_class_list = []
for evaluator_subclass in evaluator_class.__subclasses__():
for eval_class in evaluator_subclass.__subclasses__():
for eval_class_type in AdvancedManager.get_classes(
config, eval_class):
evaluator_advanced_eval_class_list.append(eval_class_type)
return evaluator_advanced_eval_class_list
def eval_impl(self):
interest_over_time_df = self.pytrends.interest_over_time()
# compute bollinger bands
self.eval_note = AdvancedManager.get_class(
self.config, StatisticAnalysis).analyse_recent_trend_changes(
interest_over_time_df[self.symbol].astype('float64').values,
numpy.sqrt)
def init_time_frames_from_strategies(config):
time_frame_list = set()
for strategies_eval_class in AdvancedManager.create_advanced_evaluator_types_list(StrategiesEvaluator, config):
if strategies_eval_class.is_enabled(config, False):
for time_frame in strategies_eval_class.get_required_time_frames(config):
time_frame_list.add(time_frame)
time_frame_list = TimeFrameManager.sort_time_frames(time_frame_list)
config[CONFIG_TIME_FRAME] = time_frame_list
async def eval_impl(self):
interest_over_time = self.simplified_pytrends.interest_over_time()
trend = numpy.array([d["data"] for d in interest_over_time])
# compute bollinger bands
self.eval_note = AdvancedManager.get_class(
self.config,
StatisticAnalysis).analyse_recent_trend_changes(trend, numpy.sqrt)
def __init__(self):
# Logger
fileConfig('config/logging_config.ini')
self.logger = logging.getLogger(self.__class__.__name__)
sys.excepthook = self.log_uncaught_exceptions
# Version
self.logger.info("Version : {0}".format(VERSION))
# Config
self.logger.info("Load config file...")
self.config = load_config()
# Advanced
AdvancedManager.create_class_list(self.config)
# Interfaces
self.web_app = WebApp(self.config)
if self.web_app.enabled():
self.web_app.start()
# 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()
# TODO : CONFIG TEMP LOCATION
self.time_frames = [
TimeFrames.THIRTY_MINUTES, TimeFrames.ONE_HOUR,
TimeFrames.FOUR_HOURS, TimeFrames.ONE_DAY
]
self.exchanges = [ccxt.binance]
# Add services to self.config[CONFIG_CATEGORY_SERVICES]
ServiceCreator.create_services(self.config)
# Notifier
self.config[CONFIG_NOTIFICATION_INSTANCE] = Notification(self.config)
self.symbols_threads_manager = []
self.exchange_traders = {}
self.exchange_trader_simulators = {}
self.exchanges_list = {}
self.symbol_evaluator_list = []
self.dispatchers_list = []
def _get_tools():
config = load_test_config()
symbol = "BTC/USDT"
exchange_traders = {}
exchange_traders2 = {}
time_frame = TimeFrames.FIVE_MINUTES
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()
trader_inst2.set_enabled(False)
trader_inst.portfolio.portfolio["SUB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["BNB"] = {
Portfolio.TOTAL: 0.000000000000000000005,
Portfolio.AVAILABLE: 0.000000000000000000005
}
trader_inst.portfolio.portfolio["USDT"] = {
Portfolio.TOTAL: 2000,
Portfolio.AVAILABLE: 2000
}
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)
trading_mode_inst = OctoBot.get_trading_mode_class(config)(config,
exchange_inst)
_ = EvaluatorThreadsManager(config, time_frame,
symbol_time_frame_updater_thread,
symbol_evaluator, exchange_inst,
trading_mode_inst, [])
trading_mode = HighFrequencyMode(config, exchange_inst)
trading_mode.add_symbol_evaluator(symbol_evaluator)
return config, exchange_inst, trader_inst, symbol, trading_mode
def get_relevant_TAs_for_strategy(strategy, config):
ta_classes_list = []
relevant_evaluators = strategy.get_required_evaluators(config)
for ta_eval_class in AdvancedManager.create_advanced_evaluator_types_list(TAEvaluator, config):
ta_eval_class_instance = ta_eval_class()
ta_eval_class_instance.set_config(config)
if EvaluatorCreator.is_relevant_evaluator(ta_eval_class_instance, relevant_evaluators):
ta_classes_list.append(ta_eval_class)
return ta_classes_list
def get_relevant_evaluators_from_strategies(config):
evaluator_list = set()
for strategies_eval_class in AdvancedManager.create_advanced_evaluator_types_list(StrategiesEvaluator, config):
if strategies_eval_class.is_enabled(config, False):
required_evaluators = strategies_eval_class.get_required_evaluators(config)
if required_evaluators == CONFIG_EVALUATORS_WILDCARD:
return CONFIG_EVALUATORS_WILDCARD
else:
for evaluator in required_evaluators:
evaluator_list.add(evaluator)
return evaluator_list
def create_ta_eval_list(evaluator):
ta_eval_instance_list = []
for ta_eval_class in AdvancedManager.create_advanced_evaluator_types_list(TAEvaluator, evaluator.get_config()):
ta_eval_class_instance = ta_eval_class()
ta_eval_class_instance.set_config(evaluator.config)
if ta_eval_class_instance.get_is_enabled():
ta_eval_class_instance.set_logger(logging.getLogger(ta_eval_class.get_name()))
ta_eval_class_instance.set_data(evaluator.data)
ta_eval_class_instance.set_symbol(evaluator.get_symbol())
ta_eval_instance_list.append(ta_eval_class_instance)
return ta_eval_instance_list
def create_strategies_eval_list(config):
strategies_eval_list = []
for strategies_eval_class in AdvancedManager.create_advanced_evaluator_types_list(StrategiesEvaluator, config):
strategies_eval_class_instance = strategies_eval_class()
strategies_eval_class_instance.set_config(config)
if strategies_eval_class_instance.get_is_enabled():
strategies_eval_class_instance.set_logger(
logging.getLogger(strategies_eval_class_instance.get_name()))
strategies_eval_list.append(strategies_eval_class_instance)
return strategies_eval_list
def create_strategies_eval_list(config):
strategies_eval_list = []
for strategies_eval_class in AdvancedManager.create_advanced_evaluator_types_list(StrategiesEvaluator, config):
strategies_eval_class_instance = strategies_eval_class()
strategies_eval_class_instance.set_config(config)
if strategies_eval_class_instance.get_is_enabled():
strategies_eval_class_instance.set_logger(
get_logger(strategies_eval_class_instance.get_name()))
strategies_eval_list.append(strategies_eval_class_instance)
return strategies_eval_list
def create_ta_eval_list(evaluator, relevant_evaluators):
ta_eval_instance_list = []
for ta_eval_class in AdvancedManager.create_advanced_evaluator_types_list(TAEvaluator, evaluator.get_config()):
ta_eval_class_instance = ta_eval_class()
ta_eval_class_instance.set_config(evaluator.config)
if EvaluatorCreator.is_relevant_evaluator(ta_eval_class_instance, relevant_evaluators):
ta_eval_class_instance.set_logger(get_logger(ta_eval_class.get_name()))
ta_eval_class_instance.set_data(evaluator.data)
ta_eval_class_instance.set_symbol(evaluator.get_symbol())
ta_eval_instance_list.append(ta_eval_class_instance)
return ta_eval_instance_list
def add_class_to_config_file_content(clazz,
config_file_content,
classes_list,
activated=False):
from evaluator.Util.advanced_manager import AdvancedManager
changed_something = False
current_classes_list = AdvancedManager.create_default_types_list(clazz)
for current_class in current_classes_list:
if not current_class.get_name() in config_file_content:
config_file_content[current_class.get_name()] = activated
changed_something = True
classes_list += current_classes_list
return changed_something
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()
self.time_frames = TimeFrameManager.get_config_time_frame(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
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 = []
def create_real_time_ta_evals(config, exchange_inst, symbol):
real_time_ta_eval_list = []
for real_time_eval_class in AdvancedManager.create_advanced_evaluator_types_list(RealTimeEvaluator, config):
real_time_eval_class_instance = real_time_eval_class(exchange_inst, symbol)
real_time_eval_class_instance.set_config(config)
if real_time_eval_class_instance.get_is_enabled():
real_time_eval_class_instance.set_logger(logging.getLogger(real_time_eval_class.get_name()))
# start refreshing thread
real_time_eval_class_instance.start()
real_time_ta_eval_list.append(real_time_eval_class_instance)
return real_time_ta_eval_list
def add_evaluator_to_evaluator_config_content(evaluator_type,
evaluator_config_content,
evaluator_list,
activated=False):
from evaluator.Util.advanced_manager import AdvancedManager
changed_something = False
current_evaluator_list = AdvancedManager.create_default_evaluator_types_list(
evaluator_type)
for eval_class in current_evaluator_list:
if not eval_class.get_name() in evaluator_config_content:
evaluator_config_content[eval_class.get_name()] = activated
changed_something = True
evaluator_list += current_evaluator_list
return changed_something
def create_ta_eval_list(evaluator):
ta_eval_instance_list = []
for ta_eval_class in AdvancedManager.create_advanced_evaluator_types_list(
TAEvaluator, evaluator.get_config()):
ta_eval_class_instance = ta_eval_class()
ta_eval_class_instance.set_config(evaluator.config)
if ta_eval_class_instance.get_is_enabled():
ta_eval_class_instance.set_logger(
logging.getLogger(ta_eval_class.get_name()))
ta_eval_class_instance.set_data(evaluator.data)
ta_eval_class_instance.set_symbol(evaluator.get_symbol())
ta_eval_instance_list.append(ta_eval_class_instance)
return ta_eval_instance_list
def eval_impl(self):
interest_over_time_df = self.pytrends.interest_over_time()
# compute bollinger bands
self.eval_note = AdvancedManager.get_class(self.config, StatisticAnalysis).analyse_recent_trend_changes(
interest_over_time_df[self.symbol], numpy.sqrt)
def prepare(self):
self._purify_config()
self.sentiment_analyser = AdvancedManager.get_util_instance(self.config, TextAnalysis)
