tradingSystem/app/services/risk_exit.py

542 lines
29 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""原策略持仓的退出纪律。事件先入账,暂停买入与清仓按实际回报持续收尾。"""
from datetime import datetime
from config.settings import settings
from app.core import risk_exit as rules, strategy_book as books
from app.repo import pms_repo, rotation_repo
from app.services import param_store
KIND = 'risk_exit'
PAUSED = {'STOP_BUY', 'EXIT_PENDING', 'EXITING', 'CLOSED', 'MANUAL'}
LIVE = ('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED', 'WAIT_REVIEW')
def supported():
return settings.INFRA_STRATEGY_BOOK_SCHEMA and books.CURRENT.get() == books.ORIGINAL
def enabled():
return supported() and param_store.get_bool('PMS_RISK_EXIT_ENABLED', False)
def _key(code):
return 'risk-exit:original:' + code
def _code_ok(code):
from app.core.command_spec import is_stock_code
return is_stock_code(code) and str(code).endswith(('.SH', '.SZ'))
def buy_blocker(code):
if not supported() or not _code_ok(code):
return None
state, _ = rotation_repo.get(_key(code))
if state and (enabled() or state.get('user_stop')) and state.get('phase') in PAUSED:
return state.get('reason') or '该股退出纪律已生效,停止新增买入'
return None
def decorate_positions(rows):
"""只读展示退出纪律,非方案持仓也不能把停买误写成等待补仓。"""
if not supported():
return
labels = {'STOP_BUY': '只卖不买', 'EXIT_PENDING': '等待清仓',
'EXITING': '清仓中', 'MANUAL': '退出待处理', 'CLOSED': '退出待核实'}
for row in rows:
if int(row.get('total_qty') or 0) <= 0 or not _code_ok(row.get('ts_code')):
continue
try:
state, _ = rotation_repo.get(_key(row['ts_code']))
if state and (enabled() or state.get('user_stop')) and state.get('phase') in labels:
row['exit_status_text'] = labels[state['phase']]
row['exit_status_reason'] = state.get('reason') or '退出纪律已生效,停止新增买入'
except Exception:
row['exit_status_text'] = '退出状态待核实'
row['exit_status_reason'] = '暂时无法读取退出纪律,请稍后刷新'
def _holding(code):
pos = pms_repo.get_position(code) or {}
rows = pms_repo.list_lots(code, status='OPEN', limit=2001)
if len(rows) >= 2001:
raise ValueError('持仓批次超过完整核验上限')
lots = {str(r['id']) for r in rows if int(r.get('qty') or 0) > 0}
if sum(int(r.get('qty') or 0) for r in rows) != int(pos.get('total_qty') or 0):
raise ValueError('持仓与批次数量不一致,等待对账后执行退出纪律')
pos['_risk_lots'] = rows
return pos, lots
def _ledger(code, action, reason, hard, ref):
if pms_repo.insert_ledger(ts_code=code, action=action, arbiter='system', verdict='PASS',
price_at=0, hard_numbers=hard, reason=reason[:500], ref_id=ref) != 1:
raise RuntimeError('退出纪律依据未入账')
def _sync(state, code, pos, lots, now, *, seed=True):
"""以真实未平批次衔接持仓轮次,清空后再开仓不继承上轮信号。"""
if not lots:
return
late = any(r.get('instruction_id') in (state.get('stopped_parents') or []) for r in pos.get('_risk_lots', []))
same = bool((state.get('opened_date') == str(pos.get('opened_date'))
and set(state.get('lot_ids') or []) & lots) or late)
if not same:
# 没有批次交集时不猜是同一轮,旧证据绝不用于新批次清仓。
state.clear()
state.update(code=code, book_id=books.ORIGINAL, opened_date=str(pos.get('opened_date')),
round_id=rules.digest([code, str(pos.get('opened_date')), sorted(lots)])[:20],
phase='WATCH', events=[], lot_ids=sorted(lots), count=0, exit_seq=0,
initialized_at=rules.stamp(now).isoformat())
if seed:
from app.services import logic_state_service
entry = logic_state_service.entry_view(code) or {}
baseline = rules.review_snapshot(entry.get('company_review'), now=now,
stale_days=param_store.get_int('PMS_FUND_STALE_DAYS', 120))
if baseline:
state['review'] = baseline
_seed_legacy_first(state, code, pos, now)
else:
state['lot_ids'] = sorted(set(state['lot_ids']) | lots)
if state.get('phase') == 'CLOSED' and late:
state['phase'] = 'EXIT_PENDING'
state['stopped_parents'] = sorted(set(state.get('stopped_parents') or []) |
{r['instruction_id'] for r in pos.get('_risk_lots', []) if r.get('instruction_id')})
def _stop_commands():
rows = pms_repo.list_effective_stock_params(('SET_STOP_PRICE',))
if len(rows) >= 500:
raise ValueError('人工止损命令超过完整核验上限')
out = {}
for row in sorted(rows, key=lambda r: r['id']):
if _code_ok(row.get('ts_code')):
out[row['ts_code']] = row
return out
def observe_user_stop(code, quote, *, now=None):
"""用户价格条件已授权清仓;只记退出意图,统一由drive撤单与收尾。"""
if not supported() or not _code_ok(code):
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,
max_age=param_store.get_int('PMS_EXEC_MINUTE_MAX_AGE_SEC', 90))
if not event:
return {'triggered': False, 'reason': why}
pos, lots = _holding(code)
if not lots:
return {'triggered': False, 'reason': '当前没有原策略持仓'}
_sync(state, code, pos, lots, now, seed=False)
if state.get('user_stop') or state['phase'] in ('CLOSED', 'MANUAL'):
return {'triggered': False, 'reason': '已有退出安排,沿原流程收尾'}
reason = f"现价{event['price']:g}已触及人工止损价{event['stop_price']:g},按用户命令清仓"
# 已有模型退出时补记人工命令依据,沿原进度继续,不新开一条清仓。
phase = state['phase'] if state['phase'] in ('EXIT_PENDING', 'EXITING') else 'EXIT_PENDING'
state.update(phase=phase, reason=reason, user_stop=event)
_ledger(code, 'EXIT', reason, {'user_stop': event, 'round_id': state['round_id'],
'stage': 'intent'}, event['command_id'])
return {'triggered': True, 'reason': reason}
def _seed_legacy_first(state, code, pos, now):
"""只承接已有的真实停买及待确认清仓,不回扫历史凑第二次信号。"""
from app.services import strategy_service
pause = strategy_service.buypause_map().get(code) or {}
sources = pause.get('sources') or {pause.get('source'): pause}
candidates = pms_repo.list_proposals(statuses=('WAIT_USER',), limit=501)
if len(candidates) >= 501:
raise ValueError('待确认提议过多,不能截断迁移退出依据')
for p in candidates:
if p.get('ts_code') != code or p.get('action') != 'EXIT' or p.get('judge_verdict') != 'STRATEGY_RISK':
continue
hard = p.get('hard_numbers') or {}
source = hard.get('signal_source')
at, paused = rules.stamp(p.get('created_at')), sources.get(source) or {}
pat = rules.stamp(paused.get('at'))
if (not at or not pat or at.date() != rules.stamp(now).date()
or abs((at-pat).total_seconds()) > 120 or not hard.get('on_strategy')
or float(hard.get('confidence') or 0) < param_store.get_float('PMS_SIGNAL_AUTO_EXIT_CONF', .85)):
continue
reason = str(paused.get('reason') or '')
if not reason or reason not in str(hard.get('reason') or ''):
continue
original = reason.split(' —— ', 1)[-1]
event = {'key': rules.digest(['legacy', p['proposal_id']]), 'source': source,
'source_id': p['proposal_id'], 'msg_id': 'legacy:'+p['proposal_id'],
'at': pat.isoformat(), 'reason': original, 'content': rules.digest([code, original]),
'confidence': float(hard['confidence']), 'legacy_proposal': p['proposal_id']}
state.update(events=[event], count=1, phase='STOP_BUY',
reason='第一次清仓信号已确认,停止新增买入,等待第二次独立信号')
_ledger(code, 'SIGNAL', state['reason'], {'legacy_proposal': p['proposal_id'],
'event': event, 'round_id': state['round_id']}, p['proposal_id'])
return
def on_signal(sig, *, now=None, dry_run=False):
if not enabled():
return None
now = now or datetime.now()
from app.services import timing_fusion
from app.core import timing_fusion_contract
if timing_fusion.enabled():
event = timing_fusion_contract.valid(sig, now, since=param_store.get('PMS_TIMING_FUSION_START_AT', ''))
event = event if event and event['action'] == 'SELL' else None
why = '没有有效的合成看空结论'
else:
event, why = rules.signal_event(sig, now=now,
since=param_store.get('PMS_RISK_EXIT_START_AT', ''),
threshold=param_store.get_float('PMS_SIGNAL_AUTO_EXIT_CONF', .85),
max_age=param_store.get_int('PMS_RISK_SIGNAL_MAX_AGE_SEC', 300))
if not event:
return {'accepted': False, 'reason': why}
code = sig['ts_code']
if dry_run:
state, _ = rotation_repo.get(_key(code))
return {'accepted': True, 'dry_run': True, 'count': (state or {}).get('count', 0),
'reason': '只读预览,不登记次数、不改变委托'}
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
pos, lots = _holding(code)
if not lots:
return {'accepted': False, 'reason': '当前没有原策略持仓'}
_sync(state, code, pos, lots, now)
reset = rules.stamp(state.get('reset_at'))
if reset and rules.stamp(event['at']) <= reset:
return {'accepted': False, 'reason': '信号早于本次恢复买入'}
# 持仓买入前的消息不能用来清这轮新仓。
opened = rules.stamp(pos.get('opened_date'))
if opened and rules.stamp(event['at']) < opened:
return {'accepted': False, 'reason': '信号早于当前持仓轮次'}
duplicate = (timing_fusion_contract.duplicate(state['events'], event) if timing_fusion.enabled() else
rules.duplicate(state['events'], event, mirror_seconds=param_store.get_int('PMS_RISK_SIGNAL_MIRROR_SEC', 120)))
if not duplicate and state['phase'] not in ('EXIT_PENDING', 'EXITING', 'CLOSED', 'MANUAL'):
state['events'].append(event)
state['count'] = int(state.get('count') or 0) + 1
state['phase'] = 'STOP_BUY' if state['count'] == 1 else 'EXIT_PENDING'
state['reason'] = ('第一次清仓信号已确认,停止新增买入,等待第二次独立信号'
if state['count'] == 1 else '第二次独立清仓信号已确认,开始清仓')
_ledger(code, 'SIGNAL', state['reason'],
{'event': event, 'count': state['count'], 'round_id': state['round_id']}, event['key'][:64])
count, phase = state['count'], state['phase']
drive(code, now=now)
return {'accepted': True, 'duplicate': duplicate, 'count': count, 'phase': phase}
def 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 (event.get('source') != 'timing_fusion' and
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
first_stop = state.get('phase') == 'STOP_BUY' and state.get('count') == 1
legacy_warning = (event.get('source') == 'timing_fusion' and
state.get('phase') == 'WATCH' and state.get('count') == 0)
if (not (first_stop or legacy_warning) 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 = {'intraday', 'risk_sell'} if legacy_warning else {'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 = ('新的有效看多信号通过三源合议,解除历史信号预警停买' if legacy_warning
else '新的有效看多信号通过三源合议,解除首次系统停买')
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
now = now or datetime.now()
snapshot = rules.review_snapshot(review, now=now,
stale_days=param_store.get_int('PMS_FUND_STALE_DAYS', 120))
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
pos, lots = _holding(code)
if not lots:
return None
_sync(state, code, pos, lots, now)
change = rules.review_change(state.get('review'), snapshot)
if change in ('baseline', 'updated', 'downgrade'):
before = state.get('review')
state['review'] = snapshot
if change == 'downgrade' and state['phase'] not in ('EXIT_PENDING', 'EXITING', 'MANUAL'):
state.update(phase='EXIT_PENDING', reason=f"买方评析整体评级由{before['grade']}降为{snapshot['grade']},开始清仓")
state['review_exit'] = {'before': before, 'after': snapshot}
_ledger(code, 'SIGNAL', state['reason'],
{'review_exit': state['review_exit'], 'round_id': state['round_id']}, snapshot['ref'])
return change
def _stop_buys(code, state):
"""先持久化逐指令停止依据,再请求撤单;未确认撤销的量继续保留。"""
from app.services import executor, strategy_service
reason = state['reason']
strategy_service.pause_buy(code, reason=reason, source='risk_exit')
pause = strategy_service.buypause_map().get(code) or {}
if 'risk_exit' not in (pause.get('sources') or {}):
raise RuntimeError('退出纪律暂停买入未保存')
rows = pms_repo.list_instructions(statuses=list(LIVE), side='buy', ts_code=code, limit=501)
if len(rows) >= 501:
raise ValueError('在途买入过多,不能截断处理')
for ins in rows:
iid = ins['instruction_id']
state['stopped_parents'] = sorted(set(state.get('stopped_parents') or []) | {iid})
if not pms_repo.instruction_buy_stop(iid):
_ledger(code, 'BUY_STOP', reason, {'risk_exit': True}, iid)
result = executor.cancel_instruction(iid, reason=reason, arbiter='system') or {}
if not result.get('ok'):
raise RuntimeError('退出纪律撤单失败,保留停买并等待重试')
def drive(code, *, now=None):
"""同账户串行收尾。T+1、迟到成交、部分成交继续沿已有执行与回报链处理。"""
if not supported() or not _code_ok(code) or param_store.get_bool('PMS_GLOBAL_EXEC_HALT', False):
return
now = now or datetime.now()
from app.services import execution_conflicts, execution_orders, strategy_service
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
if not state or not (enabled() or state.get('user_stop')) or state.get('phase') not in PAUSED:
return
if state.get('user_stop'):
# 人工命令独立于评级扫描;清零后旧买单迟到仍须重开本轮收尾。
pos, lots = _holding(code)
_sync(state, code, pos, lots, now, seed=False)
if state.get('phase') not in PAUSED:
return
_stop_buys(code, state)
if state['phase'] in ('STOP_BUY', 'CLOSED', 'MANUAL'):
return
# 旧网格卖单也需明确撤销,不能只撤策略后让旧父单永久等待来源状态。
from app.services import executor
all_live = pms_repo.list_instructions(statuses=list(LIVE), ts_code=code, limit=501)
if len(all_live) >= 501:
raise ValueError('在途指令过多,不能截断处理')
for old in all_live:
if old.get('origin_type') == 'strategy' and old.get('side') == 'sell':
result = executor.cancel_instruction(old['instruction_id'], reason=state['reason'], arbiter='system') or {}
if not result.get('ok'):
raise RuntimeError('旧策略卖出撤单失败,等待重试')
# 撤掉网格等自动策略,避免旧卖单与整票清仓并发占用可卖量。
result = strategy_service.cancel_by_code(code, reason=state['reason']) or {}
if not result.get('ok'):
raise RuntimeError('清仓前策略撤销未完成,等待重试')
if pms_repo.list_strategies(ts_code=code, statuses=['ACTIVE', 'PAUSED'], limit=1):
raise RuntimeError('清仓前仍有未撤下的交易方案,等待重试')
# 同一账户锁和文档事务覆盖清仓指令、计数、报告版本与审计。
current = state
pos, lots = _holding(code)
from app.repo import qmt_repo
children = qmt_repo.list_orders(ts_code=code, statuses=list(qmt_repo.LIVE), limit=1001)
if len(children) >= 1001:
raise ValueError('在途委托超过核验上限')
owned = []
for child in children:
with books.scope('all'):
parent = pms_repo.get_instruction(child['parent_id'])
if not parent or parent.get('book_id') not in (books.ORIGINAL, books.MICRO):
raise ValueError('在途委托策略归属无法核实')
if parent['book_id'] == books.ORIGINAL:
owned.append(child)
if any(c.get('side') == 'sell' for c in owned):
return
if current.get('user_stop') and (owned or pms_repo.list_instructions(
statuses=list(LIVE), side='buy', ts_code=code, limit=1)):
return # 人工止损先完成旧买单撤销,保留迟到成交后再核实全量。
if qmt_repo.inbox_pending_count() or qmt_repo.inbox_orphan_count():
return
rows = pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=code, limit=501)
if len(rows) >= 501:
raise ValueError('在途卖出过多,不能截断处理')
if rows:
return # 已有真实卖出先收尾,不叠加超卖,也不覆盖用户指令。
if current.get('exit_iid'):
prev = pms_repo.get_instruction(current['exit_iid'])
if not prev or prev.get('status') in ('CANCELLED', 'REJECTED'):
current.update(phase='MANUAL', reason='清仓安排已撤销、拒绝或无法核实,等待人工处理')
return
# 等所有回报入账后才确认清仓完成;迟到买入仍归本轮退出收尾。
qty = int(pos.get('total_qty') or 0)
if qty <= 0:
live_buy = pms_repo.list_instructions(statuses=list(LIVE), side='buy', ts_code=code, limit=1)
if not live_buy and not owned:
current.update(phase='CLOSED', closed_at=rules.stamp(now).isoformat())
return
blocker = execution_orders.correction_blocker(ts_code=code, side='sell')
if blocker:
raise RuntimeError(blocker)
seq = int(current.get('exit_seq') or 0) + 1
iid = f"RX_{current['round_id']}_{seq}"
user_stop = current.get('user_stop')
progress = {'is_command': bool(user_stop), 'urgent': True, 'from_signal': not bool(user_stop),
'risk_exit': {'round_id': current['round_id'], 'events': current['events'],
'review_exit': current.get('review_exit'), 'user_stop': user_stop},
'reason': current['reason'], 'children': [], 'deadline': str(now.date())}
if pms_repo.insert_instruction(instruction_id=iid, origin_type='system', origin_id='risk_exit',
ts_code=code, action='EXIT', side='sell', qty=qty, limit_price=None,
window_tdays=1, status='PROPOSED', progress=progress) != 1:
raise RuntimeError('清仓指令未成功落表')
_ledger(code, 'EXIT', current['reason'], progress['risk_exit'], iid)
current.update(phase='EXITING', exit_iid=iid, exit_seq=seq)
# 旧风控/目标价提议被新清仓覆盖,避免再被采纳为重复委托。
proposals = pms_repo.list_proposals(statuses=('WAIT_USER',), limit=501)
if len(proposals) >= 501:
raise ValueError('提议过多,不能完整清理退出冲突')
for p in proposals:
if p.get('ts_code') == code and p.get('action') in ('EXIT', 'TRIM', 'OPEN', 'FILL', 'ADD', 'DCA'):
if not pms_repo.decide_proposal(p['proposal_id'], 'EXPIRED'):
raise RuntimeError('清仓冲突提议未成功收尾')
result = execution_conflicts.enforce_exit(pms_repo.get_instruction(iid))
if not result.get('ok'):
raise RuntimeError('清仓已落表,买入侧仍待收尾')
def resume_buy(code):
"""仅响应用户明确恢复;清仓已启动时不能用恢复买入撤销卖出安排。"""
if not supported():
return
with rotation_repo.account_guard(), rotation_repo.locked(_key(code), KIND, {}) as state:
if not (enabled() or state.get('user_stop')):
return
if state.get('phase') in ('EXIT_PENDING', 'EXITING'):
raise ValueError('该股已进入清仓流程,请先处理清仓安排')
if state.get('phase') == 'MANUAL':
from app.repo import qmt_repo
if (pms_repo.list_instructions(statuses=list(LIVE), side='sell', ts_code=code, limit=1)
or qmt_repo.list_orders(ts_code=code, statuses=list(qmt_repo.LIVE), limit=1)
or qmt_repo.inbox_pending_count() or qmt_repo.inbox_orphan_count()):
raise ValueError('该股委托或回报仍待收尾,暂不能恢复买入')
if state:
state.update(phase='WATCH', count=0, reset_at=rules.stamp(datetime.now()).isoformat(), reason='用户明确恢复买入')
state.pop('exit_iid', None)
state.pop('user_stop', None)
from app.services import strategy_service
result = strategy_service.clear_buypause(code) or {}
if not result.get('ok'):
raise RuntimeError('用户恢复买入未保存,保留原暂停')
_ledger(code, 'SIGNAL', state['reason'], {'round_id': state['round_id'],
'reset_at': state['reset_at']}, state['round_id'])
def scan(*, now=None):
out = {'enabled': enabled(), 'reviews': {}, 'user_stops': {}, 'errors': []}
if not supported():
return out
now = now or datetime.now()
from app.services import logic_state_service
commands = _stop_commands()
# 人工止损不依赖模型资料可用;评析读取异常不阻断已记录的退出收尾。
try:
states = logic_state_service.state_map() if out['enabled'] 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)
for code in sorted(codes):
try:
command = commands.get(code)
if command and (command.get('params') or {}).get('price'):
from app.services import market
quote = market.execution_quote(code, now=now, limits={})
out['user_stops'][code] = observe_user_stop(code, quote, now=now)
except Exception as exc:
out['errors'].append(f'{code}人工止损: {type(exc).__name__}: {exc}')
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)
except Exception as exc:
out['errors'].append(f'{code}: {type(exc).__name__}: {exc}')
try:
drive(code, now=now)
except Exception as exc:
out['errors'].append(f'{code}退出收尾: {type(exc).__name__}: {exc}')
out['ok'] = not out['errors']
return out
def refresh_reviews(*, now=None):
"""在独立刷新任务中批量只读持仓评析;执行任务不等待外部请求或模型。"""
out = {'enabled': enabled(), 'ok': True, 'reviews': {}, 'errors': []}
if not out['enabled']:
return out
now = now or datetime.now()
current = rules.stamp(now)
from app.services import plan_feed
positions = pms_repo.list_positions(only_open=True)
codes = sorted({p['ts_code'] for p in positions if _code_ok(p['ts_code'])})
if not codes:
return out
if len(codes) > 200:
raise ValueError('持仓评级批量查询超过完整核验上限')
with rotation_repo.locked('risk-review-refresh:original', 'risk_review_refresh', {}) as state:
previous = rules.stamp(state.get('attempt_at'))
if previous and (current-previous).total_seconds() < param_store.get_int('PMS_RISK_REVIEW_REFRESH_SEC', 300):
return {**out, 'skipped': '尚未到持仓评析刷新时间'}
state['attempt_at'] = current.isoformat()
try:
states = plan_feed.fetch_logic_states(codes,
timeout=param_store.get_int('PMS_RISK_REVIEW_TIMEOUT_SEC', 3))
except Exception as exc:
out.update(ok=False, errors=[f'持仓评析补读失败,保留原评级:{type(exc).__name__}'])
return out
for code in codes:
try:
out['reviews'][code] = observe_review(code, (states.get(code) or {}).get('company_review'), now=now)
except Exception as exc:
out['errors'].append(f'{code}: {type(exc).__name__}: {exc}')
out['ok'] = not out['errors']
return out