akg-factor-bridge/plan.py

1224 lines
71 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""每日选股计划(R4):数据装配 / Markdown 渲染 / 产出,三段分离。
collect() -> dict 结构化计划——api.py 直接当 JSON 返回
render_md() -> str 从 dict 渲染 Markdown
generate() CLI 与 cron 的入口:collect + render + 落盘 + 打印
数据全部来自已落库的表,不重算:
平台因子表 t_factor_akg_score / _gate / _upside / _heat —— 当日截面
基座只读视图 v_factor_transmission —— 传导证据
基座 industry_pools —— 股票名称
升降档一节对比前一交易日的档位表——数据到达本身是信号(首次覆盖 /
新进传导链即升档)。
2026-09-03 起(《主观量化系统方案_2026-09-03》第 3.3 节):候选卡每票多带数据基座的因果论断
证据线(只展示不进判决,sources.logic_claims);generate 出计划时把市场四项(两市成交额、广度、
融资、恐贪,sources.market_context)写进快照的 market 段,与 08:45 追加的 regime 段并列,
接口 /plan 只从快照读这两段。
"""
from __future__ import annotations # 注解不在定义时求值:开发机的 Python 3.9 也能导入本模块跑离线单测
import datetime as dt
import json
import os
import re
import pandas as pd
import card
import rating_priority
import common
import config
import judgement
import logic_state
import logic_state_daily
import db
import sources
import version
import plan_inputs
import plan_versions
# 来源代理只在输入录制/重放上下文内生效。普通独立研究调用保持原行为。
sources = plan_inputs.Readers(sources)
db = plan_inputs.Readers(db, {'read_pg', 'read_mysql'})
judgement = plan_inputs.Readers(judgement, {'load_previous', 'recent_rows'})
logic_state_daily = plan_inputs.Readers(logic_state_daily, {'history'})
config = plan_inputs.Config(config)
# 分数编码(与 factors.build_score 一致):主榜 = 200 + 传导档位×20 + 组内分,
# 观察档 = 100 + 组内分,组内分 clip ±9.9。150 落在两带中间的空档上,用作分界。
_MAIN_MIN = 150.0
def _factor(table: str, ds: str) -> pd.Series:
df = db.read_mysql(
"factor",
f"SELECT stock_code, factor_value FROM {table} WHERE trade_date = %s", (ds,))
if df.empty:
return pd.Series(dtype=float)
return df.set_index("stock_code")["factor_value"].astype(float)
def _latest_date(table: str, upto: str | None = None):
if upto:
df = db.read_mysql(
"factor", f"SELECT MAX(trade_date) d FROM {table} "
f"WHERE trade_date <= %s", (upto,))
else:
df = db.read_mysql("factor", f"SELECT MAX(trade_date) d FROM {table}")
v = None if df.empty else df.iloc[0, 0]
return None if v is None or pd.isna(v) else pd.Timestamp(v).date().isoformat()
def _prev_date(table: str, before: str):
df = db.read_mysql(
"factor", f"SELECT MAX(trade_date) d FROM {table} "
f"WHERE trade_date < %s", (before,))
v = None if df.empty else df.iloc[0, 0]
return None if v is None or pd.isna(v) else pd.Timestamp(v).date().isoformat()
def _names() -> dict:
out = {}
pools = db.read_pg("SELECT members FROM industry_pools")
for _, r in pools.iterrows():
ms = r["members"]
if isinstance(ms, str):
ms = json.loads(ms)
for m in ms or []:
ts, name = (m or {}).get("ts_code"), (m or {}).get("name")
if ts and name:
out.setdefault(common.to_prefix(ts), str(name))
return out
def _evidence(ds: str):
"""每股最强一条传导证据:主题、源数、已动比例;另返回涉及的行情快照日。"""
tr = db.read_pg(
"SELECT ts_code, target, n_sources, moved_ratio, mkt_trade_date, "
"members_total, moved FROM v_factor_transmission WHERE scan_date = %s", (ds,))
if tr.empty:
return {}, set()
tr["k"] = tr["ts_code"].map(common.to_prefix)
tr["n_sources"] = pd.to_numeric(tr["n_sources"], errors="coerce").fillna(0)
tr["moved_ratio"] = pd.to_numeric(tr["moved_ratio"], errors="coerce").fillna(0)
tr["strength"] = tr["n_sources"] * (1.0 - tr["moved_ratio"])
tr = tr.sort_values(["strength", "k", "target", "n_sources", "moved_ratio",
"members_total", "moved", "mkt_trade_date"],
ascending=[False, True, True, False, True, False, False, False],
kind="mergesort").drop_duplicates("k")
# 元组前三项是既有口径(多处按下标取),第四、五项是环节的成员数与已动数(关注环节表用)
ev = {r.k: (str(r.target), int(r.n_sources), float(r.moved_ratio),
None if pd.isna(r.members_total) else int(r.members_total),
None if pd.isna(r.moved) else int(r.moved))
for r in tr.itertuples()}
days = {str(x) for x in tr["mkt_trade_date"].dropna().unique()}
return ev, days
def _tier_label(score: float) -> str:
return {0: "无传导", 1: "弱传导", 2: "强传导"}.get(
int((score - 190.0) // 20), "?")
def _quality_bonus(cr, bonus: float) -> float:
"""公司质地评析对组内分的加成(2026-09-14 工作包四)。
质地好加 bonus、差减 bonus,中/证据不足/无评析都不动。bonus 为 0 时恒回 0。"""
if not bonus or not isinstance(cr, dict):
return 0.0
o = cr.get("overall")
if o == "好":
return float(bonus)
if o == "差":
return -float(bonus)
return 0.0
def _rerank_by_quality(ranked, cards: dict, bonus: float):
"""按质地调整分给一段榜单(主榜或观察档的分数序列)重排名次。
只改顺序,序列里的分值仍是原始分——档位标签靠原始分解码,不能被加成污染。
并列时用稳定排序保留原始名次;bonus 为 0 或空榜时原样返回,保证关掉即逐字回旧。"""
if not bonus or ranked.empty:
return ranked
adj = ranked + pd.Series(
{k: _quality_bonus((cards.get(k) or {}).get("company_review"), bonus)
for k in ranked.index}, dtype=float)
order = adj.sort_values(ascending=False, kind="mergesort").index
return ranked.reindex(order)
def _rerank_by_axis(ranked, cards: dict, axis: str, stale_days: int, has_tier: bool = True):
"""质地轴重排(2026-09-17):按(质地带降序、被指向降序、组内分降序、原始分降序、代码升序)词典序。
只改顺序、不改分值——档位标签仍按原始分解码。传导强弱档位不再进次序,只保留"被指向"这一位。
"被指向"以候选卡门槛一为准(cards[k]['gates']['pointed']),不看传导视图的证据行——已启动成员在
那张视图里没有证据行,只看证据行会把它误判成没被指向。组内分从原始分反解:主榜分减二百再减档位
乘二十(档位取 int((score-190)//20));观察档没有档位,带内直接按原始分。空榜原样返回。"""
if ranked.empty:
return ranked
def _key(item):
k = item[0]
s = float(item[1])
available = pd.notna(s)
c = cards.get(k) or {}
band = c.get("quality_band")
if band is None:
band = card.quality_band(c.get("company_review"), stale_days)
pointed = bool((c.get("gates") or {}).get("pointed"))
if not available:
group, s = -float('inf'), -float('inf')
elif has_tier:
tier = int((s - 190.0) // 20)
group = s - 200.0 - tier * 20.0 # 剥掉档位:传导档位不进次序
else:
group = s # 观察档无档位,带内直接按原始分
priority = rating_priority.key(c.get('company_review')) if config.PLAN_RATING_PRIORITY_ENABLED else 0
return (-int(band), -priority, not pointed, -group, -s, k) # 每层升序排,负号即降序
order = [k for k, _ in sorted(ranked.items(), key=_key)]
return ranked.reindex(order)
def _rerank(ranked, cards: dict, has_tier: bool):
"""按 config.PLAN_RANK_AXIS 分派:quality(默认)走质地轴;transmission 逐字回旧走 09-14 的质地加成。"""
if config.PLAN_RANK_AXIS == "quality":
return _rerank_by_axis(ranked, cards, "quality", config.COMPANY_REVIEW_STALE_DAYS, has_tier)
return _rerank_by_quality(ranked, cards, config.PLAN_QUALITY_BONUS)
def take_by_theme(items, n, theme_cap, theme_of, uncapped_no_theme):
"""按主题限额截取——装配路与快照路的唯一实现(2026-09-17 修复必改一)。
items 可迭代;theme_of(item) 回主题字符串、无主题回 None。有主题的每主题最多 theme_cap 条
(0 不设限);无主题的:uncapped_no_theme 为真时免限额、不计数,为假时归"(无传导)"一个桶计数
(旧轴原样)。取够 n 条即停。两条路对"已启动成员"是否算进所在主题的分歧,靠 theme_of 同源消除。"""
out, cnt = [], {}
for it in items:
th = theme_of(it)
exempt = not th # 无主题不代表同一行业;两种排序轴都不把它们合成一桶。
if not exempt:
bucket = th or "(无传导)"
if theme_cap and cnt.get(bucket, 0) >= theme_cap:
continue
cnt[bucket] = cnt.get(bucket, 0) + 1
out.append(it)
if len(out) >= n:
break
return out
def _val(series: pd.Series, k: str):
v = series.get(k)
return None if v is None or pd.isna(v) else float(v)
def _fmt_regime(reg) -> str:
"""市场环境那一行。三种情况分开写,因为读的人要做的事不一样。
原先写「环境标签:UNKNOWN,弱势指数 None/8」。三处毛病:UNKNOWN 是枚举值,
8 是硬写的分母(快照里其实带着真实的指数总数),None 是取不到时的空值——
三样都是内部表示,不该印在给人读的报告里。
另外必须写清一件事:这个标签**不影响任何一只票买不买**。它只在事后复盘时用来
分组。不写的话,读的人看到「弱势日」会以为下面的名单被压过一轮。
"""
tail = "这个标签只在事后复盘时用来分组,不参与今天选股,也不影响任何一只票买不买。"
if (reg or {}).get("status") != "OK" or reg.get("weak_count") is None:
return ("市场环境:今天没拿到读数(择时决策系统的环境数据当天没送过来)。"
"这里留空不代表市场好或坏,下面的名单照常,不受影响。")
n = reg["weak_count"]
total = reg.get("weak_total")
line = config.REGIME_WEAK_COUNT
scope = f"{total} 个主参考指数里有 {n} 个走弱" if total else f"有 {n} 个主参考指数走弱"
if reg.get("weak_day"):
return f"市场环境:{scope}。走弱满 {line} 个就算弱势日,今天算。{tail}"
return f"市场环境:{scope},没到 {line} 个,今天不算弱势日。{tail}"
def _state_out(st) -> dict | None:
"""逻辑状态发给下游的形状:只留人要读的和判决要用的,不发内部中间量。
每路都带自己的截止日与一句话说明——四态的合成规则第一条就是每路必须带截止日,
下游要能看出"这一路的证据是哪天的",否则分不清"没有证据"和"证据很旧"。
"""
if not isinstance(st, dict):
return None
return {"state": st.get("state"), "why": st.get("why"), "as_of": st.get("as_of"),
# 落定态在 state 里(下游按它分流);原始态、落定说明、上一次落定态三键一并发出,
# 让人看得出"今天原始判的是什么、为什么被按住没迁"(2026-09-07 第三件桥侧前置)。
# 没做过落定的(旧调用、单测)原始态就是 state 本身。
"raw_state": st.get("raw_state", st.get("state")),
"settle_note": st.get("settle_note"), "prev_state": st.get("prev_state"),
"usable": st.get("usable") or [], "missing": st.get("missing") or [],
"reasons": (st.get("reasons") or [])[:6],
"paths": [{"path": p.get("path"), "signal": p.get("signal"),
"as_of": p.get("as_of"), "why": p.get("why")}
for p in (st.get("paths") or []) if isinstance(p, dict)]}
def _next_day(ds: str) -> str:
"""数据日的次日,也就是计划日。行业观点快照按计划日落库,行情与论断按数据日取,
两者在生产里本来就差一天:计划日凌晨构建,用的是上一个交易日的数据。"""
try:
return (dt.date.fromisoformat(ds) + dt.timedelta(days=1)).isoformat()
except ValueError:
return ds
def _segments_of(ds: str) -> dict:
"""每只票当日所在的全部被指向环节,按前缀码索引。
读的是完整的传导视图,不是只含已启动成员的那张——候选卡判"所在环节被指向"时
认的就是完整这张,这里必须跟它一致,否则算出来的产业研判覆盖比卡上真实看到的低。
读不到返回空字典,产业研判这一路整体缺席,不让计划断产。
"""
try:
d = db.read_pg("SELECT ts_code, target FROM v_factor_transmission "
"WHERE scan_date = %s", (ds,))
except Exception as e: # noqa: BLE001
print(f" (传导视图读取失败,产业研判这一路整体缺席: {e!r})")
return {}
out: dict = {}
for r in d.itertuples():
out.setdefault(common.to_prefix(str(r.ts_code).strip()), []).append(str(r.target))
return out
def _logic_state_of(k: str, evd: dict, seg_of: dict, seg_view: dict,
broker: dict, ds: str, full_logic=None, seg_hist=None, company=None) -> dict:
"""一只票的逻辑状态四态。四路各自归一,再按合成规则合成。
乙路的取法:一只票可能挂在多个被指向的环节上,取第一个有行业观点的那个。
取不到就是缺失,卡上会写明缺的是哪一路——缺失既不算负面也不算正面证据,
但必须让人看得见系统缺的是什么,不能让人以为系统判过了。
"""
# 甲路吃全量论断(2026-09-07);没传全量时退回卡上那几条,只为让旧调用与单测不断。
claims = full_logic if full_logic is not None else evd.get("logic")
a = logic_state.from_claims(claims, ds, stale_days=config.LOGIC_STALE_DAYS)
row = next((seg_view[t] for t in seg_of.get(k, []) if t in seg_view), None)
# 乙路带上这个簇近几个计划日的历史,让"偏多到偏空"的硬触发能维持住(2026-09-07)。
hist = (seg_hist or {}).get(str(row.get("cluster_key") or "")) if row else None
b = logic_state.from_judgement(row, history=hist, hold_days=config.JUDGEMENT_HOLD_DAYS)
c = broker.get(k) or logic_state.signal(
logic_state.PATH_BROKER, logic_state.SIG_NONE,
why="两个等长窗口里算不出可比的每股收益预测")
paths = [a, b, c, logic_state.from_events()]
# 第五路 公司质地(2026-09-09 接入方案第四节,开关 LOGIC_PATH_COMPANY):慢信号,单独不定态;
# 质地差且盈余质量类差才达到存疑的进入条件。关掉开关这一路根本不进合成。
if config.LOGIC_PATH_COMPANY:
paths.append(logic_state.from_company((company or {}).get(k), ds, stale_days=config.COMPANY_REVIEW_STALE_DAYS))
return logic_state.compose(paths)
def _logic_inputs(codes: list, ds: str) -> dict:
"""逻辑状态四态的取数,一次取全(计划装配与接口现算共用这一处,口径改了两边一起变)。
甲路(因果论断):2026-09-03 起挂在卡上作证据线,只展示不进判决;视图未建时为空。
2026-09-07 审查修:四态的甲路要吃**全量**论断,卡上展示只取最近几条。原先两者共用
一份截断到三条的列表,跨期翻转与同期分歧都只在三条上算,翻转两头都会判错——
历史八空两好加最新一空,全量判无法判断、三条判逻辑存疑;历史五好近三空则反过来。
全量取一次,展示从里面切前几条,取数层在截断前算的质量画像照旧挂在每条上。
乙路(产业研判):行业观点快照在交易日 D 的晚上 20:40 写,plan_date 记的是 D;计划在 D+1
凌晨构建,数据日 ds 就是 D。所以要读的是 plan_date 不晚于 ds 的最近一版,不是 ds+1。
09-04 之前这里读的是 ds+1,能对上只因为那天上午手工跑过一次快照——把一次手工操作
的时序写进了代码,到周一就全部落空(台账 033 记的"快照断了"其实是这个错,
调度中心一直在按时跑)。load_previous(D+1) 取的正是 plan_date <= D 的每簇最新一行,
顺带也扛得住某个晚上没跑:会退回上一版,陈旧天数照常累加。seg_hist 是每簇近几个
计划日的快照,给乙路判"硬触发要不要维持"(2026-09-07 审查修)。
丙路(券商行动):两个等长窗口的每股收益预测中位数与机构数。丁路无数据源,logic_state 恒出缺失。
hist 是逐票日频表里每只票的近日行,给抗抖动用(2026-09-07 第三件桥侧前置);表没建或
读不到为空字典,那时落定态等于原始态,计划照出。这张表只在早上 generate 里写,这里只读。
"""
# 券商研报原始行取一次,券商行动(丙路)与安全边际三情景(第四件)共用——两路看同一批研报。
broker_rows = sources.broker_reports(codes, ds)
return {
"logic_full": sources.logic_claims(codes, ds, per_stock=config.LOGIC_CLAIMS_FULL),
"seg_view": judgement.by_segment_name(judgement.load_previous(_next_day(ds))),
"seg_hist": judgement.recent_rows(_next_day(ds), days=config.JUDGEMENT_HOLD_DAYS),
"broker_rows": broker_rows,
"broker": sources.broker_actions(codes, ds, rows=broker_rows),
"seg_of": _segments_of(ds),
"hist": logic_state_daily.history(ds, codes=None if len(codes) > 50 else codes),
# 公司质地(2026-09-09 接入方案):基座个股深度评析索引表的摘要,第五路与卡上一行共用。读不到为空字典。
"company": sources.company_reviews(codes, ds),
}
def logic_states_for(codes: list, ds: str) -> dict:
"""给定几只票,按此刻的数据算它们的逻辑状态并按逐票日频表的历史落定,按前缀码索引。
给接口 /logic_state 用:持仓票在候选筛选第一步就被整行剔掉,计划装配根本不会走到它。
取数与计划装配走同一个 _logic_inputs,口径逐字相同;落定与计划装配走同一个 settle_one。
"""
codes = [str(c).strip() for c in (codes or []) if str(c).strip()]
if not codes:
return {}
inp = _logic_inputs(codes, ds)
out = {}
for k in codes:
raw = _logic_state_of(k, {"logic": []}, inp["seg_of"], inp["seg_view"], inp["broker"], ds,
full_logic=inp["logic_full"].get(k) or [], seg_hist=inp["seg_hist"], company=inp["company"])
out[k] = logic_state_daily.settle_one(k, raw, inp["hist"].get(k))
return out
def valuations_for(codes: list, ds: str) -> dict:
"""给定几只票的安全边际三情景(第四件),按前缀码索引。给接口 /logic_state 用:持仓页要显示
参考目标价(中性情景,2026-09-07 拍板:只显示不触发,不替代用户手设的目标价),而持仓票
不在计划里。取数与计划装配同一处:券商研报原始行、前复权收盘价。"""
codes = [str(c).strip() for c in (codes or []) if str(c).strip()]
if not codes:
return {}
rows = sources.broker_reports(codes, ds)
prices = sources.close_prices(ds)
return sources.valuation_scenarios(codes, ds, prices, rows=rows)
def _assemble_cards(ds: str, codes: list, ev: dict, upside: pd.Series,
mkt_days: set, risk: set | None = None, user_candidates=None) -> tuple[dict, list]:
"""候选卡装配(2026-09-02 方案第 2.2 节第三项):对档位表里的全部票(主榜与观察档,
裁剪之前)读三路证据、逐票判决。规则在 card.py,取数在 sources.py,这里只做对齐。
返回 (cards, segments_pointed):cards 按前缀码索引,含判决、理由、缺失、风险、卡内序
与证据线原值;segments_pointed 是"关注环节"聚合——今日被传导指向的每个环节的源数、
链符、成员数、已启动成员、领涨者、候选数。这是拍板记录第一项"强传导档降为关注环节"
在计划文本层的落地。"""
import factors
moved = sources.moved_members(ds)
daily = sources.stock_daily(ds)
night = sources.night_conclusions(codes, ds)
# 逻辑状态四态的取数(三路输入加逐票日频表的近日行;取数口径与理由见 _logic_inputs)。
# 这三路都是"研究证据还在不在"的跟踪,与候选卡的三门槛判决是正交的两维:
# 判决回答今天要不要买,四态回答支撑它的研究证据还在不在。收敛规则在
# logic_state.apply_to_card,是单调的——强化只能提前卡内序、永远不升判决。
inp = _logic_inputs(codes, ds)
logic_full, seg_view, seg_hist = inp["logic_full"], inp["seg_view"], inp["seg_hist"]
company = inp.get("company") or {}
broker, seg_of, hist = inp["broker"], inp["seg_of"], inp["hist"]
logic = {k: v[:config.LOGIC_CLAIMS_PER_STOCK] for k, v in logic_full.items()}
# 安全边际三情景(2026-09-07 第四件):按同一预测期的每股收益与市盈率预测算悲观、中性、乐观
# 三个估值与现价的差,只展示不进判决。现价与预期空间同源(前复权行情表);两处任一读不到,
# 卡上那一行写"算不出"并说明原因,不拦票、不断产。
prices = sources.close_prices(ds)
valuation = sources.valuation_scenarios(codes, ds, prices, rows=inp["broker_rows"])
# 催化事件与定价状态(2026-09-08《量价研判链吸收方案》3.4):四类券商正向事件从研报明细表算,
# 事件日字段从前复权行情表算,归成四情形。只展示加复盘分组,不进判决;任一读不到整体缺席不断产。
events = sources.analyst_events(codes, ds)
ev_fields = sources.event_day_fields(codes, ds, events)
# 相关快讯(2026-09-08 台账 050):财联社电报近 3 天点名这只票的条目,只当上下文送人看与送研判,
# 不判正负、不进判决、不进定价状态。表读不到整体缺席不断产。
news = sources.news_flashes(codes, ds)
# 行业催化(2026-09-08 台账 051):数据基座按环节评析材料标出的行业级催化,挂在环节上;
# 按票所在的被指向环节取,只展示加复盘分组,不进判决、不进逻辑状态。表没建就整体缺席。
_seg_of = inp["seg_of"]
ind_cat = sources.catalysts_for_codes(
{k: _seg_of.get(k, []) for k in codes},
sources.segment_catalysts(sorted({t for k in codes for t in _seg_of.get(k, [])}), ds))
if risk is None: # collect 会传入读过一次的名单;单独调用时自己读
try:
risk = factors._risk_set() or set() # noqa: SLF001 —— 同仓自用
except Exception: # noqa: BLE001 —— 风险名单拿不到时不当 ST 处理,与 gate 的宽容一致
risk = set()
stale = bool(mkt_days) and any(x != ds for x in mkt_days)
cards: dict = {}
for k in codes:
mv, e, d, n = moved.get(k), ev.get(k), daily.get(k, {}), night.get(k, {})
theme = (mv or {}).get("theme") or (e[0] if e else None)
n_sources = (mv or {}).get("n_sources") or (e[1] if e else None)
up = _val(upside, k)
evd = {"pointed": bool(mv or e), "theme": theme, "n_sources": n_sources,
"chain_fit": (mv or {}).get("chain_fit"),
"pct0": d.get("pct0"), "covered": up is not None, "upside": up,
"risk_name": k in risk, "user_selected": k in (user_candidates or {}),
"accum_state": n.get("accum_state"), "accum_score": n.get("accum_score"),
"accum_age": n.get("accum_age"), "y_signal": n.get("signal"),
"stale_snapshot": stale, "logic": logic.get(k) or []}
raw_state = _logic_state_of(k, evd, seg_of, seg_view, broker, ds,
full_logic=logic_full.get(k) or [], seg_hist=seg_hist, company=company)
# 抗抖动(2026-09-07 第三件桥侧前置):配上这只票在逐票日频表里的近日行,落定今天的状态。
# 进入逻辑存疑即刻成立,退出要连续几天不再存疑,其余迁移要连续几天同向;表里没有
# 这只票时落定态就是原始态。落定态进 state,原始态另存 raw_state,两个都发给下游。
state = logic_state_daily.settle_one(k, raw_state, hist.get(k),
confirm_days=config.LOGIC_SETTLE_CONFIRM_DAYS, exit_days=config.LOGIC_SETTLE_EXIT_DAYS)
j = card.judge(evd, start_pct=config.CARD_START_PCT,
accum_max_age=config.CARD_ACCUM_MAX_AGE,
require_accum_confirm=config.CARD_ACCUM_CONFIRM_REQUIRED,
consensus_admission=config.CARD_CONSENSUS_ADMISSION_ENABLED,
neg_tol=config.UPSIDE_NEG_TOLERANCE,
logic_stale_days=config.LOGIC_STALE_DAYS,
require_started=config.CARD_REQUIRE_STARTED,
company_review=company.get(k), quality_gate=config.CARD_COMPANY_QUALITY_GATE,
stale_days=config.COMPANY_REVIEW_STALE_DAYS)
cards[k] = {
**j, "logic_state": state,
"valuation": valuation.get(k), "valuation_text": card.valuation_view(valuation.get(k)),
"events": events.get(k), "events_text": card.events_view(events.get(k)),
"pricing_state": card.pricing_state(ev_fields.get(k)),
"news": news.get(k), "news_text": card.news_view(news.get(k)),
"industry_catalyst": ind_cat.get(k), "industry_catalyst_text": card.industry_catalyst_view(ind_cat.get(k)),
"company_review": company.get(k), "company_review_text": card.company_review_view(company.get(k)),
"theme": theme, "n_sources": n_sources, "chain_fit": evd["chain_fit"],
"started_source": "moved_view" if mv else None,
"logic_claims": evd["logic"],
"pct0": d.get("pct0"), "net_z": d.get("net_z"), "heat_chg": d.get("heat_chg"),
"accum": ({"state": n.get("accum_state"), "score": n.get("accum_score"),
"age": n.get("accum_age"), "pos_tag": n.get("accum_pos_tag"),
"date": n.get("conclusion_date")} if n else None),
"night": ({"signal": n.get("signal"), "support": n.get("support"),
"pressure": n.get("pressure"), "date": n.get("conclusion_date")}
if n else None),
}
for i, (k, c) in enumerate(sorted(cards.items(), key=lambda kv: (*card.sort_key(kv[1], config.CARD_SORT_BY_QUALITY, config.PLAN_RATING_PRIORITY_ENABLED), kv[0])), 1):
c["card_rank"] = i
segs: dict = {}
for k, mv in moved.items():
s = segs.setdefault(mv["theme"], {
"segment": mv["theme"], "n_sources": mv["n_sources"], "chain_fit": mv["chain_fit"],
"members_total": mv.get("members_total"), "moved": mv.get("moved"),
"started": [], "candidates": 0, "leader": None})
s["started"].append(k)
if cards.get(k, {}).get("verdict") == card.VERDICT_CANDIDATE:
s["candidates"] += 1
for e in ev.values(): # 只有未动名单的环节也是"被指向",列入但无已启动
s = segs.setdefault(e[0], {"segment": e[0], "n_sources": e[1], "chain_fit": None,
"members_total": None, "moved": None,
"started": [], "candidates": 0, "leader": None})
if s["members_total"] is None and len(e) > 4:
s["members_total"], s["moved"] = e[3], e[4]
for s in segs.values():
best, best_pct = None, None
for k in s["started"]:
# 领涨者按行情视图找,不限于档位表里的票:被指向且已启动但不在主榜与观察档的
# (无覆盖且不在赛道、或被风险闸挡)也要显示,这是"定位对不对"的读数
p = (daily.get(k) or {}).get("pct0")
if p is not None and (best_pct is None or p > best_pct):
best, best_pct = k, p
s["leader"] = {"code": best, "pct0": best_pct} if best else None
s["started_count"] = len(s["started"])
s["started_in_tiers"] = sum(1 for k in s["started"] if k in cards)
ordered = sorted(segs.values(), key=lambda s: (-s["candidates"], -(s["n_sources"] or 0),
-(s["chain_fit"] or 0), s["segment"]))
return cards, ordered
def collect(date: str | None = None, top: int = 20, obs_top: int = 10,
theme_cap: int = 5, user_candidates=None) -> dict:
"""装配一天的计划为结构化字典。数据缺失抛 RuntimeError(api 侧转 404)。
2026-09-02 起附带候选卡:main / observe 的装配、排序、裁剪一字不动(下游 PMS 只读
这两段的既有字段),每行只是多联入判决类字段;顶层新增 generated_at、plan_version、
card_counts、candidates(候选单全量,不受裁剪)、watch、segments_pointed。
`_full` 是全量主榜与观察档行,只给 generate 落快照用,api 返回前会去掉。"""
ds = date or _latest_date("t_factor_akg_score")
if not ds:
raise RuntimeError("t_factor_akg_score 还没有数据——先 build akg_score。")
score = _factor("t_factor_akg_score", ds)
gate = _factor("t_factor_akg_gate", ds)
if score.empty or gate.empty:
raise RuntimeError(f"{ds} 缺 akg_score / akg_gate——先 build 该日再出计划。")
upside = _factor("t_factor_akg_upside", ds)
if upside.empty:
# 当日 upside 表为空时现算兜底(as-of 口径不变:consensus<=当日、当日收盘价)
import factors
df_up = plan_inputs.factor_read('build_upside', ds, ds)
if df_up is not None and not df_up.empty:
x = df_up.copy()
x["k"] = x["stock_code"].map(common.to_prefix)
upside = x.groupby("k")["factor_value"].max().astype(float)
hd = _latest_date("t_factor_akg_heat", ds)
heat = _factor("t_factor_akg_heat", hd) if hd else pd.Series(dtype=float)
names = _names()
ev, mkt_days = _evidence(ds)
import user_candidates as uc
score = score[[bool(re.fullmatch(r'(SH(?:60|68)\d{4}|SZ(?:00|30)\d{4})', str(k))) for k in score.index]]
selected = {uc.normalize(r['code']): r for r in (user_candidates or [])}
if selected:
# 完整证券名称随真实修订录制,重放时不回源,也不补造历史名称。
manual_names = plan_inputs.read('user_candidates.catalog', uc.catalog)
names = dict(names)
for code in selected:
if manual_names.get(code):
names[code] = manual_names[code]
ordinary = set(score.index)
extras = [k for k in selected if k not in ordinary]
main = score[score >= _MAIN_MIN].sort_index().sort_values(ascending=False, kind='mergesort')
obs = score[score < _MAIN_MIN].sort_index().sort_values(ascending=False, kind='mergesort')
if extras:
main = pd.concat([main, pd.Series({k: float('nan') for k in extras})])
score = pd.concat([score, pd.Series({k: float('nan') for k in extras})])
generated_at = dt.datetime.now().isoformat(timespec="seconds")
try: # 风险名单只读一次:候选卡与升降档原因共用
import factors
risk = plan_inputs.factor_read('_risk_set') or set()
except Exception: # noqa: BLE001
risk = set()
if selected and config.EXCLUDE_RISK_NAMES:
risk = set(risk) | {k for k in selected
if str(names.get(k) or '').replace(' ', '').startswith(factors._RISK_PREFIXES)
or str(names.get(k) or '').endswith('退')}
cards, segments_pointed = _assemble_cards(
ds, list(main.index) + list(obs.index), ev, upside, mkt_days, risk=risk, user_candidates=selected)
# 排序轴(2026-09-17):拿到评析后在主榜与观察档这两个分数序列上重排一次。
# 下面的 _pick 出接口、_full_rows 出复盘快照、快照又喂逐票逻辑状态入库与评析目标名单——
# 四个出口都从这两个序列取,所以只在这里改一次,四处才同序。只改顺序、不改分值。
# 质地轴下先用 09-14 的旧序(_rerank_by_quality)算一遍全量名次拿 rank_old(供周报四周对照),再算新序。
axis = config.PLAN_RANK_AXIS
main_old = _rerank_by_quality(main, cards, config.PLAN_QUALITY_BONUS)
obs_old = _rerank_by_quality(obs, cards, config.PLAN_QUALITY_BONUS)
rank_old_map: dict = {}
rank_old_map.update({k: i for i, k in enumerate(main_old.index, 1)})
rank_old_map.update({k: i for i, k in enumerate(obs_old.index, 1)})
main = _rerank(main, cards, True)
obs = _rerank(obs, cards, False)
def _theme_of(k):
"""一条记录的传导主题(与 _row 写 evidence 同源):传导视图有证据行取它,否则已启动成员用
已动成员视图补的主题,都没有回 None。必改一:装配路与快照路的主题取法从此一处同源,
已启动成员两条路都算进所在主题。"""
e = ev.get(k)
if e:
return e[0]
c = cards.get(k) or {}
if c.get("started_source") == "moved_view" and c.get("theme"):
return c["theme"]
return None
def _pick(ranked: pd.Series, n: int, uncapped_no_theme: bool = False):
"""主榜/观察档截取:调模块级 take_by_theme,主题取法用 _theme_of(含已动成员视图补充),
与快照路 pick_rows 同一套规则。质地轴下无传导行免主题限额(限额防的是单板块刷屏,无传导不是板块)。"""
return take_by_theme(ranked.items(), n, theme_cap,
lambda kv: _theme_of(kv[0]), uncapped_no_theme)
def _row(rank: int, k: str, s: float, with_tier: bool) -> dict:
e = ev.get(k)
c = cards.get(k) or {}
evidence = ({"theme": e[0], "n_sources": e[1], "moved_ratio": round(e[2], 4)}
if e else None)
# 已启动成员在传导视图里没有证据行(视图只摊平未动名单):只在原本为空时用
# 已动成员视图的目标环节与源数补上,不覆盖已有值——否则到 PMS 会全落进"无主题"桶。
if evidence is None and c.get("started_source") == "moved_view" and c.get("theme"):
evidence = {"theme": c["theme"], "n_sources": c.get("n_sources"),
"moved_ratio": None, "source": "moved_view"}
r = {"rank": rank, "code": k, "name": names.get(k),
"score": round(float(s), 2) if pd.notna(s) else None,
# 调整分只随行展示、供排序追溯;档位标签仍按原始 score 解码(工作包四)
"score_adj": round(
float(s) + _quality_bonus(c.get("company_review"), config.PLAN_QUALITY_BONUS), 2) if pd.notna(s) else None,
"evidence": evidence,
"heat": _val(heat, k), "upside": _val(upside, k)}
# 排序轴四键(2026-09-17):质地带、主轴名、是否被指向(候选卡门槛一)、旧序全量名次。
# rank_old 只在质地轴下填(由 09-14 旧序再算一遍得到),供周报四周对照,四周后可停。
qb = c.get("quality_band")
if qb is None:
qb = card.quality_band(c.get("company_review"), config.COMPANY_REVIEW_STALE_DAYS)
r["quality_band"] = int(qb)
r["rank_axis"] = config.PLAN_RANK_AXIS
r["pointed"] = bool((c.get("gates") or {}).get("pointed"))
if config.PLAN_RANK_AXIS == "quality":
r["rank_old"] = rank_old_map.get(k)
if with_tier and pd.notna(s):
r["tier"] = _tier_label(s)
if c:
# 2026-09-03 新增只联入:basis(判决依据一句话)、logic(因果论断带出处的文字行)、
# card.chain_fit(链符,入池上下文用)、card.logic_claims(论断原值)、card.failed_gates。
r.update(verdict=c["verdict"], reasons=c["reasons"], missing=c["missing"],
risk=c["risk"], reference_risk=c.get('reference_risk') or [], card_rank=c["card_rank"],
basis=c.get("basis"), logic=c.get("logic") or [],
# 2026-09-04 新增:逻辑状态四态。只发状态、子因、每路的来龙去脉与
# 截止日,不发权重也不发判决改动——四态怎么作用于建仓通道是 PMS
# 那边的事,这里只提供状态与出处。
logic_state=_state_out(c.get("logic_state")),
# 安全边际三情景(2026-09-07 第四件):原值给程序,整句给人;只展示不进判决。
valuation=c.get("valuation"), valuation_text=c.get("valuation_text"),
# 催化事件与定价状态(2026-09-08):原值给程序,整句给人;只展示不进判决。
events=c.get("events"), events_text=c.get("events_text"),
pricing_state=c.get("pricing_state"),
pricing_text=card.pricing_view(c.get("pricing_state")),
# 相关快讯(2026-09-08 台账 050):原值给程序,整句给人;只是上下文,不进判决。
news=c.get("news"), news_text=c.get("news_text"),
# 行业催化(2026-09-08 台账 051):环节级,原值给程序,整句给人;只展示不进判决。
industry_catalyst=c.get("industry_catalyst"),
industry_catalyst_text=c.get("industry_catalyst_text"),
# 公司深度(2026-09-09 接入方案):质地档与评议摘要,原值给程序,整句给人;
# 质地进逻辑状态第五路与判决收敛(只降不升),评议文字只给人看与送研判。
company_review=({key: value for key, value in c['company_review'].items() if key != 'rating_priority'} if c.get('company_review') else None),
rating_priority=(c.get('company_review') or {}).get('rating_priority'),
company_review_text=c.get("company_review_text"),
company_gate=c.get("company_gate"),
card={"pct0": c.get("pct0"), "net_z": c.get("net_z"),
"heat_chg": c.get("heat_chg"), "accum": c.get("accum"),
"night": c.get("night"), "gates": c.get("gates"),
"confirm": c.get("confirm"), "failed_gates": c.get("failed_gates"),
"chain_fit": c.get("chain_fit"),
"logic_claims": c.get("logic_claims") or []})
if k in selected:
r['user_candidate'] = selected[k]
r['user_required'] = k not in ordinary or not r['pointed']
if not names.get(k):
r.update(verdict=card.VERDICT_SHOW, basis='证券资料尚未齐全,暂不参与交易')
return r
def _full_rows(ranked: pd.Series, with_tier: bool) -> list:
return [_row(i, k, s, with_tier) for i, (k, s) in enumerate(ranked.items(), 1)]
def _by_verdict(v: str) -> list:
rows = [_row(0, k, score[k], k in main.index) for k, c in cards.items()
if c.get("verdict") == v]
rows.sort(key=lambda r: r["card_rank"])
for i, r in enumerate(rows, 1):
r["rank"] = i
return rows
changes = None
prev_ds = _prev_date("t_factor_akg_gate", ds)
if prev_ds:
prev = _factor("t_factor_akg_gate", prev_ds)
both = pd.concat([prev.rename("prev"), gate.rename("cur")],
axis=1).fillna(-1.0) # -1 = 当日不在面板
lab = {-1.0: "池外", 0.0: "不采纳", 1.0: "观察档", 2.0: "主榜"}
up_df = both[both["cur"] > both["prev"]].sort_values("cur", ascending=False)
down_df = both[both["cur"] < both["prev"]].sort_values("prev", ascending=False)
# ---- 升降原因(07-31 加):区分首次覆盖 / 估值转正 / 新进传导链等。
# 依据前一日的 upside / 传导因子表;表空时现算兜底。原因是启发式归类
# (取最主要的一条),精确审计以档位表与因子表为准。
prev_up = _factor("t_factor_akg_upside", prev_ds)
if prev_up.empty:
try:
import factors
dfu = plan_inputs.factor_read('build_upside', prev_ds, prev_ds)
if dfu is not None and not dfu.empty:
x = dfu.copy()
x["k"] = x["stock_code"].map(common.to_prefix)
prev_up = x.groupby("k")["factor_value"].max().astype(float)
except Exception: # noqa: BLE001 —— 兜底失败则原因退化为通用文案
pass
prev_tr = _factor("t_factor_akg_transmission", prev_ds)
# 赛道闸与风险闸的成员集合(07-31 修:赛道闸开启后,"不在赛道"曾被
# 误标成"风险闸/档位调整"、"赛道锚生效"曾被误标成"新进传导链")。
# 两个集合都尊重各自开关:闸没开时对应原因自然不会出现。
tset = None
try:
import factors
tset = plan_inputs.factor_read('_track_set')
except Exception: # noqa: BLE001 —— 拿不到就退化为通用文案
pass
def _why(k: str, pg: float, cg: float) -> str:
if cg == 2.0: # 升入主榜
pu = _val(prev_up, k)
if pu is None:
return "首次覆盖"
return "估值转正" if pu < 0 else "重获资格"
if cg == 1.0: # 升入观察档
if k in ev: # 今天真在传导链上
pt = _val(prev_tr, k)
return "新进传导链" if pt is None or pt <= 0 else "档位调整"
if tset is not None and k in tset:
return "赛道锚生效" # 赛道成员身份给的锚(闸切换/成员变动)
return "档位调整"
if pg == 2.0: # 从主榜降出
if k in risk:
return "风险闸"
cu = _val(upside, k)
if cu is None:
return "覆盖脱落"
if cu < 0:
return "估值转负"
if tset is not None and k not in tset:
return "赛道闸外" # 有覆盖也不贵,但不在十赛道内
return "档位调整"
if pg == 1.0: # 从观察档降出
if k in risk:
return "风险闸"
if k not in ev and (tset is None or k not in tset):
return "离开传导链"
return "档位调整"
return "出入面板"
def _mv(d: pd.DataFrame):
return [{"code": k, "name": names.get(k),
"from": lab.get(r["prev"], "?"), "to": lab.get(r["cur"], "?"),
"reason": _why(k, r["prev"], r["cur"])}
for k, r in d.iterrows()]
changes = {"base_date": prev_ds,
"upgrades_total": int(len(up_df)),
"downgrades_total": int(len(down_df)),
"upgrades": _mv(up_df.head(15)),
"downgrades": _mv(down_df.head(15))}
card_counts = {v: sum(1 for c in cards.values() if c.get("verdict") == v)
for v in (card.VERDICT_CANDIDATE, card.VERDICT_WATCH, card.VERDICT_SHOW)}
result = {
"date": ds,
"user_candidates": list(selected.values()),
"generated_at": generated_at,
"plan_version": version.git_short_rev(),
"counts": {"main": int(len(main)), "observe": int(len(obs)),
"gate_covered": int(len(gate))},
"market_snapshot_days": sorted(mkt_days),
"heat_date": hd,
"theme_cap": theme_cap,
"main": [_row(i, k, s, True)
for i, (k, s) in enumerate(_pick(main, top, uncapped_no_theme=(axis == "quality")), 1)],
"observe": [_row(i, k, s, False)
for i, (k, s) in enumerate(_pick(obs, obs_top, uncapped_no_theme=(axis == "quality")), 1)],
"changes": changes,
"gate_on": bool(config.ENABLE_TRACK_GATE),
"encoding": "主榜分=200+传导档位×20+组内分(还没热、还便宜);"
"观察档分=100+0.6z(传导)+0.4z(−热度);"
"名次按开关 PLAN_RANK_AXIS:quality 时质地带优先、传导只在带内作次级键,"
"transmission 时按 09-14 的质地调整分序",
# ---- 候选卡(2026-09-02):分数与档位之外的另一份产物,不受 top / theme_cap 裁剪 ----
"card_params": {"start_pct": config.CARD_START_PCT,
"consensus_admission": config.CARD_CONSENSUS_ADMISSION_ENABLED,
"accum_confirm_required": config.CARD_ACCUM_CONFIRM_REQUIRED,
"admission_rule": ("consensus-admission-v3-20261110" if config.CARD_CONSENSUS_ADMISSION_ENABLED else
"accum-confirm-v1" if config.CARD_ACCUM_CONFIRM_REQUIRED
else "accum-reference-v2-20261104"),
"require_started": config.CARD_REQUIRE_STARTED,
"accum_max_age": config.CARD_ACCUM_MAX_AGE,
"neg_tol": config.UPSIDE_NEG_TOLERANCE,
"logic_per_stock": config.LOGIC_CLAIMS_PER_STOCK,
"rules": ("沿用质地排序,传导与吸筹仅作参考;旧择时结论不在选股层单独否决;"
"保留证券资格、有效数据及覆盖空间约束,建仓由PMS按最新基本面、技术面和择时三源合议决定"
if config.CARD_CONSENSUS_ADMISSION_ENABLED else
"候选=环节被指向∧当日涨幅达标∧券商覆盖且非ST∧明确吸筹∧无硬风险;"
"关注=三门槛全过∧无硬风险∧确认线缺失或陈旧(系统无法判断,交人裁决);"
"其余仅展示(只差覆盖、潜在吸筹等非明确状态都不升格,台账 013);"
"因果论断只展示不进判决" if config.CARD_ACCUM_CONFIRM_REQUIRED else
"质地排序不变,候选须满足现行选股资格、覆盖及风险条件;"
"吸筹仅作参考,非明确、潜在、缺评分或陈旧本身不否决;"
"高位派发及其他真实风险仍拦截,质地差仍按现行规则降为关注;"
"建仓看基本面、技术面和择时三源合议,由PMS按命令、风控与现行自决档处理;"
"因果论断只展示不进判决")},
"card_counts": card_counts,
"candidates": _by_verdict(card.VERDICT_CANDIDATE),
"watch": _by_verdict(card.VERDICT_WATCH),
"segments_pointed": segments_pointed,
"_full": {"main": _full_rows(main, True), "observe": _full_rows(obs, False)},
}
# 排序轴三个只读键(2026-09-17,只在质地轴下加):主轴名、一句话次序规则、主榜与观察档各带只数。
if axis == "quality":
def _band_counts(rows: list) -> dict:
out: dict = {}
for r in rows:
b = r.get("quality_band")
out[b] = out.get(b, 0) + 1
return out
result["rank_axis"] = axis
result["rating_priority_policy"] = {"enabled": config.PLAN_RATING_PRIORITY_ENABLED, "days": config.PLAN_RATING_PRIORITY_DAYS}
result["rank_rule"] = "质地带(好3中2无评析1差0)降序 → 带内被指向优先 → 组内分 → 原始分 → 代码"
if config.PLAN_RATING_PRIORITY_ENABLED:
result['rank_rule'] = result['rank_rule'].replace('带内被指向优先', '带内近30天评级上调优先、下调后置,再按被指向优先')
result["quality_band_counts"] = {"main": _band_counts(result["_full"]["main"]),
"observe": _band_counts(result["_full"]["observe"])}
return result
def _fmt_pct(v) -> str:
return "—" if v is None else f"{v:+.0%}"
def _fmt_num(v) -> str:
return "—" if v is None else f"{v:.2f}"
def _fmt_ev(e) -> str:
if not e:
return "—"
if e.get("moved_ratio") is None: # 已动成员视图补的证据行,没有已动比例
return f"{e['theme']}({e.get('n_sources') or '—'} 源,本票已启动)"
return f"{e['theme']}({e['n_sources']} 源,已动 {e['moved_ratio']:.0%})"
def _fmt_pct0(v) -> str:
return "—" if v is None else f"{v:+.1f}%"
def _fmt_accum(ac: dict) -> str:
if not ac or not ac.get("state"):
return "无评分"
st = str(ac["state"]).split("·")[0]
age = ac.get("age")
return f"{st}({age} 日前)" if isinstance(age, int) else st
def _fmt_logic(lines, width: int = 60) -> str:
"""候选单与关注单表格里的因果论断列:第一条截到 width 字,多于一条时带条数;表格里不能有竖线。"""
lines = [str(x) for x in (lines or []) if x]
if not lines:
return "—"
first = lines[0].replace("|", "/")
if len(first) > width:
first = first[:width] + "…"
return f"{first}(共 {len(lines)} 条)" if len(lines) > 1 else first
def _fmt_yi(v) -> str:
"""已经是"亿元"的数直接显示。两市成交额由取数层换算好(原表单位是千元),不在这里换算。"""
return "—" if v is None else f"{v:,.0f} 亿"
def _fmt_amount(v) -> str:
"""以元为单位的金额换算成亿显示。融资余额用它(那张表的单位是元)。"""
if v is None:
return "—"
return f"{v / 1e8:,.0f} 亿" if abs(v) >= 1e8 else f"{v:,.0f}"
def _fmt_market(m: dict) -> str:
"""环境段市场四项的一行文字;缺的项写"—",读数原因在 JSON 的 market.errors 里。"""
t, b, mg, fg = m.get("turnover") or {}, m.get("breadth") or {}, m.get("margin") or {}, m.get("fear_greed") or {}
parts = []
if t:
ratio = t.get("ratio_vs_prev5")
parts.append(f"两市成交额 {_fmt_yi(t.get('amount_yi'))}"
+ (f"(前五日均值的 {ratio:.2f} 倍)" if ratio else "")
+ (f",数据日 {t['data_date']}" if t.get("data_date") and t.get("data_date") != m.get("date") else ""))
else:
parts.append("两市成交额 —")
if b:
med = b.get("pct_median")
parts.append(f"广度 上涨 {b.get('up')} / 下跌 {b.get('down')} 家,涨停近似 {b.get('limit_up_approx')} 家,"
f"涨幅中位数 {med:+.2f}%" if med is not None else
f"广度 上涨 {b.get('up')} / 下跌 {b.get('down')} 家")
else:
parts.append("广度 —")
if mg:
bal, chg = mg.get("financing_balance"), mg.get("change_percent_5d")
parts.append(f"融资余额 {_fmt_amount(bal)}"
+ (f"(五日变化 {chg:+.2f}%)" if chg is not None else "")
+ (f",{mg['date']}" if mg.get("date") else ""))
else:
parts.append("融资余额 —")
if fg and fg.get("index_value") is not None:
parts.append(f"恐贪指数 {fg['index_value']:.0f}" + (f"({fg['date']})" if fg.get("date") else ""))
else:
parts.append("恐贪指数 —")
return "市场环境:" + ";".join(parts) + "(只展示与复盘分组,不作交易前置)。"
def render_md(d: dict) -> str:
L = [f"# 每日选股计划 · {d['date']}", ""]
c = d["counts"]
L.append(f"主榜 {c['main']} 只 / 观察档 {c['observe']} 只 / "
f"全池档位覆盖 {c['gate_covered']} 只。")
stale = [x for x in d["market_snapshot_days"] if x != d["date"]]
if stale:
L.append(f"注:本日传导用的行情快照 = {'、'.join(stale)}"
f"(与计划日不同——历史降级日口径)。")
L.append("")
# ---- 候选单与关注环节(2026-09-02):放在主榜之前,这是新的主产物 ----
cc = d.get("card_counts") or {}
cands = d.get("candidates") or []
L.append(f"## 候选单(环节被指向、当日已启动、券商覆盖且非 ST、明确吸筹、无硬风险;"
f"共 {cc.get('候选', len(cands))} 只,全量列出不受裁剪)")
L.append("")
if not cands:
L.append("(今日无候选——候选为空不是故障:环节没被指向、成员没启动或没有明确吸筹,都会为空。)")
else:
L.append("| # | 代码 | 名称 | 环节 | 源数 | 当日涨幅 | 吸筹 | 预期空间 | 安全边际(悲观下行/中性上行,赔率) "
"| 公司质地 | 催化事件 | 定价状态 | 理由 | 因果论断(出处) |")
L.append("|---|------|------|------|------|----------|------|----------|----------|----------|----------|----------|------|------------------|")
for r in cands:
c = r.get("card") or {}
ac = c.get("accum") or {}
ev_ = r.get("evidence") or {}
L.append(f"| {r['rank']} | {r['code']} | {r['name'] or '—'} | {ev_.get('theme') or '—'} "
f"| {ev_.get('n_sources') or '—'} | {_fmt_pct0(c.get('pct0'))} "
f"| {_fmt_accum(ac)} | {_fmt_pct(r.get('upside'))} | {card.valuation_short(r.get('valuation'))} "
f"| {card.company_review_short(r.get('company_review'))} "
f"| {card.events_short(r.get('events'))} | {card.pricing_short(r.get('pricing_state'))} "
f"| {';'.join(r.get('reasons') or [])} | {_fmt_logic(r.get('logic'))} |")
L.append("")
L.append("安全边际按同一预测期的每股收益与市盈率预测算:悲观是最低每股收益乘最低市盈率,中性是两项中位数,"
"乐观是两项最高;赔率是中性上行对悲观下行,不到一比一就是这个位置的赔率不吸引人。"
"它只展示、不进判决,与上面用目标价平均算的预期空间是两个口径。")
L.append("催化事件是近 60 天券商的正向事件(深度覆盖、上调盈利预测、业绩超预期),从研报明细表算,最新一条列在表里。"
"定价状态按最近一次事件日的事件前涨幅、事件日跳空、收盘位置与量比归成四情形:"
"价格发现(事件前没涨、事件日放量收高)、趋势延续(事件前已涨、事件日仍放量收高)、"
"高位兑现(事件前大涨、事件日放量冲高回落)、震荡消化(其余)。两者都只展示、不进判决。")
L.append("公司质地是数据基座个股深度评析按代码合成的档(回报与护城河、盈余质量与财务安全、成长与含金量三类),"
"后面是估值标签(贵中便宜,只展示)与十个大师视角的好中差计数。质地进逻辑状态第五路;质地差的候选降为关注交人;"
"评议文字见候选卡整句与报告链接。")
L.append("")
segs = d.get("segments_pointed") or []
L.append(f"## 关注环节(今日被传导指向的 {len(segs)} 个环节:定位对不对看这里,挑票看候选单)")
L.append("")
if segs:
L.append("| 环节 | 源数 | 链符 | 成员 | 已启动 | 领涨 | 候选 |")
L.append("|------|------|------|------|--------|------|------|")
for s in segs:
ld = s.get("leader") or {}
L.append(f"| {s['segment']} | {s.get('n_sources') or '—'} | {_fmt_num(s.get('chain_fit'))} "
f"| {s.get('members_total') if s.get('members_total') is not None else '—'} "
f"| {s.get('started_count', 0)} "
f"| {(ld.get('code') or '—') + (' ' + _fmt_pct0(ld.get('pct0')) if ld.get('code') else '')} "
f"| {s.get('candidates', 0)} |")
L.append("")
watch = d.get("watch") or []
L.append(f"## 关注单(三门槛全过、无硬风险,但吸筹确认线缺失或陈旧——系统无法判断,交人裁决;"
f"共 {cc.get('关注', len(watch))} 只,列前 20)")
L.append("")
if watch:
L.append("| # | 代码 | 名称 | 环节 | 当日涨幅 | 吸筹 | 缺什么 | 因果论断(出处) |")
L.append("|---|------|------|------|----------|------|--------|------------------|")
for r in watch[:20]:
c = r.get("card") or {}
ev_ = r.get("evidence") or {}
L.append(f"| {r['rank']} | {r['code']} | {r['name'] or '—'} | {ev_.get('theme') or '—'} "
f"| {_fmt_pct0(c.get('pct0'))} | {_fmt_accum(c.get('accum') or {})} "
f"| {';'.join(r.get('missing') or [])} | {_fmt_logic(r.get('logic'))} |")
L.append("")
reg = d.get("regime")
if reg:
L.append(_fmt_regime(reg))
L.append("")
mk = d.get("market")
if mk:
L.append(_fmt_market(mk))
L.append("")
cap_txt = f",每主题限额 {d['theme_cap']}" if d["theme_cap"] else ""
gate_txt = "、在十五五赛道内" if d.get("gate_on") else ""
L.append(f"## 主榜 Top {len(d['main'])}"
f"(有券商预期、目标价不低于现价{gate_txt}{cap_txt})")
L.append("")
L.append("| # | 代码 | 名称 | 总分 | 档位 | 传导证据 | 热度 | 预期空间 |")
L.append("|---|------|------|------|------|----------|------|----------|")
for r in d["main"]:
L.append(f"| {r['rank']} | {r['code']} | {r['name'] or '—'} | {_fmt_num(r['score'])} "
f"| {r.get('tier') or '—'} | {_fmt_ev(r['evidence'])} "
f"| {_fmt_num(r['heat'])} | {_fmt_pct(r['upside'])} |")
L.append("")
L.append(f"## 观察档 Top {len(d['observe'])}"
f"(无券商预期、但{'在赛道或传导链上' if d.get('gate_on') else '在传导链上'}"
f"——没有估值锚,置信度低{cap_txt})")
L.append("")
L.append("| # | 代码 | 名称 | 分 | 传导证据 | 热度 |")
L.append("|---|------|------|----|----------|------|")
for r in d["observe"]:
L.append(f"| {r['rank']} | {r['code']} | {r['name'] or '—'} | {_fmt_num(r['score'])} "
f"| {_fmt_ev(r['evidence'])} | {_fmt_num(r['heat'])} |")
L.append("")
L.append("## 今日升降档")
L.append("")
ch = d["changes"]
if not ch:
L.append("(没有更早的档位表可比,升降档从下一个交易日开始。)")
else:
L.append(f"对比 {ch['base_date']}:升档 {ch['upgrades_total']} 只,"
f"降档 {ch['downgrades_total']} 只。"
f"升档=拿到新锚(首次覆盖 / 新进传导链),本身就是值得看的信号。")
if ch["upgrades"]:
L.append("")
L.append("**升档**:")
L += [f"- {m['code']} {m['name'] or ''}:{m['from']} → {m['to']}"
f"({m.get('reason', '—')})"
for m in ch["upgrades"]]
if ch["upgrades_total"] > len(ch["upgrades"]):
L.append(f"- ……共 {ch['upgrades_total']} 只,其余见档位表")
if ch["downgrades"]:
L.append("")
L.append("**降档**:")
L += [f"- {m['code']} {m['name'] or ''}:{m['from']} → {m['to']}"
f"({m.get('reason', '—')})"
for m in ch["downgrades"]]
if ch["downgrades_total"] > len(ch["downgrades"]):
L.append(f"- ……共 {ch['downgrades_total']} 只,其余见档位表")
L.append("")
L.append("---")
L.append(f"口径:{d['encoding']}。")
return "\n".join(L)
class StaleSnapshot(RuntimeError):
"""旧快照无法证明在有效期内;查询明确失败,不回落实时装配。"""
def snapshot_fresh_enough(snap: dict) -> tuple:
"""旧格式快照的时间守卫,返回 (是否可用, 原因)。
2026-10-15,台账 064:已发布内容与代码部署相互独立。新代码仍可读有效期内
的旧计划,保留原 plan_version 并注明追溯不完整,不能因代码版本不同而失效,
也不能查询时用当前证据重装配。新完整版本不使用旧格式的这道兼容守卫。
沿用 PLAN_SNAPSHOT_MAX_AGE_HOURS(默认十六小时)及未来时刻检查。
有时区的生成时刻按自身时区算经过时间;旧无时区值保持原运行时解释,不能
为旧档补造时区或新的决策版本。显式历史查询不受当前时间限制。
"""
max_age_h = float(os.environ.get("PLAN_SNAPSHOT_MAX_AGE_HOURS", "16"))
gen = str(snap.get("generated_at") or "")
if not gen:
return False, "快照没有生成时刻,判不了新旧"
try:
g = dt.datetime.fromisoformat(gen)
except ValueError:
return False, f"快照的生成时刻认不出: {gen}"
age_h = (dt.datetime.now(g.tzinfo) - g).total_seconds() / 3600.0
if age_h > max_age_h:
return False, (f"快照出于 {gen},距今 {age_h:.1f} 小时,超过 {max_age_h:g} 小时的界;"
f"请检查已发布计划,查询不会实时重装配")
if age_h < -1: # 生成时刻在未来:多半是两边时区不一致,别当新鲜的用
return False, f"快照的生成时刻 {gen} 在未来 {-age_h:.1f} 小时,判不了新旧"
return True, ""
def pick_rows(rows, n: int, theme_cap: int, uncapped_no_theme=None) -> list:
"""从**已按分数排好序**的行里取 n 条,每个传导主题最多 theme_cap 条(0=不设限)。
与 collect 里那个同名的内部函数是同一套规则,差别只在取主题的来源:那边回查证据映射,
这边直接读行里的 evidence.theme —— 装配时就把主题写进每一行了,快照里也带着。
两处规则必须一致,test_plan_snapshot.py 拿真实快照逐行比对钉住这件事。
uncapped_no_theme(2026-09-17):质地轴下没有传导主题的行免限额、不计数(与 _pick 同口径)。
缺省 None 时从行的 rank_axis 推断(质地轴即为真),周报重建旧序时显式传 False。
必改一:与 collect 里的 _pick 调同一个模块级 take_by_theme,主题取行上的 evidence.theme(含已动
成员视图补的),已启动成员两条路都算进所在主题,同一天 md 与接口给出同一份前二十。
"""
if uncapped_no_theme is None:
uncapped_no_theme = bool(rows) and (rows[0].get("rank_axis") == "quality")
return take_by_theme(rows, n, theme_cap,
lambda r: ((r.get("evidence") or {}).get("theme")) or None, uncapped_no_theme)
def from_snapshot(date: str | None = None, top: int = 20, obs_top: int = 10,
theme_cap: int = 5, decision_id=None, include_user_candidates=False) -> dict:
"""从当日 JSON 快照读计划,按请求参数截取。**不做任何装配、不查任何库。**
为什么要这条路(2026-09-10,台账 057): collect 每次请求都现场装配整池,实测三十三秒,
而选股计划是日频的、用的全是昨收与昨夜数据 —— 一天算一次就够,不该放在请求里现算。
出计划时本来就落了一份全量快照(不裁剪、不设主题限额),注释里写明它是"复盘与对账的
唯一底本",只是接口一直没读它。这条路就是把接口接到那份底本上。
与 collect 的输出逐字一致,只差三处、都是设计使然:
· main / observe 按本次请求的参数从全量截取,名次重编成连续的
· theme_cap 按本次请求写,不用落盘时那个
· 多两个键 plan_source 与 snapshot_generated_at,让人一眼看出这份是哪来的、多新
快照不存在、读不动、或数据日对不上,一律抛异常;查询不得回落当前研究。
"""
ds = date or (decision_id[:10] if decision_id else plan_versions.latest_date(config.PLAN_SNAPSHOT_DIR))
path = os.path.join(config.PLAN_SNAPSHOT_DIR, f"plan_{ds}.json")
snap = plan_versions.load(config.PLAN_SNAPSHOT_DIR, ds, decision_id)
import user_candidates as uc
snap = uc.consumer_view(snap, include_user_candidates)
if str(snap.get("date") or "") != str(ds):
raise RuntimeError(f"快照里的数据日 {snap.get('date')} 与请求的 {ds} 对不上: {path}")
full_main, full_obs = snap.get("main"), snap.get("observe")
if not isinstance(full_main, list) or not isinstance(full_obs, list):
raise RuntimeError(f"快照缺全量主榜或观察档: {path}")
if not date and not decision_id and not snap.get('decision'):
ok, why = snapshot_fresh_enough(snap)
if not ok:
raise StaleSnapshot(why)
data = {k: v for k, v in snap.items()
# 落盘那次的裁剪参数与本次请求无关,研究及环境仍来自同一版本。
if k not in ("main_shown", "observe_shown", "shown_params")}
def picked(rows, count):
chosen = {r['code'] for r in pick_rows(rows, count, theme_cap)}
if include_user_candidates:
chosen.update(r['code'] for r in rows if (r.get('user_candidate') or {}).get('id'))
# 仍按同一份冻结榜单排序,人工来源只免于返回数量截断,不另排一份优先榜。
return [{**r, 'rank': i} for i, r in enumerate((r for r in rows if r['code'] in chosen), 1)]
data["main"] = picked(full_main, top)
data["observe"] = picked(full_obs, obs_top)
data["theme_cap"] = theme_cap
data["plan_source"] = "snapshot"
data["snapshot_generated_at"] = snap.get("generated_at")
data['traceability'] = snap.get('traceability') or 'legacy_unverified'
data['refresh_status'] = (plan_versions.health(config.PLAN_SNAPSHOT_DIR, ds)
if not decision_id else {})
return data
def generate(date: str | None = None, top: int = 20, obs_top: int = 10,
theme_cap: int = 5) -> str:
with plan_versions.writer(config.PLAN_SNAPSHOT_DIR):
return _generate(date, top, obs_top, theme_cap)
def _generate(date, top, obs_top, theme_cap, *, before_publish=None):
ds = date or _latest_date('t_factor_akg_score')
# 既有夜间流水线也会触发全量构建。已发布日只能由独立 refresh 修订,
# 不能重新取研究覆盖晨版或把旧格式快照升级成事后生成的真实历史。
try:
published = plan_versions.load(config.PLAN_SNAPSHOT_DIR, ds)
except FileNotFoundError:
pass
else:
write_published_md(published)
print(f"复用已发布计划 {ds},未重新采集输入")
return os.path.join(config.PLAN_SNAPSHOT_DIR, f"plan_{ds}.md")
import user_candidates as uc
selected = uc.active(config.PLAN_SNAPSHOT_DIR)
bundle = plan_inputs.Bundle(params=plan_inputs.effective_config(config.module))
try:
with bundle.use():
data = collect(ds, top, obs_top, theme_cap, **({"user_candidates": selected} if selected else {}))
data['market'] = sources.market_context(data['date'])
except RuntimeError as e:
raise SystemExit(str(e))
# 环境段的市场四项(2026-09-03):出计划时读一次落进快照,接口 /plan 只从快照读,盘中不再取数;
# 每项读失败为空并把原因记在 market.errors,不阻断。区制段仍由 08:45 的追加步骤写入。
out = os.path.join(config.PLAN_SNAPSHOT_DIR, f"plan_{data['date']}.md")
# ---- 当日 JSON 快照(2026-09-02 方案第 2.2 节第一项):主榜与观察档全部行、全部证据线,
# 不裁剪、不设主题限额;带生成时刻与代码版本。它是复盘与对账的唯一底本;
# 08:45 的 regime-append 步骤会往里追加 regime 段,/plan 的 regime 段只读这份。----
full = data.pop("_full", None) or {}
snap = {**data, "main_shown": data["main"], "observe_shown": data["observe"],
"main": full.get("main", []), "observe": full.get("observe", []),
"shown_params": {"top": top, "obs_top": obs_top, "theme_cap": theme_cap}}
jpath = os.path.join(config.PLAN_SNAPSHOT_DIR, f"plan_{data['date']}.json")
if before_publish is not None:
before_publish(data['date'])
snap = plan_versions.publish(config.PLAN_SNAPSHOT_DIR, snap,
{'records': bundle.records, 'market': data['market'], 'regime': data.get('regime'), 'user_candidates': selected},
bundle.params, cutoff_at=bundle.cutoff_at, reason='晨版生成')
text = write_published_md(snap)
# ---- 逐票日频逻辑状态表(2026-09-07 第三件桥侧前置):只在这一次生成里写,/plan 的实时重算
# 只读不写。写在快照落盘之后:表写失败只打印原因,计划文件与快照照出,不断产。----
try:
logic_state_daily.persist(data["date"], snap["main"] + snap["observe"],
data.get("plan_version"))
except Exception as e: # noqa: BLE001 —— 表写失败不能拖垮出计划
print(f" (逐票逻辑状态表写入失败,计划照出,抗抖动明天少一天历史: {e!r})")
# ---- 个股深度评析的目标名单(2026-09-09 方案):主榜与观察档写进 153 库小表,数据基座 00:45 读它。
# 写失败只打印,不断产。----
try:
import review_targets
review_targets.persist(data["date"], snap)
except Exception as e: # noqa: BLE001
print(f" (评析目标名单写入失败,计划照出: {e!r})")
print(text)
print(f"\n已写入 {out} 与快照 {jpath}"
f"(主榜 {len(snap['main'])} 行、观察档 {len(snap['observe'])} 行、"
f"候选 {len(data.get('candidates') or [])} 只,版本 {data.get('plan_version')})")
return out
def write_published_md(snap):
"""兼容 Markdown 是已发布 JSON 的派生物,带版本号;失败不回滚完整版本。"""
shown = dict(snap, main=snap.get('main_shown', snap['main']),
observe=snap.get('observe_shown', snap['observe']))
text = '决策版本:' + snap['decision']['id'] + '\n\n' + render_md(shown) + '\n'
try:
plan_versions.atomic(os.path.join(config.PLAN_SNAPSHOT_DIR, f"plan_{snap['date']}.md"), text, text=True)
except OSError as e:
print(f'兼容 Markdown 更新失败,已发布 JSON 仍有效:{type(e).__name__}')
return text