Example #1
0
def test_run_period():
    target = mock.MagicMock()

    dts = pd.date_range('2010-01-01', periods=35)
    data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)

    algo = algos.RunPeriod()

    # adds the initial day
    backtest = bt.Backtest(
        bt.Strategy('', [algo]),
        data
    )
    target.data = backtest.data
    dts = target.data.index

    target.now = None
    assert not algo(target)

    # run on first date
    target.now = dts[0]
    assert not algo(target)

    # run on first supplied date
    target.now = dts[1]
    assert algo(target)

    # run on last date
    target.now = dts[len(dts) - 1]
    assert not algo(target)

    algo = algos.RunPeriod(
        run_on_first_date=False,
        run_on_end_of_period=True,
        run_on_last_date=True
    )

    # adds the initial day
    backtest = bt.Backtest(
        bt.Strategy('', [algo]),
        data
    )
    target.data = backtest.data
    dts = target.data.index

    # run on first date
    target.now = dts[0]
    assert not algo(target)

    # first supplied date
    target.now = dts[1]
    assert not algo(target)

    # run on last date
    target.now = dts[len(dts) - 1]
    assert algo(target)

    # date not in index
    target.now = datetime(2009, 2, 15)
    assert not algo(target)
def abovema_trainandtest(tickers,
                         sma=50,
                         start_train='06-01-2015',
                         end_train='05-31-2017',
                         start_test='06-01-2017',
                         end_test='05-31-2019',
                         name1='above_sma50_train',
                         name2='above_sma50_test'):
    #training test
    data_train = bt.get(tickers, start=start_train, end=end_train)
    sma_train = data_train.rolling(sma).mean()
    signal = data_train > sma_train
    s = bt.Strategy(name1, [
        bt.algos.SelectWhere(signal),
        bt.algos.WeighEqually(),
        bt.algos.Rebalance()
    ])

    #testing set
    data_test = bt.get(tickers, start=start_test, end=end_test)
    sma_test = data_test.rolling(sma).mean()
    signal2 = data_test > sma_test
    s2 = bt.Strategy(name2, [
        bt.algos.SelectWhere(signal2),
        bt.algos.WeighEqually(),
        bt.algos.Rebalance()
    ])
    return (bt.Backtest(s, data_train), bt.Backtest(s2, data_test))
Example #3
0
def comb_strat_settings_from_ml_prob(test_prob_dict, cut_num_dict, bt_fromdate, df_prc, shift_flag=False, comb_only=False, \
                                    trade_cost=0., ls_target_weight=0.5):
    weight_sig_data_dict = {}
    strats = []

    fsets = list(test_prob_dict.keys())

    weight_divisor = 1. / len(fsets)
    allidx = list(test_prob_dict[fsets[0]].index)
    codesToLoad = list(test_prob_dict[fsets[0]].columns)
    comb_sig = pd.DataFrame(0., index=allidx,
                            columns=codesToLoad).loc[bt_fromdate:]

    for fset in fsets:
        print(fset)
        sig_data = qcut_signal(test_prob_dict[fset], cut_num_dict[fset],
                               test_prob_dict[fset].index[0])
        sig_data = sig_data.pivot(index='tdate',
                                  columns='code',
                                  values='value')
        sig_data.index = pd.to_datetime(sig_data.index)
        long_sig = cut_num_dict[fset] * 1. - 1.
        short_sig = 0.

        # do below if you want to check lagging effect
        if shift_flag:
            sig_data = sig_data.reindex(df_prc.index).shift(1).dropna(
                axis=0, how='all')

        weight_sig_data_dict[fset] = sig_data.copy().apply(
            sig_to_weight,
            axis=1,
            args=(long_sig, short_sig, ls_target_weight)).loc[bt_fromdate:]

        if not comb_only:
            s = bt.Strategy(fset, [
                bt.algos.RunOnDate(*weight_sig_data_dict[fset].index),
                bt.algos.WeighTarget(weight_sig_data_dict[fset]),
                bt.algos.Rebalance()
            ])
            strats.append(bt.Backtest(s, df_prc.loc[weight_sig_data_dict[fset].index[0]:].fillna(method='ffill'), initial_capital=10.**9, \
                                      commissions=lambda q, p: abs(q*p)*trade_cost))

        tmp_sig_data = weight_sig_data_dict[fset].loc[
            bt_fromdate:] * weight_divisor
        comb_sig = comb_sig.add(tmp_sig_data.fillna(0.), fill_value=0.)

    weight_sig_data_dict[
        'comb'] = comb_sig  #[df_prc.loc[comb_sig.index, comb_sig.columns].notnull()]
    weight_sig_data_dict['comb'].fillna(0, inplace=True)

    s = bt.Strategy('comb', [
        bt.algos.RunOnDate(*weight_sig_data_dict['comb'].index),
        bt.algos.WeighTarget(weight_sig_data_dict['comb']),
        bt.algos.Rebalance()
    ])
    strats.append(bt.Backtest(s, df_prc.loc[weight_sig_data_dict['comb'].index[0]:].fillna(method='ffill').fillna(0), initial_capital=10.**9, \
                              commissions=lambda q, p: abs(q*p)*trade_cost))

    return strats, weight_sig_data_dict
