""" 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