Skip to content
All library documents

RSI-2 Pullbacks Filtered by Ichimoku and Hilbert Trend Mode

Article Strategy library · Author: Jesse community

Summary

This crypto strategy adapts the RSI-2 pullback approach for long entries. It signals when the two-period RSI falls below 10, then requires the close to be above both Ichimoku cloud spans and the Hilbert Transform trend mode to indicate a trend. The Ichimoku settings are described as adjusted for crypto markets. Short entries are disabled.

The strategy sizes each entry using the full available balance and exits when the close exceeds the highs of the two preceding candles. The document provides implementation details, but no performance results or backtest evidence. It also does not specify protective stops, leverage limits, or how the approach behaves across different assets and timeframes, so its suitability and risk cannot be inferred from the rules alone.

Key ideas

  • The strategy looks for long entries when a two-period RSI falls below 10.
  • It filters entries by requiring price above both Ichimoku cloud spans and a positive Hilbert trend mode.
  • Short trades are disabled.
  • Positions are sized using the full balance and exited after the close exceeds the preceding two candle highs.
  • The document gives no performance evidence or explicit stop-loss rule.

Tags

Full text
# IFR2


# IFR2









IFR2 (portuguese translation of RSI2)
Repo: https://github.com/gabrielweich/jesse-strategies
Simillar to RSI2 described by Larry Connors but with some modifications.
Uses Ichimoku Cloud with parameters adapted to crypto market and also
Hilbert Transform Trendmode as filters to only buy in an uptrend.
The exit occurs when the close is above the highest high of the two
previous cadles.
References:
 - RSI2: https://school.stockcharts.com/doku.php?id=trading_strategies:rsi2
 - Ichimoku Crypto Parameters: https://www.altcointrading.net/ichimoku-cloud/

## Source (MIT)

```python
"""
IFR2 (portuguese translation of RSI2)
Repo: https://github.com/gabrielweich/jesse-strategies
Simillar to RSI2 described by Larry Connors but with some modifications.
Uses Ichimoku Cloud with parameters adapted to crypto market and also
Hilbert Transform Trendmode as filters to only buy in an uptrend.
The exit occurs when the close is above the highest high of the two
previous cadles.
References:
 - RSI2: https://school.stockcharts.com/doku.php?id=trading_strategies:rsi2
 - Ichimoku Crypto Parameters: https://www.altcointrading.net/ichimoku-cloud/
"""

from jesse.strategies import Strategy
import jesse.indicators as ta
from jesse import utils


class IFR2(Strategy):
    @property
    def rsi(self):
        return ta.rsi(self.candles, period=2)

    @property
    def trend_mode(self):
        return ta.ht_trendmode(self.candles)

    @property
    def ichimoku(self):
        # Ichimoku cloud using parameters adapted to crypto market
        return ta.ichimoku_cloud(
            self.candles,
            conversion_line_period=20,
            base_line_period=30,
            lagging_line_period=120,
            displacement=60,
        )

    def filter_trend_ichimoku(self):
        # Only opens a long position when close is above ichimoku cloud
        return self.close > self.ichimoku.span_a and self.close > self.ichimoku.span_b

    def filter_trend_mode(self):
        # Only opens a long position when trend_mode indicates a trend
        return self.trend_mode == 1

    def filters(self):
        return [self.filter_trend_ichimoku, self.filter_trend_mode]

    def should_long(self) -> bool:
        # Go long if candle RSI2 is below 10
        return self.rsi < 10

    def should_short(self) -> bool:
        return False

    def should_cancel_entry(self) -> bool:
        return True

    def go_long(self):
        # Open long position using entire balance
        qty = utils.size_to_qty(self.balance, self.price, fee_rate=self.fee_rate)
        self.buy = qty, self.price

    def go_short(self):
        pass

    def update_position(self):
        # Close the position when candle is above the highest high of the two previous cadles
        if (
            self.close > self.candles[-2:, 3][-2]
            and self.close > self.candles[-3:, 3][-3]
        ):
            self.liquidate()
```

Shown in full with attribution under the source's licence. Licence: MIT

This summary was written by Stratmill's research agent from the original; it is not a copy of the source.