vramd 0.3.2__tar.gz → 0.3.4__tar.gz

{vramd-0.3.2/src/vramd.egg-info → vramd-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vramd
-Version: 0.3.2
+Version: 0.3.4
 Summary: VRAM admission control for generative inference on consumer GPUs
 Author: Maikeu Locatelli
 License-Expression: MIT

{vramd-0.3.2 → vramd-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vramd"
-version = "0.3.2"
+version = "0.3.4"
 description = "VRAM admission control for generative inference on consumer GPUs"
 readme = "README.md"
 authors = [{ name = "Maikeu Locatelli" }]

{vramd-0.3.2 → vramd-0.3.4}/src/vramd/__init__.py

@@ -19,5 +19,5 @@ adivinhar: o número que o admit usa vem do driver, não de uma estimativa.
 
 from __future__ import annotations
 
-__version__ = "0.3.1"
+__version__ = "0.3.4"
 __all__ = ["__version__"]

{vramd-0.3.2 → vramd-0.3.4}/src/vramd/backend_manager.py

@@ -692,7 +692,16 @@ class BackendManager:
         measured = self._measured_parts_mib(desc, quant_mode=quant_mode)
         if measured is not None:
             weights_measured, activation_measured = measured
-            if memory_efficient and not group_offload:
+            measured_mem_eff = bool(
+                ((getattr(desc, "peak_profile", None) or {}).get("load_kwargs") or {}).get("memory_efficient")
+            )
+            # O desconto 0.65 só vale quando a medição foi feita SEM mem-eff
+            # (realidade FP16) e o request agora pede o modo económico. Se a
+            # calibração já foi medida COM memory_efficient (caso paint3d 6g:
+            # load_kwargs.memory_efficient=true), a activação medida JÁ reflete
+            # o modo — descontar de novo subdimensionava o admit em ~1 GiB e
+            # admitia jobs que estouravam (OOM-spin do worker).
+            if memory_efficient and not group_offload and not measured_mem_eff:
                 activation_measured = max(512, int(activation_measured * _MEMORY_EFFICIENT_ACTIVATION_FACTOR))
             return weights_measured, activation_measured
 
@@ -753,6 +762,14 @@ class BackendManager:
         footprint_key: str | None = None,
     ) -> int:
         """Pico = pesos(quant) + activação de inferência + safety."""
+        with contextlib.suppress(KeyError):
+            vram = getattr(self._registry.descriptor(name), "vram", None) or {}
+            admit_peak = vram.get("admit_peak_mib")
+            if admit_peak:
+                # Recomendação do calibrador: pico REAL medido (pesos +
+                # activação + safety). Vence a soma analítica — que pode
+                # descontar mem-eff duas vezes e admitir jobs condenados.
+                return int(admit_peak)
         weights, activation = self.footprint_parts_mib(
             name,
             quant_mode=quant_mode,

{vramd-0.3.2 → vramd-0.3.4}/src/vramd/dispatcher.py

@@ -38,7 +38,13 @@ def _is_worker_dead(result: dict[str, Any]) -> bool:
     if result.get("error_code") == P.ERR_WORKER_DEAD:
         return True
     err = str(result.get("error") or "").lower()
-    return "não está vivo" in err or "nao esta vivo" in err or "worker fechou stdout" in err or "eof no load" in err
+    return (
+        "não está vivo" in err
+        or "nao esta vivo" in err
+        or "worker fechou stdout" in err
+        or "eof no load" in err
+        or "worker wedged" in err
+    )
 
 
 def _vram_retry_worthwhile(result: dict[str, Any], total_mib: int | None) -> bool:

{vramd-0.3.2 → vramd-0.3.4}/src/vramd/server.py

@@ -420,6 +420,13 @@ class VramdServer:
             if "cancel" in err_txt:
                 out.setdefault("error_code", P.ERR_CANCELLED)
                 out.setdefault("hint", "Job cancelado (queued ou durante generate).")
+            elif "oom" in err_txt:
+                out.setdefault("error_code", P.ERR_GENERATE_FAILED)
+                out.setdefault(
+                    "hint",
+                    "OOM/spin no worker — vê o log vramd-worker-<backend>.log; "
+                    "considera reduzir tamanho/qualidade do pedido.",
+                )
             elif "timeout" in err_txt:
                 out.setdefault("error_code", P.ERR_TIMEOUT)
                 out.setdefault("hint", "Aumenta timeout do cliente ou inspecciona vramd queue.")

{vramd-0.3.2 → vramd-0.3.4}/src/vramd/subprocess_pool.py

@@ -53,7 +53,18 @@ _logger = Logger()
 
 # Idle entre eventos de progresso (reset a cada progress). Hunyuan pode
 # demorar muitos minutos no total — NÃO é wall-clock do generate inteiro.
-DEFAULT_EVENT_TIMEOUT_SEC = 600.0  # 10 min sem progress → force abort
+DEFAULT_EVENT_TIMEOUT_SEC = 600.0
+
+# Watcher de OOM-spin: o allocator CUDA em retry infinito não emite eventos —
+# cresce no stderr do worker (~0.7 linhas/s de "expandable_segments: memory
+# mapping failed"). 8 linhas + 30s sem progress denunciam o wedge em ~40s
+# em vez dos 600s do idle-timeout (que depois virava "timeout do cliente").
+_OOM_SPIN_PATTERNS = ("expandable_segments: memory mapping failed", "CUDA out of memory")
+_OOM_SPIN_MIN_LINES = 8
+_OOM_SPIN_QUIET_SEC = 30.0
+# Reciclagem do worker persistente: fragmentação/estado CUDA acumulam entre
+# jobs — após N jobs o worker morre e o próximo load re-spawna fresco.
+DEFAULT_WORKER_MAX_JOBS = 12  # 10 min sem progress → force abort
 # Após progress pct≥1.0 / msg "done": o adapter já acabou o GPU work — só
 # falta ``EVENT_DONE``. NÃO renovar o idle de 600s (era o hang de ~7-10 min
 # com UI a 100% done e ``completed=0``). Grace curto para scrub+emit.
@@ -174,6 +185,7 @@ class _WorkerState:
     # File handle do stderr do worker (aberto em _spawn, fechado em
     # shutdown/_force_abort — antes ficava órfão e só era recuperado por GC).
     log_fh: Any = None
+    jobs_served: int = 0
 
 
 class SubprocessWorkerError(Exception):
@@ -199,6 +211,7 @@ class SubprocessWorkerPool:
         post_done_timeout_sec: float | None = None,
         ping_timeout_sec: float = DEFAULT_PING_TIMEOUT_SEC,
         python_override: dict[str, str] | None = None,
+        worker_max_jobs: int | None = None,
     ) -> None:
         self._spawn_fn = spawn_fn
         self._log_path_fn = log_path_fn
@@ -218,6 +231,11 @@ class SubprocessWorkerPool:
             if post_done_timeout_sec is not None
             else _env_float("VRAMD_POST_DONE_TIMEOUT_SEC", DEFAULT_POST_DONE_TIMEOUT_SEC)
         )
