A backtesting.py alternative for crypto traders

import numpy as np
import pandas as pd
from backtesting import Backtest, Strategy


def load_eth_daily_csv(path: str) -> pd.DataFrame:
    """You source OHLCV before Backtest(...) can run."""
    df = pd.read_csv(path)
    df.columns = [c.strip().title() for c in df.columns]
    rename = {"Timestamp": "Date", "Datetime": "Date", "Open_time": "Date"}
    df = df.rename(columns={k: v for k, v in rename.items() if k in df.columns})
    df["Date"] = pd.to_datetime(df["Date"], utc=True)
    df = df.set_index("Date").sort_index()
    df = df[["Open", "High", "Low", "Close", "Volume"]].astype(float)
    return df[~df.index.duplicated(keep="first")].dropna()


def sma(values, period):
    return pd.Series(values).rolling(period).mean()


def rsi(values, period=14):
    delta = pd.Series(values).diff()
    gain = delta.clip(lower=0).rolling(period).mean()
    loss = (-delta.clip(upper=0)).rolling(period).mean()
    rs = gain / loss.replace(0, np.nan)
    return 100 - (100 / (1 + rs))


def atr(high, low, close, period=14):
    h, l, c = map(pd.Series, (high, low, close))
    prev_c = c.shift(1)
    tr = pd.concat([
        h - l,
        (h - prev_c).abs(),
        (l - prev_c).abs(),
    ], axis=1).max(axis=1)
    return tr.rolling(period).mean()


def momentum_pct(close, period=20):
    s = pd.Series(close)
    return s / s.shift(period) - 1.0


class EthTrendVolSized(Strategy):
    mom_period = 20
    ma_period = 30
    atr_period = 14
    rsi_period = 14
    vol_ma_period = 20
    mom_entry = 0.05
    equity_risk = 0.10
    cooldown_bars = 5

    def init(self):
        c = self.data.Close
        h = self.data.High
        l = self.data.Low
        v = self.data.Volume
        self.ma30 = self.I(sma, c, self.ma_period)
        self.momentum = self.I(momentum_pct, c, self.mom_period)
        self.rsi = self.I(rsi, c, self.rsi_period)
        self.atr = self.I(atr, h, l, c, self.atr_period)
        self.vol_ma = self.I(sma, v, self.vol_ma_period)
        self.bars_since_exit = self.cooldown_bars

    def _ma_rising(self):
        if len(self.ma30) < 6:
            return False
        return self.ma30[-1] > self.ma30[-6]

    def _atr_position_size(self):
        atr_val = float(self.atr[-1])
        price = float(self.data.Close[-1])
        if not np.isfinite(atr_val) or atr_val <= 0 or price <= 0:
            return 0.0
        risk_cash = self.equity * self.equity_risk
        units = risk_cash / atr_val
        fraction = (units * price) / self.equity
        return min(max(fraction, 0.0), 0.99)

    def next(self):
        self.bars_since_exit += 1
        warmup = max(self.ma_period, self.mom_period, self.vol_ma_period) + 6
        if len(self.data) < warmup:
            return

        price = float(self.data.Close[-1])
        mom = float(self.momentum[-1])
        rsi_val = float(self.rsi[-1])
        ma = float(self.ma30[-1])
        vol_ok = float(self.data.Volume[-1]) >= float(self.vol_ma[-1])

        if self.position:
            if price < ma or mom < 0:
                self.position.close()
                self.bars_since_exit = 0
            return

        if self.bars_since_exit < self.cooldown_bars:
            return

        entry_ok = (
            mom >= self.mom_entry
            and price > ma
            and self._ma_rising()
            and 40 <= rsi_val <= 65
            and vol_ok
        )
        if not entry_ok:
            return

        size = self._atr_position_size()
        if size > 0:
            self.buy(size=size)


if __name__ == "__main__":
    data = load_eth_daily_csv("eth_usd_daily.csv")

    bt = Backtest(
        data,
        EthTrendVolSized,
        cash=100_000,
        commission=0.001,
        exclusive_orders=True,
        trade_on_close=True,
    )
    stats = bt.run()
    print(stats[["Return [%]", "Max. Drawdown [%]", "Sharpe Ratio", "# Trades"]])
    bt.plot(open_browser=False)