Compare commits

..

No commits in common. "codex/manual-watch-review-20261104" and "main" have entirely different histories.

22 changed files with 62 additions and 1692 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)
## HTTP 接口(桥常驻 API,端口 8300,全部只读除 refresh)
| 端点 | 作用 |
|---|---|
@ -191,10 +191,6 @@ 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。纯文件读取,不连库 |
@ -202,24 +198,6 @@ 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` 的北京时间日期。财报期是否落后仍由基座原有批任务判断;旧报告缺固定引用或评议未完成时明确等待补齐,不能伪造完成状态。
开发机与最终候选镜像验证:35 个测试文件全部经配置隔离、禁网护栏通过,其中吸筹参考专项 5 项、人工关注评析专项 19 项通过。155 桥已于 2026-11-04 11:08:27 发布 `e5696ee`;实际规则、历史保全、自然回执与待办见[人工关注与吸筹参考发布接续](docs/人工关注与吸筹参考发布接续_2026-11-04.md)。规则决定见[复盘决定台账 084](docs/复盘决定台账.md)。
## 里程碑状态(设计 §8)
- **G2 赛道门槛 ✅**:`config/frontier_tracks.yml` + `tracks.py`,三路映射

82
api.py
View File

@ -20,7 +20,7 @@ import time
import threading
import pandas as pd
from fastapi import FastAPI, HTTPException, Request, Body, Header, BackgroundTasks
from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import PlainTextResponse, JSONResponse, HTMLResponse
import card
@ -96,58 +96,6 @@ def dividend_candidate_feed(code: str = None):
raise HTTPException(status_code=503, detail="高股息资料暂不可用,请稍后再试") from exc
@app.get('/plan/user-candidates/search')
def search_user_candidates(q: str = ''):
import user_candidates as uc
query = q.strip().upper()[:40]
if not query:
return {'ok': True, 'items': []}
names = uc.catalog()
items = []
for code, name in names.items():
try:
uc.normalize(code)
except ValueError:
continue
if query in code or query in name.upper():
items.append({'code': code, 'name': name})
return {'ok': True, 'items': sorted(items, key=lambda x: x['code'])[:30]}
@app.get('/plan/user-candidates')
def list_user_candidates():
import user_candidates as uc
return uc.listing(config.PLAN_SNAPSHOT_DIR)
@app.post('/plan/user-candidates')
def add_user_candidates(background_tasks: BackgroundTasks, payload: dict = Body(...),
x_job_key: str = Header(None)):
from xxl import _require_key
import user_candidates as uc
_require_key(x_job_key, None)
try:
result = uc.save(config.PLAN_SNAPSHOT_DIR, payload, payload.get('actor') or 'PMS', names=uc.catalog())
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc)) from exc
background_tasks.add_task(uc.refresh_saved)
return result
@app.post('/plan/user-candidates/{identity}/remove')
def remove_user_candidate(identity: str, background_tasks: BackgroundTasks,
payload: dict = Body(...), x_job_key: str = Header(None)):
from xxl import _require_key
import user_candidates as uc
_require_key(x_job_key, None)
try:
result = uc.remove(config.PLAN_SNAPSHOT_DIR, identity, payload.get('actor') or 'PMS')
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc)) from exc
background_tasks.add_task(uc.refresh_saved)
return result
@app.get("/plan/dates")
def plan_dates(limit: int = 30):
from pathlib import Path
@ -180,13 +128,12 @@ _PLAN_CACHE_MAX = 8 # 不同参数组合最多留几份,防内存慢
_PLAN_BUILD_LOCKS: dict = {} # 每个缓存键一把「正在算」的锁,见 _plan_cached 里的说明
def _plan_build(date, top, obs_top, theme_cap, decision_id=None, include_user_candidates=False) -> dict:
def _plan_build(date, top, obs_top, theme_cap, decision_id=None) -> dict:
"""只读已发布版本。缺档明确报错,禁止用当前研究重构历史。"""
return plan.from_snapshot(date, top, obs_top, theme_cap, decision_id=decision_id,
include_user_candidates=include_user_candidates)
return plan.from_snapshot(date, top, obs_top, theme_cap, decision_id=decision_id)
def _plan_cached(date, top, obs_top, theme_cap, nocache: bool, decision_id=None, include_user_candidates=False):
def _plan_cached(date, top, obs_top, theme_cap, nocache: bool, decision_id=None):
"""返回 (data, 命中与否)。data 是 plan.collect 的结果(已去掉 _full)。
键里放**真实数据日**而不是请求里的 date:不传 date 时数据日随构建更新,明早换日后
@ -196,10 +143,7 @@ def _plan_cached(date, top, obs_top, theme_cap, nocache: bool, decision_id=None,
ds_key = published['date']
pinned = (published.get('decision') or {}).get('id')
state = pv.health(config.PLAN_SNAPSHOT_DIR, ds_key) if not decision_id else {}
if not decision_id and not date:
import user_candidates as uc
state = dict(state, pending_codes=sorted(set(state.get('pending_codes') or []) | set(uc.live_pending(config.PLAN_SNAPSHOT_DIR, published))))
key = (pinned or pv.digest(published), pv.digest(state), int(top), int(obs_top), int(theme_cap), bool(include_user_candidates))
key = (pinned or pv.digest(published), pv.digest(state), int(top), int(obs_top), int(theme_cap))
now = time.time()
if not nocache and PLAN_CACHE_SEC > 0:
with _PLAN_CACHE_LOCK:
@ -223,8 +167,7 @@ def _plan_cached(date, top, obs_top, theme_cap, nocache: bool, decision_id=None,
hit = _PLAN_CACHE.get(key)
if hit and time.time() - hit[0] < PLAN_CACHE_SEC:
return hit[1], True
data = _plan_build(ds_key, top, obs_top, theme_cap, pinned,
**({'include_user_candidates': True} if include_user_candidates else {}))
data = _plan_build(ds_key, top, obs_top, theme_cap, pinned)
data['refresh_status'] = state
if PLAN_CACHE_SEC > 0:
with _PLAN_CACHE_LOCK:
@ -241,14 +184,14 @@ def _plan_cached(date, top, obs_top, theme_cap, nocache: bool, decision_id=None,
@app.get("/plan")
def get_plan(request: Request, date: str | None = None, format: str = "json",
top: int = 20, obs_top: int = 10, theme_cap: int = 5, nocache: int = 0,
decision_id: str | None = None, include_user_candidates: bool = False):
decision_id: str | None = None):
"""向下兼容承诺(2026-09-02 方案 2.7):main / observe 的装配、排序、裁剪与既有字段
一字不动,每行只多联入判决类字段;顶层只新增 generated_at、plan_version、regime、
card_counts、candidates、watch、segments_pointed、snapshot,2026-09-03 再加 market
(环境段市场四项,与 regime 一样只从当日快照读,快照缺失为空字典)。PMS 按字段名取值、忽略未知键。"""
t0 = time.time()
try:
data, cached = _plan_cached(date, top, obs_top, theme_cap, bool(nocache), decision_id, include_user_candidates)
data, cached = _plan_cached(date, top, obs_top, theme_cap, bool(nocache), decision_id)
except (RuntimeError, ValueError, OSError) as e:
raise HTTPException(status_code=404, detail=str(e))
data = dict(data) # 下面几个键按请求写,不污染缓存里那一份
@ -273,12 +216,11 @@ def get_plan(request: Request, date: str | None = None, format: str = "json",
@app.get('/plan/check')
def check_plan_stock(code: str, include_user_candidates: bool = False):
def check_plan_stock(code: str):
"""采纳专用逐票读取。只读已发布计划,不装配、不查研究库。"""
from common import to_prefix
try:
return JSONResponse(content=plan_versions.stock_check(config.PLAN_SNAPSHOT_DIR, to_prefix(code),
include_user_candidates=include_user_candidates))
return JSONResponse(content=plan_versions.stock_check(config.PLAN_SNAPSHOT_DIR, to_prefix(code)))
except (OSError, ValueError, RuntimeError) as e:
raise HTTPException(status_code=503, detail=str(e))
@ -290,15 +232,13 @@ def refresh(date: str | None = None, key: str | None = None):
key=key, x_job_key=None)
def _published_stock_rows(want, date, decision_id, include_user_candidates=False):
def _published_stock_rows(want, date, decision_id):
try:
published = plan_versions.load(config.PLAN_SNAPSHOT_DIR, date, decision_id)
except (OSError, ValueError):
if decision_id or date:
raise HTTPException(status_code=404, detail='指定计划版本不可用')
return {}, {}
import user_candidates as uc
published = uc.consumer_view(published, include_user_candidates)
rows = {r['code']: dict(r, decision=bucket, source='published',
traceability=published.get('traceability') or 'legacy_unverified',
decision_version=published.get('decision'), date=published['date'],

34
card.py
View File

@ -1,9 +1,5 @@
"""候选卡:把一只票的各条证据线装配成判决与理由(纯函数,零 IO)。
2026-11-04新增参考模式:require_accum_confirm=False时,非明确、缺失和陈旧
吸筹不再单独否决候选。资格、真实风险和公司质地分流保留,建仓交PMS三源合议。
以下确认线描述为兼容旧模式,历史快照保持原判决。
## 为什么要有它
桥原来的产物是一个分数:主榜分 = 200 + 传导档位×20 + 组内分。分数排在最前的
@ -99,7 +95,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, require_accum_confirm: bool = True) -> dict[str, Any]:
stale_days: int = 120) -> dict[str, Any]:
"""一只票的证据字典 -> 判决字典。
ev 里认的键(缺键按缺失处理,不报错):
@ -167,7 +163,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 require_accum_confirm and confirm_negative and "派发" not in accum_state:
elif confirm_negative and "派发" not in accum_state:
state_short = accum_state.split("·")[0].strip()
missing.append(f"吸筹只到「{state_short}」,没到明确吸筹这条线")
if not gates["pointed"]:
@ -192,33 +188,17 @@ 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%}")
# 人工来源替代发现条件;pointed 仍保留真实传导状态,不改变排序和其他门槛。
user_selected = bool(ev.get('user_selected'))
if user_selected and not gates['pointed']:
missing = [x for x in missing if x != '所在环节当日没有被传导指向']
reasons.insert(0, '用户添加,按现有条件评估')
effective = dict(gates, pointed=gates['pointed'] or user_selected)
all_gates = all(effective.values())
failed = [k for k, ok in effective.items() if not ok]
all_gates = all(gates.values())
failed = [k for k, ok in gates.items() if not ok]
# 判决依据是这张卡上唯一一句"为什么",PMS 原样显示在页面上给人读。所以它必须是
# 一句完整的中文,带上具体数字,不许出现门槛的变量名(started 这类)或信号的
# 枚举值(SELL 这类)——那些是系统之间传递用的,不是给人看的。
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} 个交易日前评的)"
@ -250,13 +230,11 @@ 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}),候选降为关注交人裁决" if require_accum_confirm else
f"公司质地评为差({why_q}),按PMS现行合议和自决档处理关注候选")
company_gate = f"公司质地评为差({why_q}),候选降为关注交人裁决"
basis = f"{basis};{company_gate}"
return {"verdict": verdict, "reasons": reasons, "missing": missing, "risk": risk,
"gates": gates, "confirm": confirm, "confirm_required": bool(require_accum_confirm),
"failed_gates": failed, "basis": basis,
"gates": gates, "confirm": 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,9 +224,6 @@ 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")
@ -321,9 +318,6 @@ 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

@ -1,103 +0,0 @@
# 个股评析全池覆盖开发规格
日期为2026年10月28日。本文时间均为北京时间。
## 目标与授权
用户要求本轮覆盖整个产业池和高股息池。
当前候选优先,未完成对象不因每日名单变化而丢失。
本轮补普通个股评析,不自动扩大分红专项研究。
股票资格、排序、模型判据和交易参数保持。
## 改前实测
178基座提交7ef107e,评析队列为零。
当前目标148家,全部已有报告、定性及评议。
产业池3833家,仅747家有报告。
桥高股息池169家,仅9家有报告。
两个池有交集,缺口不能直接相加。
本轮只读预览并集3885家,已有747家,首次报告缺口3138家。
高股息缺报告的160家均未进入留存的评析目标名单。
近72小时43次成功运行平均185.5秒。
第95百分位246.4秒,最大286.5秒。
近七天评议平均输出13465个token。
原每日上限为评议150家、定性200家、评议输出300万token。
## 具体工作
1. 复用原每小时批任务和review队列,不新增任务或表。
2. 自动读取全部产业池成员。
3. 从桥已发布的高股息研究接口读取研究对象。
不按投资资格eligible过滤,基座不重新计算股息筛选。
4. 在现有job_runs保存累计研究名单,名单变化才追加快照。
已纳入对象继续保留。来源读取失败保留旧名单并报告。
旧快照读失败时停止扩展投递,不能用空名单覆盖。
5. 新报告优先于名单外旧报告升级。
当前候选保留优先名额,剩余名额持续补名单外对象。
旧报告的复核不能无限挤占首次报告。
6. 每批完整运行最多30家。每日评议、定性各600家。
评议输出上限900万token,单次模型预算保持。
每日额度不足时不继续投递完整运行。
7. 用Redis短期凭据防止重复投递。
失败对象延后重试,队列积压时暂停增加整批任务。
重试不删除旧报告,不清空历史记录。
8. 名单外补齐避开06:00至08:00、20:00至23:00。
原候选任务仍按原调度执行。
晚间行业催化与分红专项使用原队列和时刻。
9. 日检分别显示有报告、定性、评议及首次报告缺口。
无财务数据、材料薄和失败不能宣称完整研究已完成。
## 偏差发现与撤销
新增配置文件控制覆盖开关和每日额度。
关闭覆盖开关即回到原目标集合与每日额度。
旧报告、固定引用和累计名单保留。
日检报告来源失败、剩余缺口和最近调度状态。
同一对象反复失败时先暂停其重试,不阻塞后面的对象。
按每日有效完成约450至550家估算,首次覆盖约需一周。
这只是按现有耗时计算的容量预估。
上游缺财务数据及缺年报的对象单列,不能承诺完整结论。
## 分批验收预期
### 本地
- 合并去重和排序确定,重复读取不改变名单。
- 高股息资格尚未通过的对象仍能进入研究。
- 来源暂不可用时累计待办不丢,旧快照损坏时不覆盖。
- 当前候选和首次报告均能获得名额。
- 预算不足、已有在途及失败冷却时不重复投递。
- 保护时段只运行原候选。
- 旧指纹、有效标志、固定报告引用和财务期口径不变。
- 全部离线unittest通过。
### 部署前只读预览
在178容器内核对两个池并集、首次报告缺口和首批代码。
预览不保存名单,不登记运行,不投递任务,不调用模型。
核对桥消费的company_review_runs及报告路径保持。
### 服务生效与生产判收
容器重建须取得用户同意。
按仓库规则统一重建四类worker。
beat调度不改,不需要重建。
首批显式投递review队列,核对报告增量与预算读数。
首批成功不等于全池覆盖完成。
后续按实际缺口下降和失败清单判收。
## 开发者参考
原targets.collect仍供材料需求单和旧入口使用。
扩大覆盖只在评析批任务启用,避免一次扩大数千张采集单。
累计名单使用job_runs的既有tail JSON字段。
临时投递凭据使用Redis,带过期和所有者校验。
同一凭据只能从待执行原子转为执行中一次。
失败冷却六小时;无数据沿用七天复查,三次评议失败沿用原放弃规则。
预算沿用索引表的当日登记口径,含失败状态。
每次模型调用仍受原单次输出上限约束。
这不是服务商账单的逐次计费审计,不能把登记量称为实际费用。
排序只决定研究先后,不形成证券评分。
报告内容及下游排序由现有逻辑继续处理。

View File

@ -1,129 +0,0 @@
# 个股评析全池覆盖交接
本轮日期为2026年10月28日,时间按北京时间。
规格见《个股评析全池覆盖开发规格_2026-10-28.md》。
## 用户决定
用户要求本轮直接覆盖整个产业池和高股息池。
本轮扩大普通个股评析,不扩大分红专项研究,也不改交易参数。
## 已实现
复用原每小时批任务、review队列及两个工作并发。
每批最多30家,当前候选保留10个优先名额。
没有候选待办时,30个名额均可补首次报告。
高股息研究对象取桥已发布的现有接口。
基座不重新计算股息筛选,也不按投资资格过滤研究。
累计范围沿用job_runs的tail字段,仅名单变化时追加快照。
来源失败保留旧名单;旧名单损坏时停止扩展。
在途凭据有所有者校验和六小时过期。
失败冷却六小时,任务不反复抢同一批名额。
每日评议和定性上限各600家,评议输出上限900万token。
开关和额度由config/company_review_coverage.json热读。
06:00至08:00、20:00至23:00仅处理原候选。
其余时段允许补齐全池,原beat时刻保持。
材料需求单仍使用原targets.collect。
本轮没有一次扩开数千张采集需求单。
报告判据、财务期、幂等指纹和固定引用保持。
批任务返回保留原有字段,新增覆盖和来源读数。
## 部署前实测证据
178原代码为7ef107e,旧服务正在运行。
当前候选148家,全部已有评析、定性与评议。
产业池3833家,高股息研究池169家。
新范围去重后3885家,已有747家,缺3138家。
首批只读预览为30家首次报告与60家原候选轻量复核。
两路范围来源读取成功,review队列为零。
预览未保存累计名单,未投任务,未调用模型。
本地全部离线unittest为264项,通过。
新增26项覆盖轮转、预算、来源失败、在途及任务收尾测试。
已有指纹、报告与财务历史边界测试保持通过。
桥sources.company_reviews仍直接读原索引字段。
报告路径与输出格式未改变。
## 部署前边界(已由下文上线记录更新)
代码尚未在178拉取,工作容器尚未重建。
新范围尚未投递,不能把只读预览称为覆盖完成。
服务器现有未提交文件保留。
其他仓库只同步本文和规格副本,并追加桥决定台账。
桥现有未提交台账与其他工作保持。
## 上线及撤销
用户同意后,在review队列与在途任务为空时统一重建四类worker。
保留原worker副本数,不调整并发,不重建beat或前端。
核验热读配置与只读预览后,显式向review队列投递首批。
首批成功后,按自然小时批次继续推进。
首次覆盖容量预估约一周,不保证缺材料对象得到完整结论。
撤销时在本地将配置enabled改为false,再提交并由178拉取。
下一批恢复原名单和每日额度。
已在途任务可完成,旧报告与累计名单保留。
## 可运行验证
```bash
# 本地 · /Users/baobao/Documents/work/project/astock-kg
PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=backend python3 -m unittest discover -s backend/tests -t backend
git diff --check
```
预期264项通过,差异检查无输出。
```bash
# 基座机 · ~/project/astock-kg,部署后
docker compose exec -T -e PYTHONPATH=/app backend python /app/scripts/company_review_coverage.py
```
预期dry_run为true,dispatched为空。
初始targets为3885、missing_reports为3138,后续随真实产出改变。
source_errors应为空;无数据与材料薄须分开看。
新增的日检行同时显示最近批次时刻及状态。
## 2026-10-28生产上线记录
本节时间均为北京时间。
用户明确同意部署并启动补齐。
15:35再次核查四条队列均为零,四类worker在途任务均为空。
178从7ef107e快进到42191df,服务器已有未提交文件保持一致。
15:35:52统一重建四类worker,镜像、各服务副本数及并发保持。
15:36四个新节点均返回pong。
beat、前端及数据库容器未重建。
部署后只读预览与部署前一致。
范围3885家,有报告747家,首次缺口3138家。
每日额度为评议600家、定性600家、评议输出900万token。
名单来源无异常,预计首批为30家首次报告及60家轻量复核。
15:36:32显式向review队列投递批次。
任务号为e20798d0-6186-4a96-9093-f35a133cf70f。
15:36:33批任务成功,实际投递90项。
其中30项带定性与评议,60项仅复核原候选。
累计名单已保存,初始90项均持有在途凭据。
首批投递成功不等于90项执行完成。
15:37部署后完整日检通过,19项正常、零警告、零错误。
新增覆盖行和最近批次行均成功输出。
15:38接口健康检查返回HTTP 200。
15:40:46首份新增报告000543.SZ成功落库。
报告、评议、定性状态均为ok,在途凭据自动删除。
最新报告和固定引用接口均返回HTTP 200,各51418字节。
固定引用为3aae8fc1e87736811af30027715c12f64b9a656075608dbfff981338a97b07d1。
15:41:43复查累计名单3885家,有报告748家,剩余3137家。
在途89项、重试冷却零项,两路名单来源仍无异常。
当日登记评议8家、定性8家、评议输出104020个token。
本轮已判收部署、批次投递、首份报告和凭据收尾。
首批全部完成、下一次自然小时批次及全池覆盖尚未判收。
后续由原定时任务继续推进,无需人工逐批投递。
缺财务数据、材料薄及失败须分列,不能充作完整结论。
部署日志在178的~/akg_logs/review-coverage-deploy-20261028-1535/。
目录保留前后服务状态、原镜像与命令、拉取记录和首批预览。

View File

@ -1,119 +0,0 @@
# 人工关注与吸筹参考发布接续
记录日期:2026-11-04,北京时间。部署回执时间:11:08:27;最新阶段结论更新至14:35。全部6条买方评析、每日分析及盘中分析已完成,并匹配当前报告引用。最后1条守原模型失败冷却,于14:33自然重试完成。155左侧已恢复原单行信息流。下文按时序保留历史核验,不将此前行情阻塞视为当前状态。
## 授权和本次变化
用户明确选择沿用公司质地排序,吸筹作为参考,建仓看基本面、技术面和择时三源合议。本次仅在 155 模拟链路关闭桥的明确吸筹确认门槛,保留发现资格、覆盖、估值、风险及 PMS 后续命令、合议、资金、组合与执行约束。高位派发等真实风险继续拦截,不新造评分或权重,不扩展到 188 真实 PMS。
人工关注的登记、计划收录和真实买方评析完成各自留痕。后台和自然修订周期同步评析,全部有效沪深人工关注补入原研究目标名单;GET 查询不提交任务。提交前持久化受理凭据,只有真实受理回执才标记排队,网络超时或结果不明不立即重投。完成以真实固定报告引用、买方评议成功、论点及生成时间为准。核对时间可以证明报告已复核,但不能改写报告生成日期。
规则切换追加新修订,记录当时真实截止时间、参数指纹和原因;旧晨版与所有历史版本保留。计划说明随开关切换,旧模式原文保留,新模式明确吸筹参考及三源合议,不再以旧说明误导用户。决定依据见[复盘决定台账 084](复盘决定台账.md)。
## 已核验的发布状态
| 项目 | 实际结果 |
|---|---|
| 发布实例 | 155 的 bridge 服务 |
| 代码版本 | `e5696ee` |
| 生效时间 | 2026-11-04 11:08:27,北京时间 |
| 镜像标签 | `bridge:watch-e5696ee` |
| 实际镜像 ID | `sha256:47c838d131b0dc653024e8dc1b92446ee17ed968ea5d44a509d49e4d0808d58e` |
| 独立发布源码 | `/home/factor/project/akg-factor-bridge-releases/e5696ee` |
| 私有备份目录 | `backups/manual-watch-20261104-e5696ee` |
| 最终候选断网回归 | 35/35 测试文件通过,包含 5 项吸筹参考与 19 项人工关注评析专项 |
| 实际确认门槛 | `CARD_ACCUM_CONFIRM_REQUIRED=false` |
| 实际排序 | `CARD_SORT_BY_QUALITY=true`,`PLAN_RANK_AXIS=quality` |
原数据目录继续挂载,原 `.env` 和原源码 `d9c4b92` 保持不变,通过已核对的独立发布配置切换目标服务。其余 17 个容器保持原标识、镜像和启动时间。本次桥发布未操作其他实例或容器。旧 `4ed46da` 候选只完成准备,未应用到服务;最终实际运行版本为 `e5696ee`。
本接续及 README 的后续文档提交不构建或重建服务,产品运行版本继续保持 `e5696ee`,不能把文档提交号记作运行版本。
## 自然回执与待核验事项
部署后已只读确认运行开关为参考模式,质地排序保持。发布时有 6 条有效人工关注,其中 1 条有可核验的完整报告,5 条尚待补齐;部署前原研究目标表对这 6 条的覆盖为 0/6。此处只记录数量,不记录具体关注名单或财务资料。
11:10:46 的只读探针确认自然调度已产生以下结果,探针无读取错误:
| 核验项 | 自然结果 |
|---|---|
| 真实采集截止时刻 | 2026-11-04 11:10:02,北京时间 |
| 新计划发布时间 | 2026-11-04 11:10:20,北京时间 |
| 计划代码与修订 | `e5696ee`,`publication_kind=revision`,`revision_index=23` |
| 修订原因 | 吸筹改为三源合议参考 |
| 规则 | `accum_confirm_required=false`,`admission_rule=accum-reference-v2-20261104` |
| 资格判决数量 | 候选由 6 增至 21,关注由 11 增至 27 |
| 研究范围与排序 | 主榜 579、观察档 651;质地分布及质量参数与切换前一致,继续按 `quality` 排序 |
| 计划完整性 | 最新入口与固定版本一致,无错误、无待修订条目 |
| 研究目标 | 总计 156 条,主榜 130、观察档 20、人工关注 6;6 条活跃关注全部覆盖 |
| 人工关注评析 | 完整报告 1 条,真实受理排队 3 条,待后续自然调度预算补齐 2 条 |
新版本为 `2026-11-03_4751aa11b99bd46e04605795f66fb775cfa016bcacf9b556d830b651f9b8d3ab`,参数指纹为 `0f97153c6267739c7d79524f343edbf4231db2cafec83bb2434466687f9b881b`。这是以真实盘中截止时刻追加的修订,不是补填晨版。原 15 份晨版指针及所指归档的聚合 SHA-256 仍为 `2901885b8cd5f788b228f01c77076eceaf6b283aee2186416725d8f50d5e8927`,与部署前完全一致。
11:15 自然刷新已受理前一轮剩余的 2 个请求。11:16:34 的最新桥回执为 6 条有效关注、1 条评析完成、5 条真实受理排队,目标覆盖仍为 6/6。当前可读取 2 份历史报告,但只有 1 份满足完成条件;另一份缺少固定引用,不能计为完成。有效报告的真实生成日期与核对日期均为 2026-10-30。
178 的只读核验确认这 5 个真实任务均为 `PENDING`,均在原 `review` 队列中;队列总长度为 66,工作进程正常。没有修改 178 的队列、优先级或任务,也没有重新投递。5 份报告仍未完成,保留排队状态,后续由已有自然任务推进。
11:15 自然周期还追加了 `revision_index=24`,截止时刻为 11:15:02,版本为 `2026-11-03_3d4e638e12bcd73a0d87f6e61acc9671e1bb87812d2c803fa5f8bcf6d077ac89`。参考规则及参数指纹与第 23 次修订一致,候选 21、关注 27、主榜 579、观察档 651 保持,无错误或待修订条目;15 份晨版聚合哈希仍与部署前相同。其他风险参数保持。
原来已有有效报告的 1 条关注,Bionic 已产生真实新模型回执:日研究于 11:12 启动、11:13:38 完成,耗时约 98 秒,数据日为 2026-11-03,研究结论为 `WATCH`;盘中观察于 11:15 启动、11:15:16 完成,耗时约 16 秒,数据日为 2026-11-04。两者均为 `COMPLETE`,没有沿用旧日策略冒充本轮研究。此结果仅证明该条自然研究链已经运行,不代表剩余 5 条均已覆盖,也不是建仓或交易授权。
只读证据为本轮私有验收目录中的 `bridge-natural-1110.json`、`bridge-final.json`、`review-status.json` 和 `bionic-natural-1115.json`。PMS 展示与其他服务发布结果仍由对应接续记录说明。全程未注入信号、模型请求或测试委托制造验收结果。
### 11:40 核验与 11:44 接续结论
用户在前次收尾后明确要求继续跟进剩余 5 条关注。178 的原任务已分别于 11:30:04、11:33:02、11:34:27、11:38:20 和 11:39:48 完成。11:40:16 的只读核验确认 5 个任务均为 `SUCCESS`,任务结果与数据库内同一份固定报告逐一匹配。每份报告均有有效固定引用、`brain_used=true`、`brain_status=ok` 和非空买方论点;生成时间不晚于当前时刻,且不晚于对应任务完成时间。任务返回的定性状态也均为 `ok`。此前缺少引用的旧报告不再被当作本次完成依据。
从真实受理到完成,总等待为 20 分 02.5 秒至 24 分 46.4 秒。单份实际评析耗时为 263.5 至 320.8 秒,主要等待发生在原队列中。原因已只读核实:10:07:20 的原自然批次投递了 30 项完整评析和 60 项轻量复核,工作进程并发为 2;后一个批次直到 11:25:30 执行,因队列仍有任务而标记 `queue_busy`,实际未再投递。11:29 队列降至 1 条,11:40 核验时为 0 条,未发现队列停滞。
近两小时的日志中,170 个单股任务完成,包含 120 个不到一秒的轻量复核和 50 个耗时 201 至 398 秒的完整任务。因此,不能把队列长度乘以完整评析耗时作为等待估计。工作进程采用预取倍数 1 和任务开始时确认,允许 2 项执行、另有 2 项预取;已预取的 `PENDING` 不等于任务丢失。本次未修改 178 队列、优先级、并发或服务,未重新投递。单次模型请求超时也不代表整项评析时限,当前任务未设置整体硬超时。
最终私有证据为 `review-five-complete-final.json`,等待原因的聚合证据为 `review-throughput-summary.json`、`review-queue-position-1129.json` 和 `review-batch-counts-final.json`。Git 文档只保留聚合事实,不记录关注名单、任务编号、报告原文或财务数据。
截至 11:44,买方评析缺口已补齐,后续 5 条日研究和盘中观察仍待完成。午间不派发新的这类观察任务,按现有交易时段规则等待 13:00 后自然调度;不为赶验收绕过时段限制。报告完成不等于日研究或盘中观察完成,也不等于交易资格或建仓授权。
### 13:05 新报告期更新与补齐核验
13:01 的只读状态显示,原来已有有效报告的 1 条关注从评析完成转为排队,当前有效研究来源暂由 6 条降为 5 条。原因不是关注期限或缓存过期。12:05:02 的原自然批次将该对象按轻量复核投递,未请求买方评议或定性模型;执行时发现报告期从 `2026Q2` 更新为 `2026Q3`,于 12:58:42 生成了新期报告。新报告有固定引用,但尚无买方评议和论点,因此不能作为完整评析继续使用。旧期完整报告仍然保留,没有被删除。
代码核对表明,轻量复核的完整标志保护读取同一期、同一版本的已有记录。新期当时没有对应行,因而不会继承旧期的买方评议。桥依据最新报告降为待补齐,并于 13:00:01 自然受理一次完整评析请求。13:03:55 采样时该任务为 `STARTED`;这是状态采样时间,不是任务开始时间。任务于 13:03:57.749 返回 `SUCCESS`,实际执行 236.0 秒,从受理到完成为 236.5 秒,对应约 13:00 开始执行。
13:05:27 已逐项核对新期固定报告与真实任务结果一致,`brain_used=true`,买方评议和定性状态均为 `ok`,固定引用及买方论点有效。报告生成时刻为 13:03:57.737,早于任务完成且不晚于核验时刻。13:03:55 的队列和预取检查未发现该对象的重复任务,原批次的在途凭据也已清理;本次没有手工重投、改队列或调整服务。
其余 5 条在 13:04:55 的只读核验中,最新记录仍是上午已完成的同一批固定报告,均有完整评议,没有循环降级。同一期普通复核会保留已完成标志;后续若出现新报告期、实际证据变化或新的评析失败,仍须按新结果核对,不能保证永久沿用旧状态。旧完整报告可以作为历史资料,但不能伪装成对新一期材料的完整判断。
报告引用改变后,上午该对象的旧日研究和盘中观察回执仅保留为历史,不再作为新报告版本的完成凭据。当前须由原自然调度重新产生与新报告引用一致的回执。其余 5 条的日研究及盘中观察最终判收仍待补录。
本次私有证据为 `original-watch-report-diagnostic-1305.json`、`five-report-stability-1305.json` 和 `original-watch-newperiod-complete.json`。这里只记录报告版本与处理状态,不记录关注名单、任务编号或财务原文。
### 13:21 日研究完成与分钟行情阻塞
午后自然调度已确认全部 6 条关注的日研究为 `COMPLETE`。原来缺报的 5 条现已完成买方评析和日研究;午间更新报告期的 1 条也已按新报告继续研究。上午旧报告对应的完成回执仍只作为历史保留。
13:18、13:21 的自然盘中任务已出现 `UNAVAILABLE`。只读核验发现,分钟行情源 `192.168.18.208:6379` 的 Redis 数据库 13 中,这 6 条关注的行情都停在 11:30。记录按时间正序排列,最大时间即最后一条时间,上海时区解释正常;不是取错末条或时区转换导致的误判。任务在真实行情新鲜度检查时停止,尚未调用模型,不存在用午前价格生成午后研究结论的情况。
当前阻塞在分钟行情没有继续更新。已向用户核实分钟采集项目和任务归属,尚未对采集端执行变更。没有放宽新鲜度阈值、改队列、补造行情或通过重投绕过检查。盘中完整判收仍未通过,最终 6 条任务的逐项状态与计数待后续真实回执补录。
## 回退边界
回退仅限本次 155 bridge 服务和本次明确变更的规则配置,使用私有备份中的原镜像、挂载与配置恢复;不重建其他 17 个容器,不更改原 `.env` 或原源码。需要恢复吸筹确认规则时将 `CARD_ACCUM_CONFIRM_REQUIRED` 恢复为开启,通过正常修订机制追加新的恢复版本,不把旧文件覆盖到最新计划。
报告、人工关注登记、独立评析受理状态、研究目标、任务队列、计划版本、晨版及真实回执均须保留。回退不删除报告、不清状态、不强杀在途模型任务,不以重投掩盖受理结果不明;恢复后继续只读核对既有结果。涉及其他服务或 188 真实 PMS 的变化须另按授权范围处理。
## 14:07恢复结果与接续动作
13:33:36六条分钟源已恢复至13:32或13:33。用户说明行情请求可能超时,后续可按需回填;本次没有更改未知的外部采集服务,也没有改变行情真实时间或放宽新鲜度。第六条取得新鲜行情后,因辅助模型空认证头而失败,请求未取得模型答复。
Bionic于13:48只更新三个已授权服务,修复空密钥请求头,并让明确未调用模型的数据等待在行情恢复后沿原时钟继续。旧失败回执、已耗次数、模型冷却和预算保留。开发机及候选16组离线检查通过。前五条于13:48至14:00自然取得新盘中结果,14:03只读确认六份报告和每日研究有效、五条盘中完成,报告引用均匹配。第六条仍等待14:33原冷却到期,不人为重投。
155仅网页服务于14:06更新为pms:watch-flow-67b0277。左侧统一原时间、股票、类别和方向,详情保留实际进度及理由。桌面和窄屏真实响应复现通过;这是隔离浏览器复现,不是真实登录验收。其他17容器与私有配置保持,桥继续运行e5696ee,没有重建或改队列。本次跟进不新增长期观察或自动化,最终自然结果另行补录。
## 14:34最终自然结果
最后1条于14:33:00.106沿原调度登记,14:33:00.127开始,14:33:19.519完成。实际约19.39秒,结论为OBSERVE,new_model及model_called均为true。原失败的一小时冷却完整保留,没有人为重投。
14:34:02的只读核验确认全部6条买方评析有效、6条每日和6条盘中均为COMPLETE,报告引用均匹配当前版本。每日实际数据日为11月3日,结论均为WATCH;盘中数据日为11月4日,实际五条OBSERVE、一条RISK。原五条缺口及午间新报告期对应的研究均已补齐,没有沿用旧报告的回执冒充当前完成。
14:35的188交叉核验确认新任务与当前来源的报告引用、关注版本均一致,旧失败记录保留,最后一股累计3次、全局盘中登记13次。14:34实际响应的桌面和窄屏浏览器复现逐一通过十二个阶段,无写请求、外联或伪造登录会话。私有聚合证据为watch-follow-1434-summary.json、bionic-target-final-1435.json及original-flow-1434-result.json,原始报告和名单不进入Git。
本次跟进完成。桥继续运行e5696ee,文档提交不重建服务;178评析队列始终仅只读检查。外部分钟采集的历史回填本次未改,数据恢复仍要求真实新鲜行情,不以改时间戳或虚构价格通过。研究完成不等于交易资格或建仓授权,不新增长期观察或自动化。

View File

@ -882,13 +882,3 @@
研究池从该已发布版本取 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 部署、真实评析受理与完成、自然日研究及盘中观察仍须在发布阶段逐项判收,不注入交易制造结果。

78
plan.py
View File

@ -21,7 +21,6 @@ from __future__ import annotations # 注解不在定义时求值:开发机
import datetime as dt
import json
import os
import re
import pandas as pd
@ -160,15 +159,12 @@ def _rerank_by_axis(ranked, cards: dict, axis: str, stale_days: int, has_tier: b
def _key(item):
k = item[0]
s = float(item[1])
available = pd.notna(s)
c = cards.get(k) or {}
band = c.get("quality_band")
if band is None:
band = card.quality_band(c.get("company_review"), stale_days)
pointed = bool((c.get("gates") or {}).get("pointed"))
if not available:
group, s = -float('inf'), -float('inf')
elif has_tier:
if has_tier:
tier = int((s - 190.0) // 20)
group = s - 200.0 - tier * 20.0 # 剥掉档位:传导档位不进次序
else:
@ -377,7 +373,7 @@ def valuations_for(codes: list, ds: str) -> dict:
def _assemble_cards(ds: str, codes: list, ev: dict, upside: pd.Series,
mkt_days: set, risk: set | None = None, user_candidates=None) -> tuple[dict, list]:
mkt_days: set, risk: set | None = None) -> tuple[dict, list]:
"""候选卡装配(2026-09-02 方案第 2.2 节第三项):对档位表里的全部票(主榜与观察档,
裁剪之前)读三路证据、逐票判决。规则在 card.py,取数在 sources.py,这里只做对齐。
@ -433,7 +429,7 @@ def _assemble_cards(ds: str, codes: list, ev: dict, upside: pd.Series,
evd = {"pointed": bool(mv or e), "theme": theme, "n_sources": n_sources,
"chain_fit": (mv or {}).get("chain_fit"),
"pct0": d.get("pct0"), "covered": up is not None, "upside": up,
"risk_name": k in risk, "user_selected": k in (user_candidates or {}),
"risk_name": k in risk,
"accum_state": n.get("accum_state"), "accum_score": n.get("accum_score"),
"accum_age": n.get("accum_age"), "y_signal": n.get("signal"),
"stale_snapshot": stale, "logic": logic.get(k) or []}
@ -446,7 +442,6 @@ 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,
@ -506,7 +501,7 @@ def _assemble_cards(ds: str, codes: list, ev: dict, upside: pd.Series,
def collect(date: str | None = None, top: int = 20, obs_top: int = 10,
theme_cap: int = 5, user_candidates=None) -> dict:
theme_cap: int = 5) -> dict:
"""装配一天的计划为结构化字典。数据缺失抛 RuntimeError(api 侧转 404)。
2026-09-02 起附带候选卡:main / observe 的装配、排序、裁剪一字不动(下游 PMS 只读
@ -534,35 +529,16 @@ def collect(date: str | None = None, top: int = 20, obs_top: int = 10,
names = _names()
ev, mkt_days = _evidence(ds)
import user_candidates as uc
score = score[[bool(re.fullmatch(r'(SH(?:60|68)\d{4}|SZ(?:00|30)\d{4})', str(k))) for k in score.index]]
selected = {uc.normalize(r['code']): r for r in (user_candidates or [])}
if selected:
# 完整证券名称随真实修订录制,重放时不回源,也不补造历史名称。
manual_names = plan_inputs.read('user_candidates.catalog', uc.catalog)
names = dict(names)
for code in selected:
if manual_names.get(code):
names[code] = manual_names[code]
ordinary = set(score.index)
extras = [k for k in selected if k not in ordinary]
main = score[score >= _MAIN_MIN].sort_index().sort_values(ascending=False, kind='mergesort')
obs = score[score < _MAIN_MIN].sort_index().sort_values(ascending=False, kind='mergesort')
if extras:
main = pd.concat([main, pd.Series({k: float('nan') for k in extras})])
score = pd.concat([score, pd.Series({k: float('nan') for k in extras})])
generated_at = dt.datetime.now().isoformat(timespec="seconds")
try: # 风险名单只读一次:候选卡与升降档原因共用
import factors
risk = plan_inputs.factor_read('_risk_set') or set()
except Exception: # noqa: BLE001
risk = set()
if selected and config.EXCLUDE_RISK_NAMES:
risk = set(risk) | {k for k in selected
if str(names.get(k) or '').replace(' ', '').startswith(factors._RISK_PREFIXES)
or str(names.get(k) or '').endswith('退')}
cards, segments_pointed = _assemble_cards(
ds, list(main.index) + list(obs.index), ev, upside, mkt_days, risk=risk, user_candidates=selected)
ds, list(main.index) + list(obs.index), ev, upside, mkt_days, risk=risk)
# 排序轴(2026-09-17):拿到评析后在主榜与观察档这两个分数序列上重排一次。
# 下面的 _pick 出接口、_full_rows 出复盘快照、快照又喂逐票逻辑状态入库与评析目标名单——
@ -606,10 +582,10 @@ def collect(date: str | None = None, top: int = 20, obs_top: int = 10,
evidence = {"theme": c["theme"], "n_sources": c.get("n_sources"),
"moved_ratio": None, "source": "moved_view"}
r = {"rank": rank, "code": k, "name": names.get(k),
"score": round(float(s), 2) if pd.notna(s) else None,
"score": round(float(s), 2),
# 调整分只随行展示、供排序追溯;档位标签仍按原始 score 解码(工作包四)
"score_adj": round(
float(s) + _quality_bonus(c.get("company_review"), config.PLAN_QUALITY_BONUS), 2) if pd.notna(s) else None,
float(s) + _quality_bonus(c.get("company_review"), config.PLAN_QUALITY_BONUS), 2),
"evidence": evidence,
"heat": _val(heat, k), "upside": _val(upside, k)}
# 排序轴四键(2026-09-17):质地带、主轴名、是否被指向(候选卡门槛一)、旧序全量名次。
@ -622,7 +598,7 @@ def collect(date: str | None = None, top: int = 20, obs_top: int = 10,
r["pointed"] = bool((c.get("gates") or {}).get("pointed"))
if config.PLAN_RANK_AXIS == "quality":
r["rank_old"] = rank_old_map.get(k)
if with_tier and pd.notna(s):
if with_tier:
r["tier"] = _tier_label(s)
if c:
# 2026-09-03 新增只联入:basis(判决依据一句话)、logic(因果论断带出处的文字行)、
@ -655,11 +631,6 @@ def collect(date: str | None = None, top: int = 20, obs_top: int = 10,
"confirm": c.get("confirm"), "failed_gates": c.get("failed_gates"),
"chain_fit": c.get("chain_fit"),
"logic_claims": c.get("logic_claims") or []})
if k in selected:
r['user_candidate'] = selected[k]
r['user_required'] = k not in ordinary or not r['pointed']
if not names.get(k):
r.update(verdict=card.VERDICT_SHOW, basis='证券资料尚未齐全,暂不参与交易')
return r
def _full_rows(ranked: pd.Series, with_tier: bool) -> list:
@ -756,7 +727,6 @@ def collect(date: str | None = None, top: int = 20, obs_top: int = 10,
for v in (card.VERDICT_CANDIDATE, card.VERDICT_WATCH, card.VERDICT_SHOW)}
result = {
"date": ds,
"user_candidates": list(selected.values()),
"generated_at": generated_at,
"plan_version": version.git_short_rev(),
"counts": {"main": int(len(main)), "observe": int(len(obs)),
@ -776,22 +746,14 @@ 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,
"logic_per_stock": config.LOGIC_CLAIMS_PER_STOCK,
"rules": ("候选=环节被指向∧当日涨幅达标∧券商覆盖且非ST∧明确吸筹∧无硬风险;"
"关注=三门槛全过∧无硬风险∧确认线缺失或陈旧(系统无法判断,交人裁决);"
"其余仅展示(只差覆盖、潜在吸筹等非明确状态都不升格,台账 013);"
"因果论断只展示不进判决" if config.CARD_ACCUM_CONFIRM_REQUIRED else
"质地排序不变,候选须满足现行选股资格、覆盖及风险条件;"
"吸筹仅作参考,非明确、潜在、缺评分或陈旧本身不否决;"
"高位派发及其他真实风险仍拦截,质地差仍按现行规则降为关注;"
"建仓看基本面、技术面和择时三源合议,由PMS按命令、风控与现行自决档处理;"
"因果论断只展示不进判决")},
"rules": "候选=环节被指向∧当日涨幅达标∧券商覆盖且非ST∧明确吸筹∧无硬风险;"
"关注=三门槛全过∧无硬风险∧确认线缺失或陈旧(系统无法判断,交人裁决);"
"其余仅展示(只差覆盖、潜在吸筹等非明确状态都不升格,台账 013);"
"因果论断只展示不进判决"},
"card_counts": card_counts,
"candidates": _by_verdict(card.VERDICT_CANDIDATE),
"watch": _by_verdict(card.VERDICT_WATCH),
@ -986,8 +948,8 @@ def render_md(d: dict) -> str:
L.append("| # | 代码 | 名称 | 总分 | 档位 | 传导证据 | 热度 | 预期空间 |")
L.append("|---|------|------|------|------|----------|------|----------|")
for r in d["main"]:
L.append(f"| {r['rank']} | {r['code']} | {r['name'] or '—'} | {_fmt_num(r['score'])} "
f"| {r.get('tier') or '—'} | {_fmt_ev(r['evidence'])} "
L.append(f"| {r['rank']} | {r['code']} | {r['name'] or '—'} | {r['score']:.1f} "
f"| {r['tier']} | {_fmt_ev(r['evidence'])} "
f"| {_fmt_num(r['heat'])} | {_fmt_pct(r['upside'])} |")
L.append("")
@ -998,7 +960,7 @@ def render_md(d: dict) -> str:
L.append("| # | 代码 | 名称 | 分 | 传导证据 | 热度 |")
L.append("|---|------|------|----|----------|------|")
for r in d["observe"]:
L.append(f"| {r['rank']} | {r['code']} | {r['name'] or '—'} | {_fmt_num(r['score'])} "
L.append(f"| {r['rank']} | {r['code']} | {r['name'] or '—'} | {r['score']:.1f} "
f"| {_fmt_ev(r['evidence'])} | {_fmt_num(r['heat'])} |")
L.append("")
@ -1084,7 +1046,7 @@ def pick_rows(rows, n: int, theme_cap: int, uncapped_no_theme=None) -> list:
def from_snapshot(date: str | None = None, top: int = 20, obs_top: int = 10,
theme_cap: int = 5, decision_id=None, include_user_candidates=False) -> dict:
theme_cap: int = 5, decision_id=None) -> dict:
"""从当日 JSON 快照读计划,按请求参数截取。**不做任何装配、不查任何库。**
为什么要这条路(2026-09-10,台账 057): collect 每次请求都现场装配整池,实测三十三秒,
@ -1101,8 +1063,6 @@ def from_snapshot(date: str | None = None, top: int = 20, obs_top: int = 10,
ds = date or (decision_id[:10] if decision_id else plan_versions.latest_date(config.PLAN_SNAPSHOT_DIR))
path = os.path.join(config.PLAN_SNAPSHOT_DIR, f"plan_{ds}.json")
snap = plan_versions.load(config.PLAN_SNAPSHOT_DIR, ds, decision_id)
import user_candidates as uc
snap = uc.consumer_view(snap, include_user_candidates)
if str(snap.get("date") or "") != str(ds):
raise RuntimeError(f"快照里的数据日 {snap.get('date')} 与请求的 {ds} 对不上: {path}")
full_main, full_obs = snap.get("main"), snap.get("observe")
@ -1147,12 +1107,10 @@ def _generate(date, top, obs_top, theme_cap):
write_published_md(published)
print(f"复用已发布计划 {ds},未重新采集输入")
return os.path.join(config.PLAN_SNAPSHOT_DIR, f"plan_{ds}.md")
import user_candidates as uc
selected = uc.active(config.PLAN_SNAPSHOT_DIR)
bundle = plan_inputs.Bundle(params=plan_inputs.effective_config(config.module))
try:
with bundle.use():
data = collect(ds, top, obs_top, theme_cap, **({"user_candidates": selected} if selected else {}))
data = collect(ds, top, obs_top, theme_cap)
data['market'] = sources.market_context(data['date'])
except RuntimeError as e:
raise SystemExit(str(e))
@ -1168,7 +1126,7 @@ def _generate(date, top, obs_top, theme_cap):
"shown_params": {"top": top, "obs_top": obs_top, "theme_cap": theme_cap}}
jpath = os.path.join(config.PLAN_SNAPSHOT_DIR, f"plan_{data['date']}.json")
snap = plan_versions.publish(config.PLAN_SNAPSHOT_DIR, snap,
{'records': bundle.records, 'market': data['market'], 'regime': data.get('regime'), 'user_candidates': selected},
{'records': bundle.records, 'market': data['market'], 'regime': data.get('regime')},
bundle.params, cutoff_at=bundle.cutoff_at, reason='晨版生成')
text = write_published_md(snap)
# ---- 逐票日频逻辑状态表(2026-09-07 第三件桥侧前置):只在这一次生成里写,/plan 的实时重算

View File

@ -43,31 +43,7 @@ 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)
candidates_changed = selected != inputs.get('user_candidates', [])
if candidates_changed:
pending.update(r['code'] for r in selected + inputs.get('user_candidates', []))
inputs['user_candidates'] = selected
pv.health(root, day, pending_codes=sorted(pending), error=None)
if selected and not any(r['name'] == 'user_candidates.catalog' for r in inputs['records'].values()):
# 旧发布版尚未录制完整证券名单时,作为本次真实修订的新输入补齐。
pending.update(r['code'] for r in selected)
pv.health(root, day, pending_codes=sorted(pending), error=None)
catalog_bundle = pi.Bundle(cutoff_at=now.isoformat())
with catalog_bundle.use():
pi.read('user_candidates.catalog', uc.catalog)
inputs['records'].update(catalog_bundle.records)
for rec in inputs['records'].values():
if rec['name'] != 'sources.company_reviews':
continue
@ -87,28 +63,20 @@ 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'] and not policy_changed:
if pv.digest(inputs) == old['decision']['input_hash']:
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=params, cutoff_at=now.isoformat())
if candidates_changed:
# 原有调用继续读冻结输入;新增股票带来的新取数在本次真实修订中录制。
bundle.records = copy.deepcopy(inputs['records'])
bundle = pi.Bundle(records=inputs['records'], params=env['params'], cutoff_at=now.isoformat())
shown = old.get('shown_params') or {'top': 20, 'obs_top': 10, 'theme_cap': 5}
with bundle.use():
data = plan.collect(day, **shown, **({'user_candidates': selected} if selected else {}))
inputs['records'] = bundle.records
data = plan.collect(day, **shown)
full = data.pop('_full')
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'))
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)
published = pv.publish(root, data, inputs, env['params'], cutoff_at=now.isoformat(),
reason='评析更新' if pending else '市场区制更新')
plan.write_published_md(published)
return {'status': 'published', 'decision': published['decision']}
except Exception as e:

View File

@ -233,7 +233,7 @@ def publish(root, plan, inputs, params, *, cutoff_at, reason):
return p
def stock_check(root, code, include_user_candidates=False):
def stock_check(root, code):
"""只读完整发布文件的一只股票。不存在与取数失败严格区分;不按展示名次裁剪。"""
if not re.fullmatch(r'(SH|SZ|BJ)\d{6}', code):
raise ValueError('股票代码无效')
@ -243,24 +243,20 @@ def stock_check(root, code, include_user_candidates=False):
raise FileNotFoundError('无已发布计划')
path = Path(root) / f'plan_{day}.json'
health_path = Path(root) / 'versions' / day / 'health.json'
candidates_path = Path(root) / 'user_candidates.json'
def identity(p):
try:
s = p.stat()
return (s.st_dev, s.st_ino, s.st_size, s.st_mtime_ns, s.st_ctime_ns)
except FileNotFoundError:
return None
before = (identity(path), identity(health_path), identity(candidates_path))
before = (identity(path), identity(health_path))
published = load(root, day)
state = health(root, day)
import user_candidates as uc
state = dict(state, pending_codes=sorted(set(state.get('pending_codes') or []) | set(uc.live_pending(root, published))))
if (day != latest_date(root) or before != (identity(path), identity(health_path), identity(candidates_path))):
if (day != latest_date(root) or before != (identity(path), identity(health_path))):
continue
if (published.get('date') != day or not (published.get('decision') or {}).get('id')
or not all(isinstance(published.get(b), list) for b in ('main', 'observe'))):
raise ValueError('完整发布计划不可核验')
published = uc.consumer_view(published, include_user_candidates)
rows = {b: [r for r in published[b] if r.get('code') == code] for b in ('main', 'observe')}
count = sum(map(len, rows.values()))
if count > 1:

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 / manual)、rank、name。
表 t_akg_review_targets:plan_date、ts_code(点后缀式 600000.SH)、source(main / observe)、rank、name。
幂等:删该日行再整批插。写失败不拦计划(try 包住)。"""
from __future__ import annotations
@ -35,17 +35,13 @@ def to_dot(code: str) -> str:
return s
def build_rows(ds: str, main_rows: list, obs_rows: list, user_rows=None) -> list[dict]:
from user_candidates import normalize
def build_rows(ds: str, main_rows: list, obs_rows: list) -> list[dict]:
seen: set = set()
out: list[dict] = []
for src, rows in (("main", main_rows), ("observe", obs_rows), ("manual", user_rows)):
for src, rows in (("main", main_rows), ("observe", obs_rows)):
for i, r in enumerate(rows or [], 1):
try:
code = to_dot(normalize(r.get('code')))
except ValueError:
continue
if code in seen:
code = to_dot(str(r.get("code") or ""))
if len(code) != 9 or 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]})
@ -93,18 +89,15 @@ 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, user_rows=None) -> dict:
def persist(ds: str, snap: dict, write=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],
snap.get('user_candidates', []) if user_rows is None else user_rows)
rows = build_rows(ds, main_sel, (snap.get("observe") or [])[:TOP_OBS])
(write or save)(ds, rows)
n_main = sum(1 for r in rows if r["source"] == "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}
print(f" 评析目标名单 {ds}:主榜 {n_main},观察 {len(rows) - n_main},写入 {TABLE}")
return {"date": ds, "rows": len(rows), "main": n_main}
def from_plan_file(ds: str, plan_dir: str | None = None, write=None) -> dict:

6
run.py
View File

@ -238,12 +238,6 @@ 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, include_check=False) -> dict:
def company_reviews(codes, ds: str, *, read_pg=None, cutoff_at=None, strict=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,8 +1185,7 @@ 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')
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 + " "
df = rp("SELECT DISTINCT ON (ts_code) ts_code, period, review_version, grades, summary, brain_used, brain_status, ran_at "
"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
@ -1210,14 +1209,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:
@ -1244,15 +1243,6 @@ 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

View File

@ -1,121 +0,0 @@
"""离线:吸筹只作参考及同输入规则修订,全部来源使用内存替身。"""
import copy
import datetime as dt
import tempfile
import unittest
from contextlib import ExitStack
from unittest.mock import patch
import pandas as pd
import test_api_support
import card
import config
import plan
import plan_refresh
import plan_versions as pv
class ReferenceTests(unittest.TestCase):
def test_published_rule_description_matches_confirmation_mode(self):
legacy = ("候选=环节被指向∧当日涨幅达标∧券商覆盖且非ST∧明确吸筹∧无硬风险;"
"关注=三门槛全过∧无硬风险∧确认线缺失或陈旧(系统无法判断,交人裁决);"
"其余仅展示(只差覆盖、潜在吸筹等非明确状态都不升格,台账 013);"
"因果论断只展示不进判决")
with ExitStack() as stack:
for name, value in (('_factor', pd.Series([240.], index=['SH600001'])),
('_latest_date', None), ('_prev_date', None),
('_names', {}), ('_evidence', ({}, set())),
('_assemble_cards', ({}, []))):
stack.enter_context(patch.object(plan, name, return_value=value))
stack.enter_context(patch.object(plan.plan_inputs, 'factor_read', return_value=set()))
stack.enter_context(patch.object(plan.version, 'git_short_rev', return_value='test'))
for enabled in (True, False, True):
with self.subTest(confirm_required=enabled), patch.object(config, 'CARD_ACCUM_CONFIRM_REQUIRED', enabled):
params = plan.collect('2026-11-03')['card_params']
self.assertEqual(params['accum_confirm_required'], enabled)
if enabled:
self.assertEqual(params['admission_rule'], 'accum-confirm-v1')
self.assertEqual(params['rules'], legacy)
else:
self.assertEqual(params['admission_rule'], 'accum-reference-v2-20261104')
for phrase in ('质地排序不变', '吸筹仅作参考', '非明确、潜在、缺评分或陈旧本身不否决',
'现行选股资格', '高位派发及其他真实风险仍拦截',
'基本面、技术面和择时三源合议', '现行自决档'):
self.assertIn(phrase, params['rules'])
self.assertNotIn('∧明确吸筹', params['rules'])
self.assertNotIn('交人裁决', params['rules'])
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

@ -20,8 +20,7 @@ except ImportError:
fa.FastAPI = fa.APIRouter = Router
fa.Request = type('Request', (), {})
fa.HTTPException = HTTPException
fa.Body = fa.Header = fa.Query = lambda default=None, **kw: default
fa.BackgroundTasks = type('BackgroundTasks', (), {'add_task': lambda self, *a, **kw: None})
fa.Header = fa.Query = lambda default=None, **kw: default
sys.modules['fastapi'] = fa
resp = types.ModuleType('fastapi.responses')
resp.PlainTextResponse = lambda content, **kw: content

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_user_research'):
'test_plan_rank_switch'):
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(__file__).with_name('xxl.py').read_text())
tree = ast.parse(Path('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(__file__).with_name('api.py').read_text())
tree = ast.parse(Path('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

@ -1,199 +0,0 @@
"""用户候选登记、原有门槛与版本闭环的断网回归。"""
import copy
import datetime as dt
import json
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch, Mock
from contextlib import ExitStack
import pandas as pd
import test_api_support
import user_candidates as uc
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'
PAYLOAD = {'codes': ['600001.SH'], 'reason': '行业需求变化', 'expires_on': '2026-11-10'}
USER_NAMES = dict(zip(
['SZ300133', 'SZ300364', 'SZ300182', 'SH603533', 'SZ300291', 'SZ301052'],
['华策影视', '中文在线', '捷成股份', '掌阅科技', '百纳千成', '果麦文化']))
class CandidateTests(unittest.TestCase):
def setUp(self):
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'):
with self.assertRaises(ValueError):
uc.save(self.root, dict(PAYLOAD, codes=['600001', code]), '甲', NOW)
self.assertEqual(uc.read(self.root)['rows'], [])
r = uc.save(self.root, dict(PAYLOAD, codes=['600001', 'SH600001', '600001.SH']), '甲', NOW)
self.assertEqual(r['added'], 1)
self.assertEqual(uc.save(self.root, PAYLOAD, '乙', NOW)['existing'], 1)
self.assertEqual(uc.read(self.root)['rows'][0]['created_by'], '甲')
def test_pasted_names_mixed_codes_and_separators_save_canonical_codes(self):
text = '华策影视 中文在线,捷成股份\n掌阅科技;百纳千成、果麦文化'
result = uc.save(self.root, dict(PAYLOAD, codes=[text, '300133.SZ']), '甲', NOW, names=USER_NAMES)
self.assertEqual(result['added'], 6)
self.assertEqual([r['code'] for r in uc.read(self.root)['rows']], list(USER_NAMES))
self.assertEqual([r['name'] for r in uc.listing(self.root, NOW)['rows']], list(USER_NAMES.values())[::-1])
self.assertEqual(uc.save(self.root, dict(PAYLOAD, codes=text), '甲', NOW, names=USER_NAMES)['existing'], 6)
def test_unmatched_or_ambiguous_name_does_not_partially_save(self):
names = dict(USER_NAMES, SH600001='同名', SZ000001='同名')
for value, message in [('华策影视 不存在的股票', '未找到沪深 A 股'),
('华策影视 同名', '对应多只股票'),
('华策影视 中文', '未找到沪深 A 股'),
('华策影视 920001', '仅支持沪深 A 股'),
(' '.join(['华策影视'] * 31), '1 至 30')]:
with self.assertRaisesRegex(ValueError, message):
uc.save(self.root, dict(PAYLOAD, codes=[value]), '甲', NOW, names=names)
self.assertFalse(Path(self.root, 'user_candidates.json').exists())
def test_catalog_reads_full_listed_shanghai_shenzhen_universe(self):
import db
rows = [{'gp_code_two': c[2:]+'.'+c[:2], 'gp_name': n} for c, n in USER_NAMES.items()]
rows += [{'gp_code_two': '920001.BJ', 'gp_name': '排除示例'}, {'gp_code_two': '510300.SH', 'gp_name': '基金示例'}]
with patch.object(db, 'read_mysql', return_value=pd.DataFrame(rows)) as read:
self.assertEqual(uc.catalog(), USER_NAMES)
self.assertEqual(read.call_args.args[0], 'heat')
self.assertIn("list_status='L'", read.call_args.args[1])
self.assertIn("gp_code_two LIKE '%.SH' OR gp_code_two LIKE '%.SZ'", read.call_args.args[1])
def test_search_and_add_use_full_catalog_without_industry_membership(self):
import api
with patch.object(config, 'XXL_TRIGGER_KEY', 'test-secret'), patch.object(config, 'PLAN_SNAPSHOT_DIR', self.root), \
patch.object(uc, 'catalog', return_value=USER_NAMES), patch.object(plan, '_names', side_effect=AssertionError('不能依赖行业池')):
self.assertEqual(api.search_user_candidates('中文在线')['items'], [{'code': 'SZ300364', 'name': '中文在线'}])
background = Mock()
expiry = (dt.datetime.now(uc.BJ).date() + dt.timedelta(days=1)).isoformat()
result = api.add_user_candidates(background, dict(PAYLOAD, codes=list(USER_NAMES.values()), expires_on=expiry), x_job_key='test-secret')
self.assertEqual(result['added'], 6)
background.add_task.assert_called_once_with(uc.refresh_saved)
def test_expiry_remove_and_readd_do_not_erase_history(self):
uc.save(self.root, PAYLOAD, '甲', NOW)
old = uc.active(self.root, NOW)[0]
pub = {'user_candidates': [old]}
uc.remove(self.root, old['id'], '甲', NOW)
self.assertEqual(uc.live_pending(self.root, pub, NOW), ['SH600001'])
self.assertEqual(uc.remove(self.root, old['id'], '甲', NOW)['revision'], 2)
uc.save(self.root, PAYLOAD, '甲', NOW)
self.assertNotEqual(uc.active(self.root, NOW)[0]['id'], old['id'])
self.assertEqual(len(uc.read(self.root)['rows']), 2)
later = NOW + dt.timedelta(days=8)
self.assertEqual(uc.active(self.root, later), [])
def test_manual_discovery_never_fakes_transmission_or_other_gates(self):
evidence = {'pointed': False, 'user_selected': True, 'pct0': 4,
'covered': True, 'upside': .2, 'accum_state': '明确吸筹', 'accum_age': 0}
result = card.judge(evidence)
self.assertEqual(result['verdict'], card.VERDICT_CANDIDATE)
self.assertFalse(result['gates']['pointed'])
for change in ({'covered': False}, {'upside': -.2}, {'risk_name': True},
{'pct0': 0}, {'y_signal': 'SELL'}, {'accum_state': '潜在吸筹'}):
self.assertEqual(card.judge(dict(evidence, **change))['verdict'], card.VERDICT_SHOW)
self.assertEqual(card.judge(dict(evidence, user_selected=False))['verdict'], card.VERDICT_SHOW)
def test_mutations_require_key_and_do_not_publish_inline(self):
import api
with patch.object(config, 'XXL_TRIGGER_KEY', 'test-secret'), patch.object(config, 'PLAN_SNAPSHOT_DIR', self.root):
with self.assertRaises(api.HTTPException):
api.add_user_candidates(None, PAYLOAD, x_job_key='bad')
self.assertFalse(Path(self.root, 'user_candidates.json').exists())
def test_old_consumers_exclude_user_source_before_top_and_cache_is_separate(self):
import api
source={'id':'a'*32,'code':'SH600001'}
row={'code':'SH600001','score':250,'rank':1,'research_rank':1,'evidence':{},
'user_candidate':source,'user_required':True,'verdict':'候选'}
ordinary={'code':'SH600002','score':240,'rank':2,'research_rank':2,'evidence':{},'verdict':'候选'}
published={'date':DAY,'decision':{'id':'v-opt-in'},'main':[row,ordinary],'observe':[],
'user_candidates':[source],'candidates':[row,ordinary],'watch':[],
'counts':{'main':2,'observe':0}}
original=copy.deepcopy(published)
with patch.object(config,'PLAN_SNAPSHOT_DIR',self.root),patch.object(pv,'load',return_value=published):
default,_=api._plan_cached(DAY,1,0,0,True)
opted,_=api._plan_cached(DAY,1,0,0,True,include_user_candidates=True)
again,hit=api._plan_cached(DAY,1,0,0,False)
self.assertEqual(default['main'][0]['code'],'SH600002')
self.assertEqual(opted['main'][0]['code'],'SH600001')
self.assertEqual(default,again)
self.assertTrue(hit)
self.assertNotIn('user_candidates',default)
self.assertEqual(default['counts']['main'],1)
self.assertEqual(len(default['candidates']),1)
self.assertEqual(original,published)
def test_revision_add_remove_replay_and_frozen_morning(self):
codes = ['SH600001', 'SH600002']
with ExitStack() as stack:
def stub(obj, name, **kw): return stack.enter_context(patch.object(obj, name, **kw))
stub(config, 'PLAN_SNAPSHOT_DIR', new=self.root)
stub(config, 'PLAN_RANK_AXIS', new='quality')
stub(plan, '_factor', side_effect=lambda table, day: pd.Series(
[240.,230.] if 'score' in table else [.3,.2] if 'upside' in table else [2.,2.], index=codes))
stub(plan, '_latest_date', return_value=DAY)
stub(plan, '_prev_date', return_value=None)
stub(plan, '_names', return_value={'SH600001':'甲','SH600002':'乙'})
stub(uc, 'catalog', return_value={'SH600001':'甲','SH600002':'乙','SH600003':'丙'})
stub(plan, '_evidence', return_value=({}, {DAY}))
stub(plan, '_segments_of', return_value={})
stub(factors, '_risk_set', return_value=set())
stub(judgement, 'load_previous', return_value=[])
stub(judgement, 'recent_rows', return_value={})
stub(logic_state_daily, 'history', return_value={})
for name in ('moved_members','broker_reports','logic_claims','broker_actions','close_prices',
'valuation_scenarios','analyst_events','event_day_fields','news_flashes',
'segment_catalysts','catalysts_for_codes'):
stub(sources, name, return_value={})
stub(sources, 'stock_daily', return_value={c:{'pct0':4} for c in codes})
stub(sources, 'night_conclusions', return_value={c:{'accum_state':'明确吸筹','accum_age':0} for c in codes})
stub(sources, 'company_reviews', side_effect=lambda cs,*a,**kw: {c:{'overall':'好','age_days':0,'review_ref':'r'} for c in cs})
bundle = pi.Bundle(params=pi.effective_config(config), cutoff_at='2026-11-03T07:10:00+08:00')
with bundle.use():
data = plan.collect(DAY)
data.update(data.pop('_full'))
with pv.writer(self.root):
morning = pv.publish(self.root,data,{'records':bundle.records,'market':{},'regime':None},
bundle.params,cutoff_at=bundle.cutoff_at,reason='晨版')
frozen = copy.deepcopy(morning)
uc.save(self.root,dict(PAYLOAD,codes=['600001','600003']), '甲', NOW)
self.assertEqual(pv.stock_check(self.root,'SH600001')['refresh_status']['pending_codes'],['SH600001','SH600003'])
result = plan_refresh.refresh(now=NOW)
self.assertEqual(result['status'],'published')
published = pv.load(self.root)
rows = {r['code']:r for r in published['main']}
self.assertEqual(rows['SH600001']['verdict'],'候选')
self.assertFalse(rows['SH600001']['pointed'])
self.assertEqual(rows['SH600001']['score'],240.)
self.assertIsNone(rows['SH600003']['score'])
self.assertEqual(rows['SH600003']['name'], '丙')
self.assertNotIn('tier',rows['SH600003'])
self.assertFalse(pv.stock_check(self.root,'SH600003')['found'])
self.assertTrue(pv.stock_check(self.root,'SH600003',include_user_candidates=True)['found'])
json.dumps(published,allow_nan=False)
self.assertIn('SH600003', Path(self.root, f'plan_{DAY}.md').read_text())
self.assertEqual(pv.load(self.root,DAY,morning=True),frozen)
self.assertEqual(plan_refresh.refresh(now=NOW)['status'],'unchanged')
for source in uc.active(self.root,NOW):
uc.remove(self.root,source['id'],'甲',NOW)
plan_refresh.refresh(now=NOW)
after = pv.load(self.root)
self.assertEqual(after['main'][0]['verdict'],'仅展示')
self.assertNotIn('SH600003',[r['code'] for r in after['main']])
self.assertEqual(pv.load(self.root,DAY,morning=True),frozen)
if __name__ == '__main__':
unittest.main()

View File

@ -1,244 +0,0 @@
"""人工关注评析:所有外部来源与投递均用桩,状态文件仅在临时目录。"""
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

@ -1,220 +0,0 @@
"""用户补充的候选来源。与计划共用文件锁,先保存,再由修订任务发布。"""
from __future__ import annotations
import datetime as dt
import json
import re
import uuid
from pathlib import Path
from zoneinfo import ZoneInfo
import plan_versions as pv
BJ = ZoneInfo('Asia/Shanghai')
def consumer_view(published, include_user_candidates=False):
"""旧调用方只取系统来源;显式声明支持新来源后才返回人工候选。"""
if include_user_candidates or not published.get('user_candidates'):
return published
out = dict(published)
out.pop('user_candidates', None)
for bucket in ('main', 'observe', 'main_shown', 'observe_shown', 'candidates', 'watch'):
if bucket in out:
out[bucket] = [{k: v for k, v in r.items() if k not in ('user_candidate', 'user_required')}
for r in out[bucket] if not r.get('user_required')]
if 'counts' in out:
out['counts'] = dict(out['counts'], main=len(out.get('main', [])), observe=len(out.get('observe', [])))
if 'card_counts' in out:
rows = out.get('main', []) + out.get('observe', [])
out['card_counts'] = {v: sum(r.get('verdict') == v for r in rows) for v in out['card_counts']}
return out
def normalize(value):
value = str(value or '').strip().upper()
if re.fullmatch(r'\d{6}\.(SH|SZ)', value):
value = value[-2:] + value[:6]
elif re.fullmatch(r'\d{6}', value):
value = ('SH' if value.startswith(('60', '68')) else 'SZ') + value
if not re.fullmatch(r'(SH(?:60|68)\d{4}|SZ(?:00|30)\d{4})', value):
raise ValueError('仅支持沪深 A 股,请检查股票代码')
return value
def catalog():
"""使用上市证券基础表,不能把部分行业池当作完整可搜索名单。"""
import db
frame = db.read_mysql('heat',
"SELECT gp_code_two,gp_name FROM gp_code_all WHERE list_status='L' "
"AND (gp_code_two LIKE '%.SH' OR gp_code_two LIKE '%.SZ')")
out = {}
for row in frame.to_dict('records'):
try:
code = normalize(row.get('gp_code_two'))
except ValueError:
continue
name = str(row.get('gp_name') or '').strip()
if name:
out[code] = name
if not out:
raise ValueError('证券名称资料暂不可用,请稍后重试')
return out
def resolve(raw, names=None):
"""批量名称只按完整简称精确匹配;全部解析成功后才允许保存。"""
if isinstance(raw, str):
raw = [raw]
if not isinstance(raw, list) or any(not isinstance(v, str) for v in raw):
raise ValueError('请输入股票名称或代码')
tokens = [v for item in raw for v in re.split(r'[\s,,;;、]+', item.strip()) if v]
if not 1 <= len(tokens) <= 30:
raise ValueError('每次可添加 1 至 30 只股票')
index = None
codes = []
for value in tokens:
try:
code = normalize(value)
except ValueError:
# 明确的证券代码继续走原交易所限制,不尝试按名称解释。
if re.fullmatch(r'(?:(?:SH|SZ|BJ)?\d+(?:\.(?:SH|SZ|BJ))?)', value.upper()):
raise
if index is None:
source = names() if callable(names) else names or {}
index = {}
for candidate, name in source.items():
try:
canonical = normalize(candidate)
except ValueError:
continue
index.setdefault(str(name).strip().upper(), set()).add(canonical)
matches = index.get(value.upper(), set())
if not matches:
raise ValueError(f'未找到沪深 A 股“{value[:40]}”,请检查完整名称或使用代码') from None
if len(matches) != 1:
raise ValueError(f'“{value[:40]}”对应多只股票,请使用代码') from None
code = next(iter(matches))
if code not in codes:
codes.append(code)
return codes
def read(root):
path = Path(root) / 'user_candidates.json'
if not path.exists():
return {'revision': 0, 'rows': []}
state = json.loads(path.read_text())
if not isinstance(state.get('rows'), list) or not isinstance(state.get('revision'), int):
raise ValueError('添加记录暂不可用')
return state
def active(root, now=None):
today = (now or dt.datetime.now(BJ)).astimezone(BJ).date().isoformat()
return [dict(r) for r in read(root)['rows']
if not r.get('removed_at') and r['expires_on'] >= today]
def save(root, payload, actor, now=None, *, names=None):
now = now or dt.datetime.now(BJ)
codes = resolve(payload.get('codes'), names)
reason = str(payload.get('reason') or '').strip()
if not reason or len(reason) > 300:
raise ValueError('请填写添加理由,最多 300 字')
try:
expires = dt.date.fromisoformat(str(payload.get('expires_on') or ''))
except ValueError as exc:
raise ValueError('请选择关注截止日期') from exc
if not now.astimezone(BJ).date() <= expires <= now.astimezone(BJ).date() + dt.timedelta(days=90):
raise ValueError('关注期限应在今天至未来 90 天内')
with pv.writer(root):
state = read(root)
current = {r['code'] for r in active(root, now)}
added = []
for code in codes:
if code in current:
continue
row = {'id': uuid.uuid4().hex, 'code': code, 'reason': reason,
'expires_on': expires.isoformat(), 'created_at': now.isoformat(),
'created_by': str(actor)[:100]}
if isinstance(names, dict) and names.get(code):
row['name'] = names[code]
state['rows'].append(row)
added.append(row)
if added:
state['revision'] += 1
pv.atomic(Path(root) / 'user_candidates.json', state)
mark_pending(root, [r['code'] for r in added])
return {'ok': True, 'added': len(added), 'existing': len(codes) - len(added),
'revision': state['revision']}
def remove(root, identity, actor, now=None):
now = now or dt.datetime.now(BJ)
with pv.writer(root):
state = read(root)
row = next((r for r in state['rows'] if r['id'] == identity), None)
if row is None:
raise ValueError('添加记录不存在,请刷新后重试')
if not row.get('removed_at'):
row.update(removed_at=now.isoformat(), removed_by=str(actor)[:100])
state['revision'] += 1
pv.atomic(Path(root) / 'user_candidates.json', state)
mark_pending(root, [row['code']])
return {'ok': True, 'revision': state['revision']}
def mark_pending(root, codes):
day = pv.latest_date(root)
if day:
state = pv.health(root, day)
pv.health(root, day, pending_codes=sorted(set(state.get('pending_codes') or []) | set(codes)))
def live_pending(root, published, now=None):
"""写后未发布、删除或到期时,即使后台失败也不能继续消费旧人工来源。"""
current = {r['code']: r['id'] for r in active(root, now)}
frozen = {r['code']: r['id'] for r in published.get('user_candidates', [])}
return sorted(c for c in current.keys() | frozen.keys() if current.get(c) != frozen.get(c))
def listing(root, now=None):
now = now or dt.datetime.now(BJ)
state = read(root)
try:
published = pv.load(root) if pv.latest_date(root) else {}
except FileNotFoundError:
published = {}
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 {}
status = ('removed' if source.get('removed_at') else
'expired' if source['expires_on'] < today else
'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'),
**research.get(source['code'], {})})
return {'ok': True, 'rows': rows[:300], 'revision': state['revision']}
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:
logging.getLogger(__name__).exception('用户候选已保存,计划修订待重试')
return {'status': 'pending'}

View File

@ -1,273 +0,0 @@
"""人工关注的独立评析状态:先持久化受理凭据,再投基座;查询绝不派任务。
计划的 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}