+        self._worker_max_jobs = int(
+            worker_max_jobs
+            if worker_max_jobs is not None
+            else _env_float("VRAMD_WORKER_MAX_JOBS", DEFAULT_WORKER_MAX_JOBS)
+        )
         self._ping_timeout = float(ping_timeout_sec)
         # Override do interpretador python por backend (testes / ambientes exóticos).
         self._python_override: dict[str, str] = dict(python_override or {})
@@ -369,70 +387,99 @@ class SubprocessWorkerPool:
             # estado interno (state["abort"] + emissor de progress).
             serializable_request = {k: v for k, v in request.items() if not k.startswith("_") and not callable(v)}
             self._safe_send(backend, state, CMD_GENERATE, request=serializable_request)
+            # Idle timeout por backend (RuntimeSpec.event_timeout_sec) — senão default.
+            rt = self._runtimes.get(backend)
+            ev_timeout = float(getattr(rt, "event_timeout_sec", None) or 0.0) or self._event_timeout
             # Idle timeout: renovado a cada progress (generate longo OK).
-            idle_deadline = time.monotonic() + self._event_timeout
+            idle_deadline = time.monotonic() + ev_timeout
             abort_sent = False
             abort_deadline: float | None = None
-            while True:
-                now = time.monotonic()
-                if now >= idle_deadline:
-                    self._force_abort(state, backend)
-                    raise SubprocessWorkerError(
-                        f"{backend}: timeout idle ({self._event_timeout:.0f}s sem progress) no generate"
-                    )
-                # Poll cooperativo: se o caller pediu abort, enviar ao worker.
-                if not abort_sent and should_abort and should_abort():
-                    with contextlib.suppress(OSError, ValueError):
-                        # Worker pode ter morrido entretanto — o idle/poll check
-                        # a seguir apanha-o; não deixar BrokenPipe saltar daqui.
-                        from vramd.worker.protocol import send_cmd
-
-                        send_cmd(state.proc.stdin, CMD_ABORT)  # type: ignore[union-attr]
-                    abort_sent = True
-                    abort_deadline = now + self._abort_timeout
+            oom_lines = 0
+            oom_offset = self._worker_log_size(state)
+            last_progress = time.monotonic()
+            try:
+                while True:
+                    now = time.monotonic()
+                    if now >= idle_deadline:
+                        self._force_abort(state, backend)
+                        raise SubprocessWorkerError(f"{backend}: worker wedged — idle {ev_timeout:.0f}s sem progress")
+                    # Poll cooperativo: se o caller pediu abort, enviar ao worker.
+                    if not abort_sent and should_abort and should_abort():
+                        with contextlib.suppress(OSError, ValueError):
+                            # Worker pode ter morrido entretanto — o idle/poll
+                            # check a seguir apanha-o; não deixar BrokenPipe
+                            # saltar daqui.
+                            from vramd.worker.protocol import send_cmd
+
+                            send_cmd(state.proc.stdin, CMD_ABORT)  # type: ignore[union-attr]
+                        abort_sent = True
+                        abort_deadline = now + self._abort_timeout
+                        _logger.info(
+                            f"[vramd] worker {backend}: abort pedido — SIGTERM se sem done"
+                            f" em {self._abort_timeout:.0f}s"
+                        )
+                    # Escalação: abort cooperativo ignorado (text3d mid image_to_3d).
+                    if abort_sent and abort_deadline is not None and now >= abort_deadline:
+                        self._force_abort(state, backend)
+                        raise SubprocessWorkerError(
+                            f"{backend}: abort timeout ({self._abort_timeout:.0f}s) — worker forçado (SIGTERM)"
+                        )
+                    wait = min(idle_deadline - now, 1.0)
+                    if abort_deadline is not None:
+                        wait = min(wait, max(0.05, abort_deadline - now))
+                    event = self._read_event_with_timeout(state, timeout=wait)
+                    if event is None:
+                        # Silêncio ≠ morte: só falha se o processo já saiu.
+                        if state.proc is None or state.proc.poll() is not None:
+                            state.loaded = False
+                            raise SubprocessWorkerError(f"{backend}: worker fechou stdout mid-generate")
+                        # Watcher de OOM-spin: o allocator em retry não emite
+                        # eventos — as linhas de OOM crescem no stderr.
+                        n, oom_offset = self._scan_worker_oom(state, oom_offset)
+                        oom_lines += n
+                        if oom_lines >= _OOM_SPIN_MIN_LINES and (now - last_progress) >= _OOM_SPIN_QUIET_SEC:
+                            self._force_abort(state, backend)
+                            raise SubprocessWorkerError(
+                                f"{backend}: worker wedged — OOM-spin ({oom_lines} allocs, "
+                                f"{now - last_progress:.0f}s sem progress)"
+                            )
+                        continue
+                    ev = event["event"]
+                    if ev == "progress":
+                        last_progress = time.monotonic()
+                        pct, msg = event.get("pct"), event.get("msg")
+                        # Progress terminal NÃO renova os 600s — senão um DONE
+                        # perdido/atrasado segura inflight ~10 min com UI a 100%.
+                        if _progress_is_terminal(pct, msg):
+                            idle_deadline = time.monotonic() + self._post_done_timeout
+                        else:
+                            idle_deadline = time.monotonic() + ev_timeout
+                        if on_progress:
+                            with contextlib.suppress(Exception):
+                                on_progress(pct, msg)
+                        continue
+                    if ev == "vram_budget":
+                        state.vram_mib = event.get("vram_mib", state.vram_mib)
+                        continue
+                    if ev == EVENT_DONE:
+                        result = event.get("result", {})
+                        return result
+                    if ev == EVENT_ERROR:
+                        raise SubprocessWorkerError(
+                            f"{backend}: generate erro — {event.get('error')} ({event.get('error_code')})"
+                        )
+                    # Evento inesperado (pong, ready, unloaded): ignorar.
+            finally:
+                # Reciclagem: worker persistente acumula fragmentação/estado
+                # CUDA entre jobs (OOM residual, alocador partido) — após N
+                # jobs morre e o próximo load re-spawna fresco.
+                state.jobs_served += 1
+                if state.jobs_served >= self._worker_max_jobs and state.proc is not None and state.proc.poll() is None:
                     _logger.info(
-                        f"[vramd] worker {backend}: abort pedido — SIGTERM se sem done em {self._abort_timeout:.0f}s"
+                        f"[vramd] worker {backend}: {state.jobs_served} jobs servidos — a reciclar "
+                        f"(próximo load re-spawna)"
                     )
