From 8344ed6e6b5919a2efe1ead66567ae538ee9d41e Mon Sep 17 00:00:00 2001 From: openbot-coder Date: Thu, 22 Oct 2026 09:06:40 +0800 Subject: [PATCH] =?UTF-8?q?fix:=20=E4=BF=AE=E5=A4=8D=E6=B2=AA=E5=B8=82?= =?UTF-8?q?=E6=8C=87=E6=95=B0=E4=BB=B7=E6=A0=BC=E5=B0=9110=E5=80=8D=20+=20?= =?UTF-8?q?=E9=80=90=E7=AC=94=E7=AB=9E=E4=BB=B7=E5=A7=94=E6=89=98=E6=B1=A1?= =?UTF-8?q?=E6=9F=93=EF=BC=88=CE=A3vol=20=E8=99=9A=E9=AB=98/=E8=B7=A8?= =?UTF-8?q?=E4=B8=BB=E6=9C=BA=E4=B8=8D=E7=A8=B3=E5=AE=9A=EF=BC=89=20(#3)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 核对 sh000016 上证50 与 50 只成分股的 tick 汇总时,发现三个口径 (快照/分时/逐笔)互不一致,追查到 5 个缺陷。 1. 沪市指数价格整体少 10 倍 price_decimal_digits 把沪市 000xxx(上证/上证50/沪深300/科创50)与 8xxxxx(板块指数)判为 3 位小数,实际协议是 2 位。 上证指数 3713 -> 371、上证50 2747 -> 274。 实证 6 只指数 + 2 只板块指数全部 ×10,而 ETF/股票/科创板/深市全类 ×1 正确。 改法:沪市仅 ETF(5开头) 保留 3 位,其余 2 位。 2. get_ticks 把 bs_flag=8 竞价委托当成成交 该记录是 09:15~09:25 / 14:57~15:00 竞价段的撮合委托快照, vol 是累计值(可被后续覆盖),不是成交增量。 - Σvol 虚高:sh600000 含 b8 = 668,693 vs 快照 462,562(1.4456); 剔 b8 = 462,634(1.000156,精确一致) - 跨主机不稳定:干净主机 0 条、脏主机 135 条 -> 同一 start 落到不同真实成交 改法:分页后统一剔除 b8。 3. A股逐笔改单连接串行游标(_ticks_cn_serial) 并发分页各页来自不同主机,而 0x122F 的 start 是「从最新往回数」的相对锚点, 主机间 b8 收录差异导致页边界既重叠(冗余 116 条)又漏条(13:03 附近丢 59 条)。 逐笔单日仅 5~6 页,串行开销可忽略。 4. trade_count 有符号解析(前序)、返回列表时间序(前序)保留。 - sh000016 三口径闭合:快照 vol/amount 比值 1.00000061/0.99999997; 指数逐笔 Σvol = 分时 Σvol = 1,045,584,467(完全相等) - 6 只标的 Σvol/快照 vol 全部回到 1.0001~1.0007 - 跨主机公共时间窗逐条一致(5/5 标的,条数差 0) - 测试 194 -> 217 passed(+20 小数位、+3 逐笔回归) - TransactionRecord 类注释 + get_ticks docstring 明示指数语义: vol 单位「百元」(成交额/100)、trade_count 为「均价×1000」而非笔数 - API_REFERENCE / llms.txt 同步 Co-authored-by: openbot-coder --- CHANGELOG.md | 81 +++++++ docs/API_REFERENCE.md | 2 +- docs/llms.txt | 2 +- src/pytdxdata/api.py | 114 ++++++++-- src/pytdxdata/models/__init__.py | 28 ++- src/pytdxdata/protocol/commands/quotes.py | 19 +- .../protocol/commands/transaction.py | 5 +- src/pytdxdata/scheduler/paginator.py | 10 +- tests/test_api.py | 212 +++++++++++++++++- tests/test_protocol.py | 59 +++++ 10 files changed, 493 insertions(+), 39 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2496d04..27836be 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,87 @@ 本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。 +## [未发布] + +### 修复 + +- **`get_ticks()` 返回列表不是时间序,每 `page_size` 处时间回跳一次**。 + + `0x122F`(A股逐笔)与 EX 逐笔通道的偏移量 `start` 都是**从最新一笔往回数**的: + 实测 `sh600000`,`start=0` 返回 `14:07:48..15:20:16`(当天最新 1000 条), + `start=4000` 返回 `09:15:03..09:41:18`(当天最早)。而 `paginator` 按 `start` + 升序拼接,于是拼出"新的块在前、旧的块在后"的倒序结构: + + | | 修复前 | 修复后 | + |---|---|---| + | `sh600000` 时间轴 | 4 处逆序跳跃(index 999 / 1999 / 2999) | 严格升序 | + | `hk00700` 时间轴 | 21 处逆序跳跃(每 1800 条一次) | 严格升序 | + + 修复分两层:① `PageSpec.newest_first=True` 让 `paginator` 反页序拼装(页内本身升序, + 只翻页序),这条能力保留给将来需要按"最新优先"锚点分页的命令;② A股逐笔最终改为 + **单连接串行游标**(见下一条),从根上避开多主机锚点错位。 + + **`start` 参数语义同时明确**:它是"从最新往回数的偏移",不是"从最早往后数的偏移", + `docstring` 已补充。注意这修正的是**顺序**,数据本身无缺口、无重复(4304 条唯一时间戳)。 + +- **`TransactionRecord.trade_count` 在集合竞价段被读成 42 亿量级脏值**。 + + 该字段在协议里是**有符号** `int32`,但解析格式串写的是无符号 `I`。集合竞价段 + (`bs_flag=8`)真实值为负数,按 uint32 解出 `4294966422`: + + ``` + 原始 18 字节: 17820000 0ad71b41 d9000000 96fcffff 0800 + 修复前: trade_count = 4294966422 + 修复后: trade_count = -874 ← 0xfffffc96 的 int32 补码 + ``` + + 实测 `sh600000` 全天 4304 条中有 **38 条**命中(占 0.88%),全部落在 09:15~09:25 + 集合竞价段;正常交易段(`bs_flag` 0/1/2/5)**无一条为负**。旧行为会让 + `max()` / `mean()` 等统计直接失真(曾算出 `mean=37,920,247`)。 + + 格式串由 `80 只自动切批)、`get_snapshot`(个股特征)、`get_market_stat` -- **逐笔 / 分时**:`get_ticks`(含 `trade_count`,支持历史日期)、`get_minutes`(`sampling=True` 取缩略采样) +- **逐笔 / 分时**:`get_ticks`(含 `trade_count`,支持历史日期,返回按时间升序;`vol`/`trade_count` 为约 3 秒切片增量而非累计;已剔除 `bs_flag=8` 竞价委托;**指数**的 `vol` 是百元、`trade_count` 是均价×1000)、`get_minutes`(`sampling=True` 取缩略采样) - **财务 / 除权**:`get_finance`(最新快照)、`get_xdxr`、`get_price_limits`(本地计算涨跌停) - **F10**:`get_f10`(公司资料目录 + 正文) - **板块**:`get_boards`、`get_board_members`、`get_board_of`、`get_board_summary`、 diff --git a/src/pytdxdata/api.py b/src/pytdxdata/api.py index 3d9a084..214a8e2 100644 --- a/src/pytdxdata/api.py +++ b/src/pytdxdata/api.py @@ -146,6 +146,8 @@ _EX_PAGE = 1000 # EX 商品列表单页 _TICK_PAGE = 1000 # MAC 逐笔单页 _EX_TICK_PAGE = 1800 # 港股逐笔单页 _ALL_PAGES_CAP = 50 # count=None(全量)时的翻页上限 +# 集合竞价**委托**记录标记(0x122F 第 5 字段)。不是成交,见 _ticks_one 注释。 +_BS_AUCTION_ORDER = 8 # 港股系市场:逐笔走 EX 专用 16B 协议(0x23FC/0x2406),其余扩展市场走 MAC 0x122F _HK_MARKETS = frozenset({27, 31, 48, 49, 71, 98}) @@ -795,12 +797,26 @@ class TdxData: 参数: date: ``None``=当日,``YYYYMMDD``=历史某日。 - start: 起始偏移。 + start: 起始偏移,**从最新一笔往回数**(``0``=当天最后一条)。 + ``start=1000`` 表示跳过最近 1000 条、从更早的位置开始。 count: ``None``=尽量取全量(自动翻页,上限 50 页);给了就取这么多条。 返回: - ``list[TransactionRecord]``,按入参标的顺序拼接(A股含 ``trade_count``, - 港股为 HH:MM 时间 + ``fields["zengcang"]`` 增仓)。 + ``list[TransactionRecord]``,按入参标的顺序拼接,**每条标的内部按时间升序**。 + 注意服务端是按约 3 秒聚合的切片,``vol``/``trade_count`` 是切片增量 + 而非当日累计。 + A股含 ``trade_count``,港股为 HH:MM 时间 + ``fields["zengcang"]`` 增仓。 + + **集合竞价委托(``bs_flag=8``)不会出现在结果里**:它们不是成交,``vol`` + 是累计撮合量(会被后续记录覆盖),计入会让 Σvol 比真值虚高 20%~160%, + 且不同主机收录的条数不同 → 同一查询两次调用结果不一致。 + + **指数(``sh000016`` 等)的两个字段语义与个股不同**: + + - ``vol`` 单位是**百元**(成交额/100),不是手。 + - ``trade_count`` 是**当时均价 × 1000**,不是笔数。 + + 详见 :class:`~pytdxdata.models.TransactionRecord` 的类注释。 """ syms = parse_symbols(symbols) sem = asyncio.Semaphore(max(1, concurrency)) @@ -821,18 +837,19 @@ class TdxData: if sym.is_ex: rows = await self._ticks_ex(sym, date=date, start=start, count=count) else: - def make_cmd(s: int, c: int): - return MacTransactionCmd(sym.market, sym.code, date or 0, s, c) - - spec = PageSpec( - page_size=_TICK_PAGE, - total=None if count is None else start + count, - min_page=100, - stop_when_short=True, - max_pages=_ALL_PAGES_CAP if count is None else None, - start_offset=start, - ) - rows = await self._fetch_paginated_list("mac", make_cmd, spec) + rows = await self._ticks_cn_serial(sym, date=date, start=start, + count=count) + # ★ 过滤集合竞价**委托**记录(bs_flag=8)。必须在逐页拉取**全部结束之后**做: + # 分页靠 `len(rows) < page_size` 判终止,若在 parse_response 里过滤, + # 满页会被剥短成"短页" → 提前终止 → 丢数据。 + # 实测(2026-10-21 sh600000):b8 是 09:15~09:25 / 14:57~15:00 竞价段的 + # 撮合快照,vol 是**累计值**(可被后续记录覆盖),不是成交增量; + # 计入后 Σvol 比真值虚高 20%~160%,且**不同主机的 b8 集合不同** + # (干净主机 0 条、脏主机 135 条)→ 同一查询两次调用结果不一致。 + # 剔除后:Σvol 与快照 vol 精确相等(比值 1.0000),且跨主机逐条一致。 + rows = [r for r in rows if r.bs_flag != _BS_AUCTION_ORDER] + # 排序放在 pack 之前,让缓存直接存入正确顺序,避免每次命中都重排。 + rows.sort(key=lambda r: r.time) return pack_payload(rows) records = unpack_payload(await self._cache.get_or_fetch(key, fetch)) @@ -840,6 +857,54 @@ class TdxData: r.symbol = sym.text return records + async def _ticks_cn_serial(self, sym: Symbol, *, date: int | None, start: int, + count: int | None) -> list[TransactionRecord]: + """A股逐笔(0x122F)**单连接串行游标**翻页。 + + 为什么不用并发分页器:``0x122F`` 的 ``start`` 是「从**最新一笔**往回数的偏移」, + 是个**相对锚点**,不是稳定的绝对序号。而池里各主机对集合竞价委托(``bs_flag=8``) + 的收录**不一致**(实测干净主机 0 条、脏主机 135 条),同一 ``start`` 在不同主机上 + 落到**不同的真实成交**上。并发分页 = 各页来自不同主机 → 页边界既**重叠** + (sh600000 冗余 116 条)又**漏条**(13:03 附近丢 59 条),Σvol 偏移 −1.2%。 + + 逐笔单日仅 5~6 页(1000 条/页),串行开销可忽略、换来精确一致, + 故这里固定**单连接**、按 ``start`` 递增(= 向更早方向)推进。 + + 返回:按页序累加后再**整体翻转**,得到时间升序的完整列表。 + """ + chunks: list[list[TransactionRecord]] = [] + pos = start + remaining = count + pc = await self._mac_pool.acquire() + try: + for _ in range(_ALL_PAGES_CAP): + n = _TICK_PAGE if remaining is None else min(_TICK_PAGE, remaining) + if n <= 0: + break + rows = await pc.execute( + MacTransactionCmd(sym.market, sym.code, date or 0, pos, n)) + if not rows: + break + chunks.append(list(rows)) + pos += len(rows) + if remaining is not None: + remaining -= len(rows) + if remaining <= 0: + break + # 短页 = 已到最早一笔 + if len(rows) < n: + break + except Exception: + await self._mac_pool.release(pc, broken=True) + raise + await self._mac_pool.release(pc) + out: list[TransactionRecord] = [] + for chunk in reversed(chunks): + out.extend(chunk) + for r in out: + r.symbol = sym.text + return out + async def _ticks_ex(self, sym: Symbol, *, date: int | None, start: int, count: int | None) -> list[TransactionRecord]: from .protocol.commands.ex_ext import ( @@ -848,7 +913,7 @@ class TdxData: ) hk = sym.market in _HK_MARKETS page = _EX_TICK_PAGE if hk else _TICK_PAGE - out: list[TransactionRecord] = [] + chunks: list[list[TransactionRecord]] = [] pos = start remaining = count for _ in range(_ALL_PAGES_CAP): @@ -860,22 +925,27 @@ class TdxData: if date else GetExTransactionDataCmd(sym.market, sym.code, pos, n)) rows = await self._execute_ex(cmd) - out.extend(self._ex_tick(sym, r) for r in rows) + chunk = [self._ex_tick(sym, r) for r in rows] else: cmd = MacTransactionCmd(sym.market, sym.code, date or 0, pos, n) rows = await self._execute_ex(cmd) for r in rows: r.symbol = sym.text - out.extend(rows) - if not rows: + chunk = list(rows) + if not chunk: break - pos += len(rows) + # EX 通道的 pos 同样是"从最新往回数",逐页倒序累加 → 最后整体翻转。 + chunks.append(chunk) + pos += len(chunk) if remaining is not None: - remaining -= len(rows) + remaining -= len(chunk) if remaining <= 0: break - if len(rows) < n: + if len(chunk) < n: break + out: list[TransactionRecord] = [] + for chunk in reversed(chunks): + out.extend(chunk) return out @staticmethod diff --git a/src/pytdxdata/models/__init__.py b/src/pytdxdata/models/__init__.py index 9f4459a..d285e42 100644 --- a/src/pytdxdata/models/__init__.py +++ b/src/pytdxdata/models/__init__.py @@ -228,14 +228,34 @@ class SecurityInfo: @dataclass(slots=True) class TransactionRecord: - """逐笔成交(跨市场统一模型;A股 MAC 通道含 trade_count=成交笔数)""" + """逐笔成交(跨市场统一模型;A股 MAC 通道含 trade_count=成交笔数)。 + + 注意(实测 2026-10-21): + + - 服务端是按**约 3 秒聚合**返回的切片,不是交易所原始逐笔成交。 + - ``vol`` / ``trade_count`` 都是**该切片自身的增量**,不是当日累计值。 + - ``trade_count`` 为**有符号**值:集合竞价段(``bs_flag=8``)会是负数 + (实测 sh600000 09:15 段为 -874),不要对全表直接求 max/mean。 + - 返回列表已按时间升序,但同秒多条时顺序不保证。 + - ``bs_flag=8`` 的**竞价委托记录已被 ``get_ticks()`` 过滤掉**,不会出现在结果里。 + + **指数语义完全不同**(``is_cn_index`` 为真时,如 ``sh000016``): + + - ``vol`` 单位是**百元**(= 成交额 / 100),不是「手」。实测 + ``快照amount / Σtick.vol = 100.0002``,且 ``Σtick.vol`` 与分时 Σvol **逐位相等**。 + 想和成分股成交量对比必须先换算,直接比会得到 ~26 倍的假比例。 + - ``trade_count`` **不是笔数**,而是**当时均价 × 1000**(实测 tc/1000 与分时 + ``avg_price`` 的差 < 1.1)。指数没有「成交笔数」概念。 + - ``bs_flag`` 语义不成立(实测返回 2,而模型只定义 0=卖 / 1=买)。 + """ + market: int code: str time: str # HH:MM:SS(扩展市场为 HH:MM) price: float - vol: float # 手(MAC逐笔) - trade_count: int # 成交笔数(MAC=逐笔记录字段;标准当日逐笔协议也有但需单独解析) - bs_flag: int # 1=主动买 0=主动卖 + vol: float # 股票=手;指数=百元(成交额/100),见类注释 + trade_count: int # 股票=笔数增量;指数=均价×1000,见类注释 + bs_flag: int # 1=主动买 0=主动卖 2=中性 5=盘后固定价(指数语义不成立) symbol: str = "" fields: dict[str, float] = field(default_factory=dict) # 扩展市场额外字段(增仓等) diff --git a/src/pytdxdata/protocol/commands/quotes.py b/src/pytdxdata/protocol/commands/quotes.py index 1e84d68..bfe0b07 100644 --- a/src/pytdxdata/protocol/commands/quotes.py +++ b/src/pytdxdata/protocol/commands/quotes.py @@ -13,16 +13,23 @@ MAX_QUOTES = 80 def price_decimal_digits(market: int, code: str) -> int: - """推断报价有效小数位:股票2位(/100)、指数/ETF/基金/转债/国债3位(/1000)。""" + """推断报价有效小数位:股票 2 位(/100)、ETF/基金 3 位(/1000)。 + + **沪市指数必须是 2 位**,此前把 ``000``/``8`` 一并判成 3 位,导致上证50、 + 上证指数、科创50 等**价格整体少 10 倍**。实证(2026-10-21):协议原始整数 + 与分时/逐笔价格比对,6 只沪市指数 + 2 只板块指数(880001/880305)全部是 + ``×10`` 错误,而 4 只沪市 ETF(510300/510500/588000/511010)、4 只沪市 + 股票、3 只科创板、3 只深市指数、深市股票/创业板/ETF 全部 ``×1`` 正确。 + """ code = (code or "").strip().rstrip("\x00") if market == 1: # SH - if code.startswith(("5", "000", "8")): - return 3 - return 2 + if code.startswith("5"): + return 3 # ETF/基金 + return 2 # 指数(000xxx/880xxx)、股票(60xxxx/688xxx) if market == 0: # SZ if code.startswith("1"): - return 3 - return 2 + return 3 # 基金/债券 + return 2 # 指数(399xxx)、股票(00xxxx/30xxxx) return 2 diff --git a/src/pytdxdata/protocol/commands/transaction.py b/src/pytdxdata/protocol/commands/transaction.py index 155be90..015b6de 100644 --- a/src/pytdxdata/protocol/commands/transaction.py +++ b/src/pytdxdata/protocol/commands/transaction.py @@ -111,8 +111,11 @@ class MacTransactionCmd(BaseCommand[list[TransactionRecord]]): for i in range(count): offset = 39 + i * 18 try: + # trade_count 必须按**有符号** int32 解析:集合竞价段(bs_flag=8) + # 该字段实为负值,按 uint32 会读出 42 亿量级的脏数据。 + # 实测(2026-10-21 sh600000):09:15:03 原始 96fcffff = -874。 time_sec, price, volume, trade_count, bs_flag = unpack_from( - " list[tuple[int, int]]: """切页:返回 [(start, count), ...]。""" @@ -158,9 +159,12 @@ class Paginator: return None, False return None, False - def _assemble(self, results: list[PageResult], ordered: bool) -> list[Any]: + def _assemble(self, results: list[PageResult], ordered: bool, + newest_first: bool = False) -> list[Any]: + # newest_first=True:start=0 是最新一页,start 越大越旧 → 反向拼才对得上时间序。 + # 单页内部服务端已按时间升序,所以只翻页序,不翻页内元素。 if ordered: - results.sort(key=lambda r: r.start) + results.sort(key=lambda r: r.start, reverse=newest_first) out: list[Any] = [] for r in results: out.extend(r.items) diff --git a/tests/test_api.py b/tests/test_api.py index 59f3822..7111649 100644 --- a/tests/test_api.py +++ b/tests/test_api.py @@ -8,7 +8,13 @@ import unittest.mock as mock import pytest from pytdxdata.api import TdxData -from pytdxdata.models import KlinePeriod, Market, MinuteBar, SecurityBar +from pytdxdata.models import ( + KlinePeriod, + Market, + MinuteBar, + SecurityBar, + TransactionRecord, +) from pytdxdata.protocol.commands.mac_tick import MacTickChartCmd from pytdxdata.scheduler.paginator import PageSpec, Paginator @@ -243,6 +249,70 @@ async def test_paginator_start_offset_default_zero(): assert result[0].close == 10.0 # 从 offset 0 开始 +# ---------- Paginator 逆序偏移(服务端 start 从最新往回数) ---------- + +class NewestFirstConn: + """模拟 0x122F 真实行为:start=0 返回**最新**的一页,start 越大越旧。 + + 实测依据(2026-10-21,sh600000): + start=0 -> 14:07:48 .. 15:20:16(当天最新 1000 条) + start=4000 -> 09:15:03 .. 09:41:18(当天最早) + 每页内部按时间升序,页与页之间是倒序。 + """ + + def __init__(self, total: int, page_size: int): + self.total = total + self.page_size = page_size + self.executed: list[tuple[int, int]] = [] + + async def execute(self, cmd): + start, count = cmd + self.executed.append((start, count)) + # 服务端语义:偏移 start 是从"最新"往回数,所以取倒数区间 + end_from_oldest = self.total - start + begin_from_oldest = max(0, end_from_oldest - count) + return [_make_bar(i) for i in range(begin_from_oldest, end_from_oldest)] + + +@pytest.mark.asyncio +async def test_paginator_newest_first_offset_returns_chronological(): + """服务端 start 从最新往回数时,交付列表必须仍是时间升序(BUG 回归)。""" + conns = [NewestFirstConn(3000, 1000) for _ in range(3)] + pool = FakePool(conns) + pag = Paginator(pool, concurrency=3) # type: ignore[arg-type] + + def factory(s, c): + return (s, c) + + result = await pag.fetch_all( + factory, PageSpec(page_size=1000, total=3000, newest_first=True)) + assert len(result) == 3000 + # 时间升序:close 随 index 单调递增 + closes = [b.close for b in result] + assert closes == sorted(closes), "返回列表必须按时间升序拼接" + assert result[0].close == pytest.approx(10.0) + assert result[-1].close == pytest.approx(10.0 + 2999 * 0.01) + + +@pytest.mark.asyncio +async def test_paginator_newest_first_respects_start_offset(): + """newest_first + start_offset:只取最近 N 条里的后段。""" + conns = [NewestFirstConn(3000, 1000) for _ in range(3)] + pool = FakePool(conns) + pag = Paginator(pool, concurrency=3) # type: ignore[arg-type] + + def factory(s, c): + return (s, c) + + result = await pag.fetch_all( + factory, + PageSpec(page_size=1000, total=1000, newest_first=True, start_offset=0)) + assert len(result) == 1000 + # 只取了最新的 1000 条 → 是 2000..2999 这一段 + assert result[0].close == pytest.approx(10.0 + 2000 * 0.01) + assert result[-1].close == pytest.approx(10.0 + 2999 * 0.01) + + # ---------- get_kline 日期过滤 ---------- class DateBarApiConn(FakeApiConn): @@ -329,3 +399,143 @@ async def test_get_kline_since(): assert bars[-1].year == 2027 finally: await td.close() + +# ---------- A股逐笔:b8 过滤 + 单连接串行游标(回归) ---------- + +class TickApiConn(FakeApiConn): + """模拟 0x122F:服务端 start 从**最新**往回数,且可注入 bs_flag=8 委托记录。""" + + # 类级:[(time, price, vol, trade_count, bs_flag), ...],时间升序(最早在前) + rows: list[tuple] = [] + calls: list[tuple[int, int]] = [] + + async def execute(self, cmd): + if "MacTransactionCmd" not in type(cmd).__name__: + return await super().execute(cmd) + TickApiConn.calls.append((cmd.start, cmd.count)) + # 从最新往回数:start 偏移落在末尾,往前取 count 条 + end = len(TickApiConn.rows) - cmd.start + begin = max(0, end - cmd.count) + chunk = TickApiConn.rows[begin:end] + return [TransactionRecord(market=1, code="600000", time=t, price=p, + vol=v, trade_count=tc, bs_flag=bs) + for (t, p, v, tc, bs) in chunk] + + +def _build_tick_rows(n_trade: int = 25, n_b8: int = 7) -> list[tuple]: + """构造 n_trade 条正常成交 + n_b8 条竞价委托(穿插在中间)。""" + rows: list[tuple] = [] + for i in range(n_trade): + rows.append((f"09:{30 + i // 60:02d}:{i % 60:02d}", 10.0 + i * 0.01, + 100.0 + i, 3 + i, 1 if i % 2 else 0)) + if i % 4 == 0 and len([r for r in rows if r[4] == 8]) < n_b8: + # 竞价委托:(time, price, vol, tc, bs=8),vol 是累计值、不计入成交 + rows.append((f"09:15:{i:02d}", 10.0, 9999.0, -1, 8)) + return rows + + +@pytest.mark.asyncio +async def test_get_ticks_filters_auction_orders(): + """bs_flag=8 是竞价**委托**快照,不是成交 → 必须从 get_ticks 结果中剔除。 + + 实测(2026-10-21 sh600000):b8 的 vol 是累计撮合量(可被覆盖), + 计入后 Σvol 比快照 vol 虚高 20%~160%,且不同主机的 b8 集合不同。 + """ + TickApiConn.rows = _build_tick_rows(n_trade=25, n_b8=7) + TickApiConn.calls = [] + assert sum(1 for r in TickApiConn.rows if r[4] == 8) == 7 + + with mock.patch("pytdxdata.api.get_standard_hosts", return_value=["s1"]), \ + mock.patch("pytdxdata.api.get_mac_hosts", return_value=["m1"]), \ + mock.patch("pytdxdata.pool.pool.TdxConnection", + side_effect=lambda h, p=7709, t=10.0: TickApiConn(h)): + td = TdxData(cache_dir=None, pool_min=1, pool_max=2) + await td.start() + try: + out = await td.get_ticks("sh600000") + finally: + await td.close() + + assert out, "应返回成交记录" + assert all(r.bs_flag != 8 for r in out), "bs_flag=8 竞价委托必须被剔除" + assert len(out) == 25 + assert sum(r.vol for r in out) == sum(100.0 + i for i in range(25)) + + +@pytest.mark.asyncio +async def test_get_ticks_pages_on_single_connection(): + """翻页必须走**同一连接**:并发多主机会让页边界错位(重叠 + 漏条)。""" + TickApiConn.rows = _build_tick_rows(n_trade=25, n_b8=0) + TickApiConn.calls = [] + + with mock.patch("pytdxdata.api.get_standard_hosts", return_value=["s1"]), \ + mock.patch("pytdxdata.api.get_mac_hosts", return_value=["m1", "m2", "m3"]), \ + mock.patch("pytdxdata.pool.pool.TdxConnection", + side_effect=lambda h, p=7709, t=10.0: TickApiConn(h)): + td = TdxData(cache_dir=None, pool_min=1, pool_max=4) + await td.start() + try: + out = await td.get_ticks("sh600000") + finally: + await td.close() + + # 单页装得下 → 只发一次请求 + assert len(TickApiConn.calls) == 1 + assert len(out) == 25 + # 时间升序 + times = [r.time for r in out] + assert times == sorted(times) + +@pytest.mark.asyncio +async def test_get_ticks_multi_page_uses_one_connection_and_no_overlap(): + """多页(>_TICK_PAGE):同一连接、游标按 len(rows) 推进、页间不重叠不漏条。 + + 回归:并发分页时各页来自不同主机,而 0x122F 的 start 是「从最新往回数」的 + 相对锚点 —— 各主机对 bs_flag=8 收录不同,同一 start 落到不同真实成交上, + 结果页边界既重叠又漏条(实测 sh600000 冗余 116 条、13:03 附近丢 59 条)。 + """ + from pytdxdata.api import _TICK_PAGE + + n = _TICK_PAGE * 2 + 137 # 3 页,末页短页 → 触发 stop_when_short + TickApiConn.rows = [ + (f"{9 + i // 3600:02d}:{i // 60 % 60:02d}:{i % 60:02d}", + 10.0 + i * 0.001, 1.0 + i, 1 + i, 1) + for i in range(n) + ] + TickApiConn.calls = [] + + with mock.patch("pytdxdata.api.get_standard_hosts", return_value=["s1"]), \ + mock.patch("pytdxdata.api.get_mac_hosts", return_value=["m1", "m2", "m3"]), \ + mock.patch("pytdxdata.pool.pool.TdxConnection", + side_effect=lambda h, p=7709, t=10.0: TickApiConn(h)): + td = TdxData(cache_dir=None, pool_min=1, pool_max=4) + await td.start() + try: + out = await td.get_ticks("sh600000") + finally: + await td.close() + + # 恰好 3 页:0 / 1000 / 2000,游标按实际返回条数推进 + assert TickApiConn.calls == [(0, _TICK_PAGE), + (_TICK_PAGE, _TICK_PAGE), + (_TICK_PAGE * 2, _TICK_PAGE)] + assert len(out) == n, f"必须无重叠、无漏条:期望 {n},实得 {len(out)}" + vols = [r.vol for r in out] + assert len(set(vols)) == n, "vol 全唯一(无重复记录)" + assert vols == sorted(vols), "时间升序" + + # count 参数:游标逐页扣减 + TickApiConn.calls = [] + with mock.patch("pytdxdata.api.get_standard_hosts", return_value=["s1"]), \ + mock.patch("pytdxdata.api.get_mac_hosts", return_value=["m1", "m2", "m3"]), \ + mock.patch("pytdxdata.pool.pool.TdxConnection", + side_effect=lambda h, p=7709, t=10.0: TickApiConn(h)): + td = TdxData(cache_dir=None, pool_min=1, pool_max=4) + await td.start() + try: + out2 = await td.get_ticks("sh600000", count=_TICK_PAGE + 50) + finally: + await td.close() + assert len(out2) == _TICK_PAGE + 50 + assert TickApiConn.calls[1][1] == 50, "末页只补足剩余 50 条" + diff --git a/tests/test_protocol.py b/tests/test_protocol.py index 47c8986..c737139 100644 --- a/tests/test_protocol.py +++ b/tests/test_protocol.py @@ -12,6 +12,7 @@ from pytdxdata.protocol.commands.ex_proto import GetExInstrumentBarsCmd from pytdxdata.protocol.commands.kline import GetSecurityBarsCmd from pytdxdata.protocol.commands.mac import MacKlineCmd from pytdxdata.protocol.commands.minute import GetHistoryMinuteTimeDataCmd +from pytdxdata.protocol.commands.quotes import price_decimal_digits from pytdxdata.protocol.commands.transaction import MacTransactionCmd from pytdxdata.protocol.frame import FrameHeader, decompress_body, parse_header from pytdxdata.protocol.price import decode_ohlc_diffs, get_price, put_price @@ -181,6 +182,30 @@ def test_mac_transaction_parse(): assert recs[1].trade_count == 1 +def test_mac_transaction_parse_negative_trade_count_auction(): + """集合竞价段 trade_count 是有符号 int32,负数不能被读成 42 亿(BUG 回归)。 + + 实测(2026-10-21,sh600000 09:15:03):18 字节为 + 17820000 0ad71b41 d9000000 96fcffff 0800 + 最后四字节前的 96fcffff = int32 -874,旧解析按 uint32 得 4294966422。 + """ + body = bytearray(39 + 2 * 18) + struct.pack_into("