16 Commits
Author SHA1 Message Date
openbotandopenbot-coder 2cf3657f4b fix: get_universe 请求多发 2 字节污染连接(冷启动 12~18s → 1.6s) (#11)
## 根因

GetSecurityListCmd 请求体应为「12 字节命令头 + market(H) + start(H)」= 16 字节,
实现里多塞了一个 H(写死 0),实际发 18 字节。服务端只消费前 16 字节,剩下的
00 00 停在它接收缓冲里,把下一个请求的开头吃掉 —— 同一连接「第一次成功、
第二次起永远无响应」。

对照实验(同一主机、同一命令):
- 18 字节:第 1 次 OK,第 2/3 次全部 ConnectionError
- 16 字节:连发 3 次全部 OK(27 台主机复测,第二次请求 27/27 成功,此前 0/27)

分页器复用连接,等于每页都要先失败重连,冷启动被拖到 12~18s 且常直接报错。

| 场景 | 前 | 后 |
|---|---|---|
| get_universe("sh") 冷(27,534 条/28 页) | 12,267ms | 1,610ms |
| get_universe("sz") 冷(24,460 条/25 页) | 18,260ms | 571ms |
| get_universe() 全市场冷(146,848 条) | 19,085ms | 4,371ms |
| get_universe() 热 | — | 669ms |

## 北交所清单优雅降级

0x053E 对 market=2 在 27 台标准主机上全部无响应(26 台 6s 无回包、1 台立刻拒连),
同市场 0x053D 数量接口正常(389)。原实现重试 2 次×3s 后抛错,连带
get_universe() 整批失败。现直接返回空列表 + WARNING 一次。

北交所标的本身没问题:get_quotes("bj920992")/get_bars/逐笔全正常
(实测 11.79 与日线 close 一致)。

## 优化

- get_universe() 的 EX 全量只取一次(命中缓存也要反序列化 10 万条 ~200ms,
  原先十几个 EX 市场各来一次)
- EX 商品列表改并发翻页(110 页,8 并发)

## 文档 / 测试

- get_universe docstring、API_REFERENCE、llms.txt、SKILL.md 写明北交所限制
- 新增 tests/test_universe.py 7 项:请求长度锁 16 字节、无尾部 padding、
  北交所返回空且不碰连接池、_ex_all 只取一次

## 已知限制(非本次引入)

EX 全量含非证券条目(人员名录),(market, code) 原始数据里就不唯一,
重复出现在同一页内部;属数据源特性,未去重。

版本 0.6.8 → 0.6.9;测试 354 → 361 全通过。

Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-23 15:24:17 +08:00
openbotandopenbot-coder dc78d81be8 fix(cli): 价格按品种小数位显示 + 分时时间列改真实时钟 (0.6.8) (#10)
* fix(cli): price decimals per instrument + minute time column

1) 价格按品种小数位显示:可转债 128.892 原被 %8.2f 截成 128.89;
   新增 _price_fmt/_display_dp,宽度随小数位走(%8.2f -> %9.3f)不破坏对齐。
   可转债(沪 110/111/113/118、深 123/127/128)解码是 4 位但报价步长 0.001,
   显示降到 3 位;ETF 3 位、国债/回购 4 位、股票/指数 2 位沿用 price_decimal_digits。
2) tdx minute 时间列原按序号推算(i//60, i%60)打印成 00:00~03:59,
   改用 MinuteBar.hour/minute。
3) cmd_transactions/cmd_minute 改调 get_ticks/get_minutes,消掉 DeprecationWarning。
新增 tests/test_cli_format.py(8 项);全量 354 passed。

* chore: release 0.6.8(CLI 价格小数位 + 分时时间列修复)

- 版本号 0.6.7 -> 0.6.8(pyproject / __init__.py / uv.lock / CHANGELOG 四处对齐)
- CHANGELOG:`[未发布]` -> `[0.6.8] - 2026-10-23`
- docs/cli.md:补「价格小数位按品种适配」对照表 + `tdx minute` 时间列说明

功能改动见 cd8227f(CLI 价格按品种小数位显示、分时时间列改真实时钟、
cmd_transactions/cmd_minute 改调 get_ticks/get_minutes 消 DeprecationWarning)。

实测 `tdx minute sh113708` -> 时间 09:30 起、价格 127.631(3 位);
`tdx transactions sh113708` -> 11:29:47 / 127.141 / 44 手 / 买(4笔)。

测试 354 全通过(310 + 16 + 23 + 5)。

