diff --git a/ChanEnum.py b/ChanEnum.py index a2c2305..3754d21 100644 --- a/ChanEnum.py +++ b/ChanEnum.py @@ -22,6 +22,30 @@ class Chan_K_DIR(Enum): BULL = auto() BEAR = auto() CROSS = auto() + +class Chan_EMA_POS(Enum): + """K线与任意EMA的位置关系（与趋势方向无关的客观分类，支持threshold容差）""" + ABOVE = auto() # 完全在EMA上方（远离）：low > ema + threshold + NEAR_ABOVE = auto() # 在EMA上方但接近：ema < low <= ema + threshold + CROSS_CLOSE_ABOVE = auto() # 跨越EMA，收盘在上方：close > ema, low <= ema（含threshold范围内触碰） + ON_EMA = auto() # 收盘价在EMA附近：abs(close - ema) <= threshold + CROSS_CLOSE_BELOW = auto() # 跨越EMA，收盘在下方：close < ema, high >= ema（含threshold范围内触碰） + NEAR_BELOW = auto() # 在EMA下方但接近：ema - threshold <= high < ema + BELOW = auto() # 完全在EMA下方（远离）：high < ema - threshold + UNKNOWN = auto() # 未知（EMA值无效） + +class Chan_EMA_SEMANTIC(Enum): + """K线与EMA结合趋势方向的语义状态（用于交易判断）""" + STRONG_TREND = auto() # 7: 顺势K线完全在EMA趋势侧（强势，远未及EMA） + TREND_SIDE = auto() # 6: 完全在EMA趋势侧（正常趋势运行） + RECOVER = auto() # 5: 逆势后穿越EMA回到趋势侧（收复EMA，趋势恢复） + TOUCH_FAIL = auto() # 4: 逆势触碰EMA但未穿越（反弹/反抽力度不足） + DEEP_COUNTER = auto() # 3: 完全在EMA逆势侧（深度回调/反抽） + BREAK = auto() # 2: 穿越EMA，收盘在逆势侧（支撑/压力失败） + TOUCH_HOLD = auto() # 1: 触碰EMA，收盘守住趋势侧（支撑/压力有效） + WEAK_COUNTER = auto() # 8: 逆势K线完全在EMA逆势侧（弱势，远未到EMA） + APPROACHING = auto() # 9: K线接近EMA但未触碰（即将测试支撑/压力） + NEUTRAL = auto() # 0: 盘整/无法判断 class Chan_KL_TYPE(Enum): K_1S = auto() K_1M = auto() diff --git a/ChanKLC.py b/ChanKLC.py index 7a2c505..a0d6fc2 100644 --- a/ChanKLC.py +++ b/ChanKLC.py @@ -1,7 +1,7 @@ import copy from typing import Dict, Optional -from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_KLC_FX, Chan_K_DIR, Chan_MACD_STATE, Chan_PRICE_TREND +from ChanEnum import Chan_FX_TYPE, Chan_KLINE_DIR, Chan_BI_DIR, Chan_KLC_FX, Chan_K_DIR, Chan_MACD_STATE, Chan_PRICE_TREND, Chan_EMA_POS, Chan_EMA_SEMANTIC import ChanKLU import ChanCTime @@ -45,11 +45,247 @@ class ChanKLC(): self.state = Chan_MACD_STATE.UNKNOWN self.continue_div = False self.separate_div = False - self.ema52 = klu.ema52 self.ema24 = klu.ema24 + self.ema52 = klu.ema52 + self.ema104 = klu.ema104 + self.ema156 = klu.ema156 + self.ema208 = klu.ema208 self.trend = Chan_PRICE_TREND.UNKNOWN self.exception = klu.exception self.klc_dir = Chan_KLINE_DIR.UP if klu.close > klu.open else Chan_KLINE_DIR.DOWN + self.ema_dir = klu.ema_dir + self.bsp = False + # EMA状态字典：key为EMA名称，value为 {'pos': Chan_EMA_POS, 'semantic': Chan_EMA_SEMANTIC} + self.ema_status = {} + # 向后兼容：保留 ema52_status 和 ema52_pos + self.ema52_status = 0 + self.ema52_pos = Chan_EMA_POS.UNKNOWN + self.cal_all_ema_status() + + # ==================== EMA 通用计算方法 ==================== + + @staticmethod + def cal_ema_pos(high, low, close, ema_value, threshold=0): + """ + 计算K线与任意EMA的客观位置关系（与趋势方向无关，支持threshold容差） + + 参数: + high, low, close: K线的高低收盘价 + ema_value: EMA的值 + threshold: 容差值（绝对值），在此范围内视为"接近/触碰" + 例如 BTC 价格 $100,000 时 threshold=100 表示差100点视为触碰 + 返回: + Chan_EMA_POS 枚举值 + + 判断逻辑（以threshold=100, ema=97000为例）： + ema_zone = [96900, 97100] （EMA上下各扩展threshold） + + ABOVE: low > 97100 K线完全在zone上方（远离EMA） + NEAR_ABOVE: 97000 < low <= 97100 K线在上方但下影线进入zone（接近EMA） + CROSS_CLOSE_ABOVE: close > 97000, low <= 97000 K线穿越EMA，收盘在上方 + ON_EMA: abs(close - 97000) <= 100 收盘价在zone内 + CROSS_CLOSE_BELOW: close < 97000, high >= 97000 K线穿越EMA，收盘在下方 + NEAR_BELOW: 96900 <= high < 97000 K线在下方但上影线进入zone（接近EMA） + BELOW: high < 96900 K线完全在zone下方（远离EMA） + """ + if ema_value is None or ema_value == 0: + return Chan_EMA_POS.UNKNOWN + + ema_upper = ema_value + threshold # EMA zone 上界 + ema_lower = ema_value - threshold # EMA zone 下界 + + # 1. 收盘价在EMA附近（zone内） + if threshold > 0 and abs(close - ema_value) <= threshold: + # 收盘价在zone内，但还需要看是否有实际穿越 + if low <= ema_value and close >= ema_value: + return Chan_EMA_POS.CROSS_CLOSE_ABOVE # 实际穿越了精确EMA线 + elif high >= ema_value and close <= ema_value: + return Chan_EMA_POS.CROSS_CLOSE_BELOW + return Chan_EMA_POS.ON_EMA + + # 2. K线实际穿越了精确的EMA线 + if close > ema_value and low <= ema_value: + return Chan_EMA_POS.CROSS_CLOSE_ABOVE + if close < ema_value and high >= ema_value: + return Chan_EMA_POS.CROSS_CLOSE_BELOW + if close == ema_value: + return Chan_EMA_POS.ON_EMA + + # 3. 没有实际穿越，检查是否"接近"（在threshold zone内） + if close > ema_value: + # K线在EMA上方 + if threshold > 0 and low <= ema_upper: + return Chan_EMA_POS.NEAR_ABOVE # 下影线进入zone，接近但未触碰 + return Chan_EMA_POS.ABOVE # 远离EMA + else: + # K线在EMA下方 + if threshold > 0 and high >= ema_lower: + return Chan_EMA_POS.NEAR_BELOW # 上影线进入zone，接近但未触碰 + return Chan_EMA_POS.BELOW # 远离EMA + + @staticmethod + def cal_ema_semantic(ema_pos, kline_dir, ema_dir): + """ + 根据客观位置 + K线方向 + 趋势方向，计算语义状态 + + 参数: + ema_pos: Chan_EMA_POS 客观位置 + kline_dir: Chan_KLINE_DIR K线方向 (UP/DOWN/COMBINE/INCLUDED) + ema_dir: int 趋势方向 (1=多头, -1=空头, 0=盘整) + 返回: + Chan_EMA_SEMANTIC 枚举值 + + 语义含义（以多头为例，空头完全对称）： + TOUCH_HOLD: 触碰EMA，收盘守住趋势侧（支撑/压力有效） + BREAK: 穿越EMA，收盘在逆势侧（支撑/压力失败） + DEEP_COUNTER: 完全在EMA逆势侧（深度回调/反抽） + TOUCH_FAIL: 逆势触碰EMA但未穿越（反弹/反抽力度不足） + RECOVER: 逆势后穿越EMA回到趋势侧（收复EMA） + TREND_SIDE: 完全在EMA趋势侧（正常运行） + STRONG_TREND: 顺势K线完全在EMA趋势侧（强势，远未及EMA） + WEAK_COUNTER: 逆势K线完全在EMA逆势侧（弱势，远未到EMA） + """ + if ema_pos == Chan_EMA_POS.UNKNOWN: + return Chan_EMA_SEMANTIC.NEUTRAL + + # 统一处理：将多头/盘整和空头映射到同一套逻辑 + # is_bull=True 时，"趋势侧"=上方，"逆势侧"=下方 + # is_bull=False时，"趋势侧"=下方，"逆势侧"=上方 + is_bull = ema_dir >= 0 # 多头和盘整都按多头逻辑处理 + + # K线是否是顺势方向（多头下UP为顺势，空头下DOWN为顺势） + is_trend_kline = (kline_dir == Chan_KLINE_DIR.UP) if is_bull else (kline_dir == Chan_KLINE_DIR.DOWN) + is_counter_kline = (kline_dir == Chan_KLINE_DIR.DOWN) if is_bull else (kline_dir == Chan_KLINE_DIR.UP) + + # 位置映射：多头下 ABOVE=趋势侧, BELOW=逆势侧; 空头反过来 + trend_side = Chan_EMA_POS.ABOVE if is_bull else Chan_EMA_POS.BELOW + counter_side = Chan_EMA_POS.BELOW if is_bull else Chan_EMA_POS.ABOVE + near_trend = Chan_EMA_POS.NEAR_ABOVE if is_bull else Chan_EMA_POS.NEAR_BELOW + near_counter = Chan_EMA_POS.NEAR_BELOW if is_bull else Chan_EMA_POS.NEAR_ABOVE + cross_to_trend = Chan_EMA_POS.CROSS_CLOSE_ABOVE if is_bull else Chan_EMA_POS.CROSS_CLOSE_BELOW + cross_to_counter = Chan_EMA_POS.CROSS_CLOSE_BELOW if is_bull else Chan_EMA_POS.CROSS_CLOSE_ABOVE + + # COMBINE / INCLUDED 方向：只看位置，不区分强弱 + if not is_trend_kline and not is_counter_kline: + if ema_pos == trend_side: + return Chan_EMA_SEMANTIC.TREND_SIDE + elif ema_pos in (near_trend, cross_to_trend, Chan_EMA_POS.ON_EMA): + return Chan_EMA_SEMANTIC.APPROACHING + elif ema_pos in (near_counter, cross_to_counter): + return Chan_EMA_SEMANTIC.APPROACHING + elif ema_pos == counter_side: + return Chan_EMA_SEMANTIC.DEEP_COUNTER + return Chan_EMA_SEMANTIC.NEUTRAL + + # 逆势K线（多头下的下跌K线 / 空头下的上涨K线） + if is_counter_kline: + if ema_pos == trend_side: + return Chan_EMA_SEMANTIC.STRONG_TREND # 逆势K线仍在趋势侧（回调很浅） + elif ema_pos == near_trend: + return Chan_EMA_SEMANTIC.APPROACHING # 接近EMA，即将测试支撑/压力 + elif ema_pos == cross_to_trend: + return Chan_EMA_SEMANTIC.TOUCH_HOLD # 触碰EMA后守住趋势侧 + elif ema_pos == Chan_EMA_POS.ON_EMA: + return Chan_EMA_SEMANTIC.TOUCH_HOLD # 收盘在EMA附近，视为守住 + elif ema_pos == cross_to_counter: + return Chan_EMA_SEMANTIC.BREAK # 穿越EMA到逆势侧 + elif ema_pos == near_counter: + return Chan_EMA_SEMANTIC.BREAK # 接近EMA但收盘在逆势侧，也视为击穿 + elif ema_pos == counter_side: + return Chan_EMA_SEMANTIC.DEEP_COUNTER # 完全在逆势侧 + + # 顺势K线（多头下的上涨K线 / 空头下的下跌K线） + if is_trend_kline: + if ema_pos == counter_side: + return Chan_EMA_SEMANTIC.WEAK_COUNTER # 顺势K线却在逆势侧（弱势） + elif ema_pos == near_counter: + return Chan_EMA_SEMANTIC.APPROACHING # 从逆势侧接近EMA + elif ema_pos == cross_to_counter: + return Chan_EMA_SEMANTIC.TOUCH_FAIL # 触碰EMA但未穿越回趋势侧 + elif ema_pos == Chan_EMA_POS.ON_EMA: + return Chan_EMA_SEMANTIC.TOUCH_FAIL # 收盘在EMA附近，未确认突破 + elif ema_pos == cross_to_trend: + return Chan_EMA_SEMANTIC.RECOVER # 从逆势侧穿越回趋势侧 + elif ema_pos == near_trend: + return Chan_EMA_SEMANTIC.RECOVER # 接近趋势侧（刚收复EMA附近） + elif ema_pos == trend_side: + return Chan_EMA_SEMANTIC.TREND_SIDE # 完全在趋势侧（正常） + + return Chan_EMA_SEMANTIC.NEUTRAL + + @staticmethod + def semantic_to_int(semantic): + """将 Chan_EMA_SEMANTIC 枚举转换为整数，兼容旧的 ema52_status 数值""" + mapping = { + Chan_EMA_SEMANTIC.TOUCH_HOLD: 1, + Chan_EMA_SEMANTIC.BREAK: 2, + Chan_EMA_SEMANTIC.DEEP_COUNTER: 3, + Chan_EMA_SEMANTIC.TOUCH_FAIL: 4, + Chan_EMA_SEMANTIC.RECOVER: 5, + Chan_EMA_SEMANTIC.TREND_SIDE: 6, + Chan_EMA_SEMANTIC.STRONG_TREND: 7, + Chan_EMA_SEMANTIC.WEAK_COUNTER: 8, + Chan_EMA_SEMANTIC.APPROACHING: 9, + Chan_EMA_SEMANTIC.NEUTRAL: 0, + } + return mapping.get(semantic, 0) + + # threshold_pct: 阈值百分比，用于自动计算绝对阈值 + # 例如 0.001 表示 EMA 值的 0.1%，BTC $100,000 时 threshold = $100 + threshold_pct = 0.001 + + def cal_all_ema_status(self): + """ + 统一计算所有EMA与K线的位置关系和语义状态 + + threshold 自动按 EMA 值的百分比计算（cls.threshold_pct，默认0.1%） + - BTC $100,000 时：threshold ≈ $100 + - ETH $3,000 时：threshold ≈ $3 + - SOL $200 时：threshold ≈ $0.2 + + 结果存储在 self.ema_status 字典中，格式： + { + 'ema24': {'pos': Chan_EMA_POS, 'semantic': Chan_EMA_SEMANTIC, 'value': float, 'threshold': float}, + 'ema52': {...}, + ... + } + + 同时保持向后兼容：self.ema52_pos 和 self.ema52_status + """ + ema_configs = { + 'ema24': self.ema24, + 'ema52': self.ema52, + 'ema104': self.ema104, + 'ema156': self.ema156, + 'ema208': self.ema208, + } + self.ema_status = {} + for name, value in ema_configs.items(): + # 按 EMA 值的百分比自动计算阈值 + threshold = abs(value) * self.threshold_pct if value and self.threshold_pct > 0 else 0 + pos = ChanKLC.cal_ema_pos(self.high, self.low, self.close, value, threshold) + semantic = ChanKLC.cal_ema_semantic(pos, self.dir, self.ema_dir) + self.ema_status[name] = { + 'pos': pos, + 'semantic': semantic, + 'value': value, + 'threshold': threshold, + } + # 向后兼容 + self.ema52_pos = self.ema_status['ema52']['pos'] + self.ema52_status = ChanKLC.semantic_to_int(self.ema_status['ema52']['semantic']) + + def get_ema_pos(self, ema_name): + """获取指定EMA的客观位置，如 klc.get_ema_pos('ema24')""" + if ema_name in self.ema_status: + return self.ema_status[ema_name]['pos'] + return Chan_EMA_POS.UNKNOWN + + def get_ema_semantic(self, ema_name): + """获取指定EMA的语义状态，如 klc.get_ema_semantic('ema52')""" + if ema_name in self.ema_status: + return self.ema_status[ema_name]['semantic'] + return Chan_EMA_SEMANTIC.NEUTRAL def set_trend(self, trend): self.trend = trend def to_string(self): @@ -123,14 +359,23 @@ class ChanKLC(): self.rsi += self.klu_list[index].rsi self.volume_ratio += self.klu_list[index].volume_ratio self.macdhist += self.klu_list[index].macdhist - self.ema52 += self.klu_list[index].ema52 self.ema24 += self.klu_list[index].ema24 - self.rsi = self.rsi / len(self.klu_list) - self.volume_ratio = self.volume_ratio / len(self.klu_list) - self.volume = self.volume / len(self.klu_list) - self.macdhist = self.macdhist / len(self.klu_list) - self.ema52 = self.ema52 / len(self.klu_list) - self.ema24 = self.ema24 / len(self.klu_list) + self.ema52 += self.klu_list[index].ema52 + self.ema104 += self.klu_list[index].ema104 + self.ema156 += self.klu_list[index].ema156 + self.ema208 += self.klu_list[index].ema208 + if self.ema_dir != self.klu_list[index].ema_dir: + self.ema_dir = 0 + n = len(self.klu_list) + self.rsi = self.rsi / n + self.volume_ratio = self.volume_ratio / n + self.volume = self.volume / n + self.macdhist = self.macdhist / n + self.ema24 = self.ema24 / n + self.ema52 = self.ema52 / n + self.ema104 = self.ema104 / n + self.ema156 = self.ema156 / n + self.ema208 = self.ema208 / n if len(self.klu_list) > 0: self.macd = self.klu_list[-1].macd self.signal = self.klu_list[-1].signal diff --git a/ChanKLU.py b/ChanKLU.py index 0934a66..117a3dd 100644 --- a/ChanKLU.py +++ b/ChanKLU.py @@ -69,6 +69,8 @@ class ChanKLU: self.mode4_touch52_no_zero = False # 先触碰EMA52但黄白线未归零 self.div_type = "none" # {bearish, bullish, hidden_bearish, hidden_bullish, none} self.div_score = 0.0 # 背离强度(0-100) + self.ema_dir = 0 + self.get_ema_dir() #print(self.open, self.close, self.high, self.low, self.candle_dir, self.strength) def set_macd_state(self, state): self.macd_state = state @@ -123,14 +125,14 @@ class ChanKLU: return 0 else: return 0 - def ema_pattern(self): + def get_ema_dir(self): if self.check_indicators(): if self.ema24 > self.ema52 and self.ema52 > self.ema104 and self.ema104 > self.ema156: - return 1 + self.ema_dir = 1 elif self.ema24 < self.ema52 and self.ema52 < self.ema104 and self.ema104 < self.ema156: - return -1 + self.ema_dir = -1 else: - return 0 + self.ema_dir = 0 def check_indicators(self): if self.ema156 == 0: return False diff --git a/ChanLun.py b/ChanLun.py index 936053b..a6f6c0b 100644 --- a/ChanLun.py +++ b/ChanLun.py @@ -51,9 +51,9 @@ class ChanLun(): self.time1y = 12*30*24*60 self.time_M_intervals = [2*30*24*60, 3*30*24*60, 6*30*24*60, 12*30*24*60] self.time_M_symbols = ['2M', '3M', '6M', '1y'] - self.time_symbols = ['1m', '2m', '3m', '5m', '10m', '15m', '20m', '30m', '45m','1h', '2h', '4h', '6h', '8h', '12h', '16h', '1d', '2d', '3d', '1w', '2w', '1M', '3M', '6M', '1y'] + self.time_symbols = ['1m', '2m', '3m', '5m', '10m', '15m', '20m', '30m', '45m','1h', '2h', '4h', '6h', '8h', '12h', '16h', '1d', '2d', '3d'] self.tf_df_dict = {} - self.ema_symbols = ['5m', '10m', '15m', '20m', '30m', '45m', '1h', '2h', '4h', '6h', '8h', '12h', '16h', '1d', '2d', '3d'] + self.ema_symbols = ['5m', '15m', '30m', '45m', '1h', '2h', '4h', '8h', '12h', '1d', '2d', '3d'] self.tf_df = TF_DF() def init_data(self, dataframe, intervals, timeframes): for index in range(0, len(intervals)): @@ -74,10 +74,10 @@ class ChanLun(): if dataframe_d is not None: self.tf_df_dict['1d'] = TF_DF(dataframe_d, 1, '1d') self.init_data(dataframe_d, self.time_d_intervals, self.time_d_symbols) - if dataframe_w is not None: + if dataframe_w is not None and False: self.tf_df_dict['1w'] = TF_DF(dataframe_w, 1, '1w') self.init_data(dataframe_w, self.time_w_intervals, self.time_w_symbols) - if dataframe_M is not None: + if dataframe_M is not None and False: self.tf_df_dict['1M'] = TF_DF(dataframe_M, 1, '1M') self.init_data(dataframe_M, self.time_M_intervals, self.time_M_symbols) def get_ema52_dict(self): @@ -105,7 +105,12 @@ class ChanLun(): if abs(price - ema52_dict[key]) < 100: key_list.append(key) return key_list - + def get_ema_bsp(self, long_tf='1h', short_tf='15m'): + if long_tf in self.tf_df_dict and short_tf in self.tf_df_dict: + long_df = self.tf_df_dict[long_tf] + short_df = self.tf_df_dict[short_tf] + return long_df.get_ema_bsp(short_df) + return None diff --git a/TF_DF.py b/TF_DF.py index e78c94d..2100b79 100644 --- a/TF_DF.py +++ b/TF_DF.py @@ -40,6 +40,7 @@ class TF_DF(): self.zs_list = [] self.bsp_list = [] self.seg_list = [] + self.klc_fx_list = [] self.klu_list = self.cal_kl_data(self.dataframe) self.klc_list = self.get_klc_list(self.klu_list) self.bi_list = self.cal_bi_list(self.klc_list) @@ -47,6 +48,8 @@ class TF_DF(): self.zs_list = self.get_zs_list(self.bi_list, self.seg_list) self.chanmacd = ChanMACD(self.klu_list) self.klu_list = self.chanmacd.cal_macd_state() + + def get_ema52(self, index=-1): if self.klu_list: ema52_value = self.klu_list[index].ema52 diff --git a/strategies/ChanLun_EMA52.py b/strategies/ChanLun_EMA52.py index 566d047..6af06e7 100644 --- a/strategies/ChanLun_EMA52.py +++ b/strategies/ChanLun_EMA52.py @@ -112,27 +112,25 @@ class ChanLun_EMA52(IStrategy): def informative_pairs(self): return [(self.pair, "1h"), (self.pair, "1d"), - (self.pair, "1M"), + #(self.pair, "1M"), (self.pair, "15m"), - (self.pair, "1w"), + #(self.pair, "1w"), ] def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame: dataframe = self.add_indicators(dataframe) long_df = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1h') long_df = self.add_indicators(long_df) - long_df['entry_long'] = self.long_entry_condition(long_df) dataframe['rsi'] = ta.RSI(long_df, timeperiod=14) - if self.last_time is None or self.last_time + timedelta(minutes=1) < datetime.now(): + if self.last_time is None or self.last_time + timedelta(seconds=10) < datetime.now(): self.last_time = datetime.now() logger.info("init_dataframes----------------------------") last_price = dataframe.iloc[-1]['close'] - macdstr = str(long_df.iloc[-1]['macd']) + " " + str(long_df.iloc[-1]['macdsignal']) + " " + str(long_df.iloc[-1]['macdhist']) date = dataframe.iloc[-1]['date'] tf_ema52_list = self.chan.check_price_ema52(last_price) self.init_dataframes(dataframe) - logger.info("Date: " + date.strftime('%Y-%m-%d %H:%M:%S') + " Price: " + str(last_price) + " EMA52_list: " + str(tf_ema52_list) + " MACD: " + macdstr) + logger.info("Date: " + date.strftime('%Y-%m-%d %H:%M:%S') + " Price: " + str(last_price) + " EMA52_list: " + str(tf_ema52_list)) + #print(long_df.iloc[-1]) dataframe = resampled_merge(dataframe, long_df) - #print(dataframe.iloc[-1]) return dataframe def ema_dir(self, dataframe): """ @@ -200,9 +198,6 @@ class ChanLun_EMA52(IStrategy): dataframe['ema_slope'] = (ema52 - ema52.shift(3)) / ema52.shift(3) * 100 return dataframe - def long_entry_condition(self, long_df): - long_entry_condition = (long_df['dir52'] > 0) & (long_df['dir156'] > 0) & (long_df['macdhist'] > 0) - return long_entry_condition def add_indicators(self, dataframe): dataframe['ema24'] = ta.EMA(dataframe, timeperiod=24) dataframe['dir24'] = dataframe['close'] - dataframe['ema24'] @@ -222,10 +217,9 @@ class ChanLun_EMA52(IStrategy): dataframe_15m = self.dp.get_pair_dataframe(pair=self.pair, timeframe='15m') dataframe_1h = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1h') dataframe_1d = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1d') - dataframe_1w = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1w') - dataframe_1M = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1M') - self.chan = ChanLun() - self.chan.init_dataframes(dataframe_1m, dataframe_15m,dataframe_1h, dataframe_1d, dataframe_1w, dataframe_1M) + #dataframe_1w = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1w') + #dataframe_1M = self.dp.get_pair_dataframe(pair=self.pair, timeframe='1M') + self.chan.init_dataframes(dataframe_1m, dataframe_15m,dataframe_1h, dataframe_1d) def custom_entry_price(self, pair: str, trade: Trade | None, current_time: datetime, proposed_rate: float, entry_tag: str | None, side: str, **kwargs) -> float: new_entryprice = proposed_rate