Plugin

RSI trend pullback

Buys short, sharp dips while price is above its 200 bar SMA and sells rallies below it, out when RSI(2) recovers or price crosses the 5 bar SMA.

Strategy templateNo networkDesktop onlyv1.1.0

Get early access Plugin API documentation

About

A mean reversion template inside a trend filter, after the RSI(2) pullback idea Larry Connors and Cesar Alvarez published. The 200 bar SMA decides the direction: above it only longs, below it only shorts. A 2 bar RSI at or below 10 marks a short, sharp dip in an uptrend, and the long is entered at the next bar's open; above 90 marks a rally in a downtrend for a short. The trade ends when the RSI recovers above 70 (below 30 for a short) or the close crosses back over the 5 bar SMA, whichever comes first.

The published rules have no stop. This template adds two guards you can widen or switch off: a stop 3 ATR from the entry, which also sizes the position by risk, and an exit after 10 bars held. The published rules are written for daily bars of stocks and indices; on other markets and timeframes every length counts bars.

It exports to MetaTrader 5, cTrader and Rust as it runs here. It keeps its own record of the trade, the fill on the ask or the bid and the stop on the other side, so the expert advisor and the cBot follow the bid and ask of the quotes they see. TradingView's bars carry one price and no bid or ask, so there is no export to it.

Parameters

Name	Type	Default	Range or options	Description
`trendLength`	int	`200`	min 10, max 500	Bars in the trend SMA: longs only above it, shorts only below it.
`rsiLength`	int	`2`	min 2, max 30	Bars in the RSI. 2 in the published rules.
`entryLevel`	float	`10`	min 1, max 49	A long enters when the RSI is at or below this, a short when it is at or above 100 minus this.
`exitLevel`	float	`70`	min 51, max 99	A long exits when the RSI rises above this, a short when it falls below 100 minus this.
`exitSma`	int	`5`	min 0, max 50	Bars in the exit SMA: a long exits on a close above it, a short on a close below it. 0 is off.
`atrLength`	int	`14`	min 2, max 100	Bars in the ATR the stop is measured in.
`stopAtr`	float	`3`	min 0.5, max 20	The stop's distance from the entry, in ATR.
`maxBars`	int	`10`	min 0, max 200	Close the position after it has been held this many bars, counting the bar it opened on. 0 is off.
`riskPercent`	float	`1`	min 0, max 10	Per cent of the balance lost if the stop is hit. 0 trades the run's lot size.
`allowShort`	int	`1`	min 0, max 1	1 also sells rallies in a downtrend, 0 long only.

Use it in a strategy

python# The entry rule in your own strategy:
trend = ctx.ind("sma", length=200)
rsi = ctx.ind("rsi", length=2)
atr = ctx.ind("atr", length=14)
close = ctx.bars(1)[-1].close
if trend is not None and rsi is not None and atr is not None:
    if close > trend and rsi <= 10:
        ctx.signal("LONG", sl_pips=3 * atr / ctx.pip(), risk_percent=1.0)

To run the whole template, install it, switch it on and pick RSI trend pullback under Plugins in the strategy list. The rules were published for daily bars.

What it provides

rsi_trend_pullback/rsi_pullbackStrategy The strategy, with its parameters: trend SMA, RSI length, entry and exit levels, exit SMA, ATR stop, maximum bars held, the risk per trade and the short side.

When values are known

Every decision is made on a bar's close from that bar and the ones before it, and fills at the next bar's open. The stop is checked from the bar after the entry.

Limits

Buying dips means buying into falling prices. In a trend that breaks, the next bars can fall further before the exit; the stop limits that, at the price of being hit on deep dips the published rules would have held through.
Trades are short and frequent, so costs matter: spread, commission and the gap between a close and the next open. A test without realistic costs says little.
The published research used daily bars of US stocks and indices. Results on other markets or timeframes are not covered by it.
The template keeps its own record from the bars, as it did before a strategy could read the engine's position, so it trades as it always has. Without bid and ask on the bars the engine adds a spread to the fill the record cannot see, so on a bar that only just reaches the stop the two can differ; the record then waits for its own exit before the next entry.
No result is promised.

