|
|
"""
|
|
|
V2 交易计划生成器 - 5维度综合评分 + 多周期共振分析
|
|
|
"""
|
|
|
import json
|
|
|
import logging
|
|
|
from collections import Counter
|
|
|
from typing import Dict, List, Optional, Tuple
|
|
|
from datetime import datetime
|
|
|
|
|
|
from sqlalchemy.orm import Session
|
|
|
|
|
|
from app.services.cache import get_cached_data
|
|
|
from app.analysis_models import (
|
|
|
ReviewPlanV2, SymbolScoreV2, TradingPlanV2, SectorHeat,
|
|
|
)
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
# 板块分类
|
|
|
SECTOR_MAP = {
|
|
|
"贵金属": ["沪银", "沪金"],
|
|
|
"有色金属": ["沪铜", "沪锌", "沪锡", "沪铅", "沪铝", "铝合金", "沪镍"],
|
|
|
"黑色系": ["焦炭", "焦煤", "螺纹钢", "热卷", "铁矿石"],
|
|
|
"能源": ["原油", "低硫燃油", "燃油"],
|
|
|
"化工": ["PTA", "甲醇", "尿素", "PVC", "乙二醇", "合成橡胶", "烧碱", "纯碱", "玻璃", "橡胶"],
|
|
|
"农产品": ["白糖", "棉花", "棕榈油", "豆粕"],
|
|
|
"新能源": ["氧化铝", "多晶硅", "碳酸锂", "工业硅"],
|
|
|
"股指": ["中证1000"],
|
|
|
"航运": ["集运欧线"],
|
|
|
"橡胶": ["20号胶"],
|
|
|
}
|
|
|
|
|
|
# 权重
|
|
|
WEIGHTS = {
|
|
|
"amplitude": 0.20,
|
|
|
"volume": 0.15,
|
|
|
"change": 0.15,
|
|
|
"trend": 0.35,
|
|
|
"activity": 0.15,
|
|
|
}
|
|
|
|
|
|
|
|
|
def load_symbols_config() -> Dict[str, str]:
|
|
|
"""加载品种配置 {中文名: 合约代码}"""
|
|
|
from app.config_store import get_config_store
|
|
|
data = get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
|
|
|
return data.get("futures", {})
|
|
|
|
|
|
|
|
|
def _get_candle_date(candle: dict) -> Optional[str]:
|
|
|
"""从K线数据中提取日期字符串 (YYYY-MM-DD)"""
|
|
|
dt_str = candle.get("datetime") or candle.get("time")
|
|
|
if not dt_str:
|
|
|
return None
|
|
|
try:
|
|
|
if isinstance(dt_str, str):
|
|
|
dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
|
|
|
else:
|
|
|
dt = dt_str
|
|
|
return dt.strftime("%Y-%m-%d")
|
|
|
except Exception:
|
|
|
return None
|
|
|
|
|
|
|
|
|
def _get_candle_values(candles: List[dict]) -> Tuple[list, list, list, list, list]:
|
|
|
"""从K线列表提取 OHLCV"""
|
|
|
opens, highs, lows, closes, volumes = [], [], [], [], []
|
|
|
for c in candles:
|
|
|
opens.append(float(c.get("open", 0)))
|
|
|
highs.append(float(c.get("high", 0)))
|
|
|
lows.append(float(c.get("low", 0)))
|
|
|
closes.append(float(c.get("close", 0)))
|
|
|
volumes.append(float(c.get("volume", 0)))
|
|
|
return opens, highs, lows, closes, volumes
|
|
|
|
|
|
|
|
|
def _calc_single_period_trend(candles: List[dict]) -> float:
|
|
|
"""
|
|
|
计算单周期趋势分 (-50 ~ +50)
|
|
|
MA排列: 多头+50 / 空头-50
|
|
|
MACD: DIF>DEA +30 / DIF<DEA -30
|
|
|
综合: -50 ~ +50 (归一化后映射)
|
|
|
"""
|
|
|
if len(candles) < 5:
|
|
|
return 0.0
|
|
|
|
|
|
last = candles[-1]
|
|
|
ma10 = last.get("ma10")
|
|
|
ma20 = last.get("ma20")
|
|
|
macd_dif = last.get("macd_dif", 0) or 0
|
|
|
macd_dea = last.get("macd_dea", 0) or 0
|
|
|
|
|
|
score = 0.0
|
|
|
# MA排列
|
|
|
if ma10 and ma20:
|
|
|
if ma10 > ma20:
|
|
|
score += 50
|
|
|
else:
|
|
|
score -= 50
|
|
|
# MACD
|
|
|
if macd_dif > macd_dea:
|
|
|
score += 30
|
|
|
else:
|
|
|
score -= 30
|
|
|
|
|
|
# 归一化到 -50 ~ +50
|
|
|
return max(-50, min(50, score * 50 / 80))
|
|
|
|
|
|
|
|
|
def _calc_trend_score(t60: float, t15: float, t5: float) -> Tuple[float, str, str]:
|
|
|
"""
|
|
|
三周期共振判定
|
|
|
Returns: (趋势总分 0-100, 方向标签, 方向简写)
|
|
|
"""
|
|
|
# 共振判定
|
|
|
if t60 > 20 and t15 > 20 and t5 > 20:
|
|
|
direction = "多头共振"
|
|
|
tag = "强多"
|
|
|
raw = 80 + min(20, (t60 + t15 + t5) / 3 * 20 / 50)
|
|
|
elif t60 < -20 and t15 < -20 and t5 < -20:
|
|
|
direction = "空头共振"
|
|
|
tag = "强空"
|
|
|
raw = 80 + min(20, abs(t60 + t15 + t5) / 3 * 20 / 50)
|
|
|
elif t60 > 0 and t15 > 0:
|
|
|
direction = "偏多震荡"
|
|
|
tag = "偏多"
|
|
|
raw = 50 + min(20, (t60 + t15) / 2 * 20 / 50)
|
|
|
elif t60 < 0 and t15 < 0:
|
|
|
direction = "偏空震荡"
|
|
|
tag = "偏空"
|
|
|
raw = 50 + min(20, abs(t60 + t15) / 2 * 20 / 50)
|
|
|
else:
|
|
|
direction = "多空交织"
|
|
|
tag = "震荡"
|
|
|
raw = max(0, 40 - abs(t60 + t15 + t5) / 3)
|
|
|
|
|
|
return round(raw, 1), direction, tag
|
|
|
|
|
|
|
|
|
def _get_price_precision(price: float) -> int:
|
|
|
"""根据价格大小确定合适的小数位数"""
|
|
|
if price >= 10000:
|
|
|
return 0 # 如白银8250、股指5000+
|
|
|
elif price >= 1000:
|
|
|
return 1 # 如原油528、黄金685(实际2位)
|
|
|
elif price >= 100:
|
|
|
return 2 # 如大部分化工品
|
|
|
else:
|
|
|
return 2 # 小数值的品种
|
|
|
|
|
|
|
|
|
def _round_by_price(value: float, price: float) -> float:
|
|
|
"""根据价格精度四舍五入"""
|
|
|
precision = _get_price_precision(price)
|
|
|
return round(value, precision)
|
|
|
|
|
|
|
|
|
def _calc_pivot_points(high: float, low: float, close: float) -> dict:
|
|
|
"""计算枢轴点和支撑/阻力位（根据价格精度自动调整小数位）"""
|
|
|
pivot = (high + low + close) / 3
|
|
|
r1 = 2 * pivot - low
|
|
|
s1 = 2 * pivot - high
|
|
|
r2 = pivot + (high - low)
|
|
|
s2 = pivot - (high - low)
|
|
|
# 根据价格精度四舍五入
|
|
|
p = _get_price_precision(close)
|
|
|
return {
|
|
|
"pivot": round(pivot, p),
|
|
|
"r1": round(r1, p),
|
|
|
"r2": round(r2, p),
|
|
|
"s1": round(s1, p),
|
|
|
"s2": round(s2, p),
|
|
|
}
|
|
|
|
|
|
|
|
|
def _normalize_scores(values: List[float], reverse: bool = False) -> List[float]:
|
|
|
"""将一组值归一化到 0-100"""
|
|
|
if not values:
|
|
|
return []
|
|
|
min_v = min(values)
|
|
|
max_v = max(values)
|
|
|
if max_v == min_v:
|
|
|
return [50.0] * len(values)
|
|
|
result = []
|
|
|
for v in values:
|
|
|
if reverse:
|
|
|
score = (max_v - v) / (max_v - min_v) * 100
|
|
|
else:
|
|
|
score = (v - min_v) / (max_v - min_v) * 100
|
|
|
result.append(round(score, 1))
|
|
|
return result
|
|
|
|
|
|
|
|
|
def _normalize_abs_scores(values: List[float]) -> List[float]:
|
|
|
"""将绝对值归一化到 0-100（涨跌幅用绝对值排名）"""
|
|
|
abs_values = [abs(v) for v in values]
|
|
|
return _normalize_scores(abs_values)
|
|
|
|
|
|
|
|
|
def _generate_trigger(score_data: dict, direction: str) -> str:
|
|
|
"""
|
|
|
根据分析结果动态生成触发条件
|
|
|
|
|
|
Args:
|
|
|
score_data: 品种评分数据
|
|
|
direction: 方向 (long/short)
|
|
|
|
|
|
Returns:
|
|
|
触发条件文本
|
|
|
"""
|
|
|
conditions = []
|
|
|
direction_tag = score_data.get("direction_tag", "震荡")
|
|
|
volume_ratio = score_data.get("volume_ratio", 1.0)
|
|
|
amplitude_pct = score_data.get("amplitude_pct", 0)
|
|
|
change_pct = score_data.get("change_pct", 0)
|
|
|
|
|
|
# 根据方向标签生成基础条件
|
|
|
if direction == "long":
|
|
|
if direction_tag == "强多":
|
|
|
conditions.append("价格站稳支撑位上方")
|
|
|
elif direction_tag == "偏多":
|
|
|
conditions.append("回踩支撑企稳")
|
|
|
else:
|
|
|
conditions.append("突破枢轴点P位")
|
|
|
else:
|
|
|
if direction_tag == "强空":
|
|
|
conditions.append("价格跌破阻力位下方")
|
|
|
elif direction_tag == "偏空":
|
|
|
conditions.append("反弹阻力受阻")
|
|
|
else:
|
|
|
conditions.append("跌破枢轴点P位")
|
|
|
|
|
|
# 根据量比添加量能条件
|
|
|
if volume_ratio > 1.5:
|
|
|
conditions.append("量能持续放大")
|
|
|
elif volume_ratio > 1.2:
|
|
|
conditions.append("5分钟K线放量确认")
|
|
|
else:
|
|
|
conditions.append("等待量能配合")
|
|
|
|
|
|
# 根据振幅添加波动条件
|
|
|
if amplitude_pct > 2:
|
|
|
conditions.append("注意波动风险")
|
|
|
elif amplitude_pct > 1:
|
|
|
conditions.append("关注区间突破")
|
|
|
|
|
|
# 根据涨跌幅添加趋势条件
|
|
|
if abs(change_pct) > 2:
|
|
|
if change_pct > 0:
|
|
|
conditions.append("强势延续确认")
|
|
|
else:
|
|
|
conditions.append("弱势延续确认")
|
|
|
|
|
|
return " + ".join(conditions[:3]) # 最多返回3个条件
|
|
|
|
|
|
|
|
|
def generate_plan(db: Session, review_date_str: str, week_day: str) -> dict:
|
|
|
"""
|
|
|
生成V2复盘与交易计划
|
|
|
|
|
|
Returns:
|
|
|
{
|
|
|
"review_date_id": int,
|
|
|
"summary": {...},
|
|
|
"scores": [...],
|
|
|
"plans": [...],
|
|
|
"sectors": [...],
|
|
|
}
|
|
|
"""
|
|
|
symbols_config = load_symbols_config()
|
|
|
if not symbols_config:
|
|
|
raise ValueError("品种配置文件为空")
|
|
|
|
|
|
# 反转映射: 合约代码 -> 中文名
|
|
|
code_to_name = {v: k for k, v in symbols_config.items()}
|
|
|
all_symbols = list(symbols_config.values())
|
|
|
|
|
|
logger.info(f"开始生成交易计划: {review_date_str} ({week_day}), 共 {len(all_symbols)} 个品种")
|
|
|
|
|
|
# 将复盘日期作为数据截止时间（当天 23:59:59）
|
|
|
try:
|
|
|
end_time = datetime.strptime(review_date_str, "%Y-%m-%d").replace(hour=23, minute=59, second=59)
|
|
|
except ValueError:
|
|
|
end_time = datetime.now()
|
|
|
|
|
|
# ==================== 第一步: 数据收集 ====================
|
|
|
symbol_data = {}
|
|
|
periods_needed = ["daily", "60min", "15min", "5min"]
|
|
|
|
|
|
for symbol in all_symbols:
|
|
|
try:
|
|
|
data = get_cached_data(
|
|
|
db, symbol, "futures",
|
|
|
periods=periods_needed,
|
|
|
end_time=end_time,
|
|
|
max_candles=100,
|
|
|
)
|
|
|
if data and data.get("timeframes"):
|
|
|
symbol_data[symbol] = data
|
|
|
else:
|
|
|
logger.warning(f"{symbol} 无数据")
|
|
|
except Exception as e:
|
|
|
logger.error(f"获取 {symbol} 数据失败: {e}")
|
|
|
|
|
|
if not symbol_data:
|
|
|
raise ValueError("无法从数据库获取任何品种数据，请先进行数据更新")
|
|
|
|
|
|
logger.info(f"成功获取 {len(symbol_data)}/{len(all_symbols)} 个品种数据")
|
|
|
|
|
|
# ==================== 第二步: 多维度打分 ====================
|
|
|
raw_scores = []
|
|
|
|
|
|
for symbol, data in symbol_data.items():
|
|
|
name = code_to_name.get(symbol, symbol)
|
|
|
tf = data.get("timeframes", {})
|
|
|
|
|
|
daily = tf.get("daily", [])
|
|
|
h1 = tf.get("60min", [])
|
|
|
m15 = tf.get("15min", [])
|
|
|
m5 = tf.get("5min", [])
|
|
|
|
|
|
# 日线数据
|
|
|
if not daily or len(daily) < 2:
|
|
|
continue
|
|
|
|
|
|
_, d_highs, d_lows, d_closes, d_volumes = _get_candle_values(daily)
|
|
|
today_high = d_highs[-1]
|
|
|
today_low = d_lows[-1]
|
|
|
today_close = d_closes[-1]
|
|
|
prev_close = d_closes[-2] if len(d_closes) >= 2 else today_close
|
|
|
today_volume = d_volumes[-1]
|
|
|
|
|
|
# 提取实际数据日期（日线最后一根K线的日期）
|
|
|
data_date = _get_candle_date(daily[-1])
|
|
|
|
|
|
# 近5日均量
|
|
|
recent_vols = d_volumes[-6:-1] if len(d_volumes) >= 6 else d_volumes[:-1]
|
|
|
avg_vol_5 = sum(recent_vols) / len(recent_vols) if recent_vols else today_volume
|
|
|
|
|
|
# A. 振幅
|
|
|
amplitude_pct = (today_high - today_low) / today_close * 100 if today_close else 0
|
|
|
|
|
|
# B. 量比
|
|
|
volume_ratio = today_volume / avg_vol_5 if avg_vol_5 > 0 else 1.0
|
|
|
|
|
|
# C. 涨跌幅
|
|
|
change_pct = (today_close - prev_close) / prev_close * 100 if prev_close else 0
|
|
|
|
|
|
# D. 多周期趋势
|
|
|
t60 = _calc_single_period_trend(h1) if h1 else 0
|
|
|
t15 = _calc_single_period_trend(m15) if m15 else 0
|
|
|
t5 = _calc_single_period_trend(m5) if m5 else 0
|
|
|
trend_total, direction, direction_tag = _calc_trend_score(t60, t15, t5)
|
|
|
|
|
|
# E. 活跃度 (5min K线近10根)
|
|
|
if m5 and len(m5) >= 5:
|
|
|
recent_m5 = m5[-10:] if len(m5) >= 10 else m5
|
|
|
_, _, _, m5_closes, m5_vols = _get_candle_values(recent_m5)
|
|
|
# 价格变动率
|
|
|
if m5_closes and m5_closes[0] > 0:
|
|
|
price_change_rate = abs(m5_closes[-1] - m5_closes[0]) / m5_closes[0] * 100
|
|
|
else:
|
|
|
price_change_rate = 0
|
|
|
# 量能活跃度
|
|
|
avg_m5_vol = sum(m5_vols) / len(m5_vols) if m5_vols else 0
|
|
|
vol_activity = min(100, avg_m5_vol / 100) if avg_m5_vol > 0 else 0
|
|
|
price_activity = min(100, price_change_rate * 50)
|
|
|
activity_score = (vol_activity + price_activity) / 2
|
|
|
else:
|
|
|
activity_score = 0
|
|
|
|
|
|
# 关键点位
|
|
|
pivots = _calc_pivot_points(today_high, today_low, today_close)
|
|
|
|
|
|
raw_scores.append({
|
|
|
"symbol": symbol,
|
|
|
"name": name,
|
|
|
"data_date": data_date,
|
|
|
"close_price": today_close,
|
|
|
"prev_close": prev_close,
|
|
|
"high_price": today_high,
|
|
|
"low_price": today_low,
|
|
|
"volume": today_volume,
|
|
|
"avg_volume_5": avg_vol_5,
|
|
|
"amplitude_pct": round(amplitude_pct, 2),
|
|
|
"volume_ratio": round(volume_ratio, 2),
|
|
|
"change_pct": round(change_pct, 2),
|
|
|
"amplitude_raw": amplitude_pct,
|
|
|
"volume_raw": volume_ratio,
|
|
|
"change_raw": abs(change_pct),
|
|
|
"trend_score": trend_total,
|
|
|
"trend_60m": round(t60, 1),
|
|
|
"trend_15m": round(t15, 1),
|
|
|
"trend_5m": round(t5, 1),
|
|
|
"direction": direction,
|
|
|
"direction_tag": direction_tag,
|
|
|
"activity_raw": activity_score,
|
|
|
"pivots": pivots,
|
|
|
})
|
|
|
|
|
|
if not raw_scores:
|
|
|
raise ValueError("没有足够的数据进行评分计算")
|
|
|
|
|
|
# ==================== 第三步: 归一化评分 ====================
|
|
|
amp_scores = _normalize_scores([s["amplitude_raw"] for s in raw_scores])
|
|
|
vol_scores = _normalize_scores([s["volume_raw"] for s in raw_scores])
|
|
|
chg_scores = _normalize_abs_scores([s["change_raw"] for s in raw_scores])
|
|
|
act_scores = _normalize_scores([s["activity_raw"] for s in raw_scores])
|
|
|
|
|
|
for i, s in enumerate(raw_scores):
|
|
|
s["amplitude_score"] = amp_scores[i]
|
|
|
s["volume_score"] = vol_scores[i]
|
|
|
s["change_score"] = chg_scores[i]
|
|
|
s["activity_score"] = act_scores[i]
|
|
|
|
|
|
# 综合评分 = 振幅×0.20 + 量能×0.15 + 涨跌幅×0.15 + 趋势×0.35 + 活跃度×0.15
|
|
|
# 趋势分映射: trend_score 0-100 直接使用
|
|
|
s["composite_score"] = round(
|
|
|
amp_scores[i] * WEIGHTS["amplitude"]
|
|
|
+ vol_scores[i] * WEIGHTS["volume"]
|
|
|
+ chg_scores[i] * WEIGHTS["change"]
|
|
|
+ s["trend_score"] * WEIGHTS["trend"]
|
|
|
+ act_scores[i] * WEIGHTS["activity"],
|
|
|
1
|
|
|
)
|
|
|
|
|
|
# 排序
|
|
|
raw_scores.sort(key=lambda x: x["composite_score"], reverse=True)
|
|
|
|
|
|
# ==================== 第四步: 分类 ====================
|
|
|
for rank, s in enumerate(raw_scores, 1):
|
|
|
s["rank"] = rank
|
|
|
score = s["composite_score"]
|
|
|
trend = s["trend_score"]
|
|
|
|
|
|
if score >= 55 and trend >= 50:
|
|
|
s["category"] = "green"
|
|
|
elif score >= 45 or (score >= 40 and 30 <= trend < 50):
|
|
|
s["category"] = "yellow"
|
|
|
else:
|
|
|
s["category"] = "red"
|
|
|
|
|
|
# ==================== 第五步: 生成交易计划 ====================
|
|
|
plans = []
|
|
|
green_items = [s for s in raw_scores if s["category"] == "green"]
|
|
|
|
|
|
for s in green_items:
|
|
|
# 根据方向标签判断实际方向（强多/偏多→做多，强空/偏空→做空）
|
|
|
direction_tag = s.get("direction_tag", "震荡")
|
|
|
if direction_tag in ["强空", "偏空"]:
|
|
|
direction = "short"
|
|
|
elif direction_tag in ["强多", "偏多"]:
|
|
|
direction = "long"
|
|
|
else:
|
|
|
# 震荡情况下根据涨跌幅判断
|
|
|
direction = "long" if s["change_pct"] > 0 else "short"
|
|
|
|
|
|
pivots = s["pivots"]
|
|
|
price = s["close_price"]
|
|
|
|
|
|
if direction == "long":
|
|
|
entry_low = _round_by_price(pivots["s1"], price)
|
|
|
entry_high = _round_by_price(pivots["pivot"], price)
|
|
|
stop_loss = _round_by_price(pivots["s2"], price)
|
|
|
target1 = _round_by_price(pivots["r1"], price)
|
|
|
target2 = _round_by_price(pivots["r2"], price)
|
|
|
else:
|
|
|
entry_low = _round_by_price(pivots["pivot"], price)
|
|
|
entry_high = _round_by_price(pivots["r1"], price)
|
|
|
stop_loss = _round_by_price(pivots["r2"], price)
|
|
|
target1 = _round_by_price(pivots["s1"], price)
|
|
|
target2 = _round_by_price(pivots["s2"], price)
|
|
|
|
|
|
# 根据分析结果动态生成触发条件
|
|
|
trigger = _generate_trigger(s, direction)
|
|
|
|
|
|
plans.append({
|
|
|
"symbol": s["symbol"],
|
|
|
"name": s["name"],
|
|
|
"direction": direction,
|
|
|
"composite_score": s["composite_score"],
|
|
|
"entry_low": entry_low,
|
|
|
"entry_high": entry_high,
|
|
|
"stop_loss": stop_loss,
|
|
|
"target1": target1,
|
|
|
"target2": target2,
|
|
|
"trigger": trigger,
|
|
|
"amplitude_score": s["amplitude_score"],
|
|
|
"volume_score": s["volume_score"],
|
|
|
"trend_score": s["trend_score"],
|
|
|
"activity_score": s["activity_score"],
|
|
|
"category": s["category"],
|
|
|
})
|
|
|
|
|
|
# ==================== 第六步: 板块热度 ====================
|
|
|
sectors = _calc_sector_heat(raw_scores, code_to_name)
|
|
|
|
|
|
# ==================== 第七步: 汇总 ====================
|
|
|
bull_count = sum(1 for s in raw_scores if s["trend_score"] >= 50)
|
|
|
bear_count = sum(1 for s in raw_scores if s["trend_score"] < 30)
|
|
|
neutral_count = len(raw_scores) - bull_count - bear_count
|
|
|
|
|
|
# 统计实际数据日期（取出现最多的日期作为基准数据日期）
|
|
|
date_counts = Counter(s.get("data_date") for s in raw_scores if s.get("data_date"))
|
|
|
actual_data_date = date_counts.most_common(1)[0][0] if date_counts else review_date_str
|
|
|
# 判断数据日期是否与复盘日期一致
|
|
|
data_date_matches = (actual_data_date == review_date_str)
|
|
|
|
|
|
# 核心结论
|
|
|
top3 = raw_scores[:3]
|
|
|
top_names = [f"{s['symbol']} {s['name']}" for s in top3]
|
|
|
main_direction = "多头" if bull_count > bear_count else "空头" if bear_count > bull_count else "震荡"
|
|
|
core_conclusion = f"{main_direction}格局{'延续' if bull_count > 15 else '分化'}，{'贵金属+黑色系共振做多' if bull_count > 20 else '板块轮动明显'}"
|
|
|
|
|
|
# 风险提示
|
|
|
risk_warnings = []
|
|
|
if top3:
|
|
|
top_sym = top3[0]
|
|
|
risk_warnings.append(
|
|
|
f"极值品种严禁追{'多' if top_sym['trend_score'] >= 50 else '空'}："
|
|
|
f"{top_sym['symbol']}({top_sym['composite_score']}分) "
|
|
|
f"{'周一大概率高开' if top_sym['change_pct'] > 2 else '注意风险控制'}"
|
|
|
)
|
|
|
if bear_count > 0:
|
|
|
bear_syms = [s for s in raw_scores if s["category"] == "red" and s["trend_score"] < 30][:2]
|
|
|
if bear_syms:
|
|
|
names = "/".join(s["symbol"] for s in bear_syms)
|
|
|
risk_warnings.append(f"空头品种谨慎：{names} 趋势偏空，需严格止损")
|
|
|
risk_warnings.append("关注宏观数据和消息面变化，可能影响开盘方向")
|
|
|
if any(s["volume_ratio"] > 2.5 for s in raw_scores):
|
|
|
high_vol = [s for s in raw_scores if s["volume_ratio"] > 2.5]
|
|
|
risk_warnings.append(
|
|
|
f"量能异常品种：{', '.join(s['symbol'] for s in high_vol[:3])} "
|
|
|
f"量比超2.5倍，需确认量能可持续性"
|
|
|
)
|
|
|
|
|
|
# 构建数据基准描述
|
|
|
if data_date_matches:
|
|
|
data_basis = f"{actual_data_date} 收盘 ({len(symbol_data)} 品种) | 多周期共振分析"
|
|
|
else:
|
|
|
data_basis = f"复盘日期: {review_date_str} | 数据截至: {actual_data_date} 收盘 ({len(symbol_data)} 品种) | 多周期共振分析"
|
|
|
|
|
|
return {
|
|
|
"review_date": review_date_str,
|
|
|
"week_day": week_day,
|
|
|
"actual_data_date": actual_data_date,
|
|
|
"data_date_matches": data_date_matches,
|
|
|
"data_basis": data_basis,
|
|
|
"core_conclusion": core_conclusion,
|
|
|
"bull_count": bull_count,
|
|
|
"bear_count": bear_count,
|
|
|
"neutral_count": neutral_count,
|
|
|
"opportunity_count": len(green_items),
|
|
|
"risk_warnings": risk_warnings,
|
|
|
"scores": raw_scores,
|
|
|
"plans": plans,
|
|
|
"sectors": sectors,
|
|
|
"symbol_count": len(symbol_data),
|
|
|
}
|
|
|
|
|
|
|
|
|
def _calc_sector_heat(scores: List[dict], code_to_name: dict) -> List[dict]:
|
|
|
"""计算板块热度"""
|
|
|
# 构建 symbol -> score 映射
|
|
|
name_to_score = {}
|
|
|
for s in scores:
|
|
|
name_to_score[s["name"]] = s
|
|
|
|
|
|
sectors = []
|
|
|
for sector_name, members_names in SECTOR_MAP.items():
|
|
|
members = []
|
|
|
for mn in members_names:
|
|
|
if mn in name_to_score:
|
|
|
sc = name_to_score[mn]
|
|
|
members.append({
|
|
|
"symbol": sc["symbol"],
|
|
|
"name": sc["name"],
|
|
|
"score": sc["composite_score"],
|
|
|
"trend": sc["trend_score"],
|
|
|
"change_pct": sc["change_pct"],
|
|
|
})
|
|
|
|
|
|
if not members:
|
|
|
continue
|
|
|
|
|
|
avg_score = round(sum(m["score"] for m in members) / len(members), 1)
|
|
|
avg_trend = round(sum(m["trend"] for m in members) / len(members), 0)
|
|
|
|
|
|
if avg_trend > 20:
|
|
|
direction = "多头"
|
|
|
elif avg_trend < -20:
|
|
|
direction = "空头"
|
|
|
else:
|
|
|
direction = "震荡"
|
|
|
|
|
|
# 热度等级
|
|
|
if avg_score >= 75:
|
|
|
heat = 3
|
|
|
elif avg_score >= 60:
|
|
|
heat = 2
|
|
|
elif avg_score >= 45:
|
|
|
heat = 1
|
|
|
else:
|
|
|
heat = 0
|
|
|
|
|
|
# 龙头
|
|
|
leader = max(members, key=lambda m: m["score"])
|
|
|
|
|
|
sectors.append({
|
|
|
"sector_name": sector_name,
|
|
|
"avg_score": avg_score,
|
|
|
"avg_trend": int(avg_trend),
|
|
|
"direction": direction,
|
|
|
"heat_level": heat,
|
|
|
"leader_symbol": leader["symbol"],
|
|
|
"leader_score": leader["score"],
|
|
|
"members": sorted(members, key=lambda m: m["score"], reverse=True),
|
|
|
})
|
|
|
|
|
|
sectors.sort(key=lambda s: s["avg_score"], reverse=True)
|
|
|
return sectors
|
|
|
|
|
|
|
|
|
def save_plan_to_db(db: Session, plan_data: dict) -> int:
|
|
|
"""将计划数据保存到数据库"""
|
|
|
review_date_str = plan_data["review_date"]
|
|
|
week_day = plan_data["week_day"]
|
|
|
|
|
|
# 清理旧数据
|
|
|
existing = db.query(ReviewPlanV2).filter_by(review_date=review_date_str).first()
|
|
|
if existing:
|
|
|
review_plan_id = existing.id
|
|
|
# 清理关联数据
|
|
|
db.query(SymbolScoreV2).filter_by(review_date_id=review_plan_id).delete()
|
|
|
db.query(TradingPlanV2).filter_by(review_date_id=review_plan_id).delete()
|
|
|
db.query(SectorHeat).filter_by(review_date_id=review_plan_id).delete()
|
|
|
# 更新元数据
|
|
|
existing.week_day = week_day
|
|
|
existing.data_basis = plan_data.get("data_basis")
|
|
|
existing.core_conclusion = plan_data.get("core_conclusion")
|
|
|
existing.bull_count = plan_data.get("bull_count")
|
|
|
existing.bear_count = plan_data.get("bear_count")
|
|
|
existing.neutral_count = plan_data.get("neutral_count")
|
|
|
existing.opportunity_count = plan_data.get("opportunity_count")
|
|
|
existing.risk_warnings = plan_data.get("risk_warnings")
|
|
|
existing.actual_data_date = plan_data.get("actual_data_date")
|
|
|
existing.data_date_matches = 1 if plan_data.get("data_date_matches") else 0
|
|
|
else:
|
|
|
review_plan = ReviewPlanV2(
|
|
|
review_date=review_date_str,
|
|
|
week_day=week_day,
|
|
|
data_basis=plan_data.get("data_basis"),
|
|
|
core_conclusion=plan_data.get("core_conclusion"),
|
|
|
bull_count=plan_data.get("bull_count"),
|
|
|
bear_count=plan_data.get("bear_count"),
|
|
|
neutral_count=plan_data.get("neutral_count"),
|
|
|
opportunity_count=plan_data.get("opportunity_count"),
|
|
|
risk_warnings=plan_data.get("risk_warnings"),
|
|
|
actual_data_date=plan_data.get("actual_data_date"),
|
|
|
data_date_matches=1 if plan_data.get("data_date_matches") else 0,
|
|
|
)
|
|
|
db.add(review_plan)
|
|
|
db.flush()
|
|
|
review_plan_id = review_plan.id
|
|
|
|
|
|
# 保存评分数据
|
|
|
for s in plan_data.get("scores", []):
|
|
|
pivots = s.get("pivots", {})
|
|
|
score_record = SymbolScoreV2(
|
|
|
review_date_id=review_plan_id,
|
|
|
symbol=s["symbol"],
|
|
|
name=s["name"],
|
|
|
close_price=s.get("close_price"),
|
|
|
prev_close=s.get("prev_close"),
|
|
|
high_price=s.get("high_price"),
|
|
|
low_price=s.get("low_price"),
|
|
|
volume=s.get("volume"),
|
|
|
avg_volume_5=s.get("avg_volume_5"),
|
|
|
amplitude_score=s.get("amplitude_score"),
|
|
|
volume_score=s.get("volume_score"),
|
|
|
change_score=s.get("change_score"),
|
|
|
trend_score=s.get("trend_score"),
|
|
|
activity_score=s.get("activity_score"),
|
|
|
composite_score=s.get("composite_score"),
|
|
|
amplitude_pct=s.get("amplitude_pct"),
|
|
|
change_pct=s.get("change_pct"),
|
|
|
volume_ratio=s.get("volume_ratio"),
|
|
|
trend_60m=s.get("trend_60m"),
|
|
|
trend_15m=s.get("trend_15m"),
|
|
|
trend_5m=s.get("trend_5m"),
|
|
|
direction=s.get("direction"),
|
|
|
direction_tag=s.get("direction_tag"),
|
|
|
category=s.get("category"),
|
|
|
pivot=pivots.get("pivot"),
|
|
|
r1=pivots.get("r1"),
|
|
|
r2=pivots.get("r2"),
|
|
|
s1=pivots.get("s1"),
|
|
|
s2=pivots.get("s2"),
|
|
|
rank=s.get("rank"),
|
|
|
data_date=s.get("data_date"),
|
|
|
)
|
|
|
db.add(score_record)
|
|
|
|
|
|
# 保存交易计划
|
|
|
for p in plan_data.get("plans", []):
|
|
|
plan_record = TradingPlanV2(
|
|
|
review_date_id=review_plan_id,
|
|
|
symbol=p["symbol"],
|
|
|
name=p["name"],
|
|
|
direction=p["direction"],
|
|
|
composite_score=p.get("composite_score"),
|
|
|
entry_low=p.get("entry_low"),
|
|
|
entry_high=p.get("entry_high"),
|
|
|
stop_loss=p.get("stop_loss"),
|
|
|
target1=p.get("target1"),
|
|
|
target2=p.get("target2"),
|
|
|
trigger=p.get("trigger"),
|
|
|
amplitude_score=p.get("amplitude_score"),
|
|
|
volume_score=p.get("volume_score"),
|
|
|
trend_score=p.get("trend_score"),
|
|
|
activity_score=p.get("activity_score"),
|
|
|
category=p.get("category"),
|
|
|
)
|
|
|
db.add(plan_record)
|
|
|
|
|
|
# 保存板块热度
|
|
|
for sec in plan_data.get("sectors", []):
|
|
|
sector_record = SectorHeat(
|
|
|
review_date_id=review_plan_id,
|
|
|
sector_name=sec["sector_name"],
|
|
|
avg_score=sec.get("avg_score"),
|
|
|
avg_trend=sec.get("avg_trend"),
|
|
|
direction=sec.get("direction"),
|
|
|
heat_level=sec.get("heat_level"),
|
|
|
leader_symbol=sec.get("leader_symbol"),
|
|
|
leader_score=sec.get("leader_score"),
|
|
|
members=sec.get("members"),
|
|
|
)
|
|
|
db.add(sector_record)
|
|
|
|
|
|
db.commit()
|
|
|
logger.info(f"交易计划已保存: {review_date_str}, ID={review_plan_id}")
|
|
|
return review_plan_id
|
|
|
|
|
|
|
|
|
def get_plan_data(db: Session, review_plan_id: int) -> Optional[dict]:
|
|
|
"""从数据库读取完整的计划数据"""
|
|
|
plan_meta = db.query(ReviewPlanV2).filter_by(id=review_plan_id).first()
|
|
|
if not plan_meta:
|
|
|
return None
|
|
|
|
|
|
scores = db.query(SymbolScoreV2).filter_by(
|
|
|
review_date_id=review_plan_id
|
|
|
).order_by(SymbolScoreV2.composite_score.desc()).all()
|
|
|
|
|
|
plans = db.query(TradingPlanV2).filter_by(
|
|
|
review_date_id=review_plan_id
|
|
|
).order_by(TradingPlanV2.composite_score.desc()).all()
|
|
|
|
|
|
sectors = db.query(SectorHeat).filter_by(
|
|
|
review_date_id=review_plan_id
|
|
|
).order_by(SectorHeat.avg_score.desc()).all()
|
|
|
|
|
|
return {
|
|
|
"meta": {
|
|
|
"id": plan_meta.id,
|
|
|
"review_date": plan_meta.review_date,
|
|
|
"week_day": plan_meta.week_day,
|
|
|
"data_basis": plan_meta.data_basis,
|
|
|
"actual_data_date": plan_meta.actual_data_date,
|
|
|
"data_date_matches": bool(plan_meta.data_date_matches),
|
|
|
"core_conclusion": plan_meta.core_conclusion,
|
|
|
"bull_count": plan_meta.bull_count,
|
|
|
"bear_count": plan_meta.bear_count,
|
|
|
"neutral_count": plan_meta.neutral_count,
|
|
|
"opportunity_count": plan_meta.opportunity_count,
|
|
|
"risk_warnings": plan_meta.risk_warnings,
|
|
|
"created_at": plan_meta.created_at.isoformat() if plan_meta.created_at else None,
|
|
|
},
|
|
|
"scores": [_score_to_dict(s) for s in scores],
|
|
|
"plans": [_plan_to_dict(p) for p in plans],
|
|
|
"sectors": [_sector_to_dict(s) for s in sectors],
|
|
|
}
|
|
|
|
|
|
|
|
|
def _score_to_dict(s: SymbolScoreV2) -> dict:
|
|
|
return {
|
|
|
"id": s.id,
|
|
|
"symbol": s.symbol,
|
|
|
"name": s.name,
|
|
|
"data_date": s.data_date,
|
|
|
"close_price": s.close_price,
|
|
|
"prev_close": s.prev_close,
|
|
|
"high_price": s.high_price,
|
|
|
"low_price": s.low_price,
|
|
|
"volume": s.volume,
|
|
|
"avg_volume_5": s.avg_volume_5,
|
|
|
"amplitude_score": s.amplitude_score,
|
|
|
"volume_score": s.volume_score,
|
|
|
"change_score": s.change_score,
|
|
|
"trend_score": s.trend_score,
|
|
|
"activity_score": s.activity_score,
|
|
|
"composite_score": s.composite_score,
|
|
|
"amplitude_pct": s.amplitude_pct,
|
|
|
"change_pct": s.change_pct,
|
|
|
"volume_ratio": s.volume_ratio,
|
|
|
"trend_60m": s.trend_60m,
|
|
|
"trend_15m": s.trend_15m,
|
|
|
"trend_5m": s.trend_5m,
|
|
|
"direction": s.direction,
|
|
|
"direction_tag": s.direction_tag,
|
|
|
"category": s.category,
|
|
|
"pivot": s.pivot,
|
|
|
"r1": s.r1,
|
|
|
"r2": s.r2,
|
|
|
"s1": s.s1,
|
|
|
"s2": s.s2,
|
|
|
"rank": s.rank,
|
|
|
}
|
|
|
|
|
|
|
|
|
def _plan_to_dict(p: TradingPlanV2) -> dict:
|
|
|
return {
|
|
|
"id": p.id,
|
|
|
"symbol": p.symbol,
|
|
|
"name": p.name,
|
|
|
"direction": p.direction,
|
|
|
"composite_score": p.composite_score,
|
|
|
"entry_low": p.entry_low,
|
|
|
"entry_high": p.entry_high,
|
|
|
"stop_loss": p.stop_loss,
|
|
|
"target1": p.target1,
|
|
|
"target2": p.target2,
|
|
|
"trigger": p.trigger,
|
|
|
"amplitude_score": p.amplitude_score,
|
|
|
"volume_score": p.volume_score,
|
|
|
"trend_score": p.trend_score,
|
|
|
"activity_score": p.activity_score,
|
|
|
"category": p.category,
|
|
|
}
|
|
|
|
|
|
|
|
|
def _sector_to_dict(s: SectorHeat) -> dict:
|
|
|
return {
|
|
|
"id": s.id,
|
|
|
"sector_name": s.sector_name,
|
|
|
"avg_score": s.avg_score,
|
|
|
"avg_trend": s.avg_trend,
|
|
|
"direction": s.direction,
|
|
|
"heat_level": s.heat_level,
|
|
|
"leader_symbol": s.leader_symbol,
|
|
|
"leader_score": s.leader_score,
|
|
|
"members": s.members,
|
|
|
}
|
