mirror of
https://github.com/snapotter-hq/SnapOtter.git
synced 2026-08-03 07:46:42 +02:00
SnapOtterandGitHub
35e18d8b79
* fix(docker): pin CUDA base to 12.6 so the GPU image starts on R560+ drivers The amd64 base nvidia/cuda:12.9.2-cudnn-runtime bakes a cuda>=12.9 driver gate enforced by nvidia-container-toolkit at container start, so the image fails to launch on common production drivers (e.g. 570.x / CUDA 12.8). The AI bundles are all cu126 wheels and the image installs libcublas-12-6, so 12.9 was misaligned with the workload. Pin to nvidia/cuda:12.6.3-cudnn-runtime-ubuntu24.04 to match the wheels and lower the driver floor to R560+. * fix(ai): broaden OOM detection so the rembg lighter-model fallback fires onnxruntime/CUDA allocation failures surface as 'Failed to allocate memory for requested buffer', CUBLAS_STATUS_ALLOC_FAILED, or bad_alloc, not just 'out of memory'. The background-removal and transparency-fixer fallback-to-lighter-model paths only matched the literal 'out of memory', so the fallback was dead code and transparency-fixer (default birefnet-hr-matting) always failed with an allocation error. Add isMemoryAllocError() and use it in both checks. * fix(ai): use bundled PaddleOCR models so OCR runs offline ocr.py passed no model dirs to PaddleOCR, so PaddleX resolved models from ~/.paddlex and downloaded them from HuggingFace at runtime (slow first use, broken air-gapped), ignoring the models the OCR bundle ships in MODELS_PATH; it also pulled doc-orientation/unwarping models that are not bundled. Pin detection, recognition and textline models to the bundled dirs in MODELS_PATH (per language) and disable use_doc_orientation_classify / use_doc_unwarping, with per-component fallback when a model is absent. Verified: OCR runs with zero HuggingFace requests. * fix(docker): add CAP_KILL so container shutdown is graceful cap_drop: ALL without re-adding KILL meant tini (PID 1, root) could not forward SIGTERM to the gosu-dropped snapotter process (root minus CAP_KILL cannot signal a different UID). docker stop logged '[FATAL tini] forwarding signal: Operation not permitted', never delivered the signal, and fell back to SIGKILL after the 10s timeout. Add KILL to cap_add in both compose files. Verified: docker stop completes in 0s with SIGTERM delivered (exit 143) and no FATAL tini. * fix(ai): serialize bundle installs against AI jobs to prevent sidecar segfault A feature bundle install rewrites the shared Python venv (pip + copytree of site-packages/*.so) as a background subprocess, with no coordination against AI tool jobs that dlopen native libs (torch / onnxruntime CUDA) from the same venv; a job loading a shared object while it is overwritten segfaults the sidecar. Add a process-wide async mutex (venv-lock.ts): bridge.run() acquires it before every AI script and the install route holds it across the installer subprocess. Both run in the same Node process so a module-level lock suffices. Verified: concurrent install + AI job produces zero segfaults and the job serializes behind the install. * fix(ai): make the venv lock read/write so concurrent AI jobs are not serialized The first cut used an exclusive mutex, which (a) deferred the dispatcher spawn by a microtask and broke unit tests that synchronously drive the mocked spawn, and (b) serialized AI jobs against each other, removing the dispatcher's by-id request multiplexing. Make it a writer-preferring read/write lock: AI jobs are shared readers (with a synchronous fast path so spawn still happens in-tick) and a bundle install is the exclusive writer. Verified: all 764 AI unit tests pass. * fix(ai): degrade OCR to Tesseract on CPU-only hosts instead of segfaulting The amd64 AI bundle ships paddlepaddle-gpu, whose native libs dlopen libcuda.so.1 at import and segfault on a host without a GPU (libcuda is the driver lib, injected only by nvidia-container-toolkit on GPU hosts). The segfault crashed the shared long-lived AI dispatcher and, after a few attempts, tripped the bridge crash-recovery permanent-disable, wedging all AI until a container restart. The standalone ocr tool defaults to quality=balanced (PaddleOCR), so it hit this on every CPU-only deployment; ocr-pdf already hardcoded Tesseract and was unaffected. ocr.py now gates the PaddleOCR tiers on gpu_available(): balanced/best transparently fall back to fast (Tesseract, CPU-capable) when no usable GPU is present, and run_paddleocr_v5/run_paddleocr_vl refuse before importing paddle so the GPU build is never dlopen'd on CPU. GPU hosts are unchanged. Verified on a CPU-only Windows/WSL2 box: ocr returns Tesseract text across repeated runs with the dispatcher staying healthy (no wedge).
45 lines
1.8 KiB
Python
45 lines
1.8 KiB
Python
"""OCR must degrade gracefully on CPU-only hosts.
|
|
|
|
The amd64 AI bundle ships paddlepaddle-gpu, whose native libraries dlopen
|
|
libcuda.so.1 at import time and segfault on a host without a GPU (libcuda is the
|
|
driver lib, injected only by nvidia-container-toolkit on GPU hosts). That segfault
|
|
crashes the shared long-lived AI dispatcher and wedges all AI. So on a CPU-only
|
|
host the PaddleOCR tiers (balanced/best) must transparently fall back to Tesseract
|
|
and must never reach the paddle import.
|
|
"""
|
|
import os
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
|
|
import ocr # noqa: E402
|
|
|
|
|
|
def test_effective_quality_downgrades_paddle_tiers_on_cpu(monkeypatch):
|
|
monkeypatch.setattr(ocr, "gpu_available", lambda: False)
|
|
assert ocr.effective_quality("balanced") == "fast"
|
|
assert ocr.effective_quality("best") == "fast"
|
|
assert ocr.effective_quality("fast") == "fast"
|
|
|
|
|
|
def test_effective_quality_preserves_paddle_tiers_on_gpu(monkeypatch):
|
|
monkeypatch.setattr(ocr, "gpu_available", lambda: True)
|
|
assert ocr.effective_quality("balanced") == "balanced"
|
|
assert ocr.effective_quality("best") == "best"
|
|
assert ocr.effective_quality("fast") == "fast"
|
|
|
|
|
|
def test_run_paddleocr_v5_refuses_on_cpu_before_import(monkeypatch):
|
|
# Must raise a GPU-specific error (the guard), NOT attempt the paddle import
|
|
# that would segfault on a CPU-only host.
|
|
monkeypatch.setattr(ocr, "gpu_available", lambda: False)
|
|
with pytest.raises(ImportError, match="GPU"):
|
|
ocr.run_paddleocr_v5("/nonexistent.png", "en")
|
|
|
|
|
|
def test_run_paddleocr_vl_refuses_on_cpu_before_import(monkeypatch):
|
|
monkeypatch.setattr(ocr, "gpu_available", lambda: False)
|
|
with pytest.raises(ImportError, match="GPU"):
|
|
ocr.run_paddleocr_vl("/nonexistent.png")
|