Preview

json{
  "atr14": 48.5,
  "close": 5021.4,
  "exitWhen": "RSI(2) above 70, a close over the SMA 5, or 10 bars held",
  "note": "Made-up example, not a real trade",
  "rsi2": 6.8,
  "signal": "LONG at the next open",
  "sma200": 4870.2,
  "stopDistance": 145.5
}

A made-up sample that shows the shape of the output. Not vendor data and not a result.

The code

main.py, the file the app installs.

python"""RSI trend pullback: buy sharp dips in an uptrend, sell sharp rallies in a downtrend.

The idea is the RSI(2) pullback Larry Connors and Cesar Alvarez published
("Short Term Trading Strategies That Work", 2008), built from its public
description:

- trend: a close above the `trendLength` (200) bar SMA allows longs, a close
  below it shorts;
- entry: RSI(`rsiLength`) at or below `entryLevel` (10) for a long, at or
  above 100 minus it for a short; the order is sent on the close and fills at
  the next bar's open;
- exit: RSI back above `exitLevel` (70; below 100 minus it for a short), or
  the close back over the `exitSma` (5) bar SMA (under it for a short),
  whichever comes first;
- two guards the published rules do not have: a stop `stopAtr` times the ATR
  from the entry, and an exit after `maxBars` bars held.

The strategy keeps its own record of the position, played by the engine's
rules: the entry fills at the next open (the ask for a buy, the bid for a
sell, when the bar carries them), the stop is checked from the bar after, a
long's on the bid low and a short's on the ask high. On bars without bid and
ask the record uses the mid, where the engine adds a spread the strategy
cannot see; the record, not `ctx.position`, decides, so the template trades
as it always has.

Written in the subset the Python to IR compiler takes (`ir/from_python.py`),
so the template exports to MetaTrader 5, cTrader and Rust as it runs here: the
parameters are read and clamped in `__init__`, every rule is in `on_bar`, and
the fields hold numbers and flags only. Its record reads the bar's bid and ask,
which a TradingView bar does not have, so there is no Pine export.
"""

from orionquant_engine.strategy.base_strategy import Strategy

STRATEGY_ID = "rsi_pullback"

PARAMS = [
    {"key": "trendLength", "label": "Trend SMA (bars)", "type": "int", "default": 200, "min": 10, "max": 500},
    {"key": "rsiLength", "label": "RSI length (bars)", "type": "int", "default": 2, "min": 2, "max": 30},
    {"key": "entryLevel", "label": "Long below RSI (short above 100 minus it)", "type": "float", "default": 10,
     "min": 1, "max": 49},
    {"key": "exitLevel", "label": "Long exit above RSI (short below 100 minus it)", "type": "float", "default": 70,
     "min": 51, "max": 99},
    {"key": "exitSma", "label": "Exit SMA (bars, 0 off)", "type": "int", "default": 5, "min": 0, "max": 50},
    {"key": "atrLength", "label": "ATR length (bars)", "type": "int", "default": 14, "min": 2, "max": 100},
    {"key": "stopAtr", "label": "Stop distance (ATR)", "type": "float", "default": 3.0, "min": 0.5, "max": 20},
    {"key": "maxBars", "label": "Exit after (bars held, 0 off)", "type": "int", "default": 10, "min": 0, "max": 200},
    {"key": "riskPercent", "label": "Risk at the stop (% of balance, 0 lot size)", "type": "float", "default": 1.0,
     "min": 0, "max": 10},
    {"key": "allowShort", "label": "Short trades (1 on, 0 off)", "type": "int", "default": 1, "min": 0, "max": 1},
]


def entry_fill(bar, side):
    """Where a market order sent on the last bar filled: this bar's open, on the ask for a
    buy (side 1) and the bid for a sell (side -1) when the bar carries them. Without them
    the engine adds a spread this strategy cannot see, so the record uses the mid."""
    if bar.sides is not None:
        return bar.ask_open if side == 1 else bar.bid_open
    return bar.open


