补齐人工关注评析并将吸筹改为参考

This commit is contained in:
zlt 2026-11-04 10:51:53 +08:00
parent c11ae6591e
commit 4ed46da7cc
16 changed files with 738 additions and 27 deletions

View File

@ -183,7 +183,7 @@ docker compose exec akg-factor-bridge python run.py freeze --date 2026-07-24
`source_type` 不是这个字符串,事件因子会被过滤成空(会显式告警),按实际值改
`EVENT_SOURCE_TYPES`。
## HTTP 接口(桥常驻 API,端口 8300,全部只读除 refresh)
## HTTP 接口(桥常驻 API,端口 8300)
| 端点 | 作用 |
|---|---|
@ -191,6 +191,10 @@ docker compose exec akg-factor-bridge python run.py freeze --date 2026-07-24
| `GET /plan/dates?limit=30` | 有计划文件的日期清单 |
| `GET /plan?date=&format=json\|md&top=&obs_top=` | 当日选股计划(基座今日页 `/plan/today` 与 PMS 下单候选都读它)。顶层 `regime`(区制)与 `market`(两市成交额、广度、融资、恐贪四项)都只从当日快照读,快照缺失为空;每行的判决类字段 2026-09-03 起多 `basis`(判决依据)与 `logic`(因果论断带出处);2026-09-17 起名次改按质地带优先,每行多 `quality_band`(质地带:好 3 中 2 无评析 1 差 0)、`rank_axis`(quality/transmission)、`pointed`(是否被传导指向)、`rank_old`(旧序名次,供周报四周对照),开关 `PLAN_RANK_AXIS` 设 transmission 即逐字回旧 |
| `POST /plan/refresh?date=&key=` | 使用既有 XXL key 排入完整修订;晨版缺失不代造 |
| `GET /plan/user-candidates/search?q=` | 按名称或代码查找沪深 A 股 |
| `GET /plan/user-candidates` | 人工关注登记与实时评析状态;只读,不提交评析任务 |
| `POST /plan/user-candidates` | 经既有 `X-Job-Key` 鉴权登记人工关注;保存后由后台补齐评析并尝试计划修订 |
| `POST /plan/user-candidates/{id}/remove` | 经既有 `X-Job-Key` 鉴权移除关注,保留原登记记录 |
| `GET /plan/verdict?codes=300750,SH600438&date=` | 逐票『计划判决』(2026-08-18 PMS 对接加):decision(main/observe/reject/absent)+ 与命令行 `plan_reconcile` 逐字同口径的 verdict_text + score/rank/tier/赛道/图谱证据。单票数据异常或代码形态认不出只报该票 error,不崩整批 |
| `GET\|POST /api/v1/xxl/daily-build?key=&steps=&date=` | XXL-JOB 平台触发盘前链(build→plan→push-pool,白名单步骤、单实例互斥、回调结案);`.env` 不配 `XXL_TRIGGER_KEY` 则整组禁用 |
| `GET /review/latest` | 最新一份复盘周报的只读读数(2026-09-16 加,配合数据基座判收读数包):文件名、日期、大小、前二十行、三个标记行计数(`公司质地=`、`五日头`、`二十日头`)。没有周报回 404。纯文件读取,不连库 |
@ -198,6 +202,24 @@ docker compose exec akg-factor-bridge python run.py freeze --date 2026-07-24
逐票对账的命令行形态(同一段判决代码):
`docker compose exec -T akg-factor-bridge python plan_reconcile.py 300750 [--date 2026-08-04]`
## 人工关注评析与吸筹参考规则(2026-11-04)
用户已明确选择沿用公司质地排序,吸筹作为参考,建仓由 PMS 的基本面、技术面、择时三源合议及后续规则判断。本次仅授权在 **155 模拟链路**配置 `CARD_ACCUM_CONFIRM_REQUIRED=0`。代码默认仍为 `1`,保留旧确认规则的回退能力;188 真实 PMS 不在本次切换范围。实际部署、参数生效与自然回执另记发布判收,不能用本地测试代替上线结论。
关闭确认要求后,潜在吸筹、其他非明确状态、缺评分或评分陈旧不再单独把股票降为“仅展示”或“关注”;原评分、状态与新鲜度仍保留为研究证据。不新增吸筹权重或综合分,质地排序与原始分数编码保持。券商覆盖、预期空间、证券资格、既有真实风险否决、高位派发和快照时点校验继续生效;人工来源只替代原发现入口。PMS 的三源合议、规则闸、研判、资金、组合及执行约束仍决定后续动作,研究完成或进入候选均不等于下单授权。
`plan-refresh` 只将本次获准的吸筹确认参数同步到新修订,其他冻结参数继续沿用原版本。即使研究输入未变,规则变化也必须追加带真实截止时刻、新参数指纹及明确原因的完整版本。`card_params.admission_rule` 区分确认规则与参考规则,`card_params.accum_confirm_required` 表明当前要求。旧日期、固定决策版本与晨版文件保持原样,不重写历史判决,也不倒填晨版。
人工关注走独立的真实买方评析链。登记后的后台任务与自然 `run.py plan-refresh` 周期先同步评析状态;GET 查询只批量读取真实报告。全部有效沪深人工关注加入原 `t_akg_review_targets` 目标名单,不受主榜前列、原分数或交易判决限制。缺少完整报告时,后台仅向配置的 `AKG_API_BASE` 提交原个股评析入口,要求买方评议和定性材料,使用 `force=false`,复用基座既有评析逻辑。
请求前先原子保存独立受理凭据,实际返回入队回执后才标记 `queued`。网络超时或受理结果不明时保持 `pending`,不立即重复提交;后续根据真实报告核验,并由原目标名单的自然批任务补齐。状态存于 `user_research.json`,不修改交易账本或历史计划。每轮默认最多提交 3 只、单次请求超时 3 秒;超过本轮额度的对象留待后续自然周期。移除或到期后停止新增提交与下游关注覆盖。
`GET /plan/user-candidates` 中,原 `status` 的 `pending/evaluated` 仅表示计划是否收录。独立的 `review_status` 为 `missing/pending/queued/completed/failed`,并附 `review_updated_at`、`review_error`、`review_data_date`、`company_review`、`company_review_text` 与 `review_ref`。任务标识不作为产品状态展示。
评析完成必须有真实固定版本引用、完整成功的买方评议、买方论点及不晚于当前时刻的报告生成时间。新鲜度按基座真实 `ran_at` 与 `checked_at` 中较新者检查,默认 7 天;轻量复核命中原指纹时可以更新核对时间,不能把它改写为新报告。`review_data_date` 始终取 `company_review.report_ran_at` 的北京时间日期。财报期是否落后仍由基座原有批任务判断;旧报告缺固定引用或评议未完成时明确等待补齐,不能伪造完成状态。
开发机验证:新增评析专项 19 项通过,包含吸筹参考规则的 35 个测试文件均经配置隔离、禁网护栏通过。候选镜像断网回归、真实评析受理与完成、自然日研究及盘中观察回执仍须在发布阶段分别核验。规则决定见[复盘决定台账 084](docs/复盘决定台账.md)。
## 里程碑状态(设计 §8)
- **G2 赛道门槛 ✅**:`config/frontier_tracks.yml` + `tracks.py`,三路映射

24
card.py
View File