Example #4
0
def test_run_yearly():
    dts = pd.date_range('2010-01-01', periods=367)
    data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)

    target = mock.MagicMock()
    target.data = data

    algo = algos.RunYearly()
    # adds the initial day
    backtest = bt.Backtest(bt.Strategy('', [algo]), data)
    target.data = backtest.data

    # end of year
    target.now = dts[364]
    assert not algo(target)

    # new year
    target.now = dts[365]
    assert algo(target)

    algo = algos.RunYearly(run_on_first_date=False,
                           run_on_end_of_period=True,
                           run_on_last_date=True)
    # adds the initial day
    backtest = bt.Backtest(bt.Strategy('', [algo]), data)
    target.data = backtest.data

    # end of year
    target.now = dts[364]
    assert algo(target)

    # new year
    target.now = dts[365]
    assert not algo(target)
Example #5
0
def test_run_quarterly():
    dts = pd.date_range('2010-01-01', periods=367)
    data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)

    target = mock.MagicMock()
    target.data = data

    algo = algos.RunQuarterly()
    # adds the initial day
    backtest = bt.Backtest(
        bt.Strategy('', [algo]),
        data
    )
    target.data = backtest.data

    # end of quarter
    target.now = dts[89]
    assert not algo(target)

    # new quarter
    target.now = dts[90]
    assert algo(target)

    algo = algos.RunQuarterly(
        run_on_first_date=False,
        run_on_end_of_period=True,
        run_on_last_date=True
    )
    # adds the initial day
    backtest = bt.Backtest(
        bt.Strategy('', [algo]),
        data
    )
    target.data = backtest.data

    # end of quarter
    target.now = dts[89]
    assert algo(target)

    # new quarter
    target.now = dts[90]
    assert not algo(target)

    dts = pd.DatetimeIndex([datetime(2016, 1, 3), datetime(2017, 1, 8), datetime(2018, 1, 7)])
    data = pd.DataFrame(index=dts, columns=['c1', 'c2'], data=100)
    # adds the initial day
    backtest = bt.Backtest(
        bt.Strategy('', [algo]),
        data
    )
    target.data = backtest.data

    # check next year
    target.now = dts[1]
    assert algo(target)
Example #6
0
def buy_and_hold(ticker: str, start: Union[str, datetime], name: str):
    """
    Generates a backtest object for the given ticker
    Parameters
    ----------
    ticker: str
        Stock to test
    start: Union[str, datetime]
        Backtest start date.  Can be either string or datetime
    name:
        Name of the backtest (for labeling purposes)

    Returns
    -------
    bt.Backtest object for buy and hold strategy
    """
    prices = bt.get(ticker, start=start)
    bt_strategy = bt.Strategy(
        name,
        [
            bt.algos.RunOnce(),
            bt.algos.SelectAll(),
            bt.algos.WeighEqually(),
            bt.algos.Rebalance(),
        ],
    )
    return bt.Backtest(bt_strategy, prices)
