Compare commits
No commits in common. "codex/manual-watch-review-20261104" and "main" have entirely different histories.
codex/manu
...
main
24
README.md
24
README.md
|
|
@ -183,7 +183,7 @@ docker compose exec akg-factor-bridge python run.py freeze --date 2026-07-24
|
|||
`source_type` 不是这个字符串,事件因子会被过滤成空(会显式告警),按实际值改
|
||||
`EVENT_SOURCE_TYPES`。
|
||||
|
||||
## HTTP 接口(桥常驻 API,端口 8300)
|
||||
## 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
82
api.py
|
|
@ -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
34
card.py
|
|
@ -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"))}
|
||||
|
|
|
|||
|
|
@ -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"))
|
||||
# 读上一次落定态与近几日原始态时往前看几个自然日。要盖住国庆这种连休八天再加两个周末的空档;
|
||||
|
|
|
|||
|
|
@ -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,带过期和所有者校验。
|
||||
同一凭据只能从待执行原子转为执行中一次。
|
||||
失败冷却六小时;无数据沿用七天复查,三次评议失败沿用原放弃规则。
|
||||
预算沿用索引表的当日登记口径,含失败状态。
|
||||
每次模型调用仍受原单次输出上限约束。
|
||||
这不是服务商账单的逐次计费审计,不能把登记量称为实际费用。
|
||||
排序只决定研究先后,不形成证券评分。
|
||||
报告内容及下游排序由现有逻辑继续处理。
|
||||
|
|
@ -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/。
|
||||
目录保留前后服务状态、原镜像与命令、拉取记录和首批预览。
|
||||
|
|
@ -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评析队列始终仅只读检查。外部分钟采集的历史回填本次未改,数据恢复仍要求真实新鲜行情,不以改时间戳或虚构价格通过。研究完成不等于交易资格或建仓授权,不新增长期观察或自动化。
|
||||
|
|
@ -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
78
plan.py
|
|
@ -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 的实时重算
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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
6
run.py
|
|
@ -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'):
|
||||
|
|
|
|||
20
sources.py
20
sources.py
|
|
@ -1174,7 +1174,7 @@ def catalysts_for_codes(seg_of: dict, cat_by_seg: dict, *, limit: int = 3) -> di
|
|||
# 公司深度评析(2026-09-09 接入方案,台账 053):数据基座 company_review_runs 索引表最新一行的摘要。
|
||||
# 质地由基座代码合成,这里只读不算;报告正文在对象存储,链接给人。表读不到整体缺席不断产。
|
||||
# ---------------------------------------------------------------------------
|
||||
def company_reviews(codes, ds: str, *, read_pg=None, cutoff_at=None, strict=False, 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
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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',
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
@ -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()
|
||||
|
|
@ -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'}
|
||||
273
user_research.py
273
user_research.py
|
|
@ -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}
|
||||
Loading…
Reference in New Issue