@ -1,5 +1,9 @@
"""候选卡:把一只票的各条证据线装配成判决与理由(纯函数,零 IO)。
2026-11-04新增参考模式:require_accum_confirm=False时,非明确、缺失和陈旧
吸筹不再单独否决候选。资格、真实风险和公司质地分流保留,建仓交PMS三源合议。
以下确认线描述为兼容旧模式,历史快照保持原判决。
## 为什么要有它
桥原来的产物是一个分数:主榜分 = 200 + 传导档位×20 + 组内分。分数排在最前的
@ -95,7 +99,7 @@ def judge(ev: dict[str, Any], *, start_pct: float = 3.0,
accum_max_age: int = 30, neg_tol: float = 0.0,
logic_stale_days: int = 90, require_started: bool = True,
company_review: dict | None = None, quality_gate: bool = True,
stale_days: int = 120) -> dict[str, Any]:
stale_days: int = 120, require_accum_confirm: bool = True) -> dict[str, Any]:
"""一只票的证据字典 -> 判决字典。
ev 里认的键(缺键按缺失处理,不报错):
@ -163,7 +167,7 @@ def judge(ev: dict[str, Any], *, start_pct: float = 3.0,
elif confirm_stale:
missing.append(f"吸筹评分是 {accum_age} 个交易日前的,太旧了"
if isinstance(accum_age, int) else "吸筹评分有多旧算不出来")
elif confirm_negative and "派发" not in accum_state:
elif require_accum_confirm and confirm_negative and "派发" not in accum_state:
state_short = accum_state.split("·")[0].strip()
missing.append(f"吸筹只到「{state_short}」,没到明确吸筹这条线")
if not gates["pointed"]:
@ -188,6 +192,13 @@ def judge(ev: dict[str, Any], *, start_pct: float = 3.0,
if confirm:
reasons.append(f"明确吸筹(评分 {accum_score:.0f},{accum_age} 日前)"
if accum_score is not None else f"明确吸筹({accum_age} 日前)")
elif not require_accum_confirm and accum_state:
detail = []
if accum_score is not None:
detail.append(f"评分 {accum_score:.0f}")
if isinstance(accum_age, int):
detail.append(f"{accum_age} 个交易日前")
reasons.append("吸筹状态:" + accum_state + ("(" + ",".join(detail) + ")" if detail else ""))
if gates["covered"]:
reasons.append(f"券商覆盖,预期空间 {upside:+.0%}")
@ -205,6 +216,9 @@ def judge(ev: dict[str, Any], *, start_pct: float = 3.0,
if risk:
verdict = VERDICT_SHOW
basis = ";".join(risk)
elif all_gates and not require_accum_confirm:
verdict = VERDICT_CANDIDATE
basis = "选股资格通过,进入基本面、技术面和择时合议"
elif all_gates and confirm:
verdict = VERDICT_CANDIDATE
basis = (f"三条门槛都过了,没有风险,且明确吸筹({accum_age} 个交易日前评的)"
@ -236,11 +250,13 @@ def judge(ev: dict[str, Any], *, start_pct: float = 3.0,
if quality_gate and cr and qband == 0 and verdict == VERDICT_CANDIDATE:
verdict = VERDICT_WATCH
why_q = ";".join((cr.get("quality_reasons") or [])[:2]) or "基座代码合成的质地档为差"
company_gate = f"公司质地评为差({why_q}),候选降为关注交人裁决"
company_gate = (f"公司质地评为差({why_q}),候选降为关注交人裁决" if require_accum_confirm else
f"公司质地评为差({why_q}),按PMS现行合议和自决档处理关注候选")
basis = f"{basis};{company_gate}"
return {"verdict": verdict, "reasons": reasons, "missing": missing, "risk": risk,
"gates": gates, "confirm": confirm, "failed_gates": failed, "basis": basis,
"gates": gates, "confirm": confirm, "confirm_required": bool(require_accum_confirm),
"failed_gates": failed, "basis": basis,
"company_gate": company_gate, "quality_band": qband,
"logic": logic_lines(ev.get("logic")),
"logic_quality": logic_quality(ev.get("logic"))}

View File

@ -224,6 +224,9 @@ CARD_START_PCT = float(os.environ.get("CARD_START_PCT", "3")) # 门槛二
# 想开回去就把这个值设回 1 并重建容器,判决当天即恢复原样。
CARD_REQUIRE_STARTED = os.environ.get("CARD_REQUIRE_STARTED", "1") == "1"
CARD_ACCUM_MAX_AGE = int(os.environ.get("CARD_ACCUM_MAX_AGE", "30")) # 确认线:吸筹评分日龄上限(交易日)
# 2026-11-04:155显式关闭旧吸筹准入确认,吸筹转为三源合议的参考。
# 默认保留旧模式以兼容其他调用方;切换必须发布新计划版本,不能改历史快照。
CARD_ACCUM_CONFIRM_REQUIRED = os.environ.get("CARD_ACCUM_CONFIRM_REQUIRED", "1").lower() not in ("0", "false", "no")
# 计划快照落点(容器内路径;仓库根挂在 /app,故默认落在仓库 data/plan/)。
# 每日 JSON 含主榜与观察档全部行与全部证据线,是复盘与对账的唯一底本。
PLAN_SNAPSHOT_DIR = os.environ.get("PLAN_SNAPSHOT_DIR", "data/plan")
@ -318,6 +321,9 @@ LOGIC_PATH_COMPANY = os.environ.get("LOGIC_PATH_COMPANY", "1") == "1"
CARD_COMPANY_QUALITY_GATE = os.environ.get("CARD_COMPANY_QUALITY_GATE", "1") == "1" # 候选卡"质地差降一档"
COMPANY_REVIEW_STALE_DAYS = int(os.environ.get("COMPANY_REVIEW_STALE_DAYS", "120")) # 报告运行日超过它算陈旧
AKG_API_BASE = os.environ.get("AKG_API_BASE", "http://192.168.16.178:8000") # 报告链接前缀
USER_RESEARCH_FRESH_DAYS = int(os.environ.get("USER_RESEARCH_FRESH_DAYS", "7")) # 基座核对时刻口径,不把复核当新报告
USER_RESEARCH_REQUEST_TIMEOUT = float(os.environ.get("USER_RESEARCH_REQUEST_TIMEOUT", "3"))
USER_RESEARCH_SUBMIT_LIMIT = int(os.environ.get("USER_RESEARCH_SUBMIT_LIMIT", "3")) # 每轮有界受理,后续自然调度继续
LOGIC_SETTLE_CONFIRM_DAYS = int(os.environ.get("LOGIC_SETTLE_CONFIRM_DAYS", "2"))
LOGIC_SETTLE_EXIT_DAYS = int(os.environ.get("LOGIC_SETTLE_EXIT_DAYS", "3"))
# 读上一次落定态与近几日原始态时往前看几个自然日。要盖住国庆这种连休八天再加两个周末的空档;

View File

@ -882,3 +882,13 @@
研究池从该已发布版本取 rank 前 50 个被指向对象,保留实际 3 只持仓,上限仍为 100。补入 12 只,按原规则回收 1 只及池满移出 11 只。全部 16 只 PMS 候选与持仓在池内,候选关联决策版本和研究名次一致。增量补扫任务 5ce6930c-dd01-45ef-a68b-f830419d4858 已受理,未把受理写成研究完成。POOL_TIERS 的旧配置在 rank 来源不参与过滤,日志打印它不代表生效。
PMS 155 镜像 50 批、1165 例通过;桥 54 组契约及池、构建就绪、XXL 触发三个脚本通过。页面、桥健康及 QMT 账实核对正常,部署判收为真机见过。切换窗口一次高股息读取超时于 15:01:39 复查恢复。私有备份和验收在 155 的 /home/factor/pms_logs/quality-switch-20261026;旧镜像与分支保留,回退须追加版本而非覆盖历史。详见 PMS docs/开发接续_2026-10-12.md 第十节。未制造交易,实际自然建仓及收益表现另行观察。
## 084 · 2026-11-04 · 人工关注补齐真实评析,吸筹改为参考
- **日期与授权。** 2026-11-04,北京时间。用户明确选择“沿用当前质地排序,吸筹作为参考,建仓看三源合议”。本次仅在 155 模拟链路切换 `CARD_ACCUM_CONFIRM_REQUIRED=0`,不扩展到 188 真实 PMS。代码默认保持旧确认规则,回退仍有明确开关。
- **改动。** 桥不再仅因吸筹未达到明确状态、缺评分或评分陈旧而阻断候选评估;原吸筹评分、状态及新鲜度继续作为证据。质地排序、原始分数编码和发现资格保持,不新造加权评分。证券范围、覆盖与估值条件、既有真实风险、高位派发及快照时点校验继续生效。PMS 的基本面、技术面、择时三源合议及后续规则、研判、资金、组合与执行约束继续决定建仓;本次不是关闭全部判决过滤。
- **依据。** 代码和历史记录核对表明,桥从 9 月起将明确吸筹作为候选确认线;10 月质地排序切换保留了该判决。PMS 三源合议在上游“仅展示”过滤之后运行,因此无法评估已被旧确认线排除的对象。此次依据用户的新明确决定改变吸筹角色,不将其写成已经发生过的部署回退或历史修复。
- **人工关注评析。** 登记后的后台任务与自然计划修订周期同步独立评析状态;查询入口不派模型任务。全部有效沪深人工关注进入原研究目标名单,不受原分数、名次和交易判决限制。后台复用基座真实评析入口,开启买方评议及定性材料,默认不强制重跑。提交前持久化受理凭据,收到真实入队回执才标记排队;超时或结果不明保持待核实,不立即重复投递。原登记的“已收录”与“评析完成”独立展示。
- **完成与时间口径。** 完成要求真实固定报告引用、成功的买方评议、论点及有效生成时间。七天复核窗口使用真实运行或核对时刻,避免指纹命中后只有核对时间更新而永远无法完成;报告日期仍取原生成时间的北京时间日期。缺引用、材料不全、评议失败或来源不可用均不伪造完成。财报期与原评析重试规则继续由基座负责。
- **版本与预期。** 规则切换即使输入不变也追加新的完整修订,记录真实截止时刻、参数指纹和变更原因。旧晨版、历史计划及固定版本查询不变。人工关注的研究覆盖与交易资格分开,移除或到期后停止新增关注研究;评析完成不等于可以自动建仓。预期自然回执能分别说明登记、受理、报告完成、日研究和盘中观察状态。
- **验证与未完成事项。** 开发机新增评析专项 19 项通过;包含本次规则切换的 35 个测试文件均完成配置隔离、禁网验证,其中高股息旧测试的两处相对路径已修复并定向复测。此条记录开发交付和授权边界,不代表运行参数已切换。候选镜像断网回归、155 部署、真实评析受理与完成、自然日研究及盘中观察仍须在发布阶段逐项判收,不注入交易制造结果。

View File

@ -446,6 +446,7 @@ def _assemble_cards(ds: str, codes: list, ev: dict, upside: pd.Series,
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,
neg_tol=config.UPSIDE_NEG_TOLERANCE,
logic_stale_days=config.LOGIC_STALE_DAYS,
require_started=config.CARD_REQUIRE_STARTED,
@ -775,6 +776,9 @@ def collect(date: str | None = None, top: int = 20, obs_top: int = 10,
"transmission 时按 09-14 的质地调整分序",
# ---- 候选卡(2026-09-02):分数与档位之外的另一份产物,不受 top / theme_cap 裁剪 ----
"card_params": {"start_pct": config.CARD_START_PCT,
"accum_confirm_required": config.CARD_ACCUM_CONFIRM_REQUIRED,
"admission_rule": ("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,

View File

@ -43,6 +43,15 @@ def refresh(day=None, *, now=None, regime_value=None):
pending = set(pv.health(root, day).get('pending_codes') or [])
try:
env = pv.envelope(root, old['decision']['id'])
params = copy.deepcopy(env['params'])
# 只允许本次明确批准的吸筹角色参数随真实修订改变。
# 其余冻结参数原样重放,不顺带采用当前环境的排序或资格变化。
previous_confirm = params.get('CARD_ACCUM_CONFIRM_REQUIRED', True)
desired_confirm = bool(config.CARD_ACCUM_CONFIRM_REQUIRED)
policy_changed = previous_confirm != desired_confirm
if policy_changed:
params['CARD_ACCUM_CONFIRM_REQUIRED'] = desired_confirm
pending.update(r['code'] for b in ('main', 'observe') for r in old.get(b, []))
inputs = copy.deepcopy(env['inputs'])
import user_candidates as uc
selected = uc.active(root, now)
@ -78,12 +87,14 @@ def refresh(day=None, *, now=None, regime_value=None):
return {k: v for k, v in (x or {}).items() if k != 'fetched_at'}
if meaningful(inputs.get('regime')) != meaningful(regime_value):
inputs['regime'] = regime_value
if policy_changed:
pending.update(r['code'] for b in ('main', 'observe') for r in old.get(b, []))
pv.health(root, day, pending_codes=sorted(pending), error=None)
if pv.digest(inputs) == old['decision']['input_hash']:
if pv.digest(inputs) == old['decision']['input_hash'] and not policy_changed:
pv.health(root, day, pending_codes=[], error=None, decision_id=old['decision']['id'])
return {'status': 'unchanged', 'decision': old['decision']}
bundle = pi.Bundle(records=None if candidates_changed else inputs['records'],
params=env['params'], cutoff_at=now.isoformat())
params=params, cutoff_at=now.isoformat())
if candidates_changed:
# 原有调用继续读冻结输入;新增股票带来的新取数在本次真实修订中录制。
bundle.records = copy.deepcopy(inputs['records'])
@ -95,8 +106,9 @@ def refresh(day=None, *, now=None, regime_value=None):
data.update(main_shown=data['main'], observe_shown=data['observe'], shown_params=shown,
main=full['main'], observe=full['observe'], market=inputs.get('market'),
regime=inputs.get('regime'))
published = pv.publish(root, data, inputs, env['params'], cutoff_at=now.isoformat(),
reason='用户候选更新' if candidates_changed else '评析更新' if pending else '市场区制更新')
reason = ('恢复吸筹确认规则' if desired_confirm else '吸筹改为三源合议参考') if policy_changed else (
'用户候选更新' if candidates_changed else '评析更新' if pending else '市场区制更新')
published = pv.publish(root, data, inputs, params, cutoff_at=now.isoformat(), reason=reason)
plan.write_published_md(published)
return {'status': 'published', 'decision': published['decision']}
except Exception as e:

View File

@ -1,7 +1,7 @@
"""个股深度评析的目标名单(2026-09-09 方案附录甲):每早出计划时把主榜与观察档写进 153 库一张小表,
数据基座的 00:45 任务读它选目标(178 的容器打不到 155 的接口,只能走库)。
表 t_akg_review_targets:plan_date、ts_code(点后缀式 600000.SH)、source(main / observe)、rank、name。
表 t_akg_review_targets:plan_date、ts_code(点后缀式 600000.SH)、source(main / observe / manual)、rank、name。
幂等:删该日行再整批插。写失败不拦计划(try 包住)。"""
from __future__ import annotations
@ -35,13 +35,17 @@ def to_dot(code: str) -> str:
return s
def build_rows(ds: str, main_rows: list, obs_rows: list) -> list[dict]:
def build_rows(ds: str, main_rows: list, obs_rows: list, user_rows=None) -> list[dict]:
from user_candidates import normalize
seen: set = set()
out: list[dict] = []
for src, rows in (("main", main_rows), ("observe", obs_rows)):
for src, rows in (("main", main_rows), ("observe", obs_rows), ("manual", user_rows)):
for i, r in enumerate(rows or [], 1):
code = to_dot(str(r.get("code") or ""))
if len(code) != 9 or code in seen:
try:
code = to_dot(normalize(r.get('code')))
except ValueError:
continue
if code in seen:
continue
seen.add(code)
out.append({"plan_date": ds, "ts_code": code, "source": src, "rank": i, "name": (r.get("name") or "")[:64]})
@ -89,15 +93,18 @@ def pick_main_targets(main_rows: list, axis: str, top_score: int, top_rank: int)
return union
def persist(ds: str, snap: dict, write=None) -> dict:
def persist(ds: str, snap: dict, write=None, user_rows=None) -> dict:
"""目标是主榜(按 REVIEW_TARGETS_AXIS 取,both 是原始分前 TOP_MAIN ∪ 新序前 TOP_MAIN_RANK)加观察档前
TOP_OBS 只(快照里的 main / observe 已是新序全部行,每行带 score 与 rank),约一百二十到一百五十家。"""
main_sel = pick_main_targets(snap.get("main") or [], config.REVIEW_TARGETS_AXIS, TOP_MAIN, TOP_MAIN_RANK)
rows = build_rows(ds, main_sel, (snap.get("observe") or [])[:TOP_OBS])
rows = build_rows(ds, main_sel, (snap.get("observe") or [])[:TOP_OBS],
snap.get('user_candidates', []) if user_rows is None else user_rows)
(write or save)(ds, rows)
n_main = sum(1 for r in rows if r["source"] == "main")
print(f" 评析目标名单 {ds}:主榜 {n_main},观察 {len(rows) - n_main},写入 {TABLE}")
return {"date": ds, "rows": len(rows), "main": n_main}
n_manual = sum(1 for r in rows if r['source'] == 'manual')
n_obs = len(rows) - n_main - n_manual
print(f" 评析目标名单 {ds}:主榜 {n_main},观察 {n_obs},人工关注 {n_manual},写入 {TABLE}")
return {"date": ds, "rows": len(rows), "main": n_main, 'observe': n_obs, 'manual': n_manual}
def from_plan_file(ds: str, plan_dir: str | None = None, write=None) -> dict:

6
run.py
View File

@ -238,6 +238,12 @@ def main():
regime.append_to_snapshot(day)
elif a.cmd == 'plan-refresh':
import plan_refresh
import user_research
try:
user_research.sync()
except Exception:
import logging
logging.getLogger(__name__).exception('人工关注评析同步失败,继续正常计划修订')
result = plan_refresh.refresh(a.date)
print(result)
if result['status'] in ('no_morning', 'no_morning_today'):

View File

@ -1174,7 +1174,7 @@ def catalysts_for_codes(seg_of: dict, cat_by_seg: dict, *, limit: int = 3) -> di
# 公司深度评析(2026-09-09 接入方案,台账 053):数据基座 company_review_runs 索引表最新一行的摘要。
# 质地由基座代码合成,这里只读不算;报告正文在对象存储,链接给人。表读不到整体缺席不断产。
# ---------------------------------------------------------------------------
def company_reviews(codes, ds: str, *, read_pg=None, cutoff_at=None, strict=False) -> dict:
def company_reviews(codes, ds: str, *, read_pg=None, cutoff_at=None, strict=False, include_check=False) -> dict:
"""{前缀码: {"period", "review_version", "overall", "groups", "valuation", "doubt_hard", "quality_reasons",
"grade_counts", "grade_line", "thesis", "confidence", "invalidation", "antithesis", "catalyst", "brain_status",
"ran_at", "age_days", "report_url"}};没报告的票不在字典里。"""
@ -1185,7 +1185,8 @@ def company_reviews(codes, ds: str, *, read_pg=None, cutoff_at=None, strict=Fals
dots = [_to_dot(c) for c in want]
try:
cutoff = cutoff_at or (str(ds) + 'T23:59:59.999999+08:00')
df = rp("SELECT DISTINCT ON (ts_code) ts_code, period, review_version, grades, summary, brain_used, brain_status, ran_at "
checked_column = ', checked_at' if include_check else ''
df = rp("SELECT DISTINCT ON (ts_code) ts_code, period, review_version, grades, summary, brain_used, brain_status, ran_at" + checked_column + " "
"FROM company_review_runs WHERE status = 'ok' AND ts_code = ANY(%s) AND ran_at <= %s "
"ORDER BY ts_code, ran_at DESC, period DESC, review_version DESC", (dots, cutoff))
except Exception as e: # noqa: BLE001
@ -1209,14 +1210,14 @@ def company_reviews(codes, ds: str, *, read_pg=None, cutoff_at=None, strict=Fals
except ValueError:
grades = {}
ran = r.get("ran_at")
edge = dt.datetime.fromisoformat(str(cutoff).replace('Z', '+00:00'))
if edge.tzinfo is None:
edge = edge.replace(tzinfo=dt.timezone.utc)
# 桩与某些代理不保证过滤;本地再守一遍时间边界,绝不把未来行归零当新鲜。
if ran is not None:
stamp = dt.datetime.fromisoformat(str(ran).replace('Z', '+00:00'))
if stamp.tzinfo is None:
stamp = stamp.replace(tzinfo=dt.timezone.utc)
edge = dt.datetime.fromisoformat(str(cutoff).replace('Z', '+00:00'))
if edge.tzinfo is None:
edge = edge.replace(tzinfo=dt.timezone.utc)
if stamp > edge:
continue
try:
@ -1243,6 +1244,15 @@ def company_reviews(codes, ds: str, *, read_pg=None, cutoff_at=None, strict=Fals
'unknown_n', 'numbers_unmatched', 'review_ref'):
out[k][field] = sm.get(field)
out[k]['report_ran_at'] = stamp.isoformat() if ran is not None else None
if include_check:
checked = r.get('checked_at')
try:
checked = dt.datetime.fromisoformat(str(checked).replace('Z', '+00:00'))
if checked.tzinfo is None:
checked = checked.replace(tzinfo=dt.timezone.utc)
out[k]['checked_at'] = checked.isoformat() if checked <= edge else None
except (TypeError, ValueError):
out[k]['checked_at'] = None
out[k]['report_version_url'] = (config.AKG_API_BASE + sm['report_version_path']
if sm.get('report_version_path') else None)
return out

89
test_accum_reference.py Normal file
View File

@ -0,0 +1,89 @@
"""离线:吸筹只作参考及同输入规则修订,全部来源使用内存替身。"""
import copy
import datetime as dt
import tempfile
import unittest
from unittest.mock import patch
import test_api_support
import card
import config
import plan
import plan_refresh
import plan_versions as pv
class ReferenceTests(unittest.TestCase):
def test_nonconfirmed_evidence_no_longer_blocks_qualified_stock(self):
for state, age in [('潜在吸筹·低位企稳', 0), ('无吸筹迹象', 0), ('量能温和、信号不明', 1),
('', None), ('明确吸筹', 45), ('明确吸筹', None)]:
ev = dict(pointed=True, covered=True, upside=.2, pct0=3,
accum_state=state, accum_age=age, accum_score=60)
old = card.judge(ev)
new = card.judge(ev, require_accum_confirm=False)
self.assertNotEqual(old['verdict'], card.VERDICT_CANDIDATE)
self.assertEqual(new['verdict'], card.VERDICT_CANDIDATE)
self.assertFalse(new['confirm_required'])
self.assertNotIn('confirm', new['failed_gates'])
self.assertNotIn('没到明确吸筹', str(new))
self.assertIn('基本面、技术面和择时', new['basis'])
def test_risks_and_qualification_remain_effective(self):
base = dict(pointed=True, covered=True, upside=.2, pct0=3, accum_state='潜在吸筹', accum_age=0)
for change in ({'pointed': False}, {'covered': False}, {'upside': -.2}, {'risk_name': True},
{'stale_snapshot': True}, {'y_signal': 'SELL'}, {'y_signal': 'AVOID'},
{'y_signal': 'DROPPED'}, {'accum_state': '高位派发'}):
self.assertEqual(card.judge(dict(base, **change), require_accum_confirm=False)['verdict'],
card.VERDICT_SHOW)
poor = card.judge(base, require_accum_confirm=False,
company_review={'overall': '差', 'age_days': 1})
self.assertEqual(poor['verdict'], card.VERDICT_WATCH)
def test_policy_change_publishes_new_version_without_changing_history(self):
with tempfile.TemporaryDirectory() as root:
now = dt.datetime.fromisoformat('2026-11-04T10:30:00+08:00')
old = {'date': '2026-11-03', 'plan_version': 'test',
'main': [{'code': 'SH600001', 'verdict': '仅展示'}], 'observe': [],
'shown_params': {'top': 20, 'obs_top': 10, 'theme_cap': 5}}
inputs = {'records': {}, 'user_candidates': [], 'market': {}, 'regime': None}
first = pv.publish(root, old, inputs, {}, cutoff_at='2026-11-04T07:10:00+08:00', reason='晨版')
original = copy.deepcopy(first)
def collect(*a, **kw):
self.assertFalse(plan.config.CARD_ACCUM_CONFIRM_REQUIRED)
data = copy.deepcopy(old)
data['_full'] = {'main': [dict(old['main'][0], verdict='候选')], 'observe': []}
return data
with patch.object(config, 'PLAN_SNAPSHOT_DIR', root), \
patch.object(config, 'CARD_ACCUM_CONFIRM_REQUIRED', False), \
patch.object(plan_refresh, 'in_window', return_value=True), \
patch.object(plan, 'collect', side_effect=collect), \
patch.object(plan, 'write_published_md'):
result = plan_refresh.refresh(now=now)
self.assertEqual(result['status'], 'published')
newest = pv.load(root)
self.assertEqual(newest['decision']['reason'], '吸筹改为三源合议参考')
self.assertEqual(newest['decision']['input_hash'], first['decision']['input_hash'])
self.assertNotEqual(newest['decision']['params_hash'], first['decision']['params_hash'])
self.assertEqual(newest['decision']['parent_id'], first['decision']['id'])
self.assertEqual(pv.load(root, decision_id=first['decision']['id']), original)
self.assertEqual(pv.load(root, morning=True), original)
self.assertEqual(plan_refresh.refresh(now=now)['status'], 'unchanged')
def test_rebuild_failure_keeps_old_plan_and_pending_codes(self):
with tempfile.TemporaryDirectory() as root:
old = {'date': '2026-11-03', 'plan_version': 'test',
'main': [{'code': 'SH600001', 'verdict': '仅展示'}], 'observe': []}
inputs = {'records': {}, 'user_candidates': [], 'market': {}, 'regime': None}
first = pv.publish(root, old, inputs, {}, cutoff_at='2026-11-04T07:10:00+08:00', reason='晨版')
with patch.object(config, 'PLAN_SNAPSHOT_DIR', root), \
patch.object(config, 'CARD_ACCUM_CONFIRM_REQUIRED', False), \
patch.object(plan_refresh, 'in_window', return_value=True), \
patch.object(plan, 'collect', side_effect=ValueError('材料损坏')):
with self.assertRaises(ValueError):
plan_refresh.refresh(now=dt.datetime.fromisoformat('2026-11-04T10:30:00+08:00'))
self.assertEqual(pv.load(root), first)
self.assertEqual(pv.health(root, old['date'])['pending_codes'], ['SH600001'])
if __name__ == '__main__':
unittest.main()

View File

@ -11,7 +11,7 @@ import test_api_support # noqa: F401
def main():
suite = unittest.TestSuite()
for name in ('test_plan_versions', 'test_plan_reviews_live', 'test_plan_review_source', 'test_plan_stock_check',
'test_plan_rank_switch', 'test_user_candidates'):
'test_plan_rank_switch', 'test_user_candidates', 'test_user_research'):
suite.addTests(unittest.defaultTestLoader.loadTestsFromModule(importlib.import_module(name)))
for name in ('test_plan_cache', 'test_plan_snapshot', 'test_plan_rank_axis',
'test_plan_quality_rank', 'test_plan_verdict', 'test_plan_logic_state',

View File

@ -188,7 +188,7 @@ class PublishTest(unittest.TestCase):
class IntegrationContractTest(unittest.TestCase):
def test_business_defaults_unchanged_and_explicit_entry(self):
import ast
tree = ast.parse(Path('xxl.py').read_text())
tree = ast.parse(Path(__file__).with_name('xxl.py').read_text())
values = {}
for node in tree.body:
if isinstance(node, ast.Assign):
@ -201,7 +201,7 @@ class IntegrationContractTest(unittest.TestCase):
def test_read_query_cannot_collect_or_publish(self):
import ast
tree = ast.parse(Path('api.py').read_text())
tree = ast.parse(Path(__file__).with_name('api.py').read_text())
fn = next(x for x in tree.body if isinstance(x, ast.FunctionDef) and x.name == 'dividend_research')
calls = [n.func.attr for n in ast.walk(fn) if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute)]
self.assertNotIn('collect', calls); self.assertNotIn('publish', calls)

View File

@ -14,6 +14,7 @@ import plan, config, card, sources, factors, judgement, logic_state_daily
import plan_inputs as pi
import plan_versions as pv
import plan_refresh
import user_research
NOW = dt.datetime.fromisoformat('2026-11-03T10:00:00+08:00')
DAY = '2026-11-02'
@ -27,6 +28,9 @@ class CandidateTests(unittest.TestCase):
self.temp = tempfile.TemporaryDirectory()
self.root = self.temp.name
self.addCleanup(self.temp.cleanup)
self.reports = patch.object(user_research, 'load_reports', return_value={})
self.reports.start()
self.addCleanup(self.reports.stop)
def test_exchange_validation_batch_atomic_and_dedup(self):
for code in ('830001.BJ', '920001', 'SH000001', 'SZ600001', '123', '510300.SH'):

244
test_user_research.py Normal file
View File

@ -0,0 +1,244 @@
"""人工关注评析:所有外部来源与投递均用桩,状态文件仅在临时目录。"""
import copy
import datetime as dt
import io
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import Mock, patch
import urllib.error
import urllib.parse
import test_plan_versions # 缺席数据库驱动用桩;统一由断网护栏启动。
import config
import sources
import user_candidates as uc
import user_research as ur
import plan_versions as pv
import review_targets as rt
NOW = dt.datetime.fromisoformat('2026-11-04T10:00:00+08:00')
CODE = 'SZ300133'
def report(**changes):
return dict({'review_ref': 'a' * 64, 'brain_used': True, 'brain_status': 'ok',
'thesis': '订单改善仍需后续验证', 'overall': '中',
'report_ran_at': '2026-11-03T18:00:00+00:00',
'checked_at': '2026-11-03T18:00:00+00:00'}, **changes)
class ResearchTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = self.temp.name
self.reader = Mock(return_value={})
self.submit = Mock(return_value={'status': 'queued', 'task_id': 'private-task'})
self.patches = [patch.object(config, 'PLAN_SNAPSHOT_DIR', self.root),
patch.object(config, 'USER_RESEARCH_FRESH_DAYS', 7),
patch.object(config, 'USER_RESEARCH_SUBMIT_LIMIT', 3)]
for p in self.patches:
p.start()
self.addCleanup(p.stop)
uc.save(self.root, {'codes': [CODE], 'reason': '自主关注', 'expires_on': '2026-11-10'}, 'test', NOW)
def sync(self, **kwargs):
return ur.sync(self.root, now=kwargs.pop('now', NOW), reader=self.reader,
submit=self.submit, target_write=lambda *a: None, **kwargs)
def test_complete_requires_real_reference_brain_thesis_and_time(self):
self.assertTrue(ur.report_state(report(), NOW)[0])
for change in ({'review_ref': None}, {'review_ref': 'old'}, {'brain_used': False},
{'brain_status': 'half'}, {'thesis': ''}, {'report_ran_at': None},
{'report_ran_at': '2026-11-05T10:00:00+08:00'}):
with self.subTest(change=change):
self.assertFalse(ur.report_state(report(**change), NOW)[0])
def test_recent_real_recheck_keeps_old_report_ready_without_redating(self):
old = report(report_ran_at='2026-09-29T00:00:00+00:00')
self.reader.return_value = {CODE: old}
self.sync()
self.submit.assert_not_called()
view = ur.views(self.root, [CODE], now=NOW, reader=self.reader)[CODE]
self.assertEqual(view['review_status'], 'completed')
self.assertEqual(view['review_data_date'], '2026-09-29')
self.assertNotIn('task_id', view)
def test_future_check_cannot_freshen_stale_report(self):
old = report(report_ran_at='2026-09-29T00:00:00+00:00', checked_at='2026-11-05T00:00:00+00:00')
self.assertFalse(ur.report_state(old, NOW)[0])
def test_claim_is_durable_before_submission_and_prevents_double_enqueue(self):
def submit(code):
self.assertEqual(ur.read(self.root)['rows'][code]['status'], 'pending')
self.sync() # 并发调用能看到已持久化的 claim,不能再次派单。
return {'status': 'queued', 'task_id': 'private-task'}
self.submit.side_effect = submit
self.sync()
self.sync()
self.assertEqual(self.submit.call_count, 1)
row = ur.read(self.root)['rows'][CODE]
self.assertEqual(row['status'], 'queued')
self.assertEqual(row['task_id'], 'private-task')
def test_timeout_is_uncertain_not_failure_or_automatic_retry(self):
self.submit.side_effect = TimeoutError('offline timeout')
self.sync()
self.sync(now=NOW + dt.timedelta(hours=2))
self.assertEqual(self.submit.call_count, 1)
row = ur.read(self.root)['rows'][CODE]
self.assertEqual(row['status'], 'pending')
self.assertIn('待核实', row['error'])
def test_completed_report_recovers_queued_or_uncertain_request(self):
self.sync()
self.reader.return_value = {CODE: report()}
self.sync(now=NOW + dt.timedelta(minutes=5))
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'completed')
self.assertEqual(self.submit.call_count, 1)
def test_submission_done_is_not_report_completion(self):
self.submit.return_value = {'status': 'done', 'result': {'status': 'ok'}}
self.sync()
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'pending')
self.reader.return_value = {CODE: report()}
self.sync(now=NOW + dt.timedelta(minutes=5))
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'completed')
def test_old_no_reference_recheck_is_failed_not_fabricated_completed(self):
self.reader.return_value = {CODE: report(review_ref=None)}
self.sync()
self.reader.return_value = {CODE: report(review_ref=None, checked_at='2026-11-04T10:01:00+08:00')}
self.sync(now=NOW + dt.timedelta(minutes=5))
row = ur.read(self.root)['rows'][CODE]
self.assertEqual(row['status'], 'failed')
self.assertIn('固定版本', row['error'])
self.assertEqual(self.submit.call_count, 1)
def test_explicit_rejection_does_not_retry_every_schedule(self):
self.submit.side_effect = urllib.error.HTTPError('offline', 403, '', {}, None)
self.sync()
self.sync()
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'failed')
self.assertEqual(self.submit.call_count, 1)
def test_source_failure_never_submits_and_get_reports_failure(self):
self.reader.side_effect = RuntimeError('offline unavailable')
self.assertEqual(self.sync()['status'], 'failed')
self.submit.assert_not_called()
self.assertEqual(ur.views(self.root, [CODE], now=NOW, reader=self.reader)[CODE]['review_status'], 'failed')
def test_readonly_listing_reads_live_reports_without_side_effects(self):
before = {p.name: p.read_bytes() for p in Path(self.root).iterdir() if p.is_file()}
with patch.object(ur, 'load_reports', return_value={CODE: report()}), \
patch.object(ur, 'submit_review', side_effect=AssertionError('GET不可投递')):
row = uc.listing(self.root, NOW)['rows'][0]
self.assertEqual(row['status'], 'pending') # 尚无计划仍可有真实完成报告。
self.assertEqual(row['review_status'], 'completed')
self.assertEqual(row['review_ref'], 'a' * 64)
self.assertEqual(before, {p.name: p.read_bytes() for p in Path(self.root).iterdir() if p.is_file()})
def test_removed_expired_and_out_of_scope_never_submit(self):
uc.remove(self.root, uc.active(self.root, NOW)[0]['id'], 'test', NOW)
self.sync()
self.submit.assert_not_called()
state = uc.read(self.root)
state['rows'].append({'id': 'bad', 'code': 'BJ920001', 'expires_on': '2026-11-10'})
pv.atomic(Path(self.root) / 'user_candidates.json', state)
self.sync()
self.submit.assert_not_called()
self.assertEqual(ur.views(self.root, ['920001.BJ'], now=NOW, reader=self.reader), {})
def test_bounded_submissions_continue_next_natural_cycle(self):
uc.save(self.root, {'codes': ['300364', '300182', '603533', '300291', '301052'],
'reason': '自主关注', 'expires_on': '2026-11-10'}, 'test', NOW)
self.assertEqual(self.sync()['submitted'], 3)
self.assertEqual(self.sync()['submitted'], 3)
self.assertEqual(self.sync()['submitted'], 0)
self.assertEqual(self.submit.call_count, 6)
def test_stale_complete_gets_real_recheck_then_checked_at_recovers(self):
self.reader.return_value = {CODE: report()}
self.sync()
later = NOW + dt.timedelta(days=8)
# 延长关注仅供隔离测试,不改变报告时间。
state = uc.read(self.root)
state['rows'][0]['expires_on'] = '2026-11-30'
pv.atomic(Path(self.root) / 'user_candidates.json', state)
self.assertEqual(self.sync(now=later)['submitted'], 1)
self.reader.return_value = {CODE: report(checked_at=later.isoformat())}
self.sync(now=later + dt.timedelta(minutes=5))
self.assertEqual(ur.read(self.root)['rows'][CODE]['status'], 'completed')
def test_targets_append_all_manual_without_score_verdict_or_prefix_cut(self):
snap = {'main': [{'code': f'SH60{i:04d}', 'score': 300-i, 'rank': i+1} for i in range(150)],
'observe': [], 'user_candidates': [dict(r, verdict='仅展示', score=None) for r in uc.active(self.root, NOW)]}
got = []
rt.persist('2026-11-03', snap, write=lambda day, rows: got.extend(rows))
row = next(r for r in got if r['ts_code'] == '300133.SZ')
self.assertEqual(row['source'], 'manual')
self.assertEqual(len(got), rt.TOP_MAIN + 1)
rows = rt.build_rows('2026-11-03', [], [], [{'code': 'BJ920001'}, {'code': CODE}, {'code': CODE}])
self.assertEqual([r['ts_code'] for r in rows], ['300133.SZ'])
def test_target_sync_preserves_plan_files_and_removes_deleted_manual_rows(self):
snap = {'date': '2026-11-03', 'main': [], 'observe': [], 'decision': {'id': 'read-only'}}
path = Path(self.root) / 'plan_2026-11-03.json'
pv.atomic(path, snap)
before = path.read_bytes()
got = []
ur.sync(self.root, now=NOW, reader=self.reader, submit=self.submit,
target_write=lambda day, rows: got.append(rows))
self.assertEqual(got[-1][0]['ts_code'], '300133.SZ')
self.assertEqual(path.read_bytes(), before)
uc.remove(self.root, uc.active(self.root, NOW)[0]['id'], 'test', NOW)
ur.sync(self.root, now=NOW, reader=self.reader, submit=self.submit,
target_write=lambda day, rows: got.append(rows))
self.assertEqual(got[-1], [])
self.assertEqual(path.read_bytes(), before)
def test_submit_uses_fixed_base_and_flags_without_redirect(self):
response = io.BytesIO(json.dumps({'status': 'queued', 'task_id': 'x'}).encode())
opener = Mock()
opener.open.return_value = response
with patch.object(config, 'AKG_API_BASE', 'http://offline.invalid:8000'), \
patch.object(ur.urllib.request, 'build_opener', return_value=opener):
self.assertEqual(ur.submit_review(CODE)['status'], 'queued')
req = opener.open.call_args.args[0]
url = urllib.parse.urlsplit(req.full_url)
self.assertEqual((url.netloc, url.path), ('offline.invalid:8000', '/admin/company_review'))
self.assertEqual(req.method, 'POST')
q = urllib.parse.parse_qs(url.query)
self.assertEqual(q, {'ts_code': ['300133.SZ'], 'force': ['false'], 'sync': ['false'],
'with_brain': ['true'], 'with_qual': ['true']})
self.assertLessEqual(opener.open.call_args.kwargs['timeout'], 10)
with self.assertRaises(urllib.error.HTTPError):
ur._NoRedirect().redirect_request(req, None, 302, '', {}, 'http://elsewhere.invalid')
def test_checked_column_only_for_live_independent_research(self):
import pandas as pd
row = {'ts_code': '300133.SZ', 'period': '2026Q3', 'review_version': 'v',
'grades': {}, 'summary': report(), 'brain_used': True, 'brain_status': 'ok',
'ran_at': dt.datetime.fromisoformat('2026-09-29T00:00:00+00:00'),
'checked_at': NOW}
reader = Mock(return_value=pd.DataFrame([row]))
got = sources.company_reviews([CODE], '2026-11-04', read_pg=reader,
cutoff_at=NOW.isoformat(), include_check=True)
self.assertIn('checked_at', reader.call_args.args[0])
self.assertEqual(got[CODE]['checked_at'], NOW.isoformat())
normal = sources.company_reviews([CODE], '2026-11-04', read_pg=reader, cutoff_at=NOW.isoformat())
self.assertNotIn('checked_at', normal[CODE])
self.assertNotIn(', checked_at', reader.call_args.args[0])
def test_background_research_failure_does_not_block_plan_refresh(self):
import plan_refresh
with patch.object(ur, 'sync', side_effect=RuntimeError('offline failure')), \
patch.object(plan_refresh, 'refresh', return_value={'status': 'unchanged'}) as refresh:
self.assertEqual(uc.refresh_saved()['status'], 'unchanged')
refresh.assert_called_once()
if __name__ == '__main__':
unittest.main()

View File

@ -189,6 +189,8 @@ def listing(root, now=None):
material = {r['code']: r for b in ('main', 'observe') for r in published.get(b, [])}
expected = {r['id'] for r in published.get('user_candidates', [])}
today = now.astimezone(BJ).date().isoformat()
import user_research
research = user_research.views(root, [r['code'] for r in state['rows'][-300:]], now=now)
rows = []
for source in reversed(state['rows']):
row = material.get(source['code']) or {}
@ -197,7 +199,8 @@ def listing(root, now=None):
'pending' if source['id'] not in expected else 'evaluated')
rows.append({**source, 'status': status, 'name': row.get('name') or source.get('name'),
'verdict': row.get('verdict'), 'basis': row.get('basis'),
'decision_id': (published.get('decision') or {}).get('id')})
'decision_id': (published.get('decision') or {}).get('id'),
**research.get(source['code'], {})})
return {'ok': True, 'rows': rows[:300], 'revision': state['revision']}
@ -205,6 +208,11 @@ def refresh_saved():
"""请求结束后尝试发布;失败保留登记和待核验状态,定时修订会重试。"""
import logging
import plan_refresh
import user_research
try:
user_research.sync()
except Exception:
logging.getLogger(__name__).exception('人工关注评析状态同步失败,保留登记等待自然调度')
try:
return plan_refresh.refresh()
except Exception:

273
user_research.py Normal file
View File

@ -0,0 +1,273 @@
"""人工关注的独立评析状态:先持久化受理凭据,再投基座;查询绝不派任务。
计划的 evaluated 只表示已收录,不能代替买方评议完成。网络结果不明时不重复
投递,后续只读核验真实报告,并由原评析目标名单/批任务继续补齐。
"""
from __future__ import annotations
import contextlib
import datetime as dt
import fcntl
import json
import logging
from pathlib import Path
import re
import urllib.error
import urllib.parse
import urllib.request
import uuid
from zoneinfo import ZoneInfo
import plan_versions as pv
BJ = ZoneInfo('Asia/Shanghai')
UTC = dt.timezone.utc
_FILE = 'user_research.json'
log = logging.getLogger(__name__)
def _time(value):
try:
value = value if isinstance(value, dt.datetime) else dt.datetime.fromisoformat(str(value).replace('Z', '+00:00'))
return value.replace(tzinfo=UTC) if value.tzinfo is None else value
except (TypeError, ValueError):
return None
def _now(now=None):
return _time(now) or dt.datetime.now(UTC)
@contextlib.contextmanager
def _writer(root):
Path(root).mkdir(parents=True, exist_ok=True)
with open(Path(root) / '.user-research.lock', 'a') as lock:
fcntl.flock(lock, fcntl.LOCK_EX)
yield
def read(root):
path = Path(root) / _FILE
if not path.exists():
return {'version': 1, 'rows': {}}
value = json.loads(path.read_text())
if value.get('version') != 1 or not isinstance(value.get('rows'), dict):
raise ValueError('人工关注评析状态暂不可用')
return value
def _save(root, state):
pv.atomic(Path(root) / _FILE, state)
def _active(root, now):
import user_candidates as uc
rows = []
for row in uc.active(root, now):
try:
rows.append(dict(row, code=uc.normalize(row['code'])))
except (ValueError, KeyError):
# 持久化来源也在入口守沪深范围,不能因旧文件或外部写入越界。
continue
return rows
def report_state(report, now=None, fresh_days=7):
"""只判报告完成事实;财报期是否落后仍由基座原有批任务判断。"""
now = _now(now)
report = report if isinstance(report, dict) else {}
generated = _time(report.get('report_ran_at'))
checked = _time(report.get('checked_at'))
if not report:
return False, '尚无买方评析报告', None
if generated is None or generated > now:
return False, '评析生成时间缺失或晚于当前时刻,待核实', None
# 旧报告命中指纹时只更新 checked_at;不能把复核当新报告,也不能永远判旧。
verified = max(t for t in (generated, checked) if t is not None and t <= now)
if not report.get('brain_used') or report.get('brain_status') != 'ok':
return False, '买方评议尚未完整完成', verified
if not re.fullmatch(r'[0-9a-f]{64}', str(report.get('review_ref') or '')):
return False, '报告缺少可核验的固定版本,等待重新归档', verified
if not str(report.get('thesis') or '').strip():
return False, '报告尚缺买方论点', verified
if now - verified > dt.timedelta(days=fresh_days):
return False, '评析需要重新核对资料', verified
return True, None, verified
def load_reports(codes, now=None):
import sources
now = _now(now)
if not codes:
return {}
return sources.company_reviews(codes, now.astimezone(BJ).date().isoformat(),
cutoff_at=now.isoformat(), strict=True, include_check=True)
def _public(report, record, now, fresh_days):
import card
report = report if isinstance(report, dict) else None
complete, reason, verified = report_state(report, now, fresh_days)
status = (record or {}).get('status', 'missing')
if status == 'completed' and not complete: # 上次完成不能掩盖这次缺报或陈旧。
status = 'missing'
if complete:
status = 'completed'
generated = _time((report or {}).get('report_ran_at'))
error = None if complete else (record or {}).get('error') or reason
return {'review_status': status, 'review_updated_at': (verified.isoformat() if complete and verified else (record or {}).get('updated_at')),
'review_error': error,
'review_data_date': generated.astimezone(BJ).date().isoformat() if generated and generated <= now else None,
'company_review': report, 'company_review_text': card.company_review_view(report),
'review_ref': (report or {}).get('review_ref')}
def views(root, codes, *, now=None, reader=None):
"""实时只读视图;既不落状态文件,也不触发请求或写研究目标表。"""
import config
import user_candidates as uc
now = _now(now)
safe = []
for code in codes:
try:
safe.append(uc.normalize(code))
except ValueError:
continue
safe = sorted(set(safe))
state = read(root)
try:
reports = (reader or load_reports)(safe, now)
except Exception:
log.exception('人工关注评析读取失败')
return {code: {'review_status': 'failed', 'review_updated_at': None,
'review_error': '评析资料暂不可读取,请稍后核实', 'review_data_date': None,
'company_review': None, 'company_review_text': '', 'review_ref': None}
for code in safe}
return {code: _public(reports.get(code), state['rows'].get(code), now,
config.USER_RESEARCH_FRESH_DAYS) for code in safe}
class _NoRedirect(urllib.request.HTTPRedirectHandler):
def redirect_request(self, req, fp, code, msg, headers, newurl):
raise urllib.error.HTTPError(req.full_url, code, '评析提交不接受跳转', headers, fp)
def submit_review(code):
"""唯一请求地址来自受管配置,代码参数无法改变域名、路径或强制重跑。"""
import config
import user_candidates as uc
code = uc.normalize(code)
base = urllib.parse.urlsplit(config.AKG_API_BASE)
if (base.scheme not in ('http', 'https') or not base.hostname or base.username
or base.password or base.query or base.fragment):
raise ValueError('评析服务地址配置无效')
endpoint = config.AKG_API_BASE.rstrip('/') + '/admin/company_review'
query = urllib.parse.urlencode({'ts_code': code[2:] + '.' + code[:2],
'force': 'false', 'sync': 'false',
'with_brain': 'true', 'with_qual': 'true'})
request = urllib.request.Request(endpoint + '?' + query, data=b'', method='POST')
timeout = max(1.0, min(float(config.USER_RESEARCH_REQUEST_TIMEOUT), 10.0))
opener = urllib.request.build_opener(_NoRedirect())
with opener.open(request, timeout=timeout) as response:
return json.loads(response.read(1024 * 1024).decode('utf-8'))
def _targets(root, active, state, write=None):
"""给原自然批任务补齐全部有效人工关注,不改变已发布计划内容。"""
import review_targets
if not active and not state.get('targets_key'):
return
day = pv.latest_date(root)
if not day:
return
published = pv.load(root, day)
key = pv.digest({'day': day, 'decision': published.get('decision'), 'active': active})
if state.get('targets_key') == key:
return
review_targets.persist(day, published, write=write, user_rows=active)
state['targets_key'] = key
state.pop('targets_error', None)
def sync(root=None, *, now=None, reader=None, submit=None, target_write=None):
"""后台/自然调度入口。锁只护本地状态;网络前 claim 已经原子落盘。"""
import config
root = root or config.PLAN_SNAPSHOT_DIR
now = _now(now)
active = _active(root, now)
codes = sorted({r['code'] for r in active})
with _writer(root):
state = read(root)
try:
_targets(root, active, state, target_write)
except Exception:
state['targets_error'] = '研究目标名单同步失败,后台会继续核对'
log.exception('人工关注研究目标名单同步失败')
_save(root, state)
try:
reports = (reader or load_reports)(codes, now)
except Exception:
log.exception('人工关注评析同步读取失败,本轮不投递')
return {'status': 'failed', 'error': '评析资料暂不可读取,本轮未重复提交', 'submitted': 0}
submitted = 0
for code in codes:
report = reports.get(code)
complete, reason, verified = report_state(report, now, config.USER_RESEARCH_FRESH_DAYS)
with _writer(root):
state = read(root)
previous = state['rows'].get(code, {})
# 提交前再核对删除/到期,避免旧后台任务给已移除关注派新任务。
if code not in {r['code'] for r in _active(root, now)}:
continue
if complete:
state['rows'][code] = dict(previous, status='completed', error=None,
updated_at=verified.isoformat(), observed_at=now.isoformat(),
report_ref=report['review_ref'])
_save(root, state)
continue
if previous.get('status') == 'completed' and (_time(previous.get('observed_at')) or dt.datetime.min.replace(tzinfo=UTC)) >= now:
continue # 较早开始的并发读取不能把刚核实的完成状态反向改成待投递。
claimed = _time(previous.get('claimed_at'))
if previous.get('status') in ('pending', 'queued', 'failed') and claimed:
# 已投过的旧无 ref/不完整报告,核对更新后仍不合格,明确留待补齐;不假造完成。
if verified and verified > claimed and previous.get('status') != 'failed':
state['rows'][code] = dict(previous, status='failed', error=reason,
updated_at=now.isoformat())
_save(root, state)
continue
if submitted >= max(1, config.USER_RESEARCH_SUBMIT_LIMIT):
continue
claim = uuid.uuid4().hex
state['rows'][code] = dict(previous, status='pending', claim_id=claim,
claimed_at=now.isoformat(), updated_at=now.isoformat(),
error='评析请求正在受理,结果待核实')
_save(root, state)
submitted += 1
status, error, task_id = 'pending', '评析请求的受理结果待核实,暂不重复提交', None
try:
result = (submit or submit_review)(code)
if (isinstance(result, dict) and result.get('status') == 'queued'
and isinstance(result.get('task_id'), str) and result['task_id'].strip()):
status, error, task_id = 'queued', None, str(result['task_id'])
elif isinstance(result, dict) and result.get('status') == 'done':
result_status = (result.get('result') or {}).get('status')
if result_status not in ('ok', 'skipped_fresh'):
status, error = 'failed', '评析尚未生成完整报告,等待资料补齐'
else:
error = '评析已返回,等待核验固定报告'
except urllib.error.HTTPError as exc:
if 400 <= exc.code < 500:
status, error = 'failed', '评析请求未被接受,请核对服务后重试'
log.warning('人工关注评析请求失败 code=%s http=%s', code, exc.code)
except ValueError:
log.exception('人工关注评析响应或配置不可核验 code=%s', code)
except Exception:
log.exception('人工关注评析受理结果不明 code=%s', code)
with _writer(root):
state = read(root)
previous = state['rows'].get(code, {})
if previous.get('claim_id') == claim and previous.get('status') != 'completed':
state['rows'][code] = dict(previous, status=status, error=error,
task_id=task_id, updated_at=now.isoformat())
_save(root, state)
return {'status': 'checked', 'active': len(codes), 'submitted': submitted}