Skip to content

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++
12.6 KB
Raw Blame
"""DeepSeek's engine as its own signed package (feed member ``dsv41``): fetched with resume, verified, unpacked beside the engine, and the
engine's own files are not touched.  A local signed feed on a loopback server, a stub strata-dsv41, a throwaway key."""
from __future__ import annotations

import hashlib
import json
import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path
from unittest import mock

sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "packaging"))
import feed_tool  # noqa: E402
import package_engine  # noqa: E402
from strata_control import components, dsv41_engine, engine_component as ec, signing  # noqa: E402
from strata_control.targets import host_platform  # noqa: E402
from tests.terminal import update_fixture as fx  # noqa: E402

EXE = dsv41_engine.exe_name()


def build(parent: Path, version: str, key: dict, padding: int = 0) -> Path:
    src = parent / f"src-{version}"
    src.mkdir(parents=True)
    (src / EXE).write_bytes(b"stub strata-dsv41 " + (os.urandom(padding) if padding else b"x" * 100))
    library = "cudart64_13.dll" if os.name == "nt" else "libcudart.so.13"
    (src / library).write_bytes(b"a runtime library " * 50)
    out = parent / "built"
    out.mkdir(exist_ok=True)
    folder = package_engine.build(src, "cuda", version, components.host_platform(), out, entry=EXE, archs=("sm_86",),
                                  min_driver={"nvidia": "580.65"}, build_id=f"dsv41-{version}", variant="cuda13")
    feed_tool.sign_package(folder, key)
    return folder


class Dsv41Engine(unittest.TestCase):
    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory(prefix="strata-dsv41-eng-")
        self.addCleanup(self.tmp.cleanup)
        self.root = Path(self.tmp.name)
        self.key = fx.make_key()
        trust = self.root / "trust.json"
        trust.write_text(json.dumps({"keys": [signing.public_part(self.key)]}))
        for p in (mock.patch.dict(os.environ, {"STRATA_UPDATE_TRUSTED_KEYS": str(trust), "STRATA_COMPONENTS_DIR": str(self.root / "c")}),
                  mock.patch.object(signing, "BUILTIN_KEYS", self.root / "none.json"),
                  mock.patch.object(ec, "cuda_archs_present", return_value=["sm_86"]),
                  mock.patch.object(ec, "nvidia_driver_version", return_value="610.47")):
            p.start()
            self.addCleanup(p.stop)
        self.addCleanup(ec.register_signature_verifier, None)
        self.hw = {"platform": host_platform(), "backend": "cuda", "runtime": None, "nvidia_driver": "610.47", "cuda_archs": ["sm_86"], "gfx": []}
        self.release = self.root / "release"
        self.release.mkdir()
        self.server = fx.FeedServer(self.release)
        self.server.__enter__()
        self.addCleanup(self.server.__exit__)
        self.eng = self.root / "data" / "engine"                    # a stand-in Qwen engine folder: its hash must not change
        self.eng.mkdir(parents=True)
        for n in ("strata", "BUILD.json"):
            (self.eng / n).write_bytes(os.urandom(500))
        self.before = self.tree(self.eng)

    @staticmethod
    def tree(d: Path) -> str:
        h = hashlib.sha256()
        for p in sorted(Path(d).rglob("*")):
            if p.is_file():
                h.update(p.name.encode() + p.read_bytes())
        return h.hexdigest()

    def publish(self, version="0.1.49", padding=0):
        shutil.rmtree(self.release, ignore_errors=True)
        (self.release / "dsv41").mkdir(parents=True)
        folder = build(self.root / f"pub-{version}", version, self.key, padding)
        feed_tool.pack_engine(folder, self.release / "dsv41", url_prefix="dsv41/")
        feed_tool.build_feed(self.release, key=self.key, sequence=1, dsv41_dir=self.release / "dsv41")

    def install(self, lines=None):
        out = [] if lines is None else lines
        return dsv41_engine.install(self.root / "data" / "engine-dsv41", self.server.url + "/strata-feed.json", hardware=self.hw, emit=out.append)

    def test_downloads_verifies_installs_beside_the_engine(self):
        self.publish()
        lines = []
        exe = self.install(lines)
        self.assertIsNotNone(exe, lines)
        self.assertEqual(exe.parent.parent, self.root / "data" / "engine-dsv41")
        self.assertTrue(exe.is_file())
        self.assertEqual(dsv41_engine.find(self.root / "data" / "engine-dsv41"), exe)
        self.assertEqual(self.tree(self.eng), self.before, "the Qwen engine's files must not change")
        self.assertFalse((self.root / "data" / "engine-dsv41.work").exists())

    def test_a_cut_download_resumes(self):
        self.publish(padding=3_000_000)
        name = next((self.release / "dsv41").glob("*.tar.gz")).name
        self.server.cut[name] = 800_000
        lines = []
        self.assertIsNone(self.install(lines))                       # the connection broke part-way: said plainly, the partial file is kept
        self.assertIn("resumes", " ".join(lines))
        exe = self.install(lines)                                    # the next try continues from the byte it reached
        self.assertIsNotNone(exe, lines)
        ranges = [r for r in self.server.requests if r[1].endswith(".tar.gz") and r[2] and r[2] != "bytes=0-"]
        self.assertTrue(ranges, self.server.requests)
        self.assertEqual(self.tree(self.eng), self.before)

    def test_no_package_for_this_pc_is_a_plain_line_not_a_crash(self):
        self.publish()
        self.hw = {**self.hw, "cuda_archs": ["sm_61"], "gfx": []}
        lines = []
        with mock.patch.object(ec, "cuda_archs_present", return_value=["sm_61"]):
            self.assertIsNone(self.install(lines))
        self.assertTrue(lines)
        self.assertEqual(self.tree(self.eng), self.before)

    def test_a_feed_signed_with_another_key_is_refused(self):
        self.publish()
        self.key = fx.make_key()                                     # (the trust file still names the first key)
        shutil.rmtree(self.release / "dsv41")
        self.publish_other = None
        folder = build(self.root / "other", "0.1.50", self.key)
        (self.release / "dsv41").mkdir()
        feed_tool.pack_engine(folder, self.release / "dsv41", url_prefix="dsv41/")
        feed_tool.build_feed(self.release, key=self.key, sequence=2, dsv41_dir=self.release / "dsv41")
        lines = []
        self.assertIsNone(self.install(lines))
        self.assertIn("could not be fetched", " ".join(lines))
        self.assertFalse((self.root / "data" / "engine-dsv41").exists() and any((self.root / "data" / "engine-dsv41").iterdir()))


