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)
