补齐当日限制价并隔离采集与交易执行

This commit is contained in:
baobao 2026-11-03 16:24:44 +08:00
parent 76d7043e4c
commit 0b3c50ef34
25 changed files with 2210 additions and 12 deletions

View File

@ -3,6 +3,9 @@
__pycache__
*.pyc
.env
.env.*
!.env.example
backups/
logs
.DS_Store
# 开发代理的本地配置和嵌套工作树不进入运行镜像。

View File

@ -4,6 +4,10 @@
# 业务参数 (PMS_TOTAL_SCALE 等) 不必写在这里 —— settings.py 有初值,
# 上线后经管理页面调整并持久化到 pms_runtime_param 表。
# 限制价采集密钥PMS_TUSHARE_TOKEN必须仅写入专用.env.market-data,不要放进主.env。
# 该专用文件只由pms-market-data服务注入,不提交Git,也不放进镜像。
# 缓存消费和采集开关默认关闭,业务运行值经ParamStore维护。
# ---- 153 代理 (pms_* 全部表 + trading_* + strategy_daily_results, 严格单表访问) ----
PROXY_DB_URL=mysql+pymysql://用户:密码@192.168.16.153:3307/my_quant_db
@ -60,4 +64,4 @@ PMS_QMT_SIGN_SEED_HEX=
PMS_QMT_PEER_PUBKEY_B64=
PMS_QMT_WS_URL=ws://192.168.18.182:9443/pms
PMS_QMT_WS_URL=ws://192.168.18.182:9443/pms

3
.gitignore vendored
View File

@ -1,5 +1,8 @@
# 机密: 数据库/Redis 连接串与密码, 绝不入库 (服务器上手工维护, 参照 .env.example)
.env
.env.*
!.env.example
backups/
__pycache__/
*.pyc

View File

@ -2721,3 +2721,11 @@ PMS最终代码56db0fd已推送,155 web/WS/beat为execution-2b1c447,worker
15:38新v3快照50首选100候选、信号与名单就绪,数据11-02/执行11-03,frozen=false;11-04版待夜间数据,不回填早盘冻结。15:40确认1598996、最近160条连续、资金10.3秒、数量现金一致,无待入账和孤儿。已安排11-04 10:00一次性任务v3核验自然请求,未恢复长期观察。
现行交易所规则与源表核实后,日线计算评估为普通情形可行,但缺完整目标日公司行为与证券状态,不能作为唯一精确兜底。发现11-04已有明确除息个例,报价与名称资料陈旧,故本轮未将推算接入下单;保留正式当日限制价及逐票等待。该评估和真实数据日期、回退备份、当前参数及验证安排已写发布接续和决策台账。
## 2026-11-03 当日限制价独立采集代码完成
按用户批准方案实现155模拟PMS的独立采集、本地当日缓存和两个执行消费入口。实际Tushare单证券HTTPS可取得11月3日记录,逗号批量代码返回空,故采用逐票限速。目标覆盖原策略全部持仓、活动指令、在途、计划和建议,以及微盘完整100候选;入口排除北交所。查询共享gp_stk_limit的pre_close列存在,但11月2日实际样本为空,因此该票需要Tushare补全证据,不能冒充已完整校验。
新增缓存及采集开关默认关闭,密钥仅专用采集容器注入。价格严格校验、跨日失效、逐票隔离、重试退避、租约防并发、来源版本留痕均已实现;日线推算不进入下单。只读复核确认本次不需重建WS或beat,待发布目标为worker、web和新增采集进程。
开发机新增121项隔离检查通过,最终全量末行ALL SUITES PASS,日志/private/tmp/pms-limits-local-tests-release-20261103.log。审查补齐共享坏值重复退避、超时票饥饿、单票脏元数据及开关损坏四类边界。后续以已提交代码构建候选并完成155断网全量,再启动采集和核对实际覆盖;本条不代表已部署或自然交易判收。

View File

