BackcastPro 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

BackcastPro/test/_test.py

@@ -1,1174 +0,0 @@
-import inspect
-import multiprocessing as mp
-import os
-import sys
-import time
-import unittest
-from concurrent.futures.process import ProcessPoolExecutor
-from contextlib import contextmanager
-from glob import glob
-from runpy import run_path
-from tempfile import NamedTemporaryFile, gettempdir
-from unittest import TestCase
-
-import numpy as np
-import pandas as pd
-from pandas.testing import assert_frame_equal
-
-from BackcastPro import Backtest, Strategy
-from BackcastPro._stats import compute_drawdown_duration_peaks
-from BackcastPro._util import _Array, _as_str, _Indicator, patch, try_
-from BackcastPro.lib import (
-    FractionalBacktest, MultiBacktest, OHLCV_AGG,
-    SignalStrategy,
-    TrailingStrategy,
-    barssince,
-    compute_stats,
-    cross,
-    crossover,
-    plot_heatmaps,
-    quantile,
-    random_ohlc_data,
-    resample_apply,
-)
-from BackcastPro.test import BTCUSD, EURUSD, GOOG, SMA
-
-SHORT_DATA = GOOG.iloc[:20]  # Short data for fast tests with no indicator lag
-
-
-@contextmanager
-def _tempfile():
-    with NamedTemporaryFile(suffix='.html') as f:
-        if sys.platform.startswith('win'):
-            f.close()
-        yield f.name
-
-
-@contextmanager
-def chdir(path):
-    cwd = os.getcwd()
-    os.chdir(path)
-    try:
-        yield
-    finally:
-        os.chdir(cwd)
-
-
-class SmaCross(Strategy):
-    # NOTE: These values are also used on the website!
-    fast = 10
-    slow = 30
-
-    def init(self):
-        self.sma1 = self.I(SMA, self.data.Close, self.fast)
-        self.sma2 = self.I(SMA, self.data.Close, self.slow)
-
-    def next(self):
-        if crossover(self.sma1, self.sma2):
-            self.position.close()
-            self.buy()
-        elif crossover(self.sma2, self.sma1):
-            self.position.close()
-            self.sell()
-
-
-class _S(Strategy):
-    def init(self):
-        super().init()
-
-
-class TestBacktest(TestCase):
-    def test_run(self):
-        bt = Backtest(EURUSD, SmaCross)
-        bt.run()
-
-    def test_run_invalid_param(self):
-        bt = Backtest(GOOG, SmaCross)
-        self.assertRaises(AttributeError, bt.run, foo=3)
-
-    def test_run_speed(self):
-        bt = Backtest(GOOG, SmaCross)
-        start = time.process_time()
-        bt.run()
-        end = time.process_time()
-        self.assertLess(end - start, .3)
-
-    def test_data_missing_columns(self):
-        df = GOOG.copy(deep=False)
-        del df['Open']
-        with self.assertRaises(ValueError):
-            Backtest(df, SmaCross).run()
-
-    def test_data_nan_columns(self):
-        df = GOOG.copy()
-        df['Open'] = np.nan
-        with self.assertRaises(ValueError):
-            Backtest(df, SmaCross).run()
-
-    def test_data_extra_columns(self):
-        df = GOOG.copy(deep=False)
-        df['P/E'] = np.arange(len(df))
-        df['MCap'] = np.arange(len(df))
-
-        class S(Strategy):
-            def init(self):
-                assert len(self.data.MCap) == len(self.data.Close)
-                assert len(self.data['P/E']) == len(self.data.Close)
-
-            def next(self):
-                assert len(self.data.MCap) == len(self.data.Close)
-                assert len(self.data['P/E']) == len(self.data.Close)
-
-        Backtest(df, S).run()
-
-    def test_data_invalid(self):
-        with self.assertRaises(TypeError):
-            Backtest(GOOG.index, SmaCross).run()
-        with self.assertRaises(ValueError):
-            Backtest(GOOG.iloc[:0], SmaCross).run()
-
-    def test_assertions(self):
-        class Assertive(Strategy):
-            def init(self):
-                self.sma = self.I(SMA, self.data.Close, 10)
-                self.remains_indicator = np.r_[2] * np.cumsum(self.sma * 5 + 1) * np.r_[2]
-
-                self.transpose_invalid = self.I(lambda: np.column_stack((self.data.Open,
-                                                                         self.data.Close)))
-
-                resampled = resample_apply('W', SMA, self.data.Close, 3)
-                resampled_ind = resample_apply('W', SMA, self.sma, 3)
-                assert np.unique(resampled[-5:]).size == 1
-                assert np.unique(resampled[-6:]).size == 2
-                assert resampled in self._indicators, "Strategy.I not called"
-                assert resampled_ind in self._indicators, "Strategy.I not called"
-
-                assert 1 == try_(lambda: self.data.X, 1, AttributeError)
-                assert 1 == try_(lambda: self.data['X'], 1, KeyError)
-
-                assert self.data.pip == .01
-
-                assert float(self.data.Close) == self.data.Close[-1]
-
-            def next(self, _FEW_DAYS=pd.Timedelta('3 days')):  # noqa: N803
-                assert self.equity >= 0
-
-                assert isinstance(self.sma, _Indicator)
-                assert isinstance(self.remains_indicator, _Indicator)
-                assert self.remains_indicator.name
-                assert isinstance(self.remains_indicator._opts, dict)
-
-                assert not np.isnan(self.data.Open[-1])
-                assert not np.isnan(self.data.High[-1])
-                assert not np.isnan(self.data.Low[-1])
-                assert not np.isnan(self.data.Close[-1])
-                assert not np.isnan(self.data.Volume[-1])
-                assert not np.isnan(self.sma[-1])
-                assert self.data.index[-1]
-
-                self.position
-                self.position.size
-                self.position.pl
-                self.position.pl_pct
-                self.position.is_long
-
-                if crossover(self.sma, self.data.Close):
-                    self.orders.cancel()  # cancels only non-contingent
-                    price = self.data.Close[-1]
-                    sl, tp = 1.05 * price, .9 * price
-
-                    n_orders = len(self.orders)
-                    self.sell(size=.21, limit=price, stop=price, sl=sl, tp=tp)
-                    assert len(self.orders) == n_orders + 1
-
-                    order = self.orders[-1]
-                    assert order.limit == price
-                    assert order.stop == price
-                    assert order.size == -.21
-                    assert order.sl == sl
-                    assert order.tp == tp
-                    assert not order.is_contingent
-
-                elif self.position:
-                    assert not self.position.is_long
-                    assert self.position.is_short
-                    assert self.position.pl
-                    assert self.position.pl_pct
-                    assert self.position.size < 0
-
-                    trade = self.trades[0]
-                    if self.data.index[-1] - self.data.index[trade.entry_bar] > _FEW_DAYS:
-                        assert not trade.is_long
-                        assert trade.is_short
-                        assert trade.size < 0
-                        assert trade.entry_bar > 0
-                        assert isinstance(trade.entry_time, pd.Timestamp)
-                        assert trade.exit_bar is None
-                        assert trade.exit_time is None
-                        assert trade.entry_price > 0
-                        assert trade.exit_price is None
-                        assert trade.pl / 1
-                        assert trade.pl_pct / 1
-                        assert trade.value > 0
-                        assert trade.sl
-                        assert trade.tp
-                        # Close multiple times
-                        self.position.close(.5)
-                        self.position.close(.5)
-                        self.position.close(.5)
-                        self.position.close()
-                        self.position.close()
-
-        bt = Backtest(GOOG, Assertive)
-        with self.assertWarns(UserWarning):
-            stats = bt.run()
-        self.assertEqual(stats['# Trades'], 131)
-
-    def test_broker_params(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross,
-                      cash=1000, spread=.01, margin=.1, trade_on_close=True)
-        bt.run()
-
-    def test_spread_commission(self):
-        class S(Strategy):
-            def init(self):
-                self.done = False
-
-            def next(self):
-                if not self.position:
-                    self.buy()
-                else:
-                    self.position.close()
-                    self.next = lambda: None  # Done
-
-        SPREAD = .01
-        COMMISSION = .01
-        CASH = 10_000
-        ORDER_BAR = 2
-        stats = Backtest(SHORT_DATA, S, cash=CASH, spread=SPREAD, commission=COMMISSION).run()
-        trade_open_price = SHORT_DATA['Open'].iloc[ORDER_BAR]
-        self.assertEqual(stats['_trades']['EntryPrice'].iloc[0], trade_open_price * (1 + SPREAD))
-        self.assertEqual(stats['_equity_curve']['Equity'].iloc[2:4].round(2).tolist(),
-                         [9685.31, 9749.33])
-
-        stats = Backtest(SHORT_DATA, S, cash=CASH, commission=(100, COMMISSION)).run()
-        self.assertEqual(stats['_equity_curve']['Equity'].iloc[2:4].round(2).tolist(),
-                         [9784.50, 9718.69])
-
-        commission_func = lambda size, price: size * price * COMMISSION  # noqa: E731
-        stats = Backtest(SHORT_DATA, S, cash=CASH, commission=commission_func).run()
-        self.assertEqual(stats['_equity_curve']['Equity'].iloc[2:4].round(2).tolist(),
-                         [9781.28, 9846.04])
-
-    def test_commissions(self):
-        class S(_S):
-            def next(self):
-                if len(self.data) == 2:
-                    self.buy(size=SIZE, tp=3)
-
-        FIXED_COMMISSION, COMMISSION = 10, .01
-        CASH, SIZE, PRICE_ENTRY, PRICE_EXIT = 5000, 100, 1, 4
-        arr = np.r_[1, PRICE_ENTRY, 1, 2, PRICE_EXIT, 1, 2]
-        df = pd.DataFrame({'Open': arr, 'High': arr, 'Low': arr, 'Close': arr})
-        with self.assertWarnsRegex(UserWarning, 'index is not datetime'):
-            stats = Backtest(df, S, cash=CASH, commission=(FIXED_COMMISSION, COMMISSION)).run()
-        EXPECTED_PAID_COMMISSION = (
-            FIXED_COMMISSION + COMMISSION * SIZE * PRICE_ENTRY +
-            FIXED_COMMISSION + COMMISSION * SIZE * PRICE_EXIT)
-        self.assertEqual(stats['Commissions [$]'], EXPECTED_PAID_COMMISSION)
-        self.assertEqual(stats._trades['Commission'][0], EXPECTED_PAID_COMMISSION)
-        self.assertEqual(
-            stats['Equity Final [$]'],
-            CASH + (PRICE_EXIT - PRICE_ENTRY) * SIZE - EXPECTED_PAID_COMMISSION)
-
-    def test_dont_overwrite_data(self):
-        df = EURUSD.copy()
-        bt = Backtest(df, SmaCross)
-        bt.run()
-        bt.optimize(fast=4, slow=[6, 8])
-        bt.plot(plot_drawdown=True, open_browser=False)
-        self.assertTrue(df.equals(EURUSD))
-
-    def test_strategy_abstract(self):
-        class MyStrategy(Strategy):
-            pass
-
-        self.assertRaises(TypeError, MyStrategy, None, None)
-
-    def test_strategy_str(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross)
-        self.assertEqual(str(bt.run()._strategy), SmaCross.__name__)
-        self.assertEqual(str(bt.run(fast=11)._strategy), SmaCross.__name__ + '(fast=11)')
-
-    def test_compute_drawdown(self):
-        dd = pd.Series([0, 1, 7, 0, 4, 0, 0])
-        durations, peaks = compute_drawdown_duration_peaks(dd)
-        np.testing.assert_array_equal(durations, pd.Series([3, 2], index=[3, 5]).reindex(dd.index))
-        np.testing.assert_array_equal(peaks, pd.Series([7, 4], index=[3, 5]).reindex(dd.index))
-
-    def test_compute_stats(self):
-        stats = Backtest(GOOG, SmaCross, finalize_trades=True).run()
-        expected = pd.Series({
-                # NOTE: These values are also used on the website!  # noqa: E126
-                '# Trades': 66,
-                'Avg. Drawdown Duration': pd.Timedelta('41 days 00:00:00'),
-                'Avg. Drawdown [%]': -5.925851581948801,
-                'Avg. Trade Duration': pd.Timedelta('46 days 00:00:00'),
-                'Avg. Trade [%]': 2.531715975158555,
-                'Best Trade [%]': 53.59595229490424,
-                'Buy & Hold Return [%]': 522.0601851851852,
-                'Calmar Ratio': 0.4414380935608377,
-                'Duration': pd.Timedelta('3116 days 00:00:00'),
-                'End': pd.Timestamp('2013-03-01 00:00:00'),
-                'Equity Final [$]': 51422.98999999996,
-                'Equity Peak [$]': 75787.44,
-                'Expectancy [%]': 3.2748078066748834,
-                'Exposure Time [%]': 96.74115456238361,
-                'Max. Drawdown Duration': pd.Timedelta('584 days 00:00:00'),
-                'Max. Drawdown [%]': -47.98012705007589,
-                'Max. Trade Duration': pd.Timedelta('183 days 00:00:00'),
-                'Profit Factor': 2.167945974262033,
-                'Return (Ann.) [%]': 21.180255813792282,
-                'Return [%]': 414.2298999999996,
-                'Volatility (Ann.) [%]': 36.49390889140787,
-                'CAGR [%]': 14.159843619607383,
-                'SQN': 1.0766187356697705,
-                'Kelly Criterion': 0.1518705127029717,
-                'Sharpe Ratio': 0.5803778344714113,
-                'Sortino Ratio': 1.0847880675854096,
-                'Start': pd.Timestamp('2004-08-19 00:00:00'),
-                'Win Rate [%]': 46.96969696969697,
-                'Worst Trade [%]': -18.39887353835481,
-                'Alpha [%]': 394.37391142027462,
-                'Beta': 0.03803390709192,
-        })
-
-        def almost_equal(a, b):
-            try:
-                return np.isclose(a, b, rtol=1.e-8)
-            except TypeError:
-                return a == b
-
-        diff = {key: print(key) or value  # noqa: T201
-                for key, value in stats.filter(regex='^[^_]').items()
-                if not almost_equal(value, expected[key])}
-        self.assertDictEqual(diff, {})
-
-        self.assertSequenceEqual(
-            sorted(stats['_equity_curve'].columns),
-            sorted(['Equity', 'DrawdownPct', 'DrawdownDuration']))
-
-        self.assertEqual(len(stats['_trades']), 66)
-
-        indicator_columns = [
-            f'{entry}_SMA(C,{n})'
-            for entry in ('Entry', 'Exit')
-            for n in (SmaCross.fast, SmaCross.slow)]
-        self.assertSequenceEqual(
-            sorted(stats['_trades'].columns),
-            sorted(['Size', 'EntryBar', 'ExitBar', 'EntryPrice', 'ExitPrice',
-                    'SL', 'TP', 'PnL', 'ReturnPct', 'EntryTime', 'ExitTime',
-                    'Duration', 'Tag', 'Commission',
-                    *indicator_columns]))
-
-    def test_compute_stats_bordercase(self):
-
-        class SingleTrade(Strategy):
-            def init(self):
-                self._done = False
-
-            def next(self):
-                if not self._done:
-                    self.buy()
-                    self._done = True
-                if self.position:
-                    self.position.close()
-
-        class SinglePosition(_S):
-            def next(self):
-                if not self.position:
-                    self.buy()
-
-        class NoTrade(_S):
-            def next(self):
-                pass
-
-        for strategy in (SmaCross,
-                         SingleTrade,
-                         SinglePosition,
-                         NoTrade):
-            with self.subTest(strategy=strategy.__name__):
-                stats = Backtest(GOOG.iloc[:100], strategy).run()
-
-                self.assertFalse(np.isnan(stats['Equity Final [$]']))
-                self.assertFalse(stats['_equity_curve']['Equity'].isnull().any())
-                self.assertEqual(stats['_strategy'].__class__, strategy)
-
-    def test_trade_enter_hit_sl_on_same_day(self):
-        the_day = pd.Timestamp("2012-10-17 00:00:00")
-
-        class S(_S):
-            def next(self):
-                if self.data.index[-1] == the_day:
-                    self.buy(sl=720)
-
-        self.assertEqual(Backtest(GOOG, S).run()._trades.iloc[0].ExitPrice, 720)
-
-        class S(_S):
-            def next(self):
-                if self.data.index[-1] == the_day:
-                    self.buy(stop=758, sl=720)
-
-        with self.assertWarns(UserWarning):
-            self.assertEqual(Backtest(GOOG, S).run()._trades.iloc[0].ExitPrice, 705.58)
-
-    def test_stop_price_between_sl_tp(self):
-        class S(_S):
-            def next(self):
-                if self.data.index[-1] == pd.Timestamp("2004-09-09 00:00:00"):
-                    self.buy(stop=104, sl=103, tp=110)
-
-        with self.assertWarns(UserWarning):
-            self.assertEqual(Backtest(GOOG, S).run()._trades.iloc[0].EntryPrice, 104)
-
-    def test_position_close_portion(self):
-        class SmaCross(Strategy):
-            def init(self):
-                self.sma1 = self.I(SMA, self.data.Close, 10)
-                self.sma2 = self.I(SMA, self.data.Close, 20)
-
-            def next(self):
-                if not self.position and crossover(self.sma1, self.sma2):
-                    self.buy(size=10)
-                if self.position and crossover(self.sma2, self.sma1):
-                    self.position.close(portion=.5)
-
-        bt = Backtest(GOOG, SmaCross, spread=.002)
-        bt.run()
-
-    def test_close_orders_from_last_strategy_iteration(self):
-        class S(_S):
-            def next(self):
-                if not self.position:
-                    self.buy()
-                elif len(self.data) == len(SHORT_DATA):
-                    self.position.close()
-
-        with self.assertWarnsRegex(UserWarning, 'finalize_trades'):
-            self.assertTrue(Backtest(SHORT_DATA, S, finalize_trades=False).run()._trades.empty)
-        self.assertFalse(Backtest(SHORT_DATA, S, finalize_trades=True).run()._trades.empty)
-
-    def test_check_adjusted_price_when_placing_order(self):
-        class S(_S):
-            def next(self):
-                self.buy(tp=self.data.Close * 1.01)
-
-        self.assertRaises(ValueError, Backtest(SHORT_DATA, S, spread=.02).run)
-
-
-class TestStrategy(TestCase):
-    @staticmethod
-    def _Backtest(strategy_coroutine, data=SHORT_DATA, **kwargs):
-        class S(Strategy):
-            def init(self):
-                self.step = strategy_coroutine(self)
-
-            def next(self):
-                try_(self.step.__next__, None, StopIteration)
-
-        return Backtest(data, S, **kwargs)
-
-    def test_position(self):
-        def coroutine(self):
-            yield self.buy()
-
-            assert self.position
-            assert self.position.is_long
-            assert not self.position.is_short
-            assert self.position.size > 0
-            assert self.position.pl
-            assert self.position.pl_pct
-
-            yield self.position.close()
-
-            assert not self.position
-            assert not self.position.is_long
-            assert not self.position.is_short
-            assert not self.position.size
-            assert not self.position.pl
-            assert not self.position.pl_pct
-
-        self._Backtest(coroutine).run()
-
-    def test_broker_hedging(self):
-        def coroutine(self):
-            yield self.buy(size=2)
-
-            assert len(self.trades) == 1
-            yield self.sell(size=1)
-
-            assert len(self.trades) == 2
-
-        self._Backtest(coroutine, hedging=True).run()
-
-    def test_broker_exclusive_orders(self):
-        def coroutine(self):
-            yield self.buy(size=2)
-
-            assert len(self.trades) == 1
-            yield self.sell(size=3)
-
-            assert len(self.trades) == 1
-            assert self.trades[0].size == -3
-
-        self._Backtest(coroutine, exclusive_orders=True).run()
-
-    def test_trade_multiple_close(self):
-        def coroutine(self):
-            yield self.buy()
-
-            assert self.trades
-            self.trades[-1].close(1)
-            self.trades[-1].close(.1)
-            yield
-
-        self._Backtest(coroutine).run()
-
-    def test_close_trade_leaves_needsize_0(self):
-        def coroutine(self):
-            self.buy(size=1)
-            self.buy(size=1)
-            yield
-            if self.position:
-                self.sell(size=1)
-
-        self._Backtest(coroutine).run()
-
-    def test_stop_limit_order_price_is_stop_price(self):
-        def coroutine(self):
-            self.buy(stop=112, limit=113, size=1)
-            self.sell(stop=107, limit=105, size=1)
-            yield
-
-        stats = self._Backtest(coroutine).run()
-        self.assertListEqual(stats._trades.filter(like='Price').stack().tolist(), [112, 107])
-
-    def test_autoclose_trades_on_finish(self):
-        def coroutine(self):
-            yield self.buy()
-
-        stats = self._Backtest(coroutine, finalize_trades=True).run()
-        self.assertEqual(len(stats._trades), 1)
-
-    def test_order_tag(self):
-        def coroutine(self):
-            yield self.buy(size=2, tag=1)
-            yield self.sell(size=1, tag='s')
-            yield self.sell(size=1)
-
-            yield self.buy(tag=2)
-            yield self.position.close()
-
-        stats = self._Backtest(coroutine).run()
-        self.assertEqual(list(stats._trades.Tag), [1, 1, 2])
-
-
-class TestOptimize(TestCase):
-    def test_optimize(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross)
-        OPT_PARAMS = {'fast': range(2, 5, 2), 'slow': [2, 5, 7, 9]}
-
-        self.assertRaises(ValueError, bt.optimize)
-        self.assertRaises(ValueError, bt.optimize, maximize='missing key', **OPT_PARAMS)
-        self.assertRaises(ValueError, bt.optimize, maximize='missing key', **OPT_PARAMS)
-        self.assertRaises(TypeError, bt.optimize, maximize=15, **OPT_PARAMS)
-        self.assertRaises(TypeError, bt.optimize, constraint=15, **OPT_PARAMS)
-        self.assertRaises(ValueError, bt.optimize, constraint=lambda d: False, **OPT_PARAMS)
-        self.assertRaises(ValueError, bt.optimize, return_optimization=True, **OPT_PARAMS)
-
-        res = bt.optimize(**OPT_PARAMS)
-        self.assertIsInstance(res, pd.Series)
-
-        default_maximize = inspect.signature(Backtest.optimize).parameters['maximize'].default
-        res2 = bt.optimize(**OPT_PARAMS, maximize=lambda s: s[default_maximize])
-        self.assertDictEqual(res.filter(regex='^[^_]').fillna(-1).to_dict(),
-                             res2.filter(regex='^[^_]').fillna(-1).to_dict())
-
-        res3, heatmap = bt.optimize(**OPT_PARAMS, return_heatmap=True,
-                                    constraint=lambda d: d.slow > 2 * d.fast)
-        self.assertIsInstance(heatmap, pd.Series)
-        self.assertEqual(len(heatmap), 4)
-        self.assertEqual(heatmap.name, default_maximize)
-
-        with _tempfile() as f:
-            bt.plot(filename=f, open_browser=False)
-
-    def test_method_sambo(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross, finalize_trades=True)
-        res, heatmap, sambo_results = bt.optimize(
-            fast=range(2, 20), slow=np.arange(2, 20, dtype=object),
-            constraint=lambda p: p.fast < p.slow,
-            max_tries=30,
-            method='sambo',
-            return_optimization=True,
-            return_heatmap=True,
-            random_state=2)
-        self.assertIsInstance(res, pd.Series)
-        self.assertIsInstance(heatmap, pd.Series)
-        self.assertGreater(heatmap.max(), 1.1)
-        self.assertGreater(heatmap.min(), -2)
-        self.assertEqual(-sambo_results.fun, heatmap.max())
-        self.assertEqual(heatmap.index.tolist(), heatmap.dropna().index.unique().tolist())
-
-    def test_max_tries(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross)
-        OPT_PARAMS = {'fast': range(2, 10, 2), 'slow': [2, 5, 7, 9]}
-        for method, max_tries, random_state in (('grid', 5, 0),
-                                                ('grid', .3, 0),
-                                                ('sambo', 6, 0),
-                                                ('sambo', .42, 0)):
-            with self.subTest(method=method,
-                              max_tries=max_tries,
-                              random_state=random_state):
-                _, heatmap = bt.optimize(max_tries=max_tries,
-                                         method=method,
-                                         random_state=random_state,
-                                         return_heatmap=True,
-                                         **OPT_PARAMS)
-                self.assertEqual(len(heatmap), 6)
-
-    def test_optimize_invalid_param(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross)
-        self.assertRaises(AttributeError, bt.optimize, foo=range(3))
-        self.assertRaises(ValueError, bt.optimize, fast=[])
-
-    def test_optimize_no_trades(self):
-        bt = Backtest(GOOG, SmaCross)
-        stats = bt.optimize(fast=[3], slow=[3])
-        self.assertTrue(stats.isnull().any())
-
-    def test_optimize_speed(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross)
-        start = time.process_time()
-        bt.optimize(fast=range(2, 20, 2), slow=range(10, 40, 2))
-        end = time.process_time()
-        print(end - start)
-        handicap = 5 if 'win' in sys.platform else .1
-        self.assertLess(end - start, .3 + handicap)
-
-
-class TestPlot(TestCase):
-    def test_plot_before_run(self):
-        bt = Backtest(GOOG, SmaCross)
-        self.assertRaises(RuntimeError, bt.plot)
-
-    def test_file_size(self):
-        bt = Backtest(GOOG, SmaCross)
-        bt.run()
-        with _tempfile() as f:
-            bt.plot(filename=f[:-len('.html')], open_browser=False)
-            self.assertLess(os.path.getsize(f), 500000)
-
-    def test_params(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross)
-        bt.run()
-        with _tempfile() as f:
-            for p in dict(plot_volume=False,  # noqa: C408
-                          plot_equity=False,
-                          plot_return=True,
-                          plot_pl=False,
-                          plot_drawdown=True,
-                          plot_trades=False,
-                          superimpose=False,
-                          resample='1W',
-                          smooth_equity=False,
-                          relative_equity=False,
-                          reverse_indicators=True,
-                          show_legend=False).items():
-                with self.subTest(param=p[0]):
-                    bt.plot(**dict([p]), filename=f, open_browser=False)
-
-    def test_hide_legend(self):
-        bt = Backtest(GOOG.iloc[:100], SmaCross)
-        bt.run()
-        with _tempfile() as f:
-            bt.plot(filename=f, show_legend=False)
-            # Give browser time to open before tempfile is removed
-            time.sleep(5)
-
-    def test_resolutions(self):
-        with _tempfile() as f:
-            for rule in 'ms s min h D W ME'.split():
-                with self.subTest(rule=rule):
-                    df = EURUSD.iloc[:2].resample(rule).agg(OHLCV_AGG).dropna().iloc[:1100]
-                    bt = Backtest(df, SmaCross)
-                    bt.run()
-                    bt.plot(filename=f, open_browser=False)
-
-    def test_range_axis(self):
-        df = GOOG.iloc[:100].reset_index(drop=True)
-
-        # Warm-up. CPython bug bpo-29620.
-        try:
-            with self.assertWarns(UserWarning):
-                Backtest(df, SmaCross)
-        except RuntimeError:
-            pass
-
-        with self.assertWarns(UserWarning):
-            bt = Backtest(df, SmaCross)
-        bt.run()
-        with _tempfile() as f:
-            bt.plot(filename=f, open_browser=False)
-
-    def test_preview(self):
-        class Strategy(SmaCross):
-            def init(self):
-                super().init()
-
-                def ok(x):
-                    return x
-
-                self.a = self.I(SMA, self.data.Open, 5, overlay=False, name='ok')
-                self.b = self.I(ok, np.random.random(len(self.data.Open)))
-
-        bt = Backtest(GOOG, Strategy)
-        bt.run()
-        with _tempfile() as f:
-            bt.plot(filename=f, plot_drawdown=True, smooth_equity=True)
-            # Give browser time to open before tempfile is removed
-            time.sleep(5)
-
-    def test_wellknown(self):
-        class S(_S):
-            def next(self):
-                date = self.data.index[-1]
-                if date == pd.Timestamp('Thu 19 Oct 2006'):
-                    self.buy(stop=484, limit=466, size=100)
-                elif date == pd.Timestamp('Thu 30 Oct 2007'):
-                    self.position.close()
-                elif date == pd.Timestamp('Tue 11 Nov 2008'):
-                    self.sell(stop=self.data.Low,
-                              limit=324.90,  # High from 14 Nov
-                              size=200)
-
-        bt = Backtest(GOOG, S, margin=.1)
-        stats = bt.run()
-        trades = stats['_trades']
-
-        self.assertAlmostEqual(stats['Equity Peak [$]'], 46961)
-        self.assertEqual(stats['Equity Final [$]'], 0)
-        self.assertEqual(len(trades), 2)
-        assert trades[['EntryTime', 'ExitTime']].equals(
-            pd.DataFrame({'EntryTime': pd.to_datetime(['2006-11-01', '2008-11-14']),
-                          'ExitTime': pd.to_datetime(['2007-10-31', '2009-09-21'])}))
-        assert trades['PnL'].round().equals(pd.Series([23469., -34420.]))
-
-        with _tempfile() as f:
-            bt.plot(filename=f, plot_drawdown=True, smooth_equity=False)
-            # Give browser time to open before tempfile is removed
-            time.sleep(1)
-
-    def test_resample(self):
-        class S(SmaCross):
-            def init(self):
-                self.I(lambda: ['x'] * len(self.data))  # categorical indicator, GH-309
-                super().init()
-
-        bt = Backtest(GOOG, S)
-        bt.run()
-        import backtesting._plotting
-        with _tempfile() as f, \
-                patch(backtesting._plotting, '_MAX_CANDLES', 10), \
-                self.assertWarns(UserWarning):
-            bt.plot(filename=f, resample=True)
-            # Give browser time to open before tempfile is removed
-            time.sleep(1)
-
-    def test_indicator_name(self):
-        test_self = self
-
-        class S(Strategy):
-            def init(self):
-                def _SMA():
-                    return SMA(self.data.Close, 5), SMA(self.data.Close, 10)
-
-                test_self.assertRaises(TypeError, self.I, _SMA, name=42)
-                test_self.assertRaises(ValueError, self.I, _SMA, name=("SMA One", ))
-                test_self.assertRaises(
-                    ValueError, self.I, _SMA, name=("SMA One", "SMA Two", "SMA Three"))
-
-                for overlay in (True, False):
-                    self.I(SMA, self.data.Close, 5, overlay=overlay)
-                    self.I(SMA, self.data.Close, 5, name="My SMA", overlay=overlay)
-                    self.I(SMA, self.data.Close, 5, name=("My SMA", ), overlay=overlay)
-                    self.I(_SMA, overlay=overlay)
-                    self.I(_SMA, name="My SMA", overlay=overlay)
-                    self.I(_SMA, name=("SMA One", "SMA Two"), overlay=overlay)
-
-            def next(self):
-                pass
-
-        bt = Backtest(GOOG, S)
-        bt.run()
-        with _tempfile() as f:
-            bt.plot(filename=f,
-                    plot_drawdown=False, plot_equity=False, plot_pl=False, plot_volume=False,
-                    open_browser=False)
-
-    def test_indicator_color(self):
-        class S(Strategy):
-            def init(self):
-                a = self.I(SMA, self.data.Close, 5, overlay=True, color='red')
-                b = self.I(SMA, self.data.Close, 10, overlay=False, color='blue')
-                self.I(lambda: (a, b), overlay=False, color=('green', 'orange'))
-
-            def next(self):
-                pass
-
-        bt = Backtest(GOOG, S)
-        bt.run()
-        with _tempfile() as f:
-            bt.plot(filename=f,
-                    plot_drawdown=False, plot_equity=False, plot_pl=False, plot_volume=False,
-                    open_browser=False)
-
-    def test_indicator_scatter(self):
-        class S(Strategy):
-            def init(self):
-                self.I(SMA, self.data.Close, 5, overlay=True, scatter=True)
-                self.I(SMA, self.data.Close, 10, overlay=False, scatter=True)
-
-            def next(self):
-                pass
-
-        bt = Backtest(GOOG, S)
-        bt.run()
-        with _tempfile() as f:
-            bt.plot(filename=f,
-                    plot_drawdown=False, plot_equity=False, plot_pl=False, plot_volume=False,
-                    open_browser=False)
-
-
-class TestLib(TestCase):
-    def test_barssince(self):
-        self.assertEqual(barssince(np.r_[1, 0, 0]), 2)
-        self.assertEqual(barssince(np.r_[0, 0, 0]), np.inf)
-        self.assertEqual(barssince(np.r_[0, 0, 0], 0), 0)
-
-    def test_cross(self):
-        self.assertTrue(cross([0, 1], [1, 0]))
-        self.assertTrue(cross([1, 0], [0, 1]))
-        self.assertFalse(cross([1, 0], [1, 0]))
-
-    def test_crossover(self):
-        self.assertTrue(crossover([0, 1], [1, 0]))
-        self.assertTrue(crossover([0, 1], .5))
-        self.assertTrue(crossover([0, 1], pd.Series([.5, .5], index=[5, 6])))
-        self.assertFalse(crossover([1, 0], [1, 0]))
-        self.assertFalse(crossover([0], [1]))
-
-    def test_quantile(self):
-        self.assertEqual(quantile(np.r_[1, 3, 2], .5), 2)
-        self.assertEqual(quantile(np.r_[1, 3, 2]), .5)
-
-    def test_resample_apply(self):
-        res = resample_apply('D', SMA, EURUSD.Close, 10)
-        self.assertEqual(res.name, 'C[D]')
-        self.assertEqual(res.count() / res.size, .9634)
-        np.testing.assert_almost_equal(res.iloc[-48:].unique().tolist(),
-                                       [1.242643, 1.242381, 1.242275],
-                                       decimal=6)
-
-        def resets_index(*args):
-            return pd.Series(SMA(*args).values)
-
-        res2 = resample_apply('D', resets_index, EURUSD.Close, 10)
-        self.assertTrue((res.dropna() == res2.dropna()).all())
-        self.assertTrue((res.index == res2.index).all())
-
-        res3 = resample_apply('D', None, EURUSD)
-        self.assertIn('Volume', res3)
-
-        res3 = resample_apply('D', lambda df: (df.Close, df.Close), EURUSD)
-        self.assertIsInstance(res3, pd.DataFrame)
-
-    def test_plot_heatmaps(self):
-        bt = Backtest(GOOG, SmaCross)
-        stats, heatmap = bt.optimize(fast=range(2, 7, 2),
-                                     slow=range(7, 15, 2),
-                                     return_heatmap=True)
-        with _tempfile() as f:
-            for agg in ('mean',
-                        lambda x: np.percentile(x, 75)):
-                plot_heatmaps(heatmap, agg, filename=f, open_browser=False)
-
-            # Preview
-            plot_heatmaps(heatmap, filename=f)
-            time.sleep(5)
-
-    def test_random_ohlc_data(self):
-        generator = random_ohlc_data(GOOG, frac=1)
-        new_data = next(generator)
-        self.assertEqual(list(new_data.index), list(GOOG.index))
-        self.assertEqual(new_data.shape, GOOG.shape)
-        self.assertEqual(list(new_data.columns), list(GOOG.columns))
-
-    def test_compute_stats(self):
-        stats = Backtest(GOOG, SmaCross).run()
-        only_long_trades = stats._trades[stats._trades.Size > 0]
-        long_stats = compute_stats(stats=stats, trades=only_long_trades,
-                                   data=GOOG, risk_free_rate=.02)
-        self.assertNotEqual(list(stats._equity_curve.Equity),
-                            list(long_stats._equity_curve.Equity))
-        self.assertNotEqual(stats['Sharpe Ratio'], long_stats['Sharpe Ratio'])
-        self.assertEqual(long_stats['# Trades'], len(only_long_trades))
-        self.assertEqual(stats._strategy, long_stats._strategy)
-        assert_frame_equal(long_stats._trades, only_long_trades)
-
-    def test_SignalStrategy(self):
-        class S(SignalStrategy):
-            def init(self):
-                sma = self.data.Close.s.rolling(10).mean()
-                self.set_signal(self.data.Close > sma,
-                                self.data.Close < sma)
-
-        stats = Backtest(GOOG, S).run()
-        self.assertIn(stats['# Trades'], (1179, 1180))  # varies on different archs?
-
-    def test_TrailingStrategy(self):
-        class S(TrailingStrategy):
-            def init(self):
-                super().init()
-                self.set_atr_periods(40)
-                self.set_trailing_pct(.1)
-                self.set_trailing_sl(3)
-                self.sma = self.I(lambda: self.data.Close.s.rolling(10).mean())
-
-            def next(self):
-                super().next()
-                if not self.position and self.data.Close > self.sma:
-                    self.buy()
-
-        stats = Backtest(GOOG, S).run()
-        self.assertEqual(stats['# Trades'], 56)
-
-    def test_FractionalBacktest(self):
-        ubtc_bt = FractionalBacktest(BTCUSD['2015':], SmaCross, fractional_unit=1 / 1e6, cash=100)
-        stats = ubtc_bt.run(fast=2, slow=3)
-        self.assertEqual(stats['# Trades'], 41)
-        trades = stats['_trades']
-        self.assertEqual(len(trades), 41)
-        trade = trades.iloc[0]
-        self.assertAlmostEqual(trade['EntryPrice'], 236.69)
-        self.assertAlmostEqual(stats['_strategy']._indicators[0][trade['EntryBar']], 234.14)
-
-    def test_MultiBacktest(self):
-        import backtesting
-        assert callable(getattr(backtesting, 'Pool', None)), backtesting.__dict__
-        for start_method in mp.get_all_start_methods():
-            with self.subTest(start_method=start_method), \
-                    patch(backtesting, 'Pool', mp.get_context(start_method).Pool):
-                start_time = time.monotonic()
-                btm = MultiBacktest([GOOG, EURUSD, BTCUSD], SmaCross, cash=100_000)
-                res = btm.run(fast=2)
-                self.assertIsInstance(res, pd.DataFrame)
-                self.assertEqual(res.columns.tolist(), [0, 1, 2])
-                heatmap = btm.optimize(fast=[2, 4], slow=[10, 20])
-                self.assertIsInstance(heatmap, pd.DataFrame)
-                self.assertEqual(heatmap.columns.tolist(), [0, 1, 2])
-                print(start_method, time.monotonic() - start_time)
-        plot_heatmaps(heatmap.mean(axis=1), open_browser=False)
-
-
-class TestUtil(TestCase):
-    def test_as_str(self):
-        def func():
-            pass
-
-        class Class:
-            def __call__(self):
-                pass
-
-        self.assertEqual(_as_str('4'), '4')
-        self.assertEqual(_as_str(4), '4')
-        self.assertEqual(_as_str(_Indicator([1, 2], name='x')), 'x')
-        self.assertEqual(_as_str(func), 'func')
-        self.assertEqual(_as_str(Class), 'Class')
-        self.assertEqual(_as_str(Class()), 'Class')
-        self.assertEqual(_as_str(pd.Series([1, 2], name='x')), 'x')
-        self.assertEqual(_as_str(pd.DataFrame()), 'df')
-        self.assertEqual(_as_str(lambda x: x), 'λ')
-        for s in ('Open', 'High', 'Low', 'Close', 'Volume'):
-            self.assertEqual(_as_str(_Array([1], name=s)), s[0])
-
-    def test_patch(self):
-        class Object:
-            pass
-        o = Object()
-        o.attr = False
-        with patch(o, 'attr', True):
-            self.assertTrue(o.attr)
-        self.assertFalse(o.attr)
-
-    def test_pandas_accessors(self):
-        class S(Strategy):
-            def init(self):
-                close, index = self.data.Close, self.data.index
-                assert close.s.equals(pd.Series(close, index=index))
-                assert self.data.df['Close'].equals(pd.Series(close, index=index))
-                self.data.df['new_key'] = 2 * close
-
-            def next(self):
-                close, index = self.data.Close, self.data.index
-                assert close.s.equals(pd.Series(close, index=index))
-                assert self.data.df['Close'].equals(pd.Series(close, index=index))
-                assert self.data.df['new_key'].equals(pd.Series(self.data.new_key, index=index))
-
-        Backtest(GOOG.iloc[:20], S).run()
-
-    def test_indicators_picklable(self):
-        bt = Backtest(SHORT_DATA, SmaCross)
-        with ProcessPoolExecutor() as executor:
-            stats = executor.submit(Backtest.run, bt).result()
-        assert stats._strategy._indicators[0]._opts, '._opts and .name were not unpickled'
-        bt.plot(results=stats, resample='2d', open_browser=False)
-
-
-class TestDocs(TestCase):
-    DOCS_DIR = os.path.join(os.path.dirname(__file__), '..', '..', 'doc')
-
-    @unittest.skipUnless(os.path.isdir(DOCS_DIR), "docs dir doesn't exist")
-    def test_examples(self):
-        examples = glob(os.path.join(self.DOCS_DIR, 'examples', '*.py'))
-        self.assertGreaterEqual(len(examples), 4)
-        with chdir(gettempdir()):
-            for file in examples:
-                with self.subTest(example=os.path.basename(file)):
-                    run_path(file)
-
-    def test_backtest_run_docstring_contains_stats_keys(self):
-        stats = Backtest(SHORT_DATA, SmaCross).run()
-        for key in stats.index:
-            self.assertIn(key, Backtest.run.__doc__)
-
-    def test_readme_contains_stats_keys(self):
-        with open(os.path.join(os.path.dirname(__file__),
-                               '..', '..', 'README.md')) as f:
-            readme = f.read()
-        stats = Backtest(SHORT_DATA, SmaCross).run()
-        for key in stats.index:
-            self.assertIn(key, readme)
-
-
-class TestRegressions(TestCase):
-    def test_gh_521(self):
-        class S(_S):
-            def next(self):
-                if self.data.Close[-1] == 100:
-                    self.buy(size=1, sl=90)
-
-        arr = np.r_[100, 100, 100, 50, 50]
-        df = pd.DataFrame({'Open': arr, 'High': arr, 'Low': arr, 'Close': arr})
-        with self.assertWarnsRegex(UserWarning, 'index is not datetime'):
-            bt = Backtest(df, S, cash=100, trade_on_close=True)
-        self.assertEqual(bt.run()._trades['ExitPrice'][0], 50)
-
-    def test_stats_annualized(self):
-        stats = Backtest(GOOG.resample('W').agg(OHLCV_AGG), SmaCross).run()
-        self.assertFalse(np.isnan(stats['Return (Ann.) [%]']))
-        self.assertEqual(round(stats['Return (Ann.) [%]']), -3)
-
-    def test_cancel_orders(self):
-        class S(_S):
-            def next(self):
-                self.buy(sl=1, tp=1e3)
-                if self.position:
-                    self.position.close()
-                    for order in self.orders:
-                        order.cancel()
-
-        Backtest(SHORT_DATA, S).run()
-
-    def test_trade_on_close_closes_trades_on_close(self):
-        def coro(strat):
-            yield strat.buy(size=1, sl=90) and strat.buy(size=1, sl=80)
-            assert len(strat.trades) == 2
-            yield strat.trades[0].close()
-            yield
-
-        arr = np.r_[100, 101, 102, 50, 51]
-        df = pd.DataFrame({
-            'Open': arr - 10,
-            'Close': arr, 'High': arr, 'Low': arr})
-        with self.assertWarnsRegex(UserWarning, 'index is not datetime'):
-            trades = TestStrategy._Backtest(coro, df, cash=250, trade_on_close=True).run()._trades
-            # trades = Backtest(df, S, cash=250, trade_on_close=True).run()._trades
-            self.assertEqual(trades['EntryBar'][0], 1)
-            self.assertEqual(trades['ExitBar'][0], 2)
-            self.assertEqual(trades['EntryPrice'][0], 101)
-            self.assertEqual(trades['ExitPrice'][0], 102)
-            self.assertEqual(trades['EntryBar'][1], 1)
-            self.assertEqual(trades['ExitBar'][1], 3)
-            self.assertEqual(trades['EntryPrice'][1], 101)
-            self.assertEqual(trades['ExitPrice'][1], 40)
-
-        with self.assertWarnsRegex(UserWarning, 'index is not datetime'):
-            trades = TestStrategy._Backtest(coro, df, cash=250, trade_on_close=False).run()._trades
-            # trades = Backtest(df, S, cash=250, trade_on_close=False).run()._trades
-            self.assertEqual(trades['EntryBar'][0], 2)
-            self.assertEqual(trades['ExitBar'][0], 3)
-            self.assertEqual(trades['EntryPrice'][0], 92)
-            self.assertEqual(trades['ExitPrice'][0], 40)
-            self.assertEqual(trades['EntryBar'][1], 2)
-            self.assertEqual(trades['ExitBar'][1], 3)
-            self.assertEqual(trades['EntryPrice'][1], 92)
-            self.assertEqual(trades['ExitPrice'][1], 40)
-
-    def test_trades_dates_match_prices(self):
-        bt = Backtest(EURUSD, SmaCross, trade_on_close=True)
-        trades = bt.run()._trades
-        self.assertEqual(EURUSD.Close[trades['ExitTime']].tolist(),
-                         trades['ExitPrice'].tolist())
-
-    def test_sl_always_before_tp(self):
-        class S(_S):
-            def next(self):
-                i = len(self.data.index)
-                if i == 4:
-                    self.buy()
-                if i == 5:
-                    t = self.trades[0]
-                    t.sl = 105
-                    t.tp = 107.9
-
-        trades = Backtest(SHORT_DATA, S).run()._trades
-        self.assertEqual(trades['ExitPrice'].iloc[0], 104.95)
-
-    def test_stop_entry_and_tp_in_same_bar(self):
-        class S(_S):
-            def next(self):
-                i = len(self.data.index)
-                if i == 3:
-                    self.sell(stop=108, tp=105, sl=113)
-
-        trades = Backtest(SHORT_DATA, S).run()._trades
-        self.assertEqual(trades['ExitBar'].iloc[0], 3)
-        self.assertEqual(trades['ExitPrice'].iloc[0], 105)
-
-    def test_optimize_datetime_index_with_timezone(self):
-        data: pd.DataFrame = GOOG.iloc[:100]
-        data.index = data.index.tz_localize('Asia/Kolkata')
-        res = Backtest(data, SmaCross).optimize(fast=range(2, 3), slow=range(4, 5))
-        self.assertGreater(res['# Trades'], 0)
-
-    def test_sl_tp_values_in_trades_df(self):
-        class S(_S):
-            def next(self):
-                self.next = lambda: None
-                self.buy(size=1, tp=111)
-                self.buy(size=1, sl=99)
-
-        trades = Backtest(SHORT_DATA, S).run()._trades
-        self.assertEqual(trades['SL'].fillna(0).tolist(), [0, 99])
-        self.assertEqual(trades['TP'].fillna(0).tolist(), [111, 0])