class ManualPackage(Dsv41Engine):
    """A package the person downloaded by hand: a .tar.gz / .zip or the unpacked folder, checked before it is installed."""

    def archive(self, version="0.1.49"):
        folder = build(self.root / f"man-{version}", version, self.key)
        out = self.root / "dl"
        out.mkdir(exist_ok=True)
        entry = feed_tool.pack_engine(folder, out, prefix="strata-dsv41")
        return folder, out / Path(entry["url"]).name

    def test_a_downloaded_archive_is_checked_and_installed_beside_the_engine(self):
        _folder, archive = self.archive()
        lines = []
        exe = dsv41_engine.install_package(self.root / "data" / "engine-dsv41", archive, emit=lines.append)
        self.assertIsNotNone(exe, lines)
        self.assertTrue(exe.is_file())
        self.assertIn("signed, every file matches", " ".join(lines))
        self.assertEqual(self.tree(self.eng), self.before)

    def test_an_unpacked_folder_works_too(self):
        folder, _ = self.archive()
        exe = dsv41_engine.install_package(self.root / "data" / "engine-dsv41", folder)
        self.assertIsNotNone(exe)

    def test_a_damaged_file_is_refused_and_nothing_is_installed(self):
        folder, _ = self.archive()
        (folder / EXE).write_bytes(b"tampered")
        lines = []
        self.assertIsNone(dsv41_engine.install_package(self.root / "data" / "engine-dsv41", folder, emit=lines.append))
        self.assertIn("did not pass its check", " ".join(lines))
        dest = self.root / "data" / "engine-dsv41"
        self.assertFalse(dest.exists() and any(p.is_dir() for p in dest.iterdir()))

    def test_a_package_signed_by_an_unknown_key_is_refused(self):
        other = fx.make_key()
        folder = build(self.root / "foreign", "0.1.49", other)
        lines = []
        self.assertIsNone(dsv41_engine.install_package(self.root / "data" / "engine-dsv41", folder, emit=lines.append))
        self.assertIn("did not pass its check", " ".join(lines))

    def test_the_strata_engine_package_is_not_taken_for_deepseeks(self):
        src = self.root / "qsrc"
        src.mkdir()
        (src / "strata").write_bytes(b"qwen engine")
        folder = package_engine.build(src, "cuda", "0.1.49", components.host_platform(), self.root / "qout", entry="strata", archs=("sm_86",),
                                      min_driver={"nvidia": "580.65"}, build_id="q", variant="cuda13")
        feed_tool.sign_package(folder, self.key)
        lines = []
        self.assertIsNone(dsv41_engine.install_package(self.root / "data" / "engine-dsv41", folder, emit=lines.append))
        self.assertIn("not the DeepSeek engine", " ".join(lines))

    def test_a_missing_or_wrong_file_is_said_plainly(self):
        lines = []
        self.assertIsNone(dsv41_engine.install_package(self.root / "x", self.root / "nope.tar.gz", emit=lines.append))
        self.assertIn("is not there", " ".join(lines))
        junk = self.root / "notes.txt"
        junk.write_text("x")
        self.assertIsNone(dsv41_engine.install_package(self.root / "x", junk, emit=lines.append))
        self.assertIn("not a package file", " ".join(lines))

    def test_files_put_in_the_folder_are_found(self):
        _f, archive = self.archive()
        dest = self.root / "data" / "engine-dsv41"
        dest.mkdir(parents=True)
        shutil.copy(archive, dest / archive.name)
        (dest / "readme.txt").write_text("x")
        self.assertEqual([p.name for p in dsv41_engine.pending(dest)], [archive.name])


