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)