AMT Mean Reversion

# strategies/AMTMeanReversion/__init__.py
 
from jesse.strategies import Strategy
import jesse.indicators as ta
from jesse import utils
 
class AMTMeanReversion(Strategy):
    def __init__(self):
        super().__init__()
        self.vars['entry_bar'] = 0
 
    @property
    def rsi(self):
        return ta.rsi(self.candles, period=14)
 
    @property
    def volume_sma(self):
        return ta.sma(self.candles[:, 5], period=20)  # Volume column
 
    @property
    def value_area(self):
        return self.calculate_value_area(lookback=24)
 
    def is_failed_auction_low(self) -> bool:
        """Check for failed auction at lows."""
        # Price made a new low but couldn't continue
        recent_lows = [c[4] for c in self.candles[-5:]]  # Low prices
        lowest = min(recent_lows[:-1])
        current_low = recent_lows[-1]
 
        # Failed to make new low
        return current_low > lowest
 
    def is_failed_auction_high(self) -> bool:
        """Check for failed auction at highs."""
        recent_highs = [c[3] for c in self.candles[-5:]]  # High prices
        highest = max(recent_highs[:-1])
        current_high = recent_highs[-1]
 
        # Failed to make new high
        return current_high < highest
 
    def is_volume_declining(self) -> bool:
        """Check if volume is declining."""
        return self.volume < self.volume_sma * 0.8
 
    def should_long(self) -> bool:
        vp = self.value_area
 
        # Price below VAL
        if self.price > vp['val']:
            return False
 
        # RSI oversold
        if self.rsi > 30:
            return False
 
        # Volume declining (weak selling)
        if not self.is_volume_declining():
            return False
 
        # Failed auction (couldn't make new lows)
        if not self.is_failed_auction_low():
            return False
 
        return not self.is_long
 
    def should_short(self) -> bool:
        vp = self.value_area
 
        # Price above VAH
        if self.price < vp['vah']:
            return False
 
        # RSI overbought
        if self.rsi < 70:
            return False
 
        # Volume declining (weak buying)
        if not self.is_volume_declining():
            return False
 
        # Failed auction (couldn't make new highs)
        if not self.is_failed_auction_high():
            return False
 
        return not self.is_short
 
    def go_long(self):
        vp = self.value_area
        qty = utils.size_to_qty(
            self.balance * 0.02,
            self.price,
            fee_rate=self.fee_rate
        )
 
        self.buy = qty, self.price
        self.stop_loss = qty, self.low - (self.atr * 0.5)
        self.take_profit = [
            (qty * 0.5, vp['poc']),      # 50% at POC
            (qty * 0.5, vp['vah'])       # 50% at VAH
        ]
        self.vars['entry_bar'] = self.index
 
    def go_short(self):
        vp = self.value_area
        qty = utils.size_to_qty(
            self.balance * 0.02,
            self.price,
            fee_rate=self.fee_rate
        )
 
        self.sell = qty, self.price
        self.stop_loss = qty, self.high + (self.atr * 0.5)
        self.take_profit = [
            (qty * 0.5, vp['poc']),      # 50% at POC
            (qty * 0.5, vp['val'])       # 50% at VAL
        ]
        self.vars['entry_bar'] = self.index
 
    def update_position(self):
        # Time stop - exit if no reversion in 12 bars
        bars_in_trade = self.index - self.vars['entry_bar']
        if bars_in_trade > 12:
            self.liquidate()
 
    @property
    def atr(self):
        return ta.atr(self.candles, period=14)

# Conservative: 1% risk
risk_per_trade = 0.01
 
# Moderate: 2% risk
risk_per_trade = 0.02
 
# Aggressive: 3% risk
risk_per_trade = 0.03

Pair: ETH-USDT
Period: 2023-01-01 to 2024-01-01
Timeframe: 1H

Total Trades: 78
Win Rate: 65%
Profit Factor: 1.58
Max Drawdown: 7.2%
Sharpe Ratio: 1.32
Net Return: 28.3%

def should_long(self) -> bool:
    # Only take longs if higher timeframe is bullish
    htf_trend = self.get_htf_trend()  # Custom method
    if htf_trend != 'bullish':
        return False
 
    # ... rest of conditions