Merge pull request #3975 from freqtrade/volatility_filter

RangeStabilityFilter filter - filter for pairs without much movement

freqtrade/constants.py

@@ -25,7 +25,7 @@ HYPEROPT_LOSS_BUILTIN = ['ShortTradeDurHyperOptLoss', 'OnlyProfitHyperOptLoss',
                          'SortinoHyperOptLoss', 'SortinoHyperOptLossDaily']
 AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList',
                        'AgeFilter', 'PrecisionFilter', 'PriceFilter',
-                       'ShuffleFilter', 'SpreadFilter']
+                       'RangeStabilityFilter', 'ShuffleFilter', 'SpreadFilter']
 AVAILABLE_DATAHANDLERS = ['json', 'jsongz', 'hdf5']
 DRY_RUN_WALLET = 1000
 DATETIME_PRINT_FORMAT = '%Y-%m-%d %H:%M:%S'

freqtrade/exchange/exchange.py

@@ -679,12 +679,25 @@ class Exchange:
         :param pair: Pair to download
         :param timeframe: Timeframe to get data for
         :param since_ms: Timestamp in milliseconds to get history from
-        :returns List with candle (OHLCV) data
+        :return: List with candle (OHLCV) data
         """
         return asyncio.get_event_loop().run_until_complete(
             self._async_get_historic_ohlcv(pair=pair, timeframe=timeframe,
                                            since_ms=since_ms))
 
+    def get_historic_ohlcv_as_df(self, pair: str, timeframe: str,
+                                 since_ms: int) -> DataFrame:
+        """
+        Minimal wrapper around get_historic_ohlcv - converting the result into a dataframe
+        :param pair: Pair to download
+        :param timeframe: Timeframe to get data for
+        :param since_ms: Timestamp in milliseconds to get history from
+        :return: OHLCV DataFrame
+        """
+        ticks = self.get_historic_ohlcv(pair, timeframe, since_ms=since_ms)
+        return ohlcv_to_dataframe(ticks, timeframe, pair=pair, fill_missing=True,
+                                  drop_incomplete=self._ohlcv_partial_candle)
+
     async def _async_get_historic_ohlcv(self, pair: str,
                                         timeframe: str,
                                         since_ms: int) -> List:

freqtrade/pairlist/AgeFilter.py

@@ -49,7 +49,7 @@ class AgeFilter(IPairList):
         return (f"{self.name} - Filtering pairs with age less than "
                 f"{self._min_days_listed} {plural(self._min_days_listed, 'day')}.")
 
-    def _validate_pair(self, ticker: dict) -> bool:
+    def _validate_pair(self, ticker: Dict) -> bool:
         """
         Validate age for the ticker
         :param ticker: ticker dict as returned from ccxt.load_markets()

freqtrade/pairlist/rangestabilityfilter.py

@@ -0,0 +1,89 @@
+"""
+Rate of change pairlist filter
+"""
+import logging
+from typing import Any, Dict
+
+import arrow
+from cachetools.ttl import TTLCache
+
+from freqtrade.exceptions import OperationalException
+from freqtrade.misc import plural
+from freqtrade.pairlist.IPairList import IPairList
+
+
+logger = logging.getLogger(__name__)
+
+
+class RangeStabilityFilter(IPairList):
+
+    def __init__(self, exchange, pairlistmanager,
+                 config: Dict[str, Any], pairlistconfig: Dict[str, Any],
+                 pairlist_pos: int) -> None:
+        super().__init__(exchange, pairlistmanager, config, pairlistconfig, pairlist_pos)
+
+        self._days = pairlistconfig.get('lookback_days', 10)
+        self._min_rate_of_change = pairlistconfig.get('min_rate_of_change', 0.01)
+        self._refresh_period = pairlistconfig.get('refresh_period', 1440)
+
+        self._pair_cache: TTLCache = TTLCache(maxsize=100, ttl=self._refresh_period)
+
+        if self._days < 1:
+            raise OperationalException("RangeStabilityFilter requires lookback_days to be >= 1")
+        if self._days > exchange.ohlcv_candle_limit:
+            raise OperationalException("RangeStabilityFilter requires lookback_days to not "
+                                       "exceed exchange max request size "
+                                       f"({exchange.ohlcv_candle_limit})")
+
+    @property
+    def needstickers(self) -> bool:
+        """
+        Boolean property defining if tickers are necessary.
+        If no Pairlist requires tickers, an empty List is passed
+        as tickers argument to filter_pairlist
+        """
+        return True
+
+    def short_desc(self) -> str:
+        """
+        Short whitelist method description - used for startup-messages
+        """
+        return (f"{self.name} - Filtering pairs with rate of change below "
+                f"{self._min_rate_of_change} over the last {plural(self._days, 'day')}.")
+
+    def _validate_pair(self, ticker: Dict) -> bool:
+        """
+        Validate trading range
+        :param ticker: ticker dict as returned from ccxt.load_markets()
+        :return: True if the pair can stay, False if it should be removed
+        """
+        pair = ticker['symbol']
+        # Check symbol in cache
+        if pair in self._pair_cache:
+            return self._pair_cache[pair]
+
+        since_ms = int(arrow.utcnow()
+                       .floor('day')
+                       .shift(days=-self._days)
+                       .float_timestamp) * 1000
+
+        daily_candles = self._exchange.get_historic_ohlcv_as_df(pair=pair,
+                                                                timeframe='1d',
+                                                                since_ms=since_ms)
+        result = False
+        if daily_candles is not None and not daily_candles.empty:
+            highest_high = daily_candles['high'].max()
+            lowest_low = daily_candles['low'].min()
+            pct_change = ((highest_high - lowest_low) / lowest_low) if lowest_low > 0 else 0
+            if pct_change >= self._min_rate_of_change:
+                result = True
+            else:
+                self.log_on_refresh(logger.info,
+                                    f"Removed {pair} from whitelist, "
+                                    f"because rate of change over {plural(self._days, 'day')} is "
+                                    f"{pct_change:.3f}, which is below the "
+                                    f"threshold of {self._min_rate_of_change}.")
+                result = False
+            self._pair_cache[pair] = result
+
+        return result