Example #7
0
def SMA_cross(data):
    sma50 = data.rolling(50).mean()
    sma200 = data.rolling(200).mean()
    
    tw = sma200.copy()
    tw[sma50 > sma200] = 1.0
    tw[sma50 <= sma200] = -1.0
    
    tw[sma200.isnull()] = 0.0
    
    tmp = bt.merge(tw, data, sma50, sma200)
    tmp.columns = ["tw", "price", "sma50", "sma200"]
    # tmp.columns = ['tw', 'price', 'sma50', 'sma200']
    ax = tmp.plot(figsize = (15, 5), secondary_y = ["tw"])
    plt.savefig("smacross.png")
    
    ma_cross = bt.Strategy("ma_cross",
    [WeighTarget(tw),
     bt.algos.Rebalance()
    ])
    t = bt.Backtest(ma_cross, data)
    res = bt.run(t)
    res.display()
    
    res.plot()
    plt.savefig("smacross_res")
Example #8
0
def run():
    df_price, df_thred = transfer()
    signal = df_thred > 0.7
    for col in range(signal.shape[1]):
        eng = 0
        for i in range(signal.shape[0]):
            if signal.iloc[i, col]:
                eng = 4
            elif eng > 0:
                signal.iloc[i, col] = True
                eng -= 1
            else:
                pass


    # first we create the Strategy
    s = bt.Strategy('above50sma', [SelectWhere(signal),
                                   bt.algos.WeighEqually(),
                                   bt.algos.Rebalance()])
    # now we create the Backtest
    t = bt.Backtest(s, df_price, initial_capital=9000)

    # and let's run it!
    res = bt.run(t)
    res.plot('d')
    ser = res._get_series('d').rebase()
    plot = ser.plot()
    fig = plot.get_figure()
    fig.savefig(os.path.join(root, "report", "backtest.png"))
Example #9
0
def test_turnover():
    dts = pd.date_range('2010-01-01', periods=5)
    data = pd.DataFrame(index=dts, columns=['a', 'b'], data=100)

    data['a'][dts[1]] = 105
    data['b'][dts[1]] = 95

    data['a'][dts[2]] = 110
    data['b'][dts[2]] = 90

    data['a'][dts[3]] = 115
    data['b'][dts[3]] = 85

    s = bt.Strategy('s', [bt.algos.SelectAll(),
                          bt.algos.WeighEqually(),
                          bt.algos.Rebalance()])

    t = bt.Backtest(s, data, commissions=lambda x, y: 0, progress_bar=False)
    res = bt.run(t)

    t = res.backtests['s']

    # these numbers were (tediously) calculated in excel
    assert np.allclose(t.turnover[dts[0]], 0. / 1000000)
    assert np.allclose(t.turnover[dts[1]], 24985. / 1000000)
    assert np.allclose(t.turnover[dts[2]], 24970. / 997490)
    assert np.allclose(t.turnover[dts[3]], 25160. / 992455)
    assert np.allclose(t.turnover[dts[4]], 76100. / 1015285)
def main():
    '''entry point'''

    # Get Test Data with all fields
    symbol_list = ['BTC', 'ETH']
    history = coinrepo.get_coinhistory(symbol_list)
    history = history.set_index('Date')

    # Pivot to have only price as timeseries
    pricehistory = history.pivot(columns='Symbol')['Price']

    # Create the strategy
    s = bt.Strategy('s1', [
        bt.algos.RunMonthly(),
        bt.algos.SelectAll(),
        bt.algos.WeighEqually(),
        bt.algos.Rebalance()
    ])

    # create a backtest and run it
    test = bt.Backtest(s, pricehistory)
    res = bt.run(test)

    res.display()

    # Save figures
    plot = pricehistory.plot(figsize=(15, 5))
    fig = plot.get_figure()
    fig.savefig("price.png")
    plot1 = res.plot_weights(figsize=(15, 5))
    fig1 = plot1.get_figure()
    fig1.savefig("bt_rest.png")
