diff --git a/app/AGENTS.md b/app/AGENTS.md index 6937ad0..704b866 100644 --- a/app/AGENTS.md +++ b/app/AGENTS.md @@ -10,6 +10,7 @@ - 业务参数走`services/param_store.py`;`config/settings.py`只是业务初值和基础设施配置。新密钥同时登记`SECRET_KEYS`和相应测试,不进入参数快照。 - 资金冻结、在途买入、卖出释放及策略划拨使用既有统一占用口径。新增执行路径不能另算一份余额;划拨不是盈利。 - 关键写入和下发函数可能返回`ok=False`或影响0行而不抛异常,必须检查返回值并处理失败。新软失败函数同步登记`test_batch10_units.py`的`SOFT_FAIL`。 +- 同一授权存在自动、人工、复核或恢复入口时,共用业务事实。涉及共享额度或独占策略的最终授权在同一短事务内重读,批准与可执行指令同成同败。测试覆盖在两阶段之间改变授权、部分成功后重试,以及应继续允许的反向操作。 - 内部股票代码使用Tushare点式,例如`600000.SH`;访问上游时在边界转换。改`core/ws_codec.py`后验证协议签名向量,不能只看连接成功。 - 修改接口先查对应契约:QMT用[协议](../QMT_WS_PROTOCOL.md),bionic用[接口说明](../BIONIC_PMS_INTERFACE.md),上游选股用[计划接口](../UPSTREAM_PLAN_API.md)。架构定位见[README](../README.md)。 diff --git a/app/core/micro_rotation.py b/app/core/micro_rotation.py index 3e41a50..f6116e8 100644 --- a/app/core/micro_rotation.py +++ b/app/core/micro_rotation.py @@ -206,7 +206,7 @@ def preflight(members, budget, allowed_boards, costs): def orders(state, snapshot, *, original, micro, quotes, cash, account_mv, cap_amount, - reserve_cash=0., pending=(), control='run', blacklisted=(), costs=None): + reserve_cash=0., pending=(), control='run', blacklisted=(), costs=None, buy_restrictions=None): """只形成意图,不把计划卖出计入现金。调用者落表后再执行。""" from app.core.planner import plan_reduce_exposure costs = costs or {} @@ -252,6 +252,9 @@ def orders(state, snapshot, *, original, micro, quotes, cash, account_mv, cap_am c for c, t in objectives.items() if int(t['qty']) > int(micro_by.get(c, {}).get('total_qty') or 0)}) per_new = available/len(missing) if missing else 0. for c in candidates: + if buy_restrictions and c in buy_restrictions: + waits.append(c+':'+buy_restrictions[c]) + continue if c in original_by or c in active_codes or c in blacklisted: waits.append(c+'旧仓、在途委托或黑名单阻止买入') continue diff --git a/app/core/timing_fusion_contract.py b/app/core/timing_fusion_contract.py index 51aed3d..e57ef42 100644 --- a/app/core/timing_fusion_contract.py +++ b/app/core/timing_fusion_contract.py @@ -23,7 +23,7 @@ def valid(value, now, *, since=None): if not start or at < start: return None key = value.get('key', '') - if len(key) != 64 or any(c not in '0123456789abcdef' for c in key): + if not isinstance(key, str) or len(key) != 64 or any(c not in '0123456789abcdef' for c in key): return None groups = value.get('groups') if not isinstance(groups, dict) or set(groups) != set(GROUPS): diff --git a/app/db/session.py b/app/db/session.py index b7b2d2d..a33da95 100644 --- a/app/db/session.py +++ b/app/db/session.py @@ -21,6 +21,7 @@ import time import threading import contextlib import contextvars +from dataclasses import dataclass, field from sqlalchemy import create_engine, text from sqlalchemy.exc import SQLAlchemyError @@ -34,6 +35,20 @@ _lock = threading.Lock() _TRANSACTION = contextvars.ContextVar('pms_transaction', default=None) +@dataclass +class TransactionState: + local: dict = field(default_factory=dict) + after_commit: set = field(default_factory=set) + + +_state = contextvars.ContextVar('pms_transaction_state', default=None) + + +def transaction_state(): + """供事务参与者保存私有读数和登记提交成功后执行的缓存失效操作。""" + return _state.get() + + @contextlib.contextmanager def transaction(): """跨多条单表语句的原子事务。只在显式业务编排中启用。""" @@ -41,12 +56,17 @@ def transaction(): if existing is not None: yield existing return + state = TransactionState() with get_engine('proxy').begin() as connection: token = _TRANSACTION.set(connection) + state_token = _state.set(state) try: yield connection finally: + _state.reset(state_token) _TRANSACTION.reset(token) + for callback in state.after_commit: + callback() @contextlib.contextmanager def savepoint(): diff --git a/app/repo/pms_repo.py b/app/repo/pms_repo.py index 351c82b..8068210 100644 --- a/app/repo/pms_repo.py +++ b/app/repo/pms_repo.py @@ -9,6 +9,7 @@ PMS 自有表数据访问 (pms_*, 153 代理侧, 严格单表) from __future__ import annotations import json +from contextlib import contextmanager from datetime import datetime from app.db.session import execute, execute_many, fetch_all, fetch_one @@ -63,8 +64,9 @@ def set_param(key: str, value, updated_by: str = "user") -> int: {"k": key, "v": str(value), "by": updated_by, "ts": _NOW()}) -def get_param(key: str): - r = fetch_one("SELECT param_value FROM pms_runtime_param WHERE param_key = :k", {"k": key}) +def get_param(key: str, *, for_update=False): + sql = "SELECT param_value FROM pms_runtime_param WHERE param_key = :k" + r = fetch_one(sql + (" FOR UPDATE" if for_update else ""), {"k": key}) return r["param_value"] if r else None @@ -91,7 +93,7 @@ def get_command(command_id: str): return _cmd_row(r) if r else None -def list_commands(*, statuses=None, cmd_class=None, limit: int = 200, +def list_commands(*, statuses=None, cmd_class=None, cmd_type=None, limit: int = 200, include_archived: bool = False) -> list: where, p = [], {"n": int(limit)} if statuses: @@ -103,6 +105,9 @@ def list_commands(*, statuses=None, cmd_class=None, limit: int = 200, if cmd_class: where.append("cmd_class = :cls") p["cls"] = cmd_class + if cmd_type: + where.append("cmd_type = :cmd_type") + p["cmd_type"] = cmd_type if not include_archived: where.append("archived_at IS NULL") sql = "SELECT * FROM pms_command" @@ -170,7 +175,7 @@ def latest_effective(cmd_type: str, ts_code=None): return _cmd_row(r) if r else None -def list_effective_stock_params(cmd_types=None) -> list: +def list_effective_stock_params(cmd_types=None, *, ts_code=None) -> list: """个股参数命令的当前值 (黑白名单/止损价/目标价/做T授权/冻结 的事实源)。""" sql = ("SELECT * FROM pms_command WHERE cmd_class = 'param' AND status = 'EFFECTIVE' " "AND ts_code IS NOT NULL") @@ -181,7 +186,11 @@ def list_effective_stock_params(cmd_types=None) -> list: keys.append(f":t{i}") p[f"t{i}"] = t sql += f" AND cmd_type IN ({', '.join(keys)})" - sql += " ORDER BY id DESC LIMIT 500" + if ts_code is not None: + sql += " AND ts_code = :code" + p["code"] = ts_code + # 其他股票的命令增加不能让仍然生效的旧冻结消失。 + sql += " ORDER BY id DESC" return [_cmd_row(r) for r in fetch_all(sql, p)] @@ -275,6 +284,23 @@ def list_positions(*, only_open: bool = False) -> list: return fetch_all(sql) +def strategy_guard(ts_code): + """双账本复用交易账户锁,旧账本按唯一证券持仓行串行化。""" + from config.settings import settings + if settings.INFRA_STRATEGY_BOOK_SCHEMA: + from app.repo import rotation_repo + return rotation_repo.account_guard() + return _position_guard(ts_code) + + +@contextmanager +def _position_guard(ts_code): + from app.db.session import transaction + with transaction(): + fetch_one("SELECT ts_code FROM pms_position WHERE ts_code=:code FOR UPDATE", {"code": ts_code}) + yield + + def get_position(ts_code: str): return fetch_one("SELECT * FROM pms_position WHERE ts_code = :code", {"code": ts_code}) @@ -416,9 +442,9 @@ def insert_instruction(*, instruction_id, origin_type, origin_id, ts_code, actio "w": int(window_tdays), "st": status, "pg": _dumps(progress), "ts": now}) -def list_instructions(*, statuses=None, side=None, ts_code=None, limit: int = 300, +def list_instructions(*, statuses=None, side=None, ts_code=None, limit: int | None = 300, include_archived: bool = False) -> list: - where, p = [], {"n": int(limit)} + where, p = [], {} if statuses: keys = [] for i, s in enumerate(statuses): @@ -436,7 +462,10 @@ def list_instructions(*, statuses=None, side=None, ts_code=None, limit: int = 30 sql = "SELECT * FROM pms_instruction" if where: sql += " WHERE " + " AND ".join(where) - sql += " ORDER BY id DESC LIMIT :n" + sql += " ORDER BY id DESC" + if limit is not None: + sql += " LIMIT :n" + p["n"] = int(limit) rows = fetch_all(sql, p) for r in rows: r["progress"] = _loads(r.get("progress_json"), {}) @@ -708,6 +737,23 @@ def system_decided_today(since) -> set: return {(r["ts_code"], r["action"]) for r in rows} +@contextmanager +def account_decision_guard(): + """账户决策与临发额度共用同一实例的短事务锁。""" + from app.db import session as db + from config.settings import settings + if settings.INFRA_STRATEGY_BOOK_SCHEMA: + from app.repo import rotation_repo + with rotation_repo.account_guard(): + yield + else: + # 单账本模式无轮换文档表,基础 DDL 已建 ws_state 的唯一账户行。 + with db.transaction(): + if not db.fetch_one("SELECT id FROM pms_ws_state WHERE id=1 FOR UPDATE"): + raise RuntimeError('无法锁定账户,本次自动建仓暂缓') + yield + + def system_pass_count_today(since) -> int: """今天系统自决**自动采纳**的新建仓只数, 供每日上限 PMS_SELF_DECIDE_DAILY_MAX 判断。 @@ -718,7 +764,7 @@ def system_pass_count_today(since) -> int: "WHERE action = 'OPEN' AND verdict = 'PASS' AND decided_at >= :d " "AND reason LIKE :pfx", {"d": since, "pfx": SYSTEM_ACCEPT_REASON_PREFIX + "%"}) - return int((r or {}).get("n") or 0) + return int(r["n"]) def judge_rejected_open_rows(since) -> dict: diff --git a/app/repo/rotation_repo.py b/app/repo/rotation_repo.py index f11499c..217a39e 100644 --- a/app/repo/rotation_repo.py +++ b/app/repo/rotation_repo.py @@ -48,6 +48,12 @@ def recent(kind, limit=100): return [{'id': r['doc_id'], 'value': json.loads(r['payload_json']), 'updated_at': str(r['updated_at'])} for r in rows] +def document_ids(kind, *, limit): + rows = db.fetch_all('SELECT doc_id FROM pms_rotation_document WHERE kind=:kind LIMIT :n', + {'kind': kind, 'n': int(limit)}) + return {r['doc_id'] for r in rows} + + def updated_since(kind, since, limit=6001): rows = db.fetch_all('SELECT doc_id,payload_json FROM pms_rotation_document ' 'WHERE kind=:kind AND updated_at>=:since ORDER BY updated_at DESC LIMIT :n', diff --git a/app/scheduler.py b/app/scheduler.py index a880ad8..0910748 100644 --- a/app/scheduler.py +++ b/app/scheduler.py @@ -140,6 +140,8 @@ def _brief(r): keep = {k: v for k, v in r.items() if k in ("ok", "fills", "actions", "planned", "failed", "diffs", "errors", "skipped", "avail_reset", "refs", "cursor", "date", "returned")} + if 'timing_fusion' in r: + keep['timing_fusion'] = r['timing_fusion'].get('status') if isinstance(keep.get("diffs"), list): keep["diffs"] = len(keep["diffs"]) if isinstance(keep.get("errors"), list): @@ -244,14 +246,22 @@ def replay_fills(): @celery_app.task(name="pms.intraday_exec") -@guard(trade_day=True, session=True) +@guard(trade_day=True, session=True, respect_exec_halt=False) @_exclusive("INFRA_LOCK_INTRADAY_EXEC", ttl_sec=230) def intraday_exec(): """盘中执行: 方案转指令 → 择时出手 (规则闸终检 → 下发 → 记子单)。 含自主提议扫描 (FILL/ADD/DCA/TRIM 动作引擎 → 规则闸 → 研判闸 → 按档位分流)。 """ - from app.services import executor, proposal_service, strategy_runner + from app.services import executor, proposal_service, strategy_runner, risk_exit + observe_stops = risk_exit.supported() and not settings.PMS_TABLE_PREFIX + halted = param_store.execution_halted() if observe_stops else param_store.get_bool('PMS_GLOBAL_EXEC_HALT', False) + if halted: + if not observe_stops: + return {'skipped': 'exec_halt'} + observed = risk_exit.scan(user_stops_only=True) + return {'skipped': 'exec_halt', 'risk_exit': observed, 'ok': not observed['errors'], + 'errors': observed['errors']} r = {"materialized": executor.materialize_plans()} if not param_store.get_bool('PMS_JUDGE_ASYNC_ENABLED', False): from app.services import daily_buy_review @@ -260,7 +270,6 @@ 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 的单当即作废, diff --git a/app/services/command_service.py b/app/services/command_service.py index 15c722d..2615ba3 100644 --- a/app/services/command_service.py +++ b/app/services/command_service.py @@ -42,9 +42,10 @@ def active_commands() -> list: cs.ST_EFFECTIVE], limit=300) -def effective_stock_params() -> dict: +def effective_stock_params(*, cmd_types=STOCK_PARAM_TYPES, ts_code=None) -> dict: """个股参数命令当前值: {ts_code: {frozen, t0, stop_price, target_price, black, white}}""" - rows = pms_repo.list_effective_stock_params(STOCK_PARAM_TYPES) + rows = (pms_repo.list_effective_stock_params(cmd_types, ts_code=ts_code) if ts_code else + pms_repo.list_effective_stock_params(cmd_types)) out = {} for r in sorted(rows, key=lambda x: x["id"]): # 旧 → 新, 后者覆盖前者 code = r.get("ts_code") @@ -169,14 +170,20 @@ def issue(cmd_type: str, params: dict, *, note=None, issued_by="user", # 只有明确解冻才能恢复;新买入方案失败或旧命令重规划都不能顺带清掉风控停买。 from app.services import risk_exit - if cmd_type == 'UNFREEZE_STOCK' and risk_exit.supported(): + from config.settings import settings as infrastructure + stock_restriction = cmd_type in ('FREEZE_STOCK', 'UNFREEZE_STOCK', 'BLACKLIST_ADD', 'BLACKLIST_REMOVE') + simulated_restriction = stock_restriction and risk_exit.supported() and not infrastructure.PMS_TABLE_PREFIX + if simulated_restriction or (cmd_type == 'UNFREEZE_STOCK' and risk_exit.supported()): from app.db import session as db + from app.repo import rotation_repo + guard = rotation_repo.account_guard if simulated_restriction else db.transaction try: - with db.transaction(): - risk_exit.resume_buy(ts_code) + with guard(): + if cmd_type == 'UNFREEZE_STOCK': + risk_exit.resume_buy(ts_code) res = _apply_param(command_id, cmd_type, spec, norm) if not res.get('ok'): - raise RuntimeError('解冻命令未生效,保留原停买状态') + 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)]} @@ -186,7 +193,6 @@ def issue(cmd_type: str, params: dict, *, note=None, issued_by="user", res = plan_command(pms_repo.get_command(command_id)) res.setdefault("command_id", command_id) res["conflicts"] = conflicts - from config.settings import settings as infrastructure if infrastructure.INFRA_STRATEGY_BOOK_SCHEMA and res.get('ok'): from app.services.rotation_service import on_user_command on_user_command(cmd_type, command_id, issued_by) @@ -211,8 +217,9 @@ def _apply_param(command_id: str, cmd_type: str, spec: dict, norm: dict) -> dict applied = dict(norm) pms_repo.supersede_param_commands(cmd_type, ts_code, keep_command_id=command_id) _supersede_opposites(cmd_type, ts_code) - pms_repo.update_command(command_id, status=cs.ST_EFFECTIVE, progress={"applied": applied}, - done_at=datetime.now()) + if not pms_repo.update_command(command_id, status=cs.ST_EFFECTIVE, progress={"applied": applied}, + done_at=datetime.now()): + raise RuntimeError("参数命令未写入生效状态") return {"ok": True, "status": cs.ST_EFFECTIVE, "applied": applied, "plan": None} except Exception as e: logger.exception("参数命令生效失败") diff --git a/app/services/daily_buy_review.py b/app/services/daily_buy_review.py index 5affd0c..06e9515 100644 --- a/app/services/daily_buy_review.py +++ b/app/services/daily_buy_review.py @@ -1,6 +1,6 @@ """跨日买入复核:停止旧单、等待真实回报、重走当日决策,再开放当日额度。""" from copy import deepcopy -from datetime import datetime +from datetime import datetime, timedelta import hashlib from app.db.session import transaction @@ -115,7 +115,8 @@ def _hold(ins, now, reason): previous = prog.get('daily_review') or {} if previous: prog['daily_review_history'] = (prog.get('daily_review_history', []) + [previous])[-20:] - prog['daily_review'] = {'ymd': _day(now), 'status': 'pending', 'reason': reason} + prog['daily_review'] = {'ymd': _day(now), 'status': 'pending', 'reason': reason, + 'entered_at': now.isoformat()} # 同一日人工维护后重核也不能复用旧执行价。 for key in ('exec_advice', 'ref_lock', 'last_decision'): prog.pop(key, None) @@ -193,6 +194,66 @@ def _queue(ins, result, now): return True +def _finish_review(row, fresh, now): + if not fresh['auto_exec']: + return 'queued' if _queue(row, fresh, now) else None + sd = fresh.get('self_decide') or {} + if row['action'] == 'OPEN' and sd.get('decision') == 'accept': + # 跨日续买和当日新建仓共用每日名额;只锁最后的核验、状态推进和审计。 + from app.services import proposal_service as ps + with pms_repo.account_decision_guard(): + stopped = ps.locked_open_authorization({'self_decide': 'full'}, trial=sd.get('tier') == 'trial') + if stopped: + return 'waiting' + maximum = param_store.locked_open_param('PMS_SELF_DECIDE_DAILY_MAX') + why = ps._quota_confirm_reason(ps._auto_open_count(now), maximum) + if why: + manual = dict(fresh, candidate=dict(fresh['candidate'], confirm_why=why)) + return 'queued' if _queue(row, manual, now) else None + return 'approved' if _approve(row, fresh, now) else None + return 'approved' if _approve(row, fresh, now) else None + + +def _queue_position(row): + review = (row.get('progress') or {}).get('daily_review') or {} + # 旧指令无排队时间时沿用创建时间。同一时刻未试过的先到,最后以数据库 id 稳定排序。 + last = review.get('last_attempt_at') + stamp = last or review.get('entered_at') or str(row.get('created_at') or '').replace(' ', 'T') + return stamp, int(review.get('attempts') or bool(last)), int(row.get('id') or 0) + + +def _claim_review(row, now): + """在发起耗时研判之前原子移到队尾;服务重启或资料待补仍保留公平顺序。""" + progress = deepcopy(row['progress']) + review = progress['daily_review'] + # 与盘中调度的既有 230 秒租期一致。崩溃后可重新领取,迟到的旧结果不能覆盖新版本。 + if review.get('active_until', '') > now.isoformat(): + return None + review['last_attempt_at'] = now.isoformat() + review['active_until'] = (now + timedelta(seconds=230)).isoformat() + review['attempts'] = int(review.get('attempts') or 0) + 1 + with transaction(): + if not pms_repo.compare_review_instruction(row, progress, 'WAIT_REVIEW'): + return None + return pms_repo.get_instruction(row['instruction_id']) + + +def _release_review(claimed): + """只释放本轮领取的机会。批准、撤销和新一轮复核各自保留其结果。""" + with transaction(): + current = pms_repo.get_instruction(claimed['instruction_id']) + if not current or current['status'] != 'WAIT_REVIEW': + return + progress = deepcopy(current['progress']) + state = progress.get('daily_review') or {} + owner = claimed['progress']['daily_review'] + if any(state.get(key) != owner[key] for key in ('active_until', 'last_attempt_at', 'attempts')): + return + del state['active_until'] + if not pms_repo.compare_review_instruction(current, progress, 'WAIT_REVIEW'): + raise RuntimeError('父指令同时发生变化,本次占用将到期释放') + + def process(*, now=None): from app.services import dispatcher, proposal_service, execution_orders now = now or datetime.now() @@ -200,22 +261,25 @@ def process(*, now=None): if not param_store.get_bool('PMS_DAILY_BUY_REVIEW', False): return out # 先停完所有旧任务,再进行可能耗时的研判;未处理到的也不能从下发出口绕过。 - for row in pms_repo.list_instructions(statuses=list(LIVE), side='buy', limit=500): - if not applies(row) or not blocker(row, now=now): + for row in pms_repo.list_instructions(statuses=list(LIVE), side='buy', limit=None): + if not applies(row): continue try: review = (row.get('progress') or {}).get('daily_review') or {} - if row['status'] != 'WAIT_REVIEW' or review.get('ymd') != _day(now): - held = _hold(row, now, blocker(row, now=now)) - if held: - out['held'].append(row['instruction_id']) + if row['status'] == 'WAIT_REVIEW' and review.get('ymd') == _day(now): + continue + reason = blocker(row, now=now) + if reason and _hold(row, now, reason): + out['held'].append(row['instruction_id']) except Exception as e: out['errors'].append(f"{row['instruction_id']}: {e}") reviewed = 0 - for row in pms_repo.list_instructions(statuses=['WAIT_REVIEW'], side='buy', limit=500): + waiting = pms_repo.list_instructions(statuses=['WAIT_REVIEW'], side='buy', limit=None) + for row in sorted(waiting, key=_queue_position): if not applies(row): continue iid = row['instruction_id'] + claimed = None try: if execution_orders.correction_blocker(row): out['waiting'].append(iid) @@ -252,7 +316,13 @@ def process(*, now=None): out['waiting'].append(iid) continue if reviewed >= 1: - break + continue + if state.get('ymd') != _day(now): + continue + claimed = _claim_review(row, now) + if not claimed: + continue + row = claimed reviewed += 1 result = proposal_service.scan_and_route(now=now, review_instruction=row) if result.get('errors') or not result.get('ok'): @@ -271,9 +341,9 @@ def process(*, now=None): out['waiting'].append(iid) continue fresh = current - changed = _approve(row, fresh, now) if fresh['auto_exec'] else _queue(row, fresh, now) - if changed: - out['approved' if fresh['auto_exec'] else 'queued'].append(iid) + disposition = _finish_review(row, fresh, now) + if disposition: + out[disposition].append(iid) else: # 未通过不带昨日任务继续。后续条件转好仍由正常扫描产生新建议。 reasons = [r.get('why') or ';'.join(r.get('failed') or []) @@ -284,6 +354,12 @@ def process(*, now=None): out['ended'].append(iid) except Exception as e: out['errors'].append(f'{iid}: {e}') + finally: + if claimed: + try: + _release_review(claimed) + except Exception as e: + out['errors'].append(f'{iid}: 释放复核占用失败:{e}') return out diff --git a/app/services/dispatcher.py b/app/services/dispatcher.py index 3a1dc38..9ce38f1 100644 --- a/app/services/dispatcher.py +++ b/app/services/dispatcher.py @@ -173,21 +173,35 @@ def dispatch(*, instruction_id: str, ts_code: str, side: str, qty: int, limit_pr if blocked: return {'ok': False, 'ref': None, 'mode': m, 'note': '', 'error': blocked} if m == MODE_WS: - with execution_orders.account_guard(): + from app.services import executor + now = datetime.now() + multi_day = executor.ordinary_days_left(parent, now) + guard = pms_repo.account_decision_guard if multi_day else execution_orders.account_guard + with guard(): parent = pms_repo.get_instruction(pid) blocked = execution_orders.correction_blocker(parent, ts_code=ts_code, side=str(side).lower()) if blocked: raise ValueError(blocked) - if execution_orders.enabled() and not qmt_repo.get_order(instruction_id): - from app.core.execution_policy import supported_code - if not supported_code(ts_code): - raise ValueError('执行范围仅限沪深合资格证券') - parent = pms_repo.get_instruction(pid) + reprice = execution_orders.enabled() + new_order = (multi_day or reprice) and not qmt_repo.get_order(instruction_id) + if new_order: if not parent or parent.get('status') not in ('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED'): raise ValueError('父指令未获准或已结束') progress = parent.get('progress') or {} if progress.get('cancel_requested'): raise ValueError('父指令正在撤销') + if multi_day and new_order: + days = executor.ordinary_days_left(parent, now) + if days: + available = executor.dispatch_allowance(parent, now, days) + if qty > available: + reason = f'本轮原计划{qty}股,按最新成交和在途委托当日还可投{available}股,下一轮重新计算' + return {'ok': False, 'deferred': True, 'ref': None, 'mode': m, + 'note': '', 'error': reason} + if reprice and new_order: + from app.core.execution_policy import supported_code + if not supported_code(ts_code): + raise ValueError('执行范围仅限沪深合资格证券') state = execution_orders.replacement_state(pid) if not state['ready'] or qty > state['remaining']: raise ValueError('旧子单未确认结束、成交未入账或数量超过剩余目标') diff --git a/app/services/execution_orders.py b/app/services/execution_orders.py index 3574256..d11f0fe 100644 --- a/app/services/execution_orders.py +++ b/app/services/execution_orders.py @@ -109,6 +109,11 @@ def prepare_send(instruction_id): blocked = correction_blocker(parent, ts_code=order['ts_code'], side=order['side']) if blocked: return {'marked': False, 'blocked': blocked} + if settings.INFRA_STRATEGY_BOOK_SCHEMA and not settings.PMS_TABLE_PREFIX: + from app.services.rotation_service import order_control_blocker + blocked = order_control_blocker(parent, order['side']) + if blocked: + return {'marked': False, 'blocked': blocked} return {'marked': qmt_repo.mark_send_attempt(instruction_id), 'blocked': ''} @@ -152,14 +157,25 @@ def replacement_state(parent_id): 'pending_trades': pending_trades, 'booked': booked, 'missing_orders': missing} -def code_settlement_blocker(ts_code): +def code_settlement_blocker(ts_code, *, manual_exit_day=None, manual_exit_requested_at=None): """跨父指令与策略检查迟到成交,不因旧父指令本地终态而再次建仓。""" with books.scope('all'): parents = pms_repo.list_instructions(ts_code=ts_code, limit=10001, include_archived=True) if len(parents) >= 10001: return '该股历史指令超过核验上限,等待核对' for parent in parents: + progress = parent.get('progress') or {} + same_exit = (manual_exit_day and parent.get('book_id') == books.MICRO and parent.get('side') == 'sell' + and progress.get('execution_profile') == 'rotation' and progress.get('deadline') == manual_exit_day) + cancelled = progress.get('cancel_requested') + if same_exit and cancelled and (not isinstance(cancelled, dict) or cancelled.get('arbiter') != 'system'): + cancelled_at = _receipt_time(cancelled.get('at')) if isinstance(cancelled, dict) else None + renewed_at = _receipt_time(manual_exit_requested_at) + if not renewed_at or not cancelled_at or renewed_at <= cancelled_at: + return '该股今日退出父单已被撤销,重新确认退出后才可继续' state = replacement_state(parent['instruction_id']) + if same_exit and state.get('active'): + return '该股旧退出委托仍在途,待撤成确认及成交入账' if state['pending_trades'] or state['booked'] < state['confirmed_filled'] or state['missing_orders']: return '该股已有成交或旧委托尚未核实入账' return '' diff --git a/app/services/executor.py b/app/services/executor.py index 7e1a37d..0b09b85 100644 --- a/app/services/executor.py +++ b/app/services/executor.py @@ -180,7 +180,7 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict: slices = param_store.get_int("PMS_EXEC_SLICES", 1) order_ttl = param_store.get_int("PMS_ORDER_TTL_MIN", 10) # 单个分片挂单有效期(交易分钟) brake_active = td.ymd() < param_store.get_int("PMS_BRAKE_UNTIL", 0) - ymd_today = td.ymd() + ymd_today = td.ymd(now) for ins in instrs: out["checked"] += 1 @@ -237,16 +237,25 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict: out['errors'].append(cancelled.get('message') or '清仓停止买入尚未完成') continue from app.services import daily_buy_review - blocked = daily_buy_review.blocker(ins, now=now) or execution_conflicts.buy_blocker(code) + review_block = daily_buy_review.blocker(ins, now=now) + blocked = review_block or execution_conflicts.buy_blocker(code) if blocked: - prog['last_decision'] = {'at': now.strftime('%H:%M'), 'action': 'WAIT', 'reason': blocked} - if not dry_run: + # 跨日复核自行保存等待与批准。不能以执行扫描较早读到的进度抹去排队和批准。 + if not dry_run and not review_block: + prog['last_decision'] = {'at': now.strftime('%H:%M'), 'action': 'WAIT', 'reason': blocked} pms_repo.update_instruction(ins['instruction_id'], progress=prog) out['waited'].append({'instruction_id': ins['instruction_id'], 'code': code, 'reason': blocked}) continue # 回放与下发是两个任务。出口已成交时,exec_qty 可能还没更新, # 不能把「已终态、不在途」误当成「父指令还有额度」。 - available = _parent_available(ins, children) + if dispatcher.mode() == dispatcher.MODE_WS: + remaining, available, filled_today, pending_today = _order_usage(ins, children, ymd_today) + else: + # 影子委托没有真实出口回报,只能把未核实的当日下发保留为在途。 + pending_today = _inflight_today(children, ymd_today) + consumed = _consumed_today(children, ymd_today) + filled_today = min(int(ins.get('exec_qty') or 0), max(0, consumed - pending_today)) + available = remaining if side == 'buy': available = min(available, daily_buy_review.allowance(ins, now=now)) if available <= 0: @@ -259,22 +268,15 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict: continue day = market.day_snapshot(code) pos = _pos_of(view, code) - quota = et.daily_quota(remaining, tdays_left, lot=lot_of(code), - allow_odd_tail=(ins.get("action") == "EXIT")) - # 当日配额的「今日已投放量」口径分两种: - # 普通多日单 —— _consumed_today (今日已成交 + 今日在途), 给多日出手节流用。 - # 紧急单 / 窗口末日单 —— 只按「今日在途量」算 (_inflight_today)。这两类单的 - # 配额本来就等于全部剩余量, 而剩余量 = 委托量 − 累计成交, 已经扣过成交一次; - # 若再从「已投放量」里把今日成交扣第二遍, 同一笔成交被扣两次, 当天成交越多, - # 「可再投放 = 配额 − 已投放」越快变成负数 —— 于是发一两笔、成交回来之后就误判 - # 「当日配额已出完」, 当天不再补单, 连 14:45 强制兜底也被挡在这道判断前面, - # 要等次日配额清零才继续。这正是 2026-08-19 紧急清仓剩三支拖到次日早盘的根因。 - # 只按在途量扣: 可再投放 = 剩余 − 在途, 永不重复扣, 紧急清仓当天会持续补单, - # 父指令总量另由 _parent_available 限制。可卖量只能保护账户持仓, - # 不能保护某次只卖一半的指令,更不能假定回放已及时更新 exec_qty。 is_urgent = bool(prog.get("urgent")) - fired_today = (_inflight_today(children, ymd_today) if (is_urgent or is_last) - else _consumed_today(children, ymd_today)) + if is_urgent or is_last: + # 紧急命令保留其指定窗口。末日配额等于全部剩余,仅再扣尚可成交的在途份额。 + quota = _day_quota(ins, remaining, tdays_left) + fired_today = pending_today + else: + # 普通指令以日初未完成量分日。同一天的部分成交只消费一次当日配额。 + quota = _day_quota(ins, remaining + filled_today, tdays_left) + fired_today = filled_today + pending_today lim_up, lim_down = _limit_flags(code, day) day_ctx = {**day, "support": pos.get("support_ref"), "limit_up": lim_up, "limit_down": lim_down, @@ -325,6 +327,10 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict: qty = slice_list[0] if slice_list else 0 if side == "sell": qty = min(qty, int(pos.get("avail_qty") or 0)) + # 部分成交可能留下非整百额度。可申报的整百先出,卖出实际全部持仓时保留零股。 + sell_entire_position = side == 'sell' and qty == int(pos.get("total_qty") or 0) + if qty >= et.LOT and not sell_entire_position: + qty = qty // et.LOT * et.LOT budget_reason = None if side == 'buy' and qty > 0: from app.services.buy_budget import allowed_quantity @@ -425,7 +431,11 @@ def run_tick(*, now=None, dry_run: bool = False) -> dict: valid_until=now.replace(hour=dl_min // 60, minute=dl_min % 60, second=0, microsecond=0)) if not res.get("ok"): - out["errors"].append(f"{ins['instruction_id']} 下发失败: {res.get('error')}") + if res.get('deferred'): + out['waited'].append({'instruction_id': ins['instruction_id'], 'code': code, + 'action': et.ACT_WAIT, 'reason': res['error']}) + else: + out["errors"].append(f"{ins['instruction_id']} 下发失败: {res.get('error')}") continue children.append({"ymd": ymd_today, "at": now.strftime("%H:%M:%S"), "qty": qty, @@ -611,45 +621,73 @@ def _child_id(instruction_id: str, n: int) -> str: return f"{instruction_id}_D{n:02d}" -def _parent_available(ins: dict, children: list) -> int: - """父指令总量减去已成交量与仍可成交量,不把通道回报当作账本入账。 +def _day_quota(parent, remaining, days_left): + return et.daily_quota(remaining, days_left, lot=lot_of(parent['ts_code']), + allow_odd_tail=parent.get('action') == 'EXIT') - 已成交取父指令与全部出口子单累计成交的较大值,兼容任一方暂时领先。 - 在途子单再预留尚未成交的数量;终态只释放未成交部分。必须跨日查询, - 也必须包含已入出口但没写回 progress 的子单。查询失败由调用方报错,禁止下发。 - """ - from app.services import execution_orders - if execution_orders.correction_blocker(ins): + +def ordinary_days_left(parent, now): + progress = (parent or {}).get('progress') or {} + if progress.get('urgent') or progress.get('execution_profile') == 'rotation' or not progress.get('deadline'): return 0 + days = td.trade_days_left(progress['deadline'], now) + return days if days > 1 else 0 + + +def dispatch_allowance(parent, now, days_left): + remaining, available, filled, pending = _order_usage( + parent, (parent.get('progress') or {}).get('children') or [], td.ymd(now)) + quota = _day_quota(parent, remaining + filled, days_left) + return max(0, min(available, quota - filled - pending)) + + +def _order_usage(ins, children, today): + """同一批出口回报计算父单剩余、可投量、当日成交和当日在途,兼容进度漏记子单。""" + from app.services import execution_orders target = int(ins['qty']) booked = int(ins.get('exec_qty') or 0) - if dispatcher.mode() != dispatcher.MODE_WS: - return max(0, target - booked) - filled, pending = 0, 0 + child_days = {c['ref']: int(c.get('ymd') or 0) for c in children if c.get('ref')} + filled = pending = filled_today = pending_today = 0 seen = set() for order in qmt_repo.orders_for_parent(ins['instruction_id']): ref = order['instruction_id'] if ref in seen: raise ValueError('同一父指令的出口子单重复,暂停下发') seen.add(ref) - qty = int(order['qty']) done = execution_orders.effective_filled(order) status = str(order.get('status') or '').upper() + live = 0 if status in qmt_repo.FINAL else int(order['qty']) - done filled += done - if status not in qmt_repo.FINAL: - pending += qty - done + pending += live + day = td.ymd(order['created_at']) if order.get('created_at') else child_days.get(ref) + if day == today or not day: + # 无法定位日期的旧单按可能占用今日份额计。其成交仍只扣一次,紧急退出仍可执行。 + filled_today += done + pending_today += live for child in children: ref = child.get('ref') if ref in seen: continue - # 查不到出口的既有下发,或切换模式前的人工委托,保守预留全部数量。 qty = int(child['qty']) if qty <= 0: raise ValueError('既有子单数量异常,暂停下发') pending += qty + if not child.get('ymd') or int(child['ymd']) == today: + pending_today += qty if ref: seen.add(ref) - return max(0, target - max(booked, filled) - pending) + remaining = max(0, target - max(booked, filled)) + return remaining, max(0, remaining - pending), filled_today, pending_today + + +def _parent_available(ins: dict, children: list) -> int: + """父单总量兼容尚未入账的成交、在途与漏记子单,成交待修正时关闭。""" + from app.services import execution_orders + if execution_orders.correction_blocker(ins): + return 0 + if dispatcher.mode() != dispatcher.MODE_WS: + return max(0, int(ins['qty']) - int(ins.get('exec_qty') or 0)) + return _order_usage(ins, children, None)[1] def _consumed_today(children: list, ymd_today: int) -> int: diff --git a/app/services/param_store.py b/app/services/param_store.py index f15c300..4231f47 100644 --- a/app/services/param_store.py +++ b/app/services/param_store.py @@ -21,6 +21,7 @@ import time from config.settings import settings from app.repo import pms_repo +from app.db import session as db logger = logging.getLogger("pms.params") @@ -124,7 +125,7 @@ RUNTIME_EXTRA = { # 2026-08-14: 上游信号告警面板的三个显示参数。原来只在 upstream_signals.py 里用 get_int # 兜底、没登记, 所以设置页调不到、改一次得重新部署。注册进来后可在页面实时调 (即时生效)。 "PMS_UPSTREAM_ALERT_SCAN": (300, int, "告警扫描窗: 每轮从告警流取最近 N 条再分类限量 (窗要大于各类上限之和, 防 price_notice 等高频源把风控告警挤出最新N)"), - "PMS_UPSTREAM_ALERT_PER_CAT": (20, int, "告警每类上限: 同一类型最多显示最新 N 条 (砍单类刷屏, 不挤别的类)"), + "PMS_UPSTREAM_ALERT_PER_CAT": (20, int, "历史兼容参数;现行告警按当天来源分页,每类不再单独截断"), "PMS_UPSTREAM_ALERT_MAX_AGE_MIN": (60, int, "告警时间窗(分钟): 超过此龄判为陈旧并在页面置灰标注(不删除, 风控不丢信息), 0=不限龄。与每类上限正交, 先按龄标记再每类限量"), # 2026-09-09: 点股票看它今天全部信号 (台账 055)。快照口径只留每类最新 N 条, 到下午 # 一只活跃票早盘的信号早被挤掉; 按代码回扫是另一条路径, 上限单独可调。 @@ -467,23 +468,55 @@ def _type_of(key: str): return str +def _current_cache(*, force=False): + state = db.transaction_state() + if state is None: + return _cache + local = state.local.get("params") + if local is None and not force and _cache["loaded"] and time.time() - _cache["at"] < CACHE_TTL: + return _cache + # 保存点内的读数不能沿用到其回滚或释放之后;写入过的外层事务始终看自己的表值。 + scope = db._TRANSACTION.get().get_nested_transaction() + if local is None or local.get("scope") is not scope: + local = state.local["params"] = {"scope": scope, "loaded": False, "at": 0, "data": {}, "error": None} + return local + + +def _refresh_cache(cache, now): + try: + rows = pms_repo.all_params() + cache.update({"data": rows, "at": now, "error": None, "loaded": True}) + except Exception as exc: + msg = f"{type(exc).__name__}: {exc}" + changed = cache.get("error") != msg + cache.update({"at": now, "error": msg, "loaded": True}) + if changed: + logger.warning("参数表读取失败, 退回 settings 初值: %s", exc) + + def refresh(force: bool = False) -> dict: - """拉一次表值 (带 TTL 缓存)。连库失败不抛异常 —— 退回文件初值并记 error。""" + """事务内刚写的参数仅在本事务可见。进程共享缓存只从已提交的数据刷新。""" + cache = _current_cache(force=force) now = time.time() - if not force and _cache["loaded"] and now - _cache["at"] < CACHE_TTL: - return _cache["data"] + if cache["loaded"] and not force and now - cache["at"] < CACHE_TTL: + return cache["data"] + if db.transaction_state() is not None: + # 共享快照可能正好到期或被另一线程失效,此处也必须改用私有读数。 + cache = _current_cache(force=True) + _refresh_cache(cache, now) + else: + with _lock: + _refresh_cache(cache, now) + return cache["data"] + + +def _invalidate_shared(): with _lock: - try: - rows = pms_repo.all_params() - _cache.update({"data": rows, "at": now, "error": None, "loaded": True}) - except Exception as e: - msg = f"{type(e).__name__}: {e}" - changed = _cache.get("error") != msg - # 失败也要更新时间戳并置 loaded, 否则下一次 get() 立刻又去连库 - _cache.update({"at": now, "error": msg, "loaded": True}) - if changed: # 同一个错误只吼一次, 恢复或换错才再吼 - logger.warning("参数表读取失败, 退回 settings 初值: %s", e) - return _cache["data"] + _cache["loaded"] = False + + +def _is_simulation_halt(key): + return key == 'PMS_GLOBAL_EXEC_HALT' and settings.INFRA_STRATEGY_BOOK_SCHEMA and not settings.PMS_TABLE_PREFIX def get(key: str, default=None): @@ -498,12 +531,13 @@ def get(key: str, default=None): t = _type_of(key) # 表读不到时, 安全开关按"拦"而不是按默认值放行 —— 见 FAIL_CLOSED 的注释。 # 只在**表确实读失败**时生效; 表读到了而这个键没设过, 那是真的没设, 照常走默认值。 - if _cache.get("error") and key in FAIL_CLOSED and key not in rows: + error = _current_cache().get("error") + if error and key in FAIL_CLOSED and key not in rows: logger.error("[参数] 读不到 %s (参数表: %s) —— 按 fail-closed 取 %r, " - "宁可多拦一轮也不放行", key, _cache["error"], FAIL_CLOSED[key]) + "宁可多拦一轮也不放行", key, error, FAIL_CLOSED[key]) return FAIL_CLOSED[key] if key in rows: - if key in LIMIT_FLAGS and not _valid_limit_flag(rows[key].get('param_value')): + if (key in LIMIT_FLAGS or _is_simulation_halt(key)) and not _valid_limit_flag(rows[key].get('param_value')): return FAIL_CLOSED[key] try: return _coerce(rows[key]["param_value"], t) @@ -516,6 +550,51 @@ def get(key: str, default=None): return default +def execution_halted(*, locked=False): + """止损观察与执行分流必须看当前暂停命令;持账户锁时同时锁定参数行。""" + key = 'PMS_GLOBAL_EXEC_HALT' + try: + raw = pms_repo.get_param(key, for_update=True) if locked else pms_repo.get_param(key) + except Exception as exc: + logger.warning('当前暂停命令读取失败,停止执行: %s', type(exc).__name__) + return True + if raw is None: + return RUNTIME_EXTRA[key][0] + if not _valid_limit_flag(raw): + return True + return _coerce(raw, bool) + + +def current_rotation_param(key, *, locked=False): + """轮换开关决定是否允许下单,直接读取当前事务的运行参数。""" + if key not in ('PMS_ROTATION_MODE', 'PMS_ROTATION_CONTROL'): + raise ValueError('此参数不属于轮换执行控制') + raw = pms_repo.get_param(key, for_update=locked) + value = RUNTIME_EXTRA[key][0] if raw is None else raw + allowed = ('observe', 'paper', 'auto') if key == 'PMS_ROTATION_MODE' else ('run', 'pause_new', 'pause_all', 'exit_disable') + if value not in allowed: + raise ValueError('轮换执行控制取值无效') + return value + + +def locked_open_param(key): + """建仓最终批准读取本事务内最新的授权,读取失败由调用方保持暂停。""" + if key not in ('PMS_GLOBAL_BUY_HALT', 'PMS_SELF_DECIDE_DAILY_MAX', 'PMS_SELF_DECIDE', + 'PMS_SELF_DECIDE_TRIAL', 'PMS_AUTONOMY', 'PMS_OPEN_AUTONOMY', + 'PMS_OPEN_AUTO_EXEC_ON_VERDICT'): + raise ValueError('此参数不属于建仓授权') + raw = pms_repo.get_param(key, for_update=True) + if raw is None: + return getattr(settings, key) if hasattr(settings, key) else RUNTIME_EXTRA[key][0] + typ = _type_of(key) + if typ is bool and not _valid_limit_flag(raw): + raise ValueError('当前建仓授权取值无效') + value = int(raw) if typ is int else _coerce(raw, typ) + if _range_check(key, value): + raise ValueError('当前建仓授权取值超出有效范围') + return value + + def get_float(key, default=0.0): try: return float(get(key, default)) @@ -553,6 +632,9 @@ def get_tuple_floats(key, default=(0.5, 0.25, 0.25)): def set_param(key: str, value, updated_by: str = "user") -> dict: """页面改参入口。校验键名与类型后落表, 并立即失效缓存。""" editable = _editable_keys() + simulation_halt = _is_simulation_halt(key) + if simulation_halt and not _valid_limit_flag(value): + return {'ok': False, 'error': '全局暂停执行必须明确选择开启或关闭'} if key in LIMIT_FLAGS and not _valid_limit_flag(value): return {'ok': False, 'error': '限制价开关必须为明确的布尔值'} if key not in editable and key not in RUNTIME_EXTRA and not key.startswith("PMS_SECTOR_CAP_"): @@ -567,11 +649,23 @@ def set_param(key: str, value, updated_by: str = "user") -> dict: if bad: return {"ok": False, "error": bad} try: - pms_repo.set_param(key, v, updated_by) + # 包含参数行尚未创建的首个暂停命令,与模拟账户退出事务按同一账户锁排序。 + if simulation_halt: + from app.repo import rotation_repo + with rotation_repo.account_guard(): + pms_repo.set_param(key, v, updated_by) + else: + pms_repo.set_param(key, v, updated_by) except Exception as e: return {"ok": False, "error": f"写入失败: {type(e).__name__}: {e}"} - _cache["loaded"] = False - refresh(force=True) + state = db.transaction_state() + if state is None: + _invalidate_shared() + refresh(force=True) + else: + # 即使随后回滚保存点,也应从所在事务重新读表。失效动作在最外层提交后才可见。 + _current_cache(force=True)["loaded"] = False + state.after_commit.add(_invalidate_shared) return {"ok": True, "key": key, "value": v} @@ -707,7 +801,7 @@ def _range_check(key, v): def snapshot() -> dict: """页面「参数设置」用: 每个可调参数的 当前值/来源/初值/说明。""" rows = refresh() - out = {"params": [], "source_error": _cache.get("error")} + out = {"params": [], "source_error": _current_cache().get("error")} for key, field in sorted(_editable_keys().items()): cur = get(key) out["params"].append({ diff --git a/app/services/plan_feed.py b/app/services/plan_feed.py index 22662b5..4461300 100644 --- a/app/services/plan_feed.py +++ b/app/services/plan_feed.py @@ -1210,7 +1210,13 @@ def candidates(*, held=(), black=(), route_by_verdict: bool = False, force=False 显式传 True。要让命令驱动也按判决过滤, 改这里的调用方, 不改默认值。 """ p = _params() - plan = plan_override if plan_override is not None else (get_plan(force=force) if force else get_plan()) + if plan_override is not None: + plan = plan_override + elif recheck_code: + # 已入选的股票只复核当前资格。普通榜单的返回上限仅用于发现新仓。 + plan = read_current_plan(code=recheck_code) + else: + plan = get_plan(force=True) if force else get_plan() route = bool(route_by_verdict) if not allow_user: plan = dict(plan, **{b: [r for r in plan.get(b, []) if not r.get('user_required')] for b in ('main', 'observe')}) @@ -1237,6 +1243,9 @@ def candidates(*, held=(), black=(), route_by_verdict: bool = False, force=False 'recheck_code': recheck_code} if recheck_code: out['items'] = [r for r in out['items'] if r['ts_code'] == recheck_code] + for row in out['items']: + # 逐票回执带完整研究名次,本次没有全池候选排序。 + row.pop('selection_rank', None) consumption = {'kind': 'rechecked' if recheck_code else 'consumed', 'decision': plan.get('decision'), 'params': effective, 'context': context, 'rank_mode': out['rank_mode'], 'filtered': out['filtered'], 'order': [r['ts_code'] for r in out['items']]} diff --git a/app/services/plan_recheck.py b/app/services/plan_recheck.py index 7548559..dafeee6 100644 --- a/app/services/plan_recheck.py +++ b/app/services/plan_recheck.py @@ -2,7 +2,7 @@ from datetime import datetime, timedelta import logging import re -from app.core.plan_revision import compare, fingerprint, portfolio_context, confirmation_revision +from app.core.plan_revision import compare, fingerprint, portfolio_context, confirmation_revision, needs_new_judgement from app.services.plan_feed import PlanFeedError logger = logging.getLogger('pms.proposal.prepare') @@ -16,12 +16,9 @@ def current_basis(hard, code, proposal_id=None, *, record=True): feed = plan_feed if hard.get('candidate_source') == 'dividend': from app.services import dividend_feed as feed - options = {'record': record} - else: - options = {'force': True} if record else {'record': False, 'plan_override': plan_feed.read_current_plan(code=code)} selected = feed.candidates(held=[x['ts_code'] for x in view['held']], black=[c for c, v in stock.items() if v.get('black')], - route_by_verdict=bool(params.get('open_route_by_verdict')), recheck_code=code, **options) + route_by_verdict=bool(params.get('open_route_by_verdict')), recheck_code=code, record=record) current = next((r for r in selected['items'] if r['ts_code'] == code), None) if not (selected.get('decision') or {}).get('id'): return {'ok': False, 'error': '当前研究资料暂不可用,恢复后自动更新建议', 'stage': 'source'} @@ -281,10 +278,19 @@ def refresh_one(p, *, now=None, deadline=None): if not fresh: return _failed_recheck(p, out) c = fresh[0] + if hard.get('candidate_source') != 'dividend': + # 单票重评没有与其他候选竞争,原扫描的先后顺序仍在原消费记录中。 + for key in ('selection_rank', 'execution_rank', 'priority_reason'): + c['hard_numbers'].pop(key, None) from app.services.buy_budget import from_hard previous_budget = from_hard(hard, p['ts_code']) if previous_budget is not None: c.setdefault('hard_numbers', {})['buy_budget'] = previous_budget + # 重新评估取到的发布版可能刚在第一次核对后变化。旧批准只能复用于相同的研究材料。 + if not needs_model and needs_new_judgement(c['hard_numbers'], hard): + needs_model = True + if not ps._judge_budget_left(deadline): + return _pending_response(p, '等待下一轮完成研究更新', 'budget') c['_plan_recheck'] = needs_model verdict = None if needs_model else _judgement(p) result = ps._route_one(c, check['view'], params, check['stock'], diff --git a/app/services/proposal_service.py b/app/services/proposal_service.py index e1cc7ea..26490de 100644 --- a/app/services/proposal_service.py +++ b/app/services/proposal_service.py @@ -28,6 +28,7 @@ """ from __future__ import annotations +from contextlib import nullcontext import logging import time from datetime import datetime, timedelta @@ -103,15 +104,9 @@ def scan_and_route(*, now=None, dry_run: bool = False, review_instruction=None, stock_params = command_service.effective_stock_params() mkt = _market_ctx(view["held"], now) params["_mkt"] = mkt # 规则闸要用同一份 MA5, 不再重取 - # 系统自决每日新建仓上限的基数: 今天已自动采纳几只 (评审账本按前缀数)。只读一次, - # 本轮内 _route_one 每采纳一只再往 out["_sd_accepts"] 加, 两者相加即当日累计。off 时不查库。 + # 此读数供试算和初筛。实际批准前会在账户锁内重读并占用名额。 if ae.self_decide_on(params): - try: - _t0 = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) - params["_sd_base_count"] = pms_repo.system_pass_count_today(_t0) - except Exception as e: # noqa: BLE001 - logger.warning("[系统自决] 读当日已采纳数失败 (本轮按 0 起算): %s", e) - params["_sd_base_count"] = 0 + params["_sd_base_count"] = _auto_open_count(now) # 跳过三类: ①已有在途提议或指令的 ②今天已被规则闸拒过的 ③今天已被研判闸驳回的新建仓。 # ② 是 2026-07-29 的教训 —— 组合已超总仓上限时, 16 只深亏票的补仓候选每分钟被拒 # 一次, 一天往评审账本灌几千行一模一样的记录。闸门结论当天基本不会变, 记一次就够。 @@ -1069,7 +1064,10 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out, # 重问放行也归自决 (试探仓): 先给它打上 decide_kind, 再交 _self_decide 判。 if c.get("reask") and ae.self_decide_on(params) and not c.get("decide_kind"): c["decide_kind"] = ae.DK_REASK - sd = _self_decide(c, verdict, params, params.get("_sd_base_count", 0) + out.get("_sd_accepts", 0)) + count = params.get("_sd_base_count", 0) + if count is not None: + count += out.get("_sd_accepts", 0) + sd = _self_decide(c, verdict, params, count) if sd.get("would") and sd["would"] != "none": _con = _sd_consensus_brief(c) out.setdefault("self_decide_seen", []).append( @@ -1081,8 +1079,6 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out, sd_decision = sd.get("decision", "none") if sd_decision == "accept": auto_exec, force_queue = True, False - if is_open: - out["_sd_accepts"] = out.get("_sd_accepts", 0) + 1 elif sd_decision == "decline": # 自动放弃: 落账 (评审方 system) + 追加 rejected by system + 当日不重评 + 返回 if dry_run: @@ -1125,6 +1121,8 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out, 'self_decide': sd} if dry_run: + if is_open and sd_decision == "accept": + out["_sd_accepts"] = out.get("_sd_accepts", 0) + 1 (out["executed"] if auto_exec else out["queued"]).append( {**_brief(c), "route": "auto" if auto_exec else "queue", "judge": verdict["verdict"], "dry_run": True, @@ -1162,52 +1160,55 @@ def _route_one(c, view, params, stock_params, brake_active, now, dry_run, out, logger.warning("[自决清仓] 停买入侧有未成项 %s: %s", code, r["errors"]) except Exception as e: # noqa: BLE001 logger.warning("[自决清仓] 停买入侧失败 %s (清仓照落): %s", code, e) - elif sd_accept and is_open: - # 试探仓类采纳: 把数量重算成建议档 (弱基本面那类还带上紧止盈标记 advice.tight_trail)。 - _apply_advice_tier(c, c.setdefault("hard_numbers", {}), verdict, - force_trial=(sd.get("tier") == "trial")) + original_reason = c["reason"] if sd_accept: # 指令与账本理由一致。到价清仓把原句 (现价/目标价/股数) 接在后面, 复盘看得见到的是什么价 (09-14 评审补)。 _why = sd.get("why") or c["reason"] if sd.get("rule") == ae.DK_TARGET_PRICE and c.get("reason"): _why = f"{_why};{c['reason']}" c["reason"] = _why - iid = _make_instruction(c, price, now) - if sd_accept: - reason = c["reason"] - _dc = params.get("_sd_base_count", 0) + out.get("_sd_accepts", 0) + reason = _why hard = {**(c.get("hard_numbers") or {}), - "self_decide": _self_decide_hard(c, verdict, sd, params, strat_cancelled, _dc, + "self_decide": _self_decide_hard(c, verdict, sd, params, strat_cancelled, count, buys_cancelled=buys_cancelled)} else: reason = verdict.get("reason") or c["reason"] if auto_why: reason = f"判决候选自动执行: {reason}" hard = c["hard_numbers"] - pms_repo.insert_ledger(ts_code=code, action=action, - arbiter="judge" if c.get("judge_required") else "rule", - verdict="PASS", price_at=price, hard_numbers=hard, - ref_id=iid, reason=reason[:500]) - out["executed"].append({**_brief(c), "instruction_id": iid, - "why": (sd.get("why") if sd_accept else - ("减持自动执行 (规则触发, 来源没有要求交人裁决)" - if side == "sell" - else (auto_why or ("新建仓档位 full" if is_open - else "档位 full"))))}) - else: - pid = _make_proposal(c, price, verdict) - # 交人的原因按从具体到笼统取: 重问放行 → 上游标的硬风险 → 候选自带的 (关注判决等, - # 见 action_engine.verdict_confirm_why) → 来源强制的 (研究证据走弱那类减持) → - # 深档补仓那条老规矩 → 研判不可用 → 档位。 - # 重问放行仍排在最前 (2026-09-09 拍板): 它是这张提议最需要人知道的那件事 - # (曾被驳回、什么变了、可能买不上)。硬风险 (2026-09-10 加) 紧随其后 —— 两者 - # 实际上几乎不会同时出现: 上游标了硬风险的票判决多半不是「候选」, 走不到重问那一步, - # 所以这个次序之争是空的, 不必为它推翻上一次拍板。 - why = (reask_why or risk_why or c.get("confirm_why") or src_why - or ("深档补仓强制确认" if c.get("needs_user_confirm") else None) - or ("研判不可用, 降级人工确认" if verdict.get("degraded") else None) - or ("新建仓档位 propose_only" if is_open else "档位 propose_only")) - out["queued"].append({**_brief(c), "proposal_id": pid, "why": why}) + result = _save_automatic_action(c, price, now, hard, reason, sd_accept, params, out, auto_why) + if result.get('skip'): + out['skipped'].append({**_brief(c), 'why': result['skip']}) + return + if result.get('confirm'): + c['confirm_why'] = result['confirm'] + # 恢复交易员看到的决定与原因;保存后的实际处置优先于初筛。 + c['reason'] = original_reason + out['self_decide_seen'][-1].update( + would='confirm', decision='confirm', tier=None, why=result['confirm']) + else: + if is_open and sd_accept: + out["_sd_accepts"] = out.get("_sd_accepts", 0) + 1 + out["executed"].append({**_brief(c), "instruction_id": result['instruction_id'], + "why": (sd.get("why") if sd_accept else + ("减持自动执行 (规则触发, 来源没有要求交人裁决)" + if side == "sell" + else (auto_why or ("新建仓档位 full" if is_open + else "档位 full"))))}) + return + pid = _make_proposal(c, price, verdict) + # 交人的原因按从具体到笼统取: 重问放行 → 上游标的硬风险 → 候选自带的 (关注判决等, + # 见 action_engine.verdict_confirm_why) → 来源强制的 (研究证据走弱那类减持) → + # 深档补仓那条老规矩 → 研判不可用 → 档位。 + # 重问放行仍排在最前 (2026-09-09 拍板): 它是这张提议最需要人知道的那件事 + # (曾被驳回、什么变了、可能买不上)。硬风险 (2026-09-10 加) 紧随其后 —— 两者 + # 实际上几乎不会同时出现: 上游标了硬风险的票判决多半不是「候选」, 走不到重问那一步, + # 所以这个次序之争是空的, 不必为它推翻上一次拍板。 + why = (reask_why or risk_why or c.get("confirm_why") or src_why + or ("深档补仓强制确认" if c.get("needs_user_confirm") else None) + or ("研判不可用, 降级人工确认" if verdict.get("degraded") else None) + or ("新建仓档位 propose_only" if is_open else "档位 propose_only")) + out["queued"].append({**_brief(c), "proposal_id": pid, "why": why}) def _verdict_auto_exec_why(c, verdict): @@ -1263,7 +1264,73 @@ def verify_open_basis(hard, code): return {'ok': False, 'error': f'当前计划版本无法核验:{type(e).__name__}'} -def _make_instruction(c, price, now) -> str: +def _auto_open_count(now): + try: + return pms_repo.system_pass_count_today(now.replace(hour=0, minute=0, second=0, microsecond=0)) + except Exception: + logger.exception("无法核实今日自动建仓只数") + return None + + +def _quota_confirm_reason(count, maximum): + if maximum and count is None: + return "今日自动建仓只数暂时无法核实,交人裁决" + if maximum and count >= maximum: + return f"今日自动新建仓已达上限 {maximum} 只,本只转交人裁决" + return None + + +def locked_open_authorization(params, out=None, *, trial=False, verdict_override=False): + """模型等待期间用户可能改变授权;在短提交事务中验证当前开关。""" + if param_store.execution_halted(locked=True) or param_store.locked_open_param('PMS_GLOBAL_BUY_HALT'): + return '当前账户已暂停执行或买入,自动建仓暂缓' + mode = param_store.locked_open_param('PMS_AUTONOMY') + open_mode = param_store.locked_open_param('PMS_OPEN_AUTONOMY') + if mode == AUTONOMY_OFF or open_mode == AUTONOMY_OFF: + return '当前已关闭自主建仓,暂缓执行' + if out and open_mode != (out.get('open_autonomy') or AUTONOMY_FULL): + return '自主建仓档位已改变,下一轮按最新授权评估' + if (params.get('self_decide') or 'off') != param_store.locked_open_param('PMS_SELF_DECIDE'): + return '系统自决档位已改变,下一轮按最新授权评估' + if trial and not param_store.locked_open_param('PMS_SELF_DECIDE_TRIAL'): + return '试探仓自动采纳已关闭,下一轮重新评估' + if verdict_override and not param_store.locked_open_param('PMS_OPEN_AUTO_EXEC_ON_VERDICT'): + return '候选自动采纳已关闭,下一轮重新评估' + return None + + +def _save_automatic_action(c, price, now, hard, reason, sd_accept, params, out, auto_why): + from app.services import buy_budget + is_open = c['action'] == ae.A_OPEN + with pms_repo.account_decision_guard() if is_open else nullcontext(): + if is_open: + stopped = locked_open_authorization(params, out, + trial=(hard.get('self_decide') or {}).get('tier') == '试探仓', verdict_override=bool(auto_why)) + if stopped: + return {'skip': stopped} + # 同一轮重试沿用同一指令号;另一次并发扫描也不能给在途买单重复建仓。 + iid = cs.make_instruction_id(td.ymd(now), c['ts_code'], c['action'], int(now.strftime('%H%M%S'))) + if pms_repo.get_instruction(iid) or pms_repo.list_instructions( + ts_code=c['ts_code'], side='buy', statuses=buy_budget.LIVE, limit=1): + return {'skip': '这只股票已有买入安排,本轮不重复建仓'} + if sd_accept: + maximum = param_store.locked_open_param('PMS_SELF_DECIDE_DAILY_MAX') + current = _auto_open_count(now) + hard['self_decide']['daily_max'] = maximum + why = _quota_confirm_reason(current, maximum) + if why: + return {'confirm': why} + hard['self_decide']['daily_count'] = current + 1 if current is not None else None + iid = _make_instruction(c, price, now, account_locked=is_open) + saved = pms_repo.insert_ledger(ts_code=c['ts_code'], action=c['action'], + arbiter='judge' if c.get('judge_required') else 'rule', + verdict='PASS', price_at=price, hard_numbers=hard, ref_id=iid, reason=reason[:500]) + if is_open and saved != 1: + raise RuntimeError('自动建仓批准记录未保存,本次指令已回滚') + return {'instruction_id': iid} + + +def _make_instruction(c, price, now, *, account_locked=False) -> str: ymd = td.ymd(now) # 序号用完整时分秒 (2026-08-28 修): 原来 %1000 只留「分钟个位+秒」, 同日同票同动作 # 第二条指令约 1/600 概率撞唯一键丢单一跳。撞了再退一步逐秒加一重试。 @@ -1272,13 +1339,13 @@ def _make_instruction(c, price, now) -> str: iid = None last_err = None from app.services import buy_budget, execution_orders - with execution_orders.account_guard(): + with nullcontext() if account_locked else execution_orders.account_guard(): budget = None if c['side'] == 'buy': buy_budget.before_parent(c['ts_code'], action=c['action']) if c['action'] == 'OPEN': budget = buy_budget.candidate(c.get('hard_numbers') or {}, c['ts_code'], c['qty'], price) - for salt in range(3): + for salt in range(1 if account_locked else 3): try_iid = cs.make_instruction_id(ymd, c["ts_code"], c["action"], seq + salt) try: affected = pms_repo.insert_instruction( @@ -1469,8 +1536,9 @@ def _self_decide(c, verdict, params, today_auto_count) -> dict: "why": "系统采纳:合议放行" + (f",研判通过(把握度 {int(conf)})" if conf is not None else "")} # 五, 每日自动新建仓上限: 超过转交人 (0 = 不限) dmax = int((params or {}).get("self_decide_daily_max") or 0) - if res["decision"] == "accept" and is_open and dmax and today_auto_count >= dmax: - return _mode({"decision": "confirm", "why": f"今日自动新建仓已达上限 {dmax} 只,本只转交人裁决"}) + quota_reason = _quota_confirm_reason(today_auto_count, dmax) + if quota_reason: + return _mode({"decision": "confirm", "why": quota_reason}) return _mode(res) diff --git a/app/services/risk_exit.py b/app/services/risk_exit.py index f341704..029f62e 100644 --- a/app/services/risk_exit.py +++ b/app/services/risk_exit.py @@ -119,10 +119,8 @@ def _sync(state, code, pos, lots, now, *, seed=True): {r['instruction_id'] for r in pos.get('_risk_lots', []) if r.get('instruction_id')}) -def _stop_commands(): - rows = pms_repo.list_effective_stock_params(('SET_STOP_PRICE',)) - if len(rows) >= 500: - raise ValueError('人工止损命令超过完整核验上限') +def _stop_commands(code=None): + rows = pms_repo.list_effective_stock_params(('SET_STOP_PRICE',), ts_code=code) out = {} for row in sorted(rows, key=lambda r: r['id']): if _code_ok(row.get('ts_code')): @@ -136,7 +134,7 @@ def observe_user_stop(code, quote, *, now=None): return None now = now or datetime.now() with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state: - event, why = rules.user_stop_event(_stop_commands().get(code), quote, now=now, + event, why = rules.user_stop_event(_stop_commands(code).get(code), quote, now=now, max_age=param_store.get_int('PMS_EXEC_MINUTE_MAX_AGE_SEC', 90)) if not event: return {'triggered': False, 'reason': why} @@ -358,6 +356,8 @@ def drive(code, *, now=None): with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state: if not state or not (enabled() or state.get('user_stop')) or state.get('phase') not in PAUSED: return + if not settings.PMS_TABLE_PREFIX and param_store.execution_halted(locked=True): + return if state.get('user_stop'): # 人工命令独立于评级扫描;清零后旧买单迟到仍须重开本轮收尾。 pos, lots = _holding(code) @@ -478,7 +478,7 @@ def resume_buy(code): 'reset_at': state['reset_at']}, state['round_id']) -def scan(*, now=None): +def scan(*, now=None, user_stops_only=False): out = {'enabled': enabled(), 'reviews': {}, 'user_stops': {}, 'errors': []} if not supported(): return out @@ -487,16 +487,19 @@ def scan(*, now=None): commands = _stop_commands() # 人工止损不依赖模型资料可用;评析读取异常不阻断已记录的退出收尾。 try: - states = logic_state_service.state_map() if out['enabled'] else {} + states = logic_state_service.state_map() if out['enabled'] and not user_stops_only else {} except Exception as exc: states = {} out['errors'].append(f'评析读取失败: {type(exc).__name__}: {exc}') 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) + if user_stops_only: + codes.intersection_update(commands) + else: + 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: command = commands.get(code) @@ -506,6 +509,8 @@ def scan(*, now=None): out['user_stops'][code] = observe_user_stop(code, quote, now=now) except Exception as exc: out['errors'].append(f'{code}人工止损: {type(exc).__name__}: {exc}') + if user_stops_only: + continue try: out['reviews'][code] = observe_review(code, (states.get(code) or {}).get('company_review'), now=now) from app.services import timing_state diff --git a/app/services/rotation_execution.py b/app/services/rotation_execution.py index 5ae1d42..94ce0b3 100644 --- a/app/services/rotation_execution.py +++ b/app/services/rotation_execution.py @@ -65,7 +65,7 @@ def enqueue_with_reservation(payload, parent_id): if any(old[k] != v for k, v in [('parent_id', parent_id), ('ts_code', code), ('side', side), ('qty', qty)]) or abs(float(old['limit_price'])-price) > 1e-8: raise ValueError('委托幂等键与内容冲突') return - if param_store.get_bool('PMS_GLOBAL_EXEC_HALT', False): + if settings.PMS_TABLE_PREFIX and param_store.get_bool('PMS_GLOBAL_EXEC_HALT', False): raise ValueError('用户暂停全部执行') with books.scope('all'): parent = pms_repo.get_instruction(parent_id) @@ -79,7 +79,11 @@ def enqueue_with_reservation(payload, parent_id): from app.services.buy_budget import check_order with books.scope(book): check_order(parent, payload) - if side == 'buy': + if not settings.PMS_TABLE_PREFIX: + blocked = service.order_control_blocker(parent, side) + if blocked: + raise ValueError(blocked) + if settings.PMS_TABLE_PREFIX and side == 'buy': if param_store.get_bool('PMS_GLOBAL_BUY_HALT', False): raise ValueError('用户暂停买入') reason = service.strategy_buy_blocker(book, parent) @@ -171,9 +175,15 @@ def send_intent(intent, price, now, snapshot_version): parent = intent['id'] book = intent['book_id'] with books.scope(book), db.transaction(): - blocker = execution_orders.code_settlement_blocker(intent['ts_code']) - if blocker: - raise ValueError(blocker) + if intent.get('manual_exit_cutoff'): + blocker = execution_orders.code_settlement_blocker(intent['ts_code'], manual_exit_day=now.date().isoformat(), + manual_exit_requested_at=intent.get('manual_exit_requested_at')) + if blocker: + return {'instruction_id': parent, 'state': blocker, 'pending': True} + else: + blocker = execution_orders.code_settlement_blocker(intent['ts_code']) + if blocker: + raise ValueError(blocker) existing = pms_repo.get_instruction(parent) if not existing: command = 'ROT_CMD_'+book+'_'+now.strftime('%Y%m%d') @@ -190,7 +200,8 @@ def send_intent(intent, price, now, snapshot_version): ts_code=intent['ts_code'], action=action, side=intent['side'], qty=intent['qty'], window_tdays=1, progress={'execution_profile': 'rotation', 'snapshot_version': snapshot_version, 'rule_version': intent.get('rule_version', core.RULE), - 'deadline': now.date().isoformat(), 'is_command': True, 'children': []}) + 'deadline': now.date().isoformat(), 'is_command': True, 'children': [], + **{k:intent[k] for k in ('manual_exit_cutoff','manual_exit_requested_at') if k in intent}}) elif existing['status'] not in ('PROPOSED', 'DISPATCHED'): return {'instruction_id': parent, 'state': '已有终态记录,次日重新规划'} elif (existing.get('progress') or {}).get('cancel_requested'): @@ -204,24 +215,31 @@ def send_intent(intent, price, now, snapshot_version): retry_reason = execution_orders.retry_reason(parent, now=now) if retry_reason: return {'instruction_id': parent, 'state': retry_reason, 'pending': True} + progress = (existing or {}).get('progress') or {} + manual_cutoff = progress.get('manual_exit_cutoff') or intent.get('manual_exit_cutoff') + cutoff = _session_deadline(now, manual_cutoff) + if now >= cutoff: + return {'instruction_id': parent, 'state': '轮换本次执行窗口已结束'} + valid_until = min(now + dt.timedelta(minutes=10), cutoff) if manual_cutoff else cutoff child = execution_orders.next_child_id(parent) result = dispatcher.dispatch(instruction_id=child, parent_id=parent, intent='OPEN' if intent['side'] == 'buy' else 'EXIT', ts_code=intent['ts_code'], side=intent['side'], qty=quantity, limit_price=price, - valid_until=(now.replace(hour=10, minute=0, second=0, microsecond=0) if now.hour < 10 else min(now+dt.timedelta(minutes=10), now.replace(hour=14, minute=57, second=0, microsecond=0))), note=intent['reason']) + valid_until=valid_until, note=intent['reason']) if not result.get('ok'): raise ValueError('轮换委托未下发:'+str(result.get('error'))) progress = (pms_repo.get_instruction(parent) or {}).get('progress', {}) progress.setdefault('children', []).append({'ref': child, 'qty': quantity, 'limit': price, - 'mode': 'ws', 'ymd': int(now.strftime('%Y%m%d')), 'at': now.strftime('%H:%M:%S'), 'valid_until': '10:00'}) + 'mode': 'ws', 'ymd': int(now.strftime('%Y%m%d')), 'at': now.strftime('%H:%M:%S'), 'valid_until': valid_until.strftime('%H:%M')}) progress['quote'] = intent.get('quote_basis') - pms_repo.update_instruction(parent, status='DISPATCHED', dispatch_ref=child, progress=progress) + if not pms_repo.update_instruction(parent, status='DISPATCHED', dispatch_ref=child, progress=progress): + raise RuntimeError('子委托与轮换父指令未一并保存') return {'instruction_id': parent, 'book_id': book, 'result': result} def pending_instructions(): """父记录与真实出口合并,父单本地结束不能隐去仍活动的子委托。""" with books.scope('all'): - parents = pms_repo.list_instructions(statuses=('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED', 'WAIT_REVIEW'), limit=10000) + parents = pms_repo.list_instructions(statuses=('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED', 'WAIT_REVIEW'), limit=None) by_id = {p['instruction_id']: p for p in parents} children = qmt_repo.list_orders(statuses=qmt_repo.LIVE, limit=10001) if len(children) > 10000: @@ -266,14 +284,17 @@ def refresh_orders(parents, quotes, now, snapshot_version, target, unavailable): results, waits = [], [] for parent in parents: progress = parent.get('progress') or {} - if progress.get('execution_profile') != 'rotation' or progress.get('rule_version') != core.EXECUTION_RULE: - continue code, side = parent['ts_code'], parent['side'] + manual = progress.get('manual_exit_cutoff') and side == 'sell' and parent['book_id'] == books.MICRO + if progress.get('execution_profile') != 'rotation' or progress.get('rule_version') not in core.SUPPORTED_RULES: + continue + if progress['rule_version'] != core.EXECUTION_RULE and not manual: + continue if str(progress.get('deadline')) != now.date().isoformat(): continue with books.scope(parent['book_id']): if side == 'buy' and (code in unavailable or code not in target): - result = executor.cancel_instruction(parent['instruction_id'], reason='微盘成员不可交易或已调出', arbiter='system') + result = executor.cancel_instruction(parent['instruction_id'], reason=unavailable.get(code) or '微盘成员已调出', arbiter='system') waits.append(code+'撤单确认后处理剩余席位') if not result.get('ok'): waits.append(code+'撤单请求待重试') @@ -312,7 +333,7 @@ def refresh_orders(parents, quotes, now, snapshot_version, target, unavailable): continue intent = {'id': parent['instruction_id'], 'book_id': parent['book_id'], 'ts_code': code, 'side': side, 'qty': int(parent['qty']), 'reason': '微盘剩余数量继续执行', - 'rule_version': core.EXECUTION_RULE, 'quote_basis': {**quote, **priced}} + 'rule_version': progress['rule_version'], 'quote_basis': {**quote, **priced}} try: with db.savepoint(): results.append(send_intent(intent, priced['limit_price'], now, snapshot_version)) @@ -321,20 +342,40 @@ def refresh_orders(parents, quotes, now, snapshot_version, target, unavailable): return results, waits -def cancel_expired(now): - from app.services import executor +def _session_deadline(now, manual_exit_cutoff): + # 旧父单没有人工退出时段标记,仍按批准的普通轮换窗口收尾。 + end = {None: (10, 0), '11:30': (11, 30), '14:57': (14, 57)}[manual_exit_cutoff] + return now.replace(hour=end[0], minute=end[1], second=0, microsecond=0) + + +def cancel_expired(now, *, continue_exits=False): + from app.services import executor, rotation_service as service with books.scope('all'): - rows = pms_repo.list_instructions(statuses=('PROPOSED', 'DISPATCHED'), limit=10000) + rows = pms_repo.list_instructions(statuses=('PROPOSED', 'DISPATCHED'), limit=None) + restrictions = None + waits = [] for row in rows: p = row.get('progress') or {} if p.get('execution_profile') != 'rotation': continue deadline = str(p.get('deadline') or '') - if deadline < now.date().isoformat() or (deadline == now.date().isoformat() and now.hour >= 10): + cutoff = _session_deadline(now, p.get('manual_exit_cutoff')) + reason = None + expired = deadline < now.date().isoformat() or (deadline == now.date().isoformat() and now >= cutoff) + if expired: + reason = '轮换当日执行窗口结束' + elif row['book_id'] == books.MICRO and row.get('side') == 'buy': + if restrictions is None: + restrictions = service.micro_buy_restrictions() + reason = restrictions.get(row['ts_code']) + if reason: with books.scope(row['book_id']): - result = executor.cancel_instruction(row['instruction_id'], reason='轮换当日执行窗口结束', arbiter='system') + result = executor.cancel_instruction(row['instruction_id'], reason=reason, arbiter='system') if not result.get('ok'): - raise RuntimeError('轮换委托撤销未确认') + if expired and not continue_exits: + raise RuntimeError('轮换委托撤销未确认') + waits.append(row['ts_code']+'旧委托撤销待重试') + return waits def book_trade(act, fees, seq): diff --git a/app/services/rotation_service.py b/app/services/rotation_service.py index 93c8499..b53d9cf 100644 --- a/app/services/rotation_service.py +++ b/app/services/rotation_service.py @@ -21,11 +21,17 @@ def documents_ready(): return settings.INFRA_ROTATION_DOCUMENT_SCHEMA or settings.INFRA_STRATEGY_BOOK_SCHEMA -def configuration(): - return {'mode': str(param_store.get('PMS_ROTATION_MODE', 'observe')), - 'rule_version': str(param_store.get('PMS_ROTATION_RULE_VERSION', core.RULE)), +def _rotation_controls(*, locked=False): + return {'mode': param_store.current_rotation_param('PMS_ROTATION_MODE', locked=locked), + 'control': param_store.current_rotation_param('PMS_ROTATION_CONTROL', locked=locked)} + + +def configuration(*, current=False): + controls = _rotation_controls() if current and not settings.PMS_TABLE_PREFIX else { + 'mode': str(param_store.get('PMS_ROTATION_MODE', 'observe')), + 'control': str(param_store.get('PMS_ROTATION_CONTROL', 'run'))} + return {**controls, 'rule_version': str(param_store.get('PMS_ROTATION_RULE_VERSION', core.RULE)), 'candidate_pool_size': param_store.get_int('PMS_ROTATION_CANDIDATE_POOL_SIZE', 100), - 'control': str(param_store.get('PMS_ROTATION_CONTROL', 'run')), 'url': str(param_store.get('PMS_ROTATION_MONITOR_URL', '')).rstrip('/'), 'boards': set(str(param_store.get('PMS_MICRO30_ALLOWED_BOARDS', '')).split(','))-{''}, 'costs': {'rate': param_store.get_float('PMS_MICRO30_COMMISSION_RATE', .0002), @@ -190,33 +196,96 @@ def control(*, mode=None, action=None, actor='user'): if not result.get('ok'): raise RuntimeError('档位保存失败') if action: - result = param_store.set_param('PMS_ROTATION_CONTROL', action, actor) - if not result.get('ok'): - raise RuntimeError('控制保存失败') + _set_control(action, actor) if settings.INFRA_STRATEGY_BOOK_SCHEMA and configuration()['mode'] == 'auto': cancel_control_orders(action) return status() -def cancel_control_orders(action): +def _set_control(action, actor, *, exit_command=None): + """先保存退出意图;显式恢复要等持仓、在途、清仓命令都已结清。""" + if action not in ('exit_disable', 'run') or not documents_ready(): + if not param_store.set_param('PMS_ROTATION_CONTROL', action, actor).get('ok'): + raise RuntimeError('轮换控制保存失败') + return + from app.services.rotation_execution import pending_instructions + with store.account_guard(): + config = configuration(current=True) + paper = config['mode'] == 'paper' + key = 'state:paper' if paper else 'state:live' + with store.locked(key, 'state', {'rotation': core.initial_state()}) as state: + rotation = state['rotation'] + if action == 'exit_disable': + rotation['disabled'] = True + if not exit_command or exit_command != rotation.get('exit_command'): + rotation['manual_exit_requested_at'] = dt.datetime.now(TZ).isoformat() + if rotation['phase'] != 'original': + rotation.update(phase='returning_original', reason='用户退出并停用') + if exit_command: + rotation['exit_command'] = exit_command + elif rotation.get('disabled') or config['control'] == 'exit_disable': + if rotation['phase'] != 'original': + raise ValueError('微盘退出仍在办理;若已暂停,请选择退出并停用,待清仓确认后恢复') + if not paper and settings.INFRA_STRATEGY_BOOK_SCHEMA: + from app.core.command_spec import ACTIVE_TASK_STATES + with books.scope(books.ORIGINAL): + active = pms_repo.list_commands(statuses=ACTIVE_TASK_STATES, cmd_class='task', + cmd_type='LIQUIDATE_ALL', limit=1) + if active: + raise ValueError('全账户清仓命令尚未确认结束,暂不能恢复微盘') + if rotation.get('exit_command') and not paper: + from app.core.command_spec import ST_DONE, ST_CANCELLED + with books.scope(books.ORIGINAL): + command = pms_repo.get_command(rotation['exit_command']) + if not command or command.get('status') not in (ST_DONE, ST_CANCELLED): + raise ValueError('全账户清仓命令尚未确认结束,暂不能恢复微盘') + + if paper: + held = (state.get('account') or {}).get('books', {}).get('micro30', {}) + if any(p.get('qty') for p in held.values()): + raise ValueError('纸面微盘仍有持仓,请先完成退出') + elif settings.INFRA_STRATEGY_BOOK_SCHEMA: + if positions(books.MICRO) or _micro_unsettled(pending_instructions()) or not reconcile_books()['ok']: + raise ValueError('微盘持仓、在途委托或对账尚未结清,请核对后恢复运行') + rotation['disabled'] = False + rotation.pop('exit_command', None) + if not param_store.set_param('PMS_ROTATION_CONTROL', action, actor).get('ok'): + raise RuntimeError('轮换控制保存失败') + + +def micro_buy_restrictions(ts_code=None): + """用户单股命令经原账户命令台写入;轮换买单在两个账本作用域下都以此为准。""" + from app.services import command_service + with books.scope(books.ORIGINAL): + params = command_service.effective_stock_params( + cmd_types=('FREEZE_STOCK', 'UNFREEZE_STOCK', 'BLACKLIST_ADD', 'BLACKLIST_REMOVE'), ts_code=ts_code) + return {code: ('用户冻结该股,暂停增持' if flags.get('frozen') else '用户黑名单禁止买入') + for code, flags in params.items() if flags.get('frozen') or flags.get('black')} + + +def cancel_control_orders(action, *, continue_exits=False): """先保存暂停,再撤已发出的轮换委托;失败保留暂停并由调度重试。""" if action not in ('pause_all', 'pause_new', 'exit_disable'): return from app.services import executor with books.scope('all'): - rows = pms_repo.list_instructions(statuses=LIVE, limit=10000) + rows = pms_repo.list_instructions(statuses=LIVE, limit=None) failed = [] for row in rows: if (row.get('progress') or {}).get('execution_profile') != 'rotation': continue - if action != 'pause_all' and row['side'] != 'buy': + funding_sale = action == 'exit_disable' and row['book_id'] == books.ORIGINAL and row['side'] == 'sell' + if action != 'pause_all' and row['side'] != 'buy' and not funding_sale: continue with books.scope(row['book_id']): result = executor.cancel_instruction(row['instruction_id'], reason='用户轮换控制:'+action, arbiter='user') if not result.get('ok'): failed.append(row['instruction_id']) if failed: + if continue_exits: + return ['旧委托撤销待重试:'+'、'.join(failed)] raise RuntimeError('已停止新增指令,部分既有委托尚未完成撤销') + return [] def positions(book): @@ -308,7 +377,7 @@ def _micro_unsettled(pending): def tick(now=None): """先独立提交轮换决定,再执行;两段均先锁账户,再锁轮换状态。""" - config = configuration() + config = configuration(current=settings.INFRA_STRATEGY_BOOK_SCHEMA) if settings.INFRA_STRATEGY_BOOK_SCHEMA and config['mode'] == 'auto': # 撤单、限制价查询或下发失败不能回滚已经确认的入场/退出任务。 # 两段之间释放账户锁;执行段重新读取用户控制、资金和实际持仓。 @@ -318,6 +387,9 @@ def tick(now=None): return prepared with store.account_guard(): return _tick(now) + if config['mode'] == 'paper' and settings.INFRA_STRATEGY_BOOK_SCHEMA: + with store.account_guard(): + return _tick(now) return _tick(now) @@ -325,13 +397,14 @@ def _tick(now=None, *, prepare_only=False): now = now or dt.datetime.now(TZ) if now.tzinfo is None: now = now.replace(tzinfo=TZ) - config = configuration() + config = configuration(current=settings.INFRA_STRATEGY_BOOK_SCHEMA) day = now.date().isoformat() + cancel_waits = [] if settings.INFRA_STRATEGY_BOOK_SCHEMA and config['mode'] == 'auto': - cancel_control_orders(config['control']) - if config['mode'] == 'auto' and settings.INFRA_STRATEGY_BOOK_SCHEMA: from app.services.rotation_execution import cancel_expired - cancel_expired(now) + continuing_exit = config['control'] == 'exit_disable' + cancel_waits.extend(cancel_control_orders(config['control'], continue_exits=continuing_exit) or []) + cancel_waits.extend(cancel_expired(now, continue_exits=continuing_exit) or []) if td.calendar_degraded(day) or not td.is_trade_day(day): return {'skipped': '交易日历不可用或非交易日'} key = 'state:'+('paper' if config['mode'] == 'paper' else 'live') @@ -366,13 +439,13 @@ def _tick(now=None, *, prepare_only=False): # 仅作为已确认退出的执行上下文,不写成新快照、不生成任何入场。 value = {'members': [], 'signal_ready': False, 'basket_ready': False, 'effective_date': day, 'snapshot_version': saved.get('rotation', {}).get('last_snapshot'), 'signal': {}} - if param_store.get_bool('PMS_GLOBAL_EXEC_HALT', False): + if param_store.execution_halted(locked=settings.INFRA_STRATEGY_BOOK_SCHEMA): config['control'] = 'pause_all' elif param_store.get_bool('PMS_GLOBAL_BUY_HALT', False) and config['control'] == 'run': config['control'] = 'pause_new' manual_exit = config['control'] == 'exit_disable' and (570 <= now.hour*60+now.minute < 690 or 780 <= now.hour*60+now.minute < 895) if not 570 <= now.hour*60+now.minute < 600 and not manual_exit: - if config['mode'] == 'auto': + if config['mode'] == 'auto' and not settings.INFRA_STRATEGY_BOOK_SCHEMA: from app.services.rotation_execution import cancel_expired cancel_expired(now) return {'skipped': '执行窗口之外'} @@ -421,14 +494,15 @@ def _tick(now=None, *, prepare_only=False): buy_prices = {} quote_errors = [] limits = None - if config['rule_version'] == core.EXECUTION_RULE and not prepare_only: + if (config['rule_version'] == core.EXECUTION_RULE or manual_exit) and not prepare_only: from app.services import execution_orders try: limits = _limits(day) except Exception as exc: limits = {} quote_errors.append('当日限制价查询失败:'+type(exc).__name__) - for c in codes: + quote_codes = {p['ts_code'] for p in micro} if manual_exit else codes + for c in quote_codes: try: execution_quotes[c] = market.execution_quote(c, now=now, limits=limits.get(c, {})) except Exception as exc: @@ -444,11 +518,17 @@ def _tick(now=None, *, prepare_only=False): from app.services.rotation_execution import suspended_rejections unavailable.update(suspended_rejections(now)) fresh_entry = state['rotation']['phase'] == 'original' and config['control'] == 'run' and value.get('signal_ready') and value.get('basket_ready') and not value['signal'].get('high') and (value['signal'].get('low') or value['signal'].get('growth_break')) + active_basket = state['rotation']['phase'] in ('entering_micro', 'micro') + buy_restrictions = micro_buy_restrictions() if config['control'] == 'run' and (fresh_entry or active_basket) and not exit_pending else {} if fresh_entry: # 先排除确定性整体不可执行,不能先清旧仓再发现根本没有建仓预算。 static_issues = core.preflight(value['members'], budget, boards, config['costs']) if config['rule_version'] == core.EXECUTION_RULE: static_issues = ['没有可执行的初始建仓候选或预算'] if budget <= 0 or not any(m['code'] not in unavailable for m in value['candidates']) else [] + first_targets = [m['code'] for m in value.get('candidates', value['members']) + if m['code'] not in unavailable][:core.SIZE] + if first_targets and all(code in buy_restrictions for code in first_targets): + static_issues.append('首选成员均受用户禁买命令约束,保留原策略仓位') if static_issues: state['blocked'] = static_issues return {'blocked': static_issues} @@ -463,32 +543,26 @@ def _tick(now=None, *, prepare_only=False): if prepare_only: return {'prepared': True, 'mode': config['mode'], 'phase': s['phase']} if config['mode'] == 'auto' and s['phase'] in ('entering_micro', 'returning_original'): - from app.services import executor - for old in pending: - if old['side'] == 'buy' and not (old['book_id'] == 'original' and closing_t0(old)) and (s['phase'] == 'returning_original' or old['book_id'] == 'original'): - with books.scope(old['book_id']): - result = executor.cancel_instruction(old['instruction_id'], reason='策略轮换停止新增投入', arbiter='system') - if not result.get('ok'): - raise RuntimeError('原买入撤单尚未确认,暂停轮换') - with books.scope('original'): - t0_open = any((r.get('state') or {}).get('open_leg') for r in pms_repo.active_strategies() if r.get('type') == 'T0') - if t0_open or any(p.get('t0_qty', 0) for p in original): + if _stop_leaving_orders(s['phase'], pending, original, cancel_waits): state['blocked'] = ['原策略尚有做T批次,等待完成后继续轮换'] return {'blocked': state['blocked']} - from app.services import command_service - black = command_service.blacklist() refreshed, refresh_waits = [], [] - if config['mode'] == 'auto' and s.get('rule_version') == core.EXECUTION_RULE and config['control'] == 'run': + if config['mode'] == 'auto' and (manual_exit or (s.get('rule_version') == core.EXECUTION_RULE and config['control'] == 'run')): from app.services.rotation_execution import refresh_orders - refreshed, refresh_waits = refresh_orders(pending, execution_quotes, now, value['snapshot_version'], set(s['target']) if s['phase'] in ('entering_micro', 'micro') else set(), unavailable) - if s['phase'] == 'entering_micro' and s.get('rule_version') == core.EXECUTION_RULE and not any(c in buy_prices and c not in unavailable for c in s['target']): + refreshable = pending + if manual_exit: + refreshable = [parent for parent in pending if parent['book_id'] == books.MICRO + and parent['side'] == 'sell' and (parent.get('progress') or {}).get('manual_exit_cutoff')] + refreshed, refresh_waits = refresh_orders(refreshable, execution_quotes, now, value['snapshot_version'], + set(s['target']) if s['phase'] in ('entering_micro', 'micro') else set(), {**unavailable, **buy_restrictions}) + if s['phase'] == 'entering_micro' and s.get('rule_version') == core.EXECUTION_RULE and not any(c in buy_prices and c not in unavailable and c not in buy_restrictions for c in s['target']): # 先完成已有单的撤销确认,避免全部停牌时卡住递补;不新卖原仓筹资。 - state['blocked'] = quote_errors+target_waits+refresh_waits+['目标成员当前没有可核实执行报价,暂不卖出原策略筹资'] + state['blocked'] = quote_errors+target_waits+refresh_waits+['目标成员当前没有可执行的买入报价或受用户禁买限制,暂不卖出原策略筹资'] return {'blocked': state['blocked'], 'phase': s['phase'], 'results': refreshed} planning_quotes = {**quotes, **buy_prices} intents, waits = core.orders(s, value, original=original, micro=micro, quotes=planning_quotes, cash=cash, account_mv=account_mv, cap_amount=cap, reserve_cash=reserve, - pending=pending, control=config['control'], blacklisted=black, costs=config['costs']) + pending=pending, control=config['control'], buy_restrictions=buy_restrictions, costs=config['costs']) # 纸面档明确采用全沪深权限假设,不把它当实际账户权限判收。 issues = core.preflight(value['members'], budget, boards, config['costs']) if value['basket_ready'] else ['名单未就绪'] if issues and s.get('rule_version') != core.EXECUTION_RULE: @@ -496,16 +570,19 @@ def _tick(now=None, *, prepare_only=False): waits.extend(issues) if s.get('rule_version') == core.EXECUTION_RULE: intents = [r for r in intents if r['side'] == 'sell' or r['ts_code'] not in unavailable] - waits.extend(quote_errors+target_waits+refresh_waits) + waits.extend(quote_errors+target_waits+refresh_waits+cancel_waits) if limits is None: limits = _limits(day) done = list(refreshed) - for i, intent in enumerate(intents): + if config['mode'] == 'paper' and intents and param_store.execution_halted(locked=True): + state['blocked'] = ['用户暂停全部执行'] + return {'blocked': state['blocked']} + for intent in intents: c, side = intent['ts_code'], intent['side'] quote = quotes.get(c, {}) price = quote.get('price') lim = limits.get(c) - if s.get('rule_version') == core.EXECUTION_RULE: + if s.get('rule_version') == core.EXECUTION_RULE or manual_exit: from app.services import execution_orders priced = execution_orders.quote_order(side, execution_quotes.get(c, {}), now) if priced.get('action') != 'FIRE': @@ -513,7 +590,7 @@ def _tick(now=None, *, prepare_only=False): continue price = priced['limit_price'] intent['quote_basis'] = {**execution_quotes.get(c, {}), **priced} - intent['rule_version'] = core.EXECUTION_RULE + intent['rule_version'] = s.get('rule_version', core.RULE) if not price or not lim or not lim.get('up_limit') or not lim.get('down_limit'): waits.append(c+'行情或限制价不完整') continue @@ -526,6 +603,10 @@ def _tick(now=None, *, prepare_only=False): intent['qty'] = min(intent['qty'], int(pos.get('avail_qty') or 0)) if not intent['qty']: continue + if manual_exit and intent['book_id'] == books.MICRO and side == 'sell': + intent['manual_exit_cutoff'] = '11:30' if now.hour < 12 else '14:57' + if s.get('manual_exit_requested_at'): + intent['manual_exit_requested_at'] = s['manual_exit_requested_at'] # 报价是可变执行信息,不进入父任务幂等键。 identity = {k: v for k, v in intent.items() if k != 'quote_basis'} token = hashlib.sha256(json.dumps([day, s['cycle'], identity, len(state.get('account', {}).get('fills', {}))], sort_keys=True).encode()).hexdigest()[:24] @@ -558,6 +639,30 @@ def _tick(now=None, *, prepare_only=False): return {'mode': config['mode'], 'phase': s['phase'], 'results': done, 'blocked': waits+errors} +def _stop_leaving_orders(phase, pending, original, waits): + """仅停离开策略的新增投入;卖回资金时,原策略可以继续使用实际到账的钱。""" + from app.services import executor + leaving = books.ORIGINAL if phase == 'entering_micro' else books.MICRO + for parent in pending: + if parent['book_id'] == leaving and parent['side'] == 'buy': + cancel = leaving != books.ORIGINAL or not closing_t0(parent) + else: + cancel = (leaving == books.MICRO and parent['book_id'] == books.ORIGINAL and parent['side'] == 'sell' + and (parent.get('progress') or {}).get('execution_profile') == 'rotation') + if cancel: + with books.scope(parent['book_id']): + result = executor.cancel_instruction(parent['instruction_id'], reason='停止转入资金或新增投入', arbiter='system') + if not result.get('ok'): + if leaving == books.ORIGINAL: + raise RuntimeError('旧轮换委托撤销尚未确认') + waits.append(parent['instruction_id']+'撤销待重试,同股等待收尾') + if leaving == books.MICRO: + return False + with books.scope(books.ORIGINAL): + open_leg = any((r.get('state') or {}).get('open_leg') for r in pms_repo.active_strategies() if r.get('type') == 'T0') + return open_leg or any(p.get('t0_qty', 0) for p in original) + + def original_buy_blocker(): if not settings.INFRA_STRATEGY_BOOK_SCHEMA: return None @@ -572,17 +677,50 @@ def closing_t0(parent): return p.get('origin_type') == 'strategy' and p.get('action') == 'T0_ROUND' and (p.get('progress') or {}).get('leg') == 'close' -def strategy_buy_blocker(book, parent=None): - config = configuration() +def strategy_buy_blocker(book, parent=None, *, config=None): if book == books.ORIGINAL: if closing_t0(parent): return None return original_buy_blocker() + config = config or configuration(current=True) if config['mode'] != 'auto' or config['control'] != 'run': return '微盘未在自动运行档或用户已停止新增' value, _ = store.get('state:live') if (value or {}).get('rotation', {}).get('phase') not in ('entering_micro', 'micro'): return '微盘阶段不允许新增买入' + if parent and parent.get('ts_code'): + return micro_buy_restrictions(parent['ts_code']).get(parent['ts_code']) + return None + + +def order_control_blocker(parent, side): + """模拟账户入队和最终发送标记持同一账户锁,两个时刻均核验最新命令。""" + if param_store.execution_halted(locked=True): + return '用户暂停全部执行' + if not parent or parent.get('book_id') not in (books.ORIGINAL, books.MICRO): + return '委托的策略来源无法核实' + book = parent['book_id'] + progress = parent.get('progress') or {} + if progress.get('cancel_requested') or parent.get('status') not in LIVE: + return '来源指令已停止执行' + rotation = progress.get('execution_profile') == 'rotation' + config = None + if rotation or book == books.MICRO: + config = _rotation_controls(locked=True) + if config['mode'] != 'auto' or config['control'] == 'pause_all': + return '微盘未在自动执行档或用户暂停轮换' + if rotation and side == 'sell' and book == books.ORIGINAL: + live, _ = store.get('state:live') + state = (live or {}).get('rotation', {}) + if state.get('phase') != 'entering_micro' or config['control'] == 'exit_disable': + return '账户已停止转入微盘,原策略筹资卖单停止' + restrictions = micro_buy_restrictions() + if state.get('target') and all(code in restrictions for code in state['target']): + return '当前目标成员均受用户禁买约束,停止筹资卖单' + if side == 'buy': + if param_store.locked_open_param('PMS_GLOBAL_BUY_HALT'): + return '用户暂停买入' + return strategy_buy_blocker(book, parent, config=config) return None @@ -607,14 +745,30 @@ def reconcile_books(): def on_user_command(cmd_type, command_id, issued_by): if issued_by in ('rotation', 'macro') or str(issued_by).startswith('macro'): return - if cmd_type in ('LIQUIDATE_ALL', 'HALT_ALL', 'HALT_BUY'): + if cmd_type in ('FREEZE_STOCK', 'BLACKLIST_ADD') and not settings.PMS_TABLE_PREFIX: + from app.services import executor + failed = False + with store.account_guard(): + with books.scope(books.ORIGINAL): + cmd = pms_repo.get_command(command_id) + if not cmd or not cmd.get('ts_code'): + raise ValueError('单股禁买命令已生效,证券待核对') + if cmd['status'] != 'EFFECTIVE': + return + with books.scope(books.MICRO): + rows = pms_repo.list_instructions(statuses=LIVE, ts_code=cmd['ts_code'], side='buy', limit=None) + for row in rows: + result = executor.cancel_instruction(row['instruction_id'], reason='用户单股禁买命令 '+command_id, arbiter='user') + if not result.get('ok'): + failed = True + if failed: + raise RuntimeError('单股禁买已生效,原微盘买单的撤销尚未确认') + elif cmd_type in ('LIQUIDATE_ALL', 'HALT_ALL', 'HALT_BUY'): action = {'LIQUIDATE_ALL': 'exit_disable', 'HALT_ALL': 'pause_all', 'HALT_BUY': 'pause_new'}[cmd_type] - result = param_store.set_param('PMS_ROTATION_CONTROL', action, issued_by) - if not result.get('ok'): - raise RuntimeError('全账户命令未同步到轮换控制') + _set_control(action, issued_by, exit_command=command_id if cmd_type == 'LIQUIDATE_ALL' else None) from app.services import executor with books.scope('micro30'): - for ins in pms_repo.list_instructions(statuses=LIVE, limit=10000): + for ins in pms_repo.list_instructions(statuses=LIVE, limit=None): if cmd_type == 'HALT_ALL' or ins['side'] == 'buy': result = executor.cancel_instruction(ins['instruction_id'], reason='用户全账户命令'+command_id, arbiter='user') if not result.get('ok'): diff --git a/app/services/signal_service.py b/app/services/signal_service.py index 85e6557..663d311 100644 --- a/app/services/signal_service.py +++ b/app/services/signal_service.py @@ -108,8 +108,14 @@ def consume(*, batch: int = 50, dry_run: bool = False) -> dict: from app.services import timing_fusion if timing_fusion.enabled(): try: - out['timing_fusion'] = timing_fusion.refresh(dry_run=dry_run) + fusion = timing_fusion.refresh(dry_run=dry_run) + out['timing_fusion'] = fusion + if fusion.get('status') in ('DEGRADED', 'FAILED'): + summary = '部分可用' if fusion['status'] == 'DEGRADED' else '不可用' + out['errors'].append(f"合成择时{summary}," + f"无效记录{fusion['invalid']}条,来源错误{len(fusion['source_errors'])}项") except Exception as exc: + out['timing_fusion'] = {'enabled': True, 'status': 'FAILED'} out['errors'].append('合成择时未更新: '+type(exc).__name__) prm = {"sell_conf_min": param_store.get_float("PMS_SIGNAL_SELL_CONF_MIN", 0.75), diff --git a/app/services/strategy_advisor.py b/app/services/strategy_advisor.py index 978a96b..2abe1b3 100644 --- a/app/services/strategy_advisor.py +++ b/app/services/strategy_advisor.py @@ -516,7 +516,7 @@ def scan(*, dry_run: bool = False, now=None) -> dict: "strategy": (st or {}).get("type")}) if st: _tend_existing(st, p, a, fresh, hv, prm, buypause, handoff_cool, - today, dry_run, out, strategy_service, accum_ok=accum_ok) + today, dry_run, out, strategy_service, accum_ok=accum_ok, now=now) continue # 弱基本面试探仓的紧止盈自动挂载 (2026-09-11 工作包三 part 4): 无策略票里, 基本面看空加 # 技术面看多的试探仓次日自动挂紧止盈, 不占每日名额。挂了 (或占位让路) 就不再走常规边。 @@ -656,7 +656,7 @@ def _attach_tight_trail(p, prm, live_codes, optout, dry_run, out, strategy_servi def _tend_existing(st, p, a, fresh, hv, prm, buypause, handoff_cool, today, - dry_run, out, strategy_service, accum_ok=True): + dry_run, out, strategy_service, accum_ok=True, now=None): """已挂策略的票: 边三 (派发停买/回明确恢复) 与 边四 (接力切换)。""" code = p["ts_code"] note = str(st.get("note") or "") @@ -680,14 +680,23 @@ def _tend_existing(st, p, a, fresh, hv, prm, buypause, handoff_cool, today, heat=hv, cushion=p.get("cushion_pct"), prm=prm) if ok_h and code in handoff_cool: ok_h, why_h = False, "接力条件到了但在接力冷却期内, 不动" - if ok_h and _has_pending(st): - ok_h, why_h = False, "接力条件到了但策略有在途委托, 等它走完 (下一跳再看)" + if ok_h and _has_pending(st, review_history=True): + ok_h, why_h = False, "上笔策略安排仍在途或尚未核实,暂缓接力" + if ok_h: + from app.services.strategy_runner import fresh_trail_price + price = fresh_trail_price(code, now) + cost = _f(p.get("avg_cost")) + cushion = price / cost - 1 if cost and price else None + ok_h, why_h = handoff_ready(price=price, price_ok=bool(price), + upper=(st.get("params") or {}).get("upper"), heat=hv, cushion=cushion, prm=prm) + if not ok_h and not why_h: + why_h = "暂无有效突破行情,暂缓接力" if ok_h: if dry_run: out["handoffs"].append({"ts_code": code, "from": st["strategy_id"], "dry_run": True, "why": why_h}) return - _do_handoff(st, p, hv, prm, why_h, out, strategy_service) + _do_handoff(st, p, hv, prm, why_h, out, strategy_service, high_water=price) return if why_h: out["skipped"].append({"ts_code": code, "why": why_h}) @@ -824,56 +833,73 @@ def _attach_one(edge, why, p, a, hv, prm, view, black, live_codes, optout, logger.warning("[自动挂载] %s 挂 %s: %s", code, stype, why) -def _do_handoff(st, p, hv, prm, why, out, strategy_service): +def _do_handoff(st, p, hv, prm, why, out, strategy_service, *, high_water): """边四落地: 撤网格 (打接力标记) → 挂止盈 → 高水位从当日高点起算 → 留痕。""" code = p["ts_code"] - old_note = str(st.get("note") or "") - r1 = strategy_service.set_status(st["strategy_id"], "CANCELLED", by="auto") or {} - if not r1.get("ok"): - out["errors"].append(f"{code} 接力第一步撤网格失败: {r1.get('error')}") + sid = st["strategy_id"] + try: + with pms_repo.strategy_guard(code): + current = pms_repo.get_strategy(sid) + if (not current or current.get("status") != "ACTIVE" or current.get("archived_at") + or current.get("state") != st.get("state") or current.get("params") != st.get("params") + or _has_pending(current)): + out["skipped"].append({"ts_code": code, "why": "网格状态已变化或委托尚未核实,暂缓接力"}) + return + # 撤旧、挂新和初始化高水位共用事务,任何一步失败均保留原网格。 + r1 = strategy_service.set_status(sid, "CANCELLED", by="auto") or {} + if not r1.get("ok"): + raise ValueError(r1.get("error") or "原网格撤下失败") + note = (str(current.get("note") or "") + " " + MARK_HANDOFF_OUT)[:280] + if pms_repo.update_strategy(sid, note=note) != 1: + raise ValueError("原网格接力记录未保存") + params = {"giveback": prm["trail_giveback"], "sell_ratio": prm["trail_sell_ratio"]} + trail_note = f"{NOTE_HANDOFF}{why} 回撤 {prm['trail_giveback']:.1%}" + r2 = strategy_service.attach({"ts_code": code, "type": "TRAIL", "autonomy": "auto", + "params": params, "note": trail_note[:280]}, by="auto", + view={"positions": [p]}) or {} + if not r2.get("ok"): + raise ValueError("、".join(r2.get("errors") or ["跟踪止盈未挂载"])) + if pms_repo.update_strategy(r2["strategy_id"], state={"high_water": round(high_water, 3)}) != 1: + raise ValueError("跟踪止盈高水位未保存") + if pms_repo.insert_ledger(ts_code=code, action="HANDOFF", arbiter="rule", verdict="PASS", + price_at=high_water, hard_numbers={"heat": hv, "from": sid, "to": r2["strategy_id"]}, + ref_id=r2["strategy_id"], reason=f"接力切换: {why}"[:500]) != 1: + raise ValueError("接力记录未保存") + except Exception as exc: + logger.warning("网格接力未完成 %s: %s", code, exc) + out["errors"].append(f"{code} 接力未完成,请核对策略状态:{exc}") + _ledger(code, "REJECT", f"网格接力未完成:{exc}", {"heat": hv}, sid, out, action="HANDOFF") return - n = pms_repo.update_strategy(st["strategy_id"], - note=(old_note + " " + MARK_HANDOFF_OUT)[:280]) - if not n: - # 标记没打上: 冷却推导会把这次接力误判成人工撤下 —— 只是偏保守 (多冷却), 但要留痕 - out["errors"].append(f"{code} 接力标记没写上 (影响 0 行), 冷却推导会偏保守") - params = {"giveback": prm["trail_giveback"], "sell_ratio": prm["trail_sell_ratio"]} - note = (f"{NOTE_HANDOFF}{why}"[:200] + f" 回撤 {prm['trail_giveback']:.1%}") - r2 = strategy_service.attach({"ts_code": code, "type": "TRAIL", "autonomy": "auto", - "params": params, "note": note[:280]}, by="auto") or {} - if not r2.get("ok"): - errs = "; ".join(str(x) for x in (r2.get("errors") or ["挂载校验未过"])) - out["errors"].append(f"{code} 接力第二步挂止盈失败 (网格已撤!): {errs} —— " - f"该票此刻无策略保护, 请人工处理") - _ledger(code, "REJECT", f"接力半途而废: 网格已撤但止盈没挂上 ({errs})", - {"heat": hv}, st["strategy_id"], out, action="HANDOFF") - return - hw0 = _f((p.get("price") if p.get("price_ok") else None), 0.0) - if hw0: - nn = pms_repo.update_strategy(r2["strategy_id"], state={"high_water": round(hw0, 3)}) - if not nn: - out["errors"].append(f"{code} 止盈高水位初始化没写上 (影响 0 行), " - f"将从下一跳现价起算, 只偏保守") out["handoffs"].append({"ts_code": code, "from": st["strategy_id"], "to": r2.get("strategy_id"), "why": why}) - _ledger(code, "PASS", f"接力切换: {why}", - {"heat": hv, "from": st["strategy_id"], "to": r2.get("strategy_id")}, - r2.get("strategy_id"), out, action="HANDOFF") logger.warning("[自动挂载] %s 接力: 网格 %s → 止盈 %s", code, st["strategy_id"], r2.get("strategy_id")) -def _has_pending(st) -> bool: - """策略上一笔委托还在途? 查不到按无在途 (接力多等一天没有代价, 误停一天有)。""" - pend = (st.get("state") or {}).get("pending") or {} - iid = pend.get("iid") - if not iid: - return False +def _has_pending(st, *, review_history=False) -> bool: + """只有确认上一笔提议或委托已收尾才允许接管。""" + from app.services import strategy_runner, execution_orders + from config.settings import settings + pending = (st.get("state") or {}).get("pending") try: - ins = pms_repo.get_instruction(iid) - except Exception: # noqa: BLE001 + done, parent = strategy_runner._pending_terminal(pending) + if not done: + return True + code = st["ts_code"] + if pms_repo.list_instructions(ts_code=code, statuses=strategy_runner.LIVE_INS, limit=1): + return True + if settings.INFRA_STRATEGY_BOOK_SCHEMA and param_store.get('PMS_DISPATCH_MODE', '') == 'ws': + from app.repo import qmt_repo + if qmt_repo.list_orders(ts_code=code, statuses=qmt_repo.LIVE, limit=1): + return True + if parent and not execution_orders.replacement_state(pending['iid'])['ready']: + return True + # 全票历史回报检查仅做锁外预检;锁内定向重读父单、活跃子单及本策略回报。 + return review_history and bool(execution_orders.code_settlement_blocker(code)) return False - return bool(ins and ins.get("status") in ("PROPOSED", "RULE_PASSED", "DISPATCHED", "WAIT_REVIEW")) + except Exception as exc: + logger.warning("网格在途状态无法核实,保留原策略 %s: %s", st.get("strategy_id"), exc) + return True def _snap(a, hv, p) -> dict: diff --git a/app/services/strategy_runner.py b/app/services/strategy_runner.py index 13d9d7b..7ca63cf 100644 --- a/app/services/strategy_runner.py +++ b/app/services/strategy_runner.py @@ -45,6 +45,7 @@ signal_digest / intraday_exec 互相覆盖 (与 portfolio.neg_streak_map 用独 from __future__ import annotations import logging +from collections import Counter from contextlib import contextmanager, nullcontext from copy import deepcopy from datetime import datetime @@ -58,7 +59,8 @@ from app.services import market, param_store, portfolio logger = logging.getLogger("pms.strategy") # 指令在途 (未终态) 的状态集 —— 与 executor.LIVE 一致; 本层据此判断「上一笔还没走完, 先别再发」。 -LIVE_INS = ("PROPOSED", "RULE_PASSED", "DISPATCHED", "WAIT_REVIEW") +LIVE_INS = ("PROPOSED", "RULE_PASSED", "JUDGE_PASSED", "DISPATCHED", "WAIT_REVIEW") +FINAL_INS = {"CONFIRMED", "REJECTED", "EXPIRED", "CANCELLED"} # 批次动作 (与 recon.ACTION_TO_LOT 对齐) A_T0 = "T0_ROUND" # 做T 买入与卖出 → T0 批次 @@ -138,11 +140,13 @@ def _correction_id(st: dict): @contextmanager def _current_strategy(st: dict): """保护策略快照与落单;网格批次读取和状态更新也在同一账户锁内。""" - from app.services.execution_orders import account_guard - with account_guard(): + with pms_repo.strategy_guard(st['ts_code']): fresh = pms_repo.get_strategy(st["strategy_id"]) if not fresh or fresh.get("status") != "ACTIVE" or fresh.get("archived_at"): raise RuntimeError("策略已停用,停止生成新指令或提议") + owners = pms_repo.list_strategies(ts_code=st["ts_code"], statuses=["ACTIVE"], limit=2) + if len(owners) != 1 or owners[0]["strategy_id"] != st["strategy_id"]: + raise RuntimeError("同股生效交易方案不唯一,请先核对后再执行") if (fresh.get("state") or {}).get("correction_hold"): raise RuntimeError("策略成交数量已更正,等待核对后续安排") if _correction_id(fresh) != _correction_id(st): @@ -209,10 +213,13 @@ def _emit_proposal(st: dict, dec: dict) -> str: def emit_from_spec(spec: dict) -> dict: """confirm 提议被采纳后的回调 (main._decide 调): 按 hard_numbers 里存的动作参数发指令。 返回 {ok, instruction_id} 或 {ok:false, error}。""" - from app.services.execution_orders import account_guard try: - with account_guard(): - st = pms_repo.get_strategy(spec.get("strategy_id")) + strategy_id = spec.get("strategy_id") + st = pms_repo.get_strategy(strategy_id) + if not st: + return {"ok": False, "error": "策略不存在或已撤下"} + with pms_repo.strategy_guard(st["ts_code"]): + st = pms_repo.get_strategy(strategy_id) if not st: return {"ok": False, "error": "策略不存在或已撤下"} if st.get("status") != "ACTIVE": @@ -238,21 +245,22 @@ def emit_from_spec(spec: dict) -> dict: # ================================================================ 在途委托的收敛 def _pending_terminal(pending: dict): """上一笔委托是否已终态。返回 (已终态?, 指令行 or None)。无 pending 视为已终态。""" - if not pending: + if pending is None: return True, None + if not isinstance(pending, dict): + raise ValueError("在途记录格式无法核实,保留策略等待核对") iid = pending.get("iid") - if not iid: # confirm 提议还没被采纳 —— 看提议是否还在等 + if not iid: pid = pending.get("pid") - if not pid: - return True, None - pr = pms_repo.get_proposal(pid) - if pr and pr.get("status") == "WAIT_USER": - return False, None # 还在等人拍板, 先别再发 - return True, None # 已采纳(转指令,另有pending.iid)/驳回/过期 + proposal = pms_repo.get_proposal(pid) if pid else None + if not proposal or proposal.get("status") not in ("WAIT_USER", "ACCEPTED", "DECLINED", "REJECTED", "EXPIRED"): + raise ValueError("策略提议状态无法核实,保留等待") + # 采纳会在同一事务把 pending 换成 iid;仅有旧 pid 不能证明委托已收尾。 + return proposal["status"] in ("DECLINED", "REJECTED", "EXPIRED"), None ins = pms_repo.get_instruction(iid) - if not ins: + if not ins or (ins.get("status") not in LIVE_INS and ins.get("status") not in FINAL_INS): raise ValueError("在途父指令无法核实,保留策略等待核对") - return (ins.get("status") not in LIVE_INS), ins + return ins["status"] in FINAL_INS, ins def _reconcile(st: dict, state: dict, pos: dict): @@ -274,7 +282,7 @@ def _reconcile(st: dict, state: dict, pos: dict): return True filled = int(ins.get("exec_qty") or 0) > 0 leg = pending.get("leg") - if st.get('type') == 'GRID': + if st.get('type') in ('GRID', 'TRAIL'): # 委托终态不等于已入账;新库存由真实批次投影,不恢复发单时的假设库存。 from config.settings import settings if settings.INFRA_STRATEGY_BOOK_SCHEMA and param_store.get('PMS_DISPATCH_MODE', '') == 'ws': @@ -586,6 +594,18 @@ def _tick_grid(st, pos, now, dry_run, out, buy_paused): # ================================================================ 评估器: 跟踪止盈 (设计 §七B) +def fresh_trail_price(code, now=None): + """同一根当日有效分钟线的收盘价供止盈触发及接力初始高点使用。""" + from app.core.execution_policy import local_now, positive, timestamp + quote = market.execution_quote(code, now=now, limits={}) + at = timestamp(quote.get('as_of')) + current = local_now(now) + max_age = param_store.get_int('PMS_EXEC_MINUTE_MAX_AGE_SEC', 90) + if at and at.date() == current.date() and 0 <= (current - at).total_seconds() <= max_age: + return positive(quote.get('last')) + return 0. + + def _eval_trail(st, pos, day, now, ctx): """止盈意图在实际成交后扣减;撤单、部分成交、T+1不能消耗整次减持。""" state, params = ctx['state'], st.get('params') or {} @@ -710,12 +730,16 @@ def tick(*, now=None, dry_run: bool = False) -> dict: if global_halt: out["notes"].append(f"全局当日T亏 {global_t_pnl:.0f} 元 达熔断线 {global_loss_cap:.0f} 元, 今日不再开新T") + owners = Counter(st.get("ts_code") for st in strategies) for st in strategies: out["checked"] += 1 code = st.get("ts_code") from app.core.execution_policy import supported_code if not supported_code(code): continue + if owners[code] > 1: + out["errors"].append(f"{code} 有多条生效交易方案,暂停自动策略动作,请保留一条") + continue fn = EVALUATORS.get(st.get("type")) if not fn: out["skipped"].append({"strategy_id": st.get("strategy_id"), @@ -744,17 +768,22 @@ def tick(*, now=None, dry_run: bool = False) -> dict: # 上一笔还没走完就别再发; 走完了先把结果并进 state if not _reconcile(st, state, pos): - if not dry_run: - pms_repo.update_strategy(st["strategy_id"], state=state) + if not dry_run and state != (st.get("state") or {}): + with _current_strategy(st): + pms_repo.update_strategy(st["strategy_id"], state=state) out["skipped"].append({"strategy_id": st["strategy_id"], "why": "上一笔还在途, 等它走完"}) continue - day = market.day_snapshot(code) + if st.get("type") == "TRAIL": + day = {"price": fresh_trail_price(code, now)} + else: + day = market.day_snapshot(code) if not day or not day.get("price"): out["skipped"].append({"strategy_id": st["strategy_id"], - "why": f"{code} 无实时行情 (停牌/盘前), 顺延"}) - if not dry_run: - pms_repo.update_strategy(st["strategy_id"], state=state) + "why": f"{code} 暂无有效实时行情,等待更新后再评估"}) + if not dry_run and state != (st.get("state") or {}): + with _current_strategy(st): + pms_repo.update_strategy(st["strategy_id"], state=state) continue # 单票当日T亏熔断 (做T) @@ -778,8 +807,8 @@ def tick(*, now=None, dry_run: bool = False) -> dict: "qty": dec["qty"], "entry": dec.get("entry")} if pms_repo.update_strategy(st["strategy_id"], state=state) != 1: raise RuntimeError("策略状态未成功保存") - out["queued"].append({"strategy_id": st["strategy_id"], "proposal_id": pid, - "reason": dec["reason"]}) + group, record = "queued", {"strategy_id": st["strategy_id"], + "proposal_id": pid, "reason": dec["reason"]} else: iid = _emit_instruction(st, dec, forced=False) state["pending"] = {"iid": iid, "leg": dec["leg"], "dir": dec.get("dir"), @@ -788,14 +817,16 @@ def tick(*, now=None, dry_run: bool = False) -> dict: "grid_restore": dec.get("_grid_restore")} if pms_repo.update_strategy(st["strategy_id"], state=state) != 1: raise RuntimeError("策略状态未成功保存") - out["fired"].append({"strategy_id": st["strategy_id"], "instruction_id": iid, - "side": dec["side"], "qty": dec["qty"], "reason": dec["reason"]}) + group, record = "fired", {"strategy_id": st["strategy_id"], + "instruction_id": iid, "side": dec["side"], "qty": dec["qty"], "reason": dec["reason"]} + out[group].append(record) else: out["fired"].append({"strategy_id": st["strategy_id"], "dry_run": True, "side": dec["side"], "qty": dec["qty"], "reason": dec["reason"]}) - if not dry_run and not dec: - pms_repo.update_strategy(st["strategy_id"], state=state) + if not dry_run and not dec and state != (st.get("state") or {}): + with _current_strategy(st): + pms_repo.update_strategy(st["strategy_id"], state=state) except Exception as e: # noqa: BLE001 —— 单策略异常不拖垮整轮 logger.exception("[strategy] 评估失败 %s", st.get("strategy_id")) out["errors"].append(f"{st.get('strategy_id')}: {type(e).__name__}: {e}") @@ -834,7 +865,9 @@ def force_t0_close(*, now=None) -> dict: open_leg = state.get("open_leg") if not open_leg: out["skipped"].append({"strategy_id": st["strategy_id"], "why": "无未平仓"}) - pms_repo.update_strategy(st["strategy_id"], state=state) + if state != (st.get("state") or {}): + with _current_strategy(st): + pms_repo.update_strategy(st["strategy_id"], state=state) continue if state.get("pending"): out["skipped"].append({"strategy_id": st["strategy_id"], "why": "平回委托已在途"}) diff --git a/app/services/strategy_service.py b/app/services/strategy_service.py index ea959df..b08543c 100644 --- a/app/services/strategy_service.py +++ b/app/services/strategy_service.py @@ -12,6 +12,7 @@ from __future__ import annotations import json import logging from datetime import datetime +from uuid import uuid4 from app.core import tradedays as td from app.repo import pms_repo @@ -73,12 +74,7 @@ def validate(cfg: dict, view=None) -> dict: if dup: reasons.append(f"该股已挂着一条 {dup[0].get('type')} 策略(生效中), 先撤下再挂新的") - prm = view["params"] - scale = _f(prm.get("scale")) - stock_cap = _f(prm.get("stock_cap")) - mv = _f(pos.get("market_value")) avail = int(pos.get("avail_qty") or 0) - cap_room = max(0.0, stock_cap * scale - mv) # 这只票离单股上限还差多少钱 if typ == "T0": tr = _f(params.get("t_ratio")) @@ -87,6 +83,10 @@ def validate(cfg: dict, view=None) -> dict: if avail <= 0: reasons.append("做T 需要 T+1 可卖的存量股(当前可卖为 0), 无法在存量上做差价") elif typ == "GRID": + scale = _f(view["params"].get("scale")) + stock_cap = _f(view["params"].get("stock_cap")) + mv = _f(pos.get("market_value")) + cap_room = max(0.0, stock_cap * scale - mv) lo, hi = _f(params.get("lower")), _f(params.get("upper")) mid = _f(params.get("center")) or _f(pos.get("price")) step = _f(params.get("step")) @@ -111,21 +111,40 @@ def validate(cfg: dict, view=None) -> dict: return {"ok": not reasons, "reasons": reasons} -def attach(cfg: dict, by: str = "user") -> dict: +def attach(cfg: dict, by: str = "user", *, view=None) -> dict: """挂载一条策略。先校验, 违反返回 {ok:false, errors}; 通过则写 pms_strategy(ACTIVE)。""" - v = validate(cfg) - if not v["ok"]: - return {"ok": False, "errors": v["reasons"]} - code = cfg["ts_code"] - ymd = td.ymd() - sid = f"STR_{ymd}_{code.replace('.', '')}_{int(datetime.now().timestamp()) % 1000000}" - saved = pms_repo.insert_strategy(strategy_id=sid, ts_code=code, stype=cfg["type"], - autonomy=cfg.get("autonomy") or "auto", - params=cfg.get("params") or {}, state={}, - status="ACTIVE", note=cfg.get("note")) - if saved != 1: - return {"ok": False, "errors": ["交易方案未成功保存"]} - return {"ok": True, "strategy_id": sid, "ts_code": code} + code = (cfg or {}).get("ts_code") + from app.core.execution_policy import supported_code + if not supported_code(code): + return {"ok": False, "errors": ["交易方案仅支持规范沪深A股代码"]} + # 组合、行业及分钟行情在锁外读取。接力可传入本次扫描已有的持仓快照。 + try: + snapshot = portfolio.positions_view() if view is None else view + quoted = _pos(snapshot, code) + except Exception as exc: + return {"ok": False, "errors": [f"读持仓失败,暂不能挂载:{type(exc).__name__}"]} + if not quoted: + return {"ok": False, "errors": ["该股没有可核实的持仓快照"]} + with pms_repo.strategy_guard(code): + current = pms_repo.get_position(code) or {} + qty = int(current.get("total_qty") or 0) + price = _f(quoted.get("price")) if quoted.get("price_ok") else _f(current.get("avg_cost")) + pos = dict(quoted, total_qty=qty, avail_qty=int(current.get("avail_qty") or 0), + market_value=qty * price, price=price) + if cfg.get("type") == "GRID" and qty > 0 and price <= 0: + return {"ok": False, "errors": ["持仓市值无法核实,暂不能确定网格投入上限"]} + v = validate(cfg, view={**snapshot, "positions": [pos]}) + if not v["ok"]: + return {"ok": False, "errors": v["reasons"]} + ymd = td.ymd() + sid = f"STR_{ymd}_{code.replace('.', '')}_{uuid4().hex[:12]}" + saved = pms_repo.insert_strategy(strategy_id=sid, ts_code=code, stype=cfg["type"], + autonomy=cfg.get("autonomy") or "auto", + params=cfg.get("params") or {}, state={}, + status="ACTIVE", note=cfg.get("note")) + if saved != 1: + return {"ok": False, "errors": ["交易方案未成功保存"]} + return {"ok": True, "strategy_id": sid, "ts_code": code} def set_status(strategy_id: str, status: str, by: str = "user") -> dict: @@ -136,9 +155,28 @@ def set_status(strategy_id: str, status: str, by: str = "user") -> dict: st = pms_repo.get_strategy(strategy_id) if not st: return {"ok": False, "error": "策略不存在"} - if pms_repo.update_strategy(strategy_id, status=status) != 1: - return {"ok": False, "error": "交易方案状态未成功保存"} - return {"ok": True, "strategy_id": strategy_id, "ts_code": st.get("ts_code"), "status": status} + code = st["ts_code"] + with pms_repo.strategy_guard(code): + st = pms_repo.get_strategy(strategy_id) + if not st or st.get("archived_at"): + return {"ok": False, "error": "交易方案已归档或不存在"} + old = st["status"] + if status == "ACTIVE": + if old not in ("PAUSED", "ACTIVE"): + return {"ok": False, "error": "已结束的交易方案不能恢复,请按当前持仓重新挂载"} + if (st.get("state") or {}).get("correction_hold"): + return {"ok": False, "error": "成交数量更正仍待核对,无法恢复交易方案"} + active = pms_repo.list_strategies(ts_code=code, statuses=["ACTIVE"], limit=2) + if any(row["strategy_id"] != strategy_id for row in active): + return {"ok": False, "error": "同股已有其他生效方案,请先处理该方案"} + if old == "PAUSED" and int((pms_repo.get_position(code) or {}).get("total_qty") or 0) <= 0: + return {"ok": False, "error": "该股已无持仓,无法恢复交易方案"} + if old != status: + if old in ("DONE", "CANCELLED"): + return {"ok": False, "error": "已结束的交易方案不能再改变状态"} + if pms_repo.update_strategy(strategy_id, status=status) != 1: + return {"ok": False, "error": "交易方案状态未成功保存"} + return {"ok": True, "strategy_id": strategy_id, "ts_code": code, "status": status} def cancel_by_code(ts_code: str, reason: str = "") -> dict: diff --git a/app/services/timing_fusion.py b/app/services/timing_fusion.py index cf6fb0f..a39f491 100644 --- a/app/services/timing_fusion.py +++ b/app/services/timing_fusion.py @@ -21,30 +21,39 @@ def refresh(*, now=None, dry_run=False): return {'enabled': False} import requests from app.services import exec_advisor, timing_state, risk_exit - now = now or datetime.now() response = requests.get(exec_advisor.base_url()+'/api/intraday/timing_fusion', timeout=(2,5)) response.raise_for_status() data = response.json() + received_at = now or datetime.now() if data.get('version') != contract.VERSION or data.get('enabled') is not True: raise ValueError('合成择时来源未就绪') + if not isinstance(data.get('errors', []), list): + raise ValueError('合成择时来源错误清单格式无效') states = data.get('states') if not isinstance(states, list) or len(states)>6000: raise ValueError('合成择时响应超过完整读取边界') # 广域v3f覆盖上千只票。缺少第二组的无方向记录不进入PMS账本; # 已有方向必须接收WAIT,及时撤销过期或冲突的旧结论。 - known_rows = rotation_repo.recent(timing_state.KIND, 6001) - if len(known_rows) >= 6001: + known = rotation_repo.document_ids(timing_state.KIND, limit=6001) + if len(known) >= 6001: raise ValueError('本地方向状态超过完整读取上限') - known = {r['id'] for r in known_rows} - out = {'enabled': True, 'accepted': 0, 'invalid': 0, 'source_errors': data.get('errors', []), 'actions': []} + out = {'enabled': True, 'accepted': 0, 'invalid': 0, 'source_errors': data.get('errors', []), + 'directions': 0, 'waiting': 0, 'no_evidence': 0, 'actions': []} + since = param_store.get('PMS_TIMING_FUSION_START_AT', '') for state in states: - if state.get('action') == 'WAIT' and timing_state.key(state.get('ts_code', '')) not in known: - continue - event = contract.valid(state, now, since=param_store.get('PMS_TIMING_FUSION_START_AT', '')) + event = contract.valid(state, received_at, since=since) if not event: out['invalid'] += 1 continue code = event['ts_code'] + if event['action'] == 'WAIT': + out['waiting'] += 1 + if not any(group['evidence'] for group in event['groups'].values()): + out['no_evidence'] += 1 + if timing_state.key(code) not in known: + continue + else: + out['directions'] += 1 if dry_run: out['accepted'] += 1 continue @@ -62,10 +71,18 @@ def refresh(*, now=None, dry_run=False): raise RuntimeError('合成择时依据未成功入账') out['accepted'] += 1 if event['action'] == 'BUY': - result = risk_exit.recover_on_buy(code, event, now=now) + result = risk_exit.recover_on_buy(code, event, now=now or datetime.now()) elif event['action'] == 'SELL': - result = risk_exit.on_signal(event, now=now) + result = risk_exit.on_signal(event, now=now or datetime.now()) else: continue out['actions'].append({'ts_code':code, 'action':event['action'], 'result':result}) + if out['source_errors'] or out['invalid']: + out['status'] = 'DEGRADED' if out['directions'] or out['waiting'] > out['no_evidence'] else 'FAILED' + elif out['directions']: + out['status'] = 'DIRECTION' + elif out['waiting'] > out['no_evidence']: + out['status'] = 'NO_DIRECTION' + else: + out['status'] = 'NO_EVIDENCE' return out diff --git a/app/services/upstream_signals.py b/app/services/upstream_signals.py index cd14ab0..e9132ed 100644 --- a/app/services/upstream_signals.py +++ b/app/services/upstream_signals.py @@ -114,14 +114,9 @@ def _alert_scan() -> int: return max(_limit(), param_store.get_int("PMS_UPSTREAM_ALERT_SCAN", 300)) -def _alert_per_cat() -> int: - # 每个类型最多留最新 N 条, 高频源只占它自己那一档, 不挤别的类。 - return max(1, param_store.get_int("PMS_UPSTREAM_ALERT_PER_CAT", 20)) - - def _alert_max_age_sec() -> int: # 告警时间窗(秒): 0=不限龄。只用于给每条打"陈旧"标记(超龄置灰), **不删条目** —— - # 用户拍板"置灰标注"而非隐藏, 风控面板不丢信息。与每类上限正交: 先按龄标 stale, 再每类限量。 + # 风控面板保留陈旧记录,便于交易员核对当天的完整过程。 return max(0, param_store.get_int("PMS_UPSTREAM_ALERT_MAX_AGE_MIN", 60)) * 60 @@ -375,9 +370,7 @@ def snapshot(force: bool = False) -> dict: # 信号栏一行 = 上游流里的一条原始消息, 同一只票一天出现很多次 (实测活跃票一天十来条)。 # 这里按代码把五个源汇到一起, 给页面的「这只票今天的信号」抽屉用。 # -# 与 snapshot() 的分工: 那个是**全场最近 N 条**的快照 (告警每类只留最新 20 条), 到下午 -# 一只活跃票早盘的信号早被挤掉了; 这个是**单票回扫到当天开盘**, 所以才叫"全部"。 -# 两份缓存不合并 —— 口径不同, 合并会让单票结果被全场快照污染。 +# 全场快照按来源分页,单票明细按股票汇集当天事件。各自的扫描边界和缓存独立。 # # 只读纪律与 snapshot() 逐字相同: 一律 XREVRANGE / ZREVRANGE, 不建消费组、不 ACK、不写。 # **这个接口只能点击触发, 绝不能加进页面轮询** —— 加进去就是每 30 秒对上游做一次全流扫描, diff --git a/scripts/run_tests.py b/scripts/run_tests.py index 8a5ee2e..6f2046f 100644 --- a/scripts/run_tests.py +++ b/scripts/run_tests.py @@ -5,6 +5,7 @@ 运行: docker compose run --rm pms-web python scripts/run_tests.py 历史准备逐路覆盖、旧证据拒绝及嵌套业务失败核验专项21例。 +选股逐票复核专项5例;自动建仓批准与跨日竞争同一额度专项8例。 test_batch54_units.py 用户候选来源、到期核验、权限、显式取用、技术面补读及评级排序透传 (10例) @@ -27,8 +28,8 @@ test_batch55_units.py 共同撤换状态、报价、依据监控与取消确认 (34例) test_sim_reset_units.py 双账本重置、空仓证据、配置与去重保留、幂等及SQL回滚 (9例) test_batch53_units.py QMT下单策略类型、原字段与签名、双策略买卖归属及读取故障保留队列 (8例) - test_batch52_units.py 当日限价、撤单拒绝、迟到成交、发送恢复与真实SQL状态保护 (22例) - test_batch51_units.py 跨日决策复核、撤单回报、数量约束、人工确认与真实SQL事务及完整选股接线及异步等待 (37例) + test_batch52_units.py 当日限价、撤单拒绝、迟到成交、日配额与发送前复核 (29例) + test_batch51_units.py 跨日决策复核、撤单、共享日额、异步轮转和并发领取 (42例) test_batch50_units.py QMT限价等待、价格来源故障、用户暂停、配额防重、试算隔离及收盘边界 (17例) test_batch49_units.py 持仓与指令分组、同名股票及批次归属、撤单账本、未迁移及缺数展示 (14例) test_batch48_units.py 策略账本隔离、轮换优先级、交易单位、模拟直接启用、读数及微盘50规则换版 (55例) @@ -207,11 +208,12 @@ HERE = os.path.dirname(os.path.abspath(__file__)) ROOT = os.path.dirname(HERE) # 退出纪律专项:两次独立清仓信号、评级下降、事务、双策略隔离及撤单收尾。 SUITES = [ + "test_plan_rank_boundary.py", "test_auto_open_approval.py", "test_business_evidence.py", # 历史准备覆盖与嵌套业务失败(21例) "test_signal_health.py", # 资金监测可用性与交易员提示,7例 "test_proposal_trader_view.py", # 当前分析、数据库读数保存及旧确认保护(21例) "test_watch_missing_fund.py", - "test_timing_fusion.py", # 三组证据契约、二次清仓可达性与恢复(19例) + "test_timing_fusion.py", # 三组择时证据、收件时钟、来源退化与退出收尾 "test_signal_recovery.py", # 最新方向、停买恢复、网格合议、关注入口与负净成本(16例) "test_grid_execution.py", "test_buy_budget.py", diff --git a/scripts/test_auto_open_approval.py b/scripts/test_auto_open_approval.py new file mode 100644 index 0000000..35b8e89 --- /dev/null +++ b/scripts/test_auto_open_approval.py @@ -0,0 +1,192 @@ +"""自动建仓名额、待执行指令和批准账本的事务边界。""" +import unit_test_guard # noqa: F401 +import sys +import tempfile +import unittest +from concurrent.futures import ThreadPoolExecutor +from contextlib import ExitStack +from datetime import datetime +from pathlib import Path +from threading import Barrier +from unittest.mock import patch + +from sqlalchemy import create_engine, event, text + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from app.db import session +from app.repo import pms_repo +from app.services import judge, param_store, proposal_service as ps +from config.settings import settings + +NOW = datetime.now().replace(hour=10, minute=0, second=0, microsecond=0) +CODES = ('600000.SH', '600001.SH') +DDL = [ + 'CREATE TABLE pms_runtime_param(param_key TEXT PRIMARY KEY, param_value TEXT)', + "INSERT INTO pms_runtime_param VALUES('PMS_SELF_DECIDE','full'), ('PMS_SELF_DECIDE_DAILY_MAX','1')", + 'CREATE TABLE pms_ws_state(id INTEGER PRIMARY KEY)', + 'INSERT INTO pms_ws_state VALUES(1)', + '''CREATE TABLE pms_instruction(id INTEGER PRIMARY KEY,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,progress_json TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT)''', + '''CREATE TABLE pms_action_ledger(id INTEGER PRIMARY KEY,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)''', + '''CREATE TABLE pms_proposal(id INTEGER PRIMARY KEY,proposal_id TEXT UNIQUE,ts_code TEXT,action TEXT, + qty INTEGER,hard_numbers_json TEXT,status TEXT,expire_at TEXT,decided_at TEXT,judge_verdict TEXT, + judge_reason TEXT,archived_at TEXT,created_at TEXT)''', +] + + +def candidate(code): + return {'ts_code': code, 'action': 'OPEN', 'side': 'buy', 'qty': 100, 'price': 10., + 'reason': '当前计划合格', 'judge_required': True, 'hard_numbers': {'consensus': {'route': '放行'}}} + + +class AutoOpenApproval(unittest.TestCase): + def setUp(self): + self.stack = ExitStack() + self.addCleanup(self.stack.close) + root = self.stack.enter_context(tempfile.TemporaryDirectory()) + engine = create_engine('sqlite:///' + root + '/ledger.db') + self.stack.callback(engine.dispose) + # SQLite 用短写事务实现与生产账户行锁相同的互斥,事务与所有业务 SQL 仍走真实路径。 + @event.listens_for(engine, 'begin') + def begin(conn): + conn.exec_driver_sql('BEGIN IMMEDIATE') + + @event.listens_for(engine, 'before_cursor_execute', retval=True) + def locking_sql(conn, cursor, statement, parameters, context, executemany): + return statement.removesuffix(' FOR UPDATE'), parameters + + with engine.begin() as conn: + for statement in DDL: + conn.execute(text(statement)) + self.use(session, 'get_engine', return_value=engine) + self.use(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', False) + self.use(param_store, 'get_int', side_effect=lambda key, default=0: default) + self.use(param_store, 'get_bool', side_effect=lambda key, default=False: default) + self.use(ps, 'check_candidate_rules', return_value={'passed': True}) + self.params = {'self_decide': 'full', 'self_decide_daily_max': 1} + + def use(self, owner, name, *args, **kwargs): + return self.stack.enter_context(patch.object(owner, name, *args, **kwargs)) + + def route(self, code, params=None, out=None): + if out is None: + out = dict(autonomy='full', open_autonomy='full', skipped=[], rejected=[], executed=[], queued=[]) + verdict = {'verdict': judge.PASS, 'confidence': 80, 'raw': {'ok': True}, 'reason': '通过'} + ps._route_one(candidate(code), {'positions': []}, params or self.params, {}, False, NOW, False, + out, prepared_verdict=verdict) + return out + + def ledger(self): + return session.fetch_all('SELECT * FROM pms_action_ledger') + + def test_carried_order_and_new_open_share_last_place(self): + from app.repo import qmt_repo + from app.services import daily_buy_review as daily + self.use(qmt_repo, 'orders_for_parent', return_value=[]) + pms_repo.insert_instruction(instruction_id='earlier', origin_type='proposal', origin_id=None, + ts_code=CODES[0], action='OPEN', side='buy', qty=100, status='WAIT_REVIEW', progress={}) + parent = pms_repo.get_instruction('earlier') + fresh = {'auto_exec': True, 'candidate': candidate(CODES[0]), 'verdict': {'verdict': 'PASS'}, + 'self_decide': {'decision': 'accept'}} + gate = Barrier(2) + def existing(): + gate.wait() + return daily._finish_review(parent, fresh, NOW) + def new_open(): + gate.wait() + return self.route(CODES[1]) + with ThreadPoolExecutor(max_workers=2) as pool: + existing_result = pool.submit(existing) + new_result = pool.submit(new_open) + actual = [existing_result.result(), 'approved' if new_result.result()['executed'] else 'queued'] + self.assertCountEqual(actual, ['approved', 'queued']) + self.assertEqual(pms_repo.system_pass_count_today(NOW.replace(hour=0)), 1) + self.assertEqual(len(pms_repo.list_proposals(statuses=['WAIT_USER'])), 1) + + def test_competing_stocks_share_one_place(self): + gate = Barrier(2) + def route(code): + gate.wait() + return self.route(code) + with ThreadPoolExecutor(max_workers=2) as pool: + results = list(pool.map(route, CODES)) + self.assertEqual(sum(len(r['executed']) for r in results), 1) + queued = [p for r in results for p in r['queued']] + self.assertEqual(len(queued), 1) + self.assertIn('上限', queued[0]['why']) + self.assertEqual(len(pms_repo.list_instructions()), 1) + self.assertEqual(pms_repo.system_pass_count_today(NOW.replace(hour=0)), 1) + + def test_audit_failure_rolls_back_parent_and_preserves_place(self): + for failure in [RuntimeError('审计写入中断'), 0]: + with self.subTest(failure=failure): + with patch.object(pms_repo, 'insert_ledger', **( + {'side_effect': failure} if isinstance(failure, Exception) else {'return_value': failure})): + with self.assertRaises(RuntimeError): + self.route(CODES[0]) + self.assertEqual(pms_repo.list_instructions(), []) + self.assertEqual(self.ledger(), []) + success = self.route(CODES[1]) + self.assertEqual(success['_sd_accepts'], 1) + self.assertEqual(self.ledger()[0]['ref_id'], success['executed'][0]['instruction_id']) + + def test_parent_write_failure_does_not_consume_a_place_in_the_same_round(self): + out = dict(autonomy='full', open_autonomy='full', skipped=[], rejected=[], executed=[], queued=[]) + with patch.object(pms_repo, 'insert_instruction', return_value=0): + with self.assertRaises(RuntimeError): + self.route(CODES[0], out=out) + self.assertEqual(out.get('_sd_accepts', 0), 0) + self.assertEqual(self.ledger(), []) + self.route(CODES[1], out=out) + self.assertEqual(out['_sd_accepts'], 1) + + def test_unreadable_count_falls_back_to_manual(self): + with patch.object(pms_repo, 'system_pass_count_today', side_effect=RuntimeError('计数读取失败')): + initial = self.route(CODES[0], dict(self.params, _sd_base_count=ps._auto_open_count(NOW))) + raced = self.route(CODES[1]) + for result in (initial, raced): + self.assertIn('无法核实', result['queued'][0]['why']) + self.assertEqual(pms_repo.list_instructions(), []) + self.assertEqual(self.ledger(), []) + + def test_disabled_limit_allows_and_duplicate_input_is_idempotent(self): + session.execute("UPDATE pms_runtime_param SET param_value='0' WHERE param_key='PMS_SELF_DECIDE_DAILY_MAX'") + params = {'self_decide': 'full', 'self_decide_daily_max': 0} + with patch.object(pms_repo, 'system_pass_count_today', side_effect=RuntimeError('计数不可读')): + first = self.route(CODES[0], params) + second = self.route(CODES[0], params) + self.assertTrue(first['executed']) + self.assertTrue(second['skipped']) + self.assertEqual(len(pms_repo.list_instructions()), 1) + self.assertEqual(len(self.ledger()), 1) + + def test_final_approval_observes_new_limit_and_purchase_halts(self): + self.route(CODES[0]) + stale = dict(self.params, self_decide_daily_max=3) + capped = self.route(CODES[1], stale) + self.assertIn('上限 1', capped['queued'][0]['why']) + for flag in ('PMS_GLOBAL_EXEC_HALT', 'PMS_GLOBAL_BUY_HALT'): + with self.subTest(flag=flag): + session.execute('INSERT INTO pms_runtime_param VALUES(:key, :value)', {'key': flag, 'value': 'true'}) + stopped = self.route(CODES[1], stale) + self.assertIn('暂停', stopped['skipped'][0]['why']) + session.execute('DELETE FROM pms_runtime_param WHERE param_key=:key', {'key': flag}) + self.assertEqual(len(pms_repo.list_instructions()), 1) + + def test_non_open_and_manual_decisions_preserve_independent_routes(self): + p = dict(self.params, _sd_base_count=None) + dca = {'action': ps.ae.A_DCA, 'decide_kind': ps.ae.DK_DCA_DEEP} + target = {'action': ps.ae.A_EXIT, 'decide_kind': ps.ae.DK_TARGET_PRICE} + verdict = {'verdict': judge.PASS, 'raw': {}, 'confidence': 90} + self.assertEqual(ps._self_decide(dca, verdict, p, None)['decision'], 'accept') + self.assertEqual(ps._self_decide(target, verdict, p, None)['decision'], 'accept') + already_full = self.route(CODES[0], dict(self.params, _sd_base_count=1)) + self.assertTrue(already_full['queued']) + self.assertEqual(pms_repo.list_instructions(), []) + + +if __name__ == '__main__': + unittest.main() diff --git a/scripts/test_batch17_units.py b/scripts/test_batch17_units.py index cc9bd44..99fbea4 100644 --- a/scripts/test_batch17_units.py +++ b/scripts/test_batch17_units.py @@ -16,9 +16,12 @@ import os import sys import traceback from types import SimpleNamespace +from contextlib import nullcontext +from unittest.mock import patch sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +from app.services import strategy_runner from app.services import param_store # noqa: E402 from app.services import strategy_advisor as adv # noqa: E402 from app.services import strategy_service as svc # noqa: E402 @@ -54,7 +57,7 @@ def _out(): def _pos(**kw): d = {"ts_code": "600000.SH", "total_qty": 1000, "avail_qty": 1000, - "price": 10.0, "price_ok": True, "market_value": 10000.0, + "price": 10.0, "avg_cost": 9.5, "price_ok": True, "market_value": 10000.0, "cushion_pct": 0.05, "support_ref": 9.0, "pressure_ref": 11.0, "frozen_reason": "NONE"} d.update(kw) @@ -573,7 +576,7 @@ def _(): fake_svc = SimpleNamespace( set_status=lambda sid, s, by="user": rec.status_calls.append((sid, s, by)) or {"ok": True}, - attach=lambda cfg, by="user": rec.attach_calls.append((cfg, by)) or + attach=lambda cfg, by="user", **kw: rec.attach_calls.append((cfg, by)) or {"ok": True, "strategy_id": "S_T"}, pause_buy=lambda *a, **k: [], clear_buypause=lambda *a, **k: {"ok": True}) orig_led, orig_upd = pms_repo.insert_ledger, pms_repo.update_strategy @@ -581,7 +584,11 @@ def _(): pms_repo.update_strategy = lambda sid, **kw: rec.upd_calls.append((sid, kw)) or 1 try: out = _out() - adv._tend_existing(st, _pos(price=10.6), {"cls": adv.CLS_CLEAR}, True, 0.9, + with (patch.object(strategy_runner, "fresh_trail_price", return_value=10.6), + patch.object(pms_repo, "list_instructions", return_value=[]), + patch.object(pms_repo, "strategy_guard", return_value=nullcontext()), + patch.object(pms_repo, "get_strategy", return_value=dict(st, status="ACTIVE"))): + adv._tend_existing(st, _pos(price=10.6), {"cls": adv.CLS_CLEAR}, True, 0.9, _prm(), {}, set(), TODAY, False, out, fake_svc) assert rec.status_calls == [("S_G", "CANCELLED", "auto")], rec.status_calls marks = [kw for sid, kw in rec.upd_calls if sid == "S_G"] @@ -625,8 +632,10 @@ def _(): pms_repo.get_instruction = orig_get # dry_run 只报不动 out3 = _out() - adv._tend_existing(st, _pos(price=10.6), {"cls": adv.CLS_CLEAR}, True, 0.9, - _prm(), {}, set(), TODAY, True, out3, fake_svc) + with (patch.object(strategy_runner, "fresh_trail_price", return_value=10.6), + patch.object(pms_repo, "list_instructions", return_value=[])): + adv._tend_existing(st, _pos(price=10.6), {"cls": adv.CLS_CLEAR}, True, 0.9, + _prm(), {}, set(), TODAY, True, out3, fake_svc) assert out3["handoffs"] and out3["handoffs"][0]["dry_run"] and not rec.status_calls @@ -635,7 +644,7 @@ def _(): rec = _Rec() fake_svc = SimpleNamespace( set_status=lambda sid, s, by="user": {"ok": True}, - attach=lambda cfg, by="user": {"ok": False, "errors": ["跟踪止盈触发时要卖出, 但当前 T+1 可卖为 0"]}, + attach=lambda cfg, by="user", **kw: {"ok": False, "errors": ["跟踪止盈触发时要卖出, 但当前 T+1 可卖为 0"]}, pause_buy=lambda *a, **k: [], clear_buypause=lambda *a, **k: {"ok": True}) manual = {"strategy_id": "S_M", "ts_code": "600000.SH", "type": "GRID", "note": "手工网格", "params": {"upper": 10.5}, "state": {}} @@ -648,16 +657,20 @@ def _(): adv._tend_existing(auto_trail, _pos(price=10.6), {"cls": adv.CLS_CLEAR}, True, 0.9, _prm(), {}, set(), TODAY, False, out2, fake_svc) assert any("本轮无需变更" in s["why"] for s in out2["skipped"]), out2["skipped"] - # 半途而废: 撤成挂败 → errors 里有「人工处理」, 留痕 HANDOFF/REJECT + # 新方案挂载失败,留下接力未完成的原因与 REJECT 回执。 orig_led, orig_upd = pms_repo.insert_ledger, pms_repo.update_strategy pms_repo.insert_ledger = lambda **kw: rec.ledger.append(kw) or 1 pms_repo.update_strategy = lambda sid, **kw: 1 try: grid = dict(manual, note="自动挂载: 网格") out3 = _out() - adv._tend_existing(grid, _pos(price=10.6), {"cls": adv.CLS_CLEAR}, True, 0.9, + with (patch.object(strategy_runner, "fresh_trail_price", return_value=10.6), + patch.object(pms_repo, "list_instructions", return_value=[]), + patch.object(pms_repo, "strategy_guard", return_value=nullcontext()), + patch.object(pms_repo, "get_strategy", return_value=dict(grid, status="ACTIVE"))): + adv._tend_existing(grid, _pos(price=10.6), {"cls": adv.CLS_CLEAR}, True, 0.9, _prm(), {}, set(), TODAY, False, out3, fake_svc) - assert any("人工处理" in e for e in out3["errors"]), out3["errors"] + assert any("接力未完成" in e for e in out3["errors"]), out3["errors"] assert any(x.get("action") == "HANDOFF" and x.get("verdict") == "REJECT" for x in rec.ledger), rec.ledger finally: diff --git a/scripts/test_batch20_units.py b/scripts/test_batch20_units.py index 97a217c..511765e 100644 --- a/scripts/test_batch20_units.py +++ b/scripts/test_batch20_units.py @@ -291,6 +291,8 @@ def _route(c, *, values, judge_resp, open_autonomy="propose_only"): p(pms_repo, "insert_instruction", lambda **kw: got["instructions"].append(kw) or 1) p(pms_repo, "insert_proposal", lambda **kw: got["proposals"].append(kw) or 1) p(pms_repo, "list_ledger", lambda **kw: []) + p(pms_repo, "get_param", lambda key, *, for_update=False: + {"PMS_OPEN_AUTONOMY": open_autonomy, **values}.get(key)) _patch_params(p, param_store, {"PMS_EXEC_WINDOW_TDAYS": 3, "PMS_PROPOSAL_TTL_HOURS": 24, "PMS_JUDGE_TICK_BUDGET_SEC": 150, **values}) out = {"autonomy": "propose_only", "open_autonomy": open_autonomy, "executed": [], diff --git a/scripts/test_batch38_units.py b/scripts/test_batch38_units.py index dff3724..97a1c4f 100644 --- a/scripts/test_batch38_units.py +++ b/scripts/test_batch38_units.py @@ -116,7 +116,8 @@ class DailyPlanTest(unittest.TestCase): p = dict(top_n=1, tiers=['强传导'], include_observe=False, min_score=0, min_sources=0, min_upside=0, theme_cap_local=1, exclude_st=False, rank_by_quality=True, rank_by_upstream=True, observe_if_fund_bull=False) - with patch.object(pf, '_params', return_value=p), patch.object(pf, 'get_plan', return_value=pf.parse_plan(raw)): + with patch.object(pf, '_params', return_value=p), patch.object(pf, 'get_plan', return_value=pf.parse_plan(raw)), \ + patch.object(pf, 'read_current_plan', return_value=pf.parse_plan(dict(raw, main=raw['main'][1:]))): self.assertEqual([x['ts_code'] for x in pf.candidates(record=False)['items']], ['600001.SH']) fresh = pf.candidates(record=False, recheck_code='600002.SH') self.assertEqual([x['ts_code'] for x in fresh['items']], ['600002.SH']) diff --git a/scripts/test_batch51_units.py b/scripts/test_batch51_units.py index a214080..a8eec87 100644 --- a/scripts/test_batch51_units.py +++ b/scripts/test_batch51_units.py @@ -47,6 +47,9 @@ class DailyReviewTests(unittest.TestCase): return int(isinstance(value, dict) and path[2:] in value) connection.create_function('JSON_CONTAINS_PATH', 3, contains_path) event.listen(self.engine, 'connect', register_json_functions) + @event.listens_for(self.engine, 'before_cursor_execute', retval=True) + def sqlite_lock_syntax(conn, cursor, statement, parameters, context, executemany): + return statement.removesuffix(' FOR UPDATE'), parameters self.use(session, 'get_engine', return_value=self.engine) self.use(session, '_check_cooldown') self.use(execution_repo, 'pending_corrections', return_value=0) @@ -61,6 +64,10 @@ class DailyReviewTests(unittest.TestCase): 'verdict': {'verdict': 'PASS', 'reason': 'today', 'degraded': False}, 'auto_exec': True} self.scan = self.use(ps, 'scan_and_route', side_effect=lambda **kw: {'ok': True, 'review': copy.deepcopy(self.fresh)}) ddl = [ + 'CREATE TABLE pms_ws_state(id INTEGER PRIMARY KEY)', + 'INSERT INTO pms_ws_state VALUES(1)', + 'CREATE TABLE pms_runtime_param(param_key TEXT PRIMARY KEY,param_value TEXT)', + "INSERT INTO pms_runtime_param VALUES ('PMS_SELF_DECIDE','full')", 'CREATE TABLE pms_proposal(id INTEGER PRIMARY KEY,proposal_id TEXT UNIQUE,ts_code TEXT,action TEXT,qty INTEGER,hard_numbers_json TEXT,status TEXT,expire_at TEXT,decided_at TEXT,judge_verdict TEXT,judge_reason TEXT,archived_at TEXT,created_at TEXT)', 'CREATE TABLE pms_action_ledger(id INTEGER PRIMARY KEY,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)', 'CREATE TABLE pms_instruction(id INTEGER PRIMARY KEY,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,progress_json TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT)'] @@ -84,6 +91,59 @@ class DailyReviewTests(unittest.TestCase): p = p or self.prop() return dr.decide_confirmation(p, 'ACCEPTED', '交易员确认', p['hard_numbers']['proposal_revision'], now=NOW) + def test_each_waiting_parent_gets_a_turn_after_pending_or_failure(self): + for iid in ('Q', 'R'): + pms_repo.insert_instruction(instruction_id=iid, origin_type='plan', origin_id=iid, + ts_code=CODE, action='OPEN', side='buy', qty=600, limit_price=None, + window_tdays=3, status='PROPOSED', progress={'decision_ymd': 20261029}) + seen = [] + def decide(**kwargs): + iid = kwargs['review_instruction']['instruction_id'] + seen.append(iid) + if iid == 'P': + return {'ok': False, 'errors': ['资料暂不可用']} + if iid == 'Q': + return {'ok': True, 'skipped': [{'by': 'judge_pending'}]} + return {'ok': True, 'review': None} + self.scan.side_effect = decide + for minute in range(4): + dr.process(now=NOW + timedelta(minutes=minute)) + self.assertEqual(seen, ['P', 'Q', 'R', 'P']) + self.assertEqual(pms_repo.get_instruction('R')['status'], 'EXPIRED') + self.assertEqual(self.parent()['progress']['daily_review']['attempts'], 2) + + def test_concurrent_review_skips_an_active_request_and_recovers_after_worker_loss(self): + calls = [] + def decide(**kwargs): + calls.append(kwargs['review_instruction']['instruction_id']) + if len(calls) == 1: + dr.process(now=NOW + timedelta(seconds=1)) + return {'ok': True, 'skipped': [{'by': 'judge_pending'}]} + self.scan.side_effect = decide + self.run_review() + self.assertEqual(calls, ['P']) + old = self.parent() + self.assertIsNotNone(dr._claim_review(old, NOW)) + self.assertIsNone(dr._claim_review(old, NOW)) + dr.process(now=NOW + timedelta(seconds=5)) + self.assertEqual(len(calls), 1) + dr.process(now=NOW + timedelta(minutes=5)) + self.assertEqual(len(calls), 2) + + def test_waiting_parent_beyond_newest_500_is_serviced(self): + with session.transaction(): + for index in range(500): + pms_repo.insert_instruction(instruction_id=f'held-{index}', origin_type='plan', + origin_id='plan', ts_code=CODE, action='OPEN', side='buy', qty=100, + limit_price=None, window_tdays=3, status='WAIT_REVIEW', progress={ + 'daily_review': {'ymd': 20261030, 'status': 'pending'}, + 'trade_correction_hold': True}) + self.scan.side_effect = lambda **kwargs: {'ok': True, 'review': None} + result = self.run_review() + self.assertEqual(result['ended'], ['P']) + self.assertEqual(len(result['waiting']), 500) + self.assertEqual(result['errors'], []) + def test_async_pending_keeps_parent_for_later_result(self): self.scan.side_effect=None self.scan.return_value={'ok':True,'review':None, @@ -189,6 +249,19 @@ class DailyReviewTests(unittest.TestCase): self.params['PMS_GLOBAL_BUY_HALT'] = True self.run_review(); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW'); self.scan.assert_not_called() + def test_no_remaining_auto_places_queues_existing_parent(self): + session.execute("INSERT INTO pms_runtime_param VALUES ('PMS_SELF_DECIDE_DAILY_MAX','1')") + pms_repo.insert_ledger(ts_code='600000.SH', action='OPEN', arbiter='judge', verdict='PASS', + price_at=10, ref_id='recent_open', reason='系统采纳:原新建仓') + self.fresh['self_decide'] = {'decision': 'accept'} + result = self.run_review() + self.assertEqual(result['queued'], ['P']) + self.assertEqual(self.parent()['status'], 'WAIT_REVIEW') + self.assertIn('上限', self.prop()['hard_numbers']['reason']) + self.assertEqual(pms_repo.system_pass_count_today('2000-01-01'), 1) + self.assertTrue(self.accept()['ok']) + self.assertEqual(pms_repo.system_pass_count_today('2000-01-01'), 1) + def test_auto_accept_is_counted_in_existing_daily_limit(self): self.fresh['self_decide'] = {'decision': 'accept'} self.run_review() diff --git a/scripts/test_batch52_units.py b/scripts/test_batch52_units.py index 32fb063..c365d6a 100644 --- a/scripts/test_batch52_units.py +++ b/scripts/test_batch52_units.py @@ -223,4 +223,160 @@ class ZBookTest(unittest.TestCase): cash.assert_called_once_with('original', 'buy', 2330., 0, '1') +class DailyQuantityTests(unittest.TestCase): + def setUp(self): + from app.services import command_service, market, param_store, portfolio + self.now = datetime(2026, 11, 18, 10, 10) + self.code = '600000.SH' + self.parent = {'instruction_id': 'reduction', 'ts_code': self.code, 'action': 'TRIM', + 'side': 'sell', 'qty': 3000, 'exec_qty': 0, 'status': 'DISPATCHED', 'origin_type': 'plan', + 'progress': {'deadline': '2026-11-20', 'is_command': True, 'children': []}} + self.orders = [] + self.position = {'ts_code': self.code, 'total_qty': 5000, 'avail_qty': 5000} + self.use(pms_repo, 'list_instructions', return_value=[self.parent]) + self.use(pms_repo, 'get_instruction', return_value=self.parent) + self.use(qmt_repo, 'orders_for_parent', side_effect=lambda _: copy.deepcopy(self.orders)) + self.use(qmt_repo, 'get_order', side_effect=lambda iid: next( + (r for r in self.orders if r['instruction_id'] == iid), None)) + self.use(execution_repo, 'pending_corrections', return_value=0) + self.use(execution_repo, 'pending_trades', return_value=[]) + self.use(dispatcher, 'mode', return_value='ws') + self.use(param_store, 'get_bool', side_effect=lambda k, d=False: k == 'PMS_EXEC_REPRICE_ENABLED' or d) + self.use(param_store, 'get_int', side_effect=lambda k, d=0: d) + self.use(param_store, 'get_float', side_effect=lambda k, d=0.: d) + self.use(param_store, 'get', side_effect=lambda k, d=None: d) + self.use(command_service, 'effective_stock_params', return_value={}) + self.use(portfolio, 'positions_view', return_value={'positions': [self.position], + 'params': {'exec_halt': False, 'buy_halt': False}, 'sector_ready': True}) + self.use(market, 'day_snapshot', return_value={'price': 10, 'low': 9, 'high': 11}) + self.use(market, 'execution_quote', return_value={'source': '测试', 'kind': 'level1', + 'last': 10, 'bid': 9.99, 'ask': 10, 'as_of': self.now.isoformat()+'+08:00', + 'limit_down': 9, 'limit_up': 11}) + + def use(self, obj, name, **kwargs): + hook = patch.object(obj, name, **kwargs) + self.addCleanup(hook.stop) + return hook.start() + + def child(self, qty, filled, *, day=None, status='CANCELLED', progress=True): + ref = f"reduction_D{len(self.orders)+1:02d}" + day = day or self.now + self.orders.append({'instruction_id': ref, 'parent_id': 'reduction', 'qty': qty, + 'cum_qty': filled, 'status': status, 'created_at': day}) + self.parent['exec_qty'] += filled + if progress: + self.parent['progress']['children'].append({'ref': ref, 'qty': qty, + 'ymd': int(day.strftime('%Y%m%d'))}) + + def quantity(self): + result = executor.run_tick(now=self.now, dry_run=True) + self.assertEqual(result['errors'], []) + self.assertEqual(result['rejected'], []) + return sum(item['qty'] for item in result['fired']) + + def test_outdated_execution_read_cannot_overwrite_a_new_review_claim(self): + from app.services import daily_buy_review + self.parent.update(action='OPEN', side='buy', status='PROPOSED') + self.use(pms_repo, 'get_instruction', side_effect=lambda _: copy.deepcopy(self.parent)) + self.use(pms_repo, 'instruction_buy_stop', return_value=None) + update = self.use(pms_repo, 'update_instruction') + + def gate(_, *, now): + self.parent.update(status='WAIT_REVIEW') + self.parent['progress']['daily_review'] = {'ymd': 20261118, 'status': 'pending', 'attempts': 1} + return '旧买入安排需完成当日复核' + self.use(daily_buy_review, 'blocker', side_effect=gate) + result = executor.run_tick(now=self.now) + self.assertEqual(result['errors'], []) + self.assertTrue(result['waited']) + update.assert_not_called() + + def test_partial_fill_does_not_shrink_opening_allotment(self): + self.assertEqual(self.quantity(), 1000) + self.child(1000, 700) + self.assertEqual(self.quantity(), 300) + self.assertEqual(self.quantity(), 300) + self.child(300, 300, status='FILLED', progress=False) + self.assertEqual(self.quantity(), 0) + + def test_yesterday_and_missing_progress_are_counted_on_their_own_day(self): + self.child(600, 600, day=datetime(2026, 11, 17), status='FILLED') + self.child(800, 300, progress=False) + self.assertEqual(self.quantity(), 500) + self.orders[-1]['status'] = 'PARTIAL' + self.assertEqual(self.quantity(), 0) + self.assertEqual(executor.dispatch_allowance(self.parent, self.now, 3), 0) + self.orders[-1]['status'] = 'CANCELLED' + self.parent['exec_qty'] = 600 + self.assertEqual(self.quantity(), 0) + self.parent['exec_qty'] = 900 + self.assertEqual(self.quantity(), 500) + + def test_partial_lot_and_full_odd_lot_exit(self): + self.child(1000, 725) + self.assertEqual(self.quantity(), 200) + self.parent.update(action='EXIT', qty=1000) + self.position.update(total_qty=275, avail_qty=275) + self.parent['progress']['urgent'] = True + self.assertEqual(self.quantity(), 100) + self.parent['progress']['deadline'] = '2026-11-18' + self.assertEqual(self.quantity(), 275) + self.parent['progress']['urgent'] = False + self.assertEqual(self.quantity(), 275) + + def test_fill_between_quote_and_dispatch_waits_then_the_next_tick_uses_balance(self): + from app.services import execution_orders + clock = self.use(dispatcher, 'datetime', wraps=datetime) + clock.now.return_value = self.now + self.use(pms_repo, 'account_decision_guard', side_effect=nullcontext) + outlet = self.use(dispatcher, '_ws', return_value={'ok': True}) + + def other_tick_settles(_): + self.child(1000, 700, progress=False) + return 'reduction_D02' + self.use(execution_orders, 'next_child_id', side_effect=other_tick_settles) + result = executor.run_tick(now=self.now) + self.assertEqual(result['errors'], []) + self.assertEqual(result['fired'], []) + self.assertIn('300股', result['waited'][0]['reason']) + outlet.assert_not_called() + self.assertEqual(self.quantity(), 300) + + def test_rotation_and_urgent_parents_keep_their_execution_rules(self): + from app.services import execution_orders + self.use(execution_orders, 'enabled', return_value=False) + self.use(execution_orders, 'account_guard', side_effect=nullcontext) + ordinary_guard = self.use(pms_repo, 'account_decision_guard') + self.use(dispatcher, '_ws', return_value={'ok': True}) + clock = self.use(dispatcher, 'datetime', wraps=datetime) + clock.now.return_value = self.now + for field, value in [('execution_profile', 'rotation'), ('urgent', True)]: + self.parent['progress'][field] = value + result = dispatcher.dispatch(instruction_id='reduction_D01', parent_id='reduction', + ts_code=self.code, side='sell', qty=3000, limit_price=10, valid_until=self.now) + self.assertTrue(result['ok'], result) + del self.parent['progress'][field] + ordinary_guard.assert_not_called() + + def test_dispatch_rechecks_day_usage_after_quote_and_retains_idempotent_retry(self): + self.child(1000, 700, progress=False) + clock = self.use(dispatcher, 'datetime', wraps=datetime) + clock.now.return_value = self.now + guard = self.use(pms_repo, 'account_decision_guard', side_effect=nullcontext) + outlet = self.use(dispatcher, '_ws', return_value={'ok': True}) + from app.services import execution_orders + self.use(execution_orders, 'enabled', return_value=False) + def send(qty, iid='reduction_D02'): + return dispatcher.dispatch(instruction_id=iid, parent_id='reduction', ts_code=self.code, + side='sell', qty=qty, limit_price=10, valid_until=self.now.replace(minute=20)) + stale = send(1000) + self.assertFalse(stale['ok']) + self.assertTrue(stale['deferred']) + self.assertIn('300股', stale['error']) + outlet.assert_not_called() + self.assertTrue(send(300)['ok']) + self.assertTrue(send(1000, 'reduction_D01')['ok']) + self.assertEqual(guard.call_count, 3) + + if __name__ == '__main__': unittest.main() diff --git a/scripts/test_batch53_units.py b/scripts/test_batch53_units.py index d9ec572..963179f 100644 --- a/scripts/test_batch53_units.py +++ b/scripts/test_batch53_units.py @@ -66,7 +66,7 @@ class StrategyOutboxTest(unittest.TestCase): try: with ExitStack() as stack: from contextlib import nullcontext - from app.services import execution_orders + from app.services import execution_orders, rotation_service from app.repo import execution_repo stack.enter_context(patch.object(execution_orders, 'account_guard', side_effect=nullcontext)) stack.enter_context(patch.object(execution_repo, 'pending_corrections', return_value=0)) @@ -79,6 +79,7 @@ class StrategyOutboxTest(unittest.TestCase): (qmt_repo, 'mark_sent', {}), (pms_repo, 'get_instruction', {'side_effect': read}), (execution_conflicts, 'queued_buy_blocker', {'return_value': None}), + (rotation_service, 'order_control_blocker', {'return_value': None}), ]: stack.enter_context(patch.object(obj, name, **kw)) send = stack.enter_context(patch.object(runner, '_send', new_callable=AsyncMock)) diff --git a/scripts/test_batch56_units.py b/scripts/test_batch56_units.py index b94cd1b..332c4c8 100644 --- a/scripts/test_batch56_units.py +++ b/scripts/test_batch56_units.py @@ -34,6 +34,269 @@ def state(snap=None): return m.transition(m.initial_state(), snap, micro_qty=0, original_qty=0, budget=100000) +class MicroBuyRestrictionTests(unittest.TestCase): + def setUp(self): + from app.core import strategy_book as books + from app.repo import pms_repo + from app.services import rotation_service + self.enterContext(patch.object(rotation_service.store, 'account_guard', side_effect=nullcontext)) + self.commands = [] + + def effective_commands(*args, **kwargs): + self.assertEqual(books.CURRENT.get(), books.ORIGINAL) + return list(self.commands) + + self.enterContext(patch.object(pms_repo, 'list_effective_stock_params', side_effect=effective_commands)) + + def command(self, code, kind): + self.commands.append({'id': len(self.commands)+1, 'ts_code': code, 'cmd_type': kind}) + + def parent(self, code, side='buy'): + return {'instruction_id': code+'-'+side, 'ts_code': code, 'book_id': 'micro30', + 'side': side, 'action': 'OPEN' if side == 'buy' else 'EXIT', 'qty': 300, + 'exec_qty': 100, 'status': 'DISPATCHED', 'origin_type': 'rotation', + 'progress': {'execution_profile': 'rotation', 'rule_version': m.EXECUTION_RULE, + 'deadline': '2026-11-03'}} + + def test_entry_preserves_other_members_and_authorized_sales(self): + from app.services import rotation_service + snap = snapshot() + basket = state(snap) + held, frozen, black = '000001.SZ', '600000.SH', '600001.SH' + self.command(held, 'FREEZE_STOCK') + self.command(frozen, 'FREEZE_STOCK') + self.command(black, 'BLACKLIST_ADD') + quotes = {r['code']: {'price': 10.} for r in snap['members']} + quotes[held] = {'price': 10.} + def intents(): + orders, _ = m.orders(basket, snap, original=[{'ts_code': held, 'total_qty': 100}], + micro=[], quotes=quotes, cash=100000, account_mv=1000, cap_amount=110000, + buy_restrictions=rotation_service.micro_buy_restrictions()) + return {(r['ts_code'], r['side']) for r in orders} + + allowed = intents() + expected = {(r['code'], 'buy') for r in snap['members'] if r['code'] not in (frozen, black)} + self.assertEqual(allowed, expected | {(held, 'sell')}) + self.command(frozen, 'UNFREEZE_STOCK') + self.assertEqual(intents(), allowed | {(frozen, 'buy')}) + self.command(black, 'BLACKLIST_REMOVE') + self.assertEqual(intents(), allowed | {(frozen, 'buy'), (black, 'buy')}) + + def test_live_partial_buy_is_cancelled_without_replacing_its_remainder(self): + from app.services import rotation_service, rotation_execution as execution, executor, execution_orders + parent = self.parent('600000.SH') + self.command(parent['ts_code'], 'FREEZE_STOCK') + now = dt.datetime(2026, 11, 3, 9, 40) + with patch.object(executor, 'cancel_instruction', return_value={'ok': True}) as cancel, \ + patch.object(execution_orders, 'request_replace') as reprice, \ + patch.object(execution, 'send_intent') as send: + results, waits = execution.refresh_orders([parent], {parent['ts_code']: {'price': 10.}}, now, + 'version', {parent['ts_code']}, rotation_service.micro_buy_restrictions()) + self.assertTrue(waits) + self.assertEqual(results, []) + self.assertEqual(cancel.call_args.args, (parent['instruction_id'],)) + self.assertIn('冻结', cancel.call_args.kwargs['reason']) + reprice.assert_not_called() + send.assert_not_called() + + def test_user_command_cancels_only_live_micro_buys_in_that_stock(self): + from app.services import rotation_service, executor + from app.repo import pms_repo + from app.core import strategy_book as books + parent = self.parent('600000.SH') + def buys(**filters): + self.assertEqual(books.CURRENT.get(), books.MICRO) + self.assertEqual((filters['side'], filters['ts_code']), ('buy', parent['ts_code'])) + self.assertIn('DISPATCHED', filters['statuses']) + return [parent] + def get_command(command_id): + self.assertEqual(books.CURRENT.get(), books.ORIGINAL) + return {'ts_code': parent['ts_code'], 'status': 'EFFECTIVE'} + with patch.object(pms_repo, 'get_command', side_effect=get_command), \ + patch.object(pms_repo, 'list_instructions', side_effect=buys), \ + patch.object(executor, 'cancel_instruction', return_value={'ok': True}) as cancel: + rotation_service.on_user_command('BLACKLIST_ADD', 'cmd', 'user') + cancel.assert_called_once_with(parent['instruction_id'], reason='用户单股禁买命令 cmd', arbiter='user') + + def test_next_poll_retries_failed_cancel_of_legacy_parent_only_on_buy_side(self): + from app.services import rotation_service, rotation_execution as execution, executor + from app.repo import pms_repo + code = '600000.SH' + old = self.parent(code) + old['progress']['rule_version'] = m.RULE + same_stock_sell = self.parent(code, side='sell') + other_buy = self.parent('600001.SH') + self.command(code, 'FREEZE_STOCK') + + def active(**filters): + return [old] if filters.get('side') == 'buy' else [old, same_stock_sell, other_buy] + + with patch.object(pms_repo, 'get_command', return_value={'ts_code': code, 'status': 'EFFECTIVE'}), \ + patch.object(pms_repo, 'list_instructions', side_effect=active), \ + patch.object(executor, 'cancel_instruction', side_effect=[{'ok': False}, {'ok': True}]) as cancel: + with self.assertRaises(RuntimeError): + rotation_service.on_user_command('FREEZE_STOCK', 'cmd', 'user') + execution.cancel_expired(dt.datetime(2026, 11, 3, 9, 35)) + self.assertEqual([call.args[0] for call in cancel.call_args_list], + [old['instruction_id'], old['instruction_id']]) + self.assertEqual([call.kwargs['arbiter'] for call in cancel.call_args_list], ['user', 'system']) + + def test_queued_then_frozen_then_released_at_final_send(self): + from app.services import execution_orders as eo, execution_conflicts as conflicts, rotation_service + from app.services import param_store, risk_exit + from app.repo import pms_repo, qmt_repo + from config.settings import settings + parent = self.parent('600000.SH') + order = {'instruction_id': 'child', 'parent_id': parent['instruction_id'], + 'ts_code': parent['ts_code'], 'side': 'buy', 'status': 'QUEUED'} + self.enterContext(patch.object(settings, 'PMS_TABLE_PREFIX', '')) + self.enterContext(patch.object(pms_repo, 'get_param', side_effect=lambda key, **kwargs: + {'PMS_ROTATION_MODE': 'auto', 'PMS_ROTATION_CONTROL': 'run'}.get(key))) + self.enterContext(patch.object(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', True)) + self.enterContext(patch.object(eo, 'account_guard', side_effect=nullcontext)) + self.enterContext(patch.object(eo, 'correction_blocker', return_value=None)) + self.enterContext(patch.object(risk_exit, 'buy_blocker', return_value=None)) + self.enterContext(patch.object(param_store, 'get_bool', return_value=False)) + self.enterContext(patch.object(param_store, 'get', side_effect=lambda key, default=None: default)) + self.enterContext(patch.object(rotation_service, 'configuration', return_value={'mode': 'auto', 'control': 'run'})) + self.enterContext(patch.object(rotation_service.store, 'get', return_value=({'rotation': {'phase': 'micro'}}, 1))) + self.enterContext(patch.object(pms_repo, 'get_instruction', return_value=parent)) + self.enterContext(patch.object(pms_repo, 'instruction_buy_stop', return_value=False)) + self.enterContext(patch.object(pms_repo, 'list_instructions', return_value=[])) + self.enterContext(patch.object(qmt_repo, 'get_order', return_value=order)) + mark = self.enterContext(patch.object(qmt_repo, 'mark_send_attempt', return_value=True)) + self.assertFalse(conflicts.queued_buy_blocker(order)) + for stop, resume in (('FREEZE_STOCK', 'UNFREEZE_STOCK'), ('BLACKLIST_ADD', 'BLACKLIST_REMOVE')): + self.command(order['ts_code'], stop) + self.assertTrue(conflicts.queued_buy_blocker(order)) + self.assertFalse(eo.prepare_send('child')['marked']) + mark.assert_not_called() + self.command(order['ts_code'], resume) + self.assertFalse(conflicts.queued_buy_blocker(order)) + self.assertTrue(eo.prepare_send('child')['marked']) + mark.assert_called_once_with('child') + mark.reset_mock() + + + def test_new_global_halt_blocks_even_exit_sell_but_preserves_order_cancellation(self): + from app.repo import pms_repo, qmt_repo + from app.services import dispatcher, execution_orders as eo, param_store, rotation_service + from config.settings import settings + parent = self.parent('600000.SH', side='sell') + order = {'instruction_id': 'child', 'parent_id': parent['instruction_id'], + 'ts_code': parent['ts_code'], 'side': 'sell', 'status': 'QUEUED'} + authoritative = {'PMS_ROTATION_MODE': 'auto', 'PMS_ROTATION_CONTROL': 'exit_disable'} + def current_param(key, *, for_update=False): + self.assertTrue(for_update) + return authoritative.get(key) + self.enterContext(patch.object(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', True)) + self.enterContext(patch.object(settings, 'PMS_TABLE_PREFIX', '')) + self.enterContext(patch.object(param_store, 'get_bool', return_value=False)) + self.enterContext(patch.object(pms_repo, 'get_param', side_effect=current_param)) + self.enterContext(patch.object(eo, 'account_guard', side_effect=nullcontext)) + self.enterContext(patch.object(eo, 'correction_blocker', return_value=None)) + self.enterContext(patch.object(pms_repo, 'get_instruction', return_value=parent)) + self.enterContext(patch.object(qmt_repo, 'get_order', return_value=order)) + self.enterContext(patch.object(rotation_service, 'configuration', + return_value={'mode': 'auto', 'control': 'exit_disable'})) + mark = self.enterContext(patch.object(qmt_repo, 'mark_send_attempt', return_value=True)) + self.assertTrue(eo.prepare_send('child')['marked']) + mark.reset_mock() + authoritative['PMS_GLOBAL_EXEC_HALT'] = 'true' + result = eo.prepare_send('child') + self.assertFalse(result['marked']) + self.assertIn('暂停', result['blocked']) + mark.assert_not_called() + with patch.object(dispatcher, 'mode', return_value='ws'), \ + patch.object(dispatcher, 'channel_status', return_value={'online': True}), \ + patch.object(qmt_repo, 'request_cancel', return_value=1) as request: + cancelled = dispatcher.cancel(instruction_id=parent['instruction_id']) + self.assertTrue(cancelled['ok']) + self.assertTrue(cancelled['cancel_pending']) + self.assertEqual(request.call_args.kwargs['parent_id'], parent['instruction_id']) + + +class StockRestrictionIssueTests(unittest.TestCase): + def setUp(self): + from sqlalchemy import create_engine, event, text + from app.db import session + from app.repo import pms_repo + from app.services import param_store + from config.settings import settings + self.engine = create_engine('sqlite:///:memory:') + self.addCleanup(self.engine.dispose) + self.enterContext(patch.object(session, 'get_engine', return_value=self.engine)) + self.enterContext(patch.object(session, '_check_cooldown')) + self.enterContext(patch.object(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', True)) + self.enterContext(patch.object(settings, 'PMS_TABLE_PREFIX', '')) + self.enterContext(patch.object(param_store, 'get_bool', return_value=False)) + self.enterContext(patch.object(pms_repo, 'list_instructions', return_value=[])) + + @event.listens_for(self.engine, 'begin') + def transaction_started(conn): + conn.info['account_locked'] = False + + @event.listens_for(self.engine, 'before_cursor_execute', retval=True) + def sqlite_dialect(conn, cursor, statement, params, context, many): + # SQLite内存事务用写操作取得锁。保留生产的加锁次序和全部业务SQL。 + if "doc_id='account-execution' FOR UPDATE" in statement: + conn.info['account_locked'] = True + statement = ("UPDATE pms_rotation_document SET revision=revision " + "WHERE doc_id='account-execution' RETURNING doc_id") + else: + statement = statement.replace(' FOR UPDATE', '') + statement = statement.replace('ON DUPLICATE KEY UPDATE doc_id=VALUES(doc_id)', + 'ON CONFLICT(doc_id) DO NOTHING') + statement = statement.replace('ON DUPLICATE KEY UPDATE updated_at =', + 'ON CONFLICT(book_id,ts_code) DO UPDATE SET updated_at =') + if statement.startswith('UPDATE pms_command SET status') and 'EFFECTIVE' in params: + self.assertTrue(conn.info['account_locked']) + return statement, params + + with self.engine.begin() as conn: + conn.execute(text('CREATE TABLE pms_command (id INTEGER PRIMARY KEY, book_id TEXT, ' + 'command_id TEXT UNIQUE, cmd_class TEXT, cmd_type TEXT, ts_code TEXT, params_json TEXT, ' + 'status TEXT, progress_json TEXT, issued_by TEXT, issued_at TEXT, done_at TEXT, note TEXT, archived_at TEXT)')) + conn.execute(text('CREATE TABLE pms_position (book_id TEXT, ts_code TEXT, status TEXT, ' + 'updated_at TEXT, frozen_reason TEXT, PRIMARY KEY(book_id,ts_code))')) + conn.execute(text('CREATE TABLE pms_rotation_document (doc_id TEXT PRIMARY KEY, kind TEXT, ' + 'payload_json TEXT, revision INTEGER, updated_at TEXT)')) + + def issue(self, kind): + from app.services import command_service + return command_service.issue(kind, {'ts_code': '600000.SH'}) + + def test_failed_new_effective_status_restores_prior_freeze_and_position(self): + from sqlalchemy import text + from app.repo import pms_repo + from app.services import command_service + first = self.issue('FREEZE_STOCK') + self.assertTrue(first['ok'], first) + with self.engine.begin() as conn: + conn.execute(text("CREATE TRIGGER refuse_effective BEFORE UPDATE OF status ON pms_command " + "WHEN NEW.status='EFFECTIVE' BEGIN SELECT RAISE(IGNORE); END")) + for kind in ('FREEZE_STOCK', 'UNFREEZE_STOCK'): + with self.subTest(kind=kind): + result = self.issue(kind) + self.assertFalse(result['ok'], result) + self.assertEqual(pms_repo.get_command(result['command_id'])['status'], 'CANCELLED') + self.assertEqual(pms_repo.get_command(first['command_id'])['status'], 'EFFECTIVE') + self.assertTrue(command_service.effective_stock_params()['600000.SH']['frozen']) + self.assertEqual(pms_repo.get_position('600000.SH')['frozen_reason'], 'COMMAND_HALT') + + def test_releasing_one_restriction_keeps_the_other_effective(self): + from app.services import command_service, rotation_service + for kind, frozen, black in [('FREEZE_STOCK', True, False), ('BLACKLIST_ADD', True, True), + ('BLACKLIST_REMOVE', True, False), ('BLACKLIST_ADD', True, True), + ('UNFREEZE_STOCK', False, True), ('BLACKLIST_REMOVE', False, False)]: + with self.subTest(kind=kind): + result = self.issue(kind) + self.assertTrue(result['ok'], result) + flags = command_service.effective_stock_params()['600000.SH'] + self.assertEqual((flags.get('frozen', False), flags.get('black', False)), (frozen, black)) + self.assertEqual('600000.SH' in rotation_service.micro_buy_restrictions(), frozen or black) + + class SnapshotTests(unittest.TestCase): def test_v2_remains_compatible_without_candidates(self): snap = snapshot(rule=m.RULE) @@ -156,7 +419,7 @@ class TargetTests(unittest.TestCase): class ServiceBoundaries(unittest.TestCase): def prepare(self, snap, funds, scale, *, prepare_only=True, fail_limits=False, - missing_position=False, refresh=None): + missing_position=False, refresh=None, configure=None, now=None): from app.services import rotation_service as r, rotation_execution as execution, execution_orders, command_service stored = {'rotation': m.initial_state()} config = {'mode': 'auto', 'control': 'run', 'rule_version': snap['rule_version'], @@ -167,6 +430,7 @@ class ServiceBoundaries(unittest.TestCase): with ExitStack() as stack: for obj, name, value in ( (r, 'configuration', config), (r, 'documents_ready', True), (r, 'activation_errors', []), + (r.param_store, 'execution_halted', False), (r, 'pull', snap), (r, 'reconcile_books', {'ok': True, 'diffs': []}), (r, 'positions', [{'ts_code':'600000.SH','total_qty':100}] if missing_position else []), (r, '_quote', {} if missing_position else {'price': 10}), @@ -177,7 +441,7 @@ class ServiceBoundaries(unittest.TestCase): (r.store, 'get', (stored, 0)), (r.store, 'put_once', None), (r, 'cancel_control_orders', None), (execution, 'cancel_expired', None), (execution, 'suspended_rejections', {}), - (r.pms_repo, 'active_strategies', []), (command_service, 'blacklist', []), + (r.pms_repo, 'active_strategies', []), (command_service, 'effective_stock_params', {}), (execution, 'pending_instructions', [])): stack.enter_context(patch.object(obj, name, return_value=value)) stack.enter_context(patch.object(execution, 'refresh_orders', @@ -190,9 +454,53 @@ class ServiceBoundaries(unittest.TestCase): stack.enter_context(patch.object(r.param_store, 'get_bool', return_value=False)) stack.enter_context(patch.object(r.param_store, 'get_float', side_effect=lambda k,d=0: { 'PMS_TOTAL_SCALE': scale, 'PMS_PORTFOLIO_CAP': 1, 'PMS_CASH_RESERVE': 0}.get(k,d))) - result = r._tick(dt.datetime(2026, 11, 3, 9, 31, tzinfo=r.TZ), prepare_only=prepare_only) + if configure: + configure(stack, stored, config) + result = r._tick(now or dt.datetime(2026, 11, 3, 9, 31, tzinfo=r.TZ), prepare_only=prepare_only) return stored, result, stage.call_count + def test_all_first_choices_frozen_keeps_original_exposure(self): + from app.services import command_service + snap = snapshot() + def configure(stack, stored, config): + flags = {row['code']:{'frozen':True} for row in snap['members']} + stack.enter_context(patch.object(command_service,'effective_stock_params',return_value=flags)) + saved, result, writes = self.prepare(snap,100000,100000,configure=configure) + self.assertEqual(saved['rotation']['phase'],'original') + self.assertIn('禁买',result['blocked'][0]) + self.assertEqual(writes,0) + + def test_afternoon_tick_sells_micro_without_waiting_for_original_t0(self): + from app.db import session as db + from app.services import rotation_service as r, rotation_execution as execution, execution_orders, executor + snap = snapshot() + code = snap['members'][0]['code'] + sold = [] + def configure(stack, stored, config): + stored['rotation'] = state(snap) + config['control'] = 'exit_disable' + holding = {'ts_code':code,'total_qty':300,'avail_qty':200} + stack.enter_context(patch.object(r,'positions',side_effect=lambda b: [holding] if b=='micro30' else [])) + old = {'instruction_id':'old','book_id':'micro30','ts_code':'600001.SH','side':'buy'} + stack.enter_context(patch.object(execution,'pending_instructions',return_value=[old])) + stack.enter_context(patch.object(executor,'cancel_instruction',return_value={'ok':False})) + stack.enter_context(patch.object(r,'_micro_unsettled',return_value=True)) + stack.enter_context(patch.object(r.pms_repo,'active_strategies',return_value=[{'type':'T0','state':{'open_leg':'sell'}}])) + stack.enter_context(patch.object(r,'_limits',return_value={code:{'up_limit':11,'down_limit':9}})) + stack.enter_context(patch.object(execution_orders,'quote_order',return_value={'action':'FIRE','limit_price':10})) + stack.enter_context(patch.object(db,'savepoint',side_effect=nullcontext)) + def send(intent, price, now, version): + sold.append(intent) + return {'ok':True} + stack.enter_context(patch.object(execution,'send_intent',side_effect=send)) + now = dt.datetime(2026,11,3,14,12,tzinfo=r.TZ) + saved, result, _ = self.prepare(snap,100000,100000,prepare_only=False,configure=configure,now=now) + self.assertEqual(saved['rotation']['phase'],'returning_original') + self.assertTrue(any('撤销待重试' in message for message in saved['blocked'])) + self.assertEqual(len(sold),1) + self.assertEqual((sold[0]['side'],sold[0]['book_id'],sold[0]['qty'],sold[0]['manual_exit_cutoff']), + ('sell','micro30',200,'14:57')) + def test_static_failure_prevents_committing_entry(self): stored, result, writes = self.prepare(snapshot(rule=m.RULE), 500, 500) self.assertEqual(stored['rotation']['phase'], 'original') @@ -273,11 +581,14 @@ class ServiceBoundaries(unittest.TestCase): with self.assertRaises(ValueError): r.pending_instructions() - def send_existing(self, settled, cancel=False): + def send_existing(self, settled, cancel=False, *, now=None, cutoff=None): from app.services import rotation_execution as r, execution_orders as e, dispatcher - parent = {'instruction_id':'p', 'book_id':'micro30', 'ts_code':'600000.SH', 'side':'buy', + side = 'sell' if cutoff else 'buy' + parent = {'instruction_id':'p', 'book_id':'micro30', 'ts_code':'600000.SH', 'side':side, 'qty':300, 'exec_qty':100, 'status':'DISPATCHED', 'progress':{'children':[{'ref':'p_D01'}], **({'cancel_requested':True} if cancel else {})}} + if cutoff: + parent['progress']['manual_exit_cutoff'] = cutoff with patch.object(r.db, 'transaction', side_effect=nullcontext), \ patch.object(r.pms_repo, 'get_instruction', return_value=parent), \ patch.object(r.pms_repo, 'update_instruction', return_value=1), \ @@ -287,10 +598,79 @@ class ServiceBoundaries(unittest.TestCase): patch.object(e, 'next_child_id', return_value='p_D02'), \ patch.object(dispatcher, 'mode', return_value='ws'), \ patch.object(dispatcher, 'dispatch', return_value={'ok':True}) as send: - result = r.send_intent({'id':'p','book_id':'micro30','ts_code':'600000.SH','side':'buy', - 'qty':300,'reason':'补齐'},10,dt.datetime(2026,11,3,9,40),'snapshot') + result = r.send_intent({'id':'p','book_id':'micro30','ts_code':'600000.SH','side':side, + 'qty':300,'reason':'补齐'},10,now or dt.datetime(2026,11,3,9,40),'snapshot') return result, send.call_args + def test_legacy_exit_can_reopen_after_system_expiry_and_honors_user_cancellation(self): + from app.services import execution_orders as e + day = '2026-11-03' + record = {'instruction_id':'legacy','book_id':'micro30','ts_code':'600000.SH','side':'sell', + 'status':'CANCELLED','progress':{'execution_profile':'rotation','deadline':day}} + settled = {'active':[], 'pending_trades':0, 'booked':100, 'confirmed_filled':100, 'missing_orders':[]} + with patch.object(e.pms_repo,'list_instructions',return_value=[record]), \ + patch.object(e,'replacement_state',return_value=settled): + def check(authorized_at=None): + return e.code_settlement_blocker(record['ts_code'],manual_exit_day=day, + manual_exit_requested_at=authorized_at) + record['progress']['cancel_requested'] = {'arbiter':'system','at':day+'T10:00:00'} + self.assertFalse(check()) + settled['active'] = [{'status':'ACCEPTED'}] + self.assertIn('仍在途',check()) + settled['active'] = [] + settled['booked'] = 0 + self.assertIn('入账',check()) + settled['booked'] = 100 + record['progress']['cancel_requested'] = {'arbiter':'user','at':day+'T13:55:00'} + self.assertIn('已被撤销',check()) + self.assertIn('已被撤销',check(day+'T13:54:59+08:00')) + self.assertFalse(check(day+'T13:55:01+08:00')) + + def test_manual_exit_retries_only_remaining_and_honors_its_own_session(self): + for hour, minute, cutoff, deadline in ((11,27,'11:30',(11,30)), (14,0,'14:57',(14,10)), + (14,53,'14:57',(14,57))): + with self.subTest(hour=hour, minute=minute): + now = dt.datetime(2026,11,3,hour,minute) + result, sent = self.send_existing({'ready':True,'remaining':200}, now=now, cutoff=cutoff) + self.assertEqual(sent.kwargs['side'], 'sell') + self.assertEqual(sent.kwargs['qty'], 200) + self.assertEqual(sent.kwargs['valid_until'], now.replace(hour=deadline[0],minute=deadline[1])) + ended, sent = self.send_existing({'ready':True,'remaining':200}, + now=dt.datetime(2026,11,3,14,57), cutoff='14:57') + self.assertIsNone(sent) + self.assertIn('结束', ended['state']) + + def test_expiry_preserves_manual_afternoon_order_across_ticks(self): + from app.services import rotation_execution as r, executor + base = {'execution_profile':'rotation', 'deadline':'2026-11-03'} + parents = [{'book_id':'micro30', 'instruction_id':key, 'progress':dict(base, **extra)} + for key, extra in [('regular',{}), ('am',{'manual_exit_cutoff':'11:30'}), + ('pm',{'manual_exit_cutoff':'14:57'})]] + with patch.object(r.pms_repo, 'list_instructions', return_value=parents), \ + patch.object(executor, 'cancel_instruction', return_value={'ok':True}) as cancel: + for hour, minute, expected in [(10,0,['regular']), (14,0,['regular','am']), + (14,57,['regular','am','pm'])]: + cancel.reset_mock() + r.cancel_expired(dt.datetime(2026,11,3,hour,minute)) + self.assertEqual([c.args[0] for c in cancel.call_args_list], expected) + + def test_v2_manual_exit_retries_but_v2_regular_still_uses_frozen_price(self): + from app.services import rotation_execution as r, execution_orders as e + common = {'book_id':'micro30','ts_code':'600000.SH','side':'sell','qty':300} + progress = {'execution_profile':'rotation','deadline':'2026-11-03','rule_version':m.RULE} + parents = [dict(common,instruction_id='manual',progress=dict(progress,manual_exit_cutoff='14:57')), + dict(common,instruction_id='regular',progress=progress)] + with patch.object(r.qmt_repo,'orders_for_parent',return_value=[]), \ + patch.object(e,'quote_order',return_value={'action':'FIRE','limit_price':10}), \ + patch.object(e,'replacement_state',return_value={'ready':True,'remaining':100}), \ + patch.object(r.db,'savepoint',side_effect=nullcontext), \ + patch.object(r,'send_intent',return_value={'ok':True}) as send: + results, waits = r.refresh_orders(parents,{},dt.datetime(2026,11,3,14,0),'snapshot',set(),{}) + self.assertEqual(results,[{'ok':True}]) + self.assertEqual(waits,[]) + self.assertEqual(send.call_args.args[0]['id'],'manual') + self.assertEqual(send.call_args.args[0]['rule_version'],m.RULE) + def test_replacement_waits_until_cancellation_and_booking_finish(self): result, sent = self.send_existing({'ready':False,'remaining':200}) self.assertTrue(result['pending']) @@ -338,6 +718,78 @@ class ServiceBoundaries(unittest.TestCase): replace.assert_not_called() +class ResumeTests(unittest.TestCase): + def test_return_to_original_preserves_released_cash_and_original_t0(self): + from app.services import rotation_service as r, executor + rows = [ + ('old-open','original','buy',{}), ('fund','original','sell',{'execution_profile':'rotation'}), + ('open','micro30','buy',{}), ('exit','micro30','sell',{}), + ('close-t0','original','buy',{'leg':'close'}), ('trader-sell','original','sell',{})] + parents = [dict(instruction_id=i,book_id=b,side=s,progress=p) for i,b,s,p in rows] + parents[-2].update(origin_type='strategy', action='T0_ROUND') + with patch.object(executor,'cancel_instruction',return_value={'ok':True}) as cancel, \ + patch.object(r.pms_repo,'active_strategies',return_value=[{'type':'T0','state':{'open_leg':'buy'}}]) as t0: + self.assertFalse(r._stop_leaving_orders('returning_original',parents,[{'t0_qty':100}],[])) + self.assertEqual([c.args[0] for c in cancel.call_args_list],['fund','open']) + t0.assert_not_called() + cancel.reset_mock() + self.assertTrue(r._stop_leaving_orders('entering_micro',parents,[{'t0_qty':100}],[])) + self.assertEqual([c.args[0] for c in cancel.call_args_list],['old-open']) + + def test_explicit_resume_requires_settlement_and_does_not_reuse_old_signal(self): + from app.services import rotation_service as r, rotation_execution as execution + snap = snapshot() + saved = {'rotation':state(snap)} + config = {'mode':'auto','control':'run'} + @contextmanager + def locked(*args): + yield saved + def save(_key, value, _actor): + config['control'] = value + return {'ok':True} + with ExitStack() as stub: + for obj, name, kwargs in [ + (r,'documents_ready',{'return_value':True}), (r.store,'account_guard',{'side_effect':nullcontext}), + (r.store,'locked',{'side_effect':locked}), (r,'configuration',{'return_value':config}), + (r.param_store,'set_param',{'side_effect':save}), (execution,'pending_instructions',{'return_value':[]})]: + stub.enter_context(patch.object(obj,name,**kwargs)) + stub.enter_context(patch.object(r.settings,'INFRA_STRATEGY_BOOK_SCHEMA',True)) + held = stub.enter_context(patch.object(r,'positions',return_value=[])) + unsettled = stub.enter_context(patch.object(r,'_micro_unsettled',return_value=False)) + recon = stub.enter_context(patch.object(r,'reconcile_books',return_value={'ok':True})) + active = stub.enter_context(patch.object(r.pms_repo,'list_commands',return_value=[])) + command = stub.enter_context(patch.object(r.pms_repo,'get_command',return_value={'status':'EXECUTING'})) + r._set_control('exit_disable','user',exit_command='clear-all') + self.assertEqual(saved['rotation']['phase'],'returning_original') + with self.assertRaisesRegex(ValueError,'退出仍在办理'): + r._set_control('run','user') + saved['rotation'] = m.transition(saved['rotation'],snap,micro_qty=0,original_qty=0,budget=100000,control='exit_disable') + for status in ('EXECUTING','UNKNOWN'): + command.return_value = {'status':status} + with self.assertRaisesRegex(ValueError,'清仓命令'): + r._set_control('run','user') + command.return_value = {'status':'DONE'} + active.return_value = [{'command_id':'another-clear-all'}] + with self.assertRaisesRegex(ValueError,'清仓命令'): + r._set_control('run','user') + active.return_value = [] + for query, active in [(held,[{'total_qty':100}]), (unsettled,True), (recon,{'ok':False})]: + old = query.return_value + query.return_value = active + with self.assertRaisesRegex(ValueError,'尚未结清'): + r._set_control('run','user') + self.assertTrue(saved['rotation']['disabled']) + self.assertEqual(config['control'],'exit_disable') + query.return_value = old + r._set_control('run','user') + self.assertFalse(saved['rotation']['disabled']) + self.assertEqual(config['control'],'run') + same_day = m.transition(saved['rotation'],snap,micro_qty=0,original_qty=0,budget=100000) + self.assertEqual(same_day['phase'],'original') + next_day = m.transition(same_day,snapshot(day='2026-11-04'),micro_qty=0,original_qty=0,budget=100000) + self.assertEqual(next_day['phase'],'entering_micro') + + class ReservationTests(unittest.TestCase): def setUp(self): from app.repo import execution_repo diff --git a/scripts/test_plan_rank_boundary.py b/scripts/test_plan_rank_boundary.py new file mode 100644 index 0000000..84f2ebd --- /dev/null +++ b/scripts/test_plan_rank_boundary.py @@ -0,0 +1,153 @@ +"""逐票核验须穿过普通发现窗口,同时保留原有资格条件。""" +import unit_test_guard # noqa: F401 +import json +import sys +import unittest +from datetime import datetime +from pathlib import Path +from unittest.mock import patch + +import requests + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from app.core.plan_revision import basis, fingerprint, portfolio_context +from app.repo import pms_repo +from app.services import plan_feed, plan_recheck, portfolio, proposal_service +from test_wiring import install_fakes + + +CODE = '603999.SH' +UPSTREAM_CODE = 'SH603999' + + +class PlanRankBoundaryTest(unittest.TestCase): + def setUp(self): + fake = install_fakes(prices={CODE: 10}, positions=[], params={ + 'PMS_PLAN_API_BASE': 'http://bridge.invalid', 'PMS_PLAN_TOP': '300', + 'PMS_CONSENSUS_ROUTE': 'false', 'PMS_PLAN_BY_ADVICE': 'false', + 'PMS_PLAN_TOP_N': '50', 'PMS_PLAN_SNAPSHOT': 'false', + 'PMS_PLAN_THEME_CAP_LOCAL': '0', 'PMS_PLAN_VERSION_RECHECK': 'true', + }) + fake.qmt.put_snapshot(kind='funds', data={'total_asset': 2000000, 'available_cash': 2000000}) + self.date = datetime.now().date().isoformat() + self.row = {'code': UPSTREAM_CODE, 'name': '样本', 'research_rank': 301, 'rank': 301, + 'tier': '强传导', 'score': 231, 'verdict': '候选'} + self.plan = {'date': self.date, 'main': [self.row], 'observe': [], + 'rank_axis': 'quality', 'decision': {'id': 'published-v2'}} + self.ordinary = [dict(self.row, code=f'SH{600000+i}', rank=i+1, research_rank=i+1) + for i in range(300)] + self.plan['main'] = self.ordinary + [self.row] + plan_feed.invalidate() + self.addCleanup(plan_feed.invalidate) + self.http = self.enterContext(patch('requests.get', side_effect=self.response)) + self.record = self.enterContext(patch.object(pms_repo, 'insert_plan_snapshot', return_value=1)) + old = dict(self.plan, decision={'id': 'published-v1'}, main=[dict(self.row, rank=1, research_rank=1)]) + selected = plan_feed.select_candidates(plan_feed.parse_plan(old))['items'][0] + self.view = portfolio.positions_view() + self.params = proposal_service._scan_params(self.view) + self.hard = {'decision': old['decision'], 'consumption_id': 'original-consumption', + 'plan_basis': basis(selected), 'scan_params_hash': fingerprint(self.params), + 'portfolio_context_hash': portfolio_context(self.view, + proposal_service._inflight_open_commitments(self.view))} + + def response(self, url, params, timeout): + if url.endswith('/check'): + self.assertEqual(params, {'code': CODE, 'include_user_candidates': 1}) + rows = [r for r in self.plan['main'] if r['code'] == UPSTREAM_CODE] + result = dict(self.plan, main=rows, check_code=UPSTREAM_CODE, found=bool(rows)) + else: + self.assertEqual(url, 'http://bridge.invalid/plan') + count = int(params['top']) + self.assertEqual(count, 300) + result = dict(self.plan, main=self.plan['main'][:count]) + reply = requests.Response() + reply.status_code = 200 + reply.encoding = 'utf-8' + reply._content = json.dumps(result, ensure_ascii=False).encode('utf-8') + return reply + + def test_current_rank_301_preserves_qualification_across_routes(self): + discovery = plan_feed.candidates(record=False) + self.assertNotIn(CODE, [r['ts_code'] for r in discovery['items']]) + fast = plan_recheck.current_basis(self.hard, CODE, record=False) + self.assertTrue(fast['ok'], fast) + self.record.assert_not_called() + + automatic = proposal_service.verify_open_basis(self.hard, CODE) + self.assertTrue(automatic['ok'], automatic) + self.assertEqual(automatic['provenance']['consumption_id'], fast['provenance']['consumption_id']) + prepared = plan_recheck.prepare_new(self.hard, CODE, {'verdict': 'PASS'}) + self.assertEqual(prepared['preparation']['status'], 'ready') + self.assertEqual(self.record.call_count, 2) + for receipt in self.record.call_args_list: + self.assertEqual(receipt.kwargs['meta']['kind'], 'rechecked') + self.assertEqual(receipt.kwargs['meta']['order'], [CODE]) + self.assertEqual(receipt.kwargs['meta']['decision'], self.plan['decision']) + recorded = receipt.kwargs['roster'][0] + self.assertEqual(recorded['research_rank'], 301) + self.assertNotIn('selection_rank', recorded) + + def test_background_refresh_reprices_one_stock_outside_the_discovery_window(self): + hard = dict(self.hard, preparation={'status': 'pending'}, proposal_revision='v1-shown', + prepared_judgement={'verdict': 'PASS', 'confidence': 80, 'degraded': False}) + proposal = {'proposal_id': 'pending', 'ts_code': CODE, 'action': 'OPEN', 'qty': 100, + 'hard_numbers': hard} + with patch.object(pms_repo, 'record_proposal_check', return_value=1), \ + patch.object(pms_repo, 'publish_prepared_proposal', return_value=1) as publish: + result = plan_recheck.refresh_one(proposal) + self.assertTrue(result['ok'], result) + saved = publish.call_args.args[1]['hard_numbers'] + self.assertEqual(saved['preparation']['status'], 'ready') + self.assertEqual(saved['research_rank'], 301) + for key in ('selection_rank', 'execution_rank', 'priority_reason'): + self.assertNotIn(key, saved) + self.assertEqual(self.http.call_count, 3) + + def test_report_published_between_two_checks_requires_a_new_judgement(self): + hard = dict(self.hard, preparation={'status': 'pending'}, proposal_revision='v1-shown', + prepared_judgement={'verdict': 'PASS', 'reason': '基于旧评析', 'confidence': 80}) + proposal = {'proposal_id': 'pending', 'ts_code': CODE, 'action': 'OPEN', 'qty': 100, + 'hard_numbers': hard} + + def publish_new_report(url, params, timeout): + if self.http.call_count == 2: + self.plan['decision'] = {'id': 'published-v3'} + self.row['company_review_text'] = '新的买方评析' + return self.response(url, params, timeout) + + self.http.side_effect = publish_new_report + new_judgement = {'verdict': 'PASS', 'reason': '已核验新评析', 'confidence': 80, 'raw': {}} + with patch.object(pms_repo, 'record_proposal_check', return_value=1), \ + patch.object(pms_repo, 'publish_prepared_proposal', return_value=1) as publish, \ + patch.object(proposal_service.judge, 'request', return_value=new_judgement) as judge: + result = plan_recheck.refresh_one(proposal) + self.assertTrue(result['ok'], result) + judge.assert_called_once() + self.assertTrue(judge.call_args.kwargs['force']) + self.assertEqual(publish.call_args.args[2]['reason'], '已核验新评析') + self.assertEqual(publish.call_args.args[1]['hard_numbers']['decision']['id'], 'published-v3') + + def test_absent_in_complete_version_is_a_real_qualification_loss(self): + self.plan['main'] = self.ordinary + for record in (False, True): + self.assertTrue(plan_recheck.current_basis(self.hard, CODE, record=record)['withdraw']) + self.plan['refresh_status'] = {'pending_codes': [UPSTREAM_CODE]} + retry = plan_recheck.current_basis(self.hard, CODE, record=True) + self.assertFalse(retry['ok']) + self.assertEqual(retry['stage'], 'research_pending') + self.assertFalse(retry.get('withdraw')) + + def test_material_change_or_record_failure_blocks_automatic_approval(self): + self.row['risk'] = ['新增风险'] + changed = proposal_service.verify_open_basis(self.hard, CODE) + self.assertFalse(changed['ok']) + self.assertTrue(changed['research_changed']) + self.record.side_effect = RuntimeError('核验账本写入失败') + blocked = proposal_service.verify_open_basis(self.hard, CODE) + self.assertFalse(blocked['ok']) + self.assertEqual(blocked['stage'], 'record') + self.assertFalse(blocked.get('withdraw')) + + +if __name__ == '__main__': + unittest.main() diff --git a/scripts/test_risk_exit.py b/scripts/test_risk_exit.py index ccffad2..6e79e48 100644 --- a/scripts/test_risk_exit.py +++ b/scripts/test_risk_exit.py @@ -143,6 +143,7 @@ class ServiceTests(unittest.TestCase): self.use(executor,'cancel_instruction',cancel) schema={ 'pms_command':'id INTEGER PRIMARY KEY,book_id TEXT,command_id TEXT,cmd_class TEXT,cmd_type TEXT,ts_code TEXT,params_json TEXT,status TEXT,progress_json TEXT,issued_by TEXT,issued_at TEXT,archived_at TEXT', + 'pms_runtime_param':'param_key TEXT PRIMARY KEY,param_value TEXT', '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', diff --git a/scripts/test_timing_fusion.py b/scripts/test_timing_fusion.py index 71d25fa..c72a078 100644 --- a/scripts/test_timing_fusion.py +++ b/scripts/test_timing_fusion.py @@ -157,6 +157,84 @@ class ServiceTests(recovery.DirectionTests): self.assertEqual(timing_fusion.refresh(now=now)['accepted'],1) self.assertEqual(timing_state.latest(base.CODE,now)['action'],'WAIT') + def test_refresh_verifies_at_receipt_and_preserves_lease(self): + import json + import requests + from app.services import exec_advisor + sent = self.setup_fusion() + received = sent + dt.timedelta(milliseconds=20) + current = [sent] + event = fused(at=sent) + event['verified_at'] = (sent + dt.timedelta(milliseconds=5)).isoformat() + + def get(url, timeout): + self.assertTrue(url.endswith('/api/intraday/timing_fusion')) + current[0] = received + response = requests.Response() + response.status_code = 200 + response._content = json.dumps({'version': contract.VERSION, 'enabled': True, + 'states': [event]}).encode() + return response + + with patch.object(timing_fusion, 'datetime') as clock, patch.object(exec_advisor, 'base_url', return_value='http://offline.invalid'), patch.object(requests, 'get', side_effect=get): + clock.now.side_effect = lambda: current[0] + first = timing_fusion.refresh() + self.assertEqual((first['accepted'], first['invalid'], self.state()['phase']), (1, 0, 'STOP_BUY')) + event['verified_at'] = (received + dt.timedelta(milliseconds=5)).isoformat() + self.assertEqual(timing_fusion.refresh()['status'], 'FAILED') + event['verified_at'] = sent.isoformat() + event['expires_at'] = received.isoformat() + self.assertEqual(timing_fusion.refresh()['status'], 'FAILED') + self.assertEqual(self.state()['count'], 1) + + def test_actual_digest_reports_partial_batch_wait_and_failure(self): + import requests + from app import scheduler + from app.services import exec_advisor + from types import SimpleNamespace + now = self.setup_fusion() + wait = fused('WAIT', at=now) + response = {'version': contract.VERSION, 'enabled': True, 'states': [wait]} + with patch.object(signal_service.portfolio, 'positions_view', return_value={}), \ + patch.object(signal_service, 'streams', return_value=[]), patch.object(signal_service, '_load_seen', return_value={}), \ + patch.object(exec_advisor, 'base_url', return_value='http://offline.invalid'), \ + patch.object(timing_fusion, 'datetime') as clock, patch.object(requests, 'get', return_value=SimpleNamespace(raise_for_status=lambda:None, json=lambda:response)): + clock.now.return_value = now + def digest(): + return signal_service.consume(dry_run=True) + clean = digest() + self.assertTrue(clean['ok']) + self.assertEqual(clean['timing_fusion']['status'], 'NO_DIRECTION') + self.assertIn('NO_DIRECTION', scheduler._brief(clean)) + response['states'] = [] + self.assertEqual(digest()['timing_fusion']['status'], 'NO_EVIDENCE') + response.update(states=[fused(at=now), None], errors=['主力资金来源异常']) + partial = digest() + self.assertFalse(partial['ok']) + self.assertEqual(partial['timing_fusion']['accepted'], 1) + self.assertEqual(partial['timing_fusion']['status'], 'DEGRADED') + response['states'] = [None] + failure = digest() + self.assertFalse(failure['ok']) + self.assertIn('FAILED', scheduler._brief(failure)) + + def test_previously_known_wait_after_one_thousand_other_rows_is_saved(self): + from types import SimpleNamespace + now = self.setup_fusion() + self.save(fused(at=now)) + ids = [{'doc_id':'timing-direction:' + str(600100 + i) + '.SH', 'kind':timing_state.KIND, + 'payload_json':'{}', 'revision':1, 'updated_at':'2099-01-01'} for i in range(1001)] + from sqlalchemy import text + with self.engine.begin() as conn: + conn.execute(text('INSERT INTO pms_rotation_document VALUES (:doc_id,:kind,:payload_json,:revision,:updated_at)'), ids) + payload = {'version': contract.VERSION, 'enabled': True, 'states':[fused('WAIT',at=now,n=2)]} + with patch('requests.get', return_value=SimpleNamespace(raise_for_status=lambda:None, json=lambda:payload)): + self.assertEqual(timing_fusion.refresh(now=now)['accepted'], 1) + self.assertEqual(timing_state.latest(base.CODE,now)['action'], 'WAIT') + with patch.object(rotation_repo, 'document_ids', return_value=set(range(6001))): + with self.assertRaisesRegex(ValueError, '超过完整读取上限'): + timing_fusion.refresh(now=now) + def test_fusion_manual_halt_not_recovered(self): now=self.setup_fusion();a=fused(at=now);self.save(a);risk_exit.on_signal(a,now=now) self.params['PMS_GLOBAL_BUY_HALT']=True diff --git a/scripts/test_trade_correction_strategy.py b/scripts/test_trade_correction_strategy.py index db4761b..6a4d638 100644 --- a/scripts/test_trade_correction_strategy.py +++ b/scripts/test_trade_correction_strategy.py @@ -5,6 +5,8 @@ import datetime as dt import json import sys import tempfile +import threading +from concurrent.futures import ThreadPoolExecutor import unittest from pathlib import Path from unittest.mock import patch @@ -13,8 +15,9 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1])) from sqlalchemy import create_engine, event, text from app.core import strategy_book as books from app.db import session as db -from app.repo import pms_repo +from app.repo import pms_repo, qmt_repo from app.services import strategy_runner as runner, rotation_service, grid_inventory +from app.services import execution_orders, strategy_advisor, strategy_service from config.settings import settings CODE = '600001.SH' @@ -56,7 +59,7 @@ class StrategyCorrectionTests(unittest.TestCase): (runner.param_store, 'get_float', lambda key, default=0: default), (runner.param_store, 'get_int', lambda key, default=0: default), (runner.param_store, 'get', lambda key, default=None: default), - (runner.portfolio, 'positions_view', lambda: {'positions': [{'ts_code': CODE, 'total_qty': 100, 'avail_qty': 100}], 'totals': {'scale': 10000}}), + (runner.portfolio, 'positions_view', lambda: {'positions': [{'ts_code': CODE, 'total_qty': 100, 'avail_qty': 100}], 'totals': {'scale': 10000}, 'params': {'scale': 10000, 'stock_cap': .2}}), (runner.market, 'day_snapshot', lambda code: {'price': 10, 'bar_time': self.now.isoformat()}), (pms_repo, 'get_position', lambda code: {'total_qty':100, 'add_qty':100, 'avail_qty':100}), (grid_inventory, 'snapshot', lambda st, pos: {'invested':1000, 'filled_levels':{'0':{'price':10,'qty':100,'sell_target':10.4}}}), @@ -256,6 +259,208 @@ class StrategyCorrectionTests(unittest.TestCase): self.assertFalse(any('account-execution' in sql for sql in self.statements)) self.assertEqual(self.count('pms_instruction'), 0) + def attach_trail(self): + return strategy_service.attach({'ts_code': CODE, 'type': 'TRAIL', 'params': {'giveback': .05}}) + + def test_resume_cannot_take_over_another_active_strategy(self): + self.assertTrue(strategy_service.set_status('GRID', 'PAUSED')['ok']) + trail = self.attach_trail() + self.assertTrue(trail['ok'], trail) + self.assertFalse(strategy_service.set_status('GRID', 'ACTIVE')['ok']) + self.assertEqual(pms_repo.get_strategy('GRID')['status'], 'PAUSED') + self.assertTrue(strategy_service.set_status(trail['strategy_id'], 'CANCELLED')['ok']) + self.assertFalse(strategy_service.set_status(trail['strategy_id'], 'ACTIVE')['ok']) + with patch.object(pms_repo, 'get_position', return_value=None): + self.assertFalse(strategy_service.set_status('GRID', 'ACTIVE')['ok']) + self.assertTrue(strategy_service.set_status('GRID', 'ACTIVE')['ok']) + self.assertEqual([s['strategy_id'] for s in pms_repo.active_strategies()], ['GRID']) + + def test_snapshot_is_read_outside_lock_and_actual_availability_is_rechecked_inside(self): + self.assertTrue(strategy_service.set_status('GRID', 'PAUSED')['ok']) + def quote_snapshot(): + self.assertIsNone(db._TRANSACTION.get()) + return {'positions': [{'ts_code': CODE, 'total_qty': 100, 'avail_qty': 100, + 'price_ok': True, 'price': 10}], + 'params': {'scale': 10000, 'stock_cap': .2}} + def changed_position(code): + self.assertIsNotNone(db._TRANSACTION.get()) + return {'total_qty': 180, 'avail_qty': 0} + with (patch.object(runner.portfolio, 'positions_view', side_effect=quote_snapshot), + patch.object(pms_repo, 'get_position', side_effect=changed_position)): + self.assertFalse(self.attach_trail()['ok']) + grid = {'ts_code': CODE, 'type': 'GRID', 'params': {'lower': 9, 'center': 10, + 'upper': 11, 'step': .5, 'max_capital': 500}} + result = strategy_service.attach(grid) + self.assertIn('超过', result['errors'][0], result) + with patch.object(runner.portfolio, 'positions_view', side_effect=RuntimeError('行情不可用')): + self.assertFalse(self.attach_trail()['ok']) + self.assertFalse(pms_repo.active_strategies()) + + def test_legacy_account_without_position_cannot_attach_or_resume_but_can_cancel(self): + self.use(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', False) + with self.engine.begin() as connection: + connection.execute(text('CREATE TABLE pms_position (ts_code TEXT PRIMARY KEY,total_qty INTEGER)')) + connection.execute(text("INSERT INTO pms_strategy(strategy_id,ts_code,type,status) " + "VALUES ('legacy',:code,'GRID','PAUSED')"), {'code': CODE}) + with (patch.object(runner.portfolio, 'positions_view', return_value={'positions': []}), + patch.object(pms_repo, 'get_position', return_value=None)): + self.assertFalse(self.attach_trail()['ok']) + self.assertFalse(strategy_service.set_status('legacy', 'ACTIVE')['ok']) + self.assertTrue(strategy_service.set_status('legacy', 'CANCELLED')['ok']) + self.assertTrue(any('FROM pms_position WHERE ts_code' in sql and 'FOR UPDATE' in sql + for sql in self.statements)) + + def test_concurrent_attach_and_resume_leave_one_owner(self): + # SQLite 没有行锁,用写事务模拟同一账户锁的排它性;读写走真实 repo。 + @event.listens_for(self.engine, 'begin') + def begin_immediate(connection): + connection.exec_driver_sql('BEGIN IMMEDIATE') + self.assertTrue(strategy_service.set_status('GRID', 'PAUSED')['ok']) + barrier = threading.Barrier(2) + def compete(action): + barrier.wait(timeout=5) + return action() + with ThreadPoolExecutor(max_workers=2) as pool: + results = list(pool.map(compete, [self.attach_trail, lambda: strategy_service.set_status('GRID', 'ACTIVE')])) + self.assertEqual(sum(result['ok'] for result in results), 1, results) + self.assertEqual(len(pms_repo.active_strategies()), 1) + self.assertTrue(any("doc_id='account-execution' FOR UPDATE" in sql for sql in self.statements)) + + def test_existing_duplicate_owners_stop_tick_and_manual_acceptance(self): + pms_repo.insert_strategy(strategy_id='TRAIL', ts_code=CODE, stype='TRAIL') + out = runner.tick(now=self.now) + self.assertFalse(out['ok']) + self.assertEqual(out['fired'] + out['queued'], []) + with self.assertLogs('pms.strategy', level='ERROR'): + result = runner.emit_from_spec(dict(DECISION, strategy_id='GRID')) + self.assertFalse(result['ok']) + self.assertEqual(self.count('pms_instruction'), 0) + self.assertTrue(strategy_service.set_status('TRAIL', 'PAUSED')['ok']) + + def test_stale_missing_or_future_price_cannot_move_trailing_high_or_trigger(self): + strategy_service.set_status('GRID', 'PAUSED') + strategy_id = self.attach_trail()['strategy_id'] + pms_repo.update_strategy(strategy_id, state={'high_water': 12, 'armed': True}) + for bars in ([], [{'close': 20, 'time': self.now - dt.timedelta(days=1)}], + [{'close': 8, 'time': self.now - dt.timedelta(seconds=91)}], + [{'close': 20, 'time': self.now + dt.timedelta(seconds=1)}], + [{'close': 'nan', 'time': self.now}]): + with self.subTest(bars=bars), patch.object(runner.market, '_bars', return_value=bars): + out = runner.tick(now=self.now) + self.assertTrue(out['ok'], out) + self.assertFalse(out['fired']) + self.assertEqual(pms_repo.get_strategy(strategy_id)['state']['high_water'], 12) + self.assertNotIn('trail_due', pms_repo.get_strategy(strategy_id)['state']) + with patch.object(runner.market, '_bars', return_value=[{'close': 10, 'time': self.now}]): + out = runner.tick(now=self.now) + self.assertEqual([row['qty'] for row in out['fired']], [100], out) + + def test_late_receipt_is_settled_once_then_only_remainder_fires_on_fresh_quote(self): + strategy_service.set_status('GRID', 'PAUSED') + strategy_id = self.attach_trail()['strategy_id'] + due = {'qty': 200, 'leg': 'trail_sell', 'partial': False, 'high_water': 12, 'reason': '回撤'} + pms_repo.update_strategy(strategy_id, state={'pending': {'iid':'prior', 'leg':'trail_sell'}, + 'trail_due': due, 'high_water': 12, 'armed': True}) + pms_repo.insert_instruction(instruction_id='prior', origin_type='strategy', origin_id=strategy_id, + ts_code=CODE, action='EXIT', side='sell', qty=200, status='CANCELLED') + pms_repo.update_instruction('prior', exec_qty=100) + self.use(runner.param_store, 'get', lambda key, default=None: 'ws' if key == 'PMS_DISPATCH_MODE' else default) + with (patch.object(runner.market, '_bars', return_value=[]), + patch.object(execution_orders, 'replacement_state', return_value={'ready': False})): + self.assertFalse(runner.tick(now=self.now)['fired']) + self.assertEqual(pms_repo.get_strategy(strategy_id)['state']['trail_due']['qty'], 200) + self.assertEqual(pms_repo.get_strategy(strategy_id)['state']['pending']['iid'], 'prior') + with (patch.object(runner.market, '_bars', return_value=[]), + patch.object(execution_orders, 'replacement_state', return_value={'ready': True})): + for _ in range(2): + self.assertFalse(runner.tick(now=self.now)['fired']) + after = pms_repo.get_strategy(strategy_id)['state'] + self.assertEqual(after['trail_due']['qty'], 100) + self.assertIsNone(after['pending']) + with patch.object(runner.market, '_bars', return_value=[{'time': self.now, 'close': 10}]): + out = runner.tick(now=self.now) + self.assertEqual([row['qty'] for row in out['fired']], [100], out) + + def test_grid_waits_on_missing_unrecognized_or_unsettled_parent_and_proposal(self): + def waiting(pending): + return strategy_advisor._has_pending({'strategy_id': 'GRID', 'ts_code': CODE, 'state': {'pending': pending}}) + self.assertFalse(waiting(None)) + self.assertTrue(waiting({})) + with patch.object(pms_repo, 'list_instructions', return_value=[{'status': 'DISPATCHED'}]): + self.assertTrue(waiting(None)) + with patch.object(pms_repo, 'list_instructions', side_effect=RuntimeError('不能核实同股在途指令')): + self.assertTrue(waiting(None)) + self.assertTrue(waiting({'iid': 'absent'})) + self.assertTrue(waiting({'pid': 'absent'})) + for status in ('JUDGE_PASSED', 'UNKNOWN'): + with patch.object(pms_repo, 'get_instruction', return_value={'status': status}): + self.assertTrue(waiting({'iid': 'prior'})) + with patch.object(pms_repo, 'get_instruction', side_effect=RuntimeError('读失败')): + self.assertTrue(waiting({'iid': 'prior'})) + for status in ('WAIT_USER', 'ACCEPTED', 'unknown'): + with patch.object(pms_repo, 'get_proposal', return_value={'status': status}): + self.assertTrue(waiting({'pid': 'prior'})) + with patch.object(pms_repo, 'get_proposal', return_value={'status':'DECLINED'}): + self.assertFalse(waiting({'pid': 'prior'})) + self.use(runner.param_store, 'get', lambda key, default=None: 'ws' if key == 'PMS_DISPATCH_MODE' else default) + with patch.object(qmt_repo, 'list_orders', return_value=[{'status':'PARTIAL'}]): + self.assertTrue(waiting(None)) + with (patch.object(qmt_repo, 'list_orders', return_value=[]), + patch.object(pms_repo, 'get_instruction', return_value={'status': 'CONFIRMED'})): + for ready in (False, True): + with patch.object(execution_orders, 'replacement_state', return_value={'ready': ready}): + self.assertEqual(waiting({'iid':'prior'}), not ready) + + def test_handoff_requires_current_breakout_and_seeds_the_new_trail_from_its_quote(self): + prm = {'handoff_enabled': True, 'rules': [strategy_advisor.R_HANDOFF], + 'heat_th': .7, 'trail_giveback': .05, 'trail_sell_ratio': .5} + pms_repo.update_strategy('GRID', note='自动挂载: 网格', params_json='{"upper":11}') + st = pms_repo.get_strategy('GRID') + pos = {'ts_code': CODE, 'price': 13, 'price_ok': True, 'avg_cost': 9.8, 'cushion_pct': .3} + self.use(runner.param_store, 'get', lambda key, default=None: 'ws' if key == 'PMS_DISPATCH_MODE' else default) + def read_history(code): + self.assertIsNone(db._TRANSACTION.get()) + return '' + def tend(bars): + out = {'skipped': [], 'errors': [], 'handoffs': []} + with (patch.object(runner.market, '_bars', return_value=bars), + patch.object(qmt_repo, 'list_orders', return_value=[]), + patch.object(execution_orders, 'code_settlement_blocker', side_effect=read_history), + patch.object(runner.portfolio, 'positions_view', side_effect=AssertionError('接力须复用持仓快照')), + patch.object(pms_repo, 'insert_ledger', return_value=1)): + strategy_advisor._tend_existing(st, pos, {}, False, .9, prm, {}, set(), 20261105, + False, out, strategy_service, now=self.now) + return out + for bars in ([], [{'time': self.now - dt.timedelta(days=1), 'close': 13}], + [{'time': self.now, 'close': 10.5}]): + self.assertFalse(tend(bars)['handoffs']) + self.assertEqual(pms_repo.get_strategy('GRID')['status'], 'ACTIVE') + out = tend([{'time': self.now, 'close': 11.5}]) + self.assertEqual(len(out['handoffs']), 1, out) + self.assertEqual(pms_repo.get_strategy('GRID')['status'], 'CANCELLED') + active = pms_repo.active_strategies() + self.assertEqual(len(active), 1) + self.assertEqual(active[0]['state']['high_water'], 11.5) + + def test_failed_handoff_ledger_rolls_back_both_strategies_and_high_water(self): + out = {'errors': [], 'skipped': [], 'handoffs': []} + history = [] + def fail_pass(**row): + history.append(row['verdict']) + return int(row['verdict'] == 'REJECT') + with patch.object(pms_repo, 'insert_ledger', side_effect=fail_pass): + strategy_advisor._do_handoff(self.original, {'ts_code': CODE}, .9, + {'trail_giveback': .05, 'trail_sell_ratio': .5}, '站上上界', out, + strategy_service, high_water=12) + self.assertTrue(out['errors'], out) + self.assertFalse(out['handoffs']) + self.assertEqual(history, ['PASS', 'REJECT']) + self.assertEqual(self.count('pms_strategy'), 1) + active = pms_repo.get_strategy('GRID') + self.assertEqual(active['status'], 'ACTIVE') + self.assertEqual(active['state'], self.original['state']) + self.assertEqual(active['note'], self.original['note']) + def test_soft_archived_parent_does_not_archive_current_strategy(self): iid = runner._emit_instruction(self.original, DECISION) with self.engine.begin() as conn: diff --git a/scripts/test_user_stop.py b/scripts/test_user_stop.py index 3cc1c7e..91fc5e3 100644 --- a/scripts/test_user_stop.py +++ b/scripts/test_user_stop.py @@ -4,6 +4,8 @@ import copy import datetime as dt import json import unittest +import tempfile +from concurrent.futures import ThreadPoolExecutor from unittest.mock import patch import test_risk_exit as base from app.core import risk_exit as core, strategy_book as books @@ -23,6 +25,14 @@ def quote(price=10, at=NOW): class CoreTests(unittest.TestCase): + def test_simulation_cached_halt_read_also_rejects_invalid_old_value(self): + from app.services import param_store + from config.settings import settings + key = 'PMS_GLOBAL_EXEC_HALT' + with patch.object(settings, 'PMS_TABLE_PREFIX', ''), patch.object(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', True), \ + patch.object(param_store, 'refresh', return_value={key:{'param_value':'unknown'}}): + self.assertTrue(param_store.get_bool(key)) + def test_equal_and_below_trigger_above_does_not(self): for price, trigger in [(9.99,True),(10,True),(10.01,False)]: self.assertEqual(bool(core.user_stop_event(command(),quote(price),now=NOW)[0]),trigger) @@ -49,6 +59,89 @@ class CoreTests(unittest.TestCase): self.assertIsNone(core.user_stop_event(command(issued=NOW),quote(at=NOW-dt.timedelta(seconds=1)),now=NOW)[0]) +class ParamTransactionTests(unittest.TestCase): + def setUp(self): + from sqlalchemy import create_engine, event + from app.db import session as db + from app.services import param_store + from config.settings import settings + + tmp = self.enterContext(tempfile.TemporaryDirectory()) + engine = create_engine('sqlite:///' + tmp + '/params.sqlite') + self.addCleanup(engine.dispose) + self.enterContext(patch.object(db, 'get_engine', return_value=engine)) + self.enterContext(patch.object(settings, 'PMS_TABLE_PREFIX', '')) + self.enterContext(patch.object(settings, 'INFRA_ROTATION_DOCUMENT_SCHEMA', True)) + self.enterContext(patch.object(param_store, '_cache', {'loaded':False, 'at':0, 'data':{}, 'error':None})) + self.fail_state = False + self.at_state_update = None + + @event.listens_for(engine, 'before_cursor_execute', retval=True) + def dialect(conn, cursor, sql, params, context, many): + sql = sql.replace(' FOR UPDATE', '') + if 'ON DUPLICATE KEY UPDATE' in sql: + if 'pms_runtime_param' in sql: + sql = sql.replace('ON DUPLICATE KEY UPDATE', 'ON CONFLICT(param_key) DO UPDATE SET') + else: + sql = sql.partition('ON DUPLICATE KEY UPDATE')[0] + 'ON CONFLICT DO NOTHING' + if sql.startswith('UPDATE pms_rotation_document SET payload_json=') and self.at_state_update: + self.at_state_update() + if self.fail_state: + raise RuntimeError('模拟状态文档末笔写入失败') + return sql, params + + with engine.begin() as conn: + conn.exec_driver_sql('CREATE TABLE pms_runtime_param (param_key TEXT PRIMARY KEY, param_value TEXT, ' + 'updated_by TEXT, updated_at TEXT)') + conn.exec_driver_sql('CREATE TABLE pms_rotation_document (doc_id TEXT PRIMARY KEY, kind TEXT, ' + 'payload_json TEXT, revision INTEGER, updated_at TEXT)') + self.key = 'PMS_ROTATION_CONTROL' + self.assertTrue(param_store.set_param('PMS_ROTATION_MODE', 'paper', 'isolated')['ok']) + self.assertTrue(param_store.set_param(self.key, 'pause_all', 'isolated')['ok']) + self.pool = self.enterContext(ThreadPoolExecutor(max_workers=1)) + + def test_real_control_and_document_publish_together_across_rollback_and_commit(self): + from app.services import rotation_service, param_store + + def check_readers(): + self.assertEqual(param_store.get(self.key), 'exit_disable') + self.assertEqual(self.pool.submit(param_store.get, self.key).result(timeout=3), 'pause_all') + def fresh_reader(): + return param_store.refresh(force=True)[self.key]['param_value'] + self.assertEqual(self.pool.submit(fresh_reader).result(timeout=3), 'pause_all') + + self.at_state_update = check_readers + self.fail_state = True + with self.assertRaisesRegex(RuntimeError, '末笔写入失败'): + rotation_service._set_control('exit_disable', 'isolated') + self.assertEqual(pms_repo.get_param(self.key), 'pause_all') + self.assertEqual(param_store.get(self.key), 'pause_all') + self.assertIsNone(rotation_service.store.get('state:paper')[0]) + self.fail_state = False + rotation_service._set_control('exit_disable', 'isolated') + self.assertTrue(rotation_service.store.get('state:paper')[0]['rotation']['disabled']) + self.assertEqual(self.pool.submit(param_store.get, self.key).result(timeout=3), 'exit_disable') + + def test_savepoint_rollback_and_release_preserve_outer_value_until_commit(self): + from app.db import session as db + from app.services import param_store + + with db.transaction(): + self.assertTrue(param_store.set_param(self.key, 'pause_new')['ok']) + with self.assertRaisesRegex(ValueError, '回滚'): + with db.savepoint(): + self.assertTrue(param_store.set_param(self.key, 'run')['ok']) + self.assertEqual(param_store.get(self.key), 'run') + raise ValueError('回滚') + self.assertEqual(param_store.get(self.key), 'pause_new') + with db.savepoint(): + self.assertTrue(param_store.set_param(self.key, 'exit_disable')['ok']) + self.assertEqual(param_store.get(self.key), 'exit_disable') + self.assertEqual(param_store.get(self.key), 'exit_disable') + self.assertEqual(self.pool.submit(param_store.get, self.key).result(timeout=3), 'pause_all') + self.assertEqual(self.pool.submit(param_store.get, self.key).result(timeout=3), 'exit_disable') + + class ServiceTests(base.ServiceTests): def put_stop(self, price=10, cid='STOP1'): c=command(price,cid) @@ -60,6 +153,28 @@ class ServiceTests(base.ServiceTests): service.drive(CODE,now=NOW) return result + def test_old_freeze_and_stop_survive_500_newer_effective_commands(self): + from sqlalchemy import text + from app.services import rotation_service + + self.insert('pms_command', dict(book_id='original', command_id='old-freeze', cmd_class='param', + cmd_type='FREEZE_STOCK', ts_code=CODE, status='EFFECTIVE')) + self.put_stop(cid='old-stop') + other = '600002.SH' + with self.engine.begin() as conn: + sql = text("INSERT INTO pms_command (book_id,command_id,cmd_class,cmd_type,ts_code,status) " + "VALUES ('original',:cid,'param',:kind,:code,'EFFECTIVE')") + conn.execute(sql, [{'cid':kind+str(i), 'kind':kind, 'code':other} + for kind in ('FREEZE_STOCK', 'SET_STOP_PRICE') for i in range(500)]) + freeze = ('FREEZE_STOCK',) + self.assertEqual(len(pms_repo.list_effective_stock_params(freeze)), 501) + filtered = pms_repo.list_effective_stock_params(freeze, ts_code=CODE) + self.assertEqual([row['command_id'] for row in filtered], ['old-freeze']) + self.assertIn(CODE, rotation_service.micro_buy_restrictions()) + self.assertEqual(set(rotation_service.micro_buy_restrictions(CODE)), {CODE}) + self.assertEqual(service._stop_commands()[CODE]['command_id'], 'old-stop') + self.assertTrue(service.observe_user_stop(CODE, quote(), now=NOW)['triggered']) + def test_scan_generates_one_exit_without_model_or_second_signal(self): self.put_stop() with patch.object(market,'execution_quote',return_value=quote()) as fetch, \ @@ -187,6 +302,77 @@ class ServiceTests(base.ServiceTests): self.assertEqual(self.state()['phase'],'EXIT_PENDING');self.assertEqual(self.instructions(),[]) service.drive(CODE,now=NOW);self.assertEqual(len(self.instructions()),1) + def test_missing_pause_defaults_and_bad_input_cannot_release_pause(self): + from app.services import param_store + self.assertFalse(param_store.execution_halted()) + self.change("INSERT INTO pms_runtime_param VALUES ('PMS_GLOBAL_EXEC_HALT','True')") + for value in (None, 'ture', 2): + with self.subTest(value=value): + self.assertFalse(param_store.set_param('PMS_GLOBAL_EXEC_HALT', value)['ok']) + self.assertTrue(param_store.execution_halted()) + self.change("UPDATE pms_runtime_param SET param_value='unknown'") + self.assertTrue(param_store.execution_halted()) + with patch.object(pms_repo,'get_param',side_effect=RuntimeError('isolated')): + self.assertTrue(param_store.execution_halted()) + + def test_pause_writer_uses_same_account_transaction_as_exit(self): + from app.db import session as db + from app.services import param_store + + def save_switch(key, value, by): + self.assertIsNotNone(db._TRANSACTION.get()) + self.assertEqual(key, 'PMS_GLOBAL_EXEC_HALT') + db.execute('INSERT INTO pms_runtime_param VALUES (:key,:value)', {'key':key, 'value':str(value)}) + return 1 + + with patch.object(pms_repo, 'set_param', side_effect=save_switch), patch.object(param_store, 'refresh', return_value={}): + self.assertTrue(param_store.set_param('PMS_GLOBAL_EXEC_HALT', True)['ok']) + self.assertTrue(param_store.execution_halted()) + self.put_stop() + service.observe_user_stop(CODE, quote(), now=NOW) + service.drive(CODE, now=NOW) + self.assertEqual(self.instructions(), []) + + def test_intraday_scheduler_observes_without_any_execution_while_halted(self): + from app import scheduler + from app.services import strategy_runner + self.put_stop() + self.change("INSERT INTO pms_runtime_param VALUES ('PMS_GLOBAL_EXEC_HALT','True')") + self.change('UPDATE pms_position SET avail_qty=0') + lease = {} + original_read = pms_repo.get_param + + def read(key, **opts): + return lease.get(key) if key.startswith('INFRA_LOCK_') else original_read(key, **opts) + + with patch.object(scheduler.td, 'is_trade_day', return_value=True), \ + patch.object(scheduler, 'in_session', return_value=True), \ + patch.object(pms_repo, 'get_param', side_effect=read), \ + patch.object(pms_repo, 'set_param', side_effect=lambda k,v,*a: lease.update({k:v})), \ + patch.object(service, 'datetime') as clock, patch.object(market, 'execution_quote', return_value=quote()), \ + patch.object(service, 'drive') as drive, patch.object(executor, 'materialize_plans') as plans, \ + patch.object(executor, 'run_tick') as orders, patch.object(strategy_runner, 'tick') as strategies: + clock.now.return_value = NOW + result = scheduler.intraday_exec.run() + self.assertTrue(result['risk_exit']['user_stops'][CODE]['triggered'], result) + self.assertFalse(scheduler.intraday_exec.run()['risk_exit']['user_stops'][CODE]['triggered']) + for call in (drive, plans, orders, strategies): + call.assert_not_called() + self.assertEqual(self.instructions(), []) + self.assertEqual(self.state()['phase'], 'EXIT_PENDING') + # worker缓存仍读成未暂停时,退出事务重新锁定并读取真实开关。 + with patch.object(service, '_stop_buys') as stop_buys: + service.drive(CODE, now=NOW) + stop_buys.assert_not_called() + self.assertEqual(self.instructions(), []) + self.change("UPDATE pms_runtime_param SET param_value='False'") + with patch.object(market, 'execution_quote', return_value=quote(11)): + service.scan(now=NOW) + service.scan(now=NOW) + self.assertEqual(len(self.instructions()), 1) + self.assertEqual(self.instructions()[0]['qty'], 1600) + self.assertEqual(self.state()['user_stop']['command_id'], 'STOP1') + def test_other_book_and_no_holding_do_not_create_orders(self): self.put_stop() with books.scope('micro30'): diff --git a/scripts/test_wiring.py b/scripts/test_wiring.py index 874419b..3e83608 100644 --- a/scripts/test_wiring.py +++ b/scripts/test_wiring.py @@ -10,6 +10,9 @@ """ import unit_test_guard # noqa: F401,单独运行也禁止联网 import os +from contextlib import contextmanager +from copy import deepcopy +from threading import RLock import sys import traceback from datetime import date, datetime @@ -39,6 +42,7 @@ class FakeRepo: self.strategies = {} self._lot_id = 0 self._strategy_id = 0 + self._auto_open_lock = RLock() # --- runtime param --- def all_params(self): @@ -49,7 +53,7 @@ class FakeRepo: self.params[key] = str(value) return 1 - def get_param(self, key): + def get_param(self, key, *, for_update=False): return self.params.get(key) # --- command --- @@ -111,9 +115,10 @@ class FakeRepo: and c["cmd_type"] == cmd_type and (not ts_code or c["ts_code"] == ts_code)] return sorted(hits, key=lambda c: c["id"])[-1] if hits else None - def list_effective_stock_params(self, cmd_types=None): - return [c for c in self.commands.values() + def list_effective_stock_params(self, cmd_types=None, *, ts_code=None): + return [c for c in reversed(self.commands.values()) if c["cmd_class"] == "param" and c["status"] == "EFFECTIVE" and c["ts_code"] + and (ts_code is None or c["ts_code"] == ts_code) and (not cmd_types or c["cmd_type"] in cmd_types)] # --- plan --- @@ -460,6 +465,11 @@ class FakeRepo: s = self.strategies.get(strategy_id) return dict(s) if s else None + @contextmanager + def strategy_guard(self, ts_code): + with self._auto_open_lock: + yield + def active_strategies(self): return self.list_strategies(statuses=["ACTIVE"], limit=1000) @@ -472,6 +482,16 @@ class FakeRepo: return {(r["ts_code"], r["action"]) for r in self.ledger if r.get("verdict") == "REJECT" and r.get("arbiter") == "system"} + @contextmanager + def account_decision_guard(self): + with self._auto_open_lock: + instructions, ledger = deepcopy(self.instructions), deepcopy(self.ledger) + try: + yield + except BaseException: + self.instructions, self.ledger = instructions, ledger + raise + def system_pass_count_today(self, since): # 今天系统自决自动采纳的新建仓只数: 账本里 OPEN 的 PASS 且 reason 以「系统采纳」开头 return sum(1 for r in self.ledger