修复择时恢复关注入池与持仓收益

This commit is contained in:
baobao 2026-11-10 12:06:38 +08:00
parent 50b4dcd4dd
commit 6fddc50fe9
24 changed files with 602 additions and 32 deletions

View File

@ -1,5 +1,9 @@
# 开发节点记录(三系统量化交易)
## 2026-11-10 择时恢复、关注入池与持仓收益
核实华策影视被两层候选数量截断,传导前置否决仍在,雷赛智能首次系统停买没有自动恢复路径,负净成本被截零导致收益少计。本次补齐关注入口、最新有效方向及有边界的首次停买恢复,自动网格买入使用三源合议,并修正收益展示。开发机隔离回归和1440/390浏览器复现通过。当前尚未发布,候选与真机结果更新在[接续](docs/择时恢复与关注入池修复_2026-11-10.md)。
## 2026-11-04 沿用原信息流风格并修复研究恢复
14:34最终只读确认六条买方评析、六条每日及六条盘中研究全部完成,且均匹配当前报告。最后一条守原一小时冷却,于14:33自然重试并在19.39秒内完成。每日数据日为11月3日,盘中为11月4日,实际盘中结论五条观察、一条风险。没有人为重投、改回执或注入交易。当前跟进完成,不新增长期观察;外部分钟采集的历史回填本次未修改。

View File

@ -0,0 +1,46 @@
"""持仓收益展示。保留负净成本,不用收益展示反推交易安全垫。"""
from decimal import Decimal, InvalidOperation
def calculate(row, lots):
empty = {'ready': False, 'profit': None, 'profit_pct': None, 'net_cost': None,
'remaining_cost': None, 'realized': None, 'unrealized': None,
'cost_recovered': False, 'reason': '持仓成本待核实'}
try:
def number(value):
if value is None or isinstance(value, bool):
raise ValueError('缺少金额')
n = Decimal(str(value))
if not n.is_finite():
raise ValueError('金额无效')
return n
qty = int(row['total_qty'])
if qty <= 0:
return dict(empty, ready=True, profit=0., net_cost=0., remaining_cost=0.,
realized=0., unrealized=0., reason=None)
if not lots or sum(int(l['qty']) for l in lots) != qty:
return empty
remaining = Decimal(0)
realized = Decimal(0)
for lot in lots:
n = int(lot['qty'])
price = number(lot['open_price'])
if n < 0 or price <= 0:
return empty
remaining += n * price
realized += number(lot['realized_pnl'])
net = remaining - realized
result = dict(empty, net_cost=float(net), remaining_cost=float(remaining),
realized=float(realized), cost_recovered=net <= 0)
if not row.get('price_ok'):
return dict(result, reason='持仓行情待补齐')
price = number(row['price'])
if price <= 0:
return dict(result, reason='持仓行情待补齐')
value = price * qty
profit = value - net
return dict(result, ready=True, profit=float(profit.quantize(Decimal('.01'))),
profit_pct=float(profit / net) if net > 0 else None,
unrealized=float((value - remaining).quantize(Decimal('.01'))), reason=None)
except (ValueError, TypeError, KeyError, InvalidOperation):
return empty

View File

