ScalperStrategyV3

# Filename: ScalperStrategyV3.py
# Author: Auto-Optimizer
# Description: Enhanced scalping strategy with multiple indicators and hyperopt optimization
# Supports dynamic leverage, volume confirmation, and multiple technical indicators

from freqtrade.strategy import IStrategy, informative
from freqtrade.strategy.parameters import IntParameter, DecimalParameter, CategoricalParameter
from pandas import DataFrame
import talib.abstract as ta
import freqtrade.vendor.qtpylib.indicators as qtpylib
import numpy as np
from functools import reduce

class ScalperStrategyV3(IStrategy):
    """
    增强版高频剥头皮策略
    - 时间周期: 1m
    - 多重技术指标: RSI, EMA, MACD, Bollinger Bands, Volume
    - 动态杠杆调整
    - 多层止盈止损
    """
    
    # Strategy metadata
    INTERFACE_VERSION = 3
    timeframe = '1m'
    can_short: bool = True
    
    # ROI table - 剥头皮策略：快速获利了结
    minimal_roi = {
        "0": 0.015,     # 开仓即刻1.5%获利了结
        "3": 0.01,      # 3分钟后1%获利了结  
        "6": 0.005,     # 6分钟后0.5%获利了结
        "10": 0         # 10分钟后平仓
    }
    
    # Stoploss - 剥头皮策略：严格止损
    stoploss = -0.015   # 1.5%止损，控制单笔风险
    
    # Trailing stop
    trailing_stop = True
    trailing_stop_positive = 0.01
    trailing_stop_positive_offset = 0.02
    trailing_only_offset_is_reached = True
    
    # Hyperopt parameters - Buy signals (专业剥头皮参数范围)
    rsi_period = IntParameter(8, 21, default=14, space='buy')           # RSI周期优化
    rsi_buy_threshold = IntParameter(35, 55, default=45, space='buy')   # 适度超卖区间
    ema_fast_period = IntParameter(5, 12, default=8, space='buy')       # 快速EMA
    max_leverage = DecimalParameter(10.0, 20.0, default=15.0, space='buy')  # 剥头皮适中杠杆
    
    # Bollinger Bands
    bb_period = IntParameter(10, 30, default=20, space='buy')
    bb_std = DecimalParameter(1.5, 3.0, default=2.0, space='buy')
    
    # MACD
    macd_fast = IntParameter(3, 15, default=12, space='buy')
    macd_slow = IntParameter(20, 40, default=26, space='buy')
    macd_signal = IntParameter(5, 15, default=9, space='buy')
    
    # Hyperopt parameters - Sell signals (剥头皮卖出优化)
    rsi_sell_threshold = IntParameter(45, 65, default=55, space='sell')  # 适度超买区间
    ema_slow_period = IntParameter(18, 35, default=25, space='sell')     # 慢速EMA范围
    
    # Volume confirmation (剥头皮需要充足流动性)
    volume_factor = DecimalParameter(1.1, 2.5, default=1.3, space='sell')
    
    # Entry/Exit filters (剥头皮策略增强过滤器 - 默认启用关键过滤器)
    use_volume_filter = CategoricalParameter([True, False], default=True, space='buy')   # 成交量是剥头皮关键
    use_macd_filter = CategoricalParameter([True, False], default=True, space='buy')     # MACD动量确认
    use_bb_filter = CategoricalParameter([True, False], default=True, space='buy')       # 布林带位置确认
    
    def informative_pairs(self):
        return []
    
    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """计算技术指标"""
        
        # RSI
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=self.rsi_period.value)
        
        # EMA
        dataframe['ema_fast'] = ta.EMA(dataframe, timeperiod=self.ema_fast_period.value)
        dataframe['ema_slow'] = ta.EMA(dataframe, timeperiod=self.ema_slow_period.value)
        
        # MACD
        macd = ta.MACD(dataframe, 
                      fastperiod=self.macd_fast.value,
                      slowperiod=self.macd_slow.value, 
                      signalperiod=self.macd_signal.value)
        dataframe['macd'] = macd['macd']
        dataframe['macdsignal'] = macd['macdsignal']
        dataframe['macdhist'] = macd['macdhist']
        
        # Bollinger Bands
        bollinger = qtpylib.bollinger_bands(
            qtpylib.typical_price(dataframe), 
            window=self.bb_period.value, 
            stds=self.bb_std.value
        )
        dataframe['bb_lower'] = bollinger['lower']
        dataframe['bb_middle'] = bollinger['mid']
        dataframe['bb_upper'] = bollinger['upper']
        dataframe['bb_percent'] = ((dataframe['close'] - dataframe['bb_lower']) / 
                                  (dataframe['bb_upper'] - dataframe['bb_lower']))
        
        # Volume indicators
        dataframe['volume_sma'] = ta.SMA(dataframe['volume'], timeperiod=20)
        dataframe['volume_ratio'] = dataframe['volume'] / dataframe['volume_sma']
        
        # ATR for dynamic leverage
        dataframe['atr'] = ta.ATR(dataframe, timeperiod=14)
        dataframe['atr_percent'] = dataframe['atr'] / dataframe['close']
        
        # Price action
        dataframe['price_change'] = dataframe['close'].pct_change()
        dataframe['high_low_ratio'] = (dataframe['high'] - dataframe['low']) / dataframe['close']
        
        # Momentum indicators
        dataframe['stoch_k'] = ta.STOCH(dataframe)['slowk']
        dataframe['williams_r'] = ta.WILLR(dataframe, timeperiod=14)
        
        # Trend strength
        dataframe['adx'] = ta.ADX(dataframe, timeperiod=14)
        
        return dataframe
    
    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        增强版剥头皮入场信号 - 多重确认机制
        剥头皮策略的核心：高质量信号 + 快速执行 + 严格风控
        """
        
        # === 核心剥头皮条件：多重技术确认 ===
        
        # 1. 趋势确认 (EMA系统)
        trend_up = dataframe['ema_fast'] > dataframe['ema_slow']
        trend_down = dataframe['ema_fast'] < dataframe['ema_slow']
        
        # 2. 动量确认 (RSI在合理区间，避免极端值)
        rsi_oversold = dataframe['rsi'] < self.rsi_buy_threshold.value
        rsi_overbought = dataframe['rsi'] > self.rsi_sell_threshold.value
        
        # 3. 价格位置确认 (布林带)
        bb_buy_zone = dataframe['bb_percent'] < 0.2  # 接近下轨
        bb_sell_zone = dataframe['bb_percent'] > 0.8  # 接近上轨
        
        # 4. MACD动量确认
        macd_bullish = (dataframe['macd'] > dataframe['macdsignal']) & (dataframe['macdhist'] > 0)
        macd_bearish = (dataframe['macd'] < dataframe['macdsignal']) & (dataframe['macdhist'] < 0)
        
        # 5. 成交量确认 (剥头皮需要足够流动性)
        volume_sufficient = dataframe['volume_ratio'] > self.volume_factor.value
        
        # 6. 市场结构确认 (降低ADX要求，适应更多市场环境)
        trending_market = dataframe['adx'] > 15  # 放宽趋势要求
        
        # 7. 波动率过滤 (放宽波动率要求，适应剥头皮)
        volatility_ok = dataframe['atr_percent'] > 0.003  # 只要有最低波动即可
        
        # === 剥头皮核心策略：分层过滤系统 ===
        
        # 第一层：基础趋势和动量 (必须条件)
        long_basic = trend_up & rsi_oversold & trending_market
        short_basic = trend_down & rsi_overbought & trending_market
        
        # 第二层：风险控制 (必须条件)
        long_risk_ok = long_basic & volatility_ok
        short_risk_ok = short_basic & volatility_ok
        
        # 第三层：增强确认 (可选，但至少满足一个)
        long_enhanced = []
        short_enhanced = []
        
        # 构建增强确认条件
        if self.use_bb_filter.value:
            long_enhanced.append(long_risk_ok & bb_buy_zone)
            short_enhanced.append(short_risk_ok & bb_sell_zone)
        
        if self.use_macd_filter.value:
            long_enhanced.append(long_risk_ok & macd_bullish)
            short_enhanced.append(short_risk_ok & macd_bearish)
            
        if self.use_volume_filter.value:
            long_enhanced.append(long_risk_ok & volume_sufficient)
            short_enhanced.append(short_risk_ok & volume_sufficient)
        
        # 最终信号：基础条件 + 至少一个增强确认
        long_conditions = [long_risk_ok]  # 始终包含基础条件
        short_conditions = [short_risk_ok]
        
        # 如果有增强过滤器，添加增强条件
        if long_enhanced:
            long_conditions.extend(long_enhanced)
        if short_enhanced:
            short_conditions.extend(short_enhanced)
        
        # 应用分层确认信号
        # 如果没有增强过滤器，直接使用基础条件
        if not long_enhanced:
            dataframe.loc[long_risk_ok, 'enter_long'] = 1
        else:
            # 有增强过滤器时，使用OR逻辑 (满足任一增强条件即可)
            long_final_signal = reduce(lambda x, y: x | y, long_enhanced)
            dataframe.loc[long_final_signal, 'enter_long'] = 1
            
        if not short_enhanced:
            dataframe.loc[short_risk_ok, 'enter_short'] = 1
        else:
            short_final_signal = reduce(lambda x, y: x | y, short_enhanced)
            dataframe.loc[short_final_signal, 'enter_short'] = 1
        
        return dataframe
    
    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        剥头皮出场信号 - 快速获利了结或止损
        剥头皮的精髓：小利即走，快速止损
        """
        
        # === 多头出场条件 ===
        long_exit_conditions = [
            # 1. 趋势反转信号
            dataframe['ema_fast'] < dataframe['ema_slow'],
            
            # 2. RSI超买 (获利了结)
            dataframe['rsi'] > 70,
            
            # 3. 布林带上轨压力 (价格过高)
            dataframe['bb_percent'] > 0.85,
            
            # 4. MACD顶背离
            (dataframe['macd'] < dataframe['macdsignal']) & (dataframe['macdhist'] < 0),
            
            # 5. 成交量萎缩 (动能不足)
            dataframe['volume_ratio'] < 0.8,
            
            # 6. ADX下降 (趋势减弱)
            dataframe['adx'] < 15,
        ]
        
        # 多头出场：任一条件满足即出场 (剥头皮要快进快出)
        dataframe.loc[
            reduce(lambda x, y: x | y, long_exit_conditions),
            'exit_long'
        ] = 1
        
        # === 空头出场条件 ===
        short_exit_conditions = [
            # 1. 趋势反转信号
            dataframe['ema_fast'] > dataframe['ema_slow'],
            
            # 2. RSI超卖 (获利了结)
            dataframe['rsi'] < 30,
            
            # 3. 布林带下轨支撑 (价格过低)
            dataframe['bb_percent'] < 0.15,
            
            # 4. MACD底背离
            (dataframe['macd'] > dataframe['macdsignal']) & (dataframe['macdhist'] > 0),
            
            # 5. 成交量萎缩 (动能不足)
            dataframe['volume_ratio'] < 0.8,
            
            # 6. ADX下降 (趋势减弱)
            dataframe['adx'] < 15,
        ]
        
        # 空头出场：任一条件满足即出场
        dataframe.loc[
            reduce(lambda x, y: x | y, short_exit_conditions),
            'exit_short'
        ] = 1
        
        return dataframe
    
    def leverage(self, pair, current_time, current_rate, proposed_leverage, max_leverage, entry_tag, side, **kwargs) -> float:
        """
        动态杠杆调整
        根据市场波动率、趋势强度和风险管理原则
        """
        try:
            dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
            if len(dataframe) > 0:
                latest = dataframe.iloc[-1]
                
                # 基础杠杆
                base_leverage = self.max_leverage.value
                
                # 波动率调整
                atr_percent = latest.get('atr_percent', 0.01)
                volatility_factor = max(0.3, 1 - min(atr_percent * 100, 0.7))
                
                # 趋势强度调整
                adx = latest.get('adx', 20)
                trend_factor = min(1.5, adx / 30) if adx > 20 else 0.5
                
                # 成交量确认
                volume_ratio = latest.get('volume_ratio', 1.0)
                volume_factor = min(1.2, volume_ratio / 2) if volume_ratio > 1 else 0.8
                
                # RSI极值调整
                rsi = latest.get('rsi', 50)
                if side == 'long' and rsi < 25:
                    rsi_factor = 1.2
                elif side == 'short' and rsi > 75:
                    rsi_factor = 1.2
                else:
                    rsi_factor = 1.0
                
                # 综合调整
                final_leverage = (base_leverage * volatility_factor * 
                                trend_factor * volume_factor * rsi_factor)
                
                # 限制范围
                final_leverage = max(1.0, min(final_leverage, float(max_leverage)))
                
                return final_leverage
                
        except Exception as e:
            # 安全回退
            return max(1.0, min(5.0, float(max_leverage)))
    
    def custom_stoploss(self, pair: str, trade: 'Trade', current_time: 'datetime', 
                       current_rate: float, current_profit: float, **kwargs) -> float:
        """
        动态止损
        """
        try:
            dataframe, _ = self.dp.get_analyzed_dataframe(pair, self.timeframe)
            if len(dataframe) > 0:
                latest = dataframe.iloc[-1]
                
                # 基于ATR的动态止损
                atr_percent = latest.get('atr_percent', 0.01)
                
                # 基础止损
                base_stoploss = self.stoploss
                
                # 根据持仓时间调整
                trade_duration = (current_time - trade.open_date).total_seconds() / 60  # 分钟
                
                if trade_duration < 5:  # 前5分钟紧止损
                    dynamic_stoploss = max(base_stoploss, -atr_percent * 2)
                elif trade_duration < 15:  # 5-15分钟适中
                    dynamic_stoploss = max(base_stoploss, -atr_percent * 3)
                else:  # 15分钟后放宽
                    dynamic_stoploss = base_stoploss
                
                # 盈利保护
                if current_profit > 0.01:  # 盈利超过1%
                    dynamic_stoploss = max(dynamic_stoploss, -current_profit / 2)
                
                return dynamic_stoploss
        except Exception:
            pass
        
        return self.stoploss