From 5ab4bef80e8012e661b49d02690a6dc43e01612e Mon Sep 17 00:00:00 2001 From: zimoyin <2556608754@qq.com> Date: Wed, 14 Oct 2026 03:53:48 +0800 Subject: [PATCH] =?UTF-8?q?build:=20CPU/GPU=20=E5=8F=8C=E7=8E=AF=E5=A2=83?= =?UTF-8?q?=E3=80=81=E4=BA=A7=E7=89=A9=E5=91=BD=E5=90=8D=E4=B8=8E=E6=89=93?= =?UTF-8?q?=E5=8C=85=E4=BF=AE=E5=A4=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 交付: · 产物按变体命名:CPU -> dist/ocr-server/,GPU -> dist/ocr-server-gpu/。 变体由构建环境实际装的 paddle 自动判断,不需要人工声明 · GPU 包额外加 --collect-binaries nvidia。漏收的后果实测是最难查的那种: 引擎能正常加载、设备也识别成 GPU,但第一次推理才报 cudnn64_9.dll error 126 · --copy-metadata 的发行包名随变体变化(paddlepaddle / paddlepaddle-gpu), 改由 scripts/paddle_env.py 动态取;写死任何一个在另一种环境下都打不出包 · 新增 scripts/prepare_release_config.py 按变体覆盖发布配置(用 Python 改写 以保持 UTF-8,PowerShell 的 Set-Content 会把中文注释写坏) 环境: · paddle 从 pyproject 依赖里移除,改用 scripts/install_paddle.py 安装。 它没法写死:CPU/GPU 互斥,GPU 还得按显卡选 CUDA 通道(RTX 50 系必须 cu129)。 钉死 CPU 版时,uv sync / uv run / PyCharm 自动同步都会把装好的 paddlepaddle-gpu 静默挤掉、服务悄悄退回 CPU(实测踩过三次) · 新增 scripts/switch_env.py:.venv(CPU)与 .venv-gpu(GPU)两套环境共存, 切换零成本;所有 uv run 补 --no-sync,打包改用 uv sync --inexact · 预置模型扩到 8 套(v4/v5 × 服务端/移动端 × 检测/识别,约 398MB) 其它: · scripts/start.* 先找发布包再退回源码环境;入口脚本名固定是 ocr-server · benchmark_ocr.py 输出 segments 与 chars,换设备/模型时可直接比对召回 · .gitignore 覆盖 .venv-gpu/ 与 dist*/ Co-Authored-By: Claude Code --- .gitignore | 4 +- README.md | 502 +++++++++++++++++++++++++++--- pyproject.toml | 13 +- scripts/benchmark_ocr.py | 82 +++-- scripts/download-models.bat | 4 +- scripts/download-models.sh | 2 +- scripts/download_models.py | 53 ++-- scripts/install_paddle.py | 183 +++++++++++ scripts/package-ubuntu.sh | 115 ++++++- scripts/package-windows.ps1 | 102 +++++- scripts/paddle_env.py | 54 ++++ scripts/prepare_release_config.py | 46 +++ scripts/start.bat | 20 +- scripts/start.ps1 | 24 +- scripts/start.sh | 26 +- scripts/switch_env.py | 150 +++++++++ tests/test_release_helpers.py | 128 ++++++++ uv.lock | 164 ---------- 18 files changed, 1366 insertions(+), 306 deletions(-) create mode 100644 scripts/install_paddle.py create mode 100644 scripts/paddle_env.py create mode 100644 scripts/prepare_release_config.py create mode 100644 scripts/switch_env.py create mode 100644 tests/test_release_helpers.py diff --git a/.gitignore b/.gitignore index 5f02cb3..8ce2328 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ -.venv/ +.venv*/ __pycache__/ *.py[cod] .pytest_cache/ @@ -12,6 +12,6 @@ http/fixtures/*.jpeg http/fixtures/*.png !http/fixtures/general_ocr_002.png *.egg-info/ -dist/ +dist*/ build/ *.spec diff --git a/README.md b/README.md index 7e6e368..297da80 100644 --- a/README.md +++ b/README.md @@ -47,7 +47,7 @@ models/official_models/PP-OCRv5_server_rec 默认模型目录是项目根目录下的 `models`,可以直接修改项目根目录的 `config.yaml`: ```yaml -model_dir: /opt/ocr-server/models +model_dir: /opt/ocr-server-gpu/models ``` 配置文件中的路径支持绝对路径,也支持相对于项目根目录的路径。服务启动时读取一次配置,修改后需要重启服务。 @@ -79,40 +79,42 @@ uv run python scripts/download_models.py ## 不同速度档位和模型选择 -当前项目默认使用 PP-OCRv5 中文服务模型: +当前项目默认使用 **v5 检测 + v4 移动端识别** 的组合: ```yaml det_model_name: PP-OCRv5_server_det -rec_model_name: PP-OCRv5_server_rec +rec_model_name: PP-OCRv4_mobile_rec ``` -PaddleOCR 还提供更小的移动端模型,但 PP-OCRv5 中文识别模型当前默认映射为 `PP-OCRv5_server_rec`;不要只把检测模型替换成其他版本而保持识别模型不变,模型版本和配套模型应成套切换。 +检测与识别可以独立指定,允许跨代际混用(本项目实测有效,见「推荐搭配」一节)。 +`scripts/download_models.py` 已预置四套模型,切换时不需要联网。 | 档位 | 检测模型 | 识别模型 | 特点 | | --- | --- | --- | --- | -| 速度优先 | PP-OCRv4_mobile_det | PP-OCRv4_mobile_rec | 体积和 CPU 推理开销更小,但不是 PP-OCRv5,中文准确率可能下降 | -| 当前默认 | PP-OCRv5_server_det | PP-OCRv5_server_rec | 中文准确率优先,模型约 166 MB | -| 新版模型 | PP-OCRv6_medium_det | PP-OCRv6_medium_rec | 需要单独下载并验证,模型版本不是 PP-OCRv5 | +| 低配 CPU | PP-OCRv5_mobile_det | PP-OCRv4_mobile_rec | 检测仅约 5MB,资源紧张时用 | +| **当前默认** | PP-OCRv5_server_det | PP-OCRv4_mobile_rec | 保召回 + 识别快 8 倍,约 96MB | +| 有 GPU | PP-OCRv5_server_det | PP-OCRv5_server_rec | 精度优先,配 `device: gpu` + `use_tensorrt` | +| 速度优先(会丢字)| PP-OCRv4_mobile_det | PP-OCRv4_mobile_rec | ⚠️ v4 移动端检测在密集图上丢字约 90%,仅适合文本稀疏的图 | 切换前建议: -1. 先把当前 `models/` 完整复制成独立备份,例如 `models.backup-ppocrv5/`; -2. 将新模型下载到另一个目录,例如 `models-ppocrv4-mobile/`; -3. 只修改 `config.yaml` 的 `model_dir` 和两个模型名称; -4. 用 `scripts/benchmark_ocr.py` 和真实业务图片对比耗时、漏检率和准确率; -5. 验证不满意时,把 `model_dir` 改回原目录即可,不改动原模型。 +1. 先用 `scripts/benchmark_ocr.py` 和**真实业务图片**对比耗时、漏检率和**字符数**; +2. 只修改 `config.yaml` 的两个模型名(模型已预置,无需改 `model_dir`); +3. 验证不满意时,把模型名改回原值即可,不改动任何模型文件。 -当前没有自动下载或替换任何小模型,也没有修改现有 PP-OCRv5 权重。服务只读加载模型;若要切换模型,必须使用新的模型目录或先制作备份。 +服务只读加载模型,不会修改权重。模型文件不在 git 里(`.gitignore` 已排除 `models/`), +但打包脚本会自动把 `models/` 复制进发布目录。 ### 当前推荐配置(实测最快且保召回) ```yaml det_model_name: PP-OCRv5_server_det # 检测保持 v5,保证召回 -rec_model_name: PP-OCRv4_mobile_rec # 识别换移动端,快约 8 倍 -cpu_threads: max # 吃满逻辑核心 -enable_mkldnn: true # 依赖 paddlepaddle 3.2.x -text_recognition_batch_size: 8 -text_det_limit_side_len: 512 +rec_model_name: PP-OCRv4_mobile_rec # 识别换移动端,快约 8 倍 +enable_mkldnn: true # 依赖 paddlepaddle 3.2.x +text_recognition_batch_size: 32 # 1.png 实测 23.87s -> 19.03s,输出不变 +text_det_limit_side_len: 1024 # 比 640 多召回约 28% 字符 +cpu_threads: 1 # 开 oneDNN 后几乎无影响,省核给 worker +ocr_workers: 1 # 有并发上传时按核数加大 ``` 叠加效果(1.png,1920x1080,339 个文本框;经服务完整路径实测): @@ -125,6 +127,24 @@ text_det_limit_side_len: 512 **提速约 28 倍,而框数与字符数与精度优先档基本一致**,召回没有损失。 +在这之上再调 `text_recognition_batch_size`(上表是 side=512 的数据,下表统一用 +当前默认的 side=1024,同一台机器、同一张 1.png): + +| batch | 耗时 | 框数 | 字符数 | +| --- | --- | --- | --- | +| 8 | 23.87s | 428 | 2240 | +| 16 | 21.62s | 428 | 2241 | +| **32** | **19.03s** | 428 | 2241 | +| 64 | 18.32s | 428 | 2238 | + +**框数完全一致,字符数只差 1~3 个**,调到 32 就能拿到大部分收益;换成 `64` 只再多省 +0.7 秒,已经饱和。 + +⚠️ 注意批次大小**不是逐字节一致**的:同一张 1.png,`batch=8` 得 2240 字符、 +`batch=32` 得 2241 字符;官方样例图则是 253 → 250。逐条对比后确认,差异只出现在 +**英文分词空格**(`日期 DATE` → `日期DATE`)和个别低置信字符(`高级搜索>` → `高级搜索>>`)上, +正文中文没有差异。切换 batch 仍建议核对一下真实图片的字符数。 + 同一配置下另外两张图(完整服务路径): | 图片 | 耗时 | 框数 | 字符数 | @@ -132,26 +152,44 @@ text_det_limit_side_len: 512 | 2.png (1920x1080) | 7.49s(原 213.52s) | 73 | 430 | | general_ocr_002.png (896x528) | 8.01s(原 70.45s) | 35 | 245 | -### cpu_threads 取 max 的含义 +### cpu_threads:开启 oneDNN 之后几乎不影响耗时 ```yaml cpu_threads: max # = os.cpu_count(),本机 20 逻辑核 → 20 -cpu_threads: 8 # 也可以直接写具体数字 +cpu_threads: 1 # 当前默认 ``` -`max` 是「省心」选项,**不保证最快**:本机为 20 逻辑核 / 14 物理核,超过物理核心数后超线程会争抢,收益递减,还会挤占同机其它服务。建议用 `benchmark_ocr.py` 实测 8 / 14 / max 三档再定。 +**⚠️ 本节结论已更新。** 早期(未启用 oneDNN 时)确实需要靠线程数提性能, +但启用 oneDNN 后识别推理本身就已是多线程,再加线程不再获益。官方样例图 +(896×528) 实测: + +```text +cpu_threads=1 -> 7.25s +cpu_threads=4 -> 6.82s +cpu_threads=8 -> 7.22s +cpu_threads=14 -> 7.29s +cpu_threads=20 -> 7.25s +``` + +差异全部落在测量噪声内。所以**保持 `1` 即可**,把省下的核留给 +`ocr_workers`(并发吞吐)或同机其它服务。 ### 不换模型的加速方式 -先尝试以下配置,不会修改模型文件: +不用换模型、不用动模型文件,先调这几个参数(按收益排序): ```yaml -text_det_limit_side_len: 640 -text_recognition_batch_size: 1 -ocr_workers: 1 +text_recognition_batch_size: 32 # 首选。1.png 实测 23.87s -> 19.03s,输出不变 +text_det_limit_side_len: 768 # 其次。省约 3s,字符数约 -2% +ocr_workers: 4 # 只在有并发上传时才有效,每个 worker 约 +105MB ``` -`text_det_limit_side_len` 从 `960` 调到 `640` 通常可以降低检测耗时,但小字可能漏检。`text_recognition_batch_size` 主要影响单张图片包含很多文本框时的吞吐;增大到 `2` 或 `4` 会增加内存,单张简单图片不一定更快。 +`text_recognition_batch_size` 是性价比最高的旋钮:框越多收益越大,识别框数不变, +字符数只差 1~3 个(差异仅限英文分词空格与个别低置信字符)。调到 `32` 就能拿到 +大部分收益,再往上饱和。 + +`text_det_limit_side_len` 主要影响检测耗时,调小会漏检小字,属于拿召回换速度, +务必用真实图片对比字符数后再定。详见下方「text_det_limit_side_len 与文本密度强相关」。 ## 日志与推理进度 @@ -433,10 +471,15 @@ rec_model_name: PP-OCRv4_mobile_rec ### 如何测速 ```powershell -uv run python scripts/benchmark_ocr.py +uv run --no-sync python scripts/benchmark_ocr.py 你的图.png 3 ``` -修改 `config.yaml` 后重新执行,比较输出的 `elapsed_ms`。建议至少使用 10 张代表性图片,不要只根据一张图片决定模型或参数。 +⚠️ **`--no-sync` 不能省**。`uv run` 默认会按 `pyproject.toml` 同步环境,而那里声明的是 +CPU 版 `paddlepaddle`,会把装好的 `paddlepaddle-gpu` 静默冲掉——测出来的其实是 CPU 成绩。 + +修改 `config.yaml` 后重新执行,比较输出的 `elapsed_ms`、`segments`、`chars`。 +建议至少使用 10 张代表性图片,不要只根据一张图片决定模型或参数;换模型或换设备时 +**重点看 `segments` 和 `chars`**,只快不准是没用的。 ## Python 版本说明 @@ -477,6 +520,21 @@ powershell -ExecutionPolicy Bypass -File .\scripts\start.ps1 # 或双击 scripts\start.bat ``` +⚠️ **`start.*` 会优先跑 `dist\ocr-server\` 里的发布包**,找不到才退回源码(`.venv`)。 +所以只要 `dist\` 里有旧包,**你改的源码就不会生效**,而且日志里看不出区别。 +实测踩过一次:改了 `device` 相关的源码后启动,跑的还是几天前那个包, +配上新写的 `config.yaml`,直接崩在 PaddleX 内部。 + +判断方法看启动日志的 `model_dir`——指向 `dist\ocr-server\models` 就是跑的发布包: + +```text +INFO [ocr_server] 启动 OCR 服务 ... model_dir=D:\...\dist\ocr-server\models ← 发布包 +INFO [ocr_server] 启动 OCR 服务 ... model_dir=D:\code\work\ocr-server\models ← 源码 +``` + +改完源码要立刻验证,直接跑 `.venv\Scripts\ocr-server.exe`(Windows)或 +`.venv/bin/ocr-server`(Linux),绕过发布包;要跑发布包就先重新打包。 + Windows 打包为 exe: ```powershell @@ -529,13 +587,15 @@ uv run python -m uvicorn ocr_server.app:app --host 0.0.0.0 --port 8000 sudo apt-get update sudo apt-get install -y curl libgl1 libglib2.0-0 -cd /opt/ocr-server +cd /opt/ocr-server-gpu curl -LsSf https://astral.sh/uv/install.sh | sh # 重新打开 shell,或按安装提示加载 ~/.local/bin uv python install 3.12 uv sync --python 3.12 +# paddle 不在依赖里,需按机器单独装一次;没有显卡就是 CPU 版 +.venv/bin/python scripts/install_paddle.py # 按需修改项目根目录 config.yaml,然后启动 -uv run ocr-server +uv run --no-sync ocr-server ``` 如果服务器不能访问模型下载源,请在联网机器上执行 `scripts/download_models.py`,将完整项目的 `models/` 目录复制到 Ubuntu 服务器,再启动服务。依赖安装仍需要提前完成;完全离线安装还需要准备本地 Python wheel 缓存。 @@ -546,13 +606,14 @@ uv run ocr-server python3.10 -m venv .venv .venv/bin/python -m pip install -U pip .venv/bin/python -m pip install -e . +.venv/bin/python scripts/install_paddle.py .venv/bin/ocr-server ``` Ubuntu 源码启动: ```bash -cd /opt/ocr-server +cd /opt/ocr-server-gpu uv sync --python 3.12 chmod +x scripts/start.sh ./scripts/start.sh @@ -561,25 +622,32 @@ chmod +x scripts/start.sh Ubuntu 22.04 打包为原生 ELF 二进制: ```bash -cd /opt/ocr-server +cd /opt/ocr-server-gpu chmod +x scripts/package-ubuntu.sh -./scripts/package-ubuntu.sh +./scripts/package-ubuntu.sh # CPU 包 -> dist/ocr-server/ +./scripts/package-ubuntu.sh --gpu # GPU 包 -> dist/ocr-server-gpu/ ``` -发布目录: +发布目录(CPU 版与 GPU 版的目录名不同,一眼能分辨): ```text -dist/ocr-server/ +dist/ocr-server/ # CPU 版 ├── ocr-server ├── config.yaml └── models/ + +dist/ocr-server-gpu/ # GPU 版,另有 _internal/nvidia/ 下的 CUDA 运行库 +├── ocr-server-gpu +├── config.yaml +└── models/ ``` 启动: ```bash -./dist/ocr-server/ocr-server -# 或:./scripts/start.sh +./dist/ocr-server/ocr-server # CPU 版 +./dist/ocr-server-gpu/ocr-server-gpu # GPU 版 +# 或:./scripts/start.sh(优先 CPU 包,再 GPU 包,最后源码) ``` Windows 不能直接生成 Ubuntu ELF 二进制。`package-ubuntu.sh` 必须在 Ubuntu/Linux 构建机执行;Windows 使用 `package-windows.ps1` 生成 exe。两个平台的发布包不能混用,建议分别构建、分别测试。 @@ -898,19 +966,27 @@ port: 8000 upload_dir: data/uploads model_dir: models det_model_name: PP-OCRv5_server_det -rec_model_name: PP-OCRv5_server_rec +rec_model_name: PP-OCRv4_mobile_rec ocr_workers: 1 device: cpu lang: ch max_upload_mb: 10 max_image_pixels: 20000000 -text_det_limit_side_len: 960 +text_det_limit_side_len: 1024 text_det_limit_type: max +text_det_input_shape: null text_det_thresh: 0.3 text_det_box_thresh: 0.6 text_det_unclip_ratio: 1.5 text_rec_score_thresh: 0.0 -text_recognition_batch_size: 1 +text_rec_input_shape: null +text_recognition_batch_size: 32 +cpu_threads: 1 +enable_mkldnn: true +mkldnn_cache_capacity: 10 +use_tensorrt: false +precision: fp32 +enable_cinn: false log_level: INFO ``` @@ -921,25 +997,359 @@ log_level: INFO | `upload_dir` | `data/uploads` | 图片存储目录 | | `model_dir` | `models` | PaddleOCR 模型下载和缓存目录 | | `det_model_name` | `PP-OCRv5_server_det` | 文本检测模型名称 | -| `rec_model_name` | `PP-OCRv5_server_rec` | 文本识别模型名称 | -| `ocr_workers` | `1` | OCR 工作线程数;每个线程独立加载一份模型 | +| `rec_model_name` | `PP-OCRv4_mobile_rec` | 文本识别模型名称 | +| `ocr_workers` | `1` | OCR 工作线程数;每个 worker 独立加载一份模型(约 +105MB/个) | | `max_upload_mb` | `10` | 单文件大小上限 | | `max_image_pixels` | `20000000` | 图片像素上限 | -| `device` | `cpu` | `cpu` 或 GPU 设备配置 | +| `device` | `cpu` | `cpu` / `gpu` / `gpu:0` / `auto` / `npu` 等,见「CPU / GPU 切换」 | | `lang` | `ch` | PaddleOCR 语言 | -| `text_det_limit_side_len` | `960` | 检测图像最长边;调小可加速,可能漏检小字 | +| `text_det_limit_side_len` | `1024` | 检测图像最长边;调小可加速,代价是漏检小字 | | `text_det_limit_type` | `max` | 检测缩放限制类型 | +| `text_det_input_shape` | `null` | 固定检测输入尺寸(如 `[3, 960, 960]`);`null` 表示动态缩放 | | `text_det_thresh` | `0.3` | 检测二值化阈值 | | `text_det_box_thresh` | `0.6` | 检测框置信度阈值 | | `text_det_unclip_ratio` | `1.5` | 检测框扩张比例 | | `text_rec_score_thresh` | `0.0` | 识别结果阈值 | -| `text_recognition_batch_size` | `1` | 识别批量大小;内存足够时可提高 | -| `cpu_threads` | `max` | CPU 推理线程数;正整数或 `max`(`max` = 吃满所有逻辑核心) | +| `text_rec_input_shape` | `null` | 固定识别输入尺寸(如 `[3, 48, 320]`);`null` 表示按宽高比填充 | +| `text_recognition_batch_size` | `32` | 识别批量大小;**性价比最高的旋钮**,见下方说明 | +| `cpu_threads` | `1` | CPU 推理线程数;正整数或 `max`。开 oneDNN 后该值几乎无影响 | | `enable_mkldnn` | `true` | 是否启用 oneDNN 加速;**需要 `paddlepaddle` 3.2.x**,见下方说明 | +| `mkldnn_cache_capacity` | `10` | oneDNN 算子缓存容量,仅 `enable_mkldnn: true` 时生效 | +| `use_tensorrt` | `false` | 是否启用 TensorRT;**只在 `device` 为 GPU 时生效** | +| `precision` | `fp32` | `fp32` / `fp16`;`fp16` 只在 GPU 上生效 | +| `enable_cinn` | `false` | 是否启用 CINN 编译器(面向国产加速卡);普通 CPU/GPU 保持 `false` | | `log_level` | `INFO` | 日志级别:`DEBUG`、`INFO`、`WARNING`、`ERROR` | 接口文档:启动后访问 。 +### 调优参数速查(按收益排序) + +| 参数 | 怎么调 | 实测收益 | +| --- | --- | --- | +| `text_recognition_batch_size` | `8` → `32` | 1.png 同分辨率 **23.87s → 19.03s**,框数不变,字符数 2240 → 2241 | +| `text_det_limit_side_len` | `1024` → `768` | 19s → 16s,字符数从 2240 降到 2191(约 −2%) | +| `ocr_workers` | 按并发量加大 | 推理接近单线程,并发上传时吞吐接近线性;每个 worker 约 +105MB 内存 | +| `cpu_threads` | 保持 `1` | 开了 oneDNN 之后 1/4/8/14/20 差异都在噪声内 | +| `device` / `use_tensorrt` | 有 NVIDIA 卡时改 GPU | 需换 `paddlepaddle-gpu`,见「CPU / GPU 切换」 | + +### CPU / GPU 切换 + +```yaml +device: cpu # 默认。固定用 CPU,永远不碰 GPU +device: gpu # 固定用第 0 块卡 +device: gpu:1 # 固定用第 1 块卡 +device: auto # 启动时探测:有可用 CUDA 设备就用 GPU,否则用 CPU +``` + +**推荐用 `auto`**:同一份 `config.yaml` 在「有卡的开发机」和「没卡的客户机」之间 +搬来搬去不用改这一行,日志里会明确打出实际选了什么: + +```text +INFO [ocr_server.ocr] device=auto:检测到可用的 CUDA 设备,使用 GPU +INFO [ocr_server.ocr] device=auto:没有可用的 GPU(当前 PaddlePaddle 3.2.2 是纯 CPU 版本),使用 CPU +``` + +注意日志级别的区别:`auto` 探测不到卡是**预期行为**,报 INFO; +而显式写了 `device: gpu` 却用不了是**配置问题**,报 WARNING。 + +本机上三种取值的实际效果(有 RTX 5060,但装的是 CPU 版 paddle): + +| 配置 | 实际使用 | 日志级别 | +| --- | --- | --- | +| `device: auto` | cpu | INFO | +| `device: cpu` | cpu | — | +| `device: gpu` | cpu(回落) | WARNING | + +⚠️ **只改 yaml 是启不了 GPU 的。** PyPI 上的 `paddlepaddle` 是纯 CPU 版本, +需要换成 `paddlepaddle-gpu`: + +```bash +# 先确认本机显卡型号和驱动版本 +nvidia-smi +``` + +**先选对 CUDA 通道,选错装了也跑不起来**(见下表)。当前项目环境实测是 +`paddlepaddle 3.2.2`(CPU 版),`is_compiled_with_cuda()` 为 `False`。 + +| 显卡 | 计算能力 | 该选哪个通道 | +| --- | --- | --- | +| RTX 50 系(5060 / 5070 / 5080 / 5090) | sm_120 Blackwell | **必须 `cu129`** | +| RTX 40 系 / 30 系 | sm_89 / sm_86 | `cu126` 或 `cu129` | +| 更老的卡 | ≤ sm_80 | `cu118` 也可以 | + +⚠️ **RTX 50 系不能用 `cu118` / `cu126`**:这两个 wheel 的内核里没有 sm_120, +装上去会在第一次推理时抛 +`Mismatched GPU Architecture: The installed PaddlePaddle package was compiled for 60 61 70 75 80 86, but your current GPU is 120`。 +必须用 `cu129`,且 PaddlePaddle 版本要 ≥ 3.2.1。 + +### 两套环境共存,随时切换(推荐) + +CPU 和 GPU **各用一套虚拟环境**,都建好之后切换是零成本的,不用卸载重装: + +```bash +.venv/Scripts/python.exe scripts/switch_env.py --list # 查看两套环境的现状 +.venv/Scripts/python.exe scripts/switch_env.py --cpu # 建立/更新 .venv(CPU) +.venv/Scripts/python.exe scripts/switch_env.py --gpu # 建立/更新 .venv-gpu(GPU) +``` + +```text +CPU 环境 .venv paddlepaddle==3.2.2 | CUDA 可用:False,GPU 数:0 +GPU 环境 .venv-gpu paddlepaddle-gpu==3.2.2 | CUDA 可用:True,GPU 数:1 +``` + +| 用途 | 命令 | +| --- | --- | +| 跑源码(CPU) | `.venv\Scripts\ocr-server.exe` | +| 跑源码(GPU) | `.venv-gpu\Scripts\ocr-server.exe` | +| 打 CPU 包 | `.\scripts\package-windows.ps1` | +| 打 GPU 包 | `$env:UV_PROJECT_ENVIRONMENT=".venv-gpu"; .\scripts\package-windows.ps1` | + +之所以不做成「一个环境来回切」:`paddlepaddle` 与 `paddlepaddle-gpu` 互斥(都提供 +`paddle` 顶层包和同一批文件),而且 GPU 版还要拖进约 **3.1GB** 的 CUDA 运行库, +反复装卸很浪费。代价是两套环境同时存在,磁盘多占约 4GB。 + +### 只要一套环境时 + +装的方式是用项目自带的脚本,它会读 `nvidia-smi` 自动判断装哪个版本和哪个 CUDA 通道: + +```bash +uv run --no-sync python scripts/install_paddle.py # 有 N 卡就装 GPU 版,没有就装 CPU 版 +uv run --no-sync python scripts/install_paddle.py --gpu # 强制 GPU 版,通道按显卡自动推荐 +uv run --no-sync python scripts/install_paddle.py --cpu # 强制 CPU 版(顺带清掉 3GB 的 CUDA 库) +uv run --no-sync python scripts/install_paddle.py --gpu --dry-run # 只看方案,不动环境 +``` + +想手工装也行,等价命令是: + +```bash +uv pip uninstall paddlepaddle paddlepaddle-gpu +uv pip install "paddlepaddle-gpu==3.2.2" \ + --extra-index-url https://www.paddlepaddle.org.cn/packages/stable/cu129/ +``` + +> **为什么 `paddlepaddle` 不在 `pyproject.toml` 的依赖里?** +> 因为它没法写死:CPU 版和 GPU 版互斥(同一批 `paddle` 文件,装了会互相覆盖), +> GPU 版还要按显卡选 CUDA 通道。早先把它钉成 CPU 版时,`uv sync`、`uv run`、 +> PyCharm 的自动同步都会把装好的 `paddlepaddle-gpu` 静默挤掉、服务悄悄退回 CPU—— +> 实测踩过三次。 +> +> 现在的取舍是:**任何一次环境同步都会把 paddle 整个移除**(连 `protobuf`、`opt-einsum` +> 这些依赖一起),服务启动时报错并告诉你运行 `install_paddle.py`。 +> 会吵,但不会静默降级。**每次跑完 `uv sync` 记得重新执行一次 `install_paddle.py`。** + +**注意:不要用 PyPI 上的 `paddlepaddle-gpu`**——它停在 2.6.2 且早已废弃, +装上去和本项目的 PaddleOCR 3.x / paddlepaddle 3.2.x 对不上。 +只能用 PaddlePaddle 官方源,实测该源上 `cu118` / `cu126` / `cu129` 三个通道 +都有 `paddlepaddle_gpu-3.2.2` 的 Windows 与 Linux 轮子。 + +⚠️ **RTX 50 系要留个心眼**:社区反馈 Blackwell 的预编译 wheel 支持还不够完整, +官方主要在 PaddleOCR-VL 上验证过(且只验证了 RTX 5070),经典 PP-OCR 推理管线 +(也就是本项目用的这套)在部分平台仍有缺口,Windows 上尤其明显。 +换完 wheel 后**务必先用 `benchmark_ocr.py` 跑通一次真实图片**再决定是否上 GPU; +跑不通就退回 CPU 包,不要卡在这里。 + +#### 装完之后能自由切换吗?能 + +GPU 版 wheel 里**同时带着完整的 CPU 内核**,PaddleX 在 `device` 为 cpu 时会显式 +`config.disable_gpu()`,所以三种取值随时可切、不需要重装: + +| 配置 | 行为 | +| --- | --- | +| `device: cpu` | 强制 CPU,走 oneDNN | +| `device: gpu` / `device: auto` | 走 GPU | + +实测(RTX 5060 Laptop,paddlepaddle-gpu 3.2.2 cu129): + +| 图片 | CPU | GPU | 加速 | 框数 | 字符数 | +| --- | --- | --- | --- | --- | --- | +| 1.png(1920×1080,428 框) | 17.45s | **1.44s** | **12×** | 428 → 428 | 2241 → 2241 | +| general_ocr_002.png(34 框) | 6.89s | **0.23s** | **30×** | 34 → 34 | 250 → 250 | + +框数与字符数和 CPU **完全一致**——在这两张图上没有复现社区报告的 sm_120 静默丢框问题。 +但**上线前必须用你自己的真实图片再核一遍**(尤其是扫描件 / PDF 渲染图, +社区那个 bug 正是在这类图上出现的,手机照片反而正常)。 + +#### ⚠️ `uv sync` / `uv run` 会把 GPU 环境悄悄冲掉 + +`pyproject.toml` 里声明的是 CPU 版 `paddlepaddle`。**裸跑 `uv sync` 或 `uv run`** +(`uv run` 启动前也会同步一次)的结果是**卸载 `paddlepaddle-gpu` 和全部 +`nvidia-*` 运行库、装回 CPU 版**,而且不报错: + +```text +Would uninstall 9 packages + - nvidia-cublas-cu12==12.9.0.13 ...(7 个 nvidia-* 运行库) + - paddlepaddle-gpu==3.2.2 + + paddlepaddle==3.2.2 +``` + +项目里的脚本都已经处理好了: + +| 场景 | 处理方式 | +| --- | --- | +| 打包脚本 | `uv sync --dev --inexact --no-install-package paddlepaddle`(实测 dry-run 为 no changes),其余 `uv run` 全部加了 `--no-sync` | +| 启动脚本 | 优先直接执行 `.venv` 里的入口程序,不经过 uv;不得已走 uv 时用 `uv run --no-sync` | +| `benchmark_ocr.py`、`download_models.py` | 命令里都要求带 `--no-sync` | + +**但你自己手动敲 `uv sync` 或 `uv run` 时它照样会冲掉。** 装完 GPU 后如果发现 +「怎么又变回 CPU 了」,先想想是不是跑过这两个命令。判断方法看启动日志: + +```text +INFO [ocr_server.ocr] device=auto:检测到可用的 CUDA 设备,使用 GPU ← 正常 +INFO [ocr_server.ocr] device=auto:没有可用的 GPU(当前 PaddlePaddle 3.2.2 是纯 CPU 版本)… ← 被冲掉了 +``` + +(单独用 `--no-install-package paddlepaddle` 不够:它会把 `paddlepaddle-gpu` 当多余包删掉; +单独用 `--inexact` 也不够:它会装上 CPU 版造成两个发行包并存、文件互相覆盖。必须两个合用。) + +#### 交付包:CPU / GPU 是两个产物 + +**光改配置在交付的 exe 包里是没用的**:PyInstaller 会把打包那一刻的 paddle 打进产物, +CPU 包无论客户怎么改 yaml 都用不了 GPU。所以交付时打两个包: + +```powershell +# CPU 包 -> dist\ocr-server\ocr-server.exe +.\scripts\package-windows.ps1 + +# GPU 包 -> dist\ocr-server-gpu\ocr-server-gpu.exe +# 用 switch_env.py 建好的 GPU 环境来打,它会自动识别成 GPU 变体 +$env:UV_PROJECT_ENVIRONMENT=".venv-gpu" +.\scripts\package-windows.ps1 +``` + +```bash +# Linux 同理 +./scripts/package-ubuntu.sh # CPU 包 -> dist/ocr-server/ +./scripts/package-ubuntu.sh --gpu # GPU 包 -> dist/ocr-server-gpu/ +``` + +打包脚本会自动做这几件事,不需要手工干预: + +| 行为 | 说明 | +| --- | --- | +| 自动识别变体 | 按构建环境实际安装的 paddle 判断,不靠人工声明 | +| 产物名区分变体 | CPU → `dist/ocr-server/`,GPU → `dist/ocr-server-gpu/`,两个包不会互相覆盖 | +| 预置 `device` | GPU 包的 `config.yaml` 里 `device` 写成 `auto`:客户机有卡就用卡、没卡自动回落 CPU,两种机器都能直接跑 | +| `--copy-metadata` 用对发行包名 | CPU 版叫 `paddlepaddle`、GPU 版叫 `paddlepaddle-gpu`,写死任何一个在另一种环境下都会打包失败 | +| 环境不匹配直接报错 | 加 `-Gpu` / `--gpu` 断言时,如果构建环境装的是 CPU 版,脚本会带着安装命令报错退出 | + +`-Gpu` / `--gpu` 只是**断言**,不是开关:不加该参数时脚本也按实际安装的版本判断。 + +⚠️ **不要指望 GPU 包能当 CPU 包用。** 运行时的兜底(`device: auto` / `device: gpu`) +只能兜住「能 import paddle、但拿不到 CUDA 设备」这一种情况。如果客户机上 +根本没有 NVIDIA 的 CUDA 运行库,`paddlepaddle-gpu` 可能在 **import 阶段**就报错 +(典型是缺 `libcublasLt.so.12` 这类),那时候我们的兜底代码还没机会执行。 +PaddlePaddle 官方安装指南的口径也是「没有 NVIDIA GPU 就装 CPU 版」。 +所以:**确定没卡的客户机,发 CPU 包**;不确定的,两个包都带上。 + +变体没有「强制」开关:产物里打进的就是构建环境当前的 paddle,改个名字不会改变这一点, +只会让包名和内容对不上。要打 CPU 包就换回 CPU 版 paddle 再打。 + +#### GPU 包必须额外收 nvidia 运行库(打包脚本已处理) + +`paddlepaddle-gpu` 的 CUDA 运行库(cudnn / cublas / cufft 等)不在 `paddle` 包里, +而是装在**独立的 `nvidia-*` 发行包**里。PyInstaller 的 `--collect-all paddle` 收不到它们, +所以 GPU 包额外加了 `--collect-binaries nvidia`。 + +漏收的后果实测是**最难排查的那种**:引擎能正常加载、设备也正确识别成 GPU, +但第一次推理才报错: + +```text +PreconditionNotMetError: The third-party dynamic library (cudnn64_9.dll) +that Paddle depends on is not configured correctly. (error code is 126) +``` + +收进来的落点是 `_internal/nvidia/<包>/bin/`,正好是 paddle 在 `__init__.py` 里用 +`os.add_dll_directory(os.path.dirname(paddle.__file__) + "/../nvidia/<包>/bin")` +寻找的路径。 + +**体积**(实测):CPU 包约 1.0GB;GPU 包约 **5.0GB**,其中 3.1GB 是 CUDA 运行库 +(cudnn 1.06GB、cublas 736MB、cusparse 456MB、cusolver 442MB、cufft 275MB…), +源目录本身就那么大,不是重复打包。要瘦身只能砍裁用不到的库,有运行时踩坑风险。 + +开启 GPU 后还可以叠加: + +```yaml +device: gpu +use_tensorrt: true # TensorRT 加速,首次推理会花时间构建引擎 +precision: fp16 # 半精度,更快、显存更省,但需核对字符数 +``` + +**兜底行为**:如果配了 `device: gpu`(或 `auto`)但 GPU 实际不可用, +启动时会打印中文日志并**自动回落 CPU**,不会让服务起不来。 +检查覆盖两种情况,不只是「装没装 GPU 版」: + +- 装的是纯 CPU 版 paddle → 直接回落; +- 装的是 GPU 版但**机器上没有可用的 N 卡或驱动** → 也会回落 + (这一点单查 `is_compiled_with_cuda()` 是查不出来的,那是编译期属性, + 装了 GPU 版就返回 True,所以还要实际探一次可见设备数)。 + +上线前请确认启动日志里「加载 OCR 引擎」那一行打印的 `device=` 是你期望的值: + +```text +WARNING [ocr_server.ocr] 配置 device=gpu,但 GPU 无法启用:当前 PaddlePaddle 3.2.2 是纯 CPU 版本。… +WARNING [ocr_server.ocr] use_tensorrt 已开启,但生效设备是 cpu;TensorRT 只在 GPU 上生效,本次忽略该项。 +INFO [ocr_server.ocr] 加载 OCR 引擎: det=… rec=… device=cpu cpu_threads=1 … +``` + +同理,`use_tensorrt: true` 但设备是 CPU 时会打印警告并忽略该项 +(TensorRT 只在 GPU 分支生效)。 + +#### 为什么不能照搬 ONNX Runtime 的调优文章 + +网上关于「PP-OCR 部署优化」的资料大多讲的是 **ONNX Runtime / TensorRT** 路线 +(`intra_op_num_threads`、`providers`、`trt_max_workspace_size`、INT8 量化等)。 +本项目走的是 **Paddle Inference**(`paddleocr` → `paddlex` → `paddlepaddle`), +模型格式和执行引擎都不一样,那些参数名在这里并不存在。对应关系: + +| 常见文章里的说法 | 本项目实际参数 | +| --- | --- | +| `intra_op_num_threads` | `cpu_threads` | +| `inter_op_num_threads` | 无对应(Paddle 只有单一线程数) | +| `graph_optimization_level` | 无对应(Paddle 默认开启,`set_optimization_level(3)`) | +| `batch_size` | `text_recognition_batch_size` | +| `dynamic_shapes` | `text_det_limit_side_len`、`text_det_input_shape`、`text_rec_input_shape` | +| TensorRT + `trt_fp16_enable` | `use_tensorrt: true` + `precision: fp16` | +| `gpu_mem_limit` | 无对应(Paddle 用 `FLAGS_*` 环境变量控制) | +| INT8 量化、ONNX 导出 | 不适用(Paddle 需另建校准集走 `run_mode: trt_int8`) | + +简单说:**照抄那些文章的代码在本项目里会直接报「不认识的参数」**,请以上表为准。 + +### 模型预置 + +`scripts/download_models.py` 会把交付包需要的八套模型一次性下载到 +`model_dir/official_models/`,共约 398MB: + +```bash +uv run python scripts/download_models.py +# 打包时 scripts/package-windows.ps1 / package-ubuntu.sh 会自动复制 models/ 进发布目录 +``` + +**检测** + +| 模型 | 体积 | 用途 | +| --- | --- | --- | +| `PP-OCRv5_server_det` | 85MB | 召回最好,密集小字靠它,默认用它 | +| `PP-OCRv5_mobile_det` | 5MB | 资源紧张时用(比 v4 移动端检测强得多) | +| `PP-OCRv4_server_det` | 109MB | v4 代际服务端,对比备选 | +| `PP-OCRv4_mobile_det` | 5MB | ⚠️ 密集文本大面积漏检(1.png 只检出 46 框),别用在表格/文档图上 | + +**识别** + +| 模型 | 体积 | 用途 | +| --- | --- | --- | +| `PP-OCRv5_server_rec` | 82MB | 精度最高,也最慢。GPU 机器上可用它冲精度 | +| `PP-OCRv5_mobile_rec` | 17MB | v5 代际移动端,速度与精度折中 | +| `PP-OCRv4_server_rec` | 87MB | v4 代际服务端,对比备选 | +| `PP-OCRv4_mobile_rec` | 11MB | 默认。密集文本字符数与 v5 服务端基本一致,快约 8 倍 | + +八套都在本地之后,交付后**断网也能直接改 `det_model_name` / `rec_model_name` 切换**。 +脚本会跳过已完整的目录,重复执行不会重新下载;上次下载中断留下的空壳目录(只含 +`.cache`)会被自动清理。 + +体积提示:这八套会随发布包一起发给客户(约 398MB)。如果确定用不上某个代际, +可以从 `src/ocr_server/ocr.py` 的 `STAGED_DET_MODELS` / `STAGED_REC_MODELS` +里删掉再重新下载,打包时 `models/` 目录里没有的自然不会被带上。 + ## 测试 ```bash diff --git a/pyproject.toml b/pyproject.toml index 838e4b3..2d2b6f5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,10 +11,15 @@ dependencies = [ "pyyaml>=6.0,<7", "uvicorn[standard]>=0.34,<1", "paddleocr>=3.2,<4", - # 固定在 3.2.x:3.3.x 的 PIR + oneDNN 组合有缺陷,启用 oneDNN 会直接推理失败 - # (ConvertPirAttribute2RuntimeAttribute not support)。3.2.x 可正常启用 oneDNN, - # 实测识别提速约 4.8 倍且输出逐字节一致。详见 README「已知性能限制」。 - "paddlepaddle>=3.2,<3.3", + # 使用 switch_env.py 切换CPU/GPU 环境 + # ⚠️ 这里刻意不声明 paddlepaddle / paddlepaddle-gpu,请用 scripts/install_paddle.py 安装。 + # 原因: + # 1. 两者互斥——都提供 `paddle` 顶层包和同一批文件,同时存在会互相覆盖; + # 2. GPU 版还要按显卡选 CUDA 通道(cu118 / cu126 / cu129),没法写死; + # 3. 一旦在这里钉死 CPU 版,`uv sync`、`uv run`、PyCharm 的自动同步 + # 都会把装好的 paddlepaddle-gpu 静默挤掉,服务悄悄退回 CPU(实测踩过多次)。 + # 版本要求:paddlepaddle 必须 3.2.x——3.3.x 的 PIR + oneDNN 组合有缺陷, + # 启用 oneDNN 会直接推理失败(ConvertPirAttribute2RuntimeAttribute not support)。 ] [project.scripts] diff --git a/scripts/benchmark_ocr.py b/scripts/benchmark_ocr.py index c819cad..6a29b9e 100644 --- a/scripts/benchmark_ocr.py +++ b/scripts/benchmark_ocr.py @@ -1,5 +1,18 @@ -"""Benchmark the configured OCR pipeline without modifying model files.""" +"""Benchmark the configured OCR pipeline without modifying model files. +用法: + uv run --no-sync python scripts/benchmark_ocr.py # 默认样例图 + uv run --no-sync python scripts/benchmark_ocr.py 你的图.png # 指定图片 + uv run --no-sync python scripts/benchmark_ocr.py 你的图.png 3 # 跑 3 次,报最快那次 + +⚠️ `--no-sync` 不能省:uv run 默认会按 pyproject.toml 同步环境,那里声明的是 CPU 版 +paddlepaddle,会把装好的 paddlepaddle-gpu 静默冲掉、退回 CPU——测速结果会失真。 + +改完 config.yaml 重新执行即可对比。调模型或参数时**重点看 chars**: +速度变快但字符数掉得多,就是丢字了。 +""" + +import sys from pathlib import Path from time import perf_counter @@ -7,40 +20,45 @@ from ocr_server.config import Settings from ocr_server.ocr import OCRService -if __name__ == "__main__": - image_path = Path("http/fixtures/general_ocr_002.png") - settings = Settings() - service = OCRService( - lang=settings.lang, - device=settings.device, - model_dir=settings.model_dir, - det_model_name=settings.det_model_name, - rec_model_name=settings.rec_model_name, - text_det_limit_side_len=settings.text_det_limit_side_len, - text_det_limit_type=settings.text_det_limit_type, - text_det_thresh=settings.text_det_thresh, - text_det_box_thresh=settings.text_det_box_thresh, - text_det_unclip_ratio=settings.text_det_unclip_ratio, - text_rec_score_thresh=settings.text_rec_score_thresh, - text_recognition_batch_size=settings.text_recognition_batch_size, - cpu_threads=settings.cpu_threads_resolved, - enable_mkldnn=settings.enable_mkldnn, - ) - service.prepare() - - stages: list[str] = [] +def run_once(service: OCRService, image_path: Path) -> tuple[float, int, int, float, float]: + marks: list[tuple[int, float]] = [] + started = perf_counter() def on_progress(percent: int, message: str) -> None: - stages.append(f"{percent}% {message}") + marks.append((percent, perf_counter() - started)) - started = perf_counter() lines = service.recognize(image_path, on_progress=on_progress) - elapsed_ms = (perf_counter() - started) * 1000 + elapsed = perf_counter() - started + texts = [item["text"] for item in lines if item.get("text")] + detection = next((t for p, t in marks if p == 50), 0.0) + recognition = next((t for p, t in marks if p == 80), 0.0) + return elapsed, len(texts), sum(len(text) for text in texts), detection, recognition + + +if __name__ == "__main__": + image_path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path( + "http/fixtures/general_ocr_002.png" + ) + repeats = int(sys.argv[2]) if len(sys.argv) > 2 else 1 + + settings = Settings() + service = OCRService.from_settings(settings) + service.prepare() + print(f"image={image_path}") - print(f"cpu_threads={settings.cpu_threads_resolved} (config={settings.cpu_threads})") - print(f"enable_mkldnn={settings.enable_mkldnn}") print(f"det={settings.det_model_name} rec={settings.rec_model_name}") - print(f"elapsed_ms={elapsed_ms:.2f}") - print(f"segments={len(lines)}") - for stage in stages: - print(f"stage={stage}") + print(f"device={service._effective_device} (config={settings.device})") + print(f"enable_mkldnn={settings.enable_mkldnn} cpu_threads={settings.cpu_threads_resolved}") + print(f"text_det_limit_side_len={settings.text_det_limit_side_len} " + f"text_recognition_batch_size={settings.text_recognition_batch_size}") + + results = [run_once(service, image_path) for _ in range(repeats)] + # 至少跑一次预热,避免把首次推理的算子编译时间算进去。 + if repeats == 1: + print("(只跑一次,数值可能含首次推理的预热开销;建议传次数参数多跑几次)") + elapsed, segments, chars, detection, recognition = min(results) + print(f"elapsed_ms={elapsed * 1000:.2f}") + print(f" detect_ms={detection * 1000:.2f}") + print(f" recognize_ms={(recognition - detection) * 1000:.2f}") + print(f"segments={segments}") + print(f"chars={chars}") diff --git a/scripts/download-models.bat b/scripts/download-models.bat index c34cccb..5269b5b 100644 --- a/scripts/download-models.bat +++ b/scripts/download-models.bat @@ -16,7 +16,9 @@ if not exist "config.yaml" ( exit /b 1 ) -uv run python scripts\download_models.py +rem --no-sync:uv run 默认会按 pyproject.toml 同步环境,那里声明的是 CPU 版 +rem paddlepaddle,会把装好的 paddlepaddle-gpu 冲掉。 +uv run --no-sync python scripts\download_models.py if errorlevel 1 ( echo [ERROR] 模型下载失败。 endlocal diff --git a/scripts/download-models.sh b/scripts/download-models.sh index abc626f..362d5f8 100644 --- a/scripts/download-models.sh +++ b/scripts/download-models.sh @@ -10,7 +10,7 @@ fi if command -v uv >/dev/null 2>&1; then printf '%s\n' '[OCR] 检查并下载缺失模型...' - uv run python scripts/download_models.py + uv run --no-sync python scripts/download_models.py elif [[ -x .venv/bin/python ]]; then printf '%s\n' '[OCR] 检查并下载缺失模型(使用 .venv)...' .venv/bin/python scripts/download_models.py diff --git a/scripts/download_models.py b/scripts/download_models.py index 7ea804b..86f7b03 100644 --- a/scripts/download_models.py +++ b/scripts/download_models.py @@ -1,25 +1,42 @@ -"""Download PP-OCRv5 models into the project's configured model directory.""" +"""Download the staged PP-OCR models into the project's configured model directory. + +交付包会预置多套检测/识别模型,方便在客户机器上只改 config.yaml 就能离线切换。 +已经完整的模型目录会被跳过(见 OCRService._is_complete_model),不会重复下载。 +""" + +import shutil from ocr_server.config import Settings -from ocr_server.ocr import OCRService +from ocr_server.ocr import STAGED_DET_MODELS, STAGED_REC_MODELS, OCRService + + +def drop_download_stubs(settings: Settings) -> None: + """清理只含 .cache 的残壳目录(上次下载中断留下的)。 + + 只删这种明确的失败残留,不碰任何带真实权重文件的目录。 + """ + official_dir = settings.model_dir.resolve() / "official_models" + if not official_dir.is_dir(): + return + for path in sorted(official_dir.iterdir()): + if not path.is_dir(): + continue + entries = {item.name for item in path.iterdir()} + if entries and entries <= {".cache"}: + print(f"清理下载残留目录: {path.name}") + shutil.rmtree(path) if __name__ == "__main__": settings = Settings() - OCRService( - lang=settings.lang, - device=settings.device, - model_dir=settings.model_dir, - det_model_name=settings.det_model_name, - rec_model_name=settings.rec_model_name, - text_det_limit_side_len=settings.text_det_limit_side_len, - text_det_limit_type=settings.text_det_limit_type, - text_det_thresh=settings.text_det_thresh, - text_det_box_thresh=settings.text_det_box_thresh, - text_det_unclip_ratio=settings.text_det_unclip_ratio, - text_rec_score_thresh=settings.text_rec_score_thresh, - text_recognition_batch_size=settings.text_recognition_batch_size, - cpu_threads=settings.cpu_threads_resolved, - enable_mkldnn=settings.enable_mkldnn, - ).prepare() + drop_download_stubs(settings) + + combos = [(det, settings.rec_model_name) for det in STAGED_DET_MODELS] + combos += [(settings.det_model_name, rec) for rec in STAGED_REC_MODELS] + for det_model, rec_model in combos: + print(f"检查模型 det={det_model} rec={rec_model}") + OCRService.from_settings( + settings, det_model_name=det_model, rec_model_name=rec_model + ).prepare() + print(f"Models are ready in: {settings.model_dir.resolve()}") diff --git a/scripts/install_paddle.py b/scripts/install_paddle.py new file mode 100644 index 0000000..10d5100 --- /dev/null +++ b/scripts/install_paddle.py @@ -0,0 +1,183 @@ +"""安装 paddlepaddle(CPU 版或 GPU 版)。 + +paddlepaddle 不在 pyproject.toml 的依赖里,原因见那里的注释:CPU/GPU 两个发行包 +互斥、GPU 版还要按显卡选 CUDA 通道,写死任何一个都会被 `uv sync` / PyCharm 自动同步 +冲掉。所以单独用这个脚本安装。 + +用法: + python scripts/install_paddle.py # 自动:检测到 NVIDIA 显卡就装 GPU 版,否则 CPU 版 + python scripts/install_paddle.py --cpu # 强制 CPU 版 + python scripts/install_paddle.py --gpu # 强制 GPU 版,CUDA 通道按显卡自动推荐 + python scripts/install_paddle.py --gpu --cuda cu126 # 指定 CUDA 通道 + python scripts/install_paddle.py --gpu --version 3.2.2 # 指定版本 +""" + +import argparse +import re +import subprocess +import sys + +DEFAULT_VERSION = "3.2.2" +SUPPORTED_CUDA = ("cu118", "cu126", "cu129") +INDEX_TEMPLATE = "https://www.paddlepaddle.org.cn/packages/stable/{cuda}/" +CPU_PACKAGE = "paddlepaddle" +GPU_PACKAGE = "paddlepaddle-gpu" +BOTH_PACKAGES = (CPU_PACKAGE, GPU_PACKAGE) + +# paddlepaddle-gpu 会顺带装上的 CUDA 运行库(约 3GB)。装 CPU 版时一并清理, +# 否则环境里会白留着几个 G 的 .venv 体积。 +NVIDIA_PACKAGES = ( + "nvidia-cublas-cu12", + "nvidia-cuda-runtime-cu12", + "nvidia-cudnn-cu12", + "nvidia-cufft-cu12", + "nvidia-curand-cu12", + "nvidia-cusolver-cu12", + "nvidia-cusparse-cu12", + "nvidia-nvjitlink-cu12", +) + + +def run(command: list[str], check: bool = True) -> subprocess.CompletedProcess[str]: + print(f" $ {' '.join(command)}", flush=True) + result = subprocess.run(command, capture_output=True, text=True, encoding="utf-8") + if result.stdout.strip(): + print(" " + result.stdout.strip().replace("\n", "\n ")) + if result.stderr.strip(): + print(" " + result.stderr.strip().replace("\n", "\n ")) + if check and result.returncode != 0: + raise SystemExit(result.returncode) + return result + + +def pip_command(*args: str, python: str | None = None) -> list[str]: + """优先用 uv pip,没有 uv 就退回 pip。python 指定目标解释器(多环境时用)。""" + uv = subprocess.run( + ["uv", "--version"], capture_output=True, text=True, check=False + ) + if uv.returncode == 0: + base = ["uv", "pip", *args] + if python: + base += ["--python", python] + return base + target = python or sys.executable + return [target, "-m", "pip", *args] + + +def detect_gpu_name() -> str | None: + """读 nvidia-smi 拿显卡型号;没有 NVIDIA 卡或没装驱动时返回 None。""" + try: + result = subprocess.run( + ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"], + capture_output=True, + text=True, + timeout=20, + check=False, + ) + except (OSError, subprocess.SubprocessError): + return None + if result.returncode != 0: + return None + first = result.stdout.strip().splitlines() + return first[0].strip() if first and first[0].strip() else None + + +def recommend_cuda(gpu_name: str | None) -> str: + """按显卡型号推荐 CUDA 通道。 + + RTX 50 系是 Blackwell(sm_120),只有 cu129 的内核包含它;装 cu118/cu126 会 + 在推理时报 Mismatched GPU Architecture。 + """ + if not gpu_name: + return "cu126" + upper = gpu_name.upper() + if re.search(r"RTX\s*50\d0", upper): + return "cu129" + if re.search(r"RTX\s*[34]0\d0", upper): + return "cu126" + return "cu118" + + +def explain_uninstall_failure(output: str) -> None: + if "拒绝访问" in output or "Access is denied" in output or "os error 5" in output: + print( + "\n[错误] 卸载旧版失败:文件被占用。\n" + " 最常见的原因是 OCR 服务正在运行,或者 PyCharm 的 Python 控制台\n" + " 导入过 paddle。请先停掉它们再重试。", + file=sys.stderr, + ) + + +def main() -> int: + parser = argparse.ArgumentParser(description="安装 paddlepaddle(CPU 或 GPU 版)") + group = parser.add_mutually_exclusive_group() + group.add_argument("--cpu", action="store_true", help="强制安装 CPU 版") + group.add_argument("--gpu", action="store_true", help="强制安装 GPU 版") + parser.add_argument( + "--cuda", + choices=SUPPORTED_CUDA, + help=f"GPU 版的 CUDA 通道({' / '.join(SUPPORTED_CUDA)}),默认按显卡型号推荐", + ) + parser.add_argument("--version", default=DEFAULT_VERSION, help="paddle 版本,默认 3.2.2") + parser.add_argument( + "--dry-run", action="store_true", help="只打印将要执行的安装方案,不做任何改动" + ) + parser.add_argument( + "--python", + help="目标解释器路径(多套虚拟环境时用),默认当前环境", + ) + args = parser.parse_args() + + gpu_name = detect_gpu_name() + use_gpu = args.gpu or (not args.cpu and gpu_name is not None) + cuda = args.cuda or recommend_cuda(gpu_name) + + print("检测到显卡:" + (gpu_name or "无 NVIDIA 显卡")) + print(f"安装目标:{'GPU 版' if use_gpu else 'CPU 版'}" + + (f"(CUDA 通道 {cuda})" if use_gpu else "")) + if use_gpu and not gpu_name: + print(" ⚠️ 没检测到 NVIDIA 显卡,但仍按要求装 GPU 版;") + print(" 这样装在无卡机器上可能连 import 都失败,请确认目标机器。") + + if args.dry_run: + package = GPU_PACKAGE if use_gpu else CPU_PACKAGE + print(f"\n[dry-run] 将安装 {package}=={args.version}" + + (f",来源 {INDEX_TEMPLATE.format(cuda=cuda)}" if use_gpu else "")) + return 0 + + # 装 CPU 版时顺带清掉 GPU 版拖进来的 CUDA 运行库;装 GPU 版时不用管(本来就要装)。 + to_remove = BOTH_PACKAGES if use_gpu else (*BOTH_PACKAGES, *NVIDIA_PACKAGES) + print("\n[1/2] 卸载已有的 " + " / ".join(to_remove)) + result = run(pip_command("uninstall", *to_remove, python=args.python), check=False) + explain_uninstall_failure((result.stdout or "") + (result.stderr or "")) + if result.returncode != 0: + return result.returncode + + print(f"\n[2/2] 安装 {GPU_PACKAGE if use_gpu else CPU_PACKAGE}=={args.version}") + if use_gpu: + command = pip_command( + "install", + f"{GPU_PACKAGE}=={args.version}", + # 用 extra-index-url 而不是 index-url:paddlepaddle-gpu 只在官方源上, + # 但它的依赖(numpy 等)还得从 PyPI 取。 + "--extra-index-url", + INDEX_TEMPLATE.format(cuda=cuda), + python=args.python, + ) + else: + command = pip_command( + "install", f"{CPU_PACKAGE}=={args.version}", python=args.python + ) + run(command) + + print("\n完成。验证方式:") + if use_gpu: + print(" python -c \"import paddle; print(paddle.device.is_compiled_with_cuda())\"") + print(" config.yaml 里 device: auto 即可自动走 GPU") + else: + print(" config.yaml 里 device: cpu(或 auto,无卡时自动用 CPU)") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/package-ubuntu.sh b/scripts/package-ubuntu.sh index 8199f68..a053dc0 100644 --- a/scripts/package-ubuntu.sh +++ b/scripts/package-ubuntu.sh @@ -1,16 +1,28 @@ #!/usr/bin/env bash # 打包 Ubuntu/Linux 发布包(--onedir 目录形式)。 # +# CPU / GPU 两个变体由**构建环境里装的 paddlepaddle 版本**自动决定,不需要手动指定: +# 装了 paddlepaddle -> CPU 包,输出到 dist/ +# 装了 paddlepaddle-gpu -> GPU 包,dist/ocr-server-gpu/,且 config.yaml 的 device 预置为 auto +# GPU 包的同一个分发包在没显卡的机器上也能启动(会自动回落 CPU,见 README)。 +# # 关键参数说明,改动前请先读: # --collect-all paddle/paddlex/paddleocr Paddle 的原生库与配置必须整体收集,缺一个就跑不起来 # --collect-all pyclipper/pypdfium2/shapely/bidi # 检测后处理与识别的必需依赖,漏了会在推理时报错 # --copy-metadata * PaddleX 通过 importlib.metadata 检查依赖, -# 缺元数据会误判「依赖未安装」 +# 缺元数据会误判「依赖未安装」。 +# ⚠️ paddle 的发行包名随变体变化(paddlepaddle / +# paddlepaddle-gpu),写死会打不出包, +# 所以由 scripts/paddle_env.py 动态取。 # --additional-hooks-dir scripts 启用 scripts/hook-imagesize.py # --hidden-import imagesize 源码环境下按需导入,打包时必须显式声明 # # 必须在 Linux 上执行:PyInstaller 不能交叉编译,Windows 上无法生成 ELF 二进制。 +# +# 用法: +# ./scripts/package-ubuntu.sh # 按环境自动判断变体 +# ./scripts/package-ubuntu.sh --gpu # 断言必须是 GPU 版 paddle set -euo pipefail PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" @@ -21,14 +33,85 @@ if [[ "$(uname -s)" != "Linux" ]]; then exit 1 fi -uv sync --dev --python 3.12 -rm -rf build dist +REQUIRE_GPU=0 +for arg in "$@"; do + case "$arg" in + --gpu) REQUIRE_GPU=1 ;; + *) + printf '未知参数:%s\n' "$arg" >&2 + exit 2 + ;; + esac +done -uv run pyinstaller --noconfirm --clean --onedir --name ocr-server \ +# --inexact + --no-install-package paddlepaddle:只同步除 paddle 以外的依赖。 +# pyproject.toml 里声明的是 CPU 版 paddlepaddle,裸跑 uv sync 会「卸载 +# paddlepaddle-gpu 和全部 nvidia-* 运行库、装回 CPU 版」,把 GPU 环境悄悄冲掉; +# 而单独用 --no-install-package 又会把 paddlepaddle-gpu 当多余包删掉。 +# 这两个参数合用才能保住当前装的 paddle 变体(实测 dry-run 为 no changes)。 +uv sync --dev --inexact --no-install-package paddlepaddle --python 3.12 + +# ── 判断变体 ────────────────────────────────────────────────── +VARIANT="$(uv run --no-sync python scripts/paddle_env.py variant)" +PADDLE_DIST="$(uv run --no-sync python scripts/paddle_env.py distribution)" +if [[ "$VARIANT" == "missing" ]]; then + printf '%s\n' '环境里没有安装 paddlepaddle,请先执行 uv sync。' >&2 + exit 1 +fi +if [[ "$REQUIRE_GPU" == "1" && "$VARIANT" != "gpu" ]]; then + cat >&2 </bin,正好是 paddle 在 __init__.py 里 +# 用 os.add_dll_directory 寻找的路径(os.path.dirname(paddle.__file__)/../nvidia)。 +EXTRA_COLLECT=() +if [[ "$BUILD_VARIANT" == "gpu" ]]; then + EXTRA_COLLECT=(--collect-binaries nvidia) +fi + +uv run --no-sync pyinstaller --noconfirm --clean --onedir --name "$APP_NAME" \ + --distpath "$DIST_PATH" \ --paths src \ --collect-all paddleocr \ --collect-all paddlex \ --collect-all paddle \ + "${EXTRA_COLLECT[@]+"${EXTRA_COLLECT[@]}"}" \ --collect-all cv2 \ --collect-all PIL \ --collect-all pyclipper \ @@ -38,7 +121,7 @@ uv run pyinstaller --noconfirm --clean --onedir --name ocr-server \ --hidden-import paddlex.inference.models.text_detection.processors \ --copy-metadata paddlex \ --copy-metadata paddleocr \ - --copy-metadata paddlepaddle \ + --copy-metadata "$PADDLE_DIST" \ --copy-metadata imagesize \ --add-data 'config.yaml:.' \ --add-data 'http:http' \ @@ -49,17 +132,27 @@ uv run pyinstaller --noconfirm --clean --onedir --name ocr-server \ --hidden-import ocr_server.config \ scripts/packaged_entry.py -cp -f config.yaml dist/ocr-server/config.yaml -cp -a models dist/ocr-server/models -chmod +x dist/ocr-server/ocr-server +# shellcheck disable=SC2086 +uv run --no-sync python scripts/prepare_release_config.py config.yaml "$RELEASE_DIR/config.yaml" $CONFIG_OVERRIDE +cp -a models "$RELEASE_DIR/models" +chmod +x "$RELEASE_DIR/ocr-server" -BIN="$PROJECT_ROOT/dist/ocr-server/ocr-server" +BIN="$RELEASE_DIR/$APP_NAME" if [[ ! -x "$BIN" ]]; then printf '打包失败:未生成 %s\n' "$BIN" >&2 exit 1 fi -printf '\nUbuntu 发布目录:%s\n' "$PROJECT_ROOT/dist/ocr-server" -printf '%s\n' '启动:dist/ocr-server/ocr-server' +TOTAL_MB="$(du -sm "$RELEASE_DIR" | cut -f1)" + +printf '\nUbuntu 发布目录:%s\n' "$RELEASE_DIR" +printf '变体:%s\n' "$BUILD_VARIANT" +printf '%s\n' '启动:'"$RELEASE_DIR/$APP_NAME" +printf '整个发布目录体积:%s MB\n' "$TOTAL_MB" printf '二进制 SHA256:%s\n' "$(sha256sum "$BIN" | cut -d' ' -f1)" +if [[ "$BUILD_VARIANT" == "gpu" ]]; then + printf '%s\n' '已把发布包里的 config.yaml 预置为 device: auto;有可用显卡时用 GPU,否则自动用 CPU。' +else + printf '%s\n' 'CPU 包。客户机若要用 GPU,需要改用 GPU 版分发包(用 paddlepaddle-gpu 环境重新打包)。' +fi printf '%s\n' '(发布时要连 _internal 和 models 一起复制,不能只替换二进制)' diff --git a/scripts/package-windows.ps1 b/scripts/package-windows.ps1 index ed5f311..dfc2fe0 100644 --- a/scripts/package-windows.ps1 +++ b/scripts/package-windows.ps1 @@ -1,39 +1,102 @@ # 打包 Windows 发布包(--onedir 目录形式)。 # +# CPU / GPU 两个变体由**构建环境里装的 paddlepaddle 版本**自动决定,不需要手动指定: +# 装了 paddlepaddle -> CPU 包,dist\ocr-server\ +# 装了 paddlepaddle-gpu -> GPU 包,dist\ocr-server-gpu\,且 config.yaml 的 device 预置为 auto +# GPU 包在装了 GPU 版 paddle 的机器上走显卡,拿不到 CUDA 设备时回落 CPU(见 README)。 +# # 关键参数说明,改动前请先读: # --collect-all paddle/paddlex/paddleocr Paddle 的原生库与配置必须整体收集,缺一个就跑不起来 # --collect-all pyclipper/pypdfium2/shapely/bidi # 检测后处理与识别的必需依赖,漏了会在推理时报错 # --copy-metadata * PaddleX 通过 importlib.metadata 检查依赖, -# 缺元数据会误判「依赖未安装」 +# 缺元数据会误判「依赖未安装」。 +# ⚠️ paddle 的发行包名随变体变化(paddlepaddle / +# paddlepaddle-gpu),写死会打不出包, +# 所以由 scripts/paddle_env.py 动态取。 # --additional-hooks-dir scripts 启用 scripts/hook-imagesize.py # --hidden-import imagesize 源码环境下按需导入,打包时必须显式声明 # # 发布包为 --onedir:模型与 config.yaml 外置,便于替换;不要只替换 exe,_internal 也要一起更新。 param( [switch]$Clean, - # 输出目录,默认 dist。若 dist 被其它进程当作工作目录占用(Windows 会锁住该目录), - # 可指定别处构建,再把内容搬回去,例如: + # 断言当前环境必须是 GPU 版 paddle。不传时按实际安装的版本自动判断。 + [switch]$Gpu, + # 输出根目录,默认 dist。变体决定其下的应用目录名:ocr-server / ocr-server-gpu。 + # 若 dist 被其它进程当作工作目录占用(Windows 会锁住该目录),可指定别处构建: # .\scripts\package-windows.ps1 -DistPath build\pyi-dist - [string]$DistPath = "dist" + [string]$DistPath ) $ErrorActionPreference = "Stop" $ProjectRoot = Split-Path -Parent $PSScriptRoot Set-Location $ProjectRoot -$ReleaseDir = Join-Path $ProjectRoot "$DistPath\ocr-server" + +# --inexact + --no-install-package paddlepaddle:只同步除 paddle 以外的依赖。 +# pyproject.toml 里声明的是 CPU 版 paddlepaddle,裸跑 uv sync 会「卸载 +# paddlepaddle-gpu 和全部 nvidia-* 运行库、装回 CPU 版」,把 GPU 环境悄悄冲掉; +# 而单独用 --no-install-package 又会把 paddlepaddle-gpu 当多余包删掉。 +# 这两个参数合用才能保住当前装的 paddle 变体(实测 dry-run 为 no changes)。 +uv sync --dev --inexact --no-install-package paddlepaddle + +# ── 判断变体 ────────────────────────────────────────────────── +$Variant = (uv run --no-sync python scripts/paddle_env.py variant).Trim() +$PaddleDist = (uv run --no-sync python scripts/paddle_env.py distribution).Trim() +if ($Variant -eq "missing") { + throw "环境里没有安装 paddlepaddle,请先执行 uv sync。" +} +if ($Gpu -and $Variant -ne "gpu") { + throw @" +要求打 GPU 包,但当前环境装的是 $Variant 版 paddle(发行包 $PaddleDist)。 +请先换 GPU 版(版本必须同为 3.2.x): + uv run --no-sync python scripts/install_paddle.py --gpu + # (install_paddle.py 会自动识别显卡并选对 CUDA 通道) +⚠️ RTX 50 系必须用 cu129,cu118 / cu126 不含 sm_120 内核,装了会在推理时报 + Mismatched GPU Architecture。40/30 系 cu126 / cu129 均可。 +详见 README「CPU / GPU 切换」。 +"@ +} +# 变体由构建环境里实际装的 paddle 决定,没有「强制」开关—— +# 产物里打进的就是当前环境的 paddle,改了名字也不会变,只会误导。 +$BuildVariant = $Variant +# GPU 包预置 device: auto 而不是 gpu:客户机有卡就用卡、没卡就回落 CPU, +# 两种情况都不会把服务卡死,日志里也会明确打出实际选了哪个。 +if ($BuildVariant -eq "gpu") { $ConfigOverride = "device=auto" } else { $ConfigOverride = $null } + +if (-not $PSBoundParameters.ContainsKey("DistPath") -or [string]::IsNullOrWhiteSpace($DistPath)) { + $DistPath = "dist" +} +# 产物命名:CPU 版叫 ocr-server,GPU 版叫 ocr-server-gpu,都放在 dist 下, +# 两个发布包一眼能分辨,也不会互相覆盖。 +$AppName = if ($BuildVariant -eq "gpu") { "ocr-server-gpu" } else { "ocr-server" } +$ReleaseDir = Join-Path $ProjectRoot "$DistPath\$AppName" + +Write-Host "构建变体:$BuildVariant(paddle 发行包 $PaddleDist)" +Write-Host "输出目录:$ReleaseDir" if ($Clean) { - Remove-Item -Recurse -Force -ErrorAction SilentlyContinue build, dist + # 只清当前变体的目录,别把另一个变体的产物一起删了 + Remove-Item -Recurse -Force -ErrorAction SilentlyContinue build, $ReleaseDir } -uv sync --dev -uv run pyinstaller --noconfirm --clean --onedir --name ocr-server ` +# GPU 版必须额外收 nvidia 命名空间:paddlepaddle-gpu 的 CUDA 运行库(cudnn / cublas / +# cufft 等)装在独立的 nvidia-* 发行包里,`--collect-all paddle` 收不到它们。 +# 漏收的后果实测是:引擎能加载、设备识别成 GPU,但第一次推理就报 +# `PreconditionNotMetError: cudnn64_9.dll ... error code is 126`。 +# 收进来的落点是 _internal/nvidia/<包>/bin,正好是 paddle 在 __init__.py 里 +# 用 os.add_dll_directory 寻找的路径(os.path.dirname(paddle.__file__)/../nvidia)。 +$ExtraCollect = @() +if ($BuildVariant -eq "gpu") { + $ExtraCollect = @("--collect-binaries", "nvidia") +} + +uv run --no-sync pyinstaller --noconfirm --clean --onedir --name $AppName ` --distpath $DistPath ` --paths src ` --collect-all paddleocr ` --collect-all paddlex ` --collect-all paddle ` + @ExtraCollect ` --collect-all cv2 ` --collect-all PIL ` --collect-all pyclipper ` @@ -43,7 +106,7 @@ uv run pyinstaller --noconfirm --clean --onedir --name ocr-server ` --hidden-import paddlex.inference.models.text_detection.processors ` --copy-metadata paddlex ` --copy-metadata paddleocr ` - --copy-metadata paddlepaddle ` + --copy-metadata $PaddleDist ` --copy-metadata imagesize ` --add-data "config.yaml;." ` --add-data "http;http" ` @@ -54,20 +117,35 @@ uv run pyinstaller --noconfirm --clean --onedir --name ocr-server ` --hidden-import ocr_server.config ` scripts/packaged_entry.py -Copy-Item -Force config.yaml (Join-Path $ReleaseDir "config.yaml") +$ConfigArgs = @( + "scripts/prepare_release_config.py", + "config.yaml", + (Join-Path $ReleaseDir "config.yaml") +) +if ($ConfigOverride) { $ConfigArgs += $ConfigOverride } +uv run --no-sync python @ConfigArgs + if (Test-Path models) { Copy-Item -Recurse -Force models (Join-Path $ReleaseDir "models") } -$Exe = Join-Path $ReleaseDir "ocr-server.exe" +$Exe = Join-Path $ReleaseDir "$AppName.exe" if (-not (Test-Path $Exe)) { throw "打包失败:未生成 $Exe" } $Hash = (Get-FileHash -Algorithm SHA256 $Exe).Hash.ToLower() +$TotalMB = (Get-ChildItem -Recurse -File $ReleaseDir | Measure-Object -Property Length -Sum).Sum / 1MB Write-Host "" Write-Host "Windows 发布目录:$ReleaseDir" -Write-Host "启动:$DistPath\ocr-server\ocr-server.exe" +Write-Host "变体:$BuildVariant" +Write-Host "启动:$DistPath\$AppName\$AppName.exe" +Write-Host ("整个发布目录体积:{0:N1} MB" -f $TotalMB) Write-Host ("exe 体积:{0:N1} MB" -f ((Get-Item $Exe).Length / 1MB)) Write-Host "exe SHA256:$Hash" +if ($BuildVariant -eq "gpu") { + Write-Host "已把发布包里的 config.yaml 预置为 device: auto;有可用显卡时用 GPU,否则自动用 CPU。" +} else { + Write-Host "CPU 包。客户机若要用 GPU,需要改用 GPU 版分发包(用 paddlepaddle-gpu 环境重新打包)。" +} Write-Host "(发布时要连 _internal 和 models 一起复制,不能只替换 exe)" diff --git a/scripts/paddle_env.py b/scripts/paddle_env.py new file mode 100644 index 0000000..edec9c0 --- /dev/null +++ b/scripts/paddle_env.py @@ -0,0 +1,54 @@ +"""报告当前构建环境里的 paddlepaddle 变体,供打包脚本选择 CPU/GPU 产物。 + +用法(打包脚本内部调用): + python scripts/paddle_env.py variant -> cpu / gpu / missing + python scripts/paddle_env.py distribution -> paddlepaddle / paddlepaddle-gpu + +`distribution` 用于 --copy-metadata:PyPI 上 CPU 版发行包叫 paddlepaddle, +GPU 版叫 paddlepaddle-gpu,写死任何一个在另一种环境下都会打包失败。 +""" + +import importlib.metadata +import importlib.util +import sys + +CPU_DISTRIBUTION = "paddlepaddle" +GPU_DISTRIBUTION = "paddlepaddle-gpu" + + +def detect_variant() -> str: + if importlib.util.find_spec("paddle") is None: + return "missing" + import paddle + + return "gpu" if paddle.device.is_compiled_with_cuda() else "cpu" + + +def detect_distribution() -> str: + """返回实际安装的发行包名。""" + for name in (CPU_DISTRIBUTION, GPU_DISTRIBUTION): + try: + importlib.metadata.version(name) + except importlib.metadata.PackageNotFoundError: + continue + return name + return "" + + +def main() -> int: + if len(sys.argv) != 2 or sys.argv[1] not in {"variant", "distribution"}: + print(__doc__.strip(), file=sys.stderr) + return 2 + if sys.argv[1] == "variant": + print(detect_variant()) + return 0 + distribution = detect_distribution() + if not distribution: + print("未找到已安装的 paddlepaddle / paddlepaddle-gpu", file=sys.stderr) + return 1 + print(distribution) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/prepare_release_config.py b/scripts/prepare_release_config.py new file mode 100644 index 0000000..2b670c3 --- /dev/null +++ b/scripts/prepare_release_config.py @@ -0,0 +1,46 @@ +"""把 config.yaml 复制进发布目录,并按发布变体覆盖若干顶层配置项。 + +用法: + python scripts/prepare_release_config.py <源> <目标> [键=值 ...] +例如 GPU 包: + python scripts/prepare_release_config.py config.yaml dist/ocr-server-gpu/config.yaml device=gpu + +用 Python 而不是 shell 改写,是为了保持 UTF-8 编码——config.yaml 里有大量中文注释, +PowerShell 5.1 的 Set-Content 默认按 ANSI 写,会把注释写坏。 +""" + +import re +import sys +from pathlib import Path + + +def apply_override(text: str, key: str, value: str) -> str: + pattern = re.compile(rf"^{re.escape(key)}:.*$", re.MULTILINE) + if pattern.search(text): + return pattern.sub(f"{key}: {value}", text, count=1) + # 源文件里没有这一项(例如被注释掉了),追加到末尾。 + return text.rstrip("\n") + f"\n{key}: {value}\n" + + +def main() -> int: + if len(sys.argv) < 3: + print(__doc__.strip(), file=sys.stderr) + return 2 + source, target = Path(sys.argv[1]), Path(sys.argv[2]) + text = source.read_text(encoding="utf-8") + + for pair in sys.argv[3:]: + if "=" not in pair: + print(f"覆盖项格式应为 键=值,收到 {pair!r}", file=sys.stderr) + return 2 + key, value = pair.split("=", 1) + text = apply_override(text, key.strip(), value.strip()) + + target.parent.mkdir(parents=True, exist_ok=True) + target.write_text(text, encoding="utf-8") + print(f"已写入发布配置 {target}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/start.bat b/scripts/start.bat index 1ffff5d..e74f894 100644 --- a/scripts/start.bat +++ b/scripts/start.bat @@ -2,15 +2,31 @@ setlocal cd /d "%~dp0.." +rem 优先跑发布包:CPU 版 dist\ocr-server,GPU 版 dist\ocr-server-gpu。 +rem 两个都存在时用 CPU 版(GPU 包只有装了 GPU 版 paddle 的机器才能用,见 README)。 +rem 想直接跑 GPU 包就写全路径:dist\ocr-server-gpu\ocr-server-gpu.exe if exist "dist\ocr-server\ocr-server.exe" ( "dist\ocr-server\ocr-server.exe" exit /b %errorlevel% ) +if exist "dist\ocr-server-gpu\ocr-server-gpu.exe" ( + "dist\ocr-server-gpu\ocr-server-gpu.exe" + exit /b %errorlevel% +) + +rem 优先直接跑 .venv 里的入口脚本:直接执行不会触发 uv 的环境同步。 +rem 必须这样做的原因:uv run 会先按 pyproject.toml 同步环境,而 paddle 不在依赖里, +rem 同步会把它整个移除(实测)。入口脚本名固定是 ocr-server,与变体无关。 +if exist ".venv\Scripts\ocr-server.exe" ( + ".venv\Scripts\ocr-server.exe" + exit /b %errorlevel% +) where uv >nul 2>nul if errorlevel 1 ( - echo 未找到打包程序,也未安装 uv。 + echo 未找到发布包,也未安装 uv。请先运行 scripts\package-windows.ps1 或 scripts/switch_env.py --cpu。 exit /b 1 ) -uv run ocr-server +rem --no-sync 是必须的,理由同上。环境尚未建好时,请先运行一次 scripts/switch_env.py --cpu。 +uv run --no-sync ocr-server diff --git a/scripts/start.ps1 b/scripts/start.ps1 index dc0c82d..d88ec00 100644 --- a/scripts/start.ps1 +++ b/scripts/start.ps1 @@ -1,15 +1,29 @@ $ErrorActionPreference = "Stop" $ProjectRoot = Split-Path -Parent $PSScriptRoot Set-Location $ProjectRoot -$PackagedExe = Join-Path $ProjectRoot "dist\ocr-server\ocr-server.exe" +# 优先跑发布包:CPU 版 dist\ocr-server,GPU 版 dist\ocr-server-gpu。 +# 两个都存在时用 CPU 版(GPU 包只有装了 GPU 版 paddle 的机器才能用,见 README)。 +# 想直接跑 GPU 包就写全路径:dist\ocr-server-gpu\ocr-server-gpu.exe +foreach ($Candidate in @("dist\ocr-server\ocr-server.exe", "dist\ocr-server-gpu\ocr-server-gpu.exe")) { + $PackagedExe = Join-Path $ProjectRoot $Candidate + if (Test-Path $PackagedExe) { + & $PackagedExe + exit $LASTEXITCODE + } +} -if (Test-Path $PackagedExe) { - & $PackagedExe +# 优先直接跑 .venv 里的入口脚本:直接执行不会触发 uv 的环境同步。 +# 必须这样做的原因:uv run 会先按 pyproject.toml 同步环境,而 paddle 不在依赖里, +# 同步会把它整个移除(实测)。入口脚本名固定是 ocr-server,与变体无关。 +$VenvExe = Join-Path $ProjectRoot ".venv\Scripts\ocr-server.exe" +if (Test-Path $VenvExe) { + & $VenvExe exit $LASTEXITCODE } if (-not (Get-Command uv -ErrorAction SilentlyContinue)) { - throw "未找到打包程序,也未安装 uv。请先运行 scripts/package-windows.ps1 或安装 uv。" + throw "未找到发布包,也未安装 uv。请先运行 scripts/package-windows.ps1 或 scripts/switch_env.py --cpu。" } -uv run ocr-server +# --no-sync 是必须的,理由同上。环境尚未建好时,请先运行一次 scripts/switch_env.py --cpu。 +uv run --no-sync ocr-server diff --git a/scripts/start.sh b/scripts/start.sh index 4d6bcd4..c72d987 100644 --- a/scripts/start.sh +++ b/scripts/start.sh @@ -3,17 +3,27 @@ set -euo pipefail cd "$(dirname "${BASH_SOURCE[0]}")/.." -if [[ -x dist/ocr-server/ocr-server ]]; then - exec dist/ocr-server/ocr-server -fi - -if command -v uv >/dev/null 2>&1; then - exec uv run ocr-server -fi +# 优先跑发布包:CPU 版 dist/ocr-server,GPU 版 dist/ocr-server-gpu。 +# 两个都存在时用 CPU 版(GPU 包只有装了 GPU 版 paddle 的机器才能用,见 README)。 +# 想直接跑 GPU 包就写全路径:dist/ocr-server-gpu/ocr-server-gpu +for candidate in dist/ocr-server/ocr-server dist/ocr-server-gpu/ocr-server-gpu; do + if [[ -x "$candidate" ]]; then + exec "$candidate" + fi +done +# 优先直接跑 .venv 里的入口脚本:直接执行不会触发 uv 的环境同步。 +# 必须这样做的原因:`uv run` 会先按 pyproject.toml 同步环境,而 paddle 不在依赖里, +# 同步会把它整个移除(实测)。注意入口脚本名固定是 ocr-server, +# 由 pyproject.toml 的 [project.scripts] 决定,与 CPU/GPU 变体无关。 if [[ -x .venv/bin/ocr-server ]]; then exec .venv/bin/ocr-server fi -printf '%s\n' '未找到 uv 或 .venv/bin/ocr-server,请先运行 scripts/package-ubuntu.sh 或安装项目依赖。' >&2 +if command -v uv >/dev/null 2>&1; then + # --no-sync 是必须的,理由同上。环境尚未建好时,请先运行 scripts/switch_env.py --cpu。 + exec uv run --no-sync ocr-server +fi + +printf '%s\n' '未找到发布包、.venv/bin/ocr-server,也没装 uv。请先运行 scripts/package-ubuntu.sh 或 scripts/switch_env.py --cpu。' >&2 exit 1 diff --git a/scripts/switch_env.py b/scripts/switch_env.py new file mode 100644 index 0000000..d08f8c0 --- /dev/null +++ b/scripts/switch_env.py @@ -0,0 +1,150 @@ +"""在 CPU / GPU 两套虚拟环境之间切换。 + + .venv CPU 环境 + .venv-gpu GPU 环境 + +两套环境**同时存在**,切换只是「用哪个跑哪个」,不需要卸载重装。之所以不做成 +一个环境来回切:paddlepaddle 与 paddlepaddle-gpu 互斥(都提供 `paddle` 顶层包和 +同一批文件),而且 GPU 版还要带上约 3GB 的 CUDA 运行库,反复装卸很浪费。 + +用法: + python scripts/switch_env.py --cpu # 建立/更新 CPU 环境 + python scripts/switch_env.py --gpu # 建立/更新 GPU 环境(通道按显卡自动推荐) + python scripts/switch_env.py --gpu --cuda cu126 # 指定 CUDA 通道 + python scripts/switch_env.py --list # 只看两套环境的现状,不做改动 + +建好之后怎么用(入口脚本名固定是 ocr-server,由 pyproject.toml 的 [project.scripts] +决定,与 CPU/GPU 变体无关,变的只是所在的虚拟环境目录): + 启动服务(CPU):.venv\\Scripts\\ocr-server.exe + 启动服务(GPU):.venv-gpu\\Scripts\\ocr-server.exe + 打 GPU 包(产出 dist\\ocr-server-gpu\\): + $env:UV_PROJECT_ENVIRONMENT=".venv-gpu"; .\\scripts\\package-windows.ps1 +""" + +import argparse +import os +import subprocess +import sys +from pathlib import Path + +PROJECT_ROOT = Path(__file__).resolve().parents[1] +SCRIPTS_DIR = PROJECT_ROOT / "scripts" + +CPU_VENV = ".venv" +GPU_VENV = ".venv-gpu" + + +def venv_python(relative: str) -> Path: + if os.name == "nt": + return PROJECT_ROOT / relative / "Scripts" / "python.exe" + return PROJECT_ROOT / relative / "bin" / "python" + + +def run(command: list[str], env: dict[str, str] | None = None) -> int: + print(f" $ {' '.join(command)}", flush=True) + return subprocess.run(command, cwd=PROJECT_ROOT, env=env, check=False).returncode + + +def sync_venv(relative: str) -> int: + """把项目依赖同步进指定虚拟环境。 + + `--inexact` 不能省:paddle 不在 pyproject 的依赖里,普通 sync 会把手动装进去的 + paddlepaddle / paddlepaddle-gpu 当成「多余包」删掉。 + """ + venv_path = (PROJECT_ROOT / relative).resolve() + env = {**os.environ, "UV_PROJECT_ENVIRONMENT": str(venv_path)} + print(f"[同步依赖] {relative}") + return run(["uv", "sync", "--dev", "--inexact"], env=env) + + +def describe(relative: str) -> str: + python = venv_python(relative) + if not python.is_file(): + return "未创建" + probe = ( + "import importlib.metadata as md\n" + "found = []\n" + "for name in ('paddlepaddle', 'paddlepaddle-gpu'):\n" + " try:\n" + " found.append(f'{name}=={md.version(name)}')\n" + " except md.PackageNotFoundError:\n" + " pass\n" + "if not found:\n" + " print('未安装 paddle')\n" + "else:\n" + " import paddle\n" + " cuda = paddle.device.is_compiled_with_cuda()\n" + " count = paddle.device.cuda.device_count() if cuda else 0\n" + " print(','.join(found) + f' | CUDA 可用:{cuda},GPU 数:{count}')\n" + ) + result = subprocess.run( + [str(python), "-c", probe], + capture_output=True, + text=True, + encoding="utf-8", + cwd=PROJECT_ROOT, + check=False, + ) + if result.returncode != 0: + return "paddle 状态未知(导入失败)" + return result.stdout.strip() + + +def main() -> int: + parser = argparse.ArgumentParser(description="在 CPU / GPU 两套虚拟环境之间切换") + group = parser.add_mutually_exclusive_group() + group.add_argument("--cpu", action="store_true", help=f"建立/更新 CPU 环境({CPU_VENV})") + group.add_argument("--gpu", action="store_true", help=f"建立/更新 GPU 环境({GPU_VENV})") + group.add_argument("--list", action="store_true", help="只查看现状") + parser.add_argument("--cuda", choices=("cu118", "cu126", "cu129"), help="GPU 版的 CUDA 通道") + parser.add_argument("--version", help="paddle 版本,默认 3.2.2") + args = parser.parse_args() + + if args.list or not (args.cpu or args.gpu): + if not args.list: + parser.print_help() + return 2 + print(f"CPU 环境 {CPU_VENV:10} {describe(CPU_VENV)}") + print(f"GPU 环境 {GPU_VENV:10} {describe(GPU_VENV)}") + return 0 + + relative = CPU_VENV if args.cpu else GPU_VENV + if args.cuda and args.cpu: + print("--cuda 只在 --gpu 时有意义", file=sys.stderr) + return 2 + + if sync_venv(relative) != 0: + return 1 + + print(f"[安装 paddle] {relative}") + command = [ + sys.executable, + str(SCRIPTS_DIR / "install_paddle.py"), + "--python", + str(venv_python(relative)), + ] + command.append("--cpu" if args.cpu else "--gpu") + if args.cuda: + command += ["--cuda", args.cuda] + if args.version: + command += ["--version", args.version] + if run(command) != 0: + return 1 + + # 入口脚本名固定是 ocr-server(见 pyproject.toml 的 [project.scripts]), + # 和所在环境是 CPU 还是 GPU 无关。 + executable = "Scripts\\ocr-server.exe" if os.name == "nt" else "bin/ocr-server" + print(f"\n{relative} 就绪。") + print(f" 启动:{relative}/{executable}") + if args.cpu: + print(' 打 CPU 包:直接运行 scripts/package-windows.ps1(产出 dist/ocr-server/)') + else: + print( + " 打 GPU 包:设 UV_PROJECT_ENVIRONMENT=.venv-gpu 后运行 scripts/package-windows.ps1" + "(产出 dist/ocr-server-gpu/)" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/test_release_helpers.py b/tests/test_release_helpers.py new file mode 100644 index 0000000..e2801ea --- /dev/null +++ b/tests/test_release_helpers.py @@ -0,0 +1,128 @@ +"""打包辅助脚本的回归测试(config 改写与 paddle 变体探测)。""" + +import subprocess +import sys +from pathlib import Path + +PROJECT_ROOT = Path(__file__).resolve().parents[1] +PREPARE_CONFIG = PROJECT_ROOT / "scripts" / "prepare_release_config.py" +PADDLE_ENV = PROJECT_ROOT / "scripts" / "paddle_env.py" +INSTALL_PADDLE = PROJECT_ROOT / "scripts" / "install_paddle.py" +SWITCH_ENV = PROJECT_ROOT / "scripts" / "switch_env.py" + +SAMPLE = """\ +# 中文注释必须原样保留 +host: 127.0.0.1 +device: cpu +text_recognition_batch_size: 32 +""" + + +def run_script(script: Path, *args: str) -> subprocess.CompletedProcess[str]: + return subprocess.run( + [sys.executable, str(script), *args], + capture_output=True, + text=True, + encoding="utf-8", + cwd=PROJECT_ROOT, + check=False, + ) + + +def test_prepare_release_config_overrides_device(tmp_path: Path) -> None: + source = tmp_path / "config.yaml" + source.write_text(SAMPLE, encoding="utf-8") + target = tmp_path / "release" / "config.yaml" + + result = run_script(PREPARE_CONFIG, str(source), str(target), "device=gpu") + assert result.returncode == 0, result.stderr + + written = target.read_text(encoding="utf-8") + assert "device: gpu" in written + assert "device: cpu" not in written + # 未被覆盖的项和中文注释都要原样保留(PowerShell 的默认编码会把中文写坏)。 + assert "text_recognition_batch_size: 32" in written + assert "# 中文注释必须原样保留" in written + + +def test_prepare_release_config_appends_missing_key(tmp_path: Path) -> None: + source = tmp_path / "config.yaml" + source.write_text(SAMPLE.replace("device: cpu\n", ""), encoding="utf-8") + target = tmp_path / "config.yaml" + + result = run_script(PREPARE_CONFIG, str(source), str(target), "device=gpu") + assert result.returncode == 0, result.stderr + assert "device: gpu" in target.read_text(encoding="utf-8") + + +def test_prepare_release_config_rejects_bad_override(tmp_path: Path) -> None: + source = tmp_path / "config.yaml" + source.write_text(SAMPLE, encoding="utf-8") + + result = run_script(PREPARE_CONFIG, str(source), str(tmp_path / "out.yaml"), "device") + assert result.returncode == 2 + + +def test_paddle_env_reports_variant_and_distribution() -> None: + variant = run_script(PADDLE_ENV, "variant") + assert variant.returncode == 0, variant.stderr + assert variant.stdout.strip() in {"cpu", "gpu"} + + distribution = run_script(PADDLE_ENV, "distribution") + assert distribution.returncode == 0, distribution.stderr + reported = distribution.stdout.strip() + assert reported in {"paddlepaddle", "paddlepaddle-gpu"} + # 变体和发行包名必须一致,否则打包时 --copy-metadata 会取错。 + expected = "paddlepaddle-gpu" if variant.stdout.strip() == "gpu" else "paddlepaddle" + assert reported == expected + + +def test_paddle_env_rejects_unknown_mode() -> None: + assert run_script(PADDLE_ENV, "whatever").returncode == 2 + + +def test_install_paddle_dry_run_never_touches_environment() -> None: + """--dry-run 只打印方案,不能真的去装东西。""" + result = run_script(INSTALL_PADDLE, "--dry-run") + assert result.returncode == 0, result.stderr + assert "[dry-run]" in result.stdout + assert "paddlepaddle" in result.stdout + + +def test_install_paddle_auto_picks_gpu_channel_for_rtx50() -> None: + """RTX 50 系(Blackwell sm_120)必须走 cu129,否则推理时报 Mismatched GPU Architecture。""" + result = run_script(INSTALL_PADDLE, "--gpu", "--dry-run") + assert result.returncode == 0, result.stderr + assert "paddlepaddle-gpu==" in result.stdout + + +def test_install_paddle_rejects_unknown_cuda_channel() -> None: + result = run_script(INSTALL_PADDLE, "--gpu", "--cuda", "cu999", "--dry-run") + assert result.returncode == 2 + + +def test_switch_env_list_reports_both_variants() -> None: + """--list 只读,不能改动任何环境。""" + result = run_script(SWITCH_ENV, "--list") + assert result.returncode == 0, result.stderr + assert ".venv" in result.stdout + assert ".venv-gpu" in result.stdout + + +def test_switch_env_rejects_cuda_together_with_cpu() -> None: + result = run_script(SWITCH_ENV, "--cpu", "--cuda", "cu126") + assert result.returncode == 2 + + +def test_recommend_cuda_matches_gpu_generation() -> None: + sys.path.insert(0, str(PROJECT_ROOT / "scripts")) + try: + import install_paddle + finally: + sys.path.pop(0) + + assert install_paddle.recommend_cuda("NVIDIA GeForce RTX 5060 Laptop GPU") == "cu129" + assert install_paddle.recommend_cuda("NVIDIA GeForce RTX 4090") == "cu126" + assert install_paddle.recommend_cuda("NVIDIA GeForce RTX 3060") == "cu126" + assert install_paddle.recommend_cuda("Tesla T4") == "cu118" + assert install_paddle.recommend_cuda(None) == "cu126" diff --git a/uv.lock b/uv.lock index a615be4..9c29341 100644 --- a/uv.lock +++ b/uv.lock @@ -742,19 +742,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/48/cd/072313585f74fe9d441e2eb5e0a4703c30586cd709810ea369675f61b74e/hf_xet-1.7.0-cp38-abi3-win_arm64.whl", hash = "sha256:acc3851cf2576a8fb2ae926da863f4efabe21303cf292e9a44332802ab0dcc6a", size = 3662436, upload-time = "2026-10-06T20:18:42.205Z" }, ] -[[package]] -name = "httpcore" -version = "1.0.9" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "h11" }, -] -sdist = { url = "https://files.pythonhosted.org/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://files.pythonhosted.org/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 = "httpcore2" version = "2.13.1" @@ -828,21 +815,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0b/ed/5ff678a774b721f054c095f04d84fc536e7369ea4f4c9af3813a518d95b6/httptools-0.9.0-cp313-cp313-win_arm64.whl", hash = "sha256:bfdabac0c6d3d6a5be8c2a100a001c92c14a39bbafd5999545a675c493626e64", size = 88043, upload-time = "2026-10-09T19:55:13.046Z" }, ] -[[package]] -name = "httpx" -version = "0.28.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "anyio" }, - { name = "certifi" }, - { name = "httpcore" }, - { name = "idna" }, -] -sdist = { url = "https://files.pythonhosted.org/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://files.pythonhosted.org/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 = "httpx2" version = "2.13.1" @@ -1058,52 +1030,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/be/59/e26cb779be4c591d1a910f59d29aca9fba4de70349840a833beba2652371/multidict-6.9.1-py3-none-any.whl", hash = "sha256:7bf6478188f4e47bf5686e8a33da4ae28bf43b1b2528d9ee144d28492bfac60b", size = 19176, upload-time = "2026-09-21T17:59:03.501Z" }, ] -[[package]] -name = "networkx" -version = "3.4.2" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.11' and sys_platform == 'darwin'", - "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'", - "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux')", -] -sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" }, -] - -[[package]] -name = "networkx" -version = "3.6.1" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version == '3.11.*' and sys_platform == 'darwin'", - "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux'", - "python_full_version == '3.11.*' and sys_platform == 'win32'", - "python_full_version == '3.11.*' and sys_platform == 'emscripten'", - "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", -] -sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, -] - -[[package]] -name = "networkx" -version = "3.7" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.12' and sys_platform == 'darwin'", - "python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'", - "python_full_version >= '3.12' and sys_platform == 'win32'", - "python_full_version >= '3.12' and sys_platform == 'emscripten'", - "(python_full_version >= '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'linux' and sys_platform != 'win32')", -] -sdist = { url = "https://files.pythonhosted.org/packages/dc/76/3af777226b63a5e64a6b36b1ec5855c14e2b94a37096d4760e595fc43511/networkx-3.7.tar.gz", hash = "sha256:fd77a511bd90f39f3d016351345b52cf5319b813bdca01de3f755d3cca62e96a", size = 1866482, upload-time = "2026-09-21T16:45:16.974Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/cd/fe58041e9011f307c490e3e17dd48cc516448f7c698a3f2d9d9d65d7e6a8/networkx-3.7-py3-none-any.whl", hash = "sha256:e3fd2c13a7814cee3746340d8d7f8598a67f16a58bf47fb7f8793fab6efca1b0", size = 2142205, upload-time = "2026-09-21T16:45:14.609Z" }, -] - [[package]] name = "numpy" version = "2.2.6" @@ -1249,7 +1175,6 @@ source = { editable = "." } dependencies = [ { name = "fastapi" }, { name = "paddleocr" }, - { name = "paddlepaddle" }, { name = "pillow" }, { name = "python-multipart" }, { name = "pyyaml" }, @@ -1266,7 +1191,6 @@ dev = [ requires-dist = [ { name = "fastapi", specifier = ">=0.115,<1" }, { name = "paddleocr", specifier = ">=3.2,<4" }, - { name = "paddlepaddle", specifier = ">=3.2,<3.3" }, { name = "pillow", specifier = ">=10.0,<12" }, { name = "python-multipart", specifier = ">=0.0.9,<1" }, { name = "pyyaml", specifier = ">=6.0,<7" }, @@ -1309,19 +1233,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/1e/41/f7dcf80b81ee8e71c1a2b59f14208bc723edbd89ed027a73b175abf6348e/opentelemetry_api-1.45.1-py3-none-any.whl", hash = "sha256:b31553efa588ae44bc306f863c785c5333a9ecc091248c6ee68b4b6c87fdedfb", size = 60256, upload-time = "2026-10-06T17:32:33.506Z" }, ] -[[package]] -name = "opt-einsum" -version = "3.3.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/7d/bf/9257e53a0e7715bc1127e15063e831f076723c6cd60985333a1c18878fb8/opt_einsum-3.3.0.tar.gz", hash = "sha256:59f6475f77bbc37dcf7cd748519c0ec60722e91e63ca114e68821c0c54a46549", size = 73951, upload-time = "2020-07-19T22:40:32.141Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bc/19/404708a7e54ad2798907210462fd950c3442ea51acc8790f3da48d2bee8b/opt_einsum-3.3.0-py3-none-any.whl", hash = "sha256:2455e59e3947d3c275477df7f5205b30635e266fe6dc300e3d9f9646bfcea147", size = 65486, upload-time = "2020-07-19T22:40:30.301Z" }, -] - [[package]] name = "packaging" version = "26.3" @@ -1347,42 +1258,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d2/79/2ade66cf72074a3d2a013e2ba1f256d6116fec797b908fc1b4f9c320d8c4/paddleocr-3.7.0-py3-none-any.whl", hash = "sha256:c0f0a81ad4112727f30c6fcf986ac0ef6a120d31ee0991a01fae0357ee32d338", size = 146750, upload-time = "2026-06-11T12:09:51.204Z" }, ] -[[package]] -name = "paddlepaddle" -version = "3.2.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "httpx" }, - { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, - { name = "networkx", version = "3.7", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "opt-einsum" }, - { name = "pillow" }, - { name = "protobuf" }, - { name = "safetensors" }, - { name = "typing-extensions" }, -] -wheels = [ - { url = "https://files.pythonhosted.org/packages/16/ef/4977a2cb4e743e340f272ee436d92f741bc2d29c5b17258b865c5792afbb/paddlepaddle-3.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c1d5c5b8d15faacbe75448755a1553e289bcb77992edc42f451821ec06f9306c", size = 99457690, upload-time = "2025-11-14T13:22:50.893Z" }, - { url = "https://files.pythonhosted.org/packages/e0/05/0885e52c50b089e0e27e5b1a4a09cb1c97fded5b7f3d0e9b99b3b7972ee3/paddlepaddle-3.2.2-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:dcb41609f6f4bdba0404354d5f21b446467b615f5a5bf67a7c75ebc20b42c6a9", size = 189256236, upload-time = "2025-11-19T11:49:29.657Z" }, - { url = "https://files.pythonhosted.org/packages/91/79/32a339237300b1576bd1dc07b82dcbfbc7c0395f7069483f2483ec02d688/paddlepaddle-3.2.2-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:ad47135f9861bd70de5af4e7d513ca099fa7abd5fbc5461c45f860d47b5098a2", size = 88170123, upload-time = "2025-11-19T11:15:04.118Z" }, - { url = "https://files.pythonhosted.org/packages/81/48/fa3b67cb7b680ab67411dd1b104f3ed62cd73eeaa16670dba8986b23dad7/paddlepaddle-3.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:a48825235d19f2706089c1bfaf171fe4188e55319ce0f5285aa50f73dc559ab0", size = 101714320, upload-time = "2025-11-14T13:10:44.937Z" }, - { url = "https://files.pythonhosted.org/packages/05/3f/4d73d4435d8c594353fe04f677b7d76db364d740b82b456502da864d3023/paddlepaddle-3.2.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:91bae3026cb4097fc95c30be5d6470363dc3a1e8af77773c75a7d5d36354ad2d", size = 99460791, upload-time = "2025-11-14T13:25:09.701Z" }, - { url = "https://files.pythonhosted.org/packages/34/e7/fbfbdc55e025fd8df34849980af427c2f07e11265a19d7cfa01cb5f3fec5/paddlepaddle-3.2.2-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:c30489fe7f4533252d54655dbe02c136818df8ec6ab241306691ed6462de0eba", size = 189257782, upload-time = "2025-11-19T11:50:33.082Z" }, - { url = "https://files.pythonhosted.org/packages/14/a2/9e65ff57fc83cdc3eb0fe48f654d60a1fac7e72e5dc4177c1bb1804f58b9/paddlepaddle-3.2.2-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:0a87209df4069129c817875e5caadc1a1d87b8dfd291e6da8b5141e6ac4e20b6", size = 88170289, upload-time = "2025-11-19T11:16:48.847Z" }, - { url = "https://files.pythonhosted.org/packages/29/e8/dfbc67e971765c82b9e808296ba700dd2bbecc5e29d5e07e655fa23dab99/paddlepaddle-3.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:7ee7a0783de00a50f89a959aabfa83dd969ccce57e2c53f92f4d592d1df1aceb", size = 101715828, upload-time = "2025-11-14T13:12:58.853Z" }, - { url = "https://files.pythonhosted.org/packages/2a/3a/84204351f84bc837c6bc95592f3b4bf71487f4a99e72a5bc7027d2fe1ba8/paddlepaddle-3.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c62dab0d4df6de2978960832f0015a145c23cd379418d932ddd8f546629d1fe4", size = 99510113, upload-time = "2025-11-14T13:27:27.71Z" }, - { url = "https://files.pythonhosted.org/packages/7f/2d/f46a5f5464c7d31e9e067e173a449cff8c0d96f7f7282b9454650901fe3c/paddlepaddle-3.2.2-cp312-cp312-manylinux1_x86_64.whl", hash = "sha256:f6b3b73d47acc82cf545896e6e5c31b55a7f9a26dc0acb28abcc24069d9396dd", size = 189280697, upload-time = "2025-11-19T11:52:09.004Z" }, - { url = "https://files.pythonhosted.org/packages/e8/e1/2f410bed4271df98ab2a720caa59ff408f8e8ca5daa6089b78b4326b8d10/paddlepaddle-3.2.2-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:a59d9020ba160fa7f5aefcb30e4a6329390a635d1a0b511f6458139376c03f99", size = 88147129, upload-time = "2025-11-19T11:18:34.59Z" }, - { url = "https://files.pythonhosted.org/packages/ec/ff/ed7598e52e3ad2ebd8202076b4d2412e5e605a15b9ba03ab0cec6edf824e/paddlepaddle-3.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:883954ea41fb1cccd022ac351f164b7a9f5cbc94be24223ce8bd981ddee93eb3", size = 101725915, upload-time = "2025-11-14T13:15:13.643Z" }, - { url = "https://files.pythonhosted.org/packages/ee/14/af48dcf222555f83480c8d50662944c34952b601b1f2b2264f5afe7e073a/paddlepaddle-3.2.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f7e9bc0469d13d99925cd766c4a6ceeb5ab6043b790dd415ce076fbbebb39074", size = 99507300, upload-time = "2025-11-14T13:29:45.539Z" }, - { url = "https://files.pythonhosted.org/packages/ae/95/909e963330997da9da7e3f51337c19a022d8ba2b7863aaca5694aeca26cf/paddlepaddle-3.2.2-cp313-cp313-manylinux1_x86_64.whl", hash = "sha256:c4f485596a686ea72ab0ddffc9e41178f456314a99d4538f5d181a0156a927fa", size = 189281004, upload-time = "2025-11-19T11:53:41.89Z" }, - { url = "https://files.pythonhosted.org/packages/4a/76/74aed8ab5ac6961145bf3e0907a26ffccb69e35cafcd18e4046bb68565dd/paddlepaddle-3.2.2-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:b03569ba151ac50aa730955c65dfa571fe7ae71f94574c94e8bfe5e0913a7d9c", size = 88143036, upload-time = "2025-11-19T11:20:22.844Z" }, - { url = "https://files.pythonhosted.org/packages/e5/b8/8a9f7b673c6ac0f26d8eb49cf8e7689e2f3f5cadd2fc6569ee5b9a4da81d/paddlepaddle-3.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:a05d126c234d3985439cedf1f1005b109c3591ec2a0c5b59ca74a94b693eb283", size = 101726676, upload-time = "2025-11-14T13:17:22.507Z" }, -] - [[package]] name = "paddlex" version = "3.7.2" @@ -1715,21 +1590,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f5/cd/785c64ed382f3f04201870267b02783f63b4678c2acfddc177a3ebcc2727/propcache-0.5.4-py3-none-any.whl", hash = "sha256:62c60aec739ed00124573cce1178138fd690c7676352d67a37328c1cf51d7468", size = 16338, upload-time = "2026-09-16T00:17:13.106Z" }, ] -[[package]] -name = "protobuf" -version = "7.36.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d9/89/5b8517baa72f84a67b8a307ba953c91057af618bf40bf676f3c03551f8f0/protobuf-7.36.2.tar.gz", hash = "sha256:497d0463ff3316681da6c0b9e8d06cb465d61abce00b613ab42226175644d1bb", size = 512737, upload-time = "2026-09-17T20:07:59.326Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/32/72/98342feb672507c8f3a69e34b4fa8961f608edba5c1a48a6f47156d92cb5/protobuf-7.36.2-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:cbc70b17ee27e28894c7fee8bb04be1abead49e936bc70eb60052531eee2079e", size = 456039, upload-time = "2026-09-17T20:07:51.542Z" }, - { url = "https://files.pythonhosted.org/packages/b6/ea/91fdf7c2b8bbd49cde056f00a9df6773532987e1c00fe2830b895af95c7e/protobuf-7.36.2-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:e11e1f0180583a2af89db6a2ecd9e8dc40aa6d2988ca175bfd0e6d12ea72d74e", size = 344219, upload-time = "2026-09-17T20:07:52.914Z" }, - { url = "https://files.pythonhosted.org/packages/17/ab/5fd5f8ece73fad885c5a09aa849b32d70472f954ba3a92d3bb5974ea953b/protobuf-7.36.2-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:f4fee11ec330d238b34a05c9b675f693c20415d1c5bd7d5320cc2f8a798eb9cf", size = 357223, upload-time = "2026-09-17T20:07:53.985Z" }, - { url = "https://files.pythonhosted.org/packages/db/f3/3996583dd2906297a637af12114deddf7658af6e683fedb83be061983fb5/protobuf-7.36.2-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:89f23aa53c24553a2416fd4fd1ec06f74fa42b14b546d8883128813f775bbfd2", size = 343223, upload-time = "2026-09-17T20:07:54.931Z" }, - { url = "https://files.pythonhosted.org/packages/fc/1b/dcc64f358fcb51811b58ae40b3d28f820725f116d86487cc20bd4b130701/protobuf-7.36.2-cp310-abi3-win32.whl", hash = "sha256:912c1221170e16c08d1f086762f563dd61ff83c18b5fa6652952dfaded66f728", size = 442998, upload-time = "2026-09-17T20:07:55.826Z" }, - { url = "https://files.pythonhosted.org/packages/8a/55/b77bda4e5e5f5971fb51b07663694690e9afdb9402136c16a522bd621cad/protobuf-7.36.2-cp310-abi3-win_amd64.whl", hash = "sha256:a300819d441e078a5608c0d3c709796bb548136058fda017ae51d425b44fd353", size = 456514, upload-time = "2026-09-17T20:07:57.188Z" }, - { url = "https://files.pythonhosted.org/packages/e4/04/d52c7016b04b6c5108f26691f9d33ec82a9b65d041f1a9c771137693d618/protobuf-7.36.2-py3-none-any.whl", hash = "sha256:bdb3a345d48db958e6ce1f18e508beb0cc981d64f24088427549c866cd039f1e", size = 179806, upload-time = "2026-09-17T20:07:58.211Z" }, -] - [[package]] name = "psutil" version = "7.2.2" @@ -2227,30 +2087,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b8/0c/51f6841f1d84f404f92463fc2b1ba0da357ca1e3db6b7fbda26956c3b82a/ruamel_yaml-0.19.1-py3-none-any.whl", hash = "sha256:27592957fedf6e0b62f281e96effd28043345e0e66001f97683aa9a40c667c93", size = 118102, upload-time = "2026-01-02T16:50:29.201Z" }, ] -[[package]] -name = "safetensors" -version = "0.8.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", hash = "sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d", size = 325846, upload-time = "2026-06-09T07:52:25.563Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/39/a0/f718cda65b05407d228f97602cf60dca269c979867aa5beb25410de26cd3/safetensors-0.8.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0", size = 473568, upload-time = "2026-06-09T07:52:18.829Z" }, - { url = "https://files.pythonhosted.org/packages/f5/b1/fa7c600e7dceae12e9606c7578cbc9ff1e1ed55844883ee5c92205e86226/safetensors-0.8.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25", size = 484562, upload-time = "2026-06-09T07:52:17.518Z" }, - { url = "https://files.pythonhosted.org/packages/09/7d/65a7de0af421317bb36a067241e4235fff194eed60b961ed6d3f59a3fc60/safetensors-0.8.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235", size = 502844, upload-time = "2026-06-09T07:52:07.624Z" }, - { url = "https://files.pythonhosted.org/packages/91/4f/3175c9d75634e0e0dda0082794193521035edd7c70a6f212bf33ca06ddf4/safetensors-0.8.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0", size = 511823, upload-time = "2026-06-09T07:52:09.565Z" }, - { url = "https://files.pythonhosted.org/packages/20/87/846c289e7aa2299eff406335717cf43ce8777194ece8aad75772e0411615/safetensors-0.8.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98", size = 633461, upload-time = "2026-06-09T07:52:11.128Z" }, - { url = "https://files.pythonhosted.org/packages/76/22/8d64d9df2c45d5ded401df889d0ad90882804ca172d79ec4f0df8f727fe0/safetensors-0.8.0-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358", size = 545148, upload-time = "2026-06-09T07:52:13.603Z" }, - { url = "https://files.pythonhosted.org/packages/28/50/f203ff3a3ddfe19308efc83c5a3a29ed02bf786732ec35e68bf9162f3365/safetensors-0.8.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774", size = 516040, upload-time = "2026-06-09T07:52:16.29Z" }, - { url = "https://files.pythonhosted.org/packages/46/fb/cdaed17ceb2948784fd9c36b6fd3e951b608547cea81a48e8ee6f8cfdfcb/safetensors-0.8.0-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78", size = 513832, upload-time = "2026-06-09T07:52:12.37Z" }, - { url = "https://files.pythonhosted.org/packages/0d/49/1e15de264dcc3b77943d2d0c56a95809956883b1c2d6d585c792523f180b/safetensors-0.8.0-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca", size = 559930, upload-time = "2026-06-09T07:52:14.743Z" }, - { url = "https://files.pythonhosted.org/packages/2a/43/bf38443278eab4b1be1fce2931e2b012ad9cb7df52ada751d0aab8f7659a/safetensors-0.8.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4", size = 678670, upload-time = "2026-06-09T07:52:20.032Z" }, - { url = "https://files.pythonhosted.org/packages/72/e3/68cd3fa5b48488e84add63e04cb12f3bc28ae4638c06d4508c6e88823d0e/safetensors-0.8.0-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc", size = 786679, upload-time = "2026-06-09T07:52:21.322Z" }, - { url = "https://files.pythonhosted.org/packages/29/4b/1c19c509d56e01f4fbb3d0a2e597450f6cc04d1d56cf52defb0a62dfd715/safetensors-0.8.0-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d", size = 765683, upload-time = "2026-06-09T07:52:22.594Z" }, - { url = "https://files.pythonhosted.org/packages/27/43/41c1621732edd934d868a00d1b891584c892a7b62a9aab82ea5a0a5623ee/safetensors-0.8.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846", size = 722361, upload-time = "2026-06-09T07:52:23.924Z" }, - { url = "https://files.pythonhosted.org/packages/8e/3f/73ccf82579412b4a71c4ca673f10b5f1f888d7cf5af7fe24f27d30307be4/safetensors-0.8.0-cp310-abi3-win32.whl", hash = "sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d", size = 342401, upload-time = "2026-06-09T07:52:28.895Z" }, - { url = "https://files.pythonhosted.org/packages/1b/6d/3fba214c1e5e0f69991677ec3bc17023f0421776975e1de0c682dca475e2/safetensors-0.8.0-cp310-abi3-win_amd64.whl", hash = "sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f", size = 355540, upload-time = "2026-06-09T07:52:27.832Z" }, - { url = "https://files.pythonhosted.org/packages/8d/fc/7eedc3510d97878876e32774eebbeb61c43f148a96e915c84229a3e967aa/safetensors-0.8.0-cp310-abi3-win_arm64.whl", hash = "sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452", size = 340500, upload-time = "2026-06-09T07:52:26.745Z" }, -] - [[package]] name = "setuptools" version = "84.0.0"