Merge pull request #7473 from freqtrade/feat/producerpairlist

Producerpairlist

freqtrade/constants.py

@@ -31,7 +31,7 @@ HYPEROPT_LOSS_BUILTIN = ['ShortTradeDurHyperOptLoss', 'OnlyProfitHyperOptLoss',
                          'CalmarHyperOptLoss',
                          'MaxDrawDownHyperOptLoss', 'MaxDrawDownRelativeHyperOptLoss',
                          'ProfitDrawDownHyperOptLoss']
-AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList',
+AVAILABLE_PAIRLISTS = ['StaticPairList', 'VolumePairList', 'ProducerPairList',
                        'AgeFilter', 'OffsetFilter', 'PerformanceFilter',
                        'PrecisionFilter', 'PriceFilter', 'RangeStabilityFilter',
                        'ShuffleFilter', 'SpreadFilter', 'VolatilityFilter']

freqtrade/freqtradebot.py

@@ -82,7 +82,10 @@ class FreqtradeBot(LoggingMixin):
         # Keep this at the end of this initialization method.
         self.rpc: RPCManager = RPCManager(self)
 
-        self.dataprovider = DataProvider(self.config, self.exchange, self.pairlists, self.rpc)
+        self.dataprovider = DataProvider(self.config, self.exchange, rpc=self.rpc)
+        self.pairlists = PairListManager(self.exchange, self.config, self.dataprovider)
+
+        self.dataprovider.add_pairlisthandler(self.pairlists)
 
         # Attach Dataprovider to strategy instance
         self.strategy.dp = self.dataprovider

freqtrade/optimize/backtesting.py

@@ -110,7 +110,7 @@ class Backtesting:
         self.timeframe = str(self.config.get('timeframe'))
         self.timeframe_min = timeframe_to_minutes(self.timeframe)
         self.init_backtest_detail()
-        self.pairlists = PairListManager(self.exchange, self.config)
+        self.pairlists = PairListManager(self.exchange, self.config, self.dataprovider)
         if 'VolumePairList' in self.pairlists.name_list:
             raise OperationalException("VolumePairList not allowed for backtesting. "
                                        "Please use StaticPairList instead.")

freqtrade/plugins/pairlist/ProducerPairList.py

@@ -0,0 +1,90 @@
+"""
+External Pair List provider
+
+Provides pair list from Leader data
+"""
+import logging
+from typing import Any, Dict, List, Optional
+
+from freqtrade.exceptions import OperationalException
+from freqtrade.plugins.pairlist.IPairList import IPairList
+
+
+logger = logging.getLogger(__name__)
+
+
+class ProducerPairList(IPairList):
+    """
+    PairList plugin for use with external_message_consumer.
+    Will use pairs given from leader data.
+
+    Usage:
+        "pairlists": [
+            {
+                "method": "ProducerPairList",
+                "number_assets": 5,
+                "producer_name": "default",
+            }
+        ],
+    """
+
+    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._num_assets: int = self._pairlistconfig.get('number_assets', 0)
+        self._producer_name = self._pairlistconfig.get('producer_name', 'default')
+        if not config.get('external_message_consumer', {}).get('enabled'):
+            raise OperationalException(
+                "ProducerPairList requires external_message_consumer to be enabled.")
+
+    @property
+    def needstickers(self) -> bool:
+        """
+        Boolean property defining if tickers are necessary.
+        If no Pairlist requires tickers, an empty Dict is passed
+        as tickers argument to filter_pairlist
+        """
+        return False
+
+    def short_desc(self) -> str:
+        """
+        Short whitelist method description - used for startup-messages
+        -> Please overwrite in subclasses
+        """
+        return f"{self.name} - {self._producer_name}"
+
+    def _filter_pairlist(self, pairlist: Optional[List[str]]):
+        upstream_pairlist = self._pairlistmanager._dataprovider.get_producer_pairs(
+            self._producer_name)
+
+        if pairlist is None:
+            pairlist = self._pairlistmanager._dataprovider.get_producer_pairs(self._producer_name)
+
+        pairs = list(dict.fromkeys(pairlist + upstream_pairlist))
+        if self._num_assets:
+            pairs = pairs[:self._num_assets]
+
+        return pairs
+
+    def gen_pairlist(self, tickers: Dict) -> List[str]:
+        """
+        Generate the pairlist
+        :param tickers: Tickers (from exchange.get_tickers()). May be cached.
+        :return: List of pairs
+        """
+        pairs = self._filter_pairlist(None)
+        self.log_once(f"Received pairs: {pairs}", logger.debug)
+        pairs = self._whitelist_for_active_markets(self.verify_whitelist(pairs, logger.info))
+        return pairs
+
+    def filter_pairlist(self, pairlist: List[str], tickers: Dict) -> List[str]:
+        """
+        Filters and sorts pairlist and returns the whitelist again.
+        Called on each bot iteration - please use internal caching if necessary
+        :param pairlist: pairlist to filter or sort
+        :param tickers: Tickers (from exchange.get_tickers()). May be cached.
+        :return: new whitelist
+        """
+        return self._filter_pairlist(pairlist)

freqtrade/plugins/pairlist/VolumePairList.py

@@ -232,6 +232,4 @@ class VolumePairList(IPairList):
         # Limit pairlist to the requested number of pairs
         pairs = pairs[:self._number_pairs]
 
-        self.log_once(f"Searching {self._number_pairs} pairs: {pairs}", logger.info)
-
         return pairs

freqtrade/plugins/pairlistmanager.py

@@ -3,11 +3,12 @@ PairList manager class
 """
 import logging
 from functools import partial
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from cachetools import TTLCache, cached
 
 from freqtrade.constants import Config, ListPairsWithTimeframes
+from freqtrade.data.dataprovider import DataProvider
 from freqtrade.enums import CandleType
 from freqtrade.exceptions import OperationalException
 from freqtrade.mixins import LoggingMixin
@@ -21,13 +22,14 @@ logger = logging.getLogger(__name__)
 
 class PairListManager(LoggingMixin):
 
-    def __init__(self, exchange, config: Config) -> None:
+    def __init__(self, exchange, config: Config, dataprovider: DataProvider = None) -> None:
         self._exchange = exchange
         self._config = config
         self._whitelist = self._config['exchange'].get('pair_whitelist')
         self._blacklist = self._config['exchange'].get('pair_blacklist', [])
         self._pairlist_handlers: List[IPairList] = []
         self._tickers_needed = False
+        self._dataprovider: Optional[DataProvider] = dataprovider
         for pairlist_handler_config in self._config.get('pairlists', []):
             pairlist_handler = PairListResolver.load_pairlist(
                 pairlist_handler_config['method'],
@@ -96,6 +98,8 @@ class PairListManager(LoggingMixin):
         # to ensure blacklist is respected.
         pairlist = self.verify_blacklist(pairlist, logger.warning)
 
+        self.log_once(f"Whitelist with {len(pairlist)} pairs: {pairlist}", logger.info)
+
         self._whitelist = pairlist
 
     def verify_blacklist(self, pairlist: List[str], logmethod) -> List[str]: