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++
setup: the build tools come from the virtualenv first and an older system cmake (below the 3.24 CMakeLists.txt needs) counts as missing, so pip installs the right one (#3822); tests
Niko12215bfce4bea063
diff --git a/setup.py b/setup.pyindex 40793db78..432de323e 100644--- a/setup.py+++ b/setup.py@@ -2100,22 +2100,43 @@ def find_vcvars(cuda_v=None):return v if v and v.exists() else None+CMAKE_MIN = (3, 24) # CMakeLists.txt: cmake_minimum_required(VERSION 3.24)+++def _tool_version(path, name):+ """(ok, version tuple) of `path --version`: ok False when it does not run (a pip launcher whose Python is gone)."""+ try:+ done = subprocess.run([path, "--version"], capture_output=True, text=True, timeout=30)+ except (OSError, subprocess.SubprocessError):+ return False, ()+ if done.returncode != 0:+ return False, ()+ found = re.search(r"(\d+)\.(\d+)(?:\.(\d+))?", done.stdout or "")+ return True, tuple(int(x) for x in found.groups() if x) if found else ()++def find_tool(name):- """A tool on PATH, or the one pip installed next to this Python (cmake, ninja). A PATH copy that does not run- (a pip launcher whose Python is gone) is skipped for the one next to this Python."""- p = shutil.which(name)- if p:- try:- if subprocess.run([p, "--version"], capture_output=True, timeout=30).returncode == 0:- return p- except (OSError, subprocess.SubprocessError):- pass- for d in (Path(sys.executable).parent / "Scripts", Path(sys.executable).parent,- Path.home() / ".local" / "bin"):- c = d / (name + (".exe" if WIN else ""))- if c.exists():- return str(c)- return None+ """The tool the build uses (cmake, ninja): the one pip installed next to THIS Python first (the virtualenv's own, #3822), then PATH,+ then ~/.local/bin. One that does not run (a pip launcher whose Python is gone) is skipped, and so is a cmake older than the+ one CMakeLists.txt needs while another is found; with only an older one it is returned and the build says so."""+ exe = name + (".exe" if WIN else "")+ candidates = [str(d / exe) for d in (Path(sys.executable).parent / "Scripts", Path(sys.executable).parent) if (d / exe).exists()]+ on_path = shutil.which(name)+ if on_path and on_path not in candidates:+ candidates.append(on_path)+ local = Path.home() / ".local" / "bin" / exe+ if local.exists() and str(local) not in candidates:+ candidates.append(str(local))+ older = None+ for c in candidates:+ runs, version = _tool_version(c, name)+ if not runs:+ continue+ if name == "cmake" and version and version[:2] < CMAKE_MIN:+ older = older or c+ continue+ return c+ return olderdef free_gb(path):@@ -5483,13 +5504,24 @@ def install_build_tools(gpu, yes):return nvcc, find_vcvars(cuda_v) if WIN else None+def tool_usable(name):+ """find_tool found one that runs and (cmake) is new enough: an older system cmake counts as missing, so pip puts the right one in the venv."""+ found = find_tool(name)+ if found is None:+ return False+ if name == "cmake":+ runs, version = _tool_version(found, name)+ return runs and (not version or version[:2] >= CMAKE_MIN)+ return True++def ensure_build_tools():"""cmake and ninja for a local compile, installed from requirements-build.txt when missing (#3403: the Mac setupcompiles without cmake_build(), so it calls this too). Returns (cmake, ninja)."""# The ready-made engine path never calls this function. Keep build helpers out of# the normal serving environment, and use already installed tools offline.build_packages = requirement_lines(BUILD_REQUIREMENTS) if BUILD_REQUIREMENTS.exists() else BUILD_PACKAGES- missing = [package for package in build_packages if find_tool(req_name(package)) is None]+ missing = [package for package in build_packages if not tool_usable(req_name(package))]if missing:pip_install(missing, "CMake and Ninja build tools")cmake, ninja = find_tool("cmake"), find_tool("ninja")diff --git a/tools/test_setup_find_tool.py b/tools/test_setup_find_tool.pynew file mode 100644index 000000000..419efa7aa--- /dev/null+++ b/tools/test_setup_find_tool.py@@ -0,0 +1,65 @@+"""setup.find_tool takes the virtualenv's own cmake before a PATH one and skips a cmake older than CMakeLists.txt needs (#3822).++ python -m unittest tools.test_setup_find_tool+"""+from __future__ import annotations++import sys+import tempfile+import unittest+from pathlib import Path+from unittest import mock++ROOT = Path(__file__).resolve().parents[1]+sys.path.insert(0, str(ROOT))+import setup # noqa: E402+++class FindTool(unittest.TestCase):+ def setUp(self):+ self.tmp = tempfile.TemporaryDirectory()+ self.addCleanup(self.tmp.cleanup)+ self.bin = Path(self.tmp.name) / "venv" / "bin"+ self.bin.mkdir(parents=True)+ self.venv_python = self.bin / "python"++ def versions(self, table):+ return lambda path, name: table.get(str(path), (False, ()))++ def venv_tool(self, name="cmake"):+ return str(self.bin / (name + (".exe" if setup.WIN else "")))++ def find(self, table, on_path, name="cmake", venv_copy=True):+ if venv_copy:+ Path(self.venv_tool(name)).write_text("x")+ with mock.patch.object(setup.sys, "executable", str(self.venv_python)), \+ mock.patch.object(setup.shutil, "which", return_value=on_path), \+ mock.patch.object(setup, "_tool_version", side_effect=self.versions(table)), \+ mock.patch.object(setup.Path, "home", return_value=Path(self.tmp.name) / "home"):+ return setup.find_tool(name), setup.tool_usable(name)++ def test_the_virtualenv_copy_wins_over_an_old_system_cmake(self):+ got, usable = self.find({"/usr/bin/cmake": (True, (3, 22, 1)), self.venv_tool(): (True, (4, 1, 0))}, "/usr/bin/cmake")+ self.assertEqual(got, self.venv_tool())+ self.assertTrue(usable)++ def test_an_old_cmake_on_its_own_is_returned_but_not_usable(self):+ got, usable = self.find({"/usr/bin/cmake": (True, (3, 22, 1))}, "/usr/bin/cmake", venv_copy=False)+ self.assertEqual(got, "/usr/bin/cmake") # the build would say "CMake 3.24 or higher is required"+ self.assertFalse(usable) # so setup installs the pip cmake first++ def test_a_new_enough_system_cmake_is_fine_without_a_venv_one(self):+ got, usable = self.find({"/usr/bin/cmake": (True, (3, 28, 3))}, "/usr/bin/cmake", venv_copy=False)+ self.assertEqual((got, usable), ("/usr/bin/cmake", True))++ def test_ninja_has_no_version_floor(self):+ got, usable = self.find({"/usr/bin/ninja": (True, (1, 10))}, "/usr/bin/ninja", "ninja", venv_copy=False)+ self.assertTrue(usable)++ def test_a_launcher_that_does_not_run_is_skipped(self):+ got, _ = self.find({self.venv_tool(): (False, ()), "/usr/bin/cmake": (True, (3, 30, 0))}, "/usr/bin/cmake")+ self.assertEqual(got, "/usr/bin/cmake")+++if __name__ == "__main__":+ unittest.main()diff --git a/tools/test_setup_pins.py b/tools/test_setup_pins.pyindex 83d73fb2e..052c9a973 100644--- a/tools/test_setup_pins.py+++ b/tools/test_setup_pins.py@@ -378,6 +378,7 @@ class Requirements(unittest.TestCase):with mock.patch.object(setup, "WIN", False), \mock.patch.object(setup, "find_tool", side_effect=find_tool), \+ mock.patch.object(setup, "_tool_version", return_value=(True, (3, 28, 1))), \mock.patch.object(setup, "pip_install", side_effect=pip_install), \mock.patch.object(setup, "run", side_effect=run):setup.cmake_build(ROOT, ROOT / "build-test", "strata", [], None, "unused.bat")