Example #11
0
def SMA(data):
    sma = data.rolling(50).mean()
    plot = bt.merge(data, sma).plot(figsize=(15, 5))
    plt.savefig("sma.png")
    
    # 建立策略
    s = bt.Strategy("above50sma",
        [SelectWhere(data > sma),
         bt.algos.WeighEqually(),
         bt.algos.Rebalance()
        ])
    # 建立回测
    t = bt.Backtest(s, data)
    # 执行回测
    res = bt.run(t)
    # 输出结果
    res.display()
    res.plot()
    plt.savefig("sma_result.png")
    
    # 多种策略的测试
    sma10 = above_sma(data, sma_per = 10, name = "sma10")
    sma20 = above_sma(data, sma_per = 10, name = "sma20")
    sma40 = above_sma(data, sma_per = 10, name = "sma40")
    base_line = baseTest(data)
    
    # 一起运行回测
    res2 = bt.run(sma10, sma20, sma40, base_line)
    # 输出结果
    res2.display()
    res2.plot()
    plt.savefig("sma.png")
    plt.savefig("multi_sma_result.png")
Example #12
0
def run():
    """ Run the code that illustrates the pairs trading strategy """
    data = make_data()

    # Define the "entry" strategy of the trade. In this case, we give each asset unit weight and trade it
    trade_entry = bt.AlgoStack( bt.algos.RunOnce(), WeighPair(1.), bt.algos.Rebalance() )

    # Define the "exit" strategy of the trade. Here we exit when we cross either an upper/lower
    # threshold on the price of the strategy, or hold it for a fixed length of time.
    trade_exit = bt.AlgoStack(
        bt.algos.Or( [PriceCompare( 96., is_greater=False ),
                    PriceCompare( 104., is_greater=True),
                    bt.algos.RunAfterDays( 5 ) ] ),
        ClosePositions()
        )
    # Combine the entry, exit and debug algos for each trade
    trade_algos = [ bt.algos.Or( [ trade_entry, trade_exit, DebugTradeLevel() ] )]

    # Define the strategy for the master portfolio.
    strategy_algos = [
        PairsSignal( threshold = 4., indicator_name = 'my_indicator' ),
        SetupPairsTrades( trade_algos ),
        SizePairsTrades( pct_of_capital = 0.2 ),
        DebugPortfolioLevel()
    ]

    # Build and run the strategy
    strategy = bt.Strategy( 'PairsStrategy', strategy_algos )
    test = bt.Backtest( strategy, data, additional_data={'my_indicator':data} )
    out = bt.run( test )
    print(out.stats)
    return out
Example #13
0
def main():
    days = 5
    change = .02
    with open('ticker_sectors.data', 'rb') as f:
        tickerSectors = pickle.load(f)
    companies = tickerSectors[0]
    companyList = 'aos'
    for i in range(1, 10):
        companyList = companyList + ',' + companies[i].lower()
    print(companyList)
    data = bt.get(companyList, start='2014-01-01')
    print(data)
    weights = getPredictions(days, change)
    print(weights)
    s = bt.Strategy('s1', [
        bt.algos.RunWeekly(),
        bt.algos.SelectAll(),
        bt.algos.WeighTarget(weights),
        bt.algos.Rebalance()
    ])
    test = bt.Backtest(s, data)
    res = bt.run(test)
    res.plot()
    res.display()
    print("GOOD")
Example #14
0
def test_30_min_data():
    names = ['foo']
    dates = pd.date_range(start='2017-01-01', end='2017-12-31', freq='30min')
    n = len(dates)
    rdf = pd.DataFrame(np.zeros((n, len(names))), index=dates, columns=names)

    np.random.seed(1)
    rdf[names[0]] = np.random.normal(loc=0.1 / n,
                                     scale=0.2 / np.sqrt(n),
                                     size=n)

    pdf = 100 * np.cumprod(1 + rdf)

    sma50 = pdf.rolling(50).mean()
    sma200 = pdf.rolling(200).mean()

    tw = sma200.copy()
    tw[sma50 > sma200] = 1.0
    tw[sma50 <= sma200] = -1.0
    tw[sma200.isnull()] = 0.0

    ma_cross = bt.Strategy('ma_cross',
                           [bt.algos.WeighTarget(tw),
                            bt.algos.Rebalance()])
    t = bt.Backtest(ma_cross, pdf, progress_bar=False)
    res = bt.run(t)

    wait = 1
