456 lines
16 KiB
Python
456 lines
16 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""
|
|
策略决策服务
|
|
综合信号、持仓、资金等做出交易决策
|
|
"""
|
|
|
|
from typing import List, Dict, Optional
|
|
from datetime import datetime
|
|
import threading
|
|
|
|
from ...models import TradingSignal, TradingStrategy, TradingDecision
|
|
from ...models import ConsistencyRequirement, ConflictResolution
|
|
from ...models import StopLossMode, TakeProfitMode
|
|
from ...store import StrategyStore
|
|
from ..signal import SignalService
|
|
from .risk_manager import RiskManager
|
|
|
|
|
|
class StrategyService:
|
|
"""策略决策服务"""
|
|
|
|
def __init__(self, strategy_store: StrategyStore = None,
|
|
signal_service: SignalService = None,
|
|
risk_manager: RiskManager = None):
|
|
self.strategy_store = strategy_store or StrategyStore()
|
|
self.signal_service = signal_service or SignalService()
|
|
self.risk_manager = risk_manager or RiskManager()
|
|
|
|
# 持仓服务引用（外部设置）
|
|
self._position_service = None
|
|
|
|
# 待确认订单服务引用（外部设置）
|
|
self._pending_order_service = None
|
|
|
|
# 决策冷却
|
|
self._decision_cooldowns: Dict[str, datetime] = {}
|
|
self._cooldown_lock = threading.Lock()
|
|
self.decision_cooldown = 60 # 60秒冷却
|
|
|
|
print("[StrategyService] 策略决策服务已初始化")
|
|
|
|
def set_position_service(self, service) -> None:
|
|
"""设置持仓服务"""
|
|
self._position_service = service
|
|
|
|
def set_pending_order_service(self, service) -> None:
|
|
"""设置待确认订单服务"""
|
|
self._pending_order_service = service
|
|
|
|
# ==================== 策略配置 ====================
|
|
|
|
def get_strategy(self, symbol: str) -> TradingStrategy:
|
|
"""获取品种策略配置"""
|
|
return self.strategy_store.get_or_create_strategy(symbol)
|
|
|
|
def update_strategy(self, symbol: str, data: Dict) -> TradingStrategy:
|
|
"""更新策略配置"""
|
|
return self.strategy_store.update_strategy(symbol, data)
|
|
|
|
def get_all_strategies(self) -> List[TradingStrategy]:
|
|
"""获取所有策略"""
|
|
return self.strategy_store.get_all_strategies()
|
|
|
|
# ==================== 信号综合分析 ====================
|
|
|
|
def analyze_signals(self, symbol: str, signals: List[TradingSignal],
|
|
strategy: TradingStrategy) -> Dict:
|
|
"""
|
|
综合分析信号
|
|
|
|
Args:
|
|
symbol: 品种
|
|
signals: 信号列表
|
|
strategy: 策略配置
|
|
|
|
Returns:
|
|
分析结果
|
|
"""
|
|
if not signals:
|
|
return {
|
|
"total_count": 0,
|
|
"buy_count": 0,
|
|
"sell_count": 0,
|
|
"buy_weighted_score": 0,
|
|
"sell_weighted_score": 0,
|
|
"consistency": 0,
|
|
"direction": None,
|
|
"action": "none",
|
|
}
|
|
|
|
# 过滤掉未启用的信号
|
|
filtered_signals = []
|
|
for s in signals:
|
|
period = s.source_period if s.source != "key_level" else None
|
|
if strategy.is_signal_enabled(s.source, period):
|
|
filtered_signals.append(s)
|
|
|
|
if not filtered_signals:
|
|
return {
|
|
"total_count": 0,
|
|
"buy_count": 0,
|
|
"sell_count": 0,
|
|
"buy_weighted_score": 0,
|
|
"sell_weighted_score": 0,
|
|
"consistency": 0,
|
|
"direction": None,
|
|
"action": "none",
|
|
"filtered_out": len(signals),
|
|
}
|
|
|
|
buy_signals = [s for s in filtered_signals if s.action == "buy"]
|
|
sell_signals = [s for s in filtered_signals if s.action == "sell"]
|
|
|
|
# 计算加权分数（使用新的周期级别权重）
|
|
buy_score = sum(
|
|
s.confidence * strategy.get_signal_weight(s.source, s.source_period) / 100
|
|
for s in buy_signals
|
|
)
|
|
sell_score = sum(
|
|
s.confidence * strategy.get_signal_weight(s.source, s.source_period) / 100
|
|
for s in sell_signals
|
|
)
|
|
|
|
# 计算一致性
|
|
total = len(filtered_signals)
|
|
majority_count = max(len(buy_signals), len(sell_signals))
|
|
consistency = majority_count / total if total > 0 else 0
|
|
|
|
# 确定方向
|
|
direction = None
|
|
if buy_score > sell_score:
|
|
direction = "buy"
|
|
elif sell_score > buy_score:
|
|
direction = "sell"
|
|
|
|
# 检查一致性要求
|
|
action = "none"
|
|
if direction:
|
|
if strategy.consistency_requirement == ConsistencyRequirement.ANY:
|
|
action = direction
|
|
elif strategy.consistency_requirement == ConsistencyRequirement.MAJORITY:
|
|
if consistency >= 0.5:
|
|
action = direction
|
|
elif strategy.consistency_requirement == ConsistencyRequirement.ALL:
|
|
if consistency == 1.0:
|
|
action = direction
|
|
|
|
return {
|
|
"total_count": total,
|
|
"buy_count": len(buy_signals),
|
|
"sell_count": len(sell_signals),
|
|
"buy_weighted_score": round(buy_score, 2),
|
|
"sell_weighted_score": round(sell_score, 2),
|
|
"consistency": round(consistency, 2),
|
|
"direction": direction,
|
|
"action": action,
|
|
"buy_signals": [s.signal_id for s in buy_signals],
|
|
"sell_signals": [s.signal_id for s in sell_signals],
|
|
"filtered_out": len(signals) - len(filtered_signals),
|
|
}
|
|
|
|
# ==================== 决策生成 ====================
|
|
|
|
def make_decision(self, symbol: str, current_price: float,
|
|
force_signals: List[TradingSignal] = None) -> Optional[TradingDecision]:
|
|
"""
|
|
做出交易决策
|
|
|
|
Args:
|
|
symbol: 品种
|
|
current_price: 当前价格
|
|
force_signals: 强制使用的信号（用于测试）
|
|
|
|
Returns:
|
|
TradingDecision 或 None
|
|
"""
|
|
# 检查决策冷却
|
|
if self._is_in_cooldown(symbol):
|
|
return None
|
|
|
|
# 获取策略配置
|
|
strategy = self.get_strategy(symbol)
|
|
if not strategy.enabled:
|
|
return None
|
|
|
|
# 获取信号
|
|
signals = force_signals if force_signals else self.signal_service.get_active_signals(symbol)
|
|
|
|
# 过滤低置信度信号
|
|
signals = [s for s in signals if s.confidence >= strategy.min_confidence]
|
|
|
|
if not signals:
|
|
return None
|
|
|
|
# 分析信号
|
|
analysis = self.analyze_signals(symbol, signals, strategy)
|
|
|
|
if analysis["action"] == "none":
|
|
return None
|
|
|
|
action = analysis["action"]
|
|
|
|
# 选择最佳信号（用于止损止盈）
|
|
best_signal = self._select_best_signal(signals, action, strategy)
|
|
if not best_signal:
|
|
return None
|
|
|
|
# 计算止损止盈
|
|
entry_price = current_price
|
|
sl, tp = self._calculate_sl_tp(entry_price, best_signal, strategy)
|
|
|
|
if not sl or not tp or sl == 0 or tp == 0:
|
|
print(f"[StrategyService] 无效的止损止盈: sl={sl}, tp={tp}")
|
|
return None
|
|
|
|
# 计算风险
|
|
risk_points = abs(entry_price - sl)
|
|
reward_points = abs(tp - entry_price)
|
|
rr_ratio = reward_points / risk_points if risk_points > 0 else 0
|
|
|
|
# 检查风险回报比
|
|
if rr_ratio < strategy.min_risk_reward:
|
|
print(f"[StrategyService] 风险回报比 {rr_ratio:.2f} 低于最小要求 {strategy.min_risk_reward}")
|
|
return None
|
|
|
|
# 动态止损范围（根据价格调整）
|
|
# 最小止损 = 价格的 0.05% 或 5 点（取较大）
|
|
# 最大止损 = 价格的 2% 或 100 点（取较小）
|
|
price_min_sl = entry_price * 0.0005 # 价格的 0.05%
|
|
price_max_sl = entry_price * 0.02 # 价格的 2%
|
|
|
|
# 确保 min <= max
|
|
dynamic_min_sl = max(1.0, price_min_sl) # 最小至少 1 点
|
|
dynamic_max_sl = max(dynamic_min_sl, price_max_sl) # 最大至少等于最小
|
|
|
|
# 如果动态范围不合理，跳过
|
|
if dynamic_min_sl > dynamic_max_sl:
|
|
print(f"[StrategyService] 动态止损范围无效: [{dynamic_min_sl:.2f}, {dynamic_max_sl:.2f}], 跳过决策")
|
|
return None
|
|
|
|
# 检查止损点数
|
|
if risk_points < dynamic_min_sl or risk_points > dynamic_max_sl:
|
|
print(f"[StrategyService] 止损点数 {risk_points:.2f} 不在动态范围 [{dynamic_min_sl:.2f}, {dynamic_max_sl:.2f}] (价格={entry_price:.2f})")
|
|
return None
|
|
|
|
# 计算手数
|
|
volume = self.risk_manager.calculate_volume(symbol, risk_points, strategy)
|
|
if volume <= 0:
|
|
return None
|
|
|
|
# 检查持仓限制
|
|
position_check = self._check_position_limits(symbol, strategy, action)
|
|
|
|
# 检查风险限制
|
|
risk_check = self.risk_manager.check_risk(symbol, volume, risk_points)
|
|
|
|
# 如果检查不通过，返回拒绝的决策
|
|
if not position_check.get("allowed", True) or not risk_check.get("allowed", True):
|
|
# 即使被拒绝也要设置冷却，避免频繁推送
|
|
self._set_cooldown(symbol)
|
|
decision = TradingDecision(
|
|
symbol=symbol,
|
|
strategy_id=strategy.strategy_id,
|
|
action="none",
|
|
decision_type="rejected",
|
|
signals=[s.to_dict() for s in signals],
|
|
signal_summary=analysis,
|
|
decision_reason="风控检查未通过",
|
|
confidence_score=0,
|
|
position_check=position_check,
|
|
risk_check=risk_check,
|
|
status="rejected",
|
|
)
|
|
return decision
|
|
|
|
# 设置决策冷却
|
|
self._set_cooldown(symbol)
|
|
|
|
# 生成决策理由
|
|
decision_reason = self._generate_decision_reason(analysis, best_signal)
|
|
|
|
# 创建决策
|
|
decision = TradingDecision(
|
|
symbol=symbol,
|
|
strategy_id=strategy.strategy_id,
|
|
action=action,
|
|
decision_type="signal_combined" if len(signals) > 1 else "single_signal",
|
|
signals=[s.to_dict() for s in signals],
|
|
signal_summary=analysis,
|
|
entry_price=entry_price,
|
|
sl=round(sl, 2),
|
|
tp=round(tp, 2),
|
|
volume=volume,
|
|
risk_points=round(risk_points, 2),
|
|
reward_points=round(reward_points, 2),
|
|
risk_reward_ratio=round(rr_ratio, 2),
|
|
decision_reason=decision_reason,
|
|
confidence_score=analysis["buy_weighted_score"] if action == "buy" else analysis["sell_weighted_score"],
|
|
position_check=position_check,
|
|
risk_check=risk_check,
|
|
)
|
|
|
|
print(f"[StrategyService] 生成决策: {decision.decision_id} {action} {symbol} @ {entry_price}")
|
|
|
|
return decision
|
|
|
|
def _select_best_signal(self, signals: List[TradingSignal],
|
|
action: str, strategy: TradingStrategy) -> Optional[TradingSignal]:
|
|
"""选择最佳信号"""
|
|
filtered = [s for s in signals if s.action == action]
|
|
if not filtered:
|
|
return None
|
|
|
|
if strategy.conflict_resolution == ConflictResolution.HIGHEST_CONFIDENCE:
|
|
return max(filtered, key=lambda s: s.confidence)
|
|
elif strategy.conflict_resolution == ConflictResolution.HIGHEST_WEIGHT:
|
|
return max(filtered, key=lambda s: s.confidence * strategy.get_signal_weight(s.source, s.source_period))
|
|
else:
|
|
return filtered[0]
|
|
|
|
def _calculate_sl_tp(self, entry_price: float, signal: TradingSignal,
|
|
strategy: TradingStrategy) -> tuple:
|
|
"""计算止损止盈"""
|
|
# 止损
|
|
if strategy.sl_mode == StopLossMode.SIGNAL:
|
|
sl = signal.suggested_sl
|
|
elif strategy.sl_mode == StopLossMode.FIXED_POINTS:
|
|
if signal.action == "buy":
|
|
sl = entry_price - strategy.sl_fixed_points
|
|
else:
|
|
sl = entry_price + strategy.sl_fixed_points
|
|
else:
|
|
sl = signal.suggested_sl
|
|
|
|
# 止盈
|
|
if strategy.tp_mode == TakeProfitMode.SIGNAL:
|
|
tp = signal.suggested_tp
|
|
elif strategy.tp_mode == TakeProfitMode.FIXED_POINTS:
|
|
if signal.action == "buy":
|
|
tp = entry_price + strategy.tp_fixed_points
|
|
else:
|
|
tp = entry_price - strategy.tp_fixed_points
|
|
elif strategy.tp_mode == TakeProfitMode.RISK_REWARD:
|
|
risk = abs(entry_price - sl)
|
|
if signal.action == "buy":
|
|
tp = entry_price + risk * strategy.tp_risk_reward
|
|
else:
|
|
tp = entry_price - risk * strategy.tp_risk_reward
|
|
else:
|
|
tp = signal.suggested_tp
|
|
|
|
return sl, tp
|
|
|
|
def _check_position_limits(self, symbol: str, strategy: TradingStrategy,
|
|
action: str) -> Dict:
|
|
"""检查持仓限制"""
|
|
current_positions = 0
|
|
same_direction = 0
|
|
opposite_direction = 0
|
|
|
|
if self._position_service:
|
|
positions = self._position_service.get_positions(symbol)
|
|
current_positions = len(positions)
|
|
for pos in positions:
|
|
# PositionData.to_dict() 返回 direction 字段
|
|
pos_direction = pos.get('direction', '')
|
|
if pos_direction == action:
|
|
same_direction += 1
|
|
else:
|
|
opposite_direction += 1
|
|
|
|
return self.risk_manager.check_position_limit(
|
|
symbol, strategy, current_positions, same_direction, opposite_direction, action
|
|
)
|
|
|
|
def _generate_decision_reason(self, analysis: Dict, signal: TradingSignal) -> str:
|
|
"""生成决策理由"""
|
|
reasons = []
|
|
|
|
total = analysis["total_count"]
|
|
buy_count = analysis["buy_count"]
|
|
sell_count = analysis["sell_count"]
|
|
direction = analysis["direction"]
|
|
|
|
if total == 1:
|
|
reasons.append(f"单一信号({signal.source})建议{direction}")
|
|
else:
|
|
reasons.append(f"{total}个信号中{buy_count}个买入、{sell_count}个卖出")
|
|
|
|
reasons.append(f"综合判断: {direction}")
|
|
reasons.append(f"风险回报比: {signal.risk_reward_ratio:.2f}")
|
|
|
|
return " | ".join(reasons)
|
|
|
|
def _is_in_cooldown(self, symbol: str) -> bool:
|
|
"""检查是否在冷却期"""
|
|
with self._cooldown_lock:
|
|
if symbol in self._decision_cooldowns:
|
|
last_time = self._decision_cooldowns[symbol]
|
|
elapsed = (datetime.now() - last_time).total_seconds()
|
|
return elapsed < self.decision_cooldown
|
|
return False
|
|
|
|
def _set_cooldown(self, symbol: str) -> None:
|
|
"""设置冷却"""
|
|
with self._cooldown_lock:
|
|
self._decision_cooldowns[symbol] = datetime.now()
|
|
|
|
# ==================== 执行决策 ====================
|
|
|
|
def execute_decision(self, decision: TradingDecision) -> Optional[str]:
|
|
"""
|
|
执行决策（生成待确认订单）
|
|
|
|
Args:
|
|
decision: 交易决策
|
|
|
|
Returns:
|
|
订单ID 或 None
|
|
"""
|
|
if decision.action == "none":
|
|
return None
|
|
|
|
if not self._pending_order_service:
|
|
print("[StrategyService] 待确认订单服务未设置")
|
|
return None
|
|
|
|
# 创建订单
|
|
order_id = self._pending_order_service.create_order(
|
|
symbol=decision.symbol,
|
|
action=decision.action,
|
|
price=decision.entry_price,
|
|
mount=decision.volume,
|
|
sl=decision.sl,
|
|
tp=decision.tp,
|
|
reason=decision.decision_reason,
|
|
description=f"Strategy: {decision.strategy_id}",
|
|
source="strategy_decision",
|
|
)
|
|
|
|
decision.order_id = order_id
|
|
decision.status = "confirmed"
|
|
|
|
print(f"[StrategyService] 决策已执行，订单ID: {order_id}")
|
|
return order_id
|
|
|
|
# ==================== 状态 ====================
|
|
|
|
def get_status(self) -> Dict:
|
|
"""获取服务状态"""
|
|
return {
|
|
"strategy_store": self.strategy_store.get_status(),
|
|
"signal_service": self.signal_service.get_status(),
|
|
"risk_manager": self.risk_manager.get_status(),
|
|
} |