class MyStrategy(StrategyBase):
    def on_init(self):
        self.params.setdefault('fast', 10)
        self.params.setdefault('slow', 30)

    def _sma(self, closes, period):
        if len(closes) < period:
            return None
        return sum(closes[-period:]) / period

    def on_data(self, bar):
        fast = self.params['fast']
        slow = self.params['slow']
        hist = self.history(bar.symbol, slow + 1)
        if len(hist) < slow + 1:
            return
        closes = [b.close for b in hist]

        fast_now = self._sma(closes, fast)
        slow_now = self._sma(closes, slow)
        fast_prev = self._sma(closes[:-1], fast)
        slow_prev = self._sma(closes[:-1], slow)

        if None in (fast_now, slow_now, fast_prev, slow_prev):
            return

        if self.is_flat(bar.symbol):
            if fast_prev <= slow_prev and fast_now > slow_now:
                qty = max(1, int(self.portfolio.cash * 0.95 / bar.close))
                self.market_order(bar.symbol, qty)
        elif self.is_long(bar.symbol):
            if fast_prev >= slow_prev and fast_now < slow_now:
                self.close_position(bar.symbol)

class MyStrategy(StrategyBase):
    """Your strategy description."""

    def on_init(self):
        # Set parameters, warm-up, initial state
        self.params.setdefault('period', 20)
        self.set_warmup(bars=200)

    def on_data(self, bar):
        # Called each bar — your main trading logic
        hist = self.history(bar.symbol, 20)
        # ... compute indicators, place orders ...

    def on_order_event(self, fill):
        # Optional: react to fills
        pass

    def on_end(self):
        # Optional: cleanup after backtest
        pass

# Get last 50 bars
hist = self.history(bar.symbol, 50)
closes = [b.close for b in hist]
highs = [b.high for b in hist]

# Always guard against insufficient data
if len(hist) < 50:
    return

# Single-input indicators: pass a list of closes (or other values)
closes = [b.close for b in self.history(bar.symbol, 50)]
sma_val = SMA(period=20)(closes)         # → float
ema_val = EMA(period=20)(closes)         # → float
rsi_val = RSI(period=14)(closes)         # → float

# Multi-value indicators (return a dict)
macd = MACD(fast=12, slow=26, signal=9)(closes)
# → {"macd": float, "signal": float, "histogram": float}

bb = BollingerBands(period=20, num_std=2.0)(closes)
# → {"upper": float, "middle": float, "lower": float}

# Multi-input indicators: pass high, low, close, volume as keyword args
hist = self.history(bar.symbol, 50)
highs  = [b.high for b in hist]
lows   = [b.low for b in hist]
volumes = [b.volume for b in hist]

stoch = Stochastic(k_period=14, d_period=3)(high=highs, low=lows, close=closes)
# → {"k": float, "d": float}

atr_val = ATR(period=14)(high=highs, low=lows, close=closes)
# → float

mfi_val = MFI(period=14)(high=highs, low=lows, close=closes, volume=volumes)
# → float

# You can also get a full series (useful for crossover detection)
sma_series = SMA(period=20).series(closes)   # → numpy array

# Access a specific position
pos = self.portfolio.get_position(bar.symbol)
if pos:
    print(pos.quantity)        # Number of shares
    print(pos.avg_cost)        # Average cost basis
    print(pos.realized_pnl)    # Realized P&L
    print(pos.unrealized_pnl(bar.close))  # Current unrealized P&L
    print(pos.is_long)         # True if long
    print(pos.total_commission) # Total commission paid

# Check if position exists
has_pos = self.portfolio.has_position(bar.symbol)
qty = self.portfolio.get_position_quantity(bar.symbol)

class MyStrategy(StrategyBase):
    """
    Multi-timeframe strategy using bar consolidators.
    Uses 1-hour bars derived from lower-timeframe data.
    """
    def on_init(self):
        # Create a 1-hour consolidator
        self.hourly = TimeConsolidator(
            minutes=60, callback=self.on_hourly)
        self.hourly_sma = None

    def on_data(self, bar):
        # Feed every bar into the consolidator
        self.hourly.update(bar)

        # Trade based on hourly signal + current bar
        if self.hourly_sma and self.is_flat(bar.symbol):
            if bar.close > self.hourly_sma:
                qty = max(1, int(self.portfolio.cash * 0.95 / bar.close))
                self.market_order(bar.symbol, qty)
        elif self.is_long(bar.symbol) and self.hourly_sma:
            if bar.close < self.hourly_sma:
                self.close_position(bar.symbol)

    def on_hourly(self, consolidated_bar):
        # Called when a 1-hour bar completes
        hist = self.history(length=50)
        if len(hist) >= 20:
            closes = [b.close for b in hist[-20:]]
            self.hourly_sma = SMA(period=20)(closes)

def on_init(self):
    # These become sliders/inputs in the Playground
    self.params.setdefault('fast', 10)       # Fast MA period
    self.params.setdefault('slow', 30)       # Slow MA period
    self.params.setdefault('threshold', 2.0) # Entry threshold

def on_data(self, bar):
    fast = self.params['fast']   # Read current value
    slow = self.params['slow']
    # ... use parameters in your logic