diff --git a/DEVLOG.md b/DEVLOG.md index 1446630..8346617 100644 --- a/DEVLOG.md +++ b/DEVLOG.md @@ -2826,3 +2826,9 @@ PMS最终代码56db0fd已推送,155 web/WS/beat为execution-2b1c447,worker 开发机隔离全量和页面三道护栏通过,1440/390/320像素浏览器复现52条真实信号,并用明确标注的离线样例验证关注同类展示及无信号不占行。10:44快照中六只关注没有既有实际信号,未将样例或研究回执冒充自然信号。155候选断网全量ALL SUITES PASS后,10:55:36仅web发布pms:original-signal-e4a7424;其他17个容器完整基线不变,线上页面摘要与验收版一致。 10:56:31确认1640502、近200条连续、待入账及孤儿0、现金数量一致。用户参数、私有配置、挂载、worker和唯一WS保持,188未动。产品提交e4a7424及发布证据分别留档;文档提交不再重建。部署、回退和隔离验证边界见[接续](docs/信号流格式与选股恢复_2026-11-05.md)及[发布证据](docs/evidence/pms_original_signal_release_20261105.json)。 + +## 2026-11-05 12:22 原策略退出纪律实现 + +用户确认手工试探仓不约束后续系统仓位,仓位和网格计算保持。新增第一次有效清仓级信号停买、第二次独立信号全仓退出;买方整体评级好降中、中降差、好降差直接退出。持仓轮次与消息防重独立落表,撤旧卖单后按实际数量清仓,T+1与迟到成交沿原回报收尾,人工清仓和全局暂停优先。 + +发现盘前评级映射遗漏当日四只新仓,增加独立批量只读补齐,执行不等待外部请求。35项隔离专项通过;12:19实际五只持仓补读均与入场评级相同。雷赛智能只承接09:38真实第一次停买,不伪造第二次。全量、候选及定向发布结果后续追加,规则和边界见[退出纪律接续](docs/两次清仓信号与评级下降退出_2026-11-05.md)。 diff --git a/app/core/risk_exit.py b/app/core/risk_exit.py new file mode 100644 index 0000000..437ea9e --- /dev/null +++ b/app/core/risk_exit.py @@ -0,0 +1,108 @@ +"""两次清仓信号与买方评级下降。只识别事实,不生成新的研判。""" +import hashlib +import json +import math +from datetime import datetime, timedelta, timezone + +TZ = timezone(timedelta(hours=8)) +GRADES = {'差': 0, '中': 1, '好': 2} + + +def stamp(value): + try: + if isinstance(value, datetime): + d = value + elif isinstance(value, (int, float)) or str(value).isdigit(): + n = float(value) + d = datetime.fromtimestamp(n / 1000 if n > 100000000000 else n, TZ) + else: + d = datetime.fromisoformat(str(value).replace('Z', '+00:00')) + return d.replace(tzinfo=TZ) if d.tzinfo is None else d.astimezone(TZ) + except (ValueError, TypeError, OverflowError, OSError): + return None + + +def digest(value): + return hashlib.sha256(json.dumps(value, ensure_ascii=False, sort_keys=True, + separators=(',', ':'), allow_nan=False).encode()).hexdigest() + + +def signal_event(sig, *, now, since, threshold=.85, max_age=300): + """真正的清仓级信号才计次。过期、未来、回退结论及无出处不计数。""" + code = str(sig.get('ts_code') or '') + from app.core.command_spec import is_stock_code + if not is_stock_code(code) or not code.endswith(('.SH', '.SZ')): + return None, '证券不在沪深范围' + try: + conf = float(sig.get('confidence')) + except (TypeError, ValueError): + return None, '没有有效置信度' + if (sig.get('action') != 'SELL' or not math.isfinite(conf) or conf < threshold or conf > 1 + or sig.get('is_fallback') not in (None, False, 0, 'false', '0', '')): + return None, '不是有效清仓级结论' + source = sig.get('source') + if source not in ('intraday', 'risk_sell'): + return None, '信号来源不可核实' + reason = ' '.join(str(sig.get('reason') or '').split())[:500] + at = stamp(sig.get('event_time')) + now, start = stamp(now), stamp(since) + if not at or not now or not start or not reason or not sig.get('msg_id'): + return None, '缺少原始信号时间、内容或标识' + if at < start or at > now or (now-at).total_seconds() > max_age: + return None, '信号不在当前有效窗口' + expiry = stamp(sig.get('expires_at')) + if sig.get('expires_at') is not None and (not expiry or now >= expiry): + return None, '信号已过期或期限无效' + producer = str(sig.get('producer_id') or '') + if source == 'intraday' and not producer.startswith('bionic_brain_intraday'): + return None, '不是决策系统盘中研判' + source_id = str(sig.get('signal_id') or '') + # 风控流未提供研判编号,保留原始时间与内容指纹;不把消费时刻当研判时刻。 + key = digest([code, source, source_id or at.isoformat(), reason]) + return {'key': key, 'source': source, 'source_id': source_id, + 'msg_id': str(sig['msg_id']), 'at': at.isoformat(), 'confidence': conf, + 'reason': reason[:500], 'content': digest([code, reason])}, '' + + +def duplicate(events, event, *, mirror_seconds=120): + for old in events: + if old.get('key') == event['key']: + return True + if old.get('source') == event['source'] and old.get('msg_id') == event['msg_id']: + return True + if old.get('source') == event['source'] and event.get('source_id') and old.get('source_id') == event['source_id']: + return True + # 上游两条流没有共同研判编号,文案也可能不同。近时跨流不能证明独立,只记一次。 + if old.get('source') != event['source']: + a, b = stamp(old.get('at')), stamp(event.get('at')) + if a and b and abs((a-b).total_seconds()) <= mirror_seconds: + return True + return False + + +def review_snapshot(review, *, now, stale_days=120): + """只接受可追溯的正式买方评析整体评级;缺失、过期不等于降级。""" + r = review if isinstance(review, dict) else {} + grade, ref = r.get('overall'), str(r.get('review_ref') or '') + at, current = stamp(r.get('report_ran_at')), stamp(now) + if grade not in GRADES or len(ref) != 64 or any(c not in '0123456789abcdef' for c in ref): + return None + if not at or not current or at > current or (current-at).days > stale_days: + return None + if r.get('qual') != 'ok' or r.get('brain_status') != 'ok': + return None + return {'grade': grade, 'ref': ref, 'at': at.isoformat()} + + +def review_change(before, after): + if not after: + return 'missing' + if not before: + return 'baseline' + if before['ref'] == after['ref']: + if before != after: + raise ValueError('同一买方评析版本内容不一致,等待核实') + return 'same' + if stamp(after['at']) <= stamp(before['at']): + return 'old' + return 'downgrade' if GRADES[after['grade']] < GRADES[before['grade']] else 'updated' diff --git a/app/core/signal_rules.py b/app/core/signal_rules.py index dc19864..3d389ac 100644 --- a/app/core/signal_rules.py +++ b/app/core/signal_rules.py @@ -107,7 +107,15 @@ def parse_intraday(fields: dict, *, msg_id: str = None) -> dict: scores = json.loads(raw_scores) if isinstance(raw_scores, str) else dict(raw_scores) except (json.JSONDecodeError, TypeError, ValueError): scores = {} + validity = f.get('signal_validity') or {} + if isinstance(validity, str): + try: + validity = json.loads(validity) + except (ValueError, TypeError): + validity = {'expires_at': 'invalid'} return {"source": SRC_INTRADAY, "msg_id": msg_id, + 'signal_id': f.get('signal_id'), 'event_time': f.get('trigger_time'), + 'expires_at': validity.get('expires_at') if isinstance(validity, dict) else 'invalid', "ts_code": (f.get("ts_code") or "").strip(), "action": (f.get("action") or "").strip().upper(), "confidence": _norm_conf(f.get("confidence")), @@ -132,6 +140,8 @@ def parse_risk_sell(fields: dict, *, msg_id: str = None) -> dict: "confidence": 0.0, "parse_error": "内层 data JSON 解析失败", "reason": "", "dominant_signal": ""} return {"source": SRC_RISK_SELL, "msg_id": msg_id, + 'signal_id': inner.get('signal_id'), 'event_time': inner.get('timestamp'), + 'is_fallback': inner.get('is_fallback'), "ts_code": (inner.get("ts_code") or "").strip(), "action": (inner.get("action") or "").strip().upper(), "confidence": _norm_conf_pct(inner.get("confidence")), diff --git a/app/scheduler.py b/app/scheduler.py index 3d21537..7d0cfb8 100644 --- a/app/scheduler.py +++ b/app/scheduler.py @@ -260,6 +260,8 @@ def intraday_exec(): if param_store.get_bool('PMS_EXEC_REPRICE_ENABLED', False): from app.services import execution_basis r['execution_basis'] = execution_basis.monitor() + from app.services import risk_exit + r['risk_exit'] = risk_exit.scan() # 先收尾退出纪律,网格与买入执行不得越过停买状态。 r["strategies"] = strategy_runner.tick() # 个股交易方案: 触发即发短窗口指令, 由下面 run_tick 执行 # 过期收口改为每分钟一次 (原来只在 15:10 日结跑) —— 让过了窗口/deadline 的单当即作废, # 不再多活一整天堵在「今日在办」、也不会隔天还替它试单 (2026-08-12 用户定的"实时"口径)。 @@ -295,10 +297,14 @@ def proposal_scan(): @guard(trade_day=True, session=True) @_exclusive("INFRA_LOCK_EXEC_BASIS_REFRESH", ttl_sec=115) def execution_basis_refresh(): + from app.services import risk_exit + reviews = risk_exit.refresh_reviews() if not param_store.get_bool('PMS_EXEC_REPRICE_ENABLED', False): - return {'skipped': '独立执行依据刷新未开启'} + return {'skipped': '独立执行依据刷新未开启', 'risk_reviews': reviews} from app.services import execution_basis - return execution_basis.refresh() + result = execution_basis.refresh() + result['risk_reviews'] = reviews + return result @celery_app.task(name="pms.signal_digest") diff --git a/app/services/command_service.py b/app/services/command_service.py index e5d0ada..0b9f0df 100644 --- a/app/services/command_service.py +++ b/app/services/command_service.py @@ -167,7 +167,20 @@ def issue(cmd_type: str, params: dict, *, note=None, issued_by="user", logger.exception("命令落表失败") return {"ok": False, "errors": [f"DB_ERROR: 命令落表失败 {type(e).__name__}: {e}"]} - if spec["cls"] == cs.CLS_PARAM: + # 只有明确解冻才能恢复;新买入方案失败或旧命令重规划都不能顺带清掉风控停买。 + from app.services import risk_exit + if cmd_type == 'UNFREEZE_STOCK' and risk_exit.enabled(): + from app.db import session as db + try: + with db.transaction(): + risk_exit.resume_buy(ts_code) + res = _apply_param(command_id, cmd_type, spec, norm) + if not res.get('ok'): + raise RuntimeError('解冻命令未生效,保留原停买状态') + except (ValueError, RuntimeError) as exc: + pms_repo.update_command(command_id, status=cs.ST_CANCELLED, note=str(exc)) + return {'ok': False, 'command_id': command_id, 'errors': [str(exc)]} + elif spec["cls"] == cs.CLS_PARAM: res = _apply_param(command_id, cmd_type, spec, norm) else: res = plan_command(pms_repo.get_command(command_id)) diff --git a/app/services/execution_conflicts.py b/app/services/execution_conflicts.py index ceba2be..61ce988 100644 --- a/app/services/execution_conflicts.py +++ b/app/services/execution_conflicts.py @@ -6,6 +6,10 @@ BUY_ACTIONS = ('OPEN', 'FILL', 'ADD', 'DCA') def buy_blocker(ts_code): + from app.services import risk_exit + stopped = risk_exit.buy_blocker(ts_code) + if stopped: + return stopped # 查询失败必须抛给调用者,不能当作无冲突。按票查,不受全局列表裁剪影响。 rows = pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=ts_code, limit=500) for row in rows: diff --git a/app/services/param_store.py b/app/services/param_store.py index dfc4e82..298308a 100644 --- a/app/services/param_store.py +++ b/app/services/param_store.py @@ -46,6 +46,12 @@ def _valid_limit_flag(value): # 运行态开关: key -> (默认值, 类型, 说明) RUNTIME_EXTRA = { + 'PMS_RISK_EXIT_ENABLED': (False, bool, '原策略退出纪律:第一次清仓级信号停买,第二次独立信号清仓;买方整体评级下降直接清仓'), + 'PMS_RISK_EXIT_START_AT': ('', str, '退出纪律启用时刻,北京时间;只接收此后有效新信号,既有真实停买最多承接第一次'), + 'PMS_RISK_SIGNAL_MAX_AGE_SEC': (300, int, '清仓信号最大时龄,秒;消息期限更短时服从消息期限'), + 'PMS_RISK_SIGNAL_MIRROR_SEC': (120, int, '两条信号流的近时副本合并窗口,秒;缺少共同研判编号时不重复计次'), + 'PMS_RISK_REVIEW_REFRESH_SEC': (300, int, '原策略持仓买方评析补读间隔,秒;新报告按原版本和评级比较'), + 'PMS_RISK_REVIEW_TIMEOUT_SEC': (3, int, '原策略持仓买方评析批量只读请求超时,秒;失败保留原评级'), 'PMS_MONITOR_WATCH_SCOPE': ('', str, '人工关注研究覆盖来源;仅155模拟实例设置pms-sim-155,留空停用'), 'PMS_MONITOR_WATCH_TTL_SEC': (600, int, '人工关注研究名单有效期,秒;与交易候选和交易开关分离'), 'PMS_LIMIT_CACHE_ENABLED': (False, bool, '执行报价读取已核实的当日限制价缓存;缺失时逐票等待'), @@ -206,6 +212,7 @@ RUNTIME_EXTRA = { # 冷启、连库超时), 全局暂停买入、休假模式、组合刹车就一起静默解除, 且没有任何调用方 # 看得出这是降级。安全开关的默认方向必须是"拦", 不是"放"。 FAIL_CLOSED = { + 'PMS_RISK_EXIT_ENABLED': False, 'PMS_MONITOR_WATCH_SCOPE': '', "PMS_LIMIT_CACHE_ENABLED": True, # 无法确认开关时仍走严格本地缓存,不退到旧读取。 "PMS_LIMIT_COLLECT_ENABLED": False, @@ -559,6 +566,10 @@ def set_param(key: str, value, updated_by: str = "user") -> dict: _RANGES = { 'PMS_MONITOR_WATCH_TTL_SEC': (120, 600), + 'PMS_RISK_SIGNAL_MAX_AGE_SEC': (30, 900), + 'PMS_RISK_SIGNAL_MIRROR_SEC': (0, 600), + 'PMS_RISK_REVIEW_REFRESH_SEC': (60, 3600), + 'PMS_RISK_REVIEW_TIMEOUT_SEC': (1, 10), 'PMS_LIMIT_FETCH_TIMEOUT_SEC': (1, 10), 'PMS_LIMIT_ROUND_BUDGET_SEC': (5, 60), 'PMS_LIMIT_ROUND_MAX_CODES': (1, 60), diff --git a/app/services/risk_exit.py b/app/services/risk_exit.py new file mode 100644 index 0000000..a4e7fbf --- /dev/null +++ b/app/services/risk_exit.py @@ -0,0 +1,374 @@ +"""原策略持仓的退出纪律。事件先入账,暂停买入与清仓按实际回报持续收尾。""" +from datetime import datetime + +from config.settings import settings +from app.core import risk_exit as rules, strategy_book as books +from app.repo import pms_repo, rotation_repo +from app.services import param_store + +KIND = 'risk_exit' +PAUSED = {'STOP_BUY', 'EXIT_PENDING', 'EXITING', 'CLOSED', 'MANUAL'} +LIVE = ('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED', 'WAIT_REVIEW') + + +def enabled(): + return (settings.INFRA_STRATEGY_BOOK_SCHEMA and books.CURRENT.get() == books.ORIGINAL + and param_store.get_bool('PMS_RISK_EXIT_ENABLED', False)) + + +def _key(code): + return 'risk-exit:original:' + code + + +def _code_ok(code): + from app.core.command_spec import is_stock_code + return is_stock_code(code) and str(code).endswith(('.SH', '.SZ')) + + +def buy_blocker(code): + if not enabled() or not _code_ok(code): + return None + state, _ = rotation_repo.get(_key(code)) + if state and state.get('phase') in PAUSED: + return state.get('reason') or '该股退出纪律已生效,停止新增买入' + return None + + +def _holding(code): + pos = pms_repo.get_position(code) or {} + rows = pms_repo.list_lots(code, status='OPEN', limit=2001) + if len(rows) >= 2001: + raise ValueError('持仓批次超过完整核验上限') + lots = {str(r['id']) for r in rows if int(r.get('qty') or 0) > 0} + if sum(int(r.get('qty') or 0) for r in rows) != int(pos.get('total_qty') or 0): + raise ValueError('持仓与批次数量不一致,等待对账后执行退出纪律') + pos['_risk_lots'] = rows + return pos, lots + + +def _ledger(code, action, reason, hard, ref): + if pms_repo.insert_ledger(ts_code=code, action=action, arbiter='system', verdict='PASS', + price_at=0, hard_numbers=hard, reason=reason[:500], ref_id=ref) != 1: + raise RuntimeError('退出纪律依据未入账') + + +def _sync(state, code, pos, lots, now): + """以真实未平批次衔接持仓轮次,清空后再开仓不继承上轮信号。""" + if not lots: + return + late = any(r.get('instruction_id') in (state.get('stopped_parents') or []) for r in pos.get('_risk_lots', [])) + same = bool((state.get('opened_date') == str(pos.get('opened_date')) + and set(state.get('lot_ids') or []) & lots) or late) + if not same: + # 没有批次交集时不猜是同一轮,旧证据绝不用于新批次清仓。 + state.clear() + state.update(code=code, book_id=books.ORIGINAL, opened_date=str(pos.get('opened_date')), + round_id=rules.digest([code, str(pos.get('opened_date')), sorted(lots)])[:20], + phase='WATCH', events=[], lot_ids=sorted(lots), count=0, exit_seq=0, + initialized_at=rules.stamp(now).isoformat()) + from app.services import logic_state_service + entry = logic_state_service.entry_view(code) or {} + baseline = rules.review_snapshot(entry.get('company_review'), now=now, + stale_days=param_store.get_int('PMS_FUND_STALE_DAYS', 120)) + if baseline: + state['review'] = baseline + _seed_legacy_first(state, code, pos, now) + else: + state['lot_ids'] = sorted(set(state['lot_ids']) | lots) + if state.get('phase') == 'CLOSED' and late: + state['phase'] = 'EXIT_PENDING' + state['stopped_parents'] = sorted(set(state.get('stopped_parents') or []) | + {r['instruction_id'] for r in pos.get('_risk_lots', []) if r.get('instruction_id')}) + + +def _seed_legacy_first(state, code, pos, now): + """只承接已有的真实停买及待确认清仓,不回扫历史凑第二次信号。""" + from app.services import strategy_service + pause = strategy_service.buypause_map().get(code) or {} + sources = pause.get('sources') or {pause.get('source'): pause} + candidates = pms_repo.list_proposals(statuses=('WAIT_USER',), limit=501) + if len(candidates) >= 501: + raise ValueError('待确认提议过多,不能截断迁移退出依据') + for p in candidates: + if p.get('ts_code') != code or p.get('action') != 'EXIT' or p.get('judge_verdict') != 'STRATEGY_RISK': + continue + hard = p.get('hard_numbers') or {} + source = hard.get('signal_source') + at, paused = rules.stamp(p.get('created_at')), sources.get(source) or {} + pat = rules.stamp(paused.get('at')) + if (not at or not pat or at.date() != rules.stamp(now).date() + or abs((at-pat).total_seconds()) > 120 or not hard.get('on_strategy') + or float(hard.get('confidence') or 0) < param_store.get_float('PMS_SIGNAL_AUTO_EXIT_CONF', .85)): + continue + reason = str(paused.get('reason') or '') + if not reason or reason not in str(hard.get('reason') or ''): + continue + original = reason.split(' —— ', 1)[-1] + event = {'key': rules.digest(['legacy', p['proposal_id']]), 'source': source, + 'source_id': p['proposal_id'], 'msg_id': 'legacy:'+p['proposal_id'], + 'at': pat.isoformat(), 'reason': original, 'content': rules.digest([code, original]), + 'confidence': float(hard['confidence']), 'legacy_proposal': p['proposal_id']} + state.update(events=[event], count=1, phase='STOP_BUY', + reason='第一次清仓信号已确认,停止新增买入,等待第二次独立信号') + _ledger(code, 'SIGNAL', state['reason'], {'legacy_proposal': p['proposal_id'], + 'event': event, 'round_id': state['round_id']}, p['proposal_id']) + return + + +def on_signal(sig, *, now=None, dry_run=False): + if not enabled(): + return None + now = now or datetime.now() + event, why = rules.signal_event(sig, now=now, + since=param_store.get('PMS_RISK_EXIT_START_AT', ''), + threshold=param_store.get_float('PMS_SIGNAL_AUTO_EXIT_CONF', .85), + max_age=param_store.get_int('PMS_RISK_SIGNAL_MAX_AGE_SEC', 300)) + if not event: + return {'accepted': False, 'reason': why} + code = sig['ts_code'] + if dry_run: + state, _ = rotation_repo.get(_key(code)) + return {'accepted': True, 'dry_run': True, 'count': (state or {}).get('count', 0), + 'reason': '只读预览,不登记次数、不改变委托'} + with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state: + pos, lots = _holding(code) + if not lots: + return {'accepted': False, 'reason': '当前没有原策略持仓'} + _sync(state, code, pos, lots, now) + reset = rules.stamp(state.get('reset_at')) + if reset and rules.stamp(event['at']) <= reset: + return {'accepted': False, 'reason': '信号早于人工恢复买入'} + # 持仓买入前的消息不能用来清这轮新仓。 + opened = rules.stamp(pos.get('opened_date')) + if opened and rules.stamp(event['at']) < opened: + return {'accepted': False, 'reason': '信号早于当前持仓轮次'} + duplicate = rules.duplicate(state['events'], event, + mirror_seconds=param_store.get_int('PMS_RISK_SIGNAL_MIRROR_SEC', 120)) + if not duplicate and state['phase'] not in ('EXIT_PENDING', 'EXITING', 'CLOSED', 'MANUAL'): + state['events'].append(event) + state['count'] = int(state.get('count') or 0) + 1 + state['phase'] = 'STOP_BUY' if state['count'] == 1 else 'EXIT_PENDING' + state['reason'] = ('第一次清仓信号已确认,停止新增买入,等待第二次独立信号' + if state['count'] == 1 else '第二次独立清仓信号已确认,开始清仓') + _ledger(code, 'SIGNAL', state['reason'], + {'event': event, 'count': state['count'], 'round_id': state['round_id']}, event['key'][:64]) + count, phase = state['count'], state['phase'] + drive(code, now=now) + return {'accepted': True, 'duplicate': duplicate, 'count': count, 'phase': phase} + + +def observe_review(code, review, *, now=None): + if not enabled() or not _code_ok(code): + return None + now = now or datetime.now() + snapshot = rules.review_snapshot(review, now=now, + stale_days=param_store.get_int('PMS_FUND_STALE_DAYS', 120)) + with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state: + pos, lots = _holding(code) + if not lots: + return None + _sync(state, code, pos, lots, now) + change = rules.review_change(state.get('review'), snapshot) + if change in ('baseline', 'updated', 'downgrade'): + before = state.get('review') + state['review'] = snapshot + if change == 'downgrade' and state['phase'] not in ('EXIT_PENDING', 'EXITING', 'MANUAL'): + state.update(phase='EXIT_PENDING', reason=f"买方评析整体评级由{before['grade']}降为{snapshot['grade']},开始清仓") + state['review_exit'] = {'before': before, 'after': snapshot} + _ledger(code, 'SIGNAL', state['reason'], + {'review_exit': state['review_exit'], 'round_id': state['round_id']}, snapshot['ref']) + return change + + +def _stop_buys(code, state): + """先持久化逐指令停止依据,再请求撤单;未确认撤销的量继续保留。""" + from app.services import executor, strategy_service + reason = state['reason'] + strategy_service.pause_buy(code, reason=reason, source='risk_exit') + pause = strategy_service.buypause_map().get(code) or {} + if 'risk_exit' not in (pause.get('sources') or {}): + raise RuntimeError('退出纪律暂停买入未保存') + rows = pms_repo.list_instructions(statuses=list(LIVE), side='buy', ts_code=code, limit=501) + if len(rows) >= 501: + raise ValueError('在途买入过多,不能截断处理') + for ins in rows: + iid = ins['instruction_id'] + state['stopped_parents'] = sorted(set(state.get('stopped_parents') or []) | {iid}) + if not pms_repo.instruction_buy_stop(iid): + _ledger(code, 'BUY_STOP', reason, {'risk_exit': True}, iid) + result = executor.cancel_instruction(iid, reason=reason, arbiter='system') or {} + if not result.get('ok'): + raise RuntimeError('退出纪律撤单失败,保留停买并等待重试') + + +def drive(code, *, now=None): + """同账户串行收尾。T+1、迟到成交、部分成交继续沿已有执行与回报链处理。""" + if not enabled() or not _code_ok(code) or param_store.get_bool('PMS_GLOBAL_EXEC_HALT', False): + return + now = now or datetime.now() + from app.services import execution_conflicts, execution_orders, strategy_service + with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state: + if not state or state.get('phase') not in PAUSED: + return + _stop_buys(code, state) + if state['phase'] in ('STOP_BUY', 'CLOSED', 'MANUAL'): + return + # 旧网格卖单也需明确撤销,不能只撤策略后让旧父单永久等待来源状态。 + from app.services import executor + all_live = pms_repo.list_instructions(statuses=list(LIVE), ts_code=code, limit=501) + if len(all_live) >= 501: + raise ValueError('在途指令过多,不能截断处理') + for old in all_live: + if old.get('origin_type') == 'strategy' and old.get('side') == 'sell': + result = executor.cancel_instruction(old['instruction_id'], reason=state['reason'], arbiter='system') or {} + if not result.get('ok'): + raise RuntimeError('旧策略卖出撤单失败,等待重试') + # 撤掉网格等自动策略,避免旧卖单与整票清仓并发占用可卖量。 + result = strategy_service.cancel_by_code(code, reason=state['reason']) or {} + if not result.get('ok'): + raise RuntimeError('清仓前策略撤销未完成,等待重试') + if pms_repo.list_strategies(ts_code=code, statuses=['ACTIVE', 'PAUSED'], limit=1): + raise RuntimeError('清仓前仍有未撤下的交易方案,等待重试') + # 同一账户锁和文档事务覆盖清仓指令、计数、报告版本与审计。 + current = state + pos, lots = _holding(code) + from app.repo import qmt_repo + children = qmt_repo.list_orders(ts_code=code, statuses=list(qmt_repo.LIVE), limit=1001) + if len(children) >= 1001: + raise ValueError('在途委托超过核验上限') + owned = [] + for child in children: + with books.scope('all'): + parent = pms_repo.get_instruction(child['parent_id']) + if not parent or parent.get('book_id') not in (books.ORIGINAL, books.MICRO): + raise ValueError('在途委托策略归属无法核实') + if parent['book_id'] == books.ORIGINAL: + owned.append(child) + if any(c.get('side') == 'sell' for c in owned): + return + if qmt_repo.inbox_pending_count() or qmt_repo.inbox_orphan_count(): + return + rows = pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=code, limit=501) + if len(rows) >= 501: + raise ValueError('在途卖出过多,不能截断处理') + if rows: + return # 已有真实卖出先收尾,不叠加超卖,也不覆盖用户指令。 + if current.get('exit_iid'): + prev = pms_repo.get_instruction(current['exit_iid']) + if not prev or prev.get('status') in ('CANCELLED', 'REJECTED'): + current.update(phase='MANUAL', reason='清仓安排已撤销、拒绝或无法核实,等待人工处理') + return + # 等所有回报入账后才确认清仓完成;迟到买入仍归本轮退出收尾。 + qty = int(pos.get('total_qty') or 0) + if qty <= 0: + live_buy = pms_repo.list_instructions(statuses=list(LIVE), side='buy', ts_code=code, limit=1) + if not live_buy and not owned: + current.update(phase='CLOSED', closed_at=rules.stamp(now).isoformat()) + return + blocker = execution_orders.correction_blocker(ts_code=code, side='sell') + if blocker: + raise RuntimeError(blocker) + seq = int(current.get('exit_seq') or 0) + 1 + iid = f"RX_{current['round_id']}_{seq}" + progress = {'is_command': False, 'urgent': True, 'from_signal': True, + 'risk_exit': {'round_id': current['round_id'], 'events': current['events'], + 'review_exit': current.get('review_exit')}, + 'reason': current['reason'], 'children': [], 'deadline': str(now.date())} + if pms_repo.insert_instruction(instruction_id=iid, origin_type='system', origin_id='risk_exit', + ts_code=code, action='EXIT', side='sell', qty=qty, limit_price=None, + window_tdays=1, status='PROPOSED', progress=progress) != 1: + raise RuntimeError('清仓指令未成功落表') + _ledger(code, 'EXIT', current['reason'], progress['risk_exit'], iid) + current.update(phase='EXITING', exit_iid=iid, exit_seq=seq) + # 旧风控/目标价提议被新清仓覆盖,避免再被采纳为重复委托。 + proposals = pms_repo.list_proposals(statuses=('WAIT_USER',), limit=501) + if len(proposals) >= 501: + raise ValueError('提议过多,不能完整清理退出冲突') + for p in proposals: + if p.get('ts_code') == code and p.get('action') in ('EXIT', 'TRIM', 'OPEN', 'FILL', 'ADD', 'DCA'): + if not pms_repo.decide_proposal(p['proposal_id'], 'EXPIRED'): + raise RuntimeError('清仓冲突提议未成功收尾') + result = execution_conflicts.enforce_exit(pms_repo.get_instruction(iid)) + if not result.get('ok'): + raise RuntimeError('清仓已落表,买入侧仍待收尾') + + +def resume_buy(code): + """仅响应用户明确恢复;清仓已启动时不能用恢复买入撤销卖出安排。""" + if not enabled(): + return + with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state: + if state.get('phase') in ('EXIT_PENDING', 'EXITING'): + raise ValueError('该股已进入清仓流程,请先处理清仓安排') + if state.get('phase') == 'MANUAL': + from app.repo import qmt_repo + if (pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=code, limit=1) + or qmt_repo.list_orders(ts_code=code, statuses=list(qmt_repo.LIVE), limit=1) + or qmt_repo.inbox_pending_count() or qmt_repo.inbox_orphan_count()): + raise ValueError('该股委托或回报仍待收尾,暂不能恢复买入') + if state: + state.update(phase='WATCH', count=0, reset_at=rules.stamp(datetime.now()).isoformat(), reason='用户明确恢复买入') + state.pop('exit_iid', None) + from app.services import strategy_service + result = strategy_service.clear_buypause(code) or {} + if not result.get('ok'): + raise RuntimeError('用户恢复买入未保存,保留原暂停') + _ledger(code, 'SIGNAL', state['reason'], {'round_id': state['round_id'], + 'reset_at': state['reset_at']}, state['round_id']) + + +def scan(*, now=None): + out = {'enabled': enabled(), 'reviews': {}, 'errors': []} + if not out['enabled']: + return out + now = now or datetime.now() + from app.services import logic_state_service + states = logic_state_service.state_map() + positions = pms_repo.list_positions(only_open=True) + codes = {p['ts_code'] for p in positions if _code_ok(p['ts_code'])} + pending = rotation_repo.recent(KIND, limit=1000) + if len(pending) >= 1000: + raise RuntimeError('退出纪律记录超过核验上限') + codes.update(r['value']['code'] for r in pending if r['value'].get('phase') in PAUSED) + for code in sorted(codes): + try: + out['reviews'][code] = observe_review(code, (states.get(code) or {}).get('company_review'), now=now) + drive(code, now=now) + except Exception as exc: + out['errors'].append(f'{code}: {type(exc).__name__}: {exc}') + out['ok'] = not out['errors'] + return out + + +def refresh_reviews(*, now=None): + """在独立刷新任务中批量只读持仓评析;执行任务不等待外部请求或模型。""" + out = {'enabled': enabled(), 'ok': True, 'reviews': {}, 'errors': []} + if not out['enabled']: + return out + now = now or datetime.now() + current = rules.stamp(now) + from app.services import plan_feed + positions = pms_repo.list_positions(only_open=True) + codes = sorted({p['ts_code'] for p in positions if _code_ok(p['ts_code'])}) + if not codes: + return out + if len(codes) > 200: + raise ValueError('持仓评级批量查询超过完整核验上限') + with rotation_repo.locked('risk-review-refresh:original', 'risk_review_refresh', {}) as state: + previous = rules.stamp(state.get('attempt_at')) + if previous and (current-previous).total_seconds() < param_store.get_int('PMS_RISK_REVIEW_REFRESH_SEC', 300): + return {**out, 'skipped': '尚未到持仓评析刷新时间'} + state['attempt_at'] = current.isoformat() + try: + states = plan_feed.fetch_logic_states(codes, + timeout=param_store.get_int('PMS_RISK_REVIEW_TIMEOUT_SEC', 3)) + except Exception as exc: + out.update(ok=False, errors=[f'持仓评析补读失败,保留原评级:{type(exc).__name__}']) + return out + for code in codes: + try: + out['reviews'][code] = observe_review(code, (states.get(code) or {}).get('company_review'), now=now) + except Exception as exc: + out['errors'].append(f'{code}: {type(exc).__name__}: {exc}') + out['ok'] = not out['errors'] + return out diff --git a/app/services/signal_service.py b/app/services/signal_service.py index 4ce8c4a..ddefd4d 100644 --- a/app/services/signal_service.py +++ b/app/services/signal_service.py @@ -148,6 +148,15 @@ def _handle(sig, view, prm, seen, ymd, dry_run, out, strat_codes=frozenset()): d = sr.digest(sig, pos, prm) act = d["action"] + # 已授权退出纪律独立于旧的“每股每天一次”去重;重放按原研判标识防重。 + # 必须早于在途提议检查,否则第一次生成的提议会吞掉第二次真实信号。 + if act == sr.ACT_EXIT: + from app.services import risk_exit + handled = risk_exit.on_signal(sig, dry_run=dry_run) + if handled is not None: + out.setdefault('risk_exit', []).append({'ts_code': code, **handled}) + return + if act == sr.ACT_IGNORE: out["ignored"] += 1 # **持仓票的卖出被忽略也要留痕** (2026-08-18)。digest 对"低于门槛"返回 IGNORE, diff --git a/app/services/strategy_service.py b/app/services/strategy_service.py index 8653d21..669d022 100644 --- a/app/services/strategy_service.py +++ b/app/services/strategy_service.py @@ -285,6 +285,11 @@ def resume_buy(strategy_id: str, by: str = "user") -> dict: if not st: return {"ok": False, "error": "策略不存在"} code = st.get("ts_code") + from app.services import risk_exit + try: + risk_exit.resume_buy(code) + except (ValueError, RuntimeError) as exc: + return {'ok': False, 'error': str(exc)} m = buypause_map() if code in m: m.pop(code, None) diff --git a/docs/两次清仓信号与评级下降退出_2026-11-05.md b/docs/两次清仓信号与评级下降退出_2026-11-05.md new file mode 100644 index 0000000..4b8886b --- /dev/null +++ b/docs/两次清仓信号与评级下降退出_2026-11-05.md @@ -0,0 +1,41 @@ +# 两次清仓信号与评级下降退出 + +## 用户决定与范围 + +2026年11月5日,用户说明试探仓由人工操作,不应以试探仓比例约束后续系统规划。本次不修改仓位预算、网格档距和每格数量。用户确定:系统第一次清仓信号停止买入,第二次独立清仓信号开始清仓;买方评析整体评级只要下降就直接清仓,包括“好”降为“中”。人工清仓命令仍立即生效。 + +本次只涉及155模拟PMS的original账本。微盘轮换规则、188真实PMS、选股排序、三源合议与已确认的单行信号页面保持原规则。需要更新web、worker及唯一WS,因为新的停买检查覆盖规划、执行、下发和已排队委托的最终发送。 + +## 生效规则 + +1. 清仓级信号沿用现行置信度门槛,当前为85%。只接受有效的决策系统盘中SELL或风控SELL,核对原始时间、期限、出处、非降级结果及当前沪深持仓。新开关开启前的积压消息不计次。 +2. 第一次登记持仓轮次、原始消息标识和内容依据,立即阻断新增买入,撤销该股在途买入。取消未确认和迟到成交保留原回报处理。此时不撤下正常卖出侧,不自动清仓。 +3. 第二次独立信号撤下该股网格等交易方案,待旧卖出委托、待入账与孤儿回报收尾后,按original实际持仓量建立一条紧急EXIT。不是仅平掉试探仓或某个网格层。T+1部分顺延,后续迟到买入继续收尾;已有人工卖出先处理,不叠加卖出数量。 +4. 消息重放和同一研判编号只算一次。上游两条流缺少共同研判编号,近120秒跨流消息保守地按一份处理,即使文字不同;不能证明独立时不凑足第二次。此边界可能合并近时的两个真实跨流结论,属于有意保守处理。 +5. 正式买方评析以整体评级“好、中、差”比较。报告有可追溯版本、生成时间和有效状态;较新版本下降一档或两档直接进入清仓,不等待两个信号。旧版本、同版冲突、缺失、超时、过期和未知档均不当作降级。已启动的退出不会因评级随后回升自动撤销。 +6. 首次取入场记录的正式评级作基线;无入场评级则以首次有效报告建基线,不臆测历史。按未平批次识别持仓轮次,已清空再开仓不继承旧计数;被停止父指令的迟到买入仍归旧退出收尾。 +7. 用户全局暂停优先。第一次停买可以通过既有“恢复买入”或明确解冻命令解除;普通建仓失败、重试和旧命令重规划不能清除状态。已启动清仓须先处理冲突,用户取消的清仓不会被后台不断重新建立。取消收尾后可明确恢复。微盘账本不可被此路径认领或清仓。 + +## 实现及定时补读 + +`app/core/risk_exit.py`负责纯事实校验,`app/services/risk_exit.py`用既有轮换文档表保存每股计数、持仓轮次、评级版本和退出进度。事件先记账,账户锁与数据库事务保证同一轮不重复生成EXIT,无新表和账本重建。 + +信号入口在旧每日去重和待确认提议拦截之前消费新规则,否则旧的“一天一次”会吞掉第二个有效信号。盘中执行每轮在网格之前检查退出状态;执行任务不联网等评级。 + +持仓评级另在既有独立依据刷新任务中每300秒批量只读补齐,单次超时3秒,不发起模型任务。解决盘前映射遗漏当天新持仓以及无法及时发现新报告的问题。失败保留已确认评级与退出状态,下次重试。无新增调度项,不重建beat。 + +参数经ParamStore读取:`PMS_RISK_EXIT_ENABLED`默认关闭,`PMS_RISK_EXIT_START_AT`使用实际切换时刻,信号时龄300秒,跨流合并120秒,评级刷新300秒、请求超时3秒。部署完成后只在155开启。 + +## 发布前实况与验证 + +12:17只读核验:155主机factorevaluation,原PMS目录,表前缀为空,dispatch为ws,用户两项暂停false,改价、异步与微盘v3开启。最近200条连续确认1641795,资金与持仓快照5.9秒,待入账与孤儿0,数量和现金一致。当前web为e4a7424,worker和唯一WS为f756344。 + +12:19只读补读返回五只原策略持仓的正式报告,均与入场评级相同,未发现评级下降。盘前映射仅含雷赛智能,四只当日新仓原来尚未覆盖。雷赛智能1600股,存在09:38真实清仓提议和同源停买,评级“好”。切换只承接这一条真实第一次信号,不回扫历史补第二次,不补造模型、委托或回报。 + +开发机35项专项覆盖信号防重、三种评级下降、持仓轮次、缺失和超时、事务回滚、原策略与微盘隔离、取消待确认、既有卖出、迟到成交、T+1数量保留、用户恢复与解冻失败回滚、独立调度。全量与候选回归、部署和自然判收将在下节按实际结果追加。 + +## 回退与待验 + +回退只限三个目标服务,保留所有退出文档、指令、账本和回报。已经登记的停买不能仅关闭开关后丢失:回退前须先停止新增买入,检查已有EXIT和QMT委托,再按已落表指令继续收尾,不能删除计数或重放真实成交。 + +隔离检查不等于自然判收。当前没有本规则启用后的第二次独立清仓信号或评级下降,不能报告真实自动清仓已经验证。发布后记录实际开关、迁移初始化、自然调度和委托回报各自的状态,不为验证制造交易。 diff --git a/docs/开发入口.md b/docs/开发入口.md index c46da7b..6158d0d 100644 --- a/docs/开发入口.md +++ b/docs/开发入口.md @@ -16,6 +16,7 @@ | 盘中改价、异步研判与微盘递补发布 | [执行链路发布接续](执行报价与异步研判发布接续_2026-11-03.md),区分部署、开关与自然判收;[实施规格](执行报价与异步研判实施规格_2026-11-03.md);[当日限制价采集边界](当日限制价采集边界_2026-11-03.md) | | 策略资金缺行情提示、成本三位精度与含费口径 | [估值与成本精度修复](策略估值与成本精度修复_2026-11-04.md),含实际QMT回执、展示降级和导出舍入边界 | | QMT工作台成交修正与配套委托回报 | [成交修正接入与发布](QMT成交修正接入与发布_2026-11-05.md),含原成交保留、修正幂等、数量变化阻断续单和证据不足挂起边界 | +| 原策略两次清仓信号与买方评级下降退出 | [退出纪律接续](两次清仓信号与评级下降退出_2026-11-05.md),含第一次停买、第二次清仓、任一级评级下降、持仓轮次、重复消息和T+1收尾 | | 人工关注显示已剔除、每日选股重复与研究覆盖 | [人工关注分析链修复规格](人工关注分析链修复规格_2026-11-04.md),说明独立研究、回执与交易边界;[只读巡检及当日更正](人工关注与选股覆盖巡检_2026-11-04.md)保留历史时点证据;首次部署见[发布接续](人工关注与吸筹参考发布接续_2026-11-04.md),11月4日进度见[后续跟进](人工关注后续跟进与信号融合_2026-11-04.md),最新格式要求及计划过期恢复见[11月5日接续](信号流格式与选股恢复_2026-11-05.md) | | 架构与接口 | [README模块地图](../README.md)、[总体设计](../POSITION_MGMT_DESIGN.md);改接口再读[QMT协议](../QMT_WS_PROTOCOL.md)、[bionic接口](../BIONIC_PMS_INTERFACE.md)或[计划接口](../UPSTREAM_PLAN_API.md) | | 后端、前端、测试、研究 | [后端规则](../app/AGENTS.md)、[页面规则](../app/web/AGENTS.md)、[脚本规则](../scripts/AGENTS.md)、[研究规则](../research/AGENTS.md),仅选择所涉及目录 | diff --git a/scripts/run_tests.py b/scripts/run_tests.py index 2dfa285..e10381d 100644 --- a/scripts/run_tests.py +++ b/scripts/run_tests.py @@ -198,7 +198,8 @@ import sys HERE = os.path.dirname(os.path.abspath(__file__)) ROOT = os.path.dirname(HERE) -SUITES = ["test_rotation_accounting_units.py", "test_cost_precision.py", "test_execution_basis_decimal.py", +# 退出纪律专项:两次独立清仓信号、评级下降、事务、双策略隔离及撤单收尾。 +SUITES = ["test_risk_exit.py", "test_rotation_accounting_units.py", "test_cost_precision.py", "test_execution_basis_decimal.py", "test_trade_correction_units.py", "test_trade_correction_transport.py", "test_trade_correction_service.py", "test_trade_lineage_units.py", "test_trade_correction_strategy.py", diff --git a/scripts/test_batch10_units.py b/scripts/test_batch10_units.py index 5743778..91a9edb 100644 --- a/scripts/test_batch10_units.py +++ b/scripts/test_batch10_units.py @@ -50,6 +50,8 @@ ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # 这些函数**写失败时不抛异常**, 只把失败写在返回值里。调用点必须接住。 # key = 函数名, value = 允许的调用者模块名 (None = 不限, 用于 _db(f, ...) 这种间接调用) SOFT_FAIL = { + "scan": {"risk_exit"}, + "refresh_reviews": {"risk_exit"}, "consume": {"trade_correction"}, "sync": {"monitor_watch"}, "mark_send_attempt": {"qmt_repo"}, diff --git a/scripts/test_batch57_units.py b/scripts/test_batch57_units.py index 47a5e5c..4775869 100644 --- a/scripts/test_batch57_units.py +++ b/scripts/test_batch57_units.py @@ -209,7 +209,9 @@ class SchedulerEntryTests(unittest.TestCase): self.review.assert_called_once_with();self.model.assert_called_once_with() def test_basis_refresh_entry_uses_new_flag(self): - self.assertEqual(self.sch.execution_basis_refresh.run(),{'enabled':True}) + result = self.sch.execution_basis_refresh.run() + self.assertTrue(result['enabled']) + self.assertEqual(result['risk_reviews'], {'enabled': False, 'ok': True, 'reviews': {}, 'errors': []}) self.refresh.assert_called_once_with() def test_cancel_confirm_entry_continues_under_global_halt(self): diff --git a/scripts/test_risk_exit.py b/scripts/test_risk_exit.py new file mode 100644 index 0000000..fb994e3 --- /dev/null +++ b/scripts/test_risk_exit.py @@ -0,0 +1,412 @@ +"""退出纪律:虚构事件、真实SQLite事务与双策略隔离,禁止联网。""" +import unit_test_guard # noqa: F401 +import copy +import datetime as dt +import json +import sys +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from sqlalchemy import create_engine, event, text +from app.core import risk_exit as core, signal_rules, strategy_book as books +from app.db import session as db +from app.repo import pms_repo, qmt_repo, rotation_repo as store +from app.services import risk_exit as service, param_store, strategy_service, logic_state_service +from app.services import executor, execution_orders, execution_conflicts, signal_service +from config.settings import settings + +CODE = '600001.SH' +NOW = dt.datetime(2026, 11, 5, 10, tzinfo=core.TZ) +START = NOW-dt.timedelta(hours=1) + + +def signal(n=1, *, at=None, source='intraday', reason='独立研判确认退出'): + return {'ts_code': CODE, 'action': 'SELL', 'confidence': .95, 'reason': reason, + 'source': source, 'producer_id': 'bionic_brain_intraday_v2.0', + 'msg_id': str(n), 'signal_id': 'S'+str(n), + 'event_time': (at or NOW).isoformat(), 'is_fallback': False} + + +def review(grade='好', ref='a', days=2): + return {'overall': grade, 'review_ref': ref*64, + 'report_ran_at': (NOW-dt.timedelta(days=days)).isoformat(), + 'qual': 'ok', 'brain_status': 'ok'} + + +class CoreTests(unittest.TestCase): + def parse(self, value): + return core.signal_event(value, now=NOW, since=START) + + def test_valid_and_invalid_event_boundaries(self): + self.assertIsNotNone(self.parse(signal())[0]) + changes = [dict(ts_code='920001.BJ'), dict(confidence=.6), dict(confidence=float('nan')), + dict(action='BUY'), dict(source='unknown'), dict(producer_id='smoketest'), + dict(event_time=None), dict(msg_id=None), dict(reason=''), dict(is_fallback=True), + dict(is_fallback='true'), dict(event_time=(NOW+dt.timedelta(seconds=1)).isoformat()), + dict(event_time=(NOW-dt.timedelta(minutes=6)).isoformat()), + dict(expires_at=(NOW-dt.timedelta(seconds=1)).isoformat()), dict(expires_at='bad')] + for changeset in changes: + with self.subTest(changeset=changeset): + self.assertIsNone(self.parse({**signal(), **changeset})[0]) + + def test_cutover_does_not_replay_old_signals(self): + self.assertIsNone(core.signal_event(signal(),now=NOW,since=NOW+dt.timedelta(seconds=1))[0]) + self.assertIsNone(core.signal_event(signal(),now=NOW,since='')[0]) + + def test_replay_and_cross_stream_copy_do_not_count_twice(self): + a=self.parse(signal())[0] + self.assertTrue(core.duplicate([a],a)) + copy_event=self.parse({**signal(2,source='risk_sell'), 'event_time':(NOW-dt.timedelta(seconds=1)).isoformat()})[0] + self.assertTrue(core.duplicate([a],copy_event)) + copy_event=self.parse(signal(3,source='risk_sell',reason='同一研判的另一份文字'))[0] + self.assertTrue(core.duplicate([a],copy_event)) + modified=self.parse({**signal(3), 'signal_id':'S1','reason':'重新包装的同一信号'})[0] + self.assertTrue(core.duplicate([a],modified)) + self.assertFalse(core.duplicate([a],self.parse(signal(4))[0])) + + def test_parser_preserves_upstream_identity_and_expiry(self): + t=int(NOW.timestamp()*1000) + a=signal_rules.parse_intraday({'ts_code':CODE,'action':'SELL','confidence':'.95', + 'signal_id':'id','trigger_time':str(t),'producer_id':'bionic_brain_intraday_v2.0', + 'signal_validity':json.dumps({'expires_at':t+300000}),'audit_reason':'退出'},msg_id='1') + self.assertEqual(a['event_time'],str(t));self.assertEqual(a['expires_at'],t+300000) + self.assertIsNotNone(self.parse(a)[0]) + b=signal_rules.parse_risk_sell({'data':json.dumps({'ts_code':CODE,'action':'SELL', + 'confidence':95,'timestamp':t,'is_fallback':False,'llm_reason':'退出'})},msg_id='2') + self.assertIsNotNone(self.parse(b)[0]) + + def test_every_overall_downgrade_counts(self): + for before,after in [('好','中'),('中','差'),('好','差')]: + with self.subTest(before=before,after=after): + a=core.review_snapshot(review(before),now=NOW) + b=core.review_snapshot(review(after,'b',1),now=NOW) + self.assertEqual(core.review_change(a,b),'downgrade') + + def test_missing_stale_incomplete_and_future_review_are_not_downgrades(self): + for value in [None,{},review('未知'),{**review(),'qual':'off'}, + {**review(),'brain_status':'timeout'},review(days=121),review(days=-1), + {**review(),'review_ref':''}]: + self.assertIsNone(core.review_snapshot(value,now=NOW)) + + def test_review_order_and_immutable_identity(self): + a=core.review_snapshot(review(),now=NOW) + self.assertEqual(core.review_change(a,a),'same') + self.assertEqual(core.review_change(None,a),'baseline') + self.assertEqual(core.review_change(a,None),'missing') + self.assertEqual(core.review_change(a,core.review_snapshot(review('差','b',3),now=NOW)),'old') + with self.assertRaises(ValueError):core.review_change(a,{**a,'grade':'中'}) + + +class ServiceTests(unittest.TestCase): + def setUp(self): + self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup) + self.engine=create_engine('sqlite:///'+self.tmp.name+'/risk.sqlite');self.addCleanup(self.engine.dispose) + @event.listens_for(self.engine,'before_cursor_execute',retval=True) + def dialect(conn,cursor,sql,params,context,many): + db.assert_single_table(sql) + sql=sql.replace(' FOR UPDATE','') + if 'ON DUPLICATE KEY UPDATE' in sql: + self.assertIn('pms_rotation_document',sql) + sql=sql.split('ON DUPLICATE KEY UPDATE')[0]+'ON CONFLICT DO NOTHING' + return sql,params + self.params={'PMS_RISK_EXIT_ENABLED':True,'PMS_RISK_EXIT_START_AT':START.isoformat()} + self.use(db,'get_engine',lambda *args:self.engine) + self.use(db,'_check_cooldown',lambda *args:None) + self.use(settings,'INFRA_STRATEGY_BOOK_SCHEMA',True) + for name in ('get','get_bool','get_int','get_float'): + self.use(param_store,name,lambda key,default=None:self.params.get(key,default)) + self.use(logic_state_service,'entry_view',lambda code:{'company_review':review()}) + self.reviews={CODE:{'company_review':review()}} + self.use(logic_state_service,'state_map',lambda:self.reviews) + self.use(execution_orders,'correction_blocker',lambda *a,**k:'') + self.pending,self.orphans=0,0 + self.use(qmt_repo,'inbox_pending_count',lambda:self.pending) + self.use(qmt_repo,'inbox_orphan_count',lambda:self.orphans) + self.use(strategy_service,'buypause_map',lambda:(store.get('test-pause')[0] or {})) + def pause(code,reason='',source='signal'): + with store.locked('test-pause','test',{}) as m: + e=m.setdefault(code,{'sources':{}}) + e['sources'][source]={'reason':reason,'at':NOW.isoformat()} + return [] + def clear(code,only_source=None): + with store.locked('test-pause','test',{}) as m:m.pop(code,None) + return {'ok':True,'cleared':True} + self.use(strategy_service,'pause_buy',pause) + self.use(strategy_service,'clear_buypause',clear) + self.cancel_pending=False + def cancel(iid,reason='',arbiter='user',**kwargs): + self.assertEqual(arbiter,'system') + if not self.cancel_pending:pms_repo.update_instruction(iid,status='CANCELLED') + return {'ok':True,'pending':self.cancel_pending} + self.use(executor,'cancel_instruction',cancel) + schema={ + 'pms_position':'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,total_qty INTEGER,avail_qty INTEGER,opened_date TEXT,status TEXT', + 'pms_lot':'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,instruction_id TEXT,qty INTEGER,status TEXT,open_date TEXT', + 'pms_instruction':'id INTEGER PRIMARY KEY,book_id TEXT,instruction_id TEXT UNIQUE,origin_type TEXT,origin_id TEXT,ts_code TEXT,action TEXT,side TEXT,qty INTEGER,limit_price REAL,window_tdays INTEGER,status TEXT,exec_qty INTEGER DEFAULT 0,exec_avg_price REAL,progress_json TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT', + 'pms_action_ledger':'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,decided_at TEXT,action TEXT,arbiter TEXT,verdict TEXT,price_at REAL,hard_numbers_json TEXT,failed_checks_json TEXT,reason TEXT,ref_id TEXT,outcome_scored INTEGER', + 'pms_proposal':'id INTEGER PRIMARY KEY,book_id TEXT,proposal_id TEXT,ts_code TEXT,action TEXT,qty INTEGER,hard_numbers_json TEXT,judge_verdict TEXT,judge_reason TEXT,status TEXT,expire_at TEXT,created_at TEXT,decided_at TEXT,archived_at TEXT', + 'pms_strategy':'id INTEGER PRIMARY KEY,book_id TEXT,strategy_id TEXT,ts_code TEXT,type TEXT,status TEXT,params_json TEXT,state_json TEXT,autonomy TEXT,note TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT', + 'pms_rotation_document':'doc_id TEXT PRIMARY KEY,kind TEXT,payload_json TEXT,revision INTEGER,updated_at TEXT', + 'pms_plan':'id INTEGER PRIMARY KEY,book_id TEXT,plan_id TEXT,ts_code TEXT,action TEXT,status TEXT,priority INTEGER,created_at TEXT,updated_at TEXT', + 'pms_qmt_order':'id INTEGER PRIMARY KEY,instruction_id TEXT,parent_id TEXT,ts_code TEXT,side TEXT,status TEXT', + } + with self.engine.begin() as conn: + for table,cols in schema.items():conn.execute(text('CREATE TABLE '+table+' ('+cols+')')) + self.insert('pms_position',dict(book_id='original',ts_code=CODE,total_qty=1600,avail_qty=1600,opened_date='2026-11-03',status='HOLDING')) + self.insert('pms_lot',dict(id=1,book_id='original',ts_code=CODE,instruction_id='BASE',qty=1600,status='OPEN',open_date='2026-11-03')) + + def use(self,obj,name,value): + p=patch.object(obj,name,value);p.start();self.addCleanup(p.stop) + + def insert(self,table,value): + with self.engine.begin() as conn: + conn.execute(text('INSERT INTO '+table+' ('+','.join(value)+') VALUES ('+','.join(':'+k for k in value)+')'),value) + + def change(self,sql): + with self.engine.begin() as conn:conn.execute(text(sql)) + + def state(self):return store.get(service._key(CODE))[0] or {} + def instructions(self):return pms_repo.list_instructions(ts_code=CODE,include_archived=True) + def fire(self,n=1,**kwargs):return service.on_signal(signal(n,**kwargs),now=NOW) + + def test_first_stops_buys_second_creates_one_full_exit(self): + self.assertEqual(self.fire()['count'],1) + self.assertTrue(execution_conflicts.buy_blocker(CODE));self.assertEqual(self.instructions(),[]) + self.assertEqual(self.fire(2)['count'],2) + orders=self.instructions();self.assertEqual(len(orders),1) + self.assertEqual((orders[0]['action'],orders[0]['qty']),('EXIT',1600)) + self.assertTrue(orders[0]['progress']['urgent']) + + def test_duplicate_after_restart_does_not_count(self): + self.fire();self.fire() + self.assertEqual(self.state()['count'],1);self.assertEqual(self.instructions(),[]) + self.fire(2);self.fire(2);service.scan(now=NOW) + self.assertEqual(len(self.instructions()),1) + + def test_same_report_and_upgrade_no_exit_downgrade_exits(self): + self.assertEqual(service.observe_review(CODE,review(),now=NOW),'same') + service.drive(CODE,now=NOW);self.assertEqual(self.instructions(),[]) + self.assertEqual(service.observe_review(CODE,review('中','b',1),now=NOW),'downgrade') + service.drive(CODE,now=NOW) + self.assertEqual(self.instructions()[0]['qty'],1600) + self.assertEqual(self.state()['review_exit']['before']['grade'],'好') + + def test_missing_entry_review_starts_baseline_without_fabricated_decline(self): + self.use(logic_state_service,'entry_view',lambda code:{}) + self.assertEqual(service.observe_review(CODE,review('中'),now=NOW),'baseline') + service.drive(CODE,now=NOW);self.assertEqual(self.instructions(),[]) + + def test_incomplete_review_keeps_last_valid_baseline(self): + service.observe_review(CODE,review(),now=NOW) + service.observe_review(CODE,{**review('差','b',1),'brain_status':'timeout'},now=NOW) + self.assertEqual(self.state()['review']['grade'],'好');self.assertEqual(self.instructions(),[]) + + def test_stale_or_changed_same_version_does_not_exit(self): + service.observe_review(CODE,review(),now=NOW) + self.assertEqual(service.observe_review(CODE,review('差','b',3),now=NOW),'old') + with self.assertRaises(ValueError):service.observe_review(CODE,review('差'),now=NOW) + self.assertEqual(self.state()['review']['grade'],'好');self.assertEqual(self.instructions(),[]) + + def test_global_pause_records_intent_without_actions(self): + self.params['PMS_GLOBAL_EXEC_HALT']=True + self.fire();self.fire(2) + self.assertEqual(self.state()['phase'],'EXIT_PENDING');self.assertEqual(self.instructions(),[]) + self.params['PMS_GLOBAL_EXEC_HALT']=False + service.scan(now=NOW);self.assertEqual(len(self.instructions()),1) + + def test_dry_run_writes_nothing(self): + result=service.on_signal(signal(),now=NOW,dry_run=True) + self.assertTrue(result['dry_run']);self.assertEqual(self.state(),{});self.assertEqual(self.instructions(),[]) + + def test_feature_off_keeps_legacy_path(self): + self.params['PMS_RISK_EXIT_ENABLED']=False + self.assertIsNone(self.fire());self.assertIsNone(service.buy_blocker(CODE)) + + def test_micro_book_untouched(self): + self.insert('pms_position',dict(book_id='micro30',ts_code=CODE,total_qty=900,avail_qty=900,opened_date='2026-11-03')) + self.insert('pms_lot',dict(id=2,book_id='micro30',ts_code=CODE,instruction_id='MICRO',qty=900,status='OPEN')) + with books.scope('micro30'): + self.assertIsNone(self.fire());self.assertIsNone(service.buy_blocker(CODE)) + self.fire();self.fire(2) + self.assertEqual(self.instructions()[0]['qty'],1600) + with books.scope('micro30'): + self.assertEqual(self.instructions(),[]);self.assertEqual(pms_repo.get_position(CODE)['total_qty'],900) + + def test_t1_retains_full_exit_quantity_until_available(self): + self.change('UPDATE pms_position SET avail_qty=0') + self.fire();self.fire(2) + self.assertEqual(self.instructions()[0]['qty'],1600) + service.scan(now=NOW);self.assertEqual(len(self.instructions()),1) + + def test_exit_insert_failure_does_not_consume_second_signal_twice(self): + self.fire() + with patch.object(pms_repo,'insert_instruction',return_value=0): + with self.assertRaises(RuntimeError):self.fire(2) + self.assertEqual(self.state()['count'],2);self.assertEqual(self.state()['phase'],'EXIT_PENDING') + self.assertEqual(self.instructions(),[]) + self.fire(2);self.assertEqual(len(self.instructions()),1);self.assertEqual(self.state()['count'],2) + + def test_audit_failure_rolls_back_signal_count(self): + with patch.object(pms_repo,'insert_ledger',return_value=0): + with self.assertRaises(RuntimeError):self.fire() + self.assertEqual(self.state(),{}) + self.fire();self.assertEqual(self.state()['count'],1) + + def test_first_cancels_buy_but_preserves_sell(self): + pms_repo.insert_instruction(instruction_id='BUY',origin_type='proposal',origin_id=None,ts_code=CODE,action='ADD',side='buy',qty=100,status='PROPOSED') + pms_repo.insert_instruction(instruction_id='SELL',origin_type='plan',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='PROPOSED') + self.fire() + self.assertEqual(pms_repo.get_instruction('BUY')['status'],'CANCELLED') + self.assertEqual(pms_repo.get_instruction('SELL')['status'],'PROPOSED') + self.assertIsNotNone(pms_repo.instruction_buy_stop('BUY')) + + def test_existing_sell_finishes_before_full_exit(self): + pms_repo.insert_instruction(instruction_id='SELL',origin_type='plan',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='PROPOSED') + self.fire();self.fire(2);self.assertEqual(len(self.instructions()),1) + pms_repo.update_instruction('SELL',status='CONFIRMED') + self.change('UPDATE pms_position SET total_qty=1500,avail_qty=1500') + self.change('UPDATE pms_lot SET qty=1500') + service.drive(CODE,now=NOW) + self.assertEqual(self.instructions()[0]['qty'],1500) + + def test_pending_order_even_with_terminal_parent_prevents_double_sell(self): + pms_repo.insert_instruction(instruction_id='OLD',origin_type='strategy',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='CANCELLED') + self.insert('pms_qmt_order',dict(instruction_id='CHILD',parent_id='OLD',ts_code=CODE,side='sell',status='ACCEPTED')) + self.fire();self.fire(2) + self.assertEqual(len(self.instructions()),1) + + def test_pending_ledger_and_correction_hold_wait(self): + self.fire();self.pending=1;self.fire(2) + self.assertEqual(self.instructions(),[]) + self.pending=0 + with patch.object(execution_orders,'correction_blocker',return_value='修正待核实'): + with self.assertRaises(RuntimeError):service.drive(CODE,now=NOW) + self.assertEqual(self.instructions(),[]) + service.drive(CODE,now=NOW);self.assertEqual(len(self.instructions()),1) + + def test_cancelled_exit_is_not_reopened(self): + self.fire();self.fire(2) + pms_repo.update_instruction(self.instructions()[0]['instruction_id'],status='CANCELLED') + service.drive(CODE,now=NOW) + self.assertEqual(self.state()['phase'],'MANUAL');self.assertEqual(len(self.instructions()),1) + service.resume_buy(CODE) + self.assertEqual(self.state()['phase'],'WATCH') + self.assertIsNone(service.buy_blocker(CODE)) + + def test_late_buy_after_flat_is_still_closed_out(self): + self.fire();self.fire(2) + iid=self.instructions()[0]['instruction_id'];pms_repo.update_instruction(iid,status='CONFIRMED',exec_qty=1600) + self.change('UPDATE pms_position SET total_qty=0,avail_qty=0');self.change("UPDATE pms_lot SET qty=0,status='CLOSED'") + service.scan(now=NOW);self.assertEqual(self.state()['phase'],'CLOSED') + self.insert('pms_lot',dict(id=2,book_id='original',ts_code=CODE,instruction_id='BASE',qty=100,status='OPEN')) + self.change('UPDATE pms_position SET total_qty=100,avail_qty=0') + service.scan(now=NOW) + self.assertEqual(len(self.instructions()),2);self.assertEqual(self.instructions()[0]['qty'],100) + + def test_new_holding_round_does_not_inherit_old_signal(self): + self.fire();old=self.state()['round_id'] + self.change("UPDATE pms_lot SET qty=0,status='CLOSED'") + self.insert('pms_lot',dict(id=2,book_id='original',ts_code=CODE,instruction_id='NEW',qty=1600,status='OPEN')) + service.observe_review(CODE,review(),now=NOW) + self.assertNotEqual(self.state()['round_id'],old);self.assertEqual(self.state()['count'],0) + self.assertEqual(self.instructions(),[]) + + def test_human_resume_resets_count_but_cannot_undo_started_exit(self): + self.fire();service.resume_buy(CODE) + self.assertIsNone(service.buy_blocker(CODE));self.assertEqual(self.state()['count'],0) + self.fire();self.assertEqual(self.state()['count'],0) # 已处理的旧信号不得重算。 + self.change("DELETE FROM pms_rotation_document WHERE doc_id LIKE 'risk-exit:%'") + self.fire();self.fire(2) + with self.assertRaises(ValueError):service.resume_buy(CODE) + + def test_legacy_pause_only_seeds_one_real_signal(self): + reason='风控 SELL 置信度 95% ≥ 85%, 清仓 1600 股 —— 旧真实研判' + strategy_service.pause_buy(CODE,reason=reason,source='intraday') + pms_repo.insert_proposal(proposal_id='LEGACY',ts_code=CODE,action='EXIT',qty=1600, + hard_numbers={'on_strategy':True,'confidence':.95,'signal_source':'intraday','reason':'策略暂停。 —— '+reason}, + expire_at=NOW+dt.timedelta(days=1),judge_verdict='STRATEGY_RISK') + self.change("UPDATE pms_proposal SET created_at='2026-11-05 10:00:00'") + service.observe_review(CODE,review(),now=NOW) + self.assertEqual(self.state()['count'],1);self.assertEqual(self.instructions(),[]) + self.fire(2) + self.assertEqual(len(self.instructions()),1) + self.assertEqual(pms_repo.get_proposal('LEGACY')['status'],'EXPIRED') + + def test_signal_handler_bypasses_legacy_daily_dedup_and_pending_proposal(self): + view={'positions':[{'ts_code':CODE,'total_qty':1600,'avail_qty':1600}]} + prm={'sell_conf_min':.6,'auto_exit_conf':.85,'trim_ratio':.3333} + seen={signal_rules.dedup_key(signal(),20261105):None} + class Clock(dt.datetime): + @classmethod + def now(cls,tz=None):return NOW + with patch.object(service,'datetime',Clock): + out={'ignored':0} + signal_service._handle(signal(),view,prm,seen,20261105,False,out,{CODE}) + signal_service._handle(signal(2),view,prm,seen,20261105,False,out,{CODE}) + self.assertEqual(len(self.instructions()),1) + + def test_independent_review_refresh_and_timeout_keep_baseline(self): + from app.services import plan_feed + with patch.object(plan_feed,'fetch_logic_states',return_value={CODE:{'company_review':review('中','b',1)}}) as fetch: + out=service.refresh_reviews(now=NOW) + self.assertTrue(out['ok']);self.assertEqual(out['reviews'][CODE],'downgrade') + fetch.assert_called_once_with([CODE],timeout=3) + self.assertEqual(self.instructions(),[]) # 刷新只记意图,委托留给执行任务。 + service.refresh_reviews(now=NOW+dt.timedelta(seconds=60)) + self.assertEqual(fetch.call_count,1) + with patch.object(plan_feed,'fetch_logic_states',side_effect=TimeoutError): + out=service.refresh_reviews(now=NOW+dt.timedelta(minutes=6)) + self.assertFalse(out['ok']);self.assertEqual(self.state()['review']['grade'],'中') + self.assertEqual(self.state()['phase'],'EXIT_PENDING') + service.scan(now=NOW) + self.assertEqual(len(self.instructions()),1) + + def test_refresh_missing_rows_and_disabled_do_not_manufacture_downgrade(self): + from app.services import plan_feed + with patch.object(plan_feed,'fetch_logic_states',return_value={}) as fetch: + out=service.refresh_reviews(now=NOW) + self.assertEqual(out['reviews'][CODE],'missing') + self.assertEqual(self.state()['review']['grade'],'好') + self.params['PMS_RISK_EXIT_ENABLED']=False + service.refresh_reviews(now=NOW+dt.timedelta(minutes=6)) + self.assertEqual(fetch.call_count,1) + self.assertEqual(self.instructions(),[]) + + def test_failed_unfreeze_command_cannot_clear_risk_pause(self): + from app.services import command_service + self.fire() + with patch.object(command_service,'active_commands',return_value=[]), \ + patch.object(pms_repo,'next_command_seq',return_value=1), \ + patch.object(pms_repo,'insert_command',return_value=1), \ + patch.object(pms_repo,'update_command',return_value=1), \ + patch.object(command_service,'_apply_param',return_value={'ok':False}): + result=command_service.issue('UNFREEZE_STOCK',{'ts_code':CODE}) + self.assertFalse(result['ok']) + self.assertEqual(self.state()['phase'],'STOP_BUY') + self.assertIn('risk_exit',strategy_service.buypause_map()[CODE]['sources']) + + def test_new_buy_command_does_not_silently_reset_stop(self): + from app.services import command_service + self.fire() + with patch.object(command_service,'active_commands',return_value=[]), \ + patch.object(pms_repo,'next_command_seq',return_value=1), \ + patch.object(pms_repo,'insert_command',return_value=1), \ + patch.object(pms_repo,'get_command',return_value={}), \ + patch.object(command_service,'plan_command',return_value={'ok':False}): + command_service.issue('OPEN_TARGET',{'ts_code':CODE,'target_ratio':.05}) + self.assertEqual(self.state()['phase'],'STOP_BUY') + + def test_refresh_runs_independently_of_reprice_switch(self): + from app import scheduler + self.params['PMS_EXEC_REPRICE_ENABLED']=False + fn=scheduler.execution_basis_refresh.run + while hasattr(fn,'__wrapped__'):fn=fn.__wrapped__ + with patch.object(service,'refresh_reviews',return_value={'ok':True,'reviews':{CODE:'same'}}) as fresh: + result=fn() + fresh.assert_called_once() + self.assertEqual(result['risk_reviews']['reviews'],{CODE:'same'}) + + +if __name__=='__main__':unittest.main() diff --git a/scripts/test_wiring.py b/scripts/test_wiring.py index d8bc0b2..c041f0d 100644 --- a/scripts/test_wiring.py +++ b/scripts/test_wiring.py @@ -728,6 +728,11 @@ def install_fakes(prices=None, positions=None, params=None, high5=None, prev_clo execution_repo.pending_corrections = pending_corrections from app.repo import trade_correction_repo trade_correction_repo.pending = lambda limit=100: [] + # 持仓评析补读走既有只读接口;装配测试使用内存结果,禁止访问上游。 + from app.services import plan_feed + fake.logic_states = {} + plan_feed.fetch_logic_states = lambda codes, **kw: {c: dict(fake.logic_states[c]) + for c in codes if c in fake.logic_states} fake.params.update(params or {}) for p in (positions or []): base = {"ts_code": p["ts_code"], "status": "HOLDING", "frozen_reason": "NONE",