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 start_update_loop(self): error = None try: time_frames = self.evaluator_task_manager_by_time_frame_by_symbol.keys( ) # sort time frames to update them in order of accuracy time_frames = TimeFrameManager.sort_time_frames(time_frames) if time_frames and self.symbols: self.in_backtesting = self._init_backtesting_if_necessary( time_frames) # init refreshed_times at 0 for each time frame self.refreshed_times = { key: {symbol: 0 for symbol in self.symbols} for key in time_frames } # init last refresh times at 0 for each time frame self.time_frame_last_update = { key: {symbol: 0 for symbol in self.symbols} for key in time_frames } while self.keep_running: try: await self._trigger_update(time_frames) except CancelledError: self.logger.info("Update tasks cancelled.") except Exception as e: self.logger.error( f"exception when triggering update: {e}") self.logger.exception(e) else: self.logger.warning( "No time frames to monitor, going to sleep. " "This is normal if you did not activate any technical analysis evaluator." ) except Exception as e: self.logger.exception(e) if self.watcher is not None: error = e finally: if self.in_backtesting \ and self.symbols is not None \ and not self.exchange.get_exchange().get_backtesting().get_is_finished(self.symbols): if error is None: error = "backtesting did not finish properly." if self.watcher is not None: self.watcher.set_error(error) self.logger.error(error)
def _set_config_time_frame(self): for time_frame in TimeFrameManager.get_config_time_frame(self.config): if self.time_frame_exists(time_frame.value): self.time_frames.append(time_frame) # add shortest timeframe for realtime evaluators client_shortest_time_frame = TimeFrameManager.find_min_time_frame( self.client_time_frames[CONFIG_WILDCARD], MIN_EVAL_TIME_FRAME) if client_shortest_time_frame not in self.time_frames: self.time_frames.append(client_shortest_time_frame) self.time_frames = TimeFrameManager.sort_time_frames(self.time_frames, reverse=True)
def run(self): exchange = None symbol = None error = None try: time_frames = self.evaluator_threads_manager_by_time_frame.keys() # sort time frames to update them in order of accuracy time_frames = TimeFrameManager.sort_time_frames(time_frames) if time_frames: # figure out from an evaluator if back testing is running for this symbol evaluator_thread_manager = next( iter( self.evaluator_threads_manager_by_time_frame.values())) symbol = evaluator_thread_manager.get_symbol() # test if we need to initialize backtesting features backtesting_enabled = Backtesting.enabled( evaluator_thread_manager.get_evaluator().get_config()) if backtesting_enabled: exchange = evaluator_thread_manager.exchange.get_exchange() exchange.init_candles_offset(time_frames, symbol) # init refreshed_times at 0 for each time frame self.refreshed_times = {key: 0 for key in time_frames} # init last refresh times at 0 for each time frame self.time_frame_last_update = {key: 0 for key in time_frames} while self.keep_running: self._execute_update(symbol, exchange, time_frames, backtesting_enabled) else: self.logger.warning( "no time frames to monitor, going to sleep.") except Exception as e: self.logger.exception(e) if self.watcher is not None: error = e finally: if exchange is not None and symbol is not None and not exchange.get_backtesting( ).get_is_finished(symbol): if error is None: error = "backtesting did not finish properly." self.watcher.set_error(error)
def run(self): exchange = None symbol = None error = None try: time_frames = self.evaluator_threads_manager_by_time_frame.keys() # sort time frames to update them in order of accuracy time_frames = TimeFrameManager.sort_time_frames(time_frames) if time_frames: # figure out from an evaluator if back testing is running for this symbol evaluator_thread_manager = next(iter(self.evaluator_threads_manager_by_time_frame.values())) symbol = evaluator_thread_manager.get_symbol() # test if we need to initialize backtesting features backtesting_enabled = Backtesting.enabled(evaluator_thread_manager.get_evaluator().get_config()) if backtesting_enabled: exchange = evaluator_thread_manager.exchange.get_exchange() exchange.init_candles_offset(time_frames, symbol) # init refreshed_times at 0 for each time frame self.refreshed_times = {key: 0 for key in time_frames} # init last refresh times at 0 for each time frame self.time_frame_last_update = {key: 0 for key in time_frames} while self.keep_running: now = time.time() for time_frame in time_frames: # backtesting doesn't need to wait a specific time frame to end to refresh data if backtesting_enabled: try: if exchange.should_update_data(time_frame, symbol): self._refresh_data(time_frame) except BacktestingEndedException as e: self.logger.info(e) self.keep_running = False exchange.end_backtesting(symbol) break # if data from this time frame needs an update elif now - self.time_frame_last_update[time_frame] \ >= TimeFramesMinutes[time_frame] * MINUTE_TO_SECONDS: try: self._refresh_data(time_frame) except Exception as e: self.logger.error(f" when refreshing data for time frame {time_frame} for {symbol}: " f"{e}") self.logger.exception(e) self.time_frame_last_update[time_frame] = time.time() self._update_pause(backtesting_enabled, now) else: self.logger.warning("no time frames to monitor, going to sleep.") except Exception as e: self.logger.exception(e) if self.watcher is not None: error = e finally: if exchange is not None and symbol is not None and not exchange.get_backtesting().get_is_finished(symbol): if error is None: error = "backtesting did not finish properly." self.watcher.set_error(error)