def stop_hit(bar, side, stop):
    """Whether the protective stop was reached on this bar: a long's on the bid, a short's on the ask."""
    if side == 1:
        low = bar.bid_low if bar.sides is not None else bar.low
        return low <= stop
    high = bar.ask_high if bar.sides is not None else bar.high
    return high >= stop


class RsiTrendPullback(Strategy):
    """See the module docstring."""

    def __init__(self, params):
        # Each parameter clamped to its range in PARAMS, its default when absent.
        self.trend_length = min(max(int(params.get("trendLength", 200)), 10), 500)
        self.rsi_length = min(max(int(params.get("rsiLength", 2)), 2), 30)
        self.entry_level = min(max(float(params.get("entryLevel", 10)), 1.0), 49.0)
        self.exit_level = min(max(float(params.get("exitLevel", 70)), 51.0), 99.0)
        self.exit_sma = min(max(int(params.get("exitSma", 5)), 0), 50)
        self.atr_length = min(max(int(params.get("atrLength", 14)), 2), 100)
        self.stop_atr = min(max(float(params.get("stopAtr", 3.0)), 0.5), 20.0)
        self.max_bars = min(max(int(params.get("maxBars", 10)), 0), 200)
        self.risk_percent = min(max(float(params.get("riskPercent", 1.0)), 0.0), 10.0)
        self.allow_short = min(max(int(params.get("allowShort", 1)), 0), 1)
        # The exit SMA's length when it is on; with 0 it is read at one bar and never used.
        self.fast_length = max(self.exit_sma, 1)

        # The position by the strategy's own record: its side (1 long, -1 short, 0 none),
        # whether the order is still to fill, the stop distance, the entry, the stop, the
        # bars held.
        self.side = 0
        self.pending = False
        self.distance = None
        self.entry = None
        self.stop = None
        self.held = 0

    def on_bar(self, ctx):
        bars = ctx.bars(1)
        if not bars:
            return  # never: the hook runs once a bar is out
        bar = bars[-1]

        # The fill of an order sent on the last bar, the stop, and the bars held.
        if self.side != 0:
            if self.pending:
                entry = entry_fill(bar, self.side)
                self.entry = entry
                self.stop = entry - self.distance if self.side == 1 else entry + self.distance
                self.held = 1
                self.pending = False  # the engine checks a new position's stop from the bar after its fill
            elif stop_hit(bar, self.side, self.stop):
                self.side = 0
            else:
                self.held += 1

        trend = ctx.ind("sma", length=self.trend_length)
        rsi = ctx.ind("rsi", length=self.rsi_length)
        atr = ctx.ind("atr", length=self.atr_length)
        fast = ctx.ind("sma", length=self.fast_length)
        if trend is None or rsi is None or atr is None or (self.exit_sma > 0 and fast is None):
            return

        if self.side != 0:
            # RSI recovered, the close crossed the exit SMA, or the position is old enough.
            if self.max_bars > 0 and self.held >= self.max_bars:
                due = True
            elif self.side == 1:
                due = rsi > self.exit_level or (self.exit_sma > 0 and bar.close > fast)
            else:
                due = rsi < 100 - self.exit_level or (self.exit_sma > 0 and bar.close < fast)
            if due:
                ctx.signal("EXIT")
                self.side = 0
            return

        if bar.close > trend and rsi <= self.entry_level:
            side = 1
        elif self.allow_short == 1 and bar.close < trend and rsi >= 100 - self.entry_level:
            side = -1
        else:
            return
        distance = self.stop_atr * atr
        sl_pips = distance / ctx.pip()
        if self.risk_percent > 0:
            if side == 1:
                ctx.signal("LONG", sl_pips=sl_pips, risk_percent=self.risk_percent)
            else:
                ctx.signal("SHORT", sl_pips=sl_pips, risk_percent=self.risk_percent)
        elif side == 1:
            ctx.signal("LONG", sl_pips=sl_pips)
        else:
            ctx.signal("SHORT", sl_pips=sl_pips)
        self.side = side
        self.pending = True
        self.distance = distance


def register(api):
    api.register_strategy(STRATEGY_ID, "RSI trend pullback", RsiTrendPullback, PARAMS)