2018-02-09 07:35:38 +00:00
|
|
|
# pragma pylint: disable=missing-docstring, W0212, too-many-arguments
|
2017-11-14 21:15:24 +00:00
|
|
|
|
2018-02-09 07:35:38 +00:00
|
|
|
"""
|
|
|
|
This module contains the backtesting logic
|
|
|
|
"""
|
2018-03-25 19:37:14 +00:00
|
|
|
import logging
|
2020-10-07 18:59:05 +00:00
|
|
|
from collections import defaultdict
|
2018-07-27 21:01:52 +00:00
|
|
|
from copy import deepcopy
|
2021-01-13 06:47:03 +00:00
|
|
|
from datetime import datetime, timedelta, timezone
|
2021-01-23 12:02:48 +00:00
|
|
|
from typing import Any, Dict, List, Optional, Tuple
|
2018-03-17 21:44:47 +00:00
|
|
|
|
2022-01-16 13:46:43 +00:00
|
|
|
from numpy import nan
|
Fix exception when few pairs with no data do not result in aborting backtest.
Exception is triggered by backtesting 20210301-20210501 range with BAKE/USDT pair (binance). Pair data starts on 2021-04-30 12:00:00 and after adjusting for startup candles pair dataframe is empty.
Solution: Since there are other pairs with enough data - skip pairs with no data and issue a warning.
Exception:
```
Traceback (most recent call last):
File "/home/rk/src/freqtrade/freqtrade/main.py", line 37, in main
return_code = args['func'](args)
File "/home/rk/src/freqtrade/freqtrade/commands/optimize_commands.py", line 53, in start_backtesting
backtesting.start()
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 502, in start
min_date, max_date = self.backtest_one_strategy(strat, data, timerange)
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 474, in backtest_one_strategy
results = self.backtest(
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 365, in backtest
data: Dict = self._get_ohlcv_as_lists(processed)
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 199, in _get_ohlcv_as_lists
pair_data.loc[:, 'buy'] = 0 # cleanup from previous run
File "/home/rk/src/freqtrade/venv/lib/python3.9/site-packages/pandas/core/indexing.py", line 692, in __setitem__
iloc._setitem_with_indexer(indexer, value, self.name)
File "/home/rk/src/freqtrade/venv/lib/python3.9/site-packages/pandas/core/indexing.py", line 1587, in _setitem_with_indexer
raise ValueError(
ValueError: cannot set a frame with no defined index and a scalar
```
2021-05-13 06:47:28 +00:00
|
|
|
from pandas import DataFrame
|
2017-09-28 21:26:28 +00:00
|
|
|
|
2022-01-18 09:00:51 +00:00
|
|
|
from freqtrade import constants
|
2021-09-13 18:00:22 +00:00
|
|
|
from freqtrade.configuration import TimeRange, validate_config_consistency
|
2020-06-26 05:46:59 +00:00
|
|
|
from freqtrade.constants import DATETIME_PRINT_FORMAT
|
2018-12-13 05:34:10 +00:00
|
|
|
from freqtrade.data import history
|
2022-01-06 09:53:11 +00:00
|
|
|
from freqtrade.data.btanalysis import find_existing_backtest_stats, trade_list_to_dataframe
|
2021-07-13 17:36:15 +00:00
|
|
|
from freqtrade.data.converter import trim_dataframe, trim_dataframes
|
2019-03-24 14:24:47 +00:00
|
|
|
from freqtrade.data.dataprovider import DataProvider
|
2022-02-26 20:11:21 +00:00
|
|
|
from freqtrade.enums import BacktestState, CandleType, MarginMode, SellType, TradingMode
|
2021-02-10 19:37:55 +00:00
|
|
|
from freqtrade.exceptions import DependencyException, OperationalException
|
2019-10-20 11:56:01 +00:00
|
|
|
from freqtrade.exchange import timeframe_to_minutes, timeframe_to_seconds
|
2022-01-06 09:53:11 +00:00
|
|
|
from freqtrade.misc import get_strategy_run_id
|
2020-12-07 14:45:02 +00:00
|
|
|
from freqtrade.mixins import LoggingMixin
|
2021-03-21 14:56:36 +00:00
|
|
|
from freqtrade.optimize.bt_progress import BTProgress
|
2020-09-28 17:39:41 +00:00
|
|
|
from freqtrade.optimize.optimize_reports import (generate_backtest_stats, show_backtest_results,
|
2020-06-26 05:46:59 +00:00
|
|
|
store_backtest_stats)
|
2021-12-18 09:15:59 +00:00
|
|
|
from freqtrade.persistence import LocalTrade, Order, PairLocks, Trade
|
2020-12-23 16:00:02 +00:00
|
|
|
from freqtrade.plugins.pairlistmanager import PairListManager
|
2020-11-16 19:17:47 +00:00
|
|
|
from freqtrade.plugins.protectionmanager import ProtectionManager
|
2019-03-06 18:55:34 +00:00
|
|
|
from freqtrade.resolvers import ExchangeResolver, StrategyResolver
|
2021-06-08 19:04:34 +00:00
|
|
|
from freqtrade.strategy.interface import IStrategy, SellCheckTuple
|
2020-10-11 17:50:37 +00:00
|
|
|
from freqtrade.strategy.strategy_wrapper import strategy_safe_wrapper
|
2021-01-28 06:06:58 +00:00
|
|
|
from freqtrade.wallets import Wallets
|
2019-04-09 09:27:35 +00:00
|
|
|
|
2021-03-25 08:34:33 +00:00
|
|
|
|
2018-03-25 19:37:14 +00:00
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
2020-10-18 15:16:57 +00:00
|
|
|
# Indexes for backtest tuples
|
|
|
|
DATE_IDX = 0
|
2021-08-23 19:15:56 +00:00
|
|
|
OPEN_IDX = 1
|
|
|
|
HIGH_IDX = 2
|
|
|
|
LOW_IDX = 3
|
|
|
|
CLOSE_IDX = 4
|
2021-08-24 04:54:55 +00:00
|
|
|
LONG_IDX = 5
|
|
|
|
ELONG_IDX = 6 # Exit long
|
2021-08-23 19:15:56 +00:00
|
|
|
SHORT_IDX = 7
|
2021-08-24 04:54:55 +00:00
|
|
|
ESHORT_IDX = 8 # Exit short
|
2021-09-25 17:31:06 +00:00
|
|
|
ENTER_TAG_IDX = 9
|
2021-11-06 14:24:52 +00:00
|
|
|
EXIT_TAG_IDX = 10
|
2020-10-18 15:16:57 +00:00
|
|
|
|
2018-03-25 19:37:14 +00:00
|
|
|
|
2019-09-12 01:39:52 +00:00
|
|
|
class Backtesting:
|
2017-11-14 22:14:01 +00:00
|
|
|
"""
|
2018-02-09 07:35:38 +00:00
|
|
|
Backtesting class, this class contains all the logic to run a backtest
|
|
|
|
|
|
|
|
To run a backtest:
|
|
|
|
backtesting = Backtesting(config)
|
|
|
|
backtesting.start()
|
2017-11-14 22:14:01 +00:00
|
|
|
"""
|
2018-07-28 05:00:58 +00:00
|
|
|
|
2018-02-09 07:35:38 +00:00
|
|
|
def __init__(self, config: Dict[str, Any]) -> None:
|
2020-11-19 19:05:56 +00:00
|
|
|
|
|
|
|
LoggingMixin.show_output = False
|
2018-02-09 07:35:38 +00:00
|
|
|
self.config = config
|
2022-01-06 09:53:11 +00:00
|
|
|
self.results: Dict[str, Any] = {}
|
2022-01-22 13:11:33 +00:00
|
|
|
self.trade_id_counter: int = 0
|
|
|
|
self.order_id_counter: int = 0
|
2018-04-06 07:57:08 +00:00
|
|
|
|
2021-09-13 18:00:22 +00:00
|
|
|
config['dry_run'] = True
|
2022-01-18 09:00:51 +00:00
|
|
|
self.run_ids: Dict[str, str] = {}
|
2018-07-28 05:41:38 +00:00
|
|
|
self.strategylist: List[IStrategy] = []
|
2020-09-18 05:44:11 +00:00
|
|
|
self.all_results: Dict[str, Dict] = {}
|
2021-08-23 19:13:47 +00:00
|
|
|
self._exchange_name = self.config['exchange']['name']
|
|
|
|
self.exchange = ExchangeResolver.load_exchange(self._exchange_name, self.config)
|
2021-11-22 07:27:33 +00:00
|
|
|
self.dataprovider = DataProvider(self.config, self.exchange)
|
2019-03-24 14:24:47 +00:00
|
|
|
|
2018-07-28 05:41:38 +00:00
|
|
|
if self.config.get('strategy_list', None):
|
2018-07-28 05:55:59 +00:00
|
|
|
for strat in list(self.config['strategy_list']):
|
2018-07-28 05:41:38 +00:00
|
|
|
stratconf = deepcopy(self.config)
|
|
|
|
stratconf['strategy'] = strat
|
2019-12-23 09:23:48 +00:00
|
|
|
self.strategylist.append(StrategyResolver.load_strategy(stratconf))
|
2019-11-23 14:49:46 +00:00
|
|
|
validate_config_consistency(stratconf)
|
2018-07-28 05:41:38 +00:00
|
|
|
|
|
|
|
else:
|
2019-06-09 23:08:54 +00:00
|
|
|
# No strategy list specified, only one strategy
|
2019-12-23 09:23:48 +00:00
|
|
|
self.strategylist.append(StrategyResolver.load_strategy(self.config))
|
2019-11-23 14:49:46 +00:00
|
|
|
validate_config_consistency(self.config)
|
2019-06-09 23:08:54 +00:00
|
|
|
|
2020-06-01 18:49:40 +00:00
|
|
|
if "timeframe" not in self.config:
|
2020-03-08 10:35:31 +00:00
|
|
|
raise OperationalException("Timeframe (ticker interval) needs to be set in either "
|
2020-06-01 18:49:40 +00:00
|
|
|
"configuration or as cli argument `--timeframe 5m`")
|
|
|
|
self.timeframe = str(self.config.get('timeframe'))
|
2019-12-11 06:12:37 +00:00
|
|
|
self.timeframe_min = timeframe_to_minutes(self.timeframe)
|
2021-09-26 13:07:48 +00:00
|
|
|
self.init_backtest_detail()
|
2020-06-07 14:06:20 +00:00
|
|
|
self.pairlists = PairListManager(self.exchange, self.config)
|
|
|
|
if 'VolumePairList' in self.pairlists.name_list:
|
2021-11-25 07:00:10 +00:00
|
|
|
raise OperationalException("VolumePairList not allowed for backtesting. "
|
2021-11-26 05:27:06 +00:00
|
|
|
"Please use StaticPairlist instead.")
|
2020-12-16 18:24:47 +00:00
|
|
|
if 'PerformanceFilter' in self.pairlists.name_list:
|
|
|
|
raise OperationalException("PerformanceFilter not allowed for backtesting.")
|
2020-06-07 14:06:20 +00:00
|
|
|
|
|
|
|
if len(self.strategylist) > 1 and 'PrecisionFilter' in self.pairlists.name_list:
|
|
|
|
raise OperationalException(
|
|
|
|
"PrecisionFilter not allowed for backtesting multiple strategies."
|
|
|
|
)
|
|
|
|
|
2021-05-02 09:20:54 +00:00
|
|
|
self.dataprovider.add_pairlisthandler(self.pairlists)
|
2020-06-07 14:06:20 +00:00
|
|
|
self.pairlists.refresh_pairlist()
|
|
|
|
|
|
|
|
if len(self.pairlists.whitelist) == 0:
|
|
|
|
raise OperationalException("No pair in whitelist.")
|
|
|
|
|
2020-07-15 17:20:07 +00:00
|
|
|
if config.get('fee', None) is not None:
|
2020-06-07 14:06:20 +00:00
|
|
|
self.fee = config['fee']
|
|
|
|
else:
|
|
|
|
self.fee = self.exchange.get_fee(symbol=self.pairlists.whitelist[0])
|
|
|
|
|
2021-07-13 17:36:15 +00:00
|
|
|
self.timerange = TimeRange.parse_timerange(
|
|
|
|
None if self.config.get('timerange') is None else str(self.config.get('timerange')))
|
|
|
|
|
2019-10-20 11:56:01 +00:00
|
|
|
# Get maximum required startup period
|
|
|
|
self.required_startup = max([strat.startup_candle_count for strat in self.strategylist])
|
2021-08-01 17:16:26 +00:00
|
|
|
# Add maximum startup candle count to configuration for informative pairs support
|
|
|
|
self.config['startup_candle_count'] = self.required_startup
|
2021-07-09 05:19:44 +00:00
|
|
|
self.exchange.validate_required_startup_candles(self.required_startup, self.timeframe)
|
2018-02-09 07:35:38 +00:00
|
|
|
|
2022-02-21 18:19:12 +00:00
|
|
|
self.trading_mode: TradingMode = config.get('trading_mode', TradingMode.SPOT)
|
2022-02-27 17:59:27 +00:00
|
|
|
self.margin_mode: MarginMode = config.get('margin_mode', MarginMode.NONE)
|
2022-03-11 18:37:45 +00:00
|
|
|
# strategies which define "can_short=True" will fail to load in Spot mode.
|
2021-11-21 18:28:53 +00:00
|
|
|
self._can_short = self.trading_mode != TradingMode.SPOT
|
2021-09-22 18:36:03 +00:00
|
|
|
|
2021-03-21 14:56:36 +00:00
|
|
|
self.progress = BTProgress()
|
2021-04-05 17:58:53 +00:00
|
|
|
self.abort = False
|
2021-09-26 13:07:48 +00:00
|
|
|
self.init_backtest()
|
2021-03-11 18:16:18 +00:00
|
|
|
|
2020-11-25 08:53:13 +00:00
|
|
|
def __del__(self):
|
2021-08-09 09:18:18 +00:00
|
|
|
self.cleanup()
|
|
|
|
|
2022-02-24 05:25:21 +00:00
|
|
|
@staticmethod
|
|
|
|
def cleanup():
|
2020-11-25 08:53:13 +00:00
|
|
|
LoggingMixin.show_output = True
|
|
|
|
PairLocks.use_db = True
|
|
|
|
Trade.use_db = True
|
|
|
|
|
2021-09-26 13:07:48 +00:00
|
|
|
def init_backtest_detail(self):
|
|
|
|
# Load detail timeframe if specified
|
|
|
|
self.timeframe_detail = str(self.config.get('timeframe_detail', ''))
|
|
|
|
if self.timeframe_detail:
|
|
|
|
self.timeframe_detail_min = timeframe_to_minutes(self.timeframe_detail)
|
|
|
|
if self.timeframe_min <= self.timeframe_detail_min:
|
|
|
|
raise OperationalException(
|
|
|
|
"Detail timeframe must be smaller than strategy timeframe.")
|
|
|
|
|
|
|
|
else:
|
|
|
|
self.timeframe_detail_min = 0
|
|
|
|
self.detail_data: Dict[str, DataFrame] = {}
|
2022-01-17 18:41:01 +00:00
|
|
|
self.futures_data: Dict[str, DataFrame] = {}
|
2021-09-26 13:07:48 +00:00
|
|
|
|
|
|
|
def init_backtest(self):
|
|
|
|
|
|
|
|
self.prepare_backtest(False)
|
|
|
|
|
|
|
|
self.wallets = Wallets(self.config, self.exchange, log=False)
|
|
|
|
|
|
|
|
self.progress = BTProgress()
|
|
|
|
self.abort = False
|
|
|
|
|
2021-02-26 18:48:06 +00:00
|
|
|
def _set_strategy(self, strategy: IStrategy):
|
2018-07-28 04:54:33 +00:00
|
|
|
"""
|
|
|
|
Load strategy into backtesting
|
|
|
|
"""
|
2020-10-18 15:16:57 +00:00
|
|
|
self.strategy: IStrategy = strategy
|
2021-05-03 06:47:58 +00:00
|
|
|
strategy.dp = self.dataprovider
|
2021-07-11 09:20:31 +00:00
|
|
|
# Attach Wallets to Strategy baseclass
|
2021-09-19 23:44:12 +00:00
|
|
|
strategy.wallets = self.wallets
|
2019-03-06 18:55:34 +00:00
|
|
|
# Set stoploss_on_exchange to false for backtesting,
|
|
|
|
# since a "perfect" stoploss-sell is assumed anyway
|
|
|
|
# And the regular "stoploss" function would not apply to that case
|
|
|
|
self.strategy.order_types['stoploss_on_exchange'] = False
|
2021-08-03 04:38:15 +00:00
|
|
|
|
|
|
|
def _load_protections(self, strategy: IStrategy):
|
2021-05-07 14:28:06 +00:00
|
|
|
if self.config.get('enable_protections', False):
|
|
|
|
conf = self.config
|
|
|
|
if hasattr(strategy, 'protections'):
|
|
|
|
conf = deepcopy(conf)
|
|
|
|
conf['protections'] = strategy.protections
|
2021-06-17 19:01:22 +00:00
|
|
|
self.protections = ProtectionManager(self.config, strategy.protections)
|
2018-07-28 04:54:33 +00:00
|
|
|
|
2020-03-15 14:04:48 +00:00
|
|
|
def load_bt_data(self) -> Tuple[Dict[str, DataFrame], TimeRange]:
|
2020-09-18 05:45:47 +00:00
|
|
|
"""
|
|
|
|
Loads backtest data and returns the data combined with the timerange
|
|
|
|
as tuple.
|
|
|
|
"""
|
2021-03-21 14:56:36 +00:00
|
|
|
self.progress.init_step(BacktestState.DATALOAD, 1)
|
2021-03-11 18:16:18 +00:00
|
|
|
|
2019-10-23 18:13:43 +00:00
|
|
|
data = history.load_data(
|
2019-12-23 18:32:31 +00:00
|
|
|
datadir=self.config['datadir'],
|
2020-04-25 13:37:13 +00:00
|
|
|
pairs=self.pairlists.whitelist,
|
2019-11-02 19:26:26 +00:00
|
|
|
timeframe=self.timeframe,
|
2021-07-13 17:36:15 +00:00
|
|
|
timerange=self.timerange,
|
2019-10-23 18:13:43 +00:00
|
|
|
startup_candles=self.required_startup,
|
|
|
|
fail_without_data=True,
|
2019-12-28 13:57:39 +00:00
|
|
|
data_format=self.config.get('dataformat_ohlcv', 'json'),
|
2021-12-27 18:46:05 +00:00
|
|
|
candle_type=self.config.get('candle_type_def', CandleType.SPOT)
|
2019-10-23 18:13:43 +00:00
|
|
|
)
|
|
|
|
|
2019-12-17 22:06:03 +00:00
|
|
|
min_date, max_date = history.get_timerange(data)
|
2019-10-23 18:13:43 +00:00
|
|
|
|
2020-06-09 06:07:34 +00:00
|
|
|
logger.info(f'Loading data from {min_date.strftime(DATETIME_PRINT_FORMAT)} '
|
|
|
|
f'up to {max_date.strftime(DATETIME_PRINT_FORMAT)} '
|
2021-05-06 18:49:48 +00:00
|
|
|
f'({(max_date - min_date).days} days).')
|
2020-06-09 06:07:34 +00:00
|
|
|
|
2019-10-23 18:13:43 +00:00
|
|
|
# Adjust startts forward if not enough data is available
|
2021-07-13 17:36:15 +00:00
|
|
|
self.timerange.adjust_start_if_necessary(timeframe_to_seconds(self.timeframe),
|
|
|
|
self.required_startup, min_date)
|
2019-10-23 18:13:43 +00:00
|
|
|
|
2021-03-21 14:56:36 +00:00
|
|
|
self.progress.set_new_value(1)
|
2021-07-13 17:36:15 +00:00
|
|
|
return data, self.timerange
|
2019-10-23 18:13:43 +00:00
|
|
|
|
2021-08-14 13:34:43 +00:00
|
|
|
def load_bt_data_detail(self) -> None:
|
|
|
|
"""
|
|
|
|
Loads backtest detail data (smaller timeframe) if necessary.
|
|
|
|
"""
|
|
|
|
if self.timeframe_detail:
|
|
|
|
self.detail_data = history.load_data(
|
|
|
|
datadir=self.config['datadir'],
|
|
|
|
pairs=self.pairlists.whitelist,
|
|
|
|
timeframe=self.timeframe_detail,
|
|
|
|
timerange=self.timerange,
|
|
|
|
startup_candles=0,
|
|
|
|
fail_without_data=True,
|
|
|
|
data_format=self.config.get('dataformat_ohlcv', 'json'),
|
2021-12-27 18:46:05 +00:00
|
|
|
candle_type=self.config.get('candle_type_def', CandleType.SPOT)
|
2021-08-14 13:34:43 +00:00
|
|
|
)
|
|
|
|
else:
|
|
|
|
self.detail_data = {}
|
2022-01-08 14:07:20 +00:00
|
|
|
if self.trading_mode == TradingMode.FUTURES:
|
|
|
|
# Load additional futures data.
|
2022-01-17 18:41:01 +00:00
|
|
|
funding_rates_dict = history.load_data(
|
2022-01-08 14:07:20 +00:00
|
|
|
datadir=self.config['datadir'],
|
|
|
|
pairs=self.pairlists.whitelist,
|
|
|
|
timeframe=self.exchange._ft_has['mark_ohlcv_timeframe'],
|
|
|
|
timerange=self.timerange,
|
|
|
|
startup_candles=0,
|
|
|
|
fail_without_data=True,
|
|
|
|
data_format=self.config.get('dataformat_ohlcv', 'json'),
|
|
|
|
candle_type=CandleType.FUNDING_RATE
|
|
|
|
)
|
|
|
|
|
|
|
|
# For simplicity, assign to CandleType.Mark (might contian index candles!)
|
2022-01-17 18:41:01 +00:00
|
|
|
mark_rates_dict = history.load_data(
|
2022-01-08 14:07:20 +00:00
|
|
|
datadir=self.config['datadir'],
|
|
|
|
pairs=self.pairlists.whitelist,
|
|
|
|
timeframe=self.exchange._ft_has['mark_ohlcv_timeframe'],
|
|
|
|
timerange=self.timerange,
|
|
|
|
startup_candles=0,
|
|
|
|
fail_without_data=True,
|
|
|
|
data_format=self.config.get('dataformat_ohlcv', 'json'),
|
|
|
|
candle_type=CandleType.from_string(self.exchange._ft_has["mark_ohlcv_price"])
|
|
|
|
)
|
2022-01-17 18:41:01 +00:00
|
|
|
# Combine data to avoid combining the data per trade.
|
|
|
|
for pair in self.pairlists.whitelist:
|
|
|
|
self.futures_data[pair] = funding_rates_dict[pair].merge(
|
|
|
|
mark_rates_dict[pair], on='date', how="inner", suffixes=["_fund", "_mark"])
|
2022-01-08 14:07:20 +00:00
|
|
|
|
|
|
|
else:
|
|
|
|
self.futures_data = {}
|
2019-10-23 18:13:43 +00:00
|
|
|
|
2020-11-27 16:38:15 +00:00
|
|
|
def prepare_backtest(self, enable_protections):
|
|
|
|
"""
|
|
|
|
Backtesting setup method - called once for every call to "backtest()".
|
|
|
|
"""
|
|
|
|
PairLocks.use_db = False
|
2021-01-14 05:53:40 +00:00
|
|
|
PairLocks.timeframe = self.config['timeframe']
|
2020-11-27 16:38:15 +00:00
|
|
|
Trade.use_db = False
|
2021-03-08 18:40:29 +00:00
|
|
|
PairLocks.reset_locks()
|
|
|
|
Trade.reset_trades()
|
2021-05-23 07:36:02 +00:00
|
|
|
self.rejected_trades = 0
|
2022-02-07 17:49:30 +00:00
|
|
|
self.timedout_entry_orders = 0
|
|
|
|
self.timedout_exit_orders = 0
|
2021-05-02 09:20:54 +00:00
|
|
|
self.dataprovider.clear_cache()
|
2021-09-26 13:07:48 +00:00
|
|
|
if enable_protections:
|
|
|
|
self._load_protections(self.strategy)
|
2020-11-27 16:38:15 +00:00
|
|
|
|
2021-07-06 04:28:47 +00:00
|
|
|
def check_abort(self):
|
|
|
|
"""
|
|
|
|
Check if abort was requested, raise DependencyException if that's the case
|
|
|
|
Only applies to Interactive backtest mode (webserver mode)
|
|
|
|
"""
|
|
|
|
if self.abort:
|
|
|
|
self.abort = False
|
|
|
|
raise DependencyException("Stop requested")
|
|
|
|
|
2020-10-18 15:16:57 +00:00
|
|
|
def _get_ohlcv_as_lists(self, processed: Dict[str, DataFrame]) -> Dict[str, Tuple]:
|
2019-03-23 14:00:07 +00:00
|
|
|
"""
|
2020-03-08 10:35:31 +00:00
|
|
|
Helper function to convert a processed dataframes into lists for performance reasons.
|
2019-03-23 14:00:07 +00:00
|
|
|
|
|
|
|
Used by backtest() - so keep this optimized for performance.
|
2021-12-29 10:09:01 +00:00
|
|
|
|
|
|
|
:param processed: a processed dictionary with format {pair, data}, which gets cleared to
|
|
|
|
optimize memory usage!
|
2019-03-23 14:00:07 +00:00
|
|
|
"""
|
2020-10-18 15:16:57 +00:00
|
|
|
# Every change to this headers list must evaluate further usages of the resulting tuple
|
|
|
|
# and eventually change the constants for indexes at the top
|
2021-08-23 19:15:56 +00:00
|
|
|
headers = ['date', 'open', 'high', 'low', 'close', 'enter_long', 'exit_long',
|
2021-11-06 14:24:52 +00:00
|
|
|
'enter_short', 'exit_short', 'enter_tag', 'exit_tag']
|
2020-03-08 10:35:31 +00:00
|
|
|
data: Dict = {}
|
2021-03-21 14:56:36 +00:00
|
|
|
self.progress.init_step(BacktestState.CONVERT, len(processed))
|
|
|
|
|
2020-03-08 10:35:31 +00:00
|
|
|
# Create dict with data
|
2021-12-29 10:09:01 +00:00
|
|
|
for pair in processed.keys():
|
|
|
|
pair_data = processed[pair]
|
2021-07-06 04:28:47 +00:00
|
|
|
self.check_abort()
|
2021-03-21 14:56:36 +00:00
|
|
|
self.progress.increment()
|
2021-08-24 04:28:16 +00:00
|
|
|
|
2021-05-20 04:49:25 +00:00
|
|
|
if not pair_data.empty:
|
2021-08-23 19:15:56 +00:00
|
|
|
# Cleanup from prior runs
|
2021-09-26 13:39:34 +00:00
|
|
|
pair_data.drop(headers[5:] + ['buy', 'sell'], axis=1, errors='ignore')
|
2019-03-23 14:00:07 +00:00
|
|
|
|
2021-09-22 18:42:31 +00:00
|
|
|
df_analyzed = self.strategy.advise_exit(
|
|
|
|
self.strategy.advise_entry(pair_data, {'pair': pair}),
|
2021-08-18 12:03:44 +00:00
|
|
|
{'pair': pair}
|
|
|
|
).copy()
|
2021-07-13 17:36:15 +00:00
|
|
|
# Trim startup period from analyzed dataframe
|
2022-01-07 10:07:49 +00:00
|
|
|
df_analyzed = processed[pair] = pair_data = trim_dataframe(
|
|
|
|
df_analyzed, self.timerange, startup_candles=self.required_startup)
|
2022-01-27 16:09:19 +00:00
|
|
|
# Update dataprovider cache
|
2022-02-11 16:02:04 +00:00
|
|
|
self.dataprovider._set_cached_df(
|
|
|
|
pair, self.timeframe, df_analyzed, self.config['candle_type_def'])
|
2022-01-27 16:09:19 +00:00
|
|
|
|
|
|
|
# Create a copy of the dataframe before shifting, that way the buy signal/tag
|
|
|
|
# remains on the correct candle for callbacks.
|
|
|
|
df_analyzed = df_analyzed.copy()
|
|
|
|
|
2020-03-08 10:35:31 +00:00
|
|
|
# To avoid using data from future, we use buy/sell signals shifted
|
|
|
|
# from the previous candle
|
2021-09-26 13:39:34 +00:00
|
|
|
for col in headers[5:]:
|
2022-01-16 13:46:43 +00:00
|
|
|
tag_col = col in ('enter_tag', 'exit_tag')
|
2021-09-26 13:39:34 +00:00
|
|
|
if col in df_analyzed.columns:
|
2022-01-16 13:46:43 +00:00
|
|
|
df_analyzed.loc[:, col] = df_analyzed.loc[:, col].replace(
|
|
|
|
[nan], [0 if not tag_col else None]).shift(1)
|
2021-09-26 13:39:34 +00:00
|
|
|
else:
|
2022-01-16 13:46:43 +00:00
|
|
|
df_analyzed.loc[:, col] = 0 if not tag_col else None
|
2019-03-23 14:00:07 +00:00
|
|
|
|
2021-08-10 05:09:38 +00:00
|
|
|
df_analyzed = df_analyzed.drop(df_analyzed.head(1).index)
|
|
|
|
|
2019-03-23 14:00:07 +00:00
|
|
|
# Convert from Pandas to list for performance reasons
|
|
|
|
# (Looping Pandas is slow.)
|
2021-07-31 08:00:24 +00:00
|
|
|
data[pair] = df_analyzed[headers].values.tolist()
|
2020-03-08 10:35:31 +00:00
|
|
|
return data
|
2019-03-23 14:00:07 +00:00
|
|
|
|
2021-02-20 19:22:00 +00:00
|
|
|
def _get_close_rate(self, sell_row: Tuple, trade: LocalTrade, sell: SellCheckTuple,
|
2020-02-02 04:00:40 +00:00
|
|
|
trade_dur: int) -> float:
|
2019-12-07 14:28:56 +00:00
|
|
|
"""
|
|
|
|
Get close rate for backtesting result
|
|
|
|
"""
|
2019-12-07 13:30:14 +00:00
|
|
|
# Special handling if high or low hit STOP_LOSS or ROI
|
|
|
|
if sell.sell_type in (SellType.STOP_LOSS, SellType.TRAILING_STOP_LOSS):
|
2021-05-15 06:38:51 +00:00
|
|
|
if trade.stop_loss > sell_row[HIGH_IDX]:
|
|
|
|
# our stoploss was already higher than candle high,
|
|
|
|
# possibly due to a cancelled trade exit.
|
|
|
|
# sell at open price.
|
|
|
|
return sell_row[OPEN_IDX]
|
|
|
|
|
2021-06-12 07:16:30 +00:00
|
|
|
# Special case: trailing triggers within same candle as trade opened. Assume most
|
|
|
|
# pessimistic price movement, which is moving just enough to arm stoploss and
|
|
|
|
# immediately going down to stop price.
|
2021-06-29 13:17:52 +00:00
|
|
|
if sell.sell_type == SellType.TRAILING_STOP_LOSS and trade_dur == 0:
|
2021-07-03 06:22:21 +00:00
|
|
|
if (
|
|
|
|
not self.strategy.use_custom_stoploss and self.strategy.trailing_stop
|
|
|
|
and self.strategy.trailing_only_offset_is_reached
|
|
|
|
and self.strategy.trailing_stop_positive_offset is not None
|
|
|
|
and self.strategy.trailing_stop_positive
|
|
|
|
):
|
2021-06-12 07:16:30 +00:00
|
|
|
# Worst case: price reaches stop_positive_offset and dives down.
|
2021-06-17 04:48:41 +00:00
|
|
|
stop_rate = (sell_row[OPEN_IDX] *
|
|
|
|
(1 + abs(self.strategy.trailing_stop_positive_offset) -
|
2021-07-21 13:05:35 +00:00
|
|
|
abs(self.strategy.trailing_stop_positive)))
|
2021-06-12 07:16:30 +00:00
|
|
|
else:
|
|
|
|
# Worst case: price ticks tiny bit above open and dives down.
|
2021-06-29 13:17:52 +00:00
|
|
|
stop_rate = sell_row[OPEN_IDX] * (1 - abs(trade.stop_loss_pct))
|
2021-06-12 07:16:30 +00:00
|
|
|
assert stop_rate < sell_row[HIGH_IDX]
|
2021-10-30 14:14:13 +00:00
|
|
|
# Limit lower-end to candle low to avoid sells below the low.
|
|
|
|
# This still remains "worst case" - but "worst realistic case".
|
|
|
|
return max(sell_row[LOW_IDX], stop_rate)
|
2021-06-12 07:16:30 +00:00
|
|
|
|
2019-12-07 13:30:14 +00:00
|
|
|
# Set close_rate to stoploss
|
2019-12-07 14:28:56 +00:00
|
|
|
return trade.stop_loss
|
2019-12-07 13:30:14 +00:00
|
|
|
elif sell.sell_type == (SellType.ROI):
|
2019-12-07 14:18:12 +00:00
|
|
|
roi_entry, roi = self.strategy.min_roi_reached_entry(trade_dur)
|
2020-10-18 15:16:57 +00:00
|
|
|
if roi is not None and roi_entry is not None:
|
2019-12-14 22:10:09 +00:00
|
|
|
if roi == -1 and roi_entry % self.timeframe_min == 0:
|
2019-12-09 15:52:12 +00:00
|
|
|
# When forceselling with ROI=-1, the roi time will always be equal to trade_dur.
|
|
|
|
# If that entry is a multiple of the timeframe (so on candle open)
|
2019-12-07 14:28:56 +00:00
|
|
|
# - we'll use open instead of close
|
2020-10-18 15:16:57 +00:00
|
|
|
return sell_row[OPEN_IDX]
|
2019-12-07 14:28:56 +00:00
|
|
|
|
2019-12-07 13:30:14 +00:00
|
|
|
# - (Expected abs profit + open_rate + open_fee) / (fee_close -1)
|
2019-12-09 15:52:12 +00:00
|
|
|
close_rate = - (trade.open_rate * roi + trade.open_rate *
|
|
|
|
(1 + trade.fee_open)) / (trade.fee_close - 1)
|
|
|
|
|
|
|
|
if (trade_dur > 0 and trade_dur == roi_entry
|
2019-12-14 22:10:09 +00:00
|
|
|
and roi_entry % self.timeframe_min == 0
|
2020-10-18 15:16:57 +00:00
|
|
|
and sell_row[OPEN_IDX] > close_rate):
|
2019-12-09 15:52:12 +00:00
|
|
|
# new ROI entry came into effect.
|
|
|
|
# use Open rate if open_rate > calculated sell rate
|
2020-10-18 15:16:57 +00:00
|
|
|
return sell_row[OPEN_IDX]
|
2019-12-07 13:30:14 +00:00
|
|
|
|
2022-02-14 19:02:38 +00:00
|
|
|
if (
|
|
|
|
trade_dur == 0
|
2022-02-15 18:25:32 +00:00
|
|
|
# Red candle (for longs), TODO: green candle (for shorts)
|
2022-02-14 19:02:38 +00:00
|
|
|
and sell_row[OPEN_IDX] > sell_row[CLOSE_IDX] # Red candle
|
2022-02-15 18:25:32 +00:00
|
|
|
and trade.open_rate < sell_row[OPEN_IDX] # trade-open below open_rate
|
|
|
|
and close_rate > sell_row[CLOSE_IDX]
|
2022-02-14 19:02:38 +00:00
|
|
|
):
|
|
|
|
# ROI on opening candles with custom pricing can only
|
|
|
|
# trigger if the entry was at Open or lower.
|
|
|
|
# details: https: // github.com/freqtrade/freqtrade/issues/6261
|
2022-02-15 18:25:32 +00:00
|
|
|
# If open_rate is < open, only allow sells below the close on red candles.
|
2022-02-14 19:02:38 +00:00
|
|
|
raise ValueError("Opening candle ROI on red candles.")
|
2022-01-30 14:27:18 +00:00
|
|
|
# Use the maximum between close_rate and low as we
|
|
|
|
# cannot sell outside of a candle.
|
|
|
|
# Applies when a new ROI setting comes in place and the whole candle is above that.
|
|
|
|
return min(max(close_rate, sell_row[LOW_IDX]), sell_row[HIGH_IDX])
|
2019-12-07 14:18:12 +00:00
|
|
|
|
2019-12-07 13:30:14 +00:00
|
|
|
else:
|
|
|
|
# This should not be reached...
|
2020-10-18 15:16:57 +00:00
|
|
|
return sell_row[OPEN_IDX]
|
2019-12-07 13:30:14 +00:00
|
|
|
else:
|
2020-10-18 15:16:57 +00:00
|
|
|
return sell_row[OPEN_IDX]
|
2019-12-07 13:30:14 +00:00
|
|
|
|
2021-12-18 09:00:25 +00:00
|
|
|
def _get_adjust_trade_entry_for_candle(self, trade: LocalTrade, row: Tuple
|
2021-12-18 09:15:59 +00:00
|
|
|
) -> LocalTrade:
|
2021-12-24 10:38:43 +00:00
|
|
|
current_profit = trade.calc_profit_ratio(row[OPEN_IDX])
|
2022-01-08 15:20:02 +00:00
|
|
|
min_stake = self.exchange.get_min_pair_stake_amount(trade.pair, row[OPEN_IDX], -0.1)
|
2022-02-04 20:26:15 +00:00
|
|
|
max_stake = self.exchange.get_max_pair_stake_amount(trade.pair, row[OPEN_IDX])
|
2022-02-02 02:39:22 +00:00
|
|
|
stake_available = self.wallets.get_available_stake_amount()
|
2021-12-18 09:00:25 +00:00
|
|
|
stake_amount = strategy_safe_wrapper(self.strategy.adjust_trade_position,
|
|
|
|
default_retval=None)(
|
2022-01-08 15:20:02 +00:00
|
|
|
trade=trade, current_time=row[DATE_IDX].to_pydatetime(), current_rate=row[OPEN_IDX],
|
2022-02-02 02:39:22 +00:00
|
|
|
current_profit=current_profit, min_stake=min_stake,
|
|
|
|
max_stake=min(max_stake, stake_available))
|
2021-12-09 21:21:35 +00:00
|
|
|
|
|
|
|
# Check if we should increase our position
|
2021-12-10 18:42:24 +00:00
|
|
|
if stake_amount is not None and stake_amount > 0.0:
|
2022-01-22 16:25:21 +00:00
|
|
|
|
|
|
|
pos_trade = self._enter_trade(
|
|
|
|
trade.pair, row, 'short' if trade.is_short else 'long', stake_amount, trade)
|
2021-12-24 10:38:43 +00:00
|
|
|
if pos_trade is not None:
|
2022-01-30 18:35:46 +00:00
|
|
|
self.wallets.update()
|
2021-12-24 10:38:43 +00:00
|
|
|
return pos_trade
|
2021-12-09 21:21:35 +00:00
|
|
|
|
|
|
|
return trade
|
|
|
|
|
2022-01-16 18:39:42 +00:00
|
|
|
def _get_order_filled(self, rate: float, row: Tuple) -> bool:
|
|
|
|
""" Rate is within candle, therefore filled"""
|
2022-01-30 14:27:18 +00:00
|
|
|
return row[LOW_IDX] <= rate <= row[HIGH_IDX]
|
2022-01-16 18:39:42 +00:00
|
|
|
|
2021-08-09 13:45:02 +00:00
|
|
|
def _get_sell_trade_entry_for_candle(self, trade: LocalTrade,
|
|
|
|
sell_row: Tuple) -> Optional[LocalTrade]:
|
2021-11-21 09:25:58 +00:00
|
|
|
|
2021-12-10 22:28:12 +00:00
|
|
|
# Check if we need to adjust our current positions
|
2021-12-24 10:38:43 +00:00
|
|
|
if self.strategy.position_adjustment_enable:
|
2022-02-13 14:10:09 +00:00
|
|
|
check_adjust_entry = True
|
2022-01-27 15:57:50 +00:00
|
|
|
if self.strategy.max_entry_position_adjustment > -1:
|
2022-02-13 14:10:09 +00:00
|
|
|
entry_count = trade.nr_of_successful_entries
|
|
|
|
check_adjust_entry = (entry_count <= self.strategy.max_entry_position_adjustment)
|
|
|
|
if check_adjust_entry:
|
2022-01-20 01:03:26 +00:00
|
|
|
trade = self._get_adjust_trade_entry_for_candle(trade, sell_row)
|
2021-12-09 21:21:35 +00:00
|
|
|
|
2022-01-08 14:07:20 +00:00
|
|
|
sell_candle_time: datetime = sell_row[DATE_IDX].to_pydatetime()
|
2021-09-05 06:59:18 +00:00
|
|
|
enter = sell_row[SHORT_IDX] if trade.is_short else sell_row[LONG_IDX]
|
|
|
|
exit_ = sell_row[ESHORT_IDX] if trade.is_short else sell_row[ELONG_IDX]
|
2021-08-24 17:55:00 +00:00
|
|
|
sell = self.strategy.should_exit(
|
|
|
|
trade, sell_row[OPEN_IDX], sell_candle_time, # type: ignore
|
2021-08-24 18:47:54 +00:00
|
|
|
enter=enter, exit_=exit_,
|
2021-08-24 17:55:00 +00:00
|
|
|
low=sell_row[LOW_IDX], high=sell_row[HIGH_IDX]
|
2021-10-02 09:15:12 +00:00
|
|
|
)
|
2020-10-07 18:59:05 +00:00
|
|
|
|
2021-03-23 08:09:41 +00:00
|
|
|
if sell.sell_flag:
|
2021-08-09 13:42:17 +00:00
|
|
|
trade.close_date = sell_candle_time
|
2021-10-21 14:25:38 +00:00
|
|
|
|
2021-02-06 09:30:50 +00:00
|
|
|
trade_dur = int((trade.close_date_utc - trade.open_date_utc).total_seconds() // 60)
|
2022-02-14 19:02:38 +00:00
|
|
|
try:
|
|
|
|
closerate = self._get_close_rate(sell_row, trade, sell, trade_dur)
|
|
|
|
except ValueError:
|
|
|
|
return None
|
2021-10-19 11:45:45 +00:00
|
|
|
# call the custom exit price,with default value as previous closerate
|
|
|
|
current_profit = trade.calc_profit_ratio(closerate)
|
2022-03-07 19:32:16 +00:00
|
|
|
order_type = self.strategy.order_types['exit']
|
2021-12-04 13:14:22 +00:00
|
|
|
if sell.sell_type in (SellType.SELL_SIGNAL, SellType.CUSTOM_SELL):
|
|
|
|
# Custom exit pricing only for sell-signals
|
2022-02-08 06:10:54 +00:00
|
|
|
if order_type == 'limit':
|
|
|
|
closerate = strategy_safe_wrapper(self.strategy.custom_exit_price,
|
|
|
|
default_retval=closerate)(
|
|
|
|
pair=trade.pair, trade=trade,
|
|
|
|
current_time=sell_candle_time,
|
|
|
|
proposed_rate=closerate, current_profit=current_profit)
|
2022-02-08 18:10:29 +00:00
|
|
|
# We can't place orders lower than current low.
|
|
|
|
# freqtrade does not support this in live, and the order would fill immediately
|
|
|
|
closerate = max(closerate, sell_row[LOW_IDX])
|
2021-03-25 08:25:25 +00:00
|
|
|
# Confirm trade exit:
|
2022-03-07 06:09:01 +00:00
|
|
|
time_in_force = self.strategy.order_time_in_force['exit']
|
2022-02-08 06:10:54 +00:00
|
|
|
|
2021-03-25 08:25:25 +00:00
|
|
|
if not strategy_safe_wrapper(self.strategy.confirm_trade_exit, default_retval=True)(
|
|
|
|
pair=trade.pair, trade=trade, order_type='limit', amount=trade.amount,
|
|
|
|
rate=closerate,
|
|
|
|
time_in_force=time_in_force,
|
2021-05-02 09:20:54 +00:00
|
|
|
sell_reason=sell.sell_reason,
|
2021-08-09 13:42:17 +00:00
|
|
|
current_time=sell_candle_time):
|
2021-03-25 08:25:25 +00:00
|
|
|
return None
|
|
|
|
|
2021-11-08 05:44:55 +00:00
|
|
|
trade.sell_reason = sell.sell_reason
|
|
|
|
|
|
|
|
# Checks and adds an exit tag, after checking that the length of the
|
|
|
|
# sell_row has the length for an exit tag column
|
|
|
|
if(
|
|
|
|
len(sell_row) > EXIT_TAG_IDX
|
|
|
|
and sell_row[EXIT_TAG_IDX] is not None
|
|
|
|
and len(sell_row[EXIT_TAG_IDX]) > 0
|
|
|
|
):
|
|
|
|
trade.sell_reason = sell_row[EXIT_TAG_IDX]
|
|
|
|
|
2022-01-22 13:11:33 +00:00
|
|
|
self.order_id_counter += 1
|
2022-01-16 18:39:42 +00:00
|
|
|
order = Order(
|
2022-01-22 13:11:33 +00:00
|
|
|
id=self.order_id_counter,
|
|
|
|
ft_trade_id=trade.id,
|
2022-01-22 14:08:54 +00:00
|
|
|
order_date=sell_candle_time,
|
|
|
|
order_update_date=sell_candle_time,
|
2022-01-22 13:11:33 +00:00
|
|
|
ft_is_open=True,
|
2022-01-16 18:39:42 +00:00
|
|
|
ft_pair=trade.pair,
|
2022-01-22 13:11:33 +00:00
|
|
|
order_id=str(self.order_id_counter),
|
2022-01-16 18:39:42 +00:00
|
|
|
symbol=trade.pair,
|
2022-01-22 13:11:33 +00:00
|
|
|
ft_order_side="sell",
|
|
|
|
side="sell",
|
2022-02-08 06:10:54 +00:00
|
|
|
order_type=order_type,
|
2022-01-22 13:11:33 +00:00
|
|
|
status="open",
|
2022-01-16 18:39:42 +00:00
|
|
|
price=closerate,
|
|
|
|
average=closerate,
|
|
|
|
amount=trade.amount,
|
2022-01-22 13:11:33 +00:00
|
|
|
filled=0,
|
|
|
|
remaining=trade.amount,
|
|
|
|
cost=trade.amount * closerate,
|
2022-01-16 18:39:42 +00:00
|
|
|
)
|
|
|
|
trade.orders.append(order)
|
2021-01-23 11:50:20 +00:00
|
|
|
return trade
|
2020-11-16 19:17:47 +00:00
|
|
|
|
2020-10-08 18:10:00 +00:00
|
|
|
return None
|
|
|
|
|
2021-08-09 13:45:02 +00:00
|
|
|
def _get_sell_trade_entry(self, trade: LocalTrade, sell_row: Tuple) -> Optional[LocalTrade]:
|
2022-01-08 14:07:20 +00:00
|
|
|
sell_candle_time: datetime = sell_row[DATE_IDX].to_pydatetime()
|
|
|
|
|
|
|
|
if self.trading_mode == TradingMode.FUTURES:
|
2022-01-17 18:26:03 +00:00
|
|
|
trade.funding_fees = self.exchange.calculate_funding_fees(
|
2022-01-17 18:41:01 +00:00
|
|
|
self.futures_data[trade.pair],
|
2022-01-08 14:07:20 +00:00
|
|
|
amount=trade.amount,
|
2022-01-17 18:59:33 +00:00
|
|
|
is_short=trade.is_short,
|
2022-01-08 14:07:20 +00:00
|
|
|
open_date=trade.open_date_utc,
|
|
|
|
close_date=sell_candle_time,
|
|
|
|
)
|
|
|
|
|
2021-08-14 15:36:02 +00:00
|
|
|
if self.timeframe_detail and trade.pair in self.detail_data:
|
2021-08-09 13:45:02 +00:00
|
|
|
sell_candle_end = sell_candle_time + timedelta(minutes=self.timeframe_min)
|
|
|
|
|
|
|
|
detail_data = self.detail_data[trade.pair]
|
|
|
|
detail_data = detail_data.loc[
|
|
|
|
(detail_data['date'] >= sell_candle_time) &
|
|
|
|
(detail_data['date'] < sell_candle_end)
|
2021-10-02 09:15:12 +00:00
|
|
|
].copy()
|
2021-08-14 15:36:02 +00:00
|
|
|
if len(detail_data) == 0:
|
|
|
|
# Fall back to "regular" data if no detail data was found for this candle
|
|
|
|
return self._get_sell_trade_entry_for_candle(trade, sell_row)
|
2021-10-02 09:15:12 +00:00
|
|
|
detail_data.loc[:, 'enter_long'] = sell_row[LONG_IDX]
|
|
|
|
detail_data.loc[:, 'exit_long'] = sell_row[ELONG_IDX]
|
|
|
|
detail_data.loc[:, 'enter_long'] = sell_row[LONG_IDX]
|
|
|
|
detail_data.loc[:, 'exit_long'] = sell_row[ELONG_IDX]
|
2022-01-07 09:09:17 +00:00
|
|
|
detail_data.loc[:, 'enter_tag'] = sell_row[ENTER_TAG_IDX]
|
2022-01-06 07:22:15 +00:00
|
|
|
detail_data.loc[:, 'exit_tag'] = sell_row[EXIT_TAG_IDX]
|
2021-09-04 17:54:34 +00:00
|
|
|
headers = ['date', 'open', 'high', 'low', 'close', 'enter_long', 'exit_long',
|
2022-01-07 09:09:17 +00:00
|
|
|
'enter_short', 'exit_short', 'enter_tag', 'exit_tag']
|
2021-08-09 13:45:02 +00:00
|
|
|
for det_row in detail_data[headers].values.tolist():
|
|
|
|
res = self._get_sell_trade_entry_for_candle(trade, det_row)
|
|
|
|
if res:
|
|
|
|
return res
|
|
|
|
|
|
|
|
return None
|
|
|
|
|
|
|
|
else:
|
|
|
|
return self._get_sell_trade_entry_for_candle(trade, sell_row)
|
|
|
|
|
2022-01-22 16:25:21 +00:00
|
|
|
def _enter_trade(self, pair: str, row: Tuple, direction: str,
|
|
|
|
stake_amount: Optional[float] = None,
|
2021-12-24 10:38:43 +00:00
|
|
|
trade: Optional[LocalTrade] = None) -> Optional[LocalTrade]:
|
|
|
|
|
2021-11-18 19:55:45 +00:00
|
|
|
current_time = row[DATE_IDX].to_pydatetime()
|
2022-01-29 13:19:30 +00:00
|
|
|
entry_tag = row[ENTER_TAG_IDX] if len(row) >= ENTER_TAG_IDX + 1 else None
|
2021-10-19 11:45:45 +00:00
|
|
|
# let's call the custom entry price, using the open price as default price
|
2022-03-07 19:32:16 +00:00
|
|
|
order_type = self.strategy.order_types['entry']
|
2022-01-22 13:11:33 +00:00
|
|
|
propose_rate = row[OPEN_IDX]
|
|
|
|
if order_type == 'limit':
|
|
|
|
propose_rate = strategy_safe_wrapper(self.strategy.custom_entry_price,
|
|
|
|
default_retval=row[OPEN_IDX])(
|
|
|
|
pair=pair, current_time=current_time,
|
2022-02-08 18:10:29 +00:00
|
|
|
proposed_rate=propose_rate, entry_tag=entry_tag) # default value is the open rate
|
|
|
|
# We can't place orders higher than current high (otherwise it'd be a stop limit buy)
|
|
|
|
# which freqtrade does not support in live.
|
|
|
|
propose_rate = min(propose_rate, row[HIGH_IDX])
|
2021-12-03 16:44:53 +00:00
|
|
|
|
2021-10-19 11:45:45 +00:00
|
|
|
min_stake_amount = self.exchange.get_min_pair_stake_amount(pair, propose_rate, -0.05) or 0
|
2022-02-04 20:26:15 +00:00
|
|
|
max_stake_amount = self.exchange.get_max_pair_stake_amount(pair, propose_rate)
|
2022-02-02 02:39:22 +00:00
|
|
|
stake_available = self.wallets.get_available_stake_amount()
|
2021-07-11 09:20:31 +00:00
|
|
|
|
2022-01-13 18:16:45 +00:00
|
|
|
pos_adjust = trade is not None
|
2022-01-13 18:24:21 +00:00
|
|
|
if not pos_adjust:
|
2022-01-13 18:16:45 +00:00
|
|
|
try:
|
2022-01-30 18:35:46 +00:00
|
|
|
stake_amount = self.wallets.get_trade_stake_amount(pair, None, update=False)
|
2022-01-13 18:16:45 +00:00
|
|
|
except DependencyException:
|
2022-01-22 13:11:33 +00:00
|
|
|
return None
|
2022-01-13 18:16:45 +00:00
|
|
|
|
2021-12-24 10:38:43 +00:00
|
|
|
stake_amount = strategy_safe_wrapper(self.strategy.custom_stake_amount,
|
|
|
|
default_retval=stake_amount)(
|
2022-01-22 16:25:21 +00:00
|
|
|
pair=pair, current_time=current_time, current_rate=propose_rate,
|
2022-02-02 02:39:22 +00:00
|
|
|
proposed_stake=stake_amount, min_stake=min_stake_amount,
|
|
|
|
max_stake=min(stake_available, max_stake_amount),
|
2022-01-29 13:19:30 +00:00
|
|
|
entry_tag=entry_tag, side=direction)
|
2021-12-24 10:38:43 +00:00
|
|
|
|
2022-02-04 01:48:54 +00:00
|
|
|
stake_amount = self.wallets.validate_stake_amount(
|
|
|
|
pair=pair,
|
|
|
|
stake_amount=stake_amount,
|
|
|
|
min_stake_amount=min_stake_amount,
|
|
|
|
max_stake_amount=max_stake_amount,
|
|
|
|
)
|
2021-07-11 09:20:31 +00:00
|
|
|
|
|
|
|
if not stake_amount:
|
2021-12-24 10:38:43 +00:00
|
|
|
# In case of pos adjust, still return the original trade
|
|
|
|
# If not pos adjust, trade is None
|
|
|
|
return trade
|
2022-03-07 19:32:16 +00:00
|
|
|
order_type = self.strategy.order_types['entry']
|
2022-03-07 06:09:01 +00:00
|
|
|
time_in_force = self.strategy.order_time_in_force['entry']
|
2021-03-23 08:09:41 +00:00
|
|
|
|
2022-02-21 18:27:38 +00:00
|
|
|
if not pos_adjust:
|
|
|
|
max_leverage = self.exchange.get_max_leverage(pair, stake_amount)
|
|
|
|
leverage = strategy_safe_wrapper(self.strategy.leverage, default_retval=1.0)(
|
|
|
|
pair=pair,
|
|
|
|
current_time=current_time,
|
|
|
|
current_rate=row[OPEN_IDX],
|
|
|
|
proposed_leverage=1.0,
|
|
|
|
max_leverage=max_leverage,
|
|
|
|
side=direction,
|
|
|
|
) if self._can_short else 1.0
|
|
|
|
# Cap leverage between 1.0 and max_leverage.
|
|
|
|
leverage = min(max(leverage, 1.0), max_leverage)
|
2021-11-18 19:55:45 +00:00
|
|
|
|
2022-02-28 19:10:23 +00:00
|
|
|
# Confirm trade entry:
|
2021-12-24 10:38:43 +00:00
|
|
|
if not strategy_safe_wrapper(self.strategy.confirm_trade_entry, default_retval=True)(
|
|
|
|
pair=pair, order_type=order_type, amount=stake_amount, rate=propose_rate,
|
2022-01-22 16:25:21 +00:00
|
|
|
time_in_force=time_in_force, current_time=current_time,
|
2022-01-29 13:19:30 +00:00
|
|
|
entry_tag=entry_tag, side=direction):
|
2022-02-28 19:10:23 +00:00
|
|
|
return trade
|
|
|
|
else:
|
|
|
|
leverage = trade.leverage if trade else 1.0
|
2021-03-23 08:09:41 +00:00
|
|
|
|
2021-02-20 19:21:30 +00:00
|
|
|
if stake_amount and (not min_stake_amount or stake_amount > min_stake_amount):
|
2022-01-22 13:11:33 +00:00
|
|
|
self.order_id_counter += 1
|
2022-01-08 14:07:20 +00:00
|
|
|
amount = round((stake_amount / propose_rate) * leverage, 8)
|
2022-02-27 18:08:39 +00:00
|
|
|
is_short = (direction == 'short')
|
2022-02-28 18:45:15 +00:00
|
|
|
# Necessary for Margin trading. Disabled until support is enabled.
|
|
|
|
# interest_rate = self.exchange.get_interest_rate()
|
|
|
|
|
2021-12-24 10:38:43 +00:00
|
|
|
if trade is None:
|
|
|
|
# Enter trade
|
2022-01-22 13:11:33 +00:00
|
|
|
self.trade_id_counter += 1
|
2021-12-24 10:38:43 +00:00
|
|
|
trade = LocalTrade(
|
2022-01-22 13:11:33 +00:00
|
|
|
id=self.trade_id_counter,
|
|
|
|
open_order_id=self.order_id_counter,
|
2021-12-24 10:38:43 +00:00
|
|
|
pair=pair,
|
|
|
|
open_rate=propose_rate,
|
2022-01-19 09:42:24 +00:00
|
|
|
open_rate_requested=propose_rate,
|
2022-01-22 16:25:21 +00:00
|
|
|
open_date=current_time,
|
2021-12-24 10:38:43 +00:00
|
|
|
stake_amount=stake_amount,
|
2022-01-08 14:07:20 +00:00
|
|
|
amount=amount,
|
2022-01-22 13:11:33 +00:00
|
|
|
amount_requested=amount,
|
2021-12-24 10:38:43 +00:00
|
|
|
fee_open=self.fee,
|
|
|
|
fee_close=self.fee,
|
|
|
|
is_open=True,
|
2022-01-29 13:19:30 +00:00
|
|
|
enter_tag=entry_tag,
|
2022-01-22 16:25:21 +00:00
|
|
|
exchange=self._exchange_name,
|
2022-02-26 16:07:00 +00:00
|
|
|
is_short=is_short,
|
2022-01-08 14:07:20 +00:00
|
|
|
trading_mode=self.trading_mode,
|
2022-01-22 16:25:21 +00:00
|
|
|
leverage=leverage,
|
2022-02-28 18:45:15 +00:00
|
|
|
# interest_rate=interest_rate,
|
2022-02-26 16:07:00 +00:00
|
|
|
orders=[],
|
2021-12-24 10:38:43 +00:00
|
|
|
)
|
2022-01-30 14:27:18 +00:00
|
|
|
|
2022-01-22 14:03:12 +00:00
|
|
|
trade.adjust_stop_loss(trade.open_rate, self.strategy.stoploss, initial=True)
|
2021-12-24 10:38:43 +00:00
|
|
|
|
2022-02-28 19:10:23 +00:00
|
|
|
trade.set_isolated_liq(self.exchange.get_liquidation_price(
|
|
|
|
pair=pair,
|
|
|
|
open_rate=propose_rate,
|
|
|
|
amount=amount,
|
|
|
|
leverage=leverage,
|
|
|
|
is_short=is_short,
|
|
|
|
))
|
2022-02-27 18:08:39 +00:00
|
|
|
|
2021-12-09 21:21:35 +00:00
|
|
|
order = Order(
|
2022-01-22 13:11:33 +00:00
|
|
|
id=self.order_id_counter,
|
|
|
|
ft_trade_id=trade.id,
|
2022-01-22 14:44:33 +00:00
|
|
|
ft_is_open=True,
|
2021-12-09 21:21:35 +00:00
|
|
|
ft_pair=trade.pair,
|
2022-01-22 13:11:33 +00:00
|
|
|
order_id=str(self.order_id_counter),
|
2021-12-09 21:21:35 +00:00
|
|
|
symbol=trade.pair,
|
|
|
|
ft_order_side="buy",
|
|
|
|
side="buy",
|
2022-01-22 13:11:33 +00:00
|
|
|
order_type=order_type,
|
|
|
|
status="open",
|
2022-01-23 18:58:25 +00:00
|
|
|
order_date=current_time,
|
|
|
|
order_filled_date=current_time,
|
|
|
|
order_update_date=current_time,
|
2021-12-24 10:38:43 +00:00
|
|
|
price=propose_rate,
|
|
|
|
average=propose_rate,
|
|
|
|
amount=amount,
|
2022-01-22 13:11:33 +00:00
|
|
|
filled=0,
|
|
|
|
remaining=amount,
|
|
|
|
cost=stake_amount + trade.fee_open,
|
2021-02-10 19:37:55 +00:00
|
|
|
)
|
2022-01-30 14:41:05 +00:00
|
|
|
if pos_adjust and self._get_order_filled(order.price, row):
|
2022-01-30 14:44:13 +00:00
|
|
|
order.close_bt_order(current_time)
|
2022-01-30 14:41:05 +00:00
|
|
|
else:
|
2022-01-30 16:47:37 +00:00
|
|
|
trade.open_order_id = str(self.order_id_counter)
|
2021-12-09 21:21:35 +00:00
|
|
|
trade.orders.append(order)
|
2022-01-22 13:11:33 +00:00
|
|
|
trade.recalc_trade_from_orders()
|
2021-12-24 10:38:43 +00:00
|
|
|
|
|
|
|
return trade
|
2021-02-10 19:37:55 +00:00
|
|
|
|
2021-02-20 18:29:04 +00:00
|
|
|
def handle_left_open(self, open_trades: Dict[str, List[LocalTrade]],
|
|
|
|
data: Dict[str, List[Tuple]]) -> List[LocalTrade]:
|
2020-10-08 18:10:00 +00:00
|
|
|
"""
|
|
|
|
Handling of left open trades at the end of backtesting
|
|
|
|
"""
|
|
|
|
trades = []
|
|
|
|
for pair in open_trades.keys():
|
|
|
|
if len(open_trades[pair]) > 0:
|
|
|
|
for trade in open_trades[pair]:
|
2022-02-13 14:10:09 +00:00
|
|
|
if trade.open_order_id and trade.nr_of_successful_entries == 0:
|
2022-02-06 12:19:00 +00:00
|
|
|
# Ignore trade if buy-order did not fill yet
|
2022-01-22 13:11:33 +00:00
|
|
|
continue
|
2020-10-08 18:10:00 +00:00
|
|
|
sell_row = data[pair][-1]
|
2020-11-16 19:17:47 +00:00
|
|
|
|
2021-04-26 17:54:47 +00:00
|
|
|
trade.close_date = sell_row[DATE_IDX].to_pydatetime()
|
2021-02-06 09:30:50 +00:00
|
|
|
trade.sell_reason = SellType.FORCE_SELL.value
|
2021-01-23 11:50:20 +00:00
|
|
|
trade.close(sell_row[OPEN_IDX], show_msg=False)
|
2021-03-14 08:48:40 +00:00
|
|
|
LocalTrade.close_bt_trade(trade)
|
2021-01-28 06:06:58 +00:00
|
|
|
# Deepcopy object to have wallets update correctly
|
|
|
|
trade1 = deepcopy(trade)
|
|
|
|
trade1.is_open = True
|
|
|
|
trades.append(trade1)
|
2020-10-08 18:10:00 +00:00
|
|
|
return trades
|
2018-02-09 07:35:38 +00:00
|
|
|
|
2021-05-23 07:36:02 +00:00
|
|
|
def trade_slot_available(self, max_open_trades: int, open_trade_count: int) -> bool:
|
2021-05-23 07:46:51 +00:00
|
|
|
# Always allow trades when max_open_trades is enabled.
|
|
|
|
if max_open_trades <= 0 or open_trade_count < max_open_trades:
|
2021-05-23 07:36:02 +00:00
|
|
|
return True
|
|
|
|
# Rejected trade
|
|
|
|
self.rejected_trades += 1
|
|
|
|
return False
|
|
|
|
|
2021-08-23 19:15:56 +00:00
|
|
|
def check_for_trade_entry(self, row) -> Optional[str]:
|
2021-08-24 04:54:55 +00:00
|
|
|
enter_long = row[LONG_IDX] == 1
|
|
|
|
exit_long = row[ELONG_IDX] == 1
|
2021-09-22 18:36:03 +00:00
|
|
|
enter_short = self._can_short and row[SHORT_IDX] == 1
|
|
|
|
exit_short = self._can_short and row[ESHORT_IDX] == 1
|
2021-08-23 19:15:56 +00:00
|
|
|
|
|
|
|
if enter_long == 1 and not any([exit_long, enter_short]):
|
|
|
|
# Long
|
|
|
|
return 'long'
|
|
|
|
if enter_short == 1 and not any([exit_short, enter_long]):
|
|
|
|
# Short
|
|
|
|
return 'short'
|
|
|
|
return None
|
|
|
|
|
2022-01-30 16:17:03 +00:00
|
|
|
def run_protections(self, enable_protections, pair: str, current_time: datetime):
|
|
|
|
if enable_protections:
|
|
|
|
self.protections.stop_per_pair(pair, current_time)
|
|
|
|
self.protections.global_stop(current_time)
|
|
|
|
|
2022-01-30 16:39:23 +00:00
|
|
|
def check_order_cancel(self, trade: LocalTrade, current_time) -> bool:
|
|
|
|
"""
|
|
|
|
Check if an order has been canceled.
|
|
|
|
Returns True if the trade should be Deleted (initial order was canceled).
|
|
|
|
"""
|
|
|
|
for order in [o for o in trade.orders if o.ft_is_open]:
|
|
|
|
|
2022-01-30 16:47:37 +00:00
|
|
|
timedout = self.strategy.ft_check_timed_out(order.side, trade, order, current_time)
|
2022-01-30 16:39:23 +00:00
|
|
|
if timedout:
|
|
|
|
if order.side == 'buy':
|
2022-02-07 17:49:30 +00:00
|
|
|
self.timedout_entry_orders += 1
|
2022-02-13 14:10:09 +00:00
|
|
|
if trade.nr_of_successful_entries == 0:
|
2022-01-30 16:39:23 +00:00
|
|
|
# Remove trade due to buy timeout expiration.
|
|
|
|
return True
|
|
|
|
else:
|
|
|
|
# Close additional buy order
|
|
|
|
del trade.orders[trade.orders.index(order)]
|
|
|
|
if order.side == 'sell':
|
2022-02-07 17:49:30 +00:00
|
|
|
self.timedout_exit_orders += 1
|
2022-01-30 16:39:23 +00:00
|
|
|
# Close sell order and retry selling on next signal.
|
|
|
|
del trade.orders[trade.orders.index(order)]
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
2022-01-30 19:00:11 +00:00
|
|
|
def validate_row(
|
|
|
|
self, data: Dict, pair: str, row_index: int, current_time: datetime) -> Optional[Tuple]:
|
|
|
|
try:
|
|
|
|
# Row is treated as "current incomplete candle".
|
|
|
|
# Buy / sell signals are shifted by 1 to compensate for this.
|
|
|
|
row = data[pair][row_index]
|
|
|
|
except IndexError:
|
|
|
|
# missing Data for one pair at the end.
|
|
|
|
# Warnings for this are shown during data loading
|
|
|
|
return None
|
|
|
|
|
|
|
|
# Waits until the time-counter reaches the start of the data for this pair.
|
|
|
|
if row[DATE_IDX] > current_time:
|
|
|
|
return None
|
|
|
|
return row
|
|
|
|
|
2021-02-10 19:37:55 +00:00
|
|
|
def backtest(self, processed: Dict,
|
2020-10-18 14:18:52 +00:00
|
|
|
start_date: datetime, end_date: datetime,
|
2020-11-23 19:29:29 +00:00
|
|
|
max_open_trades: int = 0, position_stacking: bool = False,
|
2021-04-30 05:31:57 +00:00
|
|
|
enable_protections: bool = False) -> Dict[str, Any]:
|
2018-02-09 07:35:38 +00:00
|
|
|
"""
|
2019-12-13 23:12:16 +00:00
|
|
|
Implement backtesting functionality
|
2018-02-09 07:35:38 +00:00
|
|
|
|
|
|
|
NOTE: This method is used by Hyperopt at each iteration. Please keep it optimized.
|
|
|
|
Of course try to not have ugly code. By some accessor are sometime slower than functions.
|
2019-12-13 23:12:16 +00:00
|
|
|
Avoid extensive logging in this method and functions it calls.
|
|
|
|
|
2021-12-29 10:09:01 +00:00
|
|
|
:param processed: a processed dictionary with format {pair, data}, which gets cleared to
|
|
|
|
optimize memory usage!
|
2019-12-13 23:12:16 +00:00
|
|
|
:param start_date: backtesting timerange start datetime
|
|
|
|
:param end_date: backtesting timerange end datetime
|
|
|
|
:param max_open_trades: maximum number of concurrent trades, <= 0 means unlimited
|
|
|
|
:param position_stacking: do we allow position stacking?
|
2020-11-23 19:29:29 +00:00
|
|
|
:param enable_protections: Should protections be enabled?
|
2019-12-13 23:12:16 +00:00
|
|
|
:return: DataFrame with trades (results of backtesting)
|
2018-02-09 07:35:38 +00:00
|
|
|
"""
|
2021-02-20 19:22:00 +00:00
|
|
|
trades: List[LocalTrade] = []
|
2020-11-27 16:38:15 +00:00
|
|
|
self.prepare_backtest(enable_protections)
|
2022-02-10 18:40:36 +00:00
|
|
|
# Ensure wallets are uptodate (important for --strategy-list)
|
|
|
|
self.wallets.update()
|
2020-03-08 10:35:31 +00:00
|
|
|
# Use dict of lists with data for performance
|
|
|
|
# (looping lists is a lot faster than pandas DataFrames)
|
|
|
|
data: Dict = self._get_ohlcv_as_lists(processed)
|
2018-10-15 20:02:23 +00:00
|
|
|
|
2019-04-04 18:23:10 +00:00
|
|
|
# Indexes per pair, so some pairs are allowed to have a missing start.
|
2021-04-24 17:15:09 +00:00
|
|
|
indexes: Dict = defaultdict(int)
|
2022-01-22 13:11:33 +00:00
|
|
|
current_time = start_date + timedelta(minutes=self.timeframe_min)
|
2019-03-20 17:38:10 +00:00
|
|
|
|
2021-02-20 19:22:00 +00:00
|
|
|
open_trades: Dict[str, List[LocalTrade]] = defaultdict(list)
|
2020-10-07 18:59:05 +00:00
|
|
|
open_trade_count = 0
|
|
|
|
|
2021-03-21 14:56:36 +00:00
|
|
|
self.progress.init_step(BacktestState.BACKTEST, int(
|
|
|
|
(end_date - start_date) / timedelta(minutes=self.timeframe_min)))
|
2021-03-11 18:16:18 +00:00
|
|
|
|
2019-04-04 18:23:10 +00:00
|
|
|
# Loop timerange and get candle for each pair at that point in time
|
2022-01-22 13:11:33 +00:00
|
|
|
while current_time <= end_date:
|
2020-10-07 18:59:05 +00:00
|
|
|
open_trade_count_start = open_trade_count
|
2021-07-06 04:28:47 +00:00
|
|
|
self.check_abort()
|
2020-03-08 10:35:31 +00:00
|
|
|
for i, pair in enumerate(data):
|
2021-05-08 13:06:19 +00:00
|
|
|
row_index = indexes[pair]
|
2022-01-30 19:00:11 +00:00
|
|
|
row = self.validate_row(data, pair, row_index, current_time)
|
|
|
|
if not row:
|
2019-03-20 17:38:10 +00:00
|
|
|
continue
|
2021-05-08 13:06:19 +00:00
|
|
|
|
|
|
|
row_index += 1
|
|
|
|
indexes[pair] = row_index
|
2021-08-10 05:09:38 +00:00
|
|
|
self.dataprovider._set_dataframe_max_index(row_index)
|
2019-03-20 17:38:10 +00:00
|
|
|
|
2022-01-22 13:11:33 +00:00
|
|
|
# 1. Process buys.
|
2020-10-07 18:59:05 +00:00
|
|
|
# without positionstacking, we can only have one open trade per pair.
|
|
|
|
# max_open_trades must be respected
|
|
|
|
# don't open on the last row
|
2021-08-23 19:15:56 +00:00
|
|
|
trade_dir = self.check_for_trade_entry(row)
|
2021-05-23 07:36:02 +00:00
|
|
|
if (
|
|
|
|
(position_stacking or len(open_trades[pair]) == 0)
|
|
|
|
and self.trade_slot_available(max_open_trades, open_trade_count_start)
|
2022-01-22 13:11:33 +00:00
|
|
|
and current_time != end_date
|
2021-08-23 19:15:56 +00:00
|
|
|
and trade_dir is not None
|
2021-05-23 07:36:02 +00:00
|
|
|
and not PairLocks.is_pair_locked(pair, row[DATE_IDX])
|
|
|
|
):
|
2021-08-23 19:15:56 +00:00
|
|
|
trade = self._enter_trade(pair, row, trade_dir)
|
2021-02-10 19:37:55 +00:00
|
|
|
if trade:
|
|
|
|
# TODO: hacky workaround to avoid opening > max_open_trades
|
2022-01-30 14:27:18 +00:00
|
|
|
# This emulates previous behavior - not sure if this is correct
|
2021-02-10 19:37:55 +00:00
|
|
|
# Prevents buying if the trade-slot was freed in this candle
|
|
|
|
open_trade_count_start += 1
|
|
|
|
open_trade_count += 1
|
2021-02-16 06:56:35 +00:00
|
|
|
# logger.debug(f"{pair} - Emulate creation of new trade: {trade}.")
|
2021-02-10 19:37:55 +00:00
|
|
|
open_trades[pair].append(trade)
|
2020-10-07 18:59:05 +00:00
|
|
|
|
2021-08-11 06:35:16 +00:00
|
|
|
for trade in list(open_trades[pair]):
|
2022-01-22 13:11:33 +00:00
|
|
|
# 2. Process buy orders.
|
|
|
|
order = trade.select_order('buy', is_open=True)
|
|
|
|
if order and self._get_order_filled(order.price, row):
|
2022-01-30 14:44:13 +00:00
|
|
|
order.close_bt_order(current_time)
|
2022-01-22 13:11:33 +00:00
|
|
|
trade.open_order_id = None
|
|
|
|
LocalTrade.add_bt_trade(trade)
|
2022-01-30 18:35:46 +00:00
|
|
|
self.wallets.update()
|
2022-01-22 13:11:33 +00:00
|
|
|
|
|
|
|
# 3. Create sell orders (if any)
|
|
|
|
if not trade.open_order_id:
|
|
|
|
self._get_sell_trade_entry(trade, row) # Place sell order if necessary
|
|
|
|
|
|
|
|
# 4. Process sell orders.
|
|
|
|
order = trade.select_order('sell', is_open=True)
|
|
|
|
if order and self._get_order_filled(order.price, row):
|
|
|
|
trade.open_order_id = None
|
2022-01-30 14:44:13 +00:00
|
|
|
trade.close_date = current_time
|
2022-01-22 13:11:33 +00:00
|
|
|
trade.close(order.price, show_msg=False)
|
|
|
|
|
2020-10-18 14:38:16 +00:00
|
|
|
# logger.debug(f"{pair} - Backtesting sell {trade}")
|
2020-10-07 18:59:05 +00:00
|
|
|
open_trade_count -= 1
|
|
|
|
open_trades[pair].remove(trade)
|
2021-03-13 09:16:32 +00:00
|
|
|
LocalTrade.close_bt_trade(trade)
|
2022-01-22 13:11:33 +00:00
|
|
|
trades.append(trade)
|
2022-01-30 18:35:46 +00:00
|
|
|
self.wallets.update()
|
2022-01-30 16:17:03 +00:00
|
|
|
self.run_protections(enable_protections, pair, current_time)
|
2022-01-22 13:11:33 +00:00
|
|
|
|
|
|
|
# 5. Cancel expired buy/sell orders.
|
2022-01-30 19:00:11 +00:00
|
|
|
if self.check_order_cancel(trade, current_time):
|
2022-01-30 16:39:23 +00:00
|
|
|
# Close trade due to buy timeout expiration.
|
|
|
|
open_trade_count -= 1
|
|
|
|
open_trades[pair].remove(trade)
|
2022-01-30 18:35:46 +00:00
|
|
|
self.wallets.update()
|
2018-03-04 00:42:37 +00:00
|
|
|
|
2020-10-07 18:59:05 +00:00
|
|
|
# Move time one configured time_interval ahead.
|
2021-03-21 14:56:36 +00:00
|
|
|
self.progress.increment()
|
2022-01-22 13:11:33 +00:00
|
|
|
current_time += timedelta(minutes=self.timeframe_min)
|
2019-04-04 17:44:03 +00:00
|
|
|
|
2020-10-08 18:10:00 +00:00
|
|
|
trades += self.handle_left_open(open_trades, data=data)
|
2021-02-17 19:07:27 +00:00
|
|
|
self.wallets.update()
|
2018-06-09 19:44:20 +00:00
|
|
|
|
2021-04-30 05:31:57 +00:00
|
|
|
results = trade_list_to_dataframe(trades)
|
|
|
|
return {
|
|
|
|
'results': results,
|
|
|
|
'config': self.strategy.config,
|
|
|
|
'locks': PairLocks.get_all_locks(),
|
2021-05-23 07:46:51 +00:00
|
|
|
'rejected_signals': self.rejected_trades,
|
2022-02-07 17:49:30 +00:00
|
|
|
'timedout_entry_orders': self.timedout_entry_orders,
|
|
|
|
'timedout_exit_orders': self.timedout_exit_orders,
|
2021-04-30 05:31:57 +00:00
|
|
|
'final_balance': self.wallets.get_total(self.strategy.config['stake_currency']),
|
|
|
|
}
|
2018-02-09 07:35:38 +00:00
|
|
|
|
2021-08-09 12:53:18 +00:00
|
|
|
def backtest_one_strategy(self, strat: IStrategy, data: Dict[str, DataFrame],
|
|
|
|
timerange: TimeRange):
|
2021-03-21 14:56:36 +00:00
|
|
|
self.progress.init_step(BacktestState.ANALYZE, 0)
|
|
|
|
|
2020-09-18 05:44:11 +00:00
|
|
|
logger.info("Running backtesting for Strategy %s", strat.get_strategy_name())
|
2021-01-13 06:47:03 +00:00
|
|
|
backtest_start_time = datetime.now(timezone.utc)
|
2020-09-18 05:44:11 +00:00
|
|
|
self._set_strategy(strat)
|
|
|
|
|
2020-10-11 17:50:37 +00:00
|
|
|
strategy_safe_wrapper(self.strategy.bot_loop_start, supress_error=True)()
|
|
|
|
|
2020-09-18 05:44:11 +00:00
|
|
|
# Use max_open_trades in backtesting, except --disable-max-market-positions is set
|
|
|
|
if self.config.get('use_max_market_positions', True):
|
|
|
|
# Must come from strategy config, as the strategy may modify this setting.
|
|
|
|
max_open_trades = self.strategy.config['max_open_trades']
|
|
|
|
else:
|
|
|
|
logger.info(
|
|
|
|
'Ignoring max_open_trades (--disable-max-market-positions was used) ...')
|
|
|
|
max_open_trades = 0
|
|
|
|
|
|
|
|
# need to reprocess data every time to populate signals
|
2021-08-09 12:53:18 +00:00
|
|
|
preprocessed = self.strategy.advise_all_indicators(data)
|
2020-09-18 05:44:11 +00:00
|
|
|
|
|
|
|
# Trim startup period from analyzed dataframe
|
2021-07-13 17:36:15 +00:00
|
|
|
preprocessed_tmp = trim_dataframes(preprocessed, timerange, self.required_startup)
|
Fix exception when few pairs with no data do not result in aborting backtest.
Exception is triggered by backtesting 20210301-20210501 range with BAKE/USDT pair (binance). Pair data starts on 2021-04-30 12:00:00 and after adjusting for startup candles pair dataframe is empty.
Solution: Since there are other pairs with enough data - skip pairs with no data and issue a warning.
Exception:
```
Traceback (most recent call last):
File "/home/rk/src/freqtrade/freqtrade/main.py", line 37, in main
return_code = args['func'](args)
File "/home/rk/src/freqtrade/freqtrade/commands/optimize_commands.py", line 53, in start_backtesting
backtesting.start()
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 502, in start
min_date, max_date = self.backtest_one_strategy(strat, data, timerange)
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 474, in backtest_one_strategy
results = self.backtest(
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 365, in backtest
data: Dict = self._get_ohlcv_as_lists(processed)
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 199, in _get_ohlcv_as_lists
pair_data.loc[:, 'buy'] = 0 # cleanup from previous run
File "/home/rk/src/freqtrade/venv/lib/python3.9/site-packages/pandas/core/indexing.py", line 692, in __setitem__
iloc._setitem_with_indexer(indexer, value, self.name)
File "/home/rk/src/freqtrade/venv/lib/python3.9/site-packages/pandas/core/indexing.py", line 1587, in _setitem_with_indexer
raise ValueError(
ValueError: cannot set a frame with no defined index and a scalar
```
2021-05-13 06:47:28 +00:00
|
|
|
|
2021-07-13 17:36:15 +00:00
|
|
|
if not preprocessed_tmp:
|
2021-05-06 18:49:48 +00:00
|
|
|
raise OperationalException(
|
Fix exception when few pairs with no data do not result in aborting backtest.
Exception is triggered by backtesting 20210301-20210501 range with BAKE/USDT pair (binance). Pair data starts on 2021-04-30 12:00:00 and after adjusting for startup candles pair dataframe is empty.
Solution: Since there are other pairs with enough data - skip pairs with no data and issue a warning.
Exception:
```
Traceback (most recent call last):
File "/home/rk/src/freqtrade/freqtrade/main.py", line 37, in main
return_code = args['func'](args)
File "/home/rk/src/freqtrade/freqtrade/commands/optimize_commands.py", line 53, in start_backtesting
backtesting.start()
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 502, in start
min_date, max_date = self.backtest_one_strategy(strat, data, timerange)
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 474, in backtest_one_strategy
results = self.backtest(
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 365, in backtest
data: Dict = self._get_ohlcv_as_lists(processed)
File "/home/rk/src/freqtrade/freqtrade/optimize/backtesting.py", line 199, in _get_ohlcv_as_lists
pair_data.loc[:, 'buy'] = 0 # cleanup from previous run
File "/home/rk/src/freqtrade/venv/lib/python3.9/site-packages/pandas/core/indexing.py", line 692, in __setitem__
iloc._setitem_with_indexer(indexer, value, self.name)
File "/home/rk/src/freqtrade/venv/lib/python3.9/site-packages/pandas/core/indexing.py", line 1587, in _setitem_with_indexer
raise ValueError(
ValueError: cannot set a frame with no defined index and a scalar
```
2021-05-13 06:47:28 +00:00
|
|
|
"No data left after adjusting for startup candles.")
|
|
|
|
|
2021-07-13 17:36:15 +00:00
|
|
|
# Use preprocessed_tmp for date generation (the trimmed dataframe).
|
|
|
|
# Backtesting will re-trim the dataframes after buy/sell signal generation.
|
|
|
|
min_date, max_date = history.get_timerange(preprocessed_tmp)
|
2020-09-18 05:44:11 +00:00
|
|
|
logger.info(f'Backtesting with data from {min_date.strftime(DATETIME_PRINT_FORMAT)} '
|
|
|
|
f'up to {max_date.strftime(DATETIME_PRINT_FORMAT)} '
|
2021-05-06 18:49:48 +00:00
|
|
|
f'({(max_date - min_date).days} days).')
|
2020-09-18 05:44:11 +00:00
|
|
|
# Execute backtest and store results
|
|
|
|
results = self.backtest(
|
|
|
|
processed=preprocessed,
|
2021-05-06 17:34:10 +00:00
|
|
|
start_date=min_date,
|
|
|
|
end_date=max_date,
|
2020-09-18 05:44:11 +00:00
|
|
|
max_open_trades=max_open_trades,
|
|
|
|
position_stacking=self.config.get('position_stacking', False),
|
|
|
|
enable_protections=self.config.get('enable_protections', False),
|
|
|
|
)
|
2021-01-13 06:47:03 +00:00
|
|
|
backtest_end_time = datetime.now(timezone.utc)
|
2021-04-30 05:31:57 +00:00
|
|
|
results.update({
|
2022-01-18 09:00:51 +00:00
|
|
|
'run_id': self.run_ids.get(strat.get_strategy_name(), ''),
|
2021-01-13 06:47:03 +00:00
|
|
|
'backtest_start_time': int(backtest_start_time.timestamp()),
|
|
|
|
'backtest_end_time': int(backtest_end_time.timestamp()),
|
2021-04-30 05:31:57 +00:00
|
|
|
})
|
|
|
|
self.all_results[self.strategy.get_strategy_name()] = results
|
|
|
|
|
2020-09-18 05:44:11 +00:00
|
|
|
return min_date, max_date
|
|
|
|
|
2022-01-18 09:00:51 +00:00
|
|
|
def _get_min_cached_backtest_date(self):
|
|
|
|
min_backtest_date = None
|
|
|
|
backtest_cache_age = self.config.get('backtest_cache', constants.BACKTEST_CACHE_DEFAULT)
|
|
|
|
if self.timerange.stopts == 0 or datetime.fromtimestamp(
|
|
|
|
self.timerange.stopts, tz=timezone.utc) > datetime.now(tz=timezone.utc):
|
|
|
|
logger.warning('Backtest result caching disabled due to use of open-ended timerange.')
|
|
|
|
elif backtest_cache_age == 'day':
|
|
|
|
min_backtest_date = datetime.now(tz=timezone.utc) - timedelta(days=1)
|
|
|
|
elif backtest_cache_age == 'week':
|
|
|
|
min_backtest_date = datetime.now(tz=timezone.utc) - timedelta(weeks=1)
|
|
|
|
elif backtest_cache_age == 'month':
|
|
|
|
min_backtest_date = datetime.now(tz=timezone.utc) - timedelta(weeks=4)
|
|
|
|
return min_backtest_date
|
|
|
|
|
2022-01-20 05:44:41 +00:00
|
|
|
def load_prior_backtest(self):
|
2022-01-18 09:00:51 +00:00
|
|
|
self.run_ids = {
|
2022-01-06 09:53:11 +00:00
|
|
|
strategy.get_strategy_name(): get_strategy_run_id(strategy)
|
|
|
|
for strategy in self.strategylist
|
|
|
|
}
|
|
|
|
|
|
|
|
# Load previous result that will be updated incrementally.
|
2022-01-16 17:01:05 +00:00
|
|
|
# This can be circumvented in certain instances in combination with downloading more data
|
2022-01-18 09:00:51 +00:00
|
|
|
min_backtest_date = self._get_min_cached_backtest_date()
|
|
|
|
if min_backtest_date is not None:
|
2022-01-06 09:53:11 +00:00
|
|
|
self.results = find_existing_backtest_stats(
|
2022-01-18 09:00:51 +00:00
|
|
|
self.config['user_data_dir'] / 'backtest_results', self.run_ids, min_backtest_date)
|
2022-01-06 09:53:11 +00:00
|
|
|
|
2018-02-09 07:35:38 +00:00
|
|
|
def start(self) -> None:
|
|
|
|
"""
|
2019-12-13 23:12:16 +00:00
|
|
|
Run backtesting end-to-end
|
2018-02-09 07:35:38 +00:00
|
|
|
:return: None
|
|
|
|
"""
|
2018-08-19 17:39:22 +00:00
|
|
|
data: Dict[str, Any] = {}
|
2019-12-13 23:12:16 +00:00
|
|
|
|
2019-10-23 18:13:43 +00:00
|
|
|
data, timerange = self.load_bt_data()
|
2021-08-14 13:34:43 +00:00
|
|
|
self.load_bt_data_detail()
|
2021-04-23 17:22:41 +00:00
|
|
|
logger.info("Dataload complete. Calculating indicators")
|
2019-06-14 17:37:54 +00:00
|
|
|
|
2022-01-20 05:44:41 +00:00
|
|
|
self.load_prior_backtest()
|
|
|
|
|
2018-07-28 05:41:38 +00:00
|
|
|
for strat in self.strategylist:
|
2022-01-06 09:53:11 +00:00
|
|
|
if self.results and strat.get_strategy_name() in self.results['strategy']:
|
|
|
|
# When previous result hash matches - reuse that result and skip backtesting.
|
|
|
|
logger.info(f'Reusing result of previous backtest for {strat.get_strategy_name()}')
|
|
|
|
continue
|
2020-09-18 05:44:11 +00:00
|
|
|
min_date, max_date = self.backtest_one_strategy(strat, data, timerange)
|
2020-12-31 18:46:54 +00:00
|
|
|
|
2022-01-06 09:53:11 +00:00
|
|
|
# Update old results with new ones.
|
|
|
|
if len(self.all_results) > 0:
|
|
|
|
results = generate_backtest_stats(
|
|
|
|
data, self.all_results, min_date=min_date, max_date=max_date)
|
|
|
|
if self.results:
|
|
|
|
self.results['metadata'].update(results['metadata'])
|
|
|
|
self.results['strategy'].update(results['strategy'])
|
|
|
|
self.results['strategy_comparison'].extend(results['strategy_comparison'])
|
|
|
|
else:
|
|
|
|
self.results = results
|
2020-03-15 14:36:23 +00:00
|
|
|
|
2021-06-14 17:57:24 +00:00
|
|
|
if self.config.get('export', 'none') == 'trades':
|
2020-12-31 18:46:54 +00:00
|
|
|
store_backtest_stats(self.config['exportfilename'], self.results)
|
2020-09-26 12:55:12 +00:00
|
|
|
|
2022-01-06 09:53:11 +00:00
|
|
|
# Results may be mixed up now. Sort them so they follow --strategy-list order.
|
|
|
|
if 'strategy_list' in self.config and len(self.results) > 0:
|
|
|
|
self.results['strategy_comparison'] = sorted(
|
|
|
|
self.results['strategy_comparison'],
|
|
|
|
key=lambda c: self.config['strategy_list'].index(c['key']))
|
|
|
|
self.results['strategy'] = dict(
|
|
|
|
sorted(self.results['strategy'].items(),
|
|
|
|
key=lambda kv: self.config['strategy_list'].index(kv[0])))
|
|
|
|
|
|
|
|
if len(self.strategylist) > 0:
|
2021-03-01 07:57:57 +00:00
|
|
|
# Show backtest results
|
2020-12-31 18:46:54 +00:00
|
|
|
show_backtest_results(self.config, self.results)
|