class HipPackageLibraryPath(unittest.TestCase):
    """A Windows HIP DeepSeek package keeps the ROCm DLLs in rocm/bin (hipBLAS / rocBLAS), exactly like the Qwen rdna3 engine package,
    so the engine's folder list must carry it or a clean PC starts with 0xC0000135 (found on strix, 2026-10-25)."""

    def package(self, build_json=None) -> Path:
        tmp = tempfile.TemporaryDirectory(prefix="strata-dsv41-hip-")
        self.addCleanup(tmp.cleanup)
        folder = Path(tmp.name) / "0.1.51-windows-x86_64-hip-rdna3"
        (folder / "rocm" / "bin").mkdir(parents=True)
        (folder / "rocm" / "bin" / "rocblas.dll").write_bytes(b"x")
        (folder / EXE).write_bytes(b"stub")
        if build_json is not None:
            (folder / "BUILD.json").write_text(json.dumps(build_json), encoding="utf-8")
        return folder

    def test_rocm_bin_comes_after_the_package_folder(self):
        folder = self.package({"lib_dirs": ["rocm/bin"]})
        self.assertEqual(dsv41_engine.lib_dirs(folder / EXE), [str(folder), str(folder / "rocm" / "bin")])
        env = dsv41_engine.start_env(folder / EXE, {"PATH": "C:\\Windows"})
        first = env["PATH"].split(os.pathsep)[:2]
        self.assertEqual(first, [str(folder), str(folder / "rocm" / "bin")])

    def test_a_cuda_package_needs_only_its_folder(self):
        folder = self.package(None)
        self.assertEqual(dsv41_engine.lib_dirs(folder / EXE), [str(folder)])

    def test_a_package_folder_missing_from_disk_is_skipped(self):
        folder = self.package({"lib_dirs": ["rocm/bin", "nope"]})
        self.assertEqual(dsv41_engine.lib_dirs(folder / EXE), [str(folder), str(folder / "rocm" / "bin")])

    def test_the_feed_offers_a_windows_hip_package_to_strix_halo_only(self):
        from strata_control import feed as feedmod
        p = {"version": "0.1.51", "platform": "windows-x86_64", "backend": "hip", "variant": "rdna3", "archs": ["gfx1151"],
             "min_driver": {}, "min_runtime": None, "build_id": "dsv41-hip", "format": "tar.gz", "url": "strata-dsv41-0.1.51-windows-x86_64-hip-rdna3.tar.gz",
             "size": 1, "sha256": "a" * 64, "manifest_sha256": "b" * 64, "installed_bytes": 2, "notes": ""}
        packages = [feedmod._engine_package(p)]
        halo = {"platform": "windows-x86_64", "backend": "hip", "runtime": None, "nvidia_driver": None, "cuda_archs": [], "gfx": ["gfx1151"]}
        best, _why = feedmod.select_engine(packages, halo)
        self.assertIsNotNone(best)
        self.assertEqual((best.platform, best.backend, best.variant), ("windows-x86_64", "hip", "rdna3"))
        for gfx in ("gfx1100", "gfx1201", "gfx1030"):
            other = {**halo, "gfx": [gfx]}
            self.assertIsNone(feedmod.select_engine(packages, other)[0], gfx)


if __name__ == "__main__":
    unittest.main()