"""趋势突破统一筛选器（自上而下方案，中短线交易定位） 三阶段管道： Step 1: 板块定位 — 找到有资金流入的热门板块 (3-5个) Step 2: 板块内选股 — 在热门板块成分股中筛出有资金流入的候选 (30-50只) Step 3: 深度分析 — 供需 + 价格行为 + 趋势 + LLM (10-15只推荐) 评分公式：供需关系 50% + 价格行为 40% + 趋势 10% 板块和资金流作为前置过滤条件，板块涨停数作为情绪奖励。 风险乘数：惩罚取最大而非叠加（防过度惩罚），奖励可叠加。 数据源： - 盘中模式：Tushare 日线 + 腾讯实时行情 + 东方财富5分钟K线 - 盘后模式：Tushare 当日完整数据 止损止盈：基于市场结构（阻力位/支撑MA/近期低点），而非固定百分比。 """ import logging import pandas as pd from app.analysis.market_temp import calculate_market_temperature from app.analysis.sector_scanner import scan_hot_sectors from app.analysis.trend_scanner import scan_trend_breakout from app.analysis.signals import generate_signals from app.analysis.intraday import intraday_market_temperature, intraday_filter_stocks, intraday_sector_scan from app.data.models import MarketTemperature, SectorInfo, TechnicalSignal, Recommendation from app.config import settings, is_trading_hours, is_market_session logger = logging.getLogger(__name__) async def run_screening(trade_date: str = None) -> dict: """执行趋势突破筛选流程 返回: { "market_temp": MarketTemperature, "hot_sectors": [SectorInfo], "recommendations": [Recommendation], "scan_mode": "intraday" | "post_market", } """ intraday = is_market_session() scan_mode = "intraday" if intraday else "post_market" logger.info(f"=== 筛选模式: {'盘中实时' if intraday else '盘后'} ===") # ── 市场温度 ── logger.info("=== 市场温度计 ===") market_temp = calculate_market_temperature(trade_date) if intraday: market_temp = await intraday_market_temperature(market_temp) logger.info(f"盘中市场温度(实时调整): {market_temp.temperature}") else: logger.info(f"市场温度: {market_temp.temperature}") market_temp_score = market_temp.temperature # ── Step 1: 板块定位 ── logger.info("=== Step 1: 板块定位 ===") all_sectors = scan_hot_sectors(trade_date) # 前置过滤：只保留有资金流入 + 非末期的板块 hot_sectors = [ s for s in all_sectors if s.capital_inflow > 0 and s.stage not in ("end",) ][:settings.top_sector_count] if not hot_sectors: logger.info("无合格热门板块（需要资金流入+非末期），回退到全部板块") hot_sectors = all_sectors[:settings.top_sector_count] for s in hot_sectors: logger.info(f" 目标板块: {s.sector_name} 涨幅{s.pct_change}% 资金{s.capital_inflow:.0f}万 " f"涨停{s.limit_up_count} 阶段={s.stage}") # 盘中用实时行情更新板块涨幅和涨停数 if intraday: hot_sectors = await intraday_sector_scan(hot_sectors) # ── Step 2: 板块内选股 ── logger.info("=== Step 2: 板块内选股 ===") if intraday: candidates = await intraday_filter_stocks(hot_sectors) else: candidates = await _select_from_hot_sectors(hot_sectors, trade_date, intraday) if not candidates: logger.info("=== Step 2 无候选，回退到全市场扫描 ===") candidates = await scan_trend_breakout( trade_date=trade_date, market_temp=market_temp, hot_sectors=hot_sectors, intraday=intraday, ) if not candidates: logger.info("=== 筛选完成: 0 只股票 ===") return { "market_temp": market_temp, "hot_sectors": hot_sectors, "recommendations": [], "scan_mode": scan_mode, } # ── Step 3 之前：注入腾讯实时价格（防止 Tushare 日线数据过时） ── if candidates: try: from app.data.tencent_client import get_realtime_quotes_batch codes = [c["ts_code"] for c in candidates if "ts_code" in c] quotes = await get_realtime_quotes_batch(codes) for c in candidates: q = quotes.get(c["ts_code"]) if q and q.price > 0: c["price"] = q.price except Exception as e: logger.warning(f"注入实时价格失败，使用 Tushare 收盘价: {e}") # ── Step 3: 供需 + 价格行为 + 趋势评分 ── logger.info("=== Step 3: 深度分析 ===") recommendations = await _build_recommendations( candidates, market_temp, hot_sectors, market_temp_score, intraday, ) # 过滤低质量推荐（低于60分不推荐） recommendations = [r for r in recommendations if r.score >= 60] logger.info(f"=== 筛选完成: {len(recommendations)} 只股票 ({scan_mode}) ===") for r in recommendations[:5]: signal_map = {"breakout": "突破型", "breakout_confirm": "确认型", "pullback": "回踩型", "launch": "启动型", "reversal": "反转型"} signal_label = signal_map.get(r.entry_signal_type, r.entry_signal_type) logger.info(f" [{signal_label}] {r.name}({r.ts_code}) {r.level} 评分={r.score} 信号={r.signal}") return { "market_temp": market_temp, "hot_sectors": hot_sectors, "recommendations": recommendations, "scan_mode": scan_mode, } async def _select_from_hot_sectors( hot_sectors: list[SectorInfo], trade_date: str, intraday: bool, ) -> list[dict]: """Step 2: 从热门板块成分股中选出有资金流入的候选 流程: 1. 收集所有热门板块的成分股代码 2. 用 get_daily_all + get_daily_basic 过滤市值/换手率 3. 用 get_moneyflow_batch 过滤主力净流入 > 0 4. 对候选做入场信号初筛（只需满足任一信号类型） """ from app.data.tushare_client import tushare_client from datetime import datetime, timedelta import pandas as pd if not trade_date: trade_date = tushare_client.get_latest_trade_date() # 收集热门板块成分股代码 sector_member_codes: set[str] = set() sector_code_map: dict[str, str] = {} # ts_code -> sector_name for s in hot_sectors: try: members_df = tushare_client.get_ths_members(s.sector_code) if not members_df.empty and "con_code" in members_df.columns: codes = members_df["con_code"].tolist() sector_member_codes.update(codes) for c in codes: sector_code_map[c] = s.sector_name except Exception as e: logger.warning(f"获取板块 {s.sector_name} 成分股失败: {e}") if not sector_member_codes: logger.info("Step 2: 无板块成分股数据") return [] logger.info(f"Step 2: 热门板块共 {len(sector_member_codes)} 只成分股") # 过滤市值/换手率/ST/次新 stock_basic = tushare_client.get_stock_basic() exclude_codes = set() if not stock_basic.empty: st_codes = set(stock_basic[stock_basic["name"].str.contains("ST", na=False)]["ts_code"]) exclude_codes.update(st_codes) cutoff = (datetime.now() - timedelta(days=settings.min_list_days)).strftime("%Y%m%d") new_codes = set(stock_basic[stock_basic["list_date"] > cutoff]["ts_code"]) exclude_codes.update(new_codes) # 行业映射 industry_map = {} if not stock_basic.empty: for _, row in stock_basic.iterrows(): industry_map[row["ts_code"]] = row.get("industry", "") # 用 daily_basic 过滤 basic = tushare_client.get_daily_basic(trade_date) if basic.empty: logger.info("Step 2: daily_basic 无数据") return [] basic["circ_mv"] = basic["circ_mv"] / 10000 # 万元 → 亿元 filtered_basic = basic[ (basic["ts_code"].isin(sector_member_codes)) & (~basic["ts_code"].isin(exclude_codes)) & (basic["circ_mv"] >= settings.min_circ_mv) & (basic["circ_mv"] <= settings.max_circ_mv) & (basic["turnover_rate"] >= settings.min_turnover_rate) & (basic["turnover_rate"] <= settings.max_turnover_rate) ].copy() # 严格过滤为空时，放宽换手率条件重试 if filtered_basic.empty: logger.info("Step 2 严格过滤无结果，放宽换手率重试") filtered_basic = basic[ (basic["ts_code"].isin(sector_member_codes)) & (~basic["ts_code"].isin(exclude_codes)) & (basic["circ_mv"] >= settings.min_circ_mv) & (basic["circ_mv"] <= settings.max_circ_mv) ].copy() logger.info(f"Step 2 基本面过滤: {len(sector_member_codes)} 只 → {len(filtered_basic)} 只") if filtered_basic.empty: return [] # 资金流过滤：主力净流入 > 0 mf = tushare_client.get_moneyflow_batch(trade_date) if mf.empty: logger.info("Step 2: 资金流数据为空，跳过资金过滤") candidate_codes = set(filtered_basic["ts_code"].tolist()) else: mf["main_net_inflow"] = ( (mf["buy_elg_amount"] - mf["sell_elg_amount"]) + (mf["buy_lg_amount"] - mf["sell_lg_amount"]) ) total = ( mf["buy_elg_amount"] + mf["sell_elg_amount"] + mf["buy_lg_amount"] + mf["sell_lg_amount"] + mf["buy_md_amount"] + mf["sell_md_amount"] + mf["buy_sm_amount"] + mf["sell_sm_amount"] ) mf["inflow_ratio"] = (mf["main_net_inflow"] / total.replace(0, float("nan")) * 100).fillna(0) mf_positive = mf[ (mf["ts_code"].isin(set(filtered_basic["ts_code"]))) & (mf["main_net_inflow"] > 0) ].sort_values("main_net_inflow", ascending=False) candidate_codes = set(mf_positive["ts_code"].tolist()) # 构建资金流查找表 mf_lookup = {} for _, row in mf_positive.iterrows(): mf_lookup[row["ts_code"]] = { "main_net_inflow": float(row["main_net_inflow"]), "inflow_ratio": float(row.get("inflow_ratio", 0)), } logger.info(f"Step 2 资金流过滤: → {len(candidate_codes)} 只主力净流入 > 0") if not candidate_codes: return [] # 构建候选列表 import numpy as np candidates = [] for ts_code in candidate_codes: name = "" if not stock_basic.empty: row = stock_basic[stock_basic["ts_code"] == ts_code] if not row.empty: name = row.iloc[0]["name"] sector_name = sector_code_map.get(ts_code, industry_map.get(ts_code, "")) b_row = filtered_basic[filtered_basic["ts_code"] == ts_code] turnover_rate = float(b_row.iloc[0]["turnover_rate"]) if not b_row.empty else 0 circ_mv = float(b_row.iloc[0]["circ_mv"]) if not b_row.empty else 0 pe = float(b_row.iloc[0]["pe"]) if not b_row.empty and pd.notna(b_row.iloc[0].get("pe")) else None pb = float(b_row.iloc[0]["pb"]) if not b_row.empty and pd.notna(b_row.iloc[0].get("pb")) else None volume_ratio = float(b_row.iloc[0]["volume_ratio"]) if not b_row.empty and pd.notna(b_row.iloc[0].get("volume_ratio")) else None try: mf_info = mf_lookup.get(ts_code, {}) except NameError: mf_info = {} candidates.append({ "ts_code": ts_code, "name": name, "sector": sector_name, "turnover_rate": turnover_rate, "circ_mv": circ_mv, "pe": pe, "pb": pb, "volume_ratio": volume_ratio, "main_net_inflow": mf_info.get("main_net_inflow", 0), "inflow_ratio": mf_info.get("inflow_ratio", 0), }) logger.info(f"Step 2 候选: {len(candidates)} 只") return candidates async def _build_recommendations( candidates: list[dict], market_temp: MarketTemperature, hot_sectors: list[SectorInfo], market_temp_score: float = 0, intraday: bool = False, ) -> list[Recommendation]: """Step 3: 对候选做供需 + 价格行为 + 趋势深度分析 评分公式：供需关系 40% + 价格行为 35% + 趋势 25% 板块和资金流已在前置过滤中处理。 """ from app.data.tushare_client import tushare_client from app.analysis.technical import add_all_indicators from app.analysis.breakout_signals import ( classify_entry_signal, score_supply_demand, analyze_volume_pattern, EntrySignal, ) from app.analysis.signals import generate_signals from app.analysis.capital_flow import _score_valuation # 名称和行业映射 stock_basic = tushare_client.get_stock_basic() name_map = {} industry_map = {} if not stock_basic.empty: for _, row in stock_basic.iterrows(): name_map[row["ts_code"]] = row["name"] industry_map[row["ts_code"]] = row.get("industry", "") recommendations = [] llm_candidates = [] # 收集候选摘要供 LLM 分析 total = len(candidates) signal_counts = {"breakout": 0, "breakout_confirm": 0, "pullback": 0, "launch": 0, "reversal": 0, "none": 0} for idx, stock in enumerate(candidates): ts_code = stock.get("ts_code", "") if not ts_code: continue name = stock.get("name") or name_map.get(ts_code, ts_code) sector = stock.get("sector") or industry_map.get(ts_code, "") try: # 获取 120 日 K 线 df = tushare_client.get_stock_daily(ts_code, 120) if df.empty or len(df) < 30: continue # 数据新鲜度校验：最后一行必须是近 10 天内的数据 from datetime import datetime, timedelta last_date = str(df.iloc[-1]["trade_date"]) cutoff = (datetime.now() - timedelta(days=10)).strftime("%Y%m%d") if last_date < cutoff: logger.warning(f"K线数据过时 {ts_code}: 最新={last_date}, 需≥{cutoff}, 跳过") continue # 添加技术指标 df = add_all_indicators(df) # ── 入场信号分类 ── entry_signal = classify_entry_signal(df) signal_type = entry_signal["signal_type"] if signal_type == EntrySignal.NONE: signal_counts["none"] += 1 continue signal_counts[signal_type.value] += 1 # ── 三维度评分 ── # 1. 供需关系评分 (50%) — 短线核心 supply_demand_score = score_supply_demand(df) # 2. 价格行为评分 (40%) — 形态质量 price_action_score = _score_price_action(df, entry_signal) # 3. 趋势评分 (10%) — 短线趋势权重低，偏空直接过滤 trend_score = _score_trend(df) # 趋势偏空门槛过滤：MA5 20: penalties.append(0.65) elif tech_signal.rally_pct_5d > 15: penalties.append(0.80) sector_stage = _get_sector_stage(sector, hot_sectors) if sector_stage == "end": penalties.append(0.70) elif sector_stage == "late": penalties.append(0.88) if market_temp_score < 30: penalties.append(0.75) elif market_temp_score < 50: penalties.append(0.88) # 取最大惩罚（1.0 = 无惩罚） if penalties: final_score *= min(penalties) # 奖励可叠加（奖励之间互不矛盾） sector_limit_up = _get_sector_limit_up(sector, hot_sectors) sector_member_count = _get_sector_member_count(sector, hot_sectors) if sector_limit_up >= 5: final_score *= 1.20 # 板块5+涨停，情绪极强 elif sector_limit_up >= 3: final_score *= 1.10 # 板块3涨停，情绪较强 if entry_signal.get("signal_score", 0) >= 80: final_score *= 1.10 # 估值评分（辅助参考，不参与主评分） pe = stock.get("pe") pb = stock.get("pb") valuation_score = _score_valuation(pe, pb) # 确定信号和等级 level = _score_to_level(final_score) signal = "HOLD" position_score = tech_signal.position_score if tech_signal else 50 if (signal_type != EntrySignal.NONE and entry_signal.get("signal_score", 0) >= 50 and position_score >= 30 and final_score >= 60): signal = "BUY" # 价格参考 — 结构化止损止盈（基于市场结构而非固定百分比） entry_price = None target_price = None stop_loss = None if tech_signal: current_close = stock.get("price") or float(df.iloc[-1]["close"]) st = signal_type.value details = entry_signal.get("details", {}) # ── 入场价：统一为当前价（短线看盘即时进场） ── entry_price = round(current_close, 2) # ── 止损价：基于市场结构 ── if st == "breakout": # 突破型：止损在突破点（被突破的阻力位）下方1% resistance = details.get("resistance_price", 0) if resistance and resistance > 0: stop_loss = round(resistance * 0.99, 2) else: # fallback: 近20日低点下方1% low_20 = float(df.tail(20)["low"].min()) stop_loss = round(low_20 * 0.99, 2) elif st == "pullback": # 回踩型：止损在支撑均线下方1.5% support_ma = details.get("support_ma", "MA20") support_price = 0 if support_ma == "MA20" and not pd.isna(last.get("ma20")): support_price = last["ma20"] elif support_ma == "MA10" and not pd.isna(last.get("ma10")): support_price = last["ma10"] if support_price > 0: stop_loss = round(support_price * 0.985, 2) else: stop_loss = round(current_close * 0.97, 2) elif st == "reversal": # 反转型：止损在近5日最低点下方1% low_5 = float(df.tail(5)["low"].min()) stop_loss = round(low_5 * 0.99, 2) elif st == "launch": # 启动型：止损在MA20下方2% if not pd.isna(last.get("ma20")) and last["ma20"] > 0: stop_loss = round(last["ma20"] * 0.98, 2) else: stop_loss = round(current_close * 0.97, 2) else: # breakout_confirm / 其他：近20日低点下方1% low_20 = float(df.tail(20)["low"].min()) stop_loss = round(min(low_20 * 0.99, current_close * 0.97), 2) # ── 止盈价：基于下一个阻力位 ── # 近20日高点作为第一阻力 high_20 = float(df.tail(20)["high"].max()) # 近60日高点作为第二阻力 high_60 = float(df.tail(60)["high"].max()) if len(df) >= 60 else high_20 if st == "breakout": # 突破型：刚突破20日高点，目标看60日高点附近 if high_60 > current_close: target_price = round(min(high_60 * 0.98, entry_price * 1.08), 2) else: target_price = round(entry_price * 1.05, 2) elif st == "launch": # 启动型：整理后启动，目标看整理区间上方+8% target_price = round(min(high_20 * 1.03, entry_price * 1.08), 2) elif st == "reversal": # 反转型：从低位反转，目标看近20日高点 target_price = round(min(high_20 * 0.98, entry_price * 1.08), 2) elif st == "pullback": # 回踩型：目标看前高附近 target_price = round(min(high_20 * 0.98, entry_price * 1.05), 2) else: # breakout_confirm / 其他 target_price = round(min(high_20 * 0.98, entry_price * 1.05), 2) # 保底：止损不超过入场价-8%（防止结构化止损太远） max_stop_pct = 0.08 if stop_loss < entry_price * (1 - max_stop_pct): stop_loss = round(entry_price * (1 - max_stop_pct), 2) # 止损不低于入场价-2%（止损太近没有意义） min_stop_pct = 0.02 if stop_loss > entry_price * (1 - min_stop_pct): stop_loss = round(entry_price * (1 - min_stop_pct), 2) # 保底：止盈不低于入场价+3%（空间太小不值得做） min_target_pct = 0.03 if target_price < entry_price * (1 + min_target_pct): target_price = round(entry_price * (1 + min_target_pct), 2) # 生成推荐理由 reasons = _generate_reasons(stock, entry_signal, tech_signal, df, intraday) risk_note = _generate_risk_note(market_temp, tech_signal, stock) # 量价模式 vol_pattern = analyze_volume_pattern(df) # 进场时机建议（盘中适用） entry_timing = _generate_entry_timing(signal_type.value, intraday) rec = Recommendation( ts_code=ts_code, name=name, sector=sector, score=round(final_score, 1), market_temp_score=round(market_temp_score, 1), sector_score=round(_get_sector_heat(sector, hot_sectors), 1), capital_score=round(_score_capital_simple(stock), 1), technical_score=round(trend_score, 1), supply_demand_score=round(supply_demand_score, 1), price_action_score=round(price_action_score, 1), position_score=round(position_score, 1), valuation_score=round(valuation_score, 1), signal=signal, entry_price=entry_price, target_price=target_price, stop_loss=stop_loss, reasons=reasons, risk_note=risk_note, level=level, strategy="trend_breakout", entry_signal_type=signal_type.value, entry_timing=entry_timing, ) recommendations.append(rec) # 收集 LLM 分析所需的候选摘要（不含 signal_type，让 LLM 独立判断） llm_candidate = { "ts_code": ts_code, "name": name, "sector": sector, "quant_score": round(final_score, 1), "position_score": round(position_score, 1), "current_price": stock.get("price") or float(df.iloc[-1]["close"]), "kline_summary": _summarize_for_llm(df, entry_signal, tech_signal), "capital_flow_summary": ( f"主力净流入{stock.get('main_net_inflow', 0):.0f}万, " f"占比{stock.get('inflow_ratio', 0):.1f}%" ), } # 盘中模式：补充分时量能分布数据 if intraday: try: from app.data.eastmoney_client import get_min_kline, analyze_intraday_volume_distribution min_df = await get_min_kline(ts_code, period="5", count=48) if not min_df.empty: vol_dist = analyze_intraday_volume_distribution(min_df) llm_candidate["intraday_volume"] = ( f"上午量占比{vol_dist['morning_volume_ratio']}%, " f"下午{vol_dist['afternoon_volume_ratio']}%, " f"开盘30分{vol_dist['opening_strength']}%, " f"尾盘30分{vol_dist['closing_strength']}%, " f"趋势={vol_dist['volume_trend']}" ) if vol_dist["key_periods"]: llm_candidate["intraday_volume"] += f", 放量时段: {'; '.join(vol_dist['key_periods'])}" except Exception as e: logger.debug(f"分时量能数据获取失败 {ts_code}: {e}") llm_candidates.append(llm_candidate) except Exception as e: logger.debug(f"深度分析 {ts_code} 失败: {e}") continue # 让出控制权（同步函数中无法 await，跳过） # idx % 10 == 0 的让步在 _select_from_hot_sectors 的上层 async 函数中处理 logger.info( f"Step 3 入场信号分布: " f"突破={signal_counts['breakout']} 确认={signal_counts['breakout_confirm']} " f"回踩={signal_counts['pullback']} 启动={signal_counts['launch']} " f"反转={signal_counts['reversal']} 无信号={signal_counts['none']} " f"(共分析{total}只)" ) # ── LLM 逐股深度分析 ── if settings.deepseek_api_key and llm_candidates: try: from app.llm.batch_screener import analyze_candidates_individually # 只对量化评分 Top N 做LLM分析，减少API调用 llm_candidates.sort(key=lambda c: c["quant_score"], reverse=True) llm_top = llm_candidates[:settings.top_stock_count] market_summary = ( f"市场温度: {market_temp.temperature}/100, " f"涨跌比: {market_temp.up_count}涨/{market_temp.down_count}跌, " f"涨停: {market_temp.limit_up_count}家" ) llm_results = await analyze_candidates_individually(llm_top, market_summary) # 综合量化 + LLM 判断 for rec in recommendations: llm_data = llm_results.get(rec.ts_code) if llm_data: rec.llm_analysis = llm_data.get("analysis", "") # LLM 信号强度转换为分数调整 strength = llm_data.get("strength", "中") llm_signal = llm_data.get("signal", "HOLD") # 基础调整：量化评分 * 调整系数 if llm_signal == "SKIP": adjustment = 0.50 elif llm_signal == "HOLD": adjustment = 0.85 elif llm_signal == "BUY" and strength == "强": adjustment = 1.15 elif llm_signal == "BUY" and strength == "中": adjustment = 1.05 else: # BUY + 弱 adjustment = 1.00 rec.score = round(rec.score * adjustment, 1) rec.level = _score_to_level(rec.score) # 用 LLM 给出的价格替代硬编码价格 if llm_data.get("entry_price"): rec.entry_price = llm_data["entry_price"] if llm_data.get("target_price"): rec.target_price = llm_data["target_price"] if llm_data.get("stop_loss"): rec.stop_loss = llm_data["stop_loss"] recommendations.sort(key=lambda r: r.score, reverse=True) recommendations = recommendations[:settings.top_stock_count] logger.info(f"LLM 逐股分析完成, 综合评分后保留 {len(recommendations)} 只") except Exception as e: logger.error(f"LLM 逐股分析失败, 仅使用量化评分: {e}") return recommendations # ── 价格行为评分 ── def _score_price_action(df, entry_signal: dict) -> float: """价格行为学评分 (0-100) 纯粹关注 K 线形态和量价配合，不重复评估趋势/均线因素。 维度： - K线形态强度 (35): 实体占比、收盘位置、下影线 - 量价配合 (35): 放量/缩量与价格方向的配合度 - 入场形态质量 (30): 各信号类型的形态完成度 """ import pandas as pd score = 0 last = df.iloc[-1] details = entry_signal.get("details", {}) signal_type = entry_signal.get("signal_type") # K线形态强度 (35) day_range = last["high"] - last["low"] if day_range > 0: # 实体占比（实体/全振幅） body = abs(last["close"] - last["open"]) body_ratio = body / day_range if body_ratio > 0.7: score += 20 # 大实体，方向明确 elif body_ratio > 0.4: score += 12 elif body_ratio > 0.2: score += 6 # 收盘位置（越接近高点越好） close_position = (last["close"] - last["low"]) / day_range if close_position > 0.8: score += 10 # 收在上部 20% elif close_position > 0.6: score += 6 elif close_position > 0.4: score += 3 # 下影线（回踩型/启动型利好） lower_wick = (last["open"] - last["low"]) if last["close"] > last["open"] else (last["close"] - last["low"]) if lower_wick > 0: wick_ratio = lower_wick / day_range if signal_type and signal_type.value in ("pullback", "reversal") and wick_ratio > 0.2: score += 5 # 回踩型/反转型有下影线支撑 # 量价配合 (35) vol_ma_col = "vol_ma5" if "vol_ma5" in df.columns else None if vol_ma_col and not pd.isna(last[vol_ma_col]) and last[vol_ma_col] > 0: vol_ratio = last["vol"] / last[vol_ma_col] price_up = last["pct_chg"] > 0 if "pct_chg" in df.columns else last["close"] > last["open"] if price_up and vol_ratio > 2.0: score += 35 # 放量大阳 elif price_up and vol_ratio > 1.5: score += 25 elif price_up and vol_ratio > 1.2: score += 18 elif not price_up and vol_ratio < 0.7: score += 25 # 缩量回调（良性） elif not price_up and vol_ratio < 0.9: score += 15 elif price_up and vol_ratio > 1.0: score += 10 else: score += 10 # 入场形态质量 (30) — 只评估形态完成度，不涉及均线/MACD if signal_type and signal_type.value == "breakout": breakout_pct = details.get("breakout_pct", 0) vol_ratio = details.get("volume_ratio", 1) if breakout_pct > 2 and vol_ratio > 2: score += 30 elif breakout_pct > 1 and vol_ratio > 1.5: score += 20 elif breakout_pct > 0: score += 12 else: score += 6 elif signal_type and signal_type.value == "breakout_confirm": vol_ratio = details.get("volume_ratio", 1) confirm_pct = details.get("confirm_pct", 0) if vol_ratio > 2 and confirm_pct > 2: score += 30 elif vol_ratio > 1.5 and confirm_pct > 1: score += 22 elif vol_ratio > 1.0: score += 14 else: score += 8 elif signal_type and signal_type.value == "pullback": support_ma = details.get("support_ma", "") shrink = details.get("volume_shrink_ratio", 1) if support_ma == "MA20" and shrink < 0.6: score += 30 elif support_ma == "MA20": score += 22 elif support_ma == "MA10" and shrink < 0.6: score += 18 else: score += 10 elif signal_type and signal_type.value == "launch": range_pct = details.get("price_range_pct", 10) if range_pct < 3: score += 30 elif range_pct < 5: score += 20 else: score += 10 elif signal_type and signal_type.value == "reversal": reversal_pct = details.get("reversal_pct", 0) vol_ratio = details.get("volume_ratio", 1) if reversal_pct > 5 and vol_ratio > 2.5: score += 30 elif reversal_pct > 3 and vol_ratio > 2: score += 22 elif reversal_pct > 3: score += 14 else: score += 8 else: score += 10 return min(score, 100) # ── 趋势评分 ── def _score_trend(df) -> float: """趋势评分 (0-100) 维度： - 均线排列 (40): MA5>MA10>MA20>MA60 - 更高高点/更高低点结构 (35): 近 20 日价格结构 - MA20 方向 (25): MA20 是否持续上行 """ import pandas as pd score = 0 last = df.iloc[-1] # 均线排列 (40) ma_cols = [c for c in ["ma5", "ma10", "ma20", "ma60"] if c in df.columns] if len(ma_cols) >= 4 and not any(pd.isna(last[c]) for c in ma_cols): if last["ma5"] > last["ma10"] > last["ma20"] > last["ma60"]: score += 40 # 完美多头 elif last["ma5"] > last["ma10"] > last["ma20"]: score += 28 elif last["ma5"] > last["ma20"]: score += 15 elif "ma5" in df.columns and "ma20" in df.columns: if not pd.isna(last["ma5"]) and not pd.isna(last["ma20"]) and last["ma5"] > last["ma20"]: score += 15 # 更高高点/更高低点结构 (35) if len(df) >= 20: recent = df.tail(20) # 检查高点抬升 first_10_high = recent["high"].iloc[:10].max() second_10_high = recent["high"].iloc[10:].max() # 检查低点抬升 first_10_low = recent["low"].iloc[:10].min() second_10_low = recent["low"].iloc[10:].min() if second_10_high > first_10_high and second_10_low > first_10_low: score += 35 # 既抬高点又抬低点，最健康 elif second_10_high > first_10_high: score += 20 # 至少高点抬升 elif second_10_low > first_10_low: score += 12 # 至少低点抬升 # MA20 方向 (25) if "ma20" in df.columns and len(df) >= 5: ma20_now = last["ma20"] ma20_5d = df.iloc[-5]["ma20"] if not pd.isna(ma20_now) and not pd.isna(ma20_5d) and ma20_5d > 0: ma20_pct = (ma20_now - ma20_5d) / ma20_5d * 100 if ma20_pct > 2: score += 25 elif ma20_pct > 1: score += 18 elif ma20_pct > 0: score += 10 return min(score, 100) # ── 辅助函数 ── def _get_sector_stage(sector_name: str, hot_sectors: list[SectorInfo]) -> str: """获取板块所处阶段""" for s in hot_sectors: if s.sector_name == sector_name: return s.stage return "mid" def _get_sector_heat(sector_name: str, hot_sectors: list[SectorInfo]) -> float: """获取板块热度得分""" for s in hot_sectors: if s.sector_name == sector_name: return s.heat_score return 30.0 def _get_sector_limit_up(sector_name: str, hot_sectors: list[SectorInfo]) -> int: """获取板块涨停数""" for s in hot_sectors: if s.sector_name == sector_name: return s.limit_up_count return 0 def _get_sector_member_count(sector_name: str, hot_sectors: list[SectorInfo]) -> int: """获取板块成分股数量""" for s in hot_sectors: if s.sector_name == sector_name: return s.member_count return 0 def _score_capital_simple(stock: dict) -> float: """资金流简单评分（仅基于已有数据，不额外调 API）""" main_net = stock.get("main_net_inflow", 0) or 0 inflow_ratio = stock.get("inflow_ratio", 0) or 0 score = 0 if main_net > 10000: score += 60 elif main_net > 5000: score += 45 elif main_net > 2000: score += 30 elif main_net > 0: score += 15 if inflow_ratio > 15: score += 40 elif inflow_ratio > 10: score += 30 elif inflow_ratio > 5: score += 20 elif inflow_ratio > 0: score += 10 return min(score, 100) def _generate_entry_timing(signal_type: str, intraday: bool) -> str: """根据信号类型生成进场时机建议""" if not intraday: return "" # 盘后模式不需要时机建议 timing_map = { "breakout": "开盘观察是否站稳突破位，午后14:00确认不回落再进场", "breakout_confirm": "突破已确认，盘中放量时可直接进场", "pullback": "盘中靠近支撑位时分批进场，尾盘14:30确认支撑有效可加仓", "launch": "早盘放量确认后即可进场，注意开盘9:30-10:00量能", "reversal": "午后13:30确认不回落再进场，避免早盘追高", } return timing_map.get(signal_type, "盘中观察量价配合，确认信号后进场") def _score_to_level(score: float) -> str: if score >= 80: return "强烈推荐" elif score >= 60: return "推荐" elif score >= 40: return "观望" else: return "回避" def _generate_reasons( stock: dict, entry_signal: dict, tech: TechnicalSignal | None, df, intraday: bool = False, ) -> list[str]: """生成推荐理由""" import pandas as pd from app.analysis.breakout_signals import EntrySignal reasons = [] signal_type = entry_signal.get("signal_type") details = entry_signal.get("details", {}) signal_map = {EntrySignal.BREAKOUT: "突破型", EntrySignal.BREAKOUT_CONFIRM: "确认型", EntrySignal.PULLBACK: "回踩型", EntrySignal.LAUNCH: "启动型", EntrySignal.REVERSAL: "反转型"} entry_label = signal_map.get(signal_type, "") # 入场信号 if entry_label and signal_type: st = signal_type.value if st == "breakout": breakout_pct = details.get("breakout_pct", 0) vol_ratio = details.get("volume_ratio", 0) reasons.append(f"放量突破20日阻力位（涨幅{breakout_pct:.1f}%，量比{vol_ratio:.1f}倍）") elif st == "breakout_confirm": vol_ratio = details.get("volume_ratio", 0) confirm_pct = details.get("confirm_pct", 0) reasons.append(f"突破后放量确认（确认日涨{confirm_pct:.1f}%，量比{vol_ratio:.1f}倍）") elif st == "pullback": support = details.get("support_ma", "") shrink = details.get("volume_shrink_ratio", 0) reasons.append(f"缩量回踩{support}支撑（量能收缩至{shrink:.0%}）") elif st == "launch": range_pct = details.get("price_range_pct", 0) reasons.append(f"缩量横盘整理{range_pct:.1f}%后首日放量启动") elif st == "reversal": reversal_pct = details.get("reversal_pct", 0) vol_ratio = details.get("volume_ratio", 0) reasons.append(f"连续下跌后放量长阳反转（涨{reversal_pct:.1f}%，量比{vol_ratio:.1f}倍）") # 供需分析 if len(df) >= 10: recent = df.tail(10) up_days = recent[recent["pct_chg"] > 0] down_days = recent[recent["pct_chg"] <= 0] if len(up_days) > 0 and len(down_days) > 0: avg_up_vol = up_days["vol"].mean() avg_down_vol = down_days["vol"].mean() if avg_down_vol > 0: ds_ratio = avg_up_vol / avg_down_vol if ds_ratio > 1.5: reasons.append(f"需求主导（上涨均量/下跌均量={ds_ratio:.1f}）") # 资金流 main_net = stock.get("main_net_inflow", 0) if main_net > 5000: reasons.append(f"主力资金大幅流入{main_net:.0f}万元") elif main_net > 1000: reasons.append(f"主力资金持续流入{main_net:.0f}万元") # 板块 sector = stock.get("sector", "") if sector: reasons.append(f"所属热门板块【{sector}】") return reasons[:3] def _generate_risk_note( market: MarketTemperature, tech: TechnicalSignal | None, stock: dict, ) -> str: """生成风险提示""" notes = [] entry_type = stock.get("entry_signal_type", "") if entry_type == "breakout": notes.append("突破型需警惕假突破，关注量能是否持续") elif entry_type == "breakout_confirm": notes.append("确认型需观察后续量能是否跟上，防止冲高回落") elif entry_type == "pullback": notes.append("回踩型可能继续下探支撑，注意止损纪律") elif entry_type == "launch": notes.append("启动型整理可能延长，注意时间成本") elif entry_type == "reversal": notes.append("反转型可能二次探底，确认底部后再加仓") if market.temperature < 30: notes.append("市场情绪偏冷，系统性风险较高") elif market.temperature < 50: notes.append("市场情绪一般，注意仓位控制") if tech: if tech.position_score < 30: notes.append(f"近期涨幅较大(5日{tech.rally_pct_5d}%)，追高风险") if tech.rally_pct_10d > 20: notes.append(f"10日累涨{tech.rally_pct_10d}%，警惕回调") if not notes: return "注意设好止损，控制仓位" return "；".join(notes) def _summarize_for_llm(df, entry_signal: dict, tech_signal: TechnicalSignal | None) -> str: """生成 K 线分析结论供 LLM 判断（输出结论而非原始数据）""" import pandas as pd last = df.iloc[-1] parts = [] # ── 趋势结论 ── ma_fields = ["ma5", "ma10", "ma20", "ma60"] ma_vals = {m: last.get(m) for m in ma_fields} trend_desc = "趋势不明" all_ma_valid = all(ma_vals.get(m) is not None and not pd.isna(ma_vals[m]) for m in ma_fields) if all_ma_valid: if ma_vals["ma5"] > ma_vals["ma10"] > ma_vals["ma20"] > ma_vals["ma60"]: trend_desc = "强势多头排列(MA5>MA10>MA20>MA60)" elif ma_vals["ma5"] > ma_vals["ma10"] > ma_vals["ma20"]: trend_desc = "中短期多头(MA5>MA10>MA20)" elif ma_vals["ma5"] > ma_vals["ma20"]: trend_desc = "偏多(MA5在MA20上方)" elif ma_vals["ma5"] < ma_vals["ma10"] < ma_vals["ma20"]: trend_desc = "空头排列，趋势偏弱" else: trend_desc = "均线交织，趋势震荡" # MA20 方向 if len(df) >= 5 and not pd.isna(last.get("ma20")) and not pd.isna(df.iloc[-5].get("ma20")): ma20_now = last["ma20"] ma20_5d = df.iloc[-5]["ma20"] if ma20_5d > 0: ma20_pct = (ma20_now - ma20_5d) / ma20_5d * 100 if ma20_pct > 2: trend_desc += "，MA20快速上扬" elif ma20_pct > 0: trend_desc += "，MA20缓慢上行" else: trend_desc += "，MA20走平或下行" parts.append(trend_desc) # ── 量价结论 ── if len(df) >= 10: recent = df.tail(10) up_days = recent[recent["pct_chg"] > 0] down_days = recent[recent["pct_chg"] <= 0] vol_conclusion = "" if len(up_days) > 0 and len(down_days) > 0: avg_up_vol = up_days["vol"].mean() avg_down_vol = down_days["vol"].mean() if avg_down_vol > 0: ratio = avg_up_vol / avg_down_vol if ratio > 1.5: vol_conclusion = f"量价健康(上涨均量/下跌均量={ratio:.1f}，需求主导)" elif ratio > 1.0: vol_conclusion = f"量价尚可(量比={ratio:.1f}，需求略强)" else: vol_conclusion = f"量价偏弱(量比={ratio:.1f}，供给主导)" if not vol_conclusion: vol_conclusion = "量价数据不足" # 最近5日量能变化 recent_5 = df.tail(5) vol_ma5 = recent_5["vol"].mean() vol_ma10 = df.tail(10)["vol"].mean() if vol_ma10 > 0: vol_ratio = vol_ma5 / vol_ma10 if vol_ratio > 1.5: vol_conclusion += "，近5日明显放量" elif vol_ratio < 0.7: vol_conclusion += "，近5日缩量" parts.append(vol_conclusion) # ── MACD 结论 ── dif = last.get("dif", 0) or 0 dea = last.get("dea", 0) or 0 macd_desc = "" if len(df) >= 3: prev_dif = df.iloc[-2].get("dif", 0) or 0 prev_dea = df.iloc[-2].get("dea", 0) or 0 if dif > dea and prev_dif <= prev_dea: macd_desc = "MACD刚金叉" elif dif > dea: macd_desc = "MACD金叉运行中" elif dif < dea and prev_dif >= prev_dea: macd_desc = "MACD刚死叉" elif dif < dea: macd_desc = "MACD死叉运行中" if dif > 0: macd_desc += "，零轴上方(偏多)" else: macd_desc += "，零轴下方(偏空)" parts.append(macd_desc or "MACD数据不足") # ── RSI 结论 ── rsi = last.get("rsi14", 50) if not pd.isna(rsi): if rsi > 80: parts.append(f"RSI14={rsi:.0f}，超买区，回调风险大") elif rsi > 70: parts.append(f"RSI14={rsi:.0f}，偏高，注意追高风险") elif rsi >= 40: parts.append(f"RSI14={rsi:.0f}，健康区间") else: parts.append(f"RSI14={rsi:.0f}，偏低，可能超卖") # ── 价格位置结论 ── if tech_signal: pos_parts = [] if tech_signal.rally_pct_5d > 15: pos_parts.append(f"5日已涨{tech_signal.rally_pct_5d}%，追高风险大") elif tech_signal.rally_pct_5d > 8: pos_parts.append(f"5日涨{tech_signal.rally_pct_5d}%，短期有一定涨幅") elif tech_signal.rally_pct_5d > 0: pos_parts.append(f"5日涨{tech_signal.rally_pct_5d}%，涨幅温和") else: pos_parts.append(f"5日跌{abs(tech_signal.rally_pct_5d)}%，回调中") if tech_signal.distance_from_high >= 0: pos_parts.append("处于60日新高附近") elif tech_signal.distance_from_high > -5: pos_parts.append(f"距60日高点{abs(tech_signal.distance_from_high):.1f}%") else: pos_parts.append(f"距60日高点{abs(tech_signal.distance_from_high):.1f}%，位置较低") parts.append("位置: " + "，".join(pos_parts)) # ── 近5日价格走势简述 ── if len(df) >= 5: recent_5 = df.tail(5) closes = recent_5["close"].tolist() first_c = closes[0] last_c = closes[-1] pct_5d = (last_c - first_c) / first_c * 100 parts.append(f"当前价: {last_c:.2f}，5日{'涨' if pct_5d >= 0 else '跌'}{abs(pct_5d):.1f}%") return "\n".join(parts)