Example #15
0
def test_backtest_copies_strategy():
    s = mock.MagicMock()
    data = pd.DataFrame(index=pd.date_range('2010-01-01', periods=5),
                        columns=['a', 'b'], data=100)

    actual = bt.Backtest(s, data, progress_bar=False)

    assert id(s) != id(actual.strategy)
Example #16
0
def above_sma(data, sma_per = 50, name = "above_sma"):
    sma = data.rolling(sma_per).mean()
    s = bt.Strategy(name,
    [bt.algos.SelectWhere(data > sma),
     bt.algos.WeighEqually(),
     bt.algos.Rebalance()
    ])
    return bt.Backtest(s, data)
Example #17
0
def baseTest(data):
    s = bt.Strategy("base_line",
    [bt.algos.RunOnce(),
     bt.algos.SelectAll(),
     bt.algos.WeighEqually(),
     bt.algos.Rebalance()
    ])
    return bt.Backtest(s, data)
Example #18
0
def test_backtest_auto_name():
    s = mock.MagicMock()
    s.name = 's'
    data = pd.DataFrame(index=pd.date_range('2010-01-01', periods=5),
                        columns=['a', 'b'], data=100)

    actual = bt.Backtest(s, data, progress_bar=False)

    assert actual.name == 's'
Example #19
0
def test_Results_helper_functions():

    names = ['foo', 'bar']
    dates = pd.date_range(start='2017-01-01', end='2017-12-31', freq=pd.tseries.offsets.BDay())
    n = len(dates)
    rdf = pd.DataFrame(
        np.zeros((n, len(names))),
        index=dates,
        columns=names
    )

    np.random.seed(1)
    rdf[names[0]] = np.random.normal(loc=0.1 / n, scale=0.2 / np.sqrt(n), size=n)
    rdf[names[1]] = np.random.normal(loc=0.04 / n, scale=0.05 / np.sqrt(n), size=n)

    pdf = 100 * np.cumprod(1 + rdf)

    # algo to fire on the beginning of every month and to run on the first date
    runDailyAlgo = bt.algos.RunDaily(
        run_on_first_date=True
    )

    # algo to set the weights
    #  it will only run when runMonthlyAlgo returns true
    #  which only happens on the first of every month
    weights = pd.Series([0.6, 0.4], index=rdf.columns)
    weighSpecifiedAlgo = bt.algos.WeighSpecified(**weights)

    # algo to rebalance the current weights to weights set by weighSpecified
    #  will only run when weighSpecifiedAlgo returns true
    #  which happens every time it runs
    rebalAlgo = bt.algos.Rebalance()

    # a strategy that rebalances monthly to specified weights
    strat = bt.Strategy('static',
        [
            runDailyAlgo,
            weighSpecifiedAlgo,
            rebalAlgo
        ]
    )

    backtest = bt.Backtest(
        strat,
        pdf,
        integer_positions=False,
        progress_bar=False
    )

    res = bt.run(backtest)

    assert(type(res.get_security_weights()) is pd.DataFrame)

    assert (type(res.get_transactions()) is pd.DataFrame)

    assert (type(res.get_weights()) is pd.DataFrame)
Example #20
0
def make_target_weight_backtest(stock_data, signal, name, progress_bar=True):
    s = bt.Strategy(name, [
        bt.algos.bt.algos.RunOnDate(*signal.index),
        bt.algos.bt.algos.WeighTarget(signal),
        bt.algos.Rebalance()
    ])
    return bt.Backtest(s,
                       stock_data,
                       initial_capital=10.**9,
                       progress_bar=progress_bar)
