9 Commits
Author SHA1 Message Date
openbot-coder 8951ec2678 fix(api,codec): 修复 BUG-1 分时采样走错命令 + BUG-2 财务文件名纠正
BUG-1: A股 get_minutes(sampling=True) 原走 MacChartSamplingCmd(0x254D)
这是 EX 协议命令,7709 主机无响应(3×8s 超时≈24s)。
修复:A股采样由 MacTickChartCmd(0x122D) 分时数据派生,
EX 市场(hk)仍走 0x254D。4 个 A股 场景均<0.1s 返回 240 点。

BUG-2: tdxfin/gpcw.txt 索引声明 gpcwYYYYMMDD.zip,
但服务器实际只有 tdxfin/gpcwYYYYMMDD.dat(未压缩,~13MB),
.zip 请求返回 0-1 字节空壳。
修复:_fetch_financial_dat() 自动候选回退
tdxfin/*.zip → tdxfin/*.dat → 原始文件名,加 looks_like_gpcw_dat 校验。
实测 gpcw20260630.zip→5568 条,gpcw20260331.zip→5547 条。

新增 codec/financial.py: looks_like_gpcw_dat, extract_gpcw_dat(含 zip/未压缩双通道)。
同步更新 README/API_REFERENCE/docs/cli/cookbook/CHANGELOG 共 6 处文档。
tests: +18(总 182),ruff 无新增 findings,MkDocs strict 通过。
2026-09-21 20:47:48 +08:00
openbot-coder b78d0fabf5 docs: 修正 servers.json 清理后遗留的过时描述(含一处事实反转)
servers.json 复测后三池台数已变(standard 9 / mac 22 / ex 4),但 README 与部分文档
仍停留在旧口径,且有一处因果结论被实测推翻:

- README.md
  - 测试用例数 127 → 164(并补「当日测速缓存」到用例分组说明)
  - 「已知限制」补测速缓存详情的文档站链接
- docs/internals/routing.md
  - 三池台数:标准池「数十台」→ 9 台、MAC 池「数台」→ 22 台(EX 池 4 台不变),
    并标注为 2026-09-21 离线探针实测可达数、实际以当日测速缓存为准
  - **事实反转修正**:原文「MAC 池远小于标准池,这解释了逐笔/分时并发弱于日线」
    与实测不符(mac 22 > standard 9)→ 已改为陈述实测台数,
    并指出两通道单台连接上限默认相同(均 4)
- docs/internals/cache-pool.md
  - 「为什么 MAC 池更小」小节前提已不成立 → 改为「MAC 通道的单台连接上限」,
    保留 mac_pool_cap=4 的可用信息,删除错误因果
- docs/refactor-audit.md
  - 历史快照的 127 passed 标注「审查当时」,避免误读为当前基线

验证:scripts/check_docs.py exit 0;mkdocs build --strict exit 0(无告警)
2026-09-21 19:42:06 +08:00
openbot-coder d422385877 chore(servers): 离线探针复测重写 servers.json,并给探针工具补 --discover
servers.json(真数据复测 2026-09-21,两轮零漂移)
- 剔除历史脏记录 s1;刷新 status/latency/checked_at/checked_date/fast_pool
- 可达 25/33:standard 9 台、mac 22 台、ex 4 台(旧文件 mac 只标了 10 台)
- 关键发现:14 台服务器 0x010C 标准 K 线已成空响应(回 2 字节空壳),
  但同端口同主机的 0x122E MAC 帧正常 → 据实测把 protocols 由 standard/mac 收窄为 mac
- 8 台不可达:华林 4 台(218.106.92.182/183, 220.178.55.71/86)、159.75.55.232、
  117.34.114.13/14/30 → status=fail
- 117.34.114.17 实测 standard+mac 均通(此前只申报 standard)

server_probe.py
- 新增 --discover:三种协议全测并据实修正 protocols(顺带剔除 ip 非法记录)
- 失败重试一次再判定不支持(单次抖动会误删协议,且收窄后不会自动恢复)
- EX 握手模式申报错时换另一种再试(login <=> setup)
- 补写 checked_date / fast_pool / 顶层 version·note,入池规则与运行时缓存一致

验证:164 passed;servers.json 跑测前后 sha 不变;check_docs.py + mkdocs --strict 通过
2026-09-21 19:05:32 +08:00
openbot-coder 7e830c7579 docs: 补齐测速缓存相关文档,并修掉 0.6.0 遗留的过时描述
上一提交只补了 getting-started / routing / llms.txt / SKILL.md 四处,本轮把其余
教程类页面与接口清单补齐,并顺手修正 v0.6.0 统一接口改造后遗留的过时说明。

补齐(当日测速缓存):

- README「已知限制」:说明当日首次启动会自动后台测速并缓存
- FAQ 新增「启动时会变慢吗?会不会在后台偷偷联网?」:无感保证 + 三个环境变量开关
- FAQ「连不上服务器怎么办」:加入"删当日测速缓存 / 环境变量指定主机"两条前置排查
- API_REFERENCE 四、辅助模块:config 补全当日测速相关函数与优先级链说明,
  新增 pytdxdata.pool.probe_cache 一节(ProbeCache / schedule_probe / get_probe_cache)
- internals/architecture.md 目录树:config.py、probe_cache.py 的职责注释更新
- internals/cache-pool.md「下一步」:补「服务器是怎么选出来的」交叉链接

修正(v0.6.0 遗留过时描述):

- FAQ / api/enums.md:删掉「所有接口的第一个参数都是 market」——统一接口已改为字符串标的
- FAQ / cookbook:`*_batch` 已并入 `get_bars`(多标的),不再作为批量入口
- FAQ / getting-started「自建服务器清单」:`standard_servers` 实际是 Sequence[str]
  而非 (host, port) 元组(端口由统一的 port= 指定);原示例照抄会取到错的主机名
  (已实测:字符串写法正确,元组写法不会被解析)

校验:check_docs.py exit 0;mkdocs build --strict 无告警;新增交叉链接
#当日自动测速无感 / #daily-probe 均正确渲染且目标锚点存在;全量 164 项通过;
src/pytdxdata/servers.json 跑测前后逐字节不变。
2026-09-21 18:26:37 +08:00
openbot-coder c7c6c70333 chore(release): 版本号升至 0.6.1
在 v0.6.0 基线上发布当日测速缓存重写(见上一提交)。

版本号四处对齐:pyproject.toml / src/pytdxdata/__init__.py / uv.lock / CHANGELOG.md。
uv lock --check 通过(lockfile 与 pyproject 一致)。

同时修正 0.6.0 全接口回归测试与本次改动的集成冲突:
tests/test_all_interfaces.py 的 td fixture 原先替身 pool.pool.get_probe_cache,
而本次已把池内探针入口改为 pool.pool.schedule_probe,导致 fixture setup 抛
AttributeError(17 个用例 ERROR + 1 个 FAILED)。改为替身 schedule_probe 并返回 None
(与"无事件循环时不排期"的真实语义一致),单测既不再因属性缺失报错,也不会真的发起后台测速。

全量 164 项通过;mkdocs build --strict 通过;src/pytdxdata/servers.json 跑测前后逐字节不变。
2026-09-21 18:05:11 +08:00
openbot-coder 18d9e9a006 fix(pool): 重写当日测速缓存:全量候选 + 用户级缓存 + 真实数据探针
原实现在 v0.5.0 已随包发布,但有三处会"静默失效"的缺陷,等于没真正生效:

- 候选集自指:连接池把自己已过滤后的成员当探针输入,实测只重测了 9 台,
  另外 20+ 台候选(含快节点)永远测不到。改为由 probe_cache 自行枚举
  全量候选(包内清单 ∪ 代码常量 ∪ env),不再接受调用方传入的"当前池成员"。
- 写回安装目录:结果写回 src/pytdxdata/servers.json,容器/系统级安装下只读会
  静默失败、多用户共用一个安装会互相覆盖,且污染随包分发的数据。改为写入
  用户级缓存目录(Win %LOCALAPPDATA% / macOS ~/Library/Caches / Linux $XDG_CACHE_HOME),
  运行时绝不再改写包内清单。
- 探测太弱:只做握手,测不出「握手正常但 K 线空响应」的坏节点。改为发真实业务
  命令并要求返回非空(标准 GetSecurityBarsCmd / MAC MacKlineCmd / EX GetExInstrumentBarsCmd),
  EX 池(4 台,7727)也一并纳入。

无感保证:后台 task 不阻塞 start()、日志全 debug 级、绝不抛异常(取消除外)、
原子写 tmp + os.replace、进程内单例 + asyncio.Lock 单飞;全不可达时不写缓存
(否则"今天全挂"会被缓存一整天)。close() 会取消并 await 后台探针,
避免解释器退出时报 "Task was destroyed but it is pending"。

新增环境变量 PYPYTDX_DATA_CACHE_DIR(覆盖缓存目录)、
PYPYTDX_DATA_DISABLE_PROBE=1(关闭测速)。新增 tests/test_probe_cache.py(37 项)。
2026-09-21 17:54:29 +08:00
openbot-coder 3e0beb27a6 release: v0.6.0(统一对外接口重构)
按「数据类型」合并同类查询接口:一个数据类型 = 一个方法,跨市场自动选路。

- 28 个统一接口(get_universe/get_quotes/get_bars/get_indicators/get_ticks/
  get_minutes/get_f10/get_file/get_boards/get_board_of/get_snapshot 等),
  标的统一字符串写法(sz000001 / hk00700 / usAAPL / cffex:IFL0);
  同名旧方法不再兼容 (market, code) 元组。
- 旧 51 个按通道/市场分裂的接口:33 个保留为 deprecated 别名(1.0 移除),
  18 个同名升级为统一接口。公开方法共 63 个。
- 新增库层标的解析 pytdxdata.symbols;数据模型追加 symbol/name/fields 兜底字段。
- 修复:分页器连接泄漏、日期区间 K线返回 0 条(偏移方向探测)、池子全冷却死等。
- 文档/README/SKILL/llms.txt 全量同步;新增 docs/refactor-audit.md 审查报告。
- 测试 127 个用例全绿(含 tests/test_all_interfaces.py 全 63 方法回归)。
2026-09-17 11:34:52 +08:00
openbot-coder 1bee6b0fc7 release: v0.5.0(文档站 + README 瘦身 + AI 助手技能)
新增
- 文档站(MkDocs + Material + mkdocstrings),push main 自动构建并部署 GitHub Pages
- SKILL.md:面向 AI 编程助手的技能文件(三条必守约定 / 枚举取值表 / 任务→方法决策表 / 9 条陷阱)
- docs/ai.md:文档站的「AI 助手接入」页
- tests/test_check_docs.py(10 项):漂移检查器自身的自测

变更
- README 361 → 125 行,只保留入口层;CLI 手册 / API 表 / 通道路由 / 架构树 /
  扩展市场 / easy-tdx 对比 / Changelog 全部移交文档站与 CHANGELOG.md
- README 相对链接改为绝对 URL(PyPI 渲染不重写相对链接,原本在 PyPI 页面全 404)
- check_docs.py 扩展为两档:MUST_LIST_ALL(须列全)+ MUST_NOT_BE_STALE(只需无过时引用),
  并把 SKILL.md / README / llms.txt / 教程类页面纳入;白名单放行 config 的模块级函数
- 版本号 0.4.0 → 0.5.0;包元数据 Documentation 指向文档站
- uv.lock 同步

修复
- ExMarket 成员数 52 → 46(实测 IntEnum 成员数),4 处文档同步更正
- docs/ai.md 的 3 处相对链接 + CHANGELOG 的 SKILL.md 链接(会导致 mkdocs --strict 失败)
- README 标注的测试数量 85 → 109(pytest 实际收集用例数)
2026-09-15 14:55:07 +08:00
openbot-coder c4dd61665b docs: 建立 MkDocs 文档站与 AI 层文档
- 新增 MkDocs + Material 文档站(19 页):入门、CLI、场景示例、FAQ、
  Contributing、Changelog、API 参考(mkdocstrings 自动渲染)、内部原理
  (架构 / 协议 / 三池路由 / 缓存)
- 新增 docs/llms.txt:面向 LLM 的结构化摘要(枚举取值、方法速查、常见陷阱)
- 新增 scripts/check_docs.py:校验文档与 api.py 公开方法清单是否漂移
- 新增根 CHANGELOG.md 作为版本记录唯一来源,docs/changelog.md 用 snippet 引入
- 新增 .github/workflows/docs.yml:push main 自动构建并部署 GitHub Pages
- 修正文档口径:TdxData 公开方法 53 个(51 数据方法 + start/close);
  API_REFERENCE 版本号 v0.3.2 -> v0.4.0
- pyproject.toml 新增 docs 依赖组;.gitignore 忽略 site/
2026-09-15 13:57:31 +08:00
48 changed files with 7736 additions and 1692 deletions

No files matched your search

+69
View File
@@ -0,0 +1,69 @@
name: Docs
# push main 时构建文档站并部署到 GitHub Pages
# 首次启用需在仓库 Settings → Pages 里把 Source 设为 "GitHub Actions"
on:
push:
branches:
- main
paths:
- "docs/**"
- "mkdocs.yml"
- "CHANGELOG.md"
- "README.md"
- "src/pytdxdata/**"
- ".github/workflows/docs.yml"
workflow_dispatch:
permissions:
contents: read
concurrency:
group: pages
cancel-in-progress: false
jobs:
build:
name: Build site
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v7
- name: Install uv
uses: astral-sh/setup-uv@v10.1.0
with:
python-version: "3.13"
- name: Install docs dependencies
run: uv sync --locked --group docs
- name: Check documentation drift
run: uv run python scripts/check_docs.py
- name: Build site (strict)
run: uv run mkdocs build --strict
- name: Configure Pages
uses: actions/configure-pages@v6
- name: Upload site artifact
uses: actions/upload-pages-artifact@v4
with:
path: site
deploy:
name: Deploy to Pages
needs: build
runs-on: ubuntu-latest
permissions:
pages: write
id-token: write
environment:
name: github-pages
url: ${{ steps.deployment.outputs.page_url }}
steps:
- name: Deploy
id: deployment
uses: actions/deploy-pages@v5
+3
View File
@@ -28,3 +28,6 @@ examples/uvbuild_src/
# 仓库备份
_git_backup_*.bundle
# MkDocs 构建产物
site/
+225
View File
@@ -0,0 +1,225 @@
# 更新日志
本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
## [0.6.1] - 2026-09-21
### 变更
- **重写「当日首次启动测速缓存」,改为对用户完全无感**。原实现在 v0.5.0 已随包发布,但存在
三个会让它**静默失效**的缺陷,本次一并修正:
| 缺陷 | 原实现 | 现在 |
|---|---|---|
| 候选集自指 | 连接池只把自己**已过滤后的成员**交给探针 → 只重测了 9 台,另外 20+ 台候选(含快节点)永远测不到 | 探针内部取**全部候选**(包内清单 ∪ 代码常量 ∪ env) |
| 写回安装目录 | 结果写回 `src/pytdxdata/servers.json` → 容器 / 系统级安装只读、多用户互相覆盖 | 改写入**用户级缓存目录**,包内清单运行时**绝不被改写** |
| 探测太弱 | 只做握手(`TdxConnection.test`),测不出「握手正常但 K 线空响应」的坏节点 | 发**真实业务命令**并要求返回非空(标准 / MAC / EX 各一) |
| EX 池漏测 | EX 的 4 台从未被探测 | EX 一并纳入(7727 + 各自握手模式) |
- 测速结果按**实测延迟升序**被 `config.get_standard_hosts()` 等采用;当天已有缓存则**不再刷新**。
后台执行,不阻塞 `start()`、不打印、失败静默降级。
- 本版基于 **0.6.0 的统一对外接口**构建(`get_bars` + 字符串标的);同时把 0.6.0
全接口回归测试里对旧探针入口(`pool.get_probe_cache`)的替身改为新入口(`pool.schedule_probe`),
保证单测不触发真实网络测速。
### 修复
- **A股分时缩略采样 100% 失败**(`get_minutes(sampling=True)` / `get_chart_sampling()`):
旧实现走 `MacChartSamplingCmd`(**0x254D**),但该 opcode 属于 **EX 协议**,7709 标准 /
MAC 主机对它一律不响应——实测 3 台主机各 10s 超时,叠加连接池 3 次重试约 24s 才抛错。
现改为**由分时(0x122D)数据派生**价格点(分时本身就是 240 点,语义一致),
实测 4 个 A股 场景均在 0.1s 内返回 240 点;EX 通道仍用 0x254D(84 点)。
- **历史专业财报整条链路不可用**(`get_financial_records_parsed()`):
`tdxfin/gpcw.txt` 索引里写的是裸 `gpcwYYYYMMDD.zip`,而服务器**实际只提供未压缩的**
`tdxfin/gpcwYYYYMMDD.dat`。旧实现把索引名直接丢给 `zipfile` → 必然 `BadZipFile`;
废弃别名 `get_financial_records()` 更危险,会**静默返回 0~1 字节空壳**而不报错。
现按候选名(`tdxfin/*.zip` → `tdxfin/*.dat` → 原名)逐个尝试并校验数据形态,
zip 与未压缩 dat 都支持。实测 `gpcw20260630.zip` → **5568 条**、
`gpcw20260331.zip` → **5547 条**(样本 000001,584 个 float 字段),
别名返回 **13,068,116 字节**真实数据;尚未生成的占位条目
(如 `gpcw20260930.zip`,filesize=164)优雅返回空列表而非报错。
### 新增
- `codec.financial` 新增 `looks_like_gpcw_dat()` / `extract_gpcw_dat()`:
财报字节的形态判定与「zip / 未压缩 dat」统一提取(纯标准库,可脱网单测)
- 环境变量 `PYPYTDX_DATA_CACHE_DIR`(覆盖测速缓存目录)、
`PYPYTDX_DATA_DISABLE_PROBE`(关闭测速,CI / 测试用)
- `tests/test_probe_cache.py`(37 项):当日缓存不刷新、跨日重测、
原子写入且不留 tmp、**不改写包内 `servers.json`(逐字节校验)**、
单飞并发、非法主机过滤、`DISABLE_PROBE`、池 `start()` 不阻塞 / `close()` 取消后台探针
### 文档
- [安装与配置](https://openbot-coder.github.io/pytdxdata/getting-started/#当日自动测速无感):
新增「当日自动测速(无感)」小节——缓存路径、优先级链、环境变量一览
- [通道与数据源](https://openbot-coder.github.io/pytdxdata/internals/routing/#daily-probe):
新增「运行时:当日测速缓存」小节,逐条说明必须踩对的实现要点与反例
## [0.6.0] - 2026-09-16
### 新增
- **统一对外接口**:一个数据类型 = 一个方法,跨市场自动选路。
标的统用字符串写法(`sz000001` / `hk00700` / `usAAPL` / `cffex:IFL0`),
A股/港股/美股/期货/期权混合查询一次返回。旧的 51 个按通道/市场分裂的接口中,
33 个保留为 deprecated 别名(运行时发出 `DeprecationWarning`,**1.0 移除**),
另 18 个(`get_quotes` / `get_xdxr` / `get_finance` / `get_auction` / `get_capital_flow` /
`get_market_stat` / `get_unusual` / `get_server_info` / `get_kline_offset` /
`get_board_members` / `get_board_summary` / `get_board_ranking` / `get_board_change_ranking` /
`get_block_parsed` / `get_industry_map` / `get_financial_file_infos` /
`get_financial_records_parsed` / `get_price_limits`)同名升级为统一接口。
| 数据类型 | 新接口 | 合并掉的旧接口 |
|----------|--------|----------------|
| 标的清单 | `get_universe(market)` | get_security_count + get_security_list + get_security_list_all + get_goods_count + get_goods_list |
| 报价 | `get_quotes(symbols, *, fields)` | get_quotes + get_stock_quotes + get_goods_quotes + get_goods_quotes_list |
| K线 | `get_bars(symbols, period, ...)` | get_kline + get_index_kline + get_kline_batch + get_kline_since |
| 指标 | `get_indicators(symbols, indicators, ...)` | get_stock_kline_with_indicators |
| 逐笔 | `get_ticks(symbols, *, date)` | get_transactions + get_goods_transaction + get_goods_transaction_all |
| 分时 | `get_minutes(symbols, *, date, sampling)` | get_minute + get_minute_batch + get_chart_sampling + get_goods_chart_sampling + get_goods_tick_chart |
| F10 | `get_f10(symbol, section)` | get_company_info_category + get_company_info_content |
| 文件 | `get_file(name)` | get_block_info + get_report_file + get_file_meta + download_file |
| 财务文件 | `get_financial_file_infos()` / `get_financial_records_parsed(fn)` | get_financial_file_list + get_financial_records |
| 板块列表 | `get_boards(kind)` | get_board_list |
| 板块成员 | `get_board_members(board)` → 归一 `SecurityQuote` | get_board_members + get_stock_quotes_list(分类报价) |
| 个股板块 | `get_board_of(symbols)` | get_belong_board |
| 快照 | `get_snapshot(symbols)` | get_symbol_info |
> `TdxData` 公开方法 63 个 = **28 个统一接口** + 33 个 deprecated 别名 + `start`/`close`。
> 统一接口一律只接受字符串标的;同名旧方法不再兼容 `(market, code)` 元组写法。
- **库层标的解析** `pytdxdata.symbols`(原仅 CLI 内有):`parse_symbol` / `format_symbol` /
`parse_symbols` / `market_targets` / `is_cn_index`;裸 6 位数字视为沪市指数。
- **归一数据模型**:`SecurityBar` / `SecurityQuote` / `TransactionRecord` / `MinuteBar` /
`SecurityInfo` 等均新增 `symbol`(规范化标的串)/ `name` / `fields`(原始字段位兜底),
老构造写法不受影响(新字段有默认值)。
- `IndicatorSet` dataclass(`get_indicators` 返回单元:`bars + indicators` 组合)。
- `CacheKey.quote_key(..., tag=)` 支持按取数口径(标准五档 / MAC 字段位)隔离缓存。
### 修复
- **分页器连接泄漏**:`Paginator._worker` 换连接后旧连接不释放、池子被耗干
(`_Slot` 包装 + 归还时按槽释放)。
- **日期区间 K线返回 0 条**:标准通道 `start` 偏移方向是递减(0=最新),旧的二分
假设递增。改为运行时探测方向再二分(`_offset_descending` / `_bisect_offset`)。
- **池子全冷却死等**:所有服务器进冷却后 `acquire` 排队 30s 超时。
补 `ignore_cooldown=True` 兜底,避免无人持有连接时永久等待。
- `HealthEngine.COOLDOWN_SECONDS` 保持 120s(旧的 FAIL_STREAK_COOLDOWN=1 意味着
任意一次通信失败即冷却,实测下正常服务器不应被冷却,保留该行为)。
### 变更
- **`docs/api/index.md` 接口总览**重新组织:统一接口(推荐)优先于旧接口列表。
- `scripts/check_docs.py`:`docs/api/index.md` 从 `MUST_LIST_ALL` 移到
`MUST_NOT_BE_STALE`(只列推荐的统一接口,旧方法不强制出现在总览页)。
- CLI `tdx quotes` 改为统一 `td.get_quotes(symbols)`(跨市场混合报价)。
- CLI `tdx kline` 改为统一 `td.get_bars(sym, period)`。
- 测试 127 个用例全绿(新增 codec mock `get_file` 适配 + check_docs 新方法列表 +
`tests/test_all_interfaces.py` 全接口回归:mock 连接逐个调用全部 63 个公开方法,
并以「覆盖哨兵」断言无方法遗漏)。
## [0.5.0] - 2026-09-15
### 新增
- **文档站**(MkDocs + Material + `mkdocstrings`),每次 push 自动构建并部署到
<https://openbot-coder.github.io/pytdxdata/>
- **[`SKILL.md`](https://github.com/openbot-coder/pytdxdata/blob/main/SKILL.md)** — 面向 AI 编程助手的技能文件:三条必守约定、枚举取值表、
「想做什么 → 用哪个方法」决策表、9 条真实陷阱
- [`llms.txt`](https://openbot-coder.github.io/pytdxdata/llms.txt) — 面向 LLM 的结构化摘要,随站点发布到根路径
- `CHANGELOG.md` 独立成文件(此前内嵌在 README 中)
- `scripts/check_docs.py` + CI 步骤 — **文档漂移检查**:代码有而文档漏写、或文档引用了已删除的方法,都会 fail
- `tests/test_check_docs.py`(10 项)— 漂移检查器自身的自测
### 变更
- **README 瘦身为「入口层」**:361 → 129 行。只保留定位 / 安装 / 30 秒上手 / 特性 / 文档导航 / 免责声明;
CLI 手册、API 表、通道路由、架构树、扩展市场、easy-tdx 对比、Changelog 全部移交文档站与 `CHANGELOG.md`
- API 文档改由 `mkdocstrings` **从 docstring 实时生成**,不再手抄(根治漂移)
- 漂移检查扩展为两档:`MUST_LIST_ALL`(须列全所有公开方法)+ `MUST_NOT_BE_STALE`(只需无过时引用),
并把 `SKILL.md` / `README.md` / `llms.txt` / 教程类页面一并纳入
- 包元数据 `Documentation` 由仓库首页改指文档站
- 测试用例 **99 → 109**
### 文档
- 新增文档站 19 页:快速开始 / 场景示例 / CLI / FAQ / 贡献指南 / 更新日志 /
API 参考(总览·TdxData·枚举·模型·指标·解析器)/ 深入原理(架构·协议·三池路由·缓存)
- 明确口径:`TdxData` 公开方法共 **53 个**(= 51 个数据方法 + `start` / `close`),
此前各处笼统写的「51 个公开方法」不严,已统一更正
### 修复
- 修正**中文标题锚点被默认 slugify 剥光**导致跨页深链接全部失效的问题
(改用 `pymdownx.slugs.slugify`,并给被引用的标题加显式 ASCII id;`--strict` 不会报这个错,只能靠锚点检查兜住)
- README 中标注的测试数量(85)与 pytest 实际收集数不符,已更正为 109 个用例
## [0.4.0] - 2026-09-15
### 新增
- **服务器文件「下载 + 解析」能力**(对齐并超越 easy-tdx 的文件解析):
- `get_block_parsed(filename)` — 板块 `block_zs/gn/fg.dat` → `list[TdxBlock]`(板块名 / 类别 / 成分股代码)
- `get_industry_map()` — `tdxhy.cfg` → `dict[str, IndustryInfo]`(通达信行业 + 申万行业)
- `get_financial_file_infos()` — `tdxfin/gpcw.txt` → `list[FinancialFileInfo]`(文件名 / MD5 / 大小)
- `get_financial_records_parsed(filename)` — `gpcw*.zip` 解压 + 解析 → `list[FinancialRecord]`(每股原始字段)
- 解析器模块 `codec/block.py`、`codec/industry.py`、`codec/financial.py`(纯标准库,脱网可单测)
- 数据模型 `TdxBlock` / `IndustryInfo` / `FinancialFileInfo` / `FinancialRecord`
- CLI 新增 4 个命令:`tdx block` / `tdx industry` / `tdx financial-list` / `tdx financial`
- 测试 `tests/test_cli_files.py`(11 项 CLI 离线测试,FakeTD 桩)
### 修复
- 修复财报索引市场字段解析(`<6s1c1L` → `<6sBL`)。此前恒判深市,现市场字段 **0=深 / 1=沪** 正确
### 变更
- 公开异步方法 **47 → 51**,新增接口全部**向后兼容**(原 `bytes` 方法保留)
- README 与 `docs/API_REFERENCE.md` 同步更新
## [0.3.2] - 2026-08-17
### 新增
- `get_kline_batch(stocks, period, ...)` — 批量 K 线,多股票自动并发,连接池分配不同服务器
- `get_minute_batch(stocks, ...)` — 批量分时,多股票自动并发
## [0.3.1] - 2026-08-17
### 变更
- `get_kline(MIN_1)` 切换为 **MAC 通道**(`0x122E`),解决标准通道 1 分钟 K 线深度不足的问题
- `router.py` 中 `KlinePeriod.MIN_1` 强制路由到 MAC 通道
- 标准通道其他周期(`MIN_5/15/30/60/DAY/WEEK/MONTH`)不受影响
### 修复
- **修复 MAC K 线并发分页的数据空洞**:并发分页器把不同页分配到不同服务器,
而各服务器数据深度不一致时 `stop_when_short` 会导致**非确定性数据丢失**。
改为**单连接串行分页**(`_fetch_mac_kline_serial`,`start` 动态偏移,与 easy-tdx 一致)
## [0.3.0] - 2026-08-17
### 变更
- `get_minute` 切换为 **MAC 通道**(`0x122D` `MacTickChartCmd`),历史分时稳定返回完整 240 条(09:30~14:59)
- 移除不再使用的 `GetHistoryMinuteTimeDataCmd`
### 新增
- `protocol/commands/mac_tick.py` — MAC 单日分时图命令
## [0.2.2] 及之前
- 初始版本:动态连接池 + 双层 TTL 缓存 + 3 连接并发分页 + 双通道(标准 / MAC)+ 扩展市场(港股 / 美股 / 期货 / 期权)
[Unreleased]: https://github.com/openbot-coder/pytdxdata/compare/v0.6.0...HEAD
[0.6.0]: https://github.com/openbot-coder/pytdxdata/compare/v0.5.0...v0.6.0
[0.5.0]: https://github.com/openbot-coder/pytdxdata/compare/v0.4.0...v0.5.0
[0.4.0]: https://github.com/openbot-coder/pytdxdata/compare/v0.3.2...v0.4.0
[0.3.2]: https://github.com/openbot-coder/pytdxdata/compare/v0.3.1...v0.3.2
[0.3.1]: https://github.com/openbot-coder/pytdxdata/compare/v0.3.0...v0.3.1
[0.3.0]: https://github.com/openbot-coder/pytdxdata/compare/v0.2.2...v0.3.0
+72 -304
View File
@@ -6,23 +6,11 @@
[![License](https://img.shields.io/pypi/l/pytdxdata)](https://github.com/openbot-coder/pytdxdata/blob/main/LICENSE)
[![PyPI downloads](https://img.shields.io/pypi/dm/pytdxdata)](https://pypi.org/project/pytdxdata/)
通达信(TongDaXin)行情数据客户端:**动态连接池 + 双层TTL缓存 + 3连接并发分页**(纯 asyncio,零运行时依赖)。
通达信(TongDaXin)行情数据客户端:**动态连接池 + 双层 TTL 缓存 + 多连接并发分页**,纯 asyncio、**零运行时依赖**。
**A股(沪/深/北) + 港股 + 美股 + 期货 + 期权**,一套接口全市场。
参照 [easy-tdx](https://github.com/handsomejustin/easy_tdx) 重新实现,解决其三大短板(无连接池、串行分页、单连接单锁),协议层独立实现(不依赖 easy-tdx 包,仅参照其字节级格式)。
## 特性
| 特性 | 说明 |
|------|------|
| 🧩 动态连接池 | 启动时对服务器**真实K线探测**选优(剔除握手正常但数据返回空的坏节点),按等待队列/空闲时长动态扩缩容,健康分(失败×0.5/成功+0.2/冷却120s)+EWMA延迟选路,跨服务器故障转移 |
| 🗄️ 双层TTL缓存 | 内存LRU + 磁盘SQLite(WAL),TTL分级:报价5s / 分钟K线60s / 日线当天 / 复权K线1天 / **历史逐笔永久**;single-flight 并发同键去重(只回源一次);缓存"已解析记录"(重复请求0网络0解析) |
| ⚡ 并发分页 | 单请求拆N页(每页显式start偏移→无状态可并行),多连接并行拉取、按序拼接、失败换连接重试;1分钟K线走 MAC 单连接串行分页(避免多服务器数据空洞) |
| 🔀 双通道整合 | 标准通道(经典行情)+ MAC通道(逐笔/复权/1分钟K线),按命令自动选路 |
| 📦 零重型依赖 | 纯 asyncio + stdlib(socket/zlib/struct/sqlite3),返回 `list[dataclass]`,pandas 由调用方按需转换 |
| 🚀 批量下载 | `get_kline_batch` / `get_minute_batch` — 多股票自动并发,连接池分配不同服务器 |
| 📄 服务器文件解析 | 板块 `block_*.dat` / 行业 `tdxhy.cfg` / 历史财报 `gpcw*.zip` **下载即解析**成 dataclass(纯 stdlib),无需自己拆二进制 |
📖 **完整文档:<https://openbot-coder.github.io/pytdxdata/>**
## 安装
@@ -30,331 +18,111 @@
pip install pytdxdata # 或 uv add pytdxdata
```
从源码开发:
可选异步加速:
```bash
git clone <repo-url>
cd pytdxdata
uv sync # 创建虚拟环境 + 安装CLI
uv run python -c "import pytdxdata"
pip install "pytdxdata[uvloop]"
```
可选加速(uvloop):
```bash
uv add --optional uvloop uvloop
```
> 注:数据来自通达信公开行情服务器(无需账号),服务器清单由 `server_probe.py` 导入时自动探测可用性与延时,存于 `servers.json`。
## CLI 命令行工具
```bash
pip install -e . # 或 uv sync,注册 tdx 命令
tdx quotes sz000001 # 行情报价(五档) / hk00700 / usAAPL
tdx kline sz000001 --period day --count 30 --adjust qfq
tdx kline cffex:IFL0 --count 30 # 期货K线(hk/us/zz/dl/shf/cffex/gz)
tdx transactions sz000001 --count 50 # 逐笔(含成交笔数)
tdx minute sz000001 # 分时
tdx index 000001 --count 30 # 指数K线
tdx board list / members 881001 / ranking / change --days 5
tdx info sz000001 # 个股快照
tdx list --market sz --count 100 # 证券列表
tdx auction sz000001 / unusual / xdxr / finance / flow
tdx block block_gn.dat --limit 10 # 板块文件下载+解析(成分股)
tdx industry 600000 --search 银行 # 行业分类下载+解析(tdxhy.cfg)
tdx financial-list # 历史专业财报文件索引(gpcw.txt)
tdx financial gpcw20260331.zip # 历史专业财报记录下载+解析
tdx server-info / market-stat
```
## 快速开始
## 30 秒上手
```python
import asyncio
from pytdxdata import TdxData
from pytdxdata.models import KlinePeriod, Market, Adjust
from pytdxdata.models import KlinePeriod, Adjust
async def main():
async with TdxData() as td: # 自动建标准池(52台)+MAC池(3台)+缓存
# 日K线(count>800 自动3连接并发分页)
bars = await td.get_kline(1, "600000", KlinePeriod.DAY, count=2400)
# 分钟K线(复权走MAC通道)
m1 = await td.get_kline(0, "300308", KlinePeriod.MIN_1, count=240)
# 五档报价(TTL 5s 缓存,重复请求0网络)
q = await td.get_quotes([(1, "600000"), (0, "000001")])
# 逐笔成交(MAC通道,含 trade_count=成交笔数,支持历史回溯)
t = await td.get_transactions(0, "000001", date=20260811)
total_trades = sum(r.trade_count for r in t) # 当天总成交笔数
# 证券列表/数量
n = await td.get_security_count(0)
lst = await td.get_security_list(1, start=0, count=1000)
# 分时/除权除息/财务
minute = await td.get_minute(1, "600000")
xdxr = await td.get_xdxr(1, "600000")
fin = await td.get_finance(1, "600000")
async with TdxData() as td: # 自动建连接池 + 缓存
# 日K线(count 超过单页大小会自动多连接并发分页)
bars = await td.get_bars(["sz000001"], KlinePeriod.DAY, count=240)
# 前复权(自动走 MAC 通道)
qfq = await td.get_bars(["sz300308"], KlinePeriod.DAY,
count=500, adjust=Adjust.QFQ)
# 跨市场报价:A股+港股+美股一次拿全
quotes = await td.get_quotes(["sh600000", "hk00700", "usAAPL"])
# 逐笔成交(MAC 通道,支持历史日期)
ticks = await td.get_ticks(["sz000001"], date=20260811)
print(bars[-1].close, quotes[0].price, len(ticks))
asyncio.run(main())
```
## API 参考
返回的是标准库 `dataclass` 组成的 `list`(库本身不依赖 pandas)。要 DataFrame 一行转:
统一入口 `TdxData`(`async with TdxData() as td:` 自动 start/close)。
```python
from dataclasses import asdict
import pandas as pd
df = pd.DataFrame([asdict(b) for b in bars])
```
> 完整接口清单(每个方法的参数 / 返回值 / 通道)见 [`docs/API_REFERENCE.md`](docs/API_REFERENCE.md)。
## 特性
### 连接管理
| 方法 | 说明 |
| 特性 | 说明 |
|------|------|
| `start()` / `close()` | 启动(服务器探测+预建连接+缓存)/ 关闭 |
| `__aenter__` / `__aexit__` | 异步上下文管理器 |
| 🧩 动态连接池 | 启动时对服务器**真实 K 线探测**选优(剔除握手正常但数据为空的坏节点),健康分 + EWMA 延迟选路,跨服务器故障转移 |
| 🗄️ 双层 TTL 缓存 | 内存 LRU + 磁盘 SQLite(WAL),TTL 分级;single-flight 并发同键去重;缓存**已解析记录**(重复请求 0 网络 0 解析) |
| ⚡ 并发分页 | 单请求拆 N 页(显式 start 偏移 → 无状态可并行)并行拉取、按序拼接、失败换连接重试 |
| 🔀 双通道整合 | 标准通道(经典行情)+ MAC 通道(逐笔 / 复权 / 1 分钟 K 线),按命令自动选路 |
| 📦 零重型依赖 | 纯 asyncio + stdlib(socket / zlib / struct / sqlite3) |
| 📊 全市场覆盖 | A股、港股、美股、期货、期权(46 个扩展市场) |
| 📄 服务器文件解析 | 板块 `block_*.dat` / 行业 `tdxhy.cfg` / 财报 `gpcw*` **下载即解析**成 dataclass(索引名与服务器实际文件名不一致时自动纠正) |
| 🤖 AI 助手友好 | 内置 [`SKILL.md`](https://github.com/openbot-coder/pytdxdata/blob/main/SKILL.md) 与 [`llms.txt`](https://openbot-coder.github.io/pytdxdata/llms.txt) |
### 行情接口
## 文档导航
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_kline(market, code, period, *, start, count, adjust)` | `list[SecurityBar]` | K线(count>800自动并发分页;adjust≠NONE走MAC复权;88/000/399指数走指数命令) |
| `get_index_kline(market, code, period, *, start, count)` | `list[SecurityBar]` | 指数K线(多涨跌家数字段已处理) |
| `get_quotes(stocks)` | `list[SecurityQuote]` | 五档报价(>80只自动切批,缓存键=规范化股票集) |
| `get_transactions(market, code, *, date, start, count)` | `list[TransactionRecord]` | **逐笔成交(MAC,含 trade_count 成交笔数)**,支持历史回溯 |
| `get_minute(market, code, *, date)` | `list[MinuteBar]` | 分时(今日/历史,MAC通道) |
| `get_kline_batch(stocks, period, *, start, count, adjust, concurrency)` | `dict[str, list[SecurityBar]]` | **批量K线**(多股票自动并发,连接池分配不同服务器) |
| `get_minute_batch(stocks, *, date, concurrency)` | `dict[str, list[MinuteBar]]` | **批量分时**(多股票自动并发) |
| `get_security_count(market)` | `int` | 市场证券数量 |
| `get_security_list(market, *, start, count)` | `list[SecurityInfo]` | 证券列表(count=None=全部,先查总数分页) |
| `get_security_list_all(market)` | `list[SecurityInfo]` | 全市场列表(缓存1天) |
| `get_xdxr(market, code)` | `list[XdxrRecord]` | 除权除息历史(标准) |
| `get_finance(market, code)` | `FinanceRecord \| None` | 财务快照(标准) |
| 我想… | 去哪 |
|------|------|
| 装好跑起来 | [快速开始](https://openbot-coder.github.io/pytdxdata/getting-started/) |
| 抄场景代码(转 DataFrame / 批量下载 / 离线板块快照) | [场景示例](https://openbot-coder.github.io/pytdxdata/cookbook/) |
| 查方法签名与参数 | [TdxData 方法](https://openbot-coder.github.io/pytdxdata/api/tdxdata/) — 由 docstring 自动生成 |
| 搞清枚举该填几 | [枚举速查](https://openbot-coder.github.io/pytdxdata/api/enums/) |
| 看协议二进制格式、三池路由、缓存策略 | [深入原理](https://openbot-coder.github.io/pytdxdata/internals/architecture/) |
| 用命令行 | [命令行工具](https://openbot-coder.github.io/pytdxdata/cli/) |
| 完整接口清单(28 个统一方法 + 33 个废弃别名) | [`docs/API_REFERENCE.md`](https://openbot-coder.github.io/pytdxdata/API_REFERENCE/) |
| 重构审查(数据一致性 / 遗漏对账) | [接口重构审查](https://openbot-coder.github.io/pytdxdata/refactor-audit/) |
| 版本变更 | [`CHANGELOG.md`](https://github.com/openbot-coder/pytdxdata/blob/main/CHANGELOG.md) |
### 板块/竞价/异动(MAC)
> 本 README 只做**入口层**。深度内容一律在文档站,避免两处维护造成漂移。
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_board_list(board_type, count)` | `list[BoardInfo]` | 板块列表(0=全部 1=行业 2=概念) |
| `get_board_members(board_symbol, count, sort_type)` | `list[MemberQuote]` | 板块成分股报价(自定义字段) |
| `get_board_summary(board_symbol)` | `dict` | 板块汇总(成分数/成交额/主力净流入/涨跌家数) |
| `get_board_ranking(board_type, top_n)` | `list[dict]` | 板块涨跌幅排行 |
| `get_board_change_ranking(board_type, days, top_n)` | `list[dict]` | 板块N日涨跌幅排行(板块指数K线) |
| `get_belong_board(market, code)` | `list[BelongBoard]` | 个股所属板块 |
| `get_auction(market, code)` | `list[AuctionItem]` | 集合竞价 |
| `get_unusual(market, start, count)` | `list[UnusualItem]` | 市场异动 |
| `get_capital_flow(market, code)` | `CapitalFlow` | 资金流向 |
## 给 AI 助手用
### 快照/服务器/扩展(MAC)
仓库根的 [`SKILL.md`](https://github.com/openbot-coder/pytdxdata/blob/main/SKILL.md) 是一份可直接加载的技能:三条必守约定、`KlinePeriod` 等枚举取值表、
「想做什么 → 用哪个方法」决策表、以及 11 条真实陷阱。AI 编程助手读完就能一次写对,不必翻源码。
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_symbol_info(market, code)` | `SymbolSnapshot` | 个股特征快照 |
| `get_stock_quotes(stocks, bits)` | `list[MemberQuote]` | MAC自定义字段报价 |
| `get_stock_quotes_list(category, count)` | `list[MemberQuote]` | 市场分类报价列表(0沪A/6全A/8科创/14创业) |
| `get_stock_kline_with_indicators(market, code, indicators, ...)` | `dict` | K线+指标(MACD/KDJ/RSI/BOLL/MA/EMA) |
| `get_goods_list(market, start, count)` | `list[GoodsItem]` | 扩展市场商品(期货/期权) |
| `get_server_info()` | `ServerInfo` | 服务器交易时段 |
| `get_kline_offset(offset, count)` | `tuple[int,int]` | K线偏移 |
| `get_chart_sampling(market, code)` | `list[float]` | 分时采样(扩展市场命令,A股不适用) |
### 文件/信息(标准+MAC)
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_company_info_category/content(...)` | `list` / `str` | F10公司信息(标准) |
| `get_block_info(filename)` | `bytes` | 板块文件下载(标准) |
| `get_report_file(filename)` | `bytes` | 报告/财务文件下载(标准) |
| `get_financial_file_list()` | `list[str]` | 财务文件列表(tdxfin/gpcw.txt,原始行) |
| `get_financial_records(filename)` | `bytes` | 财务文件内容(gpcw*.zip,原始字节) |
| **`get_block_parsed(filename)`** | `list[TdxBlock]` | 板块文件**下载+解析**:板块名/类别/成分股代码 |
| **`get_industry_map()`** | `dict[str, IndustryInfo]` | tdxhy.cfg **下载+解析**:通达信行业+申万行业 |
| **`get_financial_file_infos()`** | `list[FinancialFileInfo]` | gpcw.txt **下载+解析**:文件名/MD5/大小 |
| **`get_financial_records_parsed(filename)`** | `list[FinancialRecord]` | gpcw*.zip **解压+解析**:每股原始字段 |
| `get_file_meta(filename)` / `download_file(filename)` | `FileMeta` / `bytes` | 远程文件(MAC) |
| `get_price_limits(market, code, name, pre_close, listed_days)` | `tuple` | 涨跌停价(本地计算) |
| `get_market_stat()` | `MarketStat` | 全市场统计(涨跌家数/总额/市值/涨跌停数) |
### 数据模型(dataclass)
| 模型 | 关键字段 |
|------|---------|
| `SecurityBar` | market/code/open/high/low/close/vol/amount/year/month/day/hour/minute + `datetime`属性 |
| `SecurityQuote` | price/pre_close/OHLC/vol/amount/s_vol/b_vol/`bid[5]`/`ask[5]`/server_time/trading_status |
| `TransactionRecord` | time/price/vol/`trade_count`/bs_flag |
| `SecurityInfo` | code/name(GBK)/volunit/decimal_point/pre_close |
| `XdxrRecord` | category/分红送转/缩股/行权等(除权除息) |
| `MinuteBar` | price/vol |
| `FinanceRecord` | 股本/资产/营收/利润(万元/万股,最新快照) |
| `TdxBlock` | name/category/count/`codes`(板块成分,block_*.dat) |
| `IndustryInfo` | code/tdx_industry/sw_industry(tdxhy.cfg) |
| `FinancialFileInfo` | filename/hash/filesize(gpcw.txt) |
| `FinancialRecord` | code/market/report_date/`fields`(历史专业财报) |
### 枚举
- `Market`:SZ=0 / SH=1 / **BJ=2**(北交所)
- `KlinePeriod`:MIN_5=0 / MIN_15=1 / MIN_30=2 / MIN_60=3 / **DAY=4** / WEEK=5 / MONTH=6 / MIN_1=7 / MIN_3=8 / YEAR=9 / SEASON=10(**与通达信协议字节一致**)
- `Adjust`:NONE / QFQ(前复权)/ HFQ(后复权)
## 通道路由
| 命令 | 默认通道 | 说明 |
|------|---------|------|
| K线(复权) | **MAC** | 支持QFQ/HFQ |
| K线(MIN_1不复权) | **MAC** | 0x122E,串行分页,避免多服务器数据空洞 |
| K线(其他周期不复权)/指数 | 标准 | 价格小数位规则已验证 |
| 报价 | 标准 | 股票2位/指数ETF转债3位 |
| **逐笔成交** | **MAC** | 含trade_count,支持历史日期 |
| **分时** | **MAC** | 0x122D,完整历史分时 |
| 列表/数量/除权/财务 | 标准 | 仅标准通道提供 |
## 架构
```
src/pytdxdata/
├── api.py # 统一接口 TdxData(对外唯一入口)
├── router.py # 标准/MAC 通道选路
├── config.py # 服务器清单加载(servers.json + 环境变量覆盖)
├── protocol/ # 独立协议层(帧/变长整数/差分还原/自定义浮点/命令)
│ └── commands/ # kline/quotes/list/transaction/minute/xdxr/finance/mac
├── pool/ # 动态连接池(connection/health/pool)
├── cache/ # 双层TTL缓存(key/ttl/memory/disk/manager)
├── scheduler/ # 并发分页调度器(Paginator,3连接并行)
├── models/ # dataclass 模型 + 枚举
└── codec/ # 缓存载荷序列化(pickle+zlib)+ 服务器文件解析(板块/行业/财报)
```bash
# 丢进你所用 AI 助手的 skills 目录即可
curl -o ~/.workbuddy/skills/pytdxdata/SKILL.md --create-dirs \
https://raw.githubusercontent.com/openbot-coder/pytdxdata/main/SKILL.md
```
## 扩展市场(EX通道:港股/美股/期货/期权)
## 示例
`get_kline` 的 market 参数接受 `ExMarket` 枚举(港股/美股/期货/期权等52个市场):
- [`examples/quickstart.py`](https://github.com/openbot-coder/pytdxdata/blob/main/examples/quickstart.py) — 报价 / K线 / 分时 / 板块
- [`examples/server_files.py`](https://github.com/openbot-coder/pytdxdata/blob/main/examples/server_files.py) — 板块 / 行业 / 财报 下载 + 解析
```python
from pytdxdata.models import ExMarket, KlinePeriod
## 开发
# 港股(HK_MAIN_BOARD=31,代码5位)
bars = await td.get_kline(ExMarket.HK_MAIN_BOARD, '00700', KlinePeriod.DAY, count=700)
# 美股(US_STOCK=74)
bars = await td.get_kline(ExMarket.US_STOCK, 'AAPL', KlinePeriod.DAY, count=700)
# 期货(CFFEX=47 / 郑28 / 大29 / 上30,合约如 IFL0/rb2610)
bars = await td.get_kline(ExMarket.CFFEX_FUTURES, 'IFL0', KlinePeriod.DAY, count=700)
# 股票期权(沪8/深9,合约代码8位)
bars = await td.get_kline(ExMarket.SH_STOCK_OPTION, '10010971', KlinePeriod.DAY, count=700)
```bash
uv sync # 建虚拟环境 + 注册 tdx 命令
uv run pytest tests/ # 182 个测试用例(协议 / 池 / 缓存 / 分页 / 全接口回归 / 文件解析 / CLI / 文档漂移 / 当日测速缓存)
uv sync --group docs # 文档站依赖(mkdocs-material + mkdocstrings)
uv run mkdocs serve # 本地预览文档站
```
- 端口 7727,统一走 **pytdx EX 协议**(0x23FF K线 / 0x23FA 报价 / 0x23F4 市场列表)
- 4台EX服务器:MAC EX 2台(116.205.135.205 / 121.37.232.167,0x2454 login)+ pytdx EX 2台(通达信扩展市场 116.205.143.214 / 国泰君安 103.221.142.82,0x2454 setup)
- EX 辅助接口:get_goods_list / get_goods_count / get_goods_quotes / get_goods_tick_chart / get_goods_transaction 等
- 实测:腾讯00700=466.6 / AAPL=332.8 / IFL0=4683.2 / 沪期权10010971=0.192
- 美股/港股期权:通达信协议无数据(美股期权可用 CBOE 公开接口,见 quantdata/scripts/import/cboe_options.py)
## 服务器文件:板块 / 行业 / 财报
通达信服务器上除了行情,还有一批**静态文件**(板块成分、行业分类、历史专业财报)。
pytdxdata 提供「**下载 + 解析**」一步到位:既保留原始 `bytes` 通道,也提供解析成 dataclass 的方法。
```python
async with TdxData() as td:
# ① 板块文件(block_zs.dat 行业 / block_gn.dat 概念 / block_fg.dat 风格)
blocks = await td.get_block_parsed("block_gn.dat")
for b in blocks:
print(b.name, b.category, b.count, b.codes[:5])
# ② 行业分类(tdxhy.cfg → 通达信行业 + 申万行业)
hy = await td.get_industry_map() # {6位代码: IndustryInfo}
print(hy["600000"].tdx_industry, hy["600000"].sw_industry)
# ③ 历史专业财报(gpcw.txt 索引 + gpcw*.zip 解压解析)
infos = await td.get_financial_file_infos() # 文件名 / MD5 / 大小
records = await td.get_financial_records_parsed(infos[-1].filename)
print(records[0].code, records[0].report_date, records[0].fields[:4])
```
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_block_parsed(filename)` | `list[TdxBlock]` | 板块成分:板块名 / 类别 / 成分股代码 |
| `get_industry_map()` | `dict[str, IndustryInfo]` | 通达信行业 + 申万行业(GBK 解析) |
| `get_financial_file_infos()` | `list[FinancialFileInfo]` | gpcw 文件索引(文件名 / MD5 / 大小) |
| `get_financial_records_parsed(filename)` | `list[FinancialRecord]` | 解压 zip + 解析每股原始字段 |
不解析的原始字节通道仍保留(向后兼容):`get_block_info()` / `get_report_file()` /
`get_financial_file_list()` / `get_financial_records()`。
> 解析器集中在 `codec/`(`block.py` / `industry.py` / `financial.py`),纯标准库(struct / zipfile),
> 可脱网单测;也可直接 `from pytdxdata.codec import parse_block_dat` 单独复用。
## 与 easy-tdx 对比
| 维度 | easy-tdx | pytdxdata |
|------|----------|----------|
| 并发分页 | ❌ 串行 while 循环 | ✅ 3连接并行 |
| 连接池 | ❌ 单连接单锁 | ✅ 动态池+故障转移 |
| 缓存 | 仅证券列表(1天) | ✅ 双层TTL+single-flight |
| 数据正确性 | 基准 | ✅ K线6字段/报价7字段逐字段一致(实测) |
| 2400根日K耗时 | 0.31s | **0.16s(1.97x)** |
| 缓存命中重取 | — | 0.016s(0网络) |
| 接口覆盖 | 基准 | **36/36 全覆盖** |
| 依赖 | pandas等 | 零运行时依赖 |
> 实测环境:Windows 11 / Python 3.13 / 同一批通达信服务器(2026-08 实测)。
## 已知限制
- 标准通道K线 `count<100` 部分服务器返回空 → 分页器已强制 `min_page=100` 规避
- 标准当日逐笔的笔数字段协议中有但 easy-tdx 模型丢弃(pytdxdata 已显式解析);历史逐笔无笔数字段
- 报价价格小数位按品种推断(股票2位/指数ETF转债3位),同代码不同市场含义不同(SH 000001=指数 vs SZ 000001=股票)
- 行情数据来自通达信公开服务器,**15分钟延时**;需实时数据请使用券商行情
- 港股/美股/期货/期权数据走通达信 EX 通道(7727),部分市场(美股/港股期权)协议内无数据
- 服务器可用性随时间变化,可用 `python -m pytdxdata.server_probe` 重新探测
- 行情来自通达信公开服务器,**15 分钟延时**;需实时数据请使用券商行情
- 标准通道 K 线 `count < 100` 部分服务器返回空 → 分页器已强制 `min_page=100` 规避
- 港股 / 美股期权在通达信协议内无数据
- 服务器可用性随时间变化。**当日首次启动会自动在后台测速并缓存**(对调用方无感,当天不再重测);
也可用 `python -m pytdxdata.server_probe` 离线重生成随包清单。
缓存路径与三个开关见 [安装与配置 → 当日自动测速](https://openbot-coder.github.io/pytdxdata/getting-started/#当日自动测速无感)
## 免责声明
本包仅用于**技术研究与教育目的**。行情数据来自通达信公开接口,不保证实时性与准确性;作者不对任何投资决策负责。使用前请遵守通达信服务条款及相关法律法规。
本包仅用于**技术研究与教育目的**。行情数据来自通达信公开接口,不保证实时性与准确性;
作者不对任何投资决策负责。使用前请遵守通达信服务条款及相关法律法规。
## 测试
## License
```bash
uv run pytest tests/ # 85个测试:协议/池/缓存/分页/API/文件解析/CLI
```
## 目录
- `docs/API_REFERENCE.md` — 完整对外接口清单(Python API / 数据模型 / 枚举 / CLI)
- `examples/quickstart.py` — 快速上手(报价 / K线 / 分时 / 板块)
- `examples/server_files.py` — 服务器文件下载 + 解析(板块 / 行业 / 财报)
## Changelog
### v0.4.0 (2026-09-15)
- **新增「服务器文件下载 + 解析」能力**(对齐并超越 easy-tdx 的文件解析):
- `get_block_parsed(filename)` — 板块 `block_zs/gn/fg.dat` → `TdxBlock` 列表(板块名 / 类别 / 成分股代码)
- `get_industry_map()` — `tdxhy.cfg` → `{代码: IndustryInfo}`(通达信行业 + 申万行业)
- `get_financial_file_infos()` — `tdxfin/gpcw.txt` → `FinancialFileInfo` 列表(文件名 / MD5 / 大小)
- `get_financial_records_parsed(filename)` — `gpcw*.zip` 解压 + 解析 → `FinancialRecord` 列表(每股原始字段)
- **新增解析器** `codec/block.py`、`codec/industry.py`、`codec/financial.py`(纯标准库,脱网可单测)
- **新增模型** `TdxBlock` / `IndustryInfo` / `FinancialFileInfo` / `FinancialRecord`
- 修复财报索引市场字段解析(`<6s1c1L` → `<6sBL`,市场 0=深 / 1=沪 正确,此前恒判深市)
- 公开异步方法 47 → **51**,新增接口全部向后兼容(原 `bytes` 方法保留)
- **CLI 新增 4 个命令**:`tdx block` / `tdx industry` / `tdx financial-list` / `tdx financial`
- 新增 `tests/test_cli_files.py`(11 项 CLI 离线测试,FakeTD 桩)
- README 与 `docs/API_REFERENCE.md` 同步更新
### v0.3.2 (2026-08-17)
- **新增** `get_kline_batch(stocks, period, ...)` — 批量K线接口,多股票自动并发下载,连接池分配不同服务器
- **新增** `get_minute_batch(stocks, ...)` — 批量分时接口,多股票自动并发下载
### v0.3.1 (2026-08-17)
- **`get_kline(MIN_1)` 切换为 MAC 通道** (0x122E),解决标准通道 1 分钟K线深度不足问题
- **修复 MAC K线并发分页数据空洞** — 并发分页器将不同页面分配到不同服务器,当服务器数据深度不一致时 `stop_when_short` 会导致非确定性数据丢失;改用**单连接串行分页**(`_fetch_mac_kline_serial`,start 动态偏移,与 easy-tdx 一致)
- 路由更新:`router.py` 中 `KlinePeriod.MIN_1` 强制路由到 MAC 通道
- 标准通道其他周期(MIN_5/15/30/60/DAY/WEEK/MONTH)不受影响
### v0.3.0 (2026-08-17)
- **`get_minute` 切换为 MAC 通道** (0x122D `MacTickChartCmd`),历史分时数据稳定返回完整 240 条(09:30~14:59)
- 新增 `protocol/commands/mac_tick.py` — MAC 单日分时图命令
- 移除不再使用的 `GetHistoryMinuteTimeDataCmd` 导入
### v0.2.2 及之前
- 初始版本:动态连接池 + 双层TTL缓存 + 3连接并发分页 + 双通道(标准/MAC)+ 扩展市场(港股/美股/期货/期权)
[MIT](https://github.com/openbot-coder/pytdxdata/blob/main/LICENSE)
+197
View File
@@ -0,0 +1,197 @@
---
name: pytdxdata
description: 用 pytdxdata 拉取通达信行情数据——A股(沪/深/北)、港股、美股、期货、期权的 K线 / 报价 / 逐笔 / 分时 / 板块 / 除权 / 财报文件。触发词:通达信数据、tdx 行情、A股日线下载、分钟K线、批量拉K线、板块成分股、行业分类、港股美股行情、pytdx、easy-tdx、pytdxdata。
---
# pytdxdata 使用技能
`pytdxdata` 是通达信公开行情服务器的纯 asyncio 客户端:动态连接池 + 双层 TTL 缓存 + 多连接并发分页,**零运行时依赖**。
本技能让你一次写对——重点是那三条一眼看不出来的约定,以及一张必须背下来的枚举表。
> 需要精确签名时查 <https://openbot-coder.github.io/pytdxdata/api/tdxdata/>(由 docstring 实时生成,不可能过期)。
## 三条必守约定
**1. 唯一入口是 `TdxData`,且必须 `async with`**
```python
from pytdxdata import TdxData
async with TdxData() as td: # 自动 start(探测服务器 + 预建连接 + 建缓存)
bars = await td.get_bars(["sz000001"], KlinePeriod.DAY, count=240)
# 退出即 close
```
不要直接 `await TdxData().get_bars(...)`——没 `start()` 就没有连接池。
**2. 标的写法是字符串,不是元组**
这是 v0.6 的最重要变化。**不要传 `(Market.SH, "600000")` 元组**,用字符串:
```python
# 旧写法(deprecated,会发出 DeprecationWarning):
bars = await td.get_kline(Market.SH, "600000", KlinePeriod.DAY, count=240)
# 新写法(推荐):
bars = await td.get_bars(["sz000001"], KlinePeriod.DAY, count=240)
# 港股/美股/期货也一样:
bars = await td.get_bars(["hk00700", "usAAPL", "cffex:IFL0"], KlinePeriod.DAY, count=240)
```
**3. 返回 `list[dataclass]`,不是 DataFrame**
库刻意不依赖 pandas。要 DataFrame 自己转一行:
```python
from dataclasses import asdict
import pandas as pd
df = pd.DataFrame([asdict(b) for b in bars])
```
## 安装
```bash
pip install pytdxdata # 或 uv add pytdxdata
```
## 可运行模板
```python
import asyncio
from pytdxdata import TdxData
from pytdxdata.models import KlinePeriod, Adjust
async def main():
async with TdxData() as td:
# 日K线,240 根(count 超过单页大小会自动多连接并发分页)
bars = await td.get_bars(["sz000001"], KlinePeriod.DAY, count=240)
print(bars[-1].close, bars[-1].datetime)
# 前复权日线(复权自动走 MAC 通道)
qfq = await td.get_bars(["sz300308"], KlinePeriod.DAY,
count=500, adjust=Adjust.QFQ)
# 跨市场报价:A股+港股+美股一次拿全
quotes = await td.get_quotes(["sz000001", "hk00700", "usAAPL"])
print(quotes[0].price, quotes[1].name, quotes[2].amount)
# 逐笔成交(MAC 通道,支持历史日期,含 trade_count 成交笔数)
ticks = await td.get_ticks(["sz000001"], date=20260811)
print(sum(r.trade_count for r in ticks))
# 分时(MAC 通道,今日或历史)
minutes = await td.get_minutes(["sz000001"])
# 批量 K 线:多股票自动并发,池子会分配到不同服务器
batch = await td.get_bars(
["sz000001", "sh600000"],
KlinePeriod.DAY, count=240,
) # 平铺返回,每条带 .symbol 字段
asyncio.run(main())
```
## 枚举取值表(别猜,对照着填)
**`Market`** — A 股市场
| 值 | 名称 | 含义 |
|---|---|---|
| 0 | `SZ` | 深市 |
| 1 | `SH` | 沪市 |
| 2 | `BJ` | 北交所 |
**`KlinePeriod`** — 周期编码,**与通达信协议字节一致,不是顺序编号**
| 值 | 名称 | | 值 | 名称 |
|---|---|---|---|---|
| 0 | `MIN_5` | | 7 | `MIN_1` |
| 1 | `MIN_15` | | 8 | `MIN_3` |
| 2 | `MIN_30` | | 9 | `YEAR` |
| 3 | `MIN_60` | | 10 | `SEASON` |
| 4 | `DAY` | | 11 | `YEAR_ALT` |
| 5 | `WEEK` | | | |
| 6 | `MONTH` | | | |
⚠️ **`DAY=4` 不是 0**,`MIN_1=7` 也不是 0。凭直觉填 `0` 会拿到 5 分钟线。
**`Adjust`** — 复权方式
| 值 | 名称 | 含义 |
|---|---|---|
| 0 | `NONE` | 不复权 |
| 1 | `QFQ` | 前复权 |
| 2 | `HFQ` | 后复权 |
**`ExMarket`** — 扩展市场(港股 / 美股 / 期货 / 期权,共 46 个成员,走独立 EX 通道)
v0.6 起统一接口用**字符串前缀**指定扩展市场,一般不再需要 `ExMarket`:
```python
await td.get_bars("hk00700", KlinePeriod.DAY, count=700) # 港股(5 位代码)
await td.get_bars("usAAPL", KlinePeriod.DAY, count=700) # 美股(ticker)
await td.get_bars("cffex:IFL0", KlinePeriod.DAY, count=700) # 期货合约
```
常用前缀:`hk` / `us` / `cffex` / `shf` / `dl` / `zz` / `gz`;完整表见 <https://openbot-coder.github.io/pytdxdata/api/enums/>。
## 想做什么 → 用哪个方法
| 需求 | 方法 |
|---|---|
| 全市场标的清单(A股+港股+期货…) | `get_universe(market=None)` |
| 日/周/月/分钟 K 线(任意市场) | `get_bars(symbols, period, *, count, adjust, start_date, end_date)` |
| K 线 + MACD/KDJ/RSI/BOLL | `get_indicators(symbols, indicators, ...)` |
| 实时五档报价(A股)/ 基础报价(港股/美股/期货) | `get_quotes(symbols, *, fields=None)` |
| 逐笔成交(任意市场) | `get_ticks(symbols, *, date)` |
| 分时图 / 缩略采样 | `get_minutes(symbols, *, date, sampling=True)` |
| 全市场股票列表(缓存 1 天) | `get_universe("sz")` / `get_universe("sh")` |
| 除权除息 / 财务快照 | `get_xdxr(symbols)` / `get_finance(symbols)` |
| F10 公司资料 | `get_f10(symbol, section)` |
| 板块列表 / 成分股 / 涨跌排行 | `get_boards` / `get_board_members` / `get_board_ranking` |
| 个股所属板块 | `get_board_of(symbols)` |
| 集合竞价 / 异动 / 资金流 | `get_auction` / `get_unusual` / `get_capital_flow` |
| 个股特征快照 | `get_snapshot(symbols)` |
| **板块成分文件**(离线快照) | `get_block_parsed("block_gn.dat")` |
| **行业分类**(通达信 + 申万) | `get_industry_map()` |
| **历史专业财报**(gpcw 全字段) | `get_financial_file_infos()` + `get_financial_records_parsed(fn)` |
| 涨跌停价 | `get_price_limits(symbol, name, pre_close, listed_days)`(本地算,无网络) |
| 全市场涨跌家数/成交额 | `get_market_stat()` |
## 通道与数据特性(影响你能拿到什么)
库内部有**标准通道**和 **MAC 通道**两条链路,会**按命令自动选路**,你不用管。但有几件事必须知道:
- **数据有 15 分钟延时**(通达信公开服务器特性)。要实时数据请用券商行情。
- **复权 K 线与 1 分钟 K 线走 MAC 通道**。`get_bars(..., adjust=Adjust.QFQ)` 自动切换。
- **`count` 很大时会自动多连接并发分页**,无需手动翻页。但标准通道 K 线 `count < 100` 部分服务器会返回空——内部已强制 `min_page=100` 规避。
- **`get_quotes` 一次 >80 只自动切批**;走 MAC 字段位通道(`fields=`)时上限为 80 只/次。
- **历史逐笔没有笔数字段**,只有当日逐笔的 `trade_count` 有效。
- 板块文件(`block_*.dat`)/ 行业(`tdxhy.cfg`)/ 财报(`gpcw*.zip`)是**服务器上的静态文件**,解析后是普通 dataclass,**落 JSON 后完全脱网可用**——适合做离线快照。
## 陷阱清单
| 坑 | 后果 | 正确做法 |
|---|---|---|
| 统一方法(`get_quotes`/`get_bars`…)传 `(Market.SH, "600000")` 元组或市场号 | v0.6 起直接报错 | 用字符串 `"sh600000"` |
| 旧别名(`get_kline`/`get_transactions`…)传 `(market, code)` | 能跑,但发出 `DeprecationWarning` | 迁移到统一方法 + 字符串 |
| 忘了 `async with` / `start()` | 无连接池,运行时报错 | 一律 `async with TdxData() as td:` |
| `KlinePeriod.DAY == 0` | 拿到的是 5 分钟线 | `DAY=4`,对照枚举表 |
| 等在返回值上找 `.to_dataframe()` | 不存在 | `pd.DataFrame([asdict(x) for x in bars])` |
| 把 `close` 当成分 | 数值差 100 倍 | 价格单位是**元**(float) |
| `sh000001` 当成平安银行 | 拿到的是上证指数 | **代码不唯一**:`sh000001`=上证指数,`sz000001`=平安银行 |
| 用 `get_block_info` 又自己拆二进制 | 白写解析器 | 用 `get_block_parsed`,已经解析好了 |
| 循环里逐个 `await get_bars` | 慢 | 用列表传多个标的,自动并发 |
| 港股/美股五档 bid/ask | 没有(协议不支持) | `fields` 字段位通道有 name 但无五档 |
| 依赖实时性做信号 | 数据是 15 分钟前的 | 换券商实时源 |
| 手动改包内 `servers.json` / 写死 IP | 容器只读、升级被覆盖、快节点捞不回来 | 日常靠内置的**当日测速缓存**自动选路;要强制指定就用 `PYPYTDX_DATA_{STANDARD,MAC,EX}_HOSTS` 环境变量 |
## 深入参考
- 文档站:<https://openbot-coder.github.io/pytdxdata/>
- 完整方法签名(自动生成):<https://openbot-coder.github.io/pytdxdata/api/tdxdata/>
- 场景示例 / 离线解析配方:<https://openbot-coder.github.io/pytdxdata/cookbook/>
- 给 LLM 的速查摘要:<https://openbot-coder.github.io/pytdxdata/llms.txt>
- 命令行等价物:`tdx quotes sz000001`、`tdx kline sz000001 --period day --count 30`、`tdx block block_gn.dat`(`tdx --help` 看全部)
> 数据来自通达信公开接口,仅供技术研究与教育用途,不构成投资建议。
+92 -27
View File
@@ -1,6 +1,8 @@
# pytdxdata 对外接口清单
> 以 `src/pytdxdata` 源码为准整理(v0.3.2)。分四类:Python API / 数据模型 / 辅助模块 / CLI。
> 以 `src/pytdxdata` 源码为准整理(v0.6.0)。分四类:Python API / 数据模型 / 辅助模块 / CLI。
>
> 方法与代码的一致性由 `scripts/check_docs.py` 在 CI 中校验。
## 一、包级导出
@@ -37,7 +39,50 @@ from pytdxdata import (
| `async close()` | 关闭全部池与缓存 |
| `async with TdxData() as td:` | 上下文管理器,自动 start/close |
### 2.1 K线(共 6 个)
### 2.1 统一接口(v0.6+ 推荐){#unified}
以下方法在 v0.6 新增,标的一律用字符串(`sz000001` / `hk00700` / `usAAPL` / `cffex:IFL0`)。
#### 标的清单
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_universe(market=None)` | `list[SecurityInfo]` | 跨市场标的清单(A 股+港股+美股+期货/期权) |
#### 报价
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_quotes(symbols, *, fields=None)` | `list[SecurityQuote]` | 跨市场混合报价(A 股标准五档;给了 fields 走 MAC/EX 字段位有 name) |
| `get_snapshot(symbols)` | `list[SymbolSnapshot]` | 个股特征快照(A 股) |
| `get_auction(symbols)` | `list[AuctionItem]` | 集合竞价(A 股) |
| `get_capital_flow(symbols)` | `list[CapitalFlow]` | 个股资金流向(A 股) |
#### K线
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_bars(symbols, period=DAY, *, start=0, count=800, adjust=None, start_date=None, end_date=None, concurrency=6)` | `list[SecurityBar]` | 跨市场 K 线(自动判指数、复权走 MAC、并发分页、日期区间二分) |
| `get_indicators(symbols, indicators, *, period=DAY, count=30, adjust=None, params=None)` | `list[IndicatorSet]` | K 线+技术指标(MACD/KDJ/RSI/BOLL/MA/EMA) |
#### 逐笔与分时
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_ticks(symbols, *, date=None, start=0, count=None, concurrency=6)` | `list[TransactionRecord]` | 跨市场逐笔成交 |
| `get_minutes(symbols, *, date=None, sampling=False, concurrency=6)` | `list[MinuteBar]` | 跨市场分时(sampling=True 取缩略采样:A股由 0x122D 派生,扩展市场 0x254D) |
#### 公司信息/文件/板块
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_f10(symbol, section=None, *, offset=0, length=65535)` | `list \| str` | F10 公司资料 |
| `get_file(name)` | `bytes` | 服务器文件原始字节(自动选通道) |
| `get_boards(kind="all", *, count=10000)` | `list[BoardInfo]` | 板块列表 |
| `get_board_members(board, *, fields=None, count=100000)` | `list[SecurityQuote]` | 板块成分股报价(归一模型) |
| `get_board_of(symbols)` | `list[BelongBoard]` | 个股所属板块 |
### 2.2 K线(旧接口,共 6 个) {#legacy-kline}
| 方法 | 返回 | 说明 |
|------|------|------|
@@ -48,25 +93,25 @@ from pytdxdata import (
| `get_stock_kline_with_indicators(market, code, indicators, *, period=DAY, count=30, adjust=None, params=None)` | `dict` | K线+技术指标(MACD/KDJ/RSI/BOLL/MA/EMA) |
| `get_kline_offset(offset=0, count=1)` | `tuple[int, int]` | K线偏移信息(MAC) |
### 2.2 报价(共 4 个)
### 2.3 报价(旧接口,共 4 个) {#legacy-quote}
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_quotes(stocks)` | `list[SecurityQuote]` | 五档报价;>80 只自动切批;TTL 5s |
| `get_quotes(symbols, *, fields=None)` | `list[SecurityQuote]` | 五档报价;>80 只自动切批;TTL 5s |
| `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_market_stat()` | `MarketStat` | 全市场统计(涨跌家数/总额/市值/涨跌停数) |
### 2.3 逐笔成交 / 分时(共 4 个)
### 2.4 逐笔成交 / 分时(旧接口,共 4 个) {#legacy-tick}
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_transactions(market, code, *, date=None, start=0, count=2000)` | `list[TransactionRecord]` | 逐笔成交(MAC,含 trade_count),支持历史日期 |
| `get_minute(market, code, *, date=None)` | `list[MinuteBar]` | 分时(MAC 0x122D,可历史) |
| `get_minute_batch(stocks, *, date=None, concurrency=6)` | `dict[str, list[MinuteBar]]` | 批量分时 |
| `get_chart_sampling(market, code)` | `list[float]` | 分时缩略采样(A股,MAC 0x254D) |
| `get_chart_sampling(market, code)` | `list[float]` | 分时缩略采样(A股由 MAC **0x122D** 派生;0x254D 仅 EX 通道可用) |
### 2.4 证券列表(共 3 个)
### 2.5 证券列表(旧接口,共 3 个) {#legacy-list}
| 方法 | 返回 | 说明 |
|------|------|------|
@@ -74,30 +119,30 @@ from pytdxdata import (
| `get_security_list(market, *, start=0, count=None)` | `list[SecurityInfo]` | count=None=全部(先查总数防死循环) |
| `get_security_list_all(market)` | `list[SecurityInfo]` | 全市场列表(高并发一次拉完,缓存 1 天) |
### 2.5 除权 / 财务 / F10 / 文件(共 15 个)
### 2.6 除权 / 财务 / F10 / 文件(旧接口,共 15 个) {#file-methods}
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_xdxr(market, code)` | `list[XdxrRecord]` | 除权除息历史(标准) |
| `get_finance(market, code)` | `FinanceRecord \| None` | 财务快照(标准) |
| `get_price_limits(market, code, name, pre_close, listed_days=9999)` | `tuple[float\|None, float\|None]` | 涨跌停价(本地计算) |
| `get_xdxr(symbols)` | `list[XdxrRecord]` | 除权除息历史(标准) |
| `get_finance(symbols)` | `list[FinanceRecord]` | 财务快照(标准;无数据的标的跳过) |
| `get_price_limits(symbol, name=None, pre_close=None, listed_days=9999)` | `tuple[float\|None, float\|None]` | 涨跌停价(本地计算) |
| `get_company_info_category(market, code)` | `list` | F10 目录(标准) |
| `get_company_info_content(market, code, filename, offset=0, length=65535)` | `str` | F10 内容(分块) |
| `get_block_info(filename)` | `bytes` | 板块文件**原始字节**(先查元数据再分块下载) |
| `get_report_file(filename)` | `bytes` | 报告/财务文件**原始字节**(标准 0x06B9) |
| `get_financial_file_list()` | `list[str]` | 财务文件列表**原始行**(tdxfin/gpcw.txt) |
| `get_financial_records(filename)` | `bytes` | 财务文件内容(gpcw*.zip 原始字节) |
| `get_financial_records(filename)` | `bytes` | 财报 `.dat` 原始字节(索引写 `.zip` 但服务器只有 `.dat` 时自动回退;取不到返回 `b""`) |
| `get_file_meta(filename)` | `FileMeta` | 远程文件元信息(MAC 0x1215) |
| `download_file(filename, filesize=0)` | `bytes` | 下载完整远程文件(MAC 0x1217,分块) |
| **`get_block_parsed(filename)`** | `list[TdxBlock]` | 板块文件**下载+解析**为板块成分(category 按文件名推断:0行业/2概念/3风格) |
| **`get_industry_map()`** | `dict[str, IndustryInfo]` | tdxhy.cfg **下载+解析**:`{代码: 通达信行业+申万行业}` |
| **`get_financial_file_infos()`** | `list[FinancialFileInfo]` | gpcw.txt **下载+解析**:文件名/MD5/大小 |
| **`get_financial_records_parsed(filename)`** | `list[FinancialRecord]` | gpcw*.zip **解压+解析**:每股原始 float 字段(报告期取自文件名,缺失回退头部) |
| **`get_financial_records_parsed(filename)`** | `list[FinancialRecord]` | 财报**解析**:每股原始 float 字段。可直接传 `get_financial_file_infos()` 的 `filename`——自动纠正服务器实际文件名(`.zip`/`.dat` 两种形态都支持);报告期取自文件名,缺失回退头部 |
> 解析层独立于网络层:解析器位于 `pytdxdata.codec`(纯标准库 `struct`/`zipfile`),可脱网单测;
> 原 `get_*` 返回 `bytes`/`list[str]` 的方法保持**向后兼容**,解析版为**新增**方法。
### 2.6 板块(共 6 个)
### 2.7 板块(旧接口,共 6 个) {#legacy-board}
| 方法 | 返回 | 说明 |
|------|------|------|
@@ -108,17 +153,17 @@ from pytdxdata import (
| `get_board_ranking(board_type=1, top_n=20)` | `list[dict]` | 板块涨跌幅排行 |
| `get_board_change_ranking(board_type=1, days=20, top_n=20)` | `list[dict]` | 板块 N 日涨跌幅排行(板块指数K线) |
### 2.7 MAC 扩展:竞价 / 异动 / 快照 / 资金流 / 服务器(共 5 个)
### 2.8 MAC 扩展:竞价 / 异动 / 快照 / 资金流 / 服务器(旧接口,共 5 个) {#legacy-mac}
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_auction(market, code)` | `list[AuctionItem]` | 集合竞价 |
| `get_unusual(market, start=0, count=600)` | `list[UnusualItem]` | 市场异动 |
| `get_auction(symbols)` | `list[AuctionItem]` | 集合竞价 |
| `get_unusual(market="all", *, start=0, count=600)` | `list[UnusualItem]` | 市场异动 |
| `get_symbol_info(market, code)` | `SymbolSnapshot` | 个股特征快照 |
| `get_capital_flow(market, code)` | `CapitalFlow` | 个股资金流向 |
| `get_capital_flow(symbols)` | `list[CapitalFlow]` | 个股资金流向 |
| `get_server_info()` | `ServerInfo` | 服务器交易时段信息 |
### 2.8 EX 扩展市场(港股/美股/期货/期权,共 8 个)
### 2.9 EX 扩展市场(旧接口,港股/美股/期货/期权,共 8 个) {#legacy-ex}
| 方法 | 返回 | 说明 |
|------|------|------|
@@ -131,7 +176,8 @@ from pytdxdata import (
| `get_goods_transaction(market, code, *, ymd=0, start=0, count=1800)` | `list[dict]` | 扩展市场逐笔(港股 0x23FC/0x2406) |
| `get_goods_transaction_all(market, code, ymd=0)` | `list[dict]` | 港股全量逐笔(自动翻页,≤50页/9万条) |
**合计:`TdxData` 公开异步方法 51 个**(另有 `_execute_standard/_execute_mac/_execute_ex` 等内部执行方法)。
**合计:`TdxData` 公开异步方法 63 个** = 28 个统一接口 + 33 个 deprecated 别名 + `start`/`close`
(另有 `_execute_standard` / `_execute_mac` / `_execute_ex` 等内部执行方法)。
## 三、数据模型(`pytdxdata.models`)
@@ -142,7 +188,7 @@ from pytdxdata import (
| `Market` | SZ=0 / SH=1 / BJ=2 |
| `KlinePeriod` | MIN_5=0 / MIN_15=1 / MIN_30=2 / MIN_60=3 / DAY=4 / WEEK=5 / MONTH=6 / MIN_1=7 / MIN_3=8 / YEAR=9 / SEASON=10 / YEAR_ALT=11(`is_minute` 属性) |
| `Adjust` | NONE=0 / QFQ=1 / HFQ=2 |
| `ExMarket` | 52 个扩展市场:HK_MAIN_BOARD=31 / US_STOCK=74 / CFFEX_FUTURES=47 / ZZ_FUTURES=28 / DL_FUTURES=29 / SH_FUTURES=30 / GZ_FUTURES=66 / SH_STOCK_OPTION=8 / SZ_STOCK_OPTION=9 等 |
| `ExMarket` | 46 个扩展市场:HK_MAIN_BOARD=31 / US_STOCK=74 / CFFEX_FUTURES=47 / ZZ_FUTURES=28 / DL_FUTURES=29 / SH_FUTURES=30 / GZ_FUTURES=66 / SH_STOCK_OPTION=8 / SZ_STOCK_OPTION=9 等 |
**dataclass(均为 `@dataclass(slots=True)`)**
@@ -186,17 +232,36 @@ from pytdxdata import (
| `boll(values, period=20, mult=2.0)` | 布林带 |
| `compute_indicators(high, low, close, indicators, params=None, tail=None)` | 统一入口(被 `get_stock_kline_with_indicators` 调用) |
**`pytdxdata.config`**(服务器清单)
**`pytdxdata.config`**(服务器清单与选路)
| 函数 | 说明 |
主机来源优先级链(各协议独立):`PYPYTDX_DATA_*_HOSTS` 环境变量 → **当日测速缓存** →
包内清单 `fast_pool` → 包内清单 → 代码内置常量。
| 函数 / 常量 | 说明 |
|------|------|
| `get_standard_hosts()` | 标准通道服务器列表 |
| `get_standard_hosts()` | 标准通道服务器列表(按上述优先级链解析) |
| `get_mac_hosts()` | MAC 通道服务器列表 |
| `get_ex_hosts()` | EX 扩展市场服务器列表 |
| `get_ex_handshakes()` | EX 握手方式映射 |
| `all_probe_candidates()` | 全量候选主机 `{standard, mac, ex}`(清单 ∪ 常量 ∪ env,**不按状态过滤**) |
| `is_valid_host(host)` | 主机名合法性校验(挡 mock 脏数据 / 非法条目) |
| `probe_cache_dir()` / `probe_cache_file()` | 用户级当日测速缓存目录 / 文件路径 |
| `load_probe_cache(today=None, path=None)` | 读当日测速缓存;缺失 / 损坏 / 非今日 / 版本不符 → `None` |
| `probe_disabled()` | 是否已用 `PYPYTDX_DATA_DISABLE_PROBE` 关闭测速 |
| `PROBE_CACHE_VERSION` | 测速缓存 payload 版本号 |
**`pytdxdata.server_probe`**(服务器探测,可 `python -m pytdxdata.server_probe` 运行)
`load_servers()` / `save_servers(cfg)` / `SERVERS_FILE`
**`pytdxdata.pool.probe_cache`**(当日测速:后台执行、对用户无感)
| 符号 | 说明 |
|------|------|
| `ProbeCache` | 进程内协调器;`ensure_probe()` 为幂等入口(单飞 + 原子写) |
| `schedule_probe(hosts=None)` | 连接池用:挂后台 task 并返回该 task;无事件循环时返回 `None` |
| `get_probe_cache()` | 取进程级单例 |
**`pytdxdata.server_probe`**(离线服务器探测,`python -m pytdxdata.server_probe`)
`load_servers()` / `save_servers(cfg)` / `SERVERS_FILE` / `probe_one(server, timeout, discover)`
CLI 开关:`--discover`(三种协议全测并据实修正 `protocols`,同时剔除脏记录)/
`--group standard|mac|ex` / `--refresh`(只重测 `status=ok` 的)/ `--timeout`
## 五、CLI(`tdx` 命令,来自 `python -m pytdxdata.cli`)
@@ -218,7 +283,7 @@ from pytdxdata import (
| `tdx block [filename] [--limit 30] [--codes]` | 板块文件 下载+解析(block_*.dat → 成分股) |
| `tdx industry [codes...] [--limit 30] [--search 词]` | 行业分类 下载+解析(tdxhy.cfg) |
| `tdx financial-list [--limit 30]` | 历史专业财报文件索引(gpcw.txt) |
| `tdx financial <filename> [--code X] [--limit 5] [--fields 4]` | 历史专业财报记录 下载+解析(gpcw*.zip) |
| `tdx financial <filename> [--code X] [--limit 5] [--fields 4]` | 历史专业财报记录 下载+解析(文件名自动纠正,见 `get_financial_records_parsed`) |
| `tdx server-info` | 服务器交易时段 |
| `tdx market-stat` | 市场统计 |
+68
View File
@@ -0,0 +1,68 @@
# AI 助手接入
pytdxdata 的枚举取值**完全没有直觉**(`KlinePeriod.DAY` 是 `4` 不是 `0`),
所以 AI 助手凭常识写代码**几乎必错**。为此项目提供两条 AI 通道,分工不同:
| 文件 | 面向 | 内容 |
|---|---|---|
| [`llms.txt`](https://openbot-coder.github.io/pytdxdata/llms.txt) | AI 爬虫 / 问答型模型 | 心智模型、能力分组、关键陷阱,自动随站点发布 |
| [`SKILL.md`](https://github.com/openbot-coder/pytdxdata/blob/main/SKILL.md) | AI **编程**助手 | 必守约定、枚举取值表、可运行模板、任务→方法决策表、11 条陷阱 |
`llms.txt` 解决「这个库能干什么」,`SKILL.md` 解决「代码该怎么写对」。
## 装载 SKILL.md
把文件放进你所用的 AI 助手的 skills 目录即可:
```bash
# WorkBuddy / Claude Code 风格
mkdir -p ~/.workbuddy/skills/pytdxdata
curl -o ~/.workbuddy/skills/pytdxdata/SKILL.md \
https://raw.githubusercontent.com/openbot-coder/pytdxdata/main/SKILL.md
```
也可以直接在提示词里附上该文件的 URL,或把它作为项目级 skill 放进你的仓库。
## 里面有什么
- **三条必守约定** —— 唯一入口是 `TdxData` 且必须 `async with`;标的是字符串(如 `sh600000`)
而不是 `(market, code)` 元组;返回值是 `list[dataclass]` 而不是 DataFrame
- **枚举取值表** —— `Market` / `KlinePeriod` / `Adjust` / `ExMarket` 的准确取值
- **可运行模板** —— K 线、复权、报价、逐笔、分时、批量,全部是能直接跑的代码
- **「想做什么 → 用哪个方法」决策表** —— 18 个常见需求的直接映射
- **11 条真实陷阱** —— 每条都注明后果和正确做法(如 `sh000001` 是上证指数、`sz000001` 才是平安银行)
## 为什么值得让 AI 读
同一个 6 位代码在不同市场含义不同、枚举值与直觉完全脱节、复权/1 分钟线会静默切换通道——
这些都不是「读一眼签名就能猜到」的信息。不加载技能,AI 通常会写出:
```python
# ❌ 几种典型错误
await td.get_bars("sh600000", 4, count=240) # 4 是数字字面量;应用 KlinePeriod.DAY
await td.get_bars((Market.SH, "600000")) # 统一接口只接受字符串标的,不接受元组
td.get_bars("sh600000") # 忘了 await,且没在 async with 内
df = bars.to_dataframe() # 返回值是 list[dataclass],没有这个方法
```
装载技能后这类错误基本消失。
## 给文档/模型作者的提示
改接口后请同步这几处(CI 会自动校验漂移):
- 手写清单(必须列全):[`docs/api/index.md`](api/index.md)、[`docs/API_REFERENCE.md`](API_REFERENCE.md)
- 入口与教程(只要求无过时引用):`SKILL.md`、`README.md`、`llms.txt`、`getting-started`、`cookbook`、`faq`、`cli`
校验命令:
```bash
python scripts/check_docs.py # 退出码 1 = 存在漂移
python scripts/check_docs.py --list # 打印全部公开方法名
```
## 下一步
- [接口总览](api/index.md) — 有哪些能力
- [TdxData 方法](api/tdxdata.md) — 完整签名(docstring 自动生成)
- [枚举速查](api/enums.md) — 参数到底该填几
+63
View File
@@ -0,0 +1,63 @@
# 文件解析器
通达信服务器上除了行情,还有一批**静态文件**:板块成分、行业分类、历史专业财报。
这些文件是自定义二进制格式,本项目把解析器独立成 `pytdxdata.codec` 子模块:
- **纯标准库**(`struct` / `zipfile`),可以脱网单测
- **与网络层解耦**,可以直接拿本地文件字节调用
- 每个解析函数的 docstring 里都写明了**字节格式**,方便对照排错
```python
from pytdxdata.codec import parse_block_dat, parse_tdxhy_cfg, parse_financial_dat
blocks = parse_block_dat(open("block_gn.dat", "rb").read(), "block_gn.dat")
```
## 三类文件
| 文件 | 解析函数 | 产出 | 说明 |
|---|---|---|---|
| `block_zs/gn/fg.dat` | `parse_block_dat` | `list[TdxBlock]` | 板块成分股代码列表 |
| `tdxhy.cfg` | `parse_tdxhy_cfg` | `dict[str, IndustryInfo]` | 通达信行业 + 申万行业 |
| `gpcw.txt` | `parse_financial_file_list` | `list[FinancialFileInfo]` | 财报文件索引(文件名 / MD5 / 大小) |
| `gpcw*.zip` 内 `.dat` | `parse_financial_dat` | `list[FinancialRecord]` | 每股历史财报原始字段 |
!!! note "走网络时用 TdxData 的解析方法"
如果不想自己管下载,直接用封装好的方法(内部就是调这些解析器):
`get_block_parsed()` / `get_industry_map()` / `get_financial_file_infos()` / `get_financial_records_parsed()`
— 见 [完整接口清单 → 除权 / 财务 / F10 / 文件](../API_REFERENCE.md#file-methods)。
## 关键细节
**板块类型由文件名推断**,因为文件头里没有可靠的分类字段:
| 文件名包含 | category |
|---|---|
| `zs` | `0` 行业 |
| `gn` | `2` 概念 |
| `fg` | `3` 风格 |
| 其他 | `0` |
**单条板块记录最多 400 只成分股**(代码区 2800 字节 ÷ 每只 7 字节)。
**财报报告期的来源优先级**:文件名 → `.dat` 头部内嵌值。两个都拿不到才为空。
**市场字段**:`0` = 深,`1` = 沪。
> 这里曾经有过一个 bug——上游实现用 `<6s1c1L` 导致市场字段恒判为深市,
> 本包用 `<6sBL` 修正。见 [更新日志](../changelog.md)。
## API
::: pytdxdata.codec
options:
members_order: source
show_root_heading: false
show_root_toc_entry: false
filters:
- "!^_"
## 下一步
- [协议与命令](../internals/protocol.md) — 行情数据的线上协议格式
- [场景示例 → 板块成分离线解析](../cookbook.md#offline-block-snapshot)
+116
View File
@@ -0,0 +1,116 @@
# 枚举速查
!!! danger "先看这里——本项目最容易踩的坑"
通达信的枚举取值**完全没有直觉**:`KlinePeriod.DAY` 是 **4** 不是 0 也不是 3,
`ExMarket.HK_MAIN_BOARD` 是 **31**,`Market.SZ` 是 **0**。
写死数字几乎必错,**请一律使用枚举成员**。
```python
from pytdxdata.models import Adjust, ExMarket, KlinePeriod, Market
```
## Market — 普通市场
| 成员 | 值 | 说明 |
|---|---|---|
| `Market.SZ` | `0` | 深圳 |
| `Market.SH` | `1` | 上海 |
| `Market.BJ` | `2` | 北京(北交所) |
!!! warning "代码不唯一"
**市场 + 代码**才唯一。`sh000001` 是上证指数,`sz000001` 是平安银行。
统一接口用**字符串标的**把两者一起表达(前缀即市场),避免只写 6 位数字时的歧义。
## KlinePeriod — K 线周期
| 成员 | 值 | 说明 |
|---|---|---|
| `KlinePeriod.MIN_5` | `0` | 5 分钟 |
| `KlinePeriod.MIN_15` | `1` | 15 分钟 |
| `KlinePeriod.MIN_30` | `2` | 30 分钟 |
| `KlinePeriod.MIN_60` | `3` | 60 分钟 |
| `KlinePeriod.DAY` | `4` | **日线(最常用)** |
| `KlinePeriod.WEEK` | `5` | 周线 |
| `KlinePeriod.MONTH` | `6` | 月线 |
| `KlinePeriod.MIN_1` | `7` | 1 分钟 |
| `KlinePeriod.MIN_3` | `8` | 3 分钟 |
| `KlinePeriod.YEAR` | `9` | 年线 |
| `KlinePeriod.SEASON` | `10` | 季线 |
| `KlinePeriod.YEAR_ALT` | `11` | 另一套年线编码 |
取值**与通达信协议字节一致**(`KlineCategory`)。附带一个属性:
```python
KlinePeriod.MIN_1.is_minute # True
KlinePeriod.DAY.is_minute # False
```
!!! warning "`MIN_1` 会换通道"
`MIN_1` 被强制路由到 **MAC 通道**并采用**单连接串行分页**,
避免并发分页在多服务器深度不一致时产生数据空洞。
详见 [通道与数据源](../internals/routing.md)。
## Adjust — 复权方式
| 成员 | 值 | 说明 |
|---|---|---|
| `Adjust.NONE` | `0` | 不复权(**默认**) |
| `Adjust.QFQ` | `1` | 前复权 |
| `Adjust.HFQ` | `2` | 后复权 |
`adjust != NONE` 时 K 线请求会切到 **MAC 通道**(标准通道不提供复权数据)。
!!! tip "和券商软件对不上,先差这里"
很多券商前端默认前复权,而本包默认 `NONE`。对比数据前先确认两边复权方式一致。
## ExMarket — 扩展市场 {#exmarket}
港股 / 美股 / 期货 / 期权等走通达信 **EX 通道(端口 7727)**,`market` 参数传 `ExMarket` 成员。
### 常用值速查
| 成员 | 值 | 说明 |
|---|---|---|
| `ExMarket.SH_STOCK_OPTION` | `8` | 沪股票期权 |
| `ExMarket.SZ_STOCK_OPTION` | `9` | 深股票期权 |
| `ExMarket.ZZ_FUTURES` | `28` | 郑商所期货 |
| `ExMarket.DL_FUTURES` | `29` | 大商所期货 |
| `ExMarket.SH_FUTURES` | `30` | 上期所期货 |
| `ExMarket.HK_MAIN_BOARD` | `31` | **港股主板(最常用)** |
| `ExMarket.NEEQ` | `44` | 新三板 |
| `ExMarket.CFFEX_FUTURES` | `47` | 中金所期货(股指 / 国债) |
| `ExMarket.HK_GEM` | `48` | 港股创业板 |
| `ExMarket.GZ_FUTURES` | `66` | 广期所期货 |
| `ExMarket.GE_STOCK` | `73` | 德国股票 |
| `ExMarket.US_STOCK` | `74` | **美股(最常用)** |
```python
from pytdxdata.models import KlinePeriod
# 统一接口用字符串前缀指定扩展市场(推荐):
await td.get_bars("hk00700", KlinePeriod.DAY, count=700) # 腾讯
await td.get_bars("usAAPL", KlinePeriod.DAY, count=700) # 苹果
await td.get_bars("cffex:IFL0", KlinePeriod.DAY, count=700) # 股指期货
await td.get_bars("sh_stock_option:10010971", KlinePeriod.DAY, count=700) # 沪股票期权
```
> 上表的 `ExMarket` 枚举值用于查阅与内部协议;统一接口不再直接传枚举,改用字符串前缀
> (短前缀 `hk` / `us` / `cffex` …,无短别名的成员用枚举名小写 + 冒号,如 `sh_stock_option:10010971`)。
### 完整成员列表
以下由 `mkdocstrings` 从源码实时渲染,**以源码为准**:
::: pytdxdata.models.ExMarket
options:
show_root_heading: false
show_root_toc_entry: false
members_order: source
!!! note "美股期权 / 港股期权不在其中"
通达信协议内**没有**美股、港股期权数据。美股期权需要走 CBOE 公开接口。
## 下一步
- [数据模型](models.md) — 返回对象字段
- [通道与数据源](../internals/routing.md) — 每个枚举对应哪台服务器
+108
View File
@@ -0,0 +1,108 @@
# 接口总览
对外唯一入口是 **`TdxData`** 类,所有方法都可直接 `await`,返回标准库 `dataclass` 组成的 `list`。
**v0.6+** 推荐使用**统一接口**(一个数据类型 = 一个方法,跨市场自动选路);
旧的按通道/市场分裂的接口仍可调用,但会发出 `DeprecationWarning`,**1.0 移除**。
```python
from pytdxdata import TdxData
```
!!! tip "签名不用背"
每个方法的完整签名、参数说明、返回值类型都在 **[TdxData 方法](tdxdata.md)** ,
由 `mkdocstrings` **从源码 docstring 实时渲染**——不可能过期。
本页只做「有哪些能力」的地图。
## 生命周期
| 方法 | 说明 |
|------|------|
| `async start()` | 启动:服务器探测 + 预建连接 + 初始化缓存 |
| `async close()` | 关闭全部连接池与缓存 |
| `async with TdxData() as td:` | 上下文管理器,自动 start / close |
---
## 统一接口(v0.6+ 推荐){#unified}
标的一律用**字符串写法**(`sz000001` / `hk00700` / `usAAPL` / `cffex:IFL0`,
裸 6 位数字 = 沪市指数)。跨市场按通道自动分组并发,返回值统一带 `symbol` 字段。
### 标的清单
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_universe(market=None)` | `list[SecurityInfo]` | 跨市场标的清单(A 股 + 港股 + 美股 + 期货/期权),EX 通道结果一次拉全后内存过滤 |
### 报价
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_quotes(symbols, *, fields=None)` | `list[SecurityQuote]` | 跨市场混合报价(A 股标准通道有五档 bid/ask + 涨跌停价;给了 `fields` 走 MAC/EX 字段位通道有 name) |
| `get_snapshot(symbols)` | `list[SymbolSnapshot]` | 个股特征快照(当日/换手/活跃度,A 股) |
| `get_auction(symbols)` | `list[AuctionItem]` | 集合竞价(A 股) |
| `get_capital_flow(symbols)` | `list[CapitalFlow]` | 个股资金流向(A 股) |
| `get_market_stat()` | `MarketStat` | 全市场统计(涨跌家数 / 总额 / 市值 / 涨跌停数) |
### K 线
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_bars(symbols, period, *, start, count, adjust, start_date, end_date, concurrency)` | `list[SecurityBar]` | 跨市场 K 线(自动判指数、复权走 MAC、并发分页、日期区间二分定位,支持混合 A 股+港股+期货) |
| `get_indicators(symbols, indicators, *, period, count, adjust, params)` | `list[IndicatorSet]` | K 线 + 技术指标(MACD / KDJ / RSI / BOLL / MA / EMA),返回 `bars + indicators` 组合 |
### 逐笔与分时
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_ticks(symbols, *, date, start, count, concurrency)` | `list[TransactionRecord]` | 跨市场逐笔成交(A 股 MAC `0x122F` 含 `trade_count`;港股 EX `0x23FC` / `0x2406`;其他扩展市场 MAC) |
| `get_minutes(symbols, *, date, sampling, concurrency)` | `list[MinuteBar]` | 跨市场分时(A 股 MAC `0x122D` 支持历史;`sampling=True` 取缩略采样约 240 点) |
### 公司信息 / 除权 / 财务 / 文件
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_f10(symbol, section=None, *, offset, length)` | `list \| str` | F10 公司资料(`section=None` 返回目录,给了返回正文) |
| `get_xdxr(symbols)` | `list[XdxrRecord]` | 除权除息历史(A 股) |
| `get_finance(symbols)` | `list[FinanceRecord]` | 财务快照(A 股,返回列表,无数据的标的跳过) |
| `get_price_limits(symbol, name, pre_close, listed_days)` | `tuple[float\|None, float\|None]` | 涨跌停价(本地计算,无网络) |
| `get_file(name)` | `bytes` | 服务器文件原始字节(`block_*.dat` / `tdxhy.cfg` / `tdxfin/*` / MAC 远程文件) |
| `get_block_parsed(filename)` | `list[TdxBlock]` | 板块文件**下载 + 解析**为成分股 |
| `get_industry_map()` | `dict[str, IndustryInfo]` | `tdxhy.cfg` **下载 + 解析** |
| `get_financial_file_infos()` | `list[FinancialFileInfo]` | `gpcw.txt` **下载 + 解析** |
| `get_financial_records_parsed(filename)` | `list[FinancialRecord]` | `gpcw*.zip` **解压 + 解析** |
### 市场 / 板块
| 方法 | 返回 | 说明 |
|------|------|------|
| `get_unusual(market="all", *, start, count)` | `list[UnusualItem]` | 市场异动(A 股,`"all"` = 深 + 沪) |
| `get_server_info()` | `ServerInfo` | 服务器交易时段信息 |
| `get_kline_offset(offset, count)` | `tuple[int, int]` | K 线偏移信息(MAC) |
| `get_boards(kind="all", *, count)` | `list[BoardInfo]` | 板块列表(`"all"` / `"industry"` / `"concept"` / `"style"`) |
| `get_board_members(board, *, fields, count)` | `list[SecurityQuote]` | 板块成分股报价(返回归一报价模型) |
| `get_board_of(symbols)` | `list[BelongBoard]` | 个股所属板块(A 股) |
| `get_board_summary(board)` | `dict` | 板块汇总(成分数 / 成交额 / 主力净流入 / 涨跌家数) |
| `get_board_ranking(kind="industry", *, top_n)` | `list[dict]` | 板块当日涨跌幅排行 |
| `get_board_change_ranking(kind="industry", *, days, top_n)` | `list[dict]` | 板块 N 日涨跌幅排行 |
---
## 旧接口(deprecated,1.0 移除){#legacy}
旧接口按通道/市场分裂(33 个 deprecated 别名),保留向后兼容但仍可用。
完整旧方法列表见 `docs/API_REFERENCE.md`。
!!! warning "迁移建议"
各通道独立方法(如 `get_kline` / `get_transactions`)在 v0.6 内仍可调用,且仍接受
`(market, code)` 写法,但会发出 `DeprecationWarning`。
统一接口(`get_quotes` / `get_bars` / `get_ticks` / `get_xdxr` / `get_finance` /
`get_auction` / `get_capital_flow` 等)一律只接受字符串标的(如 `"sz000001"`)。
迁移对照见 [更新日志](../changelog.md)。
## 下一步
- [TdxData 方法](tdxdata.md) — 完整签名(自动生成)
- [枚举速查](enums.md) — 参数到底该填几
- [数据模型](models.md) — 返回对象有哪些字段
+41
View File
@@ -0,0 +1,41 @@
# 技术指标
纯函数实现,**不依赖 pandas / numpy**,输入 `list[float]` 输出 `list[float]`(或元组),
可直接在任意序列上用。也被 `TdxData.get_stock_kline_with_indicators()` 内部调用。
```python
from pytdxdata import indicator
```
## 快速示例
```python
closes = [b.close for b in bars]
macd_line, signal, hist = indicator.macd(closes)
rsi14 = indicator.rsi(closes, period=14)
upper, mid, lower = indicator.boll(closes, period=20, mult=2.0)
```
指标计算前端数据不足时,结果用 `None` 占位,长度与输入一致——**不会截断**,
方便直接和 K 线按下标对齐。
## API
::: pytdxdata.indicator
options:
members_order: source
show_root_heading: false
show_root_toc_entry: false
filters:
- "!^_"
## 与 get_stock_kline_with_indicators 的关系
服务端侧的指标请求走 MAC 通道(`get_stock_kline_with_indicators`,服务端算好返回);
本地侧的指标走本模块。两者不互相依赖:
| 方式 | 位置 | 适用 |
|---|---|---|
| `get_stock_kline_with_indicators(...)` | 服务端计算 | 想少传数据、服务端算子齐全时 |
| `pytdxdata.indicator.*` | 本地计算 | 需要自定义参数、离线复算、和其他数据源混算 |
+80
View File
@@ -0,0 +1,80 @@
# 数据模型
全部数据模型位于 `pytdxdata.models`,统一为 `@dataclass(slots=True)`。
选择 dataclass 而不是 pandas DataFrame 是刻意的:**零依赖 + 零转换开销**,
需要 DataFrame 时你自己转(一行的事,见 [场景示例 → 转成 pandas](../cookbook.md#to-pandas))。
## 导入方式
包级只导出 4 个枚举 + 6 个核心模型:
```python
from pytdxdata import Market, ExMarket, KlinePeriod, Adjust
from pytdxdata import (
SecurityBar, SecurityQuote, TransactionRecord,
MinuteBar, XdxrRecord, FinanceRecord,
)
```
其余模型需要从子模块导入:
```python
from pytdxdata.models import TdxBlock, IndustryInfo, FinancialFileInfo, FinancialRecord
from pytdxdata.models import BoardInfo, MemberQuote, AuctionItem, CapitalFlow
```
## 模型地图
| 模型 | 代表什么 | 从哪来 |
|---|---|---|
| `SecurityBar` | 一根 K 线 | `get_bars` / `get_indicators` |
| `IndexBar` | 指数 K 线(继承 `SecurityBar`) | `get_bars` |
| `SecurityQuote` | 五档报价快照 | `get_quotes` / `get_board_members` |
| `SecurityInfo` | 证券列表条目(代码 / 名称 / 前收) | `get_universe` |
| `TransactionRecord` | 一笔成交 | `get_ticks` |
| `MinuteBar` | 一分钟分时点 | `get_minutes` |
| `XdxrRecord` | 一次除权除息事件 | `get_xdxr` |
| `FinanceRecord` | 财务**快照**(最新一期,36 字段) | `get_finance` |
| `FinancialRecord` | 历史专业财报(`gpcw*.zip`,多报告期) | `get_financial_records_parsed` |
| `FinancialFileInfo` | 财报文件索引条目 | `get_financial_file_infos` |
| `TdxBlock` | 一个板块及其成分股 | `get_block_parsed` |
| `IndustryInfo` | 一只股票的行业归属 | `get_industry_map` |
| `BoardInfo` | 板块列表条目(含领涨股) | `get_boards` |
| `MemberQuote` | 成分股报价(MAC 原始字段) | 旧 `get_stock_quotes` / `get_stock_quotes_list` |
| `BelongBoard` | 个股所属板块 | `get_board_of` |
| `AuctionItem` | 集合竞价撮合点 | `get_auction` |
| `UnusualItem` | 一笔市场异动 | `get_unusual` |
| `SymbolSnapshot` | 个股特征快照 | `get_snapshot` |
| `GoodsItem` | 扩展市场商品 | 旧 `get_goods_list` |
| `ServerInfo` | 服务器交易时段 | `get_server_info` |
| `CapitalFlow` | 个股资金流向 | `get_capital_flow` |
| `MarketStat` | 全市场统计 | `get_market_stat` |
| `FileMeta` | 远程文件元信息 | `get_file_meta` |
!!! warning "`FinanceRecord` vs `FinancialRecord` 只差一个字母"
但它们完全不同:
| | `FinanceRecord` | `FinancialRecord` |
|---|---|---|
| 来源 | `get_finance()` — 标准通道 | `get_financial_records_parsed()` — 服务器文件 |
| 内容 | **最新一期**财务快照 | **历史多报告期**专业财报 |
| 结构 | 具名属性(`zongguben`、`jingzichan` ...) | `fields: list[float]`,原始字段数组 |
| 单位 | 万元 / 万股 | 原始 float,需自行按字段语义换算 |
## 完整字段定义
以下由 `mkdocstrings` 从源码实时渲染(**以源码为准**):
::: pytdxdata.models
options:
members_order: source
show_root_heading: false
show_root_toc_entry: false
filters:
- "!^_"
## 下一步
- [枚举速查](enums.md) — `market` / `period` 参数取值
- [TdxData 方法](tdxdata.md) — 哪个方法返回哪个模型
+45
View File
@@ -0,0 +1,45 @@
# TdxData 方法签名
> 本页由 `mkdocstrings` **从 `src/pytdxdata/api.py` 的 docstring 实时渲染**。
> 你看到的签名就是当前代码的签名——不需要手动维护,也就不会过期。
## 用法
```python
import asyncio
from pytdxdata import TdxData
from pytdxdata.models import KlinePeriod
async def main():
async with TdxData() as td:
bars = await td.get_bars("sh600000", KlinePeriod.DAY, count=240)
print(bars[-1])
asyncio.run(main())
```
!!! tip "本页太长?"
想看「有哪些能力」的地图,去 [接口总览](index.md)。
本页是完整的签名字典,适合用浏览器 `Ctrl+F` 搜方法名。
## 完整定义
::: pytdxdata.TdxData
options:
members_order: source
group_by_category: true
show_category_heading: true
show_root_heading: true
show_root_full_path: false
show_signature_annotations: true
separate_signature: true
merge_init_into_class: true
docstring_section_style: list
filters:
- "!^_"
## 相关
- [枚举速查](enums.md) — 参数该填哪个成员
- [数据模型](models.md) — 返回值有哪些字段
- [场景示例](../cookbook.md) — 组合用法
+1
View File
@@ -0,0 +1 @@
--8<-- "CHANGELOG.md"
+125
View File
@@ -0,0 +1,125 @@
# 命令行工具
安装后自带 `tdx` 命令(等同 `python -m pytdxdata.cli`)。**19 个子命令**,覆盖全部主要能力,适合快速验证、脚本管道和临时取数。
```bash
tdx --help # 查看全部子命令
tdx <cmd> --help # 查看单个子命令参数
```
## 标的写法
几乎所有取行情的命令都接受同一个标的语法:
| 写法 | 含义 | 示例 |
|---|---|---|
| `sz000001` | 深市 | 平安银行 |
| `sh600000` | 沪市 | 浦发银行 |
| `bj920992` | 北交所 | — |
| `hk00700` | 港股 | 腾讯控股 |
| `usAAPL` | 美股 | 苹果 |
| `cffex:IFL0` | 期货(交易所前缀) | 中金所股指 |
| `000001` | **6 位纯数字 = 指数** | 上证指数 |
期货交易所前缀:`cffex:` 中金 / `shf:` 上期 / `zz:` 郑商 / `dl:` 大商 / `hk:` 港交所 / `gz:` 广期所。
## 行情
```bash
tdx quotes sz000001 sh600000 hk00700 # 五档报价(可多标的)
tdx info sz000001 # 个股特征快照
tdx market-stat # 全市场统计(涨跌家数/总额/市值/涨跌停数)
```
## K 线
```bash
tdx kline sz000001 --period day --count 30 --adjust qfq
tdx kline sz000001 --period min1 --count 240
tdx kline cffex:IFL0 --count 30 # 期货
tdx index 000001 --count 30 # 指数
```
| 选项 | 默认 | 说明 |
|---|---|---|
| `--period` | `day` | `min1` / `min3` / `min5` / `min15` / `min30` / `min60` / `day` / `week` / `month` / `season` / `year` |
| `--count` | `30` | 条数;`>800` 自动并发分页 |
| `--start` | `0` | 起始偏移(0 = 最新) |
| `--adjust` | `none` | `none` / `qfq`(前复权)/ `hfq`(后复权) |
## 逐笔与分时
```bash
tdx transactions sz000001 --count 50 # 今日逐笔(含成交笔数)
tdx transactions sz000001 --date 20260811 --count 50 # 历史逐笔
tdx minute sz000001 # 今日分时
tdx minute sz000001 --date 20260811 # 历史分时
```
## 板块
```bash
tdx board list --type 1 # 板块列表(0=全部 1=行业 2=概念)
tdx board members 881001 --count 30 # 板块成分股报价
tdx board ranking --type 1 --top 10 # 板块涨跌幅排行
tdx board change --type 1 --days 5 --top 10 # 板块 N 日涨跌幅排行
```
## 证券列表
```bash
tdx list --market sz --count 100 # 市场证券列表(--market sz/sh/bj)
```
## 其他标准通道数据
```bash
tdx xdxr sz000001 # 除权除息历史
tdx finance sz000001 # 财务快照
tdx auction sz000001 # 集合竞价
tdx flow sz000001 # 资金流向
tdx unusual --market sh --count 30 # 市场异动
tdx server-info # 服务器交易时段
```
## 服务器文件(板块 / 行业 / 财报)
这四个命令是 **下载 + 解析一步到位** 的,不需要自己拆二进制格式。
```bash
# 板块文件(block_zs.dat 行业 / block_gn.dat 概念 / block_fg.dat 风格)
tdx block block_gn.dat --limit 10 # 列出板块与成分股数量
tdx block block_gn.dat --limit 3 --codes # 额外打印成分股代码
# 行业分类(tdxhy.cfg)
tdx industry 600000 000001 --search 银行 # 指定代码 / 关键词搜索
tdx industry --limit 30 # 只看前 30 条
# 历史专业财报
tdx financial-list # 索引:文件名 / MD5 / 大小(gpcw.txt)
tdx financial gpcw20260331.zip --limit 5 # 下载 + 解析(服务器实际给 .dat 时自动回退)
tdx financial gpcw20260331.zip --code 600000 --fields 8 # 只取指定股票、打印更多字段
```
## 组合用法
CLI 输出是纯文本,适合直接进管道:
```bash
# 把科创板全部股票代码喂给循环
tdx list --market sh --count 2000 | grep '^68' | head -20 | while read code; do
tdx kline "sh${code}" --count 5
done
# 快速扫一遍概念板块涨幅榜
tdx board ranking --type 2 --top 30
```
!!! tip "什么时候该用 CLI,什么时候该写代码"
- **临时看数 / 验证连通性 / shell 脚本** → CLI
- **批量拉取、落库、回测** → 用 Python API,CLI 每次调用都要重建连接池,批量场景开销大
## 下一步
- [场景示例](cookbook.md) — Python API 的批量用法
- [接口总览](api/index.md) — CLI 背后的方法
+116
View File
@@ -0,0 +1,116 @@
# 参与贡献
欢迎 Issue / PR。这个项目对「数据正确性」的要求高于「功能数量」——一个算错的字段比没有这个字段糟糕得多。
## 开发环境
```bash
git clone git@github.com:openbot-coder/pytdxdata.git
cd pytdxdata
uv sync # 建虚拟环境 + 安装 CLI + 装测试依赖
```
要求 Python **≥ 3.11**。项目用 `uv` 管理依赖和构建,构建后端是 `uv_build`。
## 跑测试
```bash
.venv/Scripts/python.exe -m pytest tests/ -q # Windows
.venv/bin/python -m pytest tests/ -q # Linux / macOS
```
!!! danger "不要用 `uv run pytest`(Windows)"
Windows 上会报 `uv trampoline failed to canonicalize script path`。直接调 venv 里的解释器。
!!! warning "Windows 上异步测试会卡死"
根因是 `asyncio` 建事件循环时用到的回环 `socketpair` 被本地代理 / 安全软件拦截。
详见 [常见问题 → 开发与测试](faq.md)。
因此**CI 在 Linux 上跑首轮异步验证**;Windows 侧只能做同步驱动验证。
现有测试全部是 **mock 驱动、不连网络** 的离线测试(`tests/test_api.py` 里的
`FakeApiConn` / `FakePool` 就是为这个准备的)。新增功能请沿用这个模式,
不要把真实网络请求写进单测。
## 代码约定
| 约定 | 说明 |
|---|---|
| 数据模型 | 全部 `@dataclass(slots=True)`,集中在 `models/__init__.py`(无子模块) |
| 解析器 | 统一放 `codec/`,**纯标准库**(`struct` / `zipfile`),做到脱网可单测 |
| API 兼容性 | **保持向后兼容**。新增能力用新方法名(如 `get_block_parsed`),不改旧方法签名或返回值 |
| 类型注解 | 全部公开接口必须有完整注解(`Typing :: Typed`) |
| 依赖 | 运行时不加新依赖是本项目的核心卖点,PR 里请勿引入 |
### 新增一个行情接口的完整步骤
1. `protocol/commands/<域>.py` — 实现命令类(帧组装 + 响应解析)
2. `router.py` — 若需要按命令选通道,在这里登记
3. `models/__init__.py` — 加返回的 dataclass / 枚举
4. `api.py` — 加 `TdxData` 公开方法
5. `cli.py` — 可选,加子命令
6. `tests/` — 离线测试(构造字节流 → 断言解析结果)
7. 文档 — 更新 `docs/api/index.md` 的方法表 + `docs/API_REFERENCE.md`
> 第 7 步别漏。历史上已经发生过「加了方法但文档没跟上」的漂移。
## 文档
文档站是 MkDocs + Material,配置在 `mkdocs.yml`,源文件在 `docs/`。
```bash
uv sync --group docs
uv run mkdocs serve # http://127.0.0.1:8000 实时预览
uv run mkdocs build # 产出到 site/
```
| 内容类型 | 写到哪 |
|---|---|
| 30 秒能看懂的东西、特性表、徽章 | `README.md`(**保持精简**) |
| 教程、场景示例、CLI 用法、原理 | `docs/` 对应页面 |
| 每个方法的参数 / 返回值 | `docs/api/`(**从 docstring 自动生成,不要手写**) |
| 版本变更 | `CHANGELOG.md`(唯一来源,文档站通过 snippet 引入) |
!!! tip "API 文档不要手抄"
`docs/api/tdxdata.md` 这类页面用 `mkdocstrings` 直接从 `api.py` 的 docstring 渲染。
你只要把 docstring 写好,文档就自动是对的。手抄签名一定会漂移。
## 提交与发布
分支模型:`develop` → PR → `main`。
```bash
git checkout -b feat/xxx
# ... 改代码 ...
.venv/Scripts/python.exe -m pytest tests/ -q
git commit -m "feat: xxx"
git push origin feat/xxx
```
### 发布流程(维护者)
1. 改 `pyproject.toml` + `src/pytdxdata/__init__.py` 的版本号
2. **`uv lock`** —— 同步 `uv.lock`,否则 CI 的 `uv sync --locked` 会失败
3. 提交并 push 到 `main`
4. 打标签并推送:
```bash
git tag v0.6.0
git push origin v0.6.0
```
推 tag 会自动触发 GitHub Actions:**test → build(含版本号一致性校验)→ OIDC 免密钥发布到 PyPI**。
不需要本地 token,也不需要 `twine`。
!!! warning "tag 已推送但发布失败时"
同名 tag **不能直接重推**(push 无变化,workflow 不会触发)。先删再推:
```bash
git push --delete origin v0.6.0
git tag -d v0.6.0 && git tag v0.6.0
git push origin v0.6.0
```
或直接手动触发:`gh workflow run release.yml --ref v0.6.0`
文档站由 `.github/workflows/docs.yml` 在 push `main` 时自动部署到
<https://openbot-coder.github.io/pytdxdata/>。
+242
View File
@@ -0,0 +1,242 @@
# 场景示例
每个片段都是完整可跑的。共同前提:
```python
import asyncio
from pathlib import Path
from pytdxdata import TdxData
from pytdxdata.models import Adjust, KlinePeriod
```
## 全市场日线批量落库
传多标的时,连接池会把不同股票分配到不同服务器——这正是它比逐个 `await` 快的原因。
```python
async def dump_all_daily():
async with TdxData(cache_dir=Path("./tdx_cache")) as td:
infos = await td.get_universe("sz") # 缓存 1 天
symbols = [i.symbol for i in infos] # ["sz000001", ...]
bars = await td.get_bars(
symbols,
KlinePeriod.DAY,
count=800,
adjust=Adjust.QFQ,
concurrency=12,
)
got = {b.symbol for b in bars}
print(f"{len(got)} / {len(symbols)} 只拿到数据")
# bars 是扁平 list[SecurityBar](按标的/时间排序),落库 / 写 parquet 都行
if bars:
print(bars[-1].symbol, bars[-1].datetime, bars[-1].close)
```
!!! tip "分页与并发的取舍"
`concurrency` 不是越大越好。单台服务器有连接上限,`concurrency` 超过 `pool_max × 服务器数`
之后只会排队。实践值:**8~16**。
## 分钟线增量更新
只拉「上次之后」的部分,用 `get_bars(start_date=...)` 省掉全量重拉。
```python
async def update_minute(symbol: str, last_dt):
async with TdxData(cache_dir=Path("./tdx_cache")) as td:
rows = await td.get_bars(symbol, KlinePeriod.MIN_1, start_date=last_dt)
return [r for r in rows if r.datetime > last_dt]
```
!!! warning "1 分钟 K 线走 MAC 单连接串行分页"
这是刻意设计:并发分页会把不同页分到不同服务器,而各服务器**历史深度不一致**,
拼接后会出现**非确定性数据空洞**。所以 `MIN_1` 强制单连接串行(见 [通道与数据源](internals/routing.md))。
## 报价轮询
```python
async def poll_quotes(symbols, interval=5.0):
async with TdxData() as td:
while True:
quotes = await td.get_quotes(symbols) # >80 只自动切批;缓存 TTL 5s
for q in quotes:
print(q.code, q.price, q.bid[0], q.ask[0])
await asyncio.sleep(interval)
```
> 缓存 TTL 与轮询间隔对齐时,重复轮询几乎 0 网络开销。但注意通达信公开源本身是
> **15 分钟延时**数据,别拿它做实时交易决策。
## 板块轮动 / 领涨股
```python
async def sector_rotation():
async with TdxData() as td:
# 近 5 日概念板块涨幅排行
top = await td.get_board_change_ranking(kind="concept", days=5, top_n=10)
for row in top:
print(row)
# 拿第一名板块的成分股
symbol = top[0]["symbol"] if "symbol" in top[0] else "881001"
members = await td.get_board_members(symbol, count=20)
for m in members[:5]:
print(m.code, m.name, m.fields)
# 板块资金汇总
print(await td.get_board_summary(symbol))
```
## 个股所属板块(反向查询)
```python
async def belong(symbol: str):
async with TdxData() as td:
for b in await td.get_board_of(symbol):
print(b)
```
## 逐笔复盘
```python
async def review_transactions(symbol: str, ymd: int):
async with TdxData() as td:
rows = await td.get_ticks(symbol, date=ymd, count=2000)
total = sum(r.trade_count or 0 for r in rows)
buy = sum(r.vol for r in rows if r.bs_flag == 0) # 主动买
sell = sum(r.vol for r in rows if r.bs_flag == 1) # 主动卖
print(f"{ymd} 总成交笔数={total} 主动买={buy} 主动卖={sell}")
```
## 财务因子快照
```python
async def finance_snapshot(symbols):
async with TdxData() as td:
for fin in await td.get_finance(symbols): # 标准通道,最新快照
print(fin.symbol, fin)
```
历史专业财报(`gpcw*`,含多报告期)走文件接口。
!!! warning "索引里的文件名与服务器实际不一致"
`tdxfin/gpcw.txt` 索引里写的是 `gpcwYYYYMMDD.zip`,但服务器实际只提供**未压缩的**
`tdxfin/gpcwYYYYMMDD.dat` —— 这些差异已由 `get_financial_records_parsed()` 内部处理,
直接把索引里的 `filename` 传进去即可。
另外索引里**含有尚未生成的占位条目**(`filesize` 只有百来字节),取它们会得到空列表。
想拿最新一期可用数据,先按体积过滤:
```python
usable = [fi for fi in infos if fi.filesize > 500_000] # 排除占位条目
records = await td.get_financial_records_parsed(usable[0].filename)
```
```python
async def history_financials(code: str):
async with TdxData(cache_dir=Path("./tdx_cache")) as td:
infos = await td.get_financial_file_infos() # 索引
records = await td.get_financial_records_parsed(infos[-1].filename)
row = next((r for r in records if r.code == code), None)
if row:
print(row.report_date, row.fields[:8])
```
## 行业分类映射
```python
async def industry_lookup(codes):
async with TdxData(cache_dir=Path("./tdx_cache")) as td:
hy = await td.get_industry_map() # {6位代码: IndustryInfo}
for c in codes:
info = hy.get(c)
if info:
print(c, info.tdx_industry, info.sw_industry)
```
## 板块成分(离线解析) {#offline-block-snapshot}
`get_block_parsed` 拿到的是纯 dataclass,落成本地 JSON 后**完全脱网可用**——
适合做「板块成分快照」的定时任务。
```python
import json
async def snapshot_blocks():
async with TdxData(cache_dir=Path("./tdx_cache")) as td:
all_blocks = []
for fn in ("block_zs.dat", "block_gn.dat", "block_fg.dat"):
for b in await td.get_block_parsed(fn):
all_blocks.append({
"name": b.name,
"category": b.category,
"codes": b.codes,
})
Path("blocks.json").write_text(
json.dumps(all_blocks, ensure_ascii=False), encoding="utf-8"
)
```
## 港股 / 美股 / 期货 / 期权
```python
async def ex_markets():
async with TdxData() as td:
hk = await td.get_bars("hk00700", KlinePeriod.DAY, count=700)
us = await td.get_bars("usAAPL", KlinePeriod.DAY, count=700)
fut = await td.get_bars("cffex:IFL0", KlinePeriod.DAY, count=700)
opt = await td.get_bars("sh_stock_option:10010971", KlinePeriod.DAY, count=700)
print(len(hk), len(us), len(fut), len(opt))
# 港股全量逐笔(自动翻页,≤50 页 / 9 万条)
ticks = await td.get_ticks("hk00700", count=None)
print(len(ticks))
```
## 转成 pandas {#to-pandas}
包本身不带 pandas 依赖,但转换是一行的事:
```python
import pandas as pd
async def to_dataframe(symbol: str):
async with TdxData() as td:
bars = await td.get_bars(symbol, KlinePeriod.DAY, count=800)
df = pd.DataFrame([{
"dt": b.datetime, "open": b.open, "high": b.high,
"low": b.low, "close": b.close, "vol": b.vol, "amount": b.amount,
} for b in bars])
return df.set_index("dt")
```
## 长驻服务(FastAPI)
!!! danger "不要每次请求都新建 TdxData"
池与缓存都挂在实例上,每请求新建 = 每请求重建连接池 + 缓存全部失效。
```python
from contextlib import asynccontextmanager
from pathlib import Path
from fastapi import FastAPI, Request
@asynccontextmanager
async def lifespan(app: FastAPI):
async with TdxData(cache_dir=Path("./tdx_cache"), pool_min=4, pool_max=16) as td:
app.state.td = td
yield
app = FastAPI(lifespan=lifespan)
@app.get("/kline/{symbol}")
async def kline(symbol: str, request: Request):
td = request.app.state.td
bars = await td.get_bars(symbol, KlinePeriod.DAY, count=30)
return [{"dt": str(b.datetime), "close": b.close} for b in bars]
```
## 下一步
- [接口总览](api/index.md) — 全部方法
- [连接池与缓存](internals/cache-pool.md) — 调优 `pool_min` / `pool_max` / TTL
+177
View File
@@ -0,0 +1,177 @@
# 常见问题
## 数据与来源
??? question "数据是实时的吗?"
不是。行情来自通达信**公开**行情服务器,本身是 **15 分钟延时**数据。
需要实时数据请使用券商行情(迅投 QMT / 兴业 SMT-Q / 同花顺 等)。
本项目定位是**历史数据与研究**——日线、分钟线、逐笔、财报这些历史数据是完整且稳定的。
??? question "需要账号吗?要付费吗?"
不需要。通达信公开行情服务器无需注册,直接 TCP 连接即可。本项目也不收任何费用。
??? question "为什么 SHA 000001 和 SZ 000001 完全不一样?"
同一个 6 位代码在不同市场里是**不同标的**:
| 市场 | 代码 | 标的 |
|---|---|---|
| SH | `000001` | 上证指数 |
| SZ | `000001` | 平安银行 |
代码不唯一,**市场 + 代码**才唯一。统一接口用**字符串标的**把两者一起表达
(`sh000001` / `sz000001`),避免只写 6 位数字时的歧义。
??? question "为什么报价格式有时候是 2 位小数,有时候是 3 位?"
价格小数位按**品种**推断:股票 2 位,指数 / ETF / 可转债 3 位。
模型里的 `decimal_point` 字段就存了这个信息,需要自己格式化时以它为准。
## 连接与网络
??? question "连不上服务器 / 全部超时怎么办?"
服务器可用性会随时间变化(下线、换 IP、封禁)。本包**当日首次启动会自动后台测速**并把
可达主机按延迟排序缓存,多数情况下无需手工干预。按顺序排查:
1. **删掉当日测速缓存**,让下次启动重新测速——缓存里可能存着今天刚挂掉的节点
(路径见 [安装与配置](getting-started.md#当日自动测速无感))。
2. 手工指定主机。优先级最高,**直接跳过测速与缓存**:
```bash
PYPYTDX_DATA_STANDARD_HOSTS=1.2.3.4,5.6.7.8 python your_script.py
```
或在代码里传入(**只填主机名**,端口由 `port=` 统一指定):
```python
async with TdxData(standard_servers=["1.2.3.4"]) as td: ...
```
3. 离线重生成随包清单(该脚本会真实拉一段 K 线,剔除「握手正常但返回空」的坏节点):
```bash
python -m pytdxdata.server_probe
```
4. 检查出口网络策略——标准 / MAC 端口 **7709**、EX 端口 **7727** 需要放通。
5. 若在用代理软件,注意有些本地代理会劫持回环 TCP,导致 asyncio 建事件循环都卡住
(见下方「在 Windows 上测试卡死」)。
??? question "启动时会变慢吗?会不会在后台偷偷联网?"
会有一次**当日首次启动测速**,但完全在后台,对调用方无感:
- **不阻塞** `start()`、**不打印**任何东西、失败**静默降级**(绝不抛给调用方)
- 结果只缓存到用户级目录(**不写安装目录**),**当天后续启动直接复用、不再重测**
- 覆盖**全部候选**主机(含暂时被挤下去的),所以「上次慢、这次快」的节点能回来
三个开关:`PYPYTDX_DATA_DISABLE_PROBE=1` 关掉测速、
`PYPYTDX_DATA_CACHE_DIR` 改缓存位置、
`PYPYTDX_DATA_{STANDARD,MAC,EX}_HOSTS` 强制指定主机。
详见 [安装与配置 → 当日自动测速](getting-started.md#当日自动测速无感)。
??? question "公司网络 / 代理环境下失败"
通达信协议是裸 TCP,不走 HTTP 代理。如果环境强制走代理,需要把 `7709` / `7727`
配成直连(bypass)。云服务器上常见问题是安全组只放通了 80/443。
??? question "连接池要配多大?"
默认 `pool_min=3 / pool_max=12` 覆盖绝大多数场景。经验值:
| 场景 | 建议 |
|---|---|
| 偶发查询、CLI | 默认即可 |
| 批量落库(`get_bars` 传多标的) | `pool_max=16`、`concurrency=8~16` |
| Web 服务多并发 | `pool_max=24`,并确保单实例复用 |
再大只是排队,不会更快——瓶颈是对端服务器的连接上限。
## 数据正确性
??? question "K 线 `count` 给很小的时候返回空?"
已知问题:标准通道部分服务器在 `count < 100` 时返回空数据。
分页器已强制 `min_page=100` 规避,正常调用不会触发。
若你绕过分页器直接把 `start/count` 传给底层命令,需要自己处理。
??? question "1 分钟 K 线明明能并发,为什么是串行的?"
**刻意设计**。并发分页会把不同页分配到不同服务器,而各服务器的历史深度不一致;
拼接深度不同的分页,`stop_when_short` 会导致**非确定性数据丢失**。
所以 `KlinePeriod.MIN_1` 强制路由到 MAC 通道并**单连接串行分页**。
其他周期(`MIN_5` 及以上)不受影响,仍走并发分页。
??? question "为什么日线数据和券商软件对不上?"
按顺序检查:
1. **复权方式**是否一致 —— 券商常默认前复权,而本包默认 `Adjust.NONE`(不复权)
2. **是否含未收盘的那根** —— 盘中最后一根是动态的
3. 分钟线注意**数据来源深度**不同
??? question "缓存会不会返回过期数据?"
缓存按数据类型分级 TTL,不会返回超出 TTL 的数据:
| 数据类型 | TTL |
|---|---|
| 实时报价 | 5s |
| 分钟 K 线 | 60s |
| 日 K 线 | 当天 |
| 复权 K 线 | 1 天 |
| 历史逐笔 | 永久 |
需要绕开缓存时,用新的 `cache_dir`,或直接不传 `cache_dir`(仅内存缓存)。
## 市场覆盖
??? question "支持哪些市场?"
**标准通道**:沪 / 深 / 北(A 股)、指数、ETF、可转债。
**EX 通道**:港股、美股、期货、期权等 **46 个市场**,完整清单见 [枚举速查](api/enums.md#exmarket)。
??? question "美股期权 / 港股期权能拿吗?"
不能。通达信协议内**无美股 / 港股期权数据**。
美股期权可用 CBOE 公开接口获取。
??? question "数据能存下来离线用吗?"
能。所有方法返回的都是纯 Python `dataclass`,序列化完全自主。
服务器文件类的解析方法(板块 / 行业 / 财报)尤其适合做「快照落盘」——
解析后就是普通 dataclass,落 JSON 后**完全脱网可用**。见 [场景示例](cookbook.md#offline-block-snapshot)。
## 开发与测试
??? question "本机 `uv run pytest` 报 trampoline 错误?"
Windows 上已知问题。直接调 venv 里的解释器:
=== "Windows"
```bash
.venv/Scripts/python.exe -m pytest tests/ -q
```
=== "Linux / macOS"
```bash
.venv/bin/python -m pytest tests/ -q
```
??? question "本地测试卡死 / asyncio 事件循环建不起来?"
**根因**:Windows 上 `asyncio.new_event_loop()` 内部要建一个 `socket.socketpair()`,
走的是回环 TCP;**本地代理软件 / 安全软件会拦截回环连接**,导致建循环永久挂起。
表现:`asyncio.new_event_loop()`、`asyncio.run()`、`pytest-asyncio` 全部挂起。
规避办法(任选):
1. 退出或放行本地代理软件,让 `127.0.0.1` 回环连通;
2. 在 WSL / Linux 环境里跑异步测试;
3. 对不 `await` 真实 Future 的协程,可以同步驱动验证:
```python
coro = some_coroutine()
try:
coro.send(None)
except StopIteration as e:
result = e.value
```
> 这也是 CI 放在 Linux 上跑的原因——Windows 侧无法做首轮异步验证。
??? question "和 pytdx / easy-tdx 什么关系?"
| 项目 | 关系 |
|---|---|
| [easy-tdx](https://github.com/handsomejustin/easy_tdx) | **参照实现**。协议层独立实现,不依赖其包,只参照字节级格式;解决了它无连接池、串行分页、单连接单锁的问题 |
| [pytdx](https://github.com/rainx/pytdx) | 上游生态。本包**不依赖** pytdx,但对 EX 通道(7727)沿用 pytdx 的扩展市场协议 |
## 下一步
- [参与贡献](contributing.md) — 报 bug / 提 PR / 跑测试
- [更新日志](changelog.md) — 每个版本改了什么
+186
View File
@@ -0,0 +1,186 @@
# 安装与配置
## 环境要求
| 项 | 要求 |
|---|---|
| Python | **≥ 3.11**(开发与 CI 覆盖 3.11 / 3.13) |
| 运行时依赖 | **无**(纯 stdlib:`socket` / `ssl` / `zlib` / `struct` / `sqlite3` / `asyncio`) |
| 操作系统 | 任意(Windows / Linux / macOS) |
| 网络 | 需能直连通达信行情服务器(标准/MAC 端口 **7709**,EX 端口 **7727**) |
## 安装
=== "pip"
```bash
pip install pytdxdata
```
=== "uv"
```bash
uv add pytdxdata
```
=== "源码开发"
```bash
git clone git@github.com:openbot-coder/pytdxdata.git
cd pytdxdata
uv sync # 建虚拟环境 + 装 CLI + 装测试依赖
.venv/Scripts/python.exe -c "import pytdxdata" # Windows
# .venv/bin/python -c "import pytdxdata" # Linux / macOS
```
安装后即可使用 `tdx` 命令行工具(见 [CLI 手册](cli.md))。
### 可选:uvloop 加速
Linux / macOS 上可选用 `uvloop` 替换默认事件循环(Windows 不支持):
```bash
uv add --optional uvloop uvloop
```
```python
import uvloop, asyncio
uvloop.install() # 必须在 asyncio.run() 之前
asyncio.run(main())
```
## 构造参数
`TdxData` 全部参数为 **keyword-only**,都有合理默认值——99% 的场景直接 `TdxData()` 即可。
| 参数 | 默认 | 说明 |
|------|------|------|
| `standard_servers` | `None` | 标准通道服务器清单;`None` = 用内置探测结果 |
| `mac_servers` | `None` | MAC 通道服务器清单;`None` = 用内置探测结果 |
| `ex_servers` | `None` | EX 扩展市场服务器清单;`None` = 用内置探测结果 |
| `port` | `7709` | 标准 / MAC 端口(EX 固定 `7727`) |
| `timeout` | `3.0` | 连接超时(秒) |
| `cache_dir` | `None` | 磁盘缓存目录;**`None` = 仅内存缓存**(进程退出即失效) |
| `default_adjust` | `Adjust.NONE` | 默认复权方式,可被单次调用覆盖 |
| `max_inflight` | `64` | single-flight 并发上限(同键请求合并) |
| `pool_min` / `pool_max` | `3` / `12` | 动态连接池上下限 |
| `mac_pool_cap` | `4` | 单台 MAC 服务器连接数上限 |
### 典型配置
=== "最简(仅内存缓存)"
```python
async with TdxData() as td:
...
```
=== "生产(持久化缓存)"
```python
from pathlib import Path
async with TdxData(
cache_dir=Path.home() / ".cache" / "pytdxdata",
pool_min=4,
pool_max=16,
timeout=5.0,
) as td:
...
```
`cache_dir` 下会生成一个 SQLite 文件(WAL 模式)。**同一目录可被多个进程共享**,
适合「定时任务 + 交互式查询」并存的场景。
=== "自建服务器清单"
```python
async with TdxData(
standard_servers=["1.2.3.4", "5.6.7.8"],
mac_servers=["9.10.11.12"],
port=7709,
) as td:
...
```
主机元素**只填主机名**,端口由构造参数 `port=` 统一指定(不写在主机元素里)。
等价的免代码写法是环境变量 `PYPYTDX_DATA_STANDARD_HOSTS` / `…_MAC_HOSTS`(逗号分隔)。
## 服务器清单
内置清单随包发布(`src/pytdxdata/servers.json`),由探测脚本生成:
```bash
python -m pytdxdata.server_probe # 重新探测并覆盖 servers.json
```
探测逻辑不是简单握手——它会**真实请求一段 K 线**,把「能连上但返回空数据」的坏节点剔除。
服务器可用性会随时间变化,连不上时优先重跑探测。
`pytdxdata.config` 提供读取接口:
```python
from pytdxdata.config import get_standard_hosts, get_mac_hosts, get_ex_hosts
print(len(get_standard_hosts()), len(get_mac_hosts()), len(get_ex_hosts()))
```
### 当日自动测速(无感)
除随包发布的静态清单外,`TdxData` 还在**当日首次启动**时做一次**后台全量测速**:
- 覆盖**全部候选**(包内清单 ∪ 代码内置常量 ∪ 环境变量覆盖),而不是只测当前池里的少数节点
——否则「上次慢、这次快」的节点永远捞不回来
- 用**真实 K 线命令**判定可达(标准 / MAC / EX 各发一条业务命令并要求非空),
能剔除「握手正常但返回空数据」的坏节点
- 结果按**实测延迟升序**写入**用户级缓存**,当天后续启动直接复用、**不再重测**
- 全程在后台进行:**不打印、不阻塞 `start()`、失败静默降级**,对调用方完全无感
缓存位置(可用 `PYPYTDX_DATA_CACHE_DIR` 覆盖):
| 平台 | 路径 |
|---|---|
| Windows | `%LOCALAPPDATA%\pytdxdata\hosts-today.json` |
| macOS | `~/Library/Caches/pytdxdata/hosts-today.json` |
| Linux / 其他 | `$XDG_CACHE_HOME/pytdxdata/hosts-today.json`(默认 `~/.cache/…`) |
主机选择的优先级(各协议独立):
1. `PYPYTDX_DATA_STANDARD_HOSTS` / `…_MAC_HOSTS` / `…_EX_HOSTS` 环境变量(手工指定,最高优先)
2. **当日测速缓存**中该协议实测可达的主机(按延迟升序)
3. 包内清单里 `status=ok` 的 `fast_pool` 主机
4. 包内清单里 `status=ok` 的主机
5. 代码内置常量
!!! note "缓存绝不写回安装目录"
测速结果只写入上面的**用户级缓存目录**。`site-packages` 在容器 / 系统级安装 / `pipx`
下可能只读,多用户共用一个安装时还会互相覆盖,因此包内 `servers.json` 不会被运行时改写。
环境变量一览:
| 变量 | 作用 |
|---|---|
| `PYPYTDX_DATA_STANDARD_HOSTS` / `…_MAC_HOSTS` / `…_EX_HOSTS` | 逗号分隔,手工指定主机(优先级最高,直接跳过测速缓存) |
| `PYPYTDX_DATA_CACHE_DIR` | 覆盖当日测速缓存目录 |
| `PYPYTDX_DATA_DISABLE_PROBE=1` | 关闭当日测速与缓存(CI / 测试用,保证确定性) |
## 生命周期
`TdxData` 必须在 `async with` 内使用,或手动 `await td.start()` / `await td.close()`:
```python
async with TdxData() as td: # __aenter__ → start()
...
# __aexit__ → close():关闭全部连接池、flush 缓存
```
!!! tip "长驻进程"
池与缓存都挂在 `TdxData` 实例上。Web 服务 / 常驻任务应该**只创建一个实例并复用**,
不要每次请求都 `TdxData()`——否则等于每请求重建连接池,缓存也失效。
推荐在 FastAPI 的 `lifespan` 里创建并放进依赖。
## 下一步
- [场景示例](cookbook.md) — 看真实用法
- [CLI 手册](cli.md) — 不写代码直接拿数据
- [接口总览](api/index.md) — 完整方法清单
+145
View File
@@ -0,0 +1,145 @@
# pytdxdata
[![CI](https://img.shields.io/github/actions/workflow/status/openbot-coder/pytdxdata/ci.yml?branch=main&label=CI)](https://github.com/openbot-coder/pytdxdata/actions/workflows/ci.yml)
[![PyPI version](https://img.shields.io/pypi/v/pytdxdata)](https://pypi.org/project/pytdxdata/)
[![Python](https://img.shields.io/pypi/pyversions/pytdxdata)](https://pypi.org/project/pytdxdata/)
[![License](https://img.shields.io/pypi/l/pytdxdata)](https://github.com/openbot-coder/pytdxdata/blob/main/LICENSE)
通达信(TongDaXin)行情数据客户端:**动态连接池 + 双层 TTL 缓存 + 3 连接并发分页**。
纯 `asyncio` 实现,**零运行时依赖**(只用 stdlib);**A股(沪/深/北) + 港股 + 美股 + 期货 + 期权**,一套接口全市场。
```bash
pip install pytdxdata
```
```python
import asyncio
from pytdxdata import TdxData
from pytdxdata.models import KlinePeriod
async def main():
async with TdxData() as td: # 自动探测服务器 + 建池 + 建缓存
bars = await td.get_bars("sh600000", KlinePeriod.DAY, count=2400)
print(bars[-1].datetime, bars[-1].close)
asyncio.run(main())
```
## 特性
| 特性 | 说明 |
|------|------|
| 🧩 **动态连接池** | 启动时对服务器真实 K 线探测选优(剔除握手正常但返回空数据的坏节点);健康分(失败 ×0.5 / 成功 +0.2 / 冷却 120s)+ EWMA 延迟选路;按等待队列与空闲时长动态扩缩容;跨服务器故障转移 |
| 🗄️ **双层 TTL 缓存** | 内存 LRU + 磁盘 SQLite(WAL);TTL 分级:报价 5s / 分钟K线 60s / 日线当天 / 复权K线 1天 / 历史逐笔永久;`single-flight` 同键并发去重;缓存「已解析记录」,重复请求 0 网络 0 解析 |
| ⚡ **并发分页** | 把大请求拆成显式 `start` 偏移的页,多连接并行拉取、按序拼接、失败换连接重试 |
| 🔀 **双通道整合** | 标准通道(经典行情)+ MAC 通道(逐笔 / 复权 / 1分钟K线),按命令自动选路 |
| 📄 **服务器文件解析** | 板块 `block_*.dat` / 行业 `tdxhy.cfg` / 历史财报 `gpcw*` **下载即解析**成 dataclass(纯 stdlib),无需自己拆二进制;文件名与索引不一致时自动纠正 |
| 🚀 **批量下载** | `get_bars` / `get_minutes` 传标的列表即多股票并发,连接池自动分配到不同服务器 |
| 📦 **零重型依赖** | 返回 `list[dataclass]`,pandas / polars 由调用方按需转换 |
## 从这里开始
<div class="grid cards" markdown>
- **装好并跑通**
---
安装、构造参数、缓存目录、第一个脚本。
[:octicons-arrow-right-24: 安装与配置](getting-started.md)
- **命令行直接拿数据**
---
19 个子命令,不写代码也能拉行情、板块、财报。
[:octicons-arrow-right-24: CLI 手册](cli.md)
- **场景示例**
---
全市场批量落库、分钟线增量、报价轮询、板块轮动、逐笔复盘。
[:octicons-arrow-right-24: Cookbook](cookbook.md)
- **查接口签名**
---
28 个统一方法(+ 33 个 deprecated 别名),从 docstring 实时生成,不会过期。
[:octicons-arrow-right-24: API 参考](api/index.md)
- **让 AI 助手写对代码**
---
枚举取值反直觉,AI 凭常识几乎必错。装载 `SKILL.md` 就能一次写对。
[:octicons-arrow-right-24: AI 助手接入](ai.md)
</div>
## 设计取舍
参照 [easy-tdx](https://github.com/handsomejustin/easy_tdx) 重新实现,解决其三大短板(无连接池、串行分页、单连接单锁)。
协议层**独立实现**——不依赖 easy-tdx 包,仅参照其字节级格式。
| 维度 | easy-tdx | pytdxdata |
|------|----------|-----------|
| 并发分页 | ❌ 串行 while 循环 | ✅ 3 连接并行 |
| 连接池 | ❌ 单连接单锁 | ✅ 动态池 + 故障转移 |
| 缓存 | 仅证券列表(1天) | ✅ 双层 TTL + single-flight |
| 数据正确性 | 基准 | ✅ K线 6 字段 / 报价 7 字段逐字段一致(实测) |
| 2400 根日K耗时 | 0.31s | **0.16s(1.97x)** |
| 缓存命中重取 | — | 0.016s(0 网络) |
| 依赖 | pandas 等 | 零运行时依赖 |
> 实测环境:Windows 11 / Python 3.13 / 同一批通达信服务器(2026-08)。
## 数据来源与限制
- 行情来自通达信**公开**行情服务器(无需账号),**15 分钟延时**;需实时数据请使用券商行情
- 服务器清单由 `python -m pytdxdata.server_probe` 探测生成;运行时**当日首次启动会自动在后台测速并缓存**
(对调用方无感,当天不再重测),可用性随时间变化
- 港股 / 美股 / 期货 / 期权走通达信 EX 通道(端口 7727),部分市场(美股期权、港股期权)协议内无数据
完整清单见 [常见问题](faq.md)。
!!! warning "免责声明"
本包仅用于**技术研究与教育目的**。行情数据来自通达信公开接口,不保证实时性与准确性;
作者不对任何投资决策负责。使用前请遵守通达信服务条款及相关法律法规。
## 目录
<div class="grid cards" markdown>
- **快速开始**
- [安装与配置](getting-started.md)
- [场景示例](cookbook.md)
- [命令行工具](cli.md)
- **参考**
- [接口总览](api/index.md)
- [枚举速查](api/enums.md)
- [数据模型](api/models.md)
- [完整接口清单](API_REFERENCE.md)
- **深入原理**
- [架构总览](internals/architecture.md)
- [协议与命令](internals/protocol.md)
- [通道与数据源](internals/routing.md)
- [连接池与缓存](internals/cache-pool.md)
- **其他**
- [AI 助手接入](ai.md)
- [常见问题](faq.md)
- [更新日志](changelog.md)
- [接口重构审查](refactor-audit.md)
- [参与贡献](contributing.md)
</div>
+109
View File
@@ -0,0 +1,109 @@
# 架构总览
## 分层
调用链是单向的,每一层只依赖它下面的一层——想加新接口时先想清楚「这属于哪一层」。
```mermaid
flowchart TD
A["api.py — TdxData<br/>唯一对外入口,28 个统一方法 + 33 个废弃别名"] --> B["router.py<br/>按命令选通道"]
B --> C["pool/ — 动态连接池<br/>标准池 / MAC 池 / EX 池"]
B --> D["scheduler/ — 并发分页调度<br/>Paginator"]
C --> E["protocol/ — 协议层<br/>帧 / 变长整数 / 价格 / 日期 / 命令"]
E --> F["TCP 通达信服务器<br/>7709 标准+MAC · 7727 EX"]
A --> G["cache/ — 双层 TTL 缓存<br/>Memory LRU → Disk SQLite"]
A --> H["codec/ — 解析与序列化<br/>缓存载荷 / 服务器文件"]
H --> I["models/ — dataclass + 枚举"]
```
## 目录
```
src/pytdxdata/
├── api.py # 统一接口 TdxData(对外唯一入口)
├── symbols.py # 标的解析:字符串 → Symbol(parse_symbol / format_symbol / market_targets)
├── router.py # 标准 / MAC / EX 通道选路
├── config.py # 服务器清单加载 + 选路优先级链 + 用户级测速缓存路径
├── indicator.py # 技术指标(纯函数,无依赖)
├── server_probe.py # 服务器探测,可 python -m 运行
├── protocol/ # 协议层
│ ├── frame.py # 标准帧
│ ├── mac_frame.py # MAC 帧
│ ├── _binary.py # 变长整数等底层字节工具
│ ├── price.py # 自定义浮点价格还原
│ ├── volume.py # 成交量差分还原
│ ├── datetime_.py # 日期 / 时间编码
│ └── commands/ # 16 个命令模块
├── pool/ # 连接池
│ ├── connection.py # 单连接(含重连)
│ ├── pool.py # 标准 / MAC 动态池
│ ├── ex_pool.py # EX 池
│ ├── health.py # 健康分与选路
│ └── probe_cache.py # 当日全量测速 + 用户级缓存(后台、无感)
├── scheduler/
│ └── paginator.py # 并发分页调度(3 连接并行)
├── cache/
│ ├── key.py # 缓存键规范化
│ ├── ttl.py # TTL 分级策略
│ ├── memory.py # 内存 LRU
│ ├── disk.py # 磁盘 SQLite(WAL)
│ └── manager.py # 两级协同 + single-flight
├── models/ # dataclass + 枚举(单文件,无子模块)
└── codec/ # 缓存载荷序列化 + 服务器文件解析
├── payload.py # 缓存载荷 pickle + zlib
├── block.py # 板块 .dat
├── industry.py # tdxhy.cfg
└── financial.py # gpcw.txt / gpcw*.zip
```
## 一次 `get_bars` 的完整路径
```mermaid
sequenceDiagram
participant U as 调用方
participant A as api.py
participant C as cache/
participant R as router.py
participant P as pool/
participant S as scheduler/
U->>A: get_bars("sh600000", DAY, count=2400)
A->>A: 规范化缓存键
A->>C: 查缓存
alt 命中
C-->>A: list[SecurityBar]
A-->>U: 直接返回(0 网络 0 解析)
else 未命中
A->>C: 登记 single-flight
A->>R: 选通道
R-->>A: 标准通道
A->>S: 分页(count=2400 → 3 页)
S->>P: 并发取 3 个连接
P->>P: 健康分 + EWMA 延迟选路
P-->>S: 3 个连接
S->>S: 并行拉取 → 按序拼接
S-->>A: 完整 bars
A->>C: 写入内存 + 磁盘
A-->>U: 返回
end
```
关键点:
- **缓存查在选路之前**——命中就完全不走网络,所以重复请求是 0.016s 量级
- **single-flight 在缓存层**——同一个键的并发请求会合并成一次回源,其余等待结果
- **分页与选路分离**——`scheduler` 只管拆分与拼接,不知道通道差异;`pool` 只管给连接
## 三个设计约束
| 约束 | 原因 |
|---|---|
| **零运行时依赖** | 用 `socket` / `zlib` / `struct` / `sqlite3` / `asyncio` 全部搞定,避免依赖地狱和版本冲突 |
| **返回 `list[dataclass]`** | 不让调用方被 pandas 绑架;需要 DataFrame 自己转一行 |
| **API 向后兼容** | 一个数据类型收敛为一个跨市场统一方法;旧方法名保留为 deprecated 别名(1.0 移除),老代码在兼容窗口内仍可用 |
## 下一步
- [协议与命令](protocol.md) — 最底层在做什么
- [通道与数据源](routing.md) — 为什么有的请求走不同的服务器
- [连接池与缓存](cache-pool.md) — 性能来自哪里
+114
View File
@@ -0,0 +1,114 @@
# 连接池与缓存
这个项目相比同类实现快 **约 2 倍**,来源就是这两块。
## 缓存
### 两级结构
```
内存 LRU ──miss──▶ 磁盘 SQLite (WAL) ──miss──▶ 回源网络
↑ ↑
快,进程内 跨进程 / 跨重启持久
```
- **内存层**:进程内 LRU,命中就是字典查找
- **磁盘层**:单文件 SQLite,开 WAL 模式,**可多进程共享**
- 未传 `cache_dir` 时只有内存层(进程退出即失效)
### TTL 分级
不同数据的「新鲜度要求」差了几个数量级,所以 TTL 是分级的:
| 数据类型 | TTL | 理由 |
|---|---|---|
| 五档报价 | **5s** | 变化最快 |
| 分钟 K 线 | **60s** | 边界处才会新增一根 |
| 日 K 线 | **当天** | 当天数据在盘中会变 |
| 复权 K 线 | **1 天** | 复权因子一天最多变一次 |
| 历史逐笔 | **永久** | 已经成交的不会变 |
| 证券列表 | **1 天** | 只有新股上市才变 |
### 缓存的是「已解析记录」
缓存里存的是**解析好的 dataclass 对象**(`codec/payload.py` 做 pickle + zlib),
不是原始响应字节。所以缓存命中时是 **0 网络 + 0 解析**,只有一次反序列化。
这也是为什么重复请求能从 0.31s 降到 **0.016s**。
### single-flight
同一时刻对**同一个缓存键**的并发请求会自动合并:第一个去回源,其余的等待并共享结果。
```python
# 100 个协程同时请求同一只股票的同一段 K 线
# → 只发 1 次网络请求
results = await asyncio.gather(*[
td.get_bars("sh600000", KlinePeriod.DAY, count=800)
for _ in range(100)
])
```
上限由 `max_inflight`(默认 `64`)控制。
> 缓存键会做**规范化**——`get_quotes` 的键是排序去重后的股票集合,
> 所以 `[A, B]` 和 `[B, A]` 共享缓存。
## 连接池
### 动态扩缩容
| 参数 | 默认 | 含义 |
|---|---|---|
| `pool_min` | `3` | 保底连接数 |
| `pool_max` | `12` | 上限 |
| `mac_pool_cap` | `4` | **单台** MAC 服务器连接上限 |
| `timeout` | `3.0` | 连接超时(秒) |
按**等待队列长度**与**空闲时长**动态扩缩容,不是启动时就拉满。
### 健康分与选路
每台服务器维护一个健康分,取连接时按健康分 **+ EWMA 延迟**综合选路:
| 事件 | 健康分变化 |
|---|---|
| 请求失败 | **× 0.5** |
| 请求成功 | **+ 0.2** |
| 连续失败 | 进入 **120s 冷却**,冷却期内不再被选中 |
失败会**跨服务器故障转移**——重试用的是另一台,而不是同一台重连。
EWMA(指数加权移动平均)延迟让选路对「最近变慢」敏感,而不是被历史均值拖住。
### MAC 通道的单台连接上限
`mac_pool_cap` 默认 `4`,与标准池的 `std_pool_cap` 一致——这是**对端单台连接限制**,
不是本项目的选择。两个通道的可用台数见 [通道与数据源](routing.md#server-groups):
实测可达台数会随服务器上下线变化,以**当日测速缓存**为准。
## 并发分页
大请求会被拆成多页,每页带**显式 `start` 偏移**——**无状态,所以可以并行**。
多连接并行拉取 → 按序拼接 → 某页失败就换连接重试该页。
```
count=2400 → 3 页 → 3 个连接并行 → 按序拼接
```
两种例外:
| 场景 | 策略 | 原因 |
|---|---|---|
| `KlinePeriod.MIN_1` | **单连接串行** | 各服务器历史深度不一致,并发会导致非确定性空洞 |
| MAC 通道复权 K 线 | **单连接串行**(`_fetch_mac_kline_serial`) | 同上 |
!!! tip "调参建议"
`concurrency` 超过 `pool_max` 之后只会排队。实践值 **8~16**。
MAC 类请求(逐笔 / 分时)并发能力受 `mac_pool_cap` 限制,调大 `concurrency` 无用。
## 下一步
- [架构总览](architecture.md) — 这些模块在整体里的位置
- [通道与数据源](routing.md#daily-probe) — 服务器是怎么选出来的(当日测速缓存)
- [常见问题](../faq.md) — 缓存与超时的排查
+102
View File
@@ -0,0 +1,102 @@
# 协议与命令
约 2500 行里最硬的部分。目标是:**不依赖 `pytdx` / `easy-tdx`,自己把线上字节跑通**。
> 本页讲「要解决什么问题」。**精确的字节布局以 `src/pytdxdata/protocol/` 源码为准**——
> 每个命令类里的 `build_request()` / `parse_response()` docstring 都写了实际偏移。
## 三条协议
| | 标准通道 | MAC 通道 | EX 通道 |
|---|---|---|---|
| 端口 | 7709 | 7709 | **7727** |
| 帧格式 | 经典 TDX 帧 | MAC 帧(带会话 seq) | pytdx EX 协议 |
| 覆盖 | 报价 / K线 / 列表 / 除权 / 财务 | 逐笔 / 分时 / 复权K线 / 板块 / 竞价 / 资金流 | 港股 / 美股 / 期货 / 期权 |
| 握手 | 无需登录 | `0x2454` login | `0x2454` setup/login |
MAC 与标准**共用 7709 端口但协议不同**,所以连接池也分成两个——一条 TCP 连接只能跑一种帧格式。
## 需要自己还原的编码
通达信不是「大端小端调对就完事」的协议,这些都得逆出来:
### 变长整数
部分字段用可变字节数编码。`protocol/_binary.py` 负责读写。
### 差分还原
**成交量(volume)不是直接存的**。它是相对前一条记录的差分,必须按顺序累加还原。
这意味着**不能随意乱序或跳读**——分页拼接时必须保证顺序正确。
### 自定义浮点价格
价格用一套私有编码而不是 IEEE754。`protocol/price.py` 负责还原。
不同**品种**的小数位还不同:股票 2 位,指数 / ETF / 可转债 3 位。
模型里的 `decimal_point` 就是这个信息。
### 日期 / 时间编码
`protocol/datetime_.py`。K 线里年月日时分是**分开的整数字段**,
模型上额外提供了一个 `datetime` 属性做拼装。
## 命令模块
`protocol/commands/` 下 16 个模块,按业务域划分:
| 模块 | 负责 |
|---|---|
| `base.py` | 命令基类 |
| `setup.py` | 连接建立与握手 |
| `kline.py` | K 线(标准) |
| `quotes.py` | 五档报价 |
| `security_list.py` | 证券列表与数量 |
| `transaction.py` | 逐笔成交 |
| `minute.py` | 分时 |
| `xdxr.py` | 除权除息 |
| `finance.py` | 财务 |
| `mac.py` | MAC 通道通用命令 |
| `mac_ext.py` | MAC 扩展(板块 / 竞价 / 异动 / 快照 / 资金流) |
| `mac_tick.py` | MAC 单日分时图(`0x122D`) |
| `std_ext.py` | 标准通道扩展(F10 / 文件下载) |
| `ex_ext.py` | EX 辅助接口 |
| `ex_proto.py` | EX 主协议(K线 / 报价 / 市场列表) |
每个命令类只做两件事:**把参数打成请求字节**、**把响应字节解析成模型**。不做网络、不做缓存。
## 关键命令码
排错时对照用:
| 命令 | 码 | 通道 |
|---|---|---|
| K 线(标准) | — | 标准 |
| K 线(MAC,支持复权) | `0x122E` | MAC |
| 分时 | `0x122D` | MAC |
| 远程文件元信息 | `0x1215` | MAC |
| 远程文件下载 | `0x1217` | MAC |
| 分时缩略采样 | `0x254D` | MAC |
| 板块文件 | `0x06B9` 系 | 标准 |
| EX K 线 | `0x23FF` | EX |
| EX 报价 | `0x23FA` | EX |
| EX 市场列表 | `0x23F4` / `0x23F5` | EX |
| EX 港股逐笔 | `0x23FC` / `0x2406` | EX |
| MAC / EX 登录 | `0x2454` | MAC / EX |
## 踩过的坑
这些是实际调试中撞出来的,写在这免得重踩:
| 现象 | 根因 |
|---|---|
| K 线数据**时有时无** | 标准通道部分服务器在 `count < 100` 时返回空 → 分页器强制 `min_page=100` |
| MAC K 线**随机丢数据** | 并发分页把不同页分到深度不一致的服务器,`stop_when_short` 提前截断 → 改单连接串行 |
| 1 分钟 K 线**深度不足** | 标准通道给的深度不够 → 切到 MAC `0x122E` |
| 分时只有几十条 | 标准通道命令不完整 → 切到 MAC `0x122D`,稳定 240 条 |
| 财报**市场字段恒为深市** | 上游用 `<6s1c1L` 解析,`1c` 的类型转换吞掉了市场字节 → 改 `<6sBL` |
| 握手正常但**拉不到数据** | 坏节点。服务器探测改为「真实请求一段 K 线」而不是只看握手 |
## 下一步
- [文件解析器](../api/codec.md) — 服务器静态文件的字节格式
- [通道与数据源](routing.md) — 哪个命令走哪条通道
+125
View File
@@ -0,0 +1,125 @@
# 通道与数据源
通达信的不同数据**散落在不同的协议和服务器上**。选路是 `router.py` 的职责,
调用方不需要关心——但知道「为什么慢」「为什么某个字段没有」时,这张表是排错起点。
## 路由表
| 请求 | 通道 | 为什么 |
|---|---|---|
| K 线 — **复权**(QFQ / HFQ) | **MAC** | 复权数据只有 MAC 通道提供 |
| K 线 — **`MIN_1` 不复权** | **MAC** | 标准通道 1 分钟深度不足;且必须串行分页 |
| K 线 — 其他周期不复权 | 标准 | 价格小数位规则已验证 |
| 指数 K 线 | 标准 | 含涨跌家数等指数专有字段 |
| 五档报价 | 标准 | 标准通道字段更全(含 `decimal_point`) |
| **逐笔成交** | **MAC** | 含 `trade_count`(成交笔数),且支持历史回溯 |
| **分时** | **MAC** | 标准通道不完整;MAC `0x122D` 稳定返回 240 条 |
| 证券列表 / 数量 | 标准 | 仅标准通道提供 |
| 除权除息 / 财务 | 标准 | 仅标准通道提供 |
| 板块 / 竞价 / 异动 / 快照 / 资金流 / 服务器时段 / 分类报价 | **MAC** | 这些是 MAC 专有命令 |
| 港股 / 美股 / 期货 / 期权 | **EX**(7727) | 完全不同的协议栈 |
!!! note "只请求,不改语义"
路由是**内部实现细节**。同一个 `get_bars()` 调用,传不传 `adjust` 会走不同通道,
但返回类型和字段完全一致——你不需要写 `if adjust:` 分支。
## 三组服务器 {#server-groups}
`src/pytdxdata/servers.json` 里维护三份清单,分别对应三个连接池:
| 池 | 数量级 | 用途 |
|---|---|---|
| **标准池** | 9 台 | 报价 / K线 / 列表 / 财务 |
| **MAC 池** | 22 台 | 逐笔 / 分时 / 复权 / 板块 / 资金流 |
| **EX 池** | 4 台 | 港股 / 美股 / 期货 / 期权 |
> 上表为 2026-09-21 离线探针(`python -m pytdxdata.server_probe --discover`)实测**可达**台数。
> 服务器会下线、换 IP 或变更协议,**实际台数以当日测速缓存为准**(见下方「运行时:当日测速缓存」)。
EX 池内部还要再分两类,因为握手方式不同:
| 类型 | 数量 | 握手 |
|---|---|---|
| MAC EX 服务器 | 2 | `0x2454` login |
| pytdx EX 服务器 | 2(通达信扩展市场 / 国泰君安) | `0x2454` setup |
这就是 `config.get_ex_handshakes()` 存在的原因——EX 的 4 台机器不是同一种握手。
注意 MAC 池实测**并不比标准池小**(22 台 vs 9 台)。早期版本曾按「MAC 可用节点很少」来解释逐笔 / 分时并发弱于日线,实测已推翻该前提——两者的单台连接上限(`mac_pool_cap` / `std_pool_cap`)默认相同,都是 `4`。
## 为什么这些服务器会被「探测」
服务器列表不是静态配置——通达信节点会下线、换 IP、**或者握手正常但返回空数据**。
`server_probe` 的探测逻辑**不是只看 TCP 连通性**,而是真实请求一段 K 线并校验内容:
```bash
python -m pytdxdata.server_probe # 按申报协议全量探测
python -m pytdxdata.server_probe --discover # 三种协议全测,并据实修正 protocols
python -m pytdxdata.server_probe --group ex # 只测 EX
python -m pytdxdata.server_probe --refresh # 只重测当前 status=ok 的
```
普通「只 ping 握手」的探测会把这类坏节点放进来,症状是**偶发的空返回**——
比直接连不上更难查。所以探测必须校验数据。
写回字段:`status` / `latency` / `checked_at` / `checked_date` / `fast_pool`,
以及顶层 `version` / `checked_date` / `note`。其中 `fast_pool` 与运行时缓存里的 `fast`
用同一条规则(整体延迟前 10 名,或延迟 < 200ms),用于**还没有当日缓存时**的冷启动排序。
### 为什么需要 `--discover`
「申报协议」会过期。实测(2026-09-21)有一批服务器的 **`0x010C` 标准 K 线变成空响应
(返回 2 字节空壳),但同端口同主机的 `0x122E` MAC 帧正常**——它们从 `standard` 退化成了
`mac`-only。只测申报协议的话,这类退化永远发现不了,标准池会一直含着一批死节点。
`--discover` 对每台主机把三种协议都测一遍,并据实测结果重写 `protocols`;
配套两个必须处理的细节:
- **失败必须重试一次**再判定不支持。单次抖动会误删协议,而 `protocols` 被收窄后不会自动恢复。
- **EX 握手模式**申报可能错,探测失败时换另一种(`login` ⇄ `setup`)再试。
- 无任何协议可达时**不动 `protocols`**,只把 `status` 置 `fail`——保留"它申报过什么"的信息。
- 顺带剔除 `ip` 非法的脏记录(历史遗留如 `"s1"`)。
## 运行时:当日测速缓存 {#daily-probe}
`python -m pytdxdata.server_probe` 是**离线**重生成随包清单的工具;运行时还有一条**在线**的
轻量路径——`TdxData.start()` 会异步触发一次全量测速,把结果缓存到**用户级目录**
(`…/pytdxdata/hosts-today.json`),当天后续启动直接复用,不再重测。
设计与几个必须踩对的点:
| 关注点 | 正确做法 | 反例(会静默出错) |
|---|---|---|
| 候选集 | 取**全部候选**(清单 ∪ 常量 ∪ env) | 只把「当前池成员」丢给探针 → 上次慢的节点永远捞不回来 |
| 可达判定 | 发**真实 K 线命令**并要求非空 | 只握手 / 只读报文头 → 测不出「空响应」坏节点 |
| 写盘位置 | 用户级缓存目录 | 写回包内 `servers.json` → 容器只读、多用户互相覆盖 |
| 对调用方 | 后台 task + debug 日志 + 绝不抛异常 | 在 `start()` 里 `await` 或打印 → 启动变慢、污染用户输出 |
| 并发 | 进程内单例 + `asyncio.Lock` | 三个池各测一遍 → 三倍流量 |
| 写入 | 临时文件 + `os.replace` 原子替换 | 直接覆写 → 并发进程读到半截 JSON |
全部不可达时**不写缓存**——否则「今天全挂了」会被缓存一整天,明天也不重试。
缓存存在时,`config.get_standard_hosts()` 等按**实测延迟升序**返回该协议的可达主机;
缓存缺失 / 跨日 / 版本不符 / 已损坏时,才回落到包内清单。开关见
[安装与配置 → 环境变量](../getting-started.md#当日自动测速无感)。
## EX 通道细节
- 端口固定 **7727**,与标准 / MAC 的 7709 不同
- 走 **pytdx EX 协议**(`0x23FF` K线 / `0x23FA` 报价 / `0x23F4` 市场列表)
- 合约代码规则与 A 股不同:港股 5 位(`00700`)、美股字母(`AAPL`)、
期货带月份(`IFL0` / `rb2610`)、期权 8 位(`10010971`)
- 美股期权 / 港股期权**协议内无数据**
```python
await td.get_bars("hk00700", KlinePeriod.DAY, count=700)
await td.get_bars("usAAPL", KlinePeriod.DAY, count=700)
```
扩展市场用字符串前缀(`hk` / `us` / `cffex` …)指定;`ExMarket` 的完整成员见 [枚举速查](../api/enums.md#exmarket)。
## 下一步
- [连接池与缓存](cache-pool.md) — 选到服务器之后怎么用
- [协议与命令](protocol.md) — 通道底下的字节格式
+127
View File
@@ -0,0 +1,127 @@
# pytdxdata
> 通达信(TongDaXin)行情数据客户端:动态连接池 + 双层 TTL 缓存 + 3 连接并发分页。纯 asyncio,零运行时依赖,覆盖 A股(沪/深/北)/港股/美股/期货/期权。
pytdxdata 是一个 Python 库,从通达信**公开**行情服务器直接读取行情与服务器文件,无需账号。
面向量化研究与历史数据落库场景(数据为 15 分钟延时,不适合实时交易)。
## 安装与最小可用示例
```bash
pip install pytdxdata # 或 uv add pytdxdata;要求 Python >= 3.11
```
```python
import asyncio
from pytdxdata import TdxData
from pytdxdata.models import KlinePeriod
async def main():
async with TdxData() as td: # 自动探测服务器、建连接池、初始化缓存
bars = await td.get_bars("sh600000", KlinePeriod.DAY, count=2400)
print(bars[-1].datetime, bars[-1].close)
asyncio.run(main())
```
## 心智模型(AI 必读)
1. **入口只有一个类**:`TdxData`。所有数据获取都是它的公开异步方法(v0.6 起为 **28 个统一方法**,
另有 33 个 deprecated 别名与 `start()` / `close()` 生命周期方法),必须在 `async with` 内使用。
2. **标的用字符串**,形如 `sz000001` / `sh600000` / `hk00700` / `usAAPL` / `cffex:IFL0`。
同一个 6 位代码在不同市场含义不同:`sh000001` 是上证指数,`sz000001` 是平安银行;
裸 6 位数字(如 `000001`)视为沪市指数。统一接口不再接受 `(market, code)` 元组。
3. **枚举取值没有直觉,必须用枚举成员,不要写数字字面量**:
- `Market`: SZ=0 / SH=1 / BJ=2
- `KlinePeriod`: MIN_5=0, MIN_15=1, MIN_30=2, MIN_60=3, **DAY=4**, WEEK=5, MONTH=6, **MIN_1=7**, MIN_3=8, YEAR=9, SEASON=10, YEAR_ALT=11
- `Adjust`: NONE=0 / QFQ=1(前复权) / HFQ=2(后复权);**默认 NONE**,很多券商软件默认前复权,对比数据前先对齐
- `ExMarket`: 港股主板 HK_MAIN_BOARD=31 / 美股 US_STOCK=74 / 中金所 CFFEX_FUTURES=47 / 沪股票期权 SH_STOCK_OPTION=8 等,共 46 个成员
4. **返回 `list[dataclass]`**,不是 DataFrame。需要 pandas 自行转换(见 cookbook)。包本身无任何运行时依赖。
5. **实例要复用**:连接池与缓存都挂在 `TdxData` 实例上。长驻进程(Web 服务)应只创建一个实例,
不要每请求新建,否则等于每请求重建连接池且缓存全部失效。
## 主要能力分组(统一接口)
标的一律用字符串;以下均为 v0.6 统一接口,跨市场自动选路。
- **标的清单**:`get_universe`(A股 + 港股 + 美股 + 期货/期权)
- **K 线**:`get_bars`(自动并发分页、支持复权与日期区间、多标的并发)
- **技术指标**:`get_indicators`(K线 + MACD/KDJ/RSI/BOLL/MA/EMA)
- **报价**:`get_quotes`(五档,>80 只自动切批)、`get_snapshot`(个股特征)、`get_market_stat`
- **逐笔 / 分时**:`get_ticks`(含 `trade_count`,支持历史日期)、`get_minutes`(`sampling=True` 取缩略采样)
- **财务 / 除权**:`get_finance`(最新快照)、`get_xdxr`、`get_price_limits`(本地计算涨跌停)
- **F10**:`get_f10`(公司资料目录 + 正文)
- **板块**:`get_boards`、`get_board_members`、`get_board_of`、`get_board_summary`、
`get_board_ranking`、`get_board_change_ranking`
- **服务器文件(下载 + 解析一步到位)**:`get_file`(原始字节)、`get_block_parsed`(板块成分)、
`get_industry_map`(通达信+申万行业)、`get_financial_file_infos`、`get_financial_records_parsed`(历史专业财报)
> 旧的分通道/市场方法(`get_kline` / `get_transactions` / `get_goods_*` 等共 33 个)保留为
> deprecated 别名,1.0 移除;完整对照见[接口重构审查](https://openbot-coder.github.io/pytdxdata/refactor-audit/)与 CHANGELOG。
## 服务器与配置
服务器主机来源有一条优先级链(各协议独立):环境变量 → **当日测速缓存** → 包内清单
`fast_pool` → 包内清单 → 代码内置常量。
- `TdxData.start()` 会在**当日首次启动**后台触发一次全量测速,用**真实 K 线命令**判定可达
(不是只握手),结果按延迟升序写入**用户级缓存**(Windows `%LOCALAPPDATA%\pytdxdata`、
macOS `~/Library/Caches/pytdxdata`、Linux `$XDG_CACHE_HOME/pytdxdata`),当天复用、不再重测。
- 该操作对调用方**完全无感**:后台执行、不打印、不阻塞 `start()`、失败静默降级。
运行时**绝不改写包内 `servers.json`**。
- 环境变量:`PYPYTDX_DATA_STANDARD_HOSTS` / `…_MAC_HOSTS` / `…_EX_HOSTS`(逗号分隔,手工指定,最高优先)、
`PYPYTDX_DATA_CACHE_DIR`(覆盖缓存目录)、`PYPYTDX_DATA_DISABLE_PROBE=1`(关闭测速)。
## CLI
安装后提供 `tdx` 命令,19 个子命令,不写代码即可取数:
```bash
tdx quotes sz000001 sh600000
tdx kline sz000001 --period day --count 30 --adjust qfq
tdx transactions sz000001 --date 20260811
tdx board rank --type 1 --top 10
tdx block block_gn.dat --limit 10 --codes
tdx industry 600000 --search 银行
tdx financial gpcw20260331.zip --limit 5
```
标的写法:`sz000001` / `sh600000` / `bj920992` / `hk00700` / `usAAPL` / `cffex:IFL0` / `000001`(6 位纯数字=指数)。
## 关键陷阱
- **`KlinePeriod.MIN_1` 走 MAC 通道并单连接串行分页**,这是刻意设计:并发分页在多服务器
历史深度不一致时会产生非确定性数据空洞。不要试图"优化"成并发。
- **复权 K 线走 MAC 通道**,标准通道不提供复权数据。
- **标准通道部分服务器在 `count < 100` 时返回空**,分页器已强制 `min_page=100` 规避。
- **本地 Windows 上 `asyncio.new_event_loop()` 可能永久挂起**,根因是回环 `socket.socketpair()`
被本地代理/安全软件拦截。异步测试请在 Linux/WSL 运行。
- **`FinanceRecord` 与 `FinancialRecord` 不同**:前者是最新一期财务快照(标准通道),
后者是历史多报告期专业财报(服务器文件,字段为原始 float 数组)。
- 美股期权、港股期权在通达信协议内**无数据**。
- 行情为 **15 分钟延时**,不适合实时交易决策。
## 文档
- [首页](https://openbot-coder.github.io/pytdxdata/)
- [安装与配置](https://openbot-coder.github.io/pytdxdata/getting-started/)
- [场景示例](https://openbot-coder.github.io/pytdxdata/cookbook/)
- [CLI 手册](https://openbot-coder.github.io/pytdxdata/cli/)
- [接口总览](https://openbot-coder.github.io/pytdxdata/api/)
- [TdxData 方法签名](https://openbot-coder.github.io/pytdxdata/api/tdxdata/)
- [枚举速查](https://openbot-coder.github.io/pytdxdata/api/enums/)
- [数据模型](https://openbot-coder.github.io/pytdxdata/api/models/)
- [架构总览](https://openbot-coder.github.io/pytdxdata/internals/architecture/)
- [协议与命令](https://openbot-coder.github.io/pytdxdata/internals/protocol/)
- [通道与数据源](https://openbot-coder.github.io/pytdxdata/internals/routing/)
- [连接池与缓存](https://openbot-coder.github.io/pytdxdata/internals/cache-pool/)
- [常见问题](https://openbot-coder.github.io/pytdxdata/faq/)
## 可选
- [SKILL.md](https://raw.githubusercontent.com/openbot-coder/pytdxdata/main/SKILL.md):面向 AI **编程**助手的技能文件(必守约定 / 枚举取值表 / 决策表 / 陷阱清单),比本文件更适合指导写代码
- [完整接口清单](https://openbot-coder.github.io/pytdxdata/API_REFERENCE/):手工维护的全量清单,含参数默认值
- [接口重构审查](https://openbot-coder.github.io/pytdxdata/refactor-audit/):统一接口 / 废弃别名全清单 + 数据一致性与遗漏对账
- [更新日志](https://github.com/openbot-coder/pytdxdata/blob/main/CHANGELOG.md)
- [GitHub 仓库](https://github.com/openbot-coder/pytdxdata)
- [PyPI](https://pypi.org/project/pytdxdata/)
+148
View File
@@ -0,0 +1,148 @@
# 接口重构审查报告
> 范围:v0.6 统一接口重构(`TdxData` 对外方法 51 → 63)的**数据一致性**与**遗漏审查**。
> 结论基于对旧实现(`git show HEAD:src/pytdxdata/api.py`)与新实现的逐字段 / 逐方法对照。
## 一、结论速览
| 维度 | 结论 |
|------|------|
| 数据一致性(旧接口 vs 统一接口) | ✅ 55 条断言全部通过,无字段差异 |
| 方法丢失 | ✅ 无。旧 53 个公开方法 100% 保留 |
| 文档覆盖 | ✅ `scripts/check_docs.py` 三条硬约束通过 |
| 标的写法 | ✅ 统一接口一律只接受字符串,已无元组软兼容 |
| 公开方法计数 | `28 统一 + 33 别名 + start/close = 63` |
---
## 二、数据一致性(旧接口 vs 新统一接口)
逐字段对照 24+ 组、**55 条断言全部通过**,覆盖:
- K 线(各周期 / 复权 / 日期区间)
- 实时报价(五档 bid/ask、买卖量、涨跌停价)
- 逐笔成交(含 `trade_count`)
- 分时
- 除权除息
- 财务快照
- F10(目录 + 正文)
- 服务器文件(板块 / 行业 / 财报)
- 板块(列表 / 成员 / 归属 / 汇总 / 排行)
唯一 1 条「失败」经核实为 **mock 假象**:`security_count` 的 mock 返回固定值 100,而
`get_universe` 走真实分页逻辑,两者口径不同;**并非真实数据差异**,逐字段比较全部相等。
---
## 三、遗漏审查(方法级)
对旧 / 新 `api.py` 的公开方法集合做 AST 级 diff:
| 指标 | 数量 |
|------|------|
| 旧公开方法 | 53(51 数据 + `start` / `close`) |
| 新公开方法 | 63(61 数据 + `start` / `close`) |
| **旧有新无(丢失)** | **0** |
| 新增 | 10(全部为统一入口) |
**数值闭合**:
- `28 统一 + 33 废弃别名 + start/close = 63`
- `18 旧名升级 + 33 转别名 = 51 旧数据方法`
- `51 旧 + 10 新入口 = 61 数据方法`
---
## 四、统一接口清单(28 个数据接口)
标的写法:`"sz000001"` / `"hk00700"` / `"usAAPL"` / `"cffex:IFL0"`;裸 6 位数字 = 沪市指数。
### 4.1 新入口(10,v0.6 新增)
| 方法 | 签名 | 返回 | 吸收的旧接口 |
|------|------|------|--------------|
| `get_universe` | `(market=None)` | `list[SecurityInfo]` | get_security_count / get_security_list / get_security_list_all / get_goods_list / get_goods_count |
| `get_bars` | `(symbols, period=DAY, *, start=0, count=800, adjust=None, start_date=None, end_date=None, concurrency=6)` | `list[SecurityBar]` | get_kline / get_kline_since / get_kline_batch / get_index_kline |
| `get_indicators` | `(symbols, indicators, *, period=DAY, count=30, adjust=None, params=None)` | `list[IndicatorSet]` | get_stock_kline_with_indicators |
| `get_ticks` | `(symbols, *, date=None, start=0, count=None, concurrency=6)` | `list[TransactionRecord]` | get_transactions / get_goods_transaction / get_goods_transaction_all |
| `get_minutes` | `(symbols, *, date=None, sampling=False, concurrency=6)` | `list[MinuteBar]` | get_minute / get_minute_batch / get_chart_sampling / get_goods_chart_sampling / get_goods_tick_chart |
| `get_snapshot` | `(symbols)` | `list[SymbolSnapshot]` | get_symbol_info |
| `get_f10` | `(symbol, section=None, *, offset=0, length=65535)` | `list \| str` | get_company_info_category / get_company_info_content |
| `get_file` | `(name)` | `bytes` | get_block_info / get_report_file / get_file_meta / download_file / get_financial_file_list / get_financial_records |
| `get_boards` | `(kind="all", *, count=10000)` | `list[BoardInfo]` | get_board_list |
| `get_board_of` | `(symbols)` | `list[BelongBoard]` | get_belong_board |
### 4.2 旧名升级(18,同名泛化为统一接口)
| 方法 | 签名 | 返回 |
|------|------|------|
| `get_quotes` | `(symbols, *, fields=None)` | `list[SecurityQuote]` |
| `get_auction` | `(symbols)` | `list[AuctionItem]` |
| `get_capital_flow` | `(symbols)` | `list[CapitalFlow]` |
| `get_xdxr` | `(symbols)` | `list[XdxrRecord]` |
| `get_finance` | `(symbols)` | `list[FinanceRecord]` |
| `get_price_limits` | `(symbol, name=None, pre_close=None, listed_days=9999)` | `tuple[float\|None, float\|None]` |
| `get_market_stat` | `()` | `MarketStat` |
| `get_unusual` | `(market="all", *, start=0, count=600)` | `list[UnusualItem]` |
| `get_server_info` | `()` | `ServerInfo` |
| `get_kline_offset` | `(offset=0, count=1)` | `tuple[int, int]` |
| `get_board_members` | `(board, count=100000, sort_type=0, *, fields=None)` | `list[SecurityQuote]` |
| `get_board_summary` | `(board)` | `dict` |
| `get_board_ranking` | `(kind="industry", *, top_n=20)` | `list[dict]` |
| `get_board_change_ranking` | `(kind="industry", *, days=20, top_n=20)` | `list[dict]` |
| `get_block_parsed` | `(filename)` | `list[TdxBlock]` |
| `get_industry_map` | `()` | `dict[str, IndustryInfo]` |
| `get_financial_file_infos` | `()` | `list[FinancialFileInfo]` |
| `get_financial_records_parsed` | `(filename)` | `list[FinancialRecord]` |
> 另有生命周期方法 `start()` / `close()`,合计 30 个非别名公开方法。
---
## 五、废弃别名清单(33 个,1.0 移除)
别名运行时发出 `DeprecationWarning`;**仍接受 `(market, code)` 写法**(这是别名与统一接口的关键差异)。
| 目标统一接口 | 数量 | 废弃别名 |
|--------------|------|----------|
| `get_bars` | 4 | `get_kline`、`get_kline_since`、`get_kline_batch`、`get_index_kline` |
| `get_indicators` | 1 | `get_stock_kline_with_indicators` |
| `get_quotes` | 3 | `get_stock_quotes`、`get_goods_quotes`、`get_goods_quotes_list` |
| `get_board_members` | 1 | `get_stock_quotes_list` |
| `get_ticks` | 3 | `get_transactions`、`get_goods_transaction`、`get_goods_transaction_all` |
| `get_minutes` | 3 | `get_minute`、`get_minute_batch`、`get_goods_tick_chart` |
| `get_minutes(sampling=True)` | 2 | `get_chart_sampling`、`get_goods_chart_sampling` |
| `get_universe` | 5 | `get_security_count`、`get_security_list`、`get_security_list_all`、`get_goods_list`、`get_goods_count` |
| `get_f10` | 2 | `get_company_info_category`、`get_company_info_content` |
| `get_file` | 4 | `get_block_info`、`get_report_file`、`get_file_meta`、`download_file` |
| `get_financial_file_infos` | 1 | `get_financial_file_list` |
| `get_financial_records_parsed` | 1 | `get_financial_records` |
| `get_boards` | 1 | `get_board_list` |
| `get_board_of` | 1 | `get_belong_board` |
| `get_snapshot` | 1 | `get_symbol_info` |
| **合计** | **33** | |
---
## 六、标的写法统一(字符串化)
统一接口**只接受字符串标的**,已移除所有 `(market, code)` 元组软兼容:
- 删除模块级 `_as_symbols()`;`get_quotes` / `get_xdxr` / `get_finance` / `get_auction` /
`get_capital_flow` 去掉 `code` 位置参数,统一走 `parse_symbols()`。
- `get_price_limits` 去掉 `(market, code, …)` 旧参形式检测。
- `get_unusual` 去掉整数市场号检测。
- 调用方(CLI、示例)同步改为字符串;`get_finance` / `get_capital_flow` 的返回类型改为 `list`。
!!! note "保留项"
`get_boards(kind)` 仍接受数字板块类别(`0/1/2/3`)。这是**板类别选择器**、非标的,
文档已明示「也接受数字」,旧别名 `get_board_list(board_type=0)` 依赖它。
---
## 七、验证
- `pytest`:**127 passed**(审查当时的快照;当前基线为 164 passed)。其中 `tests/test_all_interfaces.py` 为全接口回归:mock 连接逐个
调用 63 个公开方法,并以「覆盖哨兵」断言无遗漏(7 条告警为别名测试的预期 `DeprecationWarning`)。
- `scripts/check_docs.py`:`MUST_LIST_ALL` + `MUST_NOT_BE_STALE` 全部 `[OK]`。
- 签名核对:统一接口签名与返回类型与本文一致;全仓无 `_as_symbols` 及元组式调用残留。
+5 -4
View File
@@ -4,18 +4,19 @@
python examples/quickstart.py
说明:数据来自通达信公开行情服务器(无需账号,15 分钟延时)。
标的一律用字符串(``sh600000`` / ``sz000001`` / ``hk00700`` / ``usAAPL`` / ``cffex:IFL0``)。
"""
import asyncio
from pytdxdata import KlinePeriod, Market, TdxData
from pytdxdata import TdxData
async def main() -> None:
# TdxData 为异步上下文管理器:进入时建连,退出时释放
async with TdxData() as td:
# 1) 批量五档报价(可一次传多只,超过 80 只自动切批)
quotes = await td.get_quotes([(Market.SH, "600000"), (Market.SZ, "000001")])
quotes = await td.get_quotes(["sh600000", "sz000001"])
print("== 报价 ==")
for q in quotes:
print(
@@ -24,7 +25,7 @@ async def main() -> None:
)
# 2) 日K线(最近 10 根)
bars = await td.get_kline(Market.SH, "600000", KlinePeriod.DAY, count=10)
bars = await td.get_bars("sh600000", count=10)
print("\n== 日K(最近 3 根)==")
for b in bars[-3:]:
print(
@@ -33,7 +34,7 @@ async def main() -> None:
)
# 3) 当日分时
minutes = await td.get_minute(Market.SH, "600000")
minutes = await td.get_minutes("sh600000")
latest = minutes[-1].price if minutes else "-"
print(f"\n== 分时 ==\n共 {len(minutes)} 个点,最新价={latest}")
+142
View File
@@ -0,0 +1,142 @@
site_name: pytdxdata
site_description: >-
通达信(TongDaXin)行情数据客户端 — 动态连接池 + 双层TTL缓存 + 3连接并发分页,
纯 asyncio 零运行时依赖,支持 A股/港股/美股/期货/期权
site_url: https://openbot-coder.github.io/pytdxdata/
site_author: openbot-coder
repo_url: https://github.com/openbot-coder/pytdxdata
repo_name: openbot-coder/pytdxdata
edit_uri: edit/main/docs/
copyright: MIT License · 仅供技术研究与教育用途,不构成任何投资建议
theme:
name: material
language: zh
palette:
- media: "(prefers-color-scheme: light)"
scheme: default
toggle:
icon: material/weather-night
name: 切换到深色模式
- media: "(prefers-color-scheme: dark)"
scheme: slate
toggle:
icon: material/weather-sunny
name: 切换到浅色模式
features:
- navigation.instant
- navigation.instant.progress
- navigation.tracking
- navigation.sections
- navigation.indexes
- navigation.top
- navigation.footer
- toc.follow
- search.suggest
- search.highlight
- content.code.copy
- content.code.annotate
- content.action.edit
- content.tabs.link
icon:
repo: fontawesome/brands/github
nav:
- 首页: index.md
- 快速开始:
- 安装与配置: getting-started.md
- 场景示例: cookbook.md
- 命令行工具: cli.md
- API 参考:
- 接口总览: api/index.md
- TdxData 方法: api/tdxdata.md
- 枚举速查: api/enums.md
- 数据模型: api/models.md
- 技术指标: api/indicator.md
- 文件解析器: api/codec.md
- 完整接口清单: API_REFERENCE.md
- 深入原理:
- 架构总览: internals/architecture.md
- 协议与命令: internals/protocol.md
- 通道与数据源: internals/routing.md
- 连接池与缓存: internals/cache-pool.md
- AI 助手接入: ai.md
- 其他:
- 常见问题: faq.md
- 更新日志: changelog.md
- 接口重构审查: refactor-audit.md
- 参与贡献: contributing.md
plugins:
- search:
lang:
- zh
- en
- mkdocstrings:
default_handler: python
handlers:
python:
paths: [src]
options:
docstring_style: google
docstring_section_style: list
show_source: false
show_root_heading: true
show_root_toc_entry: true
show_symbol_type_heading: true
show_symbol_type_toc: true
members_order: source
group_by_category: true
show_category_heading: true
separate_signature: true
show_signature_annotations: true
signature_crossrefs: true
merge_init_into_class: true
filters:
- "!^_"
- "!^__"
markdown_extensions:
- admonition
- attr_list
- md_in_html
- tables
- footnotes
- pymdownx.emoji:
emoji_index: !!python/name:material.extensions.emoji.twemoji
emoji_generator: !!python/name:material.extensions.emoji.to_svg
- toc:
permalink: true
toc_depth: 3
slugify: !!python/object/apply:pymdownx.slugs.slugify
kwds:
case: lower
- pymdownx.details
- pymdownx.inlinehilite
- pymdownx.snippets:
base_path: ["."]
check_paths: true
restrict_base_path: false
- pymdownx.tabbed:
alternate_style: true
- pymdownx.tasklist:
custom_checkbox: true
- pymdownx.highlight:
anchor_linenums: true
line_spans: __span
pygments_lang_class: true
- pymdownx.superfences:
custom_fences:
- name: mermaid
class: mermaid
format: !!python/name:pymdownx.superfences.fence_code_format
extra:
social:
- icon: fontawesome/brands/github
link: https://github.com/openbot-coder/pytdxdata
name: GitHub 仓库
- icon: fontawesome/brands/python
link: https://pypi.org/project/pytdxdata/
name: PyPI
generator: false
+8 -2
View File
@@ -1,6 +1,6 @@
[project]
name = "pytdxdata"
version = "0.4.0"
version = "0.6.1"
description = "通达信(TongDaXin)行情数据客户端:动态连接池 + 双层TTL缓存 + 3连接并发分页,纯asyncio零运行时依赖,支持A股/港股/美股/期货/期权"
readme = "README.md"
requires-python = ">=3.11"
@@ -27,7 +27,7 @@ dependencies = []
[project.urls]
Homepage = "https://github.com/openbot-coder/pytdxdata"
Repository = "https://github.com/openbot-coder/pytdxdata"
Documentation = "https://github.com/openbot-coder/pytdxdata#readme"
Documentation = "https://openbot-coder.github.io/pytdxdata/"
[project.optional-dependencies]
uvloop = ["uvloop>=0.21"]
@@ -53,4 +53,10 @@ dev = [
"pytest>=9.1.1",
"pytest-asyncio>=1.4.0",
]
docs = [
"mkdocs-material>=9.5",
"mkdocstrings[python]>=0.26",
"ruff>=0.6",
"jieba>=0.42",
]
+185
View File
@@ -0,0 +1,185 @@
#!/usr/bin/env python3
"""文档漂移检查。
确保 `api.py` 里 `TdxData` 的公开方法与手写文档保持一致,双向检查:
1. **漏写**:代码里有、文档里没提到的方法
2. **过时**:文档里提到、代码里已不存在的方法
`docs/api/tdxdata.md` 由 mkdocstrings 自动生成,不在检查范围内(它不可能漂移)。
本脚本只管那些**手写**的接口清单,分两档:
- `MUST_LIST_ALL`:必须列全所有公开方法(漏写也报错)
- `MUST_NOT_BE_STALE`:入口 / 教程 / 精选清单,只要求「不提到已删除的方法」
用法::
.venv/Scripts/python.exe scripts/check_docs.py # Windows
.venv/bin/python scripts/check_docs.py # Linux / macOS
退出码 0 = 一致,1 = 存在漂移。
"""
from __future__ import annotations
import ast
import re
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent.parent
API_FILE = ROOT / "src" / "pytdxdata" / "api.py"
PKG_DIR = ROOT / "src" / "pytdxdata"
# 必须**列全**所有公开方法的文档(漏写 = 漂移)
MUST_LIST_ALL = [
ROOT / "docs" / "API_REFERENCE.md",
]
# 只需**不提到已删除的方法**的文档:
# 这些是入口 / 教程 / 精选清单 / 接口总览(只列推荐的统一接口,旧方法不强制列出),
# 但绝不能引用已不存在的方法
MUST_NOT_BE_STALE = [
ROOT / "SKILL.md",
ROOT / "README.md",
ROOT / "docs" / "llms.txt",
ROOT / "docs" / "index.md",
ROOT / "docs" / "getting-started.md",
ROOT / "docs" / "cookbook.md",
ROOT / "docs" / "faq.md",
ROOT / "docs" / "cli.md",
ROOT / "docs" / "ai.md",
ROOT / "docs" / "api" / "index.md",
ROOT / "docs" / "refactor-audit.md",
]
def collect_api_methods(path: Path) -> tuple[set[str], set[str]]:
"""返回 (全部公开方法, 非 async 的公开方法)。"""
tree = ast.parse(path.read_text(encoding="utf-8"))
all_names: set[str] = set()
sync_names: set[str] = set()
for node in ast.walk(tree):
if isinstance(node, ast.ClassDef) and node.name == "TdxData":
for item in node.body:
if not isinstance(item, ast.FunctionDef | ast.AsyncFunctionDef):
continue
if item.name.startswith("_"):
continue
all_names.add(item.name)
if not isinstance(item, ast.AsyncFunctionDef):
sync_names.add(item.name)
return all_names, sync_names
def mentioned_in(text: str, name: str) -> bool:
"""文档中是否提到该方法(`get_kline` 不会误匹配 `get_kline_batch`)。"""
return re.search(rf"(?<![\w]){re.escape(name)}(?![\w])", text) is not None
def collect_doc_references(text: str) -> set[str]:
"""抽取文档中以反引号标注的疑似方法名。
同时覆盖两种写法:`` `get_kline` `` 与 `` `get_kline(market, code, ...)` ``。
"""
return set(
re.findall(r"`((?:get|download)_[a-z0-9_]+)\s*(?:\([^`()]*\))?`", text)
)
def collect_package_symbols() -> set[str]:
"""收集包内所有模块级公开函数 / 类名,以及 ``__all__`` 导出的名字。
文档里会合法地引用 `config.get_standard_hosts` 这类**模块级**函数,
不把它们纳入白名单就会被误判成「引用了已删除的方法」。
"""
names: set[str] = set()
for path in PKG_DIR.rglob("*.py"):
try:
tree = ast.parse(path.read_text(encoding="utf-8"))
except SyntaxError: # pragma: no cover - 语法错误交给 CI 的测试去抓
continue
for node in tree.body:
if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
if not node.name.startswith("_"):
names.add(node.name)
elif isinstance(node, ast.Assign):
for target in node.targets:
if isinstance(target, ast.Name) and target.id == "__all__":
try:
names.update(str(x) for x in ast.literal_eval(node.value))
except (ValueError, TypeError):
pass
return names
def main() -> int:
if not API_FILE.exists():
print(f"[FAIL] 找不到 {API_FILE}")
return 1
methods, sync_methods = collect_api_methods(API_FILE)
if "--list" in sys.argv:
for name in sorted(methods):
print(name)
return 0
print(f"api.py: TdxData 公开方法 {len(methods)} 个(含 start/close 生命周期)")
# 「已删除」判定要排除包内其它公开符号(config 的模块级函数等),否则误报
known = methods | collect_package_symbols()
problems: list[str] = []
if sync_methods:
problems.append(
"以下公开方法不是 async(本库约定全部公开方法为 async): "
+ ", ".join(sorted(sync_methods))
)
for doc in MUST_LIST_ALL:
if not doc.exists():
problems.append(f"缺少文档文件: {doc.relative_to(ROOT)}")
continue
text = doc.read_text(encoding="utf-8")
rel = doc.relative_to(ROOT).as_posix()
missing = sorted(n for n in methods if not mentioned_in(text, n))
if missing:
problems.append(
f"{rel} 漏写 {len(missing)} 个方法: " + ", ".join(missing)
)
stale = sorted(n for n in collect_doc_references(text) if n not in known)
if stale:
problems.append(f"{rel} 提到已不存在的方法: " + ", ".join(stale))
if not missing and not stale:
print(f" [OK] {rel}")
for doc in MUST_NOT_BE_STALE:
if not doc.exists():
continue
rel = doc.relative_to(ROOT).as_posix()
text = doc.read_text(encoding="utf-8")
stale = sorted(n for n in collect_doc_references(text) if n not in known)
if stale:
problems.append(f"{rel} 提到已不存在的方法: " + ", ".join(stale))
else:
print(f" [OK] {rel}(无过时引用)")
if problems:
print("\n[FAIL] 文档漂移:")
for p in problems:
print(" - " + p)
return 1
print("\n[OK] 文档与代码一致")
return 0
if __name__ == "__main__":
sys.exit(main())
+1 -1
View File
@@ -16,7 +16,7 @@ from .models import (
XdxrRecord,
)
__version__ = "0.4.0"
__version__ = "0.6.1"
__all__ = [
"TdxData",
"Market",
+1368 -927
View File
File diff suppressed because it is too large. Load diff
+8 -3
View File
@@ -40,7 +40,12 @@ class CacheKey:
)
@classmethod
def quote_key(cls, stocks: Sequence[tuple[int, str]]) -> "CacheKey":
"""报价键:对股票集规范化排序,顺序无关可命中。"""
def quote_key(cls, stocks: Sequence[tuple[int, str]],
tag: str = "") -> "CacheKey":
"""报价键:对股票集规范化排序,顺序无关可命中。
``tag`` 区分取数口径(标准五档 / MAC·EX 字段位),不同口径不互相命中。
"""
norm = sorted(f"{m}:{c}" for m, c in stocks)
return cls(category="quote", extra=",".join(norm))
extra = ",".join(norm)
return cls(category="quote", extra=f"{tag}#{extra}" if tag else extra)
+19 -55
View File
@@ -111,26 +111,17 @@ def _pct(price: float, pre: float) -> str:
# ------------------------------------------------------------------ #
async def cmd_quotes(td: TdxData, symbols: list[str]) -> None:
cn, ex = [], []
for sym in symbols:
s = parse_symbol(sym)
if s.kind == "cn":
cn.append((Market(s.market), s.code))
else:
ex.append((s.market, s.code))
for q in await td.get_quotes(cn):
_print_cn_quote(q)
if ex:
from .protocol.commands.ex_proto import GetExInstrumentQuoteCmd
for market, code in ex:
q = await td._execute_ex(GetExInstrumentQuoteCmd(market, code))
_print_ex_quote(market, code, q)
quotes = await td.get_quotes(symbols)
for q in quotes:
_print_quote(q)
def _print_cn_quote(q) -> None:
def _print_quote(q) -> None:
pct = (q.price / q.pre_close - 1) * 100 if q.pre_close else 0
mkt = {31: "港股", 74: "美股"}.get(q.market, "")
print("=" * 58)
print(" %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(" 最新 %-10.2f 涨跌 %+8.2f (%+.2f%%)" % (q.price, q.price - q.pre_close, pct))
print(" 今开 %-10.2f 最高 %.2f 最低 %.2f" % (q.open, q.high, q.low))
print(" 昨收 %-10.2f 成交量 %s 成交额 %s" % (q.pre_close, _fmt_num(q.vol), _fmt_num(q.amount)))
@@ -144,31 +135,9 @@ def _print_cn_quote(q) -> None:
print()
def _print_ex_quote(market: int, code: str, q: dict | None) -> None:
if not q:
print(" %s: 无报价数据" % code)
return
price, pre = q.get("price") or 0, q.get("pre_close") or 0
mkt = {31: "港股", 74: "美股"}.get(market, "扩展")
print("=" * 58)
print(" %s %s" % (mkt, code))
print(" 最新 %-10.2f 涨跌 %+8.2f (%s)" % (price, price - pre, _pct(price, pre)))
print(" 今开 %-10.2f 最高 %.2f 最低 %.2f" % (
q.get("open") or 0, q.get("high") or 0, q.get("low") or 0))
print(" 昨收 %-10.2f 总量 %s" % (pre, _fmt_num(q.get("zongliang") or 0)))
print()
async def cmd_kline(td: TdxData, sym: str, period: KlinePeriod, count: int,
start: int, adjust: Adjust) -> None:
s = parse_symbol(sym)
if s.kind == "cn":
bars = await td.get_kline(Market(s.market), s.code, period, start=start,
count=count, adjust=adjust)
elif s.kind == "index":
bars = await td.get_index_kline(Market(s.market), s.code, period, start=start, count=count)
else:
bars = await td.get_kline(ExMarket(s.market), s.code, period, start=start, count=count)
bars = await td.get_bars(sym, period, start=start, count=count, adjust=adjust)
print("%s K线 (%s, %d根):" % (sym, period.name, len(bars)))
print(" %-12s %8s %8s %8s %8s %12s" % ("日期", "开盘", "最高", "最低", "收盘", "成交量"))
for b in bars:
@@ -256,8 +225,7 @@ async def cmd_list(td: TdxData, market: str, count: int) -> None:
async def cmd_auction(td: TdxData, sym: str) -> None:
s = parse_symbol(sym)
items = await td.get_auction(Market(s.market), s.code)
items = await td.get_auction(sym)
print("%s 集合竞价 (%d条):" % (sym, len(items)))
for a in items:
print(" %s 价格=%.3f 量=%d %s" % (
@@ -266,7 +234,7 @@ async def cmd_auction(td: TdxData, sym: str) -> None:
async def cmd_unusual(td: TdxData, market: str, count: int) -> None:
items = await td.get_unusual(MARKET_NAMES[market], count=count)
items = await td.get_unusual(market, count=count)
print("市场异动 (%d条):" % len(items))
for u in items:
print(" %s %s %s" % (getattr(u, "code", ""), getattr(u, "name", ""),
@@ -274,8 +242,7 @@ async def cmd_unusual(td: TdxData, market: str, count: int) -> None:
async def cmd_xdxr(td: TdxData, sym: str) -> None:
s = parse_symbol(sym)
items = await td.get_xdxr(Market(s.market), s.code)
items = await td.get_xdxr(sym)
print("%s 除权除息 (%d条):" % (sym, len(items)))
for x in items[:20]:
print(" %s 送%g 配%g 派%g" % (
@@ -284,23 +251,20 @@ async def cmd_xdxr(td: TdxData, sym: str) -> None:
async def cmd_finance(td: TdxData, sym: str) -> None:
s = parse_symbol(sym)
f = await td.get_finance(Market(s.market), s.code)
if not f:
fins = await td.get_finance(sym)
if not fins:
print("无财务数据")
return
for k, v in asdict(f).items():
for k, v in asdict(fins[0]).items():
print(" %-24s %s" % (k, v))
async def cmd_flow(td: TdxData, sym: str) -> None:
s = parse_symbol(sym)
f = await td.get_capital_flow(Market(s.market), s.code)
if isinstance(f, dict):
items = f.items()
else:
items = asdict(f).items()
for k, v in items:
flows = await td.get_capital_flow(sym)
if not flows:
print("无资金流向数据")
return
for k, v in asdict(flows[0]).items():
print(" %-20s %s" % (k, v))
+59 -3
View File
@@ -17,13 +17,19 @@
"""
from __future__ import annotations
import io
import struct
import zipfile
from ..models import FinancialFileInfo, FinancialRecord
_HEADER_FMT = "<1hI1H3L"
_INDEX_FMT = "<6sBL"
_HEADER_SIZE = struct.calcsize(_HEADER_FMT)
_INDEX_SIZE = struct.calcsize(_INDEX_FMT)
_ZIP_MAGIC = b"PK\x03\x04"
def parse_financial_file_list(data: bytes) -> list[FinancialFileInfo]:
"""解析 tdxfin/gpcw.txt 内容(每行 ``filename,md5hash,filesize``)。"""
@@ -46,8 +52,58 @@ def parse_financial_file_list(data: bytes) -> list[FinancialFileInfo]:
return out
def looks_like_gpcw_dat(data: bytes) -> bool:
"""粗略判定字节流是否为 gpcw ``.dat``(校验 20 字节 header 的自洽性)。
用于把「真的取到了财报数据」与「服务器对不存在的文件名回的 0/1 字节空壳」区分开:
空壳要么长度不足、要么 header 全零,一律判否。
Args:
data: 待判定的字节流。
Returns:
可疑时返回 True。
"""
if len(data) < _HEADER_SIZE:
return False
_unknown, _date, max_count, _u1, report_size, _u2 = struct.unpack(
_HEADER_FMT, data[:_HEADER_SIZE]
)
if max_count <= 0 or report_size <= 0 or report_size % 4 != 0:
return False
# 索引区必须放得下 max_count 条 11 字节条目
return _HEADER_SIZE + max_count * _INDEX_SIZE <= len(data)
def extract_gpcw_dat(data: bytes) -> bytes:
"""从「zip 包」或「未压缩 dat」中取出 ``.dat`` 字节;无法识别时返回 ``b""``。
服务器**实际只提供未压缩的** ``tdxfin/gpcwYYYYMMDD.dat``,而 ``tdxfin/gpcw.txt``
索引里写的是 ``gpcwYYYYMMDD.zip``,因此两种形态都要能走通。
Args:
data: zip 包字节或未压缩 ``.dat`` 字节。
Returns:
内层 / 原始的 ``.dat`` 字节;不是有效财报数据时返回 ``b""``。
"""
if not data:
return b""
if data.startswith(_ZIP_MAGIC):
try:
with zipfile.ZipFile(io.BytesIO(data)) as zf:
names = [n for n in zf.namelist() if n.lower().endswith(".dat")]
if not names:
return b""
inner = zf.read(names[0])
except (zipfile.BadZipFile, OSError, KeyError):
return b""
return inner if looks_like_gpcw_dat(inner) else b""
return data if looks_like_gpcw_dat(data) else b""
def parse_financial_dat(data: bytes, report_date: int = 0) -> list[FinancialRecord]:
"""解析 gpcw*.zip 内的 .dat 二进制。
"""解析 gpcw ``.dat`` 二进制(zip 内的或服务器直接给的未压缩形式都行)。
Args:
data: .dat 文件完整字节。
@@ -56,7 +112,7 @@ def parse_financial_dat(data: bytes, report_date: int = 0) -> list[FinancialReco
Returns:
FinancialRecord 列表;数据不足或字段非法时返回空列表。
"""
header_size = struct.calcsize(_HEADER_FMT)
header_size = _HEADER_SIZE
if len(data) < header_size:
return []
@@ -72,7 +128,7 @@ def parse_financial_dat(data: bytes, report_date: int = 0) -> list[FinancialReco
if num_fields <= 0:
return []
index_size = struct.calcsize(_INDEX_FMT)
index_size = _INDEX_SIZE
report_fmt = f"<{num_fields}f"
report_pack_size = struct.calcsize(report_fmt)
+178 -13
View File
@@ -1,12 +1,28 @@
"""服务器清单与默认配置
服务器清单存于包内 servers.json,由 server_probe.py 导入时自动探测可用性与延时。
config.py 加载时只采用 status="ok" 的服务器;环境变量可覆盖;代码内嵌清单为兜底。
服务器清单存于包内 ``servers.json`` —— 它是**随包分发的基线清单,运行期只读**。
每日首次启动的后台测速结果写入**用户级缓存目录**,运行期优先采用当日实测结果。
主机选取优先级(每个协议独立)::
环境变量 PYPYTDX_DATA_*_HOSTS > 当日测速缓存 > 包内清单 fast_pool
> 包内清单 ok > 代码内嵌常量
相关环境变量:
- ``PYPYTDX_DATA_CACHE_DIR`` 覆盖用户级缓存目录(默认见 :func:`probe_cache_dir`)
- ``PYPYTDX_DATA_DISABLE_PROBE`` 置真值时既不读当日缓存也不测速(CI / 测试用,保证确定性)
为什么不把测速结果写回包内 ``servers.json``:安装目录可能是只读的(容器 / 系统级
site-packages / pipx),且多用户共用一份安装时彼此覆盖,运行期改写分发数据本身也不妥。
"""
from __future__ import annotations
import ipaddress
import json
import os
import sys
from datetime import date
from pathlib import Path
DEFAULT_PORT = 7709
@@ -14,19 +30,29 @@ DEFAULT_TIMEOUT = 10.0
_SERVERS_FILE = Path(__file__).resolve().parent / "servers.json" # 包内清单(随包分发)
# 当日测速缓存(结构变更时递增,旧版本缓存自动失效)
PROBE_CACHE_VERSION = 1
_PROBE_CACHE_NAME = "hosts-today.json"
# ---------- 包内清单(只读基线) ----------
def _read_servers_json() -> dict:
"""读取包内清单;文件缺失 / 内容损坏 / 顶层非对象 → 空 dict。"""
try:
cfg = json.loads(_SERVERS_FILE.read_text(encoding="utf-8"))
except (OSError, ValueError):
return {}
return cfg if isinstance(cfg, dict) else {}
def _load_ok_hosts(protocol: str, *, fast_only: bool = False) -> list[str]:
"""从 servers.json 加载 status=ok 且支持指定协议的服务器。
fast_only=True 时只返回当日测速入池(fast_pool)的服务器(排名前N或延迟<阈值),
fast_only=True 时只返回测速入池(fast_pool)的服务器(排名前N或延迟<阈值),
用于动态连接池优先使用优质节点。
"""
try:
cfg = json.loads(_SERVERS_FILE.read_text(encoding="utf-8"))
except (OSError, ValueError):
return []
out = []
for s in cfg.get("servers", []):
for s in _read_servers_json().get("servers", []):
if s.get("status") != "ok":
continue
if protocol not in s.get("protocols", []):
@@ -38,13 +64,90 @@ def _load_ok_hosts(protocol: str, *, fast_only: bool = False) -> list[str]:
def _load_ex_handshakes() -> dict[str, str]:
try:
cfg = json.loads(_SERVERS_FILE.read_text(encoding="utf-8"))
except (OSError, ValueError):
return {}
return {s["ip"]: s.get("handshake", "setup") for s in cfg.get("servers", [])
"""包内清单里 EX 服务器的握手模式。"""
return {s["ip"]: s.get("handshake", "setup")
for s in _read_servers_json().get("servers", [])
if "ex" in s.get("protocols", []) and s.get("status") == "ok"}
# ---------- 用户级当日测速缓存 ----------
def probe_cache_dir() -> Path:
"""用户级缓存目录(保证可写,绝不指向安装目录)。
``PYPYTDX_DATA_CACHE_DIR`` 可覆盖(测试指向临时目录)。按平台约定:
- Windows: ``%LOCALAPPDATA%\\pytdxdata``
- macOS: ``~/Library/Caches/pytdxdata``
- 其他: ``$XDG_CACHE_HOME/pytdxdata`` 或 ``~/.cache/pytdxdata``
"""
env = (os.environ.get("PYPYTDX_DATA_CACHE_DIR") or "").strip()
if env:
return Path(env).expanduser()
if os.name == "nt":
base = os.environ.get("LOCALAPPDATA") or os.environ.get("APPDATA")
return (Path(base) if base else Path.home() / "AppData" / "Local") / "pytdxdata"
if sys.platform == "darwin":
return Path.home() / "Library" / "Caches" / "pytdxdata"
base = os.environ.get("XDG_CACHE_HOME")
return (Path(base) if base else Path.home() / ".cache") / "pytdxdata"
def probe_cache_file() -> Path:
"""当日测速缓存文件路径(每次调用重新解析,便于测试改环境变量后立即生效)。"""
return probe_cache_dir() / _PROBE_CACHE_NAME
def probe_disabled() -> bool:
"""是否已通过 ``PYPYTDX_DATA_DISABLE_PROBE`` 关闭当日测速缓存。"""
return os.environ.get("PYPYTDX_DATA_DISABLE_PROBE", "").strip().lower() in {
"1", "true", "yes", "on",
}
def load_probe_cache(today: str | None = None,
path: str | Path | None = None) -> dict | None:
"""读取**当日**测速缓存;缺失 / 损坏 / 非今日 / 版本不符 → ``None``。
返回非 None 即表示"今天已经测过速了",调用方应直接复用而不再刷新。
``path`` 可显式指定缓存文件(默认 :func:`probe_cache_file`),便于注入与测试。
"""
if probe_disabled():
return None
target = Path(path) if path is not None else probe_cache_file()
try:
cfg = json.loads(target.read_text(encoding="utf-8"))
except (OSError, ValueError):
return None
if not isinstance(cfg, dict) or cfg.get("version") != PROBE_CACHE_VERSION:
return None
if str(cfg.get("date", "")) != (today or date.today().isoformat()):
return None
results = cfg.get("results")
if not isinstance(results, dict) or not results:
return None
return cfg
def _load_cached_hosts(protocol: str) -> list[str]:
"""当日测速缓存中该协议**实测可达**的主机,按延迟升序(越快越靠前)。"""
cfg = load_probe_cache()
if cfg is None:
return []
rows: list[tuple[float, str]] = []
for ip, per_proto in cfg["results"].items():
if not isinstance(per_proto, dict):
continue
lat = per_proto.get(protocol)
if isinstance(lat, bool) or not isinstance(lat, (int, float)):
continue
if lat < 0:
continue
rows.append((float(lat), str(ip)))
rows.sort(key=lambda kv: (kv[0], kv[1]))
return [ip for _, ip in rows]
# ---------- 代码内嵌兜底清单 ----------
# 标准行情服务器 —— 真实K线探测验证可用(2026-08-12, GetSecurityBarsCmd 600000 日K)
# 27台可用 = pytdxwrapper券商服务器(国泰君安/中信短线宝/华林/安信等) + 通达信官方主站
# 来源①: pytdxwrapper config.py TDX_HOSTS(券商+官方, 51台探测27可用)
@@ -91,10 +194,66 @@ EX_HANDSHAKES: dict[str, str] = {
}
# ---------- 测速候选枚举 ----------
def is_valid_host(host: object) -> bool:
"""是否是可用作服务器地址的合法主机(IPv4/IPv6 字面量,或含点的域名)。
用于挡住测试 mock 混进来的伪主机名(如 ``"s1"``)被写进缓存 / 清单。
"""
if not isinstance(host, str):
return False
h = host.strip()
if not h or len(h) > 253 or any(c.isspace() for c in h):
return False
try:
ipaddress.ip_address(h)
return True
except ValueError:
pass
return "." in h and all(
part and part[0] != "-" and part[-1] != "-" and part.replace("-", "").isalnum()
for part in h.split(".")
)
def all_probe_candidates() -> dict[str, list[str]]:
"""[测速用] 返回 ``{协议: [候选主机]}`` 全量清单(已校验、去重、保序)。
来源 = 包内清单申报的协议 ∪ 代码内嵌常量 ∪ 环境变量覆盖。
与 ``get_*_hosts()`` 的关键区别:这里**不做 status / 延迟过滤**。
测速必须能看到全部候选,否则"上次慢、这次快"的节点永远捞不回来,
形成自指循环(只重测已在池里的少数节点,其余记录一直过期)。
"""
out: dict[str, list[str]] = {"standard": [], "mac": [], "ex": []}
for s in _read_servers_json().get("servers", []):
ip = s.get("ip")
for protocol in s.get("protocols", []):
if protocol in out:
out[protocol].append(ip)
out["standard"] += STANDARD_HOSTS
out["mac"] += MAC_HOSTS
out["ex"] += EX_HOSTS
for protocol, var in (("standard", "PYPYTDX_DATA_STANDARD_HOSTS"),
("mac", "PYPYTDX_DATA_MAC_HOSTS"),
("ex", "PYPYTDX_DATA_EX_HOSTS")):
env = os.environ.get(var)
if env:
out[protocol] += env.split(",")
return {
protocol: [h for h in dict.fromkeys(hosts) if is_valid_host(h)]
for protocol, hosts in out.items()
}
# ---------- 对外取主机 ----------
def get_standard_hosts() -> list[str]:
env = os.environ.get("PYPYTDX_DATA_STANDARD_HOSTS")
if env:
return [h.strip() for h in env.split(",") if h.strip()]
cached = _load_cached_hosts("standard")
if cached:
return cached
fast = _load_ok_hosts("standard", fast_only=True)
if fast:
return fast
@@ -106,6 +265,9 @@ def get_mac_hosts() -> list[str]:
env = os.environ.get("PYPYTDX_DATA_MAC_HOSTS")
if env:
return [h.strip() for h in env.split(",") if h.strip()]
cached = _load_cached_hosts("mac")
if cached:
return cached
fast = _load_ok_hosts("mac", fast_only=True)
if fast:
return fast
@@ -117,6 +279,9 @@ def get_ex_hosts() -> list[str]:
env = os.environ.get("PYPYTDX_DATA_EX_HOSTS")
if env:
return [h.strip() for h in env.split(",") if h.strip()]
cached = _load_cached_hosts("ex")
if cached:
return cached
from_json = _load_ok_hosts("ex")
return from_json or list(EX_HOSTS)
+50 -7
View File
@@ -94,7 +94,7 @@ class Adjust(IntEnum):
@dataclass(slots=True)
class SecurityBar:
"""K线记录(价格单位:元)"""
"""K线记录(价格单位:元)。跨市场统一模型(A股/港股/美股/期货共用)。"""
market: int
code: str
open: float
@@ -108,6 +108,7 @@ class SecurityBar:
day: int
hour: int = 0
minute: int = 0
symbol: str = "" # 规范化标的串(sz000001 / hk00700),由 API 层填充
@property
def datetime(self) -> datetime:
@@ -120,9 +121,26 @@ class IndexBar(SecurityBar):
pass
@dataclass(slots=True)
class IndicatorSet:
"""K线 + 技术指标组合(``TdxData.get_indicators`` 的返回单元)。
``indicators`` 里每个序列与 ``bars`` 等长、尾部对齐;预热期为 ``None`` 的指标
(如 BOLL 前三档)保留 ``None``。
"""
symbol: str
bars: list[SecurityBar] = field(default_factory=list)
indicators: dict[str, list[float | None]] = field(default_factory=dict)
@dataclass(slots=True)
class SecurityQuote:
"""实时五档报价"""
"""报价(跨市场统一模型)。
A股(标准通道):五档 ``bid``/``ask`` + 买卖量 + 涨跌停价齐全,``name`` 为空。
A股(``fields=[...]`` 走 MAC 0x122B):``name`` 与 ``fields`` 齐全,五档为空。
扩展市场(港股/美股/期货):``name`` + 基础价量在属性上,其余字段位在 ``fields``。
"""
market: int
code: str
price: float
@@ -144,39 +162,51 @@ class SecurityQuote:
limit_down: float = 0.0 # 跌停价
decimal_point: int = 2 # 价格小数位
open_amount: float = 0.0 # 开盘金额(个股)
symbol: str = "" # 规范化标的串
name: str = "" # 名称(仅 MAC/EX 通道有)
fields: dict[str, float] = field(default_factory=dict) # 原始字段位("0x7" 等)
@dataclass(slots=True)
class SecurityInfo:
"""证券列表条目"""
"""标的清单条目(跨市场统一模型:A股证券列表 + 扩展市场商品列表)"""
market: int
code: str
name: str
volunit: int
decimal_point: int
pre_close: float
symbol: str = "" # 规范化标的串
kind: str = "" # 分类描述(扩展市场的 category/desc)
@dataclass(slots=True)
class TransactionRecord:
"""逐笔成交(MAC通道含 trade_count=成交笔数)"""
"""逐笔成交(跨市场统一模型;A股 MAC 通道含 trade_count=成交笔数)"""
market: int
code: str
time: str # HH:MM:SS
time: str # HH:MM:SS(扩展市场为 HH:MM)
price: float
vol: float # 手(MAC逐笔)
trade_count: int # 成交笔数(MAC=逐笔记录字段;标准当日逐笔协议也有但需单独解析)
bs_flag: int # 1=主动买 0=主动卖
symbol: str = ""
fields: dict[str, float] = field(default_factory=dict) # 扩展市场额外字段(增仓等)
@dataclass(slots=True)
class MinuteBar:
"""分时数据"""
"""分时(跨市场统一模型;A股 MAC 0x122D / 扩展市场 0x122D 同构)"""
price: float
vol: float
avg_price: float = 0.0 # 均价(协议第2字段)
hour: int = 0
minute: int = 0
symbol: str = ""
market: int = 0
code: str = ""
date: int = 0 # YYYYMMDD
fields: dict[str, float] = field(default_factory=dict) # 扩展市场额外字段(动量等)
@dataclass(slots=True)
@@ -201,6 +231,7 @@ class XdxrRecord:
qian_zongguben: float = 0.0
panhou_liutong: float = 0.0
hou_zongguben: float = 0.0
symbol: str = ""
@property
def date(self) -> str:
@@ -248,6 +279,7 @@ class FinanceRecord:
weifen_lirun: float = 0.0
meigujing_zichan: float = 0.0
reserve2: float = 0.0
symbol: str = ""
# ===== MAC 扩展命令模型 =====
@@ -268,15 +300,21 @@ class BoardInfo:
symbol_price: float = 0.0
symbol_rise_speed: float = 0.0
symbol_pre_close: float = 0.0
symbol: str = "" # 规范化标的串(板块码,如 sh881001)
@dataclass(slots=True)
class MemberQuote:
"""板块成分股报价(MAC自定义字段)"""
"""板块成分/自定义字段报价的**协议层原始记录**。
API 层会把它归一成 :class:`SecurityQuote`(``fields`` 原样保留、基础字段位
填进属性),所以普通调用不会看到本类。
"""
market: int
code: str
name: str
fields: dict[str, float] = field(default_factory=dict)
symbol: str = ""
@dataclass(slots=True)
@@ -287,6 +325,7 @@ class BelongBoard:
board_name: str
close: float
pre_close: float
symbol: str = "" # 被查询的个股(非板块)
@dataclass(slots=True)
@@ -296,6 +335,7 @@ class AuctionItem:
price: float
matched: int
unmatched: int
symbol: str = ""
@dataclass(slots=True)
@@ -308,6 +348,7 @@ class UnusualItem:
desc: str
value: float
time: str
symbol: str = ""
@dataclass(slots=True)
@@ -328,6 +369,7 @@ class SymbolSnapshot:
amount: float
turnover: float
avg_price: float
symbol: str = ""
@dataclass(slots=True)
@@ -361,6 +403,7 @@ class CapitalFlow:
sell5: float
big5: float
mid5: float
symbol: str = ""
# ===== 服务器文件解析模型(板块/行业/历史专业财报) =====
+26 -12
View File
@@ -6,8 +6,9 @@
- 动态:支持运行时 add() 新服务器;支持后台全量测速入库(当日首次启动)。
- 单连接约束(核心需求):per_server_cap 默认 1 —— 一台服务器只允许建立 1 个连接,
不允许多开,避免对单一券商服务器造成并发压力被限流/封禁。
- 后台测速(核心需求):当日首次启动时,在后台对全量候选服务器测速,按
「排名前 FAST_POOL_TOP_N 或 延迟 < FAST_POOL_MAX_LATENCY」筛选入库,结果写回 servers.json。
- 后台测速(核心需求):当日首次启动时,在后台对**全量候选**服务器测速(覆盖标准/MAC/EX
三个协议,而不是只测当前池内节点),结果缓存到用户级缓存目录;当天已有缓存则跳过、不再刷新。
全程不阻塞 start()、不打印、不抛错(对用户无感)。详见 pool/probe_cache.py。
- 弹性:空闲连接超时后由 reaper 缩容回 min_size;支持 stats 统计。
"""
from __future__ import annotations
@@ -19,7 +20,7 @@ import time
from .connection import TdxConnection
from .health import HealthEngine
from .probe_cache import get_probe_cache
from .probe_cache import schedule_probe
log = logging.getLogger(__name__)
@@ -101,6 +102,7 @@ class DynamicPool:
self._lock = asyncio.Lock()
self._cond = asyncio.Condition(self._lock)
self._reaper_task: asyncio.Task | None = None
self._probe_task: asyncio.Task | None = None
# ---------- 生命周期 ----------
async def start(self) -> None:
@@ -108,13 +110,11 @@ class DynamicPool:
return
self._started = True
# 需求①:当日首次启动 → 后台全量测速入库(不阻塞主流程)
# 需求①:当日首次启动 → 后台全量测速(不阻塞主流程;当天已有缓存则自动跳过)
# 候选清单由 probe_cache 自行枚举全量主机(本池的 servers 只是其中一个子集,
# 不能直接当作测速输入,否则只会重测已在池内的少数节点、其余记录永久过期)。
if self.auto_probe:
hosts = list(self.servers)
asyncio.create_task(
get_probe_cache().ensure_probe(hosts),
name="pytdxdata-daily-probe",
)
self._probe_task = schedule_probe()
targets = self._pick_servers(self.min_size)
for host in targets:
@@ -175,6 +175,15 @@ class DynamicPool:
if self._reaper_task is not None:
self._reaper_task.cancel()
self._reaper_task = None
# 后台测速仍可能持有 socket;取消并等它退场,避免事件循环关闭时冒出
# "Task was destroyed but it is pending"(那会破坏"无感")
if self._probe_task is not None:
self._probe_task.cancel()
try:
await self._probe_task
except (asyncio.CancelledError, Exception):
pass
self._probe_task = None
async with self._lock:
for pc in list(self._conns):
try:
@@ -211,6 +220,10 @@ class DynamicPool:
# 2. 可扩容(未达上限且有可用服务器)→ 新建连接
if self._total < self.max_size:
host = self._next_available_server()
if host is None:
# 兜底:全部服务器都在冷却中,而池子未满 —— 此时等 release
# 永远等不到(没人持有),只能挑最健康的一台顶着冷却重试
host = self._next_available_server(ignore_cooldown=True)
if host:
try:
pc = await self._new_conn(host)
@@ -244,18 +257,19 @@ class DynamicPool:
break
return out
def _next_available_server(self) -> str | None:
def _next_available_server(self, *, ignore_cooldown: bool = False) -> str | None:
ranked = self.health.rank(self.servers)
# 1. 优先选未冷却且未达并发上限的服务器
for h in ranked:
if self.health.in_cooldown(h):
if self.health.in_cooldown(h) and not ignore_cooldown:
continue
if self._server_count.get(h, 0) < self.per_server_cap:
return h
# 2. 兜底:仅从「未冷却」的已占用服务器里随机复用(避免反复打坏服务器)
alive = [
h for h in ranked
if not self.health.in_cooldown(h) and self._server_count.get(h, 0) > 0
if (ignore_cooldown or not self.health.in_cooldown(h))
and self._server_count.get(h, 0) > 0
]
return random.choice(alive) if alive else None
+272 -112
View File
@@ -1,162 +1,322 @@
"""当日首次启动的全量服务器测速与入库缓存。
"""当日首次启动的全量服务器测速与缓存(对用户完全无感)。
设计要点:
- 仅在"当日首次启动"时触发一次后台全量测速(按本地日期判断是否已探测)。
- 测速采用真实握手连通(TdxConnection.test),比单纯 ping 更能反映通达信可用性。
- 入库规则:延迟排名前 FAST_POOL_TOP_N(10) **或** 延迟 < FAST_POOL_MAX_LATENCY(0.2s) 的服务器
才标记为 status="ok" 并写入 servers.json,其余降权(保留但不优先)。
- 结果持久化到 servers.json,供 config / 连接池直接使用。
行为
----
- **当日首次启动**触发一次后台全量测速;当天已有缓存则直接复用,**不再刷新**。
- 测速覆盖**全部候选**(包内清单 ∪ 代码常量 ∪ env 覆盖,见
:func:`pytdxdata.config.all_probe_candidates`),而不是只测当前已在池里的少数节点 ——
否则"上次慢、这次快"的节点永远捞不回来。
- 用**真实业务命令**判定可达(标准: GetSecurityBarsCmd / MAC: MacKlineCmd /
EX: GetExInstrumentBarsCmd)并要求返回非空数据,而不是只做握手回显:
存在"握手正常但 K线空响应"的坏节点(见 ``config.py`` 注释),只有真数据能测出来。
- 结果写入**用户级缓存目录**(见 :func:`pytdxdata.config.probe_cache_file`),
不写安装目录:site-packages 在容器 / 系统级安装 / pipx 下可能只读,
多用户共用一份安装时还会互相覆盖。
- 结果被 :func:`pytdxdata.config.get_standard_hosts` 等按**实测延迟升序**采用。
无感保证
--------
- 不打印任何东西;日志一律 ``debug`` 级(默认不输出)。
- 不抛异常(取消除外);失败只落 debug 日志,下次启动自然重试。
- 由连接池以后台 task 方式调用,不阻塞 ``start()`` 与任何用户请求。
一致性与并发
------------
- 进程内单例 + ``asyncio.Lock``:标准 / MAC / EX 三个池共用一次真正测速。
- 原子写入(tmp + ``os.replace``):进程被杀或多进程并发都不会读到半截 JSON。
- 全部不可达时**不写缓存**,避免把"全挂"状态缓存一整天。
开关
----
- ``PYPYTDX_DATA_DISABLE_PROBE=1`` 关闭(CI / 测试用,保证确定性)。
- ``PYPYTDX_DATA_CACHE_DIR`` 覆盖缓存目录(测试指向临时目录)。
"""
from __future__ import annotations
import asyncio
import json
import logging
import os
import time
from collections import defaultdict
from collections.abc import Awaitable, Callable
from datetime import date
from pathlib import Path
from ..config import _SERVERS_FILE
from ..config import (
PROBE_CACHE_VERSION,
all_probe_candidates,
get_ex_handshakes,
is_valid_host,
load_probe_cache,
probe_cache_file,
probe_disabled,
)
from ..models import Adjust, KlinePeriod
from ..protocol.commands.ex_proto import GetExInstrumentBarsCmd
from ..protocol.commands.kline import GetSecurityBarsCmd
from ..protocol.commands.mac import MacKlineCmd
from .connection import TdxConnection
from .ex_connection import ExTdxConnection
log = logging.getLogger(__name__)
# 入池阈值
FAST_POOL_TOP_N = 10 # 延迟排名前 N
FAST_POOL_MAX_LATENCY = 0.2 # 延迟 < 200ms(秒)也可入池
# 入池阈值(仅用于缓存里的 fast 诊断标记;运行时按实测延迟整体排序,不做硬切)
FAST_POOL_TOP_N = 10
FAST_POOL_MAX_LATENCY = 0.2
# 探针参数
PROBE_PORT = 7709
EX_PORT = 7727
PROBE_TIMEOUT = 3.0
PROBE_CONCURRENCY = 24
PROBE_CONCURRENCY = 12
PROBE_BUDGET = 60.0 # 整轮测速硬上限(秒),防止极端网络下长期占着后台
ProbeFn = Callable[[str, float], Awaitable[float | None]]
# ---------- 三个协议各自的真实数据探针 ----------
async def _probe_standard(host: str, timeout: float) -> float | None:
"""标准通道 7709:取 600000 日K,非空才算可达。"""
conn = TdxConnection(host, PROBE_PORT, timeout)
t0 = time.monotonic()
try:
await conn.connect()
bars = await conn.execute(GetSecurityBarsCmd(1, "600000", KlinePeriod.DAY, 0, 100))
return time.monotonic() - t0 if bars else None
except Exception:
return None
finally:
await conn.close()
async def _probe_mac(host: str, timeout: float) -> float | None:
"""MAC 通道 7709:MAC 帧与标准帧不同,用 MacKlineCmd 取日K。"""
conn = TdxConnection(host, PROBE_PORT, timeout)
t0 = time.monotonic()
try:
await conn.connect()
bars = await conn.execute(
MacKlineCmd(1, "600000", KlinePeriod.DAY, Adjust.NONE, 0, 100)
)
return time.monotonic() - t0 if bars else None
except Exception:
return None
finally:
await conn.close()
async def _probe_ex(host: str, timeout: float) -> float | None:
"""EX 扩展市场 7727:取港股 00700,握手模式按主机取(login / setup)。"""
conn = ExTdxConnection(host, EX_PORT, timeout, get_ex_handshakes().get(host, "setup"))
t0 = time.monotonic()
try:
await conn.connect()
bars = await conn.execute(GetExInstrumentBarsCmd(31, "00700", 0, 0, 5))
return time.monotonic() - t0 if bars else None
except Exception:
return None
finally:
await conn.close()
_DEFAULT_PROBERS: dict[str, ProbeFn] = {
"standard": _probe_standard,
"mac": _probe_mac,
"ex": _probe_ex,
}
class ProbeCache:
"""管理当日测速缓存与 servers.json 入库。
"""当日全量测速的进程内协调器。
一台服务器不论协议(standard/mac/ex),测速结果共享:
只要任一端口可达即视为该主机可用,并以最快端口延迟作为延迟基准。
一台主机不论申报几个协议,都按协议分别探测;缓存里记录
``{host: {protocol: 延迟或 None}}``,``None`` 表示该协议本次不可达。
参数(后 5 个主要供测试注入):
cache_file: 显式指定缓存文件;``None`` 时按 config 的平台规则解析。
probers: 协议 → 探针函数;默认使用真实网络探针。
today_fn: 返回 ``YYYY-MM-DD``;测试可注入假日期来验证跨日重测。
"""
def __init__(self, servers_file: Path | None = None) -> None:
self._file = servers_file or _SERVERS_FILE
def __init__(self, cache_file: Path | str | None = None, *,
timeout: float = PROBE_TIMEOUT,
concurrency: int = PROBE_CONCURRENCY,
budget: float = PROBE_BUDGET,
probers: dict[str, ProbeFn] | None = None,
today_fn: Callable[[], str] | None = None) -> None:
self._file = Path(cache_file) if cache_file is not None else None
self._timeout = timeout
self._concurrency = concurrency
self._budget = budget
self._probers = dict(probers or _DEFAULT_PROBERS)
self._today_fn = today_fn or (lambda: date.today().isoformat())
self._lock = asyncio.Lock()
self._last_probe_date: str | None = None
self._probed_today = False
self._handled = False # 本进程是否已处理过今日测速(含"已有缓存,跳过")
self._task: asyncio.Task | None = None
# ---------- 路径与状态 ----------
def cache_file(self) -> Path:
"""缓存文件路径(构造时显式传入的优先,否则按平台规则解析)。"""
return self._file if self._file is not None else probe_cache_file()
def today(self) -> str:
return self._today_fn()
def read_cache(self) -> dict | None:
"""读取当日缓存;``None`` 表示"今天还没测过"。"""
return load_probe_cache(self.today(), self.cache_file())
# ---- 公开 API ----
def needs_probe_today(self) -> bool:
"""是否有必要在今日执行一次全量测速(文件不存在 / 日期不符 / 无 ok 项)。"""
if not self._file.exists():
return True
try:
cfg = json.loads(self._file.read_text(encoding="utf-8"))
except (OSError, ValueError):
return True
checked = str(cfg.get("checked_date", ""))
today = date.today().isoformat()
if checked != today:
return True
servers = cfg.get("servers", [])
if not any(s.get("status") == "ok" for s in servers):
return True
return False
"""今日是否仍需测速(缓存缺失 / 非今日 / 损坏 / 版本不符 / 无任何可用项)。"""
if probe_disabled():
return False
return self.read_cache() is None
async def ensure_probe(self, hosts: list[str]) -> None:
"""若今日尚未测速,则后台执行一次全量测速并入库(幂等)。"""
def reset(self) -> None:
"""清除"本进程已处理"标记(仅供测试复用单例)。"""
self._handled = False
# ---------- 主入口 ----------
async def ensure_probe(self, hosts: list[str] | None = None) -> None:
"""幂等入口:当日尚未测速则测一次;当天已有缓存则立即返回。
- 不阻塞调用方:正常由连接池以后台 task 调用。
- 绝不抛异常(``CancelledError`` 除外):测速 / 写盘失败只落 debug 日志。
- ``hosts``:为兼容旧签名保留,作为**额外的标准通道候选**并入,
且必须通过 :func:`~pytdxdata.config.is_valid_host` 校验(挡住 mock 脏数据)。
"""
async with self._lock:
if self._probed_today:
if self._handled:
return
self._handled = True # 先占位:并发调用方不必排队等网络
if not self.needs_probe_today():
self._probed_today = True
log.debug("当日测速缓存已存在,跳过测速: %s", self.cache_file())
return
self._probed_today = True
# 在锁外执行(耗时网络 IO),允许并发进入的调用方共享本次结果
try:
await self._run_full_probe(hosts)
except Exception as e: # 测速失败不能阻塞主流程
log.warning("后台全量测速失败,沿用既有清单: %s", str(e)[:80])
payload = await self._run_probe(hosts)
if payload is not None:
self._write(payload)
except asyncio.CancelledError:
raise
except Exception as exc: # 测速绝不能影响主流程
log.debug("后台测速失败,沿用既有清单: %s", str(exc)[:120])
# ---- 内部实现 ----
async def _run_full_probe(self, hosts: list[str]) -> None:
from .connection import TdxConnection
# ---------- 内部实现 ----------
async def _run_probe(self, extra_hosts: list[str] | None = None) -> dict | None:
"""全量并发测速,返回待写入的缓存 payload;无任何可达主机时返回 None。"""
candidates = all_probe_candidates()
if extra_hosts:
extra = [h.strip() for h in extra_hosts
if isinstance(h, str) and is_valid_host(h)]
if extra:
candidates["standard"] = list(dict.fromkeys(candidates["standard"] + extra))
jobs = [(proto, ip) for proto, ips in candidates.items() for ip in ips]
if not jobs:
log.debug("无测速候选,跳过")
return None
log.info("开始当日全量服务器测速 (%d 台)...", len(hosts))
sem = asyncio.Semaphore(PROBE_CONCURRENCY)
results: dict[str, float | None] = {}
log.debug("开始当日全量测速: %d 台主机 / %d 个协议探针",
len({ip for _, ip in jobs}), len(jobs))
sem = asyncio.Semaphore(self._concurrency)
# {host: {protocol: 延迟或 None}}
results: dict[str, dict[str, float | None]] = defaultdict(dict)
async def _probe_one(host: str) -> None:
async def _one(protocol: str, host: str) -> None:
async with sem:
try:
# 使用连接自带的 ping():建连+握手+发1条命令测往返延迟
conn = TdxConnection(host, PROBE_PORT, PROBE_TIMEOUT)
dt = await asyncio.wait_for(conn.ping(), timeout=PROBE_TIMEOUT + 1.0)
results[host] = dt # 失败时为 None
lat = await asyncio.wait_for(
self._probers[protocol](host, self._timeout),
timeout=self._timeout + 2.0,
)
except Exception:
results[host] = None
lat = None
results[host][protocol] = lat
await asyncio.gather(*(_probe_one(h) for h in hosts))
ok_hosts = {h: lt for h, lt in results.items() if lt is not None}
# 按延迟升序排名
ranked = sorted(ok_hosts.items(), key=lambda kv: kv[1])
fast = set()
for i, (h, lt) in enumerate(ranked):
if i < FAST_POOL_TOP_N or lt < FAST_POOL_MAX_LATENCY:
fast.add(h)
log.info("测速完成: 可用 %d 台, 入池 %d 台 (前%d或<%dms)",
len(ok_hosts), len(fast), FAST_POOL_TOP_N,
int(FAST_POOL_MAX_LATENCY * 1000))
self._write_results(results, fast)
def _write_results(self, results: dict[str, float | None], fast: set[str]) -> None:
t0 = time.monotonic()
try:
cfg = json.loads(self._file.read_text(encoding="utf-8"))
except (OSError, ValueError):
cfg = {"servers": []}
servers = cfg.get("servers", [])
by_ip = {s.get("ip"): s for s in servers}
await asyncio.wait_for(
asyncio.gather(*(_one(p, ip) for p, ip in jobs)),
timeout=self._budget,
)
except TimeoutError:
# 超时:采用已完成的部分结果(部分可用也强于完全没有)
log.debug("测速整体超过 %.0fs 预算,采用已完成的部分结果", self._budget)
except Exception as exc:
log.debug("测速过程异常: %s", str(exc)[:120])
elapsed = time.monotonic() - t0
today = date.today().isoformat()
now = time.strftime("%Y-%m-%d %H:%M:%S")
checked_any = False
for host, lt in results.items():
entry = by_ip.get(host)
if entry is None:
entry = {"ip": host, "name": host, "protocols": ["standard"]}
servers.append(entry)
by_ip[host] = entry
if lt is not None:
checked_any = True
entry["status"] = "ok" if host in fast else "slow"
entry["latency"] = round(lt, 3)
entry["fast_pool"] = host in fast
else:
# 探测不可达:不降级已有 ok(避免误杀),仅标记本次不可达
entry.setdefault("status", "unknown")
entry["latency"] = None
entry["fast_pool"] = False
entry["checked_date"] = today
entry["checked_at"] = now
responsive = {
ip: {p: lat for p, lat in per.items() if lat is not None}
for ip, per in results.items()
}
responsive = {ip: per for ip, per in responsive.items() if per}
if not responsive:
log.debug("测速结束: 无任何可达主机,不写缓存(下次启动重试)")
return None
# 若有 ok 服务器写入可入池日期;否则保留今日以免反复重试
cfg["checked_date"] = today
cfg["note"] = (
f"当日全量测速入库({today}): 入池={len(fast)}台 "
f"(排名前{FAST_POOL_TOP_N}或延迟<{int(FAST_POOL_MAX_LATENCY*1000)}ms)"
def _ordered(protocol: str) -> list[str]:
rows = [(per[protocol], ip) for ip, per in responsive.items()
if protocol in per]
rows.sort(key=lambda kv: (kv[0], kv[1]))
return [ip for _, ip in rows]
hosts_by_proto = {p: _ordered(p) for p in ("standard", "mac", "ex")}
overall = sorted(
(min(per.values()), ip) for ip, per in responsive.items()
)
if not checked_any:
# 全部不可达时不写 checked_date,下次启动重试
cfg.pop("checked_date", None)
fast = {ip for i, (lat, ip) in enumerate(overall)
if i < FAST_POOL_TOP_N or lat < FAST_POOL_MAX_LATENCY}
self._file.write_text(
json.dumps(cfg, ensure_ascii=False, indent=2), encoding="utf-8"
)
log.info("测速结果已写入 %s", self._file)
log.debug("测速完成: 候选 %d 台, 可达 %d 台, fast %d 台, 耗时 %.2fs",
len({ip for _, ip in jobs}), len(responsive), len(fast), elapsed)
return {
"version": PROBE_CACHE_VERSION,
"date": self.today(),
"probed_at": time.strftime("%Y-%m-%d %H:%M:%S"),
"elapsed": round(elapsed, 3),
# 每个协议的完整探测结果(含 None = 本次不可达),便于事后诊断
"results": {ip: dict(per) for ip, per in results.items() if per},
# 按延迟升序的可达主机(运行时即按此顺序取用)
"hosts": hosts_by_proto,
# 诊断用:符合"前N名或<200ms"的可达主机
"fast": {p: [h for h in ips if h in fast]
for p, ips in hosts_by_proto.items()},
}
def _write(self, payload: dict) -> None:
"""原子写入:先写临时文件再 ``os.replace``,避免读到半截 JSON。"""
target = self.cache_file()
tmp = target.with_name(f"{target.name}.tmp{os.getpid()}")
try:
target.parent.mkdir(parents=True, exist_ok=True)
tmp.write_text(json.dumps(payload, ensure_ascii=False, indent=2),
encoding="utf-8")
os.replace(tmp, target)
log.debug("当日测速结果已缓存: %s", target)
except OSError as exc:
log.debug("测速结果写入失败(忽略): %s", str(exc)[:120])
try:
tmp.unlink(missing_ok=True)
except OSError:
pass
# 进程级单例(跨池共享,确保当日仅测一次)
# 进程级单例(标准 / MAC / EX 三池共享,确保当日只真正测一次)
_probe_cache = ProbeCache()
def get_probe_cache() -> ProbeCache:
return _probe_cache
def schedule_probe(hosts: list[str] | None = None) -> asyncio.Task | None:
"""[连接池用] 把当日测速挂到后台并返回 Task,供调用方持有 / 取消。
返回 ``None`` 表示当前没有运行中的事件循环(此时无法起后台任务)。
"""
try:
return asyncio.create_task(
get_probe_cache().ensure_probe(hosts), name="pytdxdata-daily-probe"
)
except RuntimeError:
return None
+35 -23
View File
@@ -36,6 +36,15 @@ class PageResult:
items: list[Any]
class _Slot:
"""worker 当前持有的连接槽:失败换连时原地更新,保证最终能精确归还。"""
__slots__ = ("pc",)
def __init__(self, pc: PooledConnection) -> None:
self.pc: PooledConnection | None = pc
class Paginator:
"""用至多 concurrency 个连接并行拉取分页数据。"""
@@ -64,22 +73,27 @@ class Paginator:
conns = await self.pool.acquire_many(eff_conc)
if not conns:
raise PoolTimeoutError("连接池获取超时(无可用连接)")
# 每个 worker 一个连接槽:中途换连会更新槽内引用,
# 归还时按槽归还(否则换掉的新连接会漏还,把池耗干)
slots = [_Slot(pc) for pc in conns]
try:
stop = asyncio.Event()
out: list[PageResult] = []
out_lock = asyncio.Lock()
k = len(conns)
k = len(slots)
workers = [
asyncio.create_task(
self._worker(wid, conns[wid % k], jobs[wid::k], cmd_factory,
self._worker(slots[wid], jobs[wid::k], cmd_factory,
stop, out, out_lock, spec)
)
for wid in range(k)
]
await asyncio.gather(*workers)
finally:
for pc in conns:
await self.pool.release(pc)
for s in slots:
if s.pc is not None:
pc, s.pc = s.pc, None
await self.pool.release(pc)
return self._assemble(out, spec.ordered)
def _plan_starts(self, spec: PageSpec) -> list[tuple[int, int]]:
@@ -102,49 +116,47 @@ class Paginator:
return jobs
async def _worker(
self, wid: int, conn: PooledConnection, jobs: list[tuple[int, int]],
self, slot: _Slot, jobs: list[tuple[int, int]],
cmd_factory: Callable[[int, int], Any], stop: asyncio.Event,
out: list[PageResult], out_lock: asyncio.Lock, spec: PageSpec,
) -> None:
current = conn
for start, count in jobs:
if stop.is_set():
if stop.is_set() or slot.pc is None:
return
items, current = await self._fetch_one(
current, cmd_factory(start, count), count)
if items is None:
continue # 该页失败(strict=False 时留空)
items, ok = await self._fetch_one(slot, cmd_factory(start, count), count)
if not ok:
return # 换连接失败 → 本 worker 退出(该页留空)
async with out_lock:
out.append(PageResult(start=start, count=count, items=items))
if spec.stop_when_short and len(items) < count:
stop.set()
return
async def _fetch_one(self, conn: PooledConnection, cmd, page_size: int):
async def _fetch_one(self, slot: _Slot, cmd, page_size: int):
"""单页拉取,失败换连接重试。
返回 (items, current_conn) — current_conn 始终指向当前可用连接,
worker 据此更新自己的连接引用,避免跨页使用已关闭连接。
返回 ``(items, ok)``。失败时连接一律 ``broken=True`` 归还并把槽清空,
调用方据此退出,不会留下悬空引用。
"""
current = conn
for attempt in range(self.retries + 1):
try:
result = await current.execute(cmd)
return (list(result) if result is not None else []), current
result = await slot.pc.execute(cmd) # type: ignore[union-attr]
return (list(result) if result is not None else []), True
except Exception as e:
if slot.pc is not None:
await self.pool.release(slot.pc, broken=True)
slot.pc = None
if attempt >= self.retries:
if self.strict:
raise
log.warning("分页拉取失败(strict=False留空): %s", e)
return None, current
# 换连接重试
await self.pool.release(current, broken=True)
return None, False
try:
current = await self.pool.acquire(timeout=3.0)
slot.pc = await self.pool.acquire(timeout=3.0)
except PoolTimeoutError:
log.warning("分页重试获取连接失败,跳过该页: %s", e)
return None, current
return None, current
return None, False
return None, False
def _assemble(self, results: list[PageResult], ordered: bool) -> list[Any]:
if ordered:
+113 -39
View File
@@ -3,28 +3,43 @@
读 servers.json → 并发探测每台可用性与延时(标准/MAC用7709、EX用7727)→ 写回状态。
用法:
python -m pytdxdata.server_probe # 全量探测
python -m pytdxdata.server_probe --group ex # 只测EX
python -m pytdxdata.server_probe --refresh # 重新探测(status=ok的)
python -m pytdxdata.server_probe # 按申报协议全量探测
python -m pytdxdata.server_probe --discover # 额外测【每种协议】并据实修正 protocols
python -m pytdxdata.server_probe --group ex # 只测EX
python -m pytdxdata.server_probe --refresh # 只重测status=ok的
写回的字段
----------
``status`` / ``latency`` / ``checked_at`` / ``checked_date`` / ``fast_pool``
以及顶层 ``checked_date`` / ``note``。其中 ``fast_pool`` 与运行时缓存里的 ``fast``
用同一套规则(整体延迟前 10 名,或延迟 < 200ms),供"还没有当日缓存时"的冷启动排序。
``--discover`` 会顺带剔除 ip 非法的脏记录(如历史遗留的 ``"s1"``)。
"""
from __future__ import annotations
import argparse
import asyncio
import json
import sys
import time
from pathlib import Path
from .config import is_valid_host
from .models import Adjust, KlinePeriod
from .pool.connection import TdxConnection
from .pool.ex_connection import ExTdxConnection
from .protocol.commands.ex_proto import GetExInstrumentBarsCmd
from .protocol.commands.kline import GetSecurityBarsCmd
from .protocol.commands.mac import MacKlineCmd
from .protocol.commands.ex_proto import GetExInstrumentBarsCmd
from .models import KlinePeriod, Adjust
SERVERS_FILE = Path(__file__).resolve().parent / "servers.json"
# 与 pool/probe_cache.py 保持同一套入池规则
FAST_POOL_TOP_N = 10
FAST_POOL_MAX_LATENCY = 0.2
ALL_PROTOCOLS = ("standard", "mac", "ex")
def load_servers() -> dict:
if not SERVERS_FILE.exists():
@@ -41,7 +56,7 @@ async def probe_standard(ip: str, timeout: float = 5.0) -> tuple[bool, float]:
t0 = time.monotonic()
try:
await conn.connect()
bars = await conn.execute(GetSecurityBarsCmd(1, "600000", 5, 0, 100))
bars = await conn.execute(GetSecurityBarsCmd(1, "600000", KlinePeriod.DAY, 0, 100))
return (bool(bars), time.monotonic() - t0)
except Exception:
return (False, time.monotonic() - t0)
@@ -75,25 +90,51 @@ async def probe_ex(ip: str, handshake: str, timeout: float = 5.0) -> tuple[bool,
await conn.close()
async def probe_one(server: dict, timeout: float) -> dict:
async def probe_proto(proto: str, ip: str, handshake: str, timeout: float) -> tuple[bool, float]:
"""按协议分派到具体探针。"""
if proto == "ex":
return await probe_ex(ip, handshake, timeout)
if proto == "mac":
return await probe_mac(ip, timeout)
return await probe_standard(ip, timeout)
async def probe_one(server: dict, timeout: float, discover: bool = False) -> dict:
ip = server["ip"]
protocols = server.get("protocols", [])
best_lat = None
ok = False
# 逐协议探测(一台多协议: standard/mac同端口可复用连接——简化逐协议测)
for proto in protocols:
declared = server.get("protocols", [])
handshake = server.get("handshake") or "setup"
# discover: 三种协议全测(EX 先按申报握手,失败再试另一种);
# 默认: 只测申报的协议(保持原行为,避免误改人工裁剪的清单)
targets = list(ALL_PROTOCOLS) if discover else list(declared)
per: dict[str, float | None] = {}
for proto in targets:
if proto == "ex":
r, lat = await probe_ex(ip, server.get("handshake", "setup"), timeout)
elif proto == "mac":
r, lat = await probe_mac(ip, timeout)
ok, lat = await probe_ex(ip, handshake, timeout)
if not ok and discover:
# 握手模式申报错的节点:换一种再试(login <-> setup)
alt = "setup" if handshake == "login" else "login"
ok, lat = await probe_ex(ip, alt, timeout)
else:
r, lat = await probe_standard(ip, timeout)
if r:
ok = True
best_lat = lat if best_lat is None else min(best_lat, lat)
server["status"] = "ok" if ok else "fail"
server["latency"] = round(best_lat, 3) if best_lat is not None else None
server["checked_at"] = time.strftime("%Y-%m-%d %H:%M:%S")
ok, lat = await probe_proto(proto, ip, handshake, timeout)
if not ok and discover:
# discover 会据结果**收窄 protocols**,单次抖动就会误删协议 → 失败重试一次
ok, lat = await probe_proto(proto, ip, handshake, timeout)
if ok:
per[proto] = lat
if discover and per:
# 据实测结果修正申报协议(保序:standard / mac / ex)
server["protocols"] = [p for p in ALL_PROTOCOLS if p in per]
server["status"] = "ok" if per else "fail"
server["latency"] = round(min(per.values()), 3) if per else None
now = time.strftime("%Y-%m-%d %H:%M:%S")
server["checked_at"] = now
server["checked_date"] = now[:10]
server.setdefault("fast_pool", False)
# 供表格打印用,不落盘
server["_per_proto"] = {p: (round(v, 3) if v is not None else None) for p, v in per.items()}
return server
@@ -102,10 +143,21 @@ async def main() -> None:
ap.add_argument("--group", choices=["standard", "mac", "ex"], default=None)
ap.add_argument("--timeout", type=float, default=5.0)
ap.add_argument("--refresh", action="store_true", help="只重测status=ok的")
ap.add_argument("--discover", action="store_true",
help="三种协议全测并据实修正 protocols(同时剔除 ip 非法的脏记录)")
args = ap.parse_args()
cfg = load_servers()
servers = cfg["servers"]
all_servers = cfg["servers"]
# --- 清理:ip 不合法的脏记录(历史遗留,如 "s1") ---
junk = [s.get("ip") for s in all_servers if not is_valid_host(s.get("ip"))]
if junk:
cfg["servers"] = [s for s in all_servers if is_valid_host(s.get("ip"))]
all_servers = cfg["servers"]
print("已剔除 ip 非法记录: %s" % ", ".join(map(str, junk)))
servers = all_servers
if args.group:
servers = [s for s in servers if args.group in s.get("protocols", [])]
if args.refresh:
@@ -114,33 +166,55 @@ async def main() -> None:
print("没有待探测的服务器")
return
print("=" * 90)
print("探测 %d 台服务器 (标准/MAC:7709, EX:7727)..." % len(servers))
print("=" * 90)
print("=" * 96)
print("探测 %d 台服务器 (标准/MAC:7709, EX:7727)%s..." % (
len(servers), " [discover: 全协议]" if args.discover else ""))
print("=" * 96)
t0 = time.time()
results = await asyncio.gather(*[probe_one(s, args.timeout) for s in servers])
results = await asyncio.gather(
*[probe_one(s, args.timeout, args.discover) for s in servers]
)
elapsed = time.time() - t0
# 写回
updated = {s["ip"]: s for s in results}
# --- 入池标记:与运行时缓存同一规则(前N名 或 <200ms) ---
ok_list = [s for s in results if s["status"] == "ok"]
ok_list.sort(key=lambda s: s["latency"])
fast_ips = {s["ip"] for i, s in enumerate(ok_list)
if i < FAST_POOL_TOP_N or s["latency"] < FAST_POOL_MAX_LATENCY}
for s in ok_list:
s["fast_pool"] = s["ip"] in fast_ips
fail_list = [s for s in results if s["status"] == "fail"]
for s in fail_list:
s["fast_pool"] = False
# --- 写回(剔除内部诊断字段) ---
today = time.strftime("%Y-%m-%d")
updated = {s["ip"]: {k: v for k, v in s.items() if not k.startswith("_")} for s in results}
for s in cfg["servers"]:
if s["ip"] in updated:
s.update(updated[s["ip"]])
cfg["checked_date"] = today
cfg["version"] = today # 清单基线日期(无代码读取,仅标注本次复测时间)
cfg["note"] = "离线探针复测(%s %s): 可达=%d/%d, 入池fast_pool=%d台" % (
today, time.strftime("%H:%M"), len(ok_list), len(results), len(fast_ips))
save_servers(cfg)
ok_list = [s for s in results if s["status"] == "ok"]
ok_list.sort(key=lambda s: s["latency"])
fail_list = [s for s in results if s["status"] == "fail"]
print("\n可用: %d/%d (%.1fs)" % (len(ok_list), len(results), elapsed))
print("-" * 90)
print("\n可用: %d/%d (%.1fs) 入池: %d台" % (len(ok_list), len(results), elapsed, len(fast_ips)))
print("-" * 96)
for s in ok_list:
print(" [OK] %-16s %-14s %-28s %.3fs %s" % (
s["ip"], "/".join(s.get("protocols", [])), s["name"],
s["latency"], s.get("handshake") or ""))
per = s.get("_per_proto", {})
detail = " ".join(
"%s=%s" % (p, ("%.3fs" % v) if v is not None else "-")
for p, v in per.items()
) or "/".join(s.get("protocols", []))
print(" [OK] %-16s %-24s %-24s %.3fs %s%s" % (
s["ip"], "/".join(s.get("protocols", [])), s["name"], s["latency"],
"★" if s["fast_pool"] else " ", detail))
if fail_list:
print("\n不可用: %d台" % len(fail_list))
for s in fail_list:
print(" [X] %-16s %s" % (s["ip"], "/".join(s.get("protocols", []))))
print(" [X] %-16s %-24s %s" % (
s["ip"], "/".join(s.get("protocols", [])), s["name"]))
print("\n已写回 %s" % SERVERS_FILE)
+236 -150
View File
@@ -1,6 +1,6 @@
{
"version": "2026-08-12",
"note": "当日全量测速入库(2026-09-08): 入池=9台 (排名前10或延迟<200ms)",
"version": "2026-09-21",
"note": "离线探针复测(2026-09-21 19:03): 可达=25/33, 入池fast_pool=10台",
"servers": [
{
"ip": "139.9.52.158",
@@ -11,11 +11,15 @@
],
"handshake": null,
"status": "ok",
"latency": null,
"checked_at": "2026-08-21 11:23:14",
"latency": 0.22,
"checked_at": "2026-09-21 19:03:04",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-21"
"fast_pool": true,
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.226,
"mac": 0.22
}
},
{
"ip": "103.251.85.94",
@@ -25,42 +29,50 @@
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.481,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.366,
"checked_at": "2026-09-21 19:03:04",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.396,
"mac": 0.366
}
},
{
"ip": "58.67.221.146",
"name": "中信短线宝21",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "ok",
"latency": 0.254,
"checked_at": "2026-09-08 10:05:12",
"latency": 0.257,
"checked_at": "2026-09-21 19:03:09",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.257
}
},
{
"ip": "59.36.5.11",
"name": "安信",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "ok",
"latency": 0.254,
"checked_at": "2026-09-08 10:05:12",
"latency": 0.248,
"checked_at": "2026-09-21 19:03:04",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.248
}
},
{
"ip": "103.221.142.82",
@@ -71,12 +83,17 @@
"ex"
],
"handshake": "setup",
"status": "slow",
"latency": 0.487,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.221,
"checked_at": "2026-09-21 19:03:00",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"fast_pool": true,
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.399,
"mac": 0.414,
"ex": 0.221
}
},
{
"ip": "218.106.92.182",
@@ -85,27 +102,30 @@
"standard"
],
"handshake": null,
"status": "ok",
"latency": 0.371,
"checked_at": "2026-09-08 10:05:12",
"status": "fail",
"latency": null,
"checked_at": "2026-09-21 19:03:20",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"fast_pool": false,
"checked_date": "2026-09-21",
"_per_proto": {}
},
{
"ip": "60.12.136.251",
"name": "中信短线宝22",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "ok",
"latency": 0.37,
"checked_at": "2026-09-08 10:05:12",
"latency": 0.363,
"checked_at": "2026-09-21 19:03:10",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.363
}
},
{
"ip": "218.106.92.183",
@@ -114,42 +134,47 @@
"standard"
],
"handshake": null,
"status": "ok",
"latency": 0.377,
"checked_at": "2026-09-08 10:05:12",
"status": "fail",
"latency": null,
"checked_at": "2026-09-21 19:03:20",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"fast_pool": false,
"checked_date": "2026-09-21",
"_per_proto": {}
},
{
"ip": "60.12.136.250",
"name": "中信短线宝26",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "ok",
"latency": 0.373,
"checked_at": "2026-09-08 10:05:12",
"latency": 0.344,
"checked_at": "2026-09-21 19:03:10",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.344
}
},
{
"ip": "115.238.90.170",
"name": "中信短线宝23",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.482,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.404,
"checked_at": "2026-09-21 19:03:10",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.404
}
},
{
"ip": "220.178.55.86",
@@ -158,12 +183,13 @@
"standard"
],
"handshake": null,
"status": "slow",
"latency": 0.479,
"checked_at": "2026-08-19 15:37:35",
"status": "fail",
"latency": null,
"checked_at": "2026-09-21 19:03:24",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {}
},
{
"ip": "220.178.55.71",
@@ -172,87 +198,98 @@
"standard"
],
"handshake": null,
"status": "slow",
"latency": 0.47,
"checked_at": "2026-08-19 15:37:35",
"status": "fail",
"latency": null,
"checked_at": "2026-09-21 19:03:21",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {}
},
{
"ip": "180.153.18.170",
"name": "中信短线宝1",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.438,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.376,
"checked_at": "2026-09-21 19:03:10",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.376
}
},
{
"ip": "115.238.90.165",
"name": "杭州J4",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.476,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.377,
"checked_at": "2026-09-21 19:03:10",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.377
}
},
{
"ip": "60.191.117.167",
"name": "杭州J1",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "ok",
"latency": 0.362,
"checked_at": "2026-09-08 10:05:12",
"latency": 0.401,
"checked_at": "2026-09-21 19:03:10",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"fast_pool": false,
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.401
}
},
{
"ip": "218.75.126.9",
"name": "杭州J3",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.481,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.42,
"checked_at": "2026-09-21 19:03:10",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.42
}
},
{
"ip": "115.238.56.198",
"name": "杭州J2",
"protocols": [
"standard",
"mac"
],
"handshake": null,
"status": "ok",
"latency": 0.362,
"checked_at": "2026-09-08 10:05:12",
"latency": 0.401,
"checked_at": "2026-09-21 19:03:10",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"fast_pool": false,
"checked_date": "2026-09-21",
"_per_proto": {
"mac": 0.401
}
},
{
"ip": "117.34.114.16",
@@ -262,12 +299,16 @@
"mac"
],
"handshake": null,
"status": "slow",
"latency": 1.575,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.485,
"checked_at": "2026-09-21 19:03:05",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.485,
"mac": 0.605
}
},
{
"ip": "159.75.55.232",
@@ -276,26 +317,32 @@
"standard"
],
"handshake": null,
"status": "ok",
"latency": 0.244,
"checked_at": "2026-09-08 10:05:12",
"status": "fail",
"latency": null,
"checked_at": "2026-09-21 19:03:04",
"source": "probe-2026-08-12",
"fast_pool": true,
"checked_date": "2026-09-08"
"fast_pool": false,
"checked_date": "2026-09-21",
"_per_proto": {}
},
{
"ip": "117.34.114.17",
"name": "国泰君安",
"protocols": [
"standard"
"standard",
"mac"
],
"handshake": null,
"status": "slow",
"latency": 1.573,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.444,
"checked_at": "2026-09-21 19:03:05",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.444,
"mac": 0.903
}
},
{
"ip": "117.34.114.14",
@@ -305,12 +352,13 @@
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.508,
"checked_at": "2026-08-19 15:37:35",
"status": "fail",
"latency": null,
"checked_at": "2026-09-21 19:03:15",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {}
},
{
"ip": "117.34.114.15",
@@ -320,12 +368,16 @@
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.636,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.435,
"checked_at": "2026-09-21 19:03:05",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.463,
"mac": 0.435
}
},
{
"ip": "117.34.114.13",
@@ -335,12 +387,13 @@
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.608,
"checked_at": "2026-08-19 15:37:35",
"status": "fail",
"latency": null,
"checked_at": "2026-09-21 19:03:14",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {}
},
{
"ip": "117.34.114.27",
@@ -350,12 +403,16 @@
"mac"
],
"handshake": null,
"status": "slow",
"latency": 1.138,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.482,
"checked_at": "2026-09-21 19:03:05",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.482,
"mac": 0.579
}
},
{
"ip": "117.34.114.18",
@@ -365,12 +422,16 @@
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.969,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.609,
"checked_at": "2026-09-21 19:03:05",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.946,
"mac": 0.609
}
},
{
"ip": "117.34.114.20",
@@ -380,12 +441,16 @@
"mac"
],
"handshake": null,
"status": "slow",
"latency": 0.526,
"checked_at": "2026-08-19 15:37:35",
"status": "ok",
"latency": 0.46,
"checked_at": "2026-09-21 19:03:05",
"source": "probe-2026-08-12",
"fast_pool": false,
"checked_date": "2026-08-19"
"checked_date": "2026-09-21",
"_per_proto": {
"standard": 0.46,
"mac": 0.521
}
},
{
"ip": "117.34.114.30",
@@ -396,8 +461,11 @@
"handshake": null,
"status": "fail",
"latency": null,
"checked_at": "2026-08-12 18:36:21",
"source": "probe-2026-08-12"
"checked_at": "2026-09-21 19:03:24",
"source": "probe-2026-08-12",
"checked_date": "2026-09-21",
"fast_pool": false,
"_per_proto": {}
},
{
"ip": "121.37.207.165",
@@ -407,9 +475,14 @@
],
"handshake": null,
"status": "ok",
"latency": 0.249,
"checked_at": "2026-08-12 18:36:17",
"source": "probe-2026-08-12"
"latency": 0.271,
"checked_at": "2026-09-21 19:03:04",
"source": "probe-2026-08-12",
"checked_date": "2026-09-21",
"fast_pool": true,
"_per_proto": {
"mac": 0.271
}
},
{
"ip": "121.36.248.138",
@@ -419,9 +492,14 @@
],
"handshake": null,
"status": "ok",
"latency": 0.436,
"checked_at": "2026-08-12 18:36:17",
"source": "probe-2026-08-12"
"latency": 0.375,
"checked_at": "2026-09-21 19:03:05",
"source": "probe-2026-08-12",
"checked_date": "2026-09-21",
"fast_pool": false,
"_per_proto": {
"mac": 0.375
}
},
{
"ip": "123.60.47.136",
@@ -431,9 +509,14 @@
],
"handshake": null,
"status": "ok",
"latency": 0.476,
"checked_at": "2026-08-12 18:36:17",
"source": "probe-2026-08-12"
"latency": 0.424,
"checked_at": "2026-09-21 19:03:05",
"source": "probe-2026-08-12",
"checked_date": "2026-09-21",
"fast_pool": false,
"_per_proto": {
"mac": 0.424
}
},
{
"ip": "116.205.135.205",
@@ -443,9 +526,14 @@
],
"handshake": "login",
"status": "ok",
"latency": 0.192,
"checked_at": "2026-08-12 18:36:17",
"source": "probe-2026-08-12"
"latency": 0.176,
"checked_at": "2026-09-21 19:03:08",
"source": "probe-2026-08-12",
"checked_date": "2026-09-21",
"fast_pool": true,
"_per_proto": {
"ex": 0.176
}
},
{
"ip": "121.37.232.167",
@@ -455,9 +543,14 @@
],
"handshake": "login",
"status": "ok",
"latency": 0.194,
"checked_at": "2026-08-12 18:36:17",
"source": "probe-2026-08-12"
"latency": 0.148,
"checked_at": "2026-09-21 19:03:08",
"source": "probe-2026-08-12",
"checked_date": "2026-09-21",
"fast_pool": true,
"_per_proto": {
"ex": 0.148
}
},
{
"ip": "116.205.143.214",
@@ -467,22 +560,15 @@
],
"handshake": "setup",
"status": "ok",
"latency": 0.192,
"checked_at": "2026-08-12 18:36:17",
"source": "probe-2026-08-12"
},
{
"ip": "s1",
"name": "s1",
"protocols": [
"standard"
],
"status": "unknown",
"latency": null,
"fast_pool": false,
"checked_date": "2026-08-19",
"checked_at": "2026-08-19 15:34:45"
"latency": 0.166,
"checked_at": "2026-09-21 19:03:08",
"source": "probe-2026-08-12",
"checked_date": "2026-09-21",
"fast_pool": true,
"_per_proto": {
"ex": 0.166
}
}
],
"checked_date": "2026-09-08"
"checked_date": "2026-09-21"
}
+240
View File
@@ -0,0 +1,240 @@
"""标的代码解析:全库唯一的字符串口径。
统一写法(也是 CLI 的写法)::
sz000001 / sh600000 / bj920992 A股(6位代码,必须带市场前缀)
hk00700 港股主板(5位)
usAAPL 美股(ticker)
cffex:IFL0 / zz:AP0 期货(交易所前缀 + 合约,可带冒号)
000001 裸 6 位数字 = 沪市指数
**裸 6 位数字只当作沪市指数**:A股代码不唯一(``000001`` 既是上证指数也是平安银行),
要股票请写全前缀 ``sh000001`` / ``sz000001``。
"""
from __future__ import annotations
from dataclasses import dataclass
from typing import Sequence
from .models import ExMarket, Market
# 通道:cn=标准/MAC A股通道,ex=扩展市场通道(端口 7727)
CN = "cn"
EX = "ex"
INDEX = "index"
_CN_ALIASES: dict[str, Market] = {
"sz": Market.SZ,
"sh": Market.SH,
"bj": Market.BJ,
}
_CN_PREFIX: dict[int, str] = {int(m): k for k, m in _CN_ALIASES.items()}
# EX 常用别名(短前缀优先;其余成员用枚举名小写,如 hk_gem:08001)
_EX_ALIASES: dict[str, ExMarket] = {
"hk": ExMarket.HK_MAIN_BOARD,
"us": ExMarket.US_STOCK,
"zz": ExMarket.ZZ_FUTURES,
"dl": ExMarket.DL_FUTURES,
"shf": ExMarket.SH_FUTURES,
"cffex": ExMarket.CFFEX_FUTURES,
"gz": ExMarket.GZ_FUTURES,
}
_EX_PREFIX: dict[int, str] = {int(m): k for k, m in _EX_ALIASES.items()}
ALL = "all"
def _ex_by_name(name: str) -> ExMarket | None:
"""按枚举名匹配(hk_main_board / us_stock / ...),保证 format→parse 可往返。"""
key = name.upper()
for member in ExMarket:
if member.name == key:
return member
return None
def _lookup(text: str) -> tuple[int, str] | None:
"""前缀 -> (市场号, 通道)。"""
if text in _CN_ALIASES:
return int(_CN_ALIASES[text]), CN
if text in _EX_ALIASES:
return int(_EX_ALIASES[text]), EX
member = _ex_by_name(text)
if member is not None:
return int(member), EX
return None
def _hint() -> str:
cn = "/".join(sorted(_CN_ALIASES))
ex = "/".join(sorted(_EX_ALIASES))
return f"A股: {cn};扩展市场: {ex}(详见 pytdxdata.models.ExMarket)"
@dataclass(frozen=True, slots=True)
class Symbol:
"""解析后的标的。``kind``: cn=A股 / ex=扩展市场 / index=裸数字指数。"""
market: int
code: str
kind: str
raw: str = ""
@property
def is_ex(self) -> bool:
return self.kind == EX
@property
def is_index(self) -> bool:
return self.kind == INDEX
@property
def channel(self) -> str:
"""路由通道:ex 走扩展市场池,其余走标准/MAC A股池。"""
return EX if self.is_ex else "std"
@property
def text(self) -> str:
"""规范化写法,同时用作记录上的 ``.symbol``。"""
if self.is_index:
return self.code
return format_symbol(self.market, self.code)
def as_pair(self) -> tuple[int, str]:
"""(市场号, 代码) 元组(协议层用)。"""
return self.market, self.code
def __str__(self) -> str:
return self.text
def _prefix_for(market: int) -> str | None:
"""市场号 -> 短前缀;无短别名的扩展市场回退到枚举名小写。"""
m = int(market)
prefix = _CN_PREFIX.get(m) or _EX_PREFIX.get(m)
if prefix is not None:
return prefix
try:
return ExMarket(m).name.lower()
except ValueError:
return None
def format_symbol(market: int, code: str) -> str:
"""(市场号, 代码) -> 规范化字符串(``1, "600000"`` -> ``"sh600000"``)。"""
code = str(code).strip()
if not code:
return ""
prefix = _prefix_for(market)
if prefix is None:
return code
# 2 字母前缀贴代码(hk00700),长前缀用冒号(cffex:IFL0 / hk_gem:08001)
return f"{prefix}:{code}" if len(prefix) > 2 else f"{prefix}{code}"
def market_name(market: int) -> str:
"""市场号 -> 市场选择器字符串(``1`` -> ``"sh"``,``31`` -> ``"hk"``)。
用于把旧接口的市场号参数转成统一接口要的市场选择器。
"""
prefix = _prefix_for(market)
if prefix is None:
raise ValueError(f"未知市场号: {market}")
return prefix
def parse_symbol(text: str) -> Symbol:
"""字符串 -> Symbol。无法识别时抛 ValueError 并列出可用前缀。"""
raw = text
sym = str(text).strip()
if not sym:
raise ValueError("标的为空")
if ":" in sym:
head, code = sym.split(":", 1)
head, code = head.strip().lower(), code.strip()
hit = _lookup(head)
if hit is None:
raise ValueError(f"未知市场前缀: {head}({_hint()})")
if not code:
raise ValueError(f"缺少代码: {raw}")
return Symbol(market=hit[0], code=code.upper(), kind=hit[1], raw=raw)
head, code = sym[:2].lower(), sym[2:]
hit = _lookup(head)
if hit is not None and code:
return Symbol(market=hit[0], code=code.upper(), kind=hit[1], raw=raw)
if sym.isdigit() and len(sym) == 6:
# 裸 6 位 = 沪市指数(A股代码不唯一,股票必须带前缀)
return Symbol(market=int(Market.SH), code=sym, kind=INDEX, raw=raw)
raise ValueError(f"无法识别标的: {raw}({_hint()};裸6位数字=沪市指数)")
def parse_symbols(symbols: str | Sequence[str] | None) -> list[Symbol]:
"""接受单个字符串 / 字符串序列 / Symbol 序列,去重并保持输入顺序。"""
if symbols is None:
raise ValueError("symbols 不能为空")
items: list = [symbols] if isinstance(symbols, str) else list(symbols)
if not items:
raise ValueError("symbols 不能为空")
out: list[Symbol] = []
seen: set[tuple[int, str]] = set()
for item in items:
sym = item if isinstance(item, Symbol) else parse_symbol(item)
if sym.as_pair() in seen:
continue
seen.add(sym.as_pair())
out.append(sym)
return out
def cn_markets() -> list[int]:
"""A股市场号(深/沪/北)。"""
return [int(m) for m in Market]
def ex_markets() -> list[int]:
"""扩展市场号,按枚举值升序。"""
return sorted(int(m) for m in ExMarket)
def market_targets(text: str | None) -> list[tuple[int, str]]:
"""市场选择器 -> [(市场号, 通道)];``None`` / ``"all"`` = 全部市场。
市场号在两条通道里会撞车(``Market.SH=1`` 与 ``ExMarket.TEMP_STOCK=1``),
所以必须带通道一起返回,调用方按通道分别请求。
"""
key = "" if text is None else str(text).strip().lower()
if not key or key == ALL:
return ([(m, CN) for m in cn_markets()]
+ [(m, EX) for m in ex_markets()])
hit = _lookup(key)
if hit is None:
raise ValueError(f"未知市场: {text}({_hint()};全部用 all)")
return [hit]
def parse_market(text: str | None) -> int | None:
"""市场选择器 -> 单个市场号;``None`` / ``"all"`` 返回 None。
只用于「本来就是单市场」的接口(如市场异动)。需要跨市场时用
:func:`market_targets`。
"""
targets = market_targets(text)
return None if len(targets) > 1 else targets[0][0]
def is_cn_index(market: int, code: str) -> bool:
"""A股指数代码判定:88开头板块指数 / 沪市000 / 深市399。
深市股票 000001 不是指数,必须带市场判断。
"""
code = str(code)
return (
code.startswith("88")
or (code.startswith("000") and int(market) == int(Market.SH))
or (code.startswith("399") and int(market) == int(Market.SZ))
)
+673
View File
@@ -0,0 +1,673 @@
"""全接口回归:mock 连接,逐个调用 ``TdxData`` 的每一个公开方法。
目标是「没有接口是死的」——每个公开方法至少被真实调用一次并返回预期形状。
末尾的 ``test_every_public_method_was_exercised`` 用 AST 解析 ``api.py``,
断言覆盖集合与全部公开方法**完全相等**:以后新增方法若没纳入本文件就会失败
(与 ``scripts/check_docs.py`` 的 ``MUST_LIST_ALL`` 互为呼应)。
不连任何网络:标准 / MAC / EX 连接全部被 mock;探测缓存被短路。
"""
from __future__ import annotations
import ast
import datetime
import io
import pathlib
import struct
import time
import zipfile
from unittest import mock
import pytest
from pytdxdata.api import TdxData
from pytdxdata.models import (
AuctionItem,
BelongBoard,
BoardInfo,
CapitalFlow,
FinanceRecord,
MemberQuote,
MinuteBar,
SecurityBar,
SecurityInfo,
SecurityQuote,
ServerInfo,
SymbolSnapshot,
TransactionRecord,
UnusualItem,
XdxrRecord,
)
# --------------------------------------------------------------------------- #
# 覆盖追踪
# --------------------------------------------------------------------------- #
EXERCISED: set[str] = set()
def _use(name: str) -> None:
EXERCISED.add(name)
def _public_methods() -> set[str]:
"""AST 解析 api.py,取 TdxData 的全部公开方法名(与 check_docs 同口径)。"""
src = pathlib.Path(__file__).resolve().parent.parent / "src" / "pytdxdata" / "api.py"
tree = ast.parse(src.read_text(encoding="utf-8"))
for node in ast.walk(tree):
if isinstance(node, ast.ClassDef) and node.name == "TdxData":
return {
item.name
for item in node.body
if isinstance(item, ast.FunctionDef | ast.AsyncFunctionDef)
and not item.name.startswith("_")
}
raise AssertionError("api.py 里找不到 TdxData")
# --------------------------------------------------------------------------- #
# mock 数据
# --------------------------------------------------------------------------- #
_TOTAL_BARS = 2000
_BASE_DATE = datetime.date(2026, 9, 16)
_QUOTE_FIELDS = {
"0x0": 9.8, "0x1": 9.9, "0x2": 10.2, "0x3": 9.7, "0x4": 10.0,
"0x5": 1000.0, "0x6": 1.0, "0x7": 1_000_000.0, "0x38": 5000.0,
}
def _mk_bar(market: int, code: str, offset: int) -> SecurityBar:
"""offset 越大越老(标准通道语义:offset 0 = 最新一根)。"""
d = _BASE_DATE - datetime.timedelta(days=offset)
return SecurityBar(
market=market, code=code, open=10.0, high=10.5, low=9.5,
close=10.0 + (offset % 5) * 0.1, vol=1000.0, amount=10000.0,
year=d.year, month=d.month, day=d.day, hour=9, minute=30,
)
def _bars(start: int, count: int, market: int, code: str) -> list[SecurityBar]:
hi = min(start + count, _TOTAL_BARS)
return [_mk_bar(market, code, i) for i in range(start, hi)]
def _quote(market: int, code: str) -> SecurityQuote:
return SecurityQuote(
market=market, code=code, price=10.0, pre_close=9.8, open=9.9,
high=10.2, low=9.7, vol=1000.0, amount=1_000_000.0, s_vol=10.0,
b_vol=12.0, bid=[9.99] * 5, ask=[10.01] * 5,
)
def _member(market: int, code: str) -> MemberQuote:
return MemberQuote(market=market, code=code, name="测试",
fields=dict(_QUOTE_FIELDS))
class _FileMeta:
"""对应 protocol.commands.mac_ext.FileMeta(避免直接依赖内部类)。"""
__slots__ = ("flag", "md5", "offset", "size")
def __init__(self, offset=0, size=4, flag=0, md5=""):
self.offset, self.size, self.flag, self.md5 = offset, size, flag, md5
class _BlockMeta:
__slots__ = ("filename", "md5", "size")
def __init__(self, size=4, md5="", filename=""):
self.size, self.md5, self.filename = size, md5, filename
def _dispatch(cmd) -> object:
"""按命令类名返回形状正确的数据。"""
n = type(cmd).__name__
market = getattr(cmd, "market", 1)
code = getattr(cmd, "code", "600000")
start = getattr(cmd, "start", 0)
count = getattr(cmd, "count", 100) or 100
if n == "GetSecurityCountCmd":
return 8
if n == "GetSecurityListCmd":
return [SecurityInfo(market=1, code="600000", name="浦发银行",
volunit=100, decimal_point=2, pre_close=10.0)]
# ---- K线 ----
if n in ("GetSecurityBarsCmd", "GetIndexBarsCmd", "MacKlineCmd"):
return _bars(start, count, market, code)
if n == "GetExInstrumentBarsCmd":
return [{"year": 2026, "month": 9, "day": 1, "hour": 9, "minute": 30,
"open": 10.0, "high": 10.5, "low": 9.5, "close": 10.0,
"trade": 1000}]
# ---- 报价 ----
if n == "GetSecurityQuotesCmd":
return [_quote(m, c) for m, c in cmd.stocks]
if n == "MacSymbolQuotesCmd":
return [_member(m, c) for m, c in cmd.stocks]
if n == "MacBoardMembersQuotesCmd":
return [_member(1, "600000")]
# ---- 逐笔 / 分时 ----
if n == "MacTransactionCmd":
return [TransactionRecord(market=market, code=code, time="09:30",
price=10.0, vol=100.0, trade_count=1, bs_flag=0)]
if n in ("GetExTransactionDataCmd", "GetExHistoryTransactionDataCmd"):
return [{"minutes": 570, "price": 10.0, "vol": 100.0, "direction": 0,
"zengcang": 1.0}]
if n == "MacTickChartCmd":
return [MinuteBar(price=p, vol=100.0, hour=9, minute=30 + i)
for i, p in enumerate((10.0, 10.1, 10.2))]
if n == "SymbolTickChartCmd":
return [{"minutes": 570, "price": 10.0, "vol": 100.0, "avg": 10.0,
"momentum": 0.1}]
if n == "MacChartSamplingCmd":
# 刻意与 MacTickChartCmd 的 mock 数据不同:A股由分时派生、EX 用 0x254D,
# 靠返回值即可区分实际走了哪条命令(BUG-1 回归用)。
return [99.0, 98.0]
# ---- 公司信息 ----
if n == "MacSymbolInfoCmd":
return SymbolSnapshot(
market=market, code=code, name="浦发银行", date=20260916, time=930,
activity=1.0, pre_close=9.8, open=9.9, high=10.2, low=9.7,
close=10.0, vol=1000.0, amount=1_000_000.0, turnover=1.0,
avg_price=10.0)
if n == "MacAuctionCmd":
return [AuctionItem(time=93000, price=10.0, matched=100, unmatched=0)]
if n == "MacCapitalFlowCmd":
return CapitalFlow(market=market, code=code, main_buy=1.0, main_sell=1.0,
retail_buy=1.0, retail_sell=1.0, buy5=1.0, sell5=1.0,
big5=1.0, mid5=1.0)
if n == "GetXdxrInfoCmd":
return [XdxrRecord(market=market, code=code, year=2025, month=6, day=1,
category=1, name="除权除息")]
if n == "GetFinanceInfoCmd":
return FinanceRecord(market=market, code=code)
if n == "GetCompanyInfoCategoryCmd":
return [{"name": "最新提示", "filename": "600000.txt", "length": 10}]
if n == "GetCompanyInfoContentCmd":
return "公司资料正文"
# ---- 市场 / 板块 ----
if n == "MacUnusualCmd":
return [UnusualItem(market=1, code="600000", name="测试", type=1,
desc="描述", value=1.0, time=930)]
if n == "MacServerInfoCmd":
return ServerInfo(date=20260916, last_trade_date=20260915,
sessions=[(570, 690)])
if n == "MacKlineOffsetCmd":
return (_TOTAL_BARS, 100)
if n == "MacBoardListCmd":
return [BoardInfo(market=1, code="881001", name="银行", price=110.0,
rise_speed=0.1, pre_close=100.0)]
if n == "MacBelongBoardCmd":
return [BelongBoard(market=market, board_code=20686, board_name="银行",
close=110.0, pre_close=100.0)]
# ---- 文件 ----
if n == "MacFileListCmd":
return _FileMeta(size=4)
if n == "GetBlockInfoMetaCmd":
return _BlockMeta(size=4)
if n in ("GetBlockInfoCmd", "GetReportFileCmd", "MacFileDownloadCmd"):
return b"abcd"
# ---- EX 市场 ----
if n == "GetExInstrumentCountCmd":
return 2
if n == "GetExInstrumentInfoCmd":
return [{"market": 31, "code": "00700", "name": "腾讯控股", "desc": "港股"},
{"market": 74, "code": "AAPL", "name": "苹果", "desc": "美股"}]
return []
class _MockConn:
"""替代 TdxConnection / ExTdxConnection。"""
def __init__(self, host="h", port=7709, timeout=3.0, *args, **kwargs):
self.host = host
self.server = host
self.port = port
self.timeout = timeout
self.alive = True
self.last_used = time.monotonic()
async def connect(self) -> None:
self.alive = True
async def close(self) -> None:
self.alive = False
async def ping(self):
return 0.01
async def execute(self, cmd):
self.last_used = time.monotonic()
return _dispatch(cmd)
# --------------------------------------------------------------------------- #
# 离线文件样本(供 *_parsed / get_file 走通解析路径)
# --------------------------------------------------------------------------- #
_HEADER = 384
def _make_block_dat() -> bytes:
out = bytearray(_HEADER)
out += struct.pack("<H", 1)
rec = bytearray()
rec += "银行".encode("gbk")[:9].ljust(9, b"\x00")
rec += struct.pack("<HH", 1, 1)
area = bytearray(2800)
area[0:7] = "000001".encode("ascii").ljust(7, b"\x00")
rec += area
out += rec
return bytes(out)
def _make_financial_zip() -> bytes:
entry = struct.pack("<6sBL", b"600000", 1, 31)
header = struct.pack("<1hI1H3L", 0, 20260331, 1, 0, 8, 0)
dat = header + entry + struct.pack("<2f", 1.0, 2.0)
buf = io.BytesIO()
with zipfile.ZipFile(buf, "w") as zf:
zf.writestr("gpcw.dat", dat)
return buf.getvalue()
def _make_financial_dat() -> bytes:
"""未压缩 .dat(服务器实际提供的形式)。"""
entry = struct.pack("<6sBL", b"600000", 1, 31)
header = struct.pack("<1hI1H3L", 0, 20260331, 1, 0, 8, 0)
return header + entry + struct.pack("<2f", 1.0, 2.0)
# --------------------------------------------------------------------------- #
# fixture
# --------------------------------------------------------------------------- #
@pytest.fixture
async def td():
with mock.patch("pytdxdata.api.get_standard_hosts", return_value=["s1"]), \
mock.patch("pytdxdata.api.get_mac_hosts", return_value=["m1"]), \
mock.patch("pytdxdata.api.get_ex_hosts", return_value=["e1"]), \
mock.patch("pytdxdata.pool.pool.TdxConnection", new=_MockConn), \
mock.patch("pytdxdata.pool.ex_pool.ExTdxConnection", new=_MockConn), \
mock.patch("pytdxdata.pool.pool.schedule_probe", return_value=None):
t = TdxData(cache_dir=None, pool_min=1, pool_max=2)
_use("start")
await t.start()
try:
yield t
finally:
_use("close")
await t.close()
# --------------------------------------------------------------------------- #
# 一、标的清单 / 报价 / 快照
# --------------------------------------------------------------------------- #
async def test_universe_and_quotes(td):
for name in ("get_universe", "get_quotes"):
_use(name)
uni = await td.get_universe()
assert isinstance(uni, list) and uni
cn = await td.get_universe("sz")
assert isinstance(cn, list)
ex = await td.get_universe("hk")
assert isinstance(ex, list)
q = await td.get_quotes(["sh600000", "sz000001"])
assert len(q) == 2 and all(x.symbol for x in q)
qf = await td.get_quotes(["sh600000"], fields=[0x00, 0x04])
assert qf[0].name == "测试"
qex = await td.get_quotes(["hk00700"])
assert len(qex) == 1
async def test_snapshot_auction_flow(td):
for name in ("get_snapshot", "get_auction", "get_capital_flow"):
_use(name)
snaps = await td.get_snapshot("sh600000")
assert len(snaps) == 1 and snaps[0].name == "浦发银行"
auc = await td.get_auction("sh600000")
assert len(auc) == 1
flow = await td.get_capital_flow("sh600000")
assert len(flow) == 1 and flow[0].main_buy == 1.0
# --------------------------------------------------------------------------- #
# 二、K线 / 指标
# --------------------------------------------------------------------------- #
async def test_bars(td):
_use("get_bars")
bars = await td.get_bars("sh600000", count=120)
assert len(bars) == 120
assert all(b.symbol == "sh600000" for b in bars)
# 分页(超过单页)
big = await td.get_bars("sh600000", count=2000, concurrency=2)
assert len(big) == 2000
# 复权走 MAC 通道
qfq = await td.get_bars("sh600000", count=200, adjust=None) # NONE -> 标准
assert len(qfq) == 200
from pytdxdata.models import Adjust
mac = await td.get_bars("sh600000", count=200, adjust=Adjust.QFQ)
assert len(mac) == 200
# 多标的并发
multi = await td.get_bars(["sh600000", "sz000001"], count=60)
assert len(multi) == 120
# 日期区间(二分定位路径)
dated = await td.get_bars(
"sh600000", start_date=datetime.datetime(2026, 8, 1),
end_date=datetime.datetime(2026, 8, 31))
assert isinstance(dated, list)
# 扩展市场 K线
exb = await td.get_bars("hk00700", count=60)
assert isinstance(exb, list)
async def test_indicators(td):
_use("get_indicators")
sets = await td.get_indicators("sh600000", ["macd", "kdj", "rsi"], count=30)
assert len(sets) == 1
assert sets[0].symbol == "sh600000"
assert sets[0].indicators # 指标分量名(DIF/DEA/K/D/J/RSI* 等)
# --------------------------------------------------------------------------- #
# 三、逐笔 / 分时
# --------------------------------------------------------------------------- #
async def test_ticks(td):
_use("get_ticks")
rows = await td.get_ticks("sh600000", date=20260811, count=10)
assert isinstance(rows, list) and rows and all(r.symbol for r in rows)
full = await td.get_ticks("sh600000", count=None)
assert isinstance(full, list)
hk = await td.get_ticks("hk00700", count=10)
assert isinstance(hk, list)
async def test_minutes(td):
_use("get_minutes")
rows = await td.get_minutes("sh600000")
assert isinstance(rows, list) and rows
hist = await td.get_minutes("sh600000", date=20260811)
assert isinstance(hist, list)
samp = await td.get_minutes("sh600000", sampling=True)
assert [b.price for b in samp] == [10.0, 10.1, 10.2]
exm = await td.get_minutes("hk00700")
assert isinstance(exm, list)
# --------------------------------------------------------------------------- #
# 四、公司信息 / 市场
# --------------------------------------------------------------------------- #
async def test_company_info(td):
for name in ("get_xdxr", "get_finance", "get_price_limits", "get_f10"):
_use(name)
x = await td.get_xdxr("sh600000")
assert isinstance(x, list) and x
fin = await td.get_finance("sh600000")
assert isinstance(fin, list) and fin and fin[0].symbol == "sh600000"
lo, hi = await td.get_price_limits("sh600000", name="浦发银行", pre_close=10.0)
assert (lo, hi) == (lo, hi) # 本地计算,不连网
cat = await td.get_f10("sh600000")
assert isinstance(cat, list)
body = await td.get_f10("sh600000", section="600000.txt")
assert isinstance(body, str)
async def test_market(td):
for name in ("get_market_stat", "get_unusual", "get_server_info",
"get_kline_offset"):
_use(name)
stat = await td.get_market_stat()
assert stat.up_count == 100 # price 10.0 * 10
un = await td.get_unusual("sh")
assert isinstance(un, list) and un
info = await td.get_server_info()
assert info.date == 20260916
off = await td.get_kline_offset()
assert off == (_TOTAL_BARS, 100)
# --------------------------------------------------------------------------- #
# 五、板块
# --------------------------------------------------------------------------- #
async def test_boards(td):
for name in ("get_boards", "get_board_members", "get_board_of",
"get_board_summary", "get_board_ranking",
"get_board_change_ranking"):
_use(name)
bl = await td.get_boards("all")
assert isinstance(bl, list) and bl
mem = await td.get_board_members("881001")
assert isinstance(mem, list) and mem
of = await td.get_board_of("sh600000")
assert isinstance(of, list) and of
summ = await td.get_board_summary("881001")
assert set(summ) == {"member_count", "amount", "main_net_amount",
"up_count", "down_count"}
rank = await td.get_board_ranking("industry")
assert isinstance(rank, list)
chg = await td.get_board_change_ranking("industry", days=5)
assert isinstance(chg, list)
# --------------------------------------------------------------------------- #
# 六、服务器文件
# --------------------------------------------------------------------------- #
async def test_files(td):
_use("get_file")
raw = await td.get_file("block_gn.dat")
assert raw == b"abcd"
async def test_parsed_files(td):
for name in ("get_block_parsed", "get_industry_map",
"get_financial_file_infos", "get_financial_records_parsed"):
_use(name)
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(return_value=_make_block_dat())):
blocks = await td.get_block_parsed("block_gn.dat")
assert blocks and blocks[0].category == 2
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(
return_value="0|000001|A01|||S01\n".encode("gbk"))):
ind = await td.get_industry_map()
assert ind["000001"].sw_industry == "S01"
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(
return_value=b"gpcw20260331.zip,abc,1024\n")):
infos = await td.get_financial_file_infos()
assert infos[0].filesize == 1024
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(return_value=_make_financial_zip())):
recs = await td.get_financial_records_parsed("tdxfin/gpcw20260331.zip")
assert len(recs) == 1 and recs[0].report_date == 20260331
# --------------------------------------------------------------------------- #
# 六之二、BUG 回归(真实联网实测发现,见 tests 说明)
# --------------------------------------------------------------------------- #
async def test_financial_dat_fallback(td):
"""BUG-2 回归:索引写 ``.zip``,服务器只给未压缩 ``.dat`` 时必须能回退取到。
服务器对**不存在的**文件名不报错,而是回 0~1 字节空壳;旧实现会把空壳直接
丢给 ``zipfile`` → ``BadZipFile``。现在要求按候选名回退到 ``tdxfin/*.dat``。
"""
calls: list[str] = []
async def fake_get_file(name: str) -> bytes:
calls.append(name)
if name == "tdxfin/gpcw20260331.zip":
return b"" # 服务器没有 .zip
if name == "gpcw20260331.zip":
return b"\x00" # 裸名被路由到 MAC 通道 → 1 字节空壳
if name == "tdxfin/gpcw20260331.dat":
return _make_financial_dat()
return b""
with mock.patch.object(td, "get_file", new=fake_get_file):
recs = await td.get_financial_records_parsed("gpcw20260331.zip")
assert "tdxfin/gpcw20260331.dat" in calls, "必须回退尝试未压缩 .dat"
assert len(recs) == 1 and recs[0].report_date == 20260331
assert recs[0].code == "600000"
async def test_financial_records_alias_not_silent(td):
"""BUG-2 回归:废弃别名取不到有效财报数据时应返回 ``b""``,而非 0~1 字节空壳。"""
import warnings
async def empty_get_file(name: str) -> bytes:
return b"\x00"
with mock.patch.object(td, "get_file", new=empty_get_file), warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
got = await td.get_financial_records("gpcw20260331.zip")
assert got == b""
async def test_sampling_derives_from_tick_chart(td):
"""BUG-1 回归:A股 ``sampling=True`` 必须由分时(0x122D)派生。
``MacChartSamplingCmd``(0x254D) 是 **EX 协议**命令,7709 主机对它一律不响应
(实测 3 台各 10s 超时,叠加连接池重试 ≈24s 才报错)。两条路径的 mock 数据刻意
不同,以便从结果区分实际走的是哪条命令。
"""
# A股:得到分时派生值(10.0/10.1/10.2),而非 0x254D 的 99.0/98.0
a_share = await td.get_minutes("sh600000", sampling=True)
a_share_hist = await td.get_minutes("sh600000", date=20260811, sampling=True)
assert [b.price for b in a_share] == [10.0, 10.1, 10.2]
assert [b.price for b in a_share_hist] == [10.0, 10.1, 10.2]
assert all(b.vol == 0.0 and b.avg_price == 0 for b in a_share), "采样点无量/均价"
assert [b.fields["i"] for b in a_share] == [0.0, 1.0, 2.0], "点位序号在 fields['i']"
# EX:仍走 0x254D
ex = await td.get_minutes("hk00700", sampling=True)
assert [b.price for b in ex] == [99.0, 98.0]
# --------------------------------------------------------------------------- #
# 七、废弃别名(33 个)
# --------------------------------------------------------------------------- #
async def test_aliases_kline(td):
for name in ("get_kline", "get_kline_since", "get_kline_batch",
"get_index_kline", "get_stock_kline_with_indicators"):
_use(name)
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
assert len(await td.get_kline(1, "600000", 4, count=60)) == 60
assert len(await td.get_kline_since(
1, "600000", 4, datetime.datetime(2026, 8, 1))) >= 0
batch = await td.get_kline_batch([(1, "600000"), (0, "000001")], 4, count=30)
assert isinstance(batch, dict) and batch
assert len(await td.get_index_kline(1, "000001", 4, count=30)) == 30
withind = await td.get_stock_kline_with_indicators(1, "600000", ["macd"])
assert "bars" in withind and "indicators" in withind
async def test_aliases_quotes_ticks(td):
for name in ("get_stock_quotes", "get_stock_quotes_list", "get_transactions",
"get_minute", "get_minute_batch", "get_chart_sampling"):
_use(name)
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
assert len(await td.get_stock_quotes([(1, "600000")])) == 1
assert isinstance(await td.get_stock_quotes_list(1, count=10), list)
assert isinstance(await td.get_transactions(1, "600000", count=10), list)
assert isinstance(await td.get_minute(0, "000001"), list)
mb = await td.get_minute_batch([(1, "600000")])
assert isinstance(mb, dict)
assert (await td.get_chart_sampling(1, "600000")) == [10.0, 10.1, 10.2]
async def test_aliases_universe(td):
for name in ("get_security_count", "get_security_list",
"get_security_list_all"):
_use(name)
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
assert await td.get_security_count(0) == 8
assert isinstance(await td.get_security_list(0, count=1), list)
assert isinstance(await td.get_security_list_all(0), list)
async def test_aliases_files(td):
for name in ("get_financial_file_list", "get_financial_records",
"get_company_info_category", "get_company_info_content",
"get_block_info", "get_report_file", "get_file_meta",
"download_file"):
_use(name)
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
assert await td.get_financial_file_list() == ["abcd"]
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(
return_value=_make_financial_dat())):
assert await td.get_financial_records(
"gpcw20260331.zip") == _make_financial_dat()
assert isinstance(await td.get_company_info_category(1, "600000"), list)
assert isinstance(await td.get_company_info_content(
1, "600000", "f.txt"), str)
assert await td.get_block_info("block_gn.dat") == b"abcd"
assert await td.get_report_file("tdxhy.cfg") == b"abcd"
assert (await td.get_file_meta("x.dat")).size == 4
assert await td.download_file("x.dat") == b"abcd"
async def test_aliases_boards(td):
for name in ("get_board_list", "get_belong_board", "get_symbol_info"):
_use(name)
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
assert isinstance(await td.get_board_list(0), list)
assert isinstance(await td.get_belong_board(1, "600000"), list)
snap = await td.get_symbol_info(1, "600000")
assert snap is not None and snap.name == "浦发银行"
async def test_aliases_goods(td):
for name in ("get_goods_list", "get_goods_count", "get_goods_quotes",
"get_goods_quotes_list", "get_goods_chart_sampling",
"get_goods_tick_chart", "get_goods_transaction",
"get_goods_transaction_all"):
_use(name)
import warnings
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
assert isinstance(await td.get_goods_list(31), list)
assert await td.get_goods_count(31) == 1 # 只有 1 条 market=31
assert isinstance(await td.get_goods_quotes([(31, "00700")]), list)
assert isinstance(await td.get_goods_quotes_list(31), list)
assert await td.get_goods_chart_sampling(31, "00700") == [99.0, 98.0]
assert isinstance(await td.get_goods_tick_chart(31, "00700"), list)
assert isinstance(await td.get_goods_transaction(31, "00700"), list)
assert isinstance(await td.get_goods_transaction_all(31, "00700"), list)
# --------------------------------------------------------------------------- #
# 八、覆盖完整性(必须放最后)
# --------------------------------------------------------------------------- #
def test_every_public_method_was_exercised():
expected = _public_methods()
missing = sorted(expected - EXERCISED)
assert not missing, f"以下公开方法未被回归测试覆盖: {missing}"
extra = sorted(EXERCISED - expected)
assert not extra, f"覆盖集合包含非公开方法: {extra}"
+72
View File
@@ -0,0 +1,72 @@
"""`scripts/check_docs.py` 的自测。
防漂移脚本本身也需要被验证——一个永远返回 0 的检查等于没有检查。
这里锁定三类行为:反引号抽取规则、词边界、以及「包内模块级符号不算已删除」。
"""
from __future__ import annotations
import importlib.util
import sys
from pathlib import Path
import pytest
ROOT = Path(__file__).resolve().parent.parent
SCRIPT = ROOT / "scripts" / "check_docs.py"
def _load_check_docs():
spec = importlib.util.spec_from_file_location("_check_docs", SCRIPT)
assert spec and spec.loader
module = importlib.util.module_from_spec(spec)
sys.modules["_check_docs"] = module
spec.loader.exec_module(module)
return module
cd = _load_check_docs()
@pytest.mark.parametrize(
("text", "expected"),
[
# 裸方法名
("`get_kline`", {"get_kline"}),
# 带签名的写法(README / API_REFERENCE 里大量出现)
("`get_kline(market, code, period)`", {"get_kline"}),
("`download_file(filename, filesize)`", {"download_file"}),
# 同一行多个
("`get_quotes(stocks)` 和 `get_minute`", {"get_quotes", "get_minute"}),
# 带对象前缀的不是方法引用
("`td.get_kline(1, '600000')`", set()),
# 非 get_/download_ 前缀不匹配
("`list[SecurityBar]`", set()),
# 没有反引号就不是引用
("get_kline 没有反引号", set()),
],
)
def test_collect_doc_references(text: str, expected: set[str]) -> None:
assert cd.collect_doc_references(text) == expected
def test_mentioned_in_respects_word_boundary() -> None:
"""`get_kline` 不应误匹配 `get_kline_batch`。"""
assert not cd.mentioned_in("用 `get_kline_batch` 批量拉取", "get_kline")
assert cd.mentioned_in("用 `get_kline(m, c, p)` 拉取", "get_kline")
def test_package_level_functions_are_known_symbols() -> None:
"""config.py 的模块级函数必须被纳入白名单,否则会被误报成「已删除」。"""
known = cd.collect_api_methods(cd.API_FILE)[0] | cd.collect_package_symbols()
for name in (
"get_standard_hosts",
"get_mac_hosts",
"get_ex_hosts",
"get_ex_handshakes",
):
assert name in known
def test_repository_docs_are_in_sync() -> None:
"""仓库当前状态必须无漂移(等价于 CI 里那一步)。"""
assert cd.main() == 0
+147 -9
View File
@@ -6,14 +6,19 @@ from __future__ import annotations
import io
import struct
import unittest.mock as mock
import zipfile
from unittest import mock
import pytest
from pytdxdata.api import TdxData
from pytdxdata.codec.block import infer_block_category, parse_block_dat
from pytdxdata.codec.financial import parse_financial_dat, parse_financial_file_list
from pytdxdata.codec.financial import (
extract_gpcw_dat,
looks_like_gpcw_dat,
parse_financial_dat,
parse_financial_file_list,
)
from pytdxdata.codec.industry import parse_tdxhy_cfg
from pytdxdata.models import FinancialFileInfo, FinancialRecord, IndustryInfo, TdxBlock
@@ -252,7 +257,7 @@ def _new_tdxdata() -> TdxData:
async def test_api_get_block_parsed():
td = _new_tdxdata()
raw = _make_block_dat([("银行", ["000001"], 1, 1)])
with mock.patch.object(td, "get_block_info", new=mock.AsyncMock(return_value=raw)):
with mock.patch.object(td, "get_file", new=mock.AsyncMock(return_value=raw)):
blocks = await td.get_block_parsed("block_gn.dat")
assert len(blocks) == 1
assert blocks[0].category == 2 # gn -> 概念
@@ -263,7 +268,7 @@ async def test_api_get_industry_map():
td = _new_tdxdata()
raw = "0|000001|A01|||S01\n".encode("gbk")
patched = mock.AsyncMock(return_value=raw)
with mock.patch.object(td, "get_report_file", new=patched):
with mock.patch.object(td, "get_file", new=patched):
result = await td.get_industry_map()
patched.assert_awaited_once_with("tdxhy.cfg")
assert result["000001"].sw_industry == "S01"
@@ -274,7 +279,7 @@ async def test_api_get_financial_file_infos():
td = _new_tdxdata()
raw = b"gpcw20260331.zip,abc,1024\n"
patched = mock.AsyncMock(return_value=raw)
with mock.patch.object(td, "get_report_file", new=patched):
with mock.patch.object(td, "get_file", new=patched):
infos = await td.get_financial_file_infos()
patched.assert_awaited_once_with("tdxfin/gpcw.txt")
assert infos[0].filesize == 1024
@@ -284,7 +289,7 @@ async def test_api_get_financial_file_infos():
async def test_api_get_financial_records_parsed():
td = _new_tdxdata()
zip_bytes = _make_financial_zip(_valid_two_record_dat())
with mock.patch.object(td, "get_report_file",
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(return_value=zip_bytes)):
recs = await td.get_financial_records_parsed("tdxfin/gpcw20260331.zip")
assert len(recs) == 2
@@ -294,7 +299,7 @@ async def test_api_get_financial_records_parsed():
@pytest.mark.asyncio
async def test_api_get_financial_records_parsed_empty_zip_data():
td = _new_tdxdata()
with mock.patch.object(td, "get_report_file",
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(return_value=b"")):
assert await td.get_financial_records_parsed("tdxfin/gpcw20260331.zip") == []
@@ -303,7 +308,7 @@ async def test_api_get_financial_records_parsed_empty_zip_data():
async def test_api_get_financial_records_parsed_no_dat_member():
td = _new_tdxdata()
zip_bytes = _make_financial_zip(b"whatever", inner_name="readme.txt")
with mock.patch.object(td, "get_report_file",
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(return_value=zip_bytes)):
assert await td.get_financial_records_parsed("nodate.zip") == []
@@ -313,7 +318,140 @@ async def test_api_get_financial_records_parsed_no_date_in_name():
"""文件名无 8 位日期 -> 回退用 .dat 头部报告期。"""
td = _new_tdxdata()
zip_bytes = _make_financial_zip(_valid_two_record_dat())
with mock.patch.object(td, "get_report_file",
with mock.patch.object(td, "get_file",
new=mock.AsyncMock(return_value=zip_bytes)):
recs = await td.get_financial_records_parsed("gpcw.zip")
assert recs[0].report_date == 20260331
# --------------------------------------------------------------------------- #
# looks_like_gpcw_dat / extract_gpcw_dat(BUG-2 修复的判据层)
# --------------------------------------------------------------------------- #
def test_looks_like_gpcw_dat_accepts_real_dat():
assert looks_like_gpcw_dat(_valid_two_record_dat()) is True
def test_looks_like_gpcw_dat_rejects_short_shell():
"""服务器对不存在的文件名回的空壳(0~1 字节)必须判否。"""
assert looks_like_gpcw_dat(b"") is False
assert looks_like_gpcw_dat(b"\x00") is False
assert looks_like_gpcw_dat(b"abcd") is False
def test_looks_like_gpcw_dat_rejects_zero_header():
"""长度够但 header 全零(max_count=0 / report_size=0)也要判否。"""
assert looks_like_gpcw_dat(b"\x00" * 64) is False
def test_looks_like_gpcw_dat_rejects_report_size_not_multiple_of_4():
data = _make_dat_raw([(b"600000", 1, 31)], struct.pack("<2f", 1.0, 2.0),
report_size=6)
assert looks_like_gpcw_dat(data) is False
def test_looks_like_gpcw_dat_rejects_truncated_index():
"""header 声称的条目数超出实际长度 -> 判否。"""
data = _make_dat_raw([(b"600000", 1, 31)], struct.pack("<2f", 1.0, 2.0),
max_count=100)
assert looks_like_gpcw_dat(data) is False
def test_extract_gpcw_dat_from_uncompressed():
dat = _valid_two_record_dat()
assert extract_gpcw_dat(dat) == dat
def test_extract_gpcw_dat_from_zip():
dat = _valid_two_record_dat()
assert extract_gpcw_dat(_make_financial_zip(dat)) == dat
def test_extract_gpcw_dat_empty_and_garbage():
assert extract_gpcw_dat(b"") == b""
assert extract_gpcw_dat(b"\x00") == b""
assert extract_gpcw_dat(b"not a financial file") == b""
def test_extract_gpcw_dat_zip_without_dat_member():
assert extract_gpcw_dat(_make_financial_zip(b"x", inner_name="readme.txt")) == b""
def test_extract_gpcw_dat_zip_with_invalid_inner_dat():
"""zip 里虽有 .dat,但内容不是有效财报数据 -> 空。"""
assert extract_gpcw_dat(_make_financial_zip(b"\x00" * 4)) == b""
def test_extract_gpcw_dat_broken_zip():
"""以 PK 开头但不是合法 zip -> 空,不抛异常。"""
assert extract_gpcw_dat(b"PK\x03\x04broken-not-a-zip") == b""
# --------------------------------------------------------------------------- #
# TdxData._fetch_financial_dat 候选回退(BUG-2 回归)
# --------------------------------------------------------------------------- #
@pytest.mark.asyncio
async def test_fetch_financial_dat_falls_back_to_uncompressed_dat():
"""索引名 ``gpcw*.zip`` 取不到时,必须回退到服务器实际的 ``tdxfin/*.dat``。"""
td = _new_tdxdata()
dat = _valid_two_record_dat()
seen: list[str] = []
async def fake(name: str) -> bytes:
seen.append(name)
if name == "tdxfin/gpcw20260331.dat":
return dat
if name == "gpcw20260331.zip":
return b"\x00" # 裸名 -> MAC 路由 -> 1 字节空壳
return b"" # 带前缀的 .zip 不存在
with mock.patch.object(td, "get_file", new=fake):
got = await td._fetch_financial_dat("gpcw20260331.zip")
assert got == dat
assert seen == ["tdxfin/gpcw20260331.zip", "tdxfin/gpcw20260331.dat"]
@pytest.mark.asyncio
async def test_fetch_financial_dat_prefers_declared_zip_when_present():
"""服务器若恢复提供 .zip,应优先用索引声明的那个名字。"""
td = _new_tdxdata()
dat = _valid_two_record_dat()
seen: list[str] = []
async def fake(name: str) -> bytes:
seen.append(name)
return _make_financial_zip(dat)
with mock.patch.object(td, "get_file", new=fake):
got = await td._fetch_financial_dat("tdxfin/gpcw20260331.zip")
assert got == dat
assert seen == ["tdxfin/gpcw20260331.zip"]
@pytest.mark.asyncio
async def test_fetch_financial_dat_skips_raising_candidate():
"""某个候选取回时抛异常,不应中断,继续试后面的候选。"""
td = _new_tdxdata()
dat = _valid_two_record_dat()
async def fake(name: str) -> bytes:
if name.endswith(".zip"):
raise ConnectionError("模拟网络错误")
return dat
with mock.patch.object(td, "get_file", new=fake):
assert await td._fetch_financial_dat("gpcw20260331.zip") == dat
@pytest.mark.asyncio
async def test_fetch_financial_dat_all_candidates_fail_returns_empty():
td = _new_tdxdata()
async def fake(name: str) -> bytes:
return b""
with mock.patch.object(td, "get_file", new=fake):
assert await td._fetch_financial_dat("gpcw20260331.zip") == b""
+365
View File
@@ -0,0 +1,365 @@
"""当日测速缓存单元测试(注入假探针与假日期,不连真实网络)
覆盖点:
- 当日首次启动测一次;当天已有缓存则**不刷新**(探针一次都不发起)
- 跨日 / 缓存损坏 / 版本不符 → 重新测速
- 结果按实测延迟升序被 config 采用
- **绝不改写包内 servers.json**,缓存落在用户级缓存目录
- 全部不可达 → 不写缓存(下次启动重试)
- 并发调用只真正测一次(单飞)
- 非法主机名(测试 mock 混入的 "s1" 等)被挡在测速之外
- 连接池 start() 不阻塞、close() 会取消后台测速
"""
from __future__ import annotations
import asyncio
import json
import time
from datetime import date, timedelta
from pathlib import Path
import pytest
from pytdxdata import config
from pytdxdata.pool.probe_cache import ProbeCache
TODAY = date.today().isoformat()
YESTERDAY = (date.today() - timedelta(days=1)).isoformat()
PROTOS = ("standard", "mac", "ex")
@pytest.fixture(autouse=True)
def isolated_cache(tmp_path, monkeypatch):
"""把用户级缓存目录指到临时目录,并复位所有相关环境变量。"""
monkeypatch.setenv("PYPYTDX_DATA_CACHE_DIR", str(tmp_path))
monkeypatch.delenv("PYPYTDX_DATA_DISABLE_PROBE", raising=False)
for var in ("PYPYTDX_DATA_STANDARD_HOSTS", "PYPYTDX_DATA_MAC_HOSTS",
"PYPYTDX_DATA_EX_HOSTS"):
monkeypatch.delenv(var, raising=False)
return tmp_path
def fake_probers(latencies: dict[str, dict[str, float | None]], calls: list):
"""构造假探针;latencies = {协议: {主机: 延迟或 None}}。"""
def _make(protocol: str):
async def _probe(host: str, timeout: float) -> float | None:
calls.append((protocol, host))
return latencies.get(protocol, {}).get(host)
return _probe
return {p: _make(p) for p in PROTOS}
def patch_candidates(monkeypatch, mapping: dict[str, list[str]]) -> None:
"""把"全量候选"换成受控清单,避免依赖真实服务器清单。"""
monkeypatch.setattr("pytdxdata.pool.probe_cache.all_probe_candidates",
lambda: mapping)
def write_cache(path: Path, day: str, results: dict, version: int = 1) -> None:
path.write_text(json.dumps({"version": version, "date": day, "results": results}),
encoding="utf-8")
# ---------- 是否该测速 ----------
def test_needs_probe_when_no_cache(tmp_path):
pc = ProbeCache(tmp_path / "c.json", today_fn=lambda: TODAY)
assert pc.needs_probe_today() is True
assert pc.read_cache() is None
def test_needs_probe_false_for_today_cache(tmp_path):
cache = tmp_path / "c.json"
write_cache(cache, TODAY, {"1.1.1.1": {"standard": 0.05}})
pc = ProbeCache(cache, today_fn=lambda: TODAY)
assert pc.needs_probe_today() is False
def test_stale_cache_needs_probe(tmp_path):
cache = tmp_path / "c.json"
write_cache(cache, YESTERDAY, {"1.1.1.1": {"standard": 0.05}})
pc = ProbeCache(cache, today_fn=lambda: TODAY)
assert pc.needs_probe_today() is True
def test_version_mismatch_needs_probe(tmp_path):
cache = tmp_path / "c.json"
write_cache(cache, TODAY, {"1.1.1.1": {"standard": 0.05}}, version=999)
pc = ProbeCache(cache, today_fn=lambda: TODAY)
assert pc.needs_probe_today() is True
@pytest.mark.parametrize("content", ["{not json", "[]", '{"version":1}', ""])
def test_broken_cache_is_ignored_not_crash(tmp_path, content):
cache = tmp_path / "c.json"
cache.write_text(content, encoding="utf-8")
pc = ProbeCache(cache, today_fn=lambda: TODAY)
assert pc.read_cache() is None
assert pc.needs_probe_today() is True
# ---------- 核心行为:当天已有缓存就不刷新 ----------
async def test_today_cache_is_not_refreshed(tmp_path, monkeypatch):
cache = tmp_path / "c.json"
write_cache(cache, TODAY, {"1.1.1.1": {"standard": 0.05}})
before = cache.read_text(encoding="utf-8")
calls: list = []
patch_candidates(monkeypatch, {"standard": ["1.1.1.1"], "mac": [], "ex": []})
pc = ProbeCache(cache, probers=fake_probers({}, calls), today_fn=lambda: TODAY)
await pc.ensure_probe()
assert calls == [] # 未发起任何测速
assert cache.read_text(encoding="utf-8") == before # 缓存内容原封不动
async def test_stale_cache_is_refreshed(tmp_path, monkeypatch):
cache = tmp_path / "c.json"
write_cache(cache, YESTERDAY, {"9.9.9.9": {"standard": 9.0}})
calls: list = []
patch_candidates(monkeypatch, {"standard": ["1.1.1.1"], "mac": [], "ex": []})
pc = ProbeCache(cache,
probers=fake_probers({"standard": {"1.1.1.1": 0.02}}, calls),
today_fn=lambda: TODAY)
await pc.ensure_probe()
assert calls == [("standard", "1.1.1.1")]
data = json.loads(cache.read_text(encoding="utf-8"))
assert data["date"] == TODAY and data["version"] == config.PROBE_CACHE_VERSION
assert data["results"] == {"1.1.1.1": {"standard": 0.02}}
assert data["hosts"]["standard"] == ["1.1.1.1"]
assert "9.9.9.9" not in data["results"] # 旧结果被整体替换,不残留
# ---------- 缓存写入 ----------
async def test_write_is_atomic_and_leaves_no_tmp(tmp_path, monkeypatch):
cache = tmp_path / "sub" / "c.json" # 目录不存在也要能建
patch_candidates(monkeypatch, {"standard": ["1.1.1.1"], "mac": [], "ex": []})
pc = ProbeCache(cache,
probers=fake_probers({"standard": {"1.1.1.1": 0.03}}, []),
today_fn=lambda: TODAY)
await pc.ensure_probe()
assert cache.exists()
assert list(cache.parent.glob("*.tmp*")) == []
assert json.loads(cache.read_text(encoding="utf-8"))["probed_at"]
async def test_all_unreachable_writes_nothing(tmp_path, monkeypatch):
cache = tmp_path / "c.json"
patch_candidates(monkeypatch, {"standard": ["1.1.1.1"], "mac": [], "ex": []})
pc = ProbeCache(cache, probers=fake_probers({}, []), today_fn=lambda: TODAY)
await pc.ensure_probe()
assert not cache.exists() # 不把"全挂"缓存一整天
assert pc.needs_probe_today() is True
async def test_never_touches_package_servers_json(tmp_path, monkeypatch):
"""最关键的一条:测速**绝不能**改写随包分发的 servers.json。"""
servers_json = config._SERVERS_FILE
before_bytes = servers_json.read_bytes()
before_mtime = servers_json.stat().st_mtime_ns
patch_candidates(monkeypatch, {"standard": ["1.1.1.1"], "mac": [], "ex": []})
pc = ProbeCache(probers=fake_probers({"standard": {"1.1.1.1": 0.04}}, []),
today_fn=lambda: TODAY)
await pc.ensure_probe()
assert servers_json.read_bytes() == before_bytes
assert servers_json.stat().st_mtime_ns == before_mtime
assert pc.cache_file() == tmp_path / "hosts-today.json" # 落在用户缓存目录
assert Path(config.probe_cache_file()).parent == tmp_path
async def test_results_are_recorded_per_protocol(tmp_path, monkeypatch):
cache = tmp_path / "c.json"
patch_candidates(monkeypatch, {
"standard": ["1.1.1.1", "2.2.2.2"],
"mac": ["1.1.1.1", "2.2.2.2"],
"ex": ["3.3.3.3"],
})
lats = {"standard": {"1.1.1.1": 0.30, "2.2.2.2": 0.10},
"mac": {"1.1.1.1": 0.20}, # 2.2.2.2 的 mac 故意不给 → 应记为 None
"ex": {"3.3.3.3": 0.05}}
pc = ProbeCache(cache, probers=fake_probers(lats, []), today_fn=lambda: TODAY)
await pc.ensure_probe()
data = json.loads(cache.read_text(encoding="utf-8"))
assert data["hosts"]["standard"] == ["2.2.2.2", "1.1.1.1"] # 按延迟升序
assert data["hosts"]["mac"] == ["1.1.1.1"] # 不可达的 2.2.2.2 被排除
assert data["hosts"]["ex"] == ["3.3.3.3"]
# 2.2.2.2 的 mac 探针返回 None,也要如实记录(便于事后诊断)
assert data["results"]["2.2.2.2"]["mac"] is None
# ---------- 单飞 / 开关 / 脏数据 ----------
async def test_concurrent_ensure_probe_runs_once(tmp_path, monkeypatch):
patch_candidates(monkeypatch, {"standard": ["1.1.1.1", "2.2.2.2"], "mac": [], "ex": []})
calls: list = []
pc = ProbeCache(tmp_path / "c.json",
probers=fake_probers({"standard": {"1.1.1.1": 0.01,
"2.2.2.2": 0.02}}, calls),
today_fn=lambda: TODAY)
await asyncio.gather(pc.ensure_probe(), pc.ensure_probe(), pc.ensure_probe())
assert sorted(calls) == [("standard", "1.1.1.1"), ("standard", "2.2.2.2")]
async def test_disabled_env_skips_everything(tmp_path, monkeypatch):
monkeypatch.setenv("PYPYTDX_DATA_DISABLE_PROBE", "1")
calls: list = []
patch_candidates(monkeypatch, {"standard": ["1.1.1.1"], "mac": [], "ex": []})
pc = ProbeCache(tmp_path / "c.json",
probers=fake_probers({"standard": {"1.1.1.1": 0.01}}, calls),
today_fn=lambda: TODAY)
assert pc.needs_probe_today() is False
await pc.ensure_probe()
assert calls == []
assert not (tmp_path / "c.json").exists()
async def test_illegal_hosts_are_filtered_out(tmp_path, monkeypatch):
"""测试 mock 常传入 "s1"/"m1" 这类伪主机名,必须挡在缓存之外。"""
patch_candidates(monkeypatch, {"standard": [], "mac": [], "ex": []})
calls: list = []
pc = ProbeCache(tmp_path / "c.json",
probers=fake_probers({"standard": {"1.1.1.1": 0.01}}, calls),
today_fn=lambda: TODAY)
await pc.ensure_probe(["s1", "m1", "1.1.1.1", ""])
assert calls == [("standard", "1.1.1.1")]
data = json.loads((tmp_path / "c.json").read_text(encoding="utf-8"))
assert "s1" not in data["results"] and "m1" not in data["results"]
async def test_reset_allows_recheck(tmp_path, monkeypatch):
patch_candidates(monkeypatch, {"standard": ["1.1.1.1"], "mac": [], "ex": []})
calls: list = []
pc = ProbeCache(tmp_path / "c.json",
probers=fake_probers({"standard": {"1.1.1.1": 0.01}}, calls),
today_fn=lambda: TODAY)
await pc.ensure_probe()
await pc.ensure_probe()
assert len(calls) == 1 # 第二次被单飞挡掉
pc.reset()
await pc.ensure_probe()
assert len(calls) == 1 # 重置后当天已有缓存,仍不重测
# ---------- config 侧:采用顺序与兜底 ----------
def test_config_getters_prefer_cache_and_order_by_latency(tmp_path, monkeypatch):
monkeypatch.setenv("PYPYTDX_DATA_CACHE_DIR", str(tmp_path))
(tmp_path / "hosts-today.json").write_text(json.dumps({
"version": config.PROBE_CACHE_VERSION, "date": TODAY,
"results": {
"3.3.3.3": {"standard": 0.9},
"1.1.1.1": {"standard": 0.05},
"2.2.2.2": {"standard": 0.4, "mac": 0.1},
"9.9.9.9": {"ex": 0.2},
},
}), encoding="utf-8")
assert config.get_standard_hosts() == ["1.1.1.1", "2.2.2.2", "3.3.3.3"]
assert config.get_mac_hosts() == ["2.2.2.2"]
assert config.get_ex_hosts() == ["9.9.9.9"]
def test_config_getters_fall_back_without_cache(tmp_path, monkeypatch):
monkeypatch.setenv("PYPYTDX_DATA_CACHE_DIR", str(tmp_path))
assert config.get_standard_hosts() == config._load_ok_hosts("standard", fast_only=True)
assert config.get_mac_hosts() == config._load_ok_hosts("mac", fast_only=True)
assert config.get_ex_hosts() == config._load_ok_hosts("ex")
def test_env_override_beats_cache(tmp_path, monkeypatch):
monkeypatch.setenv("PYPYTDX_DATA_CACHE_DIR", str(tmp_path))
(tmp_path / "hosts-today.json").write_text(json.dumps({
"version": config.PROBE_CACHE_VERSION, "date": TODAY,
"results": {"1.1.1.1": {"standard": 0.05}},
}), encoding="utf-8")
monkeypatch.setenv("PYPYTDX_DATA_STANDARD_HOSTS", "8.8.8.8")
assert config.get_standard_hosts() == ["8.8.8.8"]
def test_all_probe_candidates_covers_full_set_not_filtered():
cand = config.all_probe_candidates()
assert set(config.STANDARD_HOSTS) <= set(cand["standard"])
assert set(config.MAC_HOSTS) <= set(cand["mac"])
assert set(config.EX_HOSTS) <= set(cand["ex"])
assert "117.34.114.17" in cand["standard"] # 未申报 MAC 的节点也要被测到
assert "s1" not in cand["standard"] # 包内清单里的脏数据被挡
@pytest.mark.parametrize(("host", "expected"), [
("1.2.3.4", True),
("117.34.114.17", True),
("a.b", True),
("good-host.com", True),
("s1", False),
("m1", False),
("", False),
(" ", False),
("-bad.com", False),
("bad-.com", False),
("has space.com", False),
(123, False),
(None, False),
])
def test_is_valid_host(host, expected):
assert config.is_valid_host(host) is expected
# ---------- 连接池集成 ----------
async def test_pool_start_does_not_block_and_close_cancels_probe(monkeypatch):
from pytdxdata.pool import pool as pool_mod
cancel_seen = asyncio.Event()
created: list[asyncio.Task] = []
async def _hang(hosts=None):
try:
await asyncio.sleep(30) # 模拟耗时测速
except asyncio.CancelledError:
cancel_seen.set()
raise
def _fake_schedule(hosts=None):
task = asyncio.create_task(_hang())
created.append(task)
return task
monkeypatch.setattr(pool_mod, "schedule_probe", _fake_schedule)
p = pool_mod.DynamicPool([], min_size=1, max_size=1)
t0 = time.monotonic()
await p.start()
assert time.monotonic() - t0 < 1.0 # start() 不等测速
assert p._probe_task is created[0]
await asyncio.sleep(0) # 让测速任务真正跑起来再关闭
await p.close()
assert p._probe_task is None
assert created[0].cancelled()
assert cancel_seen.is_set()
async def test_pool_auto_probe_false_schedules_nothing(monkeypatch):
from pytdxdata.pool import pool as pool_mod
def _boom(hosts=None): # pragma: no cover - 不应被调用
raise AssertionError("auto_probe=False 时不应调度测速")
monkeypatch.setattr(pool_mod, "schedule_probe", _boom)
p = pool_mod.DynamicPool([], min_size=1, max_size=1, auto_probe=False)
await p.start()
assert p._probe_task is None
await p.close()
Generated
+638 -1
View File
@@ -2,6 +2,193 @@ version = 1
revision = 3
requires-python = ">=3.11"
[[package]]
name = "babel"
version = "2.18.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" },
]
[[package]]
name = "backrefs"
version = "8.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/ec/56/4744bcd0c82184e80c52b0ac4076c261a8ffa1f1b343ff2f6e89ce0e1cef/backrefs-8.0.tar.gz", hash = "sha256:b556cd7d36c3a3a2f256b89590b176b8eddfb73bcfaee3a3ddd84ea66d21ce50", size = 7013081, upload-time = "2026-07-26T19:54:24.638Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/e3/fd/9bf53b6a6f6f519ffaac765df2f2a25e5c2fc6d32cfd2b2747099e72c911/backrefs-8.0-py310-none-any.whl", hash = "sha256:4a627b817fd2dce43b79ab48da63613340509381cd8ce0897078a0bce79a2ab8", size = 380377, upload-time = "2026-07-26T19:54:17.457Z" },
{ url = "https://files.pythonhosted.org/packages/e1/29/4bd7ae72a2634da00379c2b3bcc5439e7c94620235c6afea8af15229a973/backrefs-8.0-py311-none-any.whl", hash = "sha256:f0c35cf0102ba6b6070c12a492be3c1c1d3f5839529784b9a9565d6d04569a01", size = 392169, upload-time = "2026-07-26T19:54:18.782Z" },
{ url = "https://files.pythonhosted.org/packages/29/13/232505664e8e2a0c7a2eb0c505cfade9d715538f89a5d62bc4c272968f62/backrefs-8.0-py312-none-any.whl", hash = "sha256:87f0fae8c5f207fe9f4b2887efc71d42f4900ac78faa1af08d675ef303692dc5", size = 398084, upload-time = "2026-07-26T19:54:19.954Z" },
{ url = "https://files.pythonhosted.org/packages/8a/69/47a3dc20abc4fa5486655fde681bd55e63211b46c886d8c02223d6468431/backrefs-8.0-py313-none-any.whl", hash = "sha256:601ce68ca12385dbda06ce264406b4c4210cf5b79fd0fd627592365c92f29a88", size = 400040, upload-time = "2026-07-26T19:54:21.194Z" },
{ url = "https://files.pythonhosted.org/packages/1c/cf/e5f9b68a5b0e939a2fb933a66c20180d0c9241bf8927f7a47fa48c1675e9/backrefs-8.0-py314-none-any.whl", hash = "sha256:9ec96efa080938be92323e8e730e57718c9c88eb15ad70bbef4e1766df591408", size = 411903, upload-time = "2026-07-26T19:54:23.221Z" },
]
[[package]]
name = "certifi"
version = "2026.7.22"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
]
[[package]]
name = "charset-normalizer"
version = "3.5.1"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/6a/b6/034f6802e9c3f6418966cfabb7db8c9252cc2429c5098f41cc43af804149/charset_normalizer-3.5.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eda059b6bc8bc0812d626fd91a7ce01bf583df0a61296eff390fd94141a34e30", size = 363585, upload-time = "2026-08-15T08:16:46.646Z" },
{ url = "https://files.pythonhosted.org/packages/d5/fa/6a7e2a7c4b5451912b8c417732df79574354443592a88d616de03da66ae5/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa2bb0b37202dca27175591f761108b5d34096ade1191ffe4808bdf6b1571488", size = 251189, upload-time = "2026-08-15T08:16:48.287Z" },
{ url = "https://files.pythonhosted.org/packages/a4/c8/ab42b07cfd82e919f427fcfaa7c41abae8242833ad1aad66d42bae40b669/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b2b1b3fa5670c127b246df1d0c059defd41f689a868a3b9d79df9b1cac42d22", size = 239724, upload-time = "2026-08-15T08:16:49.67Z" },
{ url = "https://files.pythonhosted.org/packages/e7/80/b9348b5d3041209f98b4cdad7655766369233f1d533f4f4f7558e9717bec/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6e5e4d73d588ca5ed09df1b7dcd1b203d1df3c542e3f50d126c947d432b10731", size = 280078, upload-time = "2026-08-15T08:16:51.228Z" },
{ url = "https://files.pythonhosted.org/packages/82/38/083a24028304bc85bb9e376fed801178423dcbb67495f73b6ea0624e1894/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b54e7e13267d49ffbfe68e25b3cbd774dab38fa37238f71265e91b36146eb21c", size = 276650, upload-time = "2026-08-15T08:16:52.625Z" },
{ url = "https://files.pythonhosted.org/packages/0d/35/731ac04aa0a097fc1c97f0994c375bdb230c6c96619db794208fe664e9ce/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7b742bf31c88566b4bb6335a7f393bb322e580b6bb98df7bd0c25e6e3519ce8", size = 262325, upload-time = "2026-08-15T08:16:54.085Z" },
{ url = "https://files.pythonhosted.org/packages/f5/28/c2028e7021fb89c6e56868ed0e387b8e9aa811abdd2ab3208d6578d2c930/charset_normalizer-3.5.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6ba32c4d2abf1d2fe7cf27d280f4cca5664233b0f885549c7761719eb977f486", size = 261140, upload-time = "2026-08-15T08:16:55.604Z" },
{ url = "https://files.pythonhosted.org/packages/28/f0/0c0ceec6d98b7daa62e361e418135d59685811d79ba11529aad5cdf15e84/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0722590aabf9dc6a6c0343d523c05458fa2b5047dbe6302fd526bb570600753f", size = 252791, upload-time = "2026-08-15T08:16:57.103Z" },
{ url = "https://files.pythonhosted.org/packages/f0/3e/48f4cd187b1c33189d86039e9cbe4f92c05454175504b44ff81806d4d1bf/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:aa1099b956fb795e686d073568f6dc002a0bb89765ea6d5b055dd7d9bf1b116c", size = 240730, upload-time = "2026-08-15T08:16:58.418Z" },
{ url = "https://files.pythonhosted.org/packages/42/85/f9e22af69af67c54cce42be9455d9c81294f918b4ccc454db01f66efcac2/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd6c173f04743d483881bffa1478d5a4624475b8cd1d2194956a75548e191c18", size = 280791, upload-time = "2026-08-15T08:16:59.918Z" },
{ url = "https://files.pythonhosted.org/packages/fd/4c/9044135f42127630b6fa742feb51256353f6ab87a78f2fdd1de3de955a7f/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f298e218441525d3794428b4c8b8fb8662c6d3ea79925d4807ee6b9a96a3bca5", size = 259598, upload-time = "2026-08-15T08:17:01.421Z" },
{ url = "https://files.pythonhosted.org/packages/ba/ed/1dd7cfebb4e75812934c49ca3b79757d11948053f7937ab7070c151f3c55/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:6e2912d4babbc65196ac13c2f53468dc57fb8b9c25ef913e8c59ddf7c6dc0e1b", size = 278217, upload-time = "2026-08-15T08:17:02.782Z" },
{ url = "https://files.pythonhosted.org/packages/bf/eb/239c84503cc9e3ba6eb34686a24bc66e84f3924efdd7e38e751a19f6bc10/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3d27167433c0d5f18dc850f07d0b3816221984fecdc405d6c157a6f0b8f8e9e6", size = 263417, upload-time = "2026-08-15T08:17:04.216Z" },
{ url = "https://files.pythonhosted.org/packages/37/ab/4e4510e1e288478e2c8333131d1c1382382ba8cd2165053c79e39d1da961/charset_normalizer-3.5.1-cp311-cp311-win32.whl", hash = "sha256:ac00177c4831ffa650f8609e4bdddd5fe09c03b1c0c47acece7e6ea20421598b", size = 181774, upload-time = "2026-08-15T08:17:05.58Z" },
{ url = "https://files.pythonhosted.org/packages/e3/57/32f0ccea59e8612057c61d6fd22ef2cb63cca93c9fe594094919696ac170/charset_normalizer-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9b1e28d0e8dbfa858abdba91d6b547beaf2df1a59bec6da6faae7b96a4991a9", size = 206653, upload-time = "2026-08-15T08:17:07.075Z" },
{ url = "https://files.pythonhosted.org/packages/17/d4/b65c433fc521e58b5f54293982a5e51c05cb5f2dd3f1c7a6acb65b75324e/charset_normalizer-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:ae31a1a1db2ee6cc2942fccaf695c934bc7f3db9f2133a3fef1f367cf1a4ab10", size = 185630, upload-time = "2026-08-15T08:17:08.502Z" },
{ url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" },
{ url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" },
{ url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" },
{ url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" },
{ url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" },
{ url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" },
{ url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" },
{ url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" },
{ url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" },
{ url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" },
{ url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" },
{ url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" },
{ url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" },
{ url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" },
{ url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" },
{ url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" },
{ url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" },
{ url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" },
{ url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" },
{ url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" },
{ url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" },
{ url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" },
{ url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" },
{ url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" },
{ url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" },
{ url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" },
{ url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" },
{ url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" },
{ url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" },
{ url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" },
{ url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" },
{ url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" },
{ url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" },
{ url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" },
{ url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" },
{ url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" },
{ url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" },
{ url = "https://files.pythonhosted.org/packages/29/cd/2b812ce5e888f1ce69a5350281e58aab07ae64a958ecae8912f30865718e/charset_normalizer-3.5.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:774d157f112367ff4abd29019f38f023c24e00e56edc7829c20e358a5a913ad8", size = 212318, upload-time = "2026-08-15T08:18:04.403Z" },
{ url = "https://files.pythonhosted.org/packages/9e/4a/a6ee107430768a5334e6d63f31f148a04a1a491ef161a1ac9415a73f2fa8/charset_normalizer-3.5.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:26422d45fd13551cf564c58932f7d72b4f58b93b0fcf18c35ba6be12b46bb102", size = 224897, upload-time = "2026-08-15T08:18:05.997Z" },
{ url = "https://files.pythonhosted.org/packages/c3/d9/35ae3f64f29d0179c35c3baefe575904df2913dde519129c7f75995a2b1d/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:09a7bba9f739468c8e78c36a75c33768e53cb1959fc638f510454c14683f00d5", size = 194848, upload-time = "2026-08-15T08:18:07.397Z" },
{ url = "https://files.pythonhosted.org/packages/74/76/f2fc7380f056cc273a53af37f50d08ad54b2c59f61078f31432edcf1c2bd/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c9548dc78002099910abaebc0a72ac58b7d30931869e0351c09b507dff4ece3", size = 198163, upload-time = "2026-08-15T08:18:08.989Z" },
{ url = "https://files.pythonhosted.org/packages/e9/40/095ce62fa078483cccc1fa2b36e6bc9580b85422a20ee9f925341c50e44f/charset_normalizer-3.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c428c6c31eb5f4277d7f8eccaf767fbd548ddd5ce3c8b4f4cbbfab3d96b5904c", size = 341823, upload-time = "2026-08-15T08:18:10.458Z" },
{ url = "https://files.pythonhosted.org/packages/f1/5a/0e58b1c04a1596e0256f407274a92d5fb2ee21324409d1fab1da48a65b5b/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f06b7eae9dbe77fe1d644ca244dad508de8d302870a43f3c559b521270938a0", size = 242458, upload-time = "2026-08-15T08:18:11.989Z" },
{ url = "https://files.pythonhosted.org/packages/22/95/b4618ce912e6db0b1aae89ba788e38e8a7eba0f3025cc66e8c0699f977b2/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b7430cf5728e68f6c462254009a6ef4086e1bea43cf2f57aa9c55fb4f50ff96", size = 226717, upload-time = "2026-08-15T08:18:13.401Z" },
{ url = "https://files.pythonhosted.org/packages/8a/76/c681192bbda3d55356db5dadd64381d5202b37c6b598fcda5282e88b5d3d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab743e9bc90c1f73552ec33e10e3331315acd2c397b36065b591b0181de533cc", size = 266111, upload-time = "2026-08-15T08:18:14.961Z" },
{ url = "https://files.pythonhosted.org/packages/88/be/55127bfca72c0cff6c022488d140d7c5b04c771e3b72e9bdb4836d54979d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6f7deae3feb4edfa2efaf7c574fe88cbf055038a6abdb40188e4fff66d5699f", size = 263128, upload-time = "2026-08-15T08:18:16.515Z" },
{ url = "https://files.pythonhosted.org/packages/e0/91/39c3af510b0aa32bbda03374259200f28430febfd1bf5e511fe765282ce5/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f024313246a4ed976c60f440bb8d257815513a681d212ff74fd46f7d715a90", size = 251240, upload-time = "2026-08-15T08:18:18.127Z" },
{ url = "https://files.pythonhosted.org/packages/1c/a5/cbe418bbc6ecdfc3e05a0116002897c4b403a5e838d697e64c78e9f0190d/charset_normalizer-3.5.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:823f82903d189af463d7df250ef1f7f696f3cee08cc8d91deb565e8d425f6506", size = 245282, upload-time = "2026-08-15T08:18:19.625Z" },
{ url = "https://files.pythonhosted.org/packages/cc/a4/689bb42e8e7cd492f3cb64907c6bc00ad247ec9a3628cd3f8eed126e8ae1/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:01e93745f7f219b703b60ba7afead36cfc4242782be5af484673fc500df12da5", size = 244597, upload-time = "2026-08-15T08:18:21.121Z" },
{ url = "https://files.pythonhosted.org/packages/c1/ce/9962938e179cf9f699d3f1e7b3114b5d7642dee6a893745229f9dd04f274/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:329fc3ccb63ad22d867d84c2adea759a64079a37ba4a343433b02c7a2816871e", size = 231376, upload-time = "2026-08-15T08:18:22.57Z" },
{ url = "https://files.pythonhosted.org/packages/85/54/46000450ada53bd9eac5429a2c8c54cd2d9b39c0c255f229aea9af0948a5/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bb57753e36e4855b8ca375069482250a6246372331a3e4f3407eaebb007443f5", size = 266715, upload-time = "2026-08-15T08:18:24.235Z" },
{ url = "https://files.pythonhosted.org/packages/3d/bb/618749d70f792b44252a777bf89bfb86823b9bbc1ea13fe8ce759b07f38a/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fce8cbd4997efeb450bd298b54f755dcdff18d496f7a5ddbb4867c6d7c88fdc3", size = 245848, upload-time = "2026-08-15T08:18:25.726Z" },
{ url = "https://files.pythonhosted.org/packages/7e/3f/ffb64458527c7668031d5eb095d978de561958dc9f5b53f8e488a533e603/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6c9cdde8becb25a7fde49924511aa2644d6f8081cc8df8e9452724303348d8e3", size = 264521, upload-time = "2026-08-15T08:18:27.193Z" },
{ url = "https://files.pythonhosted.org/packages/4f/ab/74a55fd803916a35ac461daf002708191aac19b546b80dc8cabfedc63d98/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9ac4444d8d4fd4c4bd08bf451ed3167aa9e7ec6cdb41b648794f1d1103652e36", size = 253054, upload-time = "2026-08-15T08:18:28.568Z" },
{ url = "https://files.pythonhosted.org/packages/a0/2a/6a9034b7d3c60b17499afb482df5878bf9fa20b50cc3887d5ef017a833db/charset_normalizer-3.5.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f03ac127268b43ef4fe9e6ab6794a6794b49485a0cc0c1db79876d2f33f75bc7", size = 140580, upload-time = "2026-08-15T08:18:30.214Z" },
{ url = "https://files.pythonhosted.org/packages/f3/46/1d362e1a00d035d66b9869e1281eee115907f7e390a16a07824ab5737360/charset_normalizer-3.5.1-cp314-cp314-win32.whl", hash = "sha256:1f5883d77fd409a261abb5dc8ccbe335720d798b1de4abb3b1d47ccbbc76b53b", size = 180325, upload-time = "2026-08-15T08:18:31.877Z" },
{ url = "https://files.pythonhosted.org/packages/7a/7c/4938c329b6a9d446f6a59aa2092ff7118f274209b5ed0e26893d1d30a63c/charset_normalizer-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:c658c50ac0c98cd755a2dd50b7977d3bca7df401dcc47fbdfa87db53ef7d4e8b", size = 204175, upload-time = "2026-08-15T08:18:33.466Z" },
{ url = "https://files.pythonhosted.org/packages/ac/33/eeb384dbd8dec570661354592f4f2e1b2fcc92585624d146a000caf53841/charset_normalizer-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:4bea7f8ebe90bbd7f0e4a2de42ca6924ba23e3e76418c408ff82f1d46fabd687", size = 184123, upload-time = "2026-08-15T08:18:34.913Z" },
{ url = "https://files.pythonhosted.org/packages/1c/6c/c73fa9d5a85f6ab05395de61c5f6984e0a9ff40bb5ff888d46dff02526c6/charset_normalizer-3.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fbc597639158fd7c14d55e808718848319540f51b0e6746e3eefa59723a4a348", size = 381682, upload-time = "2026-08-15T08:18:36.349Z" },
{ url = "https://files.pythonhosted.org/packages/30/c7/63565f860921457feba93bae6c86fb7746deb4cffeed2f375cb845318146/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71c909f353863b2b89c83de2ebed71ea6d0df8a6ef65a128193c5e650766bef", size = 240826, upload-time = "2026-08-15T08:18:37.887Z" },
{ url = "https://files.pythonhosted.org/packages/06/ae/7ae8807410dfa33f8e6f1715740adeaafa8a816cc4cb33508f54b1f7c896/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7ac76cf9afd34929d76eb7fcb63be476a4853d8a96f0dcf2d0db68a0cbdf9885", size = 227861, upload-time = "2026-08-15T08:18:39.315Z" },
{ url = "https://files.pythonhosted.org/packages/e9/a3/887c1642f0da26000b0e0652d91071113c0e72cea33952e225cf589f49a9/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a3a370082ce34d0612f421e15fe011c53bb1feff21a26d06ad4fb244dab5a375", size = 260758, upload-time = "2026-08-15T08:18:40.88Z" },
{ url = "https://files.pythonhosted.org/packages/3e/11/e6f5b9a3d0e55b0ef7505cd3765cdd48f22db89994c947b316f52f801fd8/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:256dd4d85d9e4dc595e2bc983c980e73f62ddeb3165c58b4c3dfe78c5c8548c1", size = 259950, upload-time = "2026-08-15T08:18:42.351Z" },
{ url = "https://files.pythonhosted.org/packages/1b/ee/e4e10a94d51cd1ee638aa7e00b65399e6b2a4e8376ab6d2eac9f95586671/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58d4aa13a59c969dbfdf9e6a9560e242cbfd9e8a8f50c2747714df1a423adf65", size = 249329, upload-time = "2026-08-15T08:18:43.914Z" },
{ url = "https://files.pythonhosted.org/packages/c4/25/d5f4198819e6059735a84e8d0bfb72dc33976da67b97adcd3fb5a5e07ec6/charset_normalizer-3.5.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c6dfb5ca6723eeed15aa8e564a014d69fcb8812f94eef11fe3631e0508199f5", size = 243137, upload-time = "2026-08-15T08:18:45.368Z" },
{ url = "https://files.pythonhosted.org/packages/a5/e9/e925ca7569cf9fb9701fd82503fee73eea5268fdb856bdd64947092d3daa/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c010f5581d9c612804cc59fcf7b524b707fbcb72828551237ab545bb5c7034af", size = 242820, upload-time = "2026-08-15T08:18:46.842Z" },
{ url = "https://files.pythonhosted.org/packages/34/17/672c251a888ed2aebcdd2fe830ad0104e25ff83c43f5c4f9c15e9fc6853c/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:52ec005752a56ae79547a05c0139ca2501a0c866390b6115008456b9f0e7cde1", size = 230504, upload-time = "2026-08-15T08:18:48.353Z" },
{ url = "https://files.pythonhosted.org/packages/3f/fc/f6a85abebd42ce4da2f1db0aa56cc6a0df1995e318b3875d14401b8381d1/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2bced4061f000f7187254a02ad3433ae17eaf991747ceea2f478422590a5bba9", size = 263087, upload-time = "2026-08-15T08:18:49.859Z" },
{ url = "https://files.pythonhosted.org/packages/98/66/7c42677e739ba66746b297e2046918d793078094dc239e1e72768cffccc6/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9eea3ab2597a5e65fe65296e2d6a84570845a6b55532d90333d740d48bbc850a", size = 243269, upload-time = "2026-08-15T08:18:51.601Z" },
{ url = "https://files.pythonhosted.org/packages/de/d8/a50b79237f417af10f8c2a501ce8d1ca87829a22e69117891ca4ba20a69e/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:496846868fea80e479324862fa877f02411f2fd0f83b79ccee2607aa68b2a032", size = 258766, upload-time = "2026-08-15T08:18:53.23Z" },
{ url = "https://files.pythonhosted.org/packages/2e/1d/0fc91aeaeb3c83b748f532399ce67cf84604b48297405d740000f7a9e786/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:85d5855daafc240cc045c026d7a15fd198a09b0fc8ff6f5ecbb5297b509cb11e", size = 250814, upload-time = "2026-08-15T08:18:54.768Z" },
{ url = "https://files.pythonhosted.org/packages/ae/10/3d8c777cf9024615295aa1b808324ad5b4a77855869c00824bad74ffaf8a/charset_normalizer-3.5.1-cp314-cp314t-win32.whl", hash = "sha256:58d3e12c88e0950bca850ae1f7c256055c097639c2edb9eb123af9807d8b15e4", size = 191074, upload-time = "2026-08-15T08:18:56.305Z" },
{ url = "https://files.pythonhosted.org/packages/4d/81/ae557d3c44d1a1d688696d60563413a0866a91b7ebc50f20df838be3d8c8/charset_normalizer-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:acaf604462bf330b0d07e7a07c1d6e4adac79e5fb13e9c5140590542cafacc00", size = 216476, upload-time = "2026-08-15T08:18:57.889Z" },
{ url = "https://files.pythonhosted.org/packages/27/e9/61c01fb8b804692569c036b3fc50495814502dcf13a60649c6055390b02c/charset_normalizer-3.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:fdb8a068947befafba9952162645dc2fecaeb400e64584829ed5e9b2fbe21a7f", size = 194115, upload-time = "2026-08-15T08:18:59.418Z" },
{ url = "https://files.pythonhosted.org/packages/4a/4e/8544831ef59d8f27ce92c80871380fdacc8076a8a56ed62f82e54f991333/charset_normalizer-3.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9085f87b0e38a2b92b8923059b4e8789fe40d9279712d15dcc670048d77079af", size = 342048, upload-time = "2026-08-15T08:19:01.054Z" },
{ url = "https://files.pythonhosted.org/packages/7f/a6/e3b46852424246065355644f4fb6dbccc0239a42a2eee27ecfc8957f0bcd/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2679de311c7946dde5d3b6f44941844133ff5c7cb86099c0061ab1e8901c20a8", size = 242997, upload-time = "2026-08-15T08:19:02.492Z" },
{ url = "https://files.pythonhosted.org/packages/03/3b/0cc9a26777334ab2f2e3089b948bbf4e4fe72ea70b897715ef6415043ec8/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:baf3775a2635e5a11fbd5e4e64ee69c7e86875d224a5c72aca4c141064589a90", size = 237014, upload-time = "2026-08-15T08:19:03.943Z" },
{ url = "https://files.pythonhosted.org/packages/8c/c2/027335f0aa337a2a2e121bac1ad88c4f02ba6053ea0926802784f3db11af/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ac8c94b6539074e0f40899301273ac8402b9b3e01c7b7ba269ff30340aaaf20", size = 266174, upload-time = "2026-08-15T08:19:05.598Z" },
{ url = "https://files.pythonhosted.org/packages/86/d3/e367787febe4e74769dec0f406f2c3c8d1b955fce5aee1fd0f94e8367a45/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe532b3c966d1fb794e0698e4589d0444017ae77fc0b31edea13c0e35bcc449", size = 263361, upload-time = "2026-08-15T08:19:07.251Z" },
{ url = "https://files.pythonhosted.org/packages/af/3d/391b193eb9f3e84b02f9314088c386debdc0debee843535aaea2e2c6715d/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c84bec0ab5ae0c64bfe73a7d2adcb5ce73b467523fc27fd6a28ab2aa6cbe35a", size = 252143, upload-time = "2026-08-15T08:19:08.816Z" },
{ url = "https://files.pythonhosted.org/packages/2e/57/de221f1745a90d418199761967e2776bfe2c275a1194220985e8c1d37833/charset_normalizer-3.5.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:854066be00447fa8de2ccbbe893e2ffc4b123ef16d897af794c1e18bd4a714b0", size = 252086, upload-time = "2026-08-15T08:19:10.255Z" },
{ url = "https://files.pythonhosted.org/packages/c8/e3/d119f86a01f9331e8186175f24873b1d74a7ee9e2e4b4d68f9947dae5afd/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:21b82d8082f6f5e7f456ef0bd16323d08de1266efbfeb476e64b2a91d1471a4e", size = 245231, upload-time = "2026-08-15T08:19:11.807Z" },
{ url = "https://files.pythonhosted.org/packages/26/de/d8e48c135ae480879539cdb179c8d3b50c7879497d75dd899b5763b69cee/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:838648accb3a7fd9803fd45c87bce8509648eb0c11bc34e216141300977244f2", size = 241546, upload-time = "2026-08-15T08:19:13.416Z" },
{ url = "https://files.pythonhosted.org/packages/67/c4/217755fd1abc50d326c252922cd642002758095a81ff45010337b8b3ef65/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:195ce897c6153c0700078142cf8efe3e6454ca4cf4357499e4078dfd83396626", size = 267033, upload-time = "2026-08-15T08:19:14.981Z" },
{ url = "https://files.pythonhosted.org/packages/b8/d7/34d8e404e358d2adcc5a228c2134643af00104c8fb0bf525f3688d756f05/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:978eab16f55b4ab2c2a745be9a0a840bf8f09a7f227d9c76eb30214d078865a5", size = 252045, upload-time = "2026-08-15T08:19:16.618Z" },
{ url = "https://files.pythonhosted.org/packages/5e/fa/40414471acf0aa0692ca77305aa00e434fcd8288f0941c93c30e9a5f8f2f/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:cc0329df4caaceb950d2f580b5ac716a377f7059624a0bafaeaf8a218c6ed774", size = 264866, upload-time = "2026-08-15T08:19:18.101Z" },
{ url = "https://files.pythonhosted.org/packages/32/90/fcc850bae791abd2e0c041847f13e270aa08692a79f3e00de6d2dce1cb50/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:687c9ca3035544b113bea2055e180af96fb63c0c476e22a9180f51925186e7b7", size = 253932, upload-time = "2026-08-15T08:19:19.734Z" },
{ url = "https://files.pythonhosted.org/packages/af/af/53afe99068b3c10b4cbae592a52ef72a7c92c0188440e83ee3a078fd8f75/charset_normalizer-3.5.1-cp315-cp315-win32.whl", hash = "sha256:706bfd38730a5ac7a365793269a00f4e988178cec121391f4248d84ad8c972e9", size = 180320, upload-time = "2026-08-15T08:19:21.37Z" },
{ url = "https://files.pythonhosted.org/packages/c9/bc/f46a132041b29e4a8779ed712d3df1bf112e94ca8de58b66d7ec2c0cf8b9/charset_normalizer-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:92caef967d287a407085d61176fce4012b1dd62daed4eb6d5ceb26d3d2538712", size = 204174, upload-time = "2026-08-15T08:19:23.088Z" },
{ url = "https://files.pythonhosted.org/packages/a1/5d/9ed554480eda8e447b673648628fdc29574d23dbad01fe11837adedd1cae/charset_normalizer-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:5fc45d653ea8c9a20479167e11d4a0f8cb2fa3470737ab6f9c827532313187b7", size = 184126, upload-time = "2026-08-15T08:19:24.471Z" },
{ url = "https://files.pythonhosted.org/packages/3b/32/9b8929bf384061ee1fe5d9c27c6f9776d3d824039ad4e14c88ec00c7808e/charset_normalizer-3.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59171c6e45bf07d0d5cab3b0bf81d945035530f6873398b3b531c31184d46663", size = 381441, upload-time = "2026-08-15T08:19:26.038Z" },
{ url = "https://files.pythonhosted.org/packages/96/10/e9aa7923d3ddac652c99a1c5f7be494e737e151566a44abe018daf757f2c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dbdd9205662134957cf0c324f639bdc5031c0ca056e2369e238db75187c0f11", size = 241742, upload-time = "2026-08-15T08:19:27.532Z" },
{ url = "https://files.pythonhosted.org/packages/28/53/a2d249ebddf47b889a100c0bdcb61a2f9dbb8bc24ef325cc062e4f476877/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4b018dc5a0eee4676e38fe84a47a427816c590b93b55d9025274ec4d6ffc2dc", size = 235298, upload-time = "2026-08-15T08:19:29.274Z" },
{ url = "https://files.pythonhosted.org/packages/7d/07/469f78af590f7d5cd48e20d8dbfa3d66deeff9ba37768c04d886b5afd45c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced3fdd71aaa83ce593746c2edb42b7a59cb4c19c8b5c407781c72e493aae55a", size = 262500, upload-time = "2026-08-15T08:19:30.955Z" },
{ url = "https://files.pythonhosted.org/packages/55/66/3bb56a47f7dcba014055b1a1d33c6f08bbe9c1e74dba154cfa25f90ae885/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:19a3dd5aa73cef1c99687c4fc57db016a9c17104ae1185da88ba566a5d3bebe4", size = 258888, upload-time = "2026-08-15T08:19:32.458Z" },
{ url = "https://files.pythonhosted.org/packages/ff/c1/2adc2800903fb013210349313b710a5376856578d9e33e6b9a1d8b36714a/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc5d36d96478aa9c60654bd932525bf32964c62a7281eafdf16d85003a8d6004", size = 250243, upload-time = "2026-08-15T08:19:33.94Z" },
{ url = "https://files.pythonhosted.org/packages/95/b5/a18d0dd1157ab655cc2cb14a545f4a4784bbad70ab3502412e36097502d9/charset_normalizer-3.5.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04368edf83514385ffc3e1cfd4546e595f4f1272dd23ba437a93a9cc3741d47b", size = 249871, upload-time = "2026-08-15T08:19:35.413Z" },
{ url = "https://files.pythonhosted.org/packages/ad/c3/525f508cd1e58d0450ac55ed40ac75bc3a97482c59def5278456a5fbf03c/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:9b5db6052055d34d41230fb78d7c439c23dc536a9896f6cb039e8dd92cfc1263", size = 243580, upload-time = "2026-08-15T08:19:36.886Z" },
{ url = "https://files.pythonhosted.org/packages/7c/c1/49a91fe7e97c8140094ca5c64161ab623a70d9f636bf834eace14048acb5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:252d099029bcbea642f2a06c4ed5046bdf8b5a8150b64afa5e027e88b106e5ee", size = 239807, upload-time = "2026-08-15T08:19:38.392Z" },
{ url = "https://files.pythonhosted.org/packages/d3/58/56a48c296601274c4689b864a8e2dfb209b81dfcb39472753ce95eea662b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6199d5606e2bbf2b096cf64d03f8b6790c91081d5ac866b8e7bb6422738cc60c", size = 264083, upload-time = "2026-08-15T08:19:39.856Z" },
{ url = "https://files.pythonhosted.org/packages/10/4c/dc48409274a1817ff349711d26c62aa0c597df865d4d69ef79160c859193/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:77efcff2b23071c349402ac1066667a3d011f62398d81408c9b88ad991747c9e", size = 250317, upload-time = "2026-08-15T08:19:41.53Z" },
{ url = "https://files.pythonhosted.org/packages/81/58/d325912115caec62d6bdd77bbab5e0b7da5d234a9f20affdffcbcb530d0b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a5cbd90ecf0fc62e64726917ad083b73001f0563657a87ec3c0b504e277dc90d", size = 258173, upload-time = "2026-08-15T08:19:43.07Z" },
{ url = "https://files.pythonhosted.org/packages/34/f7/b13b1ccae2c8ec63980d13be1890eb73f8aeabbfce02a24aabc0908788f5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4d26f14f041e83dd8edfd61f4cd4fa7285d31798b5bf1f28e70c367ba6c41d61", size = 251960, upload-time = "2026-08-15T08:19:44.587Z" },
{ url = "https://files.pythonhosted.org/packages/1e/25/ed3f9919c5aef8cc818be1f972f565f7610d7b2076b8ebb98839516ffc3c/charset_normalizer-3.5.1-cp315-cp315t-win32.whl", hash = "sha256:ac13b004224fb341e1e25a1ed5e19d32f57cdb2a403e01f003b46f051a550f6f", size = 191186, upload-time = "2026-08-15T08:19:46.293Z" },
{ url = "https://files.pythonhosted.org/packages/69/d5/43c2b3e9d8267092b913eb8b0603f0f71993c395632886bd37a7223f96cf/charset_normalizer-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:35aea775dc2bd5f54cd84a1cd2696cc3207c479cb9cf0bd346f0d343e4300ddb", size = 215947, upload-time = "2026-08-15T08:19:47.853Z" },
{ url = "https://files.pythonhosted.org/packages/a8/76/9aad3e9c8865e5e0efa9a7f6f81c37a67635a985145ecd44528a81e088ee/charset_normalizer-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:fb78f6e7fcd8ad785d28cd577168bc1aaee827b25bb8755638f694794ea98f0a", size = 193909, upload-time = "2026-08-15T08:19:49.383Z" },
{ url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" },
{ url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" },
{ url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" },
{ url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" },
{ url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" },
{ url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" },
{ url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" },
{ url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" },
{ url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" },
{ url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" },
{ url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" },
{ url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" },
{ url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" },
{ url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" },
{ url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" },
{ url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" },
{ url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" },
]
[[package]]
name = "click"
version = "8.5.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" },
]
[[package]]
name = "colorama"
version = "0.4.6"
@@ -11,6 +198,36 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
]
[[package]]
name = "ghp-import"
version = "2.1.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "python-dateutil" },
]
sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943, upload-time = "2022-05-02T15:47:16.11Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" },
]
[[package]]
name = "griffelib"
version = "2.3.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/27/af/018c10bc9edd42b6ef6db2e96b09542050d5253f9b195e74bc910b2d13ab/griffelib-2.3.0.tar.gz", hash = "sha256:7b0952caf5bca6afa4bb5ee8c6a2d183fe3f21b62efc5f6c7243cb2b26d2d115", size = 234534, upload-time = "2026-09-04T15:08:17.472Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/41/63/e876e789525063c840ccfa8857febdabd6523bcef9ce7eb979b9305ea895/griffelib-2.3.0-py3-none-any.whl", hash = "sha256:1b8f9cd525681c26b1d6d574faa1371651e8459ca51d209684f50b8096ae06e0", size = 169423, upload-time = "2026-09-04T15:08:12.956Z" },
]
[[package]]
name = "idna"
version = "3.19"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" },
]
[[package]]
name = "iniconfig"
version = "2.3.0"
@@ -20,6 +237,235 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
]
[[package]]
name = "jieba"
version = "0.42.1"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/c6/cb/18eeb235f833b726522d7ebed54f2278ce28ba9438e3135ab0278d9792a2/jieba-0.42.1.tar.gz", hash = "sha256:055ca12f62674fafed09427f176506079bc135638a14e23e25be909131928db2", size = 19214172, upload-time = "2020-01-20T14:27:23.5Z" }
[[package]]
name = "jinja2"
version = "3.1.6"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "markupsafe" },
]
sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
]
[[package]]
name = "markdown"
version = "3.10.3"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/29/6f/da4c6aea59b3001f2e8c0ec7497475aadaf3b021c10cab5b2858f0f32b26/markdown-3.10.3.tar.gz", hash = "sha256:3589362618f743188b4d955b874402bc814f4f83f544dc207719f4baa7d9c45f", size = 372596, upload-time = "2026-07-30T19:05:29.005Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/64/69/4a5af2bc115a9a33fefe51709749de8262be3f9ba063d1753a837cdbc49c/markdown-3.10.3-py3-none-any.whl", hash = "sha256:fa6c92a00a4a3c98b22728c64a935ae1928250ae65058a6ded814d2cc29a4cea", size = 110757, upload-time = "2026-07-30T19:05:27.883Z" },
]
[[package]]
name = "markupsafe"
version = "3.0.3"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
{ url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
{ url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
{ url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
{ url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
{ url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
{ url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
{ url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
{ url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
{ url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
{ url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
{ url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
{ url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
{ url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
{ url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
{ url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
{ url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
{ url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
{ url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
{ url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
{ url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
{ url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
{ url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
{ url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
{ url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
{ url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
{ url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
{ url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
{ url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
{ url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
{ url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
{ url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
{ url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
{ url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
{ url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
{ url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
{ url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
{ url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
{ url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
{ url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
{ url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
{ url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
{ url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
{ url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
{ url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
{ url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
{ url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
{ url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
{ url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
{ url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
{ url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
{ url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
{ url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
{ url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
{ url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
{ url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
{ url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
{ url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
{ url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
{ url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
{ url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
{ url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
{ url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
{ url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
{ url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
{ url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
]
[[package]]
name = "mergedeep"
version = "1.3.4"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661, upload-time = "2021-02-05T18:55:30.623Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" },
]
[[package]]
name = "mkdocs"
version = "1.6.1"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "click" },
{ name = "colorama", marker = "sys_platform == 'win32'" },
{ name = "ghp-import" },
{ name = "jinja2" },
{ name = "markdown" },
{ name = "markupsafe" },
{ name = "mergedeep" },
{ name = "mkdocs-get-deps" },
{ name = "packaging" },
{ name = "pathspec" },
{ name = "pyyaml" },
{ name = "pyyaml-env-tag" },
{ name = "watchdog" },
]
sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159, upload-time = "2024-08-30T12:24:06.899Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" },
]
[[package]]
name = "mkdocs-autorefs"
version = "1.4.4"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "markdown" },
{ name = "markupsafe" },
{ name = "mkdocs" },
]
sdist = { url = "https://files.pythonhosted.org/packages/52/c0/f641843de3f612a6b48253f39244165acff36657a91cc903633d456ae1ac/mkdocs_autorefs-1.4.4.tar.gz", hash = "sha256:d54a284f27a7346b9c38f1f852177940c222da508e66edc816a0fa55fc6da197", size = 56588, upload-time = "2026-02-10T15:23:55.105Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/28/de/a3e710469772c6a89595fc52816da05c1e164b4c866a89e3cb82fb1b67c5/mkdocs_autorefs-1.4.4-py3-none-any.whl", hash = "sha256:834ef5408d827071ad1bc69e0f39704fa34c7fc05bc8e1c72b227dfdc5c76089", size = 25530, upload-time = "2026-02-10T15:23:53.817Z" },
]
[[package]]
name = "mkdocs-get-deps"
version = "0.2.2"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "mergedeep" },
{ name = "platformdirs" },
{ name = "pyyaml" },
]
sdist = { url = "https://files.pythonhosted.org/packages/ce/25/b3cccb187655b9393572bde9b09261d267c3bf2f2cdabe347673be5976a6/mkdocs_get_deps-0.2.2.tar.gz", hash = "sha256:8ee8d5f316cdbbb2834bc1df6e69c08fe769a83e040060de26d3c19fad3599a1", size = 11047, upload-time = "2026-03-10T02:46:33.632Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/88/29/744136411e785c4b0b744d5413e56555265939ab3a104c6a4b719dad33fd/mkdocs_get_deps-0.2.2-py3-none-any.whl", hash = "sha256:e7878cbeac04860b8b5e0ca31d3abad3df9411a75a32cde82f8e44b6c16ff650", size = 9555, upload-time = "2026-03-10T02:46:32.256Z" },
]
[[package]]
name = "mkdocs-material"
version = "9.7.7"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "babel" },
{ name = "backrefs" },
{ name = "colorama" },
{ name = "jinja2" },
{ name = "markdown" },
{ name = "mkdocs" },
{ name = "mkdocs-material-extensions" },
{ name = "paginate" },
{ name = "pygments" },
{ name = "pymdown-extensions" },
{ name = "requests" },
]
sdist = { url = "https://files.pythonhosted.org/packages/f1/cd/c05d3a530ba7934f144fb45f7203cd236adc25c7bdcc34673d202f4b0278/mkdocs_material-9.7.7.tar.gz", hash = "sha256:c0649c065b1b0512d60aad8c10f947f8e455284475239b364b610f2deb4d0855", size = 4097923, upload-time = "2026-07-17T16:21:33.156Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/ad/21/17c1bc9e6f47c972ad66fb2ac2568f99f90f1207eeb6fc3b34d094dba7b5/mkdocs_material-9.7.7-py3-none-any.whl", hash = "sha256:8ea9bb1737a5b524a5f9dcf2e1b4ebda8274ae3008aa7845720a97083bef708f", size = 9305438, upload-time = "2026-07-17T16:21:30.017Z" },
]
[[package]]
name = "mkdocs-material-extensions"
version = "1.3.1"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847, upload-time = "2023-11-22T19:09:45.208Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" },
]
[[package]]
name = "mkdocstrings"
version = "1.0.6"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "jinja2" },
{ name = "markdown" },
{ name = "markupsafe" },
{ name = "mkdocs" },
{ name = "mkdocs-autorefs" },
{ name = "pymdown-extensions" },
]
sdist = { url = "https://files.pythonhosted.org/packages/53/71/f85bdf13355073ae15a7375f09879375a830553552e58c1c4b7e0bbc5c8b/mkdocstrings-1.0.6.tar.gz", hash = "sha256:a0b8c2bdd29a6416c80d717aa369bbf7831946bd9f23c2a66db1b1dbe7693dbd", size = 100649, upload-time = "2026-07-11T19:38:05.732Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/5d/5b/4c1902e8bdd5c4db63284e9d101dece4038d4025d6d88850ffe0a1578980/mkdocstrings-1.0.6-py3-none-any.whl", hash = "sha256:2703708697487d1b6d6d7b412e176fa436edf120c1bf81dc9e126b12d00893c7", size = 35787, upload-time = "2026-07-11T19:38:04.417Z" },
]
[package.optional-dependencies]
python = [
{ name = "mkdocstrings-python" },
]
[[package]]
name = "mkdocstrings-python"
version = "2.0.8"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "griffelib" },
{ name = "mkdocs-autorefs" },
{ name = "mkdocstrings" },
]
sdist = { url = "https://files.pythonhosted.org/packages/c5/65/0db919b7c91bf033b42d04f15ff16a56f4edd6afb26e84d448359660ece3/mkdocstrings_python-2.0.8.tar.gz", hash = "sha256:34545b54681cf0b212aab95394d37b0f5326a93b102f6ad1df3d965c79384c9d", size = 201771, upload-time = "2026-08-31T20:16:06.698Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/0b/b7/a5a854d4e44853f26decc0c5e0d68df052399f3da344a313da4178f00816/mkdocstrings_python-2.0.8-py3-none-any.whl", hash = "sha256:e555d9ef53b0febdeae4dd603144d4f86ec90fef672276645ea3bb61232c3d24", size = 105443, upload-time = "2026-08-31T20:16:05.25Z" },
]
[[package]]
name = "packaging"
version = "26.3"
@@ -29,6 +475,33 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
]
[[package]]
name = "paginate"
version = "0.5.7"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252, upload-time = "2024-08-25T14:17:24.139Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746, upload-time = "2024-08-25T14:17:22.55Z" },
]
[[package]]
name = "pathspec"
version = "1.1.1"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
]
[[package]]
name = "platformdirs"
version = "4.11.8"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/53/18/f3bb8ef0d3b930692343da8aa4d3cbcd6749477c053959395ac81965a6e9/platformdirs-4.11.8.tar.gz", hash = "sha256:f23abafea7dd4276d1f29104b83598d7dcc567cafd07c9c951e66665645437fc", size = 37182, upload-time = "2026-09-08T22:20:42.866Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/f4/e1/5b7b8bbb55084d1425bcb9bc823ff519e1b2be05f6ebb0089e2eacc38413/platformdirs-4.11.8-py3-none-any.whl", hash = "sha256:52f2f181bbfde907966932cc8312d967d02976422d66d537ea16092b8e291081", size = 24027, upload-time = "2026-09-08T22:20:41.537Z" },
]
[[package]]
name = "pluggy"
version = "1.6.0"
@@ -47,9 +520,22 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
]
[[package]]
name = "pymdown-extensions"
version = "12.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "markdown" },
{ name = "pyyaml" },
]
sdist = { url = "https://files.pythonhosted.org/packages/f0/20/bb1b39c1f487e6745bfdca09625db8e8265cdce70d2bac679d930a6cbf72/pymdown_extensions-12.0.tar.gz", hash = "sha256:d00b32be02715676bfec9183371928d1db44e1cd58dbeb76c7f27d9f72682039", size = 867035, upload-time = "2026-09-15T03:32:18.85Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/52/8c/18eb38daca41f784dd06edc2ef95a75d7c7572e4105f486a5b2cd613081b/pymdown_extensions-12.0-py3-none-any.whl", hash = "sha256:ae9ee9bfd1c1e3d291d6f6ff1883a7ef388594905e80c0c714b9c596fd8a5cb7", size = 277140, upload-time = "2026-09-15T03:32:17.487Z" },
]
[[package]]
name = "pytdxdata"
version = "0.4.0"
version = "0.6.1"
source = { editable = "." }
[package.optional-dependencies]
@@ -67,6 +553,12 @@ dev = [
{ name = "pytest" },
{ name = "pytest-asyncio" },
]
docs = [
{ name = "jieba" },
{ name = "mkdocs-material" },
{ name = "mkdocstrings", extra = ["python"] },
{ name = "ruff" },
]
[package.metadata]
requires-dist = [
@@ -82,6 +574,12 @@ dev = [
{ name = "pytest", specifier = ">=9.1.1" },
{ name = "pytest-asyncio", specifier = ">=1.4.0" },
]
docs = [
{ name = "jieba", specifier = ">=0.42" },
{ name = "mkdocs-material", specifier = ">=9.5" },
{ name = "mkdocstrings", extras = ["python"], specifier = ">=0.26" },
{ name = "ruff", specifier = ">=0.6" },
]
[[package]]
name = "pytest"
@@ -112,6 +610,100 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
]
[[package]]
name = "python-dateutil"
version = "2.9.0.post0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "six" },
]
sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
]
[[package]]
name = "pyyaml"
version = "6.0.3"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
{ url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
{ url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
{ url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
{ url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
{ url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
{ url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
{ url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
{ url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
{ url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
{ url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
{ url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
{ url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
{ url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
{ url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
{ url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
{ url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
{ url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
{ url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
{ url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
{ url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
{ url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
{ url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
{ url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
{ url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
{ url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
{ url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
{ url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
{ url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
{ url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
{ url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
{ url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
{ url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
{ url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
{ url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
{ url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
{ url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
{ url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
{ url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
{ url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
{ url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
{ url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
{ url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
{ url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
{ url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
{ url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
]
[[package]]
name = "pyyaml-env-tag"
version = "1.1"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "pyyaml" },
]
sdist = { url = "https://files.pythonhosted.org/packages/eb/2e/79c822141bfd05a853236b504869ebc6b70159afc570e1d5a20641782eaa/pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff", size = 5737, upload-time = "2025-05-13T15:24:01.64Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" },
]
[[package]]
name = "requests"
version = "2.34.2"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "certifi" },
{ name = "charset-normalizer" },
{ name = "idna" },
{ name = "urllib3" },
]
sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
]
[[package]]
name = "ruff"
version = "0.16.2"
@@ -137,6 +729,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/5b/6c/93e26c22c5f78ff87363e07da49c84955affbeb1098bd1936bf3b3f293bf/ruff-0.16.2-py3-none-win_arm64.whl", hash = "sha256:d614e95cedf38a2053fd351c55b103ba30d017d61688fdbfd40ee0412852a99f", size = 11374065, upload-time = "2026-08-07T13:30:58.775Z" },
]
[[package]]
name = "six"
version = "1.17.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
]
[[package]]
name = "typing-extensions"
version = "4.16.0"
@@ -146,6 +747,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
]
[[package]]
name = "urllib3"
version = "2.7.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
]
[[package]]
name = "uvloop"
version = "0.22.1"
@@ -183,3 +793,30 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
{ url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
]
[[package]]
name = "watchdog"
version = "6.0.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/e0/24/d9be5cd6642a6aa68352ded4b4b10fb0d7889cb7f45814fb92cecd35f101/watchdog-6.0.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6eb11feb5a0d452ee41f824e271ca311a09e250441c262ca2fd7ebcf2461a06c", size = 96393, upload-time = "2024-11-01T14:06:31.756Z" },
{ url = "https://files.pythonhosted.org/packages/63/7a/6013b0d8dbc56adca7fdd4f0beed381c59f6752341b12fa0886fa7afc78b/watchdog-6.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ef810fbf7b781a5a593894e4f439773830bdecb885e6880d957d5b9382a960d2", size = 88392, upload-time = "2024-11-01T14:06:32.99Z" },
{ url = "https://files.pythonhosted.org/packages/d1/40/b75381494851556de56281e053700e46bff5b37bf4c7267e858640af5a7f/watchdog-6.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:afd0fe1b2270917c5e23c2a65ce50c2a4abb63daafb0d419fde368e272a76b7c", size = 89019, upload-time = "2024-11-01T14:06:34.963Z" },
{ url = "https://files.pythonhosted.org/packages/39/ea/3930d07dafc9e286ed356a679aa02d777c06e9bfd1164fa7c19c288a5483/watchdog-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bdd4e6f14b8b18c334febb9c4425a878a2ac20efd1e0b231978e7b150f92a948", size = 96471, upload-time = "2024-11-01T14:06:37.745Z" },
{ url = "https://files.pythonhosted.org/packages/12/87/48361531f70b1f87928b045df868a9fd4e253d9ae087fa4cf3f7113be363/watchdog-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c7c15dda13c4eb00d6fb6fc508b3c0ed88b9d5d374056b239c4ad1611125c860", size = 88449, upload-time = "2024-11-01T14:06:39.748Z" },
{ url = "https://files.pythonhosted.org/packages/5b/7e/8f322f5e600812e6f9a31b75d242631068ca8f4ef0582dd3ae6e72daecc8/watchdog-6.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6f10cb2d5902447c7d0da897e2c6768bca89174d0c6e1e30abec5421af97a5b0", size = 89054, upload-time = "2024-11-01T14:06:41.009Z" },
{ url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload-time = "2024-11-01T14:06:42.952Z" },
{ url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload-time = "2024-11-01T14:06:45.084Z" },
{ url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload-time = "2024-11-01T14:06:47.324Z" },
{ url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" },
{ url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" },
{ url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" },
{ url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload-time = "2024-11-01T14:07:03.893Z" },
{ url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload-time = "2024-11-01T14:07:05.189Z" },
{ url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload-time = "2024-11-01T14:07:06.376Z" },
{ url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload-time = "2024-11-01T14:07:07.547Z" },
{ url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload-time = "2024-11-01T14:07:09.525Z" },
{ url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload-time = "2024-11-01T14:07:10.686Z" },
{ url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
]