@ -106,6 +106,10 @@ def price_order(*, side, quote, now=None, user_limit=None, anchor_price=None, pa
value = float(price)
if not low <= value <= high:
return wait('用户边界或报价超出当日合法价格范围')
return {'action': 'FIRE', 'limit_price': value, 'reason': note,
result = {'action': 'FIRE', 'limit_price': value, 'reason': note,
'degraded': minute, 'quote_source': source, 'quote_as_of': at.isoformat(),
'quote_age_sec': age, 'anchor_price': anchor, 'user_limit': boundary or None}
if quote.get('limit_version'):
result.update(limit_source=quote.get('limit_source'), limit_version=quote['limit_version'],
limit_fetched_at=quote.get('limit_fetched_at'))
return result

153
app/core/price_limits.py Normal file
View File

@ -0,0 +1,153 @@
"""限制价主源的纯校验。只接受目标日沪深A股事实,不计算或补造价格。"""
from collections.abc import Mapping
from datetime import date, datetime
from decimal import Decimal, InvalidOperation, localcontext
import hashlib
import json
import re
MAX_ROWS = 6000
REQUIRED_FIELDS = ('trade_date', 'ts_code', 'pre_close', 'up_limit', 'down_limit')
_CENT = Decimal('0.01')
_SUPPORTED = re.compile(r'(?:60[0-9]{4}\.SH|68[0-9]{4}\.SH|00[0-9]{4}\.SZ|30[0-9]{4}\.SZ)')
_IDENTIFIABLE = re.compile(r'[0-9]{6}\.(?:SH|SZ|BJ)')
def supported(code):
"""仅规范化大小写与首尾空白,不猜测交易所,不包含北交所。"""
return isinstance(code, str) and _SUPPORTED.fullmatch(code.strip().upper()) is not None
def _result(error=None):
return {'records': {}, 'invalid': {}, 'errors': [error] if error else []}
def _day(value):
if isinstance(value, datetime):
return value.date().isoformat()
if isinstance(value, date):
return value.isoformat()
if isinstance(value, bool) or not isinstance(value, (str, int)):
raise ValueError('INVALID_DATE')
value = str(value).strip()
if re.fullmatch(r'[0-9]{8}', value):
value = value[:4]+'-'+value[4:6]+'-'+value[6:]
elif not re.fullmatch(r'[0-9]{4}-[0-9]{2}-[0-9]{2}', value):
raise ValueError('INVALID_DATE')
try:
return date.fromisoformat(value).isoformat()
except ValueError:
raise ValueError('INVALID_DATE') from None
def _price(value):
if isinstance(value, bool) or not isinstance(value, (str, int, float, Decimal)):
raise ValueError('INVALID_PRICE')
text = str(value).strip()
if not text or len(text) > 128:
raise ValueError('INVALID_PRICE')
try:
number = Decimal(text)
if not number.is_finite() or number < 0:
raise ValueError('INVALID_PRICE')
with localcontext() as context:
context.prec = 28
context.traps[InvalidOperation] = True
cents = number.quantize(_CENT)
if cents != number:
raise ValueError('INVALID_PRECISION')
return cents
except InvalidOperation:
raise ValueError('INVALID_PRICE') from None
def normalize_rows(rows, day, requested_codes=None):
"""返回可JSON序列化记录;坏票隔离,结构错误拒绝整批。
日期输出ISO格式,价格输出精确两位字符串。同票任何坏行都会隔离该票,
不能用另一条正确日期或正确价格的行掩盖。错误仅返回固定原因码。
"""
try:
target = _day(day)
except ValueError:
return _result('INVALID_TARGET_DATE')
if not isinstance(rows, (list, tuple)):
return _result('INVALID_ROWS')
if len(rows) > MAX_ROWS:
return _result('TOO_MANY_ROWS')
if any(not isinstance(row, Mapping) for row in rows):
return _result('INVALID_ROW_STRUCTURE')
allowed = None
if requested_codes is not None:
if not isinstance(requested_codes, (list, tuple, set, frozenset)):
return _result('INVALID_REQUESTED_CODES')
if any(not supported(code) for code in requested_codes):
return _result('INVALID_REQUESTED_CODES')
allowed = {code.strip().upper() for code in requested_codes} or None
result = _result()
records, invalid = result['records'], result['invalid']
for index, row in enumerate(rows):
raw_code = row.get('ts_code')
code = raw_code.strip().upper() if isinstance(raw_code, str) else ''
# 不回显任意上游文本;无法识别为证券代码时只记录行号。
key = code if _IDENTIFIABLE.fullmatch(code) else f'row:{index+1}'
reason = None
if not supported(code):
reason = 'OUT_OF_SCOPE' if _IDENTIFIABLE.fullmatch(code) else 'INVALID_CODE'
elif allowed is not None and code not in allowed:
reason = 'NOT_REQUESTED'
elif any(field not in row for field in REQUIRED_FIELDS):
reason = 'MISSING_FIELD'
else:
try:
if _day(row['trade_date']) != target:
raise ValueError('DATE_MISMATCH')
close, high, low = (_price(row[field]) for field in ('pre_close', 'up_limit', 'down_limit'))
if high == 0 or low == 0:
raise ValueError('UNSUPPORTED')
if close <= 0:
raise ValueError('INVALID_PRE_CLOSE')
if low >= high:
raise ValueError('INVALID_RANGE')
if not low <= close <= high:
raise ValueError('PRE_CLOSE_OUTSIDE_LIMITS')
record = {'trade_date': target, 'ts_code': code, 'pre_close': format(close, '.2f'),
'up_limit': format(high, '.2f'), 'down_limit': format(low, '.2f')}
digest = hashlib.sha256(json.dumps(record, sort_keys=True, ensure_ascii=False,
separators=(',', ':')).encode('utf-8')).hexdigest()
record['version'] = digest
if code in records and records[code] != record:
raise ValueError('DUPLICATE_CONFLICT')
if code not in invalid:
records[code] = record
except ValueError as exc:
reason = str(exc)
if reason:
records.pop(code, None)
invalid.setdefault(key, reason)
return result
def provider_decode(body, day, requested_codes=None):
"""校验Tushare JSON封套。HTTP状态由调用层检查,不输出msg或响应正文。"""
if not isinstance(body, Mapping) or type(body.get('code')) is not int:
return _result('INVALID_PROVIDER_RESPONSE')
if body['code'] != 0:
return _result('PROVIDER_ERROR')
data = body.get('data')
if not isinstance(data, Mapping):
return _result('INVALID_PROVIDER_DATA')
fields, items = data.get('fields'), data.get('items')
if (not isinstance(fields, list) or not fields
or any(not isinstance(field, str) or not field for field in fields)
or len(set(fields)) != len(fields)):
return _result('INVALID_PROVIDER_FIELDS')
if any(field not in fields for field in REQUIRED_FIELDS):
return _result('MISSING_PROVIDER_FIELDS')
if not isinstance(items, list):
return _result('INVALID_PROVIDER_ITEMS')
if len(items) > MAX_ROWS:
return _result('TOO_MANY_ROWS')
if any(not isinstance(item, (list, tuple)) or len(item) != len(fields) for item in items):
return _result('INVALID_PROVIDER_ITEM_STRUCTURE')
return normalize_rows([dict(zip(fields, item)) for item in items], day, requested_codes)

48
app/market_data_worker.py Normal file
View File

@ -0,0 +1,48 @@
"""当日限制价的独立采集入口,不启动Celery或QMT连接。"""
import logging
import re
import signal
from threading import Event
logger = logging.getLogger('pms.market_data_worker')
def _summary(result):
"""只保留固定摘要字段,源响应及异常正文不得进入进程日志。"""
if not isinstance(result, dict):
raise ValueError('采集摘要格式无效')
status = result.get('status')
status = status if isinstance(status, str) and re.fullmatch(r'[A-Za-z0-9_-]{1,48}', status) else 'unknown'
day = result.get('day')
day = day if isinstance(day, str) and re.fullmatch(r'\d{4}-\d{2}-\d{2}', day) else '-'
counts = []
for key in ('target_count', 'valid_count', 'missing_count', 'error_count'):
value = result.get(key)
counts.append(value if type(value) is int and value >= 0 else 0)
return status, day, *counts
def main():
from app.services import price_limit_collector
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(name)s %(message)s')
stopping = Event()
def stop(_signum, _frame):
stopping.set()
signal.signal(signal.SIGTERM, stop)
signal.signal(signal.SIGINT, stop)
while not stopping.is_set():
try:
result = price_limit_collector.run_once()
logger.info('限制价采集 status=%s day=%s target_count=%s valid_count=%s missing_count=%s error_count=%s',
*_summary(result))
except Exception as exc:
logger.warning('限制价采集失败:%s', type(exc).__name__)
stopping.wait(10)
if __name__ == '__main__':
main()

View File

@ -136,14 +136,22 @@ def execution_quote(code, now=None, limits=None):
except (ValueError, TypeError):
return {}
if limits is None:
rows = fetch_all('SELECT up_limit,down_limit FROM gp_stk_limit '
'WHERE trade_date=:day AND ts_code=:code',
{'day': current.date().isoformat(), 'code': code})
limits = rows[0] if rows else {}
if param_store.get_bool('PMS_LIMIT_CACHE_ENABLED', False):
from app.services import price_limits
limits = price_limits.get_limits(current.date(), [code]).get(code, {})
else:
rows = fetch_all('SELECT up_limit,down_limit FROM gp_stk_limit '
'WHERE trade_date=:day AND ts_code=:code',
{'day': current.date().isoformat(), 'code': code})
limits = rows[0] if rows else {}
return {'kind': 'minute', 'source': 'tushare:rt_min:1MIN',
'as_of': at.isoformat(), 'last': price, 'bid': None, 'ask': None,
'limit_up': (limits or {}).get('up_limit'),
'limit_down': (limits or {}).get('down_limit'), 'halted': None}
'limit_down': (limits or {}).get('down_limit'), 'halted': None,
'limit_source': (limits or {}).get('source') or ('gp_stk_limit' if
(limits or {}).get('up_limit') and (limits or {}).get('down_limit') else None),
'limit_version': (limits or {}).get('version'),
'limit_fetched_at': (limits or {}).get('fetched_at')}
# ================================================================ 参考位
def _shard_tables(months: int = 4) -> list:

View File

@ -36,10 +36,28 @@ INFRA_PREFIX = ("PROXY_DB", "SOURCE_DB", "DB_MYSQL", "SIGNAL_REDIS", "PMS_REDIS"
# 2026-09-03 补进会话票签名密钥 PMS_SESSION_SECRET: 它 2026-08 随登录一起加进 settings,
# 当时漏了这份名单, 于是参数设置页把它当普通业务参数原文显示出来 (登录中间件读的是
# settings, 功能没受影响, 但密钥不该出现在页面上)。
SECRET_KEYS = ("PMS_QMT_SIGN_SEED_HEX", "PMS_QMT_PEER_PUBKEY_B64", "PMS_SESSION_SECRET", "PMS_PLAN_WRITE_KEY")
SECRET_KEYS = ("PMS_QMT_SIGN_SEED_HEX", "PMS_QMT_PEER_PUBKEY_B64", "PMS_SESSION_SECRET", "PMS_PLAN_WRITE_KEY", "PMS_TUSHARE_TOKEN")
LIMIT_FLAGS = ('PMS_LIMIT_CACHE_ENABLED', 'PMS_LIMIT_COLLECT_ENABLED')
def _valid_limit_flag(value):
return isinstance(value, bool) or (type(value) in (str, int) and
str(value).strip().lower() in ('1', 'true', 'yes', 'on', 'y', '0', 'false', 'no', 'off', 'n'))
# 运行态开关: key -> (默认值, 类型, 说明)
RUNTIME_EXTRA = {
'PMS_LIMIT_CACHE_ENABLED': (False, bool, '执行报价读取已核实的当日限制价缓存;缺失时逐票等待'),
'PMS_LIMIT_COLLECT_ENABLED': (False, bool, '独立采集进程补齐目标证券的当日限制价,不生成交易指令'),
'PMS_LIMIT_FETCH_TIMEOUT_SEC': (5, int, '限制价来源单次请求超时,秒'),
'PMS_LIMIT_ROUND_BUDGET_SEC': (30, int, '每轮限制价HTTP采集阶段预算,秒'),
'PMS_LIMIT_ROUND_MAX_CODES': (25, int, '每轮最多请求的目标证券数'),
'PMS_LIMIT_MIN_REQUEST_INTERVAL_SEC': (1.2, float, '独立采集进程全部请求之间的最小间隔,秒'),
'PMS_LIMIT_RETRY_BASE_SEC': (60, int, '限制价采集失败后的首次退避秒数'),
'PMS_LIMIT_RETRY_MAX_SEC': (900, int, '限制价连续失败的最大退避秒数'),
'PMS_LIMIT_MAX_FAILURES_PER_DAY': (32, int, '每只证券每日最多连续失败次数,成功清零;达到后停止当天重试'),
'PMS_LIMIT_REFRESH_SEC': (900, int, '已有效限制价的再次核验间隔,秒'),
'PMS_LIMIT_COLLECT_START': ('08:55', str, '限制价采集开始时间,北京时间HH:MM;无效时不采集'),
'PMS_LIMIT_COLLECT_END': ('18:00', str, '限制价采集结束时间,北京时间HH:MM;仅交易日且日历可用时采集'),
'PMS_EXEC_REJECT_COOLDOWN_SEC': (60, int, '拒单后的首次退避秒数,不限制正常改价'),
'PMS_EXEC_REJECT_MAX_COOLDOWN_SEC': (900, int, '重复拒单退避最大秒数'),
'PMS_EXEC_REPRICE_ENABLED': (False, bool, '已授权委托按新鲜行情撤单确认后重挂;先发布上游执行依据接口'),
@ -186,6 +204,8 @@ RUNTIME_EXTRA = {
# 冷启、连库超时), 全局暂停买入、休假模式、组合刹车就一起静默解除, 且没有任何调用方
# 看得出这是降级。安全开关的默认方向必须是"拦", 不是"放"。
FAIL_CLOSED = {
"PMS_LIMIT_CACHE_ENABLED": True, # 无法确认开关时仍走严格本地缓存,不退到旧读取。
"PMS_LIMIT_COLLECT_ENABLED": False,
"PMS_GLOBAL_BUY_HALT": True, # 读不到 → 当作已暂停买入
"PMS_GLOBAL_EXEC_HALT": True, # 读不到 → 当作已暂停执行
# 自主新建仓的默认值是 full (无人值守地开新仓), 所以它读不到时的安全方向格外要紧:
@ -462,6 +482,8 @@ def get(key: str, default=None):
"宁可多拦一轮也不放行", key, _cache["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')):
return FAIL_CLOSED[key]
try:
return _coerce(rows[key]["param_value"], t)
except (TypeError, ValueError):
@ -510,6 +532,8 @@ 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()
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_"):
return {"ok": False, "error": f"参数 {key} 不可修改 (基础设施参数只在 .env 维护)"}
t = _type_of(key)
@ -531,6 +555,14 @@ def set_param(key: str, value, updated_by: str = "user") -> dict:
_RANGES = {
'PMS_LIMIT_FETCH_TIMEOUT_SEC': (1, 10),
'PMS_LIMIT_ROUND_BUDGET_SEC': (5, 60),
'PMS_LIMIT_ROUND_MAX_CODES': (1, 60),
'PMS_LIMIT_MIN_REQUEST_INTERVAL_SEC': (1, 10),
'PMS_LIMIT_RETRY_BASE_SEC': (30, 600),
'PMS_LIMIT_RETRY_MAX_SEC': (60, 3600),
'PMS_LIMIT_MAX_FAILURES_PER_DAY': (1, 100),
'PMS_LIMIT_REFRESH_SEC': (300, 7200),
'PMS_EXEC_REJECT_COOLDOWN_SEC': (1, 3600),
'PMS_EXEC_REJECT_MAX_COOLDOWN_SEC': (1, 86400),
'PMS_EXEC_BASIS_REFRESH_SEC': (0, 3600),

View File

@ -0,0 +1,250 @@
"""155模拟实例的独立限制价采集;不调用交易、研判或QMT动作。"""
import copy
import re
import time
import uuid
from datetime import datetime, timedelta
from config.settings import settings
from app.core import price_limits as core, tradedays
from app.core.execution_policy import local_now, timestamp
from app.db import session as db
from app.repo import rotation_repo as store
from app.services import param_store, price_limit_targets, price_limit_provider
from app.services.price_limits import day_key
LEASE_KEY = 'price-limits:collector'
LEASE_SECONDS = 300
TARGET_CAP = 1200
def _summary(status, day, targets=(), entries=None, errors=(), requests=0):
entries = entries or {}
errors = list(errors) + [c+': '+entries[c]['last_error'] for c in targets
if entries.get(c, {}).get('last_error')]
valid = sum(entries.get(c, {}).get('status') == 'VALID' for c in targets)
return {'status': status, 'day': day, 'target_count': len(targets),
'valid_count': valid, 'missing_count': len(targets)-valid,
'error_count': len(errors), 'errors': list(errors), 'requests': requests}
def _acquire(owner, now):
with store.locked(LEASE_KEY, 'price_limit_lease', {}) as lease:
until = timestamp(lease.get('until'))
if until and until > now:
return False
lease.update(owner=owner, until=(now+timedelta(seconds=LEASE_SECONDS)).isoformat())
return True
def _release(owner):
with store.locked(LEASE_KEY, 'price_limit_lease', {}) as lease:
if lease.get('owner') == owner:
lease.pop('owner', None)
lease.pop('until', None)
def _save(owner, document, now):
# 租约锁与缓存锁同一事务;不把HTTP或目标读取放进事务。
with store.locked(LEASE_KEY, 'price_limit_lease', {}) as lease:
until = timestamp(lease.get('until'))
if lease.get('owner') != owner or not until or now >= until:
return False
with store.locked(day_key(document['trade_date']), 'price_limits', {}) as value:
value.clear()
value.update(document)
return True
def _config():
p = param_store
return {'timeout': p.get_int('PMS_LIMIT_FETCH_TIMEOUT_SEC', 5),
'budget': p.get_int('PMS_LIMIT_ROUND_BUDGET_SEC', 30),
'max_codes': p.get_int('PMS_LIMIT_ROUND_MAX_CODES', 25),
'interval': p.get_float('PMS_LIMIT_MIN_REQUEST_INTERVAL_SEC', 1.2),
'retry_base': p.get_int('PMS_LIMIT_RETRY_BASE_SEC', 60),
'retry_max': p.get_int('PMS_LIMIT_RETRY_MAX_SEC', 900),
'max_failures': p.get_int('PMS_LIMIT_MAX_FAILURES_PER_DAY', 32),
'refresh': p.get_int('PMS_LIMIT_REFRESH_SEC', 900)}
def _failure(entry, reason, now, cfg, quarantine=False):
# 连接故障保留此前有效内容与原获取时间;确切坏值才撤销可执行资格。
entry['failures'] = min(100, int(entry.get('failures') or 0)+1)
entry['last_attempt'] = now.isoformat()
entry['last_error'] = reason
wait = min(cfg['retry_max'], cfg['retry_base'] * (2 ** min(entry['failures']-1, 10)))
entry['next_try'] = (now+timedelta(seconds=wait)).isoformat()
if quarantine or entry.get('status') != 'VALID':
entry['status'] = 'INVALID' if quarantine else 'MISSING'
def _accept(entry, record, source, now, cfg):
old = entry.get('record') or {}
if old and old.get('version') != record['version']:
history = entry.setdefault('revisions', [])
history.append({'record': old, 'source': entry.get('source'),
'fetched_at': entry.get('fetched_at'), 'superseded_at': now.isoformat()})
entry['revisions'] = history[-5:]
entry.update(status='VALID', record=record, source=source, fetched_at=now.isoformat(),
last_attempt=now.isoformat(), last_error='', failures=0,
next_try=(now+timedelta(seconds=cfg['refresh'])).isoformat())
def _shared_rows(day, codes):
if not codes:
return []
params = {'day': day}
params.update({f'c{i}': c for i, c in enumerate(codes)})
names = ','.join(':'+k for k in params if k != 'day')
return db.fetch_all('SELECT ts_code,trade_date,pre_close,up_limit,down_limit FROM gp_stk_limit '
'WHERE trade_date=:day AND ts_code IN ('+names+')', params)
def _reserve_request(owner, now, interval):
"""持久化限速水位;重建进程也不会立刻重复请求。"""
with store.locked(LEASE_KEY, 'price_limit_lease', {}) as lease:
until = timestamp(lease.get('until'))
if lease.get('owner') != owner or not until or now >= until:
return None
last = timestamp(lease.get('next_request_at'))
if last and last > now:
return (last-now).total_seconds()
lease['next_request_at'] = (now+timedelta(seconds=interval)).isoformat()
return 0.0
def run_once(now=None):
"""只采集实际北京日;now仅供隔离测试注入时钟,无历史补数入口。"""
current = local_now(now)
day = current.date().isoformat()
if settings.PMS_TABLE_PREFIX:
return _summary('UNAUTHORIZED_INSTANCE', day)
if not param_store.get_bool('PMS_LIMIT_COLLECT_ENABLED', False):
return _summary('DISABLED', day)
if tradedays.calendar_degraded(current.date()) or not tradedays.is_trade_day(current.date()):
return _summary('CALENDAR_WAIT', day)
try:
start = datetime.strptime(param_store.get('PMS_LIMIT_COLLECT_START', '08:55'), '%H:%M').time()
end = datetime.strptime(param_store.get('PMS_LIMIT_COLLECT_END', '18:00'), '%H:%M').time()
except (TypeError, ValueError):
return _summary('INVALID_WINDOW', day)
if not start <= current.time().replace(tzinfo=None) <= end:
return _summary('OUTSIDE_WINDOW', day)
owner = uuid.uuid4().hex
if not _acquire(owner, current):
return _summary('BUSY', day)
started = time.monotonic()
# 实际墙钟由单调时钟增量推进,测试也能准确覆盖跨日、租约和超时。
clock = lambda: current+timedelta(seconds=time.monotonic()-started)
try:
cfg = _config()
if not (1 <= cfg['timeout'] <= 10 and 5 <= cfg['budget'] <= 60 and
1 <= cfg['max_codes'] <= 60 and 1 <= cfg['interval'] <= 10 and
30 <= cfg['retry_base'] <= 600 and cfg['retry_base'] <= cfg['retry_max'] <= 3600 and
1 <= cfg['max_failures'] <= 100 and 300 <= cfg['refresh'] <= 7200):
return _summary('INVALID_CONFIG', day)
target_info = price_limit_targets.collect_targets(day)
all_codes = sorted({c for c in target_info['codes'] if core.supported(c)})
codes, errors = all_codes[:TARGET_CAP], list(target_info['errors'])
if len(all_codes) > TARGET_CAP:
errors.append('采集目标超过1200只,未覆盖部分保持等待')
previous, _ = store.get(day_key(day))
document = copy.deepcopy(previous) if isinstance(previous, dict) and previous.get('trade_date') == day else {}
document.update(trade_date=day, schema_version=1, targets=codes,
target_sources={c: target_info['sources'].get(c, []) for c in codes})
entries = document.get('entries')
if not isinstance(entries, dict):
entries = document['entries'] = {}
# 再校验已存值,损坏或异日内容不能靠VALID标记继续使用。
for code, entry in list(entries.items()):
if not core.supported(code) or not isinstance(entry, dict):
entries.pop(code, None)
continue
if type(entry.get('failures')) is not int or not 0 <= entry['failures'] <= 100:
entry['failures'] = 0
for field in ('next_try', 'last_attempt'):
stamp = timestamp(entry.get(field))
if not stamp or stamp.date().isoformat() != day:
entry.pop(field, None)
else:
entry[field] = stamp.isoformat()
if not isinstance(entry.get('revisions'), list):
entry['revisions'] = []
for field in ('last_error', 'shared_invalid_reason'):
reason = entry.get(field)
if reason and (not isinstance(reason, str) or not re.fullmatch('[A-Z_]{1,64}', reason)):
entry[field] = 'CACHE_META_INVALID'
if entry.get('status') == 'VALID':
checked = core.normalize_rows([entry.get('record')], day, [code])['records'].get(code)
if (not checked or checked['version'] != (entry.get('record') or {}).get('version')
or entry.get('source') not in ('gp_stk_limit', 'tushare.stk_limit')):
entry.update(status='INVALID', last_error='CACHE_INVALID', next_try=current.isoformat())
for code in codes:
entries.setdefault(code, {'status': 'MISSING', 'failures': 0})
try:
shared = core.normalize_rows(_shared_rows(day, codes), day, codes) if codes else {'records': {}, 'invalid': {}, 'errors': []}
errors.extend(shared['errors'])
for code, record in shared['records'].items():
entry = entries[code]
if entry.get('source') == 'tushare.stk_limit':
continue
if entry.get('status') != 'VALID' or (entry.get('record') or {}).get('version') != record['version']:
_accept(entry, record, 'gp_stk_limit', clock(), cfg)
entry.pop('shared_invalid_reason', None)
for code, reason in shared['invalid'].items():
if code in entries and entries[code].get('source') != 'tushare.stk_limit':
entry = entries[code]
# 相同坏值不在每轮重置退避;第一次仍允许直接向Tushare补齐。
if entry.get('shared_invalid_reason') != reason:
entry.update(status='INVALID', last_error=reason, next_try=current.isoformat())
entry['shared_invalid_reason'] = reason
except Exception:
errors.append('共享限制价读取失败')
# 没有采到过的票先查,避免前排失败长时间挤占后排。每票退避独立。
due = [c for c in codes if int(entries[c].get('failures') or 0) < cfg['max_failures']
and (timestamp(entries[c].get('next_try')) or current) <= clock()]
due.sort(key=lambda c: (entries[c].get('status') == 'VALID', entries[c].get('last_attempt') or '', c))
deadline = time.monotonic()+cfg['budget']
count = 0
if not settings.PMS_TUSHARE_TOKEN and due:
errors.append('采集密钥未配置')
else:
for code in due:
left = deadline-time.monotonic()
if count >= cfg['max_codes'] or left < 1 or clock().date().isoformat() != day:
break
delay = _reserve_request(owner, clock(), cfg['interval'])
if delay is None:
return _summary('LEASE_LOST', day, codes, entries, errors, count)
if delay:
if delay+1 > left:
break
time.sleep(delay)
delay = _reserve_request(owner, clock(), cfg['interval'])
if delay is None or delay > 0:
break
result = price_limit_provider.fetch_limit(code, day, settings.PMS_TUSHARE_TOKEN,
timeout_sec=min(cfg['timeout'], max(1, deadline-time.monotonic())))
count += 1
at = clock()
if at.date().isoformat() != day or time.monotonic() > deadline:
_failure(entries[code], 'ROUND_TIMEOUT', at, cfg)
errors.append('本轮采集超时,迟到响应未采纳')
break
entry = entries[code]
if code in result['records']:
_accept(entry, result['records'][code], 'tushare.stk_limit', at, cfg)
else:
invalid = result.get('invalid') or {}
reason = invalid.get(code) or (result['errors'][0] if result['errors'] else ('UNEXPECTED_SECURITY' if invalid else 'NOT_PUBLISHED'))
_failure(entry, reason, at, cfg, quarantine=bool(invalid))
end_at = clock()
summary = _summary('COMPLETE' if not errors and all(entries[c].get('status') == 'VALID' and not entries[c].get('last_error') for c in codes) else 'PARTIAL',
day, codes, entries, errors, count)
document.update(last_round_at=end_at.isoformat(), last_summary=summary)
if end_at.date().isoformat() != day or not _save(owner, document, end_at):
return _summary('LEASE_LOST', day, codes, entries, errors, count)
return summary
finally:
_release(owner)

View File

@ -0,0 +1,109 @@
"""单证券限制价主源。只访问固定地址,不重试、不输出凭据或响应正文。
Timeout.total 限定一次 HTTP 连接/读取的超时预算;流式读取还会检查单调时钟。
DNS 解析及两次流块之间的阻塞不保证被总预算中断,因此这不是绝对墙钟期限。
整轮预算、重试和退避由采集任务负责,执行报价路径只读本地缓存。
"""
import json
import math
import time
import requests
from urllib3.exceptions import TimeoutError as TransportTimeout
from urllib3.util import Timeout
from app.core import price_limits
ENDPOINT = 'https://api.tushare.pro'
FIELDS = 'ts_code,trade_date,pre_close,up_limit,down_limit'
MAX_BODY_BYTES = 64 * 1024
def _error(reason):
return {'records': {}, 'invalid': {}, 'errors': [reason]}
def fetch_limit(code, day, token, timeout_sec=5):
"""查询指定交易日的一只沪深证券;所有失败仅返回固定原因码。"""
if not price_limits.supported(code):
return _error('INVALID_REQUEST_CODE')
code = code.strip().upper()
try:
target = price_limits._day(day)
except (TypeError, ValueError):
return _error('INVALID_TARGET_DATE')
if not isinstance(token, str) or not token.strip():
return _error('MISSING_PROVIDER_TOKEN')
if isinstance(timeout_sec, bool):
return _error('INVALID_HTTP_TIMEOUT')
try:
budget = float(timeout_sec)
except (TypeError, ValueError, OverflowError):
return _error('INVALID_HTTP_TIMEOUT')
if not math.isfinite(budget) or budget <= 0:
return _error('INVALID_HTTP_TIMEOUT')
session = response = None
deadline = time.monotonic() + budget
try:
session = requests.Session()
# 不读取环境代理、.netrc 或环境 CA 设置,凭据只发往固定 HTTPS 地址。
session.trust_env = False
response = session.post(ENDPOINT, json={
'api_name': 'stk_limit', 'token': token.strip(),
'params': {'ts_code': code, 'trade_date': target.replace('-', '')},
'fields': FIELDS,
}, headers={'Accept': 'application/json', 'Accept-Encoding': 'identity'},
allow_redirects=False, stream=True,
timeout=Timeout(total=budget, connect=min(2., budget), read=budget))
if time.monotonic() >= deadline:
return _error('HTTP_TIMEOUT')
if response.status_code != 200:
return _error('HTTP_ERROR')
declared = response.headers.get('Content-Length')
if declared is not None:
try:
length = int(declared)
except (TypeError, ValueError, OverflowError):
return _error('INVALID_PROVIDER_RESPONSE')
if length < 0:
return _error('INVALID_PROVIDER_RESPONSE')
if length > MAX_BODY_BYTES:
return _error('RESPONSE_TOO_LARGE')
body = bytearray()
for chunk in response.iter_content(chunk_size=4096):
if time.monotonic() >= deadline:
return _error('HTTP_TIMEOUT')
if not isinstance(chunk, bytes):
return _error('INVALID_PROVIDER_RESPONSE')
if len(body) + len(chunk) > MAX_BODY_BYTES:
return _error('RESPONSE_TOO_LARGE')
body.extend(chunk)
if time.monotonic() >= deadline:
return _error('HTTP_TIMEOUT')
try:
decoded = json.loads(body)
# 永远传非空单代码白名单,不能借空集合放开到全市场。
result = price_limits.provider_decode(decoded, target, requested_codes=[code])
except Exception:
return _error('INVALID_PROVIDER_RESPONSE')
if time.monotonic() >= deadline:
return _error('HTTP_TIMEOUT')
return result
except (requests.exceptions.Timeout, TransportTimeout):
return _error('HTTP_TIMEOUT')
except requests.exceptions.ConnectionError as exc:
# requests 的流式读取会把 urllib3 读超时包装成 ConnectionError。
if any(isinstance(cause, TransportTimeout) for cause in exc.args):
return _error('HTTP_TIMEOUT')
return _error('HTTP_ERROR')
except Exception:
# Requests 异常可包含URL、请求信息或上游正文,禁止回显和记完整日志。
return _error('HTTP_ERROR')
finally:
for resource in (response, session):
if resource is not None:
try:
resource.close()
except Exception:
pass # 清理异常不覆盖固定错误结果,也不输出潜在凭据。

View File

@ -0,0 +1,132 @@
"""独立采集进程的限制价目标清单。只读资料,不授权交易或写入业务状态。
监控读取复用 rotation_service.pull,HTTP 连接和读取超时分别为 3、15 秒。
本函数不得在下单事务或账户锁内调用。未冻结快照只用于预取限制价,
实际轮换仍须执行原有的冻结、信号、资金和权限校验。
"""
import datetime as dt
import re
from app.core import micro_rotation, strategy_book as books
from app.repo import pms_repo, qmt_repo, rotation_repo
from app.services import rotation_service
SOURCE_CAP = 5000
# 仓储 recent 自身最多返回 1000 行,不能按 5000 行误判为读取完整。
SNAPSHOT_CAP = 1000
LIVE = ('PROPOSED', 'RULE_PASSED', 'JUDGE_PASSED', 'DISPATCHED', 'WAIT_REVIEW')
def collect_targets(day):
"""返回证券、逐来源错误和来源名;一个来源失败不丢弃其他已知证券。"""
day = day.isoformat() if isinstance(day, dt.date) and not isinstance(day, dt.datetime) else day
try:
if not isinstance(day, str) or not re.fullmatch(r'\d{4}-\d{2}-\d{2}', day):
raise ValueError('date')
dt.date.fromisoformat(day)
except (TypeError, ValueError):
return {'codes': [], 'errors': ['目标交易日格式无效'], 'sources': {}}
sources, errors = {}, []
def error(reason):
if reason not in errors:
errors.append(reason)
def add(code, name):
code = code.strip().upper() if isinstance(code, str) else ''
if micro_rotation.mainland_code(code):
sources.setdefault(code, set()).add(name)
def read(name, loader, cap=SOURCE_CAP):
try:
rows = loader()
except Exception:
error(name+'读取失败')
return []
if not isinstance(rows, list):
error(name+'记录格式异常')
return []
if len(rows) >= cap:
error(name+'达到读取上限,结果可能不完整')
return rows[:cap]
with books.scope('all'):
loaders = (
('策略持仓', lambda: pms_repo.list_positions(only_open=True)),
('待执行指令', lambda: pms_repo.list_instructions(statuses=LIVE, limit=SOURCE_CAP)),
('QMT在途委托', lambda: qmt_repo.list_orders(statuses=qmt_repo.LIVE, limit=SOURCE_CAP)),
('执行计划', lambda: pms_repo.list_plans(statuses=('PENDING', 'GATED', 'EXECUTING'), limit=SOURCE_CAP)),
('交易建议', lambda: pms_repo.list_proposals(statuses=('WAIT_USER', 'ACCEPTED'), limit=SOURCE_CAP)),
)
for name, loader in loaders:
for row in read(name, loader):
if not isinstance(row, dict) or 'ts_code' not in row:
error(name+'记录格式异常')
continue
add(row['ts_code'], name)
try:
state, _ = rotation_repo.get('state:live')
rotation = (state or {}).get('rotation') or {}
targets = rotation.get('target') or []
if not isinstance(targets, list):
raise ValueError('target')
if len(targets) >= SOURCE_CAP:
error('微盘执行目标达到读取上限,结果可能不完整')
for code in targets[:SOURCE_CAP]:
add(code, '微盘执行目标')
except Exception:
error('微盘执行目标读取失败')
try:
config = rotation_service.configuration()
rule = config['rule_version']
pool_size = config.get('candidate_pool_size', 100)
micro_rotation.rule_parameters(rule, pool_size)
except Exception:
error('微盘运行规则读取失败')
config = None
def snapshot_codes(value, name):
if not isinstance(value, dict):
error(name+'记录格式异常')
return
# effective_date 是既有快照的执行日字段;历史日期和历史规则不参与本次采集。
if value.get('effective_date') != day or value.get('rule_version') != rule:
return
try:
issues = micro_rotation.snapshot_check(value, day, require_frozen=False,
expected_rule=rule, candidate_pool_size=pool_size)
except Exception:
issues = ['invalid']
if issues:
error(name+'校验未通过')
return
if not value.get('basket_ready'):
error(name+'名单尚未就绪')
return
members = value['candidates'] if rule == micro_rotation.EXECUTION_RULE else value['members']
for member in members:
add(member['code'], name)
if config is not None:
for row in read('近期微盘快照', lambda: rotation_repo.recent('snapshot', limit=SNAPSHOT_CAP), SNAPSHOT_CAP):
snapshot_codes(row.get('value') if isinstance(row, dict) else None, '微盘保存快照')
if not config.get('url'):
error('微盘监控地址未配置')
else:
try:
value = rotation_service.pull(day)
except Exception:
error('微盘监控快照读取失败')
else:
if not isinstance(value, dict) or value.get('effective_date') != day or value.get('rule_version') != rule:
error('微盘监控快照日期或规则不符')
else:
snapshot_codes(value, '微盘监控快照')
codes = sorted(sources)
return {'codes': codes, 'errors': errors,
'sources': {code: sorted(sources[code]) for code in codes}}

View File

@ -0,0 +1,62 @@
"""执行限制价的本地只读入口,不调用外部行情接口。"""
from app.core import price_limits as core
from app.core.execution_policy import timestamp, local_now
from app.db import session as db
from app.repo import rotation_repo as store
from app.services import param_store
SOURCES = ('gp_stk_limit', 'tushare.stk_limit')
def day_key(day):
return 'price-limits:' + core._day(day)
def read_cache(day):
"""坏缓存按无值处理;执行读取不更新缓存、不延长有效日期。"""
target = core._day(day)
value, _ = store.get(day_key(target))
if not isinstance(value, dict) or value.get('trade_date') != target:
return {}
entries = value.get('entries')
if not isinstance(entries, dict):
return {}
valid = {}
for code, entry in entries.items():
if not core.supported(code) or not isinstance(entry, dict):
continue
record = entry.get('record')
if entry.get('status') != 'VALID' or entry.get('source') not in SOURCES or not entry.get('fetched_at'):
continue
fetched = timestamp(entry['fetched_at'])
if not fetched or fetched.date().isoformat() != target or fetched > local_now():
continue
result = core.normalize_rows([record], target, [code])
normalized = result['records'].get(code)
if normalized and normalized['version'] == (record or {}).get('version'):
valid[code] = dict(normalized, source=entry['source'], fetched_at=entry['fetched_at'])
return valid
def get_limits(day, codes=None):
"""开关开启后只读本实例当日缓存;失败不混用其他日期或推算来源。"""
day = core._day(day)
wanted = None if codes is None else {str(c).strip().upper() for c in codes if core.supported(c)}
if wanted == set():
return {}
if param_store.get_bool('PMS_LIMIT_CACHE_ENABLED', False):
try:
result = read_cache(day)
except Exception:
return {}
return {c: r for c, r in result.items() if wanted is None or c in wanted}
# 关闭新功能时保留原有数据路径,但在读取入口限定沪深证券。
params = {'day': day}
where = ''
if wanted is not None:
params.update({f'c{i}': c for i, c in enumerate(sorted(wanted))})
where = ' AND ts_code IN (' + ','.join(':'+k for k in params if k != 'day') + ')'
else:
where = " AND (ts_code LIKE '60____.SH' OR ts_code LIKE '68____.SH' OR ts_code LIKE '00____.SZ' OR ts_code LIKE '30____.SZ')"
rows = db.fetch_all('SELECT ts_code,up_limit,down_limit FROM gp_stk_limit WHERE trade_date=:day'+where, params)
return {r['ts_code']: r for r in rows if core.supported(r.get('ts_code'))}

View File

@ -253,8 +253,12 @@ def _quote(code, now):
def _limits(day):
if param_store.get_bool('PMS_LIMIT_CACHE_ENABLED', False):
from app.services import price_limits
return price_limits.get_limits(day)
from app.db import session as db
rows = db.fetch_all('SELECT ts_code,up_limit,down_limit FROM gp_stk_limit WHERE trade_date=:day', {'day': day})
rows = db.fetch_all('SELECT ts_code,up_limit,down_limit FROM gp_stk_limit WHERE trade_date=:day '
"AND (ts_code LIKE '60____.SH' OR ts_code LIKE '68____.SH' OR ts_code LIKE '00____.SZ' OR ts_code LIKE '30____.SZ')", {'day': day})
return {r['ts_code']: r for r in rows}

View File

@ -17,6 +17,22 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
# 当日限制价缓存与独立采集。业务开关和预算统一从ParamStore读取。
PMS_LIMIT_CACHE_ENABLED: bool = False
PMS_LIMIT_COLLECT_ENABLED: bool = False
PMS_LIMIT_FETCH_TIMEOUT_SEC: int = 5
PMS_LIMIT_ROUND_BUDGET_SEC: int = 30
PMS_LIMIT_ROUND_MAX_CODES: int = 25
PMS_LIMIT_MIN_REQUEST_INTERVAL_SEC: float = 1.2
PMS_LIMIT_RETRY_BASE_SEC: int = 60
PMS_LIMIT_RETRY_MAX_SEC: int = 900
PMS_LIMIT_MAX_FAILURES_PER_DAY: int = 32
PMS_LIMIT_REFRESH_SEC: int = 900
PMS_LIMIT_COLLECT_START: str = "08:55"
PMS_LIMIT_COLLECT_END: str = "18:00"
# 密钥只由采集容器专用.env.market-data注入,不得写入共享.env或ParamStore。
PMS_TUSHARE_TOKEN: str = ""
# 异步研判与委托报价;业务运行值统一从ParamStore读取。
PMS_EXEC_REJECT_COOLDOWN_SEC: int = 60
PMS_EXEC_REJECT_MAX_COOLDOWN_SEC: int = 900

View File

@ -9,10 +9,11 @@
# PMS_WEB_PORT_HOST=38200 → 页面宿主机端口 (容器内固定 38100, 不用改)
# COMPOSE_PROJECT_NAME=pms-real → compose 项目名 (网络/卷前缀), docker 原生支持
# 这些键进容器环境也无害: settings 是 extra="ignore", 不声明就当不存在。
# 三组服务:
# 四组服务:
# 默认 pms-web 管理页面 (38100)
# --profile sched pms-beat / pms-worker Celery 调度与执行
# --profile ws pms-ws QMT WebSocket 常驻连接 (协议 V1.0)
# --profile market-data pms-market-data 独立限制价采集,不接交易通道
#
# pms-ws 与 worker 的关系: worker 里的 executor 把待发委托写进 pms_qmt_order 出口表,
# pms-ws 亚秒轮询取走并发出。两者**只经数据库耦合**, 谁先起谁后起都不影响 —— pms-ws 没起
@ -68,6 +69,27 @@ services:
profiles: ["sched"]
command: celery -A app.scheduler.celery_app worker -l info -c 2
# 独立单进程采集,专用密钥不注入其他服务。不要扩副本或同时启动第二个采集入口。
pms-market-data:
<<: *pms-base
container_name: ${PMS_STACK_PREFIX:-}pms-market-data
profiles: ["market-data"]
env_file:
- .env
- path: .env.market-data
required: false
command: python -m app.market_data_worker
volumes: []
cpus: 0.5
mem_limit: 256m
read_only: true
tmpfs:
- /tmp:size=16m,mode=1777
cap_drop: [ALL]
security_opt: ["no-new-privileges:true"]
stop_grace_period: 60s
stop_signal: SIGTERM
# QMT WebSocket 常驻连接。协议 §1 规定 PMS 只开一条连接 (多开会让指令乱序),
# 所以这个服务**绝不能扩副本** —— 不要 deploy.replicas, 不要 docker compose up --scale。
# 退出流程见 app/ws/runner.py 的 _shutdown: 刷水位 → 最后一次 ack → 关连接 → 清心跳,

View File

@ -13,7 +13,7 @@
| 宏观价量网格、同步形成与日线趋势 | [宏观网格研究接续](宏观网格研究接续_2026-10-29.md),含三因素增量、八幅研究图、各风格与数据末日区间判断 |
| 筹码断档、套牢盘与吸筹次数(已结束) | [研究归档](筹码断档与吸筹研究接续_2026-10-30.md),用户决定不再继续;历史数据口径不代表现行研究范围 |
| PMS通用迁移与既有修复 | [开发接续](开发接续_2026-10-12.md),按主题查对应节;旧时点未完成项可能已有后续结论 |
| 盘中改价、异步研判与微盘递补发布 | [执行链路发布接续](执行报价与异步研判发布接续_2026-11-03.md),区分部署、开关与自然判收;[实施规格](执行报价与异步研判实施规格_2026-11-03.md) |
| 盘中改价、异步研判与微盘递补发布 | [执行链路发布接续](执行报价与异步研判发布接续_2026-11-03.md),区分部署、开关与自然判收;[实施规格](执行报价与异步研判实施规格_2026-11-03.md);[当日限制价采集边界](当日限制价采集边界_2026-11-03.md) |
| 架构与接口 | [README模块地图](../README.md)、[总体设计](../POSITION_MGMT_DESIGN.md);改接口再读[QMT协议](../QMT_WS_PROTOCOL.md)、[bionic接口](../BIONIC_PMS_INTERFACE.md)或[计划接口](../UPSTREAM_PLAN_API.md) |
| 后端、前端、测试、研究 | [后端规则](../app/AGENTS.md)、[页面规则](../app/web/AGENTS.md)、[脚本规则](../scripts/AGENTS.md)、[研究规则](../research/AGENTS.md),仅选择所涉及目录 |
| 部署与运行核验 | [pms-release](../.agents/skills/pms-release/SKILL.md);命令目录为`make help`,并非所有目标都是只读 |

View File

@ -0,0 +1,29 @@
# 当日限制价采集边界
本方案在2026年11月3日经用户同意实施,只部署155模拟PMS。盘中改价、微盘v3和异步研判已开启;此次补齐执行所需的当日价格边界,不修改交易授权、数量或策略资格。
## 数据来源和作用范围
独立采集进程先读取目标股票在gp_stk_limit的当日记录,再用Tushare stk_limit补齐缺失值。2026年11月3日实测HTTPS单票查询有当日数据,逗号连接两只证券会返回空,因此只按单票请求,并统一限速。只收集沪深A股的实际持仓、未完成指令、在途委托、待执行计划、待确认或已采纳建议、当前微盘目标及当前规则的完整候选池;入口排除北交所。
日线计算只作为后续辅助核对的研究方向,本次不产生可下单的推算限制价,不使用复权昨收、昨日涨跌停价或大模型价格区间替代正式当日数据。缺限制价不是停牌,也不成为微盘递补理由。
## 校验与缓存
每条记录绑定证券、交易日期、原始昨收、涨停价、跌停价、内容摘要、来源及实际获取时间。检查日期一致、价格有限且为有效分位、上下限关系、重复冲突和来源范围。零上下限或不支持的无限价情形保留等待。结构异常拒绝该次响应;同票异常隔离该票,不污染其他证券。
数据保存到本实例既有pms_rotation_document的price_limits文档,按交易日隔离。采集只写该自有缓存及采集租约,不改共享gp_stk_limit,不改账本、队列、快照冻结时间或委托。执行链只读取本地缓存,绝不临时请求Tushare。跨日自然失效;同日连接故障保留此前有效记录及原获取时间,有明确坏值或冲突证据则隔离该票。来源发生修订保留前一摘要与修订时间。
## 及时性和故障边界
新增独立pms-market-data进程,不使用Celery交易worker或模型队列,不建立QMT连接。默认交易日08:55至18:00运行,日历不可确认时不采集。每轮HTTP预算30秒、最多25只,单次5秒、两请求至少1.2秒;每10秒重新检查。缺失或失败逐票按60秒起、最多900秒退避,每票每日连续失败最多32次;有效记录每900秒复核。业务参数统一通过ParamStore读取。
单次网络超时与流式截止共同限制等待,但操作系统DNS等底层阻塞不能声称绝对墙钟保证。进程独立和有限租约保证此类异常不会占用交易任务;采集返回后再检查租约与截止,过期执行者不能覆盖后来结果。各来源读取异常明确记录,已有其他目标继续采集;达到读取上限报告不完整,不能伪称全覆盖。
一只缺数据只让该票WAIT,其他证券继续。若整个微盘篮子都没有可执行买入条件,沿用既有“不先卖原仓筹资”的保护。停止采集或回退时保留已有缓存、账本与回报;缓存开关关闭退回原来的当日gp_stk_limit读取,不会开启推算兜底。
## 密钥与发布
Tushare密钥只注入独立采集容器的私有.env.market-data,登记SECRET_KEYS;不进入主.env、ParamStore、页面、日志、镜像或Git。使用固定HTTPS地址,关闭重定向和环境代理,不输出响应正文或上游错误消息。155专用环境文件另外为采集进程的数据库连接设置5秒读写超时,不更改其他服务连接配置。专用文件缺失时不影响默认服务编排;采集无密钥会明确报告缺配置。
先完成开发机离线测试和候选镜像断网全量回归,再按实际消费关系定向重建155服务并启动采集。先检查当日目标覆盖,再开启本地缓存读取;数据未齐明确记录,不用虚假数据冒充判收。明日一次性核验自然08:50冻结、当日候选限制价、真实异步请求与超时结果;没有自然事件就保留未判收。

View File

@ -6,6 +6,9 @@
test_batch54_units.py 用户候选来源、到期核验、权限、显式取用与技术面补读 (9例)
新增限制价采集专项:core 25例、provider 21例、targets 18例、collector 28例,
缓存消费23例、独立进程入口6例。
包含 (例数按 2026-10-26 隔离回归实跑校正):
test_batch57_units.py 异步请求持久化、截止时间、旧结果隔离、失败续查、真实调度入口及行情来源 (24例)
test_batch56_units.py 微盘v3冻结候选、按序递补与部分成交保护 (40例)
@ -189,7 +192,10 @@ import sys
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SUITES = ["test_batch54_units.py",
SUITES = ["test_price_limits_core.py", "test_price_limit_provider.py",
"test_price_limit_targets.py", "test_price_limit_collector.py",
"test_price_limit_cache.py", "test_market_data_worker.py",
"test_batch54_units.py",
"test_sim_reset_units.py",
"test_batch53_units.py",
"test_batch52_units.py",

View File

@ -0,0 +1,99 @@
import unit_test_guard
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
import signal
import types
import unittest
from unittest.mock import patch, Mock
from app import market_data_worker as worker
from app import services
from app.services import param_store
from config.settings import settings
class WorkerChecks(unittest.TestCase):
def test_invalid_limit_flags_fail_closed_without_database_write(self):
rows = {key: {'param_value': 'invalid'} for key in param_store.LIMIT_FLAGS}
with patch.object(param_store, 'refresh', return_value=rows), \
patch.object(param_store.pms_repo, 'set_param') as write:
self.assertTrue(param_store.get_bool('PMS_LIMIT_CACHE_ENABLED'))
self.assertFalse(param_store.get_bool('PMS_LIMIT_COLLECT_ENABLED'))
self.assertFalse(param_store.set_param('PMS_LIMIT_CACHE_ENABLED', 'invalid')['ok'])
write.assert_not_called()
def test_shutdown_finishes_current_round_and_does_not_run_again(self):
callbacks = {}
event = Mock()
stopped = [False]
event.is_set.side_effect = lambda: stopped[0]
event.set.side_effect = lambda: stopped.__setitem__(0, True)
module = types.ModuleType('app.services.price_limit_collector')
def run():
callbacks[signal.SIGTERM](signal.SIGTERM, None)
return {'status':'done','day':'2026-11-03','target_count':3,'valid_count':2,'missing_count':1,'error_count':0,
'private':'must-not-log'}
module.run_once = Mock(side_effect=run)
with patch.object(services,'price_limit_collector',module,create=True), \
patch.object(worker,'Event',return_value=event), \
patch.object(worker.signal,'signal',side_effect=lambda name,callback: callbacks.__setitem__(name,callback)), \
patch.object(worker.logging,'basicConfig'), self.assertLogs(worker.logger,level='INFO') as logs:
worker.main()
module.run_once.assert_called_once_with()
event.wait.assert_called_once_with(10)
self.assertIn(signal.SIGINT,callbacks)
self.assertNotIn('must-not-log',str(logs.output))
self.assertIn('missing_count=1',str(logs.output))
def test_failure_logs_type_only_and_next_round_runs(self):
module = types.ModuleType('app.services.price_limit_collector')
module.run_once = Mock(side_effect=[RuntimeError('private token and address'), {'status':'done'}])
event = Mock()
event.is_set.side_effect = [False,False,True]
with patch.object(services,'price_limit_collector',module,create=True), \
patch.object(worker,'Event',return_value=event), \
patch.object(worker.signal,'signal'), patch.object(worker.logging,'basicConfig'), \
self.assertLogs(worker.logger,level='INFO') as logs:
worker.main()
self.assertEqual(module.run_once.call_count,2)
self.assertEqual(event.wait.call_count,2)
self.assertIn('RuntimeError',str(logs.output))
self.assertNotIn('private token',str(logs.output))
def test_summary_rejects_unsanitized_fields(self):
value=worker._summary({'status':{'token':'secret'},'day':'secret',
'target_count':'secret','valid_count':True,'missing_count':-1,'error_count':4})
self.assertEqual(value,('unknown','-',0,0,0,4))
with self.assertRaises(ValueError):worker._summary([])
def test_token_is_environment_only_and_absent_from_snapshot(self):
self.assertEqual(settings.PMS_TUSHARE_TOKEN,'')
self.assertIn('PMS_TUSHARE_TOKEN',param_store.SECRET_KEYS)
self.assertNotIn('PMS_TUSHARE_TOKEN',param_store.RUNTIME_EXTRA)
self.assertNotIn('PMS_TUSHARE_TOKEN',param_store._editable_keys())
with patch.object(param_store,'refresh',return_value={}) as refresh:
self.assertEqual(param_store.get('PMS_TUSHARE_TOKEN'),'')
refresh.assert_not_called()
self.assertNotIn('PMS_TUSHARE_TOKEN',{p['key'] for p in param_store.snapshot()['params']})
self.assertFalse(param_store.set_param('PMS_TUSHARE_TOKEN','private')['ok'])
def test_defaults_types_ranges_and_collection_window(self):
expected={'PMS_LIMIT_CACHE_ENABLED':(False,None),'PMS_LIMIT_COLLECT_ENABLED':(False,None),
'PMS_LIMIT_FETCH_TIMEOUT_SEC':(5,(1,10)), 'PMS_LIMIT_ROUND_BUDGET_SEC':(30,(5,60)),
'PMS_LIMIT_ROUND_MAX_CODES':(25,(1,60)), 'PMS_LIMIT_MIN_REQUEST_INTERVAL_SEC':(1.2,(1,10)),
'PMS_LIMIT_RETRY_BASE_SEC':(60,(30,600)), 'PMS_LIMIT_RETRY_MAX_SEC':(900,(60,3600)),
'PMS_LIMIT_MAX_FAILURES_PER_DAY':(32,(1,100)), 'PMS_LIMIT_REFRESH_SEC':(900,(300,7200)),
'PMS_LIMIT_COLLECT_START':('08:55',None),'PMS_LIMIT_COLLECT_END':('18:00',None)}
for key,(default,bounds) in expected.items():
self.assertEqual(getattr(settings,key),default)
self.assertEqual(param_store.RUNTIME_EXTRA[key][:2],(default,type(default)))
if bounds:
self.assertEqual(param_store._RANGES[key],bounds)
lo,hi=bounds
self.assertIsNone(param_store._range_check(key,lo))
self.assertIsNone(param_store._range_check(key,hi))
self.assertIsNotNone(param_store._range_check(key,lo-1))
self.assertIsNotNone(param_store._range_check(key,hi+1))
if __name__=='__main__':unittest.main()

View File

@ -0,0 +1,237 @@
"""限制价缓存及普通、微盘消费入口的隔离回归。无外部访问或状态写入。"""
import unit_test_guard # noqa: F401
import contextlib
import copy
from datetime import datetime, timedelta
from pathlib import Path
import sys
import unittest
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
import requests
from app.core import price_limits as core, execution_policy as policy
from app.services import price_limits as cache, market, rotation_service, param_store
DAY = '2026-11-03'
NOW = datetime(2026, 11, 3, 10, 0, tzinfo=policy.BEIJING)
A, B, BJ = '600000.SH', '000001.SZ', '920001.BJ'
def record(code=A, day=DAY, high='11.00'):
value = {'ts_code': code, 'trade_date': day, 'pre_close': '10.00',
'up_limit': high, 'down_limit': '9.00'}
return core.normalize_rows([value], day)['records'][code]
def entry(code=A, **changes):
return {'status': 'VALID', 'source': 'tushare.stk_limit',
'fetched_at': (NOW-timedelta(minutes=5)).isoformat(), 'record': record(code), **changes}
class PriceLimitCacheTests(unittest.TestCase):
def setUp(self):
self.stack = contextlib.ExitStack()
self.addCleanup(self.stack.close)
self.enabled = True
self.value = {'trade_date': DAY, 'entries': {A: entry(), B: entry(B)}}
self.stack.enter_context(patch.object(cache, 'local_now', return_value=NOW))
self.stack.enter_context(patch.object(param_store, 'get_bool', side_effect=lambda key, default=False:
self.enabled if key == 'PMS_LIMIT_CACHE_ENABLED' else default))
self.read = self.stack.enter_context(patch.object(cache.store, 'get',
side_effect=lambda key: (copy.deepcopy(self.value), 1)))
self.legacy = self.stack.enter_context(patch.object(cache.db, 'fetch_all', return_value=[]))
self.market_legacy = self.stack.enter_context(patch.object(market, 'fetch_all', return_value=[]))
self.bars = self.stack.enter_context(patch.object(market, '_bars', return_value=[
{'time': NOW.isoformat(), 'close': 10.0}]))
self.forbidden = []
for owner, name in ((requests, 'get'), (requests, 'post'), (requests, 'Session'),
(cache.db, 'execute'), (cache.db, 'fetch_one'), (cache.db, 'transaction'),
(cache.store, 'locked'), (cache.store, 'put_once'), (cache.store, 'stage_locked')):
self.forbidden.append(self.stack.enter_context(patch.object(owner, name,
side_effect=AssertionError('缓存消费禁止联网或写入'))))
def tearDown(self):
for method in self.forbidden:
method.assert_not_called()
def assert_no_legacy(self):
self.legacy.assert_not_called()
self.market_legacy.assert_not_called()
def test_valid_cache_keeps_content_version_and_source_metadata(self):
result = cache.get_limits(DAY, [A])
self.assertEqual(result[A], dict(record(), source='tushare.stk_limit', fetched_at=entry()['fetched_at']))
self.read.assert_called_once_with('price-limits:'+DAY)
self.assert_no_legacy()
def test_shared_source_is_allowed_only_after_same_validation(self):
self.value['entries'][A]['source'] = 'gp_stk_limit'
self.assertEqual(cache.read_cache(DAY)[A]['source'], 'gp_stk_limit')
self.value['entries'][A]['record']['version'] = 'corrupt'
self.assertNotIn(A, cache.read_cache(DAY))
def test_envelope_wrong_date_or_structure_returns_no_value(self):
for value in (None, [], {'trade_date': '2026-11-02', 'entries': {A: entry()}},
{'trade_date': DAY, 'entries': []}, {'trade_date': DAY}):
with self.subTest(value_type=type(value).__name__):
self.value = value
self.assertEqual(cache.read_cache(DAY), {})
self.assert_no_legacy()
def test_record_wrong_date_is_rejected_even_with_its_own_valid_hash(self):
self.value['entries'][A]['record'] = record(day='2026-11-02')
self.assertEqual(set(cache.read_cache(DAY)), {B})
def test_hash_corruption_or_changed_price_only_quarantines_affected_code(self):
good = entry()
for changed in ({**good['record'], 'version': 'bad'},
{**good['record'], 'up_limit': '12.00'},
{k: v for k, v in good['record'].items() if k != 'version'}):
self.value['entries'][A]['record'] = changed
self.assertEqual(set(cache.read_cache(DAY)), {B})
def test_bad_record_price_cannot_pass_by_preserving_previous_hash(self):
for changes in ({'pre_close': False}, {'up_limit': 0}, {'down_limit': 'NaN'}):
self.value['entries'][A]['record'] = {**record(), **changes}
self.assertEqual(set(cache.read_cache(DAY)), {B})
def test_source_status_and_fetched_timestamp_are_mandatory(self):
for changes in ({'source': 'computed'}, {'source': None}, {'status': 'UNSUPPORTED'},
{'status': 'FAILED'}, {'fetched_at': ''}, {'fetched_at': 'garbage'},
{'fetched_at': '2026-11-03T09:55:00'}, {'fetched_at': True},
{'fetched_at': (NOW-timedelta(days=1)).isoformat()},
{'fetched_at': (NOW+timedelta(seconds=1)).isoformat()}):
self.value['entries'][A] = entry(**changes)
self.assertEqual(set(cache.read_cache(DAY)), {B})
def test_timezone_conversion_checks_beijing_date(self):
self.value['entries'][A]['fetched_at'] = '2026-11-02T16:01:00+00:00'
self.assertIn(A, cache.read_cache(DAY))
self.value['entries'][A]['fetched_at'] = '2026-11-02T15:59:00+00:00'
self.assertNotIn(A, cache.read_cache(DAY))
def test_code_key_mismatch_and_beijing_rows_are_filtered(self):
self.value['entries'][A]['record'] = record(B)
self.value['entries'][BJ] = entry()
self.assertEqual(set(cache.read_cache(DAY)), {B})
self.assertEqual(cache.get_limits(DAY, [BJ]), {})
self.assertEqual(cache.get_limits(DAY, ['920001.SH']), {})
def test_unsupported_requested_codes_do_not_read_any_source(self):
self.assertEqual(cache.get_limits(DAY, [BJ, '430001.BJ']), {})
self.read.assert_not_called()
self.assert_no_legacy()
def test_requested_filter_returns_only_selected_shanghai_shenzhen_codes(self):
self.assertEqual(set(cache.get_limits(DAY, [A, BJ])), {A})
self.assertEqual(set(cache.get_limits(DAY)), {A, B})
self.assertEqual(cache.get_limits(DAY, []), {})
def test_read_is_side_effect_free_and_does_not_extend_fetched_time(self):
original = copy.deepcopy(self.value)
first = cache.get_limits(DAY, [A])
first[A]['up_limit'] = '99.00'
self.assertEqual(self.value, original)
self.assertEqual(cache.get_limits(DAY, [A])[A]['fetched_at'], original['entries'][A]['fetched_at'])
self.assertEqual(cache.get_limits(DAY, [A])[A]['up_limit'], '11.00')
def test_every_read_observes_new_persisted_version_without_process_ttl(self):
old = cache.get_limits(DAY, [A])[A]
self.value['entries'][A]['record'] = record(high='11.01')
new = cache.get_limits(DAY, [A])[A]
self.assertNotEqual(old['version'], new['version'])
self.assertEqual(self.read.call_count, 2)
def test_cache_read_failure_never_falls_back_to_shared_table(self):
self.read.side_effect = RuntimeError('local store unavailable')
self.assertEqual(cache.get_limits(DAY, [A]), {})
self.assert_no_legacy()
def test_feature_disabled_uses_old_source_and_filters_beijing(self):
self.enabled = False
self.legacy.return_value = [{'ts_code': A, 'up_limit': 11, 'down_limit': 9},
{'ts_code': BJ, 'up_limit': 11, 'down_limit': 9}]
result = cache.get_limits(DAY, [A, BJ])
self.assertEqual(set(result), {A})
sql, params = self.legacy.call_args.args
self.assertIn('gp_stk_limit', sql)
self.assertIn('ts_code IN', sql)
self.assertNotIn(BJ, params.values())
self.read.assert_not_called()
def test_market_consumer_uses_real_cache_and_preserves_metadata(self):
quote = market.execution_quote(A, now=NOW)
self.assertEqual((quote['limit_up'], quote['limit_down']), ('11.00', '9.00'))
self.assertEqual(quote['limit_source'], 'tushare.stk_limit')
self.assertEqual(quote['limit_version'], record()['version'])
self.assertEqual(quote['limit_fetched_at'], entry()['fetched_at'])
self.assertEqual(quote['source'], 'tushare:rt_min:1MIN')
self.assert_no_legacy()
def test_price_order_keeps_exact_limit_source_version_and_fetch_time(self):
quote = market.execution_quote(A, now=NOW)
result = policy.price_order(side='buy', quote=quote, now=NOW)
self.assertEqual(result['action'], 'FIRE')
for key in ('limit_source', 'limit_version', 'limit_fetched_at'):
self.assertEqual(result[key], quote[key])
def test_market_missing_or_failed_cache_waits_without_old_source(self):
for fail in (False, True):
self.value = None
self.read.side_effect = RuntimeError('unavailable') if fail else lambda key: (None, 0)
quote = market.execution_quote(A, now=NOW)
self.assertIsNone(quote['limit_up'])
self.assertIsNone(quote['limit_down'])
self.assertIn(quote.get('limit_source'), (None, 'unknown', 'unavailable'))
self.assertEqual(policy.price_order(side='buy', quote=quote, now=NOW)['action'], 'WAIT')
self.assert_no_legacy()
def test_market_feature_off_uses_original_sql_without_cache(self):
self.enabled = False
self.market_legacy.return_value = [{'up_limit': 11, 'down_limit': 9}]
quote = market.execution_quote(A, now=NOW)
self.assertEqual(quote['limit_up'], 11)
self.assertEqual(quote['limit_source'], 'gp_stk_limit')
self.assertIsNone(quote['limit_version'])
self.market_legacy.assert_called_once()
self.read.assert_not_called()
def test_market_rejects_beijing_before_loading_quotes_or_limits(self):
self.assertEqual(market.execution_quote(BJ, now=NOW), {})
self.bars.assert_not_called()
self.read.assert_not_called()
self.assert_no_legacy()
def test_rotation_consumer_uses_actual_cache_and_reuses_validated_limits(self):
limits = rotation_service._limits(DAY)
self.assertEqual(set(limits), {A, B})
quote = market.execution_quote(A, now=NOW, limits=limits[A])
self.assertEqual(self.read.call_count, 1)
self.assertEqual(quote['limit_source'], 'tushare.stk_limit')
self.assertEqual(quote['limit_version'], limits[A]['version'])
self.assertEqual(policy.price_order(side='sell', quote=quote, now=NOW)['action'], 'FIRE')
self.assert_no_legacy()
def test_rotation_missing_and_failed_cache_never_falls_back(self):
self.value = None
self.assertEqual(rotation_service._limits(DAY), {})
self.read.side_effect = RuntimeError('unavailable')
self.assertEqual(rotation_service._limits(DAY), {})
self.assert_no_legacy()
def test_rotation_feature_off_retains_old_source_with_exchange_sql_filter(self):
self.enabled = False
self.legacy.return_value = [{'ts_code': A, 'up_limit': 11, 'down_limit': 9}]
self.assertEqual(set(rotation_service._limits(DAY)), {A})
sql, params = self.legacy.call_args.args
self.assertIn('gp_stk_limit', sql)
self.assertIn("ts_code LIKE '60____.SH'", sql)
self.assertIn("ts_code LIKE '30____.SZ'", sql)
self.assertEqual(params['day'], DAY)
self.read.assert_not_called()
if __name__ == '__main__':
unittest.main(verbosity=2)

View File

@ -0,0 +1,295 @@
"""独立限制价采集的离线业务边界。HTTP、数据库、日历和时钟均使用内存桩。"""
import unit_test_guard # noqa: F401
import contextlib
import copy
import unittest
from datetime import datetime, timedelta
from unittest.mock import patch
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app.core import price_limits as core
from app.core.execution_policy import BEIJING
from app.services import price_limit_collector as worker, param_store
from config.settings import settings
NOW = datetime(2026, 11, 3, 9, 0, tzinfo=BEIJING)
DAY = '2026-11-03'
A, B = '600000.SH', '000001.SZ'
def row(code=A, day=DAY, high='11.00'):
return {'ts_code': code, 'trade_date': day, 'pre_close': '10.00',
'up_limit': high, 'down_limit': '9.00'}
class CollectorTests(unittest.TestCase):
def setUp(self):
self.stack = contextlib.ExitStack()
self.addCleanup(self.stack.close)
self.docs, self.params, self.rows, self.calls = {}, {}, [], []
self.seconds = 0.
self.target = {'codes': [A, B], 'errors': [], 'sources': {A: ['持仓'], B: ['微盘候选']}}
self.result = lambda code: core.normalize_rows([row(code)], DAY, [code])
self.stack.enter_context(patch.object(settings, 'PMS_TABLE_PREFIX', ''))
self.stack.enter_context(patch.object(settings, 'PMS_TUSHARE_TOKEN', 'test-secret-never-print'))
for name in ('get_bool', 'get_int', 'get_float'):
self.stack.enter_context(patch.object(param_store, name, side_effect=lambda key, default=None:
self.params.get(key, True if key == 'PMS_LIMIT_COLLECT_ENABLED' else default)))
self.stack.enter_context(patch.object(worker.tradedays, 'calendar_degraded', return_value=False))
self.stack.enter_context(patch.object(worker.tradedays, 'is_trade_day', return_value=True))
self.stack.enter_context(patch.object(worker.time, 'monotonic', side_effect=lambda: self.seconds))
self.stack.enter_context(patch.object(worker.time, 'sleep', side_effect=self.advance))
original_get = param_store.get
self.stack.enter_context(patch.object(param_store, 'get', side_effect=lambda key, default=None:
original_get(key, default) if key in param_store.SECRET_KEYS else self.params.get(key, default)))
self.collect = self.stack.enter_context(patch.object(worker.price_limit_targets, 'collect_targets',
side_effect=lambda day: copy.deepcopy(self.target)))
self.shared = self.stack.enter_context(patch.object(worker.db, 'fetch_all', side_effect=lambda *a, **kw: copy.deepcopy(self.rows)))
self.stack.enter_context(patch.object(worker.store, 'get', side_effect=lambda key: (copy.deepcopy(self.docs.get(key)), 1)))
self.stack.enter_context(patch.object(worker.store, 'locked', self.locked))
self.fetch = self.stack.enter_context(patch.object(worker.price_limit_provider, 'fetch_limit', side_effect=self.provider))
import requests
self.forbidden = [self.stack.enter_context(patch.object(obj, name, side_effect=AssertionError('真实外部访问')))
for obj, name in [(requests, 'Session'), (worker.db, 'execute'), (worker.db, 'fetch_one')]]
def tearDown(self):
for method in self.forbidden:
method.assert_not_called()
@contextlib.contextmanager
def locked(self, key, kind, initial):
value = copy.deepcopy(self.docs.get(key, initial))
yield value
self.docs[key] = value
def advance(self, seconds):
self.seconds += seconds
def provider(self, code, day, token, timeout_sec):
self.calls.append((code, day, self.seconds))
self.assertEqual(day, DAY)
self.assertGreater(timeout_sec, 0)
return self.result(code)
def entry(self, code=A):
return self.docs[worker.day_key(DAY)]['entries'][code]
def run_round(self, now=NOW):
return worker.run_once(now)
def test_missing_targets_fetched_and_persisted_with_source(self):
result = self.run_round()
self.assertEqual((result['status'], result['valid_count'], result['requests']), ('COMPLETE', 2, 2))
self.assertEqual(self.entry()['source'], 'tushare.stk_limit')
self.assertEqual(self.entry()['record']['trade_date'], DAY)
self.assertEqual(self.docs[worker.day_key(DAY)]['target_sources'][A], ['持仓'])
self.assertNotIn('owner', self.docs[worker.LEASE_KEY])
def test_single_code_requests_are_globally_spaced(self):
self.run_round()
self.assertEqual(len(self.calls), 2)
self.assertGreaterEqual(self.calls[1][2]-self.calls[0][2], 1.2)
for code, _, _ in self.calls:
self.assertNotIn(',', code)
def test_shared_current_values_avoid_redundant_http(self):
self.rows = [row(A), row(B)]
self.assertEqual(self.run_round()['valid_count'], 2)
self.fetch.assert_not_called()
self.assertEqual(self.entry()['source'], 'gp_stk_limit')
sql, bindings = self.shared.call_args.args
self.assertIn('ts_code IN', sql)
self.assertEqual(set(bindings.values()), {DAY, A, B})
def test_target_failure_keeps_other_targets(self):
self.target['errors'] = ['计划读取失败']
result = self.run_round()
self.assertEqual((result['status'], result['valid_count']), ('PARTIAL', 2))
self.assertEqual(result['errors'], ['计划读取失败'])
def test_bj_excluded_before_shared_and_http(self):
self.target['codes'].append('920001.BJ')
result = self.run_round()
self.assertEqual(result['target_count'], 2)
self.assertNotIn('920001.BJ', self.shared.call_args.args[1].values())
self.assertNotIn('920001.BJ', [c[0] for c in self.calls])
def test_wrong_day_shared_value_does_not_stop_provider(self):
self.rows = [row(A, '2026-11-02')]
self.run_round()
self.assertEqual(self.entry()['status'], 'VALID')
self.assertEqual(self.entry()['source'], 'tushare.stk_limit')
def test_one_empty_response_keeps_other_valid_and_retries_later(self):
self.result = lambda c: core.normalize_rows([] if c == A else [row(c)], DAY, [c])
r = self.run_round()
self.assertEqual((r['valid_count'], r['missing_count']), (1, 1))
self.assertEqual(self.entry()['last_error'], 'NOT_PUBLISHED')
self.calls.clear()
self.run_round(NOW+timedelta(seconds=20))
self.assertFalse(self.calls)
self.run_round(NOW+timedelta(seconds=70))
self.assertEqual([c[0] for c in self.calls], [A])
self.assertEqual(self.entry()['failures'], 2)
def test_failed_first_does_not_starve_next_round(self):
self.params['PMS_LIMIT_ROUND_MAX_CODES'] = 1
self.result = lambda c: core.normalize_rows([], DAY, [c])
self.run_round()
first = self.calls[-1][0]
self.run_round(NOW+timedelta(seconds=10))
self.assertNotEqual(first, self.calls[-1][0])
def test_max_failures_persist_across_rounds(self):
self.params['PMS_LIMIT_MAX_FAILURES_PER_DAY'] = 1
self.result = lambda c: {'records': {}, 'invalid': {}, 'errors': ['HTTP_TIMEOUT']}
self.run_round()
self.calls.clear()
self.run_round(NOW+timedelta(minutes=20))
self.assertFalse(self.calls)
def test_transport_error_keeps_valid_content_and_original_timestamp(self):
self.run_round()
old = copy.deepcopy(self.entry())
self.result = lambda c: {'records': {}, 'invalid': {}, 'errors': ['HTTP_TIMEOUT']}
self.run_round(NOW+timedelta(minutes=20))
self.assertEqual(self.entry()['record'], old['record'])
self.assertEqual(self.entry()['fetched_at'], old['fetched_at'])
self.assertEqual(self.entry()['status'], 'VALID')
self.assertEqual(self.entry()['last_error'], 'HTTP_TIMEOUT')
def test_explicit_bad_value_quarantines_existing_record(self):
self.run_round()
self.result = lambda c: core.normalize_rows([row(c, high='0')], DAY, [c])
self.run_round(NOW+timedelta(minutes=20))
self.assertEqual(self.entry()['status'], 'INVALID')
self.assertEqual(self.entry()['last_error'], 'UNSUPPORTED')
def test_revised_value_keeps_prior_version(self):
self.run_round()
old = self.entry()['record']['version']
self.result = lambda c: core.normalize_rows([row(c, high='11.20')], DAY, [c])
self.run_round(NOW+timedelta(minutes=20))
self.assertNotEqual(self.entry()['record']['version'], old)
self.assertEqual(self.entry()['revisions'][0]['record']['version'], old)
def test_later_shared_old_record_cannot_override_tushare(self):
self.run_round()
old = self.entry()['record']
self.rows = [row(A, high='11.10')]
self.run_round(NOW+timedelta(seconds=30))
self.assertEqual(self.entry()['record'], old)
def test_shared_failure_uses_provider(self):
self.shared.side_effect = RuntimeError('never-print')
r = self.run_round()
self.assertEqual(r['valid_count'], 2)
self.assertEqual(r['errors'], ['共享限制价读取失败'])
def test_missing_token_still_uses_shared_data(self):
self.stack.enter_context(patch.object(settings, 'PMS_TUSHARE_TOKEN', ''))
self.rows = [row(A)]
r = self.run_round()
self.assertEqual(r['valid_count'], 1)
self.assertIn('采集密钥未配置', r['errors'])
self.fetch.assert_not_called()
def test_real_prefix_disabled_and_calendar_window_guards(self):
with patch.object(settings, 'PMS_TABLE_PREFIX', 'real_'):
self.assertEqual(self.run_round()['status'], 'UNAUTHORIZED_INSTANCE')
self.params['PMS_LIMIT_COLLECT_ENABLED'] = False
self.assertEqual(self.run_round()['status'], 'DISABLED')
self.params.clear()
with patch.object(worker.tradedays, 'calendar_degraded', return_value=True):
self.assertEqual(self.run_round()['status'], 'CALENDAR_WAIT')
with patch.object(worker.tradedays, 'is_trade_day', return_value=False):
self.assertEqual(self.run_round()['status'], 'CALENDAR_WAIT')
self.assertEqual(self.run_round(NOW.replace(hour=8))['status'], 'OUTSIDE_WINDOW')
self.params['PMS_LIMIT_COLLECT_START'] = 'bad'
self.assertEqual(self.run_round()['status'], 'INVALID_WINDOW')
self.collect.assert_not_called()
def test_invalid_runtime_values_do_not_fetch(self):
self.params['PMS_LIMIT_MIN_REQUEST_INTERVAL_SEC'] = 0
self.assertEqual(self.run_round()['status'], 'INVALID_CONFIG')
self.collect.assert_not_called()
def test_live_lease_skips_all_sources(self):
self.docs[worker.LEASE_KEY] = {'owner': 'other', 'until': (NOW+timedelta(seconds=30)).isoformat()}
self.assertEqual(self.run_round()['status'], 'BUSY')
self.collect.assert_not_called()
def test_expired_lease_is_recovered(self):
self.docs[worker.LEASE_KEY] = {'owner': 'old', 'until': (NOW-timedelta(seconds=1)).isoformat()}
self.assertEqual(self.run_round()['valid_count'], 2)
def test_lost_lease_does_not_overwrite_new_owner(self):
def replaced(c):
self.docs[worker.LEASE_KEY] = {'owner': 'new', 'until': (NOW+timedelta(seconds=300)).isoformat()}
return core.normalize_rows([row(c)], DAY, [c])
self.result = replaced
self.assertEqual(self.run_round()['status'], 'LEASE_LOST')
self.assertNotIn(worker.day_key(DAY), self.docs)
self.assertEqual(self.docs[worker.LEASE_KEY]['owner'], 'new')
def test_round_timeout_discards_late_response(self):
def slow(c):
self.advance(31)
return core.normalize_rows([row(c)], DAY, [c])
self.result = slow
r = self.run_round()
self.assertEqual(r['valid_count'], 0)
self.assertIn('本轮采集超时,迟到响应未采纳', r['errors'])
self.assertEqual(self.entry()['status'], 'MISSING')
def test_old_day_document_is_not_reused(self):
self.docs[worker.day_key(DAY)] = {'trade_date': '2026-11-02', 'entries': {A: {'status': 'VALID'}}}
self.run_round()
self.assertEqual(self.entry()['record']['trade_date'], DAY)
def test_shared_bad_row_cannot_reset_http_backoff(self):
self.rows = [row(A, high='0')]
self.result = lambda c: {'records': {}, 'invalid': {}, 'errors': ['HTTP_TIMEOUT']}
self.run_round()
self.calls.clear()
self.run_round(NOW+timedelta(seconds=20))
self.assertFalse(self.calls)
self.assertEqual(self.entry()['failures'], 1)
def test_slow_first_request_does_not_starve_next_stock(self):
def slow(c):
self.advance(31)
return core.normalize_rows([row(c)], DAY, [c])
self.result = slow
self.run_round()
first = self.calls[-1][0]
self.run_round(NOW+timedelta(seconds=40))
self.assertNotEqual(first, self.calls[-1][0])
def test_empty_targets_no_market_wide_query(self):
self.target = {'codes': [], 'errors': [], 'sources': {}}
self.assertEqual(self.run_round()['target_count'], 0)
self.shared.assert_not_called()
self.fetch.assert_not_called()
def test_one_bad_schedule_record_does_not_block_other_targets(self):
self.docs[worker.day_key(DAY)] = {'trade_date': DAY, 'entries': {
A: {'status': 'INVALID', 'failures': 'bad', 'last_attempt': [], 'revisions': {}, 'last_error': {'bad': True}}}}
self.assertEqual(self.run_round()['valid_count'], 2)
self.assertEqual(self.entry()['status'], 'VALID')
def test_bad_entries_container_is_recovered(self):
self.docs[worker.day_key(DAY)] = {'trade_date': DAY, 'entries': []}
self.assertEqual(self.run_round()['valid_count'], 2)
def test_secret_not_editable_or_readable_through_paramstore(self):
self.assertIn('PMS_TUSHARE_TOKEN', param_store.SECRET_KEYS)
self.assertNotIn('PMS_TUSHARE_TOKEN', param_store._editable_keys())
self.assertEqual(param_store.get('PMS_TUSHARE_TOKEN'), '')
if __name__ == '__main__':
unittest.main()

View File

@ -0,0 +1,234 @@
"""限制价HTTP客户端的内存桩回归;不连接供应商、数据库或代理。"""
import unit_test_guard
import contextlib
import io
import json
import os
import sys
import unittest
from datetime import date
from unittest.mock import patch
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from app.services import price_limit_provider as provider
CODE = '688701.SH'
DAY = '2026-11-03'
TOKEN = 'unit-only-secret-canary-do-not-log'
def payload(items=None, **extra):
return {'code': 0, 'data': {'fields': provider.FIELDS.split(','),
'items': [[CODE, '20261103', 10, 12, 8]] if items is None else items}, **extra}
class FakeResponse:
def __init__(self, body=None, *, status=200, headers=None, chunks=None, failure=None):
self.status_code = status
self.headers = headers or {}
self.chunks = chunks if chunks is not None else [json.dumps(payload() if body is None else body).encode()]
self.failure = failure
self.closed = False
self.reads = 0
def iter_content(self, chunk_size):
self.chunk_size = chunk_size
for chunk in self.chunks:
self.reads += 1
yield chunk
if self.failure:
raise self.failure
def close(self):
self.closed = True
class FakeSession:
def __init__(self, response, failure=None):
self.response, self.failure = response, failure
self.trust_env = True
self.closed = False
self.calls = []
def post(self, url, **kwargs):
self.calls.append((url, kwargs, self.trust_env))
if self.failure:
raise self.failure
return self.response
def close(self):
self.closed = True
class ProviderTests(unittest.TestCase):
def request(self, response=None, *, code=CODE, day=DAY, token=TOKEN, timeout_sec=5,
failure=None, clock=None):
response = response or FakeResponse()
session = FakeSession(response, failure)
with contextlib.ExitStack() as stack:
factory = stack.enter_context(patch.object(provider.requests, 'Session', return_value=session))
if clock is not None:
stack.enter_context(patch.object(provider.time, 'monotonic', side_effect=clock))
result = provider.fetch_limit(code, day, token, timeout_sec)
return result, response, session, factory
def test_single_security_contract_and_normalized_date(self):
result, response, session, _ = self.request(code=' 688701.sh ', day=date(2026, 11, 3))
self.assertEqual(result['errors'], [])
self.assertEqual(list(result['records']), [CODE])
self.assertEqual(result['records'][CODE]['up_limit'], '12.00')
self.assertEqual(len(session.calls), 1)
url, kwargs, trust = session.calls[0]
self.assertEqual(url, 'https://api.tushare.pro')
self.assertEqual(kwargs['json']['api_name'], 'stk_limit')
self.assertEqual(kwargs['json']['params'], {'ts_code': CODE, 'trade_date': '20261103'})
self.assertEqual(kwargs['json']['fields'], provider.FIELDS)
self.assertTrue(kwargs['stream'])
self.assertFalse(kwargs['allow_redirects'])
self.assertFalse(trust)
self.assertEqual(kwargs['timeout'].total, 5.)
self.assertEqual(kwargs['timeout'].connect_timeout, 2.)
self.assertTrue(response.closed and session.closed)
def test_empty_success_remains_empty_without_error(self):
result, response, session, _ = self.request(FakeResponse(payload([])))
self.assertEqual(result, {'records': {}, 'invalid': {}, 'errors': []})
self.assertTrue(response.closed and session.closed)
def test_code_rejections_never_create_session(self):
for code in ('', None, '688701.SH,600000.SH', '999999.BJ', '000001.SH', 'HK00700', '*'):
with self.subTest(code=code):
result, _, _, factory = self.request(code=code)
self.assertEqual(result['errors'], ['INVALID_REQUEST_CODE'])
factory.assert_not_called()
def test_invalid_date_never_creates_session(self):
for day in (None, True, '2026-02-30', '2026113', '2026-11-03 extra', []):
with self.subTest(day=day):
result, _, _, factory = self.request(day=day)
self.assertEqual(result['errors'], ['INVALID_TARGET_DATE'])
factory.assert_not_called()
def test_missing_token_never_creates_session(self):
for token in ('', ' \n ', None, False, 123):
result, _, _, factory = self.request(token=token)
self.assertEqual(result['errors'], ['MISSING_PROVIDER_TOKEN'])
factory.assert_not_called()
def test_invalid_timeout_never_creates_session(self):
for value in (0, -1, float('nan'), float('inf'), True, 'bad', None):
result, _, _, factory = self.request(timeout_sec=value)
self.assertEqual(result['errors'], ['INVALID_HTTP_TIMEOUT'])
factory.assert_not_called()
def test_short_timeout_caps_connect(self):
_, _, session, _ = self.request(timeout_sec=.25)
timeout = session.calls[0][1]['timeout']
self.assertEqual(timeout.total, .25)
self.assertEqual(timeout.connect_timeout, .25)
def test_redirect_and_http_failure_never_read_body(self):
for status in (301, 302, 307, 401, 429, 500):
result, response, session, _ = self.request(FakeResponse(status=status))
self.assertEqual(result['errors'], ['HTTP_ERROR'])
self.assertEqual(response.reads, 0)
self.assertTrue(response.closed and session.closed)
self.assertEqual(len(session.calls), 1)
def test_provider_error_never_returns_message_or_token(self):
stream = io.StringIO()
with contextlib.redirect_stdout(stream), contextlib.redirect_stderr(stream):
result, _, _, _ = self.request(FakeResponse(payload(code=-2001, msg=TOKEN)))
self.assertEqual(result['errors'], ['PROVIDER_ERROR'])
self.assertNotIn(TOKEN, json.dumps(result)+stream.getvalue())
def test_transport_errors_do_not_echo_details_or_retry(self):
for failure, code in ((provider.requests.exceptions.Timeout(TOKEN), 'HTTP_TIMEOUT'),
(provider.requests.exceptions.ConnectionError(TOKEN), 'HTTP_ERROR'),
(RuntimeError(TOKEN), 'HTTP_ERROR')):
stream = io.StringIO()
with contextlib.redirect_stdout(stream), contextlib.redirect_stderr(stream):
result, _, session, _ = self.request(failure=failure)
self.assertEqual(result['errors'], [code])
self.assertEqual(len(session.calls), 1)
self.assertTrue(session.closed)
self.assertNotIn(TOKEN, json.dumps(result)+stream.getvalue())
def test_stream_timeout_closes_both_resources(self):
result, response, session, _ = self.request(FakeResponse(chunks=[b'{'],
failure=provider.requests.exceptions.ReadTimeout(TOKEN)))
self.assertEqual(result['errors'], ['HTTP_TIMEOUT'])
self.assertTrue(response.closed and session.closed)
def test_requests_wrapped_stream_timeout_is_still_a_timeout(self):
from urllib3.exceptions import ReadTimeoutError
failure = provider.requests.exceptions.ConnectionError(ReadTimeoutError(None, TOKEN, TOKEN))
result, response, session, _ = self.request(FakeResponse(chunks=[b'{'], failure=failure))
self.assertEqual(result['errors'], ['HTTP_TIMEOUT'])
self.assertNotIn(TOKEN, json.dumps(result))
self.assertTrue(response.closed and session.closed)
def test_declared_size_rejects_before_reading(self):
result, response, session, _ = self.request(FakeResponse(headers={'Content-Length': '65537'}))
self.assertEqual(result['errors'], ['RESPONSE_TOO_LARGE'])
self.assertEqual(response.reads, 0)
self.assertTrue(response.closed and session.closed)
def test_stream_limit_applies_without_or_despite_content_length(self):
for headers in ({}, {'Content-Length': '1'}):
result, response, session, _ = self.request(FakeResponse(headers=headers,
chunks=[b' ' * 65536, b'x', b'never-read']))
self.assertEqual(result['errors'], ['RESPONSE_TOO_LARGE'])
self.assertEqual(response.reads, 2)
self.assertTrue(response.closed and session.closed)
def test_exact_size_valid_body_is_accepted(self):
body = json.dumps(payload()).encode()
body += b' ' * (65536-len(body))
result, _, _, _ = self.request(FakeResponse(chunks=[body], headers={'Content-Length': '65536'}))
self.assertEqual(list(result['records']), [CODE])
def test_deadline_after_headers_stops_before_read(self):
result, response, session, _ = self.request(clock=[0., 5.])
self.assertEqual(result['errors'], ['HTTP_TIMEOUT'])
self.assertEqual(response.reads, 0)
self.assertTrue(response.closed and session.closed)
def test_deadline_during_stream_stops_without_more_chunks(self):
result, response, _, _ = self.request(FakeResponse(chunks=[b'{', b'}', b'never-read']),
clock=[0., 1., 2., 5.])
self.assertEqual(result['errors'], ['HTTP_TIMEOUT'])
self.assertEqual(response.reads, 2)
self.assertTrue(response.closed)
def test_invalid_json_and_headers_are_safe(self):
for response in (FakeResponse(chunks=[TOKEN.encode()]), FakeResponse(chunks=[b'\xff']),
FakeResponse(headers={'Content-Length': TOKEN}),
FakeResponse(headers={'Content-Length': '-1'})):
result, response, session, _ = self.request(response)
self.assertEqual(result['errors'], ['INVALID_PROVIDER_RESPONSE'])
self.assertNotIn(TOKEN, json.dumps(result))
self.assertTrue(response.closed and session.closed)
def test_foreign_security_and_wrong_day_are_not_accepted(self):
result, _, _, _ = self.request(FakeResponse(payload([
['600000.SH', '20261103', 10, 11, 9],
[CODE, '20261102', 10, 12, 8],
])))
self.assertEqual(result['records'], {})
self.assertEqual(result['invalid'], {'600000.SH': 'NOT_REQUESTED', CODE: 'DATE_MISMATCH'})
def test_decoder_receives_nonempty_single_code_allowlist(self):
with patch.object(provider.price_limits, 'provider_decode', wraps=provider.price_limits.provider_decode) as decode:
self.request()
self.assertEqual(decode.call_args.kwargs['requested_codes'], [CODE])
def test_environment_proxy_is_not_trusted(self):
with patch.dict(os.environ, {'HTTPS_PROXY': 'https://'+TOKEN, 'NETRC': TOKEN}):
result, _, session, _ = self.request()
self.assertEqual(result['errors'], [])
self.assertFalse(session.calls[0][2])
if __name__ == '__main__':
unittest.main(verbosity=2)

View File

@ -0,0 +1,230 @@
"""限制价目标采集:全部资料来自内存桩,禁止数据库、HTTP和模型调用。"""
import unit_test_guard # noqa: F401
from contextlib import ExitStack
import copy
import datetime as dt
import hashlib
import json
from pathlib import Path
import sys
import unittest
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app.core import micro_rotation as core, strategy_book as books
from app.services import price_limit_targets as targets
DAY = '2026-11-04'
def snapshot(*, rule=core.EXECUTION_RULE, day=DAY, start=600100, ready=True, frozen=True):
members = [{'code': f'{start+i}.SH', 'rank': i+1, 'eligible': True, 'close': 10.,
'total_mv_wan': i+1} for i in range(100)]
value = {'rule_version': rule, 'rule_parameters': core.rule_parameters(rule),
'basket_size': 50, 'data_date': '2026-11-03', 'effective_date': day,
'signal_ready': True, 'basket_ready': ready,
'signal': {'date': '2026-11-03', 'ready': True, 'low': False,
'high': False, 'growth_break': False},
'members': members[:50], 'source_hashes': {'stocks': 'fixed'}, 'errors': []}
if rule == core.EXECUTION_RULE:
value.update(candidates=members, candidate_count=len(members))
value['snapshot_version'] = hashlib.sha256(json.dumps(value, sort_keys=True,
ensure_ascii=False, separators=(',', ':')).encode()).hexdigest()
value['frozen'] = frozen
return value
class TargetCollectionTests(unittest.TestCase):
def setUp(self):
self.stack = ExitStack()
self.addCleanup(self.stack.close)
self.rows = {'positions': [], 'instructions': [], 'orders': [], 'plans': [], 'proposals': []}
self.state = None
self.saved = []
self.config = {'rule_version': core.EXECUTION_RULE, 'candidate_pool_size': 100,
'url': 'http://memory.invalid'}
self.monitored = snapshot()
self.readers = {}
for obj, method, name in (
(targets.pms_repo, 'list_positions', 'positions'),
(targets.pms_repo, 'list_instructions', 'instructions'),
(targets.qmt_repo, 'list_orders', 'orders'),
(targets.pms_repo, 'list_plans', 'plans'),
(targets.pms_repo, 'list_proposals', 'proposals')):
def read(*args, source=name, **kwargs):
self.assertEqual(books.CURRENT.get(), 'all')
return copy.deepcopy(self.rows[source])
self.readers[name] = self.stack.enter_context(patch.object(obj, method, side_effect=read))
self.get_state = self.stack.enter_context(patch.object(targets.rotation_repo, 'get',
side_effect=lambda key: (copy.deepcopy(self.state), 1)))
self.recent = self.stack.enter_context(patch.object(targets.rotation_repo, 'recent',
side_effect=lambda *args, **kwargs: copy.deepcopy(self.saved)))
self.configuration = self.stack.enter_context(patch.object(targets.rotation_service, 'configuration',
side_effect=lambda: copy.deepcopy(self.config)))
self.pull = self.stack.enter_context(patch.object(targets.rotation_service, 'pull',
side_effect=lambda day: copy.deepcopy(self.monitored)))
# 即使调用了会被业务层捕获的外部入口,也在 tearDown 显式失败。
from app.db import session as db
import requests
self.forbidden = [self.stack.enter_context(patch.object(obj, name,
side_effect=AssertionError('测试禁止真实外部调用')))
for obj, name in ((db, 'fetch_all'), (db, 'fetch_one'), (db, 'execute'),
(requests, 'get'), (requests, 'post'))]
def tearDown(self):
for mock in self.forbidden:
mock.assert_not_called()
def test_all_sources_and_both_books_merge_with_provenance(self):
self.rows['positions'] = [{'ts_code': '600000.SH', 'book_id': 'original'},
{'ts_code': '000001.SZ', 'book_id': 'micro30'}]
self.rows['instructions'] = [{'ts_code': '300001.SZ', 'status': 'WAIT_REVIEW'}]
self.rows['orders'] = [{'ts_code': '688001.SH', 'parent_id': 'terminal-parent'}]
self.rows['plans'] = [{'ts_code': '600000.SH'}, {'ts_code': '600002.SH'}]
self.rows['proposals'] = [{'ts_code': '600003.SH'}]
self.state = {'rotation': {'target': ['600004.SH']}}
self.saved = [{'value': snapshot(start=601100)}]
out = targets.collect_targets(DAY)
self.assertEqual(out['errors'], [])
self.assertTrue({'600000.SH', '000001.SZ', '300001.SZ', '688001.SH',
'600002.SH', '600003.SH', '600004.SH', '600199.SH', '601199.SH'} <= set(out['codes']))
self.assertEqual(out['sources']['600000.SH'], ['执行计划', '策略持仓'])
self.assertEqual(out['codes'], sorted(set(out['codes'])))
self.assertEqual(books.CURRENT.get(), books.ORIGINAL)
def test_status_contract_covers_reviews_plans_and_accepted_proposals(self):
targets.collect_targets(DAY)
self.assertIn('WAIT_REVIEW', self.readers['instructions'].call_args.kwargs['statuses'])
self.assertEqual(self.readers['plans'].call_args.kwargs['statuses'], ('PENDING', 'GATED', 'EXECUTING'))
self.assertEqual(self.readers['proposals'].call_args.kwargs['statuses'], ('WAIT_USER', 'ACCEPTED'))
self.assertEqual(self.readers['orders'].call_args.kwargs['statuses'], targets.qmt_repo.LIVE)
for key in ('instructions', 'plans', 'orders', 'proposals'):
self.assertEqual(self.readers[key].call_args.kwargs['limit'], 5000)
def test_normalizes_and_excludes_out_of_scope_at_entry(self):
self.rows['positions'] = [{'ts_code': code} for code in
(' 600000.sh ', '000001.sz', '920001.BJ', '830001.BJ', '000001.SH', '', None)]
self.state = {'rotation': {'target': ['920001.BJ', '688001.SH']}}
out = targets.collect_targets(DAY)
self.assertTrue({'600000.SH', '000001.SZ', '688001.SH'} <= set(out['codes']))
self.assertFalse(any(code.endswith('.BJ') for code in out['codes']))
self.assertNotIn('000001.SH', out['codes'])
def test_each_failed_source_keeps_other_known_targets_and_hides_exception_text(self):
self.rows['positions'] = [{'ts_code': '600000.SH'}]
self.readers['instructions'].side_effect = RuntimeError('private connection text')
self.readers['plans'].side_effect = RuntimeError('private connection text')
self.pull.side_effect = RuntimeError('private connection text')
out = targets.collect_targets(DAY)
self.assertEqual(out['codes'], ['600000.SH'])
self.assertEqual(out['errors'], ['待执行指令读取失败', '执行计划读取失败', '微盘监控快照读取失败'])
self.assertNotIn('private', str(out))
def test_cap_is_reported_at_exact_limit_without_discarding_known_codes(self):
self.rows['instructions'] = [{'ts_code': '600000.SH'}]*5000
out = targets.collect_targets(DAY)
self.assertIn('待执行指令达到读取上限,结果可能不完整', out['errors'])
self.assertIn('600000.SH', out['codes'])
def test_snapshot_repo_real_cap_is_reported(self):
self.saved = [{'value': snapshot(day='2026-11-05')}]*1000
out = targets.collect_targets(DAY)
self.recent.assert_called_once_with('snapshot', limit=1000)
self.assertIn('近期微盘快照达到读取上限,结果可能不完整', out['errors'])
def test_wrong_day_and_old_rule_saved_snapshots_are_ignored(self):
self.saved = [{'value': snapshot(day='2026-11-05', start=601100)},
{'value': snapshot(rule=core.RULE, start=602100)}]
out = targets.collect_targets(DAY)
self.assertEqual(len(out['codes']), 100)
self.assertEqual(out['errors'], [])
def test_tampered_saved_candidate_pool_is_not_used(self):
value = snapshot(start=601100)
value['candidates'][90]['code'] = '602999.SH'
self.saved = [{'value': value}]
out = targets.collect_targets(DAY)
self.assertNotIn('602999.SH', out['codes'])
self.assertIn('微盘保存快照校验未通过', out['errors'])
def test_valid_unfrozen_monitor_pool_can_prewarm_without_authorizing_trade(self):
self.monitored = snapshot(frozen=False)
out = targets.collect_targets(DAY)
self.pull.assert_called_once_with(DAY)
self.assertEqual(len(out['codes']), 100)
self.assertEqual(out['sources']['600199.SH'], ['微盘监控快照'])
self.assertEqual(out['errors'], [])
def test_monitor_wrong_day_or_rule_is_reported(self):
for value in (snapshot(day='2026-11-05'), snapshot(rule=core.RULE), None):
with self.subTest(value=value):
self.monitored = value
out = targets.collect_targets(DAY)
self.assertEqual(out['codes'], [])
self.assertIn('微盘监控快照日期或规则不符', out['errors'])
def test_unready_monitor_does_not_treat_unchecked_candidates_as_eligible(self):
self.monitored = snapshot(ready=False)
out = targets.collect_targets(DAY)
self.assertEqual(out['codes'], [])
self.assertIn('微盘监控快照名单尚未就绪', out['errors'])
def test_v2_only_collects_primary_members(self):
self.config['rule_version'] = core.RULE
self.monitored = snapshot(rule=core.RULE)
# 旧契约未签入摘要的附加字段不能被当作后备候选。
self.monitored['candidates'] = [{'code': '602999.SH'}]
self.assertEqual(len(targets.collect_targets(DAY)['codes']), 50)
def test_configuration_failure_preserves_holdings_and_state(self):
self.rows['positions'] = [{'ts_code': '600000.SH'}]
self.state = {'rotation': {'target': ['600001.SH']}}
self.configuration.side_effect = RuntimeError('offline')
out = targets.collect_targets(DAY)
self.assertEqual(out['codes'], ['600000.SH', '600001.SH'])
self.assertIn('微盘运行规则读取失败', out['errors'])
self.pull.assert_not_called()
def test_missing_monitor_url_preserves_saved_snapshot(self):
self.config['url'] = ''
self.saved = [{'value': snapshot(start=601100)}]
out = targets.collect_targets(DAY)
self.assertIn('601199.SH', out['codes'])
self.assertIn('微盘监控地址未配置', out['errors'])
self.pull.assert_not_called()
def test_malformed_source_rows_do_not_drop_valid_rows(self):
self.rows['positions'] = [None, {'ts_code': '600000.SH'}]
self.rows['plans'] = {'ts_code': '600001.SH'}
self.state = {'rotation': {'target': '600002.SH'}}
out = targets.collect_targets(DAY)
self.assertIn('600000.SH', out['codes'])
self.assertIn('策略持仓记录格式异常', out['errors'])
self.assertIn('执行计划记录格式异常', out['errors'])
self.assertIn('微盘执行目标读取失败', out['errors'])
def test_next_collection_discovers_intraday_new_plan(self):
before = targets.collect_targets(DAY)
self.rows['plans'].append({'ts_code': '600009.SH'})
after = targets.collect_targets(DAY)
self.assertNotIn('600009.SH', before['codes'])
self.assertIn('600009.SH', after['codes'])
self.assertEqual(after['sources']['600009.SH'], ['执行计划'])
def test_invalid_day_makes_no_source_call(self):
for day in ('20261104', '2026-02-30', None, '2026-11-04T09:00:00'):
self.assertEqual(targets.collect_targets(day),
{'codes': [], 'errors': ['目标交易日格式无效'], 'sources': {}})
for mock in self.readers.values():
mock.assert_not_called()
self.configuration.assert_not_called()
self.pull.assert_not_called()
def test_date_object_uses_iso_day(self):
self.assertEqual(len(targets.collect_targets(dt.date(2026, 11, 4))['codes']), 100)
self.pull.assert_called_once_with(DAY)
if __name__ == '__main__':
unittest.main()

View File

@ -0,0 +1,210 @@
"""限制价主源纯逻辑回归。虚构数据、无配置、无网络。"""
import unit_test_guard
import copy
from datetime import date, datetime
from decimal import Decimal, localcontext
import json
from pathlib import Path
import sys
import unittest
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from app.core.price_limits import MAX_ROWS, REQUIRED_FIELDS, normalize_rows, provider_decode, supported
DAY = '2026-11-03'
CODE = '600000.SH'
OTHER = '000001.SZ'
def row(**changes):
return {'trade_date': '20261103', 'ts_code': CODE, 'pre_close': '10.00',
'up_limit': '11.00', 'down_limit': '9.00', **changes}
def body(rows=None, fields=None):
fields = list(fields or REQUIRED_FIELDS)
rows = [row()] if rows is None else rows
return {'code': 0, 'msg': 'must-not-be-echoed',
'data': {'fields': fields, 'items': [[value.get(field) for field in fields] for value in rows]}}
class PriceLimitCoreTests(unittest.TestCase):
def test_supported_codes_are_only_shenzhen_shanghai_a_shares(self):
for code in ('600000.SH', '688001.SH', '000001.SZ', '300001.SZ', ' 600000.sh '):
self.assertTrue(supported(code))
for code in ('920001.BJ', '430001.BJ', '920001.SH', '600000.SZ', '000001.SH',
'SH600000', '600000', '510300.SH', '888888.SH', None, True):
self.assertFalse(supported(code))
def test_dates_normalize_without_substituting_today(self):
for target in ('20261103', 20261103, DAY, date(2026, 11, 3), datetime(2026, 11, 3)):
for source in ('20261103', 20261103, DAY, date(2026, 11, 3)):
result = normalize_rows([row(trade_date=source)], target)
self.assertEqual(result['records'][CODE]['trade_date'], DAY)
def test_invalid_target_date_rejects_entire_batch(self):
for value in (None, True, 20261103.0, '2026-02-30', '202611', '2026-11-03T00:00:00'):
result = normalize_rows([row()], value)
self.assertEqual(result['errors'], ['INVALID_TARGET_DATE'])
self.assertEqual(result['records'], {})
def test_wrong_day_only_quarantines_affected_security(self):
result = normalize_rows([row(trade_date='20261102'), row(ts_code=OTHER)], DAY)
self.assertEqual(result['invalid'], {CODE: 'DATE_MISMATCH'})
self.assertEqual(set(result['records']), {OTHER})
def test_correct_date_cannot_hide_same_security_wrong_date(self):
for values in ([row(), row(trade_date='20261102')], [row(trade_date='20261102'), row()]):
result = normalize_rows(values, DAY)
self.assertEqual(result['records'], {})
self.assertEqual(result['invalid'][CODE], 'DATE_MISMATCH')
def test_malformed_row_date_is_not_accepted(self):
result = normalize_rows([row(trade_date='20261340')], DAY)
self.assertEqual(result['invalid'], {CODE: 'INVALID_DATE'})
def test_nan_bool_infinity_and_negative_prices_rejected(self):
for field in ('pre_close', 'up_limit', 'down_limit'):
for bad in (float('nan'), float('inf'), Decimal('NaN'), Decimal('sNaN'),
Decimal('Infinity'), True, False, -1, None, 'oops', '1e999999'):
with self.subTest(field=field, bad=repr(bad)):
result = normalize_rows([row(**{field: bad})], DAY)
self.assertEqual(result['records'], {})
self.assertEqual(result['invalid'], {CODE: 'INVALID_PRICE'})
def test_zero_limits_are_unsupported_without_fabrication(self):
for changes in ({'up_limit': 0}, {'down_limit': '0'}, {'up_limit': 0, 'down_limit': 0}):
result = normalize_rows([row(**changes)], DAY)
self.assertEqual(result['invalid'], {CODE: 'UNSUPPORTED'})
self.assertFalse(result['records'])
def test_preclose_must_be_positive_and_within_inclusive_limits(self):
for close, error in ((0, 'INVALID_PRE_CLOSE'), ('8.99', 'PRE_CLOSE_OUTSIDE_LIMITS'),
('11.01', 'PRE_CLOSE_OUTSIDE_LIMITS')):
self.assertEqual(normalize_rows([row(pre_close=close)], DAY)['invalid'][CODE], error)
for close in ('9.00', '11.00'):
self.assertIn(CODE, normalize_rows([row(pre_close=close)], DAY)['records'])
def test_equal_or_inverted_limits_are_rejected(self):
for changes in ({'down_limit': 11}, {'down_limit': 12}):
self.assertEqual(normalize_rows([row(**changes)], DAY)['invalid'][CODE], 'INVALID_RANGE')
def test_subcent_values_are_rejected_instead_of_rounded(self):
for field in ('pre_close', 'up_limit', 'down_limit'):
result = normalize_rows([row(**{field: '10.001'})], DAY)
self.assertEqual(result['invalid'][CODE], 'INVALID_PRECISION')
result = normalize_rows([row(pre_close=10.000000000000002)], DAY)
self.assertEqual(result['invalid'][CODE], 'INVALID_PRECISION')
def test_decimal_equivalents_have_same_content_version(self):
expected = normalize_rows([row()], DAY)['records'][CODE]
equivalents = row(pre_close=10, up_limit=Decimal('11.0000'), down_limit=9.0)
actual = normalize_rows([equivalents], DAY)['records'][CODE]
self.assertEqual(expected, actual)
self.assertEqual(expected['pre_close'], '10.00')
self.assertEqual(len(expected['version']), 64)
json.dumps(actual, allow_nan=False)
changed = normalize_rows([row(up_limit='11.01')], DAY)['records'][CODE]
self.assertNotEqual(expected['version'], changed['version'])
def test_decimal_context_does_not_change_price_validation(self):
with localcontext() as context:
context.prec = 2
self.assertIn(CODE, normalize_rows([row(pre_close='10.01')], DAY)['records'])
def test_identical_duplicates_deduplicate_but_conflicts_poison_security(self):
result = normalize_rows([row(), row(pre_close=10.0)], DAY)
self.assertEqual(len(result['records']), 1)
self.assertEqual(result['invalid'], {})
for values in ([row(), row(up_limit='12.00'), row()],
[row(up_limit='12.00'), row(), row(up_limit='12.00')]):
result = normalize_rows(values+[row(ts_code=OTHER)], DAY)
self.assertEqual(result['invalid'], {CODE: 'DUPLICATE_CONFLICT'})
self.assertEqual(set(result['records']), {OTHER})
def test_bad_price_row_cannot_be_hidden_by_good_duplicate(self):
for values in ([row(), row(pre_close=False)], [row(pre_close=False), row()]):
result = normalize_rows(values, DAY)
self.assertFalse(result['records'])
self.assertEqual(result['invalid'][CODE], 'INVALID_PRICE')
def test_requested_scope_rejects_unknown_return_code(self):
result = normalize_rows([row(), row(ts_code=OTHER)], DAY, [CODE])
self.assertEqual(result['invalid'], {OTHER: 'NOT_REQUESTED'})
self.assertEqual(set(result['records']), {CODE})
for codes in (None, []):
self.assertEqual(len(normalize_rows([row(), row(ts_code=OTHER)], DAY, codes)['records']), 2)
def test_beijing_is_rejected_at_entry_without_examining_its_prices(self):
result = normalize_rows([row(ts_code='920001.BJ', pre_close=False), row()], DAY)
self.assertEqual(result['invalid'], {'920001.BJ': 'OUT_OF_SCOPE'})
self.assertEqual(set(result['records']), {CODE})
def test_missing_local_field_is_isolated_and_input_is_unchanged(self):
missing = row()
missing.pop('pre_close')
values = [missing, row(ts_code=OTHER)]
snapshot = copy.deepcopy(values)
result = normalize_rows(values, DAY)
self.assertEqual(result['invalid'], {CODE: 'MISSING_FIELD'})
self.assertEqual(set(result['records']), {OTHER})
self.assertEqual(values, snapshot)
def test_invalid_collection_structure_is_top_level_error(self):
for rows in (None, {}, 'secret', [row(), None]):
result = normalize_rows(rows, DAY)
self.assertTrue(result['errors'])
self.assertFalse(result['records'])
for requested in ('600000.SH', ['920001.BJ'], [False]):
self.assertEqual(normalize_rows([row()], DAY, requested)['errors'], ['INVALID_REQUESTED_CODES'])
def test_provider_field_order_and_extra_fields_are_supported(self):
fields = ['unused']+list(reversed(REQUIRED_FIELDS))
result = provider_decode(body(fields=fields), DAY, [CODE])
self.assertEqual(result, normalize_rows([row()], DAY, [CODE]))
def test_provider_errors_never_echo_secret_message_or_arbitrary_code(self):
secret = 'secret-token-must-not-appear'
for value in ({'code': -2001, 'msg': secret}, {'code': False, 'data': secret},
{'code': '0', 'msg': secret}, {'code': 0, 'data': secret}, None):
result = provider_decode(value, DAY, [CODE])
self.assertTrue(result['errors'])
self.assertNotIn(secret, json.dumps(result))
result = normalize_rows([row(ts_code=secret)], DAY)
self.assertEqual(result['invalid'], {'row:1': 'INVALID_CODE'})
self.assertNotIn(secret, json.dumps(result))
def test_provider_missing_duplicate_or_invalid_fields_reject_batch(self):
for fields in ([], ['ts_code'], list(REQUIRED_FIELDS)+['ts_code'],
list(REQUIRED_FIELDS)+[False], list(REQUIRED_FIELDS)+[[]]):
value = body()
value['data']['fields'] = fields
result = provider_decode(value, DAY)
self.assertTrue(result['errors'])
self.assertFalse(result['records'])
def test_provider_item_structure_rejects_entire_batch(self):
for item in (None, {}, 'not-a-row', [CODE], list(range(len(REQUIRED_FIELDS)+1))):
value = body()
value['data']['items'].append(item)
result = provider_decode(value, DAY)
self.assertEqual(result['errors'], ['INVALID_PROVIDER_ITEM_STRUCTURE'])
self.assertFalse(result['records'])
def test_provider_maximum_rows_and_empty_response(self):
value = body()
value['data']['items'] *= MAX_ROWS
self.assertIn(CODE, provider_decode(value, DAY)['records'])
value['data']['items'].append(value['data']['items'][0])
self.assertEqual(provider_decode(value, DAY)['errors'], ['TOO_MANY_ROWS'])
self.assertEqual(normalize_rows([row()]*(MAX_ROWS+1), DAY)['errors'], ['TOO_MANY_ROWS'])
self.assertEqual(provider_decode(body(rows=[]), DAY), {'records': {}, 'invalid': {}, 'errors': []})
def test_provider_passes_through_per_security_quarantine(self):
result = provider_decode(body([row(trade_date='20261102'), row(ts_code=OTHER)]), DAY, [CODE, OTHER])
self.assertEqual(result['invalid'], {CODE: 'DATE_MISMATCH'})
self.assertEqual(set(result['records']), {OTHER})
if __name__ == '__main__':
unittest.main(verbosity=2)