Example #21
0
def original_backtest(data, name='original_backtest'):
    s = bt.Strategy(name, [
        bt.algos.RunWeekly(),
        bt.algos.SelectAll(),
        bt.algos.SelectMomentum(n=1, lookback=pd.DateOffset(days=1)),
        bt.algos.WeighEqually(),
        bt.algos.Rebalance()
    ])

    return bt.Backtest(s, data)
Example #22
0
def test_backtest_dates_set():
    s = mock.MagicMock()
    data = pd.DataFrame(index=pd.date_range('2010-01-01', periods=5),
                        columns=['a', 'b'], data=100)

    actual = bt.Backtest(s, data, progress_bar=False)

    assert len(actual.dates) == len(data.index)
    assert actual.dates[0] == data.index[0]
    assert actual.dates[-1] == data.index[-1]
Example #23
0
def run_backtest_from_positions(predictions_df1, predictions_df2, predictions_df3):
	data = pd.read_excel(r'data.xlsx', index_col = 0)	
	###ML SOLUTION###
	#Expand positions_df to daily frequency
	positions_df1 = pd.DataFrame(index = data.index)
	positions_df1 = pd.merge(positions_df1, predictions_df1, how = 'left', left_index = True, right_index = True)
	positions_df1.fillna(method = 'ffill', inplace = True)
	positions_df1.dropna(inplace=True)
	positions_df1 = positions_df1.divide(((positions_df1.abs()).sum(axis=1)), axis = 'index')
	#Match starting date on data_df
	data1 = data.loc[data.index.isin(positions_df1.index),:].copy()
	#Create strategy object
	s1 = bt.Strategy('ML Solution', [bt.algos.WeighTarget(positions_df1), bt.algos.Rebalance()])
	t1 = bt.Backtest(s1, data1)

	###BASELINE NAIVE###
	positions_df2 = pd.DataFrame(index = data.index)
	positions_df2 = pd.merge(positions_df2, predictions_df2, how = 'left', left_index = True, right_index = True)
	positions_df2.fillna(method = 'ffill', inplace = True)
	positions_df2.dropna(inplace=True)
	positions_df2 = positions_df2.divide(((positions_df2.abs()).sum(axis=1)), axis = 'index')
	#Match starting date on data_df
	data2 = data.loc[data.index.isin(positions_df2.index),:].copy()
	#Create strategy object
	s2 = bt.Strategy('Baseline - Naive', [bt.algos.WeighTarget(positions_df2), bt.algos.Rebalance()])
	t2 = bt.Backtest(s2, data2)

	###BASELINE QUADRANT###
	positions_df3 = pd.DataFrame(index = data.index)
	positions_df3 = pd.merge(positions_df3, predictions_df3, how = 'left', left_index = True, right_index = True)
	positions_df3.fillna(method = 'ffill', inplace = True)
	positions_df3.dropna(inplace=True)
	positions_df3 = positions_df3.divide(((positions_df3.abs()).sum(axis=1)), axis = 'index')
	#Match starting date on data_df
	data3 = data.loc[data.index.isin(positions_df3.index),:].copy()
	#Create strategy object
	s3 = bt.Strategy('Baseline - Quadrant', [bt.algos.WeighTarget(positions_df3), bt.algos.Rebalance()])
	t3 = bt.Backtest(s3, data3)

	#Run backtest
	res = bt.run(t1, t2, t3)

	return res
