TIANHE
689 lines
29 KiB
Python
689 lines
29 KiB
Python
import json
|
|
from typing import Dict, Any, List
|
|
|
|
class StrategyCompiler:
|
|
def compile(self, config: Dict[str, Any]) -> str:
|
|
"""
|
|
Compiles the strategy configuration JSON into executable Python code.
|
|
"""
|
|
|
|
# Extract configurations
|
|
name = config.get('name', 'Generated Strategy')
|
|
entry_rules = config.get('entry_rules', [])
|
|
position_config = config.get('position_config', {})
|
|
pyramiding_rules = config.get('pyramiding_rules', {})
|
|
risk_management = config.get('risk_management', {})
|
|
|
|
# 1. Imports and Setup
|
|
code = self._get_header(name)
|
|
|
|
# 2. Parameters (Variables)
|
|
code += self._get_parameters(position_config, pyramiding_rules, risk_management)
|
|
|
|
# 3. Indicators Calculation
|
|
code += self._get_indicators_calculation(entry_rules)
|
|
|
|
# 4. Signal Logic (Entry Conditions)
|
|
code += self._get_entry_logic(entry_rules)
|
|
|
|
# 5. Core Loop (Position Management) - Based on code2.py
|
|
code += self._get_core_loop(position_config, pyramiding_rules, risk_management)
|
|
|
|
# 6. Output Formatting
|
|
code += self._get_output_section(name, entry_rules)
|
|
|
|
return code
|
|
|
|
def _get_header(self, name):
|
|
return f'''
|
|
# Generated Strategy: {name}
|
|
import pandas as pd
|
|
import numpy as np
|
|
|
|
# Helper function for checking signals safely
|
|
def get_val(arr, i, default=0):
|
|
if i < 0 or i >= len(arr): return default
|
|
return arr[i]
|
|
'''
|
|
|
|
def _get_parameters(self, pos_config, pyr_rules, risk_mgmt):
|
|
# Default values
|
|
initial_size = pos_config.get('initial_size_pct', 10) / 100.0
|
|
leverage = pos_config.get('leverage', 1)
|
|
max_pyramiding = pos_config.get('max_pyramiding', 0)
|
|
|
|
pyr_enabled = pyr_rules.get('enabled', False)
|
|
add_size = pyr_rules.get('size_pct', 0) / 100.0 if pyr_enabled else 0
|
|
add_threshold = pyr_rules.get('value', 0) / 100.0
|
|
|
|
stop_loss = risk_mgmt.get('stop_loss', {})
|
|
sl_enabled = stop_loss.get('enabled', False)
|
|
sl_pct = stop_loss.get('value', 0) / 100.0 if sl_enabled else 0.0
|
|
|
|
trailing = risk_mgmt.get('trailing_stop', {})
|
|
ts_enabled = trailing.get('enabled', False)
|
|
ts_activation = trailing.get('activation_profit', 0) / 100.0
|
|
ts_callback = trailing.get('callback_pct', 0) / 100.0
|
|
|
|
return f'''
|
|
# ===========================
|
|
# 1. Parameters
|
|
# ===========================
|
|
initial_position_pct = {initial_size}
|
|
leverage = {leverage}
|
|
max_pyramiding = {max_pyramiding}
|
|
|
|
# Pyramiding
|
|
add_position_pct = {add_size}
|
|
add_threshold_pct = {add_threshold}
|
|
|
|
# Risk Management
|
|
stop_loss_pct = {sl_pct}
|
|
take_profit_activation = {ts_activation}
|
|
trailing_callback = {ts_callback}
|
|
'''
|
|
|
|
def _get_indicators_calculation(self, rules):
|
|
code = """
|
|
# ===========================
|
|
# 2. Indicators Calculation
|
|
# ===========================
|
|
"""
|
|
calculated = set()
|
|
|
|
for rule in rules:
|
|
ind = rule.get('indicator')
|
|
params = rule.get('params', {})
|
|
|
|
if ind == 'supertrend':
|
|
key = f"st_{params.get('period')}_{params.get('multiplier')}"
|
|
if key not in calculated:
|
|
code += f"""
|
|
# SuperTrend ({params.get('period')}, {params.get('multiplier')})
|
|
period = {params.get('period', 14)}
|
|
multiplier = {params.get('multiplier', 3.0)}
|
|
df['hl2'] = (df['high'] + df['low']) / 2
|
|
df['tr'] = np.maximum(df['high'] - df['low'], np.maximum(abs(df['high'] - df['close'].shift(1)), abs(df['low'] - df['close'].shift(1))))
|
|
df['atr'] = df['tr'].ewm(alpha=1/period, adjust=False).mean()
|
|
df['basic_upper'] = df['hl2'] + (multiplier * df['atr'])
|
|
df['basic_lower'] = df['hl2'] - (multiplier * df['atr'])
|
|
|
|
final_upper = [0.0] * len(df)
|
|
final_lower = [0.0] * len(df)
|
|
trend = [1] * len(df)
|
|
close_arr = df['close'].values
|
|
basic_upper = np.nan_to_num(df['basic_upper'].values)
|
|
basic_lower = np.nan_to_num(df['basic_lower'].values)
|
|
|
|
for i in range(1, len(df)):
|
|
if basic_upper[i] < final_upper[i-1] or close_arr[i-1] > final_upper[i-1]:
|
|
final_upper[i] = basic_upper[i]
|
|
else:
|
|
final_upper[i] = final_upper[i-1]
|
|
|
|
if basic_lower[i] > final_lower[i-1] or close_arr[i-1] < final_lower[i-1]:
|
|
final_lower[i] = basic_lower[i]
|
|
else:
|
|
final_lower[i] = final_lower[i-1]
|
|
|
|
prev_trend = trend[i-1]
|
|
if prev_trend == -1 and close_arr[i] > final_upper[i-1]:
|
|
trend[i] = 1
|
|
elif prev_trend == 1 and close_arr[i] < final_lower[i-1]:
|
|
trend[i] = -1
|
|
else:
|
|
trend[i] = prev_trend
|
|
|
|
df['st_trend'] = trend
|
|
df['st_upper'] = final_upper
|
|
df['st_lower'] = final_lower
|
|
"""
|
|
calculated.add(key)
|
|
|
|
elif ind == 'ema':
|
|
period = params.get('period', 20)
|
|
key = f"ema_{period}"
|
|
if key not in calculated:
|
|
code += f"\ndf['ema_{period}'] = df['close'].ewm(span={period}, adjust=False).mean()\n"
|
|
calculated.add(key)
|
|
|
|
elif ind == 'rsi':
|
|
period = params.get('period', 14)
|
|
key = f"rsi_{period}"
|
|
if key not in calculated:
|
|
code += f"""
|
|
# RSI ({period})
|
|
delta = df['close'].diff()
|
|
gain = (delta.where(delta > 0, 0)).rolling(window={period}).mean()
|
|
loss = (-delta.where(delta < 0, 0)).rolling(window={period}).mean()
|
|
rs = gain / loss
|
|
df['rsi_{period}'] = 100 - (100 / (1 + rs))
|
|
"""
|
|
calculated.add(key)
|
|
|
|
elif ind == 'macd':
|
|
fast = params.get('fast_period', 12)
|
|
slow = params.get('slow_period', 26)
|
|
signal = params.get('signal_period', 9)
|
|
key = f"macd_{fast}_{slow}_{signal}"
|
|
if key not in calculated:
|
|
code += f"""
|
|
# MACD ({fast}, {slow}, {signal})
|
|
exp1 = df['close'].ewm(span={fast}, adjust=False).mean()
|
|
exp2 = df['close'].ewm(span={slow}, adjust=False).mean()
|
|
df['macd_{fast}_{slow}_{signal}_line'] = exp1 - exp2
|
|
df['macd_{fast}_{slow}_{signal}_signal'] = df['macd_{fast}_{slow}_{signal}_line'].ewm(span={signal}, adjust=False).mean()
|
|
df['macd_{fast}_{slow}_{signal}_hist'] = df['macd_{fast}_{slow}_{signal}_line'] - df['macd_{fast}_{slow}_{signal}_signal']
|
|
"""
|
|
calculated.add(key)
|
|
|
|
elif ind == 'bollinger':
|
|
period = params.get('period', 20)
|
|
std_dev = params.get('std_dev', 2.0)
|
|
key = f"bb_{period}_{std_dev}"
|
|
if key not in calculated:
|
|
code += f"""
|
|
# Bollinger Bands ({period}, {std_dev})
|
|
sma = df['close'].rolling(window={period}).mean()
|
|
std = df['close'].rolling(window={period}).std()
|
|
df['bb_{period}_{std_dev}_upper'] = sma + ({std_dev} * std)
|
|
df['bb_{period}_{std_dev}_lower'] = sma - ({std_dev} * std)
|
|
df['bb_{period}_{std_dev}_mid'] = sma
|
|
"""
|
|
calculated.add(key)
|
|
|
|
elif ind == 'kdj':
|
|
period = params.get('period', 9)
|
|
signal_period = params.get('signal_period', 3)
|
|
key = f"kdj_{period}_{signal_period}"
|
|
if key not in calculated:
|
|
code += f"""
|
|
# KDJ ({period}, {signal_period})
|
|
low_min = df['low'].rolling(window={period}).min()
|
|
high_max = df['high'].rolling(window={period}).max()
|
|
rsv = (df['close'] - low_min) / (high_max - low_min) * 100
|
|
df['kdj_{period}_{signal_period}_k'] = rsv.ewm(alpha=1/{signal_period}, adjust=False).mean()
|
|
df['kdj_{period}_{signal_period}_d'] = df['kdj_{period}_{signal_period}_k'].ewm(alpha=1/{signal_period}, adjust=False).mean()
|
|
df['kdj_{period}_{signal_period}_j'] = 3 * df['kdj_{period}_{signal_period}_k'] - 2 * df['kdj_{period}_{signal_period}_d']
|
|
"""
|
|
calculated.add(key)
|
|
|
|
elif ind == 'ma':
|
|
period = params.get('period', 20)
|
|
ma_type = params.get('ma_type', 'sma')
|
|
key = f"ma_{ma_type}_{period}"
|
|
if key not in calculated:
|
|
if ma_type == 'ema':
|
|
code += f"\ndf['ma_{ma_type}_{period}'] = df['close'].ewm(span={period}, adjust=False).mean()\n"
|
|
else:
|
|
code += f"\ndf['ma_{ma_type}_{period}'] = df['close'].rolling(window={period}).mean()\n"
|
|
calculated.add(key)
|
|
|
|
return code
|
|
|
|
def _get_entry_logic(self, rules):
|
|
code = """
|
|
# ===========================
|
|
# 3. Entry Signal Logic
|
|
# ===========================
|
|
# Default False
|
|
df['raw_buy'] = False
|
|
df['raw_sell'] = False
|
|
"""
|
|
conditions_buy = []
|
|
conditions_sell = []
|
|
|
|
for rule in rules:
|
|
ind = rule.get('indicator')
|
|
params = rule.get('params', {})
|
|
|
|
if ind == 'supertrend':
|
|
signal = rule.get('signal', 'trend_bullish')
|
|
if signal == 'trend_bullish':
|
|
conditions_buy.append("(df['st_trend'] == 1) & (df['st_trend'].shift(1) == -1)")
|
|
conditions_sell.append("(df['st_trend'] == -1) & (df['st_trend'].shift(1) == 1)")
|
|
elif signal == 'is_uptrend':
|
|
conditions_buy.append("(df['st_trend'] == 1)")
|
|
conditions_sell.append("(df['st_trend'] == -1)")
|
|
|
|
elif ind == 'ema':
|
|
period = params.get('period', 20)
|
|
operator = rule.get('operator', 'price_above')
|
|
col = f"df['ema_{period}']"
|
|
if operator == 'price_above':
|
|
conditions_buy.append(f"(df['close'] > {col})")
|
|
conditions_sell.append(f"(df['close'] < {col})")
|
|
elif operator == 'price_below':
|
|
conditions_buy.append(f"(df['close'] < {col})")
|
|
conditions_sell.append(f"(df['close'] > {col})")
|
|
elif operator == 'cross_up':
|
|
conditions_buy.append(f"(df['close'] > {col}) & (df['close'].shift(1) <= {col}.shift(1))")
|
|
conditions_sell.append(f"(df['close'] < {col}) & (df['close'].shift(1) >= {col}.shift(1))")
|
|
elif operator == 'cross_down':
|
|
conditions_buy.append(f"(df['close'] < {col}) & (df['close'].shift(1) >= {col}.shift(1))")
|
|
conditions_sell.append(f"(df['close'] > {col}) & (df['close'].shift(1) <= {col}.shift(1))")
|
|
|
|
elif ind == 'rsi':
|
|
period = params.get('period', 14)
|
|
operator = rule.get('operator', '<')
|
|
thresh = params.get('threshold', 30)
|
|
col = f"df['rsi_{period}']"
|
|
if operator == '<':
|
|
conditions_buy.append(f"({col} < {thresh})")
|
|
conditions_sell.append(f"({col} > {100-thresh})")
|
|
elif operator == '>':
|
|
conditions_buy.append(f"({col} > {thresh})")
|
|
conditions_sell.append(f"({col} < {100-thresh})")
|
|
elif operator == 'cross_up':
|
|
conditions_buy.append(f"({col} > {thresh}) & ({col}.shift(1) <= {thresh})")
|
|
conditions_sell.append(f"({col} < {100-thresh}) & ({col}.shift(1) >= {100-thresh})")
|
|
elif operator == 'cross_down':
|
|
conditions_buy.append(f"({col} < {thresh}) & ({col}.shift(1) >= {thresh})")
|
|
conditions_sell.append(f"({col} > {100-thresh}) & ({col}.shift(1) <= {100-thresh})")
|
|
|
|
elif ind == 'macd':
|
|
fast = params.get('fast_period', 12)
|
|
slow = params.get('slow_period', 26)
|
|
signal = params.get('signal_period', 9)
|
|
operator = rule.get('operator', 'diff_gt_dea')
|
|
line_col = f"df['macd_{fast}_{slow}_{signal}_line']"
|
|
sig_col = f"df['macd_{fast}_{slow}_{signal}_signal']"
|
|
|
|
if operator == 'diff_gt_dea':
|
|
conditions_buy.append(f"({line_col} > {sig_col})")
|
|
conditions_sell.append(f"({line_col} < {sig_col})")
|
|
elif operator == 'diff_lt_dea':
|
|
conditions_buy.append(f"({line_col} < {sig_col})")
|
|
conditions_sell.append(f"({line_col} > {sig_col})")
|
|
elif operator == 'cross_up':
|
|
conditions_buy.append(f"({line_col} > {sig_col}) & ({line_col}.shift(1) <= {sig_col}.shift(1))")
|
|
conditions_sell.append(f"({line_col} < {sig_col}) & ({line_col}.shift(1) >= {sig_col}.shift(1))")
|
|
elif operator == 'cross_down':
|
|
conditions_buy.append(f"({line_col} < {sig_col}) & ({line_col}.shift(1) >= {sig_col}.shift(1))")
|
|
conditions_sell.append(f"({line_col} > {sig_col}) & ({line_col}.shift(1) <= {sig_col}.shift(1))")
|
|
|
|
elif ind == 'bollinger':
|
|
period = params.get('period', 20)
|
|
std_dev = params.get('std_dev', 2.0)
|
|
operator = rule.get('operator', 'price_above_upper')
|
|
upper = f"df['bb_{period}_{std_dev}_upper']"
|
|
lower = f"df['bb_{period}_{std_dev}_lower']"
|
|
mid = f"df['bb_{period}_{std_dev}_mid']"
|
|
|
|
if operator == 'price_above_upper':
|
|
conditions_buy.append(f"(df['close'] > {upper})")
|
|
conditions_sell.append(f"(df['close'] < {lower})")
|
|
elif operator == 'price_below_lower':
|
|
conditions_buy.append(f"(df['close'] < {lower})")
|
|
conditions_sell.append(f"(df['close'] > {upper})")
|
|
elif operator == 'price_above_mid':
|
|
conditions_buy.append(f"(df['close'] > {mid})")
|
|
conditions_sell.append(f"(df['close'] < {mid})")
|
|
elif operator == 'price_below_mid':
|
|
conditions_buy.append(f"(df['close'] < {mid})")
|
|
conditions_sell.append(f"(df['close'] > {mid})")
|
|
elif operator == 'cross_up_lower':
|
|
conditions_buy.append(f"(df['close'] > {lower}) & (df['close'].shift(1) <= {lower}.shift(1))")
|
|
conditions_sell.append(f"(df['close'] < {upper}) & (df['close'].shift(1) >= {upper}.shift(1))")
|
|
elif operator == 'cross_down_upper':
|
|
conditions_buy.append(f"(df['close'] < {upper}) & (df['close'].shift(1) >= {upper}.shift(1))")
|
|
conditions_sell.append(f"(df['close'] > {lower}) & (df['close'].shift(1) <= {lower}.shift(1))")
|
|
|
|
elif ind == 'kdj':
|
|
period = params.get('period', 9)
|
|
signal_period = params.get('signal_period', 3)
|
|
operator = rule.get('operator', 'k_gt_d')
|
|
k_col = f"df['kdj_{period}_{signal_period}_k']"
|
|
d_col = f"df['kdj_{period}_{signal_period}_d']"
|
|
|
|
if operator == 'k_gt_d':
|
|
conditions_buy.append(f"({k_col} > {d_col})")
|
|
conditions_sell.append(f"({k_col} < {d_col})")
|
|
elif operator == 'k_lt_d':
|
|
conditions_buy.append(f"({k_col} < {d_col})")
|
|
conditions_sell.append(f"({k_col} > {d_col})")
|
|
elif operator == 'gold_cross':
|
|
conditions_buy.append(f"({k_col} > {d_col}) & ({k_col}.shift(1) <= {d_col}.shift(1))")
|
|
conditions_sell.append(f"({k_col} < {d_col}) & ({k_col}.shift(1) >= {d_col}.shift(1))")
|
|
elif operator == 'death_cross':
|
|
conditions_buy.append(f"({k_col} < {d_col}) & ({k_col}.shift(1) >= {d_col}.shift(1))")
|
|
conditions_sell.append(f"({k_col} > {d_col}) & ({k_col}.shift(1) <= {d_col}.shift(1))")
|
|
|
|
elif ind == 'ma':
|
|
period = params.get('period', 20)
|
|
ma_type = params.get('ma_type', 'sma')
|
|
operator = rule.get('operator', 'price_above')
|
|
col = f"df['ma_{ma_type}_{period}']"
|
|
|
|
if operator == 'price_above':
|
|
conditions_buy.append(f"(df['close'] > {col})")
|
|
conditions_sell.append(f"(df['close'] < {col})")
|
|
elif operator == 'price_below':
|
|
conditions_buy.append(f"(df['close'] < {col})")
|
|
conditions_sell.append(f"(df['close'] > {col})")
|
|
elif operator == 'cross_up':
|
|
conditions_buy.append(f"(df['close'] > {col}) & (df['close'].shift(1) <= {col}.shift(1))")
|
|
conditions_sell.append(f"(df['close'] < {col}) & (df['close'].shift(1) >= {col}.shift(1))")
|
|
elif operator == 'cross_down':
|
|
conditions_buy.append(f"(df['close'] < {col}) & (df['close'].shift(1) >= {col}.shift(1))")
|
|
conditions_sell.append(f"(df['close'] > {col}) & (df['close'].shift(1) <= {col}.shift(1))")
|
|
|
|
if conditions_buy:
|
|
code += f"\ndf['raw_buy'] = {' & '.join(conditions_buy)}\n"
|
|
if conditions_sell:
|
|
code += f"\ndf['raw_sell'] = {' & '.join(conditions_sell)}\n"
|
|
|
|
return code
|
|
|
|
def _get_core_loop(self, pos_config, pyr_rules, risk_mgmt):
|
|
# This mirrors the logic in code2.py loop
|
|
return """
|
|
# ===========================
|
|
# 4. Core Loop (Backtest)
|
|
# ===========================
|
|
open_long_signals = [False] * len(df)
|
|
add_long_signals = [False] * len(df)
|
|
close_long_signals = [False] * len(df)
|
|
|
|
open_long_text = [None] * len(df)
|
|
add_long_text = [None] * len(df)
|
|
|
|
open_long_price = [0.0] * len(df)
|
|
add_long_price = [0.0] * len(df)
|
|
close_long_price = [0.0] * len(df)
|
|
close_long_text = [None] * len(df)
|
|
|
|
open_short_signals = [False] * len(df)
|
|
add_short_signals = [False] * len(df)
|
|
close_short_signals = [False] * len(df)
|
|
|
|
open_short_price = [0.0] * len(df)
|
|
add_short_price = [0.0] * len(df)
|
|
close_short_price = [0.0] * len(df)
|
|
close_short_text = [None] * len(df)
|
|
|
|
position = 0 # 0, 1 (Long), -1 (Short)
|
|
position_count = 0
|
|
avg_entry_price = 0.0
|
|
last_add_price = 0.0
|
|
highest_price = 0.0 # For Long: Highest High; For Short: Lowest Low
|
|
|
|
close_arr = df['close'].values
|
|
high_arr = df['high'].values
|
|
low_arr = df['low'].values
|
|
raw_buy_arr = df['raw_buy'].values
|
|
raw_sell_arr = df['raw_sell'].values
|
|
|
|
for i in range(len(df)):
|
|
current_close = close_arr[i]
|
|
current_high = high_arr[i]
|
|
current_low = low_arr[i]
|
|
|
|
if position == 1:
|
|
# Long Position
|
|
if current_high > highest_price:
|
|
highest_price = current_high
|
|
|
|
profit_pct = (highest_price - avg_entry_price) / avg_entry_price
|
|
current_profit_pct = (current_close - avg_entry_price) / avg_entry_price
|
|
|
|
# 1. Trailing Stop
|
|
if take_profit_activation > 0 and profit_pct >= take_profit_activation:
|
|
drawdown = (highest_price - current_close) / avg_entry_price
|
|
if drawdown >= trailing_callback:
|
|
close_long_signals[i] = True
|
|
close_long_price[i] = current_close
|
|
close_long_text[i] = "Trailing Stop"
|
|
position = 0
|
|
position_count = 0
|
|
continue
|
|
|
|
# 2. Stop Loss
|
|
if stop_loss_pct > 0:
|
|
loss_pct = (avg_entry_price - current_low) / avg_entry_price
|
|
if loss_pct >= stop_loss_pct:
|
|
close_long_signals[i] = True
|
|
close_long_price[i] = avg_entry_price * (1 - stop_loss_pct)
|
|
close_long_text[i] = "Stop Loss"
|
|
position = 0
|
|
position_count = 0
|
|
continue
|
|
|
|
# 3. Signal Exit (if enabled)
|
|
# Note: Code2 uses raw_sell_arr for exit
|
|
if raw_sell_arr[i]:
|
|
close_long_signals[i] = True
|
|
close_long_price[i] = current_close
|
|
close_long_text[i] = "Signal Exit"
|
|
position = 0
|
|
position_count = 0
|
|
|
|
# Reverse to Short if trade_direction allows (simplified here)
|
|
# For now we just close.
|
|
continue
|
|
|
|
# 4. Pyramiding (Add Long)
|
|
if max_pyramiding > 0 and position_count < max_pyramiding + 1 and current_profit_pct > 0:
|
|
# Condition: Price rise by threshold
|
|
if add_threshold_pct > 0:
|
|
target_price = last_add_price * (1 + add_threshold_pct)
|
|
if current_high >= target_price:
|
|
add_long_signals[i] = True
|
|
add_long_price[i] = target_price
|
|
add_long_text[i] = "Add Long"
|
|
position_count += 1
|
|
last_add_price = target_price
|
|
|
|
elif position == -1:
|
|
# Short Position
|
|
# For Short, highest_price tracks the LOWEST price (best profit scenario)
|
|
if highest_price == 0: highest_price = avg_entry_price
|
|
if current_low < highest_price:
|
|
highest_price = current_low
|
|
|
|
# Profit: (Entry - Lowest) / Entry
|
|
profit_pct = (avg_entry_price - highest_price) / avg_entry_price
|
|
current_profit_pct = (avg_entry_price - current_close) / avg_entry_price
|
|
|
|
# 1. Trailing Stop
|
|
if take_profit_activation > 0 and profit_pct >= take_profit_activation:
|
|
# Drawdown: (Current - Lowest) / Entry
|
|
drawdown = (current_close - highest_price) / avg_entry_price
|
|
if drawdown >= trailing_callback:
|
|
close_short_signals[i] = True
|
|
close_short_price[i] = current_close
|
|
close_short_text[i] = "Trailing Stop"
|
|
position = 0
|
|
position_count = 0
|
|
continue
|
|
|
|
# 2. Stop Loss
|
|
if stop_loss_pct > 0:
|
|
# Loss: Price went up. (High - Entry) / Entry
|
|
loss_pct = (current_high - avg_entry_price) / avg_entry_price
|
|
if loss_pct >= stop_loss_pct:
|
|
close_short_signals[i] = True
|
|
close_short_price[i] = avg_entry_price * (1 + stop_loss_pct)
|
|
close_short_text[i] = "Stop Loss"
|
|
position = 0
|
|
position_count = 0
|
|
continue
|
|
|
|
# 3. Signal Exit
|
|
if raw_buy_arr[i]:
|
|
close_short_signals[i] = True
|
|
close_short_price[i] = current_close
|
|
close_short_text[i] = "Signal Exit"
|
|
position = 0
|
|
position_count = 0
|
|
continue
|
|
|
|
# 4. Pyramiding (Add Short)
|
|
if max_pyramiding > 0 and position_count < max_pyramiding + 1 and current_profit_pct > 0:
|
|
# Condition: Price drop by threshold
|
|
if add_threshold_pct > 0:
|
|
target_price = last_add_price * (1 - add_threshold_pct)
|
|
if current_low <= target_price:
|
|
add_short_signals[i] = True
|
|
add_short_price[i] = target_price
|
|
add_short_text[i] = "Add Short"
|
|
position_count += 1
|
|
last_add_price = target_price
|
|
|
|
else:
|
|
# No Position
|
|
if raw_buy_arr[i]:
|
|
open_long_signals[i] = True
|
|
open_long_price[i] = current_close
|
|
open_long_text[i] = "Open Long"
|
|
position = 1
|
|
position_count = 1
|
|
avg_entry_price = current_close
|
|
last_add_price = current_close
|
|
highest_price = current_close
|
|
|
|
elif raw_sell_arr[i]:
|
|
open_short_signals[i] = True
|
|
open_short_price[i] = current_close
|
|
open_short_text[i] = "Open Short"
|
|
position = -1
|
|
position_count = 1
|
|
avg_entry_price = current_close
|
|
last_add_price = current_close
|
|
highest_price = current_close # Init with Entry
|
|
|
|
# Append columns
|
|
df['open_long'] = open_long_signals
|
|
df['add_long'] = add_long_signals
|
|
df['close_long'] = close_long_signals
|
|
df['open_long_price'] = [p if s else None for p, s in zip(open_long_price, open_long_signals)]
|
|
df['add_long_price'] = [p if s else None for p, s in zip(add_long_price, add_long_signals)]
|
|
df['close_long_price'] = [p if s else None for p, s in zip(close_long_price, close_long_signals)]
|
|
df['open_long_text'] = open_long_text
|
|
df['add_long_text'] = add_long_text
|
|
df['close_long_text'] = close_long_text
|
|
"""
|
|
|
|
def _get_output_section(self, name, rules):
|
|
# Generate plot configs based on indicators
|
|
plots = []
|
|
for rule in rules:
|
|
ind = rule.get('indicator')
|
|
params = rule.get('params', {})
|
|
if ind == 'supertrend':
|
|
plots.append({
|
|
"name": "SuperTrend Up", "type": "line", "data": "df['st_lower'].tolist()", "color": "#00FF00", "overlay": True
|
|
})
|
|
plots.append({
|
|
"name": "SuperTrend Down", "type": "line", "data": "df['st_upper'].tolist()", "color": "#FF0000", "overlay": True
|
|
})
|
|
elif ind == 'ema':
|
|
p = params.get('period', 20)
|
|
plots.append({
|
|
"name": f"EMA {p}", "type": "line", "data": f"df['ema_{p}'].tolist()", "color": "#FFA500", "overlay": True
|
|
})
|
|
elif ind == 'ma':
|
|
p = params.get('period', 20)
|
|
t = params.get('ma_type', 'sma')
|
|
plots.append({
|
|
"name": f"{t.upper()} {p}", "type": "line", "data": f"df['ma_{t}_{p}'].tolist()", "color": "#FFA500", "overlay": True
|
|
})
|
|
elif ind == 'bollinger':
|
|
p = params.get('period', 20)
|
|
d = params.get('std_dev', 2.0)
|
|
plots.append({
|
|
"name": "BB Upper", "type": "line", "data": f"df['bb_{p}_{d}_upper'].tolist()", "color": "#0088FE", "overlay": True
|
|
})
|
|
plots.append({
|
|
"name": "BB Lower", "type": "line", "data": f"df['bb_{p}_{d}_lower'].tolist()", "color": "#0088FE", "overlay": True
|
|
})
|
|
# MACD, RSI, KDJ are typically separate panes, not overlay. The `overlay` param controls this.
|
|
elif ind == 'macd':
|
|
f = params.get('fast_period', 12)
|
|
s = params.get('slow_period', 26)
|
|
si = params.get('signal_period', 9)
|
|
plots.append({
|
|
"name": "MACD", "type": "line", "data": f"df['macd_{f}_{s}_{si}_line'].tolist()", "color": "#0088FE", "overlay": False
|
|
})
|
|
plots.append({
|
|
"name": "Signal", "type": "line", "data": f"df['macd_{f}_{s}_{si}_signal'].tolist()", "color": "#FF8042", "overlay": False
|
|
})
|
|
elif ind == 'rsi':
|
|
p = params.get('period', 14)
|
|
plots.append({
|
|
"name": f"RSI {p}", "type": "line", "data": f"df['rsi_{p}'].tolist()", "color": "#8884d8", "overlay": False
|
|
})
|
|
elif ind == 'kdj':
|
|
p = params.get('period', 9)
|
|
si = params.get('signal_period', 3)
|
|
plots.append({
|
|
"name": "K", "type": "line", "data": f"df['kdj_{p}_{si}_k'].tolist()", "color": "#8884d8", "overlay": False
|
|
})
|
|
plots.append({
|
|
"name": "D", "type": "line", "data": f"df['kdj_{p}_{si}_d'].tolist()", "color": "#82ca9d", "overlay": False
|
|
})
|
|
plots.append({
|
|
"name": "J", "type": "line", "data": f"df['kdj_{p}_{si}_j'].tolist()", "color": "#ffc658", "overlay": False
|
|
})
|
|
|
|
# Convert plots to string representation valid in Python
|
|
plots_py = "[\n"
|
|
for p in plots:
|
|
plots_py += f" {{'name': '{p['name']}', 'type': '{p['type']}', 'data': {p['data']}, 'color': '{p['color']}', 'overlay': {p['overlay']}}},\n"
|
|
plots_py += "]"
|
|
|
|
return f"""
|
|
# ===========================
|
|
# 5. Output
|
|
# ===========================
|
|
output = {{
|
|
"name": "{name}",
|
|
"plots": {plots_py},
|
|
"signals": [
|
|
{{
|
|
"name": "Open Long",
|
|
"type": "buy",
|
|
"data": df['open_long_price'].tolist(),
|
|
"color": "#00FF00",
|
|
"text": "Open Long"
|
|
}},
|
|
{{
|
|
"name": "Add Long",
|
|
"type": "buy",
|
|
"data": df['add_long_price'].tolist(),
|
|
"color": "#00DD00",
|
|
"text": "Add Long"
|
|
}},
|
|
{{
|
|
"name": "Close Long",
|
|
"type": "sell",
|
|
"data": df['close_long_price'].tolist(),
|
|
"color": "#FF6600",
|
|
"text": "Close Long"
|
|
}},
|
|
{{
|
|
"name": "Open Short",
|
|
"type": "sell",
|
|
"data": df['open_short_price'].tolist(),
|
|
"color": "#FF0000",
|
|
"text": "Open Short"
|
|
}},
|
|
{{
|
|
"name": "Add Short",
|
|
"type": "sell",
|
|
"data": df['add_short_price'].tolist(),
|
|
"color": "#DD0000",
|
|
"text": "Add Short"
|
|
}},
|
|
{{
|
|
"name": "Close Short",
|
|
"type": "buy",
|
|
"data": df['close_short_price'].tolist(),
|
|
"color": "#00CCFF",
|
|
"text": "Close Short"
|
|
}}
|
|
]
|
|
}}
|
|
"""
|
|
|