fix: fetches only every second OHLCV candle

freqtrade/data/converter/converter.py

@@ -122,9 +122,8 @@ def populate_dataframe_with_trades(config: Config, dataframe: DataFrame, trades:
                 # skip if there are no trades at next candle because that this candle isn't finished yet
                 # if not np.any((candle_next == df.candle_start)):
                 if not candle_next in trades_grouped_by_candle_start.groups:
-                    logger.debug(
+                    logger.warning(
-                        f"Skipping candle at {candle_start} with {len(trades_grouped_df)} trades, because no finished trades at {candle_next}")
+                        f"candle at {candle_start} with {len(trades_grouped_df)} trades might be unfinished, because no finished trades at {candle_next}")
-                    continue
 
                 # add trades to each candle
                 df.loc[is_between, 'trades'] = df.loc[is_between,

freqtrade/data/dataprovider.py

@@ -458,9 +458,9 @@ class DataProvider:
         use_public_trades = self._config.get(
             'exchange', {}).get('use_public_trades', False)
         if use_public_trades:
-            return self._exchange.refresh_latest_trades(pairlist,
+            datahandler = get_datahandler(
-                                                        get_datahandler(self._config['datadir'],
+                self._config['datadir'], data_format=self._config['dataformat_trades'])
-                                                                        data_format=self._config['dataformat_trades']))
+            return self._exchange.refresh_latest_trades(pairlist, datahandler)
         return {}
 
     @property

freqtrade/exchange/exchange.py

@@ -2337,11 +2337,10 @@ class Exchange:
                         from_id = self._trades[(pair, timeframe, candle_type)].iloc[-1]['id']
 
                         last_candle_refresh = self._pairs_last_refresh_time.get((pair, timeframe, candle_type), arrow.utcnow().int_timestamp)
-                        until = last_candle_refresh * 1000
+                        until = int(timeframe_to_prev_date(timeframe, datetime.fromtimestamp(last_candle_refresh)).timestamp()) * 1000
 
                     else: 
-                        next_closed_candle_time = timeframe_to_next_date(timeframe)
+                        until = int(timeframe_to_prev_date(timeframe).timestamp()) * 1000
-                        until = int(next_closed_candle_time.timestamp()) * 1000
                         all_stored_ticks = data_handler.trades_load(f"{pair}-cached")
                         if all_stored_ticks:
                             if all_stored_ticks[0][0] <= first_candle_ms:
@@ -2383,15 +2382,15 @@ class Exchange:
         # Timeframe in seconds
         interval_in_sec = timeframe_to_seconds(timeframe)
         plr = self._pairs_last_refresh_time.get((pair, timeframe, candle_type), 0) + interval_in_sec
-        # current,active candle open date
+        now = arrow.utcnow().int_timestamp
-        now = int(timeframe_to_prev_date(timeframe).timestamp())
         return plr < now
 
     def _now_is_time_to_refresh_trades(self, pair: str, timeframe: str, candle_type: CandleType, refresh_earlier_seconds=5) -> bool:
         # Timeframe in seconds
         interval_in_sec = timeframe_to_seconds(timeframe)
         plr = self._trades_last_refresh_time.get((pair, timeframe, candle_type), 0) + interval_in_sec
-        return plr < arrow.utcnow().int_timestamp - refresh_earlier_seconds
+        now = arrow.utcnow().int_timestamp
+        return plr < now - refresh_earlier_seconds
 
     @retrier_async
     async def _async_get_candle_history(