-                # Escalação: abort cooperativo ignorado (text3d mid image_to_3d).
-                if abort_sent and abort_deadline is not None and now >= abort_deadline:
                     self._force_abort(state, backend)
-                    raise SubprocessWorkerError(
-                        f"{backend}: abort timeout ({self._abort_timeout:.0f}s) — worker forçado (SIGTERM)"
-                    )
-                wait = min(idle_deadline - now, 1.0)
-                if abort_deadline is not None:
-                    wait = min(wait, max(0.05, abort_deadline - now))
-                event = self._read_event_with_timeout(state, timeout=wait)
-                if event is None:
-                    # Silêncio ≠ morte: só falha se o processo já saiu.
-                    if state.proc is None or state.proc.poll() is not None:
-                        state.loaded = False
-                        raise SubprocessWorkerError(f"{backend}: worker fechou stdout mid-generate")
-                    continue
-                ev = event["event"]
-                if ev == "progress":
-                    pct, msg = event.get("pct"), event.get("msg")
-                    # Progress terminal NÃO renova os 600s — senão um DONE
-                    # perdido/atrasado segura inflight ~10 min com UI a 100%.
-                    if _progress_is_terminal(pct, msg):
-                        idle_deadline = time.monotonic() + self._post_done_timeout
-                    else:
-                        idle_deadline = time.monotonic() + self._event_timeout
-                    if on_progress:
-                        with contextlib.suppress(Exception):
-                            on_progress(pct, msg)
-                    continue
-                if ev == "vram_budget":
-                    state.vram_mib = event.get("vram_mib", state.vram_mib)
-                    continue
-                if ev == EVENT_DONE:
-                    result = event.get("result", {})
-                    return result
-                if ev == EVENT_ERROR:
-                    raise SubprocessWorkerError(
-                        f"{backend}: generate erro — {event.get('error')} ({event.get('error_code')})"
-                    )
-                # Evento inesperado (pong, ready, unloaded): ignorar.
 
     def unload(self, backend: str) -> bool:
         """Manda o worker descarregar o modelo (worker persiste vivo)."""
