freqtrade_origin/freqtrade/plugins/pairlist/VolumePairList.py

317 lines
13 KiB
Python
Raw Normal View History

2018-11-30 05:34:56 +00:00
"""
2019-03-02 16:24:28 +00:00
Volume PairList provider
2018-11-30 05:34:56 +00:00
2020-05-17 11:26:21 +00:00
Provides dynamic pair list based on trade volumes
"""
2024-05-12 14:37:11 +00:00
2018-11-30 05:34:56 +00:00
import logging
2023-05-14 09:06:15 +00:00
from datetime import timedelta
from typing import Any, Dict, List, Literal
2019-10-29 09:39:27 +00:00
from cachetools import TTLCache
from freqtrade.constants import ListPairsWithTimeframes
from freqtrade.exceptions import OperationalException
from freqtrade.exchange import timeframe_to_minutes, timeframe_to_prev_date
from freqtrade.exchange.types import Tickers
from freqtrade.plugins.pairlist.IPairList import IPairList, PairlistParameter, SupportsBacktesting
from freqtrade.util import dt_now, format_ms_time
2021-07-04 09:40:45 +00:00
2020-05-17 11:26:21 +00:00
2018-11-30 05:34:56 +00:00
logger = logging.getLogger(__name__)
2020-05-17 11:26:21 +00:00
2024-05-12 14:37:11 +00:00
SORT_VALUES = ["quoteVolume"]
2018-12-04 06:12:56 +00:00
2018-11-30 05:34:56 +00:00
2018-12-05 19:44:56 +00:00
class VolumePairList(IPairList):
is_pairlist_generator = True
supports_backtesting = SupportsBacktesting.NO
def __init__(self, *args, **kwargs) -> None:
super().__init__(*args, **kwargs)
2019-11-09 05:55:16 +00:00
2024-05-12 14:37:11 +00:00
if "number_assets" not in self._pairlistconfig:
raise OperationalException(
2024-05-12 14:37:11 +00:00
"`number_assets` not specified. Please check your configuration "
'for "pairlist.config.number_assets"'
)
2024-06-09 06:52:40 +00:00
self._stake_currency = self._config["stake_currency"]
2024-05-12 14:37:11 +00:00
self._number_pairs = self._pairlistconfig["number_assets"]
self._sort_key: Literal["quoteVolume"] = self._pairlistconfig.get("sort_key", "quoteVolume")
self._min_value = self._pairlistconfig.get("min_value", 0)
self._max_value = self._pairlistconfig.get("max_value", None)
2024-05-12 14:37:11 +00:00
self._refresh_period = self._pairlistconfig.get("refresh_period", 1800)
self._pair_cache: TTLCache = TTLCache(maxsize=1, ttl=self._refresh_period)
2024-05-12 14:37:11 +00:00
self._lookback_days = self._pairlistconfig.get("lookback_days", 0)
self._lookback_timeframe = self._pairlistconfig.get("lookback_timeframe", "1d")
self._lookback_period = self._pairlistconfig.get("lookback_period", 0)
self._def_candletype = self._config["candle_type_def"]
if (self._lookback_days > 0) & (self._lookback_period > 0):
raise OperationalException(
"Ambiguous configuration: lookback_days and lookback_period both set in pairlist "
2024-05-12 14:37:11 +00:00
"config. Please set lookback_days only or lookback_period and lookback_timeframe "
"and restart the bot."
)
# overwrite lookback timeframe and days when lookback_days is set
if self._lookback_days > 0:
2024-05-12 14:37:11 +00:00
self._lookback_timeframe = "1d"
self._lookback_period = self._lookback_days
2021-07-04 09:40:45 +00:00
# get timeframe in minutes and seconds
self._tf_in_min = timeframe_to_minutes(self._lookback_timeframe)
_tf_in_sec = self._tf_in_min * 60
2021-07-04 09:40:45 +00:00
2024-04-18 20:51:25 +00:00
# whether to use range lookback or not
self._use_range = (self._tf_in_min > 0) & (self._lookback_period > 0)
if self._use_range & (self._refresh_period < _tf_in_sec):
raise OperationalException(
2024-05-12 14:37:11 +00:00
f"Refresh period of {self._refresh_period} seconds is smaller than one "
f"timeframe of {self._lookback_timeframe}. Please adjust refresh_period "
f"to at least {_tf_in_sec} and restart the bot."
)
2018-12-04 06:12:56 +00:00
2024-05-12 14:37:11 +00:00
if not self._use_range and not (
self._exchange.exchange_has("fetchTickers")
and self._exchange.get_option("tickers_have_quoteVolume")
):
raise OperationalException(
"Exchange does not support dynamic whitelist in this configuration. "
"Please edit your config and either remove Volumepairlist, "
"or switch to using candles. and restart the bot."
)
2018-12-05 18:48:50 +00:00
if not self._validate_keys(self._sort_key):
2024-05-12 14:37:11 +00:00
raise OperationalException(f"key {self._sort_key} not in {SORT_VALUES}")
2024-06-09 06:52:40 +00:00
candle_limit = self._exchange.ohlcv_candle_limit(
2024-05-12 14:37:11 +00:00
self._lookback_timeframe, self._config["candle_type_def"]
)
if self._lookback_period < 0:
raise OperationalException("VolumeFilter requires lookback_period to be >= 0")
2022-05-14 11:27:36 +00:00
if self._lookback_period > candle_limit:
2024-05-12 14:37:11 +00:00
raise OperationalException(
"VolumeFilter requires lookback_period to not "
f"exceed exchange max request size ({candle_limit})"
)
@property
def needstickers(self) -> bool:
"""
Boolean property defining if tickers are necessary.
2020-11-24 19:24:51 +00:00
If no Pairlist requires tickers, an empty Dict is passed
as tickers argument to filter_pairlist
"""
return not self._use_range
2018-12-05 18:48:50 +00:00
def _validate_keys(self, key):
2018-12-04 06:12:56 +00:00
return key in SORT_VALUES
2018-12-03 19:31:25 +00:00
def short_desc(self) -> str:
"""
Short whitelist method description - used for startup-messages
"""
2019-11-09 06:07:33 +00:00
return f"{self.name} - top {self._pairlistconfig['number_assets']} volume pairs."
2018-11-30 05:34:56 +00:00
@staticmethod
def description() -> str:
return "Provides dynamic pair list based on trade volumes."
2023-04-20 05:20:45 +00:00
@staticmethod
def available_parameters() -> Dict[str, PairlistParameter]:
return {
"number_assets": {
"type": "number",
2023-05-29 13:18:46 +00:00
"default": 30,
2023-04-20 05:20:45 +00:00
"description": "Number of assets",
"help": "Number of assets to use from the pairlist",
},
"sort_key": {
2023-04-21 17:30:32 +00:00
"type": "option",
2023-04-20 05:20:45 +00:00
"default": "quoteVolume",
2023-04-21 17:30:32 +00:00
"options": SORT_VALUES,
2023-04-20 05:20:45 +00:00
"description": "Sort key",
"help": "Sort key to use for sorting the pairlist.",
},
"min_value": {
"type": "number",
"default": 0,
"description": "Minimum value",
"help": "Minimum value to use for filtering the pairlist.",
},
"max_value": {
"type": "number",
"default": None,
"description": "Maximum value",
"help": "Maximum value to use for filtering the pairlist.",
},
2023-04-20 05:20:45 +00:00
**IPairList.refresh_period_parameter(),
"lookback_days": {
"type": "number",
2023-05-29 13:18:46 +00:00
"default": 0,
2023-04-20 05:20:45 +00:00
"description": "Lookback Days",
"help": "Number of days to look back at.",
},
"lookback_timeframe": {
"type": "string",
2023-05-29 13:18:46 +00:00
"default": "",
2023-04-20 05:20:45 +00:00
"description": "Lookback Timeframe",
"help": "Timeframe to use for lookback.",
},
"lookback_period": {
"type": "number",
"default": 0,
"description": "Lookback Period",
"help": "Number of periods to look back at.",
},
}
def gen_pairlist(self, tickers: Tickers) -> List[str]:
2018-11-30 05:34:56 +00:00
"""
Generate the pairlist
:param tickers: Tickers (from exchange.get_tickers). May be cached.
:return: List of pairs
2018-11-30 05:34:56 +00:00
"""
# Generate dynamic whitelist
# Must always run if this pairlist is not the first in the list.
2024-05-12 14:37:11 +00:00
pairlist = self._pair_cache.get("pairlist")
if pairlist:
# Item found - no refresh necessary
2021-08-17 04:44:20 +00:00
return pairlist.copy()
else:
# Use fresh pairlist
# Check if pair quote currency equals to the stake currency.
2024-05-12 14:37:11 +00:00
_pairlist = [
k
for k in self._exchange.get_markets(
quote_currencies=[self._stake_currency], tradable_only=True, active_only=True
).keys()
]
# No point in testing for blacklisted pairs...
_pairlist = self.verify_blacklist(_pairlist, logger.info)
if not self._use_range:
filtered_tickers = [
2024-05-12 14:37:11 +00:00
v
for k, v in tickers.items()
if (
self._exchange.get_pair_quote_currency(k) == self._stake_currency
and (self._use_range or v.get(self._sort_key) is not None)
2024-05-12 14:37:11 +00:00
and v["symbol"] in _pairlist
)
]
pairlist = [s["symbol"] for s in filtered_tickers]
else:
pairlist = _pairlist
pairlist = self.filter_pairlist(pairlist, tickers)
2024-05-12 14:37:11 +00:00
self._pair_cache["pairlist"] = pairlist.copy()
return pairlist
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
"""
2021-07-04 09:40:45 +00:00
if self._use_range:
# Create bare minimum from tickers structure.
2024-05-12 14:37:11 +00:00
filtered_tickers: List[Dict[str, Any]] = [{"symbol": k} for k in pairlist]
# get lookback period in ms, for exchange ohlcv fetch
2024-05-12 14:37:11 +00:00
since_ms = (
int(
timeframe_to_prev_date(
self._lookback_timeframe,
dt_now()
+ timedelta(
minutes=-(self._lookback_period * self._tf_in_min) - self._tf_in_min
),
).timestamp()
)
* 1000
)
2024-05-12 14:37:11 +00:00
to_ms = (
int(
timeframe_to_prev_date(
self._lookback_timeframe, dt_now() - timedelta(minutes=self._tf_in_min)
).timestamp()
)
* 1000
)
# todo: utc date output for starting date
2024-05-12 14:37:11 +00:00
self.log_once(
f"Using volume range of {self._lookback_period} candles, timeframe: "
f"{self._lookback_timeframe}, starting from {format_ms_time(since_ms)} "
f"till {format_ms_time(to_ms)}",
logger.info,
)
2021-12-03 14:08:00 +00:00
needed_pairs: ListPairsWithTimeframes = [
2024-05-12 14:37:11 +00:00
(p, self._lookback_timeframe, self._def_candletype)
for p in [s["symbol"] for s in filtered_tickers]
if p not in self._pair_cache
2021-07-04 09:40:45 +00:00
]
2021-07-03 09:47:17 +00:00
candles = self._exchange.refresh_ohlcv_with_cache(needed_pairs, since_ms)
2021-07-04 09:40:45 +00:00
for i, p in enumerate(filtered_tickers):
2024-05-12 14:37:11 +00:00
contract_size = self._exchange.markets[p["symbol"]].get("contractSize", 1.0) or 1.0
pair_candles = (
candles[(p["symbol"], self._lookback_timeframe, self._def_candletype)]
if (p["symbol"], self._lookback_timeframe, self._def_candletype) in candles
else None
)
2021-07-03 09:47:17 +00:00
# in case of candle data calculate typical price and quoteVolume for candle
if pair_candles is not None and not pair_candles.empty:
if self._exchange.get_option("ohlcv_volume_currency") == "base":
2024-05-12 14:37:11 +00:00
pair_candles["typical_price"] = (
pair_candles["high"] + pair_candles["low"] + pair_candles["close"]
) / 3
2024-05-12 14:37:11 +00:00
pair_candles["quoteVolume"] = (
pair_candles["volume"] * pair_candles["typical_price"] * contract_size
)
else:
# Exchange ohlcv data is in quote volume already.
2024-05-12 14:37:11 +00:00
pair_candles["quoteVolume"] = pair_candles["volume"]
# ensure that a rolling sum over the lookback_period is built
# if pair_candles contains more candles than lookback_period
2024-05-12 14:37:11 +00:00
quoteVolume = (
pair_candles["quoteVolume"]
.rolling(self._lookback_period)
.sum()
.fillna(0)
.iloc[-1]
)
# replace quoteVolume with range quoteVolume sum calculated above
2024-05-12 14:37:11 +00:00
filtered_tickers[i]["quoteVolume"] = quoteVolume
else:
2024-05-12 14:37:11 +00:00
filtered_tickers[i]["quoteVolume"] = 0
else:
2022-12-10 18:54:04 +00:00
# Tickers mode - filter based on incoming pairlist.
filtered_tickers = [v for k, v in tickers.items() if k in pairlist]
2020-05-15 00:59:13 +00:00
if self._min_value > 0:
2024-05-12 14:37:11 +00:00
filtered_tickers = [v for v in filtered_tickers if v[self._sort_key] > self._min_value]
if self._max_value is not None:
2024-05-12 14:37:11 +00:00
filtered_tickers = [v for v in filtered_tickers if v[self._sort_key] < self._max_value]
2020-05-15 00:59:13 +00:00
sorted_tickers = sorted(filtered_tickers, reverse=True, key=lambda t: t[self._sort_key])
2019-03-02 16:24:28 +00:00
# Validate whitelist to only have active market pairs
2024-05-12 14:37:11 +00:00
pairs = self._whitelist_for_active_markets([s["symbol"] for s in sorted_tickers])
pairs = self.verify_blacklist(pairs, logmethod=logger.info)
2020-05-17 11:26:21 +00:00
# Limit pairlist to the requested number of pairs
2024-05-12 14:37:11 +00:00
pairs = pairs[: self._number_pairs]
return pairs