diff --git a/README.md b/README.md index 2924fca..94d96bf 100644 --- a/README.md +++ b/README.md @@ -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`,三路映射 diff --git a/card.py b/card.py index 2912a7d..c870686 100644 --- a/card.py +++ b/card.py @@ -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"))} diff --git a/config.py b/config.py index 96d9e4d..ad36935 100644 --- a/config.py +++ b/config.py @@ -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")) # 读上一次落定态与近几日原始态时往前看几个自然日。要盖住国庆这种连休八天再加两个周末的空档; diff --git a/docs/复盘决定台账.md b/docs/复盘决定台账.md index 9d3ba2b..b18e87c 100644 --- a/docs/复盘决定台账.md +++ b/docs/复盘决定台账.md @@ -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 部署、真实评析受理与完成、自然日研究及盘中观察仍须在发布阶段逐项判收,不注入交易制造结果。 diff --git a/plan.py b/plan.py index 16d93dd..97a25e8 100644 --- a/plan.py +++ b/plan.py @@ -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, diff --git a/plan_refresh.py b/plan_refresh.py index 3df3b48..69ca545 100644 --- a/plan_refresh.py +++ b/plan_refresh.py @@ -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: diff --git a/review_targets.py b/review_targets.py index 8cf12f9..7e57be3 100644 --- a/review_targets.py +++ b/review_targets.py @@ -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: diff --git a/run.py b/run.py index 93c981e..c976d08 100644 --- a/run.py +++ b/run.py @@ -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'): diff --git a/sources.py b/sources.py index 0b193c3..9f203e4 100644 --- a/sources.py +++ b/sources.py @@ -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 diff --git a/test_accum_reference.py b/test_accum_reference.py new file mode 100644 index 0000000..25e87ad --- /dev/null +++ b/test_accum_reference.py @@ -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() diff --git a/test_daily_plan_contracts.py b/test_daily_plan_contracts.py index 7486648..c93d89d 100644 --- a/test_daily_plan_contracts.py +++ b/test_daily_plan_contracts.py @@ -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', diff --git a/test_dividend_watch.py b/test_dividend_watch.py index 4933e1e..c274703 100644 --- a/test_dividend_watch.py +++ b/test_dividend_watch.py @@ -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) diff --git a/test_user_candidates.py b/test_user_candidates.py index 84722ca..4428a32 100644 --- a/test_user_candidates.py +++ b/test_user_candidates.py @@ -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'): diff --git a/test_user_research.py b/test_user_research.py new file mode 100644 index 0000000..be7c639 --- /dev/null +++ b/test_user_research.py @@ -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() diff --git a/user_candidates.py b/user_candidates.py index cb39c03..fa47c9a 100644 --- a/user_candidates.py +++ b/user_candidates.py @@ -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: diff --git a/user_research.py b/user_research.py new file mode 100644 index 0000000..953feef --- /dev/null +++ b/user_research.py @@ -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}