Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.
C++
Fix #3613 #3467: the Terminal/Control bundle ships tools/calibrate.py; a setup crash now says what it was
Niko12212a22daa4f069
diff --git a/packaging/package_terminal.py b/packaging/package_terminal.pyindex 41005f360..e546e4db8 100644--- a/packaging/package_terminal.py+++ b/packaging/package_terminal.py@@ -115,8 +115,11 @@ TOOLS_SUBSET = (#: (STRATA_CONTROL_INSTALL=1: no pip, no engine fetch, no compiler). Entry points; their local imports under tools/ come with them.#: The same list the app's Control component stages (apps/desktop/scripts/stage-control.py uses these names).INSTALLER_FILES = ("setup.py", "ref/load.py") # ref/load.py: strata_pack.py (the Q2_0 AVX-512 repack) imports it+#: calibrate: setup.py imports it after a tune (calibrate_config, and the earlier tuning that a rerun applies); it was missing from this+#: list in 0.1.47, so every launch after a tune failed (#3613, #3467). setup_tool_imports() below also reads setup.py itself, so a tools/+#: module it starts to import is never forgotten again; tests/terminal/test_bundle_imports.py checks the staged bundle.INSTALLER_TOOLS = ("strata_mcp", "iq_pack", "strata_pack", "pack_index", "mtp_fetch", "mtp_pack", "mtp_rt", "draft_vocab",- "strata_tokenizer", "gguf_reader")+ "strata_tokenizer", "gguf_reader", "calibrate")INSTALLER_DATA = "data" # draft vocabularies, expert profiles: 2 MB#: packages the bundle must import after the install (the API server's and the CLI's).@@ -247,9 +250,22 @@ def local_imports(folder: Path, entry: tuple[str, ...]) -> list[str]:return sorted(seen)+def setup_tool_imports(source: Path = ROOT) -> list[str]:+ """The `tools/<name>.py` modules that the installer files import (any import statement, at any depth: setup.py imports most of them+ inside functions after putting tools/ on sys.path). tools/hip and tools/image hold engine-install code that Control's mode never runs."""+ import ast+ found: set[str] = set()+ for name in INSTALLER_FILES:+ for node in ast.walk(ast.parse((source / name).read_text(encoding="utf-8-sig"))):+ names = [a.name.split(".")[0] for a in node.names] if isinstance(node, ast.Import) else \+ [node.module.split(".")[0]] if isinstance(node, ast.ImportFrom) and node.module and node.level == 0 else []+ found.update(m for m in names if (source / "tools" / f"{m}.py").exists())+ return sorted(found)++def add_installer(folder: Path, source: Path = ROOT) -> dict:"""Copy the installer's files from the source tree into a staged terminal folder (after the terminal payload is in place)."""- tools = local_imports(source, INSTALLER_TOOLS)+ tools = local_imports(source, tuple(sorted(set(INSTALLER_TOOLS) | set(setup_tool_imports(source)))))copied = []for name in INSTALLER_FILES:(folder / name).parent.mkdir(parents=True, exist_ok=True)diff --git a/strata_cli/launch/runner.py b/strata_cli/launch/runner.pyindex e318f567e..9df6ce552 100644--- a/strata_cli/launch/runner.py+++ b/strata_cli/launch/runner.py@@ -34,6 +34,23 @@ ROOT = Path(__file__).resolve().parents[2]WINDOWS = os.name == "nt"+def python_failure(lines: list[str]) -> str | None:+ """The last line of a Python traceback in setup.py's output (ModuleNotFoundError: No module named 'calibrate'), or None when the+ output holds no traceback. Frames are skipped; the exception line is the first unindented line after the last 'Traceback'."""+ for i in range(len(lines) - 1, -1, -1):+ if lines[i].startswith("Traceback (most recent call last)"):+ for line in lines[i + 1:]:+ if line.strip() and not line[:1].isspace():+ return line.strip()[:300]+ return None+ return None+++def missing_file(failure: str) -> bool:+ """An import or file error: the install itself is short of a file, which an update of Strata brings back."""+ return failure.startswith(("ModuleNotFoundError", "ImportError", "FileNotFoundError"))++class LaunchError(RuntimeError):"""A step could not be done. `text` says what it means; `next` says what to do."""@@ -42,6 +59,23 @@ class LaunchError(RuntimeError):self.text, self.next, self.code = text, next, code+def setup_failure(lines: list[str], err: str, hint: str, details: str | None, own_files: bool) -> LaunchError:+ """The error for a setup.py run that exited non-zero. setup.py's own `[X]` line (err) is the message when there is one; when it+ stopped with a Python error instead, that error's last line is (#3613, #3467: a file missing from the Terminal's tools/ ended every+ launch after a tune with only "The model could not be installed"). `details` is the file that holds the rest of its output."""+ crashed = python_failure(lines) if not err else None+ if crashed:+ where = f" The whole setup output is in {details}." if details else ""+ if missing_file(crashed):+ return LaunchError(f"The model could not be installed. A file that setup needs is missing from this Strata install ({crashed}).",+ "Update Strata (`strata update`) and run it again." + where, 6)+ return LaunchError(f"The model could not be installed. Setup stopped with an error ({crashed}).", "Run it again." + where, 6)+ return LaunchError("The model could not be installed." + (f" {err}." if err else ""),+ (hint or ("Run it again: finished steps are skipped." if own_files else+ "Run it again: finished steps are skipped and a download continues where it stopped."))+ + (f" Details: {details}" if details else ""), 6)++class Cancelled(LaunchError):def __init__(self):super().__init__("Stopped. Nothing was changed on your computer beyond files already downloaded.", "", 130)@@ -810,9 +844,7 @@ class Runner:adopted = self.adopt_prepared_files(err)if adopted is not None:return adopted- raise LaunchError("The model could not be installed." + (f" {err}." if err else ""),- hint or ("Run it again: finished steps are skipped." if s.model_path else- "Run it again: finished steps are skipped and a download continues where it stopped."), 6)+ raise setup_failure(lines, err, hint, self.keep_setup_output(lines), bool(s.model_path))path, _desc = self.installed_state()if path is None:raise LaunchError("Setup finished but no run config was written for this model.",@@ -821,6 +853,18 @@ class Runner:self.check_pictures(path)return path+ def keep_setup_output(self, lines: list[str]) -> str | None:+ """The last lines setup.py printed, kept next to the launch's other logs so a failed install can be read afterwards (the message+ shows one line; a traceback needs the rest). Best effort: None when it cannot be written."""+ try:+ folder = launch_dir()+ folder.mkdir(parents=True, exist_ok=True)+ path = folder / f"{self.name}.setup.log"+ path.write_text("\n".join(lines[-400:]) + "\n", encoding="utf-8", errors="replace")+ return str(path)+ except (OSError, ValueError):+ return None+def adopt_prepared_files(self, setup_error: str) -> Path | None:"""The installer cannot set this graphics card up (Intel Arc, for one): if the model's files and prepared pack are already on disk,write the run config here (strata_cli/launch/adopt.py); else say what is missing."""diff --git a/tests/terminal/test_bundle_imports.py b/tests/terminal/test_bundle_imports.pynew file mode 100644index 000000000..a12b2b755--- /dev/null+++ b/tests/terminal/test_bundle_imports.py@@ -0,0 +1,101 @@+"""The Terminal / Control bundle holds every tools/ module that setup.py can import (#3613, #3467).++0.1.47 shipped without tools/calibrate.py: setup.py imports it after a tune, so every launch after a tune ended in+ModuleNotFoundError. The bundle is staged here the way packaging/package_terminal.py stages it (the payload, the read-only tools,+then add_installer), and setup.py's tool imports are resolved against tools/ as the bundle has it, not against the source tree.+"""++import ast+import os+import shutil+import subprocess+import sys+import tempfile+import unittest+from pathlib import Path++ROOT = Path(__file__).resolve().parents[2]+sys.path.insert(0, str(ROOT / "packaging"))+import package_terminal as pt # noqa: E402+++def imports_of(path: Path) -> set[str]:+ found: set[str] = set()+ for node in ast.walk(ast.parse(path.read_text(encoding="utf-8-sig"))):+ if isinstance(node, ast.Import):+ found.update(a.name.split(".")[0] for a in node.names)+ elif isinstance(node, ast.ImportFrom) and node.module and node.level == 0:+ found.add(node.module.split(".")[0])+ return found+++class BundleImports(unittest.TestCase):+ @classmethod+ def setUpClass(cls):+ cls.temp = tempfile.TemporaryDirectory(prefix="strata-bundle-")+ cls.root = Path(cls.temp.name) / "strata-terminal"+ cls.root.mkdir()+ ignore = shutil.ignore_patterns("__pycache__", "*.pyc")+ for item in pt.PAYLOAD:+ src, dst = ROOT / item, cls.root / item+ dst.parent.mkdir(parents=True, exist_ok=True)+ if src.is_dir():+ shutil.copytree(src, dst, ignore=ignore)+ else:+ shutil.copy2(src, dst)+ (cls.root / "tools").mkdir(exist_ok=True)+ for item in pt.TOOLS_SUBSET:+ shutil.copy2(ROOT / "tools" / item, cls.root / "tools" / item)+ cls.installer = pt.add_installer(cls.root, ROOT)++ @classmethod+ def tearDownClass(cls):+ cls.temp.cleanup()++ def test_calibrate_is_in_the_bundle(self):+ # the exact file #3613 and #3467 lacked+ self.assertTrue((self.root / "tools" / "calibrate.py").is_file())+ self.assertIn("calibrate", pt.INSTALLER_TOOLS)++ def test_every_tools_module_setup_py_imports_is_in_the_bundle(self):+ in_bundle = {p.stem for p in (self.root / "tools").glob("*.py")}+ in_source = {p.stem for p in (ROOT / "tools").glob("*.py")}+ wanted = imports_of(self.root / "setup.py") & in_source+ self.assertIn("calibrate", wanted, "setup.py no longer imports calibrate: update this test")+ self.assertEqual(sorted(wanted - in_bundle), [], "setup.py imports tools/ modules that the bundle does not carry")++ def test_the_bundled_tools_import_nothing_the_bundle_lacks(self):+ in_bundle = {p.stem for p in (self.root / "tools").glob("*.py")}+ in_source = {p.stem for p in (ROOT / "tools").glob("*.py")}+ for module in sorted(in_bundle):+ missing = sorted((imports_of(self.root / "tools" / f"{module}.py") & in_source) - in_bundle)+ self.assertEqual(missing, [], f"tools/{module}.py imports tools/ modules the bundle does not carry")++ def test_setup_py_and_each_of_its_tools_import_with_tools_limited_to_the_bundle(self):+ modules = sorted(set(pt.setup_tool_imports(self.root)) | set(pt.INSTALLER_TOOLS))+ code = ("import sys, os, importlib\n"+ f"sys.path[:0] = [{str(self.root)!r}, {str(self.root / 'tools')!r}]\n"+ "import setup\n"+ f"for name in {modules!r}:\n"+ " module = importlib.import_module(name)\n"+ f" assert os.path.samefile(os.path.dirname(module.__file__), {str(self.root / 'tools')!r}), (name, module.__file__)\n"+ "print('imports ok')\n")+ env = {**os.environ, "STRATA_CONTROL_INSTALL": "1", "PYTHONNOUSERSITE": "1"}+ for key in ("PYTHONPATH", "PYTHONHOME"):+ env.pop(key, None)+ done = subprocess.run([sys.executable, "-I", "-c", code], cwd=str(self.root.parent), env=env,+ capture_output=True, text=True, timeout=120)+ self.assertEqual(done.returncode, 0, (done.stdout or "") + (done.stderr or "")[-1500:])+ self.assertIn("imports ok", done.stdout)++ def test_a_tool_setup_starts_to_import_is_added_without_editing_the_list(self):+ # setup_tool_imports reads setup.py, so INSTALLER_TOOLS cannot go stale the way it did for calibrate+ self.assertTrue(set(pt.setup_tool_imports(ROOT)) <= set(pt.local_imports(ROOT, tuple(sorted(+ set(pt.INSTALLER_TOOLS) | set(pt.setup_tool_imports(ROOT)))))))+ without = tuple(x for x in pt.INSTALLER_TOOLS if x != "calibrate")+ self.assertNotIn("calibrate", pt.local_imports(ROOT, without)) # the old list really lacked it+ self.assertIn("calibrate", pt.setup_tool_imports(ROOT)) # and the scan finds it anyway+++if __name__ == "__main__":+ unittest.main()diff --git a/tests/terminal/test_setup_failure_words.py b/tests/terminal/test_setup_failure_words.pynew file mode 100644index 000000000..44db19a80--- /dev/null+++ b/tests/terminal/test_setup_failure_words.py@@ -0,0 +1,72 @@+"""When setup.py stops with a Python error, `strata launch` says what it was and where the rest of the output is (#3613, #3467)."""++import tempfile+import unittest+from pathlib import Path+from unittest import mock++from strata_cli.launch import runner+from strata_cli.launch.runner import LaunchError, Runner, missing_file, python_failure, setup_failure++TRACEBACK = [+ " [..] Tuning Strata for this PC",+ "Traceback (most recent call last):",+ ' File "C:\\Strata\\setup.py", line 6414, in calibrate_config',+ " import calibrate as CAL",+ "ModuleNotFoundError: No module named 'calibrate'",+]+++class SetupFailureWords(unittest.TestCase):+ def test_the_last_line_of_a_traceback_is_found(self):+ self.assertEqual(python_failure(TRACEBACK), "ModuleNotFoundError: No module named 'calibrate'")+ self.assertIsNone(python_failure(["[X] Not enough disk space", " Free some space"]))+ self.assertIsNone(python_failure(["Traceback (most recent call last):", ' File "x.py", line 1, in <module>']))+ # the last traceback wins, frames and blank lines are skipped+ two = TRACEBACK[:1] + ["Traceback (most recent call last):", " frame", "ValueError: old"] + TRACEBACK[1:]+ self.assertEqual(python_failure(two), "ModuleNotFoundError: No module named 'calibrate'")++ def test_a_missing_module_is_said_as_a_missing_file_with_the_next_step_and_the_output_path(self):+ error = setup_failure(TRACEBACK, "", "", r"C:\Users\x\launch\a.setup.log", False)+ self.assertIsInstance(error, LaunchError)+ self.assertIn("The model could not be installed.", error.text)+ self.assertIn("missing from this Strata install", error.text)+ self.assertIn("No module named 'calibrate'", error.text)+ self.assertIn("strata update", error.next)+ self.assertIn(r"C:\Users\x\launch\a.setup.log", error.next)++ def test_another_python_error_keeps_its_line_and_the_path(self):+ error = setup_failure(["Traceback (most recent call last):", " f", "KeyError: 'cuda'"], "", "", "/tmp/a.setup.log", True)+ self.assertIn("KeyError: 'cuda'", error.text)+ self.assertNotIn("missing", error.text)+ self.assertIn("/tmp/a.setup.log", error.next)++ def test_a_setup_error_line_still_wins_and_gets_the_details_path(self):+ error = setup_failure(TRACEBACK, "Not enough disk space", "Free some space.", "/tmp/a.setup.log", False)+ self.assertEqual(error.text, "The model could not be installed. Not enough disk space.")+ self.assertEqual(error.next, "Free some space. Details: /tmp/a.setup.log")+ plain = setup_failure([], "", "", None, False)+ self.assertEqual(plain.text, "The model could not be installed.")+ self.assertIn("a download continues where it stopped", plain.next)+ self.assertNotIn("Details", plain.next)++ def test_missing_file_kinds(self):+ self.assertTrue(missing_file("ModuleNotFoundError: No module named 'x'"))+ self.assertTrue(missing_file("ImportError: cannot import name 'y'"))+ self.assertFalse(missing_file("ValueError: bad"))++ def test_the_setup_output_is_kept_in_the_launch_folder(self):+ with tempfile.TemporaryDirectory() as folder:+ run = Runner.__new__(Runner)+ with mock.patch.object(Runner, "name", new_callable=mock.PropertyMock, return_value="gyro-s-32k"), mock.patch.object(runner, "launch_dir", return_value=Path(folder)):+ kept = run.keep_setup_output([f"line {i}" for i in range(1000)] + TRACEBACK)+ self.assertEqual(Path(kept), Path(folder) / "gyro-s-32k.setup.log")+ text = Path(kept).read_text(encoding="utf-8")+ self.assertIn("ModuleNotFoundError: No module named 'calibrate'", text)+ self.assertEqual(len(text.splitlines()), 400) # the tail, not a runaway file+ with mock.patch.object(Runner, "name", new_callable=mock.PropertyMock, return_value="gyro-s-32k"), mock.patch.object(runner, "launch_dir", side_effect=OSError("read-only")):+ self.assertIsNone(run.keep_setup_output(["x"]))+++if __name__ == "__main__":+ unittest.main()