@@ -730,6 +777,36 @@ class SubprocessWorkerPool:
             _logger.info(f"[vramd] worker {state.backend}: evento inesperado {ev} (à espera de {expected})")
         return None
 
+    def _worker_log_size(self, state: _WorkerState) -> int:
+        """Tamanho actual do stderr do worker (0 se ainda não existe)."""
+        if state.log_path is None:
+            return 0
+        try:
+            return state.log_path.stat().st_size
+        except OSError:
+            return 0
+
+    def _scan_worker_oom(self, state: _WorkerState, offset: int) -> tuple[int, int]:
+        """Linhas OOM novas no stderr do worker desde ``offset``.
+
+        Returns:
+            ``(contagem de padrões OOM no trecho novo, novo offset)``.
+        """
+        path = state.log_path
+        if path is None:
+            return 0, offset
+        try:
+            size = path.stat().st_size
+            if size <= offset:
+                return 0, offset
+            with open(path, "rb") as fh:
+                fh.seek(offset)
+                chunk = fh.read(size - offset)
+        except OSError:
+            return 0, offset
+        text = chunk.decode("utf-8", errors="ignore")
+        return sum(text.count(pat) for pat in _OOM_SPIN_PATTERNS), size
+
     def _force_abort(self, state: _WorkerState, backend: str) -> None:
         """Abort cooperativo já falhou: SIGTERM e re-spawn limpo."""
         _logger.warn(f"[vramd] worker {backend}: abort forçado (SIGTERM)")