---------

Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-23 12:18:23 +08:00
openbotandopenbot-coder 8a78156145 perf: 全市场报价改单连接流水线(3.5s → 0.33s)+ 修复基金笔数口径 (#9)
## 性能:get_quotes 全市场 5,227 只 A股 3.5s → 0.33s

协议硬上限 80 只/请求 → 必须切 66 片;老实现是纯串行 for 循环,
每片一次往返(≈60ms),3.5s 全花在等网络上。

发现通达信响应是自描述长度帧且服务器按序应答,因此同一连接可连发
多条请求只付一次往返:实测单连接流水 66 请求 526ms(串行 7,372ms)。

- TdxConnection.execute_pipeline(cmds):一次下发全部 → 按序读回;中途失败强制断连
- _quotes_std 改工作窃取调度(快台多干,避免被最慢节点拖累)
- DynamicPool.warm(n):并发预建连接(acquire 在全局锁内一次一条,22 并发首拉会多花 5~6s)
- CacheManager.get_or_fetch_obj:回源直接返回对象,省掉冷路径 pickle→unpickle 白烧
- pool_max 默认 12 → 24

调优实测 p50/max:每台 1 连接×深度 6 = 455ms;每台 2 连接×深度 3 = 325ms。
端到端(全默认):首次 783ms、稳态 300~343ms、热缓存 67ms。
正确性:用昨收价交叉比对 30 只零错配,流水线与逐片结果集合完全一致。

## 修复:指数 / ETF / LOF 的 trade_count 不再伪装成笔数

通达信对指数和多数场内基金不提供笔数,那 4 字节里塞的是「价格 × 1000」
(指数是「均价 × 1000」)。旧版直接当笔数用,tdx transactions sh510310
会打印出「3994 笔」这种假数据。

- 新增 TransactionRecord.trade_count_available
- 新增 symbols.has_order_count(market, code) 按品种判定
  (沪市 501x/502x/506x 实测有真实笔数,不能按「5 开头=基金」一刀切)
- 历史通道 0x013001 无笔数字段,同样标记不可用

## 文档:可转债量纲口径

核查可转债分时/逐笔后确认数据本身无缺陷(16 只当日 + 8 只历史日,
分时末价/现价、Σvol/日线vol、逐笔 VWAP 比值均 1.000000),
但 vol 单位是「手」(=10 张)导致 amount/vol 是均价的 10 倍,对外文档缺失。

- SecurityBar / TransactionRecord / MinuteBar 量纲注释补全
- has_order_count 实测表补沪可转债 110/111/113/118、沪 EB 132、深可转债 123/127/128
- API_REFERENCE 新增跨品种量纲对照表;llms.txt / SKILL.md 同步

## 版本

0.6.7

## 测试

306 → 346 全通过(新增 tests/test_pipeline.py 11 项 + 基金笔数相关回归)

Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-22 19:41:55 +08:00
openbotandopenbot-coder 2c07400a3a docs: 修正 0.6.6 发布说明里的前缀数(129 -> 179) (#8)
Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-22 16:37:19 +08:00
openbotandopenbot-coder 76644919de feat: 价格小数位改用协议权威值(SecurityInfo.decimal_point) (#7)
0.6.5 用「代码前缀推断 + 全量清单离线校验」修好了债券/回购标度,但同一份证券
清单接口本来就返回 decimal_point,权威值一直没接进取数路径。本次接进来:

- price_decimal_digits:查找顺序改为 权威表 -> 静态前缀规则(兜底)
- decimal_sync(新模块):每日后台同步一次 + 磁盘缓存 + 原子写
- TdxData.sync_decimal_points() / decimal_point_status()
- start() 不阻塞:当日缓存命中直接装表(60ms 零网络),否则挂后台 task
- PYPYTDX_DATA_DISABLE_DECIMAL_SYNC=1 关闭

表按三位前缀归并(全量 5 万只 -> 129 条);若某前缀出现混合小数位则自动退化为
逐代码表,只存例外,mixed_prefixes 可观测。

实测:全量 51,982 条权威表与静态规则零分歧;首次同步 50s(后台),
热缓存 60ms。测试 289 -> 306。

Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-22 16:25:09 +08:00
openbotandopenbot-coder b84a6c8a1b feat: 指数成分成交汇总 + 债券/回购价格标度修复 + 美股分时 hour 修复 (0.6.5) (#6)
* feat: 指数成分成交汇总 + 债券/回购价格标度修复 + 美股分时 hour 修复

新增
- get_index_members / get_index_trade_stats / get_index_trade_stats_multi:
  由成分股逐笔累加出指数的每分钟成交量与成交笔数(协议里指数本身没有笔数,
  trade_count 实为均价*1000)
- CLI: tdx index-stats

修复
- price_decimal_digits 补齐债券/回购 4 位小数档:沪市少 100 倍、深市少 10 倍,
  沪市 B 股 900xxx 改为 3 位。已用全量 51982 只标的的 SecurityInfo.decimal_point
  逐条比对,零例外
- MinuteBar.hour 对美股(EX)出现 24~27:改为 hour%=24 + day_offset,
  新增 datetime / trading_date 只读属性;A股/港股零行为变化

测试 217 -> 289

* chore: bump version 0.6.5

---------

Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-22 13:54:35 +08:00
openbotandopenbot-coder ca24521d2c chore: bump version 0.6.4 (#5)
Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-22 09:11:50 +08:00
openbotandopenbot-coder 8344ed6e6b fix: 修复沪市指数价格少10倍 + 逐笔竞价委托污染(Σvol 虚高/跨主机不稳定) (#3)
核对 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 <openbot-coder@users.noreply.github.com>
2026-10-22 09:06:40 +08:00
openbotandopenbot-coder dfd6fab3af fix: 补齐 v0.6.3 遗漏的版本号(__init__.py / uv.lock) (#4)
## 问题
v0.6.3 的 bump 提交只改了 pyproject.toml 一处,漏掉:
- src/pytdxdata/__init__.py 的 __version__
- uv.lock 的 pytdxdata 条目版本

后果(远端 main 已复现):
- CI 两个 job 全部失败:`uv sync --locked` 报
  "The lockfile at `uv.lock` needs to be updated, but `--locked` was provided"
- Docs / Release 同样失败
- v0.6.3 tag 已打,但 PyPI 上 0.6.3 仍是 404(发布没成功)

## 修复
补齐两处版本号,四处对齐:pyproject.toml / __init__.py / uv.lock / CHANGELOG.md

## 验证
- `uv sync --locked` 退出码 0
- `pytdxdata.__version__` = `importlib.metadata.version()` = 0.6.3

Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-22 08:52:19 +08:00
openbot 0618062e54 chore: bump version 0.6.3 2026-10-18 16:12:51 +08:00
openbot 9c97fea71b fix(pool): ExPool acquire backpressure + ex_pool_cap (fixes #1)
- acquire(): replace 3x0.05s fast-fail with Condition-based queueing
  (default acquire_timeout=30s); timeout error carries pool state
  (idle/total/servers/per_server_cap)
- api: expose ex_pool_cap (default 2, aligned with std/mac pool caps);
  single-server scenario no longer silently capped at 1 concurrent
2026-10-18 16:10:15 +08:00
openbot-coder 2d62d82b51 feat: 新增3台EX扩展行情服务器(connect.cfg官方扩展市场,handshake=login),全量复测30/36可用 2026-10-16 13:53:19 +08:00
openbot-coder 7e72f70eb2 chore: 离线探针复测写回 servers.json(2026-10-16,可达25→27,117.34.114.13/.14 复活) 2026-10-16 12:51:12 +08:00
openbotandopenbot-coder b2f899df49 fix(models): 修复美股分钟K线 datetime 时区拼接错位,还原为北京时间 (#2)
通达信 EX 通道对美股返回的分钟级 K线把两个时区拼进同一个五元组:日期分量是
美东交易日(zipday),时分分量是北京时间(tminutes)。直拼出的 datetime 会把
同一交易日的下午半场排到上午半场之前——单日 390 根首末颠倒,且全部落在同一个
北京自然日里,导致排序 / count 切片 / 日期区间二分与过滤 / 增量水位线全部不可用。

在 SecurityBar.__post_init__ 统一归一化为北京时间(凌晨段日期 +1 天,含月末与
年末进位),EX 的两条 K线命令路径(_bars_ex 的 0x23FF 与二分所依赖的 MAC 0x122E)
因此共用同一口径,不会出现"取数按一套时间、二分按另一套时间"的错位。

新增两个只读属性:trading_date(归属交易日;美股一个交易日横跨两个北京自然日,
按交易日聚合必须用它,不能用 datetime.date())与 is_us。

实测(安装 wheel 0.6.2,非源码树):10-06 ~ 10-12 五个完整交易日各 390 根、
严格单调,首根 open / 末根 close 与日线逐位相同,成交量差 <= 1;A股 / 港股零回归。

- 版本 0.6.1 -> 0.6.2(pyproject / __init__ / uv.lock)
- tests/test_protocol.py 新增 9 项回归测试(分界点 / 月末年末进位 / 390 根整日单调性 / MAC 路径),全量 191 passed
- CHANGELOG / README / SKILL.md / docs(faq、llms.txt、api/models)同步口径说明

遗留(本版未含,待决策):EX 分时对美股返回的 MinuteBar.hour 是未取模的连续分钟数
(实测可达 27,即次日 03:xx),且 MinuteBar 无日期分量可承载跨日信息。

Co-authored-by: openbot-coder <openbot-coder@users.noreply.github.com>
2026-10-13 16:47:57 +08:00
openbot-coder 8193d560da Revert "fix(models): 修复美股分钟K线 datetime 时区拼接错位,还原为北京时间"
This reverts commit 5408903a4c.
2026-10-13 16:42:41 +08:00
openbot-coder 5408903a4c fix(models): 修复美股分钟K线 datetime 时区拼接错位,还原为北京时间
通达信 EX 通道对美股返回的分钟级 K线把两个时区拼进同一个五元组:日期分量是
美东交易日(zipday),时分分量是北京时间(tminutes)。直拼出的 datetime 会把
同一交易日的下午半场排到上午半场之前——单日 390 根首末颠倒,且全部落在同一个
北京自然日里,导致排序 / count 切片 / 日期区间二分与过滤 / 增量水位线全部不可用。

在 SecurityBar.__post_init__ 统一归一化为北京时间(凌晨段日期 +1 天,含月末与
年末进位),EX 的两条 K线命令路径(_bars_ex 的 0x23FF 与二分所依赖的 MAC 0x122E)
因此共用同一口径,不会出现"取数按一套时间、二分按另一套时间"的错位。

新增两个只读属性:trading_date(归属交易日;美股一个交易日横跨两个北京自然日,
按交易日聚合必须用它,不能用 datetime.date())与 is_us。

实测(安装 wheel 0.6.2,非源码树):10-06 ~ 10-12 五个完整交易日各 390 根、
严格单调,首根 open / 末根 close 与日线逐位相同,成交量差 <= 1;A股 / 港股零回归。

- 版本 0.6.1 -> 0.6.2(pyproject / __init__ / uv.lock)
- tests/test_protocol.py 新增 9 项回归测试(分界点 / 月末年末进位 / 390 根整日单调性 / MAC 路径),全量 191 passed
- CHANGELOG / README / SKILL.md / docs(faq、llms.txt、api/models)同步口径说明

遗留(本版未含,待决策):EX 分时对美股返回的 MinuteBar.hour 是未取模的连续分钟数
(实测可达 27,即次日 03:xx),且 MinuteBar 无日期分量可承载跨日信息。
2026-10-13 15:10:22 +08:00
37 changed files with 4155 additions and 286 deletions

No files matched your search

+463
View File
@@ -2,6 +2,469 @@
本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。 本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
## [0.6.9] - 2026-10-23
### 修复
- **`get_universe` 冷启动 12~18s / 偶发失败:证券清单请求多发了 2 字节,污染连接**。
`GetSecurityListCmd` 的请求体是「12 字节命令头 + market(H) + start(H)」= **16 字节**,
但实现里多塞了一个 `H`(写死 0),实际发出 **18 字节**。服务端只消费前 16 字节,
剩下的 `00 00` 停在它的接收缓冲里,把**下一个请求**的开头吃掉 —— 于是同一条连接
「第一次成功、第二次起永远无响应」。
分页器复用连接,等于每拉一页都要先失败重连,冷启动被拖到 12~18s,还经常直接抛
`ConnectionError`。
| 场景 | 修复前 | 修复后 |
|---|---|---|
| `get_universe("sh")` 冷启动(27,534 条 / 28 页) | 12,267ms | **1,610ms** |
| `get_universe("sz")` 冷启动(24,460 条 / 25 页) | 18,260ms | **571ms** |
| `get_universe()` 全市场冷启动(146,848 条) | 19,085ms | **4,371ms** |
| `get_universe()` 热缓存 | — | 669ms |
| 同一连接连发 2 次清单(27 台主机) | **0/27 成功** | **27/27 成功** |
- **北交所清单不再卡 15s 后报错,改为立即返回空列表**。
`0x053E` 对 `market=2` 在实测的 **27 台标准主机上全部无响应**(26 台 6s 无回包、
1 台立刻拒连),而同市场的 `0x053D` 数量接口正常(返回 389)。原实现会重试 2 次、
每次 3s 超时,最后让 `get_universe()`(不带参数)整批失败。
现在该市场直接返回空列表并 `WARNING` 一次,**北交所标的本身不受影响**:
`get_quotes("bj920992")` / `get_bars` / 逐笔全部正常(实测 11.79 与日线 close 一致)。
### 优化
- **`get_universe()` 的 EX 全量只取一次**:命中缓存也要反序列化 10 万条(~200ms),
原先十几个 EX 市场各来一次,纯属白烧。
- **EX 商品列表改并发翻页**(110 页,8 并发):全市场冷启动的一半时间花在这里。
### 文档
- `get_universe` docstring 写明北交所限制;`API_REFERENCE` / `llms.txt` / `SKILL.md` 同步。
- 新增 `tests/test_universe.py` 7 项:请求长度锁定 16 字节、无尾部 padding、
北交所返回空且**不碰连接池**、`_ex_all` 只取一次。
### 已知限制(非本次引入)
- EX 全量列表含**非证券条目**(如人员名录),`(market, code)` 在原始数据里就不唯一,
且重复项出现在**同一页内部**。属数据源特性,未做去重(去重会丢真实品种)。
## [0.6.8] - 2026-10-23
### 修复
- **CLI 价格按品种小数位显示;`tdx minute` 时间列改回真实时钟**。
两处纯显示层缺陷,数据本身没问题(分时/逐笔数值见 0.6.7 的核对结论):
| 现象 | 原因 |
|---|---|
| `tdx transactions sh113708` 打印 `128.89` | 价格写死 `%8.2f`;可转债报价步长 0.001 元,末位被截掉 |
| `tdx minute sh113708` 时间列 `00:00~03:59` | 按序号推算 `i // 60, i % 60`,与 bar 自带时间无关 |
| `tdx quotes sh113708` 打印 `128.8920` | `price_decimal_digits` 是**解码位数**(原始整数 / 10⁴),第 4 位恒为 0 |
| 位置 | 变化 |
|---|---|
| `_price_fmt(dp)`(新) | 宽度随小数位走(`%8.2f` → `%9.3f`),不破坏表格对齐 |
| `_display_dp(market, code)`(新) | 可转债(沪 `110/111/113/118`、深 `123/127/128`)由解码 4 位降到显示 3 位;其余沿用 `price_decimal_digits`(ETF 3 位、国债/回购 4 位、股票/指数 2 位) |
| `cmd_kline` / `cmd_transactions` / `cmd_minute` / `_print_quote` | 统一改用上面的格式串 |
| `cmd_minute` | 时间取 `MinuteBar.hour/minute`,不再用序号推算 |
| `cmd_transactions` / `cmd_minute` | 改调 `get_ticks` / `get_minutes`,消掉 `get_transactions` / `get_minute` 的 DeprecationWarning |
新增回归测试 8 项(`tests/test_cli_format.py`)。
文档:`docs/cli.md` 补「价格小数位按品种适配」对照表与 `tdx minute` 时间列说明。
## [0.6.7] - 2026-10-22
### 性能
- **全市场 A股报价 3.5s → 0.33s:单连接流水线 + 工作窃取**(5,227 只 / 66 片实测)。
老实现 `get_quotes` 是**纯串行 for 循环**逐片发请求:协议硬上限 80 只/请求,
全市场必须切 66 片,每片一次往返(≈60ms)→ 3.5s 全花在等网络上。
关键发现:通达信响应是**自描述长度帧**(16B 帧头 + body)且服务器**按序应答**,
因此同一 TCP 连接上可以连续下发多条请求、只付一次往返。实测单连接流水 66 个请求
只要 526ms(串行 7,372ms),响应顺序与代码完全对得上(用昨收价交叉比对 30 只,零错配)。
| 位置 | 变化 |
|---|---|
| `TdxConnection.execute_pipeline(cmds)`(新) | 一次 write 全部请求 → 按序读回全部响应。中途失败**强制断连**(响应流已错配,不可复用) |
| `PooledConnection.execute_pipeline`(新) | 池化包装转发 |
| `api._execute_std_pipeline`(新) | 借一条连接流水一整组分片;节点不支持流水线时自动降级为逐片 |
| `get_quotes(..., pipeline=True, concurrency=None)` | 新参数;小批量(≤80 只)仍走原路径,零额外开销 |
| `_quotes_std` | 改为**工作窃取**:分片放队列,连接做完一批回来再取,快的多干、慢的少干 |
| `DynamicPool.warm(n)`(新) | **并发**预建连接。`acquire()` 建连在全局锁内一次一条,22 并发首次会串行握手 22 次 —— 全市场首拉因此多花 5~6s;预热后降到 0.78s |
| `CacheManager.get_or_fetch_obj`(新) | 回源直接返回对象,省掉冷路径「pickle→立刻 unpickle」的一次白烧(5,227 条实测 ~40ms) |
| `TdxData(pool_max=)` | 默认 12 → 24,让报价并发能到「每台 2 连接」(池仍是懒扩容,不影响其他接口) |
调优实测(5,227 只 A股,11 台服务器,p50/max):
| 并发 | 每台连接 | 流水深度 | p50 | max |
|---|---|---|---|---|
| 11 | 1 | 6 | 455ms | 464ms |
| 12 | 1~2 | 3 | 457ms | 523ms |
| **22** | **2** | **3** | **325ms** | **334ms** |
| 33 | 3 | 2 | 328ms | 345ms |
⚠️ 剩余下限由公网决定:本机 → 服务器 TCP 握手 RTT 59~80ms,66 片最多只能压到
「1 次往返」;网络抖动时段实测会到 460~600ms。
端到端实测(全默认参数 `TdxData()`,11 台服务器,5,227 只):
| 场景 | 耗时 |
|---|---|
| 首次调用(含并发建 22 条连接) | 783ms |
| 稳态(第 2 次起) | **300~343ms** |
| 命中 TTL 缓存 | 67ms |
| 老版本对照(串行) | 5,996ms(首次)/ 3,460ms(稳态) |
### 修复
- **指数 / ETF / LOF 的 `trade_count` 不再伪装成成交笔数**。
通达信对**指数**和**多数场内基金**不提供笔数,但逐笔报文里那 4 字节仍塞了值:
指数是「当时均价 × 1000」,ETF/LOF 是「价格 × 1000」,货币 ETF(`sh511990`)恒为 `0`。
旧版直接把它当笔数,于是 `tdx transactions sh510310` 会打印出「3994笔」这种假数据
(实测 2026-10-22,价 3.989,原字段 3994)。
| 位置 | 变化 |
|---|---|
| `TransactionRecord.trade_count_available`(新字段) | 该品种协议上是否带笔数;默认 `True` |
| `symbols.has_order_count(market, code)`(新函数) | 按品种判定;**沪市 501x/502x/506x 实测有真实笔数**,不能按「5 开头=基金」一刀切 |
| `transaction.py` 三个解析器 | 不可用时 `trade_count=0` + `trade_count_available=False`;历史通道(0x013001,无笔数字段)同样标记 |
| `tdx transactions` CLI | 不可用时打印 `(-)`,不再打印假笔数 |
实测样本(2026-10-22,按前缀各取样):沪股票/科创/深股票/深可转债/沪逆回购 → 真实笔数;
沪 `51/52/56/58`、深 `159/15x/16x/17x/18x`、所有指数 → 不可用。
### 文档
- **可转债的量纲口径补全**(数据本身无缺陷,但对外文档一片空白,很容易被误判成 bug)。
起因:核查可转债的分时(`0x122D`)与逐笔(`0x122F`)是否有类似 ETF/LOF 的笔数问题。
结论是**价格 / 成交量 / 笔数三样全部正确**,顺带确认了 K 线标度也对;唯一的问题是
`vol` 的单位没人写清楚 —— 直接拿 `amount / vol` 算均价会**错 10 倍**。
实测(2026-10-22,16 只 A股可转债当日 + 8 只历史日 `2026-10-21`):
| 校验项 | 结果 |
|---|---|
| 分时末价 / 快照现价 | **1.000000** |
| Σ分时 vol / 日线 vol | **1.000000** |
| Σ逐笔 vol / 日线 vol | **1.000000** |
| 逐笔 VWAP vs `amount/(vol×10)` | 吻合(差 ≤0.002,是 amount 精度) |
| 快照 `pre_close` vs 上一交易日日线 `close` | **16/16 精确相等** |
| `trade_count` | 真实笔数(`sh111000` 3631 条切片 / 20443 笔) |
关键口径对照(这是文档缺失的部分):
| 品种 | 分时 / 逐笔 `vol` | 日线 `vol` | `Σ分时vol / 日线vol` | `amount / vol` |
|---|---|---|---|---|
| 股票 / ETF / LOF | 手(= 100 股) | 股 | **0.01** | 均价 ✓ |
| 可转债 | 手(= 10 张) | **手** | **1.0** | 均价 **×10** ⚠️ |
| 位置 | 变化 |
|---|---|
| `SecurityBar` / `TransactionRecord` / `MinuteBar` | 量纲注释补可转债(`vol`=手;日线 `amount/vol` 需再 `/10`) |
| `symbols.has_order_count` | 实测表补沪可转债 `110/111/113/118`、沪 EB `132`、深可转债 `123/127/128`,并说明它们走「排除法」兜底分支 |
| `docs/API_REFERENCE.md` | 新增**跨品种量纲对照表** |
| `docs/llms.txt` / `SKILL.md` | 同步同一口径 |
**代码逻辑未改**:可转债在 `has_order_count` 里本来就判为「有笔数」(不在基金/指数的
排除前缀里),本次只是把实测依据补进注释与文档。
## [0.6.6] - 2026-10-22
### 改进
- **价格小数位改用协议自带的权威值,前缀规则降为兜底**。
0.6.5 修好债券/回购标度时,采用的是「按代码前缀推断」+「用全量清单做离线校验」。
但同一份证券清单接口(`get_universe`,底层 `GetSecurityListCmd`)本来就**返回**
`SecurityInfo.decimal_point`(外加自描述浮点的 `pre_close`)——权威值一直就在手上,
只是没接进取数路径。本次把它接进来:
| 位置 | 说明 |
|---|---|
| `price_decimal_digits` | 查找顺序改为 **权威表 → 静态前缀规则**,未同步时行为与 0.6.5 完全一致 |
| `decimal_sync`(新模块) | 每日后台同步一次 + 磁盘缓存(`%LOCALAPPDATA%\pytdxdata\decimal-points.json`) |
| `TdxData.sync_decimal_points()` | 手动强制刷新(排障 / 立刻要权威表) |
| `TdxData.decimal_point_status()` | 状态:`source` / `stock` / `mixed_prefixes` / `syncing` |
**对用户仍无感**:`start()` 命中当日缓存就直接装表(实测 60 ms、零网络),
未命中则挂后台 task(实测首次 50 s,含沪 27,520 + 深 24,462 条清单),
不阻塞 `start()`(`start()` 仍 1.5 s);`close()` 会取消未完成的同步。
**表结构刻意做小**:全量 51,982 只标的只产生 **179 个**「三位前缀 → 小数位」映射
(沪 96 + 深 83),内存里就是 179 条。若将来某段代码混用两种小数位,该前缀自动
退化为**逐代码表**,只存例外代码(`mixed_prefixes` 会 > 0,可据此发现),
不会静默算错。清单拉取不完整时表会偏小 —— 缺的部分退回静态规则,不影响正确性。
为什么保留前缀规则:`get_quotes` 解析是纯同步、无网络的路径,解析那一刻可能还没
同步过清单;离线 / 首次安装也必须能出价格。实测两者在全量清单上**零分歧**
(51,982 条逐条比对,不一致 0 条),并存不会造成口径冲突。
开关:`PYPYTDX_DATA_DISABLE_DECIMAL_SYNC=1` 关闭后台同步(CI / 测试用)。
### 说明
- 新增回归测试 16 项(权威表优先级 / 混合前缀退化 / 缓存跨日失效 / 损坏容错 /
后台任务取消),测试总数 **289 → 306**。
## [0.6.5] - 2026-10-22
### 新增
- **指数成分成交汇总:一条接口拿到「某指数下全部股票的成交量与成交笔数」**
(`get_index_members` / `get_index_trade_stats` / `get_index_trade_stats_multi`)。
起因是一个绕不开的协议事实:**指数本身没有成交笔数**。指数逐笔(`sh000001`)的
`trade_count` 字段实际是「当时均价 × 1000」(2026-10-21 已验证),`get_minutes` /
`get_market_stat` / `SecurityBar` / `get_quotes` 的 160 个字段位里也都**没有**笔数
(扫描 0x122C 全字段位确认,`0x8`/`0x9` 是外盘/内盘手数)。所以「指数笔数」唯一可行
的口径是**把成分股的逐笔笔数累加**。
```python
async with TdxData() as td:
st = await td.get_index_trade_stats("000300") # 沪深300,约 10 s
for hhmm, cum in st.cum_trade_count(): # 截止该分钟的累计笔数
print(hhmm, cum)
st.minutes[0] # MinuteTradeStat(time='09:25', volume=…, trade_count=…)
st.total_volume # 手
st.total_trade_count # 笔
```
| 方法 | 作用 |
|---|---|
| `get_index_members(index, *, fields=None, count=100000)` | 指数成分股(含实时报价)。裸 6 位按**指数语义**解析:`000001`=上证指数,不是平安银行 |
| `get_index_trade_stats(index, date=None, *, concurrency=24, batch_size=50, members=None, skip_errors=True, on_progress=None)` | 成分逐笔 → 每分钟成交量/笔数;`date` 支持历史 |
| `get_index_trade_stats_multi(index, dates, *, ...)` | 多日批量(成分只请求一次),用于「近 N 日同时点均值」基准 |
**口径校验(2026-10-22 实测)**:``total_amount`` 是**成分股**合计。对「成分 = 指数
覆盖面」的指数,它与指数快照 ``amount`` 完全相等 —— 说明成分清单与量能口径一致。
| 指数 | 成分 | 成分合计 | 指数快照 | 比值 | 耗时 |
|---|---|---|---|---|---|
| `sh000016` 上证50 | 50 | 661.38 亿 | 661.34 亿 | 1.0001 | 5.8 s |
| `sh000300` 沪深300 | 300 | 2373.98 亿 | 2373.98 亿 | 1.0000 | 9.7 s |
| `sh000001` 上证指数 | 2230 | 3907.00 亿 | 4111.56 亿 | 0.9503 | 35.6 s |
历史日期同样成立(2026-10-21 收盘数据):`sh000016` 1046.29 / 1045.59 亿(1.0007)、
`sh000300` 3881.65 / 3879.30 亿(1.0006)。
单只股票级别的口径更硬:`Σ(逐笔价 × 手 × 100)` 与日线 `amount` 比值
**1.0000~1.0004**(`sh600000` / `sz000001` / `sh601398` / `bj920002` / `bj920015`
全部吻合),`Σvol` 与快照 `vol` 比值 1.0000。
CLI 同步新增:`tdx index-stats 000300 --top 10`。
**三个必须知道的限制**:
1. **深市 `399xxx` 的指数成交额是「全板块」口径**,不是样本股 —— 实测
`sz399001` 快照 5081.40 亿 = 深市 2908 只股票合计 5081.01 亿,`sz399006`
2568.60 亿 = 创业板全部股票合计。所以拿它跟 `total_amount` 比会得到 0.43 这种
无意义比值,不是数据错。**`get_index_trade_stats` 返回的始终是成分口径。**
2. **北交所(`899xxx`)没有笔数字段** —— 逐笔 `trade_count` 恒为 0,此时
`trade_count_available` 为 `False`,只有成交量可用。
3. **成分表比全市场滞后** —— 上证指数返回 2230 只,而 `get_universe("sh")` 里
股票段共 2360 只,差 130 只(新上市尚未纳入服务端板块),这正是上表
0.9503 的来源;`sh000016`/`sh000300` 这类固定样本指数不受影响。
需要精确覆盖时可自行传 `members=[...]`。
### 修复
- **债券与回购价格全线偏差:沪市少 100 倍、深市少 10 倍**(`get_quotes`)。
`price_decimal_digits` 只覆盖了「股票 2 位 / 基金 3 位」两档,债券与回购没有对应
分支,落到默认档位。它们实际是 **4 位小数**,于是被读大了两个数量级:
| 标的 | 真实价 | 修复前 | 偏差 |
|---|---|---|---|
| `sh019742` 国债 24特国01 | 110.2280 | 11022.8000 | ×100 |
| `sh110077` 可转债 洪城转债 | 199.2790 | 19927.9000 | ×100 |
| `sh204001` 回购 GC001 | 1.3850 | 138.5000 | ×100 |
| `sh900901` B股 云赛B股 | 0.5670 | 5.6700 | ×10 |
| `sz123107` 可转债 温氏转债 | 112.1890 | 1121.8900 | ×10 |
| `sz131810` 回购 R-001 | 1.3800 | 13.8000 | ×10 |
沪市 `010/018/019/020/1xx/2xx` 与深市 `10x-14x/19x/50x/52x/56x` 全部改为 4 位;
沪市 B 股 `900xxx` 另改为 3 位(与深市 `200xxx` 的 2 位不同,两市不一致)。
股票 / ETF / 指数 / 板块的行为**不变**。
**验证方式(可作为该函数的验收标准)**:拿 `pre_close`(五档快照口径,走
`price_decimal_digits`)除以上一交易日**日线收盘**(K线口径,走独立的 `/1000`
路径),比值 1.0 即两口径一致。修复后 15 类标的全数为 1.0000,零偏差。
**权威来源已确认**:证券列表里协议**自带** `SecurityInfo.decimal_point` 字段。
2026-10-22 拉取全量 **51,982 只**(沪 27,520 + 深 24,462)逐条比对,本函数与
协议字段**完全一致、零例外**——因为全量清单里没有任何一个「三位前缀」出现混合
小数位。`get_quotes` 解析时拿不到证券清单,故仍用前缀推断;需要权威值时读
`SecurityInfo.decimal_point`。
- **美股(EX 通道)分时的 `hour` 是非法时钟值**(`get_minutes("usAAPL")`)。
EX 分时的 `minutes` 字段是**自开盘起的连续分钟数**,不是「当天的分钟数」。
旧代码直接 `minutes // 60`,于是 390 条里 **240 条** 的 `hour` ≥ 24:
```
修复前: 21:30, 21:31, ..., 23:59, 24:00, 24:01, ..., 27:59 ← hour=27 不存在
修复后: 21:30, 21:31, ..., 23:59, 00:00, 00:01, ..., 03:59 ← 真实北京时间
```
任何 `datetime(...)` 拼接都会因 `hour=27` 抛 `ValueError`,按小时聚合也会把
凌晨段错误地归到同一个自然日。
**修法**:`MinuteBar.__post_init__` 把越界的 `hour` 拆成
「`hour %= 24` + `day_offset += hour // 24`」,并新增两个只读属性:
| 属性 | 用途 |
|---|---|
| `MinuteBar.datetime` | 该分时点的时刻(北京时间,已含跨日偏移) |
| `MinuteBar.trading_date` | 归属的交易日 `YYYY-MM-DD`。美股一个交易日横跨两个北京自然日(21:30~次日 04:00),**按交易日聚合必须用它**,与 `SecurityBar.trading_date` 口径一致 |
A股(合成时间 09:30~15:00)/ 港股(09:30~16:00)/ 期货的 `hour` 本就合法
→ **零行为变化**,`day_offset` 恒为 0。
实测(2026-10-22):`usAAPL` / `usTSLA` / `usNVDA` 各 390 条,修复后
`hour` 全在 0~23、时间轴严格单调、`trading_date` 收敛为单一交易日;
`hk00700` 90 条无任何变化。
### 说明
- 新增回归测试:债券/回购/B股小数位 ×29、美股分时跨日 ×6、指数成分成交汇总 ×34、
全接口 ×1,测试总数 **217 → 289**。
## [0.6.4] - 2026-10-22
### 修复
- **`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`)。
格式串由 `<IfIIH` 改为 `<IfIiH`。**注意负值语义尚未确证**(可能是撤单量/净委托),
目前只是如实保留符号,未做业务解释。
- **`get_quotes()` 沪市指数价格整体少 10 倍**。
`price_decimal_digits` 把沪市 `000`(如 000001/000016/000300/000688)与 `8`
开头(如板块指数 880001/880305)一律判成 3 位小数(除 1000),但协议原始整数
实际是 **2 位**(除 100)→ 上证指数 3713 被读成 371、上证50 2747 被读成 274。
实证(2026-10-21):沪市指数 6 只 + 板块 2 只全部 `分时中位价 / 快照价 = 10.0`,
而沪市 ETF(510300/588000/511010/501018)、股票(60/601)、科创板(688)、
深市指数/股票/创业板/ETF 全部 `= 1.0` 正确。修法是**把沪市 `000`/`8` 从 3 位改回 2 位**,
其余前缀(`5` ETF/基金、深市 `1` 基金转债)保持 3 位不变。回归测试覆盖 21 组代码。
- **`get_ticks()` 把集合竞价**委托**(`bs_flag=8`)当成成交计入,导致 Σvol 虚高且跨主机不稳定**。
`0x122F` 第 5 字段 `bs_flag=8` 的记录是 **09:15~09:25 / 14:57~15:00 竞价段的撮合委托
快照**,`vol` 是**累计值**(可被同段后续记录覆盖),根本不是成交增量。旧代码把它一并
返回,两个后果:
1. **Σvol 比真值虚高**:`sh600000` 全天 Σvol 含 b8 时 = 668,693,快照 vol = 462,562,
比值 1.4456;剔掉 b8 后 Σvol = 462,634,比值 **1.000156**(与快照精确一致)。
2. **跨主机不稳定**:干净主机不收录 b8(0 条)、脏主机收录 135 条。并发分页时各页
来自不同主机,同一 `start`(从最新往回数的相对锚点)在不同主机落到**不同的真实成交**
上 → 页边界既**重叠**(sh600000 冗余 116 条)又**漏条**(13:03 附近丢 59 条),
同一查询两次调用结果不同。
修复:① 分页拼装后**统一剔除 `bs_flag=8`**;② A股逐笔改用**单连接串行游标翻页**
(`_ticks_cn_serial`),彻底消除跨主机锚点错位。修复后单主机 1.0002、剔 b8 后跨主机
公共时间窗**逐条一致**。
- **文档化指数逐笔字段的量纲差异**(非 bug,是数据源固有语义)。
指数(如 `sh000016`)的 `vol` 单位是**百元**(成交额/100),`trade_count` 是**均价×1000**
(不是笔数),与个股完全不同。实测 `快照amount / Σtick.vol = 100.0002`、`tc/1000` 与分时
`avg_price` 差 < 1.1。已写进 `TransactionRecord` 类注释与 `get_ticks` docstring,
避免用户把指数 Σvol 直接和成分股成交量比(会误得 ~26 倍)。
### 说明
- 新增回归测试:价格小数位 ×20(19 组参数化 + 1 组去 NUL)、`get_ticks` 剔 b8 /
单连接串行 / 多页无重叠 ×3,测试总数 **194 → 217**。
## [0.6.3] - 2026-10-18
- fix(pool): ExPool acquire 背压等待(Condition 排队,默认 30s 超时)替代 3x0.05s 快速失败;超时异常带池状态
- feat(api): 新增 ex_pool_cap 参数(默认 2),单 EX 服务器场景不再静默退化为 1 并发(fixes #1)
## [0.6.2] - 2026-10-13
### 修复
- **美股分钟级 K 线的 `datetime` 全部错位**(`get_bars("usAAPL", KlinePeriod.MIN_1)`)。
通达信 EX 通道返回的美股分钟线时间戳,把**两个时区拼进了同一个五元组**:日期分量是
**美东交易日**(协议里的 `zipday`),时分分量却是**北京时间**(`tminutes`)。直拼出的
`datetime` 会把同一交易日的**下午半场排到上午半场之前**——单日 390 根不仅首末颠倒,
而且全部落在同一个北京自然日里。于是任何依赖 `datetime` 的行为都是错的:排序、
`count` 切片("取最新 N 根")、日期区间二分与过滤、增量更新水位线。
| 观测项 | 修复前 | 修复后 |
|---|---|---|
| 单日 390 根的日期分布 | **全部**落在 10-12(hour 0~23 混在一起) | 10-12 的 21:31~23:59(149 根)+ 10-13 的 00:00~04:00(241 根) |
| 时间轴 | 上午半场被排到下午半场**之前** | 严格单调递增 |
| `count=30` 是否取到真正最新的 30 根 | 否(拿到上一交易日的 23:30~23:59) | 是(当日收盘段 03:31~04:00) |
| 每组首根 `open` / 末根 `close` 对日线 | 对不上 | **逐位相同**(10-07/08/09/12 四个交易日实测) |
现在 `SecurityBar.datetime` **统一为北京时间**:美股凌晨段(北京 hour < 12)的日期
自动 +1 天(含月末 / 年末进位)。A股 / 港股 / 期货原始即为北京时间,**零行为变化**。
新增两个只读属性:
| 属性 | 用途 |
|---|---|
| `SecurityBar.trading_date` | 该 bar 归属的交易日 `YYYY-MM-DD`。美股一个交易日横跨两个北京自然日,**按交易日聚合(分钟线合成日线、日内统计)必须用它,不能用 `datetime.date()`** |
| `SecurityBar.is_us` | 是否美股(EX 通道 `US_STOCK`) |
归一化在 `SecurityBar.__post_init__` 中实现,因此 **EX 的两条 K 线命令路径**
(`_bars_ex` 的 0x23FF 与日期区间二分所依赖的 MAC 0x122E)自动共用同一份口径,
不会出现"取数按一套时间、二分按另一套时间"的错位。
### 说明
- 分钟线缓存 TTL 为 **60 秒**,升级后旧缓存最多残留 1 分钟即自然失效,**无需手动清理**;
日线(`period >= DAY`)不受本缺陷影响。
- 本版只修 K 线。**同日发现的同类问题未包含在内**:EX 分时(`get_minutes`)对美股返回的
`MinuteBar.hour` 是**未取模的连续分钟数**(实测可达 27,即次日 03:xx),且 `MinuteBar`
无日期分量可承载跨日信息——修法涉及"是否新增字段 / 日期如何归属"的取舍,留待下一版决策。
- 新增 9 项针对性回归测试(分界点、月末与年末进位、390 根整日单调性、MAC 路径同样归一化)。
## [0.6.1] - 2026-09-21 ## [0.6.1] - 2026-09-21
### 变更 ### 变更
+4 -1
View File
@@ -104,7 +104,7 @@ curl -o ~/.workbuddy/skills/pytdxdata/SKILL.md --create-dirs \
```bash ```bash
uv sync # 建虚拟环境 + 注册 tdx 命令 uv sync # 建虚拟环境 + 注册 tdx 命令
uv run pytest tests/ # 182 个测试用例(协议 / 池 / 缓存 / 分页 / 全接口回归 / 文件解析 / CLI / 文档漂移 / 当日测速缓存) uv run pytest tests/ # 191 个测试用例(协议 / 池 / 缓存 / 分页 / 全接口回归 / 文件解析 / CLI / 文档漂移 / 当日测速缓存)
uv sync --group docs # 文档站依赖(mkdocs-material + mkdocstrings) uv sync --group docs # 文档站依赖(mkdocs-material + mkdocstrings)
uv run mkdocs serve # 本地预览文档站 uv run mkdocs serve # 本地预览文档站
``` ```
@@ -114,6 +114,9 @@ uv run mkdocs serve # 本地预览文档站
- 行情来自通达信公开服务器,**15 分钟延时**;需实时数据请使用券商行情 - 行情来自通达信公开服务器,**15 分钟延时**;需实时数据请使用券商行情
- 标准通道 K 线 `count < 100` 部分服务器返回空 → 分页器已强制 `min_page=100` 规避 - 标准通道 K 线 `count < 100` 部分服务器返回空 → 分页器已强制 `min_page=100` 规避
- 港股 / 美股期权在通达信协议内无数据 - 港股 / 美股期权在通达信协议内无数据
- **K 线时间戳统一为北京时间**(v0.6.2 起)。美股原始报文把「美东交易日日期」与「北京时间时分」
拼在一起,库已自动归一化,`bar.datetime` 可直接排序 / 过滤;但**美股一个交易日横跨两个北京
自然日**,按交易日聚合请用 `SecurityBar.trading_date`,不要用 `datetime.date()`
- 服务器可用性随时间变化。**当日首次启动会自动在后台测速并缓存**(对调用方无感,当天不再重测); - 服务器可用性随时间变化。**当日首次启动会自动在后台测速并缓存**(对调用方无感,当天不再重测);
也可用 `python -m pytdxdata.server_probe` 离线重生成随包清单。 也可用 `python -m pytdxdata.server_probe` 离线重生成随包清单。
缓存路径与三个开关见 [安装与配置 → 当日自动测速](https://openbot-coder.github.io/pytdxdata/getting-started/#当日自动测速无感) 缓存路径与三个开关见 [安装与配置 → 当日自动测速](https://openbot-coder.github.io/pytdxdata/getting-started/#当日自动测速无感)
+20 -3
View File
@@ -139,16 +139,19 @@ await td.get_bars("cffex:IFL0", KlinePeriod.DAY, count=700) # 期货合约
| 需求 | 方法 | | 需求 | 方法 |
|---|---| |---|---|
| 全市场标的清单(A股+港股+期货…) | `get_universe(market=None)` | | 全市场标的清单(A股+港股+期货…;**北交所返回空**) | `get_universe(market=None)` |
| 日/周/月/分钟 K 线(任意市场) | `get_bars(symbols, period, *, count, adjust, start_date, end_date)` | | 日/周/月/分钟 K 线(任意市场) | `get_bars(symbols, period, *, count, adjust, start_date, end_date)` |
| K 线 + MACD/KDJ/RSI/BOLL | `get_indicators(symbols, indicators, ...)` | | K 线 + MACD/KDJ/RSI/BOLL | `get_indicators(symbols, indicators, ...)` |
| 实时五档报价(A股)/ 基础报价(港股/美股/期货) | `get_quotes(symbols, *, fields=None)` | | 实时五档报价(A股)/ 基础报价(港股/美股/期货) | `get_quotes(symbols, *, fields=None, pipeline=True)` |
| 逐笔成交(任意市场) | `get_ticks(symbols, *, date)` | | 逐笔成交(任意市场) | `get_ticks(symbols, *, date)` |
| 分时图 / 缩略采样 | `get_minutes(symbols, *, date, sampling=True)` | | 分时图 / 缩略采样 | `get_minutes(symbols, *, date, sampling=True)` |
| 全市场股票列表(缓存 1 天) | `get_universe("sz")` / `get_universe("sh")` | | 全市场股票列表(缓存 1 天) | `get_universe("sz")` / `get_universe("sh")` |
| ~~北交所全量代码~~ | 拿不到:清单命令对 market=2 无响应(27 台全测)。北交所标的仍可直接查 `bj920992` |
| 除权除息 / 财务快照 | `get_xdxr(symbols)` / `get_finance(symbols)` | | 除权除息 / 财务快照 | `get_xdxr(symbols)` / `get_finance(symbols)` |
| F10 公司资料 | `get_f10(symbol, section)` | | F10 公司资料 | `get_f10(symbol, section)` |
| 板块列表 / 成分股 / 涨跌排行 | `get_boards` / `get_board_members` / `get_board_ranking` | | 板块列表 / 成分股 / 涨跌排行 | `get_boards` / `get_board_members` / `get_board_ranking` |
| **指数的成交量 + 成交笔数**(每分钟曲线) | `get_index_trade_stats(index, date)` → `.cum_trade_count()` |
| **指数成分股** | `get_index_members(index)`(裸 `000001` 按指数语义解析) |
| 个股所属板块 | `get_board_of(symbols)` | | 个股所属板块 | `get_board_of(symbols)` |
| 集合竞价 / 异动 / 资金流 | `get_auction` / `get_unusual` / `get_capital_flow` | | 集合竞价 / 异动 / 资金流 | `get_auction` / `get_unusual` / `get_capital_flow` |
| 个股特征快照 | `get_snapshot(symbols)` | | 个股特征快照 | `get_snapshot(symbols)` |
@@ -164,9 +167,19 @@ await td.get_bars("cffex:IFL0", KlinePeriod.DAY, count=700) # 期货合约
- **数据有 15 分钟延时**(通达信公开服务器特性)。要实时数据请用券商行情。 - **数据有 15 分钟延时**(通达信公开服务器特性)。要实时数据请用券商行情。
- **复权 K 线与 1 分钟 K 线走 MAC 通道**。`get_bars(..., adjust=Adjust.QFQ)` 自动切换。 - **复权 K 线与 1 分钟 K 线走 MAC 通道**。`get_bars(..., adjust=Adjust.QFQ)` 自动切换。
- **K 线时间戳统一为北京时间**(v0.6.2 起)。美股原始报文里日期是美东交易日、时分是北京时间(两个时区拼在一起),库已自动归一化,`bar.datetime` 可直接排序 / 比较 / 过滤。但**美股一个交易日横跨两个北京自然日**,按交易日聚合(分钟线合成日线、日内统计)必须用 `bar.trading_date`。
- **`count` 很大时会自动多连接并发分页**,无需手动翻页。但标准通道 K 线 `count < 100` 部分服务器会返回空——内部已强制 `min_page=100` 规避。 - **`count` 很大时会自动多连接并发分页**,无需手动翻页。但标准通道 K 线 `count < 100` 部分服务器会返回空——内部已强制 `min_page=100` 规避。
- **`get_quotes` 一次 >80 只自动切批**;走 MAC 字段位通道(`fields=`)时上限为 80 只/次。 - **`get_quotes` 一次 >80 只自动切批**;走 MAC 字段位通道(`fields=`)时上限为 80 只/次。
- **历史逐笔没有笔数字段**,只有当日逐笔的 `trade_count` 有效。 - **全市场报价用默认参数即可,别自己写循环**。`get_quotes(全部A股)` 内部会切 66 片并走**单连接流水线**(一条连接连发多个分片、只付一次往返)+ 工作窃取调度,5,227 只实测 **p50 325ms**(老版本串行 3.5s)。自己 for 循环逐只/逐片调会把流水线优势全部丢掉。
- 想更保守可 `concurrency=11`(每台 1 连接),代价 p50 457ms。
- 个别服务器不支持流水线时自动降级逐片,结果不受影响。
- **可转债(110/111/113/118/123/127/128)三样都是真的**:价格、`vol`(手=10 张)、`trade_count`(真实笔数,3631 条切片 / 20443 笔量级)全部可用,`Σvol` 与日线 `vol` **1:1 相等**。
⚠️ 唯一要小心的是 **日线 `amount / vol` 不等于均价,而是均价的 10 倍**(`vol` 单位是手=10 张)。算可转债均价用 `amount / vol / 10`,或直接用 `Σ(price×vol) / Σvol`——后者跨品种都成立,最稳。
对照:股票/ETF 的 `Σ逐笔vol / 日线vol = 0.01`(逐笔手、日线股),而 `amount/vol` 恰好就是均价。
- **指数本身没有成交笔数**。`get_ticks("sh000001")` 的 `trade_count` 是「当时均价×1000」、`vol` 单位是百元(成交额/100)。要笔数只能用 `get_index_trade_stats(index)`(成分股逐笔累加,2230 只约 36-60 s)。北交所成分无笔数字段,该方法会返回 `trade_count_available=False`。
- **ETF / LOF 也没有成交笔数**。`get_ticks("sh510310")` 的 `trade_count` 是「价格×1000」(货币 ETF 恒为 0)。判定用 `symbols.has_order_count(market, code)`,读记录时看 `TransactionRecord.trade_count_available`——为 `False` 时 `trade_count` 已被置 0,不要求和/求均值。注意**沪市 `501x/502x/506x` 实测有真实笔数**,不能按「5 开头=基金」一刀切。
- **历史逐笔有笔数**(MAC `0x122F` 支持历史日期,实测可回溯最近 5 个交易日;更早返回空)。
- **小数位表不用手动管,但可以手动刷**。`start()` 会检查当日缓存并后台同步一次(`SecurityInfo.decimal_point` 权威值);要强制刷新用 `await td.sync_decimal_points()`,看同步状态用 `await td.decimal_point_status()`。`PYPYTDX_DATA_DISABLE_DECIMAL_SYNC=1` 可关闭后台同步。
- 板块文件(`block_*.dat`)/ 行业(`tdxhy.cfg`)/ 财报(`gpcw*.zip`)是**服务器上的静态文件**,解析后是普通 dataclass,**落 JSON 后完全脱网可用**——适合做离线快照。 - 板块文件(`block_*.dat`)/ 行业(`tdxhy.cfg`)/ 财报(`gpcw*.zip`)是**服务器上的静态文件**,解析后是普通 dataclass,**落 JSON 后完全脱网可用**——适合做离线快照。
## 陷阱清单 ## 陷阱清单
@@ -183,6 +196,10 @@ await td.get_bars("cffex:IFL0", KlinePeriod.DAY, count=700) # 期货合约
| 用 `get_block_info` 又自己拆二进制 | 白写解析器 | 用 `get_block_parsed`,已经解析好了 | | 用 `get_block_info` 又自己拆二进制 | 白写解析器 | 用 `get_block_parsed`,已经解析好了 |
| 循环里逐个 `await get_bars` | 慢 | 用列表传多个标的,自动并发 | | 循环里逐个 `await get_bars` | 慢 | 用列表传多个标的,自动并发 |
| 港股/美股五档 bid/ask | 没有(协议不支持) | `fields` 字段位通道有 name 但无五档 | | 港股/美股五档 bid/ask | 没有(协议不支持) | `fields` 字段位通道有 name 但无五档 |
| 美股分钟线用 `datetime.date()` 分组做日聚合 | 一个交易日被拆成两天(美股跨北京零点) | 用 `bar.trading_date`;`bar.datetime` 是归一化后的北京时间 |
| 拿指数逐笔的 `trade_count` 当笔数 | 拿到的是「均价×1000」,数值荒谬 | 用 `get_index_trade_stats(index)` 由成分累加 |
| 拿 ETF/LOF 逐笔的 `trade_count` 当笔数 | 拿到的是「价格×1000」(`sh510310` 显示 3994 笔) | 看 `trade_count_available`,或 `symbols.has_order_count()` |
| 拿深市 `399xxx` 的 `amount` 校验成分合计 | 比值 0.43,误以为数据错 | 深市指数 amount 是**全板块**口径(`sz399001`=深市全部 5081 亿),不是样本股 |
| 依赖实时性做信号 | 数据是 15 分钟前的 | 换券商实时源 | | 依赖实时性做信号 | 数据是 15 分钟前的 | 换券商实时源 |
| 手动改包内 `servers.json` / 写死 IP | 容器只读、升级被覆盖、快节点捞不回来 | 日常靠内置的**当日测速缓存**自动选路;要强制指定就用 `PYPYTDX_DATA_{STANDARD,MAC,EX}_HOSTS` 环境变量 | | 手动改包内 `servers.json` / 写死 IP | 容器只读、升级被覆盖、快节点捞不回来 | 日常靠内置的**当日测速缓存**自动选路;要强制指定就用 `PYPYTDX_DATA_{STANDARD,MAC,EX}_HOSTS` 环境变量 |
+25 -5
View File
@@ -47,13 +47,15 @@ from pytdxdata import (
| 方法 | 返回 | 说明 | | 方法 | 返回 | 说明 |
|------|------|------| |------|------|------|
| `get_universe(market=None)` | `list[SecurityInfo]` | 跨市场标的清单(A 股+港股+美股+期货/期权) | | `get_universe(market=None)` | `list[SecurityInfo]` | 跨市场标的清单(A 股+港股+美股+期货/期权);每条带协议自带的 `decimal_point`(价格小数位)与 `pre_close`。**北交所清单协议不支持,返回空列表** |
| `sync_decimal_points(markets=("sh","sz"))` | `dict` | 从证券清单同步**权威价格小数位表**(`SecurityInfo.decimal_point`),灌进 `price_decimal_digits` 的运行时表;`start()` 已自动做(当日缓存命中则零网络),此方法用于强制刷新/排障 |
| `decimal_point_status()` | `dict` | 小数位表状态:`source`(`cache`/`universe`/空)、`stock`、`mixed_prefixes`、`syncing` |
#### 报价 #### 报价
| 方法 | 返回 | 说明 | | 方法 | 返回 | 说明 |
|------|------|------| |------|------|------|
| `get_quotes(symbols, *, fields=None)` | `list[SecurityQuote]` | 跨市场混合报价(A 股标准五档;给了 fields 走 MAC/EX 字段位有 name) | | `get_quotes(symbols, *, fields=None, concurrency=None, pipeline=True)` | `list[SecurityQuote]` | 跨市场混合报价(A 股标准五档;给了 fields 走 MAC/EX 字段位有 name)。超 80 只自动切批,`pipeline` 开启**单连接流水线**,全市场 5,200 只 ~0.33s |
| `get_snapshot(symbols)` | `list[SymbolSnapshot]` | 个股特征快照(A 股) | | `get_snapshot(symbols)` | `list[SymbolSnapshot]` | 个股特征快照(A 股) |
| `get_auction(symbols)` | `list[AuctionItem]` | 集合竞价(A 股) | | `get_auction(symbols)` | `list[AuctionItem]` | 集合竞价(A 股) |
| `get_capital_flow(symbols)` | `list[CapitalFlow]` | 个股资金流向(A 股) | | `get_capital_flow(symbols)` | `list[CapitalFlow]` | 个股资金流向(A 股) |
@@ -69,7 +71,7 @@ from pytdxdata import (
| 方法 | 返回 | 说明 | | 方法 | 返回 | 说明 |
|------|------|------| |------|------|------|
| `get_ticks(symbols, *, date=None, start=0, count=None, concurrency=6)` | `list[TransactionRecord]` | 跨市场逐笔成交 | | `get_ticks(symbols, *, date=None, start=0, count=None, concurrency=6)` | `list[TransactionRecord]` | 跨市场逐笔成交。返回按时间升序;`start` **从最新一笔往回数**;`vol`/`trade_count` 为约 3 秒切片的增量值(非累计)。**已剔除 `bs_flag=8` 竞价委托**(非成交,`vol` 为累计撮合量)。**指数**:`vol` 单位是百元(成交额/100)、`trade_count` 是均价×1000,均非股票语义;**可转债**:`vol` 是手(=10 张)、`trade_count` 是**真实笔数**,`Σvol` 与日线 `vol` **1:1** |
| `get_minutes(symbols, *, date=None, sampling=False, concurrency=6)` | `list[MinuteBar]` | 跨市场分时(sampling=True 取缩略采样:A股由 0x122D 派生,扩展市场 0x254D) | | `get_minutes(symbols, *, date=None, sampling=False, concurrency=6)` | `list[MinuteBar]` | 跨市场分时(sampling=True 取缩略采样:A股由 0x122D 派生,扩展市场 0x254D) |
#### 公司信息/文件/板块 #### 公司信息/文件/板块
@@ -81,6 +83,9 @@ from pytdxdata import (
| `get_boards(kind="all", *, count=10000)` | `list[BoardInfo]` | 板块列表 | | `get_boards(kind="all", *, count=10000)` | `list[BoardInfo]` | 板块列表 |
| `get_board_members(board, *, fields=None, count=100000)` | `list[SecurityQuote]` | 板块成分股报价(归一模型) | | `get_board_members(board, *, fields=None, count=100000)` | `list[SecurityQuote]` | 板块成分股报价(归一模型) |
| `get_board_of(symbols)` | `list[BelongBoard]` | 个股所属板块 | | `get_board_of(symbols)` | `list[BelongBoard]` | 个股所属板块 |
| `get_index_members(index, *, fields=None, count=100000)` | `list[SecurityQuote]` | **指数成分股**报价。裸 6 位按**指数语义**解析(`000001`=上证指数,不是平安银行):`000/999/880`→沪、`399`→深、`899`→北交所 |
| `get_index_trade_stats(index, date=None, *, concurrency=24, batch_size=50, members=None, skip_errors=True, on_progress=None)` | `IndexTradeStats` | **指数成分逐笔汇总**成每分钟成交量/成交笔数。协议里指数本身没有笔数(`trade_count` 是均价×1000),故由成分股逐笔累加;`.cumulative()` 取「截止该分钟累计」,`.cum_trade_count()` 直接给 `[(HH:MM, 累计笔数)]`。2230 只(上证)约 36-60 s |
| `get_index_trade_stats_multi(index, dates, *, ...)` | `list[IndexTradeStats]` | 多日批量版(成分只请求一次),用于「近 N 日同时点累计均值」基准 |
### 2.2 K线(旧接口,共 6 个) {#legacy-kline} ### 2.2 K线(旧接口,共 6 个) {#legacy-kline}
@@ -97,7 +102,7 @@ from pytdxdata import (
| 方法 | 返回 | 说明 | | 方法 | 返回 | 说明 |
|------|------|------| |------|------|------|
| `get_quotes(symbols, *, fields=None)` | `list[SecurityQuote]` | 五档报价;>80 只自动切批;TTL 5s | | `get_quotes(symbols, *, fields=None, concurrency=None, pipeline=True)` | `list[SecurityQuote]` | 五档报价;>80 只自动切批(流水线+工作窃取,5,200 只 ~0.33s);TTL 5s |
| `get_stock_quotes(stocks, bits=None)` | `list[MemberQuote]` | MAC 自定义字段报价(≤80只/次) | | `get_stock_quotes(stocks, bits=None)` | `list[MemberQuote]` | MAC 自定义字段报价(≤80只/次) |
| `get_stock_quotes_list(category, *, start=0, count=80, sort_type=0)` | `list[MemberQuote]` | 市场分类报价(0沪A/2深A/6全A/8科创/14创业) | | `get_stock_quotes_list(category, *, start=0, count=80, sort_type=0)` | `list[MemberQuote]` | 市场分类报价(0沪A/2深A/6全A/8科创/14创业) |
| `get_market_stat()` | `MarketStat` | 全市场统计(涨跌家数/总额/市值/涨跌停数) | | `get_market_stat()` | `MarketStat` | 全市场统计(涨跌家数/总额/市值/涨跌停数) |
@@ -199,7 +204,7 @@ from pytdxdata import (
| `SecurityQuote` | price/pre_close/OHLC/vol/amount/s_vol/b_vol/`bid[5]`/`ask[5]`/server_time/trading_status/cur_vol/rise_speed/limit_up/limit_down/decimal_point/open_amount | | `SecurityQuote` | price/pre_close/OHLC/vol/amount/s_vol/b_vol/`bid[5]`/`ask[5]`/server_time/trading_status/cur_vol/rise_speed/limit_up/limit_down/decimal_point/open_amount |
| `SecurityInfo` | market/code/name/volunit/decimal_point/pre_close | | `SecurityInfo` | market/code/name/volunit/decimal_point/pre_close |
| `TransactionRecord` | market/code/time/price/vol/`trade_count`/bs_flag | | `TransactionRecord` | market/code/time/price/vol/`trade_count`/bs_flag |
| `MinuteBar` | price/vol/avg_price/hour/minute | | `MinuteBar` | price/vol/avg_price/hour/minute/day_offset + `datetime`/`trading_date` 只读属性(hour 恒为合法时钟值 0~23;美股一个交易日跨两个北京自然日,按交易日聚合用 `trading_date`) |
| `XdxrRecord` | 分红送转/配股/缩股/行权 + 股本变动 + `date` 属性 | | `XdxrRecord` | 分红送转/配股/缩股/行权 + 股本变动 + `date` 属性 |
| `FinanceRecord` | 股本/资产/负债/营收/利润等 36 个字段(万元/万股) | | `FinanceRecord` | 股本/资产/负债/营收/利润等 36 个字段(万元/万股) |
| `BoardInfo` | 板块 + 领涨股信息 | | `BoardInfo` | 板块 + 领涨股信息 |
@@ -218,6 +223,21 @@ from pytdxdata import (
> 注:`__init__` 仅导出 `Market/ExMarket/KlinePeriod/Adjust` 与 6 个核心模型;`BoardInfo/MemberQuote/AuctionItem` 等需 `from pytdxdata.models import ...`。 > 注:`__init__` 仅导出 `Market/ExMarket/KlinePeriod/Adjust` 与 6 个核心模型;`BoardInfo/MemberQuote/AuctionItem` 等需 `from pytdxdata.models import ...`。
**量纲对照(跨品种,2026-10-22 实测)**
同名字段在不同品种上单位不同。最典型的坑是用 `amount / vol` 算均价——它在可转债上会**错 10 倍**:
| 品种 | 分时 / 逐笔 `vol` | 日线 `SecurityBar.vol` | `Σ分时vol / 日线vol` | 日线 `amount / vol` |
|---|---|---|---|---|
| 股票 / ETF / LOF | 手(= 100 股) | 股 | **0.01** | 均价 ✓ |
| 可转债(110/111/113/118/123/127/128) | 手(= 10 张) | **手** | **1.0** | 均价 **×10** ⚠️ |
| 指数 | 百元(成交额/100) | 手 | — | 无意义(`amount` 是全板块口径) |
算均价:股票 `amount / vol`;可转债 `amount / vol / 10`;跨品种统一用 `Σ(price×vol) / Σvol`。
> 可转债的价格标度、分时、逐笔已全量校验(16 只当日 + 8 只历史日):分时末价 / 快照现价、`Σvol / 日线vol`、逐笔 VWAP vs `amount/(vol×10)` 比值均为 **1.000000**。
## 四、辅助模块 ## 四、辅助模块
**`pytdxdata.indicator`**(技术指标,纯函数) **`pytdxdata.indicator`**(技术指标,纯函数)
+16
View File
@@ -62,6 +62,22 @@ from pytdxdata.models import BoardInfo, MemberQuote, AuctionItem, CapitalFlow
| 结构 | 具名属性(`zongguben`、`jingzichan` ...) | `fields: list[float]`,原始字段数组 | | 结构 | 具名属性(`zongguben`、`jingzichan` ...) | `fields: list[float]`,原始字段数组 |
| 单位 | 万元 / 万股 | 原始 float,需自行按字段语义换算 | | 单位 | 万元 / 万股 | 原始 float,需自行按字段语义换算 |
!!! tip "`SecurityBar.datetime` 的时间戳口径(v0.6.2 起)"
时间统一为**北京时间**。A股 / 港股 / 期货的原始时间戳即为北京时间;美股的原始报文
混用了「美东交易日日期」与「北京时间时分」两个时区,库在构造时已自动归一化
(凌晨段日期 +1 天),因此 `bar.datetime` 可直接排序 / 比较 / 过滤。
但要注意**美股一个交易日横跨两个北京自然日**,按交易日聚合请用 `bar.trading_date`:
```python
bars = await td.get_bars("usAAPL", KlinePeriod.MIN_1, count=390)
bars[0].datetime # 2026-10-12 21:31:00(北京时间)
bars[-1].datetime # 2026-10-13 04:00:00(次日)
bars[0].trading_date # "2026-10-12" —— 归属的美东交易日
```
`bar.is_us` 可判定是否美股。详见 [常见问题 → 美股分钟 K 线](../faq.md)。
## 完整字段定义 ## 完整字段定义
以下由 `mkdocstrings` 从源码实时渲染(**以源码为准**): 以下由 `mkdocstrings` 从源码实时渲染(**以源码为准**):
+11
View File
@@ -56,6 +56,17 @@ tdx minute sz000001 # 今日分时
tdx minute sz000001 --date 20260811 # 历史分时 tdx minute sz000001 --date 20260811 # 历史分时
``` ```
价格列的小数位**按品种自动适配**,不用自己换算:
| 品种 | 显示小数位 | 示例 |
|---|---|---|
| 股票 / 指数 | 2 | `12.34` |
| ETF / LOF / 沪市 B 股 / 可转债 | 3 | `128.892`(可转债报价步长 0.001 元) |
| 债券 / 回购 | 4 | `100.0100` |
> 可转债的**解码位数**是 4 位(原始整数 / 10⁴),但第 4 位恒为 0,所以显示按 3 位。
> `tdx minute` 的时间列是该 bar 的**真实时钟**(`09:31` / `14:57`),不是序号推算。
## 板块 ## 板块
```bash ```bash
+17
View File
@@ -99,6 +99,23 @@
2. **是否含未收盘的那根** —— 盘中最后一根是动态的 2. **是否含未收盘的那根** —— 盘中最后一根是动态的
3. 分钟线注意**数据来源深度**不同 3. 分钟线注意**数据来源深度**不同
??? question "美股分钟 K 线的时间为什么跨了两个日期?"
**已在上游修好(v0.6.2)**。通达信 EX 通道对美股返回的原生时间戳把两个时区拼在一起:
日期分量是**美东交易日**、时分分量是**北京时间**。修复前,同一交易日的 390 根会全部
落在同一个北京自然日里,并且下午半场被排在上午半场**之前**。
现在 `SecurityBar.datetime` 已统一为**北京时间**(凌晨段日期自动 +1 天),可直接排序 /
过滤 / 做增量水位线。但要注意**美股一个交易日横跨两个北京自然日**:
```python
bars = await td.get_bars("usAAPL", KlinePeriod.MIN_1, count=390)
print(bars[0].datetime, bars[-1].datetime) # 2026-10-12 21:31:00 → 2026-10-13 04:00:00
print({b.trading_date for b in bars}) # {'2026-10-12'} —— 同一个交易日
```
按**交易日**聚合(分钟线合成日线、日内统计)请用 `b.trading_date`,不要用
`b.datetime.date()`。A股 / 港股 / 期货原始即为北京时间,不受影响。
??? question "缓存会不会返回过期数据?" ??? question "缓存会不会返回过期数据?"
缓存按数据类型分级 TTL,不会返回超出 TTL 的数据: 缓存按数据类型分级 TTL,不会返回超出 TTL 的数据:
+11 -3
View File
@@ -44,11 +44,15 @@ asyncio.run(main())
标的一律用字符串;以下均为 v0.6 统一接口,跨市场自动选路。 标的一律用字符串;以下均为 v0.6 统一接口,跨市场自动选路。
- **标的清单**:`get_universe`(A股 + 港股 + 美股 + 期货/期权) - **标的清单**:`get_universe`(A股 + 港股 + 美股 + 期货/期权)。⚠️ 北交所(`market="bj"`)清单**协议不支持**,返回空列表(`0x053E` 对 market=2 无响应,27 台服务器全测);但北交所**标的本身可用** —— 报价/K线/逐笔直接传 `bj920992` 这类代码正常
- **K 线**:`get_bars`(自动并发分页、支持复权与日期区间、多标的并发) - **K 线**:`get_bars`(自动并发分页、支持复权与日期区间、多标的并发)
- **技术指标**:`get_indicators`(K线 + MACD/KDJ/RSI/BOLL/MA/EMA) - **技术指标**:`get_indicators`(K线 + MACD/KDJ/RSI/BOLL/MA/EMA)
- **报价**:`get_quotes`(五档,>80 只自动切批)、`get_snapshot`(个股特征)、`get_market_stat` - **报价**:`get_quotes`(五档,>80 只自动切批;**单连接流水线**默认开启,全市场 5,200 只 A股 ~0.33s)、`get_snapshot`(个股特征)、`get_market_stat`
- **逐笔 / 分时**:`get_ticks`(含 `trade_count`,支持历史日期)、`get_minutes`(`sampling=True` 取缩略采样) - 价格标度:协议给的是整数,真实价 = `整数 / 10**小数位`。小数位由 `price_decimal_digits` 决定,
优先用**权威表**(证券清单自带的 `SecurityInfo.decimal_point`,`start()` 每日后台同步一次,
也可 `await td.sync_decimal_points()` 强制刷新),未同步时退回静态前缀规则。
债券/回购是 **4 位**、沪市 B 股 3 位 —— 这里错过两次(整批价格差 100 倍/10 倍)。
- **逐笔 / 分时**:`get_ticks`(含 `trade_count`,支持历史日期,返回按时间升序;`vol`/`trade_count` 为约 3 秒切片增量而非累计;已剔除 `bs_flag=8` 竞价委托;**指数**的 `vol` 是百元、`trade_count` 是均价×1000;**可转债**的 `vol` 是手=10 张、`trade_count` 是真实笔数,故日线 `amount/vol` 是均价的 **10 倍**,算均价要再 /10)、`get_minutes`(`sampling=True` 取缩略采样;`hour` 恒为合法时钟值 0~23,美股一个交易日跨两个北京自然日,按交易日聚合用 `MinuteBar.trading_date`、取时刻用 `MinuteBar.datetime`)
- **财务 / 除权**:`get_finance`(最新快照)、`get_xdxr`、`get_price_limits`(本地计算涨跌停) - **财务 / 除权**:`get_finance`(最新快照)、`get_xdxr`、`get_price_limits`(本地计算涨跌停)
- **F10**:`get_f10`(公司资料目录 + 正文) - **F10**:`get_f10`(公司资料目录 + 正文)
- **板块**:`get_boards`、`get_board_members`、`get_board_of`、`get_board_summary`、 - **板块**:`get_boards`、`get_board_members`、`get_board_of`、`get_board_summary`、
@@ -93,6 +97,10 @@ tdx financial gpcw20260331.zip --limit 5
- **`KlinePeriod.MIN_1` 走 MAC 通道并单连接串行分页**,这是刻意设计:并发分页在多服务器 - **`KlinePeriod.MIN_1` 走 MAC 通道并单连接串行分页**,这是刻意设计:并发分页在多服务器
历史深度不一致时会产生非确定性数据空洞。不要试图"优化"成并发。 历史深度不一致时会产生非确定性数据空洞。不要试图"优化"成并发。
- **复权 K 线走 MAC 通道**,标准通道不提供复权数据。 - **复权 K 线走 MAC 通道**,标准通道不提供复权数据。
- **K 线 `datetime` 统一为北京时间**(v0.6.2 起)。美股原始报文的日期分量是美东交易日、
时分分量是北京时间,库已自动归一化,`bar.datetime` 可直接排序 / 比较 / 过滤。
但**美股一个交易日横跨两个北京自然日**:按交易日聚合(分钟线合成日线、日内统计)
用 `bar.trading_date`,不要用 `bar.datetime.date()`。`bar.is_us` 判定美股。
- **标准通道部分服务器在 `count < 100` 时返回空**,分页器已强制 `min_page=100` 规避。 - **标准通道部分服务器在 `count < 100` 时返回空**,分页器已强制 `min_page=100` 规避。
- **本地 Windows 上 `asyncio.new_event_loop()` 可能永久挂起**,根因是回环 `socket.socketpair()` - **本地 Windows 上 `asyncio.new_event_loop()` 可能永久挂起**,根因是回环 `socket.socketpair()`
被本地代理/安全软件拦截。异步测试请在 Linux/WSL 运行。 被本地代理/安全软件拦截。异步测试请在 Linux/WSL 运行。
+1 -1
View File
@@ -1,6 +1,6 @@
[project] [project]
name = "pytdxdata" name = "pytdxdata"
version = "0.6.1" version = "0.6.9"
description = "通达信(TongDaXin)行情数据客户端:动态连接池 + 双层TTL缓存 + 3连接并发分页,纯asyncio零运行时依赖,支持A股/港股/美股/期货/期权" description = "通达信(TongDaXin)行情数据客户端:动态连接池 + 双层TTL缓存 + 3连接并发分页,纯asyncio零运行时依赖,支持A股/港股/美股/期货/期权"
readme = "README.md" readme = "README.md"
requires-python = ">=3.11" requires-python = ">=3.11"
+108
View File
@@ -0,0 +1,108 @@
"""可复现核查:指数成分逐笔汇总的口径是否与官方日线一致。
用法::
python scripts/verify_index_stats.py # 当日
python scripts/verify_index_stats.py --date 20261021 # 历史某日
python scripts/verify_index_stats.py --indices 000001 000300
两段校验:
1. **单股级**:``Σ(逐笔价 × 手 × 100)`` 对**当日日线 amount**。比值 1.0000~1.0002
说明逐笔没漏条、价格与单位都对(``bj`` 也行)。
2. **指数级**:成分股合计成交额对**该指数的日线 amount**。相等说明成分清单与
指数的量能口径一致;明显偏小则是成分表滞后(新上市未纳入)。
⚠️ **深市 `399xxx` 的指数 amount 是「全板块」口径**,不是样本股:实测
`sz399001` 5081.40 亿 = 深市 2908 只股票合计,`sz399006` 2568.60 亿 = 创业板
全部股票合计。所以这两个指数的比值天然远离 1(约 0.43),**不是数据错**。
为什么不用快照做基准:快照只有「此刻」,历史日期对不上。日线 amount 两者都能给。
注意 ``bj``(北交所)逐笔**没有笔数字段**(``trade_count`` 恒 0),脚本会打出
``有笔数`` 列便于识别。
"""
from __future__ import annotations
import argparse
import asyncio
from datetime import date as _date
def _ymd(bar) -> int:
return bar.year * 10000 + bar.month * 100 + bar.day
async def _daily_amount(td, symbol: str, ymd: int) -> float | None:
from pytdxdata import KlinePeriod
bars = await td.get_bars(symbol, KlinePeriod.DAY, count=10)
for b in bars:
if _ymd(b) == ymd:
return b.amount
return None
async def check_symbols(td, symbols: list[str], ymd: int) -> None:
print(f"## 单股级({ymd})\n")
print("| 标的 | Σ(p×手×100) / 日线amount | 笔数 |")
print("|---|---|---|")
for sym in symbols:
try:
ticks = await td.get_ticks(sym, date=ymd)
ref = await _daily_amount(td, sym, ymd)
except Exception as exc: # noqa: BLE001
print(f"| {sym} | ERR {type(exc).__name__} | - |")
continue
if not ticks:
print(f"| {sym} | 无逐笔(非交易日?) | - |")
continue
sa = sum(t.price * t.vol * 100 for t in ticks)
tc = sum(t.trade_count for t in ticks)
ratio = sa / ref if ref else 0.0
print(f"| {sym} | {ratio:.4f} | {tc:,} |")
print()
async def check_indices(td, indices: list[str], ymd: int, day: int | None) -> None:
print(f"## 指数级({ymd})\n")
print("| 指数 | 成分 | 有成交 | 有笔数 | 成分合计 | 日线amount | 比值 | 耗时 |")
print("|---|---|---|---|---|---|---|---|")
for idx in indices:
try:
st = await td.get_index_trade_stats(idx, day)
ref = await _daily_amount(td, st.index, ymd)
except Exception as exc: # noqa: BLE001
print(f"| {idx} | ERR {type(exc).__name__}: {exc} | - | - | - | - | - | - |")
continue
ratio = st.total_amount / ref if ref else 0.0
print(f"| {st.index} | {st.member_count} | {st.active_members} | "
f"{st.trade_count_members} | {st.total_amount / 1e8:,.2f} 亿 | "
f"{(ref or 0) / 1e8:,.2f} 亿 | {ratio:.4f} | {st.elapsed:.1f}s |")
print()
print("提示:`399xxx` 的比值天然远离 1 —— 深市指数的 amount 字段是全板块口径。")
print()
async def main() -> None:
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument("--symbols", nargs="*",
default=["sh600000", "sz000001", "sh601398"])
ap.add_argument("--indices", nargs="*", default=["000016", "000300"])
ap.add_argument("--date", default=None, help="YYYYMMDD(缺省=当日)")
ap.add_argument("--skip-symbols", action="store_true")
args = ap.parse_args()
from pytdxdata import TdxData
ymd = int(args.date) if args.date else int(_date.today().strftime("%Y%m%d"))
day = int(args.date) if args.date else None
async with TdxData(cache_dir=None, timeout=10.0) as td:
if not args.skip_symbols:
await check_symbols(td, args.symbols, ymd)
if args.indices:
await check_indices(td, args.indices, ymd, day)
if __name__ == "__main__":
asyncio.run(main())
+5 -1
View File
@@ -7,16 +7,18 @@ from .models import (
Adjust, Adjust,
ExMarket, ExMarket,
FinanceRecord, FinanceRecord,
IndexTradeStats,
KlinePeriod, KlinePeriod,
Market, Market,
MinuteBar, MinuteBar,
MinuteTradeStat,
SecurityBar, SecurityBar,
SecurityQuote, SecurityQuote,
TransactionRecord, TransactionRecord,
XdxrRecord, XdxrRecord,
) )
__version__ = "0.6.1" __version__ = "0.6.9"
__all__ = [ __all__ = [
"TdxData", "TdxData",
"Market", "Market",
@@ -27,6 +29,8 @@ __all__ = [
"SecurityQuote", "SecurityQuote",
"TransactionRecord", "TransactionRecord",
"MinuteBar", "MinuteBar",
"MinuteTradeStat",
"IndexTradeStats",
"XdxrRecord", "XdxrRecord",
"FinanceRecord", "FinanceRecord",
"__version__", "__version__",
+560 -51
View File
@@ -23,11 +23,15 @@ from __future__ import annotations
import asyncio import asyncio
import logging import logging
import re import re
import time
import warnings import warnings
from collections import deque
from collections.abc import Callable
from datetime import date as _date, datetime from datetime import date as _date, datetime
from pathlib import Path from pathlib import Path
from typing import Sequence from typing import Sequence
from . import decimal_sync
from .cache.disk import DiskCache from .cache.disk import DiskCache
from .cache.key import CacheKey from .cache.key import CacheKey
from .cache.manager import CacheManager from .cache.manager import CacheManager
@@ -45,11 +49,13 @@ from .models import (
FinancialFileInfo, FinancialFileInfo,
FinancialRecord, FinancialRecord,
IndicatorSet, IndicatorSet,
IndexTradeStats,
IndustryInfo, IndustryInfo,
KlinePeriod, KlinePeriod,
Market, Market,
MemberQuote, MemberQuote,
MinuteBar, MinuteBar,
MinuteTradeStat,
SecurityBar, SecurityBar,
SecurityInfo, SecurityInfo,
SecurityQuote, SecurityQuote,
@@ -142,10 +148,19 @@ _KLINE_MAX_BARS: dict[KlinePeriod, int] = {
# 自定义字段报价(0x122B/0x122C)基础字段位:昨收/开/高/低/现价/量/量比/额 # 自定义字段报价(0x122B/0x122C)基础字段位:昨收/开/高/低/现价/量/量比/额
_QUOTE_BITS = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07] _QUOTE_BITS = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]
_QUOTE_PAGE = 80 # 0x122B/0x122C 单次上限 80 只 _QUOTE_PAGE = 80 # 0x122B/0x122C 单次上限 80 只
_QUOTE_PIPE_CHUNK = 3 # 单连接流水线一次取几片(实测 3 片 + 每台 2 连接最稳)
_EX_PAGE = 1000 # EX 商品列表单页 _EX_PAGE = 1000 # EX 商品列表单页
_TICK_PAGE = 1000 # MAC 逐笔单页 _TICK_PAGE = 1000 # MAC 逐笔单页
_EX_TICK_PAGE = 1800 # 港股逐笔单页 _EX_TICK_PAGE = 1800 # 港股逐笔单页
_ALL_PAGES_CAP = 50 # count=None(全量)时的翻页上限 _ALL_PAGES_CAP = 50 # count=None(全量)时的翻页上限
# 集合竞价**委托**记录标记(0x122F 第 5 字段)。不是成交,见 _ticks_one 注释。
_BS_AUCTION_ORDER = 8
# 证券清单(0x053E)拿不到的市场。实测 27 台标准主机对 market=2(北交所)**全部
# 不响应**(26 台 6s 无回包、1 台立刻拒连),而同 market 的 0x053D 数量接口正常
# (返回 389)。故清单直接返回空,避免每次调用白等数秒再抛 ConnectionError。
# 北交所**标的本身没问题**:报价/K线/逐笔用 ``bj920992`` 这类代码都正常。
_LIST_UNSUPPORTED_MARKETS = frozenset({int(Market.BJ)})
_list_unsupported_warned: set[int] = set() # 同一市场只 WARNING 一次
# 港股系市场:逐笔走 EX 专用 16B 协议(0x23FC/0x2406),其余扩展市场走 MAC 0x122F # 港股系市场:逐笔走 EX 专用 16B 协议(0x23FC/0x2406),其余扩展市场走 MAC 0x122F
_HK_MARKETS = frozenset({27, 31, 48, 49, 71, 98}) _HK_MARKETS = frozenset({27, 31, 48, 49, 71, 98})
@@ -230,14 +245,16 @@ class TdxData:
default_adjust: Adjust = Adjust.NONE, default_adjust: Adjust = Adjust.NONE,
max_inflight: int = 64, max_inflight: int = 64,
pool_min: int = 3, pool_min: int = 3,
pool_max: int = 12, pool_max: int = 24,
mac_pool_cap: int = 4, mac_pool_cap: int = 4,
std_pool_cap: int = 4, std_pool_cap: int = 4,
ex_pool_cap: int = 2,
) -> None: ) -> None:
self.port = port self.port = port
self.timeout = timeout self.timeout = timeout
self.default_adjust = default_adjust self.default_adjust = default_adjust
self.mac_pool_cap = mac_pool_cap self.mac_pool_cap = mac_pool_cap
self.ex_pool_cap = ex_pool_cap
self._std_servers = list(standard_servers or get_standard_hosts()) self._std_servers = list(standard_servers or get_standard_hosts())
self._mac_servers = list(mac_servers or get_mac_hosts()) self._mac_servers = list(mac_servers or get_mac_hosts())
self._ex_servers = list(ex_servers or get_ex_hosts()) self._ex_servers = list(ex_servers or get_ex_hosts())
@@ -262,8 +279,11 @@ class TdxData:
probe_factory=lambda: MacKlineCmd(1, "600000", KlinePeriod.DAY, Adjust.NONE, 0, 100), probe_factory=lambda: MacKlineCmd(1, "600000", KlinePeriod.DAY, Adjust.NONE, 0, 100),
) )
# EX扩展市场池(港股/期货/美股,端口7727;MAC EX login + pytdx EX setup 混合) # EX扩展市场池(港股/期货/美股,端口7727;MAC EX login + pytdx EX setup 混合)
# 单服务器场景(测速缓存收缩后仅 1 台)下,有效并发 = 服务器数 × ex_pool_cap,
# 默认 cap=2 保证至少 2 并发;acquire 有 Condition 背压等待,不再快速失败。
self._ex_pool = ExPool(self._ex_servers, timeout=timeout, self._ex_pool = ExPool(self._ex_servers, timeout=timeout,
min_size=min(pool_min, 2), max_size=min(pool_max, 6), min_size=min(pool_min, 2), max_size=min(pool_max, 6),
per_server_cap=ex_pool_cap,
handshake_map=EX_HANDSHAKES) handshake_map=EX_HANDSHAKES)
disk = None disk = None
if self._cache_dir is not None: if self._cache_dir is not None:
@@ -274,6 +294,7 @@ class TdxData:
self._paginator_std = Paginator(self._std_pool) self._paginator_std = Paginator(self._std_pool)
self._paginator_mac = Paginator(self._mac_pool) self._paginator_mac = Paginator(self._mac_pool)
self._started = False self._started = False
self._decimal_task: asyncio.Task | None = None
async def start(self) -> None: async def start(self) -> None:
await self._std_pool.start() await self._std_pool.start()
@@ -281,8 +302,13 @@ class TdxData:
await self._ex_pool.start() await self._ex_pool.start()
await self._cache.start() await self._cache.start()
self._started = True self._started = True
# 权威价格小数位表:当日缓存命中则同步装表(无网络),否则挂后台同步。
# 不阻塞 start(),失败静默退回静态前缀规则。
self._decimal_task = decimal_sync.schedule(self)
async def close(self) -> None: async def close(self) -> None:
await decimal_sync.cancel(self._decimal_task)
self._decimal_task = None
await self._std_pool.close() await self._std_pool.close()
await self._mac_pool.close() await self._mac_pool.close()
await self._ex_pool.close() await self._ex_pool.close()
@@ -311,16 +337,68 @@ class TdxData:
返回: 返回:
``list[SecurityInfo]``,每条带 ``symbol`` 规范化标的串与 ``kind`` 分类描述。 ``list[SecurityInfo]``,每条带 ``symbol`` 规范化标的串与 ``kind`` 分类描述。
EX 通道无昨收/单位,对应字段为 0。 EX 通道无昨收/单位,对应字段为 0。
注意:
**北交所(``"bj"``)清单返回空列表**:清单命令 0x053E 对 market=2
在所有实测服务器上都不响应(27 台全测),协议层根本拿不到。
但北交所**标的本身可用** —— 报价/K线/逐笔直接传 ``bj920992`` 这类代码
都正常,只是无法枚举全量代码。``market="all"`` 时该市场被跳过,不会报错。
""" """
out: list[SecurityInfo] = [] out: list[SecurityInfo] = []
ex_items: list[SecurityInfo] | None = None
for mkt, channel in market_targets(market): for mkt, channel in market_targets(market):
if channel == "ex": if channel == "ex":
out.extend(await self._universe_ex(mkt)) # EX 全量只取一次:命中缓存也要反序列化 10 万条(~200ms),
# 十几个 EX 市场各来一次纯属白烧。
if ex_items is None:
ex_items = await self._ex_all()
out.extend(it for it in ex_items if it.market == mkt)
else: else:
out.extend(await self._universe_cn(mkt)) out.extend(await self._universe_cn(mkt))
return out return out
async def sync_decimal_points(self, markets: Sequence[str] = ("sh", "sz")
) -> dict[str, int]:
"""从证券清单同步**权威价格小数位表**,返回统计。
报价接口返回的是整数,真实价格 = ``整数 / 10**小数位``。小数位不随报价下发,
但证券清单接口自带权威值 ``SecurityInfo.decimal_point`` —— 本方法把它灌进
:func:`~pytdxdata.protocol.commands.quotes.price_decimal_digits` 使用的运行时表,
从此价格标度不再依赖硬编码前缀规则(新增代码段也不会算错)。
``start()`` 已自动处理:当日缓存命中就直接装表,否则挂后台同步,**不用手动调**。
这个方法用于「立刻要权威表」「排障时强制刷新」。
参数:
markets: 拉哪些市场,默认 ``("sh", "sz")``。证券清单走 ``get_universe``,
其本身已有缓存层,重复调用只花一次网络。
返回:
``{"prefixes", "codes", "mixed_prefixes", "stock"}`` —— 已覆盖的三位前缀数、
例外代码数、出现混合小数位的前缀数、总条目数。
``mixed_prefixes`` > 0 说明某段代码混用了不同小数位(已自动退化为逐代码查表)。
用法::
async with TdxData() as td:
print(await td.sync_decimal_points()) # {'prefixes': 300+, 'codes': 0, ...}
q = await td.get_quotes("sh019742") # 110.228(4 位小数)
"""
return await decimal_sync.refresh(self, tuple(markets))
async def decimal_point_status(self) -> dict:
"""权威小数位表当前状态(``source`` / ``stock`` / ``syncing`` 等,排障用)。"""
return decimal_sync.status()
async def _universe_cn(self, market: int) -> list[SecurityInfo]: async def _universe_cn(self, market: int) -> list[SecurityInfo]:
if market in _LIST_UNSUPPORTED_MARKETS:
if market not in _list_unsupported_warned:
_list_unsupported_warned.add(market)
log.warning(
"市场 %s 的证券清单接口协议不支持(0x053E 无响应),返回空列表;"
"该市场标的的报价/K线/逐笔不受影响", market)
return []
key = CacheKey("list", market) key = CacheKey("list", market)
async def fetch() -> bytes: async def fetch() -> bytes:
@@ -349,13 +427,18 @@ class TdxData:
async def fetch() -> bytes: async def fetch() -> bytes:
total = int(await self._execute_ex(GetExInstrumentCountCmd())) total = int(await self._execute_ex(GetExInstrumentCountCmd()))
items: list[SecurityInfo] = [] starts = list(range(0, total, _EX_PAGE))
pos = 0 sem = asyncio.Semaphore(8) # 实测 8 页并发 292ms(串行 110 页 ~4s)
while pos < total:
page = await self._execute_ex( async def one(pos: int) -> list[dict]:
async with sem:
return await self._execute_ex(
GetExInstrumentInfoCmd(0, pos, _EX_PAGE)) GetExInstrumentInfoCmd(0, pos, _EX_PAGE))
items: list[SecurityInfo] = []
for page in await asyncio.gather(*(one(s) for s in starts)):
if not page: if not page:
break continue
for g in page: for g in page:
mkt = int(g["market"]) mkt = int(g["market"])
code = str(g["code"]).strip() code = str(g["code"]).strip()
@@ -369,7 +452,6 @@ class TdxData:
symbol=format_symbol(mkt, code), symbol=format_symbol(mkt, code),
kind=str(g.get("desc", "")).strip(), kind=str(g.get("desc", "")).strip(),
)) ))
pos += len(page)
return pack_payload(items) return pack_payload(items)
return unpack_payload(await self._cache.get_or_fetch(key, fetch)) return unpack_payload(await self._cache.get_or_fetch(key, fetch))
@@ -391,7 +473,9 @@ class TdxData:
# ================================================================== # # ================================================================== #
async def get_quotes(self, symbols: str | Sequence[str], *, async def get_quotes(self, symbols: str | Sequence[str], *,
fields: Sequence[int] | None = None fields: Sequence[int] | None = None,
concurrency: int | None = None,
pipeline: bool = True
) -> list[SecurityQuote]: ) -> list[SecurityQuote]:
"""报价,一次可跨市场、跨通道混合查询。 """报价,一次可跨市场、跨通道混合查询。
@@ -401,6 +485,11 @@ class TdxData:
fields: 可选自定义字段位(如 ``[0x00, 0x04, 0x38]``)。给了就走 MAC/EX 的 fields: 可选自定义字段位(如 ``[0x00, 0x04, 0x38]``)。给了就走 MAC/EX 的
0x122B 字段位通道(有 ``name``,无五档);不给时 A股走标准通道 0x122B 字段位通道(有 ``name``,无五档);不给时 A股走标准通道
(**有五档 bid/ask、买卖量、涨跌停价,无 name**),扩展市场走 0x122B。 (**有五档 bid/ask、买卖量、涨跌停价,无 name**),扩展市场走 0x122B。
concurrency: 连接并发数(默认取连接池上限)。协议硬上限 80 只/请求,
全市场约 5,200 只 A股需切 66 片;调小可降低对服务器的压力。
pipeline: 是否启用**单连接流水线**(默认开启)。开启后一条连接可一次发出
多个分片、只付一次往返,全市场 5,200 只 A股由 ~4s 降到 **~0.3s**;
个股或小批量不受影响。个别服务器不支持流水线时会自动降级为逐片。
返回: 返回:
``list[SecurityQuote]``,按入参顺序排列(各记录带 ``symbol``)。 ``list[SecurityQuote]``,按入参顺序排列(各记录带 ``symbol``)。
@@ -411,50 +500,155 @@ class TdxData:
bits = [int(b) for b in fields] if fields else None bits = [int(b) for b in fields] if fields else None
tag = "mac:" + _fields_tag(bits) if bits else "std" tag = "mac:" + _fields_tag(bits) if bits else "std"
key = CacheKey.quote_key([s.as_pair() for s in syms], tag=tag) key = CacheKey.quote_key([s.as_pair() for s in syms], tag=tag)
payload = await self._cache.get_or_fetch( quotes = await self._cache.get_or_fetch_obj(
key, lambda: self._fetch_quotes(syms, bits)) key,
quotes = unpack_payload(payload) lambda: self._fetch_quotes(syms, bits, concurrency, pipeline),
pack=pack_payload, unpack=unpack_payload)
order = {s.as_pair(): i for i, s in enumerate(syms)} order = {s.as_pair(): i for i, s in enumerate(syms)}
quotes.sort(key=lambda q: order.get((int(q.market), q.code), len(order))) quotes.sort(key=lambda q: order.get((int(q.market), q.code), len(order)))
return quotes return quotes
async def _fetch_quotes(self, syms: list[Symbol], bits: list[int] | None) -> bytes: async def _fetch_quotes(self, syms: list[Symbol], bits: list[int] | None,
concurrency: int | None = None,
pipeline: bool = True) -> list[SecurityQuote]:
out: list[SecurityQuote] = [] out: list[SecurityQuote] = []
cn = [s for s in syms if not s.is_ex] cn = [s for s in syms if not s.is_ex]
ex = [s for s in syms if s.is_ex] ex = [s for s in syms if s.is_ex]
if bits is None: if bits is None:
if cn: if cn:
out.extend(await self._quotes_std(cn)) out.extend(await self._quotes_std(
cn, concurrency=concurrency, pipeline=pipeline))
if ex: if ex:
rows = await self._execute_ex( rows = await self._execute_ex(
MacSymbolQuotesCmd([s.as_pair() for s in ex], None)) MacSymbolQuotesCmd([s.as_pair() for s in ex], None))
out.extend(_quote_from_member(m) for m in rows) out.extend(_quote_from_member(m) for m in rows)
else: else:
for i in range(0, len(syms), _QUOTE_PAGE): batches = [syms[i:i + _QUOTE_PAGE]
batch = syms[i:i + _QUOTE_PAGE] for i in range(0, len(syms), _QUOTE_PAGE)]
sem = asyncio.Semaphore(self._quote_concurrency(concurrency))
async def one(batch: list[Symbol]) -> list[SecurityQuote]:
async with sem:
pairs = [s.as_pair() for s in batch] pairs = [s.as_pair() for s in batch]
cn_pairs = [p for p, s in zip(pairs, batch) if not s.is_ex] cn_pairs = [p for p, s in zip(pairs, batch) if not s.is_ex]
ex_pairs = [p for p, s in zip(pairs, batch) if s.is_ex] ex_pairs = [p for p, s in zip(pairs, batch) if s.is_ex]
got: list[SecurityQuote] = []
if cn_pairs: if cn_pairs:
rows = await self._execute_mac(MacSymbolQuotesCmd(cn_pairs, bits)) rows = await self._execute_mac(
out.extend(_quote_from_member(m) for m in rows) MacSymbolQuotesCmd(cn_pairs, bits))
got.extend(_quote_from_member(m) for m in rows)
if ex_pairs: if ex_pairs:
rows = await self._execute_ex(MacSymbolQuotesCmd(ex_pairs, bits)) rows = await self._execute_ex(
out.extend(_quote_from_member(m) for m in rows) MacSymbolQuotesCmd(ex_pairs, bits))
return pack_payload(out) got.extend(_quote_from_member(m) for m in rows)
return got
async def _quotes_std(self, syms: list[Symbol]) -> list[SecurityQuote]: if batches:
"""A股标准通道五档报价(>80 只自动切批)。""" for got in await asyncio.gather(*(one(b) for b in batches)):
out: list[SecurityQuote] = [] out.extend(got)
for i in range(0, len(syms), MAX_QUOTES): return out
batch = syms[i:i + MAX_QUOTES]
cmd = GetSecurityQuotesCmd([s.as_pair() for s in batch]) def _quote_concurrency(self, requested: int | None) -> int:
rows = await self._execute_standard(cmd) """连接并发数:显式指定优先,否则按「每台服务器 2 连接」估算。
实测(5,227 只 A股 / 66 片,11 台服务器):
========== ===== ====== ====== ======
并发 每台连接 流水深度 p50 max
========== ===== ====== ====== ======
11 1 6 455ms 464ms
12 1~2 3 457ms 523ms
**22** **2** **3** **325ms** **334ms**
33 3 2 328ms 345ms
========== ===== ====== ====== ======
结论:每台 2 连接 × 流水 3 片最稳;再多连接只是把同一台的队列搬个位置,
对整体无益反增抖动。池 ``per_server_cap`` 默认 4,2 连接仍留有余量。
"""
if requested is not None and requested > 0:
return max(1, int(requested))
n = len(self._std_pool.servers)
return max(1, min(self._std_pool.max_size, (n or 1) * 2))
async def _quotes_std(self, syms: list[Symbol], *,
concurrency: int | None = None,
pipeline: bool = True) -> list[SecurityQuote]:
"""A股标准通道五档报价(协议上限 80 只/请求,超出自动切批)。
切片多于 1 片时把各片**按轮转分给若干条连接**,每条连接内部用流水线
一次发出(1 次往返拿多片),不再逐片往返。
"""
if not syms:
return []
def stamp(rows: list[SecurityQuote]) -> list[SecurityQuote]:
for q in rows: for q in rows:
q.symbol = format_symbol(q.market, q.code) q.symbol = format_symbol(q.market, q.code)
out.extend(rows) return rows
batches = [syms[i:i + MAX_QUOTES]
for i in range(0, len(syms), MAX_QUOTES)]
if len(batches) == 1:
cmd = GetSecurityQuotesCmd([s.as_pair() for s in batches[0]])
return stamp(await self._execute_standard(cmd))
conc = min(self._quote_concurrency(concurrency), len(batches))
# 首次大批量:先把连接并发建好,否则 acquire 会在池锁里串行握手
# (22 路并发首次调用实测多花 5~6s)
await self._std_pool.warm(conc)
if not pipeline:
sem = asyncio.Semaphore(conc)
async def one(batch: list[Symbol]) -> list[SecurityQuote]:
async with sem:
cmd = GetSecurityQuotesCmd([s.as_pair() for s in batch])
return stamp(await self._execute_standard(cmd))
groups = await asyncio.gather(*(one(b) for b in batches))
return [q for g in groups for q in g]
# 工作窃取:连接做完一批就回来再取,快的多干、慢的少干。
# 平均分配(每台固定几片)会被最慢的一台拖住 —— 实测 11 台平均分
# 时 p50 在 400~580ms 之间抖,改窃取后波动收窄。
queue = deque(batches)
gate = asyncio.Lock()
async def worker() -> list[SecurityQuote]:
got: list[SecurityQuote] = []
while True:
async with gate:
if not queue:
return got
take = min(_QUOTE_PIPE_CHUNK, len(queue))
chunk = [queue.popleft() for _ in range(take)]
for rows in await self._execute_std_pipeline(chunk):
got.extend(stamp(rows))
out: list[SecurityQuote] = []
for part in await asyncio.gather(*(worker() for _ in range(conc))):
out.extend(part)
return out return out
async def _execute_std_pipeline(
self, batches: list[list[Symbol]]
) -> list[list[SecurityQuote]]:
"""一条连接流水线执行多片报价;节点不支持流水线时降级为逐片。"""
cmds = [GetSecurityQuotesCmd([s.as_pair() for s in b]) for b in batches]
pc = await self._std_pool.acquire()
try:
rows = await pc.execute_pipeline(cmds)
except Exception:
# 流水线中断后响应流已错配,连接必须废弃;改用逐片(每条独立借还)
await self._std_pool.release(pc, broken=True)
fallback: list[list[SecurityQuote]] = []
for cmd in cmds:
fallback.append(await self._execute_standard(cmd))
return fallback
await self._std_pool.release(pc)
return rows
async def get_snapshot(self, symbols: str | Sequence[str]) -> list[SymbolSnapshot]: async def get_snapshot(self, symbols: str | Sequence[str]) -> list[SymbolSnapshot]:
"""个股特征快照(当日/换手/活跃度等,仅 A股)。""" """个股特征快照(当日/换手/活跃度等,仅 A股)。"""
syms = parse_symbols(symbols) syms = parse_symbols(symbols)
@@ -790,12 +984,30 @@ class TdxData:
参数: 参数:
date: ``None``=当日,``YYYYMMDD``=历史某日。 date: ``None``=当日,``YYYYMMDD``=历史某日。
start: 起始偏移。 start: 起始偏移,**从最新一笔往回数**(``0``=当天最后一条)。
``start=1000`` 表示跳过最近 1000 条、从更早的位置开始。
count: ``None``=尽量取全量(自动翻页,上限 50 页);给了就取这么多条。 count: ``None``=尽量取全量(自动翻页,上限 50 页);给了就取这么多条。
返回: 返回:
``list[TransactionRecord]``,按入参标的顺序拼接(A股含 ``trade_count``, ``list[TransactionRecord]``,按入参标的顺序拼接,**每条标的内部按时间升序**。
港股为 HH:MM 时间 + ``fields["zengcang"]`` 增仓)。 注意服务端是按约 3 秒聚合的切片,``vol``/``trade_count`` 是切片增量
而非当日累计。
A股含 ``trade_count``,港股为 HH:MM 时间 + ``fields["zengcang"]`` 增仓。
**集合竞价委托(``bs_flag=8``)不会出现在结果里**:它们不是成交,``vol``
是累计撮合量(会被后续记录覆盖),计入会让 Σvol 比真值虚高 20%~160%,
且不同主机收录的条数不同 → 同一查询两次调用结果不一致。
**指数(``sh000016`` 等)的两个字段语义与个股不同**:
- ``vol`` 单位是**百元**(成交额/100),不是手。
- ``trade_count`` 是**当时均价 × 1000**,不是笔数。
**ETF / LOF 同样没有笔数**:``trade_count`` 是「价格 × 1000」(货币 ETF 恒为 0),
这类记录的 ``trade_count_available`` 为 ``False`` 且 ``trade_count`` 已置 0。
判定规则见 :func:`~pytdxdata.symbols.has_order_count`。
详见 :class:`~pytdxdata.models.TransactionRecord` 的类注释。
""" """
syms = parse_symbols(symbols) syms = parse_symbols(symbols)
sem = asyncio.Semaphore(max(1, concurrency)) sem = asyncio.Semaphore(max(1, concurrency))
@@ -816,18 +1028,19 @@ class TdxData:
if sym.is_ex: if sym.is_ex:
rows = await self._ticks_ex(sym, date=date, start=start, count=count) rows = await self._ticks_ex(sym, date=date, start=start, count=count)
else: else:
def make_cmd(s: int, c: int): rows = await self._ticks_cn_serial(sym, date=date, start=start,
return MacTransactionCmd(sym.market, sym.code, date or 0, s, c) count=count)
# ★ 过滤集合竞价**委托**记录(bs_flag=8)。必须在逐页拉取**全部结束之后**做:
spec = PageSpec( # 分页靠 `len(rows) < page_size` 判终止,若在 parse_response 里过滤,
page_size=_TICK_PAGE, # 满页会被剥短成"短页" → 提前终止 → 丢数据。
total=None if count is None else start + count, # 实测(2026-10-21 sh600000):b8 是 09:15~09:25 / 14:57~15:00 竞价段的
min_page=100, # 撮合快照,vol 是**累计值**(可被后续记录覆盖),不是成交增量;
stop_when_short=True, # 计入后 Σvol 比真值虚高 20%~160%,且**不同主机的 b8 集合不同**
max_pages=_ALL_PAGES_CAP if count is None else None, # (干净主机 0 条、脏主机 135 条)→ 同一查询两次调用结果不一致。
start_offset=start, # 剔除后:Σvol 与快照 vol 精确相等(比值 1.0000),且跨主机逐条一致。
) rows = [r for r in rows if r.bs_flag != _BS_AUCTION_ORDER]
rows = await self._fetch_paginated_list("mac", make_cmd, spec) # 排序放在 pack 之前,让缓存直接存入正确顺序,避免每次命中都重排。
rows.sort(key=lambda r: r.time)
return pack_payload(rows) return pack_payload(rows)
records = unpack_payload(await self._cache.get_or_fetch(key, fetch)) records = unpack_payload(await self._cache.get_or_fetch(key, fetch))
@@ -835,6 +1048,54 @@ class TdxData:
r.symbol = sym.text r.symbol = sym.text
return records 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, async def _ticks_ex(self, sym: Symbol, *, date: int | None, start: int,
count: int | None) -> list[TransactionRecord]: count: int | None) -> list[TransactionRecord]:
from .protocol.commands.ex_ext import ( from .protocol.commands.ex_ext import (
@@ -843,7 +1104,7 @@ class TdxData:
) )
hk = sym.market in _HK_MARKETS hk = sym.market in _HK_MARKETS
page = _EX_TICK_PAGE if hk else _TICK_PAGE page = _EX_TICK_PAGE if hk else _TICK_PAGE
out: list[TransactionRecord] = [] chunks: list[list[TransactionRecord]] = []
pos = start pos = start
remaining = count remaining = count
for _ in range(_ALL_PAGES_CAP): for _ in range(_ALL_PAGES_CAP):
@@ -855,22 +1116,27 @@ class TdxData:
if date else if date else
GetExTransactionDataCmd(sym.market, sym.code, pos, n)) GetExTransactionDataCmd(sym.market, sym.code, pos, n))
rows = await self._execute_ex(cmd) 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: else:
cmd = MacTransactionCmd(sym.market, sym.code, date or 0, pos, n) cmd = MacTransactionCmd(sym.market, sym.code, date or 0, pos, n)
rows = await self._execute_ex(cmd) rows = await self._execute_ex(cmd)
for r in rows: for r in rows:
r.symbol = sym.text r.symbol = sym.text
out.extend(rows) chunk = list(rows)
if not rows: if not chunk:
break break
pos += len(rows) # EX 通道的 pos 同样是"从最新往回数",逐页倒序累加 → 最后整体翻转。
chunks.append(chunk)
pos += len(chunk)
if remaining is not None: if remaining is not None:
remaining -= len(rows) remaining -= len(chunk)
if remaining <= 0: if remaining <= 0:
break break
if len(rows) < n: if len(chunk) < n:
break break
out: list[TransactionRecord] = []
for chunk in reversed(chunks):
out.extend(chunk)
return out return out
@staticmethod @staticmethod
@@ -887,6 +1153,7 @@ class TdxData:
trade_count=0, trade_count=0,
bs_flag=int(row.get("direction", 0) or 0), bs_flag=int(row.get("direction", 0) or 0),
fields=fields, fields=fields,
trade_count_available=False, # 扩展市场逐笔不带笔数字段
) )
async def get_minutes( async def get_minutes(
@@ -1216,6 +1483,248 @@ class TdxData:
result.sort(key=lambda x: x["change_pct"], reverse=True) result.sort(key=lambda x: x["change_pct"], reverse=True)
return result[:top_n] return result[:top_n]
# ================================================================== #
# 七之二、指数成分成交汇总(成分股逐笔 → 每分钟成交量 / 笔数)
# ================================================================== #
@staticmethod
def _index_pair(index: str) -> tuple[int, str]:
"""解析指数标的 → ``(市场号, 6 位代码)``。
与 :func:`~pytdxdata.symbols.parse_symbol` 的关键区别:**裸 6 位数字
一律按指数语义解析**,不做「``000xxx`` → 深市股票」的推断 ——
在指数接口里 ``000001`` 是**上证指数**,不是平安银行 ``sz000001``。
判定规则(与通达信板块码一致)::
000xxx / 999xxx / 880xxx -> 沪市(上证指数 / A股指数 / 板块指数)
399xxx -> 深市(深证成指 / 创业板指)
899xxx -> 北交所(北证50)
显式前缀 ``sh``/``sz``/``bj`` 优先,例如 ``sz399001``、``sh000300``。
"""
s = str(index).strip().lower().replace(".", "").replace(":", "")
if not s:
raise ValueError("指数标的不能为空")
prefix_table = {"sh": 1, "sz": 0, "bj": 2}
if s[:2] in prefix_table:
code = s[2:]
if not (code.isdigit() and len(code) == 6):
raise ValueError(f"非法指数标的: {index!r}(前缀后需 6 位数字)")
return prefix_table[s[:2]], code
if not (s.isdigit() and len(s) == 6):
raise ValueError(f"非法指数标的: {index!r}(需 6 位代码或 sh/sz/bj 前缀)")
if s.startswith(("000", "999", "880")):
return 1, s
if s.startswith("399"):
return 0, s
if s.startswith("899"):
return 2, s
raise ValueError(f"无法判定指数市场: {index!r}(不是 A股指数代码段)")
async def get_index_members(self, index: str, *, count: int = 100000,
fields: Sequence[int] | None = None
) -> list[SecurityQuote]:
"""指数**成分股**(含实时报价)。
走 MAC ``0x122C`` 板块成分命令,指数代码映射为服务端板块码:``000300`` →
31300、``399001`` → 30001、``899050`` → 32050(见 :meth:`_convert_board_code`)。
实测(2026-10-22):``sh000001`` 2230 只(沪市全部)、``sh000300`` 300 只、
``sh000016`` 50 只、``sh000905`` 500 只、``sh000852`` 1000 只、
``sz399006`` 100 只、``bj899050`` 50 只。
参数:
index: 指数代码,可裸写或带前缀(``"000300"`` / ``"sh000300"``)。
count: 最多取的成分数(分页上限,默认足够覆盖全部)。
fields: 附加报价字段位(同 :meth:`get_board_members`)。
注意:返回的是**当前**成分,指数调仓后历史日期不适用。
⚠️ **综合指数的成员名单不完整**(实测 2026-10-22):``sh000001`` 只返回
2230 只(2190 A + 40 B),而当日沪市 A 股实有 2318 只;缺的 128 只
(多为近期科创板/主板新股)当日成交 282 亿,正好对上「指数日线 amount −
成员日线 amount」的 297 亿(残差 4.9%)。因此
:meth:`get_index_trade_stats` 对**综合指数**会系统性低估约 4.6%;
样本指数 ``sh000016``(50 只)/ ``sh000300``(300 只)实测比值
**1.000000**,不受影响。要精确汇总综指成交,请自行用全市场股票列表。
用法::
members = await td.get_index_members("000300")
syms = [m.symbol for m in members] # ['sz000001', ...]
"""
_market, code = self._index_pair(index)
board_code = self._convert_board_code(code)
bits = [int(b) for b in fields] if fields else list(_QUOTE_BITS)
items: list[SecurityQuote] = []
start = 0
while start < count:
batch = await self._execute_mac(MacBoardMembersQuotesCmd(
board_code, sort_type=0, start=start,
page_size=_QUOTE_PAGE, bits=bits))
if not batch:
break
items.extend(_quote_from_member(m) for m in batch)
start += len(batch)
if len(batch) < _QUOTE_PAGE:
break
return items[:count]
async def get_index_trade_stats(
self,
index: str,
date: int | None = None,
*,
concurrency: int = 24,
batch_size: int = 50,
members: Sequence[str] | None = None,
skip_errors: bool = True,
on_progress: Callable[[int, int], None] | None = None,
) -> IndexTradeStats:
"""按指数**全部成分股**的逐笔汇总出每分钟成交量与成交笔数。
为什么必须绕这一圈:**通达信协议里指数本身没有成交笔数** —— 指数逐笔的
``trade_count`` 是「当时均价 × 1000」,不是笔数(见
:class:`TransactionRecord` 类注释)。所以「指数笔数」只能用成分股逐笔累加。
口径校验:``total_amount`` 是**成分股**合计。对「成分 = 指数覆盖面」的指数
它与指数快照 ``amount`` 完全相等(``sh000016`` 661.34 亿、``sh000300``
2373.98 亿,比值 1.0000);但深市 ``399xxx`` 的指数 ``amount`` 是**全板块**
口径(``sz399001`` = 深市全部股票 5081 亿、``sz399006`` = 创业板全部),
两者不可直接比。详见 :class:`IndexTradeStats`。
参数:
index: 指数代码(``"000300"`` / ``"sh000300"``,规则见 :meth:`_index_pair`)。
date: ``None`` = 当日;``YYYYMMDD`` = 历史某日(通达信逐笔仅保留最近
若干交易日,实测 2026-10-22 可回溯到 10-14,更早返回空)。
concurrency: 逐笔并发数(受 MAC 连接池上限约束,池满自动排队)。
batch_size: 每批处理的成分数 —— 批内并发拉取、批间串行聚合,
用于压住内存峰值(全量 tick 不驻留)。
members: 直接给成分股列表(跳过 :meth:`get_index_members`,
多日循环时可复用一次成分请求)。
skip_errors: 单只成分失败是否忽略(默认忽略并计入 ``failed_members``)。
on_progress: 进度回调 ``(已处理, 总数)``,每批结束调用一次。
返回:
:class:`IndexTradeStats`;``minutes`` 是**每分钟增量**,
「当日截止该分钟累计」用 ``.cumulative()`` / ``.cum_trade_count()``。
性能(实测 2026-10-22,盘中):
====================== ========== ============
指数 成分数 耗时
====================== ========== ============
``sh000016`` 上证50 50 ~5 s
``sh000300`` 沪深300 300 ~10 s
``sh000001`` 上证指数 2230 ~60-90 s
====================== ========== ============
**北交所成分没有笔数**(实测 ``trade_count`` 恒 0),此时
``trade_count_available`` 为 ``False``,只有成交量可用。
用法::
st = await td.get_index_trade_stats("000300")
for hhmm, cum in st.cum_trade_count():
print(hhmm, cum)
"""
started = time.perf_counter()
market, code = self._index_pair(index)
idx_text = format_symbol(market, code)
if members is None:
members = [m.symbol for m in await self.get_index_members(code)]
syms = [s for s in members if s]
total = len(syms)
if total == 0:
raise ValueError(f"指数 {index!r} 没有取到成分股")
vol_by_min: dict[str, float] = {}
tc_by_min: dict[str, int] = {}
amt_by_min: dict[str, float] = {}
active: set[str] = set()
with_tc: set[str] = set()
failed = 0
step = max(1, int(batch_size))
done = 0
for i in range(0, total, step):
batch = syms[i:i + step]
try:
ticks = await self.get_ticks(batch, date=date, concurrency=concurrency)
except Exception:
if not skip_errors:
raise
# 整批失败 → 退化为逐只重试,避免一只坏股拖垮一批
ticks = []
for one in batch:
try:
ticks.extend(await self.get_ticks(one, date=date))
except Exception:
failed += 1
for t in ticks:
hhmm = t.time[:5]
vol_by_min[hhmm] = vol_by_min.get(hhmm, 0.0) + t.vol
# 成分里若混入 ETF/LOF(协议无笔数),不能把占位值累加进笔数
if getattr(t, "trade_count_available", True):
tc_by_min[hhmm] = tc_by_min.get(hhmm, 0) + t.trade_count
amt_by_min[hhmm] = amt_by_min.get(hhmm, 0.0) + t.price * t.vol * 100.0
active.add(t.symbol)
if getattr(t, "trade_count_available", True) and t.trade_count:
with_tc.add(t.symbol)
done += len(batch)
if on_progress is not None:
on_progress(min(done, total), total)
minutes = [
MinuteTradeStat(time=k, volume=vol_by_min[k],
trade_count=tc_by_min[k], amount=amt_by_min[k])
for k in sorted(vol_by_min)
]
return IndexTradeStats(
index=idx_text,
date=date,
member_count=total,
active_members=len(active),
trade_count_members=len(with_tc),
minutes=minutes,
total_volume=sum(vol_by_min.values()),
total_trade_count=sum(tc_by_min.values()),
total_amount=sum(amt_by_min.values()),
failed_members=failed,
elapsed=time.perf_counter() - started,
)
async def get_index_trade_stats_multi(
self,
index: str,
dates: Sequence[int | None],
*,
concurrency: int = 24,
batch_size: int = 50,
skip_errors: bool = True,
on_progress: Callable[[int, int], None] | None = None,
) -> list[IndexTradeStats]:
"""多日批量版 :meth:`get_index_trade_stats`(成分只取一次)。
用于「近 N 日同时点累计平均笔数」这类基准曲线:一次拿到 N 天数据,
避免每天重复请求成分表。
用法::
# 最近 5 个交易日的笔数曲线(日期自己给,节假日请自行跳过)
stats = await td.get_index_trade_stats_multi(
"000300", [20261016, 20261019, 20261020, 20261021, 20261022])
"""
market, code = self._index_pair(index)
members = [m.symbol for m in await self.get_index_members(code)]
out: list[IndexTradeStats] = []
for d in dates:
out.append(await self.get_index_trade_stats(
code, d, concurrency=concurrency, batch_size=batch_size,
members=members, skip_errors=skip_errors,
on_progress=on_progress))
return out
# ================================================================== # # ================================================================== #
# 八、服务器文件(原始字节 + 解析) # 八、服务器文件(原始字节 + 解析)
# ================================================================== # # ================================================================== #
+32
View File
@@ -90,6 +90,38 @@ class CacheManager:
# 确保清理锁(即使 fetcher 异常也清理,避免无限增长) # 确保清理锁(即使 fetcher 异常也清理,避免无限增长)
self._locks.pop(ks, None) self._locks.pop(ks, None)
async def get_or_fetch_obj(
self,
key: CacheKey,
fetcher: Callable[[], Awaitable[Any]],
*,
pack: Callable[[Any], bytes],
unpack: Callable[[bytes], Any],
) -> Any:
"""同 :meth:`get_or_fetch`,但**回源时直接返回新取到的对象**。
用于「一次取回上千条记录」的场景(如全市场报价):常规路径对冷数据
会先 ``pack`` 再立刻 ``unpack`` 一次,纯属往返浪费 —— 5,200 条报价实测
白烧约 90ms。这里命中缓存才解序列化,回源则把对象原样返回,只在写缓存时打包。
"""
ks = key.to_str()
cached = await self.get(key)
if cached is not None:
return unpack(cached)
lock = self._locks.setdefault(ks, asyncio.Lock())
try:
async with lock:
cached = await self.get(key)
if cached is not None:
return unpack(cached)
async with self._semaphore:
obj = await fetcher()
await self.set(key, pack(obj))
return obj
finally:
self._locks.pop(ks, None)
async def invalidate(self, category: str, *, market: int | None = None, async def invalidate(self, category: str, *, market: int | None = None,
code: str | None = None) -> int: code: str | None = None) -> int:
"""按前缀批量失效,返回失效条数。""" """按前缀批量失效,返回失效条数。"""
+112 -13
View File
@@ -8,6 +8,7 @@
tdx transactions sz000001 --count 50 # 逐笔成交 tdx transactions sz000001 --count 50 # 逐笔成交
tdx minute sz000001 # 分时(今日/历史--date) tdx minute sz000001 # 分时(今日/历史--date)
tdx index 000001 --count 30 # 指数K线 tdx index 000001 --count 30 # 指数K线
tdx index-stats 000300 --top 10 # 指数成分成交汇总(每分钟成交量/笔数)
tdx board list [--type 1] # 板块列表(0全部/1行业/2概念) tdx board list [--type 1] # 板块列表(0全部/1行业/2概念)
tdx board members 881001 --count 20 # 板块成分 tdx board members 881001 --count 20 # 板块成分
tdx board ranking [--top 10] # 板块涨跌幅排行 tdx board ranking [--top 10] # 板块涨跌幅排行
@@ -37,6 +38,7 @@ from .api import TdxData
from dataclasses import asdict from dataclasses import asdict
from .models import Adjust, ExMarket, KlinePeriod, Market from .models import Adjust, ExMarket, KlinePeriod, Market
from .protocol.commands.quotes import price_decimal_digits
PERIODS = { PERIODS = {
"min1": KlinePeriod.MIN_1, "min5": KlinePeriod.MIN_5, "min15": KlinePeriod.MIN_15, "min1": KlinePeriod.MIN_1, "min5": KlinePeriod.MIN_5, "min15": KlinePeriod.MIN_15,
@@ -106,6 +108,40 @@ def _pct(price: float, pre: float) -> str:
return "%+.2f%%" % ((price / pre - 1) * 100) return "%+.2f%%" % ((price / pre - 1) * 100)
def _price_fmt(dp: int) -> str:
"""按品种小数位生成右对齐格式串。
股票 2 位、**可转债/ETF 3 位**、债券/回购 4 位。固定写 ``%8.2f`` 会把
可转债的 128.891 打成 128.89(少一位有效报价)。
"""
dp = max(0, min(int(dp or 2), 4))
return "%%%d.%df" % (6 + dp, dp)
# 可转债后缀(解码 4 位,但交易所报价步长 0.001 元,第 4 位恒为 0)
_CB_PREFIX = {1: ("110", "111", "113", "118"), 0: ("123", "127", "128")}
def _display_dp(market: int, code: str) -> int:
"""报价**显示**小数位。
注意 ``price_decimal_digits`` 给的是**解码位数**(原始整数 / 10**dp),
可转债是 4 位;但真实报价是 0.001 元的步长,第 4 位恒为 0,
按 4 位打印只会多一个 ``0``(``128.8920``)。
"""
dp = price_decimal_digits(market, code)
if str(code).startswith(_CB_PREFIX.get(int(market), ())):
return 3
return dp
def _dp_of(sym) -> int:
"""Symbol -> 价格小数位(非 A 股/指数一律 2 位)。"""
if getattr(sym, "kind", "") == "cn":
return _display_dp(sym.market, sym.code)
return 2
# ------------------------------------------------------------------ # # ------------------------------------------------------------------ #
# 各子命令 # 各子命令
# ------------------------------------------------------------------ # # ------------------------------------------------------------------ #
@@ -119,24 +155,31 @@ async def cmd_quotes(td: TdxData, symbols: list[str]) -> None:
def _print_quote(q) -> None: def _print_quote(q) -> None:
pct = (q.price / q.pre_close - 1) * 100 if q.pre_close else 0 pct = (q.price / q.pre_close - 1) * 100 if q.pre_close else 0
mkt = {31: "港股", 74: "美股"}.get(q.market, "") mkt = {31: "港股", 74: "美股"}.get(q.market, "")
if q.market in (0, 1):
dp = _display_dp(q.market, q.code)
else:
dp = getattr(q, "decimal_point", 2) or 2
print("=" * 58) print("=" * 58)
label = "%s %s" % (mkt, q.code) if mkt else "%s %s" % (q.code, q.server_time or datetime.now().strftime("%H:%M:%S")) label = "%s %s" % (mkt, q.code) if mkt else "%s %s" % (q.code, q.server_time or datetime.now().strftime("%H:%M:%S"))
print(" %s" % label) print(" %s" % label)
print(" 最新 %-10.2f 涨跌 %+8.2f (%+.2f%%)" % (q.price, q.price - q.pre_close, pct)) print(" 最新 %-10.*f 涨跌 %+8.*f (%+.2f%%)" % (dp, q.price, dp, q.price - q.pre_close, pct))
print(" 今开 %-10.2f 最高 %.2f 最低 %.2f" % (q.open, q.high, q.low)) print(" 今开 %-10.*f 最高 %.*f 最低 %.*f" % (dp, q.open, dp, q.high, dp, q.low))
print(" 昨收 %-10.2f 成交量 %s 成交额 %s" % (q.pre_close, _fmt_num(q.vol), _fmt_num(q.amount))) print(" 昨收 %-10.*f 成交量 %s 成交额 %s" % (dp, q.pre_close, _fmt_num(q.vol), _fmt_num(q.amount)))
if q.bid and q.ask: if q.bid and q.ask:
print(" " + "-" * 56) print(" " + "-" * 56)
pf = _price_fmt(dp)
for i in range(max(len(q.bid), len(q.ask))): for i in range(max(len(q.bid), len(q.ask))):
b = q.bid[i] if i < len(q.bid) else (0, 0) b = q.bid[i] if i < len(q.bid) else (0, 0)
a = q.ask[i] if i < len(q.ask) else (0, 0) a = q.ask[i] if i < len(q.ask) else (0, 0)
print(" 买%-1d %8.2f %10s | 卖%-1d %8.2f %10s" % ( print((" 买%-1d " + pf + " %10s | 卖%-1d " + pf + " %10s") % (
i + 1, b[0], _fmt_num(b[1]), i + 1, a[0], _fmt_num(a[1]))) i + 1, b[0], _fmt_num(b[1]), i + 1, a[0], _fmt_num(a[1])))
print() print()
async def cmd_kline(td: TdxData, sym: str, period: KlinePeriod, count: int, async def cmd_kline(td: TdxData, sym: str, period: KlinePeriod, count: int,
start: int, adjust: Adjust) -> None: start: int, adjust: Adjust) -> None:
s = parse_symbol(sym)
pf = _price_fmt(_dp_of(s))
bars = await td.get_bars(sym, period, start=start, count=count, adjust=adjust) bars = await td.get_bars(sym, period, start=start, count=count, adjust=adjust)
print("%s K线 (%s, %d根):" % (sym, period.name, len(bars))) print("%s K线 (%s, %d根):" % (sym, period.name, len(bars)))
print(" %-12s %8s %8s %8s %8s %12s" % ("日期", "开盘", "最高", "最低", "收盘", "成交量")) print(" %-12s %8s %8s %8s %8s %12s" % ("日期", "开盘", "最高", "最低", "收盘", "成交量"))
@@ -144,30 +187,38 @@ async def cmd_kline(td: TdxData, sym: str, period: KlinePeriod, count: int,
dt = "%04d-%02d-%02d" % (b.year, b.month, b.day) dt = "%04d-%02d-%02d" % (b.year, b.month, b.day)
if b.hour: if b.hour:
dt += " %02d:%02d" % (b.hour, b.minute) dt += " %02d:%02d" % (b.hour, b.minute)
print(" %-12s %8.2f %8.2f %8.2f %8.2f %12s" % ( print((" %-12s " + " ".join([pf] * 4) + " %12s") % (
dt, b.open, b.high, b.low, b.close, _fmt_num(b.vol))) dt, b.open, b.high, b.low, b.close, _fmt_num(b.vol)))
async def cmd_transactions(td: TdxData, sym: str, count: int, date: int | None) -> None: async def cmd_transactions(td: TdxData, sym: str, count: int, date: int | None) -> None:
s = parse_symbol(sym) s = parse_symbol(sym)
tx = await td.get_transactions(Market(s.market), s.code, date=date, count=count) pf = _price_fmt(_dp_of(s))
tx = await td.get_ticks(sym, date=date, count=count)
print("%s 逐笔成交 (%d条):" % (sym, len(tx))) print("%s 逐笔成交 (%d条):" % (sym, len(tx)))
print(" 时间 价格 成交量 方向") print(" 时间 价格 成交量 方向")
for t in tx: for t in tx:
bs = "买" if getattr(t, "bs_flag", 0) == 1 else "卖" if getattr(t, "bs_flag", 0) == 2 else "-" bs = "买" if getattr(t, "bs_flag", 0) == 1 else "卖" if getattr(t, "bs_flag", 0) == 2 else "-"
tc = getattr(t, "trade_count", 0) if not getattr(t, "trade_count_available", True):
print(" %-10s %8.2f %10s %s%s" % (t.time, t.price, _fmt_num(t.vol), bs, tc = " (-)" # 指数/ETF/LOF:协议不提供笔数
" (%d笔)" % tc if tc else "")) elif getattr(t, "trade_count", 0):
tc = " (%d笔)" % t.trade_count
else:
tc = ""
print((" %-10s " + pf + " %10s %s%s") % (
t.time, t.price, _fmt_num(t.vol), bs, tc))
async def cmd_minute(td: TdxData, sym: str, date: int | None) -> None: async def cmd_minute(td: TdxData, sym: str, date: int | None) -> None:
s = parse_symbol(sym) s = parse_symbol(sym)
bars = await td.get_minute(Market(s.market), s.code, date=date) pf = _price_fmt(_dp_of(s))
bars = await td.get_minutes(sym, date=date)
print("%s 分时 (%d条):" % (sym, len(bars))) print("%s 分时 (%d条):" % (sym, len(bars)))
print(" 时间 价格 均价 成交量") print(" 时间 价格 均价 成交量")
for i, b in enumerate(bars): for b in bars:
print(" %02d:%02d %8.2f %8.2f %10s" % ( # 用 bar 自带时间:早期按序号推算会打成 00:00~03:59
i // 60, i % 60, b.price, b.avg_price, _fmt_num(b.vol))) print((" %02d:%02d " + pf + " " + pf + " %10s") % (
b.hour, b.minute, b.price, b.avg_price, _fmt_num(b.vol)))
async def cmd_board(td: TdxData, args) -> None: async def cmd_board(td: TdxData, args) -> None:
@@ -204,6 +255,43 @@ async def cmd_board(td: TdxData, args) -> None:
print(" %-12s %+8.2f%%" % (r.get("name", ""), r.get("change_pct", 0))) print(" %-12s %+8.2f%%" % (r.get("name", ""), r.get("change_pct", 0)))
async def cmd_index_stats(td: TdxData, index: str, date: int | None,
show_all: bool, top: int, concurrency: int) -> None:
"""指数成分成交汇总:每分钟成交量 / 笔数(笔数=成分股逐笔累加)。"""
total = 0
def on_progress(done: int, all_: int) -> None:
nonlocal total
total = all_
print("\r 拉取成分逐笔 %d/%d ..." % (done, all_), end="", file=sys.stderr,
flush=True)
st = await td.get_index_trade_stats(
index, date, concurrency=concurrency, on_progress=on_progress)
if total:
print("\r" + " " * 40 + "\r", end="", file=sys.stderr, flush=True)
print("%s 成分成交汇总" % st.index)
print(" 成分 %d 只 / 有成交 %d 只 / 有笔数 %d 只%s" % (
st.member_count, st.active_members, st.trade_count_members,
"" if st.trade_count_available else " ★该指数无笔数口径"))
print(" 成交量 %s 手 成交笔数 %s 笔 成交额 %.2f 亿 耗时 %.1fs" % (
_fmt_num(st.total_volume),
_fmt_num(st.total_trade_count) if st.trade_count_available else "-",
st.total_amount / 1e8, st.elapsed))
if st.failed_members:
print(" (%d 只成分逐笔拉取失败,已跳过)" % st.failed_members)
print()
print(" 时间 累计成交量 累计笔数")
rows = st.cumulative()
if not show_all:
rows = rows[-top:]
for m in rows:
print(" %-6s %12s %12s" % (
m.time, _fmt_num(m.volume),
_fmt_num(m.trade_count) if st.trade_count_available else "-"))
async def cmd_info(td: TdxData, sym: str) -> None: async def cmd_info(td: TdxData, sym: str) -> None:
s = parse_symbol(sym) s = parse_symbol(sym)
info = await td.get_symbol_info(Market(s.market), s.code) info = await td.get_symbol_info(Market(s.market), s.code)
@@ -390,6 +478,17 @@ def main() -> None:
ix.set_defaults(func=lambda td, a: cmd_kline( ix.set_defaults(func=lambda td, a: cmd_kline(
td, a.code, KlinePeriod.DAY, a.count, 0, Adjust.NONE)) td, a.code, KlinePeriod.DAY, a.count, 0, Adjust.NONE))
ist = add("index-stats", "指数成分成交汇总(每分钟成交量/笔数)")
ist.add_argument("index", help="指数代码,如 000300 / 000001 / sh000016")
ist.add_argument("--date", type=str, default=None, help="YYYYMMDD,缺省=当日")
ist.add_argument("--top", type=int, default=10, help="只显示最后 N 分钟(默认10)")
ist.add_argument("--all", dest="show_all", action="store_true",
help="显示全部分钟")
ist.add_argument("--concurrency", type=int, default=24, help="逐笔并发数")
ist.set_defaults(func=lambda td, a: cmd_index_stats(
td, a.index, int(a.date) if a.date else None,
a.show_all, a.top, a.concurrency))
b = add("board", "板块") b = add("board", "板块")
b.add_argument("action", choices=["list", "members", "ranking", "change"]) b.add_argument("action", choices=["list", "members", "ranking", "change"])
b.add_argument("symbol", nargs="?", default="") b.add_argument("symbol", nargs="?", default="")
+13
View File
@@ -33,6 +33,7 @@ _SERVERS_FILE = Path(__file__).resolve().parent / "servers.json" # 包内清单
# 当日测速缓存(结构变更时递增,旧版本缓存自动失效) # 当日测速缓存(结构变更时递增,旧版本缓存自动失效)
PROBE_CACHE_VERSION = 1 PROBE_CACHE_VERSION = 1
_PROBE_CACHE_NAME = "hosts-today.json" _PROBE_CACHE_NAME = "hosts-today.json"
_DECIMAL_CACHE_NAME = "decimal-points.json"
# ---------- 包内清单(只读基线) ---------- # ---------- 包内清单(只读基线) ----------
@@ -97,6 +98,18 @@ def probe_cache_file() -> Path:
return probe_cache_dir() / _PROBE_CACHE_NAME return probe_cache_dir() / _PROBE_CACHE_NAME
def decimal_cache_file() -> Path:
"""权威价格小数位表缓存路径(每次调用重新解析,便于测试改环境变量后生效)。"""
return probe_cache_dir() / _DECIMAL_CACHE_NAME
def decimal_sync_disabled() -> bool:
"""是否已通过 ``PYPYTDX_DATA_DISABLE_DECIMAL_SYNC`` 关闭小数位后台同步。"""
return os.environ.get("PYPYTDX_DATA_DISABLE_DECIMAL_SYNC", "").strip().lower() in {
"1", "true", "yes", "on",
}
def probe_disabled() -> bool: def probe_disabled() -> bool:
"""是否已通过 ``PYPYTDX_DATA_DISABLE_PROBE`` 关闭当日测速缓存。""" """是否已通过 ``PYPYTDX_DATA_DISABLE_PROBE`` 关闭当日测速缓存。"""
return os.environ.get("PYPYTDX_DATA_DISABLE_PROBE", "").strip().lower() in { return os.environ.get("PYPYTDX_DATA_DISABLE_PROBE", "").strip().lower() in {
+223
View File
@@ -0,0 +1,223 @@
"""权威价格小数位表的同步与缓存(对用户无感)。
为什么需要它
------------
``get_quotes`` 解析报价时,协议给的是**整数**,真实价格 = ``整数 / 10**小数位``。
小数位在协议里**不是**随报价一起下发的,只能靠推断(见
:func:`pytdxdata.protocol.commands.quotes.price_decimal_digits`)。
但证券清单接口(``get_universe``,底层 ``GetSecurityListCmd``)**自带**这个字段:
``SecurityInfo.decimal_point``,同时还带 ``pre_close``。这就是权威来源。本模块把它
灌进 ``price_decimal_digits`` 使用的运行时表,使价格标度不再依赖硬编码前缀规则。
行为
----
- **当日首次启动**检查缓存文件(``decimal-points.json``):命中就直接装表(纯内存,
无网络、约 10 ms);未命中则挂一个**后台 task** 拉证券清单并写缓存,
当天不再重复。
- 后台 task 不阻塞 ``start()``,不打印、不抛异常(取消除外),失败只落 debug 日志。
- 未同步成功时 ``price_decimal_digits`` 静默退回静态前缀规则,行为与 0.6.5 一致。
- 证券清单本身已被 ``cache/`` 层缓存,因此同步的实际网络开销只在**首次**
(约 26 + 25 个分页请求)。
开关
----
- ``PYPYTDX_DATA_DISABLE_DECIMAL_SYNC=1`` 关闭后台同步(CI / 测试用,保证确定性)。
- ``PYPYTDX_DATA_CACHE_DIR`` 覆盖缓存目录(测试指向临时目录)。
"""
from __future__ import annotations
import asyncio
import json
import logging
import os
from datetime import date
from pathlib import Path
from typing import TYPE_CHECKING, Any
from .config import decimal_cache_file, decimal_sync_disabled
from .protocol.commands.quotes import (
clear_decimal_map,
decimal_map_source,
decimal_map_stats,
install_decimal_map,
)
if TYPE_CHECKING: # pragma: no cover
from .api import TdxData
log = logging.getLogger(__name__)
#: 同步哪些市场(只对 A 股有意义:扩展市场报价本身不含标度歧义)
DEFAULT_MARKETS: tuple[str, ...] = ("sh", "sz")
_CN_NAME = {"sh": 1, "sz": 0}
_state: dict[str, Any] = {"loaded": "", "task": None}
# ---------------------------------------------------------------------- #
# 磁盘缓存
# ---------------------------------------------------------------------- #
def cache_file() -> Path:
"""缓存文件路径(每次重新解析,便于测试改环境变量)。"""
return decimal_cache_file()
def _read_cache(path: Path | None = None) -> dict[str, dict[str, int]] | None:
"""读缓存 → ``{"1": {code: dp}}``;缺失 / 损坏 → ``None``。"""
target = Path(path) if path is not None else cache_file()
try:
raw = json.loads(target.read_text(encoding="utf-8"))
except (OSError, ValueError):
return None
if not isinstance(raw, dict):
return None
if raw.get("date") != date.today().isoformat():
return None
markets = raw.get("markets")
if not isinstance(markets, dict) or not markets:
return None
out: dict[str, dict[str, int]] = {}
for k, v in markets.items():
if not isinstance(v, dict):
continue
try:
out[str(int(k))] = {str(c): int(d) for c, d in v.items() if int(d) > 0}
except (TypeError, ValueError):
continue
return out or None
def load_cached(path: Path | None = None) -> int:
"""把当日缓存装进权威表;成功返回覆盖条目数,否则 0。"""
if decimal_sync_disabled():
return 0
markets = _read_cache(path)
if not markets:
return 0
items = [(int(m), c, d) for m, codes in markets.items() for c, d in codes.items()]
stats = install_decimal_map(items, source="cache")
_state["loaded"] = date.today().isoformat()
log.debug("小数位表已从缓存加载: %s", stats)
return int(stats["stock"])
def _write_cache(markets: dict[str, dict[str, int]], path: Path | None = None) -> None:
"""原子写缓存(tmp + ``os.replace``),失败只落 debug 日志。"""
target = Path(path) if path is not None else cache_file()
payload = {"date": date.today().isoformat(), "markets": markets}
tmp = target.with_suffix(".tmp")
try:
target.parent.mkdir(parents=True, exist_ok=True)
tmp.write_text(
json.dumps(payload, ensure_ascii=False, separators=(",", ":")),
encoding="utf-8",
)
os.replace(tmp, target)
except OSError as e: # pragma: no cover - 磁盘不可写等
log.debug("小数位表缓存写入失败: %s", e)
try:
tmp.unlink(missing_ok=True)
except OSError:
pass
# ---------------------------------------------------------------------- #
# 同步
# ---------------------------------------------------------------------- #
async def refresh(td: "TdxData", markets: tuple[str, ...] = DEFAULT_MARKETS,
*, path: Path | None = None) -> dict[str, int]:
"""拉证券清单 → 装表 + 写缓存。返回统计。
证券清单走 ``get_universe``(含 ``cache/`` 层缓存),只有首次真正发请求。
"""
tables: dict[str, dict[str, int]] = {}
items: list[tuple[int, str, int]] = []
for name in markets:
m = _CN_NAME.get(name)
if m is None:
continue
rows = await td.get_universe(name)
table: dict[str, int] = {}
for it in rows:
dp = int(getattr(it, "decimal_point", 0) or 0)
code = str(getattr(it, "code", "") or "").strip().rstrip("\x00")
if dp <= 0 or not code:
continue
table[code] = dp
items.append((m, code, dp))
if table:
tables[str(m)] = table
stats = install_decimal_map(items, source="universe")
_state["loaded"] = date.today().isoformat()
if tables:
_write_cache(tables, path)
log.debug("小数位表同步完成: %s", stats)
return stats
async def _run(td: "TdxData") -> dict[str, int]:
try:
return await refresh(td)
except asyncio.CancelledError:
raise
except Exception as e: # pragma: no cover - 网络/解析异常都不该影响用户
log.debug("小数位表后台同步失败: %s", e)
return {}
def schedule(td: "TdxData") -> asyncio.Task | None:
"""[内部] 需要时把同步挂到后台并返回 Task(调用方持有 / 取消)。
- 已关闭(``PYPYTDX_DATA_DISABLE_DECIMAL_SYNC=1``)→ ``None``
- 当日缓存命中 → 立即装表(同步、无网络),返回 ``None``
- 否则创建后台 task;进程内单例,重复调用复用同一个 task
"""
if decimal_sync_disabled():
return None
if decimal_map_stats()["stock"] and _state["loaded"] == date.today().isoformat():
return None
if load_cached():
return None
task = _state.get("task")
if task is not None and not task.done():
return task
task = asyncio.get_running_loop().create_task(_run(td), name="pytdxdata-decimal-sync")
_state["task"] = task
return task
async def cancel(task: asyncio.Task | None) -> None:
"""取消并等待后台同步 task(供 ``TdxData.close()`` 调用)。"""
if task is None or task.done():
return
task.cancel()
try:
await task
except (asyncio.CancelledError, Exception): # noqa: BLE001 - 关闭路径不抛
pass
def status() -> dict[str, Any]:
"""当前状态快照(排障 / 测试用)。"""
task = _state.get("task")
return {
"loaded": _state["loaded"],
"source": decimal_map_source(),
"syncing": bool(task is not None and not task.done()),
**decimal_map_stats(),
}
def reset() -> None:
"""清空内存状态(测试用;不动磁盘缓存)。"""
task = _state.get("task")
if task is not None and not task.done():
task.cancel()
_state["task"] = None
_state["loaded"] = ""
clear_decimal_map()
+228 -10
View File
@@ -3,7 +3,7 @@ from __future__ import annotations
import struct import struct
from dataclasses import dataclass, field from dataclasses import dataclass, field
from datetime import datetime from datetime import date, datetime, timedelta
from enum import IntEnum from enum import IntEnum
from typing import Any from typing import Any
@@ -92,17 +92,33 @@ class Adjust(IntEnum):
HFQ = 2 # 后复权 HFQ = 2 # 后复权
# 扩展市场中「时间戳跨时区拼接」的市场号:通达信 EX 通道对美股返回的分钟级 K线
# 里,日期字段是**美东交易日**、时分字段是**北京时间**,两个时区被拼进同一个
# 五元组,必须归一化(见 SecurityBar.__post_init__)。
_US_EX_MARKETS: frozenset[int] = frozenset({int(ExMarket.US_STOCK)})
# 归一化判据:北京时间 hour >= 12 的 bar 与美东交易日属同一自然日。美股常规时段
# 09:30~16:00 EDT = 北京 21:30~次日 04:00(冬令时 22:30~次日 05:00),夏令时/
# 冬令时下分界都稳定落在 12 点。
_US_DAY_SPLIT_HOUR = 12
@dataclass(slots=True) @dataclass(slots=True)
class SecurityBar: class SecurityBar:
"""K线记录(价格单位:元)。跨市场统一模型(A股/港股/美股/期货共用)。""" """K线记录(价格单位:元)。跨市场统一模型(A股/港股/美股/期货共用)。
时间戳口径**统一为北京时间**:A股/港股/期货原始即为北京时间;美股原始是
「日期=美东交易日 + 时分=北京时间」的混合值,构造时已还原为真实北京时间
(见 ``__post_init__``)。该 bar 归属的交易日见 :attr:`trading_date`。
"""
market: int market: int
code: str code: str
open: float open: float
high: float high: float
low: float low: float
close: float close: float
vol: float # 股票=股 / 转债=手(与vipdoc一致) vol: float # 股票=股 / 转债=手(1 手=10 张,与 vipdoc 一致)
amount: float # 元 amount: float # 元。⚠️ amount/vol 只在股票上等于均价;转债还要再 /10(手=10张)
year: int year: int
month: int month: int
day: int day: int
@@ -110,10 +126,40 @@ class SecurityBar:
minute: int = 0 minute: int = 0
symbol: str = "" # 规范化标的串(sz000001 / hk00700),由 API 层填充 symbol: str = "" # 规范化标的串(sz000001 / hk00700),由 API 层填充
def __post_init__(self) -> None:
"""美股(EX 通道)时间戳归一化:还原成真实北京时间。
原始报文里 ``zipday`` 是**美东交易日**、``tminutes`` 是**北京时间分钟数**,
直拼出的 ``datetime`` 会把同一交易日的下午半场(北京 00:00~04:00)排到
上午半场(北京 21:30~23:59)**之前** —— 单日 390 根全部错位、首末颠倒。
这里把凌晨段(北京 hour < 12)的日期 +1 天,得到严格单调的北京时间序列。
"""
if self.market in _US_EX_MARKETS and self.hour < _US_DAY_SPLIT_HOUR:
d = date(self.year, self.month, self.day) + timedelta(days=1)
self.year, self.month, self.day = d.year, d.month, d.day
@property
def is_us(self) -> bool:
"""是否美股(EX 通道 ``US_STOCK``)。"""
return self.market in _US_EX_MARKETS
@property @property
def datetime(self) -> datetime: def datetime(self) -> datetime:
"""bar 的时刻(北京时间)。"""
return datetime(self.year, self.month, self.day, self.hour, self.minute) return datetime(self.year, self.month, self.day, self.hour, self.minute)
@property
def trading_date(self) -> str:
"""该 bar 归属的交易日,``YYYY-MM-DD``。
美股:``datetime`` 已还原为北京时间,凌晨段(北京 hour < 12)属于**前一天**
的美东交易日,故回退一天;A股/港股/期货的交易日即自然日。按交易日聚合
(如分钟线合成日线)时应当用本字段,而不是 ``datetime.date()``。
"""
if self.is_us and self.hour < _US_DAY_SPLIT_HOUR:
return (date(self.year, self.month, self.day) - timedelta(days=1)).isoformat()
return f"{self.year:04d}-{self.month:02d}-{self.day:02d}"
@dataclass(slots=True) @dataclass(slots=True)
class IndexBar(SecurityBar): class IndexBar(SecurityBar):
@@ -182,23 +228,72 @@ class SecurityInfo:
@dataclass(slots=True) @dataclass(slots=True)
class TransactionRecord: 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=买)。
**场内基金同样没有笔数**(ETF / 多数 LOF,见
:func:`~pytdxdata.symbols.has_order_count`):
- ``trade_count`` 是 ``价格 × 1000``(实测 ``sh510310`` 收盘 tc=3994,
当时价 3.989 → 3989,偏差 σ≈2;货币 ETF ``sh511990`` 恒为 0)。
- ``vol`` 仍是**手**,``bs_flag`` 正常。
- 这类标的的 :attr:`trade_count_available` 为 ``False``,``trade_count`` 已被
置 ``0``,不要拿去求和/求均值。
``trade_count_available=False`` 表示该品种**协议上就不带笔数**,
与「本切片恰好 0 笔」不是一回事。
**可转债(110/111/113/118/123/127/128/132)三样都是真的**(实测 2026-10-22,
16 只 A股可转债当日 + 8 只历史日全部自洽):
- ``vol`` 单位是**手**(1 手 = 10 张),与股票逐笔一致;``trade_count`` 是**真实成交笔数**
(``sh111000`` 3631 条切片 / 20443 笔,可转债在
:func:`~pytdxdata.symbols.has_order_count` 里判为**可用**)。
- ``Σvol`` 与**日线** ``SecurityBar.vol`` **1:1 相等**(比值 1.000000)——
这点和股票相反:股票逐笔是「手」、日线是「股」,Σ比值是 **0.01**。
- ⚠️ 但**日线** ``amount / vol`` **不等于**均价,而是均价的 **10 倍**(``vol`` 的「手」= 10 张)。
要算可转债均价须用 ``amount / vol / 10``;股票则是 ``amount / vol`` 直接就对。
实测:``sz127025`` 逐笔 VWAP 105.9063 vs ``amount/vol`` 1059.0957,比值 10.0003。
"""
market: int market: int
code: str code: str
time: str # HH:MM:SS(扩展市场为 HH:MM) time: str # HH:MM:SS(扩展市场为 HH:MM)
price: float price: float
vol: float # 手(MAC逐笔) vol: float # 股票/转债=手;指数=百元(成交额/100),见类注释
trade_count: int # 成交笔数(MAC=逐笔记录字段;标准当日逐笔协议也有但需单独解析) trade_count: int # 股票=笔数增量;指数/基金=占位值,见类注释
bs_flag: int # 1=主动买 0=主动卖 bs_flag: int # 1=主动买 0=主动卖 2=中性 5=盘后固定价(指数语义不成立)
symbol: str = "" symbol: str = ""
fields: dict[str, float] = field(default_factory=dict) # 扩展市场额外字段(增仓等) fields: dict[str, float] = field(default_factory=dict) # 扩展市场额外字段(增仓等)
trade_count_available: bool = True # 指数/ETF/LOF 为 False(协议无笔数字段)
@dataclass(slots=True) @dataclass(slots=True)
class MinuteBar: class MinuteBar:
"""分时(跨市场统一模型;A股 MAC 0x122D / 扩展市场 0x122D 同构)""" """分时(跨市场统一模型;A股 MAC 0x122D / 扩展市场 0x122D 同构)。
``hour``/``minute`` 是**真实时钟**(``0 <= hour < 24``),跨日的分时请用
:attr:`datetime` / :attr:`trading_date`,不要自己拿 ``hour`` 拼日期。
"""
price: float price: float
vol: float vol: float # 手(股票/转债同);Σ分时vol 与当日日线 vol 同口径
avg_price: float = 0.0 # 均价(协议第2字段) avg_price: float = 0.0 # 均价(协议第2字段)
hour: int = 0 hour: int = 0
minute: int = 0 minute: int = 0
@@ -207,6 +302,50 @@ class MinuteBar:
code: str = "" code: str = ""
date: int = 0 # YYYYMMDD date: int = 0 # YYYYMMDD
fields: dict[str, float] = field(default_factory=dict) # 扩展市场额外字段(动量等) fields: dict[str, float] = field(default_factory=dict) # 扩展市场额外字段(动量等)
day_offset: int = 0 # 相对 date 的自然日偏移:美股凌晨段为 +1
def __post_init__(self) -> None:
"""美股(EX 通道)分时时间归一化。
EX 分时的 ``minutes`` 字段是**自开盘起的连续分钟数**,不是「当天的分钟数」:
实测 ``usAAPL`` 返回 ``21:30`` ~ ``27:59``(390 条里 240 条的 ``hour`` ≥ 24)。
``27:59`` 实际是次日 ``03:59`` 北京时间。直接 ``minutes // 60`` 会得到
``hour=27`` 这种**非法时钟值**,任何 ``datetime(...)`` 拼接都会抛异常,
按小时聚合也会把凌晨段错误地归到同一天。
这里拆成「真实小时 + 日偏移」:``hour = (minutes // 60) % 24``,
``day_offset = (minutes // 60) // 24``。A股/港股/期货的 ``hour`` 本就合法
(A股合成时间 09:30~15:00、港股 09:30~16:00),**零行为变化**。
"""
if self.hour >= 24:
self.day_offset += self.hour // 24
self.hour %= 24
@property
def datetime(self) -> datetime:
"""该分时点的时刻(北京时间,已含跨日偏移)。"""
base = date(self.date // 10000, self.date // 100 % 100, self.date % 100)
d = base + timedelta(days=self.day_offset)
return datetime(d.year, d.month, d.day, self.hour, self.minute)
@property
def is_us(self) -> bool:
"""是否美股(EX 通道 ``US_STOCK``)。"""
return self.market in _US_EX_MARKETS
@property
def trading_date(self) -> str:
"""该分时点归属的交易日,``YYYY-MM-DD``。
美股:一个交易日横跨两个北京自然日(21:30~次日 04:00),凌晨段
(北京 hour < 12)归属**前一天**的美东交易日,与
:attr:`SecurityBar.trading_date` 口径一致。A股/港股/期货即 ``date`` 本身。
按交易日聚合分时(合成日线、日内统计)**必须用它**。
"""
base = self.datetime
if self.is_us and base.hour < _US_DAY_SPLIT_HOUR:
base -= timedelta(days=1)
return base.date().isoformat()
@dataclass(slots=True) @dataclass(slots=True)
@@ -448,3 +587,82 @@ class FinancialRecord:
market: int # 0=深 1=沪 market: int # 0=深 1=沪
report_date: int # 报告期 YYYYMMDD report_date: int # 报告期 YYYYMMDD
fields: list[float] = field(default_factory=list) fields: list[float] = field(default_factory=list)
# ===== 指数成分成交汇总(TdxData.get_index_trade_stats) =====
@dataclass(slots=True)
class MinuteTradeStat:
"""指数**全部成分股**汇总后的单分钟成交**增量**(不是累计)。
累计曲线用 :meth:`IndexTradeStats.cumulative`,不要自己再对同一字段反复累加。
"""
time: str # HH:MM
volume: float # 成交量合计(手,1 手 = 100 股)
trade_count: int # 成交笔数合计
amount: float # 成交额估算(元)= Σ(逐笔价 × 手 × 100)
@dataclass(slots=True)
class IndexTradeStats:
"""某个指数「全部成分股逐笔」汇总出的成交曲线。
为什么需要它:**通达信协议里指数本身没有成交笔数** —— 指数逐笔
(``sh000001``)的 ``trade_count`` 字段实际是「当时均价 × 1000」(见
:class:`TransactionRecord`)。所以「指数笔数」唯一可行的口径是
**把成分股的逐笔笔数累加**,本类即该口径。
口径校验(2026-10-22 实测):
- ``total_amount`` 是**成分股**合计。对「成分恰好就是指数覆盖面」的指数,它与
指数快照 ``amount`` **完全相等**:``sh000016`` 661.34 亿 = 661.34 亿、
``sh000300`` 2373.98 亿 = 2373.98 亿(比值 1.0000)。
- **但深市 ``399xxx`` 的指数成交额字段是「全板块」口径**,不是样本股:
实测 ``sz399001`` 快照 5081.40 亿 = 深市 2908 只股票合计 5081.01 亿、
``sz399006`` 2568.60 亿 = 创业板全部股票合计。所以拿深市指数 ``amount``
与 ``total_amount`` 比会得到 ~0.43 这类无意义比值——不是数据错,是口径不同。
- ``total_volume`` 单位是**手**(与指数逐笔的「百元」单位不同,勿混用)。
- 北交所成分(``bj`` 前缀)**没有笔数字段**(实测 ``trade_count`` 恒为 0):
此时 ``trade_count_members = 0``、:attr:`trade_count_available` 为 ``False``,
只有成交量可用。``sh``/``sz`` 成分均正常返回笔数。
``minutes`` 只包含**实际有成交**的分钟(午休 11:30~13:00 之间无桶),
画累计曲线时请按 ``time`` 自行补齐或直接连线。
"""
index: str # 规范化指数标的(如 sh000300)
date: int | None # None=当日;否则 YYYYMMDD
member_count: int # 指数成分数
active_members: int # 实际有逐笔成交的成分数(停牌/无成交不计)
trade_count_members: int # 返回了笔数的成分数(北交所为 0)
minutes: list[MinuteTradeStat] = field(default_factory=list)
total_volume: float = 0.0
total_trade_count: int = 0
total_amount: float = 0.0
failed_members: int = 0 # 逐笔拉取失败的成分数(skip_errors=True 时)
elapsed: float = 0.0 # 本次汇总耗时(秒)
@property
def trade_count_available(self) -> bool:
"""是否有笔数口径(北交所成分为 ``False``,此时 ``trade_count`` 全 0)。"""
return self.trade_count_members > 0
def cumulative(self) -> list[MinuteTradeStat]:
"""累计曲线:当日**截止该分钟**的累计量,时间升序。
这是「当日截止该分钟累计成交笔数」的直接数据源。
"""
out: list[MinuteTradeStat] = []
vol = 0.0
tc = 0
amt = 0.0
for m in self.minutes:
vol += m.volume
tc += m.trade_count
amt += m.amount
out.append(MinuteTradeStat(time=m.time, volume=vol,
trade_count=tc, amount=amt))
return out
def cum_trade_count(self) -> list[tuple[str, int]]:
"""``[(HH:MM, 累计笔数)]``,画「截止该分钟累计笔数」曲线用。"""
return [(m.time, m.trade_count) for m in self.cumulative()]
+54
View File
@@ -3,6 +3,7 @@ from __future__ import annotations
import asyncio import asyncio
import time import time
from collections.abc import Sequence
from typing import Generic, TypeVar from typing import Generic, TypeVar
from ..protocol.commands.base import BaseCommand from ..protocol.commands.base import BaseCommand
@@ -22,6 +23,7 @@ class TdxConnection(Generic[T]):
self._reader: asyncio.StreamReader | None = None self._reader: asyncio.StreamReader | None = None
self._writer: asyncio.StreamWriter | None = None self._writer: asyncio.StreamWriter | None = None
self._last_result: T | None = None self._last_result: T | None = None
self._pipeline_result: list[T] = []
@property @property
def alive(self) -> bool: def alive(self) -> bool:
@@ -107,6 +109,58 @@ class TdxConnection(Generic[T]):
body = decompress_body(header, raw_body) body = decompress_body(header, raw_body)
self._last_result: T = cmd.parse_response(body) self._last_result: T = cmd.parse_response(body)
async def execute_pipeline(
self, cmds: Sequence[BaseCommand[T]], *, timeout: float | None = None
) -> list[T]:
"""单连接**流水线**:一次性发出全部请求,再按序读取全部响应。
通达信协议是自描述长度帧(16 字节帧头 + body),且服务器**按序**应答,
因此可以在同一 TCP 连接上连续下发多条请求、省掉 ``(N-1)`` 次往返。
实测 66 个「80 只报价」请求:逐条 7,372ms → 流水线 526ms(14 倍)。
与 :meth:`execute` 的关键差异:``execute`` 逐条严格配对,失败可小范围重试;
流水线一旦中途失败,**响应流已错配**,剩余响应无法再与请求对齐,
故此处强制断开连接(上层应换连接重试)。
参数:
cmds: 同一连接的请求序列(通常为同一类命令的不同分片)。
timeout: 整体超时(默认 ``self.timeout * 2``,流水线耗时随条数增长)。
返回:
与 ``cmds`` **等长且同序**的结果列表。
"""
if not cmds:
return []
if not self.alive:
raise ConnectionError(f"连接未建立或已关闭: {self.host}")
assert self._reader is not None and self._writer is not None
budget = timeout if timeout is not None else self.timeout * 2
try:
try:
await asyncio.wait_for(self._io_pipeline(cmds), budget)
except asyncio.TimeoutError:
self._force_close()
raise ConnectionError(
f"流水线超时 {self.host} ({budget:.1f}s, {len(cmds)} 条)") from None
except (ConnectionError, OSError) as e:
self._force_close()
raise ConnectionError(f"流水线错误 {self.host}: {e}") from e
except (ConnectionError, OSError):
raise
return self._pipeline_result
async def _io_pipeline(self, cmds: Sequence[BaseCommand[T]]) -> None:
assert self._reader is not None and self._writer is not None
self._writer.write(b"".join(c.build_request() for c in cmds))
await self._writer.drain()
results: list[T] = []
for cmd in cmds:
header_buf = await self._recv_exact(HEADER_SIZE)
header = parse_header(header_buf)
raw_body = await self._recv_exact(header.zipsize)
results.append(cmd.parse_response(decompress_body(header, raw_body)))
self._pipeline_result: list[T] = results
async def _send_setup(self) -> None: async def _send_setup(self) -> None:
"""按序发送3条握手命令并丢弃响应。""" """按序发送3条握手命令并丢弃响应。"""
assert self._reader is not None and self._writer is not None assert self._reader is not None and self._writer is not None
+81 -32
View File
@@ -1,4 +1,11 @@
"""EX扩展市场连接池(简化版:固定连接数,借还+坏连接重建+login自动)""" """EX扩展市场连接池(固定连接数,借还+坏连接重建+login自动)。
与标准池 pool.py 的背压语义对齐:acquire 在无空闲连接且无法扩容时,
基于 asyncio.Condition 排队等待 release 唤醒(默认 acquire_timeout=30s),
而不是快速失败。per_server_cap 限制单台服务器连接数;单服务器场景下
有效并发 = servers × per_server_cap(默认 1),通过 TdxData(ex_pool_cap=N)
可对同一 EX 主机开多连接。
"""
from __future__ import annotations from __future__ import annotations
import asyncio import asyncio
@@ -9,6 +16,23 @@ from .ex_connection import ExTdxConnection
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
DEFAULT_ACQUIRE_TIMEOUT = 30.0
class ExPoolTimeoutError(ConnectionError):
"""acquire 等待超时(携带池状态快照,便于排障)。"""
def __init__(self, pool: "ExPool", timeout: float) -> None:
idle = len(pool._idle)
total = pool._total
servers = len(pool.servers)
cap = pool.per_server_cap
super().__init__(
f"EX连接池获取超时(等了 {timeout:.1f}s):"
f"idle={idle} total={total} servers={servers} per_server_cap={cap} "
f"有效并发={servers * cap}"
)
class ExPool: class ExPool:
"""EX通道连接池(港股/期货,端口7727,连接时自动login)。""" """EX通道连接池(港股/期货,端口7727,连接时自动login)。"""
@@ -16,6 +40,7 @@ class ExPool:
def __init__(self, servers: list[str], *, timeout: float = 10.0, def __init__(self, servers: list[str], *, timeout: float = 10.0,
min_size: int = 2, max_size: int = 6, min_size: int = 2, max_size: int = 6,
per_server_cap: int = 1, per_server_cap: int = 1,
acquire_timeout: float | None = None,
handshake: str = "login", handshake: str = "login",
handshake_map: dict | None = None) -> None: handshake_map: dict | None = None) -> None:
self.servers = servers self.servers = servers
@@ -25,14 +50,17 @@ class ExPool:
self.min_size = min_size self.min_size = min_size
self.max_size = max_size self.max_size = max_size
self.per_server_cap = max(1, per_server_cap) # 一台服务器最多几个连接(默认1=单连接) self.per_server_cap = max(1, per_server_cap) # 一台服务器最多几个连接(默认1=单连接)
self.acquire_timeout = (
DEFAULT_ACQUIRE_TIMEOUT if acquire_timeout is None else acquire_timeout
)
self._idle: list[tuple[str, ExTdxConnection]] = [] self._idle: list[tuple[str, ExTdxConnection]] = []
self._server_count: dict[str, int] = {} self._server_count: dict[str, int] = {}
self._total = 0 self._total = 0
self._closed = False self._closed = False
self._lock = asyncio.Lock() self._cond = asyncio.Condition()
async def start(self) -> None: async def start(self) -> None:
async with self._lock: async with self._cond:
for host in self.servers[: self.min_size]: for host in self.servers[: self.min_size]:
if self._server_count.get(host, 0) >= self.per_server_cap: if self._server_count.get(host, 0) >= self.per_server_cap:
continue continue
@@ -47,7 +75,7 @@ class ExPool:
async def close(self) -> None: async def close(self) -> None:
self._closed = True self._closed = True
async with self._lock: async with self._cond:
for _, conn in self._idle: for _, conn in self._idle:
try: try:
await conn.close() await conn.close()
@@ -56,48 +84,61 @@ class ExPool:
self._idle.clear() self._idle.clear()
self._total = 0 self._total = 0
self._server_count.clear() self._server_count.clear()
self._cond.notify_all()
async def acquire(self) -> ExTdxConnection: async def acquire(self, timeout: float | None = None) -> ExTdxConnection:
for _ in range(3): """借出一条连接;无空闲且无法扩容时排队等待 release 唤醒。
stale_conn = None
new_conn = None timeout 默认取 self.acquire_timeout(30s);传 None 表示无限等待。
new_host = None """
async with self._lock: if timeout is None:
timeout = self.acquire_timeout
deadline = None if timeout is None else time.monotonic() + timeout
async with self._cond:
while True:
# 1. 优先借用空闲连接(过期则丢弃,槽位在锁内回收)
if self._idle: if self._idle:
_, conn = self._idle.pop() _, conn = self._idle.pop()
fresh = time.monotonic() - conn.last_used < 30.0 fresh = time.monotonic() - conn.last_used < 30.0
if conn.alive and fresh: if conn.alive and fresh:
return conn return conn
# 连接空闲过久(login会话可能失效)→ 丢弃重连 # 连接空闲过久(login会话可能失效)→ 丢弃,槽位让给扩容
self._total = max(0, self._total - 1) self._total = max(0, self._total - 1)
self._server_count[conn.host] = max(0, self._server_count.get(conn.host, 0) - 1) self._server_count[conn.host] = max(0, self._server_count.get(conn.host, 0) - 1)
stale_conn = conn self._schedule_close(conn)
# 扩容:在锁内预留槽位,锁外执行网络IO
elif self._total < self.max_size and self.servers: # 2. 可扩容 → 锁内预留槽位,锁外建连
new_conn = None
new_host = None
if self._total < self.max_size and self.servers:
host = self._next_available_server() host = self._next_available_server()
if host: if host is not None:
self._total += 1 self._total += 1
self._server_count[host] = self._server_count.get(host, 0) + 1 self._server_count[host] = self._server_count.get(host, 0) + 1
new_conn = ExTdxConnection(host, 7727, self.timeout, self.handshake_map.get(host, self.handshake)) new_conn = ExTdxConnection(host, 7727, self.timeout, self.handshake_map.get(host, self.handshake))
new_host = host new_host = host
# 锁外:关闭过期连接、建立新连接
if stale_conn is not None:
try:
await stale_conn.close()
except Exception:
pass
if new_conn is not None: if new_conn is not None:
# 锁外网络 IO:连接失败回滚槽位后继续等待
try: try:
await new_conn.connect() await new_conn.connect()
return new_conn return new_conn
except Exception as e: except Exception as e:
log.warning("EX扩容失败 %s: %s", new_host, str(e)[:60]) log.warning("EX扩容失败 %s: %s", new_host, str(e)[:60])
# 连接失败,回滚预留槽位 async with self._cond:
async with self._lock:
self._total = max(0, self._total - 1) self._total = max(0, self._total - 1)
self._server_count[new_host] = max(0, self._server_count.get(new_host, 0) - 1) self._server_count[new_host] = max(0, self._server_count.get(new_host, 0) - 1)
await asyncio.sleep(0.05)
raise ConnectionError("EX连接池无可用连接") # 3. 池满:排队等待 release 唤醒(或超时)
now = time.monotonic()
if deadline is not None and now >= deadline:
raise ExPoolTimeoutError(self, timeout)
try:
if deadline is None:
await self._cond.wait()
else:
await asyncio.wait_for(self._cond.wait(), timeout=deadline - now)
except asyncio.TimeoutError:
raise ExPoolTimeoutError(self, timeout)
def _next_available_server(self) -> str | None: def _next_available_server(self) -> str | None:
for h in self.servers: for h in self.servers:
@@ -105,15 +146,23 @@ class ExPool:
return h return h
return None return None
async def release(self, conn: ExTdxConnection, *, broken: bool = False) -> None: def _schedule_close(self, conn: ExTdxConnection) -> None:
if broken or not conn.alive: async def _close():
async with self._lock:
self._total = max(0, self._total - 1)
self._server_count[conn.host] = max(0, self._server_count.get(conn.host, 0) - 1)
try: try:
await conn.close() await conn.close()
except Exception: except Exception:
pass pass
return try:
async with self._lock: asyncio.get_running_loop().create_task(_close())
except RuntimeError:
pass
async def release(self, conn: ExTdxConnection, *, broken: bool = False) -> None:
async with self._cond:
if broken or not conn.alive:
self._total = max(0, self._total - 1)
self._server_count[conn.host] = max(0, self._server_count.get(conn.host, 0) - 1)
self._schedule_close(conn)
else:
self._idle.append((conn.host, conn)) self._idle.append((conn.host, conn))
self._cond.notify_all()
+45
View File
@@ -59,6 +59,11 @@ class PooledConnection:
self.last_used = time.monotonic() self.last_used = time.monotonic()
return await self.conn.execute(cmd) return await self.conn.execute(cmd)
async def execute_pipeline(self, cmds, *, timeout: float | None = None):
"""在同一条连接上流水线执行多条命令(见 TdxConnection.execute_pipeline)。"""
self.last_used = time.monotonic()
return await self.conn.execute_pipeline(cmds, timeout=timeout)
async def close(self) -> None: async def close(self) -> None:
self.alive = False self.alive = False
try: try:
@@ -273,6 +278,46 @@ class DynamicPool:
] ]
return random.choice(alive) if alive else None return random.choice(alive) if alive else None
async def warm(self, n: int) -> None:
"""并发预建连接至 ``n`` 条(最多到 ``max_size``)。
:meth:`acquire` 建连时持有池锁,**一次只能建一条**——22 路并发首次
调用会排队 22×握手时间(实测全市场首拉多花 5~6s)。大批量请求前先调
本方法把连接并发建好,首拉只多付一次握手。
失败静默忽略:缺的连接后续由 ``acquire`` 按需补齐。
"""
if self._closed:
return
need = min(n, self.max_size) - self._total
if need <= 0:
return
# 用局部计数挑 host,避免并发建连时反复选中同一台
counts = dict(self._server_count)
ranked = self.health.rank(self.servers)
hosts: list[str] = []
for _ in range(need):
host = next((h for h in ranked
if not self.health.in_cooldown(h)
and counts.get(h, 0) < self.per_server_cap), None)
if host is None:
break
hosts.append(host)
counts[host] = counts.get(host, 0) + 1
if not hosts:
return
results = await asyncio.gather(
*(self._new_conn(h) for h in hosts), return_exceptions=True)
async with self._lock:
for pc in results:
if isinstance(pc, PooledConnection):
self._total += 1
self.stats.total = self._total
if not self._closed and pc.alive:
self._idle.append(pc)
async def release(self, pc: PooledConnection, *, broken: bool = False) -> None: async def release(self, pc: PooledConnection, *, broken: bool = False) -> None:
if self.stats.borrowed > 0: if self.stats.borrowed > 0:
self.stats.borrowed -= 1 self.stats.borrowed -= 1
+145 -10
View File
@@ -12,18 +12,153 @@ from .base import BaseCommand
MAX_QUOTES = 80 MAX_QUOTES = 80
# ====================================================================== #
# 权威小数位表(由证券清单 SecurityInfo.decimal_point 灌入)
# ====================================================================== #
# 查找顺序:**权威表 → 静态前缀规则**。权威表来自 ``get_universe`` 返回的
# ``SecurityInfo.decimal_point``(协议自带,见 protocol/commands/security_list.py),
# 由 ``pytdxdata.decimal_sync`` 在后台每日同步一次;未同步时静默退回静态规则,
# 行为与 0.6.5 完全一致。
_DECIMAL_PREFIX: dict[tuple[int, str], int] = {}
_DECIMAL_CODE: dict[tuple[int, str], int] = {}
_DECIMAL_MIXED: set[tuple[int, str]] = set()
_DECIMAL_SOURCE: str = ""
def install_decimal_map(
items: "list[tuple[int, str, int]] | tuple[tuple[int, str, int], ...]",
*,
source: str = "",
) -> dict[str, int]:
"""用证券清单灌入权威小数位表。
``items`` 为 ``(market, code, decimal_point)`` 序列(直接来自
``SecurityInfo``)。按**三位代码前缀**归并成一个极小的表(全量 5 万只标的
只产生数百个前缀);若某个前缀出现**不同**小数位,则该前缀退化为逐代码查表,
只把这些例外代码存进 ``_DECIMAL_CODE``——这样即使将来交易所新增代码段,
也不会因为前缀规则过时而算错价格。
返回统计:``{"prefixes", "codes", "mixed_prefixes", "stock"}``。
"""
global _DECIMAL_SOURCE
votes: dict[tuple[int, str], dict[int, int]] = {}
per_code: dict[tuple[int, str], int] = {}
for market, code, dp in items:
c = str(code or "").strip().rstrip("\x00")
if len(c) < 3:
continue
m = int(market)
if m not in (0, 1):
continue
d = int(dp)
if d <= 0:
continue
per_code[(m, c)] = d
key = (m, c[:3])
bucket = votes.setdefault(key, {})
bucket[d] = bucket.get(d, 0) + 1
_DECIMAL_PREFIX.clear()
_DECIMAL_CODE.clear()
_DECIMAL_MIXED.clear()
for key, bucket in votes.items():
if len(bucket) == 1:
_DECIMAL_PREFIX[key] = next(iter(bucket))
else:
_DECIMAL_MIXED.add(key)
for (m, c), d in per_code.items():
if (m, c[:3]) in _DECIMAL_MIXED:
_DECIMAL_CODE[(m, c)] = d
_DECIMAL_SOURCE = source or "universe"
return decimal_map_stats()
def clear_decimal_map() -> None:
"""清空权威表(回到纯静态前缀规则;测试与排障用)。"""
global _DECIMAL_SOURCE
_DECIMAL_PREFIX.clear()
_DECIMAL_CODE.clear()
_DECIMAL_MIXED.clear()
_DECIMAL_SOURCE = ""
def decimal_map_stats() -> dict[str, int]:
"""权威表状态:已覆盖前缀数 / 例外代码数 / 混合前缀数 / 总条目数。"""
return {
"prefixes": len(_DECIMAL_PREFIX),
"codes": len(_DECIMAL_CODE),
"mixed_prefixes": len(_DECIMAL_MIXED),
"stock": len(_DECIMAL_PREFIX) + len(_DECIMAL_CODE),
}
def decimal_map_source() -> str:
"""权威表来源标记(``universe`` / ``cache`` / ``""``=未加载)。"""
return _DECIMAL_SOURCE
def _decimal_digits_static(market: int, code: str) -> int:
"""静态前缀规则(**兜底**,权威表缺失时使用)。"""
if market == 1: # 沪市
if code.startswith("5"):
return 3 # 基金/ETF/LOF(50/51/52/56/58 系)
if code.startswith("900"):
return 3 # B股
if code.startswith(("000", "36", "88", "99", "7", "6")):
return 2 # 指数/板块/优先股/配售/股票(60/601/603/605/688)
return 4 # 债券(01x/1xx/2xx)、回购(204xxx)、ABS
if market == 0: # 深市
if code.startswith(("080", "158", "159", "160", "161", "162", "163",
"164", "165", "166", "167", "168", "169",
"180", "181")):
return 3 # 基金/ETF/LOF/配债
if code.startswith(("000", "001", "002", "003", "070", "140",
"200", "201", "300", "301", "302", "395", "399")):
return 2 # 股票/指数/B股/优先股
return 4 # 债券(10x-14x/19x)、回购(131xxx)、ABS(50x/52x/56x)
return 2
def price_decimal_digits(market: int, code: str) -> int: def price_decimal_digits(market: int, code: str) -> int:
"""推断报价有效小数位:股票2位(/100)、指数/ETF/基金/转债/国债3位(/1000)。""" """报价小数位:**协议原始整数除以 ``10**该值``** 才是真实价格。
查找顺序:
1. **权威表**(:func:`install_decimal_map` 灌入)—— 来自证券清单里协议自带的
``SecurityInfo.decimal_point``,由 ``pytdxdata.decimal_sync`` 每日后台同步一次。
2. **静态前缀规则**(:func:`_decimal_digits_static`)—— 权威表未就绪时兜底。
四档:股票/指数/板块 ``2``、基金/ETF/B股 ``3``、债券/回购 ``4``。
为什么还要静态规则:``get_quotes`` 解析是**纯同步、无网络**的路径,解析那一刻
可能还没同步过证券清单;而现网首次安装/离线环境也必须能算出价格。
权威表与静态规则的一致性:2026-10-22 拉取全量 51,982 只(沪 27,520 + 深 24,462)
逐条比对,静态规则与 ``decimal_point`` **一一吻合、零例外**——因为全量清单里
没有任何一个三位前缀出现混合小数位。因此两者并存不会产生口径冲突。
历史修正(两次都是同一类错误:把某段前缀想当然地归错档):
- **2026-10-21**:沪市 ``000``/``8`` 被判成 3 位 → 上证指数/上证50/科创50/
板块指数**价格少 10 倍**(3713 读成 371)。它们实际是 2 位。
- **2026-10-22**:债券与回购全线偏差 —— 沪市 ``010/018/019/020/1xx/2xx``
与深市 ``10x/11x/12x/13x/14x/19x/50x/52x/56x`` 实际是 **4 位**,原先
沪市落到 2 位(**少 100 倍**)、深市落到 3 位(**少 10 倍**)。实测例:
``sh019742`` 110.228 读成 11022.8、``sh204001`` 1.385 读成 138.5、
``sz131810`` 1.38 读成 13.8。同时沪市 B 股 ``900xxx`` 是 3 位(原先 2 位)。
实证方法:拿 ``pre_close``(快照口径)除以上一交易日**日线收盘**(K线口径,
走 ``/1000`` 独立路径),比值即标度误差 —— 1.0 正确、10 少 10 倍、100 少 100 倍。
"""
code = (code or "").strip().rstrip("\x00") code = (code or "").strip().rstrip("\x00")
if market == 1: # SH m = int(market)
if code.startswith(("5", "000", "8")): if m in (0, 1):
return 3 hit = _DECIMAL_PREFIX.get((m, code[:3]))
return 2 if hit is not None:
if market == 0: # SZ return hit
if code.startswith("1"): hit = _DECIMAL_CODE.get((m, code))
return 3 if hit is not None:
return 2 return hit
return 2 return _decimal_digits_static(m, code)
def format_server_time(raw: int) -> str: def format_server_time(raw: int) -> str:
@@ -36,8 +36,12 @@ class GetSecurityListCmd(BaseCommand[list[SecurityInfo]]):
self.start = start self.start = start
def build_request(self) -> bytes: def build_request(self) -> bytes:
# 12 字节头 + market(H) + start(H) = **16 字节**。
# ⚠️ 曾经多塞一个 H(18 字节):服务端只消费前 16 字节,剩下的 00 00
# 留在它的接收缓冲里,会把**下一个请求**的开头吃掉 → 该连接的后续请求
# 永远得不到响应(表现为「第一次成功、第二次起全部通信超时」)。
header = bytes.fromhex("0c0118640101060006005004".replace(" ", "")) header = bytes.fromhex("0c0118640101060006005004".replace(" ", ""))
return header + struct.pack("<HHH", self.market, self.start, 0) return header + struct.pack("<HH", self.market, self.start)
def parse_response(self, body: bytes) -> list[SecurityInfo]: def parse_response(self, body: bytes) -> list[SecurityInfo]:
(num,) = unpack_from("<H", body, 0, "security list header") (num,) = unpack_from("<H", body, 0, "security list header")
+19 -6
View File
@@ -5,6 +5,7 @@ import struct
from ..._binary import unpack_from from ..._binary import unpack_from
from ...models import TransactionRecord from ...models import TransactionRecord
from ...symbols import has_order_count
from ..datetime_ import get_time from ..datetime_ import get_time
from ..mac_frame import build_mac_request from ..mac_frame import build_mac_request
from ..price import get_price from ..price import get_price
@@ -32,6 +33,8 @@ class GetTransactionDataCmd(BaseCommand[list[TransactionRecord]]):
pos = 2 pos = 2
last_price = 0 last_price = 0
records: list[TransactionRecord] = [] records: list[TransactionRecord] = []
code = self.code.decode("utf-8")
has_tc = has_order_count(self.market, code)
for _ in range(num): for _ in range(num):
hour, minute, pos = get_time(body, pos) hour, minute, pos = get_time(body, pos)
price_diff, pos = get_price(body, pos) price_diff, pos = get_price(body, pos)
@@ -41,10 +44,12 @@ class GetTransactionDataCmd(BaseCommand[list[TransactionRecord]]):
_unknown, pos = get_price(body, pos) _unknown, pos = get_price(body, pos)
last_price += price_diff last_price += price_diff
records.append(TransactionRecord( records.append(TransactionRecord(
market=self.market, code=self.code.decode("utf-8"), market=self.market, code=code,
time=f"{hour:02d}:{minute:02d}:00", time=f"{hour:02d}:{minute:02d}:00",
price=last_price / 100.0, vol=float(vol), price=last_price / 100.0, vol=float(vol),
trade_count=int(num_orders), bs_flag=bs_flag, # 指数/ETF/LOF 该字段是「价格×1000」占位,不是笔数
trade_count=int(num_orders) if has_tc else 0,
bs_flag=bs_flag, trade_count_available=has_tc,
)) ))
return records return records
@@ -68,6 +73,7 @@ class GetHistoryTransactionDataCmd(BaseCommand[list[TransactionRecord]]):
pos = 6 # 2(num) + 4(skip) pos = 6 # 2(num) + 4(skip)
last_price = 0 last_price = 0
records: list[TransactionRecord] = [] records: list[TransactionRecord] = []
code = self.code.decode("utf-8")
for _ in range(num): for _ in range(num):
hour, minute, pos = get_time(body, pos) hour, minute, pos = get_time(body, pos)
price_diff, pos = get_price(body, pos) price_diff, pos = get_price(body, pos)
@@ -76,10 +82,11 @@ class GetHistoryTransactionDataCmd(BaseCommand[list[TransactionRecord]]):
_unknown, pos = get_price(body, pos) _unknown, pos = get_price(body, pos)
last_price += price_diff last_price += price_diff
records.append(TransactionRecord( records.append(TransactionRecord(
market=self.market, code=self.code.decode("utf-8"), market=self.market, code=code,
time=f"{hour:02d}:{minute:02d}:00", time=f"{hour:02d}:{minute:02d}:00",
price=last_price / 100.0, vol=float(vol), price=last_price / 100.0, vol=float(vol),
trade_count=0, bs_flag=bs_flag, # 历史无笔数 trade_count=0, bs_flag=bs_flag,
trade_count_available=False, # 历史通道整条链路都没有笔数字段
)) ))
return records return records
@@ -108,11 +115,15 @@ class MacTransactionCmd(BaseCommand[list[TransactionRecord]]):
def parse_response(self, body: bytes) -> list[TransactionRecord]: def parse_response(self, body: bytes) -> list[TransactionRecord]:
(count,) = unpack_from("<H", body, 29, "mac transaction count") (count,) = unpack_from("<H", body, 29, "mac transaction count")
records: list[TransactionRecord] = [] records: list[TransactionRecord] = []
has_tc = has_order_count(self.market, self.code)
for i in range(count): for i in range(count):
offset = 39 + i * 18 offset = 39 + i * 18
try: 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( time_sec, price, volume, trade_count, bs_flag = unpack_from(
"<IfIIH", body, offset, "mac transaction item" "<IfIiH", body, offset, "mac transaction item"
) )
except ValueError: except ValueError:
break break
@@ -121,6 +132,8 @@ class MacTransactionCmd(BaseCommand[list[TransactionRecord]]):
market=self.market, code=self.code, market=self.market, code=self.code,
time=f"{h:02d}:{m:02d}:{s:02d}", time=f"{h:02d}:{m:02d}:{s:02d}",
price=price, vol=float(volume), price=price, vol=float(volume),
trade_count=int(trade_count), bs_flag=bs_flag, # 指数/ETF/LOF 该字段是「价格×1000」占位,不是笔数
trade_count=int(trade_count) if has_tc else 0,
bs_flag=bs_flag, trade_count_available=has_tc,
)) ))
return records return records
+7 -3
View File
@@ -27,6 +27,7 @@ class PageSpec:
ordered: bool = True # 按 start 升序拼接 ordered: bool = True # 按 start 升序拼接
min_page: int = 100 # 规避标准K线 count<100 空响应坑 min_page: int = 100 # 规避标准K线 count<100 空响应坑
start_offset: int = 0 # 起始偏移(从该偏移开始分页,避免拉取历史全量) start_offset: int = 0 # 起始偏移(从该偏移开始分页,避免拉取历史全量)
newest_first: bool = False # 服务端 start 从最新往回数(0x122F 逐笔即如此)
@dataclass(slots=True) @dataclass(slots=True)
@@ -94,7 +95,7 @@ class Paginator:
if s.pc is not None: if s.pc is not None:
pc, s.pc = s.pc, None pc, s.pc = s.pc, None
await self.pool.release(pc) await self.pool.release(pc)
return self._assemble(out, spec.ordered) return self._assemble(out, spec.ordered, spec.newest_first)
def _plan_starts(self, spec: PageSpec) -> list[tuple[int, int]]: def _plan_starts(self, spec: PageSpec) -> list[tuple[int, int]]:
"""切页:返回 [(start, count), ...]。""" """切页:返回 [(start, count), ...]。"""
@@ -158,9 +159,12 @@ class Paginator:
return None, False return None, False
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: if ordered:
results.sort(key=lambda r: r.start) results.sort(key=lambda r: r.start, reverse=newest_first)
out: list[Any] = [] out: list[Any] = []
for r in results: for r in results:
out.extend(r.items) out.extend(r.items)
+197 -140
View File
@@ -1,6 +1,6 @@
{ {
"version": "2026-09-21", "version": "2026-10-16",
"note": "离线探针复测(2026-09-21 19:03): 可达=25/33, 入池fast_pool=10台", "note": "离线探针复测(2026-10-16 13:46): 可达=30/36, 入池fast_pool=10台",
"servers": [ "servers": [
{ {
"ip": "139.9.52.158", "ip": "139.9.52.158",
@@ -11,14 +11,14 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.22, "latency": 0.172,
"checked_at": "2026-09-21 19:03:04", "checked_at": "2026-10-16 13:46:17",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": true, "fast_pool": true,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.226, "standard": 0.172,
"mac": 0.22 "mac": 0.183
} }
}, },
{ {
@@ -30,14 +30,14 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.366, "latency": 0.298,
"checked_at": "2026-09-21 19:03:04", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": true,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.396, "standard": 0.316,
"mac": 0.366 "mac": 0.298
} }
}, },
{ {
@@ -48,13 +48,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.257, "latency": 0.236,
"checked_at": "2026-09-21 19:03:09", "checked_at": "2026-10-16 13:46:23",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": true, "fast_pool": true,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.257 "mac": 0.236
} }
}, },
{ {
@@ -65,13 +65,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.248, "latency": 0.213,
"checked_at": "2026-09-21 19:03:04", "checked_at": "2026-10-16 13:46:17",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": true, "fast_pool": true,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.248 "mac": 0.213
} }
}, },
{ {
@@ -84,15 +84,15 @@
], ],
"handshake": "setup", "handshake": "setup",
"status": "ok", "status": "ok",
"latency": 0.221, "latency": 0.316,
"checked_at": "2026-09-21 19:03:00", "checked_at": "2026-10-16 13:46:13",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": true, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.399, "standard": 0.316,
"mac": 0.414, "mac": 0.329,
"ex": 0.221 "ex": 0.539
} }
}, },
{ {
@@ -104,10 +104,10 @@
"handshake": null, "handshake": null,
"status": "fail", "status": "fail",
"latency": null, "latency": null,
"checked_at": "2026-09-21 19:03:20", "checked_at": "2026-10-16 13:46:34",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": {} "_per_proto": {}
}, },
{ {
@@ -118,13 +118,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.363, "latency": 0.682,
"checked_at": "2026-09-21 19:03:10", "checked_at": "2026-10-16 13:46:24",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": true, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.363 "mac": 0.682
} }
}, },
{ {
@@ -136,10 +136,10 @@
"handshake": null, "handshake": null,
"status": "fail", "status": "fail",
"latency": null, "latency": null,
"checked_at": "2026-09-21 19:03:20", "checked_at": "2026-10-16 13:46:34",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": {} "_per_proto": {}
}, },
{ {
@@ -150,13 +150,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.344, "latency": 0.607,
"checked_at": "2026-09-21 19:03:10", "checked_at": "2026-10-16 13:46:23",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": true, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.344 "mac": 0.607
} }
}, },
{ {
@@ -167,13 +167,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.404, "latency": 1.264,
"checked_at": "2026-09-21 19:03:10", "checked_at": "2026-10-16 13:46:24",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.404 "mac": 1.264
} }
}, },
{ {
@@ -185,10 +185,10 @@
"handshake": null, "handshake": null,
"status": "fail", "status": "fail",
"latency": null, "latency": null,
"checked_at": "2026-09-21 19:03:24", "checked_at": "2026-10-16 13:46:34",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": {} "_per_proto": {}
}, },
{ {
@@ -200,10 +200,10 @@
"handshake": null, "handshake": null,
"status": "fail", "status": "fail",
"latency": null, "latency": null,
"checked_at": "2026-09-21 19:03:21", "checked_at": "2026-10-16 13:46:34",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": {} "_per_proto": {}
}, },
{ {
@@ -214,13 +214,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.376, "latency": 0.612,
"checked_at": "2026-09-21 19:03:10", "checked_at": "2026-10-16 13:46:23",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.376 "mac": 0.612
} }
}, },
{ {
@@ -231,13 +231,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.377, "latency": 0.613,
"checked_at": "2026-09-21 19:03:10", "checked_at": "2026-10-16 13:46:23",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.377 "mac": 0.613
} }
}, },
{ {
@@ -248,13 +248,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.401, "latency": 0.624,
"checked_at": "2026-09-21 19:03:10", "checked_at": "2026-10-16 13:46:23",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.401 "mac": 0.624
} }
}, },
{ {
@@ -265,13 +265,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.42, "latency": 0.592,
"checked_at": "2026-09-21 19:03:10", "checked_at": "2026-10-16 13:46:23",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.42 "mac": 0.592
} }
}, },
{ {
@@ -282,13 +282,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.401, "latency": 0.624,
"checked_at": "2026-09-21 19:03:10", "checked_at": "2026-10-16 13:46:23",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"mac": 0.401 "mac": 0.624
} }
}, },
{ {
@@ -300,14 +300,14 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.485, "latency": 0.306,
"checked_at": "2026-09-21 19:03:05", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.485, "standard": 0.352,
"mac": 0.605 "mac": 0.306
} }
}, },
{ {
@@ -319,10 +319,10 @@
"handshake": null, "handshake": null,
"status": "fail", "status": "fail",
"latency": null, "latency": null,
"checked_at": "2026-09-21 19:03:04", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": {} "_per_proto": {}
}, },
{ {
@@ -334,14 +334,14 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.444, "latency": 0.307,
"checked_at": "2026-09-21 19:03:05", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.444, "standard": 0.35,
"mac": 0.903 "mac": 0.307
} }
}, },
{ {
@@ -352,13 +352,16 @@
"mac" "mac"
], ],
"handshake": null, "handshake": null,
"status": "fail", "status": "ok",
"latency": null, "latency": 0.395,
"checked_at": "2026-09-21 19:03:15", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": {} "_per_proto": {
"standard": 0.395,
"mac": 0.675
}
}, },
{ {
"ip": "117.34.114.15", "ip": "117.34.114.15",
@@ -369,14 +372,14 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.435, "latency": 0.345,
"checked_at": "2026-09-21 19:03:05", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.463, "standard": 0.345,
"mac": 0.435 "mac": 0.726
} }
}, },
{ {
@@ -387,13 +390,16 @@
"mac" "mac"
], ],
"handshake": null, "handshake": null,
"status": "fail", "status": "ok",
"latency": null, "latency": 0.326,
"checked_at": "2026-09-21 19:03:14", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": {} "_per_proto": {
"standard": 0.326,
"mac": 0.743
}
}, },
{ {
"ip": "117.34.114.27", "ip": "117.34.114.27",
@@ -404,14 +410,14 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.482, "latency": 0.394,
"checked_at": "2026-09-21 19:03:05", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.482, "standard": 0.394,
"mac": 0.579 "mac": 0.78
} }
}, },
{ {
@@ -423,14 +429,14 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.609, "latency": 0.327,
"checked_at": "2026-09-21 19:03:05", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.946, "standard": 0.327,
"mac": 0.609 "mac": 0.328
} }
}, },
{ {
@@ -442,14 +448,14 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.46, "latency": 0.348,
"checked_at": "2026-09-21 19:03:05", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"fast_pool": false, "fast_pool": false,
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"_per_proto": { "_per_proto": {
"standard": 0.46, "standard": 0.348,
"mac": 0.521 "mac": 0.74
} }
}, },
{ {
@@ -461,9 +467,9 @@
"handshake": null, "handshake": null,
"status": "fail", "status": "fail",
"latency": null, "latency": null,
"checked_at": "2026-09-21 19:03:24", "checked_at": "2026-10-16 13:46:37",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"fast_pool": false, "fast_pool": false,
"_per_proto": {} "_per_proto": {}
}, },
@@ -475,13 +481,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.271, "latency": 0.726,
"checked_at": "2026-09-21 19:03:04", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"fast_pool": true, "fast_pool": false,
"_per_proto": { "_per_proto": {
"mac": 0.271 "mac": 0.726
} }
}, },
{ {
@@ -492,13 +498,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.375, "latency": 0.624,
"checked_at": "2026-09-21 19:03:05", "checked_at": "2026-10-16 13:46:18",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"fast_pool": false, "fast_pool": false,
"_per_proto": { "_per_proto": {
"mac": 0.375 "mac": 0.624
} }
}, },
{ {
@@ -509,13 +515,13 @@
], ],
"handshake": null, "handshake": null,
"status": "ok", "status": "ok",
"latency": 0.424, "latency": 0.56,
"checked_at": "2026-09-21 19:03:05", "checked_at": "2026-10-16 13:46:30",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"fast_pool": false, "fast_pool": false,
"_per_proto": { "_per_proto": {
"mac": 0.424 "mac": 0.56
} }
}, },
{ {
@@ -526,13 +532,13 @@
], ],
"handshake": "login", "handshake": "login",
"status": "ok", "status": "ok",
"latency": 0.176, "latency": 0.097,
"checked_at": "2026-09-21 19:03:08", "checked_at": "2026-10-16 13:46:21",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"fast_pool": true, "fast_pool": true,
"_per_proto": { "_per_proto": {
"ex": 0.176 "ex": 0.097
} }
}, },
{ {
@@ -543,13 +549,13 @@
], ],
"handshake": "login", "handshake": "login",
"status": "ok", "status": "ok",
"latency": 0.148, "latency": 0.097,
"checked_at": "2026-09-21 19:03:08", "checked_at": "2026-10-16 13:46:21",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"fast_pool": true, "fast_pool": true,
"_per_proto": { "_per_proto": {
"ex": 0.148 "ex": 0.097
} }
}, },
{ {
@@ -560,15 +566,66 @@
], ],
"handshake": "setup", "handshake": "setup",
"status": "ok", "status": "ok",
"latency": 0.166, "latency": 0.103,
"checked_at": "2026-09-21 19:03:08", "checked_at": "2026-10-16 13:46:21",
"source": "probe-2026-08-12", "source": "probe-2026-08-12",
"checked_date": "2026-09-21", "checked_date": "2026-10-16",
"fast_pool": true, "fast_pool": true,
"_per_proto": { "_per_proto": {
"ex": 0.166 "ex": 0.103
}
},
{
"ip": "112.74.214.43",
"name": "扩展市场深圳双线1",
"protocols": [
"ex"
],
"handshake": "login",
"status": "ok",
"latency": 0.095,
"checked_at": "2026-10-16 13:46:21",
"source": "connect.cfg",
"fast_pool": true,
"checked_date": "2026-10-16",
"_per_proto": {
"ex": 0.095
}
},
{
"ip": "120.25.218.6",
"name": "扩展市场深圳双线2",
"protocols": [
"ex"
],
"handshake": "login",
"status": "ok",
"latency": 0.101,
"checked_at": "2026-10-16 13:46:21",
"source": "connect.cfg",
"fast_pool": true,
"checked_date": "2026-10-16",
"_per_proto": {
"ex": 0.101
}
},
{
"ip": "47.102.108.214",
"name": "扩展市场上海双线2",
"protocols": [
"ex"
],
"handshake": "login",
"status": "ok",
"latency": 0.149,
"checked_at": "2026-10-16 13:46:22",
"source": "connect.cfg",
"fast_pool": true,
"checked_date": "2026-10-16",
"_per_proto": {
"ex": 0.149
} }
} }
], ],
"checked_date": "2026-09-21" "checked_date": "2026-10-16"
} }
+50
View File
@@ -238,3 +238,53 @@ def is_cn_index(market: int, code: str) -> bool:
or (code.startswith("000") and int(market) == int(Market.SH)) or (code.startswith("000") and int(market) == int(Market.SH))
or (code.startswith("399") and int(market) == int(Market.SZ)) or (code.startswith("399") and int(market) == int(Market.SZ))
) )
def has_order_count(market: int, code: str) -> bool:
"""该标的的逐笔 ``trade_count`` 是否是**真实成交笔数**。
通达信对**指数**和**多数场内基金**不提供笔数,但那 4 字节里仍塞了值:
- 指数:``当时均价 × 1000``(见 :class:`~pytdxdata.models.TransactionRecord`)
- ETF / LOF:``价格 × 1000``;货币 ETF(如 ``sh511990``)恒为 ``0``
直接当笔数用会得到 3994 这种荒谬值(实测 ``sh510310``)。
实测覆盖(2026-10-22,按代码前缀各取样 1~7 只):
================== ========================== ==========
品种 前缀 笔数可用
================== ========================== ==========
沪股票/科创 600/601/603/605/688/689 是
沪 LOF 501/502/506 是
沪 ETF/LOF 51/52/56/58 **否**
沪指数 000/88 否
沪可转债 110/111/113/118 是
沪 EB(可交换债) 132 是
沪逆回购 204 是
深股票 000/001/002/003/300/301 是
深 ETF 159 **否**
深 LOF/基金 15/16/17/18 **否**
深指数 399 否
深可转债 123/127/128 是
================== ========================== ==========
``501x/502x/506x``(沪市 LOF)实测**有**真实笔数,所以不能用「沪市 5 开头
一律当基金」的粗规则;必须按上面这组前缀精确判定。
可转债(沪 110/111/113/118/132、深 123/127/128)**走的是兜底分支**——
它们既不在沪市 ``51/52/56/58`` 里,也不在深市 ``159/15/16/17/18`` 里,
所以两个分支都落到「是」。这不是巧合而是设计:兜底按「**排除法**」认定
基金/指数,其余一律当普通品种。实测验证(2026-10-22,16 只当日 + 8 只历史日):
笔数合计与日线量级吻合(``sh111000`` 3631 条切片 / 20443 笔,
``sz128136`` 1939 条 / 14593 笔),且 ``Σvol`` 与日线 ``vol`` 比值 **1.000000**。
"""
code = str(code)
if is_cn_index(market, code):
return False
m = int(market)
if m == int(Market.SH):
return code[:2] not in ("51", "52", "56", "58")
if m == int(Market.SZ):
return not (code[:3] == "159" or code[:2] in ("15", "16", "17", "18"))
return True
+22
View File
@@ -0,0 +1,22 @@
"""测试全局隔离。
默认关掉**权威小数位表的后台同步** —— 否则任何调用 ``TdxData.start()`` 的用例都会
顺手发起证券清单请求(26 + 25 个分页),测试会变慢且依赖网络。
需要验证同步行为本身的用例(``test_decimal_sync.py``)自己 ``delenv`` 后再测。
"""
from __future__ import annotations
import os
import pytest
@pytest.fixture(autouse=True, scope="session")
def _disable_decimal_sync():
old = os.environ.get("PYPYTDX_DATA_DISABLE_DECIMAL_SYNC")
os.environ["PYPYTDX_DATA_DISABLE_DECIMAL_SYNC"] = "1"
yield
if old is None:
os.environ.pop("PYPYTDX_DATA_DISABLE_DECIMAL_SYNC", None)
else:
os.environ["PYPYTDX_DATA_DISABLE_DECIMAL_SYNC"] = old
+39
View File
@@ -324,6 +324,27 @@ async def test_universe_and_quotes(td):
assert len(qex) == 1 assert len(qex) == 1
async def test_decimal_point_sync(td, tmp_path, monkeypatch):
"""权威小数位表同步:把证券清单的 decimal_point 灌进价格标度表。"""
for name in ("sync_decimal_points", "decimal_point_status"):
_use(name)
from pytdxdata.protocol.commands.quotes import clear_decimal_map, price_decimal_digits
# 缓存目录指向临时目录,避免把 mock 数据写进用户真实缓存
monkeypatch.setenv("PYPYTDX_DATA_CACHE_DIR", str(tmp_path))
before = price_decimal_digits(1, "600000")
try:
st = await td.sync_decimal_points()
assert set(st) >= {"prefixes", "codes", "mixed_prefixes", "stock"}
assert st["stock"] >= 0
status = await td.decimal_point_status()
assert isinstance(status, dict) and "source" in status
finally:
clear_decimal_map()
# 清空后回到静态规则,不受本用例污染
assert price_decimal_digits(1, "600000") == before
async def test_snapshot_auction_flow(td): async def test_snapshot_auction_flow(td):
for name in ("get_snapshot", "get_auction", "get_capital_flow"): for name in ("get_snapshot", "get_auction", "get_capital_flow"):
_use(name) _use(name)
@@ -457,6 +478,24 @@ async def test_boards(td):
assert isinstance(chg, list) assert isinstance(chg, list)
async def test_index_trade_stats(td):
"""指数成分成交汇总:成分 → 逐笔 → 每分钟量/笔数。"""
for name in ("get_index_members", "get_index_trade_stats",
"get_index_trade_stats_multi"):
_use(name)
mem = await td.get_index_members("000016")
assert isinstance(mem, list) and mem and mem[0].symbol
st = await td.get_index_trade_stats("000016")
assert st.index == "sh000016"
assert st.member_count >= 1
assert st.minutes and st.minutes[0].time == "09:30"
assert st.total_trade_count >= 1
assert st.cum_trade_count()[-1][1] == st.total_trade_count
multi = await td.get_index_trade_stats_multi("000016", [20261020, None])
assert len(multi) == 2
assert multi[0].date == 20261020 and multi[1].date is None
# --------------------------------------------------------------------------- # # --------------------------------------------------------------------------- #
# 六、服务器文件 # 六、服务器文件
# --------------------------------------------------------------------------- # # --------------------------------------------------------------------------- #
+211 -1
View File
@@ -8,7 +8,13 @@ import unittest.mock as mock
import pytest import pytest
from pytdxdata.api import TdxData 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.protocol.commands.mac_tick import MacTickChartCmd
from pytdxdata.scheduler.paginator import PageSpec, Paginator 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 开始 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 日期过滤 ---------- # ---------- get_kline 日期过滤 ----------
class DateBarApiConn(FakeApiConn): class DateBarApiConn(FakeApiConn):
@@ -329,3 +399,143 @@ async def test_get_kline_since():
assert bars[-1].year == 2027 assert bars[-1].year == 2027
finally: finally:
await td.close() 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 条"
+125
View File
@@ -0,0 +1,125 @@
"""CLI 价格小数位 / 分时时间列的显示回归。
覆盖两个曾经出错的地方:
1. ``tdx minute`` 的时间列按序号推算(``i // 60, i % 60``),240 根分时被打印成
``00:00~03:59``,与真实交易时间无关。
2. 价格固定写死 ``%8.2f``,可转债(报价步长 0.001 元)会被截成 2 位
——``128.892`` 打成 ``128.89``。
注意 ``price_decimal_digits`` 返回的是**解码位数**(原始整数 / 10**dp),可转债
是 4 位,但第 4 位恒为 0,显示层只该给 3 位(见 ``_display_dp``)。
"""
from __future__ import annotations
from pytdxdata.cli import (
_display_dp,
_dp_of,
_price_fmt,
cmd_minute,
cmd_transactions,
parse_symbol,
)
from pytdxdata.models import MinuteBar, TransactionRecord
class FakeTD:
"""只实现 minute / transactions 需要的两个接口。"""
def __init__(self, minutes=None, ticks=None):
self._minutes = minutes or []
self._ticks = ticks or []
async def get_minutes(self, sym, date=None):
return self._minutes
async def get_ticks(self, sym, date=None, count=None):
return self._ticks
def _bar(price, hour, minute, vol=100.0, avg=0.0):
return MinuteBar(price=price, vol=vol, avg_price=avg or price,
hour=hour, minute=minute, fields={})
def _tick(price, vol, trade_count=1, available=True, time="14:59:54"):
return TransactionRecord(market=1, code="113708", time=time, price=price, vol=vol,
trade_count=trade_count, bs_flag=0, fields={},
trade_count_available=available)
# --------------------------------------------------------------------------- #
# 小数位判定
# --------------------------------------------------------------------------- #
def test_price_fmt_width_tracks_decimals():
assert _price_fmt(2) == "%8.2f" # 股票:保持原宽度,不破坏对齐
assert _price_fmt(3) == "%9.3f"
assert _price_fmt(4) == "%10.4f"
assert _price_fmt(None) == "%8.2f" # 缺省当 2 位
def test_display_dp_by_instrument():
assert _display_dp(1, "600000") == 2 # 沪股票
assert _display_dp(0, "000001") == 2 # 深股票
assert _display_dp(1, "000001") == 2 # 指数
assert _display_dp(1, "113708") == 3 # 沪可转债(解码 4 位,显示 3 位)
assert _display_dp(1, "110102") == 3
assert _display_dp(0, "123235") == 3 # 深可转债
assert _display_dp(0, "128136") == 3
assert _display_dp(1, "510310") == 3 # ETF
assert _display_dp(1, "019547") == 4 # 国债:4 位是真实报价精度
def test_dp_of_uses_cn_only():
assert _dp_of(parse_symbol("sh113708")) == 3
assert _dp_of(parse_symbol("sh600000")) == 2
assert _dp_of(parse_symbol("hk00700")) == 2 # 非 A 股固定 2 位
# --------------------------------------------------------------------------- #
# tdx minute
# --------------------------------------------------------------------------- #
async def test_cmd_minute_prints_real_clock(capsys):
bars = [_bar(129.271, 9, 30), _bar(129.270, 9, 31), _bar(128.892, 14, 59)]
await cmd_minute(FakeTD(minutes=bars), "sh113708", None)
out = capsys.readouterr().out
assert "09:30" in out and "09:31" in out and "14:59" in out
assert "00:00" not in out and "03:59" not in out
async def test_cmd_minute_cb_keeps_three_decimals(capsys):
await cmd_minute(FakeTD(minutes=[_bar(128.892, 14, 59)]), "sh113708", None)
out = capsys.readouterr().out
assert "128.892" in out
assert "128.89 " not in out
async def test_cmd_minute_stock_two_decimals(capsys):
await cmd_minute(FakeTD(minutes=[_bar(9.62, 15, 0)]), "sh600000", None)
out = capsys.readouterr().out
assert "9.62" in out and "9.620" not in out
# --------------------------------------------------------------------------- #
# tdx transactions
# --------------------------------------------------------------------------- #
async def test_cmd_transactions_cb_price_and_count(capsys):
await cmd_transactions(FakeTD(ticks=[_tick(128.892, 3, trade_count=4)]),
"sh113708", 50, None)
out = capsys.readouterr().out
assert "128.892" in out
assert "(4笔)" in out
async def test_cmd_transactions_etf_marks_missing_count(capsys):
tick = TransactionRecord(market=1, code="510310", time="15:27:35", price=3.989,
vol=15, trade_count=0, bs_flag=0, fields={},
trade_count_available=False)
await cmd_transactions(FakeTD(ticks=[tick]), "sh510310", 50, None)
out = capsys.readouterr().out
assert "3.989" in out # ETF 也是 3 位
assert "(-)" in out # 不打印假笔数
assert "笔)" not in out
+233
View File
@@ -0,0 +1,233 @@
"""权威价格小数位表(decimal_sync)单元测试。
覆盖点:
- 权威表(来自 ``SecurityInfo.decimal_point``)**优先于**静态前缀规则
- 某前缀出现混合小数位 → 自动退化为逐代码查表,不误伤同前缀其它代码
- 清空权威表 → 回到静态规则(与 0.6.5 行为一致)
- 磁盘缓存:写入 / 读取 / 跨日失效 / 损坏容错,均不回退到网络
- ``PYPYTDX_DATA_DISABLE_DECIMAL_SYNC=1`` → 完全不动作
- 证券清单里 ``decimal_point == 0`` 的脏条目被忽略
- 后台 task 可取消,且 ``close()`` 后不再改写表
(全部注入假 ``TdxData``,不连真实网络)
"""
from __future__ import annotations
import asyncio
import json
from types import SimpleNamespace
import pytest
from pytdxdata import decimal_sync
from pytdxdata.protocol.commands.quotes import (
clear_decimal_map,
decimal_map_stats,
install_decimal_map,
price_decimal_digits,
)
# ---------------------------------------------------------------------- #
# 夹具
# ---------------------------------------------------------------------- #
@pytest.fixture(autouse=True)
def _isolate(tmp_path, monkeypatch):
"""每个用例独立缓存目录 + 干净的内存状态。"""
monkeypatch.setenv("PYPYTDX_DATA_CACHE_DIR", str(tmp_path))
monkeypatch.delenv("PYPYTDX_DATA_DISABLE_DECIMAL_SYNC", raising=False)
decimal_sync.reset()
yield
decimal_sync.reset()
def _info(code: str, dp: int) -> SimpleNamespace:
return SimpleNamespace(code=code, decimal_point=dp, market=1)
class FakeTd:
"""只有 ``get_universe`` 的假客户端(记录调用次数,便于断言"没走网络")。"""
def __init__(self, tables: dict[str, list[tuple[str, int]]] | None = None) -> None:
self.tables = tables or {}
self.calls: list[str] = []
async def get_universe(self, market: str | None = None):
self.calls.append(market or "all")
return [_info(c, d) for c, d in self.tables.get(market, [])]
# ---------------------------------------------------------------------- #
# 权威表优先级
# ---------------------------------------------------------------------- #
def test_authoritative_map_overrides_static_rule():
# 静态规则说 sh019742 是 4 位;权威表说 3 位 → 必须听权威表的
assert price_decimal_digits(1, "019742") == 4
install_decimal_map([(1, "019742", 3)], source="test")
assert price_decimal_digits(1, "019742") == 3
def test_codes_outside_map_still_use_static_rule():
install_decimal_map([(1, "019742", 3)], source="test")
assert price_decimal_digits(1, "600000") == 2 # 股票
assert price_decimal_digits(1, "510300") == 3 # ETF
assert price_decimal_digits(0, "131810") == 4 # 深回购(表里没有)
def test_mixed_prefix_falls_back_to_per_code_lookup():
"""同一前缀出现两种小数位 → 该前缀不进前缀表,只把例外代码存进逐代码表。"""
stats = install_decimal_map(
[(1, "110001", 4), (1, "110002", 4), (1, "110003", 3)], source="test")
assert stats["mixed_prefixes"] == 1
assert stats["codes"] == 3 # 混合前缀下所有代码都进逐代码表
assert price_decimal_digits(1, "110001") == 4
assert price_decimal_digits(1, "110003") == 3
def test_clear_map_restores_static_rules():
install_decimal_map([(1, "019742", 3)], source="test")
assert price_decimal_digits(1, "019742") == 3
clear_decimal_map()
assert decimal_map_stats()["stock"] == 0
assert price_decimal_digits(1, "019742") == 4
def test_reinstall_replaces_previous_map():
install_decimal_map([(1, "019742", 3)], source="a")
install_decimal_map([(1, "019742", 4)], source="b")
assert price_decimal_digits(1, "019742") == 4
assert decimal_map_stats()["prefixes"] == 1
# ---------------------------------------------------------------------- #
# 同步
# ---------------------------------------------------------------------- #
def test_refresh_installs_and_writes_cache(tmp_path):
td = FakeTd({"sh": [("019742", 4), ("600000", 2)],
"sz": [("000001", 2), ("131810", 4)]})
stats = asyncio.run(decimal_sync.refresh(td))
assert td.calls == ["sh", "sz"]
assert stats["stock"] == 4
assert price_decimal_digits(1, "600000") == 2
assert price_decimal_digits(0, "131810") == 4
raw = json.loads((tmp_path / "decimal-points.json").read_text(encoding="utf-8"))
assert raw["markets"]["1"]["019742"] == 4
assert raw["markets"]["0"]["131810"] == 4
def test_refresh_skips_zero_decimal_point():
td = FakeTd({"sh": [("019742", 0), ("600000", 2)]})
stats = asyncio.run(decimal_sync.refresh(td, ("sh",)))
assert stats["stock"] == 1
def test_refresh_ignores_unknown_market():
td = FakeTd({"hk": [("00700", 3)]})
stats = asyncio.run(decimal_sync.refresh(td, ("hk",)))
assert stats["stock"] == 0
assert not (decimal_sync.cache_file()).exists()
def test_load_cached_roundtrip(tmp_path):
td = FakeTd({"sh": [("019742", 4)]})
asyncio.run(decimal_sync.refresh(td))
decimal_sync.reset()
assert decimal_map_stats()["stock"] == 0
assert decimal_sync.load_cached() == 1
assert price_decimal_digits(1, "019742") == 4
def test_cache_expires_across_days(tmp_path):
td = FakeTd({"sh": [("019742", 4)]})
asyncio.run(decimal_sync.refresh(td))
decimal_sync.reset()
path = tmp_path / "decimal-points.json"
payload = json.loads(path.read_text(encoding="utf-8"))
payload["date"] = "2000-01-01"
path.write_text(json.dumps(payload), encoding="utf-8")
assert decimal_sync.load_cached() == 0
def test_corrupt_cache_is_ignored(tmp_path):
path = tmp_path / "decimal-points.json"
path.write_text("{not json", encoding="utf-8")
assert decimal_sync.load_cached() == 0
# ---------------------------------------------------------------------- #
# 调度
# ---------------------------------------------------------------------- #
def test_schedule_disabled_by_env(monkeypatch):
monkeypatch.setenv("PYPYTDX_DATA_DISABLE_DECIMAL_SYNC", "1")
td = FakeTd({"sh": [("019742", 4)]})
async def run():
task = decimal_sync.schedule(td)
return task
assert asyncio.run(run()) is None
assert td.calls == []
def test_schedule_loads_cache_without_network(tmp_path):
td = FakeTd({"sh": [("019742", 4)]})
asyncio.run(decimal_sync.refresh(td))
decimal_sync.reset()
quiet = FakeTd({"sh": [("019742", 4)]})
async def run():
return decimal_sync.schedule(quiet)
assert asyncio.run(run()) is None # 缓存命中 → 不起 task
assert quiet.calls == [] # 也没走网络
assert price_decimal_digits(1, "019742") == 4
def test_schedule_runs_background_sync_without_cache():
td = FakeTd({"sh": [("019742", 4)]})
async def run():
task = decimal_sync.schedule(td)
assert task is not None
await task
return decimal_sync.status()
st = asyncio.run(run())
assert st["source"] == "universe"
assert st["syncing"] is False
assert td.calls == ["sh", "sz"] # 默认两市
def test_cancel_stops_background_task():
class SlowTd:
def __init__(self) -> None:
self.calls = 0
async def get_universe(self, market=None):
self.calls += 1
await asyncio.sleep(5)
return []
td = SlowTd()
async def run():
task = decimal_sync.schedule(td)
await asyncio.sleep(0.01)
await decimal_sync.cancel(task)
return task.done() or task.cancelled()
assert asyncio.run(run()) is True
def test_status_shape():
st = decimal_sync.status()
assert set(st) >= {"loaded", "source", "syncing", "prefixes", "codes",
"mixed_prefixes", "stock"}
+116
View File
@@ -0,0 +1,116 @@
"""ExPool 背压/并发语义回归(Issue #1:并发超限 0.15s 秒失败)。
用 mock 连接模拟:单服务器 + per_server_cap=1 时,
- 并发 acquire 超过有效并发 → 排队等待而不是快速失败;
- release 唤醒等待者;
- acquire 超时异常带池状态;
- ex_pool_cap 提升同主机并发。
"""
from __future__ import annotations
import asyncio
import time
import pytest
from pytdxdata.pool.ex_pool import ExPool, ExPoolTimeoutError
class MockConn:
"""Minimal stand-in for ExTdxConnection."""
last_created = 0
def __init__(self, host: str, port: int, timeout: float, handshake: str = "login"):
self.host = host
self.port = port
self.alive = True
self.last_used = time.monotonic()
self.closed = False
MockConn.last_created += 1
async def connect(self) -> None:
await asyncio.sleep(0) # instant "connect"
async def close(self) -> None:
self.closed = True
self.alive = False
@pytest.fixture
def patch_conn(monkeypatch):
monkeypatch.setattr("pytdxdata.pool.ex_pool.ExTdxConnection", MockConn)
MockConn.last_created = 0
async def test_acquire_queues_instead_of_fast_fail(patch_conn):
"""并发 > 有效并发时,后续 acquire 等待 release,而非 0.15s 抛错。"""
pool = ExPool(["e1"], min_size=1, max_size=6, per_server_cap=1)
await pool.start()
c1 = await pool.acquire() # 唯一连接被占用
t0 = time.monotonic()
async def holder():
await asyncio.sleep(0.5) # 持有 0.5s 后归还
await pool.release(c1)
asyncio.create_task(holder())
c2 = await pool.acquire() # 应在 ~0.5s 后拿到,而不是 0.15s 抛错
waited = time.monotonic() - t0
assert waited >= 0.4, f"acquire 没有等待释放(仅 {waited:.2f}s)"
assert c2 is c1 # 归还的是同一条连接
async def test_acquire_timeout_carries_pool_state(patch_conn):
"""超时异常信息带池状态(idle/total/servers/cap)。"""
pool = ExPool(["e1"], min_size=1, max_size=6, per_server_cap=1, acquire_timeout=0.3)
await pool.start()
c1 = await pool.acquire()
with pytest.raises(ExPoolTimeoutError) as ei:
await pool.acquire()
msg = str(ei.value)
assert "total=1" in msg and "per_server_cap=1" in msg and "servers=1" in msg
await pool.release(c1)
async def test_ex_pool_cap_allows_parallel_conns_same_host(patch_conn):
"""per_server_cap=2 时单主机可并发持有 2 条连接。"""
pool = ExPool(["e1"], min_size=1, max_size=6, per_server_cap=2)
await pool.start()
got = await asyncio.gather(pool.acquire(), pool.acquire())
assert len(got) == 2 and got[0] is not got[1]
assert MockConn.last_created == 2
for c in got:
await pool.release(c)
async def test_concurrent_acquire_all_succeed(patch_conn):
"""Issue 场景:单服务器 + cap=2,6 个并发任务应全部拿到连接(排队)而非部分失败。"""
pool = ExPool(["e1"], min_size=2, max_size=6, per_server_cap=2)
await pool.start()
async def task(i):
c = await pool.acquire()
await asyncio.sleep(0.1) # 模拟一次 1m 分页拉取
await pool.release(c)
return i
results = await asyncio.gather(*[task(i) for i in range(6)])
assert sorted(results) == list(range(6)) # 全部成功,零失败
async def test_release_notifies_waiters(patch_conn):
"""broken 归还(连接死亡)也要唤醒等待者(槽位回收后可扩容)。"""
pool = ExPool(["e1"], min_size=1, max_size=1, per_server_cap=1)
await pool.start()
c1 = await pool.acquire()
c1.alive = False
async def broken_release():
await asyncio.sleep(0.2)
await pool.release(c1, broken=True)
asyncio.create_task(broken_release())
c2 = await pool.acquire() # 槽位被回收→扩容新建
assert c2 is not c1
await pool.release(c2)
+303
View File
@@ -0,0 +1,303 @@
"""指数成分成交汇总(get_index_members / get_index_trade_stats)单元测试。
全部离线:成分与逐笔都用实例属性打补丁,不建立任何真实连接。
"""
from __future__ import annotations
from types import SimpleNamespace
import pytest
from pytdxdata import TdxData
from pytdxdata.models import (
IndexTradeStats,
MemberQuote,
MinuteTradeStat,
TransactionRecord,
)
# ---------- _index_pair:裸代码按指数语义解析 ----------
@pytest.mark.parametrize("text,expect", [
("000001", (1, "000001")), # 上证指数(不是平安银行!)
("sh000001", (1, "000001")),
("000300", (1, "000300")),
("sh000300", (1, "000300")),
("000905", (1, "000905")),
("999999", (1, "999999")),
("880305", (1, "880305")),
("399001", (0, "399001")), # 深证成指
("sz399006", (0, "399006")),
("899050", (2, "899050")), # 北证50
("bj899050", (2, "899050")),
("sh.000300", (1, "000300")), # 点号/冒号都容忍
("sz:399001", (0, "399001")),
])
def test_index_pair_parses(text, expect):
assert TdxData._index_pair(text) == expect
@pytest.mark.parametrize("text", [
"", "600000", "sz000001x", "sh12345", "12345", "abc", "zzz000001",
])
def test_index_pair_rejects(text):
with pytest.raises(ValueError):
TdxData._index_pair(text)
def test_index_pair_rejects_non_index_cn_code():
"""000001 之外的普通股票段(如 600xxx)不是指数,裸写必须报错。"""
with pytest.raises(ValueError):
TdxData._index_pair("600000")
# ---------- 模型:累计曲线 ----------
def test_index_trade_stats_cumulative():
st = IndexTradeStats(
index="sh000300", date=None, member_count=2, active_members=2,
trade_count_members=2,
minutes=[
MinuteTradeStat("09:30", 100.0, 10, 1000.0),
MinuteTradeStat("09:31", 200.0, 20, 2000.0),
MinuteTradeStat("09:32", 50.0, 5, 500.0),
],
total_volume=350.0, total_trade_count=35, total_amount=3500.0,
)
cum = st.cumulative()
assert [c.time for c in cum] == ["09:30", "09:31", "09:32"]
assert [c.volume for c in cum] == [100.0, 300.0, 350.0]
assert [c.trade_count for c in cum] == [10, 30, 35]
assert [c.amount for c in cum] == [1000.0, 3000.0, 3500.0]
# 累计必须是新对象,不污染原始增量
assert st.minutes[1].volume == 200.0
assert st.cum_trade_count() == [("09:30", 10), ("09:31", 30), ("09:32", 35)]
def test_index_trade_stats_trade_count_available():
ok = IndexTradeStats(index="sh000300", date=None, member_count=1,
active_members=1, trade_count_members=1)
assert ok.trade_count_available is True
bj = IndexTradeStats(index="bj899050", date=None, member_count=1,
active_members=1, trade_count_members=0)
assert bj.trade_count_available is False
# ---------- get_index_members:分页终止 ----------
def _member(market: int, code: str, name: str = "") -> MemberQuote:
return MemberQuote(market=market, code=code, name=name,
fields={"0x0": 9.9, "0x5": 1000.0, "0x7": 99000.0})
@pytest.mark.asyncio
async def test_get_index_members_pages_until_short_batch():
"""短页(不足 80 条)即视为最后一页,不再多发一次空请求。"""
calls: list[int] = []
async def fake_exec(cmd):
calls.append(cmd.start)
if cmd.start == 0:
return [_member(1, "600000"), _member(1, "600004")]
return []
td = TdxData(cache_dir=None)
td._execute_mac = fake_exec
members = await td.get_index_members("000016")
assert [m.symbol for m in members] == ["sh600000", "sh600004"]
assert calls == [0]
@pytest.mark.asyncio
async def test_get_index_members_continues_on_full_page():
"""满页(80 条)后继续翻页,直到空页。"""
calls: list[int] = []
async def fake_exec(cmd):
calls.append(cmd.start)
if cmd.start == 0:
return [_member(1, "600000")] * cmd.page_size
return []
td = TdxData(cache_dir=None)
td._execute_mac = fake_exec
members = await td.get_index_members("000016")
assert len(members) == 80
assert calls == [0, 80]
@pytest.mark.asyncio
async def test_get_index_members_respects_count_cap():
async def fake_exec(cmd):
# 永远返回满页,验证 count 能截断结果
return [_member(1, "600000")] * cmd.page_size
td = TdxData(cache_dir=None)
td._execute_mac = fake_exec
members = await td.get_index_members("000016", count=5)
assert len(members) == 5
# ---------- get_index_trade_stats:按分钟聚合 ----------
def _tick(sym: str, hhmm: str, price: float, vol: float, tc: int) -> TransactionRecord:
market, code = (1, sym[2:]) if sym.startswith("sh") else (0, sym[2:])
return TransactionRecord(market=market, code=code, time=f"{hhmm}:00",
price=price, vol=vol, trade_count=tc, bs_flag=1,
symbol=sym)
@pytest.mark.asyncio
async def test_get_index_trade_stats_aggregates_minutes():
async def fake_ticks(symbols, date=None, concurrency=6, **kw):
out = []
for s in symbols:
if s == "sh600000":
out += [_tick(s, "09:30", 10.0, 100.0, 10),
_tick(s, "09:30", 10.0, 50.0, 5),
_tick(s, "09:31", 11.0, 200.0, 20)]
else:
out += [_tick(s, "09:30", 5.0, 1000.0, 7)]
return out
td = TdxData(cache_dir=None)
td.get_ticks = fake_ticks
st = await td.get_index_trade_stats(
"000016", members=["sh600000", "sz000001"])
assert st.index == "sh000016"
assert st.member_count == 2
assert st.active_members == 2
assert st.trade_count_members == 2
assert st.trade_count_available is True
assert st.failed_members == 0
m = {x.time: x for x in st.minutes}
assert sorted(m) == ["09:30", "09:31"]
assert m["09:30"].volume == 1150.0 # 100 + 50 + 1000
assert m["09:30"].trade_count == 22 # 10 + 5 + 7
assert m["09:31"].volume == 200.0
# amount = Σ(price × 手 × 100)
assert m["09:30"].amount == pytest.approx(
10.0 * 100 * 100 + 10.0 * 50 * 100 + 5.0 * 1000 * 100)
assert st.total_volume == 1350.0
assert st.total_trade_count == 42
assert st.total_amount == pytest.approx(
10.0 * 100 * 100 + 10.0 * 50 * 100 + 5.0 * 1000 * 100 + 11.0 * 200 * 100)
assert st.cum_trade_count() == [("09:30", 22), ("09:31", 42)]
@pytest.mark.asyncio
async def test_get_index_trade_stats_bj_has_no_trade_count():
"""北交所成分返回 trade_count=0 → trade_count_available False。"""
async def fake_ticks(symbols, date=None, concurrency=6, **kw):
return [_tick("sh600000", "09:30", 10.0, 100.0, 0)]
td = TdxData(cache_dir=None)
td.get_ticks = fake_ticks
st = await td.get_index_trade_stats("899050", members=["sh600000"])
assert st.trade_count_members == 0
assert st.trade_count_available is False
assert st.total_volume == 100.0
@pytest.mark.asyncio
async def test_get_index_trade_stats_retries_per_symbol_on_batch_failure():
"""整批失败 → 退化为逐只重试,只有真正失败的计入 failed_members。"""
async def fake_ticks(symbols, date=None, concurrency=6, **kw):
single = isinstance(symbols, str)
if not single:
raise ConnectionError("批量炸了")
if symbols == "sh600004":
raise ConnectionError("这只也炸了")
return [_tick(symbols, "09:30", 10.0, 100.0, 3)]
td = TdxData(cache_dir=None)
td.get_ticks = fake_ticks
st = await td.get_index_trade_stats(
"000016", members=["sh600000", "sh600004", "sh600006"])
assert st.failed_members == 1
assert st.active_members == 2
assert st.total_trade_count == 6
@pytest.mark.asyncio
async def test_get_index_trade_stats_raises_when_not_skip_errors():
async def fake_ticks(symbols, date=None, concurrency=6, **kw):
raise ConnectionError("boom")
td = TdxData(cache_dir=None)
td.get_ticks = fake_ticks
with pytest.raises(ConnectionError):
await td.get_index_trade_stats(
"000016", members=["sh600000"], skip_errors=False)
@pytest.mark.asyncio
async def test_get_index_trade_stats_progress_callback():
seen: list[tuple[int, int]] = []
async def fake_ticks(symbols, date=None, concurrency=6, **kw):
return [_tick(s, "09:30", 10.0, 1.0, 1) for s in symbols]
td = TdxData(cache_dir=None)
td.get_ticks = fake_ticks
st = await td.get_index_trade_stats(
"000016", members=[f"sh60000{i}" for i in range(5)],
batch_size=2, on_progress=lambda d, t: seen.append((d, t)))
assert seen == [(2, 5), (4, 5), (5, 5)]
assert st.member_count == 5
@pytest.mark.asyncio
async def test_get_index_trade_stats_fetches_members_when_absent():
asked: list[str] = []
async def fake_members(code):
asked.append(code)
return [SimpleNamespace(symbol="sh600000")]
async def fake_ticks(symbols, date=None, concurrency=6, **kw):
return [_tick(s, "09:30", 10.0, 1.0, 1) for s in symbols]
td = TdxData(cache_dir=None)
td.get_index_members = fake_members
td.get_ticks = fake_ticks
await td.get_index_trade_stats("sh000300")
assert asked == ["000300"]
@pytest.mark.asyncio
async def test_get_index_trade_stats_rejects_empty_members():
td = TdxData(cache_dir=None)
async def fake_members(code):
return []
td.get_index_members = fake_members
with pytest.raises(ValueError, match="没有取到成分股"):
await td.get_index_trade_stats("000300")
@pytest.mark.asyncio
async def test_get_index_trade_stats_multi_reuses_members():
member_calls: list[str] = []
tick_dates: list[int | None] = []
async def fake_members(code):
member_calls.append(code)
return [SimpleNamespace(symbol="sh600000")]
async def fake_ticks(symbols, date=None, concurrency=6, **kw):
tick_dates.append(date)
return [_tick(s, "09:30", 10.0, 1.0, 2) for s in symbols]
td = TdxData(cache_dir=None)
td.get_index_members = fake_members
td.get_ticks = fake_ticks
out = await td.get_index_trade_stats_multi(
"000300", [20261020, 20261021, None])
assert len(out) == 3
assert member_calls == ["000300"] # 成分只取一次
assert tick_dates == [20261020, 20261021, None]
assert all(s.total_trade_count == 2 for s in out)
+236
View File
@@ -0,0 +1,236 @@
"""单连接流水线(execute_pipeline)单元测试:不连真实网络。
关键防线:流水线把多条请求塞进同一条 TCP 流,一旦响应与请求错配就是
「价格张冠李戴」级别的灾难,所以这里逐项锁死顺序、长度与失败语义。
"""
from __future__ import annotations
import struct
import unittest.mock as mock
import pytest
from pytdxdata.pool.connection import TdxConnection
from pytdxdata.pool.pool import PooledConnection
from pytdxdata.protocol.commands.base import BaseCommand
class EchoCmd(BaseCommand[bytes]):
"""请求体即 tag,响应体原样带回,便于断言顺序。"""
def __init__(self, tag: bytes) -> None:
self.tag = tag
def build_request(self) -> bytes:
return b"REQ:" + self.tag
def parse_response(self, body: bytes) -> bytes:
return body
class FakeQuote:
"""最小报价替身:stamp() 会写 symbol,需要 market/code 是可 int/str 的真值。"""
def __init__(self) -> None:
self.market = 0
self.code = "000001"
self.symbol = ""
def frame(body: bytes) -> bytes:
"""构造一帧未压缩响应(zipsize == unzipsize)。"""
return struct.pack("<IIIHH", 7654321, 0, 0x053E, len(body), len(body)) + body
class FakeReader:
def __init__(self, data: bytes) -> None:
self.data = data
self.pos = 0
async def read(self, n: int) -> bytes:
chunk = self.data[self.pos:self.pos + n]
self.pos += len(chunk)
return chunk
class FakeWriter:
def __init__(self) -> None:
self.written = b""
self.closed = False
self.transport = FakeQuote()
def write(self, data: bytes) -> None:
self.written += data
async def drain(self) -> None:
pass
def is_closing(self) -> bool:
return self.closed
def close(self) -> None:
self.closed = True
async def wait_closed(self) -> None:
pass
def make_conn(payload: bytes, host: str = "1.2.3.4") -> TdxConnection:
conn = TdxConnection(host, 7709, 5.0)
conn._reader = FakeReader(payload) # type: ignore[assignment]
conn._writer = FakeWriter() # type: ignore[assignment]
return conn
# ---------- 基本语义 ----------
@pytest.mark.asyncio
async def test_empty_cmds_returns_empty():
conn = make_conn(b"")
assert await conn.execute_pipeline([]) == []
@pytest.mark.asyncio
async def test_responses_paired_in_order():
bodies = [b"AAA", b"BBB", b"CCC"]
conn = make_conn(b"".join(frame(b) for b in bodies))
cmds = [EchoCmd(t) for t in (b"1", b"2", b"3")]
got = await conn.execute_pipeline(cmds)
assert got == bodies # 顺序必须与 cmds 严格一致
@pytest.mark.asyncio
async def test_all_requests_sent_at_once():
conn = make_conn(b"".join(frame(b"X") for _ in range(3)))
cmds = [EchoCmd(t) for t in (b"a", b"b", b"c")]
await conn.execute_pipeline(cmds)
assert conn._writer.written == b"REQ:aREQ:bREQ:c"
@pytest.mark.asyncio
async def test_closed_connection_raises():
conn = make_conn(b"")
conn._writer = None
with pytest.raises(ConnectionError):
await conn.execute_pipeline([EchoCmd(b"1")])
# ---------- 失败语义:响应流错配后必须废连接 ----------
@pytest.mark.asyncio
async def test_truncated_stream_force_closes():
# 只给第一帧完整的、第二帧只有半个头 → 读不满,抛错且连接作废
conn = make_conn(frame(b"AAA") + b"\x00" * 5)
with pytest.raises(ConnectionError):
await conn.execute_pipeline([EchoCmd(b"1"), EchoCmd(b"2")])
assert conn._writer is None # _force_close 已清空 writer
@pytest.mark.asyncio
async def test_body_length_mismatch_propagates():
bad = struct.pack("<IIIHH", 7654321, 0, 0x053E, 99, 99) + b"short"
conn = make_conn(bad)
# 帧头自称 99 字节但流里没有 → _recv_exact 读空,连接作废
with pytest.raises(ConnectionError):
await conn.execute_pipeline([EchoCmd(b"1")])
assert conn._writer is None
# ---------- 池包装转发 ----------
@pytest.mark.asyncio
async def test_pooled_connection_forwards_pipeline():
inner = mock.AsyncMock()
inner.execute_pipeline = mock.AsyncMock(return_value=["r1", "r2"])
pc = PooledConnection(inner, "host1")
got = await pc.execute_pipeline([EchoCmd(b"1"), EchoCmd(b"2")])
assert got == ["r1", "r2"]
inner.execute_pipeline.assert_awaited_once()
# ---------- api 层:切批是否走流水线 ----------
def _api_with_fake_pool():
from pytdxdata.api import TdxData
from pytdxdata.symbols import CN, Symbol
td = TdxData.__new__(TdxData) # 跳过 __init__(不建网络池)
td._std_pool = FakeQuote()
td._std_pool.max_size = 24
td._std_pool.servers = [f"s{i}" for i in range(11)]
td._std_pool.acquire = mock.AsyncMock()
td._std_pool.release = mock.AsyncMock()
td._std_pool.warm = mock.AsyncMock() # 预建连接是网络动作,测试里空转
return td, Symbol, CN
@pytest.mark.asyncio
async def test_quotes_std_uses_pipeline_for_multi_page():
td, Symbol, CN = _api_with_fake_pool()
syms = [Symbol(0, f"{i:06d}", CN) for i in range(1, 401)] # 5 片
chunks = []
async def fake_pipeline(batch_group):
chunks.append(len(batch_group))
return [[FakeQuote()] * 80 for _ in batch_group]
td._execute_std_pipeline = fake_pipeline
out = await td._quotes_std(syms, pipeline=True)
assert len(out) == 5 * 80
assert sum(chunks) == 5 # 每片恰好被处理一次,不多不少
@pytest.mark.asyncio
async def test_quotes_std_single_page_skips_pipeline():
td, Symbol, CN = _api_with_fake_pool()
called = []
td._execute_std_pipeline = mock.AsyncMock(return_value=[])
async def fake_std(cmd):
called.append(1)
return []
td._execute_standard = fake_std
syms = [Symbol(0, f"{i:06d}", CN) for i in range(1, 51)] # 1 片
await td._quotes_std(syms, pipeline=True)
assert called == [1]
td._execute_std_pipeline.assert_not_awaited()
@pytest.mark.asyncio
async def test_quotes_std_no_pipeline_flag_uses_plain_path():
td, Symbol, CN = _api_with_fake_pool()
async def fake_std(cmd):
return [FakeQuote()] * 80
td._execute_standard = fake_std
td._execute_std_pipeline = mock.AsyncMock(return_value=[])
syms = [Symbol(0, f"{i:06d}", CN) for i in range(1, 401)]
out = await td._quotes_std(syms, pipeline=False)
assert len(out) == 5 * 80
td._execute_std_pipeline.assert_not_awaited()
@pytest.mark.asyncio
async def test_pipeline_failure_falls_back_to_per_page():
"""节点不支持流水线时,降级逐片,结果条数不变。"""
td, Symbol, CN = _api_with_fake_pool()
pool = td._std_pool
pool.acquire = mock.AsyncMock(return_value=mock.Mock(
execute_pipeline=mock.AsyncMock(side_effect=ConnectionError("boom"))))
pool.release = mock.AsyncMock()
calls = []
async def fake_std(cmd):
calls.append(1)
return [FakeQuote()] * 80
td._execute_standard = fake_std
syms = [Symbol(0, f"{i:06d}", CN) for i in range(1, 241)] # 3 片
out = await td._execute_std_pipeline(
[syms[i:i + 80] for i in range(0, len(syms), 80)])
assert len(out) == 3 and len(calls) == 3
assert pool.release.await_args.kwargs.get("broken") is True
+326 -4
View File
@@ -2,17 +2,21 @@
from __future__ import annotations from __future__ import annotations
import struct import struct
from collections import Counter
from datetime import date, datetime
import pytest import pytest
from pytdxdata.protocol.frame import FrameHeader, decompress_body, parse_header from pytdxdata.models import Adjust, KlinePeriod, SecurityBar
from pytdxdata.protocol.price import get_price, put_price, decode_ohlc_diffs
from pytdxdata.protocol.volume import decode_volume
from pytdxdata.protocol.commands.ex_proto import GetExInstrumentBarsCmd from pytdxdata.protocol.commands.ex_proto import GetExInstrumentBarsCmd
from pytdxdata.protocol.commands.kline import GetSecurityBarsCmd 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.minute import GetHistoryMinuteTimeDataCmd
from pytdxdata.protocol.commands.quotes import price_decimal_digits
from pytdxdata.protocol.commands.transaction import MacTransactionCmd 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
from pytdxdata.protocol.volume import decode_volume
# ---------- 变长有符号整数 ---------- # ---------- 变长有符号整数 ----------
@@ -176,3 +180,321 @@ def test_mac_transaction_parse():
assert recs[0].trade_count == 3 assert recs[0].trade_count == 3
assert recs[0].bs_flag == 1 assert recs[0].bs_flag == 1
assert recs[1].trade_count == 1 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("<H", body, 29, 2)
# 第1条:集合竞价,trade_count = -874
struct.pack_into("<IfIiH", body, 39, 33303, 9.74, 217, -874, 8)
# 第2条:正常交易,trade_count = 3
struct.pack_into("<IfIiH", body, 39 + 18, 34200, 9.75, 100, 3, 1)
cmd = MacTransactionCmd(1, "600000", 20261021, 0, 100)
recs = cmd.parse_response(bytes(body))
assert len(recs) == 2
assert recs[0].trade_count == -874, "负值必须保留符号,不能变成 4294966422"
assert recs[0].bs_flag == 8
assert recs[1].trade_count == 3
# 正常交易段的量级不受影响
assert max(r.trade_count for r in recs) == 3
def test_mac_transaction_etf_trade_count_unavailable():
"""ETF/LOF 的 trade_count 是「价格×1000」占位,必须标记为不可用。
实测(2026-10-22 sh510310 15:27:35):价 3.989、原字段 3994;
旧行为把它当笔数打印成「3994笔」,是假的。
"""
body = bytearray(39 + 2 * 18)
struct.pack_into("<H", body, 29, 2)
struct.pack_into("<IfIiH", body, 39, 56000, 3.989, 15, 3994, 5)
struct.pack_into("<IfIiH", body, 39 + 18, 56003, 3.989, 4, 3994, 5)
for code, market, expect in (("510310", 1, False), ("159915", 0, False),
("600000", 1, True), ("501050", 1, True)):
cmd = MacTransactionCmd(market, code, 20261022, 0, 100)
recs = cmd.parse_response(bytes(body))
assert recs[0].trade_count_available is expect, code
if expect:
assert recs[0].trade_count == 3994
else:
assert recs[0].trade_count == 0
@pytest.mark.parametrize("market,code,expect", [
# 股票 / 可转债 / 回购:有笔数
(1, "600000", True), (1, "688111", True), (1, "689009", True),
(0, "000001", True), (0, "300750", True), (0, "128136", True),
(1, "204001", True),
# 沪市 LOF 50x:实测有真实笔数,不能一刀切
(1, "501050", True), (1, "501018", True), (1, "502000", True), (1, "506000", True),
# 沪市 ETF/LOF 51/52/56/58:无笔数
(1, "510310", False), (1, "511990", False), (1, "512880", False),
(1, "513050", False), (1, "515000", False), (1, "518880", False),
(1, "560010", False), (1, "562500", False), (1, "588000", False),
# 深市基金:无笔数
(0, "159915", False), (0, "159001", False),
(0, "161725", False), (0, "160119", False), (0, "165520", False),
# 指数:无笔数
(1, "000001", False), (0, "399001", False), (1, "880305", False),
])
def test_has_order_count(market, code, expect):
from pytdxdata.symbols import has_order_count
assert has_order_count(market, code) is expect
# ---------- 跨时区时间戳归一化(美股 EX 通道) ----------
#
# 通达信 EX 通道对美股返回的时间戳把两个时区拼在一起:日期字段是**美东交易日**、
# 时分字段是**北京时间**。直拼出的 datetime 会把同一交易日的下午半场(北京
# 00:00~04:00)排到上午半场(北京 21:30~23:59)之前,单日 390 根全部错位。
def _bar(market: int, y: int, mo: int, d: int, h: int, mi: int) -> SecurityBar:
return SecurityBar(market=market, code="X", open=1.0, high=1.0, low=1.0,
close=1.0, vol=1.0, amount=1.0,
year=y, month=mo, day=d, hour=h, minute=mi)
def test_us_evening_segment_keeps_date():
# 北京 21:31 ~ 23:59 与美东交易日属同一自然日,日期不动
b = _bar(74, 2026, 10, 12, 21, 31)
assert b.datetime == datetime(2026, 10, 12, 21, 31)
assert b.trading_date == "2026-10-12"
def test_us_midnight_segment_rolls_to_next_day():
# 北京次日 00:00 ~ 04:00 实际是美东 12:00~16:00,日期要 +1 天
b = _bar(74, 2026, 10, 12, 4, 0)
assert b.datetime == datetime(2026, 10, 13, 4, 0)
assert (b.hour, b.minute) == (4, 0) # 时分不参与归一化
assert b.trading_date == "2026-10-12" # 仍归属美东 10-12 交易日
def test_us_split_hour_boundary():
assert _bar(74, 2026, 10, 12, 11, 59).day == 13
assert _bar(74, 2026, 10, 12, 12, 0).day == 12
def test_us_month_and_year_rollover():
assert _bar(74, 2026, 10, 31, 4, 0).datetime == datetime(2026, 11, 1, 4, 0)
assert _bar(74, 2026, 12, 31, 4, 0).datetime == datetime(2027, 1, 1, 4, 0)
def test_cn_and_hk_bars_untouched():
cn = _bar(1, 2026, 10, 12, 9, 31) # A股/标准通道
assert (cn.year, cn.month, cn.day) == (2026, 10, 12)
assert cn.trading_date == "2026-10-12"
hk = _bar(31, 2026, 10, 12, 4, 0) # 港股同为 UTC+8,凌晨段不应 +1
assert (hk.year, hk.month, hk.day) == (2026, 10, 12)
assert hk.trading_date == "2026-10-12"
def test_us_full_session_is_monotonic_and_single_trading_day():
# 实测口径:北京 21:31~23:59(149 根)+ 次日 00:00~04:00(241 根)= 390 根
mins = list(range(21 * 60 + 31, 24 * 60)) + list(range(4 * 60 + 1))
assert len(mins) == 390
bars = [_bar(74, 2026, 10, 12, m // 60, m % 60) for m in mins]
bars.sort(key=lambda b: b.datetime)
dts = [b.datetime for b in bars]
assert dts == sorted(dts) # 归一化后严格单调
assert dts[0] == datetime(2026, 10, 12, 21, 31)
assert dts[-1] == datetime(2026, 10, 13, 4, 0)
# 全部归属于同一个美东交易日
assert {b.trading_date for b in bars} == {"2026-10-12"}
# 但横跨两个北京自然日(这正是不能用 datetime.date() 聚合的原因)
by_day = Counter(b.datetime.date() for b in bars)
assert by_day[date(2026, 10, 12)] == 149
assert by_day[date(2026, 10, 13)] == 241
# ---------- MAC 通道 K线(0x122E)同样归一化 ----------
def _mac_bars_body(records: list[tuple[int, int]]) -> bytes:
"""构造 0x122E 响应体:33B头(count@24) + 每条36B(4B ymd + 4B time秒 + 7float)。"""
body = bytearray(33 + len(records) * 36)
struct.pack_into("<HBHI", body, 24, 7, 1, len(records), 0)
for i, (ymd, tsec) in enumerate(records):
struct.pack_into("<II7f", body, 33 + i * 36,
ymd, tsec, 10.0, 10.5, 9.5, 10.2, 0.0, 1000.0, 0.0)
return bytes(body)
def test_mac_kline_us_bar_normalized():
# _probe_bar(日期区间二分依赖它)对美股走的就是这条命令
cmd = MacKlineCmd(74, "AAPL", KlinePeriod.MIN_1, Adjust.NONE, 0, 5)
bars = cmd.parse_response(_mac_bars_body([(20261012, 4 * 3600)])) # 北京 04:00
assert len(bars) == 1
assert bars[0].datetime == datetime(2026, 10, 13, 4, 0)
assert bars[0].trading_date == "2026-10-12"
def test_mac_kline_hk_bar_untouched():
cmd = MacKlineCmd(31, "00700", KlinePeriod.MIN_1, Adjust.NONE, 0, 5)
bars = cmd.parse_response(_mac_bars_body([(20260729, 13 * 3600 + 40 * 60)]))
assert (bars[0].datetime) == datetime(2026, 7, 29, 13, 40)
assert bars[0].trading_date == "2026-07-29"
# ---------- 排序:EX 返回顺序按时间正序(切片取「最新 N 根」依赖它) ----------
def test_finish_bars_sorts_us_session_chronologically():
from pytdxdata.api import TdxData
from pytdxdata.symbols import parse_symbols
sym = parse_symbols("usAAPL")[0]
# 故意按错误的顺序给(凌晨段在前)
out = TdxData._finish_bars([_bar(74, 2026, 10, 12, 4, 0),
_bar(74, 2026, 10, 12, 21, 31)], sym)
assert [b.datetime for b in out] == [datetime(2026, 10, 12, 21, 31),
datetime(2026, 10, 13, 4, 0)]
assert {b.symbol for b in out} == {"usAAPL"}
# ---------- 报价小数位:沪市指数必须 2 位(回归:曾整体少 10 倍) ----------
@pytest.mark.parametrize("market,code,expect", [
# 沪市指数:回归 bug —— 曾被判 3 位,导致价格少 10 倍
(1, "000001", 2), # 上证指数
(1, "000016", 2), # 上证50
(1, "000300", 2), # 沪深300
(1, "000688", 2), # 科创50
(1, "880001", 2), # 板块指数(8 开头,曾被判 3 位)
(1, "880305", 2),
# 沪市 ETF/基金:仍是 3 位
(1, "510300", 3),
(1, "588000", 3),
(1, "511010", 3),
(1, "501018", 3),
# 沪市股票:2 位
(1, "600000", 2),
(1, "601398", 2),
(1, "688111", 2), # 科创板
# 深市
(0, "399001", 2), # 深证成指
(0, "399006", 2), # 创业板指
(0, "000001", 2), # 平安银行(不是指数!)
(0, "300750", 2),
(0, "159915", 3), # 深市 ETF
# 债券/回购:2026-10-22 修正(沪市曾少 100 倍、深市曾少 10 倍)
(1, "019742", 4), # 沪市国债 24特国01(110.228,曾读成 11022.8)
(1, "019547", 4), # 沪市国债
(1, "010706", 4), # 沪市老国债 07国债06
(1, "018014", 4), # 沪市 018 段
(1, "020812", 4), # 沪市贴债
(1, "110077", 4), # 沪市可转债 洪城转债(199.279,曾读成 19927.9)
(1, "113616", 4), # 沪市可转债 韦尔转债
(1, "118031", 4), # 沪市可转债
(1, "111000", 4), # 沪市 111 段
(1, "132024", 4), # 沪市可交换债
(1, "184832", 4), # 沪市 184 段
(1, "204001", 4), # 沪市国债逆回购 GC001(1.385,曾读成 138.5)
(1, "204028", 4),
(0, "123107", 4), # 深市可转债 温氏转债(112.189,曾读成 1121.89)
(0, "128136", 4), # 深市可转债 立讯转债
(0, "127025", 4), # 深市可转债
(0, "131810", 4), # 深市国债逆回购 R-001(1.38,曾读成 13.8)
(0, "148004", 4), # 深市 148 段
(0, "112001", 4), # 深市公司债
(0, "101917", 4), # 深市国债
(0, "520261", 4), # 深市 520 段
# 沪市 B 股:3 位(2026-10-22 修正,曾按 2 位少 10 倍)
(1, "900901", 3), # 云赛B股
(1, "900948", 3),
# 深市 B 股:2 位(与沪市不同!)
(0, "200011", 2), # 深物业B
(0, "200488", 2),
# 边界:999xxx 是「指数」,不能被 9 开头当成 B 股
(1, "999999", 2), # 上证指数
(1, "999998", 2), # A股指数
])
def test_price_decimal_digits(market, code, expect):
assert price_decimal_digits(market, code) == expect
def test_price_decimal_digits_strips_nul():
assert price_decimal_digits(1, "000016\x00\x00") == 2
# ---------- 美股分时跨日:hour 必须是合法时钟值(回归:曾出现 hour=27) ----------
def _us_minutes(n: int = 390) -> list:
"""构造 usAAPL 的 390 条分时:从北京 21:30 起连续 n 分钟。"""
from pytdxdata.models import MinuteBar
start = 21 * 60 + 30
return [
MinuteBar(price=100.0 + i * 0.01, vol=1.0,
hour=(start + i) // 60, minute=(start + i) % 60,
market=74, code="AAPL", date=20261022)
for i in range(n)
]
def test_minute_bar_us_hour_is_valid_clock_value():
"""EX 分时的 minutes 是「自开盘起的连续分钟数」,直接 //60 会得到 hour=27。"""
bars = _us_minutes()
assert all(0 <= b.hour < 24 for b in bars)
# 归一化前的原始值确实越界(21:30 + 390min = 28:00)
assert max(b.hour + b.day_offset * 24 for b in bars) > 23
def test_minute_bar_us_day_offset_marks_next_day():
bars = _us_minutes()
assert bars[0].day_offset == 0 # 21:30 当晚
assert bars[-1].day_offset == 1 # 03:59 次日
assert (bars[-1].hour, bars[-1].minute) == (3, 59)
def test_minute_bar_us_datetime_is_monotonic_across_midnight():
bars = _us_minutes()
dts = [b.datetime for b in bars]
assert dts == sorted(dts)
assert dts[0] == datetime(2026, 10, 22, 21, 30)
assert dts[-1] == datetime(2026, 10, 23, 3, 59)
def test_minute_bar_us_trading_date_spans_two_calendar_days():
"""一个美股交易日的分时横跨两个北京自然日,trading_date 必须都是同一天。"""
bars = _us_minutes()
tds = {b.trading_date for b in bars}
assert tds == {"2026-10-22"}
# 而 datetime.date() 会给出两天 —— 这正是不能用它的原因
assert len({b.datetime.date() for b in bars}) == 2
def test_minute_bar_cn_unchanged():
"""A股/港股分时 hour 本就合法,归一化必须零行为变化。"""
from pytdxdata.models import MinuteBar
for hour, minute in ((9, 30), (11, 29), (13, 0), (14, 59)):
b = MinuteBar(price=10.0, vol=1.0, hour=hour, minute=minute,
market=1, code="600000", date=20261022)
assert (b.hour, b.minute) == (hour, minute)
assert b.day_offset == 0
assert b.datetime == datetime(2026, 10, 22, hour, minute)
assert b.trading_date == "2026-10-22"
def test_minute_bar_cn_datetime_monotonic_full_session():
"""A股全天 240 条(09:30~11:29 + 13:00~14:59)时间轴严格递增。"""
from pytdxdata.models import MinuteBar
bars = []
for idx in range(240):
if idx < 120:
hour, minute = 9 + (30 + idx) // 60, (30 + idx) % 60
else:
hour, minute = 13 + (idx - 120) // 60, (idx - 120) % 60
bars.append(MinuteBar(price=10.0, vol=1.0, hour=hour, minute=minute,
market=1, code="600000", date=20261022))
dts = [b.datetime for b in bars]
assert dts == sorted(dts)
assert dts[0] == datetime(2026, 10, 22, 9, 30)
assert dts[-1] == datetime(2026, 10, 22, 14, 59)
assert {b.trading_date for b in bars} == {"2026-10-22"}
+91
View File
@@ -0,0 +1,91 @@
"""证券清单(0x053E)回归测试:请求长度 + 北交所降级。全部离线。
背景(2026-10-23 实测):`build_request` 曾经多塞一个 ``H``(18 字节),
服务端只消费前 16 字节,剩下的 ``00 00`` 留在它的接收缓冲里,把**下一个请求**
的开头吃掉 → 同一连接「第一次成功、第二次起全部通信超时」。
`get_universe` 的分页器复用连接,于是 66/28 页全靠失败重连,冷启动 12~18s。
"""
from __future__ import annotations
import struct
import unittest.mock as mock
import pytest
from pytdxdata.models import Market
from pytdxdata.protocol.commands import GetSecurityListCmd
_HEADER = bytes.fromhex("0c0118640101060006005004")
def test_request_is_exactly_16_bytes():
"""12 字节命令头 + market(H) + start(H),一个字节都不能多。"""
req = GetSecurityListCmd(1, 0).build_request()
assert len(req) == 16
assert req == _HEADER + struct.pack("<HH", 1, 0)
def test_request_encodes_market_and_start_little_endian():
req = GetSecurityListCmd(0, 2000).build_request()
assert req[:12] == _HEADER
market, start = struct.unpack("<HH", req[12:])
assert (market, start) == (0, 2000)
def test_request_has_no_trailing_padding():
"""尾部不能有 padding:多余的 0 会让服务端解析错位。"""
for market in (0, 1, 2):
for start in (0, 1000, 27000):
req = GetSecurityListCmd(market, start).build_request()
assert len(req) == 16, f"market={market} start={start} -> {len(req)} 字节"
def test_parse_response_reads_all_records():
"""29 字节/条,头部 2 字节条数。"""
code, name = b"600000", "浦发银行".encode("gbk").ljust(8, b"\x00")
rec = struct.pack("<6sH8s4sBI4s", code, 100, name, b"\x00" * 4, 2, 0, b"\x00" * 4)
assert len(rec) == 29
body = struct.pack("<H", 2) + rec + rec
rows = GetSecurityListCmd(1, 0).parse_response(body)
assert len(rows) == 2
assert rows[0].code == "600000"
assert rows[0].decimal_point == 2
@pytest.mark.asyncio
async def test_bj_universe_returns_empty_without_network():
"""北交所清单协议不支持:必须立刻返回空,且**不碰连接池**。"""
from pytdxdata.api import TdxData
td = TdxData()
td._std_pool.acquire = mock.AsyncMock(side_effect=AssertionError("不该联网"))
td._std_pool.acquire_many = mock.AsyncMock(
side_effect=AssertionError("不该联网"))
rows = await td.get_universe("bj")
assert rows == []
td._std_pool.acquire.assert_not_called()
td._std_pool.acquire_many.assert_not_called()
@pytest.mark.asyncio
async def test_bj_market_is_in_unsupported_set():
from pytdxdata import api as api_mod
assert int(Market.BJ) in api_mod._LIST_UNSUPPORTED_MARKETS
@pytest.mark.asyncio
async def test_ex_all_fetched_once_in_get_universe():
"""`get_universe()` 跨多个 EX 市场时,EX 全量只能取一次。"""
from pytdxdata.api import TdxData
td = TdxData()
calls = {"n": 0}
async def fake_ex_all():
calls["n"] += 1
return []
td._ex_all = fake_ex_all
await td.get_universe("all")
assert calls["n"] == 1, f"_ex_all 被调用 {calls['n']} 次(应为 1)"
Generated
+1 -1
View File
@@ -535,7 +535,7 @@ wheels = [
[[package]] [[package]]
name = "pytdxdata" name = "pytdxdata"
version = "0.6.1" version = "0.6.9"
source = { editable = "." } source = { editable = "." }
[package.optional-dependencies] [package.optional-dependencies]