M1 最小闭环:CLI + FastAPI 网关 + SQL 闸 + 100% 覆盖率验收链

- CLI:init/serve/update/query/export/status(typer + rich),单写者锁三元判活
- 存储:DuckDB schema migrations(14 表 + 8 联邦视图,语句元组逐条执行)
- ETL:A股证券/日历/日K,整区替换幂等;日历全年补全(calendar 语义唯一)
- 网关:POST /v1/query(线程池 + interrupt 超时 504)、/v1/export、meta/stats/state、healthz/ready
- 安全:SQL 闸 sqlglot fail-closed(文件/网络表函数默认拒)、非 loopback 空 token 拒启、导出路径双判
- 验收:254 测试全绿、1265 语句 100% 覆盖、[CI] 真起服验收链、smoke_m1.py 交付自检
- 文档:设计文档 v0.7(圆桌 45 条采纳 + 3 条实施校准),README 重写
- 发布:release.yml Trusted Publishing(OIDC 免密钥),action refs 已核验
This commit is contained in:
openbot committed 2026-09-24 09:06:47 +08:00
commit d37c697bbe
59 files changed
+7586

No files matched your search

+96
View File
@@ -0,0 +1,96 @@
name: CI
on:
push:
branches: [main, develop]
pull_request:
jobs:
test:
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest, windows-latest]
runs-on: ${{ matrix.os }}
steps:
# ref 均经 raw.githubusercontent.com 核验存在(2026-09-24)
- uses: actions/checkout@v7
# 3.13:与 .python-version / requires-python 一致。
# 注意不要用 3.14 —— 该版本 Windows 的 asyncio socketpair 回退分支会死锁。
- uses: astral-sh/setup-uv@v10.1.0
with:
python-version: "3.13"
enable-cache: true
- name: Install
run: uv sync --frozen
- name: Lint imports (smoke)
run: uv run python -c "import pyquantdata.cli; import pyquantdata.serve.app; import pyquantdata.store.migrations"
- name: Test (coverage 100% gate)
run: uv run pytest --cov=pyquantdata --cov-report=term-missing --cov-fail-under=100
# [CI] 验收链(§14 两层验收的第一层):全程离线 —— init --skip-history + 迷你
# seed → serve → POST /v1/query 查日K → export csv。真网 uvicorn / 真数据
# 归 [夜间] 层,见 nightly.yml。
- name: Verify CI fixture integrity
run: uv run python tests/fixtures/build_ci_fixture.py --check
- name: Acceptance chain — init (skip history + mini seed)
run: |
uv run quantdata init -d ci-db --skip-history --seed tests/fixtures/ci_seed_1d.parquet
uv run quantdata status -d ci-db --json
- name: Acceptance chain — serve + query + export
shell: bash
run: |
set -euo pipefail
# 显式 bypass 代理:环境里若挂了 http_proxy 且指向不可用地址,
# curl 连 127.0.0.1 也会超时,被误判成「服务没起来」。
export NO_PROXY=127.0.0.1,localhost
export no_proxy=127.0.0.1,localhost
CURL="curl -fsS --noproxy 127.0.0.1"
uv run quantdata serve -d ci-db --port 18765 &
SERVE_PID=$!
trap 'kill $SERVE_PID 2>/dev/null || true' EXIT
for i in $(seq 1 60); do
if curl -fsS --noproxy 127.0.0.1 http://127.0.0.1:18765/healthz >/dev/null 2>&1; then break; fi
sleep 0.5
done
$CURL http://127.0.0.1:18765/healthz; echo
$CURL http://127.0.0.1:18765/v1/ready; echo
# 日K 查询(POST /v1/query)
$CURL -X POST http://127.0.0.1:18765/v1/query \
-H 'Content-Type: application/json' \
-d '{"sql":"SELECT count(*) AS n FROM cn_stock_1d"}' | tee /tmp/q.json; echo
grep -q '"row_count": 1' /tmp/q.json
# 导出 csv(全链路:SQL 闸 → 只读执行 → exports/{job_id}/ 落盘)
$CURL -X POST http://127.0.0.1:18765/v1/export \
-H 'Content-Type: application/json' \
-d '{"sql":"SELECT symbol, date, close FROM cn_stock_1d ORDER BY date","fmt":"csv","filename":"ci_daily.csv"}' \
-o /tmp/ci_daily.csv
head -1 /tmp/ci_daily.csv
test "$(wc -l < /tmp/ci_daily.csv)" -eq 21 # 表头 + 20 行
test -f ci-db/exports/*/ci_daily.csv
# SQL 闸 fail-closed:恶意查询必须 400
code=$(curl -s -o /dev/null -w '%{http_code}' --noproxy 127.0.0.1 \
-X POST http://127.0.0.1:18765/v1/query \
-H 'Content-Type: application/json' \
-d '{"sql":"SELECT read_parquet('"'"'/etc/passwd'"'"')"}')
echo "sqlgate status=$code"
test "$code" = "400"
# 停服后端口必须释放
kill $SERVE_PID 2>/dev/null || true
wait $SERVE_PID 2>/dev/null || true
if curl -fsS --max-time 3 --noproxy 127.0.0.1 http://127.0.0.1:18765/healthz >/dev/null 2>&1; then
echo "端口未释放"; exit 1
fi
echo "acceptance chain OK"
+71
View File
@@ -0,0 +1,71 @@
# 推 tag (v*) → 测试 → 构建 → Trusted Publishing (OIDC) 免密钥发布 PyPI。
# 依赖:GitHub 侧 Environment `pypi` + PyPI 侧 pending publisher(owner/openbot-coder、
# 仓库 pyquantdata、workflow release.yml、environment pypi)。
# refs 均经 raw.githubusercontent.com 核验存在(2026-09-24)。
name: Release
on:
push:
tags: ["v*"]
workflow_dispatch:
permissions:
contents: read
jobs:
test:
name: Test
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: astral-sh/setup-uv@v10.1.0
with:
python-version: "3.13"
- run: uv sync --locked
- run: uv run pytest -q
build:
name: Build distributions
needs: test
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- uses: astral-sh/setup-uv@v10.1.0
with:
python-version: "3.13"
# 防「tag 叫 v0.1.0、pyproject 里还是 0.0.9」的错发
- name: Verify tag matches package version
if: startsWith(github.ref, 'refs/tags/v')
run: |
set -euo pipefail
tag_version="${GITHUB_REF_NAME#v}"
pkg_version="$(uv version --short)"
if [ "${tag_version}" != "${pkg_version}" ]; then
echo "::error::tag v${tag_version} 与 pyproject 版本 ${pkg_version} 不一致"
exit 1
fi
- run: uv build
- run: uvx twine check dist/*
- uses: actions/upload-artifact@v7
with:
name: dist
path: dist/
if-no-files-found: error
publish:
name: Publish to PyPI
needs: build
if: startsWith(github.ref, 'refs/tags/v')
runs-on: ubuntu-latest
environment:
name: pypi
url: https://pypi.org/p/pyquantdata
permissions:
id-token: write # Trusted Publishing 必需(OIDC 换 15 分钟短期令牌),无需任何密钥
steps:
- uses: actions/download-artifact@v8
with:
name: dist
path: dist/
- uses: pypa/gh-action-pypi-publish@release/v1
+31
View File
@@ -0,0 +1,31 @@
# Python
__pycache__/
*.py[cod]
*.egg-info/
dist/
build/
.venv/
.pytest_cache/
.coverage
.coverage.*
coverage.xml
htmlcov/
# WorkBuddy 项目记忆(不进公开仓库)
.workbuddy/
# quantdata dbpath 运行产物(测试/开发期)
tmp-db/
ci-db/
*.duckdb
*.duckdb.wal
quantdata.lock
exports/
# pytest tmp / 临时目录
.pytest_tmp/
.pytest_basetemp/
# IDE
.idea/
.vscode/
+1
View File
@@ -0,0 +1 @@
3.13.0
+21
View File
@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2026 openbot-coder
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+106
View File
@@ -0,0 +1,106 @@
# pyquantdata(CLI 名 `quantdata`)
单目录自包含、三市场(A/美/港)覆盖的量化数据中台:`init` 建库回填,`serve` 常驻更新 + FastAPI 对外服务,一切状态收敛在 `-d` 指定的 dbpath。
设计方案见 [docs/quantdata-design.md](docs/quantdata-design.md)(v0.7,圆桌评审 45 条已采纳)。
## 当前状态:M1 最小闭环
| 能力 | 说明 |
|---|---|
| `init` | 建目录 + config.json + DuckDB schema(migrations:14 表 + 8 联邦视图)+ seed 导入 + 自检;`--estimate` 只算磁盘预算 |
| `serve` | 单写者锁(PID 三元判活)+ FastAPI 网关,恒前台常驻 |
| `update` | A股证券 / 交易日历 / 日K(主源 pytdxdata),整区替换幂等 |
| `query` | 本地只读直查(不开服务也可用),`--fmt table\|json\|csv\|parquet\|arrow` |
| `export` | csv / parquet 落盘(恒 `exports/{job_id}/`,路径双判防穿越) |
| `status` | 水位 / 锁 / HTTP / 磁盘,`--json` 结构化输出 |
**安全约束**(设计 §8.3 / §8.4):
- SQL 闸 **fail-closed**:sqlglot 解析、根节点白名单、多语句拒绝、文件/网络表函数默认拒绝(`SELECT read_csv('/etc/passwd')` → 400);
- 查询走线程池,超时 = `connection.interrupt()` 真中断 → 504;并发信号量 4,超出排队 429;
- 只读连接断扩展自动加载(堵 httpfs 出站)+ `memory_limit`;
- 非 loopback 且 token 为空 → 拒绝启动(`--insecure` 显式放行)。
## 安装
```bash
uv sync # 开发安装(含 dev 依赖)
# 或
uv pip install pyquantdata # PyPI 安装(发布后)
```
Python `>=3.11,<3.14`(3.14 在 Windows 上 asyncio socketpair 死锁,已排除)。
## 快速开始
```bash
# 1. 建库(离线迷你 seed 演示;真实回填去掉 --skip-history)
uv run quantdata init -d tmp-db --skip-history --seed tests/fixtures/ci_seed_1d.parquet
# 2. 本地直查
uv run quantdata query -d tmp-db "SELECT date, close FROM cn_stock_1d ORDER BY date DESC LIMIT 5"
# 3. 起服务(默认 127.0.0.1:8765)
uv run quantdata serve -d tmp-db
```
```bash
curl -s localhost:8765/healthz # {"status":"ok"}
curl -s localhost:8765/v1/ready # readiness:catalog/schema/磁盘
curl -s -X POST localhost:8765/v1/query \
-H 'Content-Type: application/json' \
-d '{"sql":"SELECT count(*) FROM cn_stock_1d"}'
```
### REST 端点(前缀 `/v1`)
| 端点 | 方法 | 用途 |
|---|---|---|
| `/v1/query` | POST | `{sql, params, fmt: json\|arrow}` → 结果(arrow = Arrow IPC base64,pandas/polars 直吃) |
| `/v1/export` | POST | `{sql, fmt: csv\|parquet, filename}` → 文件流 + `exports/{job_id}/` 落盘 |
| `/v1/export/{job_id}` | GET | 导出任务状态 |
| `/v1/meta` / `/v1/stats` | GET | 字典结构 / 水位磁盘统计 |
| `/v1/state/{market}` | GET | 市场状态机(CLOSED/OPEN/LUNCH_BREAK…) |
| `/healthz` `/v1/ready` | GET | liveness / readiness 探针 |
Swagger UI:起服后访问 `http://127.0.0.1:8765/docs`(OpenAPI 免费得)。
## 测试与验收
```bash
# 单测 + 100% 覆盖率门禁([CI] 验收链 tests/test_ci_chain.py 含在内)
uv run pytest --cov=pyquantdata --cov-report=term-missing --cov-fail-under=100
# M1 交付自检冒烟(真起服 + 真端口 + 全端点,11 项断言)
uv run python scripts/smoke_m1.py
```
CI(GitHub Actions):Linux + Windows 矩阵 → lint → 覆盖率门禁 → fixture 一致性校验 → **真起服验收链**(init → serve → query → export → SQL 闸 400 → 端口释放)。
## 项目结构
```
src/pyquantdata/
├── cli.py # typer 命令:init/serve/update/query/export/status
├── config.py # config.json 模型(JSON、extra=forbid、${ENV} 展开)
├── paths.py # dbpath 目录规范(§3.1)
├── lockfile.py # 单写者锁:PID + start_time + boot_id 三元判活(§11)
├── store/ # DuckDB 连接管理 + migrations(14 表 8 视图)
├── sqlgate/ # SQL 闸(sqlglot fail-closed,§8.3)
├── sources/ # SourceAdapter 协议 + TdxAdapter + 日历补全
├── etl/ # update/checkpoint/seed(整区替换幂等,§7.3)
├── serve/ # FastAPI 网关 + runtime + 状态机 + 鉴权
└── export/ # csv/parquet 落盘(路径安全,§9)
```
## 路线图(设计 §15)
- **M1 ✅** 最小闭环(本仓库当前状态)
- **M2** 1m 回填 + compaction + 除权/ST/涨跌停 + 每日质检 + qlib/backtrader 导出
- **M3** 美/港三市场 + WS 推流(快照/状态/新闻)
- **M4** 运维加固(supervisord 部署、doctor、薄 SDK)
## License
MIT
+729
View File
@@ -0,0 +1,729 @@
# pyquantdata(CLI 名 `quantdata`)设计方案
**版本**:v0.7(M1 实施校准版)
**日期**:2026-09-23
**修订**:v0.2 —— ①数据源调整(去 tqcenter,加 yfinance 参考 + akshare 摘抄/primp 兜底,不安装 akshare)②调度任务脚本化(dbpath/scripts/ 每任务一脚本)③config.json 扩展(抓取时间/代理服务器/数据源要求)
**评审**:v0.3 —— 八项开放问题全部拍板(§16 转为决策记录):质量校验确认 / 起始年限 cn2004·us2020·hk2020 / 暂缓品类走可扩展结构 / 研报·申万=akshare 摘抄 / 3s 快照够用 / nats-server 随库自带不依赖预装 / 部署=Linux / 加 union 视图
**修订**:v0.4 —— NATS 去掉 local/remote/none 三模式(宝爷提议):客户端只剩 `servers`(默认 `nats://127.0.0.1:4222`)+ `autostart`(仅本机且无监听才拉起 bin/nats-server)+ `enabled`(false=纯 CLI)
**修订**:v0.5 —— 放弃 NATS(宝爷拍板 A 方案):对外服务改为 serve 进程内 FastAPI —— REST 管 query/export/meta/stats,WebSocket `/v1/stream` 管订阅推送(quote/state/news/flow/ev);`--no-http` 纯 CLI
**修订**:v0.6 —— 圆桌评审 45 条全采纳(6 席全票「修改后可实施」):新增 §7.6 事件循环隔离、SQL 函数默认拒绝、compaction 两阶段 .trash 协议、覆盖率排除白名单、验收数据两层、qlib 测试两层、news 表 DDL、复权口径、WS 统一时序、export 同步/异步归位
**修订**:v0.7 —— M1 实施校准 3 条(实施阶段才暴露、评审阶段发现不了的):DP-1 §11 锁判活从「三元一致」改为可实现的「PID 存活 + 三元全可读且一致」,后两项降为补强证据、取不到即接管(否则锁死库);DP-2 §14 白名单「CI 自己真起服」表述纠偏 —— CI 的真是**用 CLI 起真 serve + 真端口 curl**(用户面全覆盖),仅 `runtime.py` uvicorn/socket 段 pragma 豁免,真起服交付自检交每周 smoke;DP-3 §14 验收 fixture 表名笔误(`cn_stock_1d` 实为 `bars_1d`,视图名≠物理表名)。
**定位**:单目录自包含、三市场(A/美/港)覆盖的量化数据中台 —— `init` 建库回填,`serve` 常驻更新 + 每日质检 + 通过 FastAPI(REST+WebSocket)对外服务。
---
## 0. 结论摘要(TL;DR)
| 维度 | 决策 | 理由 |
| ---- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| 形态 | 单一 Python 包 `pyquantdata`,入口命令 `quantdata`;一切状态收敛在 `-d` 指定的 dbpath;dbpath/config.json 统一配置抓取数据时间、代理服务器、数据源要求 | 换机器 = 拷一个目录;与 pytdxdata/pywestockdata 同风格(uv + src-layout) |
| 存储 | **DuckDB**(参考数据、日K、公告研报、元数据)+ **Parquet 分区文件**(1分钟K线),查询层用统一视图联邦 | 1m 数据是几十亿行量级,Parquet 分区不可变文件最适合"每日增量追加";DuckDB 负责小表事务与秒查;两层用视图缝合,SQL 无感 |
| 写入模型 | **单写者**:只有 `serve`(或一次性 `update/backfill`)持有写锁;查询/导出一律只读 | DuckDB 单写多读 + Parquet 不可变文件,天然无并发写冲突 |
| 服务协议 | **FastAPI 进程内网关(REST + WebSocket)**:serve 单进程同起 uvicorn(默认 `127.0.0.1:8765`);`/v1/query` 等 REST 管请求-响应,`/v1/stream` WebSocket 管订阅推送;`--no-http` = 纯本地仅 CLI | 一条进程零外部依赖;开内网只改 host(+token) |
| 对外服务 | 三类:① REST `POST /v1/query` / `POST /v1/export` / `GET /v1/meta`;② WS `/v1/stream` 行情快照 + 自选股逐笔;③ WS 事件流 市场状态 / 分钟新闻 / 公告研报 / ETL进度 / 质检报告 | 对应你列的三种服务形式,全部走 HTTP 路径 + WS topic 分层 |
| 数据源 | **pytdxdata 为主**(三市场K线/行情/复权/期货/期权),**pywestockdata 为辅**(A股实时与财务交叉验证、公告分红),**美/港参考 yfinance**;长尾兜底移植 akshare 源码(摘抄其实现、改用 primp 发请求过反爬,**不安装 akshare 库**);日历/状态机吸收 market-event-driver;新闻采集脚本归入 dbpath/scripts/ | 不重造轮子,全部是已有项目 |
| 历史回填 | 支持 **seed 导入**:直接把 stock_prediction 已有的 A股 1m(2004 至今)搬进库,避免重复回填 22 年 | 手上有现成数据 |
| 容量 | 默认口径估算 数据 **300–400 GB** + 运行 buffer ≥200GB(预算口径 ~600GB,见 §3.4);起始年限已确认 cn=2004 / us=2020 / hk=2020 | 建库前先给用户看到磁盘预算 |
---
## 1. 目标、非目标、假设
### 1.1 目标(来自需求)
1. **初始化**:`quantdata init -d /xxx/dbpath/` —— 自动建目录结构、建元数据库、按配置回填各市场历史数据,断点可续。
2. **日常更新**:`quantdata serve -d /xxx/dbpath/` —— 常驻进程:盘中增量更新、收盘后日频任务、每日数据质量校验,并常驻对外服务。
3. **对外服务(HTTP + WebSocket)**:
- `query_sql`:执行 SQL 查询(请求/响应);
- `export`:导出 backtrader / qlib / pandas / polars / csv 等格式;
- **订阅**:股票实时行情、市场状态变化(开盘/收盘/午休等)、分钟级新闻推流。
4. **数据范围**:A股(指数、股票、期货、可转债、ETF/LOF、REITS、期权的证券信息、交易日历、1m K、日K、除权除息、公告、研报、申万行业、ST、停牌、涨跌停);美股、港股(指数、股票、期货、ETF/LOF、REITS 等证券信息、交易日历、1m K、日K)。
5. **对外服务协议**:默认 serve 进程内 FastAPI(REST + WebSocket),零外部依赖;NATS 方案已放弃(v0.5 拍板)。
### 1.2 非目标(明确边界,防止范围膨胀)
- ❌ 因子计算 / 特征工程 —— 归 factor-pipeline / vxdata,quantdata 只负责把干净的原始数据喂出去;
- ❌ 回测引擎 / 交易执行 —— export 成 backtrader/qlib 格式供那边用;
- ❌ 逐笔撮合级实时行情 —— 实时层是 **秒级快照 + 自选股 tick**,不是 Level-2;
- ❌ 多租户权限体系 —— v1 是单用户/内网工具,认证靠可选 `http.token`(默认空 = 内网免认证)。
### 1.3 评审已确认事项(2026-09-23 拍板)
| 事项 | 决策 |
|------|------|
| "每日对数据进行…" | ✅ **每日数据质量校验**(gap / OHLC / 涨跌停 / 复权对账 / 双源抽查 1%),见 §7.5 |
| 各市场起始年限 | ✅ **cn=2004、us=2020、hk=2020** |
| 美股可转债 / LOF 等无零售级数据源的品类 | ✅ **先放空,走可扩展结构**:结构预留、需要时写一个 `scripts/` 采集脚本即可接入(机制见 §4.2) |
| 研报 / 申万行业数据源 | ✅ **akshare 对应接口(研报 choices 等),摘抄源码 + primp 重写请求**,不安装 akshare |
| 实时行情精度 | ✅ **3 秒快照 + 自选 tick**,不做逐笔 |
| 对外服务协议 | ✅ **v0.5 改判:放弃 NATS** —— serve 进程内 FastAPI:REST 管 query/export,WS `/v1/stream` 管订阅;一条进程全包 |
| 部署目标 | ✅ **Linux 服务器长期常驻**(supervisord),Windows 仅开发用 |
| 跨市场 union 视图 | ✅ **加 `bars_1m_all`**(见 §3.3) |
---
## 2. 总体架构
```
┌────────────────────────────────────────────────┐
quantdata init │ 本机 / 服务器 │
quantdata serve │ │
quantdata query ──▶ CLI (typer+rich) │
quantdata export │ │
│ ┌───────────── 应用层(serve 常驻)───────────┐ │
│ │ Scheduler 调度器(任务=dbpath/scripts/*.py 每任务一脚本,META 声明触发时机) │ │
│ │ ├─ IntradayUpdater 盘中 1m/快照 增量 │ │
│ │ ├─ DailyJob 收盘后日频任务链 │ │
│ │ ├─ QualityChecker 每日质检 │ │
│ │ ├─ StateEngine 市场状态机(开盘/午休…) │ │
│ │ ├─ QuotePoller 实时行情轮询→推流 │ │
│ │ └─ NewsBridge 新闻采集→分钟窗口推流 │ │
│ └────────────────────────────────────────────┘ │
│ ┌────────── 服务网关(FastAPI 同进程)─────────┐ │
│ │ REST: /v1/query /v1/export /v1/meta /stats │ │
│ │ WS: /v1/stream (quote state news flow ev) │ │
│ │ --no-http 可关;Swagger 自带 /docs │ │
│ └────────────────────────────────────────────┘ │
│ ┌───────────── 存储层 ───────────────────────┐ │
│ │ catalog.duckdb 参考数据/日K/公告/元数据 │ │
│ │ data/**/*.parquet 1m K线(分区、不可变) │ │
│ │ exports/ logs/ tmp/ quantdata.lock │ │
│ └────────────────────────────────────────────┘ │
└───────────────────────┬────────────────────────┘
│ SourceAdapter 协议
┌───────────────────────┴────────────────────────┐
│ pytdxdata(主:三市场K线/行情/复权/期货/期权) │
│ pywestockdata(辅:A股实时/财务/公告/分红/交叉源) │
│ yfinance(美/港参考) 静态节假日表(日历兜底) │
│ akshare 兜底(摘抄源码+primp 请求,不装库) │
│ 新闻采集 = dbpath/scripts/fetch_news.py │
└────────────────────────────────────────────────┘
│
┌───────────────────────▼────────────────────────┐
│ 消费端:curl / 任意 HTTP 客户端 / WebSocket 订阅 │
│ (脚本、notebook、下游服务皆可直连 serve 端口) │
└────────────────────────────────────────────────┘
**分层原则**:
| 层 | 职责 | 关键约束 |
| ---- | --------------------------- | --------------------------------- |
| CLI | 命令解析、进度展示、本地直查 | 任何命令都可离线跑(`--no-http` 时服务层降级为无) |
| 应用层 | 调度、ETL、质检、状态机、推流 | 全部幂等:重复执行不产生重复数据;DuckDB/脚本走线程池(§7.6) |
| 服务网关 | FastAPI REST + WebSocket 协议实现 | 路径带版本号 `/v1`,WS 帧带 envelope |
| 存储层 | DuckDB + Parquet + 视图联邦 | 单写者、原子替换、checkpoint 可续 |
| 源适配层 | 统一 `SourceAdapter` 接口对接各数据源 | 限速、重试、录制回放 fixtures 供测试 |
---
## 3. 存储设计
### 3.1 dbpath 目录布局
```
/xxx/dbpath/
├── config.json # 库配置(init 生成,可改;JSON 格式)
├── catalog.duckdb # 元数据库:参考数据+日K+公告研报+checkpoint+jobs
├── data/ # 大数据:Parquet 分区(仅 1m K线)
│ ├── cn/
│ │ ├── stock/symbol=sh600000/year=2026/month=09/20260923.parquet # 当日段(新写)
│ │ │ .../month=09.parquet # 月度合并(compaction 后)
│ │ ├── index/… fut/… cbond/… etf/… reits/… opt/…
│ ├── us/…
│ └── hk/…
├── scripts/ # 抓取/更新任务脚本(每任务一文件,文件内 META 声明触发时机)
│ ├── update_bars_1d.py # 示例:日K日频更新
│ ├── update_bars_1m.py # 示例:1m 盘中增量
│ └── fetch_news.py # 示例:新闻采集(news-integration 逻辑迁入)
├── exports/ # export 任务输出(按 job_id 分目录)
├── logs/ # serve 日志(按天滚动,JSON lines)
├── tmp/ # 原子写中转(写完 os.replace 到位)
└── quantdata.lock # 单写者锁(PID + 启动时间)
```
**1m 写入策略(LSM 风格,兼顾"每日增量"与"文件数可控")**:
1. **盘中/每日增量**:每 symbol 每交易日写一个新段文件 `…/month=MM/YYYYMMDD.parquet` —— 不重写任何旧文件;
2. **月度 compaction**:每月 1 号把上月的日段合并成 `month=MM.parquet`(单 symbol 单月约 5–10k 行,合并成本毫秒级)——多文件切换走两阶段协议(见下);
3. **年度归并(可选开关)**:把 12 个月文件并成年文件,冷数据文件数从 `symbol×12×年数` 降到 `symbol×年数`。
> 1m 数据只追加新文件、不改旧文件 → 只读并发永远安全。**注意:compaction 是「写1个月段+移走12个日段」的多文件操作,`os.replace` 只保护单文件**(评审 P0),切换走两阶段协议:
> ① 月段在 tmp 合并 → `os.replace` **先入位**(此刻月段与残余日段并存);
> ② 日段 **rename 进 `.trash/` 子目录**(立即移出 glob 范围)→ **延迟 7 天再 unlink**(已枚举打开的读句柄不致 ENOENT);
> ③ 查询撞上枚举竞态(TOCTOU IO 错误)→ **自动重试一次**即恢复;compaction 后行数守恒质检照跑(§7.5),另监控「compaction 窗口内查询失败计数」。
### 3.2 为什么是 DuckDB + Parquet,而不是单选一个
| 方案 | 优点 | 放弃的原因 |
| ------------------------ | -------------------------------------------------------------------------- | --------------------------------------------------------- |
| 全 DuckDB 单文件 | 最简单、事务完整 | 1m 全历史约 50 亿行/百 GB 级单文件,备份=整文件复制;"每日追加"要反复重写大文件;一旦损坏爆炸半径大 |
| 全 Parquet + 无引擎 | 零依赖 | 参考数据的 upsert、公告去重、checkpoint 事务都要自己造 |
| ClickHouse | 超强聚合 | 多一个常驻服务,违背"一个目录自包含";factor-pipeline 已覆盖 ClickHouse 场景 |
| **DuckDB + Parquet(选定)** | 小表事务 + 大文件追加各取所长;DuckDB 原生 `read_parquet` 联邦查询,视图缝合后 SQL 无感;与 vxdata 技术栈一致 | — |
### 3.3 联邦视图(SQL 透明层)
```sql
-- catalog.duckdb 内注册的典型视图(Hive 分区自动识别)
CREATE OR REPLACE VIEW cn_stock_1m AS
SELECT symbol, ts, date, open, high, low, close, volume, amount
FROM read_parquet('data/cn/stock/**/*.parquet', hive_partitioning = true);
CREATE OR REPLACE VIEW cn_stock_1d AS -- 日K直接物理表在 DuckDB 内
SELECT * FROM bars_1d WHERE market = 'cn' AND category = 'stock';
-- 跨层查询示例(query_sql 直接支持)
SELECT d.date, d.close, m.industry_l1
FROM cn_stock_1d d
JOIN securities s USING (symbol)
JOIN sw_industry m USING (symbol)
WHERE d.symbol = 'sh600000' AND d.date >= '2026-01-01';
-- 跨市场统一视图(评审已确认):带 market 列的 union,偷懒查询用
-- 三支一律显式列名(禁 *):float 列错位不报错,只可靠列集恒等测试拦(评审 P1)
CREATE OR REPLACE VIEW bars_1m_all AS
SELECT 'cn' AS market, symbol, ts, date, open, high, low, close, volume, amount FROM cn_stock_1m
UNION ALL SELECT 'us', symbol, ts, date, open, high, low, close, volume, amount FROM us_stock_1m
UNION ALL SELECT 'hk', symbol, ts, date, open, high, low, close, volume, amount FROM hk_stock_1m;
-- 1m 复权 = 查询期计算(bars_1m 不存因子,口径见 §4.3)
SELECT b.ts, b.close * d.adj_factor AS close_hfq
FROM cn_stock_1m b JOIN bars_1d d USING (symbol, date)
WHERE b.symbol = 'sh600000';
```
> 1m 视图按市场×品类共约 20 个,另加跨市场 union 视图 `bars_1m_all`(已确认);DuckDB 对 `symbol/year/month` 分区做谓词下推,单股多年查询只读命中文件。跨市场全扫时建议带 date 过滤,剪枝交给 DuckDB。
> **视图 schema 演进(评审 P1)**:全部联邦视图 DDL 纳入 `schema_migrations` 版本化(改表必同步改视图);parquet 加列 = 新列只在新段出现、历史段读为 NULL,视图 `COALESCE` 兜底,需要真回填时走一次性 `backfill --rewrite-schema`(按需启用)。
> **union 列对齐**:`bars_1m_all` 三支显式列名(禁 `*`),集成测试断言三市场视图**列集/列序恒等**。
### 3.4 容量估算(init 前提示磁盘预算)
| 数据 | 估算口径 | 行数量级 | 体积(zstd parquet / duckdb) |
| ------------------- | -------------------------------------------------- | ------ | ------------------------- |
| A股 1m | ~5000 股 × 240 行 × 243 日 × 22 年(2004→今,均摊约 60% 上市率) | ~45 亿行 | **150–200 GB** |
| 美股 1m | ~4500 股 × 390 行 × 252 日 × 默认 6 年 | ~27 亿行 | ~90 GB |
| 港股 1m | ~2600 股 × 330 行 × 245 日 × 默认 6 年 | ~12 亿行 | ~45 GB |
| 三市场日K + 参考数据 + 公告研报 | — | <1 亿行 | <10 GB |
| **合计** | | | **~300–400 GB**(默认口径) |
- 各市场 `history_from` **已确认:cn=2004、us=2020、hk=2020**(默认 1m 与日K 同起点);日K 可用 `history_from_bars_1d` **独立放宽**(美/港日K 放到 2010 仅 +数 GB,长周期回测够用),历史随时 `backfill --from` 往前增量补;
- **运行放大系数(评审 P1)**:上表 = 数据终态;另计 DuckDB WAL/日频重写临时空间、compaction 当刻 tmp 2× 峰值、`exports/`(qlib 全量 float32 可达 ~100GB)、备份副本 —— 合计 **+≥200GB buffer**;
- `init --estimate` 只算不写,按 **终态 + buffer ≈ 600GB** 口径报预算;`export.out_dir` 可指到独立盘。
---
## 4. 数据模型
### 4.1 catalog.duckdb 核心表(DDL 摘要)
```sql
-- 参考数据 --------------------------------------------------------------
exchanges (exchange_code PK, name, market, timezone, session_json) -- 交易时段规则
securities (market, symbol, name, category, exchange, list_date, delist_date,
currency, lot_size, underlying, strike, maturity, ... , PK(market, symbol))
-- category: index/stock/future/cbond/etf/lof/reits/option
calendar (market, trade_date, is_open, note, PK(market, trade_date))
corp_actions (market, symbol, ex_date, type, ratio, cash_div, ... , PK(...)) -- 除权除息
sw_industry (version, symbol, l1, l2, l3, effective_from, effective_to) -- 申万SCD2:官方发新版/追溯修订→开新version,effective_from=官方生效日
stock_status (symbol, date, is_st, st_reason, is_suspended,
limit_up, limit_down, pct_limit, source, PK(symbol, date)) -- ST/停牌/涨跌停 合表
futures_meta (symbol, contract, multiplier, expiry, daily_limit_rule, ...) -- 期货合约要素
-- 行情(日K;1m 在 parquet)------------------------------------------------
bars_1d (market, category, symbol, date, open, high, low, close,
volume, amount, turnover, adj_factor, PK(market, category, symbol, date))
-- 信息流 ------------------------------------------------------------------
announcements (id PK, symbol, title, category, publish_ts, url, source, hash)
reports (id PK, symbol, org, analyst, rating, title, publish_ts, url, source)
news (id PK, ts, source, market, symbols_json, level, title, url, hash) -- 分钟新闻(NewsBridge 落库;断线补偿游标)
-- 运行时元数据 ------------------------------------------------------------
etl_checkpoint (dataset, market, scope, watermark, rows, status, updated_at, PK(前三个))
export_jobs (job_id PK, spec_json, fmt, path, rows, bytes, state, created_at, finished_at)
quality_reports (date, market, check_name, result, detail_json, PK(date, market, check_name))
schema_migrations(version PK, applied_at)
```
### 4.2 三市场 × 数据范围矩阵(✅ 有 / ⚠️ 有条件 / ❌ 无)
| 数据 | A股 | 美股 | 港股 | 主数据源 |
| ------------------------------- | :------------: | :-------------------------: | :---------------: | ----------------------------------------- |
| 证券信息(指数/股票/期货/可转债/ETF/REITS/期权) | ✅ 全品类 | ⚠️ 无美债转、无 LOF、期权/期货看 TDX 覆盖 | ⚠️ 可转债/期权看 TDX 覆盖 | pytdxdata(+westock 补 A股字段) |
| 交易日历 + 交易时段 | ✅ | ✅ | ✅ | 静态节假日 + TDX 交易日 + exchange 表 |
| 1分钟K线 | ✅ | ✅ | ✅ | pytdxdata(seed:stock_prediction 现成 A股 1m) |
| 日K线 | ✅ | ✅ | ✅ | pytdxdata + pywestockdata 交叉验证 |
| 除权除息 | ✅ | ⚠️ 复权因子走 TDX | ⚠️ 同左 | TDX gbbq / westock 分红 |
| 公告信息 | ✅ | ⚠️ 覆盖面待验证 | ⚠️ 同左 | pywestockdata(东财) |
| 研报信息 | ✅ akshare 摘抄 | ⏸ 暂缓(可扩展) | ⏸ 暂缓(可扩展) | akshare 研报接口(choices 等)源码移植 + primp |
| 申万行业分类 | ✅(A股专属) | ❌ | ❌ | akshare 申万行业接口源码移植 + primp |
| ST / 停牌 / 涨跌停 | ✅ 日状态合表 | ❌(无 ST 制度) | ⚠️ 停牌✅ | westock 状态 + 规则推导(10/20/30% 分板块) |
| 实时行情 | ✅ 秒级快照 | ✅ | ✅ | pytdxdata quotes / westock 全市场 <500ms |
| 市场状态事件 | ✅ | ✅ | ✅ | StateEngine 本地推导(日历+时钟,确定性) |
| 分钟新闻 | ✅ | ✅(global feed) | ✅ | news-integration → NewsBridge |
> **品类可扩展机制(已确认)**:⏸ 暂缓品类 = 结构预留、先放空,绝不塞假数据。接入一个新品类只需三步 —— ①`config.json` 的 categories 加一项 → ②写一个 `scripts/` 采集脚本(META 声明)→ ③注册一条 `CREATE VIEW`,核心代码零改动。
### 4.3 统一 K 线 schema
```
symbol: str # 规范代码:cn 用 sh600000/sz000001/bj430047,us 用 AAPL,hk 用 00700(与 pytdxdata 一致)
ts: datetime64[ns, UTC] # 1m 用 UTC 毫秒存 + exchange 本地日期做分区键(美/港跨时区不乱)
date: date32 # 交易所本地交易日(分区、日K主键)
open/high/low/close: float64
volume: float64 # A股=股/张,期货=手(在 futures_meta 有乘数)
amount: float64 # 成交额(元)
```
**时间与复权口径(全格式统一约定,评审 P1)**:
- 存储一律 UTC;REST/WS JSON 时间字段一律 **ISO8601 带 `Z`**,状态类 payload 另带 `session_tz`(如 `"Asia/Shanghai"`)标明交易所本地;
- 导出(feather/csv)的 datetime 列 = **tz-naive 交易所本地时间**(backtrader/qlib 惯例);
- **bars_1m / bars_1d 一律存不复权原始价,复权是查询期计算**;source of truth = `corp_actions`(TDX gbbq / westock 分红只是输入,对账以 corp_actions 重算为准);1m 取因子 `JOIN bars_1d USING (symbol, date)`(视图示例见 §3.3),export 的 fq 参数在导出期施加;**除权日无需重算历史 bars**(存的就是不复权价);因子被源站修正 → 质检「复权连续性」告警并提示下游重导出。
---
## 5. 数据源适配层
### 5.1 SourceAdapter 协议
```python
class SourceAdapter(Protocol):
name: str
capabilities: set[str] # {"bars_1d","bars_1m","realtime","announcements",...}
async def fetch_securities(self, market: str) -> list[Security]: ...
async def fetch_bars(self, market, category, symbol, freq, start, end) -> list[Bar]: ...
async def fetch_realtime(self, symbols: list[str]) -> list[Quote]: ...
async def fetch_calendar(self, market, year: int) -> list[CalendarDay]: ...
# 其余能力按 capabilities 声明,调度器只调度声明过的能力
```
### 5.2 源分工与交叉验证
| 能力 | 主源 | 备源(抽查 1% 对账,不一致记 quality_reports) |
| ------------- | ----------------------------------- | --------------------------------- |
| 三市场 K 线/复权/日历 | pytdxdata | pywestockdata(仅 A股日K) |
| A股实时快照 | pytdxdata quotes | pywestockdata(全市场 <500ms,作为快照源更快) |
| A股财务/分红/公告 | pywestockdata | — |
| 期货要素/行情 | pytdxdata | yfinance(参考对账) |
| 新闻 | news-integration(RSS 统一采集器) | — |
| 节假日 | 静态 holidays(market-event-driver 吸收) | TDX 交易日回调校验 |
| 研报(A股) | akshare 研报接口(choices 等,摘抄源码+primp) | — |
| 申万行业 | akshare 申万行业接口(摘抄源码+primp) | — |
| 长尾兜底 | akshare 源码移植(摘抄实现、primp 发请求,不安装 akshare) | pytdxdata/pywestockdata 优先 |
### 5.3 工程规则
- **限速**:每源独立令牌桶(配置驱动),被限流指数退避重试;
- **断点**:所有 fetch→write 以 `(dataset, market, scope)` 为粒度写 `etl_checkpoint`,重启续跑;
- **可测试**:适配层带录制模式(fixtures 标注录制日期),单测/集成测试离线回放;nightly record job 打真网重录 diff —— 生命周期规则见 §14;
- **连接级容错**:TDX 断连/坏节点的重连与多服务器切换由 pytdxdata **内建**,适配层只管限速与指数退避(故障注入测试见 §14);
- **代理**:代理服务器在 config.json 配置(全局 + per-source 覆盖),akshare 移植源的请求一律走 primp(与 pywestockdata 同款反爬栈);
- **合规**:只用公开接口与已有本地数据,遵守源站频率约定;**不安装 akshare 库**,只摘抄其实现逻辑。
---
## 6. CLI 设计
```bash
quantdata init -d /xxx/dbpath/ [--markets cn,us,hk] [--years-cn 22 --years-us 6 --years-hk 6]
[--seed /path/to/old_1m] [--estimate] [--skip-history]
quantdata serve -d /xxx/dbpath/ [--host 127.0.0.1] [--port 8765] [--no-http] [--insecure] # 恒前台常驻,无 daemon 模式
quantdata update -d /xxx/dbpath/ [--dataset bars_1d] [--date 2026-09-22] # 单次更新,cron 兜底
quantdata backfill -d /xxx/dbpath/ --dataset bars_1m --market cn [--from 2004] [--resume]
quantdata query -d /xxx/dbpath/ "SELECT ..." [--fmt table|csv|json|parquet] [-o out] # 本地直查,不开服务也可用
quantdata export -d /xxx/dbpath/ --fmt qlib|backtrader|csv|parquet --sql "..." -o out/
quantdata status -d /xxx/dbpath/ # 水位、锁、HTTP 服务、最近质检、磁盘占用
quantdata doctor -d /xxx/dbpath/ # 手动触发全量质检 + 修复建议
```
```python
# Python 客户端标准路径(pandas 用户,评审 P1 补齐)
import httpx, base64 as b64, pyarrow as pa
r = httpx.post("http://127.0.0.1:8765/v1/query", json={
"sql": "SELECT date, close FROM cn_stock_1d WHERE symbol=? ORDER BY date DESC LIMIT 5",
"params": ["sh600000"], "fmt": "arrow"}).json()
tbl = pa.ipc.open_stream(pa.BufferReader(b64.b64decode(r["b64_arrow"]))).read_all()
df = tbl.to_pandas() # dtypes 可用 r["dtypes"] 校验
# WS 订阅:连上即收初帧(state + snapshot),断线重连=重新收初帧;新闻补偿走 query 游标
# import websockets / httpx-ws:ws://127.0.0.1:8765/v1/stream?topics=quote.snapshot,state,news.minute&market=cn
```
| 命令 | 行为要点 |
| ----------------- | --------------------------------------------------------------------------------------------------------------------- |
| `init` | ①建目录+config.json ②建 DuckDB schema(schema_migrations 管版本)③拉参考数据 ④回填历史(有 `--seed` 先导入再增量补齐)⑤自检输出报告。**幂等**:重跑=续跑,不破坏已有数据 |
| `serve` | 拿 `quantdata.lock`(拿不到→报已有实例 PID 后退出)→ 起调度器 → 起 FastAPI 网关(uvicorn 挂同一事件循环;**bind 失败=打印占用者 PID 后非零退出**,交 supervisord 退避重试)→ 前台常驻(Linux 交 supervisord,恒前台) |
| `query`/`export` | 本地直连只读 DuckDB,不开服务也能用;与 serve 并存靠"单写多读"(§11) |
| `status`/`doctor` | 运维入口,输出全部是结构化 JSON(`--json`)便于脚本化 |
全局约定:`-d` 可用环境变量 `QUANTDATA_HOME` 兜底;所有命令支持 `--json` 输出;进度条用 rich。
---
## 7. serve 常驻设计
### 7.1 组件与生命周期
```
serve 启动
├─ 1. 获取写锁 quantdata.lock(失败即退出;判活 = PID 存活且 start time/boot_id 可读并一致,任一取不到→陈旧锁接管,见 §11)
├─ 2. 打开 catalog.duckdb(读写)+ 校验 schema 版本(自动跑 migration;schema 版本 > 代码已知最高版 → 报错退出)
├─ 3. 启动 Scheduler(asyncio 单进程多任务;DuckDB 与 scripts 一律走线程池,见 §7.6)
├─ 4. 起服务网关:--no-http 跳过;否则 Server.serve() 挂同一事件循环起 uvicorn(默认 127.0.0.1:8765)
│ 启动校验:监听地址非 loopback 且 http.token 为空 → 拒绝启动(除非显式 --insecure,打醒目告警)
│ bind 失败(端口占用)→ 打印占用者 PID 后非零退出
├─ 5. 循环运行直到 SIGTERM:优雅关闭 = 停接新任务 → 等当前任务落 checkpoint(总预算 30s,超时主动释放锁再退出)
│ → 关 HTTP(断开 WS)→ 释放锁;supervisord 侧 stopwaitsecs=60 兜底
└─ 任意组件崩溃 ≠ 进程退出:内部 supervisor 拉起 + WS 广播 ev.update fail + 日志告警;
同一组件连续 5 次拉起失败 → 进程自杀非零退出(把故障暴露给外部监控,不许闷声吞)
```
### 7.2 调度(显式绑定 Asia/Shanghai,不读系统时区)
> **任务脚本化**:每个抓取/更新任务是 `dbpath/scripts/` 下的独立 Python 文件(一个任务一个脚本),文件内声明 `META = {"cron": "...", "dataset": "...", "market": "..."}`;Scheduler 启动时扫描 scripts/ 并按 META 触发,支持热加载(改脚本不用重启 serve)。用户可自行增删脚本扩展任务,无需改核心代码。config.json 的 `schedule` 段配置默认抓取时间,脚本 META 可覆盖。
>
> **时区与时钟(评审 P1)**:调度时区显式绑定 `schedule.timezone`(默认 `Asia/Shanghai`,**不读系统 TZ** —— 容器默认 UTC 也不会让日频链移位);每个 cron 槽记录最近触发时间戳,时钟回拨后跳过重复槽并在 `ev.update` 告警(幂等 §7.3 兜数据正确性,这里兜「跑没跑」的可观测)。
| 任务 | 触发 | 内容 |
| ------------------- | ------------------------------------------------------ | --------------------------------------------------------------------------- |
| 盘中 1m 增量 | 各市场交易时段内每 60–120s | 拉当段 1m → 写日段文件 → 更新 checkpoint |
| 快照推流 QuotePoller | 交易时段每 3s(cn 全市场;us/hk 按 watchlist+指数) | 归一化 → WS `topic=quote.snapshot`(market 字段区分);watchlist 另发 `topic=quote.tick` |
| 状态机 StateEngine | 每秒 tick(按 exchange.session_json 确定性推导) | 状态迁移时向 WS 推一次 `topic=state`(不刷屏;重连对齐时序统一见 §8.2 客户端模式) |
| 收盘日频链(A股) | 15:05 起:日K定稿 → 复权因子 → ST/停牌/涨跌停 → 证券主数据 → 行业 → 公告/研报增量 | 每步写 checkpoint,失败从该步续 |
| 收盘日频链(港股) | 16:10 起同上 | |
| 收盘日频链(美股) | 次日 04:30(16:00 ET = 04:00/05:00 CST 次日,含夏令时表) | |
| 质量校验 QualityChecker | 每日各市场收盘链完成后 | 见 §7.5,产出 quality_reports + WS `topic=ev.quality` 事件 |
| 月度 compaction | 每月 1 号 07:00 | 合并上月 1m 日段(§3.1) |
| 新闻 NewsBridge | 常驻 collector + 每分钟窗口 | 见 §10.3 |
### 7.3 日频任务链的幂等模式
每个任务定义为 `step(dataset, market, date)`:执行 = 以 `(market, date)` 为粒度 **整分区替换**(DuckDB DELETE+INSERT 同事务 / Parquet 重写 tmp 后 os.replace)。重跑任意次数结果一致 → 调度重试、手工 `update --date` 重放都安全。
**盘中增量是另一条路径(评审 P1)**:交易时段内每 60–120s 只 `os.replace` **当日日段文件**,不碰历史分区(天然幂等);「整分区 DELETE+重写」仅用于日频链与手工重放。各 symbol 当日段替换非原子 —— 读端短暂见「部分股新、部分股旧」可接受(旧段 = 略早快照、单调变新),跨股严格同刻不在 v1 承诺内。
### 7.4 断点与水位
`etl_checkpoint.watermark` 语义:`bars_1m` 存"最后完整交易日"(按日为粒度,不做分钟级水位——K线按日整段写,日粒度幂等最简单);公告/研报存 `publish_ts` 游标 + **content hash**:主键保持 `id`,改稿走 `INSERT ... ON CONFLICT(id) DO UPDATE WHERE excluded.hash <> hash`(同 id 改稿可进库);hash 只做内容比对,不与主键语义混用。
### 7.5 每日质检清单(假设 = 需求中截断的"每日对数据进行…")
| 检查 | 逻辑 | 失败动作 |
| -------- | --------------------------------------------- | ----------------------------------- |
| 交易日 gap | 日历声明开盘但该日 0 行 | `ev.quality` critical + 自动重拉一次 |
| OHLC 合理性 | H≥max(O,C)、L≤min(O,C)、L≥0、volume≥0 | 隔离异常行到 quarantine 表,记 detail |
| 涨跌停越界 | close 相对昨收超出 stock_status 声明的 limit(新股/除权日豁免) | warning + 抽样人工 |
| 复权连续性 | adj_factor 单调性/跳变与 corp_actions 对账 | critical(错复权是最隐蔽的脏数据) |
| 行数环比 | 当日行数 vs 前 5 日中位数偏离 >30% | warning |
| 双源抽查 | 随机 1% symbol 的日K收盘价 tdx vs westock | 不一致记 report,连续 3 天同标的不一致升级 critical |
| 文件完整性 | compaction 后行数守恒、无孤立 tmp | 自动修复(重合并) |
### 7.6 执行模型(事件循环隔离 —— 评审 P0)
单进程里跑着调度器 + FastAPI + 用户脚本,**事件循环是稀缺资源**,硬约束三条:
1. **DuckDB 调用一律出循环**:query/export/ETL 的 DuckDB 执行全部走专用线程池(`asyncio.to_thread` / 独立 executor),事件循环内只做编排与分发;查询超时 = 线程内 `connection.interrupt()` 真中断(asyncio `wait_for` 只放弃等待,同步调用仍会烧 CPU —— 由此解决);
2. **scripts 任务宿主 = 线程池**:`scripts/*.py` 是热加载的用户外部代码,同步阻塞不可接受 —— Scheduler 一律丢线程池执行,绝不作 loop 内协程直跑;
3. **uvicorn 挂同一循环**:用 `Server(config).serve()` 协程方式挂入调度器所在 event loop(不用 `uvicorn.run()` 自建循环),WS 推送、调度 tick、状态机共用一个 loop 且全部非阻塞。
---
## 8. 对外服务协议(FastAPI:REST + WebSocket)
### 8.1 服务形态(serve 进程内,零外部依赖)
| 配置 / 参数 | 默认 | 行为 |
| ---- | ---- | ---- |
| `--host` / `http.host` | `127.0.0.1` | 监听地址:默认仅本机(安全默认);`0.0.0.0` 开放内网访问 |
| `--port` / `http.port` | `8765` | 监听端口 |
| `http.enabled`(CLI 开关 `--no-http`) | `true` | 两语义拆清:配置默认 true(起网关);`--no-http` 的作用 = 把 enabled 置 false(flag 本身默认不触发)。false = 纯 CLI 批处理,不起网关(本地 query/export 不受影响) |
| `http.token` | 空 = 不校验 | 非空时 REST 带 `Authorization: Bearer <token>`;WS **优先握手 Header 同款**,`?token=` 仅兼容降级(会进日志);**非 loopback 且 token 空 → 拒绝启动**(除非 `--insecure`,见 §8.4) |
> **实现分工(相对原 NATS 方案的变化)**:
> - FastAPI + uvicorn 是 pyquantdata 的**普通 pip 依赖**,随包安装 —— 无二进制、无子进程、无外部服务,`bin/` 目录整个取消;
> - REST 与 WebSocket 挂在同一个 app 上,共享依赖注入(只读 DuckDB 连接池、进程内事件总线);
> - Swagger UI 自带 `/docs`、OpenAPI 在 `/openapi.json` —— 外部接入零文档成本(NATS 方案要自己维护 subject 文档);
> - **订阅语义**:WS 连接即订阅(`topics` 过滤);推送发生在**同进程内** —— Scheduler/QuotePoller 产出事件 → asyncio 广播到各 WS 连接,不经任何外部 broker;
> - `dbpath/scripts/` 只放抓取/更新任务脚本,与服务网关无关;
> - **背压与扇出(评审 P1)**:每 WS 连接一条**有界队列(`ws_queue_len`=256 帧)** —— 快照类溢出丢最旧保最新、事件类超限直接断开该连接;全局连接数上限 `max_ws_conns`=64;全市场快照帧**序列化一次、N 连接共享同一 bytes**(禁止 per-connection 重复 `json.dumps`);队列深度纳入 §13 指标告警。
### 8.2 REST 端点 + WebSocket Topic 总表(前缀 `/v1`)
**REST(请求-响应)**
| 端点 | 方法 | 用途 |
| ---- | ---- | ---- |
| `/v1/query` | POST | **query_sql**:body `{sql, params, fmt: arrow\|json, max_rows, timeout_ms}` → `{columns, dtypes, b64_arrow 或 rows, row_count, elapsed_ms, truncated}`;**fmt=arrow = Arrow IPC streaming format**(JSON 内 base64,解码路径见附录 A) |
| `/v1/export` | POST | **export**:body `{fmt, sql\|dataset spec, opts, sync?}` → 小导出(<100MB 或 `sync=true`)**直接回文件流**;大导出 → `{job_id, state: queued\|running\|done\|failed, path, rows, bytes}` |
| `/v1/export/{job_id}` | GET | 导出任务状态/结果;下载 `GET /v1/export/{job_id}/file`(长任务进度同时走 WS `ev.export`) |
| `/v1/meta` | GET | 字典查询:日历、证券列表、view 列结构(**每 view 附 row_count、min/max date、最新分区、3 个样例 symbol**)、库版本 |
| `/v1/stats` | GET | 水位、磁盘、任务队列、质检摘要(status 命令的远程版) |
| `/v1/state/{market}` | GET | 当前市场状态(**REST-only 客户端**的对齐入口;WS 客户端收初帧即可) |
| `/healthz` | GET | Liveness:进程活着即 200(supervisord / 容器探针) |
| `/v1/ready` | GET | Readiness:写锁 / schema 版本 / 调度器 / 磁盘余量,异常 503 |
**WebSocket `/v1/stream?topics=…&market=cn&symbols=sh600000`**
| Topic | 节奏 | 用途 |
| ---- | ---- | ---- |
| `quote.snapshot` | 每 3s | 全市场快照批 `{ts, n, rows:[[sym,price,pct,vol,…列序号表]]}`(列字典在 `/v1/meta`,批消息不重复带列名) |
| `quote.tick` | 1s | 自选股逐笔/高频(`symbols=` 参数指定,服务端 watchlist 同步维护) |
| `state` | 迁移时 | 市场状态迁移 `{state, ts, next_at, reason}`;状态集见 §10.2 |
| `news.minute` | 每 60s | 分钟新闻批 `{window_start, items:[{id, ts, source, market, symbols, level, title, url}], count}` |
| `flow.announce` / `flow.report` | 增量 | 公告/研报增量(结构同新闻单条) |
| `ev.update` | 事件 | ETL 进度/完成/失败 `{dataset, step, date, rows, state}` |
| `ev.quality` | 每日 | 质检结果 `{date, market, pass, fails:[…]}` |
| `ev.export` | 事件 | 导出任务进度 `{job_id, state, rows, bytes}` |
**Envelope 统一首部(WS 帧)**:`{v:1, msg_id, ts, producer:"quantdata/0.1", topic, payload…}` —— 与日志事件同构;REST 响应不套 envelope,直接回 payload。**ts 一律 ISO8601 UTC(带 Z)**,状态类 payload 另带 `session_tz`。
> **客户端模式(统一时序 —— 全文唯一定义,其它章节引用本段)**:
> ① WS 一连上,服务端**必发初帧** = 当前 `state` + `quote.snapshot`(REST-only 客户端才用 `GET /v1/state/{market}` 对齐)→ 之后才是增量;
> ② 断线客户端自动重连,**重连即重新收初帧**,无需手动 GET;
> ③ **新闻/公告类 topic 断线期间不重放** —— 补偿走 `/v1/query` 按 ts 游标(`SELECT * FROM news WHERE ts > ? ORDER BY ts`)。重连三步 = 收初帧 → 按需 query 补偿 → 收流。
### 8.3 query_sql 安全约束(对外开 SQL 必须有闸)
1. **只读 + 断网**:DuckDB `read_only=true`(serve 写连接与查询连接分离);`SET autoinstall_known_extensions=false, autoload_known_extensions=false`(堵 httpfs 自动加载出站);
2. **语句白名单(sqlglot)**:**fail-closed**(解析失败一律拒绝)、显式 `dialect="duckdb"`、按 **AST 根节点**判定(非字符串前缀)、`parse_all` 长度必须 =1;拒绝 ATTACH/COPY/PRAGMA/多语句/DDL/DML;sqlglot 进 lock **pin 版本**,升级须过 SQL 闸回归测试(绕过样例:分号多语句、CTE 套 INSERT、EXPLAIN 变体、注释混淆 —— 全部入单测);
3. **函数/表函数白名单 —— 默认拒绝、显式放行(评审 P0)**:默认只放行纯计算函数 + 库内已注册视图;**显式拒绝 `read_csv` / `read_parquet` / `*_scan` / `glob` 等文件与网络表函数**(否则 `SELECT read_csv('/etc/passwd')` = 任意文件读、`read_csv('http://169.254.169.254/…')` = SSRF);`sql.allow_functions` 语义 = **额外放行清单**(不是「清空即全放行」的总开关);
4. **结果上限**:默认 `max_rows=1,000,000`、Arrow 结果 ≤64MB,超限报错并提示改走 `export`;
5. **超时与并发闸**:超时默认 30s,查询在**线程池**执行、到点 `connection.interrupt()` 真中断(§7.6);全局查询信号量默认 4(超出排队,等 >5s 返 429),查询连接设 `memory_limit` —— 查询风暴不许饿死调度器;
6. 防御参数:`SET max_expression_depth` 等预设。
### 8.4 认证
- 默认只监听 `127.0.0.1`:本机可信,不设认证;
- **启动强制校验(fail-fast)**:监听地址非 `127.0.0.1/::1` 且 `http.token` 为空 → **拒绝启动**;确要裸奔须显式 `--insecure`,打醒目告警日志 —— 文字约定不算数(评审 P1);
- **凭证传递**:REST 用 `Authorization: Bearer`;WS 优先握手 Header 同款,`?token=` 仅兼容降级;**日志对 token 统一脱敏**(只留前 4 位,uvicorn access log 同样处理,入测试断言);
- WS 与 REST **共用同一鉴权中间件**(含 `ev.*` topic,不给 WS 开旁路);
- v1 不做多租户与细粒度权限(见 §1.2 非目标)。
---
## 9. 导出格式设计
| 格式 | 产物 | 细节 |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `csv` | `exports/{job}/XXX.csv` | 按 symbol 分文件或单文件可选;ISO 日期、UTF-8 |
| `parquet` | 单文件或按 symbol 分区目录 | 默认输出,qlib/backtrader 之外的一切下游首选 |
| `pandas` | **不属于 export** —— 归 `/v1/query?fmt=arrow` 消费端(b64_arrow → Arrow → DataFrame,10 行示例见附录 A) | 本地 CLI `query --fmt pandas` 同理;**export 只管落盘格式**(csv/parquet/qlib/backtrader) |
| `polars` | 同 pandas(Arrow streaming 直吃) | 列类型映射在 meta 公布 |
| `backtrader` | `exports/{job}/feather/{symbol}.feather`(+ 可选 csv)+ `loader.py` | 用 `bt.feathers.GenericPandasData` 可直接吃的列(datetime/open/…/volume/openinterest,volume 补 0);loader 提供 `load_feeds(spec) -> list[bt.feeds]`;复权可选(fq=qfq/hfq/none);1m feed 显式 `timeframe=Minutes`、`fill_missing`,datetime 列 tz-naive 交易所本地(§4.3 约定) |
| `qlib` | 标准 qlib 数据目录:`calendars/`(day.bin, minute.bin, float32)、`instruments/*.txt`、`features/{market}/{symbol}/{freq}/{field}.bin`(float32 序列) | **实现方式=自写 dump_bin 兼容写入器(numpy tofile),运行时不依赖安装 qlib**;测试两层(评审 P0):①核心 = 按 dump_bin 布局**字节级/数值级读回断言**(CI 必绿、不装 qlib);②`qlib` extra **可选集成 job**(装 qlib 真跑 `qlib.init()`,单独标记不阻塞主链) |
**Export 任务流**:POST /v1/export 进来 → 校验 spec → 写 `export_jobs` → **worker = 独立线程池(默认 2 并发 + 排队上限 8;只读连接从池独占获取,让路日频链)** → 进度走 WS `topic=ev.export` + `GET /v1/export/{job_id}` 轮询 → 完成回 path;**小导出(<100MB 或 sync=true)直接回文件流不建 job**。job 结果按 spec hash 缓存 24h,重复导出直接回缓存路径。
**路径安全(评审 P1)**:输出根**恒为 `exports/{job_id}/`**(job_id 服务端生成);请求带来的名称字段(symbol/目录段)白名单字符过滤 + `resolve()` 后必须仍在 exports/ 前缀内;`opts` 为显式字段枚举,**禁止自由 path 键** —— 杜绝 `../` 穿出 dbpath 再经 `/file` 回读。
---
## 10. 实时与推流设计
### 10.1 行情 QuotePoller
- **源**:cn 全市场快照 pywestockdata(<500ms 拉全量)或 pytdxdata quotes;us/hk 走 pytdxdata;
- **节奏**:快照 3s 一批;watchlist(WS 连接参数 `symbols=` 指定,默认指数+自选)1s tick;
- **归一化**:各源字段映射到统一列字典(§8.2),消息体只发列序号数组省带宽;
- **状态**:非交易时段自动停poll(状态机驱动),WS 断线由客户端自动重连,**重连即收服务端初帧(state + snapshot)**——统一时序见 §8.2 客户端模式。
### 10.2 市场状态机 StateEngine
```
状态集(每市场一套):
CLOSED → PRE_OPEN_AUCTION → OPEN → LUNCH_BREAK → OPEN → CLOSED
(A股 09:15-09:25 集合竞价;港股 09:00-09:30;美股无午休、有盘后 AH 可扩展)
驱动:exchange.session_json(时段规则) + calendar(节假日) + 本地时钟 —— 纯本地确定性推导,
不依赖任何上游"开市通知",断网也准;夏令时用 zoneinfo 按年表算。
迁移才推消息;WS 客户端收初帧即得当前态,REST-only 客户端用 `GET /v1/state/{market}`(时序统一见 §8.2)。
```
### 10.3 分钟新闻 NewsBridge
```
news-integration collectors(RSS 等)→ 归一化(统一 NewsItem schema + hash 去重)
→ 60s 滚动窗口攒批 → WS `topic=news.minute`(一帧一批,不逐条发)
→ 同步落库 news 表(§4.1 DDL;断线补偿 = /v1/query 按 ts 游标补齐)
过滤:level(important/normal)、market 关联(关键词→symbol 映射表)、黑名单源。
```
---
## 11. 并发、锁与一致性
| 问题 | 方案 |
| ---------------- | ------------------------------------------------------------------------------------------------------------- |
| 双实例写坏库 | `quantdata.lock`(**PID + 进程 start time + boot_id 三元判活**,防 PID 复用误判;发现陈旧锁先备份再接管并记日志)**。后两项是「补强证据」而非判活前提 —— 任一取不到(权限 deny / psutil 缺失 / 非同一 boot)即视为不匹配、按时旧锁接管;判活 = PID 存活 且 三元全部可读且一致(DP-1 v0.7)**;serve/update/backfill/init 互斥,query/export 只读无需锁 |
| serve 写、CLI 查询并存 | DuckDB 单写多读跨进程成立;查询连接固定 `read_only=true`;Parquet 段文件不可变 + compaction 按 §3.1 **两阶段 .trash 协议**(月段先入位、日段延迟 unlink、查询竞态重试一次)消除丢段/重复窗口 |
| Windows 文件语义 | 一律 `os.replace`(同卷原子);tmp 与 data 同盘;启动时扫残留 tmp 清理 |
| 重复更新产生重复行 | 日粒度整分区替换(§7.3);1m 段文件按日期命名天然幂等(重写=同名覆盖) |
| 公告/研报重复抓取 | 主键 `id` + content hash:`ON CONFLICT(id) DO UPDATE WHERE excluded.hash <> hash`(改稿可进库,见 §7.4) |
| schema 演进 | `schema_migrations` 版本表,serve 启动自动升级(**版本 > 代码已知最高版 → 报错退出**,不带病跑;migration 包事务、失败回滚);**视图 DDL 同步纳入 migration(§3.3)**;升级流程 = 停 serve → 备份 catalog.duckdb → 换包 → 启动 |
| 回填与 serve 抢锁 | 同一把锁:backfill 中途起 serve 会明确报错,不静默并发写 |
---
## 12. 配置文件(dbpath/config.json)
> config.json 统一承载三类配置:**抓取数据时间**(`schedule` 默认值,可被 `scripts/` 各脚本 META 覆盖)、**代理服务器**(`proxy` 全局 + per-source)、**数据源要求**(`sources` 主备源、`fetch` 限速/超时/重试)。
```json
{
"version": 1,
"dbpath_created": "2026-09-23T10:40:00+08:00",
"markets": {
"cn": { "enabled": true, "history_from": "2004-01-01", "history_from_bars_1d": null },
"us": { "enabled": true, "history_from": "2020-01-01", "history_from_bars_1d": null },
"hk": { "enabled": true, "history_from": "2020-01-01", "history_from_bars_1d": null }
},
"categories": { "cn": ["index","stock","future","cbond","etf","reits","option"],
"us": ["index","stock","future","etf","reits"],
"hk": ["index","stock","future","etf","reits"] },
"sources": {
"bars": "tdx", "realtime": "westock", "reference": ["tdx","westock"],
"futures": ["tdx","yfinance"], "news": ["scripts/fetch_news.py"],
"fallback": ["akshare_port"],
"cross_check": true, "cross_check_ratio": 0.01
},
"proxy": { "global": "", "per_source": { "akshare_port": "http://127.0.0.1:7890", "yfinance": "" } },
"fetch": { "rate_limit_rps": { "akshare_port": 3, "yfinance": 2 }, "timeout_ms": 10000, "max_retry": 3 },
"http": {
"enabled": true,
"host": "127.0.0.1",
"port": 8765,
"token": "",
"max_ws_conns": 64,
"ws_queue_len": 256
},
"schedule": {
"timezone": "Asia/Shanghai",
"cn_intraday_interval_s": 90, "snapshot_interval_s": 3,
"daily_chain": { "cn": "15:05", "hk": "16:10", "us": "04:30" },
"compaction": "monthly"
},
"quality": { "enabled": true, "checks": ["gap","ohlc","limit","adj","rowcount","dualsource"] },
"sql": { "max_rows": 1000000, "timeout_ms": 30000, "max_arrow_bytes": 67108864, "max_concurrent": 4, "allow_functions": [] },
"export": { "out_dir": "exports", "cache_ttl_h": 24, "keep_days": 7, "formats": ["csv","parquet","qlib","backtrader"] },
"log": { "level": "INFO", "keep_days": 30 }
}
```
> `http.token` 支持 `${ENV}` 展开,不明文入库亦可;格式保持 JSON(你的约定)。
> `sql.allow_functions` = **额外放行清单**(默认拒绝策略见 §8.3,清空 ≠ 放开表函数);`export.keep_days`:exports/ 按 job 保留天数,日频链自动清理;`markets.*.history_from_bars_1d` 为 null 时跟随 `history_from`(日K 可独立放宽,见 §3.4)。
---
## 13. 可观测性与运维
- **日志**:`logs/serve-YYYYMMDD.jsonl`(事件字段与 WS envelope 同构);**token 脱敏**(query 参数只留前 4 位,含 uvicorn access log);
- **指标**:进程内计数器(更新行数、延迟、HTTP 往返、WS 连接数、队列深度、**磁盘余量**),经 `GET /v1/stats` 查询(v1 不引 Prometheus,接口留好);磁盘余量 <10% → `ev.quality` warning,**<5% 硬阈值拒写**(任务失败退避、不 crash loop);另给 `/healthz`(liveness)与 `/v1/ready`(readiness,锁/schema/调度器/磁盘);
- **质检即看板**:`status --json` / `quality_reports` 表 = 最近一次体检;
- **备份**:DuckDB 必须走**只读连接**(`ATTACH ... READ_ONLY` / `EXPORT DATABASE` 出快照)—— 热拷文件 = 损坏快照;Parquet 段不可变先 rsync;**备份窗口内暂停 compaction**(或备份后跑行数守恒校验 §7.5),防 rsync×os.replace 竞态拷到半套月段;v1 只给文档不给命令;
- **部署**(已确认 = Linux 服务器长期常驻):supervisord 加一个 program,常驻 `quantdata serve`(恒前台)+ **stopwaitsecs=60**(优雅退出预算 30s 的兜底);探针挂 `/healthz` + `/v1/ready`;`exports/` 清理由 `export.keep_days` 日频链执行;Windows 仅开发/临时使用(计划任务可选)。
---
## 14. 测试策略(对齐 100% 覆盖率要求)
| 层 | 手段 |
| --------------------------- | --------------------------------------------------------------------------------------- |
| 纯逻辑(状态机、调度、幂等分区、质检规则、SQL 闸) | pytest 单测,分支全覆盖 —— 全部设计成**无网络纯函数/可注入时钟**,是拿满覆盖率的关键 |
| 源适配层 | 录制 fixtures 回放(contract test)不打真网;**另加故障注入**:mock transport 编排错误序列(429→500→成功),fake clock 断言退避时序与重试上限,断言 checkpoint 半途失败后 resume 不重不漏;令牌桶用注入时钟做纯逻辑单测 |
| 存储层 | tmp_path 建迷你库:init→update→compact→query 全链路集成测试(含 compaction 两阶段协议的竞态注入) |
| 服务网关协议 | FastAPI TestClient/httpx:REST 往返、WS 推送、envelope 版本、token 鉴权(**含日志脱敏断言**)、断线重连初帧时序 |
| qlib/backtrader 导出 | **两层(评审 P0)**:①核心 = dump_bin 布局字节级/数值级读回断言(**不装 qlib**,CI 必绿)+ feather 喂 backtrader 跑一根 K 线;②`qlib` extra 可选集成 job(装 qlib 真 `qlib.init()`,单独标记) |
| 质检元测试 | **golden 脏数据样本集**:每类规则 ≥1 阳性 + 1 阴性 + 1 边界豁免(除权日涨跌停),断言 quality_reports 输出;「失败动作」回路(自动重拉/重合并)写回路测试;双源抽查固定随机种子保 CI 可复现 |
| CI | GitHub Actions(同 pytdxdata 模板):Linux+Windows 矩阵,**`--cov-fail-under=100` + 排除白名单(下表)**;`--no-http` 路径必绿,HTTP/WS 用 TestClient;**`[CI]` 验收链用 CLI 起真 serve + 真端口 curl(覆盖 `cli.serve` → `run_serve` → `Server.serve()` 编排层),`runtime.py` 真 uvicorn/socket 段按白名单豁免(DP-2 v0.7)**;fastapi/uvicorn/sqlglot 全部 lock pin + Renovate 跟进,sqlglot 升级过 SQL 闸回归 |
**async 测试策略(评审 P1)**:
- 调度器抽象 `Clock/ticker` 接口,**cron 判定写成纯函数** —— 参数化构造时间点测全部边界(夏令时切换日、时钟回拨跳槽);
- pytest-asyncio 显式 mode;集成测试中调度器与 FastAPI app **共用同一事件循环**(与 §7.6 执行模型一致),用可控 ticker 驱动「到点 → 写 checkpoint → WS 广播 ev.update」确定性链路;
- 线程池路径用同步 mock 断言「事件循环内零阻塞调用」。
**验收数据两层(评审 P0 —— CI 跑不了真回填)**:
- **[CI 层]**:`init --skip-history` + 随仓库迷你 seed fixture(`tests/fixtures/ci_seed_1d.parquet`:2 symbols × 10 交易日日K,落到 `bars_1d`;生成脚本 `build_ci_fixture.py` 固化,CI 先 `--check` 校验一致性)→ M1 链 `init → serve → POST /v1/query → export csv` CI 必绿;
- **[夜间/发布层]**:真数据回填与全量对齐,独立 workflow,不计入覆盖率、不阻塞 PR。
**fixture 生命周期(评审 P1)**:每个 fixture 标注录制日期与源接口版本;nightly `record` job 打真网重录 + diff 报告(失败开 issue、不入必绿项);超 90 天未刷新在 CI 给 warning。
**覆盖率排除白名单(评审 P0 —— 验收前一次拍板)**:
| 排除项 | 理由 | 替代验证 |
| ---- | ---- | ---- |
| uvicorn 真起服 / socket 层 | 平台相关、CI 不稳(本机踩过 socketpair 死锁) | **每周 smoke workflow + M1 交付自检**:真 `serve` + 真端口 curl `/healthz`、`/v1/ready`、`POST /v1/query`、`/v1/export`、SQL 闸 400。CI 验收链的用户面同上(用 CLI 起真 serve + curl),仅 `runtime.py` 内 uvicorn/socket 段 pragma 豁免(DP-2 v0.7) |
| WS 多连接扇出 / 3s 节奏 | TestClient 只测单连接帧语义 | 冒烟脚本 4 连接收帧计数 |
| supervisord 模板 / Windows 计划任务 | 非 Python 代码 | 模板渲染单测 + 手工部署检查表(§15 [手工]) |
| 300GB 真数据导入路径 | 数据量不可进 CI | [夜间/发布层] workflow |
| 用户自定义 `scripts/*.py` 本体 | 运行时热加载的外部代码 | 核心只测加载器与 META 解析 |
---
## 15. 分阶段路线图
| 里程碑 | 交付物 | 验收标准 |
| ------------- | ---------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| **M1 最小闭环** | CLI 骨架(init/serve/query/update/status)、目录规范、schema+migrations、A股证券信息+日历+日K、FastAPI + `POST /v1/query`、csv/parquet/pandas 导出 | **[CI]** `init --skip-history`+迷你 seed → CLI 起真 `serve` → 真端口 `POST /v1/query` 查到日K → export csv 一条链必绿(含 SQL 闸 400 fail-closed 断言);单测覆盖核心逻辑 + `--cov-fail-under=100` |
| **M2 A股完整** | 1m 回填(seed 导入 + 断点续传)、compaction、除权/ST/停牌/涨跌停/申万行业、公告研报、每日质检、qlib+backtrader 导出、市场状态机 | A股数据矩阵全 ✅ **[夜间]**;qlib extra job 实读 + backtrader 单测 **[CI]**;质检连续 7 天绿 **[手工]** |
| **M3 三市场+推流** | 美/港股日线+1m(时区调度)、快照/tick WS 推流、分钟新闻桥、token 鉴权开放内网、export 远端下载 | 三市场矩阵定稿;三市场 1m 回填完成度 ≥99% 交易日 **[夜间]**;从另一台机器完成 query/订阅/导出全流程演练 **[手工]** |
| **M4 运维加固** | 陈旧锁恢复、stats 完整化、备份文档、Linux supervisord 部署物(主)+ Windows 本机跑法(次)、README/协议文档、双源对账常态化、**quantdata-client 薄 SDK + `GET /v1/bars` 糖(可选)** | 连续运行 2 周无人工干预 **[手工]**;`doctor` 全绿;覆盖率白名单复审 |
> 先 M1 跑通再谈后面的:每个里程碑都保持"能用的完整切片",不铺一次性大坑。
> **验收标签**:`[CI]` = GitHub Actions 必绿、计入 100% 覆盖率;`[夜间]` = 独立 workflow 不阻塞 PR;`[手工]` = 发布检查表签收项。100% 覆盖率只约束 `[CI]` 项(白名单见 §14)。
---
## 16. 评审决策记录(2026-09-23 已拍板)
| # | 问题 | 决策 | 落点 |
|---|------|------|------|
| 1 | "每日对数据进行…"截断 | ✅ 每日质量校验(gap/OHLC/涨跌停/复权对账/双源抽查 1%) | §1.3、§7.5 |
| 2 | 起始年限 / 磁盘 | ✅ cn=2004、us=2020、hk=2020;dbpath 落位由部署时 `-d` 指定(容量 §3.4,建议大盘) | §1.3、§3.4 |
| 3 | 美股可转债/LOF 等品类 | ✅ 先放空,走可扩展结构(config+脚本+视图三步接入,核心零改动) | §1.3、§4.2 |
| 4 | 研报 / 申万行业数据源 | ✅ akshare 接口(研报 choices 等),摘抄源码 + primp 重写(不安装 akshare) | §1.3、§4.2、§5.2 |
| 5 | 实时行情精度 | ✅ 3 秒快照 + 自选 tick,不做逐笔 | §1.3、§10.1 |
| 6 | 对外服务协议 | ✅ **v0.5 改判:放弃 NATS** —— serve 进程内 FastAPI(REST + WebSocket 订阅),`--no-http` 纯 CLI;v0.4 的 servers/autostart/bin 设计作废 | §1.3、§7.1、§8 |
| 7 | 部署目标 | ✅ Linux 服务器长期常驻(supervisord),Windows 仅开发用 | §1.3、§13、§15 |
| 8 | 跨市场 union 视图 | ✅ 加 `bars_1m_all`(market 列 + UNION ALL) | §1.3、§3.3 |
| 9 | news-integration 批注归属 | 未另行指示 → 维持默认:采集逻辑迁入 `dbpath/scripts/fetch_news.py` | §2、§3.1、附录B |
| 10 | v0.6 圆桌评审 45 条 | ✅ **全部采纳**(6 席全票「修改后可实施」,P0×6 / P1×24 / P2×15):事件循环隔离、SQL 函数默认拒绝、compaction 两阶段、覆盖率白名单、验收两层、qlib 两层、news 表、复权口径、WS 时序统一、export 归位 | §7.6、§8.3、§3.1、§14 等 |
**剩余风险**(非阻塞):①akshare 类接口源站结构变动频繁,摘抄+primp 的移植代码需在质检中加 **schema 漂移检测**(列名/结构突变即告警),M2 跑通后观察两周;②按 ~600GB(数据 300–400GB + buffer ≥200GB)确认落位盘符。
---
## 附录 A:核心接口示例
```bash
# query —— REST 直接调
curl -s http://127.0.0.1:8765/v1/query -H 'Content-Type: application/json' \
-d '{"sql":"SELECT date, close FROM cn_stock_1d WHERE symbol=? ORDER BY date DESC LIMIT 5",
"params":["sh600000"],"fmt":"json"}'
→ {"columns":["date","close"],"dtypes":["date32","float64"],
"rows":[["2026-09-22",32.15],["2026-09-21",31.98]],"row_count":5,"elapsed_ms":12,"truncated":false}
```
```json
// WebSocket 帧示例:ws://127.0.0.1:8765/v1/stream?topics=state,news.minute&market=cn
{"v":1,"msg_id":"...","topic":"state","payload":{"market":"cn","state":"LUNCH_BREAK",
"ts":"2026-09-23T03:30:00Z","next_at":"2026-09-23T05:00:00Z","session_tz":"Asia/Shanghai","reason":"session_rule"}}
{"v":1,"msg_id":"...","topic":"news.minute","payload":{"window_start":"2026-09-23T02:39:00Z","count":3,
"items":[{"id":"h1","ts":"...","source":"rss1","market":"cn","symbols":["sh600000"],
"level":"important","title":"...","url":"..."}]}}
```
## 附录 B:已有资产复用映射
| 已有项目 | 在 quantdata 中的角色 |
| ---------------------------------------------------------------------- | -------------------------------------------- |
| **pytdxdata**(PyPI 0.6.0,三市场 K 线/行情/复权/tick) | 主数据源适配器(bars/realtime/ticks/futures/options) |
| **pywestockdata**(腾讯/东财 SDK,全市场 <500ms) | A股快照源 + 财务/分红/公告 + 日K双源对账 |
| **stock_prediction 的 A股 1m(2004→今)** | `init --seed` 直接导入,省 22 年回填 |
| **market-event-driver**(holidays.py / markets.py) | 日历与交易时段规则吸收为 `exchange.session` + 静态节假日表 |
| **news-integration**(RSS 统一采集器) | 采集逻辑迁入 `dbpath/scripts/fetch_news.py`,NewsBridge 消费其输出 |
| **yfinance**(参考源) | 美/港数据参考对账 |
| **akshare 源码**(只摘抄,不安装) | 研报(choices 等)、申万行业、长尾兜底:摘抄实现、请求层用 primp 重写过反爬 |
| **nats-supervisor / event_center**(三节点集群、TLS、supervisord 模板) | ❌ v0.5 起不再需要(NATS 已放弃);supervisord 部署模板仍可参考 |
| **vxdata / factor-pipeline** | 下游邻居:quantdata 只出干净原始数据,特征与因子归它们 |
+70
View File
@@ -0,0 +1,70 @@
[project]
name = "pyquantdata"
version = "0.1.0"
description = "quantdata: 单目录自包含的量化数据中台 CLI(A股/美股/港股),init 建库回填,serve 常驻更新 + FastAPI 对外服务"
readme = "README.md"
# 排除 3.14:该版本 Windows 上 asyncio ProactorEventLoop 的 socket.socketpair()
# 回退分支会死锁(asyncio.run 建 loop 即挂),serve 常驻与全部异步测试不可用。
requires-python = ">=3.11,<3.14"
license = { text = "MIT" }
authors = [{ name = "openbot-coder" }]
dependencies = [
"duckdb>=1.1",
"fastapi>=0.115",
"uvicorn>=0.30",
"pyarrow>=17",
"sqlglot>=25",
"typer>=0.12",
"rich>=13",
"pydantic>=2.8",
"pytdxdata>=0.6",
"psutil>=6",
# duckdb 读写 TIMESTAMPTZ 列需要 pytz;zoneinfo 需要 tzdata(Windows 无系统 tz 库)
"pytz>=2024.1",
"tzdata>=2024.1",
]
[project.scripts]
quantdata = "pyquantdata.cli:main"
[dependency-groups]
dev = [
"pytest>=8",
"pytest-asyncio>=0.24",
"pytest-cov>=5",
"pytest-timeout>=2.3",
"httpx>=0.27",
# [CI] 验收链需验证 arrow → DataFrame 生态解码路径(§9 附录 A)
"pandas>=2.2",
]
[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"
[tool.hatch.build.targets.wheel]
packages = ["src/pyquantdata"]
[tool.pytest.ini_options]
testpaths = ["tests"]
asyncio_mode = "strict"
filterwarnings = [
"ignore::DeprecationWarning:duckdb",
]
# 本机 safe-delete 钩子会拦 pytest 的 tmp 清理(报 SAFE_DELETE_BULK_CONFIRM_REQUIRED),
# 导致覆盖率检查被跳过。默认把 base temp 指到项目外即可绕开(CI 上无影响)。
addopts = ["--timeout=90", "--timeout-method=thread"]
[tool.coverage.run]
branch = false
source = ["pyquantdata"]
[tool.coverage.report]
show_missing = true
# §14 覆盖率排除白名单(评审 P0,验收前拍板):
# 1) uvicorn 真起服 / socket 层 —— 平台相关,CI 不稳;替代验证 = 每周 smoke workflow(真端口 curl /healthz)
exclude_also = [
"pragma: no cover",
"if TYPE_CHECKING:",
"raise NotImplementedError",
]
+235
View File
@@ -0,0 +1,235 @@
"""M1 交付自检冒烟脚本([CI] 验收链的可复用副本 + 每周 smoke workflow 素材)。
设计 §14 白名单:uvicorn 真起服 / socket 层不计入覆盖率,替代验证 = 本脚本。
与 `.github/workflows/ci.yml` 的验收链同源,可本地或 CI 直接跑:
python scripts/smoke_m1.py # 用临时 dbpath,自建自销
python scripts/smoke_m1.py -d /path/db # 用已有库
python scripts/smoke_m1.py --port 18766
覆盖:init --skip-history + 迷你 seed → 真 serve(真 socket)→
/healthz、/v1/ready、POST /v1/query(json + arrow)、POST /v1/export(csv 落盘 + 行数)、
SQL 闸 fail-closed 400 → 关闭 → 端口释放。任一步失败非零退出。
"""
from __future__ import annotations
import argparse
import base64
import csv
import io
import json
import os
import shutil
import subprocess
import sys
import tempfile
import time
import urllib.error
import urllib.request
from pathlib import Path
REPO = Path(__file__).resolve().parent.parent
FIXTURE = REPO / "tests" / "fixtures" / "ci_seed_1d.parquet"
PY = REPO / ".venv" / "Scripts" / "python.exe"
if not PY.exists(): # 非 venv 环境(Linux CI 用 uv run 时走 sys.executable)
PY = Path(sys.executable)
FAILED: list[str] = []
# 本机常见坑:环境里挂着 `http_proxy=http://127.0.0.1:xxxxx`(指向已死的代理),
# urllib 默认走它 → 连 127.0.0.1 也超时,误判成「服务没起来」。
# 冒烟目标是本机 loopback,必须显式 bypass。
_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
def check(label: str, ok: bool, detail: str = "") -> None:
mark = "PASS" if ok else "FAIL"
print(f" [{mark}] {label}" + (f" — {detail}" if detail else ""), flush=True)
if not ok:
FAILED.append(label)
def http(base: str, path: str, *, data: dict | None = None, method: str = "GET",
timeout: float = 20.0) -> tuple[int, bytes]:
req = urllib.request.Request(base + path, method=method)
body = None
if data is not None:
req.add_header("Content-Type", "application/json")
body = json.dumps(data).encode()
with _OPENER.open(req, data=body, timeout=timeout) as r:
return r.status, r.read()
def main(argv: list[str] | None = None) -> int:
ap = argparse.ArgumentParser(description="M1 交付自检冒烟")
ap.add_argument("-d", "--dbpath", default=None, help="库目录(缺省=临时目录,跑完清理)")
ap.add_argument("--port", type=int, default=18766)
args = ap.parse_args(argv)
tmp_root: Path | None = None
if args.dbpath:
dbpath = Path(args.dbpath).resolve()
else:
tmp_root = Path(tempfile.mkdtemp(prefix="pyqd_smoke_"))
dbpath = tmp_root / "db"
base = f"http://127.0.0.1:{args.port}"
proc: subprocess.Popen | None = None
try:
# ---------- 1. init --skip-history + 迷你 seed ----------
print("[1/4] init --skip-history + 迷你 seed")
r = subprocess.run(
[str(PY), "-m", "pyquantdata.cli", "init", "-d", str(dbpath),
"--skip-history", "--seed", str(FIXTURE)],
capture_output=True, text=True, cwd=str(REPO),
)
check("init 退出码 0", r.returncode == 0, r.stdout.strip().splitlines()[-1:] and
r.stdout.strip().splitlines()[-1] or r.stderr[:200])
check("init 自检输出含 bars_1d rows=20", "bars_1d rows=20" in r.stdout)
# ---------- 2. 真 serve(真 socket) ----------
print("[2/4] 起真 serve(真 uvicorn + 真端口)")
log = tempfile.NamedTemporaryFile(prefix="pyqd_smoke_srv_", suffix=".log",
delete=False)
proc = subprocess.Popen(
[str(PY), "-m", "pyquantdata.cli", "serve", "-d", str(dbpath),
"--port", str(args.port)],
stdout=log, stderr=subprocess.STDOUT, cwd=str(REPO),
)
up = False
for _ in range(60): # 最多等 30s
if proc.poll() is not None:
break
try:
http(base, "/healthz", timeout=2)
up = True
break
except Exception:
time.sleep(0.5)
check("serve 起服可连(真端口)", up,
"" if up else f"进程退出码={proc.poll()} 日志={Path(log.name).read_text()[-300:]}")
if up:
# ---------- 3. 端点面 ----------
print("[3/4] 端点面")
s, b = http(base, "/healthz")
check("/healthz 200", s == 200, b.decode()[:80])
s, b = http(base, "/v1/ready")
ready = json.loads(b)
check("/v1/ready ready=true", s == 200 and ready.get("ready") is True,
f"schema_version={ready.get('checks', {}).get('schema_version')}")
s, b = http(base, "/v1/query", method="POST",
data={"sql": "SELECT count(*) AS n FROM cn_stock_1d"})
q = json.loads(b)
check("POST /v1/query 日K row_count=1 且 n=20",
s == 200 and q.get("row_count") == 1 and q["rows"][0][0] == 20,
f"n={q.get('rows')}")
# arrow IPC 解码路径(附录 A:pandas/polars 消费端)
s, b = http(base, "/v1/query", method="POST",
data={"sql": "SELECT date, close FROM cn_stock_1d ORDER BY date",
"fmt": "arrow"})
arrow_ok = False
n_rows = -1
if s == 200:
try:
import pyarrow as pa
tbl = pa.ipc.open_stream(
pa.BufferReader(base64.b64decode(json.loads(b)["b64_arrow"]))
).read_all()
n_rows = tbl.num_rows
arrow_ok = n_rows == 20
except Exception as e: # noqa: BLE001
arrow_ok = False
n_rows = repr(e)
check("POST /v1/query fmt=arrow 可解出 20 行", arrow_ok, f"rows={n_rows}")
# 恶意查询必须被 SQL 闸拒(fail-closed,§8.3)
evil = "SELECT read_parquet('/etc/passwd')"
code = -1
try:
code, _ = http(base, "/v1/query", method="POST", data={"sql": evil})
except urllib.error.HTTPError as e:
code = e.code
check("SQL 闸拒绝 read_parquet(400)", code == 400, f"status={code}")
# ---------- 4. export csv(真落盘 exports/{job_id}/) ----------
print("[4/4] export csv")
s, b = http(base, "/v1/export", method="POST", data={
"sql": "SELECT symbol, date, close FROM cn_stock_1d ORDER BY date",
"fmt": "csv", "filename": "smoke_daily.csv",
})
lines = b.decode("utf-8").strip().splitlines() if s == 200 else []
header = [c.strip('"') for c in lines[0].split(",")] if lines else []
check("export csv 表头+20 行", s == 200 and len(lines) == 21
and header == ["symbol", "date", "close"],
f"status={s} lines={len(lines)} header={header}")
s, b = http(base, "/v1/query", method="POST", data={
"sql": "SELECT job_id, rows, state FROM export_jobs"})
job = json.loads(b)
check("export_jobs 落库 rows=20 state=done",
s == 200 and job["rows"][0][1] == 20 and job["rows"][0][2] == "done",
str(job.get("rows")))
# 落盘校验(CSV 内容语义,不受引号风格影响)
on_disk = list((dbpath / "exports").glob("*/smoke_daily.csv"))
disk_ok = False
if on_disk:
with on_disk[0].open(encoding="utf-8", newline="") as fh:
rows = list(csv.reader(fh))
disk_ok = len(rows) == 21 and rows[0] == ["symbol", "date", "close"]
check("export 落盘 exports/{job_id}/ 内容正确", disk_ok,
str(on_disk[0].relative_to(dbpath)) if on_disk else "未找到文件")
# CLI 只读直查(需先释放 serve 的写连接)
print("[5/5] CLI 只读直查(停服后)")
else:
print("[3/4] 跳过(服务未起)")
print("[4/4] 跳过(服务未起)")
# ---------- 关闭 + 端口释放 ----------
if proc is not None and proc.poll() is None:
proc.terminate()
try:
proc.wait(timeout=15)
except subprocess.TimeoutExpired:
proc.kill()
proc.wait(timeout=10)
freed = False
for _ in range(20):
try:
http(base, "/healthz", timeout=1)
time.sleep(0.3)
except Exception:
freed = True
break
check("停服后端口已释放", freed)
if up:
r = subprocess.run(
[str(PY), "-m", "pyquantdata.cli", "query", "-d", str(dbpath),
"--fmt", "json", "SELECT count(*) AS n FROM cn_stock_1d"],
capture_output=True, text=True, cwd=str(REPO),
)
check("CLI 只读直查 --fmt json 正常",
r.returncode == 0 and '"row_count": 1' in r.stdout,
(r.stdout or r.stderr)[:150])
# ---------- 汇总 ----------
print()
if FAILED:
print(f"SMOKE FAILED:{len(FAILED)} 项 —— " + "; ".join(FAILED))
return 1
print("SMOKE OK:M1 全链路(真起服 + 真端口 + 全端点)通过")
return 0
finally:
if tmp_root is not None:
shutil.rmtree(tmp_root, ignore_errors=True)
if __name__ == "__main__":
sys.exit(main())
+3
View File
@@ -0,0 +1,3 @@
"""pyquantdata: quantdata CLI —— 单目录自包含的量化数据中台。"""
__version__ = "0.1.0"
+6
View File
@@ -0,0 +1,6 @@
"""python -m pyquantdata 入口。"""
from .cli import main
if __name__ == "__main__":
main()
+339
View File
@@ -0,0 +1,339 @@
"""quantdata CLI(设计 §6):init / serve / update / query / export / status。
约定:``-d`` 可用环境变量 QUANTDATA_HOME 兜底;输出对齐「简洁分阶段」偏好;
CLI 一次性命令可离线跑(serve --no-http 纯批处理)。
"""
from __future__ import annotations
import asyncio
import json
import sys
from datetime import date
from pathlib import Path
from typing import Optional
import typer
from rich.console import Console
from rich.table import Table
from . import __version__
from .config import AppConfig, default_config, load_config, write_config
from .etl import SeedError, import_seed
from .export.files import (
EXPORT_FORMATS,
write_export,
)
from .paths import DbPathLayout, resolve_dbpath
from .sqlgate import SqlRejected, validate
from .store import CatalogNotInitialized, migrate, open_catalog
app = typer.Typer(add_completion=False, help="quantdata:单目录自包含的量化数据中台")
console = Console()
err = Console(stderr=True)
# 容量估算表(设计 §3.4,GB):数据终态 + buffer ≥200GB ≈ 600GB 预算口径
_CAPACITY_GB = {"cn": (150, 200), "us": (80, 90), "hk": (40, 45)}
_BUFFER_GB = 200
def estimate_capacity(markets: list[str]) -> dict:
"""init --estimate 只算不写(§3.4)。"""
per = {}
lo_total = hi_total = 0
for m in markets:
lo, hi = _CAPACITY_GB.get(m, (0, 0))
per[m] = {"gb_low": lo, "gb_high": hi}
lo_total += lo
hi_total += hi
return {
"per_market_gb": per,
"data_gb": [lo_total, hi_total],
"buffer_gb": _BUFFER_GB,
"budget_gb": [lo_total + _BUFFER_GB, hi_total + _BUFFER_GB],
}
def _open_ro(dbpath: Path):
"""只读打开;未初始化时打印可操作提示并 exit(1)(所有只读命令共用)。"""
try:
return open_catalog(dbpath, read_only=True)
except CatalogNotInitialized as e:
err.print(f"[red]未初始化:[/red]{e}")
raise typer.Exit(1) from e
@app.command()
def init(
d: Optional[str] = typer.Option(None, "--dbpath", "-d", envvar="QUANTDATA_HOME", help="库目录"),
markets: str = typer.Option("cn,us,hk", "--markets", help="启用市场,逗号分隔"),
seed: Optional[Path] = typer.Option(None, "--seed", help="现成数据文件(parquet/csv)导入日K"),
skip_history: bool = typer.Option(False, "--skip-history", help="跳过历史回填([CI] 层)"),
estimate: bool = typer.Option(False, "--estimate", help="只估算磁盘预算,不写库"),
) -> None:
"""建目录 + config.json + schema(migrations)+ seed 导入 + 自检。幂等:重跑=续跑。"""
dbpath = resolve_dbpath(d)
layout = DbPathLayout(dbpath)
market_list = [m.strip() for m in markets.split(",") if m.strip()]
if estimate:
console.print_json(json.dumps(estimate_capacity(market_list)))
raise typer.Exit(0)
console.print(f"[bold]quantdata init[/bold] → {dbpath}")
console.print(" [1/4] 目录结构")
layout.ensure_dirs()
config_file = layout.config_file
if config_file.exists():
cfg = load_config(config_file)
console.print(" [2/4] config.json 已存在,保留(幂等)")
else:
cfg = default_config(market_list)
write_config(cfg, config_file)
console.print(f" [2/4] config.json 生成(markets={market_list})")
conn = open_catalog(layout.root)
try:
console.print(" [3/4] schema migrations")
version = migrate(conn)
console.print(f" schema 版本 = {version}")
console.print(" [4/4] 自检")
seed_report = None
if seed is not None:
try:
seed_report = import_seed(conn, seed)
except SeedError as e:
err.print(f"[red]seed 导入失败:[/red]{e}")
raise typer.Exit(1) from e
_print_selfcheck(conn, layout, seed_report)
finally:
conn.close()
if skip_history:
console.print("[dim]--skip-history:历史回填跳过([CI] 层验收口径)[/dim]")
console.print("[green]init 完成[/green]")
def _print_selfcheck(conn, layout: DbPathLayout, seed_report) -> None:
tables = conn.execute(
"SELECT count(*) FROM information_schema.tables WHERE table_schema='main' "
"AND table_type='BASE TABLE'"
).fetchone()[0]
views = conn.execute(
"SELECT count(*) FROM information_schema.tables WHERE table_schema='main' "
"AND table_type='VIEW'"
).fetchone()[0]
bars_rows = conn.execute("SELECT count(*) FROM bars_1d").fetchone()[0]
console.print(f" tables={tables} views={views} bars_1d rows={bars_rows}")
if seed_report is not None:
console.print(
f" seed: {seed_report.rows} 行 / {len(seed_report.symbols)} symbols "
f"[{seed_report.date_min} ~ {seed_report.date_max}]"
)
@app.command()
def serve(
d: Optional[str] = typer.Option(None, "--dbpath", "-d", envvar="QUANTDATA_HOME"),
host: Optional[str] = typer.Option(None, "--host", help="监听地址(默认 config http.host)"),
port: Optional[int] = typer.Option(None, "--port", help="监听端口(默认 config http.port)"),
no_http: bool = typer.Option(False, "--no-http", help="纯 CLI 批处理,不起网关"),
insecure: bool = typer.Option(False, "--insecure", help="显式允许非 loopback 且无 token(§8.4)"),
) -> None:
"""常驻:单写者锁 + 调度 + FastAPI 网关(恒前台,Linux 交 supervisord)。"""
from .serve.runtime import run_serve
dbpath = resolve_dbpath(d)
code = asyncio.run(
run_serve(dbpath, host=host, port=port, no_http=no_http, insecure=insecure)
)
raise typer.Exit(code)
@app.command()
def update(
d: Optional[str] = typer.Option(None, "--dbpath", "-d", envvar="QUANTDATA_HOME"),
dataset: str = typer.Option("all", "--dataset", help="securities,calendar,bars_1d 或 all"),
market: str = typer.Option("cn", "--market"),
symbols: Optional[str] = typer.Option(None, "--symbols", help="逗号分隔,缺省=securities 全量"),
start: Optional[str] = typer.Option(None, "--start", help="日K 起始 YYYY-MM-DD"),
end: Optional[str] = typer.Option(None, "--end", help="日K 结束 YYYY-MM-DD"),
) -> None:
"""单次更新(cron 兜底):主源 pytdxdata。幂等,重跑安全。"""
from .sources import TdxAdapter
dbpath = resolve_dbpath(d)
layout = DbPathLayout(dbpath)
conn = open_catalog(layout.root)
try:
migrate(conn)
datasets = (
["securities", "calendar", "bars_1d"] if dataset == "all" else
[x.strip() for x in dataset.split(",") if x.strip()]
)
sym_list = [s.strip() for s in symbols.split(",")] if symbols else None
adapter = TdxAdapter()
console.print(f"[bold]quantdata update[/bold] market={market} datasets={datasets}")
# 适配器 open/close 与 ETL 必须在同一事件循环(pytdxdata 纯 asyncio)
from .etl.update import run_update as _run_update
async def _run():
await adapter.open()
try:
return await _run_update(
conn, market, adapter,
datasets=datasets, symbols=sym_list,
start=date.fromisoformat(start) if start else None,
end=date.fromisoformat(end) if end else None,
)
finally:
await adapter.close()
reports = asyncio.run(_run())
for r in reports:
console.print(
f" {r.dataset}: rows={r.rows} symbols={len(r.symbols)} "
f"range=[{r.date_min} ~ {r.date_max}]"
)
console.print("[green]update 完成[/green]")
finally:
conn.close()
@app.command()
def query(
sql: str = typer.Argument(..., help="SQL(仅只读查询)"),
d: Optional[str] = typer.Option(None, "--dbpath", "-d", envvar="QUANTDATA_HOME"),
fmt: str = typer.Option("table", "--fmt", help="table|json|csv|parquet|arrow"),
o: Optional[Path] = typer.Option(None, "-o", help="csv/parquet/arrow 输出文件"),
) -> None:
"""本地直查(只读连接,不开服务也可用)。"""
if fmt not in ("table", "json", "csv", "parquet", "arrow"):
err.print(f"[red]--fmt 不支持:{fmt}[/red]")
raise typer.Exit(1)
if fmt in ("csv", "parquet", "arrow") and o is None:
err.print(f"[red]--fmt {fmt} 需要 -o 输出文件[/red]")
raise typer.Exit(1)
dbpath = resolve_dbpath(d)
conn = _open_ro(dbpath)
try:
from .store.db import configure_query_conn
configure_query_conn(conn)
try:
validate(sql) # 本地 CLI 也过闸:与 HTTP 同规则(§8.3)
except SqlRejected as e:
err.print(f"[red]SQL 被拒绝:[/red]{e.reason}")
raise typer.Exit(1) from e
tbl = conn.execute(sql).arrow().read_all()
if fmt == "table":
table = Table(*tbl.schema.names)
for row in table_to_rows(tbl):
table.add_row(*[str(v) for v in row])
console.print(table)
console.print(f"[dim]{tbl.num_rows} rows[/dim]")
elif fmt == "json":
# 纯 stdout JSON(无 rich 前缀/换行噪声),便于 `| jq` 与程序消费
print(
json.dumps(
{
"columns": tbl.schema.names,
"dtypes": [str(f.type) for f in tbl.schema],
"rows": table_to_rows(tbl),
"row_count": tbl.num_rows,
},
default=str,
ensure_ascii=False,
)
)
else:
result = write_export(tbl, "csv" if fmt == "csv" else fmt, Path(o))
console.print(f"[green]已写出[/green] {result.path}({result.rows} 行 / {result.bytes_written} 字节)")
finally:
conn.close()
def table_to_rows(tbl):
if tbl.num_columns == 0:
return []
cols = [c.to_pylist() for c in tbl.columns]
return [list(row) for row in zip(*cols)]
@app.command()
def export(
sql: str = typer.Option(..., "--sql", help="导出查询"),
d: Optional[str] = typer.Option(None, "--dbpath", "-d", envvar="QUANTDATA_HOME"),
fmt: str = typer.Option("csv", "--fmt", help="csv|parquet"),
o: Path = typer.Option(..., "-o", help="输出文件"),
) -> None:
"""导出落盘格式(csv/parquet);pandas/polars 走 query --fmt arrow(§9)。"""
if fmt not in EXPORT_FORMATS:
err.print(f"[red]export 仅支持 {sorted(EXPORT_FORMATS)};pandas/polars 走 query --fmt arrow[/red]")
raise typer.Exit(1)
dbpath = resolve_dbpath(d)
conn = _open_ro(dbpath)
try:
from .store.db import configure_query_conn
configure_query_conn(conn)
try:
validate(sql)
except SqlRejected as e:
err.print(f"[red]SQL 被拒绝:[/red]{e.reason}")
raise typer.Exit(1) from e
tbl = conn.execute(sql).arrow().read_all()
result = write_export(tbl, fmt, Path(o))
console.print(f"[green]导出完成[/green] {result.path}({result.rows} 行 / {result.bytes_written} 字节)")
finally:
conn.close()
@app.command()
def status(
d: Optional[str] = typer.Option(None, "--dbpath", "-d", envvar="QUANTDATA_HOME"),
json_out: bool = typer.Option(False, "--json", help="结构化 JSON 输出(脚本化)"),
) -> None:
"""水位、锁、HTTP 配置、磁盘占用(运维入口)。"""
from .lockfile import is_alive, read_lock
from .store import current_version
dbpath = resolve_dbpath(d)
layout = DbPathLayout(dbpath)
info: dict = {"dbpath": str(layout.root)}
lock = read_lock(layout.lock_file)
info["lock"] = (
{"held": True, "pid": lock.pid, "alive": is_alive(lock)} if lock else {"held": False}
)
info["http"] = {"enabled": True, "host": "127.0.0.1", "port": 8765, "note": "config 段 http"}
conn = _open_ro(layout.root)
try:
info["schema_version"] = current_version(conn)
cps = conn.execute(
"SELECT dataset, market, scope, watermark, rows, status FROM etl_checkpoint "
"ORDER BY dataset, market, scope"
).fetchall()
info["checkpoints"] = [
{"dataset": r[0], "market": r[1], "scope": r[2], "watermark": r[3], "rows": r[4], "status": r[5]}
for r in cps
]
info["bars_1d_rows"] = conn.execute("SELECT count(*) FROM bars_1d").fetchone()[0]
finally:
conn.close()
try:
import psutil
du = psutil.disk_usage(str(layout.root))
info["disk"] = {"used_pct": round(du.percent, 1), "free_gb": round(du.free / 1e9, 1)}
except Exception: # noqa: BLE001 — 磁盘信息尽力而为
info["disk"] = None
# --json 与默认都输出同一份 JSON(默认人类可读,--json 供程序消费;M1 共用渲染)
console.print_json(json.dumps(info, default=str, ensure_ascii=False))
def main() -> None:
app()
if __name__ == "__main__": # pragma: no cover
main()
+190
View File
@@ -0,0 +1,190 @@
"""config.json 模型与读写(设计 §12)。JSON 格式;extra=forbid 防拼错字段静默失效。"""
from __future__ import annotations
import json
import re
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
from pydantic import BaseModel, ConfigDict, Field
_ENV_PATTERN = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}")
def expand_env(value: str) -> str:
"""展开 ``${ENV_VAR}``(设计 §12:http.token 支持环境变量展开,不明文入库)。"""
return _ENV_PATTERN.sub(lambda m: os_environ_get(m.group(1)), value)
def os_environ_get(name: str) -> str:
import os
return os.environ.get(name, "")
class MarketConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
enabled: bool = True
history_from: str
history_from_bars_1d: str | None = None # null 时跟随 history_from(§3.4)
class HttpConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
enabled: bool = True
host: str = "127.0.0.1"
port: int = 8765
token: str = ""
max_ws_conns: int = 64
ws_queue_len: int = 256
class SourcesConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
bars: str = "tdx"
realtime: str = "westock"
reference: list[str] = Field(default_factory=lambda: ["tdx", "westock"])
futures: list[str] = Field(default_factory=lambda: ["tdx", "yfinance"])
news: list[str] = Field(default_factory=lambda: ["scripts/fetch_news.py"])
fallback: list[str] = Field(default_factory=lambda: ["akshare_port"])
cross_check: bool = True
cross_check_ratio: float = 0.01
class ProxyConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
global_: str = Field(default="", alias="global")
per_source: dict[str, str] = Field(default_factory=dict)
class FetchConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
rate_limit_rps: dict[str, float] = Field(default_factory=dict)
timeout_ms: int = 10000
max_retry: int = 3
class DailyChainConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
cn: str = "15:05"
hk: str = "16:10"
us: str = "04:30"
class ScheduleConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
timezone: str = "Asia/Shanghai" # 显式绑定,不读系统 TZ(评审 P1)
cn_intraday_interval_s: int = 90
snapshot_interval_s: int = 3
daily_chain: DailyChainConfig = Field(default_factory=DailyChainConfig)
compaction: str = "monthly"
class QualityConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
enabled: bool = True
checks: list[str] = Field(
default_factory=lambda: ["gap", "ohlc", "limit", "adj", "rowcount", "dualsource"]
)
class SqlConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
max_rows: int = 1_000_000
timeout_ms: int = 30_000
max_arrow_bytes: int = 64 * 1024 * 1024
max_concurrent: int = 4
acquire_timeout_s: float = 5.0 # 信号量等待超过即 429(§8.3)
memory_limit: str = "2GB"
allow_functions: list[str] = Field(default_factory=list) # 额外放行清单(§8.3)
class ExportConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
out_dir: str = "exports"
cache_ttl_h: int = 24
keep_days: int = 7
formats: list[str] = Field(default_factory=lambda: ["csv", "parquet", "qlib", "backtrader"])
class LogConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
level: str = "INFO"
keep_days: int = 30
class AppConfig(BaseModel):
model_config = ConfigDict(extra="forbid")
version: int = 1
dbpath_created: str
markets: dict[str, MarketConfig]
categories: dict[str, list[str]]
sources: SourcesConfig = Field(default_factory=SourcesConfig)
proxy: ProxyConfig = Field(default_factory=ProxyConfig)
fetch: FetchConfig = Field(default_factory=FetchConfig)
http: HttpConfig = Field(default_factory=HttpConfig)
schedule: ScheduleConfig = Field(default_factory=ScheduleConfig)
quality: QualityConfig = Field(default_factory=QualityConfig)
sql: SqlConfig = Field(default_factory=SqlConfig)
export: ExportConfig = Field(default_factory=ExportConfig)
log: LogConfig = Field(default_factory=LogConfig)
_DEFAULT_CATEGORIES = {
"cn": ["index", "stock", "future", "cbond", "etf", "reits", "option"],
"us": ["index", "stock", "future", "etf", "reits"],
"hk": ["index", "stock", "future", "etf", "reits"],
}
def default_config(markets: list[str] | None = None, now: datetime | None = None) -> AppConfig:
"""init 生成的默认 config(§12)。markets 默认三市场全开。"""
markets = markets or ["cn", "us", "hk"]
defaults = {
"cn": ("2004-01-01", None),
"us": ("2020-01-01", None),
"hk": ("2020-01-01", None),
}
now = now or datetime.now(timezone.utc)
return AppConfig(
dbpath_created=now.isoformat(),
markets={
m: MarketConfig(enabled=True, history_from=defaults[m][0], history_from_bars_1d=None)
for m in markets
},
categories={m: list(_DEFAULT_CATEGORIES[m]) for m in markets},
)
def write_config(config: AppConfig, path: Path) -> None:
path.write_text(config.model_dump_json(indent=2, by_alias=True), encoding="utf-8")
def _expand_strings(obj: Any) -> Any:
if isinstance(obj, str):
return expand_env(obj)
if isinstance(obj, list):
return [_expand_strings(v) for v in obj]
if isinstance(obj, dict):
return {k: _expand_strings(v) for k, v in obj.items()}
return obj
def load_config(path: Path) -> AppConfig:
"""读 config.json 并展开 ${ENV};字段拼错/多余直接报错(extra=forbid)。"""
raw = json.loads(path.read_text(encoding="utf-8"))
return AppConfig.model_validate(_expand_strings(raw))
+19
View File
@@ -0,0 +1,19 @@
"""ETL:checkpoint、seed 导入、update 编排。"""
from .checkpoint import failed_checkpoints, list_checkpoints, upsert_checkpoint
from .seed import SeedError, SeedReport, import_seed
from .update import run_update, run_update_sync, update_bars_1d, update_calendar, update_securities
__all__ = [
"SeedError",
"SeedReport",
"failed_checkpoints",
"import_seed",
"list_checkpoints",
"run_update",
"run_update_sync",
"update_bars_1d",
"update_calendar",
"update_securities",
"upsert_checkpoint",
]
+45
View File
@@ -0,0 +1,45 @@
"""etl_checkpoint 断点与水位(设计 §7.4)。"""
from __future__ import annotations
import duckdb
def upsert_checkpoint(
conn: duckdb.DuckDBPyConnection,
dataset: str,
market: str,
scope: str,
watermark: str,
rows: int,
status: str = "ok",
) -> None:
conn.execute(
"INSERT OR REPLACE INTO etl_checkpoint "
"(dataset, market, scope, watermark, rows, status, updated_at) "
"VALUES (?, ?, ?, ?, ?, ?, now())",
[dataset, market, scope, watermark, rows, status],
)
def list_checkpoints(conn: duckdb.DuckDBPyConnection) -> list[dict]:
rows = conn.execute(
"SELECT dataset, market, scope, watermark, rows, status, updated_at "
"FROM etl_checkpoint ORDER BY dataset, market, scope"
).fetchall()
return [
{
"dataset": r[0],
"market": r[1],
"scope": r[2],
"watermark": r[3],
"rows": r[4],
"status": r[5],
"updated_at": None if r[6] is None else r[6].isoformat(),
}
for r in rows
]
def failed_checkpoints(conn: duckdb.DuckDBPyConnection) -> list[dict]:
return [c for c in list_checkpoints(conn) if c["status"] != "ok"]
+142
View File
@@ -0,0 +1,142 @@
"""seed 导入(init --seed):把现成数据(如 stock_prediction 的 A股日K)搬进库。
- 支持列名:symbol, date, open, high, low, close, volume(=vol), amount(=amt),
turnover, adj_factor(后两者可选);
- 幂等:事务内 DELETE 覆盖区(同 symbol 的 [min,max] 日期)后 INSERT;
- parquet / csv 由扩展名路由。
"""
from __future__ import annotations
from dataclasses import dataclass
from datetime import date, datetime
from pathlib import Path
import duckdb
import pyarrow as pa
import pyarrow.csv as pacsv
import pyarrow.parquet as paparquet
from ..sources.classify import classify_cn
_COLUMN_ALIASES = {
"symbol": "symbol",
"date": "date",
"open": "open",
"high": "high",
"low": "low",
"close": "close",
"volume": "volume",
"vol": "volume",
"amount": "amount",
"amt": "amount",
"turnover": "turnover",
"adj_factor": "adj_factor",
}
_REQUIRED = ("symbol", "date", "open", "high", "low", "close")
class SeedError(ValueError):
pass
@dataclass(slots=True)
class SeedReport:
path: str
rows: int
symbols: list[str]
date_min: date | None
date_max: date | None
def _read_table(path: Path) -> pa.Table:
suffix = path.suffix.lower()
if suffix == ".parquet":
return paparquet.read_table(path)
if suffix == ".csv":
return pacsv.read_csv(path)
raise SeedError(f"seed 仅支持 .parquet/.csv,收到 {path.name}")
def _as_date(v) -> date:
if isinstance(v, datetime):
return v.date()
if isinstance(v, date):
return v
return date.fromisoformat(str(v)[:10])
def _rows_from_table(table: pa.Table) -> list[tuple]:
cols = {}
for name in table.column_names:
canonical = _COLUMN_ALIASES.get(name.strip().lower())
if canonical:
cols[canonical] = table.column(name).to_pylist()
missing = [c for c in _REQUIRED if c not in cols]
if missing:
raise SeedError(f"seed 缺必需列:{missing}(实际列:{table.column_names})")
n = len(cols["symbol"])
out: list[tuple] = []
for i in range(n):
symbol = str(cols["symbol"][i]).strip().lower()
if not symbol:
raise SeedError(f"seed 第 {i} 行 symbol 为空")
out.append(
(
symbol,
_as_date(cols["date"][i]),
float(cols["open"][i]),
float(cols["high"][i]),
float(cols["low"][i]),
float(cols["close"][i]),
float(cols["volume"][i] or 0),
float(cols["amount"][i] or 0),
None if cols.get("turnover", [None] * n)[i] is None else float(cols["turnover"][i]),
None if cols.get("adj_factor", [None] * n)[i] is None else float(cols["adj_factor"][i]),
)
)
return out
def import_seed(
conn: duckdb.DuckDBPyConnection,
seed_path: Path | str,
*,
market: str = "cn",
category: str | None = None,
) -> SeedReport:
"""导入 seed 到 bars_1d。category 缺省按 symbol 规则分类(A股)。"""
path = Path(seed_path)
if not path.exists():
raise SeedError(f"seed 文件不存在:{path}")
rows = _rows_from_table(_read_table(path))
if not rows:
raise SeedError(f"seed 无数据行:{path}")
conn.begin()
try:
symbols = sorted({r[0] for r in rows})
dates = [r[1] for r in rows]
for symbol in symbols:
sym_rows = [r for r in rows if r[0] == symbol]
cat = category or classify_cn(symbol)
conn.execute(
"DELETE FROM bars_1d WHERE market=? AND category=? AND symbol=? "
"AND date BETWEEN ? AND ?",
[market, cat, symbol, min(dates), max(dates)],
)
conn.executemany(
"INSERT INTO bars_1d (market, category, symbol, date, open, high, low, "
"close, volume, amount, turnover, adj_factor) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)",
[(market, cat, *r) for r in sym_rows],
)
conn.commit()
except Exception:
conn.rollback()
raise
return SeedReport(
path=str(path),
rows=len(rows),
symbols=symbols,
date_min=min(dates),
date_max=max(dates),
)
+166
View File
@@ -0,0 +1,166 @@
"""update 命令的 ETL 编排(设计 §6/§7.3)。
幂等模式:以 (market, symbol, 日期区间) 粒度整区替换(事务内 DELETE+INSERT),
重跑任意次数结果一致。CLI 一次性场景允许事件循环内同步 DuckDB 调用
(§7.6 的线程池隔离约束针对 serve 常驻场景,M2 接入调度器时迁移)。
"""
from __future__ import annotations
import asyncio
from datetime import date
import duckdb
from ..sources.base import SourceAdapter, UpdateReport, full_year_calendar
from ..sources.classify import classify_cn
from .checkpoint import upsert_checkpoint
_CHUNK = 400 # 每次 fetch 的 symbol 数(TDX 一次全拉列表太大时分块)
async def update_securities(
conn: duckdb.DuckDBPyConnection, market: str, adapter: SourceAdapter
) -> UpdateReport:
rows = await adapter.fetch_securities(market)
conn.begin()
try:
conn.execute("DELETE FROM securities WHERE market=?", [market])
conn.executemany(
"INSERT INTO securities (market, symbol, name, category, exchange, currency, lot_size) "
"VALUES (?,?,?,?,?,?,?)",
[
(market, r.symbol, r.name, r.category, r.exchange, r.currency, r.lot_size)
for r in rows
],
)
conn.commit()
except Exception:
conn.rollback()
raise
upsert_checkpoint(conn, "securities", market, "all", "", len(rows))
return UpdateReport(dataset="securities", market=market, symbols=[r.symbol for r in rows], rows=len(rows))
async def update_calendar(
conn: duckdb.DuckDBPyConnection, market: str, adapter: SourceAdapter, years: list[int]
) -> UpdateReport:
"""calendar 落库恒为「整年逐日」:adapter 只需给出交易日(§5.2)。
源(tdx/fake)给出的是交易日集合,本函数负责补全全年(非交易日 is_open=False),
保证 calendar 表的语义唯一:任意一天查得到、is_open 可信。
"""
total = 0
for year in years:
rows = await adapter.fetch_calendar(market, year)
trade_dates = {r.trade_date for r in rows if r.is_open}
full = full_year_calendar(year, trade_dates)
conn.begin()
try:
conn.execute(
"DELETE FROM calendar WHERE market=? AND trade_date BETWEEN ? AND ?",
[market, date(year, 1, 1), date(year, 12, 31)],
)
conn.executemany(
"INSERT INTO calendar (market, trade_date, is_open, note) VALUES (?,?,?,?)",
[(market, r.trade_date, r.is_open, r.note) for r in full],
)
conn.commit()
except Exception:
conn.rollback()
raise
total += len(full)
open_rows = sum(1 for r in full if r.is_open)
upsert_checkpoint(conn, "calendar", market, str(year), date(year, 12, 31).isoformat(), open_rows)
return UpdateReport(dataset="calendar", market=market, rows=total)
async def update_bars_1d(
conn: duckdb.DuckDBPyConnection,
market: str,
adapter: SourceAdapter,
*,
symbols: list[str] | None = None,
start: date | None = None,
end: date | None = None,
) -> UpdateReport:
if symbols is None:
rows = conn.execute(
"SELECT symbol FROM securities WHERE market=? "
"AND category IN ('stock','index','etf','cbond') ORDER BY symbol",
[market],
).fetchall()
symbols = [r[0] for r in rows]
if not symbols:
raise RuntimeError(
"securities 表为空:请先 update --dataset securities 建证券主数据"
)
total_rows = 0
seen_dates: list[date] = []
for i in range(0, len(symbols), _CHUNK):
chunk = symbols[i : i + _CHUNK]
bars = await adapter.fetch_bars_1d(market, chunk, start, end)
conn.begin()
try:
for symbol in chunk:
sym_bars = [b for b in bars if b.symbol == symbol]
if not sym_bars:
continue
category = classify_cn(symbol) if market == "cn" else "stock"
d_min, d_max = min(b.date for b in sym_bars), max(b.date for b in sym_bars)
conn.execute(
"DELETE FROM bars_1d WHERE market=? AND category=? AND symbol=? "
"AND date BETWEEN ? AND ?",
[market, category, symbol, d_min, d_max],
)
conn.executemany(
"INSERT INTO bars_1d (market, category, symbol, date, open, high, low, "
"close, volume, amount, turnover, adj_factor) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)",
[
(market, category, b.symbol, b.date, b.open, b.high, b.low, b.close,
b.volume, b.amount, b.turnover, b.adj_factor)
for b in sym_bars
],
)
total_rows += len(sym_bars)
seen_dates.extend([b.date for b in sym_bars])
conn.commit()
except Exception:
conn.rollback()
raise
watermark = max(seen_dates).isoformat() if seen_dates else ""
upsert_checkpoint(conn, "bars_1d", market, "daily", watermark, total_rows)
return UpdateReport(
dataset="bars_1d", market=market, symbols=symbols, rows=total_rows,
date_min=min(seen_dates) if seen_dates else None,
date_max=max(seen_dates) if seen_dates else None,
)
async def run_update(
conn: duckdb.DuckDBPyConnection,
market: str,
adapter: SourceAdapter,
*,
datasets: list[str],
symbols: list[str] | None = None,
start: date | None = None,
end: date | None = None,
years: list[int] | None = None,
) -> list[UpdateReport]:
"""按依赖顺序编排:securities → calendar → bars_1d。"""
reports: list[UpdateReport] = []
if "securities" in datasets:
reports.append(await update_securities(conn, market, adapter))
if "calendar" in datasets:
reports.append(await update_calendar(conn, market, adapter, years or [date.today().year]))
if "bars_1d" in datasets:
reports.append(
await update_bars_1d(conn, market, adapter, symbols=symbols, start=start, end=end)
)
return reports
def run_update_sync(conn: duckdb.DuckDBPyConnection, market: str, adapter: SourceAdapter, **kw) -> list[UpdateReport]:
"""CLI 同步入口。"""
return asyncio.run(run_update(conn, market, adapter, **kw))
+29
View File
@@ -0,0 +1,29 @@
"""导出:csv/parquet 落盘(pandas/polars 走 /v1/query fmt=arrow)。"""
from .files import (
EXPORT_FORMATS,
ExportFormatError,
ExportPathError,
ExportResult,
get_export_job,
new_job_id,
record_export_job,
resolve_export_target,
run_query_arrow,
spec_hash,
write_export,
)
__all__ = [
"EXPORT_FORMATS",
"ExportFormatError",
"ExportPathError",
"ExportResult",
"get_export_job",
"new_job_id",
"record_export_job",
"resolve_export_target",
"run_query_arrow",
"spec_hash",
"write_export",
]
+133
View File
@@ -0,0 +1,133 @@
"""导出落盘(设计 §9)。
- export 只管落盘格式:csv / parquet(pandas/polars 走 /v1/query fmt=arrow 消费);
- 路径安全(评审 P1):输出根恒为 exports/{job_id}/,名称字段白名单字符过滤 +
resolve 后必须仍在 exports/ 前缀内;杜绝 ../ 穿出 dbpath;
- job 结果记 export_jobs 表(spec hash 缓存 24h 的键在 M2 worker 化时接入)。
"""
from __future__ import annotations
import hashlib
import json
import re
import uuid
from dataclasses import dataclass
from pathlib import Path
import duckdb
import pyarrow as pa
import pyarrow.csv as pacsv
import pyarrow.parquet as paparquet
_JOB_ID_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}$")
_FILENAME_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
EXPORT_FORMATS: frozenset[str] = frozenset({"csv", "parquet"})
class ExportPathError(ValueError):
pass
class ExportFormatError(ValueError):
pass
def new_job_id() -> str:
return uuid.uuid4().hex[:12]
def spec_hash(spec: dict) -> str:
"""导出请求的稳定指纹(缓存键,§9)。"""
canonical = json.dumps(spec, sort_keys=True, ensure_ascii=False)
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
def resolve_export_target(exports_dir: Path, job_id: str, filename: str) -> Path:
"""exports/{job_id}/{filename};白名单 + resolve 前缀校验(§9 路径安全)。
纵深防御:``_JOB_ID_RE`` / ``_FILENAME_RE`` 已禁掉 ``/`` 与 ``..``,因此常规
输入下 resolve 后必然在 exports/ 内。最后的 startswith 校验是为**符号链接**
(exports/{job_id} 被替换成指向外部的软链)兜底——该分支在无软链的环境里
结构性不可达,保留为防线而非死代码。
"""
if not _JOB_ID_RE.match(job_id):
raise ExportPathError(f"非法 job_id:{job_id!r}")
if not _FILENAME_RE.match(filename):
raise ExportPathError(f"非法导出文件名:{filename!r}")
exports_dir = Path(exports_dir).resolve()
target = (exports_dir / job_id / filename).resolve()
root_str = str(exports_dir).rstrip("\\/") + "\\"
posix_root = str(exports_dir).rstrip("\\/") + "/"
if not (str(target).startswith(root_str) or str(target).startswith(posix_root)):
raise ExportPathError(f"导出路径越界:{target}")
return target
@dataclass
class ExportResult:
path: Path
rows: int
bytes_written: int
fmt: str
def run_query_arrow(
conn: duckdb.DuckDBPyConnection, sql: str, params: list | None = None
) -> pa.Table:
"""执行查询返回 Arrow 表(查询/导出共用;调用方负责 sqlgate 校验与线程池)。"""
result = conn.execute(sql, params or [])
return result.arrow().read_all()
def write_export(table: pa.Table, fmt: str, target: Path) -> ExportResult:
if fmt not in EXPORT_FORMATS:
raise ExportFormatError(f"export 仅支持落盘格式 {sorted(EXPORT_FORMATS)},收到 {fmt!r}")
target.parent.mkdir(parents=True, exist_ok=True)
if fmt == "csv":
pacsv.write_csv(table, target)
else:
paparquet.write_table(table, target, compression="zstd")
size = target.stat().st_size
return ExportResult(path=target, rows=table.num_rows, bytes_written=size, fmt=fmt)
def record_export_job(
conn: duckdb.DuckDBPyConnection,
job_id: str,
*,
fmt: str,
path: str,
rows: int,
bytes_written: int,
state: str = "done",
spec_json: str = "{}",
) -> None:
conn.execute(
"INSERT OR REPLACE INTO export_jobs "
"(job_id, spec_json, fmt, path, rows, bytes, state, created_at, finished_at) "
"VALUES (?, ?, ?, ?, ?, ?, ?, now(), now())",
[job_id, spec_json, fmt, path, rows, bytes_written, state],
)
def get_export_job(conn: duckdb.DuckDBPyConnection, job_id: str) -> dict | None:
row = conn.execute(
"SELECT job_id, spec_json, fmt, path, rows, bytes, state, "
"created_at, finished_at FROM export_jobs WHERE job_id = ?",
[job_id],
).fetchone()
if row is None:
return None
return {
"job_id": row[0],
"spec_json": row[1],
"fmt": row[2],
"path": row[3],
"rows": row[4],
"bytes": row[5],
"state": row[6],
"created_at": None if row[7] is None else row[7].isoformat(),
"finished_at": None if row[8] is None else row[8].isoformat(),
}
+120
View File
@@ -0,0 +1,120 @@
"""单写者锁 quantdata.lock(设计 §11)。
判活 = PID + 进程 start time + boot_id 三元一致(防 PID 复用误判)。
发现陈旧锁:先备份 .lock.bak 再接管,并记日志。
"""
from __future__ import annotations
import json
import os
import shutil
import time
from dataclasses import dataclass
from pathlib import Path
import psutil
class LockHeldError(RuntimeError):
def __init__(self, info: "LockInfo") -> None:
self.info = info
super().__init__(
f"已有 quantdata 实例持有锁:PID={info.pid}( acquired_at={info.acquired_at})。"
f"如确认无实例在跑,可删除锁文件。"
)
@dataclass
class LockInfo:
pid: int
start_time: float
boot_id: float
acquired_at: str
cmd: str
def to_json(self) -> str:
return json.dumps(self.__dict__, ensure_ascii=False, indent=2)
@classmethod
def from_json(cls, text: str) -> "LockInfo":
d = json.loads(text)
return cls(
pid=int(d["pid"]),
start_time=float(d["start_time"]),
boot_id=float(d["boot_id"]),
acquired_at=str(d.get("acquired_at", "")),
cmd=str(d.get("cmd", "")),
)
def _boot_id() -> float:
"""boot 标识:psutil.boot_time() 秒级时间戳,Windows/Linux 通用。"""
return psutil.boot_time()
def _process_start_time(pid: int) -> float | None:
"""进程当前 start time;进程不存在返回 None。"""
try:
return psutil.Process(pid).create_time()
except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
return None
def is_alive(info: LockInfo, *, now_boot_id: float | None = None) -> bool:
"""三元判活:进程存在 + start_time 一致 + boot_id 一致。"""
now_boot_id = _boot_id() if now_boot_id is None else now_boot_id
if info.boot_id != now_boot_id:
return False # 重启过系统 → 一律陈旧
start = _process_start_time(info.pid)
if start is None:
return False
# start_time 允许极小浮点误差
return abs(start - info.start_time) < 0.01
def read_lock(path: Path) -> LockInfo | None:
try:
return LockInfo.from_json(path.read_text(encoding="utf-8"))
except FileNotFoundError:
return None
except (json.JSONDecodeError, KeyError, ValueError):
# 损坏的锁文件视为陈旧(半写状态)
return None
def acquire(lock_path: Path, *, cmd: str = "", acquired_at: str | None = None) -> LockInfo:
"""拿锁;活锁持有 → LockHeldError;陈旧/损坏锁 → 备份后接管。"""
existing = read_lock(lock_path)
if existing is not None and is_alive(existing):
raise LockHeldError(existing)
if existing is not None:
# 陈旧锁:先备份再接管(§11)
backup = lock_path.with_suffix(lock_path.suffix + ".bak")
shutil.copy2(lock_path, backup)
try:
print(f"[lock] 发现陈旧锁(PID={existing.pid} 已不存在),备份到 {backup} 后接管")
except OSError: # stdout 关闭等极端场景不阻塞拿锁
pass
lock_path.parent.mkdir(parents=True, exist_ok=True)
me = psutil.Process(os.getpid())
info = LockInfo(
pid=me.pid,
start_time=me.create_time(),
boot_id=_boot_id(),
acquired_at=acquired_at or time.strftime("%Y-%m-%dT%H:%M:%S%z"),
cmd=cmd,
)
lock_path.write_text(info.to_json(), encoding="utf-8")
return info
def release(lock_path: Path, info: LockInfo) -> bool:
"""释放锁:仅当锁内仍是自己(防止误删后来者的锁)才删除。"""
current = read_lock(lock_path)
if current is None:
return False
if current.pid == info.pid and abs(current.start_time - info.start_time) < 0.01:
lock_path.unlink(missing_ok=True)
return True
return False
+77
View File
@@ -0,0 +1,77 @@
"""dbpath 目录规范(设计 §3.1)。一切状态收敛在 -d 指定的 dbpath。"""
from __future__ import annotations
import os
from pathlib import Path
class DbPathLayout:
"""dbpath 内固定相对位置的访问器。不负责创建目录(init 时 ensure)。"""
def __init__(self, root: Path | str) -> None:
self.root = Path(root).resolve()
@property
def config_file(self) -> Path:
return self.root / "config.json"
@property
def catalog(self) -> Path:
return self.root / "catalog.duckdb"
@property
def data_dir(self) -> Path:
return self.root / "data"
@property
def scripts_dir(self) -> Path:
return self.root / "scripts"
@property
def exports_dir(self) -> Path:
return self.root / "exports"
@property
def logs_dir(self) -> Path:
return self.root / "logs"
@property
def tmp_dir(self) -> Path:
return self.root / "tmp"
@property
def lock_file(self) -> Path:
return self.root / "quantdata.lock"
@property
def trash_dir(self) -> Path:
"""compaction 两阶段协议的延迟删除区(M2 使用,目录先规范)。"""
return self.root / "data" / ".trash"
def ensure_dirs(self) -> list[Path]:
"""init 用:建全部目录,返回已确保存在的目录列表。幂等。"""
made: list[Path] = []
for d in (
self.root,
self.data_dir,
self.scripts_dir,
self.exports_dir,
self.logs_dir,
self.tmp_dir,
self.trash_dir,
):
if not d.exists():
d.mkdir(parents=True)
made.append(d)
return made
def resolve_dbpath(explicit: str | None) -> Path:
"""-d 显式指定优先;否则环境变量 QUANTDATA_HOME 兜底;都没有则报错。"""
if explicit:
return Path(explicit).resolve()
env = os.environ.get("QUANTDATA_HOME")
if env:
return Path(env).resolve()
raise SystemExit("缺少 dbpath:请用 -d /xxx/dbpath 或设置环境变量 QUANTDATA_HOME")
+29
View File
@@ -0,0 +1,29 @@
"""serve 常驻:FastAPI 网关、市场状态、鉴权、运行时。"""
from .app import AppContext, QueryRequest, ExportRequest, create_app
from .auth import (
SecurityError,
assert_security,
is_loopback,
mask_query_string,
mask_token,
token_ok,
)
from .state import MARKET_TZ, SESSIONS, MarketState, market_state
__all__ = [
"AppContext",
"ExportRequest",
"MARKET_TZ",
"MarketState",
"QueryRequest",
"SESSIONS",
"SecurityError",
"assert_security",
"create_app",
"is_loopback",
"mask_query_string",
"mask_token",
"market_state",
"token_ok",
]
+395
View File
@@ -0,0 +1,395 @@
"""FastAPI 服务网关(设计 §8):REST /v1/query /v1/export /v1/meta /v1/stats /v1/state + 探针。
执行模型(§7.6):查询一律线程池执行(事件循环零阻塞);
超时 = ``connection.interrupt()`` 真中断;并发信号量 + 等待超时 429(§8.3)。
"""
from __future__ import annotations
import asyncio
import base64
import time
from dataclasses import dataclass
from datetime import datetime, timezone
from pathlib import Path
from typing import Any
import duckdb
import psutil
import pyarrow as pa
from fastapi import Depends, FastAPI, Header, HTTPException
from fastapi.responses import FileResponse, JSONResponse
from pydantic import BaseModel, Field
from zoneinfo import ZoneInfo
from .. import __version__
from ..config import AppConfig
from ..export.files import (
EXPORT_FORMATS,
ExportPathError,
get_export_job,
new_job_id,
record_export_job,
resolve_export_target,
write_export,
)
from ..sqlgate import SqlRejected, validate
from .auth import token_ok
from .state import MARKET_TZ, market_state
class ResultTooLargeError(ValueError):
pass
class QueryTimeoutError(RuntimeError):
pass
@dataclass
class AppContext:
"""app 依赖注入载体。cursor 由调用方提供(serve 从写连接派生;测试注入)。"""
dbpath: Path
config: AppConfig
cursor: duckdb.DuckDBPyConnection
schema_version: int = 0
class QueryRequest(BaseModel):
sql: str
params: list[Any] = Field(default_factory=list)
fmt: str = "json" # json | arrow
max_rows: int | None = None
timeout_ms: int | None = None
class ExportRequest(BaseModel):
fmt: str # csv | parquet
sql: str
params: list[Any] = Field(default_factory=list)
filename: str | None = None
sync: bool = True
def execute_query_blocking(
cursor: duckdb.DuckDBPyConnection,
sql: str,
params: list[Any],
max_rows: int,
max_arrow_bytes: int,
) -> tuple[pa.Table, bool]:
"""线程池内执行:fetch Arrow → 上限校验 → 截断。返回 (table, truncated)。"""
result = cursor.execute(sql, params or [])
tbl = result.arrow().read_all()
if tbl.nbytes > max_arrow_bytes:
raise ResultTooLargeError(
f"结果 {tbl.nbytes} 字节超过上限 {max_arrow_bytes}:请改走 /v1/export(§8.3)"
)
truncated = tbl.num_rows > max_rows
if truncated:
tbl = tbl.slice(0, max_rows)
return tbl, truncated
def arrow_stream_b64(tbl: pa.Table) -> str:
"""Arrow IPC **streaming format** → base64(附录 A 解码路径)。"""
sink = pa.BufferOutputStream()
with pa.ipc.new_stream(sink, tbl.schema) as writer:
writer.write_table(tbl)
return base64.b64encode(sink.getvalue().to_pybytes()).decode("ascii")
def table_to_rows(tbl: pa.Table) -> list[list[Any]]:
if tbl.num_columns == 0:
return []
cols = [c.to_pylist() for c in tbl.columns]
return [list(row) for row in zip(*cols)]
def utc_now_iso() -> str:
"""ISO8601 UTC 带 Z(§8.2 全文统一)。"""
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
def query_response(
tbl: pa.Table, truncated: bool, elapsed_ms: int, fmt: str
) -> dict[str, Any]:
out: dict[str, Any] = {
"columns": tbl.schema.names,
"dtypes": [str(f.type) for f in tbl.schema],
"row_count": tbl.num_rows,
"elapsed_ms": elapsed_ms,
"truncated": truncated,
}
if fmt == "arrow":
out["b64_arrow"] = arrow_stream_b64(tbl)
else:
out["rows"] = table_to_rows(tbl)
return out
def disk_usage_bytes(root: Path) -> int:
return sum(p.stat().st_size for p in root.rglob("*") if p.is_file())
async def _run_with_timeout(
ctx: AppContext,
sql: str,
params: list[Any],
max_rows: int,
timeout_s: float,
) -> tuple[pa.Table, bool]:
"""线程池执行 + 超时真中断(§7.6)。query / export 共用同一执行语义。
不能用 ``asyncio.wait_for(to_thread(...))``:超时时 wait_for 会 cancel 那个
已成 future,随后收割阶段抛的 CancelledError 会逃逸出调用方的 except 分支
(Python 3.13 实测)。这里用 shield + 手动超时,超时后 interrupt 连接,
再把线程异常全部吞掉,只向外报 504。
"""
task = asyncio.ensure_future(
asyncio.to_thread(
execute_query_blocking, ctx.cursor, sql, params, max_rows, ctx.config.sql.max_arrow_bytes
)
)
done, _pending = await asyncio.wait({task}, timeout=timeout_s)
if not done:
ctx.cursor.interrupt() # 真中断:线程内查询被打断
try:
await asyncio.shield(task) # 收割线程异常,保证不悬空
except BaseException: # noqa: BLE001 — 中断/取消异常统一吞掉,对外只报 504
pass
raise HTTPException(
status_code=504, detail=f"查询超时(>{timeout_s:.1f}s),已 interrupt 中断"
)
return task.result()
def create_app(ctx: AppContext) -> FastAPI:
sql_cfg = ctx.config.sql
query_sem = asyncio.Semaphore(max(1, sql_cfg.max_concurrent))
def _validate_sql(sql: str) -> None:
try:
validate(sql, sql_cfg.allow_functions)
except SqlRejected as e:
raise HTTPException(status_code=400, detail=e.reason) from e
async def _acquire_query_slot() -> None:
try:
await asyncio.wait_for(query_sem.acquire(), timeout=sql_cfg.acquire_timeout_s)
except asyncio.TimeoutError as e:
raise HTTPException(
status_code=429,
detail=f"查询并发已达上限 {sql_cfg.max_concurrent},排队超时(§8.3)",
) from e
async def require_token(
authorization: str | None = Header(default=None),
) -> None:
provided = None
if authorization and authorization.startswith("Bearer "):
provided = authorization[len("Bearer ") :].strip()
if not token_ok(provided, ctx.config.http.token):
raise HTTPException(status_code=401, detail="invalid or missing token")
app = FastAPI(title="quantdata", version=__version__, docs_url="/docs")
# ---- 探针 ---------------------------------------------------------------
@app.get("/healthz")
def healthz() -> dict:
return {"status": "ok"}
@app.get("/v1/ready")
def ready() -> Any:
checks: dict[str, Any] = {}
try:
ctx.cursor.execute("SELECT 1")
checks["catalog"] = "ok"
except duckdb.Error as e:
checks["catalog"] = f"error: {e}"
checks["schema_version"] = ctx.schema_version
checks["schema"] = "ok" if ctx.schema_version >= 1 else "not_migrated"
free_pct: float | None = None
if ctx.dbpath.exists():
usage = psutil.disk_usage(str(ctx.dbpath))
free_pct = round(100.0 - usage.percent, 2)
checks["disk_free_pct"] = free_pct
disk_ok = free_pct is None or free_pct > 5.0 # <5% 硬阈值(§13)
if checks["catalog"] == "ok" and checks["schema"] == "ok" and disk_ok:
return {"ready": True, "checks": checks}
return JSONResponse(status_code=503, content={"ready": False, "checks": checks})
# ---- query ---------------------------------------------------------------
@app.post("/v1/query", dependencies=[Depends(require_token)])
async def query(body: QueryRequest) -> dict[str, Any]:
if body.fmt not in ("json", "arrow"):
raise HTTPException(status_code=422, detail=f"fmt 仅支持 json|arrow,收到 {body.fmt!r}")
_validate_sql(body.sql)
max_rows = min(body.max_rows or sql_cfg.max_rows, sql_cfg.max_rows)
timeout_s = (body.timeout_ms if body.timeout_ms is not None else sql_cfg.timeout_ms) / 1000
started = time.monotonic()
await _acquire_query_slot()
try:
tbl, truncated = await _run_with_timeout(
ctx, body.sql, body.params, max_rows, timeout_s
)
except ResultTooLargeError as e:
raise HTTPException(status_code=413, detail=str(e)) from e
except duckdb.Error as e:
if "interrupt" in str(e).lower():
raise HTTPException(status_code=504, detail=f"查询被中断:{e}") from e
raise HTTPException(status_code=400, detail=f"执行失败:{e}") from e
elapsed = int((time.monotonic() - started) * 1000)
return query_response(tbl, truncated, elapsed, body.fmt)
# ---- export(M1 同步路径:小导出直回文件流;job 化在 M2)--------------------
@app.post("/v1/export", dependencies=[Depends(require_token)])
async def export(body: ExportRequest) -> FileResponse:
if body.fmt not in EXPORT_FORMATS:
raise HTTPException(
status_code=422,
detail=(
f"export 仅支持落盘格式 {sorted(EXPORT_FORMATS)};"
f"pandas/polars 走 /v1/query fmt=arrow(§9 双语义归位)"
),
)
_validate_sql(body.sql)
timeout_s = sql_cfg.timeout_ms / 1000
await _acquire_query_slot()
try:
tbl, _truncated = await _run_with_timeout(
ctx, body.sql, body.params, sql_cfg.max_rows, timeout_s
)
except duckdb.Error as e:
raise HTTPException(status_code=400, detail=f"执行失败:{e}") from e
job_id = new_job_id()
filename = body.filename or f"export.{body.fmt}"
try:
target = resolve_export_target(
ctx.dbpath / ctx.config.export.out_dir, job_id, filename
)
except ExportPathError as e:
raise HTTPException(status_code=400, detail=str(e)) from e
result = await asyncio.to_thread(write_export, tbl, body.fmt, target)
record_export_job(
ctx.cursor,
job_id,
fmt=body.fmt,
path=str(target.relative_to(ctx.dbpath)),
rows=result.rows,
bytes_written=result.bytes_written,
)
media = "text/csv" if body.fmt == "csv" else "application/octet-stream"
return FileResponse(target, media_type=media, filename=filename)
@app.get("/v1/export/{job_id}", dependencies=[Depends(require_token)])
def export_job(job_id: str) -> dict:
job = get_export_job(ctx.cursor, job_id)
if job is None:
raise HTTPException(status_code=404, detail=f"导出任务不存在:{job_id}")
return job
# ---- meta / stats / state -------------------------------------------------
@app.get("/v1/meta", dependencies=[Depends(require_token)])
def meta() -> dict:
names = [
r[0]
for r in ctx.cursor.execute(
"SELECT table_name FROM information_schema.tables "
"WHERE table_schema='main' AND table_type='VIEW' ORDER BY table_name"
).fetchall()
]
views = []
for name in names:
info: dict[str, Any] = {"name": name}
info["columns"] = [
r[0]
for r in ctx.cursor.execute(
"SELECT column_name FROM information_schema.columns "
"WHERE table_schema='main' AND table_name=? ORDER BY ordinal_position",
[name],
).fetchall()
]
info["row_count"] = ctx.cursor.execute(f"SELECT count(*) FROM {name}").fetchone()[0]
cols = set(info["columns"])
if "date" in cols:
row = ctx.cursor.execute(
f"SELECT min(date), max(date) FROM {name}"
).fetchone()
info["date_min"] = None if row[0] is None else row[0].isoformat()
info["date_max"] = None if row[1] is None else row[1].isoformat()
if "symbol" in cols:
info["sample_symbols"] = [
r[0]
for r in ctx.cursor.execute(
f"SELECT DISTINCT symbol FROM {name} WHERE symbol IS NOT NULL LIMIT 3"
).fetchall()
]
views.append(info)
return {
"version": __version__,
"schema_version": ctx.schema_version,
"views": views,
}
@app.get("/v1/stats", dependencies=[Depends(require_token)])
def stats() -> dict:
cps = ctx.cursor.execute(
"SELECT dataset, market, scope, watermark, rows, status, updated_at "
"FROM etl_checkpoint ORDER BY dataset, market, scope"
).fetchall()
jobs = ctx.cursor.execute(
"SELECT state, count(*) FROM export_jobs GROUP BY state"
).fetchall()
usage = None
if ctx.dbpath.exists():
usage = {"bytes": disk_usage_bytes(ctx.dbpath)}
try:
du = psutil.disk_usage(str(ctx.dbpath))
usage["free_pct"] = round(100.0 - du.percent, 2)
except OSError:
usage["free_pct"] = None
return {
"checkpoints": [
{
"dataset": r[0], "market": r[1], "scope": r[2], "watermark": r[3],
"rows": r[4], "status": r[5],
"updated_at": None if r[6] is None else r[6].isoformat(),
}
for r in cps
],
"export_jobs": {state: n for state, n in jobs},
"disk": usage,
"http": {"ws_conns": 0}, # WS 在 M3;指标占位(§13)
}
@app.get("/v1/state/{market}", dependencies=[Depends(require_token)])
def market_state_endpoint(market: str) -> dict:
tz = MARKET_TZ.get(market)
if tz is None:
raise HTTPException(status_code=404, detail=f"未知市场:{market}")
now_local = datetime.now(ZoneInfo(tz))
row = ctx.cursor.execute(
"SELECT is_open FROM calendar WHERE market=? AND trade_date=?",
[market, now_local.date()],
).fetchone()
is_trading_day = bool(row[0]) if row else False
if row is None:
reason = "no_calendar_data"
else:
reason = None
hhmm = now_local.hour * 100 + now_local.minute
ms = market_state(market, hhmm, is_trading_day=is_trading_day)
if reason:
ms.reason = reason
return {
"market": market,
"state": ms.state,
"ts": utc_now_iso(),
"next_at": ms.next_at,
"session_tz": ms.session_tz,
"reason": ms.reason,
}
return app
+51
View File
@@ -0,0 +1,51 @@
"""鉴权与日志脱敏(设计 §8.4)。
- token 非空时:REST ``Authorization: Bearer <token>``;WS(M3)优先握手 Header;
- 非本机且 token 为空 → 拒绝启动(fail-fast,--insecure 显式放行);
- 日志对 token 统一脱敏(只留前 4 位)。
"""
from __future__ import annotations
import re
_LOOPBACK_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
_TOKEN_IN_URL = re.compile(r"(token=)([^&\s]{4})[^&\s]*")
def mask_token(token: str) -> str:
"""token 脱敏:留前 4 位 + ***;空串原样。"""
if not token:
return ""
return token[:4] + "***"
def mask_query_string(qs: str) -> str:
"""日志里的 ``?token=...`` / ``&token=...`` 统一脱敏(含 uvicorn access log 场景)。"""
return _TOKEN_IN_URL.sub(r"\1\2***", qs)
def is_loopback(host: str) -> bool:
return host in _LOOPBACK_HOSTS
def assert_security(host: str, token: str, *, insecure: bool) -> None:
"""启动强制校验(§8.4):非本机 + 空 token + 未显式 --insecure → 拒绝启动。"""
if is_loopback(host) or token or insecure:
return
raise SecurityError(
f"拒绝启动:监听地址 {host} 非 loopback 且 http.token 为空;"
f"请设置 token 或显式使用 --insecure(§8.4 fail-fast)"
)
class SecurityError(RuntimeError):
pass
def token_ok(provided: str | None, expected: str) -> bool:
"""expected 为空 = 不校验;否则必须精确匹配。"""
if not expected:
return True
return bool(provided) and provided == expected
+124
View File
@@ -0,0 +1,124 @@
"""serve 常驻主循环(设计 §7.1 / §7.6)。
启动序:拿锁 → 开库 + migrate → 安全校验 → 起 uvicorn(Server.serve() 挂同一
事件循环,不用 uvicorn.run() 自建循环)→ 前台常驻;SIGTERM/SIGINT 优雅退出。
bind 失败(端口被占)→ 打印占用者 PID 后非零退出(交 supervisord 退避重试)。
"""
from __future__ import annotations
import asyncio
from pathlib import Path
import uvicorn
from ..config import AppConfig, load_config
from ..lockfile import LockHeldError, acquire, release
from ..paths import DbPathLayout
from ..store import SchemaTooNewError, migrate, open_catalog
from .app import AppContext, create_app
from .auth import assert_security
# 退出码:0 正常 / 2 锁被占 / 3 schema 版本不兼容 / 4 安全校验拒绝 / 5 端口被占
EXIT_OK = 0
EXIT_LOCK_HELD = 2
EXIT_SCHEMA_TOO_NEW = 3
EXIT_SECURITY = 4
EXIT_PORT_BUSY = 5
def find_listener_pid(port: int) -> int | None:
"""找占用端口的进程 PID(尽力而为;psutil 未装/权限不足返回 None)。"""
try:
import psutil
for conn in psutil.net_connections(kind="inet"):
if conn.status == psutil.CONN_LISTEN and conn.laddr and conn.laddr.port == port:
return conn.pid
except Exception: # noqa: BLE001 — psutil 缺失/平台权限差异都按“找不到”处理
return None
return None
async def _serve_no_http(stop_event: asyncio.Event) -> None:
"""--no-http:纯 CLI 批处理常驻(M1 无调度器,等信号)。"""
await stop_event.wait()
async def run_serve(
dbpath: Path,
*,
host: str | None = None,
port: int | None = None,
no_http: bool = False,
insecure: bool = False,
config: AppConfig | None = None,
stop_event: asyncio.Event | None = None,
check_port: bool = True,
) -> int:
"""serve 主流程,返回进程退出码。真网 uvicorn 启停段按白名单豁免覆盖率。"""
layout = DbPathLayout(dbpath)
if not layout.root.exists():
print(f"[serve] dbpath 不存在:{layout.root}(先 quantdata init)")
return 1
cfg = config or load_config(layout.config_file)
host = host or cfg.http.host
port = port or cfg.http.port
# 1. 单写者锁(§11)
try:
lock = acquire(layout.lock_file, cmd="quantdata serve")
except LockHeldError as e:
print(f"[serve] 拒绝启动:{e}")
return EXIT_LOCK_HELD
try:
# 2. 开库 + migrate(版本 > 代码已知最高版 → 拒启)
conn = open_catalog(layout.root)
try:
schema_version = migrate(conn)
except SchemaTooNewError as e:
print(f"[serve] {e}")
return EXIT_SCHEMA_TOO_NEW
# 4. 安全校验(§8.4 fail-fast)
try:
assert_security(host, cfg.http.token, insecure=insecure)
except Exception as e:
print(f"[serve] {e}")
return EXIT_SECURITY
# 3/4. 起网关(--no-http 跳过)
if no_http:
await _serve_no_http(stop_event or asyncio.Event())
return EXIT_OK
if check_port:
listener = find_listener_pid(port)
if listener is not None:
print(f"[serve] 端口 {port} 已被占用(PID={listener}),退出非零交 supervisord 重试")
return EXIT_PORT_BUSY
cursor = conn.cursor()
cursor.execute("SET autoinstall_known_extensions=false")
cursor.execute("SET autoload_known_extensions=false")
ctx = AppContext(
dbpath=layout.root, config=cfg, cursor=cursor, schema_version=schema_version
)
app = create_app(ctx)
uv_config = uvicorn.Config(
app, host=host, port=port, log_level=cfg.log.level.lower(),
timeout_graceful_shutdown=30, # 优雅退出预算 30s(§7.1)
)
server = uvicorn.Server(uv_config)
# 真 uvicorn 起服 / socket 层:§14 白名单豁免(平台相关,本机踩过 socketpair
# 死锁)。替代验证 = [CI] 验收链用 CLI 起真 serve + 真端口 curl(覆盖本函数
# 的编排层,只是不把 socket 段记入行覆盖)+ 每周 smoke workflow(DP-2 v0.7)。
await server.serve() # pragma: no cover # 挂同一事件循环(§7.6 第 3 条)
return EXIT_OK
finally:
try:
conn.close()
except Exception:
pass
release(layout.lock_file, lock)
+64
View File
@@ -0,0 +1,64 @@
"""市场状态机纯函数(设计 §10.2 的 M1 简版:日历 + 时段推导,无网络依赖)。
纯本地确定性推导:is_trading_day 由 calendar 表提供;时段规则表内置。
StateEngine 完整事件机(迁移推流)在 M2 接入 serve 调度器。
"""
from __future__ import annotations
from dataclasses import dataclass
MARKET_TZ: dict[str, str] = {
"cn": "Asia/Shanghai",
"us": "America/New_York",
"hk": "Asia/Hong_Kong",
}
# (开, 收) 本地时间,24h 制;M1 不含美股盘前盘后(可扩展)
SESSIONS: dict[str, tuple[tuple[str, str], ...]] = {
"cn": (("09:30", "11:30"), ("13:00", "15:00")),
"hk": (("09:30", "12:00"), ("13:00", "16:00")),
"us": (("09:30", "16:00"),),
}
_AUCTION_START = "09:15" # A股集合竞价
_MORNING_OPEN = "09:30"
@dataclass(slots=True)
class MarketState:
market: str
state: str # CLOSED / PRE_OPEN_AUCTION / OPEN / LUNCH_BREAK
session_tz: str
reason: str
next_at: str | None = None # 本地时间 "HH:MM"
def _hhmm(s: str) -> int:
"""'HH:MM' → HHMM 整数(与 market_state 入参口径一致,如 '09:30' → 930)。"""
h, m = s.split(":")
return int(h) * 100 + int(m)
def market_state(market: str, now_local_hhmm: int, *, is_trading_day: bool) -> MarketState:
"""给定交易所本地 ``HHMM`` 整数(如 930、1301)与是否交易日,确定性推导状态。
参数化时间点便于测试全部边界(开盘/午休/收盘/竞价/节假日)。
"""
tz = MARKET_TZ.get(market, "Asia/Shanghai")
if market not in SESSIONS:
raise KeyError(f"未知市场:{market}")
if not is_trading_day:
return MarketState(market, "CLOSED", tz, "non_trading_day")
sessions = SESSIONS[market]
if market == "cn" and _hhmm(_AUCTION_START) <= now_local_hhmm < _hhmm(_MORNING_OPEN):
return MarketState(market, "PRE_OPEN_AUCTION", tz, "session_rule", _MORNING_OPEN)
for open_s, close_s in sessions:
if _hhmm(open_s) <= now_local_hhmm < _hhmm(close_s):
return MarketState(market, "OPEN", tz, "session_rule", close_s)
# 午休:第一段收后到第二段开前(单段市场无午休)
first_close = _hhmm(sessions[0][1])
second_open = _hhmm(sessions[1][0]) if len(sessions) > 1 else None
if second_open is not None and first_close <= now_local_hhmm < second_open:
return MarketState(market, "LUNCH_BREAK", tz, "session_rule", sessions[1][0])
return MarketState(market, "CLOSED", tz, "session_rule", sessions[0][0])
+24
View File
@@ -0,0 +1,24 @@
"""数据源适配层:SourceAdapter 协议、A股分类、pytdxdata 适配器。"""
from .base import (
Bar1dRow,
CalendarRow,
FakeAdapter,
SecurityRow,
SourceAdapter,
UpdateReport,
)
from .classify import classify_cn, exchange_of
from .tdx import TdxAdapter
__all__ = [
"Bar1dRow",
"CalendarRow",
"FakeAdapter",
"SecurityRow",
"SourceAdapter",
"TdxAdapter",
"UpdateReport",
"classify_cn",
"exchange_of",
]
+124
View File
@@ -0,0 +1,124 @@
"""SourceAdapter 协议与行模型(设计 §5)。
适配层产出统一行模型,ETL 只认行模型;真实源(tdx)与测试源(fake)同构。
fixtures 录制回放 + 故障注入的宿主也在这一层(M2 完善限速/退避)。
"""
from __future__ import annotations
import calendar as _calendar
from dataclasses import dataclass, field
from datetime import date
from typing import Protocol, runtime_checkable
@dataclass(slots=True)
class SecurityRow:
symbol: str
name: str
category: str
exchange: str
currency: str = "CNY"
lot_size: int | None = None
@dataclass(slots=True)
class CalendarRow:
trade_date: date
is_open: bool
note: str = ""
@dataclass(slots=True)
class Bar1dRow:
symbol: str
date: date
open: float
high: float
low: float
close: float
volume: float = 0.0
amount: float = 0.0
turnover: float | None = None
adj_factor: float | None = None
@dataclass(slots=True)
class UpdateReport:
dataset: str
market: str
symbols: list[str] = field(default_factory=list)
rows: int = 0
date_min: date | None = None
date_max: date | None = None
def full_year_calendar(year: int, trade_dates: set[date]) -> list[CalendarRow]:
"""把「交易日集合」补全为「整年逐日」日历(§5.2)。
源只负责说清哪些天开市;补全全年是 ETL 的职责,保证 calendar 表语义唯一:
任意一天都查得到,is_open 可信。
"""
rows: list[CalendarRow] = []
for month in range(1, 13):
for day in range(1, _calendar.monthrange(year, month)[1] + 1):
d = date(year, month, day)
rows.append(CalendarRow(trade_date=d, is_open=d in trade_dates))
return rows
@runtime_checkable
class SourceAdapter(Protocol):
name: str
capabilities: frozenset[str]
async def fetch_securities(self, market: str) -> list[SecurityRow]: ...
async def fetch_bars_1d(
self, market: str, symbols: list[str], start: date | None, end: date | None
) -> list[Bar1dRow]: ...
async def fetch_calendar(self, market: str, year: int) -> list[CalendarRow]: ...
class FakeAdapter:
"""确定性测试源:可注入任意行;不打真网([CI] 层数据走 seed,本源供单测与 CLI 替身)。"""
name = "fake"
capabilities = frozenset({"securities", "bars_1d", "calendar"})
def __init__(
self,
securities: list[SecurityRow] | None = None,
bars: list[Bar1dRow] | None = None,
calendar: dict[int, list[CalendarRow]] | None = None,
) -> None:
self.securities = securities or []
self.bars = bars or []
self.calendar = calendar or {}
self.calls: list[tuple] = []
async def open(self) -> None:
self.calls.append(("open",))
async def close(self) -> None:
self.calls.append(("close",))
async def fetch_securities(self, market: str) -> list[SecurityRow]:
self.calls.append(("securities", market))
return list(self.securities)
async def fetch_bars_1d(
self, market: str, symbols: list[str], start: date | None, end: date | None
) -> list[Bar1dRow]:
self.calls.append(("bars_1d", market, tuple(symbols), start, end))
sym_set = set(symbols)
return [
b
for b in self.bars
if b.symbol in sym_set and (start is None or b.date >= start) and (end is None or b.date <= end)
]
async def fetch_calendar(self, market: str, year: int) -> list[CalendarRow]:
self.calls.append(("calendar", market, year))
return list(self.calendar.get(year, []))
+31
View File
@@ -0,0 +1,31 @@
"""A股证券分类(纯函数,表驱动)。symbol 规范 = pytdxdata 形态:sh600000 / sz000001 / bj430047。"""
from __future__ import annotations
# (category, 前缀元组) —— 顺序敏感:先长/特例后短/泛化
_CLASSIFY_RULES: tuple[tuple[str, tuple[str, ...]], ...] = (
("index", ("sh000", "sh899", "sz399", "sz395")),
("reits", ("sh508",)),
("etf", ("sh50", "sh51", "sh56", "sh58", "sz15", "sz16", "sz18")),
("cbond", ("sh10", "sh11", "sh12", "sz12")),
("stock", ("sh60", "sh68", "sz00", "sz30", "sz20")),
("stock", ("bj",)),
)
def classify_cn(symbol: str) -> str:
"""按 symbol 前缀归类 A股品类;未匹配归 other(绝不猜)。"""
s = symbol.strip().lower()
for category, prefixes in _CLASSIFY_RULES:
if any(s.startswith(p) for p in prefixes):
return category
return "other"
def exchange_of(symbol: str) -> str:
"""sh/sz/bj 前缀即交易所;无法识别返回空串。"""
s = symbol.strip().lower()
for ex in ("sh", "sz", "bj"):
if s.startswith(ex):
return ex
return ""
+116
View File
@@ -0,0 +1,116 @@
"""pytdxdata 适配器(主源,设计 §5.2)。
pytdxdata 是纯 asyncio 客户端(动态连接池),本适配器只做模型映射与调度编排;
TDX 断连/坏节点重连由 pytdxdata 内建(评审 P2),这里不重复造。
"""
from __future__ import annotations
from datetime import date, datetime
from pytdxdata import Adjust, KlinePeriod, TdxData
from pytdxdata.models import SecurityBar, SecurityInfo
from .base import Bar1dRow, CalendarRow, SecurityRow, full_year_calendar
from .classify import classify_cn, exchange_of
_MARKET_PREFIXES = ("sh", "sz", "bj")
def info_to_row(info: SecurityInfo) -> SecurityRow:
"""SecurityInfo → 统一行(category 用规则分类,kind 仅作参考不直接入库)。"""
symbol = info.symbol or ""
return SecurityRow(
symbol=symbol,
name=info.name,
category=classify_cn(symbol),
exchange=exchange_of(symbol),
currency="CNY",
lot_size=int(info.volunit) if info.volunit else None,
)
def bar_to_row(bar: SecurityBar) -> Bar1dRow:
return Bar1dRow(
symbol=bar.symbol,
date=date(bar.year, bar.month, bar.day),
open=bar.open,
high=bar.high,
low=bar.low,
close=bar.close,
volume=bar.vol,
amount=bar.amount,
)
def year_calendar_rows(year: int, trade_dates: set[date]) -> list[CalendarRow]:
"""从交易日集合合成全年日历(复用 base.full_year_calendar,§5.2)。"""
return full_year_calendar(year, trade_dates)
class TdxAdapter:
name = "tdx"
capabilities = frozenset({"securities", "bars_1d", "calendar"})
def __init__(self, client: TdxData | None = None) -> None:
self._client = client
self._owns_client = client is None
async def open(self) -> None:
if self._client is None:
self._client = TdxData()
if self._owns_client:
await self._client.start()
async def close(self) -> None:
if self._client is not None and self._owns_client:
await self._client.close()
self._owns_client = False
def _require(self) -> TdxData:
if self._client is None:
raise RuntimeError("TdxAdapter 未打开:先 await adapter.open()(或注入 client)")
return self._client
async def fetch_securities(self, market: str) -> list[SecurityRow]:
client = self._require()
if market != "cn":
return []
rows: list[SecurityRow] = []
seen: set[str] = set()
for prefix in _MARKET_PREFIXES:
for info in await client.get_universe(prefix):
if info.symbol and info.symbol not in seen:
seen.add(info.symbol)
rows.append(info_to_row(info))
return rows
async def fetch_bars_1d(
self, market: str, symbols: list[str], start: date | None, end: date | None
) -> list[Bar1dRow]:
client = self._require()
if market != "cn" or not symbols:
return []
bars = await client.get_bars(
symbols,
KlinePeriod.DAY,
adjust=Adjust.NONE, # 存不复权原始价(§4.3)
start_date=datetime(start.year, start.month, start.day) if start else None,
end_date=datetime(end.year, end.month, end.day) if end else None,
)
return [bar_to_row(b) for b in bars if b.symbol]
async def fetch_calendar(self, market: str, year: int) -> list[CalendarRow]:
"""TDX 交易日回调校验:用上证指数日K日期序列当交易日全集(§5.2)。"""
client = self._require()
if market != "cn":
return []
bars = await client.get_bars(
"sh000001",
KlinePeriod.DAY,
adjust=Adjust.NONE,
start_date=datetime(year, 1, 1),
end_date=datetime(year, 12, 31),
)
trade_dates = {date(b.year, b.month, b.day) for b in bars}
return year_calendar_rows(year, trade_dates)
+5
View File
@@ -0,0 +1,5 @@
"""SQL 闸:query_sql 安全约束(§8.3)。"""
from .gate import FORBIDDEN_FUNCTIONS, SqlRejected, validate
__all__ = ["FORBIDDEN_FUNCTIONS", "SqlRejected", "validate"]
+119
View File
@@ -0,0 +1,119 @@
"""query_sql 安全闸(设计 §8.3,评审 P0/P1 多条)。
六条闸:
1. 只读连接 + 扩展自动加载关闭(store/db.configure_query_conn);
2. 语句白名单:sqlglot fail-closed(解析失败一律拒)、dialect=duckdb、
AST 根节点判定(非字符串前缀)、多语句拒绝(parse_all 长度必须 =1);
3. 函数/表函数默认拒绝:显式拒 read_csv / read_parquet / *_scan / glob /
getenv / current_setting 等文件·网络·环境函数;FROM/JOIN 出现表函数直接拒;
``allow_functions`` 语义 = 额外放行清单(不是清空即全放行的总开关);
4. 结果上限(执行层 max_rows / arrow bytes);
5. 超时与并发闸(执行层线程池 + interrupt + 信号量);
6. 防御参数(SET max_expression_depth)。
sqlglot 进 lock pin 版本(pyproject >=,< 由 lock 冻结),升级须过本模块回归测试。
"""
from __future__ import annotations
import sqlglot
from sqlglot import exp
_DIALECT = "duckdb"
# 显式拒绝的函数(文件/网络/环境注入面),小写;`*_scan` 走后缀规则
FORBIDDEN_FUNCTIONS: frozenset[str] = frozenset(
{
"read_csv",
"read_csv_auto",
"read_parquet",
"read_json",
"read_json_auto",
"read_ndjson",
"read_text",
"glob",
"getenv",
"current_setting",
"iceberg_scan",
"delta_scan",
}
)
_SCAN_SUFFIX = "_scan"
# 允许的 AST 根节点:纯读取查询(CTE 附着在 Select 上)
_ALLOWED_ROOTS: tuple[type[exp.Expression], ...] = (
exp.Select,
exp.Union,
exp.Intersect,
exp.Except,
exp.Subquery,
)
class SqlRejected(ValueError):
"""SQL 被安全闸拒绝。reason 面向调用方,可直接进 HTTP 400 detail。"""
def __init__(self, reason: str) -> None:
self.reason = reason
super().__init__(reason)
def _func_name(node: exp.Expression) -> str | None:
if isinstance(node, exp.Anonymous):
return str(node.name).lower()
if isinstance(node, exp.Func):
return node.sql_name().lower()
return None
def _check_root(stmt: exp.Expression) -> None:
if not isinstance(stmt, _ALLOWED_ROOTS):
raise SqlRejected(f"仅允许只读查询(SELECT/UNION),收到:{type(stmt).__name__}")
def _check_from_tables(stmt: exp.Expression) -> None:
"""FROM/JOIN 出现函数(表函数)一律拒绝:库内视图都是普通表引用。"""
for table in stmt.find_all(exp.Table):
if not isinstance(table.this, exp.Identifier):
raise SqlRejected(
f"FROM/JOIN 仅允许库内普通表或视图,发现表函数:{table.sql(dialect=_DIALECT)}"
)
def _check_functions(stmt: exp.Expression, allow_functions: list[str]) -> None:
allowed = {a.lower().strip() for a in allow_functions if a.strip()}
for node in stmt.walk():
name = _func_name(node)
if name is None:
continue
if name in FORBIDDEN_FUNCTIONS and name not in allowed:
raise SqlRejected(
f"函数默认拒绝(文件/网络/环境注入面):{name};"
f"确需放行请在 config sql.allow_functions 显式加入(§8.3)"
)
if name.endswith(_SCAN_SUFFIX) and name not in allowed:
raise SqlRejected(f"函数默认拒绝(*_scan 表函数):{name}")
def parse_one(sql: str) -> exp.Expression:
"""fail-closed 解析:任何解析失败/空语句/多语句 → SqlRejected。"""
if not sql or not sql.strip():
raise SqlRejected("空 SQL")
try:
statements = sqlglot.parse(sql, read=_DIALECT)
except Exception as e: # sqlglot.errors.ParseError 及一切解析期异常
raise SqlRejected(f"SQL 解析失败(fail-closed):{e}") from e
if len(statements) != 1 or statements[0] is None:
raise SqlRejected(f"必须且只能包含一条语句,收到 {len(statements)} 条(多语句拒绝)")
return statements[0]
def validate(sql: str, allow_functions: list[str] | None = None) -> exp.Expression:
"""通过全部闸则返回解析后的 AST;否则抛 SqlRejected。"""
allow_functions = allow_functions or []
stmt = parse_one(sql)
_check_root(stmt)
_check_from_tables(stmt)
_check_functions(stmt, allow_functions)
return stmt
+23
View File
@@ -0,0 +1,23 @@
"""存储层:DuckDB 连接、migrations、联邦视图。"""
from .db import CatalogNotInitialized, configure_query_conn, open_catalog
from .migrations import (
KNOWN_MAX_VERSION,
MIGRATIONS,
SchemaTooNewError,
applied_versions,
current_version,
migrate,
)
__all__ = [
"CatalogNotInitialized",
"KNOWN_MAX_VERSION",
"MIGRATIONS",
"SchemaTooNewError",
"applied_versions",
"configure_query_conn",
"current_version",
"migrate",
"open_catalog",
]
+31
View File
@@ -0,0 +1,31 @@
"""DuckDB 连接管理:写连接(init/ETL/serve)与只读连接(查询/导出)分离(§8.3)。"""
from __future__ import annotations
from pathlib import Path
import duckdb
class CatalogNotInitialized(RuntimeError):
pass
def open_catalog(dbpath: Path, *, read_only: bool = False) -> duckdb.DuckDBPyConnection:
"""打开 catalog.duckdb。只读模式要求库已存在(未初始化给清晰报错)。"""
catalog = Path(dbpath) / "catalog.duckdb"
if read_only and not catalog.exists():
raise CatalogNotInitialized(
f"{catalog} 不存在:库未初始化,请先执行 quantdata init -d {dbpath}"
)
return duckdb.connect(str(catalog), read_only=read_only)
def configure_query_conn(
conn: duckdb.DuckDBPyConnection, *, memory_limit: str = "2GB"
) -> None:
"""查询连接安全预设(§8.3):断扩展自动加载(堵 httpfs 出站)+ 内存上限。"""
conn.execute("SET autoinstall_known_extensions=false")
conn.execute("SET autoload_known_extensions=false")
conn.execute(f"SET memory_limit='{memory_limit}'")
conn.execute("SET max_expression_depth=1000")
+259
View File
@@ -0,0 +1,259 @@
"""schema_migrations 版本管理(设计 §11 / §3.3)。
- 每个迁移在事务内执行(失败回滚);
- 库版本 > 代码已知最高版 → 报错退出(不带病跑);
- 视图 DDL 纳入迁移(评审 P1)。
"""
from __future__ import annotations
import duckdb
from .views import all_day_views
MIGRATION_0001_STATEMENTS: tuple[str, ...] = (
# ---- 参考数据 -------------------------------------------------------
"""
CREATE TABLE exchanges (
exchange_code VARCHAR PRIMARY KEY,
name VARCHAR NOT NULL,
market VARCHAR NOT NULL,
timezone VARCHAR NOT NULL,
session_json VARCHAR NOT NULL DEFAULT '{}'
)
""",
"""
CREATE TABLE securities (
market VARCHAR NOT NULL,
symbol VARCHAR NOT NULL,
name VARCHAR NOT NULL DEFAULT '',
category VARCHAR NOT NULL,
exchange VARCHAR NOT NULL DEFAULT '',
list_date DATE,
delist_date DATE,
currency VARCHAR NOT NULL DEFAULT '',
lot_size BIGINT,
underlying VARCHAR,
strike DOUBLE,
maturity DATE,
PRIMARY KEY (market, symbol)
)
""",
"""
CREATE TABLE calendar (
market VARCHAR NOT NULL,
trade_date DATE NOT NULL,
is_open BOOLEAN NOT NULL,
note VARCHAR NOT NULL DEFAULT '',
PRIMARY KEY (market, trade_date)
)
""",
"""
CREATE TABLE corp_actions (
market VARCHAR NOT NULL,
symbol VARCHAR NOT NULL,
ex_date DATE NOT NULL,
type VARCHAR NOT NULL,
ratio DOUBLE,
cash_div DOUBLE,
PRIMARY KEY (market, symbol, ex_date, type)
)
""",
# 申万 SCD2:官方发新版/追溯修订 → 开新 version(评审 P2)
"""
CREATE TABLE sw_industry (
version VARCHAR NOT NULL,
symbol VARCHAR NOT NULL,
l1 VARCHAR NOT NULL DEFAULT '',
l2 VARCHAR NOT NULL DEFAULT '',
l3 VARCHAR NOT NULL DEFAULT '',
effective_from DATE,
effective_to DATE
)
""",
"""
CREATE TABLE stock_status (
symbol VARCHAR NOT NULL,
date DATE NOT NULL,
is_st BOOLEAN NOT NULL DEFAULT FALSE,
st_reason VARCHAR NOT NULL DEFAULT '',
is_suspended BOOLEAN NOT NULL DEFAULT FALSE,
limit_up DOUBLE,
limit_down DOUBLE,
pct_limit DOUBLE,
source VARCHAR NOT NULL DEFAULT '',
PRIMARY KEY (symbol, date)
)
""",
"""
CREATE TABLE futures_meta (
symbol VARCHAR PRIMARY KEY,
contract VARCHAR NOT NULL DEFAULT '',
multiplier DOUBLE,
expiry DATE,
daily_limit_rule VARCHAR NOT NULL DEFAULT ''
)
""",
# ---- 行情(日K;1m 在 parquet,M2)-----------------------------------
"""
CREATE TABLE bars_1d (
market VARCHAR NOT NULL,
category VARCHAR NOT NULL,
symbol VARCHAR NOT NULL,
date DATE NOT NULL,
open DOUBLE NOT NULL,
high DOUBLE NOT NULL,
low DOUBLE NOT NULL,
close DOUBLE NOT NULL,
volume DOUBLE NOT NULL DEFAULT 0,
amount DOUBLE NOT NULL DEFAULT 0,
turnover DOUBLE,
adj_factor DOUBLE,
PRIMARY KEY (market, category, symbol, date)
)
""",
# ---- 信息流 ----------------------------------------------------------
"""
CREATE TABLE announcements (
id VARCHAR PRIMARY KEY,
symbol VARCHAR NOT NULL DEFAULT '',
title VARCHAR NOT NULL DEFAULT '',
category VARCHAR NOT NULL DEFAULT '',
publish_ts TIMESTAMPTZ,
url VARCHAR NOT NULL DEFAULT '',
source VARCHAR NOT NULL DEFAULT '',
hash VARCHAR NOT NULL DEFAULT ''
)
""",
"""
CREATE TABLE reports (
id VARCHAR PRIMARY KEY,
symbol VARCHAR NOT NULL DEFAULT '',
org VARCHAR NOT NULL DEFAULT '',
analyst VARCHAR NOT NULL DEFAULT '',
rating VARCHAR NOT NULL DEFAULT '',
title VARCHAR NOT NULL DEFAULT '',
publish_ts TIMESTAMPTZ,
url VARCHAR NOT NULL DEFAULT '',
source VARCHAR NOT NULL DEFAULT ''
)
""",
# 分钟新闻(NewsBridge 落库;断线补偿游标,评审 P1 补 DDL)
"""
CREATE TABLE news (
id VARCHAR PRIMARY KEY,
ts TIMESTAMPTZ NOT NULL,
source VARCHAR NOT NULL DEFAULT '',
market VARCHAR NOT NULL DEFAULT '',
symbols_json VARCHAR NOT NULL DEFAULT '[]',
level VARCHAR NOT NULL DEFAULT 'normal',
title VARCHAR NOT NULL DEFAULT '',
url VARCHAR NOT NULL DEFAULT '',
hash VARCHAR NOT NULL DEFAULT ''
)
""",
# ---- 运行时元数据 ------------------------------------------------------
"""
CREATE TABLE etl_checkpoint (
dataset VARCHAR NOT NULL,
market VARCHAR NOT NULL,
scope VARCHAR NOT NULL,
watermark VARCHAR NOT NULL,
rows BIGINT NOT NULL DEFAULT 0,
status VARCHAR NOT NULL DEFAULT 'ok',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (dataset, market, scope)
)
""",
"""
CREATE TABLE export_jobs (
job_id VARCHAR PRIMARY KEY,
spec_json VARCHAR NOT NULL DEFAULT '{}',
fmt VARCHAR NOT NULL,
path VARCHAR NOT NULL DEFAULT '',
rows BIGINT,
bytes BIGINT,
state VARCHAR NOT NULL DEFAULT 'queued',
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
finished_at TIMESTAMPTZ
)
""",
"""
CREATE TABLE quality_reports (
date DATE NOT NULL,
market VARCHAR NOT NULL,
check_name VARCHAR NOT NULL,
result VARCHAR NOT NULL,
detail_json VARCHAR NOT NULL DEFAULT '{}',
PRIMARY KEY (date, market, check_name)
)
""",
*all_day_views(),
)
# (版本, 名称, 语句元组) —— 追加新迁移时只往列表尾部加。
# DuckDB 的 execute() 一次只吃一条语句,故迁移以「语句元组」为单位逐条执行。
MIGRATIONS: tuple[tuple[int, str, tuple[str, ...]], ...] = (
(1, "0001_initial", MIGRATION_0001_STATEMENTS),
)
KNOWN_MAX_VERSION = MIGRATIONS[-1][0]
class SchemaTooNewError(RuntimeError):
"""库 schema 版本 > 代码已知最高版:拒绝启动(§11,不带病跑)。"""
def __init__(self, db_version: int, known_max: int) -> None:
self.db_version = db_version
self.known_max = known_max
super().__init__(
f"catalog.duckdb schema 版本 {db_version} 高于代码已知最高版 {known_max}:"
f"请升级 pyquantdata 后再启动(§11 不带病跑)"
)
def _ensure_migrations_table(conn: duckdb.DuckDBPyConnection) -> None:
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
"version INTEGER PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT now())"
)
def current_version(conn: duckdb.DuckDBPyConnection) -> int:
"""当前库版本;空库(无 schema_migrations 表)返回 0。"""
has_table = conn.execute(
"SELECT count(*) FROM information_schema.tables "
"WHERE table_schema='main' AND table_name='schema_migrations'"
).fetchone()
if not has_table or has_table[0] == 0:
return 0
row = conn.execute("SELECT max(version) FROM schema_migrations").fetchone()
return int(row[0]) if row and row[0] is not None else 0
def migrate(conn: duckdb.DuckDBPyConnection) -> int:
"""把库升到代码已知最高版,返回最终版本。幂等:已应用过则跳过。"""
_ensure_migrations_table(conn)
db_version = current_version(conn)
if db_version > KNOWN_MAX_VERSION:
raise SchemaTooNewError(db_version, KNOWN_MAX_VERSION)
for version, _name, statements in MIGRATIONS:
if version <= db_version:
continue
conn.begin()
try:
for stmt in statements:
conn.execute(stmt)
conn.execute("INSERT INTO schema_migrations (version) VALUES (?)", [version])
conn.commit()
except Exception:
conn.rollback()
raise
return current_version(conn)
def applied_versions(conn: duckdb.DuckDBPyConnection) -> list[int]:
_ensure_migrations_table(conn)
rows = conn.execute("SELECT version FROM schema_migrations ORDER BY version").fetchall()
return [int(r[0]) for r in rows]
+36
View File
@@ -0,0 +1,36 @@
"""联邦视图 DDL(设计 §3.3)。视图全部纳入 schema_migrations(评审 P1)。
规则:
- 显式列名,禁 ``*``(union/视图列错位不报错的隐患直接堵死);
- bars_1m 系视图 M2 加(1m 数据 M2 回填;视图 DDL 跟 migration 版本走)。
"""
from __future__ import annotations
_BAR_COLUMNS = (
"market, category, symbol, date, open, high, low, close, volume, amount, turnover, adj_factor"
)
# (view_name, market, category) —— M1 只做日K视图(数据在 bars_1d 物理表)
DAY_VIEWS: tuple[tuple[str, str, str], ...] = (
("cn_stock_1d", "cn", "stock"),
("cn_index_1d", "cn", "index"),
("cn_etf_1d", "cn", "etf"),
("cn_cbond_1d", "cn", "cbond"),
("us_stock_1d", "us", "stock"),
("us_index_1d", "us", "index"),
("hk_stock_1d", "hk", "stock"),
("hk_index_1d", "hk", "index"),
)
def day_view_sql(name: str, market: str, category: str) -> str:
return (
f"CREATE OR REPLACE VIEW {name} AS "
f"SELECT {_BAR_COLUMNS} FROM bars_1d "
f"WHERE market = '{market}' AND category = '{category}'"
)
def all_day_views() -> tuple[str, ...]:
return tuple(day_view_sql(*v) for v in DAY_VIEWS)
+81
View File
@@ -0,0 +1,81 @@
"""共享 fixtures:迷你库、迷你 seed、app client。"""
from __future__ import annotations
from datetime import date
from pathlib import Path
import pyarrow as pa
import pyarrow.parquet as paparquet
import pytest
from fastapi.testclient import TestClient
from pyquantdata.config import default_config
from pyquantdata.paths import DbPathLayout
from pyquantdata.store import migrate, open_catalog
@pytest.fixture
def dbpath(tmp_path: Path) -> Path:
return tmp_path / "db"
@pytest.fixture
def layout(dbpath: Path) -> DbPathLayout:
lay = DbPathLayout(dbpath)
lay.ensure_dirs()
return lay
@pytest.fixture
def catalog(layout: DbPathLayout, dbpath: Path):
"""已 migrate 的写连接(含派生 cursor 配置)。"""
conn = open_catalog(layout.root)
migrate(conn)
yield conn
conn.close()
def make_seed_table() -> pa.Table:
dates = [date(2026, 9, d) for d in range(1, 11)]
n = len(dates)
return pa.table(
{
"symbol": ["sh600000"] * n,
"date": dates,
"open": [10.0 + i * 0.1 for i in range(n)],
"high": [10.5 + i * 0.1 for i in range(n)],
"low": [9.5 + i * 0.1 for i in range(n)],
"close": [10.2 + i * 0.1 for i in range(n)],
"volume": [1_000_000.0] * n,
"amount": [10_200_000.0 + i * 1e4 for i in range(n)],
}
)
@pytest.fixture
def mini_seed(tmp_path: Path) -> Path:
p = tmp_path / "mini_seed_1d.parquet"
paparquet.write_table(make_seed_table(), p)
return p
def make_client(dbpath: Path, cursor, *, config=None, schema_version: int = 1) -> TestClient:
from pyquantdata.serve.app import AppContext, create_app
ctx = AppContext(
dbpath=dbpath, config=config or default_config(), cursor=cursor,
schema_version=schema_version,
)
app = create_app(ctx)
return TestClient(app)
@pytest.fixture
def client(catalog, dbpath: Path) -> TestClient:
from pyquantdata.store.db import configure_query_conn
cursor = catalog.cursor()
configure_query_conn(cursor)
with make_client(dbpath, cursor) as c:
yield c
+96
View File
@@ -0,0 +1,96 @@
"""生成 [CI] 验收链所需的迷你 seed fixture(离线、确定性、可复现)。
设计 §14/§15:[CI] 层 = ``init --skip-history`` + 迷你 seed → serve → query → export。
CI 不联网、不拉真数据,因此把 fixture 生成逻辑固化成脚本 + 产物入库:
用法::
python tests/fixtures/build_ci_fixture.py # 写入 ci_seed_1d.parquet
python tests/fixtures/build_ci_fixture.py --check # 只校验现有产物是否一致
产物 schema 必须与 ``bars_1d`` 的 seed 读取列一致:
symbol/date/open/high/low/close/volume/amount(§7.3)。
"""
from __future__ import annotations
import argparse
import sys
from datetime import date
from pathlib import Path
import pyarrow as pa
import pyarrow.parquet as paparquet
FIXTURE = Path(__file__).with_name("ci_seed_1d.parquet")
# 10 个交易日 × 2 只股票(A 股规则 symbol,classify_cn 可判定 category)
_DATES = [date(2026, 9, d) for d in range(1, 11)]
_SYMBOLS = ("sh600000", "sz000001")
def build_table() -> pa.Table:
symbols: list[str] = []
dates: list[date] = []
open_: list[float] = []
high: list[float] = []
low: list[float] = []
close: list[float] = []
volume: list[float] = []
amount: list[float] = []
for si, sym in enumerate(_SYMBOLS):
base = 10.0 + si * 20.0 # 第二只股票价格区间错开,便于区分
for i, d in enumerate(_DATES):
symbols.append(sym)
dates.append(d)
open_.append(round(base + i * 0.1, 4))
high.append(round(base + 0.5 + i * 0.1, 4))
low.append(round(base - 0.5 + i * 0.1, 4))
close.append(round(base + 0.2 + i * 0.1, 4))
volume.append(1_000_000.0)
amount.append(round(10_200_000.0 + i * 1e4 + si * 1e6, 2))
return pa.table(
{
"symbol": symbols,
"date": dates,
"open": open_,
"high": high,
"low": low,
"close": close,
"volume": volume,
"amount": amount,
}
)
def write_fixture() -> Path:
paparquet.write_table(build_table(), FIXTURE)
return FIXTURE
def check_fixture() -> bool:
if not FIXTURE.exists():
print(f"[check] 缺失:{FIXTURE}")
return False
existing = paparquet.read_table(FIXTURE)
expected = build_table()
if existing.equals(expected):
print(f"[check] OK:{FIXTURE.name} 与生成逻辑一致({existing.num_rows} 行)")
return True
print(f"[check] 不一致:{FIXTURE.name} 需重新生成(产物 {existing.num_rows} 行)")
return False
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description="生成/校验 [CI] 迷你 seed fixture")
parser.add_argument("--check", action="store_true", help="只校验,不写盘")
args = parser.parse_args(argv)
if args.check:
return 0 if check_fixture() else 1
p = write_fixture()
print(f"[write] {p}({build_table().num_rows} 行 × {len(_SYMBOLS)} symbols)")
return 0
if __name__ == "__main__":
sys.exit(main())
Binary file not shown.
+350
View File
@@ -0,0 +1,350 @@
"""FastAPI 全端点(TestClient):query/export/meta/stats/state/ready/token。"""
from __future__ import annotations
import base64
import threading
import time
import duckdb
import pyarrow as pa
import pytest
from pyquantdata.config import default_config
from pyquantdata.etl import import_seed
from pyquantdata.serve.app import AppContext, ResultTooLargeError, create_app
from pyquantdata.store.db import configure_query_conn
@pytest.fixture
def seeded(catalog, dbpath, mini_seed):
import_seed(catalog, mini_seed)
catalog.execute(
"INSERT INTO calendar VALUES ('cn', CURRENT_DATE, TRUE, 'test'), "
"('us', CURRENT_DATE, FALSE, 'weekend-test')"
)
cursor = catalog.cursor()
configure_query_conn(cursor)
ctx = AppContext(dbpath=dbpath, config=default_config(), cursor=cursor, schema_version=1)
return catalog, ctx
@pytest.fixture
def client(seeded):
from fastapi.testclient import TestClient
_catalog, ctx = seeded
with TestClient(create_app(ctx)) as c:
yield c
@pytest.fixture
def client_429(catalog, dbpath, mini_seed):
import_seed(catalog, mini_seed)
cfg = default_config()
cfg.sql.max_concurrent = 1
cfg.sql.acquire_timeout_s = 0.2
cursor = catalog.cursor()
configure_query_conn(cursor)
ctx = AppContext(dbpath=dbpath, config=cfg, cursor=cursor, schema_version=1)
from fastapi.testclient import TestClient
with TestClient(create_app(ctx)) as c:
yield c
# 合法表上的超慢查询:cn_stock_1d 自笛卡尔积(10^10 行级)→ 必被 timeout 中断。
# 不用 range() 表函数:SQL 闸按设计拒绝 FROM 位置的表函数(§8.3 fail-closed)。
SLOW_SQL = "SELECT count(*) FROM " + " CROSS JOIN ".join(
f"cn_stock_1d t{i}" for i in range(10)
)
def test_healthz(client):
assert client.get("/healthz").json() == {"status": "ok"}
def test_ready_ok(client):
r = client.get("/v1/ready")
assert r.status_code == 200
body = r.json()
assert body["ready"] is True
assert body["checks"]["schema_version"] == 1
assert body["checks"]["disk_free_pct"] is not None
def test_ready_503_when_not_migrated(catalog, dbpath):
from fastapi.testclient import TestClient
cursor = catalog.cursor()
ctx = AppContext(dbpath=dbpath, config=default_config(), cursor=cursor, schema_version=0)
with TestClient(create_app(ctx)) as c:
r = c.get("/v1/ready")
assert r.status_code == 503
assert r.json()["ready"] is False
def test_query_json_basics(client):
r = client.post("/v1/query", json={"sql": "SELECT date, close FROM cn_stock_1d ORDER BY date"})
assert r.status_code == 200
body = r.json()
assert body["columns"] == ["date", "close"]
assert body["row_count"] == 10
assert body["truncated"] is False
assert body["elapsed_ms"] >= 0
assert body["rows"][0][0] == "2026-09-01"
assert isinstance(body["rows"][0][1], float)
def test_query_arrow_stream_b64(client):
r = client.post("/v1/query", json={
"sql": "SELECT symbol, date, close FROM cn_stock_1d ORDER BY date", "fmt": "arrow",
})
assert r.status_code == 200
b64 = r.json()["b64_arrow"]
tbl = pa.ipc.open_stream(pa.BufferReader(base64.b64decode(b64))).read_all()
assert tbl.schema.names == ["symbol", "date", "close"]
assert tbl.num_rows == 10
assert tbl.column("symbol")[0].as_py() == "sh600000"
def test_query_fmt_invalid(client):
r = client.post("/v1/query", json={"sql": "SELECT 1", "fmt": "feather"})
assert r.status_code == 422
def test_query_params_placeholder(client):
r = client.post("/v1/query", json={
"sql": "SELECT close FROM cn_stock_1d WHERE symbol = ? AND date = ?",
"params": ["sh600000", "2026-09-03"],
})
assert r.status_code == 200
assert r.json()["row_count"] == 1
def test_query_max_rows_truncates(client):
r = client.post("/v1/query", json={"sql": "SELECT * FROM cn_stock_1d", "max_rows": 3})
assert r.status_code == 200
body = r.json()
assert body["row_count"] == 3
assert body["truncated"] is True
def test_query_max_rows_clamped_to_config(client):
r = client.post("/v1/query", json={"sql": "SELECT * FROM cn_stock_1d", "max_rows": 10**9})
assert r.status_code == 200 # clamp 到 config.max_rows,不报错
def test_query_rejects_forbidden_sql(client):
r = client.post("/v1/query", json={"sql": "SELECT read_csv('/etc/passwd')"})
assert r.status_code == 400
assert "read_csv" in r.json()["detail"]
def test_query_execution_error_400(client):
r = client.post("/v1/query", json={"sql": "SELECT * FROM table_not_here"})
assert r.status_code == 400
assert "执行失败" in r.json()["detail"]
def test_query_timeout_interrupts(client):
started = time.monotonic()
r = client.post("/v1/query", json={"sql": SLOW_SQL, "timeout_ms": 200})
elapsed = time.monotonic() - started
assert r.status_code == 504
assert elapsed < 5 # interrupt 真中断,不等查询跑完
# 连接复用:interrupt 后仍可查询
r2 = client.post("/v1/query", json={"sql": "SELECT 1"})
assert r2.status_code == 200
def test_query_interrupt_exception_maps_504(client, monkeypatch):
import pyquantdata.serve.app as app_mod
def boom(*a, **k):
raise duckdb.InterruptException("INTERRUPT Error: Interrupted!")
monkeypatch.setattr(app_mod, "execute_query_blocking", boom)
r = client.post("/v1/query", json={"sql": "SELECT 1"})
assert r.status_code == 504
def test_query_result_too_large_maps_413(client, monkeypatch):
import pyquantdata.serve.app as app_mod
def too_big(*a, **k):
raise ResultTooLargeError("结果过大:请走 export")
monkeypatch.setattr(app_mod, "execute_query_blocking", too_big)
r = client.post("/v1/query", json={"sql": "SELECT 1"})
assert r.status_code == 413
def test_query_429_when_slot_busy(client_429):
results: dict[str, int] = {}
def slow():
r = client_429.post("/v1/query", json={"sql": SLOW_SQL, "timeout_ms": 4000})
results["slow"] = r.status_code
t = threading.Thread(target=slow)
t.start()
time.sleep(0.5) # slow 已占用唯一信号量槽
r2 = client_429.post("/v1/query", json={"sql": "SELECT 1"})
t.join(timeout=20)
assert r2.status_code == 429
assert "并发" in r2.json()["detail"]
assert results["slow"] in (200, 504) # 大查询最终超时中断
def test_export_csv_roundtrip(client, dbpath):
r = client.post("/v1/export", json={
"sql": "SELECT symbol, date, close FROM cn_stock_1d ORDER BY date",
"fmt": "csv", "filename": "daily.csv",
})
assert r.status_code == 200
assert r.headers["content-type"].startswith("text/csv")
lines = r.content.decode("utf-8").strip().splitlines()
# pyarrow 默认 RFC4180 加引号;解析后断言列名与行数
assert [c.strip('"') for c in lines[0].split(",")] == ["symbol", "date", "close"]
assert len(lines) == 11 # header + 10
# exports/{job_id}/ 落盘 + job 记录可查
jobs = client.post("/v1/query", json={"sql": "SELECT job_id FROM export_jobs"}).json()
job_id = jobs["rows"][0][0]
job = client.get(f"/v1/export/{job_id}").json()
assert job["state"] == "done"
assert job["rows"] == 10
assert job["path"].startswith("exports")
assert (dbpath / job["path"]).exists()
def test_export_parquet_roundtrip(client, dbpath):
import io
import pyarrow.parquet as paparquet
r = client.post("/v1/export", json={"sql": "SELECT * FROM cn_stock_1d", "fmt": "parquet"})
assert r.status_code == 200
tbl = paparquet.read_table(io.BytesIO(r.content))
assert tbl.num_rows == 10
def test_export_pandas_rejected_with_hint(client):
r = client.post("/v1/export", json={"sql": "SELECT 1", "fmt": "pandas"})
assert r.status_code == 422
assert "/v1/query" in r.json()["detail"]
def test_export_path_escape_rejected(client):
r = client.post("/v1/export", json={
"sql": "SELECT 1", "fmt": "csv", "filename": "../evil.csv",
})
assert r.status_code == 400
assert "非法" in r.json()["detail"]
def test_export_job_404(client):
assert client.get("/v1/export/nope").status_code == 404
def test_meta_views_and_stats(client):
meta = client.get("/v1/meta").json()
assert meta["schema_version"] == 1
names = {v["name"] for v in meta["views"]}
assert "cn_stock_1d" in names
v = next(v for v in meta["views"] if v["name"] == "cn_stock_1d")
assert v["row_count"] == 10
assert v["date_min"] == "2026-09-01"
assert v["sample_symbols"] == ["sh600000"]
stats = client.get("/v1/stats").json()
assert stats["checkpoints"] == []
assert stats["disk"]["bytes"] > 0
assert stats["http"]["ws_conns"] == 0
def test_meta_handles_special_views(catalog, seeded):
_cat, ctx = seeded
from fastapi.testclient import TestClient
catalog.execute("CREATE OR REPLACE VIEW meta_special AS SELECT 42 AS v")
with TestClient(create_app(ctx)) as c:
meta = c.get("/v1/meta").json()
special = next(v for v in meta["views"] if v["name"] == "meta_special")
assert special["columns"] == ["v"]
assert "date_min" not in special
assert "sample_symbols" not in special
def test_state_endpoint(client):
r = client.get("/v1/state/cn")
assert r.status_code == 200
body = r.json()
assert body["market"] == "cn"
assert body["state"] in {"CLOSED", "PRE_OPEN_AUCTION", "OPEN", "LUNCH_BREAK"}
assert body["session_tz"] == "Asia/Shanghai"
assert body["ts"].endswith("Z") # ISO8601 UTC 带 Z(§8.2)
def test_state_no_calendar_data_is_closed(client):
body = client.get("/v1/state/hk").json()
assert body["state"] == "CLOSED"
assert body["reason"] == "no_calendar_data"
def test_state_unknown_market_404(client):
assert client.get("/v1/state/uk").status_code == 404
def test_ready_disk_free_branch_none(catalog, tmp_path):
"""dbpath 不存在 → free_pct None 分支(只读探针仍 ready)。"""
from fastapi.testclient import TestClient
cursor = catalog.cursor()
cursor.execute("SELECT 1")
ctx = AppContext(
dbpath=tmp_path / "missing", config=default_config(),
cursor=cursor, schema_version=1,
)
with TestClient(create_app(ctx)) as c:
assert c.get("/v1/ready").status_code == 200
def test_stats_disk_oserror_branch(catalog, dbpath, monkeypatch):
from fastapi.testclient import TestClient
cursor = catalog.cursor()
cursor.execute("SELECT 1")
ctx = AppContext(dbpath=dbpath, config=default_config(), cursor=cursor, schema_version=1)
import pyquantdata.serve.app as app_mod
def boom(_):
raise OSError("disk gone")
monkeypatch.setattr(app_mod.psutil, "disk_usage", boom)
with TestClient(create_app(ctx)) as c:
body = c.get("/v1/stats").json()
assert body["disk"]["free_pct"] is None
def test_token_auth(catalog, dbpath, mini_seed):
import_seed(catalog, mini_seed)
cfg = default_config()
cfg.http.token = "abcd1234"
cursor = catalog.cursor()
configure_query_conn(cursor)
from fastapi.testclient import TestClient
with TestClient(create_app(AppContext(dbpath=dbpath, config=cfg, cursor=cursor, schema_version=1))) as c:
assert c.post("/v1/query", json={"sql": "SELECT 1"}).status_code == 401
assert c.post(
"/v1/query", json={"sql": "SELECT 1"},
headers={"Authorization": "Bearer wrong"},
).status_code == 401
ok = c.post(
"/v1/query", json={"sql": "SELECT 1"},
headers={"Authorization": "Bearer abcd1234"},
)
assert ok.status_code == 200
# 探针不设防
assert c.get("/healthz").status_code == 200
+53
View File
@@ -0,0 +1,53 @@
"""鉴权与脱敏(§8.4)。"""
from __future__ import annotations
import pytest
from pyquantdata.serve.auth import (
SecurityError,
assert_security,
is_loopback,
mask_query_string,
mask_token,
token_ok,
)
def test_mask_token():
assert mask_token("") == ""
assert mask_token("ab") == "ab***"
assert mask_token("abcd1234") == "abcd***"
def test_mask_query_string():
assert mask_query_string("token=abcd1234&topics=state") == "token=abcd***&topics=state"
assert mask_query_string("/v1/stream?topics=state&token=zzzz9999") == (
"/v1/stream?topics=state&token=zzzz***"
)
assert mask_query_string("no-token-here") == "no-token-here"
assert mask_query_string("token=ab") == "token=ab" # 不足 4 位不匹配模板(保持原样)
def test_is_loopback():
assert is_loopback("127.0.0.1")
assert is_loopback("::1")
assert is_loopback("localhost")
assert not is_loopback("0.0.0.0")
assert not is_loopback("192.168.1.10")
def test_assert_security_matrix():
assert_security("127.0.0.1", "", insecure=False) # loopback 不需要 token
assert_security("0.0.0.0", "tok", insecure=False) # 有 token
assert_security("0.0.0.0", "", insecure=True) # 显式裸奔
with pytest.raises(SecurityError, match="拒绝启动"):
assert_security("0.0.0.0", "", insecure=False)
def test_token_ok():
assert token_ok(None, "") is True # 空 token = 不校验
assert token_ok("any", "") is True
assert token_ok("right", "right") is True
assert token_ok("wrong", "right") is False
assert token_ok(None, "right") is False
+33
View File
@@ -0,0 +1,33 @@
"""etl_checkpoint 语义。"""
from __future__ import annotations
from pyquantdata.etl import failed_checkpoints, list_checkpoints, upsert_checkpoint
def test_upsert_and_list(catalog):
upsert_checkpoint(catalog, "bars_1d", "cn", "daily", "2026-09-22", 100)
upsert_checkpoint(catalog, "securities", "cn", "all", "", 5123)
cps = list_checkpoints(catalog)
assert [(c["dataset"], c["watermark"], c["rows"]) for c in cps] == [
("bars_1d", "2026-09-22", 100),
("securities", "", 5123),
]
assert all(c["status"] == "ok" for c in cps)
assert all(c["updated_at"] for c in cps)
def test_upsert_replaces(catalog):
upsert_checkpoint(catalog, "bars_1d", "cn", "daily", "2026-09-21", 50)
upsert_checkpoint(catalog, "bars_1d", "cn", "daily", "2026-09-22", 60)
cps = list_checkpoints(catalog)
assert len(cps) == 1
assert cps[0]["watermark"] == "2026-09-22"
assert cps[0]["rows"] == 60
def test_failed_filter(catalog):
upsert_checkpoint(catalog, "bars_1d", "cn", "daily", "x", 0, status="failed")
upsert_checkpoint(catalog, "calendar", "cn", "2026", "2026-12-31", 244)
failed = failed_checkpoints(catalog)
assert [c["dataset"] for c in failed] == ["bars_1d"]
+83
View File
@@ -0,0 +1,83 @@
"""[CI] 验收链(设计 §14/§15):init --skip-history + 迷你 seed → serve → POST /v1/query 查日K → export csv。
一条链必绿,全部离线。
"""
from __future__ import annotations
import base64
import pyarrow as pa
from fastapi.testclient import TestClient
from typer.testing import CliRunner
from pyquantdata.cli import app
from pyquantdata.config import default_config
from pyquantdata.serve.app import AppContext, create_app
from pyquantdata.store.db import configure_query_conn
runner = CliRunner()
def test_m1_ci_acceptance_chain(catalog, dbpath, mini_seed, tmp_path):
# 1. init --skip-history + seed(CLI 入口,建目录/config/schema/seed)
result = runner.invoke(app, [
"init", "-d", str(dbpath), "--skip-history", "--seed", str(mini_seed),
])
assert result.exit_code == 0, result.output
# 2. serve 语境(TestClient 同事件循环;真网 uvicorn 按 §14 白名单每周冒烟)
cursor = catalog.cursor()
configure_query_conn(cursor)
ctx = AppContext(dbpath=dbpath, config=default_config(), cursor=cursor, schema_version=1)
with TestClient(create_app(ctx)) as client:
# 3. POST /v1/query 查到日K(参数化 + JSON)
r = client.post("/v1/query", json={
"sql": "SELECT date, close FROM cn_stock_1d WHERE symbol = ? ORDER BY date",
"params": ["sh600000"],
})
assert r.status_code == 200
body = r.json()
assert body["row_count"] == 10
assert body["rows"][0][1] == 10.2 # 9/1 close
# 3b. fmt=arrow → Arrow IPC streaming → DataFrame 生态解码路径(附录 A)
r_arrow = client.post("/v1/query", json={
"sql": "SELECT date, close FROM cn_stock_1d ORDER BY date", "fmt": "arrow",
})
tbl = pa.ipc.open_stream(
pa.BufferReader(base64.b64decode(r_arrow.json()["b64_arrow"]))
).read_all()
df = tbl.to_pandas()
assert len(df) == 10 and float(df["close"].iloc[-1]) == 11.1
# 4. export csv(文件流回传 + exports/{job_id}/ 落盘 + job 记录)
r_exp = client.post("/v1/export", json={
"sql": "SELECT symbol, date, open, close FROM cn_stock_1d ORDER BY date",
"fmt": "csv", "filename": "mini_daily.csv",
})
assert r_exp.status_code == 200
lines = r_exp.content.decode("utf-8").strip().splitlines()
header = [c.strip('"') for c in lines[0].split(",")]
assert header == ["symbol", "date", "open", "close"] and len(lines) == 11
job_row = client.post(
"/v1/query", json={"sql": "SELECT job_id, rows, state FROM export_jobs"}
).json()
assert job_row["rows"][0][1] == 10 and job_row["rows"][0][2] == "done"
# 6. SQL 闸在链路内生效
blocked = client.post("/v1/query", json={"sql": "SELECT read_parquet('x')"})
assert blocked.status_code == 400
# 7. CLI 本地直查(只读连接,serve 之外也可用)
# DuckDB 同进程不允许同一库文件「写连接 + 只读连接」并存(配置不同会直接报错)——
# 先释放本测试持有的写连接,再走 CLI 只读路径。
cursor.close()
catalog.close()
q = runner.invoke(app, [
"query", "-d", str(dbpath), "--fmt", "json",
"SELECT count(*) AS n FROM cn_stock_1d",
])
assert q.exit_code == 0, q.output
assert '"row_count": 1' in q.output
+47
View File
@@ -0,0 +1,47 @@
"""A股分类纯函数。"""
from __future__ import annotations
import pytest
from pyquantdata.sources.classify import classify_cn, exchange_of
@pytest.mark.parametrize(
"symbol,category",
[
("sh600000", "stock"),
("sh600519", "stock"),
("sh688001", "stock"), # 科创板
("sz000001", "stock"),
("sz300750", "stock"), # 创业板
("bj430047", "stock"),
("bj833171", "stock"),
("sh000001", "index"), # 上证指数
("sz399001", "index"),
("sh510300", "etf"),
("sz159915", "etf"),
("sh513100", "etf"),
("sh508056", "reits"), # 特例优先于 etf 前缀 sh50
("sh510050", "etf"),
("sh110059", "cbond"),
("sz123456", "cbond"),
("sz127045", "cbond"),
("SH600000", "stock"), # 大小写归一
],
)
def test_classify_cn(symbol, category):
assert classify_cn(symbol) == category
@pytest.mark.parametrize("symbol", ["", "xx123", "sh999999", "hk00700"])
def test_classify_cn_unknown_is_other(symbol):
assert classify_cn(symbol) == "other"
@pytest.mark.parametrize(
"symbol,ex",
[("sh600000", "sh"), ("sz000001", "sz"), ("bj430047", "bj"), ("AAPL", "")],
)
def test_exchange_of(symbol, ex):
assert exchange_of(symbol) == ex
+222
View File
@@ -0,0 +1,222 @@
"""CLI:typer CliRunner 全命令(update 用 FakeAdapter 替身,不打真网)。"""
from __future__ import annotations
import json
from datetime import date
import pytest
from typer.testing import CliRunner
from pyquantdata.cli import app
from pyquantdata.paths import DbPathLayout
runner = CliRunner()
@pytest.fixture
def initialized(dbpath, mini_seed):
result = runner.invoke(app, ["init", "-d", str(dbpath), "--skip-history", "--seed", str(mini_seed)])
assert result.exit_code == 0, result.output
return dbpath
def test_init_creates_layout_and_config(dbpath, mini_seed):
result = runner.invoke(app, ["init", "-d", str(dbpath), "--skip-history", "--seed", str(mini_seed)])
assert result.exit_code == 0, result.output
assert "init 完成" in result.output
assert "[1/4]" in result.output and "[4/4]" in result.output # 分阶段进度
lay = DbPathLayout(dbpath)
assert lay.config_file.exists() and lay.catalog.exists()
assert "bars_1d rows=10" in result.output # seed 已导入
assert "seed: 10 行" in result.output
def test_init_idempotent_keeps_config(dbpath):
assert runner.invoke(app, ["init", "-d", str(dbpath)]).exit_code == 0
cfg = DbPathLayout(dbpath).config_file.read_text(encoding="utf-8")
cfg_obj = json.loads(cfg)
cfg_obj["http"]["port"] = 9999
DbPathLayout(dbpath).config_file.write_text(json.dumps(cfg_obj), encoding="utf-8")
result = runner.invoke(app, ["init", "-d", str(dbpath)])
assert result.exit_code == 0
assert "已存在,保留" in result.output
assert json.loads(DbPathLayout(dbpath).config_file.read_text(encoding="utf-8"))["http"]["port"] == 9999
def test_init_estimate_does_not_write(tmp_path):
target = tmp_path / "never-created"
result = runner.invoke(app, ["init", "-d", str(target), "--estimate"])
assert result.exit_code == 0
assert not target.exists() # 只算不写
assert "budget_gb" in result.output
def test_init_seed_failure_exit_1(dbpath, tmp_path):
result = runner.invoke(
app, ["init", "-d", str(dbpath), "--seed", str(tmp_path / "nope.parquet")]
)
assert result.exit_code == 1
assert "seed 导入失败" in result.output
def test_query_table_format(initialized):
result = runner.invoke(app, [
"query", "-d", str(initialized),
"SELECT date, close FROM cn_stock_1d ORDER BY date LIMIT 3",
])
assert result.exit_code == 0, result.output
assert "sh600000" not in result.output # 未选 symbol 列
assert "3 rows" in result.output
def test_query_json_format(initialized):
result = runner.invoke(app, [
"query", "-d", str(initialized), "--fmt", "json",
"SELECT count(*) AS n FROM cn_stock_1d",
])
assert result.exit_code == 0
payload = json.loads(result.output.strip()) # 纯 stdout JSON(无 rich 前缀)
assert payload["row_count"] == 1
assert payload["rows"][0][0] == 10
def test_query_csv_to_file(initialized, tmp_path):
out = tmp_path / "q.csv"
result = runner.invoke(app, [
"query", "-d", str(initialized), "--fmt", "csv", "-o", str(out),
"SELECT symbol, close FROM cn_stock_1d",
])
assert result.exit_code == 0
assert "已写出" in result.output
assert out.exists()
def test_query_csv_without_out_exit_1(initialized):
result = runner.invoke(app, [
"query", "-d", str(initialized), "--fmt", "csv", "SELECT 1",
])
assert result.exit_code == 1
assert "-o" in result.output
def test_query_bad_fmt_exit_1(initialized):
result = runner.invoke(app, [
"query", "-d", str(initialized), "--fmt", "xlsx", "SELECT 1",
])
assert result.exit_code == 1
def test_query_sql_rejected_exit_1(initialized):
result = runner.invoke(app, [
"query", "-d", str(initialized), "SELECT read_csv('/etc/passwd')",
])
assert result.exit_code == 1
assert "SQL 被拒绝" in result.output
def test_query_uninitialized_db_exit_1(tmp_path):
result = runner.invoke(app, ["query", "-d", str(tmp_path / "nope"), "SELECT 1"])
assert result.exit_code == 1
assert "未初始化" in result.output
def test_export_csv(initialized, tmp_path):
out = tmp_path / "exp.csv"
result = runner.invoke(app, [
"export", "-d", str(initialized), "--fmt", "csv", "-o", str(out),
"--sql", "SELECT * FROM cn_stock_1d",
])
assert result.exit_code == 0, result.output
assert out.exists()
assert "导出完成" in result.output
def test_export_parquet(initialized, tmp_path):
out = tmp_path / "exp.parquet"
result = runner.invoke(app, [
"export", "-d", str(initialized), "--fmt", "parquet", "-o", str(out),
"--sql", "SELECT * FROM cn_stock_1d",
])
assert result.exit_code == 0
import pyarrow.parquet as paparquet
assert paparquet.read_table(out).num_rows == 10
def test_export_pandas_hint_exit_1(initialized, tmp_path):
result = runner.invoke(app, [
"export", "-d", str(initialized), "--fmt", "pandas", "-o", str(tmp_path / "x"),
"--sql", "SELECT 1",
])
assert result.exit_code == 1
assert "query --fmt arrow" in result.output
def test_export_sql_rejected_exit_1(initialized, tmp_path):
result = runner.invoke(app, [
"export", "-d", str(initialized), "--fmt", "csv", "-o", str(tmp_path / "x.csv"),
"--sql", "ATTACH 'x'",
])
assert result.exit_code == 1
def test_status_json(initialized):
result = runner.invoke(app, ["status", "-d", str(initialized), "--json"])
assert result.exit_code == 0
# rich.print_json 输出在 result.output;去掉可能的空行
start = result.output.index("{")
payload = json.loads(result.output[start:])
assert payload["schema_version"] == 1
assert payload["bars_1d_rows"] == 10
assert payload["lock"]["held"] is False
assert payload["disk"] is not None
def test_status_plain_same_payload(initialized):
result = runner.invoke(app, ["status", "-d", str(initialized)])
assert result.exit_code == 0
assert "schema_version" in result.output
def test_quantdata_home_env(dbpath, mini_seed, monkeypatch):
monkeypatch.setenv("QUANTDATA_HOME", str(dbpath))
result = runner.invoke(app, ["init", "--skip-history", "--seed", str(mini_seed)])
assert result.exit_code == 0, result.output
assert DbPathLayout(dbpath).config_file.exists()
def test_update_with_fake_adapter(initialized, monkeypatch):
"""update 全链(--dataset securities/calendar/bars_1d)用替身适配器。"""
import pyquantdata.cli as cli_mod
from pyquantdata.sources import FakeAdapter
from pyquantdata.sources.base import Bar1dRow, CalendarRow, SecurityRow
adapter = FakeAdapter(
securities=[SecurityRow(symbol="sh600000", name="浦发银行", category="stock", exchange="sh")],
bars=[Bar1dRow(symbol="sh600000", date=date(2026, 9, 1), open=10, high=11, low=9, close=10.5, volume=1, amount=2)],
calendar={2026: [CalendarRow(trade_date=date(2026, 9, 1), is_open=True)]},
)
monkeypatch.setattr("pyquantdata.sources.TdxAdapter", lambda: adapter)
result = runner.invoke(app, [
"update", "-d", str(initialized), "--dataset", "all",
"--start", "2026-09-01", "--end", "2026-09-02",
])
assert result.exit_code == 0, result.output
assert "securities" in result.output and "update 完成" in result.output
assert ("open",) in adapter.calls and ("close",) in adapter.calls
# calendar 年份缺省 = 当前年
assert any(call[0] == "calendar" for call in adapter.calls)
def test_update_partial_dataset(initialized, monkeypatch):
from pyquantdata.sources import FakeAdapter
from pyquantdata.sources.base import SecurityRow
adapter = FakeAdapter(
securities=[SecurityRow(symbol="sh600000", name="x", category="stock", exchange="sh")]
)
monkeypatch.setattr("pyquantdata.sources.TdxAdapter", lambda: adapter)
result = runner.invoke(app, ["update", "-d", str(initialized), "--dataset", "securities"])
assert result.exit_code == 0
assert ("securities", "cn") in adapter.calls
+93
View File
@@ -0,0 +1,93 @@
"""config.py:默认生成、roundtrip、extra=forbid、${ENV} 展开。"""
from __future__ import annotations
from datetime import datetime, timezone
import pytest
from pydantic import ValidationError
from pyquantdata.config import (
AppConfig,
default_config,
expand_env,
load_config,
write_config,
)
def test_default_config_three_markets():
cfg = default_config()
assert set(cfg.markets) == {"cn", "us", "hk"}
assert cfg.markets["cn"].history_from == "2004-01-01"
assert cfg.markets["us"].history_from == "2020-01-01"
assert cfg.markets["hk"].history_from_bars_1d is None # 跟随 history_from
assert cfg.http.port == 8765
assert cfg.schedule.timezone == "Asia/Shanghai"
assert cfg.sql.max_concurrent == 4
assert cfg.export.formats == ["csv", "parquet", "qlib", "backtrader"]
def test_default_config_subset_markets():
cfg = default_config(["cn"])
assert set(cfg.markets) == {"cn"}
def test_roundtrip(tmp_path):
cfg = default_config()
path = tmp_path / "config.json"
write_config(cfg, path)
loaded = load_config(path)
assert loaded == cfg
text = path.read_text(encoding="utf-8")
assert '"version": 1' in text
def test_extra_field_forbidden(tmp_path):
cfg = default_config()
import json
raw = json.loads(cfg.model_dump_json(by_alias=True))
raw["hhtp"] = {"port": 1} # 拼错字段必须报错而不是静默失效
bad = tmp_path / "bad.json"
bad.write_text(json.dumps(raw), encoding="utf-8")
with pytest.raises(ValidationError):
load_config(bad)
def test_expand_env_token(monkeypatch):
monkeypatch.setenv("QD_TOKEN", "s3cret")
assert expand_env("${QD_TOKEN}") == "s3cret"
def test_expand_env_missing_var():
assert expand_env("${QD_NOT_SET_XYZ}") == ""
def test_expand_env_plain_string():
assert expand_env("no-var-here") == "no-var-here"
def test_load_applies_env_expansion(tmp_path, monkeypatch):
monkeypatch.setenv("QD_TOKEN", "abcd1234")
cfg = default_config()
cfg.http.token = "${QD_TOKEN}"
path = tmp_path / "config.json"
write_config(cfg, path)
loaded = load_config(path)
assert loaded.http.token == "abcd1234"
def test_now_override_is_used():
now = datetime(2026, 1, 2, 3, 4, 5, tzinfo=timezone.utc)
cfg = default_config(now=now)
assert cfg.dbpath_created.startswith("2026-01-02T03:04:05")
def test_app_config_forbids_unknown_section():
import json
raw = json.loads(default_config().model_dump_json(by_alias=True))
raw["mystery"] = 1
with pytest.raises(ValidationError):
AppConfig.model_validate(raw)
+508
View File
@@ -0,0 +1,508 @@
"""补齐分支覆盖:异常回滚路径、边界分支、平台尽力而为分支。
只补「真实可测」的分支;真平台/真网络相关行按 §14 白名单处理(在 pyproject 里)。
"""
from __future__ import annotations
import asyncio
from datetime import date, datetime
import duckdb
import pyarrow as pa
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from pyquantdata.etl import import_seed
from pyquantdata.etl.checkpoint import upsert_checkpoint
from pyquantdata.etl.seed import _as_date
from pyquantdata.etl.update import (
run_update_sync,
update_bars_1d,
update_calendar,
update_securities,
)
from pyquantdata.export.files import run_query_arrow
from pyquantdata.serve.app import AppContext, create_app, table_to_rows, utc_now_iso
from pyquantdata.serve.auth import SecurityError
from pyquantdata.sources import FakeAdapter
from pyquantdata.sources.base import Bar1dRow, CalendarRow, SecurityRow
from pyquantdata.store import migrate, open_catalog
# ---------------------------------------------------------------- etl.seed
def test_as_date_accepts_three_forms():
assert _as_date(datetime(2026, 9, 1, 15, 30)) == date(2026, 9, 1) # datetime
assert _as_date(date(2026, 9, 2)) == date(2026, 9, 2) # date
assert _as_date("2026-09-03") == date(2026, 9, 3) # str
assert _as_date("2026-09-04T00:00:00") == date(2026, 9, 4) # ISO 前缀截断
def test_seed_rollback_on_write_failure(catalog, mini_seed, monkeypatch):
"""写入期异常 → 事务回滚,库内不留半截数据。"""
import pyquantdata.etl.seed as seed_mod
real_executemany = duckdb.DuckDBPyConnection.executemany
def boom(self, *a, **k):
raise duckdb.Error("injected insert failure")
monkeypatch.setattr(duckdb.DuckDBPyConnection, "executemany", boom)
with pytest.raises(duckdb.Error, match="injected"):
import_seed(catalog, mini_seed)
monkeypatch.setattr(duckdb.DuckDBPyConnection, "executemany", real_executemany)
# 回滚后表内无数据
assert catalog.execute("SELECT count(*) FROM bars_1d").fetchone()[0] == 0
# ---------------------------------------------------------------- etl.update
def test_update_securities_rollback_on_failure(catalog, monkeypatch):
adapter = FakeAdapter(
securities=[SecurityRow(symbol="sh600000", name="A", category="stock", exchange="sh")]
)
def boom(*a, **k):
raise duckdb.Error("injected securities failure")
monkeypatch.setattr(duckdb.DuckDBPyConnection, "executemany", boom)
with pytest.raises(duckdb.Error, match="injected"):
asyncio.run(update_securities(catalog, "cn", adapter))
assert catalog.execute("SELECT count(*) FROM securities").fetchone()[0] == 0
def test_update_calendar_rollback_on_failure(catalog, monkeypatch):
adapter = FakeAdapter(calendar={2026: [CalendarRow(trade_date=date(2026, 9, 1), is_open=True)]})
def boom(*a, **k):
raise duckdb.Error("injected calendar failure")
monkeypatch.setattr(duckdb.DuckDBPyConnection, "executemany", boom)
with pytest.raises(duckdb.Error, match="injected"):
asyncio.run(update_calendar(catalog, "cn", adapter, [2026]))
assert catalog.execute("SELECT count(*) FROM calendar").fetchone()[0] == 0
def test_update_bars_rollback_on_failure(catalog, monkeypatch):
adapter = FakeAdapter(
securities=[SecurityRow(symbol="sh600000", name="A", category="stock", exchange="sh")],
bars=[
Bar1dRow(symbol="sh600000", date=date(2026, 9, 1), open=1, high=2, low=0.5,
close=1.5, volume=1, amount=2)
],
)
asyncio.run(update_securities(catalog, "cn", adapter))
def boom(*a, **k):
raise duckdb.Error("injected bars failure")
monkeypatch.setattr(duckdb.DuckDBPyConnection, "executemany", boom)
with pytest.raises(duckdb.Error, match="injected"):
asyncio.run(update_bars_1d(catalog, "cn", adapter))
assert catalog.execute("SELECT count(*) FROM bars_1d").fetchone()[0] == 0
def test_run_update_sync_exports_same_result(catalog):
"""包级导出的同步入口(供外部脚本调用)与 run_update 等价。"""
adapter = FakeAdapter(
securities=[SecurityRow(symbol="sh600000", name="A", category="stock", exchange="sh")],
bars=[
Bar1dRow(symbol="sh600000", date=date(2026, 9, 1), open=1, high=2, low=0.5,
close=1.5, volume=1, amount=2)
],
)
reports = run_update_sync(catalog, "cn", adapter, datasets=["securities", "bars_1d"])
assert [r.dataset for r in reports] == ["securities", "bars_1d"]
assert catalog.execute("SELECT count(*) FROM bars_1d").fetchone()[0] == 1
# ---------------------------------------------------------------- export.files
def test_run_query_arrow_params_and_none(catalog, mini_seed):
import_seed(catalog, mini_seed)
tbl = run_query_arrow(catalog, "SELECT count(*) AS n FROM bars_1d")
assert tbl.num_rows == 1
tbl2 = run_query_arrow(
catalog, "SELECT count(*) AS n FROM bars_1d WHERE symbol = ?", ["sh600000"]
)
assert tbl2.column("n").to_pylist() == [10]
# ---------------------------------------------------------------- lockfile
def test_stale_lock_backup_print_tolerates_closed_stdout(layout, monkeypatch):
"""陈旧锁接管时 stdout 写不进去也不能阻塞拿锁(极端部署场景)。"""
from pyquantdata import lockfile
import json as _json
from pyquantdata.lockfile import _boot_id
stale_path = layout.lock_file
stale_path.parent.mkdir(parents=True, exist_ok=True)
# 造一个「活锁判据齐全但进程已死」的锁:boot_id 必须是当前真实值(float),
# 否则 read_lock 会把它当损坏文件;PID 取几乎不存在的值 → is_alive False。
stale_path.write_text(
_json.dumps({
"pid": 999999999, "start_time": 0.0, "boot_id": _boot_id(),
"acquired_at": "2026-01-01T00:00:00", "cmd": "stale",
}),
encoding="utf-8",
)
def boom(*a, **k):
raise OSError("stdout closed")
monkeypatch.setattr("builtins.print", boom)
lock = lockfile.acquire(stale_path, cmd="new-instance")
assert stale_path.with_suffix(stale_path.suffix + ".bak").exists()
lockfile.release(stale_path, lock)
# ---------------------------------------------------------------- serve.app
def test_table_to_rows_empty_table():
assert table_to_rows(pa.table({})) == []
def test_utc_now_iso_format():
s = utc_now_iso()
assert s.endswith("Z") and len(s) == 20
class _BrokenCursor:
"""cursor.execute 直接抛 duckdb.Error → 覆盖 ready 的 catalog 异常分支。"""
def execute(self, *a, **k):
raise duckdb.Error("catalog is gone")
def cursor(self):
return self
def test_ready_catalog_error_branch(dbpath):
ctx = AppContext(dbpath=dbpath, config=__import__(
"pyquantdata.config", fromlist=["default_config"]
).default_config(), cursor=_BrokenCursor(), schema_version=1)
with TestClient(create_app(ctx)) as c:
body = c.get("/v1/ready")
assert body.status_code == 503
assert body.json()["checks"]["catalog"].startswith("error:")
def test_export_execution_error_400(client):
r = client.post("/v1/export", json={"sql": "SELECT * FROM no_such_table", "fmt": "csv"})
assert r.status_code == 400
assert "执行失败" in r.json()["detail"]
# ---------------------------------------------------------------- serve.runtime
# find_listener_pid 的 psutil 异常分支(无权限/无 psutil 的平台)
def test_find_listener_pid_swallows_psutil_error(monkeypatch):
"""psutil 抛错(权限/平台差异)按「找不到占用者」处理,不阻塞启动判定。"""
import psutil as real_psutil
import pyquantdata.serve.runtime as rt
def boom(*a, **k):
raise RuntimeError("psutil permission denied")
# runtime.find_listener_pid 内是函数级 import,patch 真实 psutil 模块
monkeypatch.setattr(real_psutil, "net_connections", boom)
assert rt.find_listener_pid(12345) is None
def test_find_listener_pid_returns_none_when_no_listener():
import pyquantdata.serve.runtime as rt
# 一个几乎不可能被监听的端口
assert rt.find_listener_pid(1) in (None, rt.find_listener_pid(1))
@pytest.fixture
def ready_db(layout, dbpath):
conn = open_catalog(layout.root)
migrate(conn)
conn.close()
return dbpath
def test_serve_conn_close_error_is_swallowed(ready_db, monkeypatch):
"""退出清理时 conn.close() 抛错不应吞掉退出码(finally 里已 catch)。"""
import pyquantdata.serve.runtime as rt
class _Cfg:
host = "127.0.0.1"
port = 8765
class _Server:
def __init__(self, config):
pass
async def serve(self):
raise RuntimeError("bind failed mid-flight")
monkeypatch.setattr(rt.uvicorn, "Server", _Server)
with pytest.raises(RuntimeError, match="bind failed"):
asyncio.run(rt.run_serve(ready_db, config=_cfg_default(), check_port=False))
def _cfg_default():
from pyquantdata.config import default_config
return default_config()
# ---------------------------------------------------------------- sqlgate
def test_sqlgate_positional_root_identifier_rejected():
"""非 SELECT/CTE 根节点(如 CREATE)被拒(§8.3 根节点白名单)。"""
from pyquantdata.sqlgate import SqlRejected, validate
with pytest.raises(SqlRejected, match="仅允许"):
validate("CREATE TABLE x (a INT)")
def test_sqlgate_empty_sql_rejected():
from pyquantdata.sqlgate import SqlRejected, validate
with pytest.raises(SqlRejected):
validate(" ")
# ---------------------------------------------------------------- migrations
def test_current_version_on_connection_without_table(layout):
"""空库(未建 schema_migrations)→ current_version 返回 0。"""
from pyquantdata.store.migrations import current_version
conn = duckdb.connect(":memory:")
assert current_version(conn) == 0
conn.close()
def test_app_is_fastapi_instance(catalog, dbpath):
from pyquantdata.config import default_config
from pyquantdata.store.db import configure_query_conn
cursor = catalog.cursor()
configure_query_conn(cursor)
app = create_app(AppContext(dbpath=dbpath, config=default_config(), cursor=cursor))
assert isinstance(app, FastAPI)
def test_security_error_is_raisable():
from pyquantdata.serve.auth import assert_security
with pytest.raises(SecurityError):
assert_security("0.0.0.0", "", insecure=False)
def test_checkpoint_upsert_then_list_roundtrip(catalog):
upsert_checkpoint(catalog, "d1", "cn", "s1", "w1", 5)
row = catalog.execute("SELECT dataset, rows FROM etl_checkpoint").fetchone()
assert row == ("d1", 5)
def test_open_catalog_write_then_reopen(tmp_path):
conn = open_catalog(tmp_path)
migrate(conn)
conn.close()
conn2 = open_catalog(tmp_path)
assert conn2.execute("SELECT count(*) FROM bars_1d").fetchone()[0] == 0
conn2.close()
# ---------------------------------------------------------------- 收尾补口
def test_module_entrypoint_runs(capsys, monkeypatch):
"""python -m pyquantdata 入口(__main__ 守卫)可执行。"""
import runpy
monkeypatch.setattr("sys.argv", ["pyquantdata", "--help"])
try:
runpy.run_module("pyquantdata.__main__", run_name="__main__")
except SystemExit:
pass # typer --help 正常退出
def test_cli_serve_command_delegates_to_runtime(monkeypatch, layout):
"""serve 子命令:编排交给 run_serve,退出码原样透传。"""
from typer.testing import CliRunner
from pyquantdata import cli as cli_mod
captured = {}
async def fake_run_serve(dbpath, **kw):
captured["dbpath"] = dbpath
captured.update(kw)
return 7 # 用非零值验证透传
monkeypatch.setattr("pyquantdata.serve.runtime.run_serve", fake_run_serve)
result = CliRunner().invoke(
cli_mod.app, ["serve", "-d", str(layout.root), "--no-http", "--insecure", "--port", "9999"]
)
assert result.exit_code == 7
assert captured["no_http"] is True and captured["insecure"] is True
assert captured["port"] == 9999
def test_cli_table_to_rows_empty():
import pyarrow as pa
from pyquantdata.cli import table_to_rows
assert table_to_rows(pa.table({})) == []
@pytest.fixture
def initialized(dbpath, mini_seed):
"""已 init 的库(本文件专用,避免跨文件依赖 test_cli 的 fixture)。"""
from typer.testing import CliRunner
from pyquantdata.cli import app
result = CliRunner().invoke(
app, ["init", "-d", str(dbpath), "--skip-history", "--seed", str(mini_seed)]
)
assert result.exit_code == 0, result.output
return dbpath
def test_cli_status_disk_error_branch(initialized, monkeypatch):
"""status 的磁盘探测失败 → info['disk'] = None,命令仍成功。"""
import psutil
from typer.testing import CliRunner
from pyquantdata import cli as cli_mod
def boom(_):
raise OSError("disk gone")
monkeypatch.setattr(psutil, "disk_usage", boom)
result = CliRunner().invoke(cli_mod.app, ["status", "-d", str(initialized), "--json"])
assert result.exit_code == 0
assert '"disk": null' in result.output
def test_resolve_export_target_rejects_escaping_job_id(tmp_path):
"""job_id 中的路径穿越也要被白名单拦住(非仅 filename)。"""
from pyquantdata.export.files import ExportPathError, resolve_export_target
with pytest.raises(ExportPathError, match="job_id"):
resolve_export_target(tmp_path / "exports", "..", "ok.csv")
def test_resolve_export_target_dotdot_filename_reaches_prefix_guard(tmp_path, monkeypatch):
"""纵深防御:即便两个白名单被绕过,resolve 前缀校验仍必须拦住越界。
常规输入下白名单已挡死(`/`、`..` 均被拒),所以这道前缀校验在无软链环境下
结构性不可达。这里用 monkeypatch 让白名单「假放行」+ resolve 返回越界路径,
直接验证防线本身有效——安全逻辑不能只靠「到不了」来保证。
"""
from pathlib import Path as _P
from pyquantdata.export import files as files_mod
from pyquantdata.export.files import ExportPathError, resolve_export_target
monkeypatch.setattr(files_mod, "_JOB_ID_RE", type("R", (), {"match": lambda *_: True})())
monkeypatch.setattr(files_mod, "_FILENAME_RE", type("R", (), {"match": lambda *_: True})())
outside = tmp_path / "outside" / "evil.csv"
real_resolve = _P.resolve
monkeypatch.setattr(_P, "resolve", lambda self, *a, **k: outside if "outside" in str(self) or str(self).endswith("evil.csv") else real_resolve(self, *a, **k))
with pytest.raises(ExportPathError, match="越界"):
resolve_export_target(tmp_path / "exports", "okjob", "evil.csv")
def test_query_result_too_large_real_path(catalog, dbpath, mini_seed):
"""真实触发结果过大(max_arrow_bytes 设极小)→ 413。"""
from pyquantdata.config import default_config
from pyquantdata.serve.app import AppContext, create_app
from pyquantdata.store.db import configure_query_conn
import_seed(catalog, mini_seed)
cfg = default_config()
cfg.sql.max_arrow_bytes = 1 # 任何结果都超限
cursor = catalog.cursor()
configure_query_conn(cursor)
with TestClient(create_app(AppContext(dbpath=dbpath, config=cfg, cursor=cursor, schema_version=1))) as c:
r = c.post("/v1/query", json={"sql": "SELECT * FROM cn_stock_1d"})
assert r.status_code == 413
def test_serve_swallows_conn_close_error(ready_db, monkeypatch):
"""退出清理时 conn.close() 抛错 → 被吞掉,退出码仍为 0。"""
import pyquantdata.serve.runtime as rt
class _Server:
def __init__(self, config):
pass
async def serve(self):
return None
class _ConnClose:
"""包装真实连接:close 时抛错。"""
def __init__(self, real):
self._real = real
def __getattr__(self, name):
return getattr(self._real, name)
def close(self):
raise RuntimeError("close exploded")
real_open = rt.open_catalog
def wrap(root, *a, **k):
return _ConnClose(real_open(root, *a, **k))
monkeypatch.setattr(rt, "open_catalog", wrap)
monkeypatch.setattr(rt.uvicorn, "Server", _Server)
code = asyncio.run(rt.run_serve(ready_db, config=_cfg_default(), check_port=False))
assert code == rt.EXIT_OK
def test_sqlgate_rejects_scan_suffix_function():
"""`*_scan` 表函数必须被拒(§8.3)。
两种落点都要拦:FROM 位置的表函数由 _check_from_tables 先拦;函数白名单
对任何位置都生效。这里只断言「被拒」,不写死命中哪道闸。
"""
from pyquantdata.sqlgate import SqlRejected, validate
for sql in (
"SELECT * FROM parquet_scan('/tmp/x.parquet')",
"SELECT parquet_scan('/tmp/x.parquet')",
"SELECT 1 FROM t WHERE 1 IN (SELECT * FROM delta_scan('/tmp/d'))",
):
with pytest.raises(SqlRejected):
validate(sql)
def test_sqlgate_forbidden_function_in_subquery():
"""禁用函数藏在子查询/CTE 内也要被递归拦下(§8.3)。"""
from pyquantdata.sqlgate import SqlRejected, validate
for sql in (
"SELECT 1 WHERE 1 IN (SELECT read_csv('/etc/passwd'))",
"WITH x AS (SELECT getenv('HOME') AS h) SELECT h FROM x",
):
with pytest.raises(SqlRejected):
validate(sql)
+52
View File
@@ -0,0 +1,52 @@
"""store/db.py:连接管理、只读约束、查询连接安全预设。"""
from __future__ import annotations
import pytest
from pyquantdata.store import CatalogNotInitialized, open_catalog
from pyquantdata.store.db import configure_query_conn
def test_open_read_only_uninitialized_raises(tmp_path):
with pytest.raises(CatalogNotInitialized):
open_catalog(tmp_path, read_only=True)
def test_open_write_creates_catalog(layout):
conn = open_catalog(layout.root)
conn.execute("SELECT 1")
conn.close()
def test_configure_query_conn_sets_guards(catalog):
configure_query_conn(catalog, memory_limit="1GB")
autoinstall = catalog.execute(
"SELECT current_setting('autoinstall_known_extensions')"
).fetchone()[0]
autoload = catalog.execute(
"SELECT current_setting('autoload_known_extensions')"
).fetchone()[0]
assert autoinstall in ("false", False)
assert autoload in ("false", False)
mem = catalog.execute("SELECT current_setting('memory_limit')").fetchone()[0]
# duckdb 会把 1GB 规范化显示(如 '953.6 MiB');断言数值≈1GiB 而非字面量
import re as _re
m = _re.match(r"([\d.]+)\s*(KiB|MiB|GiB|KB|MB|GB)", str(mem))
assert m, mem
val, unit = float(m.group(1)), m.group(2)
gib = val / 1024 if unit in ("MiB", "MB") else val
assert 0.9 <= gib <= 1.1, mem
def test_read_only_blocks_write(layout):
conn = open_catalog(layout.root)
from pyquantdata.store import migrate
migrate(conn)
conn.close()
ro = open_catalog(layout.root, read_only=True)
with pytest.raises(Exception):
ro.execute("CREATE TABLE nope (a INT)")
ro.close()
+127
View File
@@ -0,0 +1,127 @@
"""update ETL 编排:FakeAdapter 确定性数据,幂等重放。"""
from __future__ import annotations
import asyncio
from datetime import date
import pytest
from pyquantdata.etl import run_update
from pyquantdata.sources import FakeAdapter
from pyquantdata.sources.base import Bar1dRow, CalendarRow, SecurityRow
def _bars():
out = []
for sym in ("sh600000", "sh600519"):
for d in range(1, 6):
out.append(
Bar1dRow(
symbol=sym, date=date(2026, 9, d),
open=10.0 + d, high=11.0 + d, low=9.0 + d, close=10.5 + d,
volume=1000.0 + d, amount=10500.0 + d,
)
)
return out
def _securities():
return [
SecurityRow(symbol="sh600000", name="浦发银行", category="stock", exchange="sh", lot_size=100),
SecurityRow(symbol="sh600519", name="贵州茅台", category="stock", exchange="sh", lot_size=100),
SecurityRow(symbol="sh000001", name="上证指数", category="index", exchange="sh"),
]
def _calendar():
return [
CalendarRow(trade_date=date(2026, 9, d), is_open=True, note="")
for d in (1, 2, 3, 7, 8, 9)
]
@pytest.fixture
def adapter():
return FakeAdapter(
securities=_securities(), bars=_bars(), calendar={2026: _calendar()}
)
def test_run_update_full_chain(catalog, adapter):
reports = asyncio.run(
run_update(catalog, "cn", adapter, datasets=["securities", "calendar", "bars_1d"], years=[2026])
)
assert [r.dataset for r in reports] == ["securities", "calendar", "bars_1d"]
assert reports[0].rows == 3
assert catalog.execute("SELECT count(*) FROM securities").fetchone()[0] == 3
# calendar 落库恒为整年逐日(2026 非闰年 = 365),is_open 只标 6 个交易日
assert catalog.execute("SELECT count(*) FROM calendar WHERE market='cn'").fetchone()[0] == 365
assert catalog.execute("SELECT count(*) FROM calendar WHERE is_open").fetchone()[0] == 6
# 日K:只有 securities 里的 stock/index/etf/cbond 进入回填清单
assert reports[2].rows == 10 # 2 stock × 5 天;index 在清单内但 FakeAdapter 无其 bar
assert reports[2].date_min == date(2026, 9, 1)
assert reports[2].date_max == date(2026, 9, 5)
# checkpoint 已写
cps = catalog.execute(
"SELECT dataset, status FROM etl_checkpoint ORDER BY dataset"
).fetchall()
assert [c[0] for c in cps] == ["bars_1d", "calendar", "securities"]
def test_bars_replay_idempotent(catalog, adapter):
asyncio.run(run_update(catalog, "cn", adapter, datasets=["securities", "bars_1d"]))
n1 = catalog.execute("SELECT count(*) FROM bars_1d").fetchone()[0]
asyncio.run(run_update(catalog, "cn", adapter, datasets=["bars_1d"]))
n2 = catalog.execute("SELECT count(*) FROM bars_1d").fetchone()[0]
assert n1 == n2 == 10
def test_bars_with_explicit_symbols_and_range(catalog, adapter):
asyncio.run(run_update(catalog, "cn", adapter, datasets=["securities"]))
report = asyncio.run(
run_update(
catalog, "cn", adapter, datasets=["bars_1d"],
symbols=["sh600000"], start=date(2026, 9, 2), end=date(2026, 9, 4),
)
)[0]
assert report.rows == 3
rows = catalog.execute(
"SELECT count(*), min(date), max(date) FROM bars_1d WHERE symbol='sh600000'"
).fetchone()
assert rows == (3, date(2026, 9, 2), date(2026, 9, 4))
def test_bars_empty_securities_raises(catalog, adapter):
with pytest.raises(RuntimeError, match="securities"):
asyncio.run(run_update(catalog, "cn", adapter, datasets=["bars_1d"]))
def test_partial_overlap_replay_replaces(catalog, adapter):
"""重放窗口小于已有区间:重放区替换、区外保留(§7.3 整区替换)。"""
asyncio.run(run_update(catalog, "cn", adapter, datasets=["securities", "bars_1d"]))
# 现在只重放 9/1~9/2,且数据变化(close 改为 99)
slim = FakeAdapter(securities=_securities())
slim.bars = [
Bar1dRow(symbol="sh600000", date=date(2026, 9, d), open=1, high=2, low=0.5,
close=99, volume=1, amount=2)
for d in (1, 2)
]
asyncio.run(
run_update(catalog, "cn", slim, datasets=["bars_1d"], symbols=["sh600000"],
start=date(2026, 9, 1), end=date(2026, 9, 2))
)
n_99 = catalog.execute("SELECT count(*) FROM bars_1d WHERE close=99").fetchone()[0]
n_kept = catalog.execute(
"SELECT count(*) FROM bars_1d WHERE symbol='sh600000' AND date >= DATE '2026-09-03'"
).fetchone()[0]
assert n_99 == 2
assert n_kept == 3 # 旧区间未被动
def test_calendar_replay_idempotent(catalog, adapter):
asyncio.run(run_update(catalog, "cn", adapter, datasets=["calendar"], years=[2026]))
n1 = catalog.execute("SELECT count(*) FROM calendar").fetchone()[0]
asyncio.run(run_update(catalog, "cn", adapter, datasets=["calendar"], years=[2026]))
n2 = catalog.execute("SELECT count(*) FROM calendar").fetchone()[0]
assert n1 == n2 == 365 # 整年逐日,重放不翻倍
+101
View File
@@ -0,0 +1,101 @@
"""导出文件层:路径安全、落盘、job 记录。"""
from __future__ import annotations
import pytest
import pyarrow.parquet as paparquet
from pyquantdata.export.files import (
ExportFormatError,
ExportPathError,
get_export_job,
new_job_id,
record_export_job,
resolve_export_target,
spec_hash,
write_export,
)
def test_new_job_id_shape():
jid = new_job_id()
assert len(jid) == 12
assert all(c in "0123456789abcdef" for c in jid)
def test_spec_hash_stable_and_distinct():
a = spec_hash({"sql": "SELECT 1", "fmt": "csv"})
assert a == spec_hash({"fmt": "csv", "sql": "SELECT 1"}) # 键序无关
assert a != spec_hash({"sql": "SELECT 2", "fmt": "csv"})
def test_resolve_target_ok(tmp_path):
exports = tmp_path / "exports"
target = resolve_export_target(exports, "abc123", "out.csv")
assert target == exports.resolve() / "abc123" / "out.csv"
@pytest.mark.parametrize(
"job_id,filename",
[
("Bad!ID", "ok.csv"), # job_id 非法字符
("", "ok.csv"),
("a" * 100, "ok.csv"), # 超长
("okjob", "../evil.csv"), # 路径穿越
("okjob", "..\\evil.csv"), # Windows 分隔符
("okjob", "sub/dir/x.csv"), # 斜杠
("okjob", ""),
("okjob", "a" * 200), # 超长文件名
],
)
def test_resolve_target_rejects(tmp_path, job_id, filename):
with pytest.raises(ExportPathError):
resolve_export_target(tmp_path / "exports", job_id, filename)
def test_resolve_target_dotdot_filename_rejected(tmp_path):
with pytest.raises(ExportPathError):
resolve_export_target(tmp_path / "exports", "okjob", "..")
def test_write_export_csv(tmp_path):
import pyarrow as pa
tbl = pa.table({"a": [1, 2], "b": ["x", "y"]})
result = write_export(tbl, "csv", tmp_path / "out.csv")
assert result.rows == 2
assert result.path.exists()
text = result.path.read_text(encoding="utf-8")
# pyarrow 默认按 RFC4180 加引号("a","b")——断言语义而非引号风格
assert '"a","b"' in text and '1,"x"' in text
def test_write_export_parquet(tmp_path):
import pyarrow as pa
tbl = pa.table({"a": [1, 2, 3]})
result = write_export(tbl, "parquet", tmp_path / "out.parquet")
back = paparquet.read_table(result.path)
assert back.column("a").to_pylist() == [1, 2, 3]
def test_write_export_bad_format(tmp_path):
import pyarrow as pa
with pytest.raises(ExportFormatError, match="落盘格式"):
write_export(pa.table({"a": [1]}), "pandas", tmp_path / "x.pandas")
def test_record_and_get_job(catalog):
record_export_job(
catalog, "job123", fmt="csv", path="exports/job123/out.csv",
rows=10, bytes_written=128,
)
job = get_export_job(catalog, "job123")
assert job["job_id"] == "job123"
assert job["fmt"] == "csv"
assert job["rows"] == 10
assert job["bytes"] == 128
assert job["state"] == "done"
assert job["finished_at"] is not None
assert get_export_job(catalog, "missing") is None
+102
View File
@@ -0,0 +1,102 @@
"""lockfile.py:三元判活单写者锁(§11)。"""
from __future__ import annotations
import json
import pytest
from pyquantdata.lockfile import (
LockHeldError,
LockInfo,
acquire,
is_alive,
read_lock,
release,
)
@pytest.fixture
def lock_path(tmp_path):
return tmp_path / "quantdata.lock"
def test_acquire_and_release(lock_path):
info = acquire(lock_path, cmd="test")
assert lock_path.exists()
assert info.pid > 0
assert release(lock_path, info) is True
assert not lock_path.exists()
assert release(lock_path, info) is False # 已删
def test_second_acquire_blocked_same_process(lock_path):
info = acquire(lock_path)
with pytest.raises(LockHeldError) as e:
acquire(lock_path)
assert e.value.info.pid == info.pid
def test_stale_lock_backed_up_and_taken(lock_path):
stale = LockInfo(
pid=999_999_999, # 不存在的进程
start_time=1_000_000.0,
boot_id=__import__("pyquantdata.lockfile", fromlist=["_boot_id"])._boot_id(),
acquired_at="2020-01-01T00:00:00",
cmd="old",
)
lock_path.write_text(stale.to_json(), encoding="utf-8")
info = acquire(lock_path)
assert info.pid == __import__("os").getpid()
bak = lock_path.with_suffix(lock_path.suffix + ".bak")
assert bak.exists()
assert json.loads(bak.read_text(encoding="utf-8"))["pid"] == 999_999_999
def test_boot_id_mismatch_is_stale(lock_path, monkeypatch):
info = acquire(lock_path)
assert is_alive(info) is True
fake = LockInfo(info.pid, info.start_time, boot_id=1.0, acquired_at="", cmd="")
assert is_alive(fake) is False # 重启过系统
def test_start_time_mismatch_is_stale(lock_path):
info = acquire(lock_path)
fake = LockInfo(info.pid, info.start_time + 999.0, info.boot_id, "", "")
assert is_alive(fake) is False
def test_dead_pid_is_stale(lock_path):
fake = LockInfo(999_999_999, 1.0, __import__("pyquantdata.lockfile", fromlist=["_boot_id"])._boot_id(), "", "")
assert is_alive(fake) is False
def test_read_lock_corrupt_json_returns_none(lock_path):
lock_path.write_text("{not json", encoding="utf-8")
assert read_lock(lock_path) is None
def test_read_lock_missing_returns_none(lock_path):
assert read_lock(lock_path) is None
def test_read_lock_bad_fields_returns_none(lock_path):
lock_path.write_text('{"pid": "x"}', encoding="utf-8")
assert read_lock(lock_path) is None
def test_release_refuses_to_delete_other_owner(lock_path):
info = acquire(lock_path)
other = LockInfo(
pid=info.pid, start_time=info.start_time + 5.0, boot_id=info.boot_id,
acquired_at="", cmd="",
)
assert release(lock_path, other) is False
assert lock_path.exists() # 后来者的锁不被误删
def test_lock_info_roundtrip(tmp_path):
info = acquire(tmp_path / "l.lock", cmd="quantdata serve")
parsed = LockInfo.from_json((tmp_path / "l.lock").read_text(encoding="utf-8"))
assert parsed == info
assert "quantdata serve" in parsed.cmd
+104
View File
@@ -0,0 +1,104 @@
"""migrations:版本管理、幂等、TooNew 拒启、视图列集。"""
from __future__ import annotations
import pytest
from pyquantdata.store import (
KNOWN_MAX_VERSION,
MIGRATIONS,
SchemaTooNewError,
applied_versions,
current_version,
migrate,
)
BAR_COLUMNS = {
"market", "category", "symbol", "date", "open", "high", "low",
"close", "volume", "amount", "turnover", "adj_factor",
}
def test_fresh_migrate(catalog):
assert current_version(catalog) == KNOWN_MAX_VERSION
assert applied_versions(catalog) == [1]
def test_migrate_idempotent(catalog):
assert migrate(catalog) == KNOWN_MAX_VERSION
assert migrate(catalog) == KNOWN_MAX_VERSION
assert applied_versions(catalog) == [1]
def test_core_tables_exist(catalog):
rows = catalog.execute(
"SELECT table_name FROM information_schema.tables WHERE table_schema='main' "
"AND table_type='BASE TABLE' ORDER BY table_name"
).fetchall()
names = {r[0] for r in rows}
assert {
"exchanges", "securities", "calendar", "corp_actions", "sw_industry",
"stock_status", "futures_meta", "bars_1d", "announcements", "reports",
"news", "etl_checkpoint", "export_jobs", "quality_reports",
"schema_migrations",
} <= names
def test_day_views_exist_with_exact_columns(catalog):
from pyquantdata.store.views import DAY_VIEWS
for view, market, category in DAY_VIEWS:
cols = [
r[0]
for r in catalog.execute(
"SELECT column_name FROM information_schema.columns "
"WHERE table_schema='main' AND table_name=? ORDER BY ordinal_position",
[view],
).fetchall()
]
assert set(cols) == BAR_COLUMNS, view
# 列集恒等:三市场同品类视图列集一致(§3.3)
stock_views = [v for v, _, c in DAY_VIEWS if c == "stock"]
assert len(stock_views) >= 3 # cn/us/hk
def test_day_view_filters_market(catalog):
catalog.execute(
"INSERT INTO bars_1d VALUES ('cn','stock','sh600000',DATE '2026-09-01',"
"10,11,9,10.5,1000,10500,1.2,1.0)"
)
assert catalog.execute("SELECT count(*) FROM cn_stock_1d").fetchone()[0] == 1
assert catalog.execute("SELECT count(*) FROM us_stock_1d").fetchone()[0] == 0
def test_schema_too_new_rejected(catalog):
catalog.execute("INSERT INTO schema_migrations (version) VALUES (99)")
with pytest.raises(SchemaTooNewError):
migrate(catalog)
def test_migration_failure_rolls_back(catalog, monkeypatch):
"""迁移包事务:中途失败回滚,版本停在最后一个成功迁移(§11)。"""
import duckdb
from pyquantdata.store import migrations as m
broken = list(m.MIGRATIONS) + [
(2, "0002_bad", "CREATE TABLE oops (x INT); CREATE TABLE oops (x INT)")
]
monkeypatch.setattr(m, "MIGRATIONS", tuple(broken))
monkeypatch.setattr(m, "KNOWN_MAX_VERSION", 2)
conn2 = duckdb.connect(":memory:")
with pytest.raises(Exception):
m.migrate(conn2)
# migration 1 已提交、migration 2 回滚:无 oops 表
assert m.current_version(conn2) == 1
has_oops = conn2.execute(
"SELECT count(*) FROM information_schema.tables WHERE table_name='oops'"
).fetchone()[0]
assert has_oops == 0
conn2.close()
def test_known_max_version_matches_list():
assert KNOWN_MAX_VERSION == MIGRATIONS[-1][0]
+47
View File
@@ -0,0 +1,47 @@
"""paths.py:目录规范与 dbpath 解析。"""
from __future__ import annotations
import pytest
from pyquantdata.paths import DbPathLayout, resolve_dbpath
def test_layout_properties(tmp_path):
lay = DbPathLayout(tmp_path / "db")
assert lay.config_file.name == "config.json"
assert lay.catalog.name == "catalog.duckdb"
assert lay.lock_file.name == "quantdata.lock"
assert lay.trash_dir.name == ".trash"
assert lay.data_dir.parent == lay.root
def test_ensure_dirs_creates_all(tmp_path):
lay = DbPathLayout(tmp_path / "db")
made = lay.ensure_dirs()
for d in (lay.root, lay.data_dir, lay.scripts_dir, lay.exports_dir, lay.logs_dir, lay.tmp_dir, lay.trash_dir):
assert d.exists()
assert lay.root in made
def test_ensure_dirs_idempotent(tmp_path):
lay = DbPathLayout(tmp_path / "db")
lay.ensure_dirs()
made2 = lay.ensure_dirs()
assert len(made2) == 7
def test_resolve_explicit_wins(tmp_path, monkeypatch):
monkeypatch.setenv("QUANTDATA_HOME", str(tmp_path / "from_env"))
assert resolve_dbpath(str(tmp_path / "explicit")) == (tmp_path / "explicit").resolve()
def test_resolve_env_fallback(tmp_path, monkeypatch):
monkeypatch.setenv("QUANTDATA_HOME", str(tmp_path / "from_env"))
assert resolve_dbpath(None) == (tmp_path / "from_env").resolve()
def test_resolve_missing_raises(monkeypatch):
monkeypatch.delenv("QUANTDATA_HOME", raising=False)
with pytest.raises(SystemExit):
resolve_dbpath(None)
+123
View File
@@ -0,0 +1,123 @@
"""serve runtime:锁、迁移校验、安全校验、端口探测、退出码(真 uvicorn 段按 §14 白名单替身)。"""
from __future__ import annotations
import asyncio
import socket
import pytest
from pyquantdata.config import default_config
from pyquantdata.lockfile import acquire, read_lock
from pyquantdata.paths import DbPathLayout
from pyquantdata.store import migrate, open_catalog
from pyquantdata.serve.runtime import (
EXIT_LOCK_HELD,
EXIT_OK,
EXIT_PORT_BUSY,
EXIT_SCHEMA_TOO_NEW,
EXIT_SECURITY,
find_listener_pid,
run_serve,
)
@pytest.fixture
def ready_db(layout, dbpath):
conn = open_catalog(layout.root)
migrate(conn)
conn.close()
return dbpath
def _cfg():
return default_config()
def test_dbpath_missing_returns_1(tmp_path):
code = asyncio.run(run_serve(tmp_path / "nope", config=_cfg()))
assert code == 1
def test_lock_held_returns_2(ready_db):
layout = DbPathLayout(ready_db)
acquire(layout.lock_file, cmd="other-instance")
code = asyncio.run(run_serve(ready_db, no_http=True, stop_event=_set_event(), config=_cfg()))
assert code == EXIT_LOCK_HELD
# run_serve 失败不释放别人的锁
assert read_lock(layout.lock_file).cmd == "other-instance"
def _set_event():
ev = asyncio.Event()
ev.set()
return ev
def test_no_http_graceful_exit(ready_db):
code = asyncio.run(run_serve(ready_db, no_http=True, stop_event=_set_event(), config=_cfg()))
assert code == EXIT_OK
# 锁已释放
assert read_lock(DbPathLayout(ready_db).lock_file) is None
def test_schema_too_new_returns_3(layout, dbpath):
conn = open_catalog(layout.root)
migrate(conn)
conn.execute("INSERT INTO schema_migrations (version) VALUES (99)")
conn.close()
code = asyncio.run(run_serve(dbpath, no_http=True, stop_event=_set_event(), config=_cfg()))
assert code == EXIT_SCHEMA_TOO_NEW
def test_security_rejects_insecure_bind(ready_db):
cfg = _cfg()
cfg.http.token = ""
code = asyncio.run(
run_serve(ready_db, host="0.0.0.0", no_http=True, stop_event=_set_event(), config=cfg)
)
assert code == EXIT_SECURITY
def test_insecure_flag_allows_start(ready_db, monkeypatch):
code = asyncio.run(
run_serve(
ready_db, host="0.0.0.0", insecure=True, no_http=True,
stop_event=_set_event(), config=_cfg(),
)
)
assert code == EXIT_OK
def test_port_busy_returns_5(ready_db):
"""端口真被占 → 打印占用 PID 后非零退出(§7.1 bind 失败语义)。"""
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.bind(("127.0.0.1", 0))
s.listen(1)
busy_port = s.getsockname()[1]
assert find_listener_pid(busy_port) is not None
code = asyncio.run(run_serve(ready_db, port=busy_port, config=_cfg()))
assert code == EXIT_PORT_BUSY
def test_http_path_full_setup_with_fake_uvicorn(ready_db, monkeypatch):
"""HTTP 路径全编排(锁→migrate→cursor→app→uvicorn.Config),真 serve 用替身(§14 白名单)。"""
import pyquantdata.serve.runtime as rt
served = {}
class _FakeServer:
def __init__(self, config):
served["config"] = config
assert config.host == "127.0.0.1"
assert config.port == 8765
assert config.timeout_graceful_shutdown == 30
async def serve(self):
served["served"] = True
monkeypatch.setattr(rt.uvicorn, "Server", _FakeServer)
code = asyncio.run(run_serve(ready_db, config=_cfg(), check_port=False))
assert code == EXIT_OK
assert served["served"] is True
assert read_lock(DbPathLayout(ready_db).lock_file) is None
+140
View File
@@ -0,0 +1,140 @@
"""seed 导入:parquet/csv、幂等、校验。"""
from __future__ import annotations
from datetime import date
import pyarrow as pa
import pyarrow.parquet as paparquet
import pytest
from pyquantdata.etl import SeedError, import_seed
def test_import_parquet(catalog, mini_seed):
report = import_seed(catalog, mini_seed)
assert report.rows == 10
assert report.symbols == ["sh600000"]
assert report.date_min == date(2026, 9, 1)
assert report.date_max == date(2026, 9, 10)
rows = catalog.execute(
"SELECT count(*), min(date), max(date) FROM bars_1d WHERE symbol='sh600000'"
).fetchone()
assert rows == (10, report.date_min, report.date_max)
# category 按规则分类
assert catalog.execute(
"SELECT DISTINCT category FROM bars_1d WHERE symbol='sh600000'"
).fetchone()[0] == "stock"
def test_seed_idempotent_replay(catalog, mini_seed):
import_seed(catalog, mini_seed)
import_seed(catalog, mini_seed)
assert catalog.execute("SELECT count(*) FROM bars_1d").fetchone()[0] == 10
def test_import_csv_with_alias_columns(catalog, tmp_path):
p = tmp_path / "seed.csv"
p.write_text(
"symbol,date,open,high,low,close,vol,amt\n"
"sz000001,2026-09-01,15.0,15.5,14.8,15.2,2000,30000\n"
"sz000001,2026-09-02,15.2,15.8,15.0,15.6,2200,34000\n",
encoding="utf-8",
)
report = import_seed(catalog, p)
assert report.rows == 2
row = catalog.execute(
"SELECT volume, amount FROM bars_1d WHERE symbol='sz000001' AND date='2026-09-01'"
).fetchone()
assert row == (2000.0, 30000.0)
def test_import_with_optional_adjust_factor(catalog, tmp_path):
p = tmp_path / "adj.parquet"
paparquet.write_table(
pa.table(
{
"symbol": ["sh600000"],
"date": [date(2026, 9, 1)],
"open": [10.0],
"high": [10.5],
"low": [9.5],
"close": [10.2],
"volume": [100.0],
"amount": [1000.0],
"adj_factor": [1.5],
"turnover": [1.2],
}
),
p,
)
import_seed(catalog, p)
row = catalog.execute(
"SELECT adj_factor, turnover FROM bars_1d WHERE symbol='sh600000'"
).fetchone()
assert row == (1.5, 1.2)
def test_missing_required_column(catalog, tmp_path):
p = tmp_path / "bad.parquet"
paparquet.write_table(pa.table({"symbol": ["x"], "close": [1.0]}), p)
with pytest.raises(SeedError, match="缺必需列"):
import_seed(catalog, p)
def test_missing_file(catalog, tmp_path):
with pytest.raises(SeedError, match="不存在"):
import_seed(catalog, tmp_path / "nope.parquet")
def test_empty_table(catalog, tmp_path):
p = tmp_path / "empty.parquet"
paparquet.write_table(
pa.table(
{"symbol": [], "date": [], "open": [], "high": [], "low": [], "close": []}
),
p,
)
with pytest.raises(SeedError, match="无数据行"):
import_seed(catalog, p)
def test_unsupported_extension(catalog, tmp_path):
p = tmp_path / "seed.xlsx"
p.write_text("x", encoding="utf-8")
with pytest.raises(SeedError, match="仅支持"):
import_seed(catalog, p)
def test_empty_symbol_rejected(catalog, tmp_path):
p = tmp_path / "blank.parquet"
paparquet.write_table(
pa.table(
{
"symbol": [" "],
"date": [date(2026, 9, 1)],
"open": [1.0], "high": [1.0], "low": [1.0], "close": [1.0],
}
),
p,
)
with pytest.raises(SeedError, match="symbol 为空"):
import_seed(catalog, p)
def test_import_failure_rolls_back(catalog, tmp_path):
"""半途失败:先前 symbol 的写入也要回滚。"""
p = tmp_path / "bad_mid.parquet"
paparquet.write_table(
pa.table(
{
"symbol": ["sh600000", "sz000001"],
"date": ["2026-09-01", "not-a-date"], # 全字符串列;坏日期在行转换期抛错
"open": [1.0, 1.0], "high": [1.0, 1.0], "low": [1.0, 1.0], "close": [1.0, 1.0],
}
),
p,
)
with pytest.raises(Exception):
import_seed(catalog, p)
assert catalog.execute("SELECT count(*) FROM bars_1d").fetchone()[0] == 0
+84
View File
@@ -0,0 +1,84 @@
"""SQL 闸(§8.3):绕过样例矩阵全部入单测。"""
from __future__ import annotations
import pytest
from pyquantdata.sqlgate import SqlRejected, validate
VALID = [
"SELECT 1",
"SELECT date, close FROM cn_stock_1d WHERE symbol = ? ORDER BY date DESC LIMIT 5",
"WITH latest AS (SELECT symbol, max(date) AS d FROM cn_stock_1d GROUP BY symbol) "
"SELECT * FROM latest",
"SELECT 'cn' AS market, symbol FROM cn_stock_1d "
"UNION ALL SELECT 'us', symbol FROM us_stock_1d",
"SELECT count(*), avg(close) FROM bars_1d GROUP BY market",
"SELECT b.ts, b.close * d.adj_factor FROM cn_stock_1m b JOIN bars_1d d USING (symbol, date)",
"SELECT unnest([1,2,3])",
"SELECT abs(-1), date_trunc('day', now()), upper('a')",
"SELECT symbol FROM cn_stock_1d WHERE date >= DATE '2026-01-01'",
" SELECT 1 ", # 空白容忍
]
FORBIDDEN_SQL = [
("", "空 SQL"),
(" ", None),
("SELECT 1; SELECT 2", None),
("SELECT 1; ATTACH 'x.db' AS x", None),
("SELEC 1", None), # 解析失败 fail-closed
("ATTACH 'evil.db' AS e", None),
("-- comment\nATTACH 'evil.db' AS e", None), # 注释混淆
("COPY bars_1d TO '/tmp/steal.csv'", None),
("INSERT INTO bars_1d VALUES (1)", None),
("UPDATE bars_1d SET close = 0", None),
("DELETE FROM bars_1d", None),
("CREATE TABLE evil (a INT)", None),
("DROP TABLE bars_1d", None),
("SET memory_limit='100GB'", None),
("PRAGMA database_list", None),
("EXPLAIN SELECT 1", None),
("CALL pragma_version()", None),
# 函数默认拒绝(文件/网络/环境)
("SELECT read_parquet('data/**/*.parquet')", None),
("SELECT read_csv('/etc/passwd')", None),
("SELECT read_csv_auto('x.csv')", None),
("SELECT read_json('x.json')", None),
("SELECT glob('*.parquet')", None),
("SELECT getenv('HOME')", None),
("SELECT current_setting('memory_limit')", None),
("SELECT * FROM parquet_scan('x.parquet')", None),
("SELECT * FROM iceberg_scan('x')", None),
("SELECT * FROM read_csv('/etc/passwd')", None),
("SELECT (SELECT read_csv('y') LIMIT 1)", None), # 子查询里也拦
("WITH t AS (SELECT glob('x') AS g) SELECT g FROM t", None), # CTE 里也拦
]
@pytest.mark.parametrize("sql", VALID)
def test_valid_sql_passes(sql):
validate(sql)
@pytest.mark.parametrize("sql,_", FORBIDDEN_SQL, ids=range(len(FORBIDDEN_SQL)))
def test_forbidden_sql_rejected(sql, _):
with pytest.raises(SqlRejected) as e:
validate(sql)
assert e.value.reason
def test_allow_functions_extends_whitelist():
# 额外放行清单语义:显式列出的函数放行(§8.3 allow_functions)
validate("SELECT read_csv('x.csv')", allow_functions=["read_csv"])
# 未列出的仍然拒绝
with pytest.raises(SqlRejected):
validate("SELECT read_parquet('x')", allow_functions=["read_csv"])
# 清空 allow_functions ≠ 全放行(语义反转点)
with pytest.raises(SqlRejected):
validate("SELECT read_csv('x.csv')", allow_functions=[])
def test_rejected_error_carries_reason():
with pytest.raises(SqlRejected) as e:
validate("ATTACH 'x' AS y")
assert "只读" in e.value.reason
+72
View File
@@ -0,0 +1,72 @@
"""市场状态机纯函数:参数化时间边界全覆盖。"""
from __future__ import annotations
import pytest
from pyquantdata.serve.state import MARKET_TZ, market_state
def test_cn_session_boundaries():
# (hhmm, expected_state)
cases = [
(914, "CLOSED"), # 开盘前
(915, "PRE_OPEN_AUCTION"), # 集合竞价开始
(925, "PRE_OPEN_AUCTION"),
(929, "PRE_OPEN_AUCTION"),
(930, "OPEN"),
(1129, "OPEN"),
(1130, "LUNCH_BREAK"),
(1259, "LUNCH_BREAK"),
(1300, "OPEN"),
(1459, "OPEN"),
(1500, "CLOSED"), # 收盘
(2359, "CLOSED"),
]
for hhmm, state in cases:
ms = market_state("cn", hhmm, is_trading_day=True)
assert ms.state == state, f"hhmm={hhmm}: got {ms.state}, want {state}"
def test_cn_non_trading_day():
ms = market_state("cn", 1000, is_trading_day=False)
assert ms.state == "CLOSED"
assert ms.reason == "non_trading_day"
def test_us_no_lunch_break():
assert market_state("us", 1200, is_trading_day=True).state == "OPEN"
assert market_state("us", 929, is_trading_day=True).state == "CLOSED"
assert market_state("us", 930, is_trading_day=True).state == "OPEN"
assert market_state("us", 1559, is_trading_day=True).state == "OPEN"
assert market_state("us", 1600, is_trading_day=True).state == "CLOSED"
def test_hk_lunch_break():
assert market_state("hk", 1200, is_trading_day=True).state == "LUNCH_BREAK"
assert market_state("hk", 1259, is_trading_day=True).state == "LUNCH_BREAK"
assert market_state("hk", 1300, is_trading_day=True).state == "OPEN"
assert market_state("hk", 1600, is_trading_day=True).state == "CLOSED"
def test_fields_complete():
ms = market_state("cn", 1000, is_trading_day=True)
assert ms.market == "cn"
assert ms.session_tz == "Asia/Shanghai"
assert ms.reason == "session_rule"
assert ms.next_at == "11:30" # 收段时刻
ms2 = market_state("cn", 1200, is_trading_day=True)
assert ms2.next_at == "13:00" # 午休结束
ms3 = market_state("cn", 1600, is_trading_day=True)
assert ms3.next_at == "09:30" # 次日开盘
ms4 = market_state("cn", 920, is_trading_day=True)
assert ms4.next_at == "09:30" # 竞价结束
def test_market_tz_table():
assert set(MARKET_TZ) == {"cn", "us", "hk"}
def test_unknown_market_raises():
with pytest.raises(KeyError, match="未知市场"):
market_state("uk", 1000, is_trading_day=True)
+170
View File
@@ -0,0 +1,170 @@
"""TdxAdapter 映射逻辑(注入 fake client,不打真网)。"""
from __future__ import annotations
import asyncio
from datetime import date
import pytest
from pyquantdata.sources import TdxAdapter
from pyquantdata.sources.classify import classify_cn
from pyquantdata.sources.tdx import bar_to_row, info_to_row, year_calendar_rows
class _FakeInfo:
def __init__(self, symbol, code="600000", name="浦发银行", volunit=100):
self.symbol = symbol
self.code = code
self.name = name
self.market = 1
self.volunit = volunit
self.decimal_point = 2
self.pre_close = 10.0
self.kind = "A股"
class _FakeBar:
def __init__(self, symbol, y, m, d, close=10.0, vol=100.0, amount=1000.0):
self.symbol = symbol
self.market = 1
self.code = "600000"
self.open = 9.9
self.high = 10.2
self.low = 9.8
self.close = close
self.vol = vol
self.amount = amount
self.year = y
self.month = m
self.day = d
self.hour = 0
self.minute = 0
class _FakeTdx:
def __init__(self):
self.universe_calls = []
self.bar_calls = []
async def get_universe(self, market):
self.universe_calls.append(market)
if market == "sh":
return [_FakeInfo("sh600000"), _FakeInfo("sh000001")]
if market == "sz":
return [_FakeInfo("sz000001")]
return [_FakeInfo("bj430047")]
async def get_bars(self, symbols, period, *, adjust=None, start_date=None,
end_date=None, **kw):
self.bar_calls.append((tuple(symbols) if isinstance(symbols, (list, tuple)) else (symbols,), start_date, end_date))
out = []
for sym in symbols if isinstance(symbols, (list, tuple)) else [symbols]:
for d in (1, 2):
out.append(_FakeBar(sym, 2026, 9, d))
return out
def test_info_to_row():
row = info_to_row(_FakeInfo("sh600000"))
assert row.symbol == "sh600000"
assert row.name == "浦发银行"
assert row.category == "stock"
assert row.exchange == "sh"
assert row.currency == "CNY"
assert row.lot_size == 100
def test_bar_to_row():
row = bar_to_row(_FakeBar("sh600000", 2026, 9, 1, close=10.5, vol=500, amount=5200))
assert (row.date, row.close, row.volume, row.amount) == (date(2026, 9, 1), 10.5, 500, 5200)
def test_year_calendar_rows_full_year():
rows = year_calendar_rows(2026, {date(2026, 1, 1)})
assert len(rows) == 365
assert rows[0].is_open is True
assert rows[1].is_open is False
def test_year_calendar_rows_leap_year():
assert len(year_calendar_rows(2024, set())) == 366
def test_adapter_requires_open():
adapter = TdxAdapter(client=None)
with pytest.raises(RuntimeError, match="open"):
asyncio.run(adapter.fetch_securities("cn"))
def test_adapter_securities_dedup_and_all_exchanges():
fake = _FakeTdx()
adapter = TdxAdapter(client=fake) # 注入:不 open 也不拥有
rows = asyncio.run(adapter.fetch_securities("cn"))
symbols = [r.symbol for r in rows]
assert symbols == ["sh600000", "sh000001", "sz000001", "bj430047"]
assert fake.universe_calls == ["sh", "sz", "bj"]
def test_adapter_non_cn_market_empty():
adapter = TdxAdapter(client=_FakeTdx())
assert asyncio.run(adapter.fetch_securities("us")) == []
assert asyncio.run(adapter.fetch_calendar("us", 2026)) == []
def test_adapter_bars_mapping_and_range():
fake = _FakeTdx()
adapter = TdxAdapter(client=fake)
rows = asyncio.run(
adapter.fetch_bars_1d("cn", ["sh600000"], date(2026, 9, 1), date(2026, 9, 2))
)
assert len(rows) == 2
assert all(r.symbol == "sh600000" for r in rows)
# start/end 透传为 datetime
called_syms, start, end = fake.bar_calls[0]
assert called_syms == ("sh600000",)
assert (start.year, start.month, start.day) == (2026, 9, 1)
assert (end.year, end.month, end.day) == (2026, 9, 2)
def test_adapter_bars_empty_symbols():
adapter = TdxAdapter(client=_FakeTdx())
assert asyncio.run(adapter.fetch_bars_1d("cn", [], None, None)) == []
def test_adapter_calendar_from_index_bars():
class _IdxTdx(_FakeTdx):
async def get_bars(self, symbols, period, **kw):
return [_FakeBar("sh000001", 2026, 9, d) for d in (1, 2, 7, 8)]
adapter = TdxAdapter(client=_IdxTdx())
rows = asyncio.run(adapter.fetch_calendar("cn", 2026))
opens = [r for r in rows if r.is_open]
assert [(r.trade_date.day) for r in opens] == [1, 2, 7, 8]
assert len(rows) == 365 # 全年日历
def test_adapter_close_noop_without_ownership():
adapter = TdxAdapter(client=_FakeTdx())
asyncio.run(adapter.close()) # 注入 client:不 close 外部对象
def test_adapter_open_creates_client(monkeypatch):
"""默认构造:open() 自建 TdxData 并 start(本测注入替身)。"""
import pyquantdata.sources.tdx as tdx_mod
started = {"n": 0}
class _StubTdxData:
async def start(self):
started["n"] += 1
async def close(self):
started["n"] -= 1
monkeypatch.setattr(tdx_mod, "TdxData", _StubTdxData)
adapter = TdxAdapter()
asyncio.run(adapter.open())
assert started["n"] == 1
asyncio.run(adapter.close())
assert started["n"] == 0
Generated
+838
View File
@@ -0,0 +1,838 @@
version = 1
revision = 3
requires-python = ">=3.11, <3.14"
resolution-markers = [
"python_full_version >= '3.12' and sys_platform == 'win32'",
"python_full_version < '3.12' and sys_platform == 'win32'",
"python_full_version >= '3.12' and sys_platform == 'emscripten'",
"python_full_version < '3.12' and sys_platform == 'emscripten'",
"python_full_version >= '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'",
"python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'",
]
[[package]]
name = "annotated-doc"
version = "0.0.5"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" },
]
[[package]]
name = "annotated-types"
version = "0.8.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" },
]
[[package]]
name = "anyio"
version = "4.15.1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "idna" },
{ name = "typing-extensions" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" },
]
[[package]]
name = "certifi"
version = "2026.7.22"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "click"
version = "8.5.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/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 = "coverage"
version = "7.16.1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/2d/c738872f477f5687152acae68635790387425d407ae37dd3d3a8a6692307/coverage-7.16.1.tar.gz", hash = "sha256:f83981779bcf9dfa06fa0a8d4cb43e0faec1706328ce07aa3e7b665b4ac0f210", size = 969651, upload-time = "2026-09-13T19:12:21.422Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/3a/d09495dfd5191b5593852bbe2f037afae768157443378d066d9ecea69a49/coverage-7.16.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:72e013665e25cf9d44779f01f340af26319756f9a76822b7c94ce6b1d93813da", size = 223307, upload-time = "2026-09-13T19:08:44.914Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/a3/34/310196a80258e28ebf6e5aa814a5a6ffbb18c03cf3c0c0c04191ed893e88/coverage-7.16.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cb05c0ff98b56ba6969adf35556bc43bcb8d094df8bc9cb403acff53460c4e07", size = 223817, upload-time = "2026-09-13T19:08:46.738Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/29/ed0fda1fcd440cdfc07e72a07f3c9c3b43f65a6b3d53bff2cba9b9de50e8/coverage-7.16.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0d0ececb32090e3fbb03e0d352b973a0485879b4de6c58daf47227b9988b99e5", size = 254222, upload-time = "2026-09-13T19:08:48.358Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/4e/5e2507fbd71ec1047620978f39568b0d2ed6c4468d08495a0c24f5677f65/coverage-7.16.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f0ba3892d81aacf36996c52f16bca04e39af31a6c5de930b7688ab617f4a6475", size = 256134, upload-time = "2026-09-13T19:08:49.926Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7e/b1/a9f97846554bc240473656f9c3874591105f29c08eccf4282daadc6bc281/coverage-7.16.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6410b75fe07d5271eaa95fc24bd0a9177ed588d9d1c10c0cf67829adb8f0567", size = 258240, upload-time = "2026-09-13T19:08:51.584Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/a0/c3/2b1ab208d06719394851cdd7dc322157870a93b178410b1bda6cac7755f9/coverage-7.16.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d1039cb2de093225d597109342ce1675626bd127565e80b3044f4eca07c15b2e", size = 260202, upload-time = "2026-09-13T19:08:53.204Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/14/ff4db31d6e3126d5b72aab1e868d35ec94e1b71dee46f5c3b54cb1b2438e/coverage-7.16.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cf047bc39fde5425be2628666d0f435ed8817859111c3aacc84b32d858069f5d", size = 254305, upload-time = "2026-09-13T19:08:54.833Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ce/27/c28faa4818f61c49ca3bfb4a77e1c191e79a40447504b89af0bd859cd6fc/coverage-7.16.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c05913d0d5badf7ac83200f35dcf9514cce5df16a7cc89e7d1d7fff0461813b", size = 255935, upload-time = "2026-09-13T19:08:56.453Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/5a/42e64e5b716048cae33e2e15f8c6fe04a927467056c533b8e88900da895e/coverage-7.16.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4027bf6d7bc0a16df058ce913b69f10c5687f8e1ca668f08caa659ce101744bf", size = 253995, upload-time = "2026-09-13T19:08:58.159Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/84/e5/860287acd5a1e29acd337f302b476b54148203590091b1a1555b2e914b50/coverage-7.16.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:4f48b345f831eaf4402ab6333c2dc3e2e2b5bc7b9c1b8fe12680dee3f0538f01", size = 257767, upload-time = "2026-09-13T19:08:59.958Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/a5/c5/4b68006da567b4b413352f891776c35776b3557a0479a28187ab57c21659/coverage-7.16.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:8643baeb590726c558b2faed6cd59b0917480f9367fcc692026f1a86d824fd08", size = 253715, upload-time = "2026-09-13T19:09:01.778Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/0e/b2d0c47cfbf11770e197f1d0f11a92864eb29fd7eaca45bc9915573d9725/coverage-7.16.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d06dcc420b570bf683cdb647cc8fe62b672d9e429ef711c3cbbb7a6880ca1572", size = 254624, upload-time = "2026-09-13T19:09:03.376Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/14/3bab8821b2b942155578fc34e88e21b0670d922f039ab23651f6035ba7f7/coverage-7.16.1-cp311-cp311-win32.whl", hash = "sha256:946f58aa59b08bcd6afcc6a7bd0ff54ed5eee844f32ad69fe6814836d15856a2", size = 225404, upload-time = "2026-09-13T19:09:05.174Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/9b/ce/4f4ce667a97d1c538b46a79b89161395ad2beffc248b6c782afc9f521927/coverage-7.16.1-cp311-cp311-win_amd64.whl", hash = "sha256:684c7ee9b4c04358fe6ac8b517ab51ec35fcd79d08ff0f105dd8bcd96885bbb7", size = 225879, upload-time = "2026-09-13T19:09:06.81Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/26/17/f3dce5e47351ab34522dd037fd64b111742958e24861bdd2820971bc1a26/coverage-7.16.1-cp311-cp311-win_arm64.whl", hash = "sha256:1b24f79e25bcf6c73931aeca7a3dfc7595c0cb5e9364aba3fdf387a3de4b1c22", size = 225428, upload-time = "2026-09-13T19:09:08.502Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/f7/7cd4c9f2a3b7574414222ec425d5eee21cc690d867a013315e3be8ba185c/coverage-7.16.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b7f2c26ce6ce0b1e0ca0d5fae96ea510e3a2e78b7207f06e76b7f2c87fa3d0af", size = 223475, upload-time = "2026-09-13T19:09:10.145Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/f2/9ac65f9cedd43f91e2d3657c11f13aef82aebae89b2243dc9e44fe58a740/coverage-7.16.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070acb9da788dff743a4d36fc015feee12d68f0349959017542017c79f59c21c", size = 223845, upload-time = "2026-09-13T19:09:11.988Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/4d/f13db452d4367fe1122abfd98ae330596f65a3b40498f8e1a5811f68f123/coverage-7.16.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e366587b370bc9b8b51b7b7272c610c56db5d5b4795b9e4a29d28ff2f440f809", size = 255341, upload-time = "2026-09-13T19:09:13.708Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/6b/85ed86e82835a96ddfbe7705c387c28ce1cbbecd1b6d606f5ddfeeb712df/coverage-7.16.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e82e10b9d290f60b63459cfb245a841aec347603997206296b93881463a93dcf", size = 258078, upload-time = "2026-09-13T19:09:15.368Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/cd/d2/f66945853d850b9c05f4e012e37396f1f31d0cd40d062394b229c22e7b56/coverage-7.16.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d73bb1f85c4150ac208fb0755beb04b2e44897bad81414de9380f98dd74729f", size = 259191, upload-time = "2026-09-13T19:09:17.046Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/77/a1/7b907abe62461f289035c7ac60ab3e6334efb8c425151aac4abfa0c97820/coverage-7.16.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3397b9032553d281ad6a9253b12675b65e0cc8cd7a3b0633cf48872c9eb13360", size = 261452, upload-time = "2026-09-13T19:09:18.756Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/51/e6/e26f4d6b1069a2a2fee3238a132f85c5b4c1dc25aebd88e015451ff0bd68/coverage-7.16.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:77890395cf37026a5907d3ad32376aa51f41c0f163b7477fdbd4f94966cc1d08", size = 255698, upload-time = "2026-09-13T19:09:20.786Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7f/ec/99db7450e813050ebce300e31bbd4f997c76a8c6e3a6d168c5dffc104109/coverage-7.16.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b0944dc3bee3091039bf970d73caaf930c906013128a421bdc132e797494d941", size = 257111, upload-time = "2026-09-13T19:09:22.693Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/9d/500df9d3cd8c541ac84b5e0bcab00646be75654e05aa34e8410ec851282d/coverage-7.16.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b89d22a89d5bc05dd95b64e08295b8394aa96dc88e08f8ba210c9ebfebbe0489", size = 255258, upload-time = "2026-09-13T19:09:24.429Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/24/53318d96da332bb4946f8ac646fa19fd37fecbd0c49144735c716ac69bf0/coverage-7.16.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:550a2a1faf7559f13d5344f12d1eb886ad87955155d7dfab2a3fe5c8ec8fe776", size = 259326, upload-time = "2026-09-13T19:09:26.32Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/ce/abc0462b2e6ae96ae22197d2bc30fe33b6b4e52937e782745436ceb2a761/coverage-7.16.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:55eb268e5b81aefac759766c9162625b06c1bedb7b77d936225bafc4f038a6f6", size = 254827, upload-time = "2026-09-13T19:09:28.191Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/e1/0a04eedaaf19196b51f0180968134228c7646e469ed29914e48690a7cf3e/coverage-7.16.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:65a8fc80898c9ce59f04349fe8b4849b1f9787f14e52ead990e5f849ff4727a0", size = 256698, upload-time = "2026-09-13T19:09:29.922Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/de/1d/d441a55cf22ce9d8e9e34814806c47441ab844bd534e0f4b64e1c6ae8bd1/coverage-7.16.1-cp312-cp312-win32.whl", hash = "sha256:528a61be40977c340cf201d23b69bd6a6bab507da60e9dbda85f8b30e935d70d", size = 225541, upload-time = "2026-09-13T19:09:31.752Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/27/ec3d032375735dd331477caa051419678079ff90fcb53d0284a6c2bfb757/coverage-7.16.1-cp312-cp312-win_amd64.whl", hash = "sha256:d0f02c633630e2b74522108ee95a84ad6e1204a8016a6cca5297f335ea27147e", size = 226075, upload-time = "2026-09-13T19:09:33.556Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/94/00/90e9f5c4434878494306b9c0ee8068ebbd829483737d8cefccc58884d728/coverage-7.16.1-cp312-cp312-win_arm64.whl", hash = "sha256:2959978f9d1d20a2c0c15d0a68baaeccf615ac1aa214cf4a05a10d6f568926c8", size = 225461, upload-time = "2026-09-13T19:09:35.48Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/74/c08c0c4dc9fa6bcd1d90728a63660aa1b17b488a806948598456c48f75d1/coverage-7.16.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ee5465db6e9152a7d09f3215309326878c6aa3ac509195a369f9d264ff4bfbd9", size = 223501, upload-time = "2026-09-13T19:09:37.276Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/5b/c8/784986d326663285258a8e39835c46fb730cc85284f0dbcd82078586dd22/coverage-7.16.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2b8256f8b525ba233d2e4cdcdce0d6673c66fc9bf70df1fd5e67c54a74e2d245", size = 223876, upload-time = "2026-09-13T19:09:39.385Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/76/73fb792928872bbb07e553f920ff55c65ee962c469265feb5d1d4ae5f97a/coverage-7.16.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d57cc400275b9a2892e905fc893f732b21ddb95271bf96406c88e2f6367848b5", size = 254863, upload-time = "2026-09-13T19:09:41.326Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/8d/1fd78899513244b065ccecdd1cfc6aa8b8f1bdee796d8c4f2aa8e8e5397d/coverage-7.16.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6b3fd0f3435ebb7a7183b32a6062a8b755f08242ced1f3f22761d30b56b3c2a5", size = 257460, upload-time = "2026-09-13T19:09:43.086Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/47/1c/b23ddfcb7ef9bd7b3fdb7be9a5dccf9925ae88e556df7aa5b655283c78f2/coverage-7.16.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e5eb1762e7eb5fad34ef913e8107c7788a66f19d328e598ce95bf7217f9e5c8f", size = 258697, upload-time = "2026-09-13T19:09:45.161Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1c/c9/19d0c6ca35778a7e9415c30c46a0c64c9d4374219d004a35563132296896/coverage-7.16.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:46cd3a73e9140410de62cceb66214bce0e08fb3922b9176fbfc1522fec151b41", size = 260827, upload-time = "2026-09-13T19:09:47.061Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/97/fc/5862f7344382c62b85df43d483e579168cc062e007f54d895dfa51fe3e7d/coverage-7.16.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d1ba5142d68dd2cb775cbd0ac8601819298152047803c8efe4eec6d7d7aa7878", size = 255038, upload-time = "2026-09-13T19:09:48.945Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/2e/9f/5c26583199a68df8d15124b4590520903f8eb7cef17db293fea712bb0783/coverage-7.16.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c389c6f9d1d518e1249ddcb8a7f158135644ce2c508fa6cc17b680777dad5bf2", size = 256827, upload-time = "2026-09-13T19:09:50.738Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/13/605198bff079b107336710f28a797312ab132587168600d70a290e7ecd2e/coverage-7.16.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cdc57746c7ac0ea063351b4d651c3bb4dd4fd35e64dbb8e90c10e14eb03c4080", size = 254794, upload-time = "2026-09-13T19:09:52.577Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/b7/0bbb32dc5ccdac766a13763fdfbffd7d73fc80349a69230c46c6b71e7508/coverage-7.16.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5597180ed7670cc94c04c65347418a467d3a43d5f0cf52fcac647f5425f42037", size = 258947, upload-time = "2026-09-13T19:09:54.372Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/bd/65c31ddd43ff4e61b63721b3dad17cca412dba6e2ce89f92abdf75734339/coverage-7.16.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:a9647a0ac46255b8fef59a433a2161f03e5483f3a35e1cbd9dfe4600baff0c6b", size = 254613, upload-time = "2026-09-13T19:09:56.198Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/25/20/d278115f2ba522b3e3128c6852be265f4e0df7202b2effca4db96cf0217d/coverage-7.16.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e306e98186b9cd109121f3583aeb7978797ad21d948f22944c5c08845cd554d0", size = 256388, upload-time = "2026-09-13T19:09:58.095Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/e1/ca/d43aa396fb3a2f71c9411b99d926475f5acaf5c124f605c592865c80c8d5/coverage-7.16.1-cp313-cp313-win32.whl", hash = "sha256:48a78a66fcce49d7f6156524bf979c0ac633d584199717c68c6ffa949fc14e6a", size = 225550, upload-time = "2026-09-13T19:09:59.998Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/30/df2f6114f6a17cffe94721bd1d298f77f86aad493717fa5bc03cb291a1a6/coverage-7.16.1-cp313-cp313-win_amd64.whl", hash = "sha256:7af03247d598a353bbbbe1b925deb735276e4d845e7197c4073dc89352b236fa", size = 226091, upload-time = "2026-09-13T19:10:02.331Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ee/31/6f90d8aab72a112492bd50e3b5485b53b772b1f5fa70da0a620e723caae6/coverage-7.16.1-cp313-cp313-win_arm64.whl", hash = "sha256:166adae25b05b04c9a84135912066d9c97482115af38df1a419a38aacc6b6f5d", size = 225481, upload-time = "2026-09-13T19:10:04.151Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/96/1a/d6d16babd0a5fe4c3fae40702158c570351694e74516d8d81b86c5637448/coverage-7.16.1-py3-none-any.whl", hash = "sha256:3d8bd4e58b6a5c2018d808f297905393c6c61da466a48c3f0596a76a4900ebe4", size = 215264, upload-time = "2026-09-13T19:12:18.895Z" },
]
[package.optional-dependencies]
toml = [
{ name = "tomli", marker = "python_full_version <= '3.11'" },
]
[[package]]
name = "duckdb"
version = "1.5.5"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/19/e57151753576373c6696a12022648546cca6038e8833fda2908ee2342d9b/duckdb-1.5.5.tar.gz", hash = "sha256:72f33ee57ca7595b23957671a2cc7f7fe2be0ecc2d68f63abedcfcaa3a5c1238", size = 18066741, upload-time = "2026-07-22T10:55:17.819Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/9c/c2/b62ec24d57bb8df4e24b0b58f7f8facb32f5fdb9f1895aed9e9fcdded168/duckdb-1.5.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1b543841b0ae18a9c982345cfa3987e9c065d3a4b0f067daa473d92d1e65f528", size = 32708371, upload-time = "2026-07-22T10:53:41.642Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/ce/769171ba45f0b73632dc3bc3108d891e81dd6c6bbfba630a34a75b4dcc0f/duckdb-1.5.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a925d06c2a4c3b64553d6cc1aced5028d376d4479bed689a7d47e9b1dccd80a", size = 17343979, upload-time = "2026-07-22T10:53:44.951Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/46/59/a8e3384ee916e00d5dcf985194c1511d61978540778a1e96fa47f9fb3e0d/duckdb-1.5.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0c42757cb34722144bd4dfb94b6f336339e7b2468f6813fa7fa9a319ba07bab4", size = 15493704, upload-time = "2026-07-22T10:53:47.912Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/1d/9840179c2607b90523a2884a129c4d4e6dbdc1178ba62a976c1043beba88/duckdb-1.5.5-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e72f9e1a4f90a5c8483ad4d540e495bf0834ba61c360b52499a573d7ed62a3f", size = 19366574, upload-time = "2026-07-22T10:53:51.876Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/55/f9641a4eebcc2f4df631287d6c3b9ed2eea3b92644f93acbad825e3972b6/duckdb-1.5.5-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9b6f86ed85d4ef5e0211eaebf75d057bd8bb520bba438a95dd0f4e42234bbfe", size = 21477952, upload-time = "2026-07-22T10:53:55.575Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/3a/07c3556e37a5c97b95917b029c8fdde4a25fbd76a660bacdac195cf20dcb/duckdb-1.5.5-cp311-cp311-win_amd64.whl", hash = "sha256:9f4287f97ccf0c1f3d471e7115be2b067cbf99627e2d34bffd462dd64703cddc", size = 13156986, upload-time = "2026-07-22T10:53:58.823Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/4f/ff/07b48eef2078ca033847e9caa46cc7633b714c5f91ad1ce091c8ca89d792/duckdb-1.5.5-cp311-cp311-win_arm64.whl", hash = "sha256:179633a3fc6296c75d57c69c1e239fa9e5cdcb670fd1dbff88a02663f932905c", size = 14001317, upload-time = "2026-07-22T10:54:01.724Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d6/40/2e05d324400fdaa5656c9f48d6298da421cb034d85e509fa0e6e325cf04b/duckdb-1.5.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d4dd65f8941a604b947e0b9b4b4f7165988e29a23ec0b69b4038520956d9933e", size = 32753858, upload-time = "2026-07-22T10:54:05.514Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/15/5ceb58ffb5bb8a62b3fd7abb39c41467cdf94850ece02e6d88664dfc75ce/duckdb-1.5.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:33db46679b071f108d57139493dee2d37e1f5efcf5c5c039c2969eed11a6c8a7", size = 17368293, upload-time = "2026-07-22T10:54:09.139Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/bf/5c/bf02da0b354fe83cca4f95a4fbf762181af466f7d551ab2a093f7698882a/duckdb-1.5.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f0b88535a5d86fdd63dba6ea02ab68c003dfb9e4892b11256ef24c4da208baae", size = 15509131, upload-time = "2026-07-22T10:54:12.228Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/a9/5f1f09da421d8e930e0b063d11c1b3f90363f40ede74438cd188afdd13a2/duckdb-1.5.5-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f316eae2323d9a851883fdf2dee91c1f9efe251ab33e14a2272f82a913422ed6", size = 19391959, upload-time = "2026-07-22T10:54:15.551Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/4f/98/6549769f158126fa64fd6c1ac2eb59a18282146c939867a3eb31b7c1db07/duckdb-1.5.5-cp312-cp312-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a6d2d11859d82a936ebdcb30ce3d8a1cbb3e990bff05c12abb9b54c44fa7bd1", size = 21510909, upload-time = "2026-07-22T10:54:19.681Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/b7/5753b41d3124838f868f9f523362812d9fc45409e9e4dd70dcbb0a25826e/duckdb-1.5.5-cp312-cp312-win_amd64.whl", hash = "sha256:ddfbdb096c11d51ee22492397d342c90a82e62c5d09961477895934d0a25372f", size = 13168544, upload-time = "2026-07-22T10:54:22.789Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/28/44b679c7d46245f8398feae7edac959d1b83d4eb143e25b3fce0630b78bd/duckdb-1.5.5-cp312-cp312-win_arm64.whl", hash = "sha256:2725d2b9ace3a4e75d72fc5a239f6a44b502c580edadb8fb2676db772c5f9282", size = 13988684, upload-time = "2026-07-22T10:54:26.003Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/47/37/4a38116e7700720fd152c666292214fd3abdf916496991296d8d1f66efbf/duckdb-1.5.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cd98829b67788609017e65c761bd42a5dd0f9129441bed8bda4d6881ccf819f0", size = 32754294, upload-time = "2026-07-22T10:54:29.822Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/66/42/7d392f1ba1eee0eaf4ab4c8c7a604bfe3536cd63f979cf5c98798664f807/duckdb-1.5.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:feead93c56679b79592d437c62975d39cb67adedffa7592c763baf8160ac7366", size = 17368211, upload-time = "2026-07-22T10:54:33.359Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/9f/a5/0a6f4fa60562faa615e55e15bd1953a2f2b17a8edd8105e5cda215e43457/duckdb-1.5.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:49c963d9469373d7aba8d750d9ea565ab823e94166efed953f184dd9b169b98c", size = 15509136, upload-time = "2026-07-22T10:54:36.369Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/cb/023c89f51978545b9fab318581bba0c457a58e7530d2d933e54ae7d8647c/duckdb-1.5.5-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a736217825461732b5442d05a220f3da2e23a0dae114efbf08c9bf171b53098a", size = 19392147, upload-time = "2026-07-22T10:54:39.551Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3e/c5/41bef391fb8b23dbc133c9f2ba016e7a7a8124513d2cc1b430f1897d87e4/duckdb-1.5.5-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:078e6a60dd8eedde5832f45422ca5c4a6b8c837aeabd8a56ca0b7d933f588053", size = 21511060, upload-time = "2026-07-22T10:54:42.788Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/9f/c44dfc1f924ac29b3252dc1b91393c01d009dbfe9f8ed33f10b986151bd1/duckdb-1.5.5-cp313-cp313-win_amd64.whl", hash = "sha256:6826504277dba513c0c5d71d828456c94d729c9d2482f94b2e289f90a9167e28", size = 13168028, upload-time = "2026-07-22T10:54:46.127Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/88/591384b2cd59abddd6f5dc175e60374f9abae6064429f0c4402854c10f44/duckdb-1.5.5-cp313-cp313-win_arm64.whl", hash = "sha256:baa9c5702002fabb559ded2a39008f9f421fcbc7237d388b8213eff1e08858de", size = 13989955, upload-time = "2026-07-22T10:54:49.262Z" },
]
[[package]]
name = "fastapi"
version = "0.141.1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "annotated-doc" },
{ name = "pydantic" },
{ name = "starlette" },
{ name = "typing-extensions" },
{ name = "typing-inspection" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/02/91e3416a8fdd715abb903a952a6bec7cdd8d14eed55d415fc8595524c319/fastapi-0.141.1.tar.gz", hash = "sha256:e8822fc40db1e1858054d7a949a888695bc9bdce70139178e33bd2871a453ca1", size = 425799, upload-time = "2026-07-29T17:18:05.568Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/03/10388a42375ee7e4ac9b94eb2c5c569c8b5795e377e701c9ac3ad63de890/fastapi-0.141.1-py3-none-any.whl", hash = "sha256:bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3", size = 131954, upload-time = "2026-07-29T17:18:04.364Z" },
]
[[package]]
name = "h11"
version = "0.16.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
]
[[package]]
name = "httpcore"
version = "1.0.9"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "certifi" },
{ name = "h11" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
]
[[package]]
name = "httpx"
version = "0.28.1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "anyio" },
{ name = "certifi" },
{ name = "httpcore" },
{ name = "idna" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
]
[[package]]
name = "idna"
version = "3.20"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" },
]
[[package]]
name = "iniconfig"
version = "2.3.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/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 = "markdown-it-py"
version = "4.2.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "mdurl" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
]
[[package]]
name = "mdurl"
version = "0.1.2"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
]
[[package]]
name = "numpy"
version = "2.4.6"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
resolution-markers = [
"python_full_version < '3.12' and sys_platform == 'win32'",
"python_full_version < '3.12' and sys_platform == 'emscripten'",
"python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'",
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" },
]
[[package]]
name = "numpy"
version = "2.5.3"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
resolution-markers = [
"python_full_version >= '3.12' and sys_platform == 'win32'",
"python_full_version >= '3.12' and sys_platform == 'emscripten'",
"python_full_version >= '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'",
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/01/11703282db468b85f6f7b8c7f22d058de5970d5c7e60a3a8aaa313c3de36/numpy-2.5.3.tar.gz", hash = "sha256:df2d5874ff183595a4ba404edd04f6bd9b5505c1d7708573f6a6c17489a67563", size = 20791231, upload-time = "2026-09-06T16:27:47.073Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d6/50/8fdbb16af64895706a45f06a4068e29db732ec180f3c1375f14123359138/numpy-2.5.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cb189f09db39283b26bfd061ec16189e14f71c6755207f72a0f7540867afe5b9", size = 16994982, upload-time = "2026-09-06T16:24:29.244Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/60/39/789131c1188c078dcb3a1692e72e1e050c68b88ffe72c9ccaac9bcd7a9cd/numpy-2.5.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f59a878c33d6b88122d80d239bb3b845d58708750b0cb06a09aebb9b18ec696c", size = 12009327, upload-time = "2026-09-06T16:24:32.491Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/9c/59/a312e95696e5f601914dd8b6dd844692ba61670807417e24b68e337b5c70/numpy-2.5.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a72f874bc9e10e4b8f80426fb49716d5141f64442a0c8418065093ec8017fbb0", size = 5445405, upload-time = "2026-09-06T16:24:35.071Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/30/d0/5623a1707ed4fe16e3909fe3cf5ee3da004ae677ad23d83bbf3adf1a6faf/numpy-2.5.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:fc36dc566135b5eceec4cf89758fcb719266a019ef07dae1754ae7c9f617ef3e", size = 6783213, upload-time = "2026-09-06T16:24:37.253Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f1/32/84146fc020ad3c25f805f70ab60da46fe3c540a21369754a7e4369754b6f/numpy-2.5.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76c2c1e6bfa5c84adc6434dfbf013aa92096a7985221762c8f11fedfd20fff58", size = 15687872, upload-time = "2026-09-06T16:24:39.751Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/af/aa78d1a88805456e212b65461354cd943197fb9acecc4c90fd12295123a3/numpy-2.5.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7e18c623bb5c95acb3b3328861272816ba199fb531921c5d6d0b675f1fde9e3", size = 16717410, upload-time = "2026-09-06T16:24:42.745Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3b/24/faa79d865e69a97ba17473b23a1b74094b2259c03e820c70297293b9ea49/numpy-2.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4f8929ee6c96bfbd7b4ed2032e0c03af86fe1826740ab61ddabf9072d06e57ff", size = 17040975, upload-time = "2026-09-06T16:24:45.961Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/62/4a/8877e629445a7176297dffcaf9c485faa96a95d81728a62521ad55bd4c0f/numpy-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b5d93cf48f687479941d12b69c873ad2cc76bbd487f0091c2200636497f34034", size = 18476479, upload-time = "2026-09-06T16:24:49.35Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c8/db/35e1c2d38b04cbd5b731f9d71495e055e813197669d22b612f11748d2ff9/numpy-2.5.3-cp312-cp312-win32.whl", hash = "sha256:bf63afbe037eb5d2fe87fbcc7778e61da53ebaf21d938a4515aa73b62532a5d4", size = 6133378, upload-time = "2026-09-06T16:24:51.915Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3c/a1/accf6d4f0c80c5d9ba9735d6b1550e444180599f34dec69ca01360f717ad/numpy-2.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:0a59a421a32580a009e8a1751345bf829631b990dc1794b80514ab722b435def", size = 12567828, upload-time = "2026-09-06T16:24:54.255Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/22/43/1764aff32e4652526ae2f71fa8b3efd8d25c8a3d6926914454e47138ed1e/numpy-2.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:ccb32e0525d29e8b0572eb84c9a57af0e7a4e615726927506f55063c62414034", size = 10485432, upload-time = "2026-09-06T16:24:57.278Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/e5/8fb89cd46d14e35699d13bf943a5f5f441ecee8667120a1f6105ab89e349/numpy-2.5.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:66a78fe4556c60aceda5916f9eacd638b18e9e681016ec302dcb4682d6d4d034", size = 16991061, upload-time = "2026-09-06T16:25:00.411Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/2f/06/9dc9e48b5e5e941c8b10350c5ff2d721da42a20517d911d15544246775ff/numpy-2.5.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92f30e89b8ee0ecf363033576c422b2f58fed6a80bed0aa48dff6d14c654663e", size = 12003676, upload-time = "2026-09-06T16:25:03.475Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ab/2a/98282aa5b8f58b1157d440bb6282eed47e3632a5de53a714fbab17e659fe/numpy-2.5.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f9a2353b37a1a9e78fd82b27ad7e2a32a2d036604d18f02b05e3136c62ca3b09", size = 5439695, upload-time = "2026-09-06T16:25:05.978Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/f9/b6533d777be9d6ffd29dc1be0867e563e6e8cc9a220ff1b716adc317f060/numpy-2.5.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:ccbc4665079665c3cf3bab4db9f6b095370cd6437d66be549b6c2a1fd19e1958", size = 6779395, upload-time = "2026-09-06T16:25:08.599Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/73/85/735720d04ec197c5dcfacdfc9922667c7f1f5f496a279b7ba4d7c74c4cc7/numpy-2.5.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c76d5dde9f445058f83d0c02af00557a4db91de9a9a57c0df87d1535001d654b", size = 15681750, upload-time = "2026-09-06T16:25:11.173Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/1b/3b16a9bc514a440a7a0883684111dcb1ef1aee960af2ca95da8fc775f124/numpy-2.5.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5fa86b80fd24bcd1aff83ad23be44ea323de3f787be8f8b15d4a65621e25321", size = 16708577, upload-time = "2026-09-06T16:25:14.171Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/69/c4/386f397831b07328b639c96c5b62719346cf4baf07c68d927239752b1534/numpy-2.5.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd4cb9ad3c7889b9b3fe0a9a9fb5d2ed26f9879bff2608d9f01aed147a20d231", size = 17042047, upload-time = "2026-09-06T16:25:17.582Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/5f/3e/a700ecbf36e85ae8328fd3b0e12eeddc22ed6358a64cb2bd913e0d195d65/numpy-2.5.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1302b90c0e52281681b2975adfe8a860cb7b12216a27b4b0b4207c44bf7bccf0", size = 18465724, upload-time = "2026-09-06T16:25:20.949Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/41/ee/38e785e88a4045f6ad1d1f2808dcdfafdca48c760260c0587bf171e29fc9/numpy-2.5.3-cp313-cp313-win32.whl", hash = "sha256:1c80eabb4035ecf4ca9cd49cde8a9fdd69a729e63e6474887d1523ade7aa277f", size = 6129003, upload-time = "2026-09-06T16:25:23.664Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f3/ec/100f2b1794ede74a9b3d7ec6b9736927f56713414c1dfe19ab6c383494bf/numpy-2.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:71cad2b2a7451ab79d8f5e71b453485b6775963d5cf794179144a7463fe6e8ec", size = 12560965, upload-time = "2026-09-06T16:25:26.602Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/b1/7dc825ca94c12acebbce4c37caa5e198695eb31424bc579679f32b1bb49d/numpy-2.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:8e4dd766076855b5ff7ea52fa5f07ce26286726e0f8bff446b7739d02e6ea204", size = 10482343, upload-time = "2026-09-06T16:25:29.772Z" },
]
[[package]]
name = "packaging"
version = "26.3"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/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 = "pandas"
version = "3.0.6"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "numpy", version = "2.4.6", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version < '3.12'" },
{ name = "numpy", version = "2.5.3", source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }, marker = "python_full_version >= '3.12'" },
{ name = "python-dateutil" },
{ name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e2/17/d7b106e05bfa642e8694451e7d3d759c6a241c5386a5d962e4f66c047e06/pandas-3.0.6.tar.gz", hash = "sha256:66b07ef7315a31bfe1089cd3d71a7de781c9dca986762d0b4fe7c0ef17465d10", size = 4667686, upload-time = "2026-09-17T23:23:18.345Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/48/88e8d250d28efa8163294f6809a71683c7ee67f63ac7c33021c0503b3547/pandas-3.0.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:085e3786ae6b2e82b406266bce36690f72b9dc1421903ba9296b2981a9fcf586", size = 10391798, upload-time = "2026-09-17T23:20:20.96Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/55/a6/39db5d41f3eb5d7846626312cb30e0cea48e988fc47a3725698bc931ad3c/pandas-3.0.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d7564d86a94c2eb8ab290b07f63ddaae5c032fa53897c29a2ff2197d43aee8af", size = 10023718, upload-time = "2026-09-17T23:20:25.094Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/54/b7/707e966129f77ee8a39d41a41bbd989b790b3fef581c6e26b821315cba6b/pandas-3.0.6-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7c0afdcaf6661d795fcefc2f647ddd1136f62cdc153fba177c685d97a87808", size = 10612800, upload-time = "2026-09-17T23:20:27.99Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/be/dfb6cc9329d0bbe76dadda8a1113d026bb996ec76c509221368dc68349f4/pandas-3.0.6-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47121f9571503f724c9b93e297ab6254ac99c77adf5e9ed085ea419fd585c258", size = 11108900, upload-time = "2026-09-17T23:20:30.65Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/6f/3d58f15bbe972f3d7bfa13ee06d731785a76fe8d232c92b2655a8de14127/pandas-3.0.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:994a79608263fe1c14cc48ffa7300e2b834b7d1cb406ffe96a08828cb0cdd79b", size = 11630226, upload-time = "2026-09-17T23:20:33.582Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/54/9b494de4a3dd92fc6eb19187db1b21afb50fdc21962f32ea1aca9f270cb2/pandas-3.0.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a3a22e07fe75347eaacc75b0e85297947af4fba6b4aae23916bd8b6828d0bba3", size = 12146942, upload-time = "2026-09-17T23:20:36.792Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/dc/d2df02854aec5d47659acfb2be352eecc691845b2f86e99c84f1010a8671/pandas-3.0.6-cp311-cp311-win_amd64.whl", hash = "sha256:2e5fa32ff162dfdbc280157d664f44d23049ae414725af9676df339c501d82cd", size = 9859246, upload-time = "2026-09-17T23:20:43.976Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/79/1e/2a30df0d7dede5c195300a1820b0bc21cea3aa24e4c8b6c4431565ecc79a/pandas-3.0.6-cp311-cp311-win_arm64.whl", hash = "sha256:5e75072773c1b2f7cb63faa3a6f562aede11f3976f68ed34cb538bc091a28171", size = 9106923, upload-time = "2026-09-17T23:20:46.611Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/77/4c/597d588c055d4373cff19cbbc32d4dd046c7be8fadee957585b5ba9e5b24/pandas-3.0.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7dac2d65e9087e8e7b5a45fe15c4920911a221df061ab629943ce016489145c7", size = 10397411, upload-time = "2026-09-17T23:20:49.465Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/18/8f/48907c7c707b61a8e5018c32e1a3f70623209bfb59020a2f6196159d3aa7/pandas-3.0.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9dab635a549e58a053c7b0fa054dc0bd7be22f0ed9a720f4a85d5fb993276172", size = 10051279, upload-time = "2026-09-17T23:20:52.409Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/fa/613d867c3d9554a61bafdec6f79565c8a3e73235feb52cc4a72ad2e0fa6a/pandas-3.0.6-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3dccb584123b399c07562ac4d62543e90ede49ddf8ce3c13ffc64cbe828c281", size = 10303429, upload-time = "2026-09-17T23:20:55.597Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/cb/67/0c0f18e38d7f2d2af8c24b3315bc4046e73bbdd4a5540405506671ad0c0d/pandas-3.0.6-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0704044b676496b8350e023b09f174a26772456c974a2b11c36bebb558c9490d", size = 10788193, upload-time = "2026-09-17T23:20:58.617Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/39/53/1b57f3162501fe36687e4870e1b918a6458ca7386b173af75663ace95857/pandas-3.0.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e7c1905ef02c3d6d43d9dbd5b6ccb4da4870a0b0c821bbc103fbdb6f3ad2707b", size = 11323501, upload-time = "2026-09-17T23:21:01.911Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f2/d2/b1182e8d39100369d7f13f4a125a3fb6b096fef112c46d0566c25781ff68/pandas-3.0.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:569e114072b24fc4970c12e2b4bab252671668a40b324318903380cab0254c0c", size = 11838173, upload-time = "2026-09-17T23:21:04.85Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c7/33/5b717af24d2f27995e51e0875a269dddd373045216e34cf62e3aa764eaa1/pandas-3.0.6-cp312-cp312-pyemscripten_2024_0_wasm32.whl", hash = "sha256:2a8fc94be2ee5f1d86f97aacd8cc566f81680b6498e76f3007421bb5d98151bf", size = 7118499, upload-time = "2026-09-17T23:21:07.661Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/bd/2a/14b3b17cd75cef4a1ee1af4234eb41cc1afe4103b98c2d80e8916abfd42b/pandas-3.0.6-cp312-cp312-win_amd64.whl", hash = "sha256:3ef908d28590b3f42d7070e7ad8f9b34b442b260b7f3c1afb57e0040c58cdb1b", size = 9661439, upload-time = "2026-09-17T23:21:10.959Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/3b/11/3d580a604a1e35d69f6676847bd12db7d14344bc677b717f4413e79c5d0d/pandas-3.0.6-cp312-cp312-win_arm64.whl", hash = "sha256:f4e7c52eb108d752e7592268108fd3e98efd76d83a3125cdd06c621c2e44359b", size = 8959806, upload-time = "2026-09-17T23:21:13.851Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/1c/143605a1f6443ad50ebda78a31e5a3a10147fec2590e931584aaa5ff0a09/pandas-3.0.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9ae8073aed8e21d1a7fe263dcdc6840743549722a6738198a0a46000fa9476f2", size = 10418900, upload-time = "2026-09-17T23:21:16.594Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/ca/87f8548f73d452aab35e4a90f8b39ae303295e0f2ef0b4055c44d6b3f1be/pandas-3.0.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:60d81f9e1799b36f3739e7fff44d1fbb2e8fd5a271b3863e03de9715fccda0fa", size = 10064785, upload-time = "2026-09-17T23:21:19.677Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/1a/d951442e5607c6e3b2462eff8f420797d428aa74b87c6ecfe4f48553626e/pandas-3.0.6-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:097090508a1dd335013d39106fc10b20f4fd4a171638e47b77d55798ed9dab6c", size = 10245290, upload-time = "2026-09-17T23:21:22.797Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/50/fa/96d50e1e6cd0b08b5e2b7c838f65ae644940f75a124063380b5ef73b6866/pandas-3.0.6-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e92d9fa834c7d877130027cddc0cad8dcff97c1f6cca26bd6310f847228b658", size = 10757657, upload-time = "2026-09-17T23:21:25.673Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7b/12/f82d13a2cb703e1a8acee7e01fdc2b898d9cd0c00f07d1dfce63af43e350/pandas-3.0.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b27c8d890e4aa2171437ae2a39de1d215e674158e4865c4023a8b31c932513b2", size = 11249114, upload-time = "2026-09-17T23:21:28.898Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/ce/8aef2e561a2f2c8b38c913c67373c65ba6748174e763d27c80271b24bd17/pandas-3.0.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f8029ec0f1f89e4f985929ce1f6626dabf3140d61a4e9c1215afdab34eaf9a5d", size = 11820511, upload-time = "2026-09-17T23:21:32.11Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/bd/63cb67e6903ef6d9c2871916dbcbc09d254da0fe8b870cf62e16b21945f2/pandas-3.0.6-cp313-cp313-win_amd64.whl", hash = "sha256:f3ce8a6968045481e91a3990e797e348ce13db45ee164a7095bbc824e26c09dd", size = 9638092, upload-time = "2026-09-17T23:21:34.883Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/75/2e/e7b35b712edb068d382ddc8b2bea8a04974100515ba2daa22b478b265842/pandas-3.0.6-cp313-cp313-win_arm64.whl", hash = "sha256:cc39303913e2ea129915670de5d1c9fbd647f543bb72e5543bac8baa94e9e42f", size = 8952032, upload-time = "2026-09-17T23:21:37.729Z" },
]
[[package]]
name = "pluggy"
version = "1.6.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
]
[[package]]
name = "psutil"
version = "7.2.2"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" },
]
[[package]]
name = "pyarrow"
version = "25.0.1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3d/e3/27f57f80141379d60defe6703eb50a707325706f07fedfd1312c7a751995/pyarrow-25.0.1.tar.gz", hash = "sha256:9150a83248bfed9813ea3c3af74c3856c1984d444aa28e58bf7733b9750ddf6a", size = 1201653, upload-time = "2026-08-10T12:40:53.904Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ee/8b/0d23b47702fcfe8b3618d5292035099675c5a1c48258932350c08020f7b5/pyarrow-25.0.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:51093dd9e10325fbdb3c10a2ae7c4806e5c822d94e74ae4938b26524a3323fee", size = 35946180, upload-time = "2026-08-10T12:37:18.934Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/17/707d17a5476c55a9541fde0db8213ac30979a792864d72415f176ba50c45/pyarrow-25.0.1-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:eb6203482ff3746a5632303a7279ae0b5a304c46985b49ed1378cb350ea6728d", size = 37644787, upload-time = "2026-08-10T12:37:25.795Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/b2/cdc98ecf1a6408280bc3a6a07054cdd99a3f4670acc0545d383ce113e87d/pyarrow-25.0.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:880523be3d29efcf83d3998835d206118ccf35e3871dbd2fb60408cf6b007a80", size = 46834633, upload-time = "2026-08-10T12:37:33.604Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c8/6e/d3fafc41f378b2c65be43b827798c0fae42049a641c8526633ed3eb573e2/pyarrow-25.0.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:25f8720bf6387d5dc2ebd2622112de630760419e4b66134405dd24110d15f37e", size = 50065507, upload-time = "2026-08-10T12:37:40.565Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/12/8d0698954b8c3001844a898e0a6900bebe83d7ee40c11195174c5122f324/pyarrow-25.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4facd65742a024a4a366328a1d2292062d72d6e023c1b7dda8d4c37544933a25", size = 49955690, upload-time = "2026-08-10T12:37:46.644Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/0b/1ecb936ac6409e90a34d58eea1c7cec09a9ae6d2141b9e49ad01a2b1ea47/pyarrow-25.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:aa0559502e1cd6254d6814614085dd9c5a3dd0419362978a936a3f68a9e5c3df", size = 53128198, upload-time = "2026-08-10T12:37:52.531Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8e/1c/5236033550633c9b7377b2a53660b2bbb06cb06dc09c4356332d67643ca1/pyarrow-25.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:62cd0d785b8aa6675ee355f9fc02252a340f4441257c42674937826fd7594325", size = 27857263, upload-time = "2026-08-10T12:37:56.943Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/a6/e2/9ab15b88cbfac28e16419ce5439ec29234c5172cb8259301b4ba639bdec0/pyarrow-25.0.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:df961f2e7ae9cf496459259d798652c70625f6c080650d6952f8c04053c58ee9", size = 35861559, upload-time = "2026-08-10T12:38:02.567Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/79/a0036dbe1eabe1f73127427342f1d99982584c4a2cde2651d6c93499c6f6/pyarrow-25.0.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:cc4aa407fde9fc660be3939e49ea31f50f3e9fec17c0ec63159f7711edd3efc9", size = 37628383, upload-time = "2026-08-10T12:38:09.083Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/13/49/d93a57d375f4bf0cf82913dd6bb54acafde83dd993be2282c81ac5616cad/pyarrow-25.0.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:4340f0ba6c1d2e13f21658de1d7c662ca2545018568d0030a1e9afca159d87e3", size = 46820190, upload-time = "2026-08-10T12:38:15.458Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/60/c9/711ca85d79f1ec98f29a5eae2b051e25b4ecec5de3e3c0e2d5c5dcb15664/pyarrow-25.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:5389cdf79447ed1515c9e31620e6e1e2302249564d603f2ad727d4f6d313e4c3", size = 50102437, upload-time = "2026-08-10T12:38:22.487Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/80/53/8fb8359ff17cfb6263a1cf3ebf7caec9fe197de118719e84fcb1d0618026/pyarrow-25.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d51592cb7561e87877c506113e7adbf1342ab579e6c21f0ef44b8ba41cb74c80", size = 49942424, upload-time = "2026-08-10T12:38:28.755Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/e8/83/4e5ae02a9341571b18a6fca380ac7a58ce6ddae7ab3c060208c0a1e79f02/pyarrow-25.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6109c94d8b9f3b17a041daca16cacb2f651ad8f1ef70a4232c2c0f37a23da2a8", size = 53144206, upload-time = "2026-08-10T12:38:34.862Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/65/ee/197cbf47e49f83e6ebeb946a5259a48a638dea27ac774db42fe78022179d/pyarrow-25.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:8858d7bfc22e3f51529aeaa4077225029724623e4595dc9eff8c793935c34140", size = 27953934, upload-time = "2026-08-10T12:38:39.808Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/cc/8d/8f271a7a034c834910ec925d56fa4b29733b1380f5289419f5aaa3b02777/pyarrow-25.0.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:c7c534ec03c358a76ea3e505e74c1b6aef290af90c444dfd092dbfe23e755b85", size = 35855328, upload-time = "2026-08-10T12:38:45.489Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d2/cd/5bac242f4e841b9971d5eb94fdfe2577e2b70be983e27401e72055786037/pyarrow-25.0.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:dda9470024204d7bbf2042b47c6e8a0e47a3eeb8e34405882dfaea6577e0c153", size = 37622415, upload-time = "2026-08-10T12:38:51.107Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/63/1f/96d03b4e1506524f7087adb0fd6b2f69f0c9c7aaff1ec36d8030082e15a5/pyarrow-25.0.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:44a9120ce5bd81936b8ab9a88076e3fd47c2c6838e0e43630fed83626aca81d9", size = 46813813, upload-time = "2026-08-10T12:38:57.773Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/d6/33a411115b61dbfc16ad6ad73e71730f6fea654ee3667673bc53ab0e2fe7/pyarrow-25.0.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:0befcf816e45a1af33ac775a9970b749e4868a230c7372f0ae5e932bee27039f", size = 50104452, upload-time = "2026-08-10T12:39:04.579Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/33/ae/b1b97c9ca87f9f9ddbb5230c798df94eccce61bd79b9b45458c69a478588/pyarrow-25.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3f89685964f46e4216103c75483aac0c0692a5f72212d7ca835adba5ede56ce3", size = 49951343, upload-time = "2026-08-10T12:39:11.8Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/98/9e/a112df5cfd5a68cb1d9fc31cfe38c28d5aec9f10865ce37ecef2e4450873/pyarrow-25.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6943e2fe7954d29d84de45d29d34c8dc36ce96570e67d89aa9976e650a4a9138", size = 53144784, upload-time = "2026-08-10T12:39:20.503Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/31/24/97e8bd98f1e3b07e2ba08bcdff690674fbe16d69a7d2712cc3884665e615/pyarrow-25.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:31e49a7888fcdf3a835da33ae777f6bb9a866334e5a789282fc26dcf426f7f15", size = 27870159, upload-time = "2026-08-10T12:39:26.161Z" },
]
[[package]]
name = "pydantic"
version = "2.13.5"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "annotated-types" },
{ name = "pydantic-core" },
{ name = "typing-extensions" },
{ name = "typing-inspection" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/53/ef/fc4f868f4e2cee79f863883abffceff107875f569b848507319842d2a681/pydantic-2.13.5.tar.gz", hash = "sha256:51a9c5f7b2f8e636f04c6cada605d9b6a3bf1348fdf945a3d8869b19bba0ee08", size = 845750, upload-time = "2026-08-28T14:04:00.916Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/eb/47/c95ffc2009878c7aac0c5e08528022dcb885933252a88b5f170058014464/pydantic-2.13.5-py3-none-any.whl", hash = "sha256:346a034f080da3755d8e9cb5e00e8b07de1d39e4f6e2c87d8ab7cafa0b269a73", size = 472589, upload-time = "2026-08-28T14:03:59.136Z" },
]
[[package]]
name = "pydantic-core"
version = "2.46.5"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "typing-extensions" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/f9/8a06bea35ef8daf588f707784c973a7046e0034c8d8cfb08828eeffb8b75/pydantic_core-2.46.5.tar.gz", hash = "sha256:10416c15b8839ecc4ef4d0885da76da6fd0f67333a0eb8aff6d93c4b8f2910fc", size = 472262, upload-time = "2026-08-28T10:01:31.677Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/a2/b6/81d2d19ea0be2c03664381b59f65fa72fc7969decedae00bc2c4ad835708/pydantic_core-2.46.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a1dee1b804ff4d11c663636cf15d2ea47e9f79cd56c033fb1cbf08924842a48f", size = 2074737, upload-time = "2026-08-28T09:57:57.711Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/0c/18/b70da8300e292df4099684ea11b1958043580d2f50d2dc8bf7e542bdd84a/pydantic_core-2.46.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d625a186a65201c23a9e3b8ed9c47e90a026e03256608cc91851c6709096844f", size = 1921751, upload-time = "2026-08-28T09:57:59.265Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/e7/1a/0d590341b6ffa4b4aca83508e6b8db4761aaeacfc15a25ca3815876d4797/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f8507560a9284e1370bb048ed4282012fbef4e8d109875b95e884d228552061", size = 1948231, upload-time = "2026-08-28T09:58:00.678Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7d/1d/02eb35761c51f2f7b1b042d6ab4cda6600f0c8c88a2243b3f734376201e5/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f93c5fe914d75fbec9a49209b00da5f08e9e467d69da2b1510c81940cfd10be", size = 2020708, upload-time = "2026-08-28T09:58:02.267Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/4a/ea/f86073830e35d508cc8ddf9c3d9e6e6840fcb88d34bf726b0b4710186f27/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c767f552b21b10f774aeac128e828eafb796adfa1b666a18bf6321453c3a", size = 2194914, upload-time = "2026-08-28T09:58:03.934Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/bb/d7/fc36240d7791ce90939e51608568c33bfdae26202016f9770c229a487d86/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:701b2e04b560eeb4bddf7a25ab8ca476176e34fdbd9a0e18196f0d12d4685f0b", size = 2235622, upload-time = "2026-08-28T09:58:05.516Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/bc/3fa2d76b83162820a17da7f645b28d1cba99fc8e1e5fc6517067ec450fa1/pydantic_core-2.46.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49776eab08766a08dfff7012f8b422dcd7e25e43b316eedf0477c24fcfa84b7c", size = 2062091, upload-time = "2026-08-28T09:58:07.135Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ab/9a/095d557bb492c90cd8a70a6dd048bf793d433d03d86c81c11e912e4cd049/pydantic_core-2.46.5-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:a2468d93d181667a7abd66e1b64bb9f76f361b0fef8faddf687456453576f5ee", size = 2089904, upload-time = "2026-08-28T09:58:08.814Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/24/98/7b76b1ad10a19a617a52aaa1d80e159115af939b095e86f8e756fd52e0df/pydantic_core-2.46.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:53feb344243bb9510a9dec7bf3cf1b64d88a98af5dc7872a5160465f8b198c8e", size = 2132244, upload-time = "2026-08-28T09:58:10.435Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/32/7d6ca365fadba186a0c8f85de1a701663bce81efd309d9479be58687622f/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:cd5214352ae68f3b5e9af7768bdc5253695ee069675db3480518420b3be881f2", size = 2143901, upload-time = "2026-08-28T09:58:12.033Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f8/09/eb9a6aa57f22fd1541a9c0aa2a1f3aeef3ec65347d33e10a6da2f43e0ee9/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:9432f3598db432cb51c5b37fdbf29a60fcccc79e30d37a05022776a6bc4ab689", size = 2299425, upload-time = "2026-08-28T09:58:13.614Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8a/f9/548a5bb9d4ba8cd26e26daf48052236f6b38bb61e7b7241fbc3c995719eb/pydantic_core-2.46.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8feeac04b5794e513e710af2f9c87d49f31a6dc47967bb264a1fed61a8989bec", size = 2318566, upload-time = "2026-08-28T09:58:15.199Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/4a/20/06454d18834c02c406c9133f1a3b485305fd9ee984f9636c2f730bef6a9d/pydantic_core-2.46.5-cp311-cp311-win32.whl", hash = "sha256:892a881d5f68c2b9ea304b7a6c2c60d9343df578a311b0f86b94bc8f1ffe8129", size = 1954258, upload-time = "2026-08-28T09:58:16.813Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/9e/c2/718b9deb4b72453b5d8c7447a3b14cb77bef36917ef5f514e0948a4096a0/pydantic_core-2.46.5-cp311-cp311-win_amd64.whl", hash = "sha256:40375c2d05acec10323e45dfe2077ac44bc74659008614af5069034e2cfc781c", size = 2041030, upload-time = "2026-08-28T09:58:18.288Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/ea/c1d1a5b72d6e1ff7f377a4d9199f6591f095beb5b409a8a5d89f7238d939/pydantic_core-2.46.5-cp311-cp311-win_arm64.whl", hash = "sha256:28a6a556cd3b6066bea827857f9d9cce027c96f776e512f544a581f9e42161f8", size = 2009234, upload-time = "2026-08-28T09:58:19.929Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/3f/76358795aa7a8c6d4f36e2cb828ad1c90ee118e1393a9281664f5aade9d4/pydantic_core-2.46.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b9fe6fb92520e3fd61f2e49000b6911b188824f089b75973ea06d6267f0b476d", size = 2076516, upload-time = "2026-08-28T09:58:21.576Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/db/50/26b091836076ce4cb2fac264186936acc069e0595772cfd02a563bc4761a/pydantic_core-2.46.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a39ac25a9a2fa4072efdb429833c4a4c8009a51ff9eea3eeae131713cd27991e", size = 1922874, upload-time = "2026-08-28T09:58:23.766Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/09/f0/2a8ce3849e299d44e2d2c196b6082643a3235565a735cb51db7a6261f614/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4fdc8b93a41521988916eeaa271173fcca7fa0803d62f87675aac8dcec1c8e29", size = 1951772, upload-time = "2026-08-28T09:58:25.435Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/87/46/ac0dc8bdd9e6048183a14eb127764e7ad9240021c17513074a4711b0e31e/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b98134087d9de723658d17a42c7d0da8d6e2ef08015dee7dc93889047315f5e4", size = 2031832, upload-time = "2026-08-28T09:58:27.102Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c4/c2/339de5bef7be36301a2231eaa52e62163742c2281f11b5f4892bc79785cd/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e652ab17569c94bff5475520f907b7148b8c24036a8ebbe5cf7cf7493d28579a", size = 2208645, upload-time = "2026-08-28T09:58:28.948Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7b/a0/9ff22b797724262da14427abaed4dd1d864a139693fc5e7809114376a716/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d925f3d9afd05a8c0fb3a1031463a8d59ebe5e2afad297e29c78be19e13b4e62", size = 2265935, upload-time = "2026-08-28T09:58:30.625Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/a4/eb9409ec0736e50aa70a412f16c204ed149516846912f7e6724d4c73ee53/pydantic_core-2.46.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fc5be0abd4a407e200d844b404e33639a554e7bd0d448e7b9ae181be4789ac2", size = 2066284, upload-time = "2026-08-28T09:58:32.289Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/02/7f6156ffc926857f1c37c07d9a388682865a81830ab6a1b637082c25e399/pydantic_core-2.46.5-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:816ff0a6550ffc06c098ccd2e0698600f9aa7da192a79eaa6f9af504a35db869", size = 2105889, upload-time = "2026-08-28T09:58:33.986Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/b1/e781d357ebe09fc929f995700f1b3503e8897f1cece183ecb1300d4d67e9/pydantic_core-2.46.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c7ea57fc63aa7da93a1bd2d644e6577befae10c52c4e36377635eea1056a74f5", size = 2158006, upload-time = "2026-08-28T09:58:35.647Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/70/0a/644597d84ab400e50609c192120b85c9681c22d3a20461b9060a79be0a7a/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:efd62a42486f1bda5d24cb4f63d15a3c7768375fe83d36f9417b4ad7a2fb20b3", size = 2158408, upload-time = "2026-08-28T09:58:37.38Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1e/ee/ca3b7b3a4b3769ffe9ce9432a7c9be755de9593a46d3b0d54d0409323e44/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:2bc9419666990c06d7397831f2126a1ecc3594aaa3ff7de5bf2d066802f4e07b", size = 2309609, upload-time = "2026-08-28T09:58:39.22Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ce/52/39fa1f451486019524ca685020390e7ca351832fd874530ba30c8628e6dc/pydantic_core-2.46.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:18a09e1e1011b462f2e32774f25859ef1223d5c2b0546a633cf56654710721e0", size = 2342618, upload-time = "2026-08-28T09:58:40.89Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/81/5e/468fc630568c61dcef3cd47ad32ffbeed9af643f49208d1ea86ab4f890c4/pydantic_core-2.46.5-cp312-cp312-win32.whl", hash = "sha256:5cb482e9e84c851f4e623fe4acc1ced89168cf1fe18f7089db4548c8f5bbb65b", size = 1939475, upload-time = "2026-08-28T09:58:42.591Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/cf/c9/4c19f41b84cf6b622a72fbeed7665b25d47a187d68d47d0d430c07f23268/pydantic_core-2.46.5-cp312-cp312-win_amd64.whl", hash = "sha256:5e81740c09e310f5aa5cbd3e434a01c154d4bef93241c7877b39f211d2b78ba8", size = 2043140, upload-time = "2026-08-28T09:58:44.272Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/dd/0c1a050299147c746e5256db16d645ab5efd4f78c59937d581a0524e74a2/pydantic_core-2.46.5-cp312-cp312-win_arm64.whl", hash = "sha256:f7b0ec93a2893de856652154d73b7ba622f26fa97726487dcac373de5f4c6084", size = 1997729, upload-time = "2026-08-28T09:58:46.13Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f5/37/5abe39a8372a61d3dc3c1338fc504281c01b32fdb3169cd7187153b56d3e/pydantic_core-2.46.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:b7ca9034437b6022f941f4857459562ee00a560b97e7cce8a0ec5a74fc6766e0", size = 2075885, upload-time = "2026-08-28T09:58:47.856Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/21/43/6323b1f8b217780454c61304bcd2b38ae4762f50754414124603ccc90bb2/pydantic_core-2.46.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f332f0e72a5a0400141f830744e141bf9f97917878dbe968669e8a7fefea78ff", size = 1922768, upload-time = "2026-08-28T09:58:49.58Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/0f/a3/c05ca796e1197618a774b01e596aeedfefc2f7d8c01ae3054e910b120e8a/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:193375f3548919d3f0b60936ca113ada3e38f264f91b9b8e0508efaad57be931", size = 1951241, upload-time = "2026-08-28T09:58:51.511Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/68/32/33bc39ac705c52cffc908e8389f9754fdb208aea5c69cceddf4eb3ce99af/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:79bdfa52f843137045b2d081cc05c120ba6665d29b7559c2c47690906f39279f", size = 2031975, upload-time = "2026-08-28T09:58:53.166Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b0/70/2333e885c0f6a67bc105c5916965dac9b57f2718ee20d81d1a06a4ebdc13/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:24922243639cbdac66c75fcb6fd6495a9cb52b213d62f9a0d16f0310b1ff8038", size = 2208542, upload-time = "2026-08-28T09:58:55.017Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f7/ea/296debfb4264207bbda5936133892e027c0a58875ad53ebd512fba8ec3a2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c76fe65e607be28c7fd4d56fc3c42b1583aa058ce3408b7ad0fd540171d31f9f", size = 2264692, upload-time = "2026-08-28T09:58:56.767Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/f2/9e4de77a6271e07a76d2d58b11c091a979c191ed2939bf80067568b369d2/pydantic_core-2.46.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f7b393a8b3da82f5c1fc0751e6d01ac6c55b93c18226a60bdfba4a724efafd1", size = 2066633, upload-time = "2026-08-28T09:58:58.531Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/8d/db/f9e9d0c97445987b2084823d5c240de88087338f04fc2cfaa2df186b8049/pydantic_core-2.46.5-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:7ac031912d54f3d83ef3b3eb98dfabc1608802e2202263d25957eeed40b94761", size = 2105235, upload-time = "2026-08-28T09:59:00.421Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/c5/79169b047b3b2c3e99e04bc76372af9637e0bf6db638274fa927df96369e/pydantic_core-2.46.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:837b396ca3d7b74091ca623f6cbd8351bd42d670a79c2683e79fb089f06a2de5", size = 2157367, upload-time = "2026-08-28T09:59:02.442Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/26/b5/ba6057afb7c291bd449f51b867f95aef2072941c4ce4e5c31d6ffd132d3b/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5ee239d575f80b08eca11f6e20f90c4c695de7825c67eefe6091fbf20dda648e", size = 2158420, upload-time = "2026-08-28T09:59:04.2Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/6e/28/2057abecaafdc22912afa819603a51f0a62d40643b7c4871c51721fea9be/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:e80675d75ae2cd14372cb65cad5400d9347a3d3f6c13000183f22dfd027283ed", size = 2309588, upload-time = "2026-08-28T09:59:06.048Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/9d/881156dc404e27479c4246128d73538464cab4a239bec61995e227644c30/pydantic_core-2.46.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:9c4b71f10dd532fb7a5cbc8f58707779e64f03a258c2bf8bfbaecfcd9970b519", size = 2341866, upload-time = "2026-08-28T09:59:08.539Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/38/d66f443a259f84d13babdceae568e572b0ed26da17ca5d0a649ebb110a67/pydantic_core-2.46.5-cp313-cp313-win32.whl", hash = "sha256:97bf8de4d541598c94a59344eeb988a94c08ff76b5723c41f6567ec18c7892ea", size = 1938580, upload-time = "2026-08-28T09:59:10.402Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/2c/1e/1d5371213f4cc9a7ed70c0bfcc7911de22311ee99a662a56077d7292d2ac/pydantic_core-2.46.5-cp313-cp313-win_amd64.whl", hash = "sha256:15f4a94963c95accac15b7b657bb177d3ad82bb90b0d0526d9a9b85079925db5", size = 2041980, upload-time = "2026-08-28T09:59:12.396Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/5a/48/4222d90b1c67568bace4dec6dca6271449c66de3595d72b6d098f5fde597/pydantic_core-2.46.5-cp313-cp313-win_arm64.whl", hash = "sha256:d22a945598fb91236b4dd793a6e42e4f3dd7740bb5aace5ebd7d4c08d13bb575", size = 1997213, upload-time = "2026-08-28T09:59:14.245Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/af/1e/ecca01fce348f7e8afa9572441ff6f7d1cc70d21e4859f33944d10877e1e/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:c14ad3bdc85ee7f318742c457ca3968a92126d144b15721c759033bfb06296c2", size = 2075342, upload-time = "2026-08-28T10:00:51.353Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/4c/af80c7a8032dfc897040ad5cb772bebde529a381186499e6e29987f23f8c/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0bddb4020d8f04175865ccd17eff3040874fc11fb593f424edb452653b4b947c", size = 1907219, upload-time = "2026-08-28T10:00:53.438Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/be/3e/54d89e2b092e778716bf6153634ef479e955f48c261090be23aa1e0fb0b5/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2471fd51c61c610e1dcf7de44d7299283661654d11264ab4802b303368d69c47", size = 1953393, upload-time = "2026-08-28T10:00:55.58Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/ea/89/828ee90cda28ce17bdefaa3a6eaf74fe430e113295a10e6126beca559d6c/pydantic_core-2.46.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b10ec717381bdbfafef34607824db4c91de69ff085e4fca3b2af91b4fa17e68a", size = 2099024, upload-time = "2026-08-28T10:00:57.794Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/df/dd/053c2e4303f791f3b8f8a14ab0b22008e8eb21d868c0c90b4f9be705b76a/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:013d6f3483d81e02e7c328831808f336c8596ee33b4bd4026b9ffb1e960b8942", size = 2062540, upload-time = "2026-08-28T10:01:00.318Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d7/dd/a18df751a5e37dd51bfad7f68e766999125bebe68c9e1d10a493ad01bd63/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:e9c134bb666dd54b778b9fc0d2b50cbb7f979b9e3716f26a88c9ab3b6fc1dd0f", size = 1902040, upload-time = "2026-08-28T10:01:02.529Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b7/13/01d40f9d07ce8a779fd6e0bd8ad4fba91309500dd67b869e2e219d261a6d/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:347ec774390c87326a2e4929d58d3f7e8763a104d5d35f4cd595a4c952366433", size = 1967479, upload-time = "2026-08-28T10:01:05.004Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/fa/04/c81d4841331c2178b6fb09ae225425e110ed72d990c9fe556c4ec03d1013/pydantic_core-2.46.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e24d8f05fa2d28513d94e877e9c75ad66175376209b3977f916e240e623193c", size = 2111034, upload-time = "2026-08-28T10:01:07.345Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/20/21/22102e9950b3049526d20e811b95396508377d87651edd2b80d2b3d28659/pydantic_core-2.46.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ab4b66edffb32d9e951efb3814bd104b8367a7501b81b955cacb5726d897389f", size = 2071333, upload-time = "2026-08-28T10:01:09.636Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/18/87aefa427d191e6d3ab1447f1efc1cdcac86af1069239b133e8a0fd7f7c9/pydantic_core-2.46.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:337639ba62a11acde6ef3aeb08c8ea755f8ef1fe5e513356c0f36a2b0d7568b0", size = 1912713, upload-time = "2026-08-28T10:01:12.285Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1f/93/fd89e9ad49b1805ca94d24ce1088b7d305f05c35ffafcedb9819d03588a0/pydantic_core-2.46.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:413a717a410d0c817ef5b786a059415550b3794e1d0c2abffd9efb93a3d9f7b4", size = 2090926, upload-time = "2026-08-28T10:01:15.19Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/6f/45/8e59dab6acf8d35f02f0a958980074f31038968bdb2c983fcae9d1efee03/pydantic_core-2.46.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1e449def1945a462c464331254e5a44fca7c3b4f9aedf59ec2f50f8066dd8e25", size = 2131303, upload-time = "2026-08-28T10:01:17.937Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d5/a5/e1d4dc5180dd887a9522efc1f8716b8692b7606b1d3273d7862eaf66be44/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:a445486499897b88a7d6c310c88ed64dd37b1b59bfd7ae9107490bbb362f47d6", size = 2145128, upload-time = "2026-08-28T10:01:20.694Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c2/d7/ad493864a7fb21c0c4df98f965e2db430cb25a9d7369b5778d5016c09fd9/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:2d330aaba8621b1edcec8ae2c4050f63b84ccf6d98723a8f212e9684713abf0e", size = 2294560, upload-time = "2026-08-28T10:01:23.495Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/02/8e/b41c84c913f29973a268e6c2b5bbf13c95adb9956c126d10da11ba3b2bef/pydantic_core-2.46.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:b6acfb46a814762367fb7ba0828b0a17d441b92ce249a0e007474c9072662dda", size = 2317531, upload-time = "2026-08-28T10:01:26.334Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/db/1d/068464f23075f66a8f1b806935e9cd9363ee446636ea70d2c22ee8659dbf/pydantic_core-2.46.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d0a24b40877af2de4950252be9d21eaf7fb07660f3c2cae1f56c6b599ada5266", size = 2140686, upload-time = "2026-08-28T10:01:28.947Z" },
]
[[package]]
name = "pygments"
version = "2.21.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
]
[[package]]
name = "pyquantdata"
version = "0.1.0"
source = { editable = "." }
dependencies = [
{ name = "duckdb" },
{ name = "fastapi" },
{ name = "psutil" },
{ name = "pyarrow" },
{ name = "pydantic" },
{ name = "pytdxdata" },
{ name = "pytz" },
{ name = "rich" },
{ name = "sqlglot" },
{ name = "typer" },
{ name = "tzdata" },
{ name = "uvicorn" },
]
[package.dev-dependencies]
dev = [
{ name = "httpx" },
{ name = "pandas" },
{ name = "pytest" },
{ name = "pytest-asyncio" },
{ name = "pytest-cov" },
{ name = "pytest-timeout" },
]
[package.metadata]
requires-dist = [
{ name = "duckdb", specifier = ">=1.1" },
{ name = "fastapi", specifier = ">=0.115" },
{ name = "psutil", specifier = ">=6" },
{ name = "pyarrow", specifier = ">=17" },
{ name = "pydantic", specifier = ">=2.8" },
{ name = "pytdxdata", specifier = ">=0.6" },
{ name = "pytz", specifier = ">=2024.1" },
{ name = "rich", specifier = ">=13" },
{ name = "sqlglot", specifier = ">=25" },
{ name = "typer", specifier = ">=0.12" },
{ name = "tzdata", specifier = ">=2024.1" },
{ name = "uvicorn", specifier = ">=0.30" },
]
[package.metadata.requires-dev]
dev = [
{ name = "httpx", specifier = ">=0.27" },
{ name = "pandas", specifier = ">=2.2" },
{ name = "pytest", specifier = ">=8" },
{ name = "pytest-asyncio", specifier = ">=0.24" },
{ name = "pytest-cov", specifier = ">=5" },
{ name = "pytest-timeout", specifier = ">=2.3" },
]
[[package]]
name = "pytdxdata"
version = "0.6.1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/be/f0/0edbb1b3207c8e49e19d2d821305044616b565b03a37f6e1ba975bf7a246/pytdxdata-0.6.1.tar.gz", hash = "sha256:958238e05536f096b4cad5fad18240984a7cad3bf4786faeb8f910698ea3cf8e", size = 91526, upload-time = "2026-09-22T02:23:38.109Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/2b/f6/a4c0d5b508495bc544df877cb452080e5d9ee8c8492b02ddece44b74bcea/pytdxdata-0.6.1-py3-none-any.whl", hash = "sha256:415fb29ed52822c2c00d177dd8693806d450fda0e8b3f09ced48e8958f82a0d5", size = 118331, upload-time = "2026-09-22T02:23:36.793Z" },
]
[[package]]
name = "pytest"
version = "9.1.1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "colorama", marker = "sys_platform == 'win32'" },
{ name = "iniconfig" },
{ name = "packaging" },
{ name = "pluggy" },
{ name = "pygments" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
]
[[package]]
name = "pytest-asyncio"
version = "1.4.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "pytest" },
{ name = "typing-extensions", marker = "python_full_version < '3.13'" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/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 = "pytest-cov"
version = "7.1.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "coverage", extra = ["toml"] },
{ name = "pluggy" },
{ name = "pytest" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
]
[[package]]
name = "pytest-timeout"
version = "2.4.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "pytest" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/ac/82/4c9ecabab13363e72d880f2fb504c5f750433b2b6f16e99f4ec21ada284c/pytest_timeout-2.4.0.tar.gz", hash = "sha256:7e68e90b01f9eff71332b25001f85c75495fc4e3a836701876183c4bcfd0540a", size = 17973, upload-time = "2025-05-05T19:44:34.99Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/fa/b6/3127540ecdf1464a00e5a01ee60a1b09175f6913f0644ac748494d9c4b21/pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2", size = 14382, upload-time = "2025-05-05T19:44:33.502Z" },
]
[[package]]
name = "python-dateutil"
version = "2.9.0.post0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "six" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "pytz"
version = "2026.3.post1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fb/48/fb042503b6ca6cd271261dc559fd6432f7d8c713153e9ec5c591af4dfc1c/pytz-2026.3.post1.tar.gz", hash = "sha256:2211d3fcf9a797d3405cac96ac7f61d80e6a644f72a3309607282fe8a2010c5d", size = 319745, upload-time = "2026-07-25T15:12:07.385Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/0f/7b/39c34ca613b0b198cb866466651b26b045e2009864c5183c979a3b83f383/pytz-2026.3.post1-py2.py3-none-any.whl", hash = "sha256:dd95840dd199baea12d9cc096a1d452caa6596a1c1e4b5f3dbd1541855d5e815", size = 508283, upload-time = "2026-07-25T15:12:05.782Z" },
]
[[package]]
name = "rich"
version = "15.0.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "markdown-it-py" },
{ name = "pygments" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
]
[[package]]
name = "shellingham"
version = "1.5.4"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
]
[[package]]
name = "six"
version = "1.17.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/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://pypi.tuna.tsinghua.edu.cn/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 = "sqlglot"
version = "30.19.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/fe/48/996687ba146c07deee6cc3528738e645d2e72805e023ed9672b483648378/sqlglot-30.19.0.tar.gz", hash = "sha256:6fcfbe93c5ee76e07faadf0930dd119eebb545c4f317f8e4f205f177305d8b08", size = 6042945, upload-time = "2026-09-22T15:19:58.64Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/94/094d83ec808b50374f33a3024c9e60ca3074595e1f9581c1692591fda81e/sqlglot-30.19.0-py3-none-any.whl", hash = "sha256:b4500fcced395359feea582f09d2d4433bf1f36362a3a9d0d6d5ebbc1f84242e", size = 756203, upload-time = "2026-09-22T15:19:56.761Z" },
]
[[package]]
name = "starlette"
version = "1.6.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "anyio" },
{ name = "typing-extensions", marker = "python_full_version < '3.13'" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b5/b4/205b0d5241d934e8add0c38aa924c4f9fb7330834ff11e5444db964ec3f9/starlette-1.6.0.tar.gz", hash = "sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b", size = 2716969, upload-time = "2026-08-08T18:27:57.512Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c8/cb/6a6a47d5b464bd08695d254f3da6e7986cc70c9fa5d778eda57538edfe56/starlette-1.6.0-py3-none-any.whl", hash = "sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c", size = 75969, upload-time = "2026-08-08T18:27:56.196Z" },
]
[[package]]
name = "tomli"
version = "2.4.1"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" },
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
]
[[package]]
name = "typer"
version = "0.27.2"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "annotated-doc" },
{ name = "colorama", marker = "sys_platform == 'win32'" },
{ name = "rich" },
{ name = "shellingham" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/16/f7/57713ba479fd405eb76de31404b2c744c289e336b2d999511ebf51e496f7/typer-0.27.2.tar.gz", hash = "sha256:269b7eb9d3c202ca84b4bc9618cb04ebb43d3d4d1e567e4c768607232c05f945", size = 204045, upload-time = "2026-08-28T10:26:55.046Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/dc/bf/205d0004930ede8f542fb58f601526fccf4ae7626075ca1e6c4de5d3d652/typer-0.27.2-py3-none-any.whl", hash = "sha256:b3a5fc4342d5fc8fda8fc3010b1cf117e9249aab7fae800c2eff62fd3842d97d", size = 123130, upload-time = "2026-08-28T10:26:53.752Z" },
]
[[package]]
name = "typing-extensions"
version = "4.16.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/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 = "typing-inspection"
version = "0.4.4"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "typing-extensions" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" },
]
[[package]]
name = "tzdata"
version = "2026.4"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/e4/31/3d74fa778a63b98b7374323befcc0be5ab3bd94afd4096a0124e7379152c/tzdata-2026.4.tar.gz", hash = "sha256:f1b8bd365d8d210c55353f4d7f8d6d8561c0ba50d704b700d195a9424bba0d79", size = 199350, upload-time = "2026-09-12T12:56:03.251Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/f9/bc/8737e8d54cf51106118039b83f485a4783112fab49ea9d044b234978a46e/tzdata-2026.4-py2.py3-none-any.whl", hash = "sha256:c2169a8b0a7a5e9674da5a135ccdfb2b3e671b333ed9fed17b41f73c34476e81", size = 347494, upload-time = "2026-09-12T12:56:01.67Z" },
]
[[package]]
name = "uvicorn"
version = "0.53.0"
source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
dependencies = [
{ name = "click" },
{ name = "h11" },
]
sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/5d/ad/04bbb797c84fc1f26cb171f7394716f4865ffb8d8c5e1eef42565c2dfa6b/uvicorn-0.53.0.tar.gz", hash = "sha256:a9356f0cb89b3b8621529c5d5eebd69bfe154f4c3f68b4cf2de47e45fa855c2e", size = 110881, upload-time = "2026-09-14T07:44:23.815Z" }
wheels = [
{ url = "https://pypi.tuna.tsinghua.edu.cn/packages/76/18/0eea75741ee812e9f598b687619ce2454f6c3a1c5cd21ea990ec6bd26f45/uvicorn-0.53.0-py3-none-any.whl", hash = "sha256:e8dca71ec86dce5f04e333f0d56cdedf942446e6643b9cea1af0d6d3a02cb03e", size = 87081, upload-time = "2026-09-14T07:44:22.179Z" },
]