@ -27,7 +27,7 @@ def digest(value):
separators=(',', ':'), allow_nan=False).encode()).hexdigest()
def signal_event(sig, *, now, since, threshold=.85, max_age=300):
def signal_event(sig, *, now, since, threshold=.85, max_age=300, actions=('SELL',)):
"""真正的清仓级信号才计次。过期、未来、回退结论及无出处不计数。"""
code = str(sig.get('ts_code') or '')
from app.core.command_spec import is_stock_code
@ -37,12 +37,14 @@ def signal_event(sig, *, now, since, threshold=.85, max_age=300):
conf = float(sig.get('confidence'))
except (TypeError, ValueError):
return None, '没有有效置信度'
if (sig.get('action') != 'SELL' or not math.isfinite(conf) or conf < threshold or conf > 1
if (sig.get('action') not in actions or not math.isfinite(conf) or conf < threshold or conf > 1
or sig.get('is_fallback') not in (None, False, 0, 'false', '0', '')):
return None, '不是有效清仓级结论'
source = sig.get('source')
if source not in ('intraday', 'risk_sell'):
return None, '信号来源不可核实'
if source == 'risk_sell' and sig.get('action') != 'SELL':
return None, '风控卖出流不能提供转多结论'
reason = ' '.join(str(sig.get('reason') or '').split())[:500]
at = stamp(sig.get('event_time'))
now, start = stamp(now), stamp(since)

View File

@ -79,6 +79,9 @@ def _num(v, d=0.0):
def _norm_conf(v) -> float:
"""盘中流 (0~1 制) 的置信度归一。大于 1 的按百分制兜底处理。"""
c = _num(v)
import math
if not math.isfinite(c):
return 0.0
if c > 1:
c = c / 100.0
return max(0.0, min(1.0, c))
@ -94,6 +97,9 @@ def _norm_conf_pct(v) -> float:
会被折成不足 1% 而落进"低于门槛只留痕"一档, 错的方向是漏报不是误清仓。
"""
c = _num(v)
import math
if not math.isfinite(c):
return 0.0
return max(0.0, min(100.0, c)) / 100.0
@ -114,6 +120,7 @@ def parse_intraday(fields: dict, *, msg_id: str = None) -> dict:
except (ValueError, TypeError):
validity = {'expires_at': 'invalid'}
return {"source": SRC_INTRADAY, "msg_id": msg_id,
'is_fallback': f.get('is_fallback'),
'signal_id': f.get('signal_id'), 'event_time': f.get('trigger_time'),
'expires_at': validity.get('expires_at') if isinstance(validity, dict) else 'invalid',
"ts_code": (f.get("ts_code") or "").strip(),

View File

@ -48,6 +48,13 @@ 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 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',
{'kind': kind, 'since': since, 'n': int(limit)})
return [{'id': r['doc_id'], 'value': json.loads(r['payload_json'])} for r in rows]
def stage_locked(key, value):
"""在既有行锁事务内先发布阶段,供同事务的下发闸读取;外部仍不可见。"""
if db._TRANSACTION.get() is None:

View File

@ -62,7 +62,8 @@ def nightly_map(codes) -> dict:
return {}
def assemble(row, *, nightly=None, tech_states=None, flip_at=None, params=None) -> dict:
def assemble(row, *, nightly=None, tech_states=None, flip_at=None, params=None,
intraday_event=None, now=None) -> dict:
"""给一行 (候选 / 持仓) 装配四块意见。row 需带 ts_code 与 company_review。不改 row。
nightly: 该票昨夜定性 entry; tech_states: 技术面映射 (state_map); flip_at: 盘中转多时刻。"""
p = params or _params()
@ -74,6 +75,15 @@ def assemble(row, *, nightly=None, tech_states=None, flip_at=None, params=None)
tech = (tech_states or {}).get(code) or {"stance": "无读数", "no_read_why": "没有技术面读数"}
tm = _timing_stance(nightly, today_ymd=tradedays.ymd(),
stale_tdays=p["timing_stale_tdays"], flip_at=flip_at)
from app.services import timing_state
if timing_state.enabled():
# 新模式只采用带原始时间和期限的最新方向,不再把旧 BUY 留痕当作全天看多。
tm = _timing_stance(nightly, today_ymd=tradedays.ymd(), stale_tdays=p['timing_stale_tdays'])
event = timing_state.valid(intraday_event, now) if intraday_event is not None else timing_state.latest(code, now)
if event:
tm.update(stance='看多' if event['action'] == 'BUY' else '看空', fresh=True,
intraday_flip_at=event['at'] if event['action'] == 'BUY' else None,
intraday_event=event, no_read_why=None)
# 合议参与分流的开关关掉时, 基本面无读数不由合议这层拦 (回到只按判决分流)
con = consensus.decide(fund["stance"], tech.get("stance") or "无读数", tm["stance"],
tech_phase=tech.get("phase"),
@ -91,7 +101,7 @@ def hard_keys(blocks) -> dict:
"tech": tech,
"tech_text": tech.get("reason") or tech.get("no_read_why"),
"timing": {"stance": tm["stance"], "nightly": tm.get("nightly"),
"flip_at": tm.get("intraday_flip_at")},
"flip_at": tm.get("intraday_flip_at"), "event": tm.get('intraday_event')},
"consensus": {"direction": con["direction"], "votes": con["votes"],
"strength": con.get("strength"), "reason": con.get("reason"),
"route": con.get("route"), "route_reason": con.get("route_reason")},
@ -108,6 +118,16 @@ def state_map():
return {}
def holding_buy_consensus(code, *, now=None):
"""自动网格新增买入也使用持仓的现行三源意见,不由吸筹标签单独开关。"""
from app.services import logic_state_service
review = (logic_state_service.state_map().get(code) or {}).get('company_review')
blocks = assemble({'ts_code': code, 'company_review': review},
nightly=nightly_map([code]).get(code), tech_states=state_map(), now=now)
con = blocks['consensus']
return con.get('route') == '放行' and con.get('direction') == '看多', blocks
def decorate_positions(rows, *, nightly=None, tech_states=None, company_reviews=None,
flip_map=None, params=None):
"""给持仓行装配三源合议四块 (原地改), 挂 consensus_blocks 一键 —— 动作引擎的增持门读它。

View File

@ -31,12 +31,16 @@ def identity(candidate, payload):
'company_review_text', 'intraday_buy_signal', 'intraday_buy_reason',
'logic_state', 'support', 'pressure', 'ref_source')}
position = (payload.get('context') or {}).get('position') or {}
return digest({'research': research, 'position': {k:position.get(k) for k in
material = {'research': research, 'position': {k:position.get(k) for k in
('total_qty', 'base_qty', 'add_qty', 'dca_qty', 'avg_cost', 'support_ref', 'pressure_ref', 'stop_ref')},
'book': candidate.get('book'), 'source': hard.get('candidate_source'),
'stage': {k: hard.get(k) for k in ('dca_stage', 'stage', 'dca_count', 'trigger', 'logic_state')},
# OPEN数量由PMS实时复核,持仓增持的模型证据还包含本次动作数量。
'action_qty': candidate.get('qty') if payload.get('action') != 'OPEN' else None})
'action_qty': candidate.get('qty') if payload.get('action') != 'OPEN' else None}
event = (hard.get('timing') or {}).get('event')
if event:
material['timing_event'] = {k: event.get(k) for k in ('key', 'action', 'at', 'expires_at')}
return digest(material)
def unavailable(reason, **extra):

View File

@ -46,6 +46,8 @@ def _valid_limit_flag(value):
# 运行态开关: key -> (默认值, 类型, 说明)
RUNTIME_EXTRA = {
'PMS_SIGNAL_RECOVERY_ENABLED': (False, bool, '使用最新有效盘中方向;三源重新放行后可解除首次系统停买,不解除人工暂停或已启动清仓'),
'PMS_SIGNAL_RECOVERY_START_AT': ('', str, '方向更新与首次停买恢复的实际启用时刻,不回补旧信号'),
"PMS_SIGNAL_FOCUS_ENABLED": (False, bool, "持仓与有效关注共用完整信号读取,不扩大交易资格"),
"PMS_BROAD_DAILY_ENABLED": (False, bool, "接入正式宽基与行业每日资金,仅供观测"),
"PMS_UPSTREAM_DAY_SCAN": (20000, int, "信号流当天每路读取上限,达到上限明确提示"),

View File

@ -517,6 +517,13 @@ def select_candidates(plan: dict, *, held=(), black=(), top_n: int = 30, tiers=N
# 有机会被看见。默认关是守「宁缺毋滥」。include_observe 已开时观察档全在, 不必再叠。
pool += [r for r in (plan.get("observe") or []) if _fund_stance_of(r) == "看多"]
# 有效人工关注必须进入同一轮评估,不因榜单分组或普通候选数量截断而消失。
# 只补上入口,后面的资格、黑名单、三源合议和资金约束照常执行。
def watched(row):
user = row.get('user_candidate') or {}
return bool(user.get('id') and str(user.get('expires_on') or '') >= today)
pool += [r for r in plan.get('observe', []) if watched(r) and r not in pool]
theme_cap = int(theme_cap or 0)
dropped = {"held": 0, "black": 0, "tier": 0, "score": 0, "sources": 0, "upside": 0,
"st": 0, "theme": 0, "dup": 0, "capped": 0, "display": 0}
@ -547,7 +554,7 @@ def select_candidates(plan: dict, *, held=(), black=(), top_n: int = 30, tiers=N
drop('dup', c)
continue
seen.add(c)
if r.get('user_required') and str((r.get('user_candidate') or {}).get('expires_on') or '') < today:
if r.get('user_required') and not watched(r):
drop('display', c)
display_only.append({'ts_code': c, 'basis': '用户关注已到期'})
continue
@ -592,8 +599,10 @@ def select_candidates(plan: dict, *, held=(), black=(), top_n: int = 30, tiers=N
passed.append(r)
n = max(0, int(top_n or 0)) or len(passed)
dropped["capped"] = max(0, len(passed) - n)
filtered.extend({'ts_code': r['ts_code'], 'reason': 'capped'} for r in passed[n:])
kept = [r for i, r in enumerate(passed) if i < n or watched(r)]
capped = [r for i, r in enumerate(passed) if i >= n and not watched(r)]
dropped["capped"] = len(capped)
filtered.extend({'ts_code': r['ts_code'], 'reason': 'capped'} for r in capped)
items = [{"ts_code": r["ts_code"], "name": r["name"], "score": r.get("score") or 0.0,
"sector": r.get("theme"), "theme": r.get("theme"), "tier": r.get("tier"),
"heat": r.get("heat"), "upside": r.get("upside"), "rank": r.get("rank"),
@ -620,7 +629,7 @@ def select_candidates(plan: dict, *, held=(), black=(), top_n: int = 30, tiers=N
"quality_band": r.get("quality_band"), "pointed": r.get("pointed"),
"rank_axis": r.get("rank_axis"), "rank_old": r.get("rank_old"),
**{k: r.get(k) for k in ('research_rank', 'rating_priority', 'research', 'review_ref', 'user_candidate', 'user_required')}}
for r in passed[:n]]
for r in kept]
for i, item in enumerate(items, 1):
item.update(selection_rank=i, decision=plan.get('decision'),
refresh_status=plan.get('refresh_status'))

View File

@ -35,13 +35,33 @@ def position_groups(original_view: dict) -> list:
held = [r for r in rows if r["total_qty"] > 0]
totals = view.get("totals", {})
missing = view.get("price_missing", [])
from app.core.holding_performance import calculate
failures = []
# 收益展示直接读本策略批次,避免负成本在交易安全垫中截断后丢失利润。
# 账本、avg_cost 与策略使用的 cushion 字段均不在这里改写。
for row in held:
try:
with books.scope(book):
lots = pms_repo.list_lots(row['ts_code'], status=None, limit=2001)
if len(lots) >= 2001:
raise ValueError('批次超过完整核验上限')
row['performance'] = calculate(row, lots)
except Exception:
logger.exception('持仓收益批次读取失败 %s %s', book, row['ts_code'])
row['performance'] = calculate(row, [])
if not row['performance']['ready']:
failures.append(row['ts_code'])
performance_ready = ready and not missing and not failures
cost = sum(row['performance']['net_cost'] for row in held) if performance_ready else None
profit = sum(row['performance']['profit'] for row in held) if performance_ready else None
return {"book_id": book, "name": name, "positions": rows, "held": held,
"ready": ready, "price_missing": missing,
"performance_ready": performance_ready, "performance_missing": failures,
"totals": {"names_count": len(held),
"market_value": totals.get("portfolio_mv", 0) if ready else None,
"cost_basis": totals.get("cost_basis", 0) if ready else None,
"pnl_pct": totals.get("float_pnl_pct") if ready and not missing else None,
"pnl": totals.get("float_pnl", 0) if ready and not missing else None}}
"cost_basis": round(cost, 2) if cost is not None else None,
"pnl_pct": profit / cost if performance_ready and cost > 0 else None,
"pnl": round(profit, 2) if performance_ready else None}}
result = [group(books.ORIGINAL, "主观量化", original_view)]
if not settings.INFRA_STRATEGY_BOOK_SCHEMA:
@ -62,7 +82,7 @@ def holding_performance(groups: list) -> dict:
rows = []
for group in groups:
totals = group["totals"]
ready = group["ready"] and not group["price_missing"]
ready = group["ready"] and not group["price_missing"] and group.get('performance_ready', True)
rows.append({"book_id": group["book_id"], "name": group["name"], "ready": ready,
"names_count": totals["names_count"],
"profit": totals["pnl"] if ready else None,

View File

@ -608,7 +608,7 @@ def _attach_consensus(cands, out=None, now=None) -> None:
try:
flip_at = (c.get("sig_buy") or {}).get("at") or None
blocks = consensus_service.assemble(
c, nightly=nightly.get(code), tech_states=tech_states, flip_at=flip_at)
c, nightly=nightly.get(code), tech_states=tech_states, flip_at=flip_at, now=now)
ikind = _apply_intraday(code, blocks, icfg, now, icache) if icfg else None
c["consensus"] = blocks["consensus"]
c["consensus_blocks"] = blocks
@ -1670,6 +1670,9 @@ def _buy_signals_today() -> dict:
最新一条取 reason —— 最新那条若是择时程序的, 决策系统更早的那条会被盖掉, 这只票就
不插队; 方向是少插一次队, 不是多插。
"""
from app.services import timing_state
if timing_state.enabled():
return timing_state.buy_map()
try:
rows = pms_repo.buy_signals_today(datetime.now().replace(
hour=0, minute=0, second=0, microsecond=0))

View File

@ -131,7 +131,9 @@ def evaluate_all(judge_keys: dict, now=None) -> dict:
logger.warning("[重问] 读当日驳回行失败 (本轮不解锁任何票): %s", e)
return {}
try:
buys = pms_repo.buy_signals_today(since) or {}
from app.services import timing_state
current_direction = timing_state.enabled()
buys = timing_state.buy_map(now) if current_direction else (pms_repo.buy_signals_today(since) or {})
except Exception as e:
logger.warning("[重问] 读当日转多留痕失败 (U1 本轮不成立): %s", e)
buys = {}
@ -147,7 +149,7 @@ def evaluate_all(judge_keys: dict, now=None) -> dict:
base.setdefault("price", row.get("price"))
b = buys.get(code) or {}
buy_at = b.get("at") or ""
if buy_at and not sr.is_bionic_buy_note(b.get("reason")):
if buy_at and not current_direction and not sr.is_bionic_buy_note(b.get("reason")):
buy_at = "" # 不是决策系统发的转多留痕, 不算 U1
try:
r = rr.evaluate(base=base, now_read=_now_read(code, str(buy_at).replace(" ", "T")),

View File

@ -137,7 +137,7 @@ def on_signal(sig, *, now=None, dry_run=False):
_sync(state, code, pos, lots, now)
reset = rules.stamp(state.get('reset_at'))
if reset and rules.stamp(event['at']) <= reset:
return {'accepted': False, 'reason': '信号早于人工恢复买入'}
return {'accepted': False, 'reason': '信号早于本次恢复买入'}
# 持仓买入前的消息不能用来清这轮新仓。
opened = rules.stamp(pos.get('opened_date'))
if opened and rules.stamp(event['at']) < opened:
@ -157,6 +157,69 @@ def on_signal(sig, *, now=None, dry_run=False):
return {'accepted': True, 'duplicate': duplicate, 'count': count, 'phase': phase}
def recover_on_buy(code, event, *, now=None):
"""新的有效转多只解除本轮第一次系统停买,不重开已撤指令。"""
from app.services import timing_state, strategy_service, consensus_service, logic_state_service
now = now or datetime.now()
wait = {'recovered': False}
if (not enabled() or not timing_state.enabled() or not _code_ok(code)
or not timing_state.valid(event, now) or event.get('action') != 'BUY'
or float(event.get('confidence') or 0) < param_store.get_float('PMS_SIGNAL_AUTO_EXIT_CONF', .85)):
return wait
if any(param_store.get_bool(k, False) for k in ('PMS_GLOBAL_BUY_HALT', 'PMS_GLOBAL_EXEC_HALT')):
return wait
review = (logic_state_service.state_map().get(code) or {}).get('company_review')
snapshot = rules.review_snapshot(review, now=now,
stale_days=param_store.get_int('PMS_FUND_STALE_DAYS', 120))
if not snapshot:
return wait
blocks = consensus_service.assemble({'ts_code': code, 'company_review': review},
nightly=consensus_service.nightly_map([code]).get(code),
tech_states=consensus_service.state_map(), intraday_event=event, now=now)
con = blocks['consensus']
if con.get('route') != '放行' or con.get('direction') != '看多':
return wait
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
current = timing_state.latest(code, now)
if not current or current['key'] != event['key']:
return wait
if (state.get('phase') != 'STOP_BUY' or state.get('count') != 1
or state.get('review_exit') or state.get('exit_iid')):
return wait
pos, lots = _holding(code)
if (not lots or not set(state.get('lot_ids') or []) & lots
or state.get('opened_date') != str(pos.get('opened_date'))):
return wait
change = rules.review_change(state.get('review'), snapshot)
if change not in ('same', 'updated'):
return wait
at = rules.stamp(event['at'])
prior = [rules.stamp(e.get('at')) for e in state.get('events', [])]
prior.append(rules.stamp(state.get('reset_at')))
if any(t and at <= t for t in prior):
return wait
if pms_repo.list_strategies(ts_code=code, statuses=['PAUSED'], limit=1):
return wait
pause = strategy_service.buypause_map().get(code) or {}
sources = pause.get('sources') or ({pause['source']: pause} if pause.get('source') else {})
allowed = {'risk_exit', 'intraday', 'risk_sell', 'accum'}
if (not sources or set(sources) - allowed
or any(not rules.stamp(v.get('at')) or rules.stamp(v['at']) >= at for v in sources.values())):
return wait
reason = '新的有效看多信号通过三源合议,解除首次系统停买'
evidence = {'round_id': state['round_id'], 'event': event,
'previous_events': list(state.get('events') or []),
'consensus': consensus_service.hard_keys(blocks), 'sources': sorted(sources)}
_ledger(code, 'SIGNAL', reason, {'buy_recovery': evidence}, event['key'][:64])
for source in sorted(sources):
result = strategy_service.clear_buypause(code, only_source=source)
if not result.get('ok') or not result.get('cleared'):
raise RuntimeError('系统恢复买入未保存,保留原暂停')
state.update(phase='WATCH', count=0, reset_at=event['at'], reason=reason,
review=snapshot, last_recovery=evidence)
return {'recovered': True, 'reason': reason}
def observe_review(code, review, *, now=None):
if not enabled() or not _code_ok(code):
return None
@ -333,6 +396,10 @@ def scan(*, now=None):
for code in sorted(codes):
try:
out['reviews'][code] = observe_review(code, (states.get(code) or {}).get('company_review'), now=now)
from app.services import timing_state
event = timing_state.latest(code, now)
if event and event['action'] == 'BUY':
out.setdefault('recoveries', {})[code] = recover_on_buy(code, event, now=now)
drive(code, now=now)
except Exception as exc:
out['errors'].append(f'{code}: {type(exc).__name__}: {exc}')

View File

@ -148,6 +148,16 @@ def _handle(sig, view, prm, seen, ymd, dry_run, out, strat_codes=frozenset()):
d = sr.digest(sig, pos, prm)
act = d["action"]
# 按每条真实方向事件更新,先于旧的每日去重。BUY→SELL→BUY 不丢最后一次转多。
from app.services import timing_state
if not dry_run and timing_state.enabled():
event = timing_state.record(sig)
if event and event['action'] == 'BUY':
from app.services import risk_exit
result = risk_exit.recover_on_buy(code, event)
if result.get('recovered'):
out.setdefault('buy_recovered', []).append({'ts_code': code, **result})
# 已授权退出纪律独立于旧的“每股每天一次”去重;重放按原研判标识防重。
# 必须早于在途提议检查,否则第一次生成的提议会吞掉第二次真实信号。
if act == sr.ACT_EXIT:

View File

@ -691,6 +691,22 @@ def _tend_existing(st, p, a, fresh, hv, prm, buypause, handoff_cool, today,
return
if why_h:
out["skipped"].append({"ts_code": code, "why": why_h})
from app.services import timing_state, consensus_service
if timing_state.enabled():
# 吸筹继续参与策略形态参考,不再越过三源合议单独暂停新增买入。
pause = (buypause or {}).get(code) or {}
sources = pause.get('sources') or {pause.get('source'): pause}
if 'accum' in sources:
allowed, blocks = consensus_service.holding_buy_consensus(code)
if allowed and not dry_run and not param_store.get_bool('PMS_GLOBAL_BUY_HALT', False):
result = strategy_service.clear_buypause(code, only_source='accum')
if not result.get('ok'):
raise RuntimeError('吸筹旧暂停解除失败')
if result.get('cleared'):
out['resumed'].append({'ts_code': code, 'why': '三源合议放行,解除旧吸筹暂停'})
_ledger(code, 'NOTE', '三源合议放行,解除旧吸筹暂停',
consensus_service.hard_keys(blocks), st['strategy_id'], out, action='NOTE')
return
# ---- 边三: 派发/失效 → 暂停买入; 回明确 → 解除 accum 来源的暂停 ----
if R_EXIT not in prm["rules"]:
return

View File

@ -719,7 +719,15 @@ def tick(*, now=None, dry_run: bool = False) -> dict:
"why": f"{code} 已无持仓, 策略空转 (可撤下)"})
continue
if st.get('type') == 'GRID':
_tick_grid(st, pos, now, dry_run, out, paused_codes is None or code in paused_codes or macro_gated)
paused = paused_codes is None or code in paused_codes or macro_gated
from app.services import timing_state, consensus_service
if timing_state.enabled() and str(st.get('note') or '').startswith('自动挂载'):
allowed, blocks = consensus_service.holding_buy_consensus(code, now=now)
paused = paused or not allowed
if not allowed:
out['notes'].append(f"{code} 自动网格买入等待三源合议放行:" +
str(blocks['consensus'].get('route_reason') or blocks['consensus'].get('reason')))
_tick_grid(st, pos, now, dry_run, out, paused)
continue
state = deepcopy(st.get("state") or {})
if st.get("type") == "T0":

View File

@ -0,0 +1,87 @@
"""最新有效盘中方向。按原始时间覆盖,不用当天第一条 BUY 代表全天方向。"""
from datetime import datetime, timedelta
from config.settings import settings
from app.core import risk_exit as rules, strategy_book as books
from app.repo import rotation_repo, pms_repo
from app.services import param_store
KIND = 'timing_direction'
def enabled():
return settings.INFRA_STRATEGY_BOOK_SCHEMA and param_store.get_bool('PMS_SIGNAL_RECOVERY_ENABLED', False)
def key(code):
return 'timing-direction:' + code
def valid(value, now=None):
if not value:
return None
now = rules.stamp(now or datetime.now())
at, expiry = rules.stamp(value.get('at')), rules.stamp(value.get('expires_at'))
if (not at or not expiry or at.date() != now.date() or not at <= now < expiry
or value.get('action') not in ('BUY', 'SELL')):
return None
return value
def latest(code, now=None):
if not enabled():
return None
return valid(rotation_repo.get(key(code))[0], now)
def record(sig, now=None):
if not enabled():
return None
now = now or datetime.now()
max_age = param_store.get_int('PMS_RISK_SIGNAL_MAX_AGE_SEC', 300)
event, _ = rules.signal_event(sig, now=now,
since=param_store.get('PMS_SIGNAL_RECOVERY_START_AT', ''),
threshold=param_store.get_float('PMS_SIGNAL_SELL_CONF_MIN', .75),
max_age=max_age, actions=('BUY', 'SELL'))
if not event:
return None
expiry = rules.stamp(event['at']) + timedelta(seconds=max_age)
explicit = rules.stamp(sig.get('expires_at'))
if explicit:
expiry = min(expiry, explicit)
event.update(action=sig['action'], expires_at=expiry.isoformat())
event['key'] = rules.digest([event['key'], event['action']])
code = sig['ts_code']
with rotation_repo.account_guard(), rotation_repo.locked(key(code), KIND, {}) as current:
if current:
before, after = rules.stamp(current['at']), rules.stamp(event['at'])
if after < before or (after == before and current['action'] == 'SELL'):
return None
if current.get('key') == event['key']:
return dict(current)
current.clear()
current.update(event)
with books.scope(books.ORIGINAL):
if pms_repo.insert_ledger(ts_code=code, action='SIGNAL', arbiter='system', verdict='NOTE',
price_at=float(sig.get('suggested_price') or 0),
hard_numbers={'timing_direction': event},
reason='决策系统最新盘中方向:' + ('看多' if event['action'] == 'BUY' else '看空'),
ref_id=event['key'][:64]) != 1:
raise RuntimeError('盘中方向依据未成功入账')
return event
def buy_map(now=None):
if not enabled():
return {}
today = rules.stamp(now or datetime.now()).replace(hour=0, minute=0, second=0, microsecond=0)
rows = rotation_repo.updated_since(KIND, today.replace(tzinfo=None), limit=6001)
if len(rows) >= 6001:
raise ValueError('盘中方向数量超过完整读取上限')
out = {}
for row in rows:
event = valid(row['value'], now)
if event and event['action'] == 'BUY':
code = row['id'][len('timing-direction:'):]
out[code] = {'at': event['at'], 'reason': event['reason'], 'event': event}
return out

View File

@ -1110,7 +1110,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<div class="pnl-book" v-for="book in holdingPnl.strategies || []" :key="book.book_id">
<span>{{ book.name }}</span><b :class="pnlColor(book.profit)">{{ pnlMoney(book.profit) }}</b><span :class="pnlColor(book.profit)">{{ book.names_count===0 && book.ready ? '暂无持仓' : pnlPercent(book.profit_pct) }}</span>
</div>
<div class="pnl-note">{{ holdingPnl.reason || '按当前持仓摊薄成本计算,包含这些持仓此前卖出已实现的盈亏;比例按各策略合计成本计算。' }}</div>
<div class="pnl-note">{{ holdingPnl.reason || '包含当前持仓此前卖出的已实现盈亏,不含手续费。成本已收回时保留盈亏金额,不计算该股收益率。' }}</div>
</div></template>
<div class="m pnl-card" tabindex="0" aria-label="持仓盈亏及策略明细"><div class="k">持仓盈亏<span class="help">?</span></div>
<div class="v pnl-value" :class="pnlColor(holdingPnl.profit)">{{ pnlMoney(holdingPnl.profit) }}<span class="pnl-rate">{{ pnlPercent(holdingPnl.profit_pct) }}</span></div></div>
@ -1130,7 +1130,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<div class="panel tblk postbl" id="t-pos">
<h3>持仓</h3>
<div class="sub2">占比按总操作规模计算。
<span class="help" data-tip="摊薄成本=(剩余批次买入金额-此前卖出已实现盈亏)÷剩余股数,不含手续费,也不是券商含费成本。费用单独记账,未回报费用不视为零。综合盈亏与安全垫均按摊薄成本计算;减仓后股数较少时,收益率可能明显放大。人工设定价仅随人工命令变更,系统参考位另见管理视图。">?</span></div>
<span class="help" data-tip="摊薄成本=(剩余批次买入金额-此前卖出已实现盈亏)÷剩余股数,不含手续费,也不是券商含费成本。费用单独记账,未回报费用不视为零。综合盈亏包含本轮已实现收益与剩余持仓浮盈亏;成本收回后仍显示金额,收益率不再计算。安全垫单独沿用交易规则。人工设定价仅随人工命令变更,系统参考位另见管理视图。">?</span></div>
<el-tabs v-model="positionTab" class="position-tabs">
<el-tab-pane v-for="group in positionGroups" :key="group.book_id" :name="'hold-'+group.book_id" class="position-book" :data-book="group.book_id">
<template #label>{{ group.name }} <span class="tabn">{{ group.ready ? group.totals.names_count : '—' }}</span></template>
@ -1172,7 +1172,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
</el-table-column>
<el-table-column v-if="group.book_id==='micro30'" label="持仓 / 可卖" width="110"><template #default="s">{{ s.row.total_qty }} / {{ s.row.avail_qty }}</template></el-table-column>
<el-table-column label="现价 / 摊薄成本" width="96">
<template #default="s">{{ s.row.price }}<span v-if="!s.row.price_ok" class="muted"> 估</span><br><span class="muted" title="摊薄成本不含手续费,费用单独记账。">{{ costPrice(s.row.avg_cost) }}</span></template>
<template #default="s">{{ s.row.price }}<span v-if="!s.row.price_ok" class="muted"> 估</span><br><span class="muted" title="摊薄成本不含手续费,费用单独记账。">{{ s.row.performance?.cost_recovered ? '成本已收回' : costPrice(s.row.avg_cost) }}</span></template>
</el-table-column>
<!-- 我设的止损价与目标价: 读命令表带出来的 user_stop_price / user_target_price,
不是持仓行上的 stop_ref。stop_ref 每天早上会被系统重算的参考位整列盖掉,
@ -1186,19 +1186,19 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
v-else class="muted">未设</span>
</template>
</el-table-column>
<el-table-column label="综合盈亏" width="76">
<el-table-column label="综合盈亏" width="108">
<template #default="s">
<span v-if="s.row.price_ok && s.row.avg_cost" :class="(s.row.price/s.row.avg_cost-1)>=0?'clr-up':'clr-down'">{{ pct(s.row.price/s.row.avg_cost-1) }}</span>
<span v-else class="muted">—</span>
<template v-if="s.row.performance?.ready"><span :class="pnlColor(s.row.performance.profit)">{{ pnlMoney(s.row.performance.profit) }}</span><br><span class="muted">{{ s.row.performance.cost_recovered ? '成本已收回' : pct(s.row.performance.profit_pct) }}</span></template>
<span v-else class="muted">{{ s.row.performance?.reason || '待核实' }}</span>
</template>
</el-table-column>
<el-table-column label="市值 / 占比" width="100">
<template #default="s">{{ money(s.row.market_value) }}<br><span class="muted">{{ pct(s.row.pct_of_scale) }}</span></template>
</el-table-column>
<el-table-column v-if="group.book_id==='original'" label="安全垫" width="100">
<template #default="s"><el-tag size="small" effect="dark" :type="cuTag(s.row.cushion_state)">{{ tx('cushion', s.row.cushion_state) }}</el-tag>
<template #default="s"><span v-if="s.row.performance?.cost_recovered" class="muted">比例不适用</span><template v-else><el-tag size="small" effect="dark" :type="cuTag(s.row.cushion_state)">{{ tx('cushion', s.row.cushion_state) }}</el-tag>
<div class="muted">{{ pct(s.row.cushion_pct) }}</div>
<div class="muted" v-if="s.row.neg_cushion_days>0">连亏 {{ s.row.neg_cushion_days }} 日</div></template>
<div class="muted" v-if="s.row.neg_cushion_days>0">连亏 {{ s.row.neg_cushion_days }} 日</div></template></template>
</el-table-column>
<el-table-column v-if="group.book_id==='original'" label="综合分析" width="168">
<template #default="s">
@ -2000,7 +2000,7 @@ body.dock-r:not(.r-fold) .side-r .strip{display:none;}
<el-table-column v-if="group.book_id==='original'" label="批次(底/补/加/补仓/T)" width="170">
<template #default="s"><span class="mono nowrap">{{ s.row.base_qty }}/{{ s.row.fill_qty }}/{{ s.row.add_qty }}/{{ s.row.dca_qty }}/{{ s.row.t0_qty }}</span></template>
</el-table-column>
<el-table-column prop="avg_cost" label="摊薄成本" width="100"><template #default="s"><span title="摊薄成本不含手续费,费用单独记账。">{{ costPrice(s.row.avg_cost) }}</span></template></el-table-column>
<el-table-column prop="avg_cost" label="摊薄成本" width="100"><template #default="s"><span title="摊薄成本不含手续费,费用单独记账。">{{ s.row.performance?.cost_recovered ? '成本已收回' : costPrice(s.row.avg_cost) }}</span></template></el-table-column>
<el-table-column prop="price" label="现价" width="90"></el-table-column>
<el-table-column v-if="group.book_id==='original'" label="安全垫" width="130">
<template #default="s">

View File

@ -1,5 +1,7 @@
# 开发资料入口
当前择时转弱后恢复、关注股入池、传导旧门槛与负净成本展示,见[11月10日修复接续](择时恢复与关注入池修复_2026-11-10.md)。
这里按任务选择资料,不要求每次读完全部文档。长期规则在根目录与各目录的AGENTS.md中,当前状态在阶段接续,操作过程在DEVLOG。`CLAUDE.md`已停止同步维护,保留原样;无需随规则修改一起提交。
## 按任务读取

View File

@ -0,0 +1,27 @@
# 择时恢复、人工关注入池与持仓收益修复
## 2026年11月10日12:05开发机核验
范围为155模拟PMS和同机选股桥。188真实PMS和其他系统没有写操作。PMS分支为`codex/signal-recovery-20261110`,基于已发布产品`5c30373`及接续`50b4dcd`;桥分支为`codex/consensus-eligibility-20261110`,产品基于`0945fa2`。
11:30至11:33只读发现:华策影视有有效关注登记和正式买方报告,期限至11月24日,但未出现在桥返回的主榜300、观察榜100中,也未进入PMS的50只扫描范围。技术面看多、基本面看空、昨夜择时中性,按现行三源合议应交人,不能因动量强就承诺自动买入。当天关注盘中研究最近一条为模型未返回合法结论,不能当作真实BUY。
同一时点返回主榜有203条仅展示,其中89条含“所在环节当日没有被传导指向”。此前只取消了明确吸筹确认,传导和昨夜负面方向的前置否决仍在。质地排序未取消;本次让这些方向参考进入现行三源合议,不伪造真实传导记录。
雷赛智能剩余100股,首次清仓纪律为STOP_BUY、计数1,仍有intraday和risk_exit两个停买来源;没有新的有效看多信号。旧代码只有人工恢复入口。11月9日1500股实际卖出后,本轮已实现6797元、剩余批次原始成本4829元,净成本为负1968元。旧展示把负成本截零,导致收益率空值并少计顶部收益。11月10日55.58元只读快照下,综合收益为7526元,不含未知费用。两策略持仓合计6115元。行情变化后不得沿用这个静态数字。
## 修复边界
1. 有效人工关注随同原榜返回,保留质地顺序,不受普通返回数量及PMS扫描数量截断;ST、沪深范围、黑名单、到期、资格、三源合议、行业和资金约束继续生效。人工关注不直接生成交易。
2. 桥启用`CARD_CONSENSUS_ADMISSION_ENABLED`后,传导和吸筹不再前置否决。昨夜方向与派发提示保留为参考,快照日期和证券资格仍拦截。真实时刻生成新修订,晨版不改写。
3. PMS启用`PMS_SIGNAL_RECOVERY_ENABLED`并写真实`PMS_SIGNAL_RECOVERY_START_AT`后,按原始时间保存最新有效BUY或SELL。保留原信号期限,最长沿用现行300秒,不把全天第一条BUY当作全天方向。新的方向参与合议、重问和异步研判身份,过期回到原日频意见。切换前历史信号不回放为新动作。
4. 只有本轮首次系统停买,在新的有效高置信BUY和三源合议放行后才自动解除。人工暂停、全局暂停、第二次清仓、已开始退出、评级下降、缺报告和不可核实的数据均不解除。先留审计再原子解除系统来源;不重开旧撤单。自动网格新增买入逐轮核对三源合议,卖出继续原规则,人工策略不受这项自动管理替代。
5. 收益展示按本策略真实批次计算“剩余持仓市值-剩余批次买入金额+本轮已实现盈亏”,保留负净成本。净成本非正时仍显示收益金额,收益率显示成本已收回,安全垫比例不适用。交易账本、交易成本字段、安全垫算法及未知费用保持原事实,不倒推费用。
## 开发验证与待发布
开发机PMS全量隔离回归通过;新增16项覆盖方向顺序、有效期、切换点、恢复幂等、人工约束、评级下降、第二次退出、写失败回滚、异步身份、关注入池和负净成本。桥全量隔离回归和新增5项规则修订测试通过。测试隔离配置并阻断网络。
1440与390宽度的浏览器使用155只读快照离线重算。收益金额、成本收回、空微盘标签页正常,页面无横向溢出,浏览器错误日志为空;所有写请求拒绝。这是本机复现,不是真机自然交易验收。
尚未发布。下一步先提交,候选镜像断网全量回归,核对155实际配置和在途任务后定向重建,再验证自然计划修订、扫描与账本对账。不得以人工注入信号或委托制造验收。

View File

@ -202,6 +202,7 @@ HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
# 退出纪律专项:两次独立清仓信号、评级下降、事务、双策略隔离及撤单收尾。
SUITES = [
"test_signal_recovery.py", # 最新方向、停买恢复、网格合议、关注入口与负净成本(16例)
"test_grid_execution.py",
"test_broad_funds.py", "test_etf_observation.py", "test_risk_exit.py", "test_rotation_accounting_units.py", "test_cost_precision.py", "test_execution_basis_decimal.py",
"test_trade_correction_units.py", "test_trade_correction_transport.py",

View File

@ -7,7 +7,7 @@ from unittest.mock import patch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from config.settings import settings
from app.core import rotation_account
from app.core import rotation_account, strategy_book as books
from app.services import rotation_accounting
from app.core import rule_gate
from app.services import portfolio
@ -175,11 +175,14 @@ class HoldingPerformanceTest(unittest.TestCase):
def view(self, qty, cost, price):
install_fakes(positions=[{'ts_code': '600000.SH', 'total_qty': qty, 'avg_cost': cost}],
prices={'600000.SH': price} if price else {})
return portfolio.positions_view()
view = portfolio.positions_view()
view['_test_lots'] = [{'qty': qty, 'open_price': cost or 10, 'realized_pnl': 0 if cost else qty*10}]
return view
def combine(self, original, micro):
with patch.object(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', True), \
patch.object(portfolio, 'positions_view', return_value=micro):
patch.object(portfolio, 'positions_view', return_value=micro), \
patch.object(portfolio.pms_repo, 'list_lots', side_effect=lambda *a, **k: (original if books.CURRENT.get() == 'original' else micro)['_test_lots']):
return portfolio.holding_performance(portfolio.position_groups(original))
def test_two_books_same_stock_count_separately_and_rate_is_weighted(self):
@ -211,7 +214,8 @@ class HoldingPerformanceTest(unittest.TestCase):
def test_strategy_read_failure_is_not_zero_profit(self):
original = self.view(100, 10, 11)
with patch.object(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', True), \
patch.object(portfolio, 'positions_view', side_effect=ValueError('test only')):
patch.object(portfolio, 'positions_view', side_effect=ValueError('test only')), \
patch.object(portfolio.pms_repo, 'list_lots', return_value=original['_test_lots']):
result = portfolio.holding_performance(portfolio.position_groups(original))
self.assertFalse(result['ready'])
self.assertEqual(result['strategies'][0]['profit'], 100)

View File

@ -14,6 +14,10 @@ class PositionGroupsTests(unittest.TestCase):
install_fakes(prices={'600000.SH': 12}, positions=[
{'ts_code': '600000.SH', 'total_qty': 100, 'avail_qty': 100, 'avg_cost': 10}])
self.original = portfolio.positions_view()
lots = patch.object(portfolio.pms_repo, 'list_lots', side_effect=lambda *a, **k:
[{'qty': 100, 'open_price': 10, 'realized_pnl': 0}] if books.CURRENT.get() == 'original'
else [{'qty': 300, 'open_price': 11, 'realized_pnl': 0}])
lots.start(); self.addCleanup(lots.stop)
def test_unmigrated_micro_is_empty_without_query(self):
before = copy.deepcopy(self.original)

View File

@ -0,0 +1,218 @@
"""隔离验证最新择时、首次系统停买恢复、关注入池与负净成本。"""
import unit_test_guard # noqa: F401
import copy
import datetime as dt
import unittest
from unittest.mock import patch
from contextlib import ExitStack
import test_risk_exit as base
from app.core import holding_performance, strategy_book as books, signal_rules
from app.services import timing_state, risk_exit, consensus_service, strategy_service, plan_feed
from app.repo import rotation_repo, pms_repo
class DirectionTests(unittest.TestCase):
setUp = base.ServiceTests.setUp
use = base.ServiceTests.use
insert = base.ServiceTests.insert
change = base.ServiceTests.change
state = base.ServiceTests.state
instructions = base.ServiceTests.instructions
fire = base.ServiceTests.fire
def setup_direction(self):
self.params.update(PMS_SIGNAL_RECOVERY_ENABLED=True, PMS_SIGNAL_RECOVERY_START_AT=base.START.isoformat())
self.use(consensus_service, 'state_map', lambda:{base.CODE:{'stance':'看多', 'phase':'趋势多'}})
self.use(consensus_service, 'nightly_map', lambda codes:{base.CODE:{'verdict':'SELL'}})
def clear(code, only_source=None):
with rotation_repo.locked('test-pause','test',{}) as m:
if only_source:
m[code]['sources'].pop(only_source, None)
if not m[code]['sources']: m.pop(code)
else: m.pop(code, None)
return {'ok':True, 'cleared':True}
self.use(strategy_service,'clear_buypause',clear)
return base.NOW + dt.timedelta(seconds=60)
def record(self, action, at, n=10, **changes):
return timing_state.record({**base.signal(n, at=at), 'action':action, **changes}, now=at)
def test_latest_direction_replaces_prior_buy_and_sell_in_event_order(self):
now = self.setup_direction()
buy = self.record('BUY',now)
sell = self.record('SELL',now+dt.timedelta(seconds=1),11)
self.assertEqual(timing_state.latest(base.CODE,now+dt.timedelta(seconds=2))['action'],'SELL')
self.assertIsNone(self.record('BUY',now,12))
con = consensus_service.assemble({'ts_code':base.CODE,'company_review':base.review()},
nightly={'verdict':'BUY'},tech_states=consensus_service.state_map(),now=now+dt.timedelta(seconds=2))
self.assertEqual(con['timing']['stance'],'看空')
self.assertEqual(consensus_service.hard_keys(con)['timing']['event']['key'],sell['key'])
self.assertNotEqual(buy['key'],sell['key'])
def test_new_direction_invalidates_old_async_result_with_same_plan(self):
from app.services import judge_async
now=self.setup_direction(); buy=self.record('BUY',now)
candidate={'hard_numbers':{'plan_basis':{'id':'unchanged'}}}
payload={'action':'OPEN','context':{},'hard_numbers':{}}
old=judge_async.identity(candidate,payload)
candidate['hard_numbers']['timing']={'event':buy}
self.assertNotEqual(judge_async.identity(candidate,payload),old)
same=judge_async.identity(candidate,payload)
candidate['qty']=1000
self.assertEqual(judge_async.identity(candidate,payload),same)
def test_original_expiry_and_cutover_cannot_be_extended(self):
now=self.setup_direction()
self.assertIsNone(self.record('BUY',base.START-dt.timedelta(seconds=1)))
self.assertIsNone(self.record('BUY',now,is_fallback='true'))
self.record('BUY',now,expires_at=(now+dt.timedelta(seconds=20)).isoformat())
self.assertEqual(set(timing_state.buy_map(now)),{base.CODE})
self.assertEqual(timing_state.buy_map(now+dt.timedelta(seconds=20)),{})
self.assertIsNone(timing_state.latest(base.CODE,now+dt.timedelta(days=1)))
parsed=signal_rules.parse_intraday({'is_fallback':'true'})
self.assertEqual(parsed['is_fallback'],'true')
self.assertEqual(signal_rules.parse_intraday({'confidence':'nan'})['confidence'],0)
def test_fresh_buy_supersedes_nightly_sell_but_expiry_returns_to_nightly(self):
now=self.setup_direction(); self.record('BUY',now)
row={'ts_code':base.CODE,'company_review':base.review()}
for at,expected in [(now,'看多'),(now+dt.timedelta(seconds=300),'看空')]:
con=consensus_service.assemble(row,nightly={'verdict':'SELL'},now=at,
tech_states=consensus_service.state_map(),flip_at=now.isoformat())
self.assertEqual(con['timing']['stance'],expected)
def test_first_stop_recovers_once_without_reopening_orders(self):
now=self.setup_direction(); self.fire()
strategy_service.pause_buy(base.CODE,reason='同一卖出信号',source='intraday')
event=self.record('BUY',now)
result=risk_exit.recover_on_buy(base.CODE,event,now=now)
self.assertTrue(result['recovered']); self.assertEqual(self.state()['phase'],'WATCH')
self.assertEqual(self.state()['count'],0); self.assertEqual(self.instructions(),[])
self.assertEqual(strategy_service.buypause_map(),{})
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
self.assertFalse(risk_exit.on_signal(base.signal(2),now=now)['accepted'])
self.assertEqual(risk_exit.on_signal(base.signal(3,at=now+dt.timedelta(seconds=1)),
now=now+dt.timedelta(seconds=1))['count'],1)
def test_manual_pause_global_halt_and_paused_strategy_never_auto_resume(self):
now=self.setup_direction(); self.fire();event=self.record('BUY',now)
for source in ['user','signal']:
strategy_service.pause_buy(base.CODE,reason='人工约束',source=source)
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
strategy_service.clear_buypause(base.CODE,only_source=source)
self.params['PMS_GLOBAL_BUY_HALT']=True
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
self.params['PMS_GLOBAL_BUY_HALT']=False
self.insert('pms_strategy',{'book_id':'original','strategy_id':'paused','ts_code':base.CODE,'status':'PAUSED'})
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
def test_two_sells_or_rating_downgrade_cannot_be_undone_by_buy(self):
now=self.setup_direction();self.fire();event=self.record('BUY',now)
self.reviews[base.CODE]['company_review']=base.review('中','b',1)
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
self.reviews[base.CODE]['company_review']=base.review()
self.fire(2)
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
self.assertNotEqual(self.state()['phase'],'WATCH')
def test_nonpassing_consensus_or_missing_review_keeps_pause(self):
now=self.setup_direction();self.fire();event=self.record('BUY',now)
self.reviews[base.CODE]['company_review']=None
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
self.reviews[base.CODE]['company_review']=dict(base.review(),overall='差',doubt_hard=True)
self.assertFalse(risk_exit.recover_on_buy(base.CODE,event,now=now)['recovered'])
def test_failed_clear_rolls_back_recovery_audit_and_state(self):
now=self.setup_direction();self.fire();event=self.record('BUY',now)
before=copy.deepcopy(self.state())
self.use(strategy_service,'clear_buypause',lambda *a,**k:{'ok':False})
with self.assertRaises(RuntimeError):risk_exit.recover_on_buy(base.CODE,event,now=now)
self.assertEqual(self.state(),before)
self.assertIn(base.CODE,strategy_service.buypause_map())
rows=pms_repo.list_ledger(ts_code=base.CODE,limit=100)
self.assertFalse(any('buy_recovery' in (r.get('hard_numbers') or {}) for r in rows))
class PerformanceTests(unittest.TestCase):
def test_negative_net_cost_preserves_realized_profit(self):
row={'total_qty':100,'price':52.67,'price_ok':True}
lots=[{'qty':100,'open_price':48.29,'realized_pnl':0},
{'qty':0,'open_price':47.28,'realized_pnl':6797}]
result=holding_performance.calculate(row,lots)
self.assertEqual(result['profit'],7235)
self.assertEqual(result['net_cost'],-1968)
self.assertEqual(result['unrealized'],438)
self.assertIsNone(result['profit_pct']); self.assertTrue(result['cost_recovered'])
def test_missing_lots_quantity_or_price_does_not_report_zero(self):
row={'total_qty':100,'price':10,'price_ok':True}
for lots in [[],[{'qty':99,'open_price':9,'realized_pnl':0}],
[{'qty':100,'open_price':9,'realized_pnl':None}]]:
self.assertFalse(holding_performance.calculate(row,lots)['ready'])
result=holding_performance.calculate(dict(row,price_ok=False),
[{'qty':100,'open_price':9,'realized_pnl':0}])
self.assertFalse(result['ready']);self.assertIsNone(result['profit'])
def test_three_decimal_cost_is_not_rounded_before_profit(self):
result=holding_performance.calculate({'total_qty':1700,'price':50,'price_ok':True},
[{'qty':1700,'open_price':47.339,'realized_pnl':0}])
self.assertEqual(result['profit'],4523.7)
class GridTests(unittest.TestCase):
def test_automatic_grid_waits_for_consensus_and_manual_grid_keeps_user_rules(self):
from app.services import strategy_runner as runner, param_store, portfolio
for note, allowed, paused, expected in [
('自动挂载:网格',False,False,True),('自动挂载:网格',True,False,False),
('自动挂载:网格',True,True,True),('人工安排',False,False,False)]:
with self.subTest(note=note,allowed=allowed,paused=paused), ExitStack() as stack:
stack.enter_context(patch.object(param_store,'get_bool',return_value=True))
stack.enter_context(patch.object(param_store,'get_float',side_effect=lambda k,d:d))
stack.enter_context(patch.object(timing_state,'enabled',return_value=True))
stack.enter_context(patch.object(pms_repo,'active_strategies',return_value=[
{'strategy_id':'g','ts_code':base.CODE,'type':'GRID','note':note}]))
stack.enter_context(patch.object(portfolio,'positions_view',return_value={
'positions':[{'ts_code':base.CODE,'total_qty':100}], 'totals':{'scale':10000}}))
stack.enter_context(patch.object(runner,'_today',return_value=20261105))
stack.enter_context(patch.object(runner,'_macro_gate_active',return_value=False))
stack.enter_context(patch.object(runner,'_buypause_codes',return_value={base.CODE} if paused else set()))
check=stack.enter_context(patch.object(consensus_service,'holding_buy_consensus',
return_value=(allowed,{'consensus':{'reason':'测试三源'}})))
run=stack.enter_context(patch.object(runner,'_tick_grid'))
self.assertTrue(runner.tick(now=base.NOW,dry_run=True)['ok'])
self.assertEqual(run.call_args.args[-1],expected)
self.assertEqual(check.called,note.startswith('自动挂载'))
def test_distribution_reference_no_longer_independently_stops_grid(self):
from app.services import strategy_advisor as advisor
from unittest.mock import Mock
svc=Mock();out={'skipped':[],'resumed':[]}
with patch.object(timing_state,'enabled',return_value=True), \
patch.object(advisor,'handoff_ready',return_value=(False,'')):
advisor._tend_existing({'strategy_id':'g','type':'GRID','status':'ACTIVE','note':'自动挂载:网格'},
{'ts_code':base.CODE}, {'cls':advisor.CLS_DISTRIB},True,0,{}, {},set(),20261105,False,out,svc)
svc.pause_buy.assert_not_called();svc.clear_buypause.assert_not_called()
class WatchTests(unittest.TestCase):
def row(self,code,rank,manual=False):
return dict(ts_code=code,name='示例',score=100-rank,rank=rank,research_rank=rank,
bucket='main',verdict='关注',upside=.2,
user_candidate={'id':'watch-id','expires_on':'2099-01-01'} if manual else None)
def test_watch_survives_both_buckets_and_cap_without_changing_rank(self):
a=self.row('600001.SH',1); b=self.row('600002.SH',100,True)
plan={'main':[a], 'observe':[b], 'rank_axis':'quality'}
result=plan_feed.select_candidates(plan,top_n=1,include_observe=False,rank_by_upstream=True)
self.assertEqual([r['ts_code'] for r in result['items']],['600001.SH','600002.SH'])
def test_manual_watch_cannot_bypass_expiry_blacklist_or_display_qualification(self):
r=self.row('600002.SH',100,True)
for changes,kwargs in [({'user_required':True,'user_candidate':{'id':'a','expires_on':'2000-01-01'}},{}),
({},{'black':['600002.SH']}),({'verdict':'仅展示'},{'route_by_verdict':True})]:
result=plan_feed.select_candidates({'main':[dict(r,**changes)]},**kwargs)
self.assertEqual(result['items'],[])
if __name__ == '__main__':
unittest.main()