freqtrade_origin/freqtrade/tests/test_backtesting.py

# pragma pylint: disable=missing-docstring,W0212


import logging
import os
from typing import Tuple, Dict

import arrow
import pytest
from pandas import DataFrame
from tabulate import tabulate

from freqtrade import exchange
from freqtrade.analyze import parse_ticker_dataframe, populate_indicators, \
    populate_buy_trend, populate_sell_trend
from freqtrade.exchange import Bittrex
from freqtrade.main import min_roi_reached
from freqtrade.misc import load_config
from freqtrade.persistence import Trade
from freqtrade.tests import load_backtesting_data

logger = logging.getLogger(__name__)


def format_results(results: DataFrame):
    return ('Made {:6d} buys. Average profit {: 5.2f}%. '
            'Total profit was {: 7.3f}. Average duration {:5.1f} mins.').format(
                len(results.index),
                results.profit.mean() * 100.0,
                results.profit.sum(),
                results.duration.mean() * 5,
            )


def preprocess(backdata) -> Dict[str, DataFrame]:
    processed = {}
    for pair, pair_data in backdata.items():
        processed[pair] = populate_indicators(parse_ticker_dataframe(pair_data))
    return processed


def get_timeframe(data: Dict[str, Dict]) -> Tuple[arrow.Arrow, arrow.Arrow]:
    """
    Get the maximum timeframe for the given backtest data
    :param data: dictionary with backtesting data
    :return: tuple containing min_date, max_date
    """
    min_date, max_date = None, None
    for values in data.values():
        sorted_values = sorted(values, key=lambda d: arrow.get(d['T']))
        if not min_date or sorted_values[0]['T'] < min_date:
            min_date = sorted_values[0]['T']
        if not max_date or sorted_values[-1]['T'] > max_date:
            max_date = sorted_values[-1]['T']
    return arrow.get(min_date), arrow.get(max_date)


def generate_text_table(data: Dict[str, Dict], results: DataFrame, stake_currency) -> str:
    """
    Generates and returns a text table for the given backtest data and the results dataframe
    :return: pretty printed table with tabulate as str
    """
    tabular_data = []
    headers = ['pair', 'buy count', 'avg profit', 'total profit', 'avg duration']
    for pair in data:
        result = results[results.currency == pair]
        tabular_data.append([
            pair,
            len(result.index),
            '{:.2f}%'.format(result.profit.mean() * 100.0),
            '{:.08f} {}'.format(result.profit.sum(), stake_currency),
            '{:.2f}'.format(result.duration.mean() * 5),
        ])

    # Append Total
    tabular_data.append([
        'TOTAL',
        len(results.index),
        '{:.2f}%'.format(results.profit.mean() * 100.0),
        '{:.08f} {}'.format(results.profit.sum(), stake_currency),
        '{:.2f}'.format(results.duration.mean() * 5),
    ])
    return tabulate(tabular_data, headers=headers)


def backtest(config: Dict, processed, mocker, max_open_trades=0):
    """
    Implements backtesting functionality
    :param config: config to use
    :param processed: a processed dictionary with format {pair, data}
    :param mocker: mocker instance
    :param max_open_trades: maximum number of concurrent trades (default: 0, disabled)
    :return: DataFrame
    """
    trades = []
    trade_count_lock = {}
    exchange._API = Bittrex({'key': '', 'secret': ''})
    mocker.patch.dict('freqtrade.main._CONF', config)
    for pair, pair_data in processed.items():
        pair_data['buy'], pair_data['sell'] = 0, 0
        ticker = populate_sell_trend(populate_buy_trend(pair_data))
        # for each buy point
        for row in ticker[ticker.buy == 1].itertuples(index=True):
            if max_open_trades > 0:
                # Check if max_open_trades has already been reached for the given date
                if not trade_count_lock.get(row.date, 0) < max_open_trades:
                    continue

            if max_open_trades > 0:
                # Increase lock
                trade_count_lock[row.date] = trade_count_lock.get(row.date, 0) + 1

            trade = Trade(
                open_rate=row.close,
                open_date=row.date,
                amount=config['stake_amount'],
                fee=exchange.get_fee() * 2
            )

            # calculate win/lose forwards from buy point
            for row2 in ticker[row.Index + 1:].itertuples(index=True):
                if max_open_trades > 0:
                    # Increase trade_count_lock for every iteration
                    trade_count_lock[row2.date] = trade_count_lock.get(row2.date, 0) + 1

                if min_roi_reached(trade, row2.close, row2.date) or row2.sell == 1:
                    current_profit = trade.calc_profit(row2.close)

                    trades.append((pair, current_profit, row2.Index - row.Index))
                    break
    labels = ['currency', 'profit', 'duration']
    return DataFrame.from_records(trades, columns=labels)


def get_max_open_trades(config):
    if not os.environ.get('BACKTEST_LIMIT_MAX_TRADES'):
        return 0
    print('Using max_open_trades: {} ...'.format(config['max_open_trades']))
    return config['max_open_trades']


@pytest.mark.skipif(not os.environ.get('BACKTEST'), reason="BACKTEST not set")
def test_backtest(backtest_conf, mocker):
    print('')
    exchange._API = Bittrex({'key': '', 'secret': ''})

    # Load configuration file based on env variable
    conf_path = os.environ.get('BACKTEST_CONFIG')
    if conf_path:
        print('Using config: {} ...'.format(conf_path))
        config = load_config(conf_path)
    else:
        config = backtest_conf

    # Parse ticker interval
    ticker_interval = int(os.environ.get('BACKTEST_TICKER_INTERVAL') or 5)
    print('Using ticker_interval: {} ...'.format(ticker_interval))

    data = {}
    if os.environ.get('BACKTEST_LIVE'):
        print('Downloading data for all pairs in whitelist ...')
        for pair in config['exchange']['pair_whitelist']:
            data[pair] = exchange.get_ticker_history(pair, ticker_interval)
    else:
        print('Using local backtesting data (ignoring whitelist in given config)...')
        data = load_backtesting_data(ticker_interval)

    print('Using stake_currency: {} ...\nUsing stake_amount: {} ...'.format(
        config['stake_currency'], config['stake_amount']
    ))

    # Print timeframe
    min_date, max_date = get_timeframe(data)
    print('Measuring data from {} up to {} ...'.format(
        min_date.isoformat(), max_date.isoformat()
    ))

    # Execute backtest and print results
    results = backtest(config, preprocess(data), mocker, get_max_open_trades(config))
    print('====================== BACKTESTING REPORT ======================================\n\n')
    print(generate_text_table(data, results, config['stake_currency']))