commit d37c697bbe250f3fb6c28322b5a648355b2ccc0f Author: openbot-coder Date: Thu Sep 24 09:06:47 2026 +0800 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 已核验 diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..35c3e60 --- /dev/null +++ b/.github/workflows/ci.yml @@ -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" diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..501d561 --- /dev/null +++ b/.github/workflows/release.yml @@ -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 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..206573f --- /dev/null +++ b/.gitignore @@ -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/ diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..4eba2a6 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.13.0 diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..7f0c384 --- /dev/null +++ b/LICENSE @@ -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. diff --git a/README.md b/README.md new file mode 100644 index 0000000..59991a8 --- /dev/null +++ b/README.md @@ -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 diff --git a/docs/quantdata-design.md b/docs/quantdata-design.md new file mode 100644 index 0000000..1bcfffc --- /dev/null +++ b/docs/quantdata-design.md @@ -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 `;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 只出干净原始数据,特征与因子归它们 | diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..1669cae --- /dev/null +++ b/pyproject.toml @@ -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", +] diff --git a/scripts/smoke_m1.py b/scripts/smoke_m1.py new file mode 100644 index 0000000..4b97993 --- /dev/null +++ b/scripts/smoke_m1.py @@ -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()) diff --git a/src/pyquantdata/__init__.py b/src/pyquantdata/__init__.py new file mode 100644 index 0000000..51f9238 --- /dev/null +++ b/src/pyquantdata/__init__.py @@ -0,0 +1,3 @@ +"""pyquantdata: quantdata CLI —— 单目录自包含的量化数据中台。""" + +__version__ = "0.1.0" diff --git a/src/pyquantdata/__main__.py b/src/pyquantdata/__main__.py new file mode 100644 index 0000000..18a0213 --- /dev/null +++ b/src/pyquantdata/__main__.py @@ -0,0 +1,6 @@ +"""python -m pyquantdata 入口。""" + +from .cli import main + +if __name__ == "__main__": + main() diff --git a/src/pyquantdata/cli.py b/src/pyquantdata/cli.py new file mode 100644 index 0000000..88e8dcf --- /dev/null +++ b/src/pyquantdata/cli.py @@ -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() diff --git a/src/pyquantdata/config.py b/src/pyquantdata/config.py new file mode 100644 index 0000000..807d774 --- /dev/null +++ b/src/pyquantdata/config.py @@ -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)) diff --git a/src/pyquantdata/etl/__init__.py b/src/pyquantdata/etl/__init__.py new file mode 100644 index 0000000..7570752 --- /dev/null +++ b/src/pyquantdata/etl/__init__.py @@ -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", +] diff --git a/src/pyquantdata/etl/checkpoint.py b/src/pyquantdata/etl/checkpoint.py new file mode 100644 index 0000000..963cb89 --- /dev/null +++ b/src/pyquantdata/etl/checkpoint.py @@ -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"] diff --git a/src/pyquantdata/etl/seed.py b/src/pyquantdata/etl/seed.py new file mode 100644 index 0000000..436286c --- /dev/null +++ b/src/pyquantdata/etl/seed.py @@ -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), + ) diff --git a/src/pyquantdata/etl/update.py b/src/pyquantdata/etl/update.py new file mode 100644 index 0000000..a033dc2 --- /dev/null +++ b/src/pyquantdata/etl/update.py @@ -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)) diff --git a/src/pyquantdata/export/__init__.py b/src/pyquantdata/export/__init__.py new file mode 100644 index 0000000..df908cf --- /dev/null +++ b/src/pyquantdata/export/__init__.py @@ -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", +] diff --git a/src/pyquantdata/export/files.py b/src/pyquantdata/export/files.py new file mode 100644 index 0000000..13b895d --- /dev/null +++ b/src/pyquantdata/export/files.py @@ -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(), + } diff --git a/src/pyquantdata/lockfile.py b/src/pyquantdata/lockfile.py new file mode 100644 index 0000000..96e29c3 --- /dev/null +++ b/src/pyquantdata/lockfile.py @@ -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 diff --git a/src/pyquantdata/paths.py b/src/pyquantdata/paths.py new file mode 100644 index 0000000..9566232 --- /dev/null +++ b/src/pyquantdata/paths.py @@ -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") diff --git a/src/pyquantdata/serve/__init__.py b/src/pyquantdata/serve/__init__.py new file mode 100644 index 0000000..5ca8f53 --- /dev/null +++ b/src/pyquantdata/serve/__init__.py @@ -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", +] diff --git a/src/pyquantdata/serve/app.py b/src/pyquantdata/serve/app.py new file mode 100644 index 0000000..0ac0a29 --- /dev/null +++ b/src/pyquantdata/serve/app.py @@ -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 diff --git a/src/pyquantdata/serve/auth.py b/src/pyquantdata/serve/auth.py new file mode 100644 index 0000000..bb8f9be --- /dev/null +++ b/src/pyquantdata/serve/auth.py @@ -0,0 +1,51 @@ +"""鉴权与日志脱敏(设计 §8.4)。 + +- token 非空时:REST ``Authorization: Bearer ``;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 diff --git a/src/pyquantdata/serve/runtime.py b/src/pyquantdata/serve/runtime.py new file mode 100644 index 0000000..0917011 --- /dev/null +++ b/src/pyquantdata/serve/runtime.py @@ -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) diff --git a/src/pyquantdata/serve/state.py b/src/pyquantdata/serve/state.py new file mode 100644 index 0000000..db7d4c4 --- /dev/null +++ b/src/pyquantdata/serve/state.py @@ -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]) diff --git a/src/pyquantdata/sources/__init__.py b/src/pyquantdata/sources/__init__.py new file mode 100644 index 0000000..a3ece14 --- /dev/null +++ b/src/pyquantdata/sources/__init__.py @@ -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", +] diff --git a/src/pyquantdata/sources/base.py b/src/pyquantdata/sources/base.py new file mode 100644 index 0000000..30a4f8e --- /dev/null +++ b/src/pyquantdata/sources/base.py @@ -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, [])) diff --git a/src/pyquantdata/sources/classify.py b/src/pyquantdata/sources/classify.py new file mode 100644 index 0000000..7ad857d --- /dev/null +++ b/src/pyquantdata/sources/classify.py @@ -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 "" diff --git a/src/pyquantdata/sources/tdx.py b/src/pyquantdata/sources/tdx.py new file mode 100644 index 0000000..f0bd5bf --- /dev/null +++ b/src/pyquantdata/sources/tdx.py @@ -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) diff --git a/src/pyquantdata/sqlgate/__init__.py b/src/pyquantdata/sqlgate/__init__.py new file mode 100644 index 0000000..dc9ae89 --- /dev/null +++ b/src/pyquantdata/sqlgate/__init__.py @@ -0,0 +1,5 @@ +"""SQL 闸:query_sql 安全约束(§8.3)。""" + +from .gate import FORBIDDEN_FUNCTIONS, SqlRejected, validate + +__all__ = ["FORBIDDEN_FUNCTIONS", "SqlRejected", "validate"] diff --git a/src/pyquantdata/sqlgate/gate.py b/src/pyquantdata/sqlgate/gate.py new file mode 100644 index 0000000..8cbccf4 --- /dev/null +++ b/src/pyquantdata/sqlgate/gate.py @@ -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 diff --git a/src/pyquantdata/store/__init__.py b/src/pyquantdata/store/__init__.py new file mode 100644 index 0000000..5c8c332 --- /dev/null +++ b/src/pyquantdata/store/__init__.py @@ -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", +] diff --git a/src/pyquantdata/store/db.py b/src/pyquantdata/store/db.py new file mode 100644 index 0000000..f220f81 --- /dev/null +++ b/src/pyquantdata/store/db.py @@ -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") diff --git a/src/pyquantdata/store/migrations.py b/src/pyquantdata/store/migrations.py new file mode 100644 index 0000000..e1e7bdd --- /dev/null +++ b/src/pyquantdata/store/migrations.py @@ -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] diff --git a/src/pyquantdata/store/views.py b/src/pyquantdata/store/views.py new file mode 100644 index 0000000..438b387 --- /dev/null +++ b/src/pyquantdata/store/views.py @@ -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) diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..cbfbf3e --- /dev/null +++ b/tests/conftest.py @@ -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 diff --git a/tests/fixtures/build_ci_fixture.py b/tests/fixtures/build_ci_fixture.py new file mode 100644 index 0000000..242a371 --- /dev/null +++ b/tests/fixtures/build_ci_fixture.py @@ -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()) diff --git a/tests/fixtures/ci_seed_1d.parquet b/tests/fixtures/ci_seed_1d.parquet new file mode 100644 index 0000000..fd5484f Binary files /dev/null and b/tests/fixtures/ci_seed_1d.parquet differ diff --git a/tests/test_app.py b/tests/test_app.py new file mode 100644 index 0000000..09544b0 --- /dev/null +++ b/tests/test_app.py @@ -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 diff --git a/tests/test_auth.py b/tests/test_auth.py new file mode 100644 index 0000000..f011b8d --- /dev/null +++ b/tests/test_auth.py @@ -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 diff --git a/tests/test_checkpoint.py b/tests/test_checkpoint.py new file mode 100644 index 0000000..dd7fbe3 --- /dev/null +++ b/tests/test_checkpoint.py @@ -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"] diff --git a/tests/test_ci_chain.py b/tests/test_ci_chain.py new file mode 100644 index 0000000..3c41366 --- /dev/null +++ b/tests/test_ci_chain.py @@ -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 diff --git a/tests/test_classify.py b/tests/test_classify.py new file mode 100644 index 0000000..5bafed3 --- /dev/null +++ b/tests/test_classify.py @@ -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 diff --git a/tests/test_cli.py b/tests/test_cli.py new file mode 100644 index 0000000..ebef5fb --- /dev/null +++ b/tests/test_cli.py @@ -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 diff --git a/tests/test_config.py b/tests/test_config.py new file mode 100644 index 0000000..6689ff8 --- /dev/null +++ b/tests/test_config.py @@ -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) diff --git a/tests/test_coverage_gaps.py b/tests/test_coverage_gaps.py new file mode 100644 index 0000000..b5efc5d --- /dev/null +++ b/tests/test_coverage_gaps.py @@ -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) diff --git a/tests/test_db.py b/tests/test_db.py new file mode 100644 index 0000000..e080997 --- /dev/null +++ b/tests/test_db.py @@ -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() diff --git a/tests/test_etl_update.py b/tests/test_etl_update.py new file mode 100644 index 0000000..e071235 --- /dev/null +++ b/tests/test_etl_update.py @@ -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 # 整年逐日,重放不翻倍 diff --git a/tests/test_export_files.py b/tests/test_export_files.py new file mode 100644 index 0000000..e178b50 --- /dev/null +++ b/tests/test_export_files.py @@ -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 diff --git a/tests/test_lockfile.py b/tests/test_lockfile.py new file mode 100644 index 0000000..88981eb --- /dev/null +++ b/tests/test_lockfile.py @@ -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 diff --git a/tests/test_migrations.py b/tests/test_migrations.py new file mode 100644 index 0000000..8fcc964 --- /dev/null +++ b/tests/test_migrations.py @@ -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] diff --git a/tests/test_paths.py b/tests/test_paths.py new file mode 100644 index 0000000..95b46b2 --- /dev/null +++ b/tests/test_paths.py @@ -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) diff --git a/tests/test_runtime.py b/tests/test_runtime.py new file mode 100644 index 0000000..d0aee6e --- /dev/null +++ b/tests/test_runtime.py @@ -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 diff --git a/tests/test_seed.py b/tests/test_seed.py new file mode 100644 index 0000000..f6c60bf --- /dev/null +++ b/tests/test_seed.py @@ -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 diff --git a/tests/test_sqlgate.py b/tests/test_sqlgate.py new file mode 100644 index 0000000..55ccbc7 --- /dev/null +++ b/tests/test_sqlgate.py @@ -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 diff --git a/tests/test_state.py b/tests/test_state.py new file mode 100644 index 0000000..3a7f3bf --- /dev/null +++ b/tests/test_state.py @@ -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) diff --git a/tests/test_tdx.py b/tests/test_tdx.py new file mode 100644 index 0000000..b779a73 --- /dev/null +++ b/tests/test_tdx.py @@ -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 diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..551d06d --- /dev/null +++ b/uv.lock @@ -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" }, +]