Easy, powerful, AI backtesting engine.

class ExampleStrategy(bt.Strategy):
    """Monthly sector rotation: each month select the top 2 of XLK, XLV, XLE,
    XLF, XLY by 6-month (126 trading day) momentum and hold them equally
    weighted. Rebalance only when the calendar month changes."""

    params = (
        ('momentum_period', 126),   # 6 months ~= 126 trading days
        ('top_n',           2),     # number of assets to hold
        ('risk_pct',        0.99),  # fraction of equity to allocate
        ('trade_day',       None)
    )

    def __init__(self):
        # Data feeds added in this exact order below
        self.symbols = ['XLK', 'XLV', 'XLE', 'XLF', 'XLY']
        self.feeds = [self.datas[i] for i in range(len(self.symbols))]
        self.last_rebalance_month = None

    def log(self, txt, dt=None):
        dt = dt or self.datas[0].datetime.date(0)
        logging.info(f'{dt.isoformat()} {txt}')

    def next(self):
        current_date = self.datas[0].datetime.date(0)
        if self.p.trade_day and current_date < self.p.trade_day:
            return

        # Need enough bars on every feed for momentum lookback
        for d in self.feeds:
            if len(d) <= self.p.momentum_period:
                return

        # Only rebalance once per calendar month
        month_key = (current_date.year, current_date.month)
        if self.last_rebalance_month == month_key:
            return
        self.last_rebalance_month = month_key

        # Compute 6-month momentum for each feed
        momentums = []
        for idx, d in enumerate(self.feeds):
            past = d.close[-self.p.momentum_period]
            # Guard division so a zero past price never raises ZeroDivisionError
            mom = d.close[0] / max(past, 1e-8) - 1.0
            momentums.append((mom, idx))

        # Sort descending by momentum and pick the top N
        momentums.sort(key=lambda x: x[0], reverse=True)
        selected = []
        for i in range(self.p.top_n):
            selected.append(momentums[i][1])

        target = self.p.risk_pct / self.p.top_n  # equal-weight fraction

        # Close feeds not selected
        for idx, d in enumerate(self.feeds):
            if idx not in selected and self.getposition(d).size:
                self.log(f'EXIT {self.symbols[idx]}')
                self.order_target_percent(data=d, target=0.0)

        # Allocate to selected feeds on the same bar
        for idx in selected:
            self.log(f'ENTER {self.symbols[idx]} target {target:.4f}')
            self.order_target_percent(data=self.feeds[idx], target=target)


for _sym in ['XLK', 'XLV', 'XLE', 'XLF', 'XLY']:
    _raw = yf.download(_sym, start_date, end_date, interval='1d',
                       auto_adjust=True, multi_level_index=False, progress=False)
    _raw = _raw[(_raw['Volume'] > 0) & (_raw['High'] != _raw['Low'])]
    _feed = bt.feeds.PandasData(dataname=_raw, name=_sym)
    cerebro.adddata(_feed)

lookback_period = 126