vramd 0.2.0__tar.gz → 0.2.2__tar.gz

{vramd-0.2.0/src/vramd.egg-info → vramd-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vramd
-Version: 0.2.0
+Version: 0.2.2
 Summary: Controlo de admissão de VRAM para inferência generativa em GPUs de consumo
 Author: Maikeu Locatelli
 License-Expression: MIT

{vramd-0.2.0 → vramd-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vramd"
-version = "0.2.0"
+version = "0.2.2"
 description = "Controlo de admissão de VRAM para inferência generativa em GPUs de consumo"
 readme = "README.md"
 authors = [{ name = "Maikeu Locatelli" }]

{vramd-0.2.0 → vramd-0.2.2}/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.2.0"
+__version__ = "0.2.2"
 __all__ = ["__version__"]

{vramd-0.2.0 → vramd-0.2.2}/src/vramd/cli.py

@@ -1534,7 +1534,9 @@ def calibrate_cmd(
         elif auto_kwargs:
             console.print(f"[dim]hw-auto ({desc.tool}): {auto_kwargs}[/dim]")
         load_kwargs.update(auto_kwargs)
-    # Explícito vence o automático: o operador pode querer medir outro ponto.
+    # ``calibrate_load_kwargs`` do descriptor (config real de produção do
+    # backend) ganha ao hw-auto; o explícito do CLI ganha a ambos.
+    load_kwargs.update(desc.calibrate_load_kwargs)
     load_kwargs.update(explicit_kwargs)
     if quant:
         load_kwargs.setdefault("sdnq_preset", quant)
@@ -1543,10 +1545,14 @@ def calibrate_cmd(
     if request_json:
         request = json.loads(Path(request_json).read_text(encoding="utf-8"))
     else:
-        request = {
-            "prompt": prompt or "calibration job",
-            "output": output_path or f"/tmp/ums-calibrate-{backend}.bin",
-        }
+        # Default do descriptor (prompt/output com a extensão certa por
+        # backend) — sem isto ``calibrate <backend>`` falha em backends que
+        # exigem inputs (mesh_path/output) ou formatos específicos.
+        request = dict(desc.calibrate_request)
+        request.setdefault("prompt", prompt or "calibration job")
+        if output_path:
+            request["output"] = output_path
+        request.setdefault("output", f"/tmp/vramd-calibrate-{backend}.bin")
 
     pool = SubprocessWorkerPool()
     runner = CalibrationRunner(pool)

{vramd-0.2.0 → vramd-0.2.2}/src/vramd/registry.py

@@ -201,6 +201,15 @@ class BackendDescriptor:
         shape_keys: Subconjunto que força reload quando muda. ``None`` = global.
         vram: Bloco ``vram:`` medido (`vramd calibrate`), quando existe.
         peak_profile: Bloco ``peak_profile:`` (quant, staged, unload_frees_vram…).
+        calibrate_request: Request de geração default para ``vramd calibrate``
+            (ex.: prompt + output com a extensão certa). Sem isto, o calibrador
+            usa ``{}`` e backends que exigem inputs (mesh_path/output) falham
+            com mensagens pouco acionáveis — o default vive no descriptor para
+            que ``vramd calibrate <backend>`` funcione sempre.
+        calibrate_load_kwargs: Kwargs de load default para ``vramd calibrate``
+            (ex.: ``sdnq_preset`` quando o perfil da tool não o resolve).
+            Fundidos com o hw-auto (este ganha) e com os explícitos do CLI
+            (``--load-kwargs``/``--quant`` ganham a este).
     """
 
     name: str
@@ -214,6 +223,8 @@ class BackendDescriptor:
     shape_keys: frozenset[str] | None = None
     vram: Mapping[str, Any] = field(default_factory=dict)
     peak_profile: Mapping[str, Any] = field(default_factory=dict)
+    calibrate_request: Mapping[str, Any] = field(default_factory=dict)
+    calibrate_load_kwargs: Mapping[str, Any] = field(default_factory=dict)
 
     @property
     def unload_frees_vram(self) -> bool:
@@ -316,6 +327,8 @@ def _to_descriptor(entry: Mapping[str, Any], *, source: str) -> BackendDescripto
         shape_keys=frozenset(str(k) for k in shape_keys) if shape_keys else None,
         vram=dict(entry.get("vram") or {}),
         peak_profile=dict(entry.get("peak_profile") or {}),
+        calibrate_request=dict(entry.get("calibrate_request") or {}),
+        calibrate_load_kwargs=dict(entry.get("calibrate_load_kwargs") or {}),
     )
 
 

{vramd-0.2.0 → vramd-0.2.2}/src/vramd/toolchain.py

@@ -25,10 +25,28 @@ ENV_TOOLS_ROOT = "VRAMD_TOOLS_ROOT"
 
 # Nomes de pasta tentados para cada ``tool`` (o mesmo nome, e a forma
 # capitalizada que muitos projetos usam para a pasta do componente).
+def _camel_title(tool: str) -> str:
+    """``text2icon`` → ``Text2Icon``; ``skymap2d`` → ``Skymap2D``.
+
+    O ``str.capitalize()`` só capitaliza a primeira letra — pastas com
+    camelCase após um dígito (Text2Icon, Paint3D, Skymap2D…) não eram
+    encontradas. Capitaliza o início de cada segmento alfanumérico.
+    """
+    import re
+
+    return "".join(part.capitalize() if not part.isdigit() else part for part in re.split(r"(\d+)", tool))
+
+
 def _candidate_dirs(tool: str) -> list[str]:
     """Variações de nome de pasta a tentar para ``tool``."""
     seen: list[str] = []
-    for name in (tool, tool.capitalize(), tool.upper(), tool.replace("_", "-")):
+    for name in (
+        tool,
+        tool.capitalize(),
+        _camel_title(tool),
+        tool.upper(),
+        tool.replace("_", "-"),
+    ):
         if name and name not in seen:
             seen.append(name)
     return seen

{vramd-0.2.0 → vramd-0.2.2/src/vramd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vramd
-Version: 0.2.0
+Version: 0.2.2
 Summary: Controlo de admissão de VRAM para inferência generativa em GPUs de consumo
 Author: Maikeu Locatelli
 License-Expression: MIT

{vramd-0.2.0 → vramd-0.2.2}/src/vramd.egg-info/SOURCES.txt

@@ -73,6 +73,7 @@ tests/test_stats.py
 tests/test_subprocess_integration.py
 tests/test_subprocess_per_backend_e2e.py
 tests/test_subprocess_pool.py
+tests/test_toolchain.py
 tests/test_unload_frees_vram.py
 tests/test_vram_admit.py
 tests/test_vram_planner.py

{vramd-0.2.0 → vramd-0.2.2}/tests/test_calibrate_cli.py

@@ -115,6 +115,70 @@ class TestCalibrateCommand:
         assert result.exit_code == 0
         assert patched["spec"].request["prompt"] == "uma pedra"
 
+    def test_descriptor_calibrate_defaults_are_used(self, runner, patched, tmp_path, monkeypatch):
+        """`vramd calibrate <backend>` funciona sem flags quando o descriptor
+        declara ``calibrate_request``/``calibrate_load_kwargs`` — o utilizador
+        comum não precisa de saber que o backend exige mesh_path/output/quant."""
+        yaml_path = tmp_path / "backends.yaml"
+        yaml_path.write_text(
+            yaml.safe_dump(
+                {
+                    "version": 2,
+                    "backends": [
+                        {
+                            "name": "text3d",
+                            "adapter": "x",
+                            "vram_mib": 4000,
+                            "tool": "text3d",
+                            "calibrate_request": {"mesh_path": "/tmp/m.glb", "output": "/tmp/out.glb"},
+                            "calibrate_load_kwargs": {"sdnq_preset": "sdnq-int4"},
+                        }
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
+        monkeypatch.setenv("VRAMD_BACKENDS_FILE", str(yaml_path))
+        result = runner.invoke(cli_mod.cli, ["calibrate", "text3d", "--no-compare"])
+        assert result.exit_code == 0
+        spec = patched["spec"]
+        assert spec.request["mesh_path"] == "/tmp/m.glb"
+        assert spec.request["output"] == "/tmp/out.glb"
+        assert spec.load_kwargs["sdnq_preset"] == "sdnq-int4"
+
+    def test_explicit_flags_override_descriptor_defaults(self, runner, patched, tmp_path, monkeypatch):
+        """--request-json/--load-kwargs do operador ganham ao descriptor."""
+        yaml_path = tmp_path / "backends.yaml"
+        yaml_path.write_text(
+            yaml.safe_dump(
+                {
+                    "version": 2,
+                    "backends": [
+                        {
+                            "name": "text3d",
+                            "adapter": "x",
+                            "vram_mib": 4000,
+                            "tool": "text3d",
+                            "calibrate_request": {"mesh_path": "/a.glb", "output": "/a-out.glb"},
+                            "calibrate_load_kwargs": {"sdnq_preset": "sdnq-int4"},
+                        }
+                    ],
+                }
+            ),
+            encoding="utf-8",
+        )
+        monkeypatch.setenv("VRAMD_BACKENDS_FILE", str(yaml_path))
+        job = tmp_path / "job.json"
+        job.write_text(json.dumps({"mesh_path": "/b.glb", "output": "/b-out.glb"}), encoding="utf-8")
+        result = runner.invoke(
+            cli_mod.cli,
+            ["calibrate", "text3d", "--no-compare", "--request-json", str(job), "--load-kwarg", "sdnq_preset=none"],
+        )
+        assert result.exit_code == 0
+        spec = patched["spec"]
+        assert spec.request["mesh_path"] == "/b.glb"
+        assert spec.load_kwargs["sdnq_preset"] is None  # "none" é coergido a None
+
     def test_repeats_and_cycles_flow_through(self, runner, patched):
         runner.invoke(cli_mod.cli, ["calibrate", "text3d", "--no-compare", "--repeats", "5", "--cycles", "2"])
         assert patched["spec"].repeats == 5

vramd-0.2.2/tests/test_toolchain.py

@@ -0,0 +1,61 @@
+"""Testes da descoberta do interpretador das tools (``VRAMD_TOOLS_ROOT``).
+
+Regressão: pastas com camelCase após um dígito (Text2Icon, Paint3D,
+Skymap2D — o layout do AiGameKit) não eram encontradas porque
+``str.capitalize()`` só capitaliza a primeira letra.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from vramd.toolchain import _camel_title, _candidate_dirs, resolve_tool_python
+
+
+class TestCamelTitle:
+    def test_camel_case_after_digit(self) -> None:
+        # O layout do AiGameKit: pasta capitalizada por segmento.
+        assert _camel_title("text2icon") == "Text2Icon"
+        assert _camel_title("skymap2d") == "Skymap2D"
+        assert _camel_title("paint3d") == "Paint3D"
+        assert _camel_title("text2sound") == "Text2Sound"
+        assert _camel_title("motion3d") == "Motion3D"
+
+    def test_simple_names_unchanged_in_spirit(self) -> None:
+        assert _camel_title("whisper") == "Whisper"
+        assert _camel_title("my_tool") == "My_tool"
+
+
+class TestCandidateDirs:
+    def test_includes_camel_title(self) -> None:
+        dirs = _candidate_dirs("text2icon")
+        assert "Text2Icon" in dirs  # o que o capitalize() não dava
+        assert "Text2icon" in dirs
+        assert "text2icon" in dirs
+
+    def test_no_duplicates(self) -> None:
+        assert len(_candidate_dirs("text2icon")) == len(set(_candidate_dirs("text2icon")))
+
+
+class TestResolveToolPython:
+    def test_finds_camel_case_folder(self, tmp_path: Path, monkeypatch) -> None:
+        venv = tmp_path / "Text2Icon" / ".venv" / "bin"
+        venv.mkdir(parents=True)
+        python = venv / "python"
+        python.write_text("#!/bin/sh\n")
+        python.chmod(0o755)
+        monkeypatch.setenv("VRAMD_TOOLS_ROOT", str(tmp_path))
+        assert resolve_tool_python("text2icon") == str(python)
+
+    def test_plain_name_still_works(self, tmp_path: Path, monkeypatch) -> None:
+        venv = tmp_path / "whisper" / ".venv" / "bin"
+        venv.mkdir(parents=True)
+        python = venv / "python"
+        python.write_text("#!/bin/sh\n")
+        python.chmod(0o755)
+        monkeypatch.setenv("VRAMD_TOOLS_ROOT", str(tmp_path))
+        assert resolve_tool_python("whisper") == str(python)
+
+    def test_no_env_means_no_discovery(self, tmp_path: Path, monkeypatch) -> None:
+        monkeypatch.delenv("VRAMD_TOOLS_ROOT", raising=False)
+        assert resolve_tool_python("text2icon") is None