bt: A flexible backtesting framework for Python

You can build a target volatility strategy by combining several bt.algos into a bt.Strategy. A typical workflow involves:

1. Scheduling: Use bt.algos.RunWeekly(run_on_first_date=True) to trigger the strategy at specific intervals.
2. Selection: Use bt.algos.SelectThese(['asset1', 'asset2']) to filter the universe.
3. Weighting: Use bt.algos.WeighInvVol(lookback=..., lag=...) to set weights based on inverse volatility.
4. Volatility Targeting: Use bt.algos.TargetVol(target_vol, lookback=..., lag=..., covar_method='standard', annualization_factor=252) to scale the portfolio to a specific annualized volatility.
5. Rebalancing: Use bt.algos.Rebalance() to apply the calculated weights to the portfolio.

Note: The TargetVol algo uses the weights calculated by the preceding weighting algo (stored in target.temp) to scale the overall portfolio volatility.

import bt
import pandas as pd

# 1. Schedule execution
runWeeklyAlgo = bt.algos.RunWeekly(run_on_first_date=True)

# 2. Select assets
selectTheseAlgo = bt.algos.SelectThese(['foo', 'bar'])

# 3. Set weights to 1/vol contributions
weighInvVolAlgo = bt.algos.WeighInvVol(
    lookback=pd.DateOffset(months=12),
    lag=pd.DateOffset(days=1)
)

# 4. Target annualized 10% volatility
targetVolAlgo = bt.algos.TargetVol(
    0.1,
    lookback=pd.DateOffset(months=12),
    lag=pd.DateOffset(days=1),
    covar_method='standard',
    annualization_factor=252
)

# 5. Rebalance to the weights set in target.temp
rebalAlgo = bt.algos.Rebalance()

# Combine into a Strategy
strat = bt.Strategy('target_vol_strategy', [
    runWeeklyAlgo,
    selectTheseAlgo,
    weighInvVolAlgo,
    targetVolAlgo,
    rebalAlgo
])

The bt framework uses a tree structure to allow mixing and matching of securities and strategies. A bt.Strategy can have children that are either bt.Security objects or other bt.Strategy objects. This allows for sophisticated capital allocation, such as a parent strategy that allocates weight between a passive bond (a security) and a momentum strategy (a sub-strategy).

To build a strategy, you can pass a list of children to the bt.Strategy constructor. Children can be represented by their ticker strings (which are automatically converted to bt.Security instances) or by existing bt.Strategy objects.

import bt

# 1. Create a sub-strategy (e.g., momentum)
# The 3rd argument ['spy', 'eem'] limits the universe for this strategy
mom_s = bt.Strategy('mom_s', [bt.algos.RunMonthly(),
                              bt.algos.SelectAll(),
                              bt.algos.SelectMomentum(1),
                              bt.algos.WeighEqually(),
                              bt.algos.Rebalance()],
                     ['spy', 'eem'])

# 2. Create a parent strategy
# One child is the sub-strategy (mom_s), the other is a security ('agg')
parent = bt.Strategy('parent', [bt.algos.RunMonthly(),
                                bt.algos.SelectAll(),
                                bt.algos.WeighEqually(),
                                bt.algos.Rebalance()],
                      [mom_s, 'agg'])

# 3. Run the backtest
t = bt.Backtest(parent, data)
r = bt.run(t)

You can create custom trading logic by subclassing bt.Algo. A signal algorithm typically calculates a metric (like total return over a lookback period) and stores it in target.temp for subsequent algorithms to use.

Key implementation details:

• Use __init__ to define parameters like lookback and lag (using pd.DateOffset).
• In __call__(self, target), access price data via target.universe[selected].
• Store results in target.temp['Signal'] to pass data down the algorithm chain.
• Return True to continue the algorithm execution or False to stop.

class Signal(bt.Algo):
    def __init__(self, lookback=pd.DateOffset(months=3), lag=pd.DateOffset(days=0)):
        super(Signal, self).__init__()
        self.lookback = lookback
        self.lag = lag

    def __call__(self, target):
        selected = 'foo'
        t0 = target.now - self.lag
        
        if target.universe[selected].index[0] > t0:
            return False
            
        prc = target.universe[selected].loc[t0 - self.lookback:t0]
        trend = prc.iloc[-1]/prc.iloc[0] - 1
        signal = trend > 0.
        
        if signal:
            target.temp['Signal'] = 1.
        else:
            target.temp['Signal'] = 0.
        return True