{vramd-0.3.2 → vramd-0.3.4/src/vramd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vramd
-Version: 0.3.2
+Version: 0.3.4
 Summary: VRAM admission control for generative inference on consumer GPUs
 Author: Maikeu Locatelli
 License-Expression: MIT

{vramd-0.3.2 → vramd-0.3.4}/src/vramd.egg-info/SOURCES.txt

@@ -87,6 +87,7 @@ tests/test_subprocess_pool.py
 tests/test_toolchain.py
 tests/test_top.py
 tests/test_unload_frees_vram.py
+tests/test_version.py
 tests/test_vram_admit.py
 tests/test_vram_planner.py
 tests/test_vramd_coverage_100.py

{vramd-0.3.2 → vramd-0.3.4}/tests/test_backend_manager.py

@@ -273,6 +273,57 @@ class TestRefCounting:
         assert eff == inference_headroom_mib(650)
 
 
+class TestMeasuredFootprintMemEffDiscount:
+    """Regressão 0.3.4: o 0.65 NÃO pode descontar uma activação medida em mem-eff.
+
+    A calibração da 6 GB foi feita COM memory_efficient (load_kwargs no
+    peak_profile) — a activação medida já reflete o modo. Descontar de novo
+    subdimensionava o admit em ~1 GiB e admitia jobs condenados ao OOM-spin.
+    """
+
+    @staticmethod
+    def _mgr(desc: BackendDescriptor) -> BackendManager:
+        registry = Registry(descriptors={"paint": desc})
+        registry._adapter_instances["paint"] = MockAdapter(name="paint")
+        return BackendManager(registry, query_free_mib=lambda: 99999, clear_vram=lambda: None)
+
+    @staticmethod
+    def _desc(mem_eff_measured: bool, *, admit_peak: int | None = None) -> BackendDescriptor:
+        vram: dict = {"weights_gib": 1.7, "activation_gib": 3.9, "context_gib": 0.0}
+        if admit_peak:
+            vram["admit_peak_mib"] = admit_peak
+        return BackendDescriptor(
+            name="paint",
+            adapter="mock",
+            vram_mib=6000,
+            priority=40,
+            vram=vram,
+            peak_profile={"quant_mode": "sdnq-fp8", "load_kwargs": {"memory_efficient": mem_eff_measured}},
+        )
+
+    def test_measured_mem_eff_activation_not_discounted_twice(self) -> None:
+        mgr = self._mgr(self._desc(mem_eff_measured=True))
+        _w, activation = mgr.footprint_parts_mib("paint", quant_mode="sdnq-fp8", memory_efficient=True)
+        assert activation == int(3.9 * 1024)  # intacta — já foi medida em mem-eff
+        assert activation > int(3.9 * 1024 * 0.65) + 100  # sem duplo desconto
+
+    def test_measured_fp16_activation_gets_mem_eff_discount(self) -> None:
+        mgr = self._mgr(self._desc(mem_eff_measured=False))
+        _w, activation = mgr.footprint_parts_mib("paint", quant_mode="sdnq-fp8", memory_efficient=True)
+        assert activation == max(512, int(int(3.9 * 1024) * 0.65))
+
+    def test_admit_peak_mib_wins_over_analytic_sum(self) -> None:
+        mgr = self._mgr(self._desc(mem_eff_measured=True, admit_peak=6144))
+        assert mgr.peak_vram_mib("paint", quant_mode="sdnq-fp8", memory_efficient=True) == 6144
+
+    def test_without_admit_peak_uses_analytic_sum(self) -> None:
+        from vramd.vram_planner import peak_vram_mib as compute_peak_mib
+
+        mgr = self._mgr(self._desc(mem_eff_measured=True))
+        w, a = mgr.footprint_parts_mib("paint", quant_mode="sdnq-fp8", memory_efficient=True)
+        assert mgr.peak_vram_mib("paint", quant_mode="sdnq-fp8", memory_efficient=True) == compute_peak_mib(w, a)
+
+
 class TestErrorRecovery:
     """Em erro de geração, o backend é descarregado para recovery."""
 

{vramd-0.3.2 → vramd-0.3.4}/tests/test_subprocess_pool.py

@@ -492,7 +492,92 @@ class TestBufferedStdoutLine:
         import time
 
         t0 = time.monotonic()
-        with pytest.raises(SubprocessWorkerError, match="timeout idle"):
+        with pytest.raises(SubprocessWorkerError, match="worker wedged"):
             pool.generate("paint3d", {})
         elapsed = time.monotonic() - t0
         assert elapsed < 5.0, f"esperava post_done curto, demorou {elapsed:.1f}s"
+
+
+class TestOomWatcher:
+    """Watcher de OOM-spin: conta só o que cresce no stderr durante o job."""
+
+    def test_scan_counts_only_new_lines(self, tmp_path):
+        from vramd.subprocess_pool import _WorkerState
+
+        pool = _make_pool(FakePopen(), log_path_fn=lambda b: tmp_path / "w.log")
+        log = tmp_path / "w.log"
+        log.write_text("expandable_segments: memory mapping failed with OOM\n" * 3, encoding="utf-8")
+        state = _WorkerState(backend="paint3d", log_path=log)
+
+        n, off = pool._scan_worker_oom(state, 0)
+        assert n == 3
+        assert off == log.stat().st_size
+
+        # Re-scan do mesmo offset: nada novo.
+        assert pool._scan_worker_oom(state, off) == (0, off)
+
+        with open(log, "a", encoding="utf-8") as fh:
+            fh.write("linha normal\nCUDA out of memory\n")
+        n2, off2 = pool._scan_worker_oom(state, off)
+        assert n2 == 1  # só o padrão novo conta
+        assert off2 == log.stat().st_size
+
+    def test_wedge_aborts_with_classified_error(self, tmp_path, monkeypatch):
+        """OOM-spin (8+ linhas novas, sem progresso) → abort em segundos."""
+        import threading
+
+        import vramd.subprocess_pool as sp
+
+        monkeypatch.setattr(sp, "_OOM_SPIN_QUIET_SEC", 2.0)
+        fake = FakePopen()
+        pool = _make_pool(
+            fake,
+            event_timeout_sec=60.0,
+            log_path_fn=lambda b: tmp_path / "worker.log",
+        )
+        fake.push_events('{"event": "ready", "vram_mib": 1300}')
+        pool.load("paint3d", "paint3d", {})
+        log = tmp_path / "worker.log"
+
+        def writer() -> None:
+            import time
+
+            time.sleep(1.0)
+            log.write_text("expandable_segments: memory mapping failed with OOM\n" * 9, encoding="utf-8")
+
+        t = threading.Thread(target=writer)
+        t.start()
+        try:
+            with pytest.raises(SubprocessWorkerError, match="worker wedged — OOM-spin"):
+                pool.generate("paint3d", {})
+        finally:
+            t.join()
+
+
+class TestWorkerDeadPredicate:
+    """ "worker wedged" entra no predicado de requeue (worker morto transitório)."""
+
+    def test_wedge_messages_trigger_requeue(self) -> None:
+        from vramd.dispatcher import _is_worker_dead
+
+        assert _is_worker_dead({"error": "paint3d: worker wedged — OOM-spin (12 allocs, 40s sem progress)"})
+        assert _is_worker_dead({"error": "paint3d: worker wedged — idle 600s sem progress"})
+        assert not _is_worker_dead({"error": "erro genérico de geração"})
+
+
+class TestWorkerRecycling:
+    """Worker persistente recicla após N jobs (fragmentação/estado não acumula)."""
+
+    def test_recycles_after_max_jobs(self):
+        fake = FakePopen()
+        pool = _make_pool(fake, worker_max_jobs=3)
+        fake.push_events('{"event": "ready", "vram_mib": 1300}')
+        pool.load("paint3d", "paint3d", {})
+        state = pool._workers["paint3d"]
+        for _i in range(3):
+            fake.push_events('{"event": "progress", "pct": 0.5}')
+            fake.push_events('{"event": "done", "result": {"status": "ok"}}')
+            out = pool.generate("paint3d", {})
+            assert out["status"] == "ok"
+        assert state.jobs_served == 3
+        assert state.proc is None  # reciclado: próximo load re-spawna

vramd-0.3.4/tests/test_version.py

@@ -0,0 +1,21 @@
+"""Consistência de versão: o literal __version__ acompanha o pyproject."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import vramd
+
+
+def _pyproject_version() -> str:
+    pyproject = Path(__file__).resolve().parents[1] / "pyproject.toml"
+    match = re.search(r'^version\s*=\s*"([^"]+)"', pyproject.read_text(encoding="utf-8"), re.MULTILINE)
+    assert match, "pyproject.toml sem version"
+    return match.group(1)
+
+
+class TestVersion:
+    def test_dunder_version_matches_pyproject(self) -> None:
+        # 0.3.2 saiu com __version__="0.3.1": `vramd --version` mentia.
+        assert vramd.__version__ == _pyproject_version()