Example #24
0
def strat_settings_from_ml_prob(s_name, test_prob, cut_num, bt_fromdate, df_prc, shift_flag=False, ls_only=False, \
                                trade_cost=0., target_weight=1.0, ls_target_weight=0.5):

    sig_data = qcut_signal(test_prob, cut_num, test_prob.index[0])
    sig_data = sig_data.pivot(index='tdate', columns='code', values='value')
    sig_data.index = pd.to_datetime(sig_data.index)

    long_sig = cut_num * 1. - 1.
    short_sig = 0.

    # do below if you want to check lagging effect
    if shift_flag:
        sig_data = sig_data.reindex(df_prc.index).shift(1).dropna(axis=0,
                                                                  how='all')

    strats = []

    if not ls_only:
        for signal in range(0, int(max(long_sig, short_sig)) + 1):
            weight_sig_data = sig_data.copy().apply(
                long_only_sig_to_weight, axis=1,
                args=(signal, target_weight)).loc[bt_fromdate:]
            s = bt.Strategy(s_name + '_' + str(signal), [
                bt.algos.RunOnDate(*weight_sig_data.index),
                bt.algos.WeighTarget(weight_sig_data),
                bt.algos.Rebalance()
            ])
            strats.append(bt.Backtest(s, df_prc.loc[weight_sig_data.index[0]:].fillna(method='ffill'), initial_capital=10.**9, \
                                  commissions=lambda q, p: abs(q*p)*trade_cost))

    weight_sig_data = sig_data.copy().apply(
        sig_to_weight, axis=1,
        args=(long_sig, short_sig, ls_target_weight)).loc[bt_fromdate:]
    s = bt.Strategy(s_name + '_ls', [
        bt.algos.RunOnDate(*weight_sig_data.index),
        bt.algos.WeighTarget(weight_sig_data),
        bt.algos.Rebalance()
    ])
    strats.append(bt.Backtest(s, df_prc.loc[weight_sig_data.index[0]:].fillna(method='ffill'), initial_capital=10.**9, \
                              commissions=lambda q, p: abs(q*p)*trade_cost))

    return strats, weight_sig_data
Example #25
0
def test_initial_capital_set():
    s = mock.MagicMock()
    data = pd.DataFrame(index=pd.date_range('2010-01-01', periods=5),
                        columns=['a', 'b'], data=100)

    actual = bt.Backtest(s, data, initial_capital=302, progress_bar=False)
    actual.run()

    s = actual.strategy

    s.adjust.assert_called_with(302)
Example #26
0
def make_backtest_by_signal(stock_data, signal, name, progress_bar=False):
    s = bt.Strategy(name, [
        bt.algos.bt.algos.RunOnDate(*signal.index),
        bt.algos.bt.algos.SelectWhere(signal),
        bt.algos.WeighEqually(),
        bt.algos.Rebalance()
    ])
    return bt.Backtest(s,
                       stock_data,
                       initial_capital=10.**9,
                       progress_bar=progress_bar)
Example #27
0
 def benchmark_cacu(benchmark, name='bench_bitcoin'):
     s = bt.Strategy(name, [
         bt.algos.RunOnce(),
         bt.algos.SelectAll(),
         bt.algos.WeighEqually(),
         bt.algos.Rebalance()
     ])
     data = pd.DataFrame(self.data[benchmark])
     print(data.head())
     self.benchmark = benchmark
     return bt.Backtest(s, data)
Example #28
0
def buy_and_hold(ticker, name, start='2020-2-1', end='2020-11-1'):
    # Get the data
    price_data = bt.get(ticker, start=start, end=end)
    # Define the benchmark strategy
    bt_strategy = bt.Strategy(name, [
        bt.algos.RunOnce(),
        bt.algos.SelectAll(),
        bt.algos.WeighEqually(),
        bt.algos.Rebalance()
    ])
    # Return the backtest
    return bt.Backtest(bt_strategy, price_data)
Example #29
0
def signal_strategy(ticker, period, name, start='2020-2-1', end='2020-11-1'):
    # Get the data and calculate SMA
    price_data = bt.get(ticker, start=start, end=end)
    sma = price_data.rolling(period).mean()
    # Define the signal-based trategy
    bt_strategy = bt.Strategy(name, [
        bt.algos.SelectWhere(price_data > sma),
        bt.algos.WeighEqually(),
        bt.algos.Rebalance()
    ])
    # Return the backtest
    return bt.Backtest(bt_strategy, price_data)
Example #30
0
def long_only(df, name='long_only'):

    df_data = df.copy()

    s = bt.Strategy(name, [
        bt.algos.RunOnce(),
        bt.algos.SelectAll(),
        bt.algos.WeighEqually(),
        bt.algos.Rebalance()
    ])

    return bt.Backtest(s, df_data)