Shorts-only Elliott Wave Oscillator strategy with crash mode stoploss.
Timeframe
5m
Direction
Long & Short
Stoploss
-99.0%
Trailing Stop
No
ROI
0m: 99.0%
Interface Version
3
Startup Candles
400
Indicators
6
freqtrade/freqtrade-strategies
Strategy 003 author@: Gerald Lonlas github@: https://github.com/freqtrade/freqtrade-strategies
"""
EI4_t4c0s_V2_2_Shorts Strategy
A shorts-only variant of the EI4_t4c0s_V2_2 strategy, designed to profit in bear markets
and during overbought conditions. This strategy mirrors the successful long-only approach
but inverts the logic for short positions.
Original EI4_t4c0s_V2_2 Strategy (Longs):
- Uses volatility-based dynamic stoploss with "moon mode"
- Multiple entry signals: lambo2, buy1ewo, buy2ewo, cofi
- EWO (Elliott Wave Oscillator) for momentum identification
- Unclog mechanism: -4% after 4 days
Strategy Concept:
Uses Elliott Wave Oscillator (EWO) and volatility indicators to identify overbought
conditions and mean reversion opportunities for short entries. Implements "crash mode"
stoploss that tightens during market crashes (inverse of moon mode).
Entry Conditions (OR logic - any can trigger entry):
1. Lambo Short: Parabolic pump (price > EMA, high RSI)
2. Sell1EWO Short: Rally during downtrend (EWO < MEAN_DN)
3. Sell2EWO Short: Extreme overbought (EWO > UP_FIB)
4. COFI Short: Stochastic overbought crossdown
Exit Conditions:
- Signal: Price falls below dynamic thresholds
- ROI: 0.99 (effectively disabled, let signals/stops control)
- Stop Loss: -0.99 base (custom stoploss manages risk)
- Crash Mode Stoploss: Dynamic trailing based on volatility
Key Differences from Long Strategy:
- Inverted entry/exit signals (overbought vs oversold)
- Crash mode stoploss: Tightens during crashes vs trailing during moons
- Shorter unclog window: 3 days vs 4 days (shorts are riskier)
- Uses min_l (distance from lows) vs max_l (distance from highs)
- Max 4 short positions via confirm_trade_entry()
Author: Derived from EI4_t4c0s_V2_2
Version: 1.0.0
"""
# --- Do not remove these libs ---
from freqtrade.strategy.interface import IStrategy
from typing import Dict, List
from functools import reduce
from typing import Optional
from pandas import DataFrame
# --------------------------------
import talib.abstract as ta
import numpy as np
import freqtrade.vendor.qtpylib.indicators as qtpylib
import datetime
from technical.util import resample_to_interval, resampled_merge
from datetime import datetime, timedelta
from freqtrade.persistence import Trade
from freqtrade.strategy import stoploss_from_open, merge_informative_pair, DecimalParameter, IntParameter, CategoricalParameter
import technical.indicators as ftt
import math
import logging
logger = logging.getLogger(__name__)
def EWO(dataframe, ema_length=5, ema2_length=3):
df = dataframe.copy()
ema1 = ta.EMA(df, timeperiod=ema_length)
ema2 = ta.EMA(df, timeperiod=ema2_length)
emadif = (ema1 - ema2) / df['close'] * 100
return emadif
class EI4_t4c0s_V2_2_Shorts(IStrategy):
"""
Shorts-only Elliott Wave Oscillator strategy with crash mode stoploss.
This strategy is designed to run in PARALLEL with EI4_t4c0s_V2_2 (longs)
in separate containers to evaluate short performance independently.
"""
INTERFACE_VERSION = 3
can_short = True
# Hyperparameter configurations from long strategy
# Will be optimized for shorts later
buy_params = {
"base_nb_candles_buy": 12,
"rsi_buy": 58,
"ewo_high": 3.001,
"ewo_low": -10.289,
"low_offset": 0.987,
"lambo2_ema_14_factor": 0.981,
"lambo2_enabled": True,
"lambo2_rsi_14_limit": 39,
"lambo2_rsi_4_limit": 44,
"buy_adx": 20,
"buy_fastd": 20,
"buy_fastk": 22,
"buy_ema_cofi": 0.98,
"buy_ewo_high": 4.179
}
sell_params = {
"base_nb_candles_sell": 22,
"high_offset": 1.014,
"high_offset_2": 1.01
}
@property
def protections(self):
return [
{
"method": "CooldownPeriod",
"stop_duration_candles": 5
},
{
"method": "MaxDrawdown",
"lookback_period_candles": 48,
"trade_limit": 20,
"stop_duration_candles": 4,
"max_allowed_drawdown": 0.2
},
{
"method": "StoplossGuard",
"lookback_period_candles": 24,
"trade_limit": 4,
"stop_duration_candles": 2,
"only_per_pair": False
},
{
"method": "LowProfitPairs",
"lookback_period_candles": 6,
"trade_limit": 2,
"stop_duration_candles": 60,
"required_profit": 0.02
},
{
"method": "LowProfitPairs",
"lookback_period_candles": 24,
"trade_limit": 4,
"stop_duration_candles": 2,
"required_profit": 0.01
}
]
# ROI table (effectively disabled, let signals control)
minimal_roi = {
"0": 0.99,
}
# Stoploss (custom_stoploss manages risk)
stoploss = -0.99
sl1 = DecimalParameter(-0.013, -0.005, default=-0.013, space='sell', optimize=True)
# SMAOffset
base_nb_candles_buy = IntParameter(8, 30, default=buy_params['base_nb_candles_buy'], space='buy', optimize=False)
base_nb_candles_sell = IntParameter(8, 30, default=sell_params['base_nb_candles_sell'], space='sell', optimize=False)
low_offset = DecimalParameter(0.985, 0.995, default=buy_params['low_offset'], space='buy', optimize=True)
high_offset = DecimalParameter(1.005, 1.015, default=sell_params['high_offset'], space='sell', optimize=True)
high_offset_2 = DecimalParameter(1.010, 1.020, default=sell_params['high_offset_2'], space='sell', optimize=True)
# lambo2
lambo2_ema_14_factor = DecimalParameter(0.975, 0.995, decimals=3, default=buy_params['lambo2_ema_14_factor'], space='buy', optimize=True)
lambo2_rsi_4_limit = IntParameter(30, 60, default=buy_params['lambo2_rsi_4_limit'], space='buy', optimize=True)
lambo2_rsi_14_limit = IntParameter(30, 55, default=buy_params['lambo2_rsi_14_limit'], space='buy', optimize=True)
# Protection
fast_ewo = 50
slow_ewo = 200
rsi_buy = IntParameter(35, 60, default=buy_params['rsi_buy'], space='buy', optimize=True)
move = IntParameter(35, 60, default=48, space='buy', optimize=True)
mms = IntParameter(6, 20, default=12, space='buy', optimize=True)
mml = IntParameter(300, 400, default=360, space='buy', optimize=True)
# cofi
is_optimize_cofi = False
buy_ema_cofi = DecimalParameter(0.96, 0.98, default=0.97, optimize=is_optimize_cofi)
buy_fastk = IntParameter(20, 30, default=20, optimize=is_optimize_cofi)
buy_fastd = IntParameter(20, 30, default=20, optimize=is_optimize_cofi)
buy_adx = IntParameter(20, 30, default=30, optimize=is_optimize_cofi)
buy_ewo_high = DecimalParameter(2, 12, default=3.553, optimize=is_optimize_cofi)
increment = DecimalParameter(low=1.0005, high=1.001, default=1.0007, decimals=4, space='buy', optimize=True, load=True)
use_custom_stoploss = True
process_only_new_candles = True
# Custom Entry
last_entry_price = None
# Unclog (3 days for shorts vs 4 days for longs)
unclog_days = IntParameter(1, 5, default=3, space='sell', optimize=True)
unclog = DecimalParameter(0.01, 0.08, default=0.04, decimals=2, space='sell', optimize=True)
# ATR-Based Dynamic Stop Loss
atr_stop_multiplier = DecimalParameter(1.5, 3.0, default=2.0, space='sell', optimize=True)
max_atr_stop = DecimalParameter(-0.20, -0.10, default=-0.15, space='sell', optimize=False)
min_atr_stop = DecimalParameter(-0.05, -0.02, default=-0.03, space='sell', optimize=False)
def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float,
time_in_force: str, current_time: datetime, entry_tag: Optional[str],
side: str, **kwargs) -> bool:
"""
Enforce maximum short position limit.
This callback is executed before every entry to ensure we don't exceed
max_short_trades positions. Essential for risk management in crypto shorts.
Args:
side: Trade direction ('long' or 'short')
Returns:
bool: True to confirm entry, False to reject
"""
# Only allow shorts in this strategy
if side == "long":
return False # Reject any long signals
# Count current open short positions
short_count = 0
trades = Trade.get_trades_proxy(is_open=True)
for trade in trades:
if trade.is_short:
short_count += 1
# Check if we can open another short
if short_count >= self.max_short_trades:
return False # Already at max short positions
return True # Confirm entry
### Trailing Stop with Crash Mode ###
def custom_stoploss(self, pair: str, trade: 'Trade', current_time: datetime,
current_rate: float, current_profit: float, **kwargs) -> float:
"""
Custom stoploss with 2-layer protection for shorts (mirrors long strategy):
Layer 1: ATR-based dynamic stop for LOSING trades (prevents liquidations)
Layer 2: Crash mode trailing for PROFITABLE shorts (immediate activation)
Logic:
- LOSING trades: Use ATR-based stop immediately
- PROFITABLE trades: Apply crash mode immediately (no 48-hour delay)
- Crash mode (min_l < 0.003): Making new lows = tighten stops (lock profits)
- Rally mode (min_l >= 0.003): Not making new lows = allow trailing
For shorts:
- Crash mode (min_l < 0.003): Making new lows = profitable short → TIGHTEN stops
- Rally mode (min_l >= 0.003): Not making new lows → Allow trailing
This is the inverse of the long strategy's moon mode which loosens stops
when making new highs. For shorts, we want to protect profit when the
market crashes (our shorts are very profitable).
Args:
pair: Trading pair
trade: Trade object
current_time: Current timestamp
current_rate: Current price
current_profit: Current profit ratio
**kwargs: Additional arguments
Returns:
float: Stoploss percentage (must be MORE NEGATIVE than base to tighten)
"""
dataframe, _ = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe)
current_candle = dataframe.iloc[-1].squeeze()
# PHASE 1: ATR-Based Dynamic Stop Loss (for losing trades)
# Prevents liquidations by using volatility-adjusted stops
if current_profit < 0:
# Calculate ATR-based stop: 2x ATR as percentage
atr_stop = -1 * self.atr_stop_multiplier.value * current_candle['atr_pcnt']
# Clamp between bounds to prevent too tight or too loose stops
# max_atr_stop = -0.15 (maximum loss allowed)
# min_atr_stop = -0.03 (minimum protection)
atr_stop = max(atr_stop, self.max_atr_stop.value)
atr_stop = min(atr_stop, self.min_atr_stop.value)
# Return ATR-based stop for losing trades
# This prevents trades from reaching -50%+ losses
return atr_stop
# PHASE 2: Crash Mode Trailing Stop (for profitable trades - IMMEDIATE activation)
SLT1 = current_candle['move_mean']
SL1 = self.sl1.value
SLT2 = current_candle['move_mean_x']
SL2 = current_candle['move_mean_x'] - current_candle['move_mean']
display_profit = current_profit * 100
slt1 = SLT1 * 100
sl1 = SL1 * 100
slt2 = SLT2 * 100
sl2 = SL2 * 100
# Crash mode: When making new lows (min_l < 0.003), tighten stops
# Small min_l = price at/near lows = SHORT IS PROFITABLE
if current_candle['min_l'] < .003:
# Short is very profitable (market crashing to new lows), use conservative stop
if SLT1 is not None and current_profit > SL1:
self.dp.send_msg(f'*** {pair} *** SHORT Profit {display_profit:.2f}% - Crash Mode {slt1:.2f}/{sl1:.2f} activated')
logger.info(f'*** {pair} *** SHORT Profit {display_profit:.2f}% - Crash Mode {slt1:.2f}/{sl1:.2f} activated')
return SL1
# Rally mode: Not making new lows (price rising away from lows), allow trailing
else:
if SLT2 is not None and current_profit > SLT2:
self.dp.send_msg(f'*** {pair} *** SHORT Profit {display_profit:.2f}% - {slt2:.2f}/{sl2:.2f} activated')
logger.info(f'*** {pair} *** SHORT Profit {display_profit:.2f}% - {slt2:.2f}/{sl2:.2f} activated')
return SL2
if SLT1 is not None and current_profit > SLT1:
self.dp.send_msg(f'*** {pair} *** SHORT Profit {display_profit:.2f}% - {slt1:.2f}/{sl1:.2f} activated')
logger.info(f'*** {pair} *** SHORT Profit {display_profit:.2f}% - {slt1:.2f}/{sl1:.2f} activated')
return SL1
# Default: Return base stoploss
return self.stoploss
def custom_entry_price(self, pair: str, trade: Optional['Trade'], current_time: datetime, proposed_rate: float,
entry_tag: Optional[str], side: str, **kwargs) -> float:
"""
Custom entry price to avoid order clustering.
For shorts: DECREMENT price (enter lower) if same as last entry.
This is the inverse of longs which increment (enter higher).
Args:
pair: Trading pair
trade: Trade object (None for new entries)
current_time: Current timestamp
proposed_rate: Proposed entry rate
entry_tag: Entry signal tag
side: Trade direction
Returns:
float: Adjusted entry price
"""
dataframe, last_updated = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe)
entry_price = (dataframe['close'].iat[-1] + dataframe['open'].iat[-1] + proposed_rate + proposed_rate) / 4
logger.info(f"{pair} Using Entry Price: {entry_price} | close: {dataframe['close'].iat[-1]} open: {dataframe['open'].iat[-1]} proposed_rate: {proposed_rate}")
# Check if there is a stored last entry price and if it matches the proposed entry price
if self.last_entry_price is not None and abs(entry_price - self.last_entry_price) < 0.0001:
# For shorts: INCREMENT to enter at a better (higher) price
# When shorting, you SELL first, so entering at HIGHER price = better entry
entry_price *= self.increment.value # Multiply to enter higher
logger.info(f"{pair} SHORT: Incremented entry price: {entry_price} based on previous entry price: {self.last_entry_price}.")
# Update the last entry price
self.last_entry_price = entry_price
return entry_price
def confirm_trade_exit(self, pair: str, trade: Trade, order_type: str, amount: float,
rate: float, time_in_force: str, exit_reason: str,
current_time: datetime, **kwargs) -> bool:
"""
Confirm trade exit with crash mode logic (inverse of moon mode).
For shorts:
- Block ROI exit if NOT making new lows (min_l < 0.003)
- Block exits below 0.3% profit
Args:
pair: Trading pair
trade: Trade object
order_type: Order type
amount: Trade amount
rate: Exit rate
time_in_force: Time in force
exit_reason: Reason for exit
current_time: Current timestamp
Returns:
bool: True to confirm exit, False to block
"""
dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
last_candle = dataframe.iloc[-1].squeeze()
# Block ROI exit if not making new lows (inverted from longs)
# For shorts: min_l > 0.003 = price far from lows = not crashing = block exit
if exit_reason == 'roi' and (last_candle['min_l'] > 0.003):
return False
# Handle freak events - block exits with low profit
if exit_reason == 'Down Trend Soon' and trade.calc_profit_ratio(rate) < 0.003:
logger.info(f"{trade.pair} Waiting for Profit")
self.dp.send_msg(f'{trade.pair} Waiting for Profit')
return False
if exit_reason == 'roi' and trade.calc_profit_ratio(rate) < 0.003:
logger.info(f"{trade.pair} ROI is below 0.003")
self.dp.send_msg(f'{trade.pair} ROI is below 0.003')
return False
if exit_reason == 'partial_exit' and trade.calc_profit_ratio(rate) < 0:
logger.info(f"{trade.pair} partial exit is below 0")
self.dp.send_msg(f'{trade.pair} partial exit is below 0')
return False
if exit_reason == 'trailing_stop_loss' and trade.calc_profit_ratio(rate) < 0:
logger.info(f"{trade.pair} trailing stop price is below 0")
self.dp.send_msg(f'{trade.pair} trailing stop price is below 0')
return False
return True
def custom_exit(self, pair: str, trade: 'Trade', current_time: 'datetime', current_rate: float, current_profit: float, **kwargs):
"""
2-Layer Exit System for Shorts (SIMPLIFIED):
Layer 1: Base stoploss (-0.99) = Safety net (almost never hit)
Layer 2: custom_stoploss = ATR-based stops + Crash mode trailing
Layer 3: custom_exit = Time-based cleanup only
Logic:
- REMOVED: Reversal detection (too aggressive, causes premature exits)
- Profitable trades: Handled by custom_stoploss crash mode (activates immediately)
- Losing trades: Handled by custom_stoploss ATR-based stops
- After 48 hours: Unclog losing/zombie trades that ATR stop didn't catch
Args:
pair: Trading pair
trade: Trade object
current_time: Current timestamp
current_rate: Current rate
current_profit: Current profit
Returns:
str: Exit reason or None
"""
# Calculate trade duration in hours
trade_duration_hours = (current_time - trade.open_date_utc).total_seconds() / 3600
# First 48 hours - Let ATR stops and crash mode handle everything
if trade_duration_hours < 48:
return None
# After 48 hours - Unclog losing/zombie trades that stops didn't catch
# Unclog: Force exit if losing > 4% (worst case scenario)
if current_profit < -0.04:
logger.info(f"*** {pair} *** SHORT Unclog: {current_profit*100:.2f}% loss after {trade_duration_hours:.1f} hours")
return 'unclog_short'
# Zombie: Force exit if stuck at breakeven after 48h
if -0.005 <= current_profit <= 0.005:
logger.info(f"*** {pair} *** SHORT Zombie: {current_profit*100:.2f}% (breakeven) after {trade_duration_hours:.1f} hours")
return 'zombie_short'
# Let custom_stoploss handle all other exits
return None
def leverage(self, pair: str, current_time: datetime, current_rate: float,
proposed_leverage: float, max_leverage: float, side: str, **kwargs) -> float:
"""
Fixed 3x leverage for all short trades.
Returns:
float: Leverage multiplier (3.0 = 3x)
"""
return 3.0
# Exit signal
use_exit_signal = True
exit_profit_only = True
exit_profit_offset = 0.01
ignore_roi_if_entry_signal = False
## Optional order time in force.
order_time_in_force = {
'entry': 'gtc',
'exit': 'gtc'
}
# Optimal timeframe for the strategy
timeframe = '5m'
position_adjustment_enable = False
process_only_new_candles = True
startup_candle_count = 400
plot_config = {
'main_plot': {
'ma_buy': {'color': 'orange'},
'ma_sell': {'color': 'orange'},
},
}
def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Calculate technical indicators.
Same indicators as long strategy - only the interpretation differs.
"""
# Calculate all ma_buy values
for val in self.base_nb_candles_buy.range:
dataframe[f'ma_buy_{val}'] = ta.EMA(dataframe, timeperiod=val)
# Calculate all ma_sell values
for val in self.base_nb_candles_sell.range:
dataframe[f'ma_sell_{val}'] = ta.EMA(dataframe, timeperiod=val)
dataframe['ma_lo'] = dataframe[f'ma_buy_{self.base_nb_candles_buy.value}'] * (self.low_offset.value)
dataframe['ma_hi'] = dataframe[f'ma_sell_{self.base_nb_candles_sell.value}'] * (self.high_offset.value)
dataframe['ma_hi_2'] = dataframe[f'ma_sell_{self.base_nb_candles_sell.value}'] * (self.high_offset_2.value)
dataframe['hma_50'] = qtpylib.hull_moving_average(dataframe['close'], window=50)
# HMA-BUY SQUEEZE
dataframe['HMA_SQZ'] = (((dataframe[f'ma_buy_{self.base_nb_candles_buy.value}'] - dataframe['hma_50'])
/ dataframe[f'ma_buy_{self.base_nb_candles_buy.value}']) * 100)
dataframe['zero'] = 0
# Elliot
dataframe['EWO'] = EWO(dataframe, self.fast_ewo, self.slow_ewo)
dataframe.loc[dataframe['EWO'] > 0, "EWO_UP"] = dataframe['EWO']
dataframe.loc[dataframe['EWO'] < 0, "EWO_DN"] = dataframe['EWO']
dataframe['EWO_UP'].ffill()
dataframe['EWO_DN'].ffill()
dataframe['EWO_MEAN_UP'] = dataframe['EWO_UP'].mean()
dataframe['EWO_MEAN_DN'] = dataframe['EWO_DN'].mean()
dataframe['EWO_UP_FIB'] = dataframe['EWO_MEAN_UP'] * 1.618
dataframe['EWO_DN_FIB'] = dataframe['EWO_MEAN_DN'] * 1.618
# RSI
dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
dataframe['rsi_fast'] = ta.RSI(dataframe, timeperiod=4)
dataframe['rsi_slow'] = ta.RSI(dataframe, timeperiod=20)
# lambo2
dataframe['ema_14'] = ta.EMA(dataframe, timeperiod=14)
dataframe['rsi_4'] = ta.RSI(dataframe, timeperiod=4)
dataframe['rsi_14'] = ta.RSI(dataframe, timeperiod=14)
# Cofi
stoch_fast = ta.STOCHF(dataframe, 5, 3, 0, 3, 0)
dataframe['fastd'] = stoch_fast['fastd']
dataframe['fastk'] = stoch_fast['fastk']
dataframe['adx'] = ta.ADX(dataframe)
dataframe['ema_8'] = ta.EMA(dataframe, timeperiod=8)
dataframe['OHLC4'] = (dataframe['open'] + dataframe['high'] + dataframe['low'] + dataframe['close']) / 4
# Check how far we are from min and max
dataframe['max'] = dataframe['OHLC4'].rolling(self.mms.value).max() / dataframe['OHLC4'] - 1
dataframe['min'] = abs(dataframe['OHLC4'].rolling(self.mms.value).min() / dataframe['OHLC4'] - 1)
dataframe['max_l'] = dataframe['OHLC4'].rolling(self.mml.value).max() / dataframe['OHLC4'] - 1
dataframe['min_l'] = abs(dataframe['OHLC4'].rolling(self.mml.value).min() / dataframe['OHLC4'] - 1)
# Apply rolling window operation to the 'OHLC4'column
rolling_window = dataframe['OHLC4'].rolling(self.move.value)
rolling_max = rolling_window.max()
rolling_min = rolling_window.min()
# Calculate the peak-to-peak value on the resulting rolling window data
ptp_value = rolling_window.apply(lambda x: np.ptp(x))
# Assign the calculated peak-to-peak value to the DataFrame column
dataframe['move'] = ptp_value / dataframe['OHLC4']
dataframe['move_mean'] = dataframe['move'].mean()
dataframe['move_mean_x'] = dataframe['move'].mean() * 1.6
dataframe['exit_mean'] = rolling_min * (1 + dataframe['move_mean'])
dataframe['exit_mean_x'] = rolling_min * (1 + dataframe['move_mean_x'])
dataframe['enter_mean'] = rolling_max * (1 - dataframe['move_mean'])
dataframe['enter_mean_x'] = rolling_max * (1 - dataframe['move_mean_x'])
dataframe['atr_pcnt'] = (ta.ATR(dataframe, timeperiod=5) / dataframe['OHLC4'])
return dataframe
def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Define SHORT entry conditions (inverted from long strategy).
All 4 entry signals are inverted for overbought conditions:
1. lambo_short: Parabolic pumps
2. sell1ewo_short: Rallies during downtrend
3. sell2ewo_short: Extreme overbought
4. cofi_short: Stochastic overbought crossdown
OPTIMIZATION (Jan 30, 2026):
- Changed rsi_fast threshold from > 65 to > 60 (conservative loosening)
- Expected: ~30% increase in short signals while maintaining quality
- Rationale: Balances trade frequency with longs (rsi_fast < 35 equivalent)
"""
# Lambo Short: Parabolic pump (inverted from lambo2)
# Long: close < ema_14 * 0.981, rsi_4 < 44, rsi_14 < 39
# Short: close > ema_14 * (2 - 0.981) = 1.019, rsi_4 > (100-44) = 56, rsi_14 > (100-39) = 61
lambo_short = (
(dataframe['close'] > (dataframe['ema_14'] * (2 - self.lambo2_ema_14_factor.value))) &
(dataframe['rsi_4'] > (100 - int(self.lambo2_rsi_4_limit.value))) &
(dataframe['rsi_14'] > (100 - int(self.lambo2_rsi_14_limit.value))) &
(dataframe['atr_pcnt'] > dataframe['min_l']) &
(dataframe['volume'] > 0)
)
dataframe.loc[lambo_short, 'enter_short'] = 1
dataframe.loc[lambo_short, 'enter_tag'] = 'lambo_short'
# Sell1EWO Short: Rally during downtrend (inverted from buy1ewo)
# Long: rsi_fast < 35, close < ma_lo, EWO > EWO_MEAN_UP
# Short: rsi_fast > 60 (OPTIMIZED from 65), close > ma_hi, EWO < EWO_MEAN_DN
sell1ewo_short = (
(dataframe['rsi_fast'] > 60) & # CHANGED from 65 to 60
(dataframe['close'] > dataframe['ma_hi']) &
(dataframe['EWO'] < dataframe['EWO_MEAN_DN']) &
(dataframe['close'] > dataframe['exit_mean_x']) &
(dataframe['close'].shift() > dataframe['exit_mean_x'].shift()) &
(dataframe['rsi'] > (100 - self.rsi_buy.value)) &
(dataframe['atr_pcnt'] > dataframe['min']) &
(dataframe['volume'] > 0)
)
dataframe.loc[sell1ewo_short, 'enter_short'] = 1
dataframe.loc[sell1ewo_short, 'enter_tag'] = 'sell1ewo_short'
# Sell2EWO Short: Extreme overbought (inverted from buy2ewo)
# Long: rsi_fast < 35, close < ma_lo, EWO < EWO_DN_FIB
# Short: rsi_fast > 60 (OPTIMIZED from 65), close > ma_hi, EWO > EWO_UP_FIB
sell2ewo_short = (
(dataframe['rsi_fast'] > 60) & # CHANGED from 65 to 60
(dataframe['close'] > dataframe['ma_hi']) &
(dataframe['EWO'] > dataframe['EWO_UP_FIB']) &
(dataframe['atr_pcnt'] > dataframe['min']) &
(dataframe['volume'] > 0)
)
dataframe.loc[sell2ewo_short, 'enter_short'] = 1
dataframe.loc[sell2ewo_short, 'enter_tag'] = 'sell2ewo_short'
# COFI Short: Overbought crossdown (inverted from cofi)
# Long: open < ema_8 * 0.98, crossed_above(fastk, fastd), fastk < 22, fastd < 20
# Short: open > ema_8 * (2 - 0.98) = 1.02, crossed_below(fastk, fastd), fastk > 78, fastd > 80
cofi_short = (
(dataframe['open'] > dataframe['ema_8'] * (2 - self.buy_ema_cofi.value)) &
(qtpylib.crossed_below(dataframe['fastk'], dataframe['fastd'])) &
(dataframe['fastk'] > (100 - self.buy_fastk.value)) &
(dataframe['fastd'] > (100 - self.buy_fastd.value)) &
(dataframe['adx'] > self.buy_adx.value) &
(dataframe['EWO'] < dataframe['EWO_MEAN_DN']) &
(dataframe['atr_pcnt'] > dataframe['min']) &
(dataframe['volume'] > 0)
)
dataframe.loc[cofi_short, 'enter_short'] = 1
dataframe.loc[cofi_short, 'enter_tag'] = 'cofi_short'
return dataframe
def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
"""
Define SHORT exit conditions (inverted from long strategy).
Exit when price falls below thresholds (profit target reached for shorts).
"""
# Exit Short Condition 1 (inverted from condition5)
# Long: close > hma_50 AND close > ma_hi_2 AND close > exit_mean_x
# Short: close < hma_50 AND close < ma_lo AND close < enter_mean_x
condition_short_1 = (
(dataframe['close'] < dataframe['hma_50']) &
(dataframe['close'] < dataframe['ma_lo']) &
(dataframe['close'] < dataframe['enter_mean_x']) &
(dataframe['rsi'] < 50) &
(dataframe['volume'] > 0) &
(dataframe['rsi_fast'] < dataframe['rsi_slow'])
)
dataframe.loc[condition_short_1, 'exit_short'] = 1
dataframe.loc[condition_short_1, 'exit_tag'] = 'Close < Offset Lo 1'
# Exit Short Condition 2 (inverted from condition6)
# Long: close < hma_50 AND close > ma_hi
# Short: close > hma_50 AND close < ma_lo
condition_short_2 = (
(dataframe['close'] > dataframe['hma_50']) &
(dataframe['close'] < dataframe['ma_lo']) &
(dataframe['volume'] > 0) &
(dataframe['rsi_fast'] < dataframe['rsi_slow'])
)
dataframe.loc[condition_short_2, 'exit_short'] = 1
dataframe.loc[condition_short_2, 'exit_tag'] = 'Close < Offset Lo 2'
return dataframe
def pct_change(a, b):
return (b - a) / a