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++
45.8 KB
Raw Blame
"""Tests for DeepSeek-V4.1-Flash in setup.py (MULTI_FILE_FAMILIES: nine pinned shards, its own engine strata-dsv41, several cards) and
for strata_control/dsv41_fit.py (where it fits, from the real numbers).  Mocked engine, downloads and processes - nothing is built,
fetched or started.

    python -m unittest tools.test_setup_dsv41
"""
from __future__ import annotations

import argparse
import contextlib
import os
import io
import json
import re
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))
sys.path.insert(0, str(ROOT / "tools"))
import setup  # noqa: E402
from strata_control import dsv41_fit  # noqa: E402

SHA = re.compile(r"/resolve/[0-9a-f]{40}/")
REPO = "unsloth/DeepSeek-V4.1-Flash-1017-GGUF"
R9700 = {"name": "AMD Radeon AI PRO R9700", "vram_gb": 32.0, "vendor": "amd"}
FOUR = [{**R9700, "index": i} for i in range(4)]


def args(**kw):
    base = dict(family="deepseek41", model=None, check=False, yes=True, vision=None, models_dir=None, gguf_dir=None, context=None,
                rope_scaling=None, rope_scale=None, kv=None, resident_budget_gib=None, low_ram="auto", vram_reserve_mib=None,
                host=None, api_key=None, browser=None, no_start=True, data_dir=None, gpu=None, gpus=None)
    base.update(kw)
    return argparse.Namespace(**base)


def run(fn, *a, **kw):
    out = io.StringIO()
    with contextlib.redirect_stdout(out):
        try:
            return fn(*a, **kw), out.getvalue()
        except SystemExit as e:
            return e.code, out.getvalue()


class Entries(unittest.TestCase):
    def test_pinned_and_hashed(self):
        fam = setup.MULTI_FILE_FAMILIES["deepseek41"]
        self.assertEqual(setup.HF_REVISIONS[REPO], "f924b94f19c1fea02c06a65c8475b0a45e2b88b1")
        self.assertRegex(fam["hf"], SHA)
        self.assertTrue(fam["hf"].endswith(f"{REPO}/resolve/f924b94f19c1fea02c06a65c8475b0a45e2b88b1/UD-Q8_K_XL/"))
        self.assertIs(setup.REPO_PINS[REPO], setup.DSV41_FILES)
        shards = fam["models"]["UD-Q8_K_XL"]["shards"]
        self.assertEqual(len(shards), 9)
        self.assertEqual(sum(setup.DSV41_FILES[n][0] for n in shards), 508_376_763_197)       # the nine shards: the pinned total
        self.assertEqual(setup.DSV41_FILES[shards[7]][0], dsv41_fit.ENGRAM_BYTES)             # shard 8 is the n-gram table
        for n, (size, sha) in setup.DSV41_FILES.items():
            self.assertRegex(sha, r"^[0-9a-f]{64}$", n)
            self.assertGreater(size, 5e6)
        self.assertEqual(setup.DSV41_FILES["mmproj-BF16.gguf"][0], 972_208_288)

    def test_not_a_pack_or_single_file_family(self):
        self.assertNotIn("deepseek41", setup.FAMILIES)
        self.assertNotIn("deepseek41", setup.OWN_PATH_FAMILIES)
        self.assertNotIn("UD-Q8_K_XL", setup.MODELS)

    def test_config_read_back(self):
        with tempfile.TemporaryDirectory() as d:
            p = Path(d) / "strata-deepseek-v4.1-flash-ud-q8_k_xl.json"
            p.write_text(json.dumps({"args": ["--pack", "x", "--max-context", "8192", "--tp", "2"], "port": 8080, "gpu": [0, 1, 2, 3]}))
            ch = setup.choices_from_config(p)
            self.assertEqual((ch["family"], ch["model"], ch["context"], ch["gpu"]), ("deepseek41", "UD-Q8_K_XL", 8192, [0, 1, 2, 3]))


class Fit(unittest.TestCase):
    def test_the_numbers_of_the_model(self):
        self.assertAlmostEqual(dsv41_fit.WEIGHTS_GB, 305.6, delta=0.1)
        self.assertAlmostEqual(dsv41_fit.EXPERTS_GB, 288.8, delta=0.1)
        self.assertAlmostEqual(dsv41_fit.ENGRAM_GB, 202.8, delta=0.1)
        self.assertAlmostEqual(dsv41_fit.DOWNLOAD_GB, 508.4, delta=0.1)
        self.assertEqual(dsv41_fit.EXPERTS, 15360)

    def test_four_amd_cards_run_the_ista_sets_with_a_plain_layer_split(self):
        # r9700, 2026-10-23: 8K prompt 370 tokens a second with --tp 1 against 196 with the engine's default (2)
        for model in ("IST-DAS-1.75bpw", "IST-DAS-2.00bpw", "IST-DAS-2.25bpw"):
            p = dsv41_fit.plan(FOUR, 251.0, 900.0, model=model)
            self.assertEqual((p["tp"], p["args"]), (1, ["--tp", "1"]), model)
        # two and three cards keep pairs; other makes keep pairs; one card needs no flag; the Unsloth set is not changed
        self.assertEqual(dsv41_fit.plan(FOUR[:2], 251.0, 900.0, model="IST-DAS-2.00bpw")["args"], ["--tp", "2"])
        self.assertEqual(dsv41_fit.plan(FOUR[:3], 251.0, 900.0, model="IST-DAS-2.00bpw")["args"], ["--tp", "2"])
        nv = [{"name": "NVIDIA GeForce RTX 3090", "vram_gb": 24.0, "vendor": "nvidia", "index": i} for i in range(4)]
        self.assertEqual(dsv41_fit.plan(nv, 251.0, 900.0, model="IST-DAS-2.00bpw")["args"], ["--tp", "2"])
        self.assertEqual(dsv41_fit.plan(FOUR[:1], 251.0, 900.0, model="IST-DAS-2.00bpw")["args"], [])
        self.assertEqual(dsv41_fit.plan(FOUR, 251.0, 900.0)["args"], ["--tp", "2"])

    def test_four_r9700_match_the_measured_run(self):
        # r9700, 2026-10-20: 1,558 + 1,559 + 1,575 + 1,505 = 6,197 experts in graphics memory, 9,163 (172.3 GB) on the CPU lane
        p = dsv41_fit.plan(FOUR, 251.0, 900.0)
        self.assertEqual(p["verdict"], "fits")
        self.assertAlmostEqual(p["experts_in_vram"], 6197, delta=100)
        self.assertAlmostEqual(p["cpu_experts_gb"], 172.3, delta=2.5)
        self.assertEqual([c["layers"] for c in p["cards"]], [[0, 9], [10, 19], [20, 29], [30, 39]])
        self.assertEqual(p["args"], ["--tp", "2"])
        self.assertTrue(p["disk_ok"])

    def test_one_card_and_little_ram_are_warnings(self):
        p = dsv41_fit.plan([{**R9700, "index": 0}], 64.0, 100.0)
        self.assertEqual(p["verdict"], "spills")
        self.assertEqual(p["args"], [])
        self.assertGreater(p["spill_gb"], 200)
        text = " ".join(p["warnings"])
        self.assertIn("read from the SSD", text)
        self.assertIn("free disk space", text)
        self.assertIn("still allowed", text)
        self.assertFalse(p["disk_ok"])

    def test_a_card_too_small_for_the_dense_weights_is_said(self):
        p = dsv41_fit.plan([{"index": 0, "name": "RTX 3060", "vram_gb": 12.0}], 128.0)
        self.assertTrue(any("dense weights" in w for w in p["warnings"]))

    def test_no_card(self):
        p = dsv41_fit.plan([], 128.0)
        self.assertEqual(p["verdict"], "no_card")
        self.assertTrue(any("No graphics card" in w for w in p["warnings"]))

    def test_cards_of_two_sizes_share_the_layers_in_proportion(self):
        cards = [{**R9700, "index": 0}, {"name": "RTX A4000", "vram_gb": 16.0, "index": 1}]
        p = dsv41_fit.plan(cards, 256.0)
        a, b = p["cards"]
        self.assertGreater(a["layers"][1] - a["layers"][0], b["layers"][1] - b["layers"][0])
        self.assertEqual(b["layers"][1], 39)
        self.assertGreater(a["experts"], b["experts"])

    def test_split_layers_covers_every_layer(self):
        for w in ([1, 1, 1, 1], [32, 16], [8, 8, 8], [32, 32, 16, 12, 12]):
            r = dsv41_fit.split_layers(w)
            self.assertEqual(r[0][0], 0)
            self.assertEqual(r[-1][1], 39)
            self.assertTrue(all(a[1] + 1 == b[0] for a, b in zip(r, r[1:])))

    def test_options_like_gpu_fit(self):
        o = dsv41_fit.options(FOUR, 251.0, "amd")
        self.assertEqual(o["recommended"], "all")
        self.assertEqual([x["key"] for x in o["options"]], ["all", "single"])
        self.assertEqual(o["options"][0]["cards"], [0, 1, 2, 3])
        self.assertTrue(o["options"][0]["recommended"])


class Install(unittest.TestCase):
    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory()
        self.addCleanup(self.tmp.cleanup)
        self.root = Path(self.tmp.name)
        self.calls = []
        self.github_up = True
        self.cfg = {}
        self.exe = self.root / "engine" / ("strata-dsv41.exe" if setup.WIN else "strata-dsv41")
        eng = self.root / "engine"

        def engine_step(a, gpu, hip, amd, cuda_tk, vision):
            self.calls.append(("engine", vision))
            eng.mkdir(parents=True, exist_ok=True)
            return self.root / "llama", eng, {"version": "0.2.2"}, ["/libs"], gpu, vision

        def write_cfg(path, cfg, source=None, explicit=None):
            self.cfg = cfg
            self.calls.append(("config", path.name))

        patches = [mock.patch.object(setup, "download", lambda url, dst, what=None: self.calls.append(("get", url, dst))),
                   mock.patch.object(setup, "verify_sha256", lambda s, size, sha, own=False: self.calls.append(("sha", s.name, own))),
                   mock.patch.object(setup, "free_gb", lambda p: 900.0),
                   mock.patch.object(setup, "github_reachable", lambda timeout=10.0: self.github_up),
                   mock.patch.object(setup, "pip_install", lambda *a, **k: None),
                   mock.patch.object(setup, "engine_step", engine_step),
                   mock.patch.object(setup, "run", lambda cmd, **k: self.calls.append(("run", cmd))),
                   mock.patch.object(setup, "data_folder", lambda d, *a, **k: (self.root / "data", [])),
                   mock.patch.object(setup, "write_setup_config", write_cfg),
                   mock.patch.object(setup, "write_run_script", lambda tag, p, port, o=True: self.root / f"run-{tag}.sh"),
                   mock.patch.object(setup, "ROOT", self.root),
                   mock.patch.object(setup, "home", lambda: self.root)]
        for p in patches:
            p.start()
            self.addCleanup(p.stop)
        mock.patch.dict("os.environ", {"STRATA_DSV41_EXE": ""}).start()
        self.addCleanup(mock.patch.stopall)

    def install(self, ram=251.0, cards=None, engine=True, **kw):
        if engine:
            self.exe.parent.mkdir(parents=True, exist_ok=True)
            self.exe.write_text("x")
        cards = cards or FOUR
        kw.setdefault("model", "UD-Q8_K_XL")
        kw.setdefault("vision", "no")            # the older tests are about the files of the model; pictures-on has its own tests (PicturesByDefault)
        gpu = {"index": 0, "count": len(cards), "vram_gb": 32.0, "name": "R9700", "cards": cards}
        return run(setup.install_dsv41, args(models_dir=str(self.root / "models"), **kw), "deepseek41", gpu, True, [], 13, [], 8080, ram,
                   None, cards)

    def test_installs_the_nine_pinned_shards_and_writes_the_config(self):
        rc, out = self.install()
        self.assertEqual(rc, 0, out)
        get = [c for c in self.calls if c[0] == "get"]
        folder = self.root / "models" / "deepseek-v4.1-flash-UD-Q8_K_XL"
        self.assertEqual([c[2] for c in get], [folder / setup.DSV41_SHARD.format(i=i) for i in range(1, 10)])
        self.assertEqual(get[1][1], setup.hf(REPO) + "UD-Q8_K_XL/" + setup.DSV41_SHARD.format(i=2))
        self.assertEqual(sum(1 for c in self.calls if c[0] == "sha"), 9)
        pack = [c for c in self.calls if c[0] == "run"][-1][1]
        self.assertIn("pack_gguf.py", " ".join(map(str, pack)))
        self.assertEqual(self.cfg["arch"], "deepseek41")
        self.assertEqual(self.cfg["exe"], str(self.exe))
        self.assertEqual(self.cfg["model_name"], "deepseek-v4.1-flash")
        a = self.cfg["args"]
        self.assertEqual(a[a.index("--max-context") + 1], "8192")
        self.assertEqual(a[a.index("--eos") + 1], "1")
        self.assertEqual(a[a.index("--tp") + 1], "2")
        self.assertTrue(Path(a[a.index("--pack") + 1]).match("*packs/deepseek-v4.1-flash-ud-q8_k_xl"))
        self.assertEqual(self.cfg["gpu"], [0, 1, 2, 3])
        self.assertEqual(self.cfg["engine_ready_s"], 3600)
        self.assertEqual(self.cfg["backend"], "hip")
        self.assertTrue(self.cfg["tokenizer"].endswith("tokenizer"))
        self.assertEqual(a[a.index("--vision") + 1], "off")     # (this test asks for no pictures: they are on by default, see PicturesByDefault)
        self.assertNotIn("--mtp", a)
        self.assertIn("4 cards, one block of layers on each", out)
        self.assertIn("n-gram table", out)

    def test_no_engine_stops_before_the_download(self):
        rc, out = self.install(engine=False)
        self.assertEqual(rc, 1, out)
        self.assertIn("DeepSeek's engine is not available for this computer yet", out)
        self.assertIn("RTX 30, 40 and 50", out)
        self.assertNotIn("cmake", out)
        self.assertNotIn("STRATA_DSV41_EXE", out)
        self.assertIn("Nothing has been downloaded", out)
        self.assertFalse([c for c in self.calls if c[0] == "get"])

    def test_own_files_are_checked_not_downloaded(self):
        own = self.root / "own"
        own.mkdir()
        for i in range(1, 10):
            (own / setup.DSV41_SHARD.format(i=i)).write_bytes(b"GGUF")
        rc, out = self.install(gguf_dir=str(own))
        self.assertEqual(rc, 0, out)
        self.assertFalse([c for c in self.calls if c[0] == "get"])
        self.assertTrue(all(c[2] for c in self.calls if c[0] == "sha"))        # own=True: setup never deletes the person's file
        pack = [c for c in self.calls if c[0] == "run"][-1][1]
        self.assertIn(str(own), pack)

    def test_a_missing_own_shard_is_said(self):
        own = self.root / "own"
        own.mkdir()
        for i in (1, 2, 3):
            (own / setup.DSV41_SHARD.format(i=i)).write_bytes(b"GGUF")
        rc, out = self.install(gguf_dir=str(own))
        self.assertEqual(rc, 1, out)
        self.assertIn("00004-of-00009.gguf is missing", out)

    def test_the_repository_layout_is_found(self):
        own = self.root / "repo"
        (own / "UD-Q8_K_XL").mkdir(parents=True)
        for i in range(1, 10):
            (own / "UD-Q8_K_XL" / setup.DSV41_SHARD.format(i=i)).write_bytes(b"GGUF")
        rc, out = self.install(gguf_dir=str(own))
        self.assertEqual(rc, 0, out)
        pack = [c for c in self.calls if c[0] == "run"][-1][1]
        self.assertIn(str(own / "UD-Q8_K_XL"), pack)

    def test_little_ram_is_asked_and_kept_with_an_explicit_model(self):
        rc, out = self.install(ram=64.0, cards=FOUR[:1])
        self.assertEqual(rc, 0, out)
        self.assertIn("read from the SSD", out)
        self.assertIn("installing UD-Q8_K_XL with 64 GB of RAM, as you chose", out)
        self.assertEqual(self.cfg["args"][self.cfg["args"].index("--max-context") + 1], "8192")
        self.assertNotIn("--tp", self.cfg["args"])

    def test_little_ram_with_yes_alone_stops_where_the_rule_says(self):
        rc, out = self.install(ram=24.0, cards=FOUR[:1], model=None)        # the version was not chosen on the command line
        self.assertEqual(rc, 1, out)
        self.assertIn("more RAM or cards fix it", out)
        self.assertFalse([c for c in self.calls if c[0] == "get"])

    def test_a_disk_that_cannot_hold_the_files_is_the_one_hard_stop(self):
        with mock.patch.object(setup, "free_gb", lambda p: 100.0):
            rc, out = self.install()
        self.assertEqual(rc, 1, out)
        self.assertIn("not enough free disk space", out)
        self.assertIn("an NVMe drive is best", out)
        self.assertFalse([c for c in self.calls if c[0] == "get"])

    def test_pictures_and_flash_next_settings_are_said(self):
        rc, out = self.install(vision="yes", kv="int8", context=131072)
        self.assertEqual(rc, 0, out)
        self.assertNotIn("cannot read pictures", out)                          # 0.2.7: the engine's own tower reads them
        a = self.cfg["args"]
        self.assertEqual(a[a.index("--vision") + 1], "on")
        self.assertIn("Flash-Next settings", out)
        self.assertEqual(self.cfg["args"][self.cfg["args"].index("--max-context") + 1], "131072")
        self.assertIn("checked at 4K and 8K", out)


class Catalog(unittest.TestCase):
    def test_the_mcp_catalog_lists_the_size(self):
        import strata_mcp as M
        s = M.Strata(ROOT)
        fam = next(f for f in s.model_table({"ram_gb": 251.0, "gpus": [{**c, "usable": True} for c in FOUR], "engine_vendor": "amd"})
                   if f["family"] == "deepseek41")
        self.assertEqual([x["model"] for x in fam["sizes"]], ["IST-DAS-2.00bpw", "IST-DAS-2.25bpw", "IST-DAS-1.75bpw", "UD-Q8_K_XL"])
        small_sets = {x["model"]: x for x in fam["sizes"]}
        self.assertEqual((small_sets["IST-DAS-2.00bpw"]["download_gb"], small_sets["IST-DAS-2.25bpw"]["download_gb"]), (256.8, 273.8))
        self.assertTrue(small_sets["IST-DAS-2.00bpw"]["on_this_pc"].startswith("fits"))
        size = small_sets["UD-Q8_K_XL"]
        self.assertEqual((size["model"], size["id"], size["download_gb"], size["images"]), ("UD-Q8_K_XL", "deepseek-v4.1-flash-ud-q8_k_xl", 508.4, True))
        self.assertTrue(size["on_this_pc"].startswith("fits"))
        self.assertTrue(size["mem_total"] and size["multi_file"])
        self.assertEqual(size["gpu_options"]["recommended"], "all")
        small = next(f for f in s.model_table({"ram_gb": 32.0, "gpus": []}) if f["family"] == "deepseek41")
        self.assertTrue(all(x["on_this_pc"].startswith("does not fit") for x in small["sizes"]))      # no card

    def test_each_set_states_the_free_disk_it_needs_from_the_set_itself(self):
        """The app's DeepSeek card says "Needs about N GB of free disk space": N is the set's whole download plus the pack and room to work, per set."""
        import strata_mcp as M
        s = M.Strata(ROOT)
        table = s.model_table({"ram_gb": 251.0, "gpus": [{**c, "usable": True} for c in FOUR], "engine_vendor": "amd"})
        fam = next(f for f in table if f["family"] == "deepseek41")
        for size in fam["sizes"]:
            self.assertEqual(size["disk_gb"], round(size["download_gb"] + dsv41_fit.DISK_HEADROOM_GB, 1), size["model"])
        by = {x["model"]: x["disk_gb"] for x in fam["sizes"]}
        self.assertNotEqual(by["IST-DAS-2.00bpw"], by["IST-DAS-2.25bpw"], "2.00 and 2.25 do not need the same disk")
        self.assertGreater(by["IST-DAS-2.25bpw"], by["IST-DAS-2.00bpw"])
        self.assertGreater(by["IST-DAS-2.00bpw"], by["IST-DAS-1.75bpw"])
        for f in table:
            if f["family"] != "deepseek41":
                self.assertTrue(all(x["disk_gb"] is None for x in f["sizes"]), f["family"])

    def test_the_install_plan(self):
        import strata_mcp as M
        s = M.Strata(ROOT)
        s.hardware = lambda fresh=False: {"ram_gb": 251.0, "gpus": [{**c, "usable": True} for c in FOUR], "engine_vendor": "amd",
                                          "cpu": {"avx2": True}}
        s.disk_free = lambda p: 2000.0
        plan, a = M.Tools(s).install_plan("deepseek41", "UD-Q8_K_XL", None, None, None, None, None, None, None, None, None)
        self.assertEqual((plan["title"], plan["download_gb"], plan["context"], plan["images"]), ("DeepSeek-V4.1-Flash UD-Q8_K_XL", 508.4, 8192, "yes"))   # 0.2.7: pictures on by default
        self.assertEqual(a[:6], ["--yes", "--no-start", "--family", "deepseek41", "--model", "UD-Q8_K_XL"])
        self.assertTrue(plan["ram"].startswith("fits"))
        for flag in ("--kv", "--low-ram", "--experimental-speed-projection"):
            self.assertNotIn(flag, a)
        files = M.expected_files(s.setup_module(), "deepseek41", "UD-Q8_K_XL", Path("/m"), False)
        self.assertEqual(len(files), 9)
        self.assertEqual(sum(f["bytes"] for f in files), 508_376_763_197)


ISTA = "IST-DAS-2.00bpw"
RTX5070 = {"index": 0, "name": "NVIDIA GeForce RTX 5070", "vram_gb": 12.0, "vendor": "nvidia"}


class NoNetwork(Install):
    """GitHub cannot be reached (a connection that is never answered): one plain line at once, not minutes of retries; and the Strata engine is not used."""

    def test_unreachable_github_is_one_plain_line_before_anything_is_downloaded(self):
        self.github_up = False
        rc, out = self.install(engine=False)
        self.assertEqual(rc, 1, out)
        self.assertIn("Strata can't reach GitHub to download the DeepSeek engine.", out)
        self.assertIn("Check the internet connection and run the same command again.", out)
        self.assertFalse([c for c in self.calls if c[0] == "get"])

    def test_a_local_feed_needs_no_github(self):
        """A run on a local feed (a folder, a loopback address) downloads nothing from GitHub: a slow or down GitHub must not stop it."""
        self.github_up = False
        with mock.patch.dict("os.environ", {"STRATA_UPDATE_FEED": str(self.root / "feed")}):
            rc, out = self.install(engine=False)
        self.assertNotIn("can't reach GitHub", out)

    def test_a_package_the_person_has_needs_no_github(self):
        self.github_up = False
        self.install(engine=False)                                    # (the first run only creates the folders)
        pk = self.root / "engine-dsv41"
        pk.mkdir(exist_ok=True)
        (pk / "strata-dsv41-0.1.49-x.tar.gz").write_bytes(b"x")
        with mock.patch.object(setup.dsv41_engine_module if hasattr(setup, "dsv41_engine_module") else __import__("strata_control.dsv41_engine", fromlist=["x"]),
                               "install_package", lambda *a, **k: None):
            rc, out = self.install(engine=False)
        self.assertNotIn("can't reach GitHub", out)

    def test_the_strata_engine_is_not_part_of_a_deepseek_install(self):
        rc, out = self.install()
        self.assertEqual(rc, 0, out)
        self.assertFalse([c for c in self.calls if c[0] == "engine"])        # engine_step is not called any more
        self.assertIn("DeepSeek engine", out)


class GithubCheck(unittest.TestCase):
    def test_github_reachable_answers_quickly_in_both_directions(self):
        import urllib.error
        with mock.patch.object(setup, "_urlopen", side_effect=urllib.error.URLError("timed out")):
            self.assertFalse(setup.github_reachable(1))
        with mock.patch.object(setup, "_urlopen", side_effect=OSError("unreachable")):
            self.assertFalse(setup.github_reachable(1))
        with mock.patch.object(setup, "_urlopen", side_effect=urllib.error.HTTPError("https://github.com", 403, "no", {}, None)):
            self.assertTrue(setup.github_reachable(1))                       # any answer means it is reachable
        with mock.patch.object(setup, "_urlopen", return_value=mock.MagicMock()):
            self.assertTrue(setup.github_reachable(1))

    def test_a_local_feed_is_told_from_the_signed_one(self):
        for feed in ("C:/feeds/f", "/tmp/feed", "file:///tmp/feed", "http://127.0.0.1:8099/feed.json", "https://localhost/f"):
            self.assertTrue(setup.local_feed(feed), feed)
        for feed in (None, "", "https://github.com/Niko1221/Strata/releases/latest/download/feed.json"):
            with mock.patch.dict("os.environ", {"STRATA_UPDATE_FEED": ""}):
                self.assertFalse(setup.local_feed(feed), feed)
        with mock.patch.dict("os.environ", {"STRATA_UPDATE_FEED": "/tmp/x"}):
            self.assertTrue(setup.local_feed())                              # the environment names it when --feed does not


class OfficialSets(unittest.TestCase):
    """The two official IST-DAS sets (ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF): the catalog, the pins, the pack recipe, the fit words."""

    def test_the_pinned_files(self):
        fam = setup.MULTI_FILE_FAMILIES["deepseek41"]
        self.assertEqual(list(fam["models"]), ["IST-DAS-2.00bpw", "IST-DAS-2.25bpw", "IST-DAS-1.75bpw", "UD-Q8_K_XL"])         # the official sets first
        repo = "ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF"
        self.assertEqual(setup.HF_REVISIONS[repo], "cb02422c900df489cea5833e8a92171224059b3c")
        self.assertIs(setup.REPO_PINS[repo], setup.DSV41_ISTA_FILES)
        self.assertNotIn("helcig/tmp-oct26-2", setup.HF_REVISIONS)           # the first release's repository is only remembered as local names
        self.assertEqual(setup.DSV41_ISTA_REPO, repo)
        self.assertEqual(len(setup.DSV41_ISTA_FILES), 13)                      # 3 x 4 shards + the Engram
        for n, (size, sha) in setup.DSV41_ISTA_FILES.items():
            self.assertRegex(sha, r"^[0-9a-f]{64}$", n)
        eng = setup.DSV41_ISTA_FILES["DeepSeek-V4.1-Flash-Engram-IQ4_NL.gguf"]
        self.assertEqual(eng, (110_595_290_816, "eb19f30d368d393784e1fc54fdfaffc427ebb2110bf3762fdf5a8fbb9a2d740a"))
        self.assertEqual(setup.DSV41_ALL_FILES["dspark-DeepSeek-V4.1-Flash-1017-Q8_0.gguf"],
                         (7_976_914_240, "6ba6ac1b331c540691a209e7fc97dec2a24e295acb1e755c84c7d24a4373927a"))
        sums = {m: sum(setup.DSV41_ALL_FILES[n][0] for n in fam["models"][m]["shards"]) for m in list(fam["models"])[:3]}
        self.assertEqual(sums, {"IST-DAS-2.00bpw": 138238893056, "IST-DAS-2.25bpw": 155225824256, "IST-DAS-1.75bpw": 120721120256})
        self.assertEqual(sums["IST-DAS-1.75bpw"], dsv41_fit.ISTA_SETS["IST-DAS-1.75bpw"]["set_bytes"])
        self.assertEqual(sums["IST-DAS-2.00bpw"], dsv41_fit.ISTA_SETS["IST-DAS-2.00bpw"]["set_bytes"])
        self.assertEqual(sums["IST-DAS-2.25bpw"], dsv41_fit.ISTA_SETS["IST-DAS-2.25bpw"]["set_bytes"])
        self.assertEqual(setup.DSV41_ISTA_FILES["DeepSeek-V4.1-Flash-Engram-IQ4_NL.gguf"][0], dsv41_fit.ISTA_ENGRAM_BYTES)
        for m in ("IST-DAS-2.00bpw", "IST-DAS-2.25bpw"):                        # both sets name the same shared files: the Engram is downloaded once
            self.assertEqual(fam["models"][m]["shared"], [setup.DSV41_ISTA_ENGRAM, setup.DSV41_SHARD.format(i=1), setup.DSV41_DSPARK])
            for n in fam["models"][m]["shared"]:
                self.assertIn(n, setup.DSV41_SHARED)
                self.assertIn(n, setup.DSV41_ALL_FILES)
        self.assertRegex(setup.DSV41_SHARED[setup.DSV41_ISTA_ENGRAM], r"ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF/resolve/cb02422c[0-9a-f]{32}/$")
        self.assertRegex(fam["models"]["IST-DAS-2.25bpw"]["hf"], r"ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF/resolve/cb02422c[0-9a-f]{32}/$")

    def test_shipped_profiles_match_their_hashes(self):
        import hashlib
        for n in ("profile-2.00.bin", "profile-2.25.bin"):
            data = (setup.DSV41_PROFILES / n).read_bytes()
            self.assertEqual(len(data), 66048)                                 # uint32 [43][384]
            want = (setup.DSV41_PROFILES / (n + ".sha256")).read_text().split()[0]
            self.assertEqual(hashlib.sha256(data).hexdigest(), want)

    def test_the_pack_recipe_is_the_plain_one(self):
        folder, pack = Path("/m/set"), Path("/d/pack")
        names = [f"DeepSeek-V4.1-Flash-1017-GSQ-RCO-IQ2_XXS-{i:05d}-of-00004.gguf" for i in range(1, 5)]
        cmd = setup.dsv41_pack_cmd(folder, names, Path("/s/engram-IQ4_NL.gguf"), Path("/s/meta.gguf"), Path("/s/dspark.gguf"), pack)
        self.assertTrue(cmd[1].endswith("pack_gguf.py"))
        self.assertEqual(cmd[2:], ["--model", str(folder), "--shards", *names, "--engram", str(Path("/s/engram-IQ4_NL.gguf")),
                                   "--engram-meta", str(Path("/s/meta.gguf")), "--dspark-gguf", str(Path("/s/dspark.gguf")),
                                   "--dspark-noise-token", "128799", "--dspark-markov-rank", "256", "--out", str(pack)])
        for bad in ("--skip-tensors", "--dense-override", "--override-experts", "--tq-experts"):      # these give garbage text on the official sets
            self.assertNotIn(bad, cmd)

    def test_fit_words_use_the_measured_numbers(self):
        for ram, verdict in ((64.0, "tight"), (46.0, "tight"), (24.0, "spills"), (256.0, "fits")):
            p = dsv41_fit.plan([RTX5070], ram, None, model=ISTA)
            self.assertEqual(p["verdict"], verdict, ram)
            self.assertAlmostEqual(p["download_gb"], 256.8, delta=0.1)
            self.assertEqual(p["args"], [])
        p = dsv41_fit.plan([RTX5070], 64.0, 100.0, model=ISTA)
        text = " ".join(p["lines"]) + " ".join(p["warnings"])
        for needle in ("4.7", "7.2", "31 tokens a second", "free disk space", "only once" if False else "downloads it once"):
            self.assertIn(needle, text)
        self.assertFalse(p["disk_ok"])
        p225 = dsv41_fit.plan([RTX5070], 64.0, None, model="IST-DAS-2.25bpw")
        self.assertAlmostEqual(p225["download_gb"], 273.8, delta=0.1)
        self.assertEqual(dsv41_fit.plan([], 64.0, None, model=ISTA)["verdict"], "no_card")
        self.assertEqual(dsv41_fit.plan([RTX5070], 64.0, None, model="UD-Q8_K_XL")["verdict"], "spills")        # the big set is unchanged


class EnginePackage(unittest.TestCase):
    """DeepSeek's engine is its own package beside the engine; the Qwen engine folder is never written."""

    def test_the_package_folder_is_beside_the_engine(self):
        self.assertEqual(setup.dsv41_engine_dir(Path("/d/engine")), Path("/d") / "engine-dsv41")

    def test_the_own_package_is_found_before_the_old_place(self):
        with tempfile.TemporaryDirectory() as d, mock.patch.dict("os.environ", {"STRATA_DSV41_EXE": ""}):
            eng = Path(d) / "engine"
            eng.mkdir()
            name = "strata-dsv41.exe" if setup.WIN else "strata-dsv41"
            self.assertIsNone(setup.dsv41_exe(eng))
            (eng / name).write_text("old")
            self.assertEqual(setup.dsv41_exe(eng), eng / name)                 # an all-in-one engine still works
            (Path(d) / "engine-dsv41" / "0.1.49-x").mkdir(parents=True)
            (Path(d) / "engine-dsv41" / "0.1.49-x" / name).write_text("new")
            self.assertEqual(setup.dsv41_exe(eng), Path(d) / "engine-dsv41" / "0.1.49-x" / name)


class SharedFiles(unittest.TestCase):
    def test_the_drafter_beside_the_sets_folder_is_found_from_the_set_folder(self):
        with tempfile.TemporaryDirectory() as d:
            root = Path(d)
            (root / "off" / "2.00bpw").mkdir(parents=True)
            (root / "dspark").mkdir()
            f = root / "dspark" / setup.DSV41_DSPARK
            f.write_bytes(b"x")
            a = argparse.Namespace(gguf_dir=str(root / "off" / "2.00bpw"))
            with mock.patch.dict(setup.DSV41_ALL_FILES, {setup.DSV41_DSPARK: (1, "0" * 64)}):
                got = setup.dsv41_find_shared(a, setup.DSV41_DSPARK, root / "off" / "2.00bpw", root / "models" / "shared")
            self.assertEqual(got, f)


class LegacyFiles(unittest.TestCase):
    """Files of the first release (model-2.00bpw-0000N-of-00004.gguf, engram-IQ4_NL.gguf, often in a 2.00bpw/ folder) are the same weights: accepted."""

    def test_the_old_pins_are_the_old_files_and_the_unchanged_shards_match_today_s(self):
        for i in (2, 3, 4):                                                   # same bytes: same size and SHA-256 under both names
            new = setup.DSV41_ISTA_SHARD.format(quant="IQ2_XXS", i=i)
            self.assertEqual(setup.DSV41_ALL_FILES[new], setup.DSV41_LEGACY_FILES["model-2.00bpw-%05d-of-00004.gguf" % i])
            new = setup.DSV41_ISTA_SHARD.format(quant="IQ2_XS", i=i)
            self.assertEqual(setup.DSV41_ALL_FILES[new], setup.DSV41_LEGACY_FILES["model-2.25bpw-%05d-of-00004.gguf" % i])
        self.assertNotEqual(setup.DSV41_ALL_FILES[setup.DSV41_ISTA_SHARD.format(quant="IQ2_XXS", i=1)],
                            setup.DSV41_LEGACY_FILES["model-2.00bpw-00001-of-00004.gguf"])        # shard 1 and the Engram differ in their header only
        self.assertNotIn("model-2.00bpw-00001-of-00004.gguf", setup.DSV41_ISTA_FILES)                 # (never downloaded under the old names)
        self.assertNotIn("model-2.00bpw-00001-of-00004.gguf", setup.REPO_PINS["ISTA-DASLab/DeepSeek-V4.1-Flash-1017-GSQ-RCO-GGUF"])

    def test_pick_prefers_today_s_name_then_the_old_one(self):
        with tempfile.TemporaryDirectory() as d:
            folder = Path(d)
            new = setup.DSV41_ISTA_SHARD.format(quant="IQ2_XXS", i=2)
            self.assertEqual(setup.dsv41_pick(folder, new), folder / new)                  # nothing there: where it will be downloaded
            (folder / "model-2.00bpw-00002-of-00004.gguf").write_bytes(b"x")
            self.assertEqual(setup.dsv41_pick(folder, new).name, "model-2.00bpw-00002-of-00004.gguf")
            (folder / new).write_bytes(b"y")
            self.assertEqual(setup.dsv41_pick(folder, new).name, new)

    def test_the_folder_of_the_first_release_is_found_from_the_parent(self):
        with tempfile.TemporaryDirectory() as d:
            sub = Path(d) / "2.00bpw"
            sub.mkdir()
            (sub / "model-2.00bpw-00001-of-00004.gguf").write_bytes(b"x")
            fam = setup.MULTI_FILE_FAMILIES["deepseek41"]
            a = argparse.Namespace(gguf_dir=d, models_dir=d)
            self.assertEqual(setup.dsv41_folder(a, fam, "t", "IST-DAS-2.00bpw"), sub)
            a2 = argparse.Namespace(gguf_dir=str(sub), models_dir=d)
            self.assertEqual(setup.dsv41_folder(a2, fam, "t", "IST-DAS-2.00bpw"), sub)

    def test_the_old_engram_name_is_found(self):
        with tempfile.TemporaryDirectory() as d:
            sub = Path(d) / "2.00bpw"
            sub.mkdir()
            old = sub / "engram-IQ4_NL.gguf"
            old.write_bytes(b"e")
            a = argparse.Namespace(gguf_dir=d)
            with mock.patch.dict(setup.DSV41_ALL_FILES, {"engram-IQ4_NL.gguf": (1, "0" * 64)}):
                got = setup.dsv41_find_shared(a, setup.DSV41_ISTA_ENGRAM, sub, Path(d) / "shared")
            self.assertEqual(got, old)


class Smallest(unittest.TestCase):
    """IST-DAS 1.75 bpw (IQ1_M): the smallest official set, recommended where 2.00 is tight, never forced."""

    def test_the_files_the_pins_and_the_recipe(self):
        fam = setup.MULTI_FILE_FAMILIES["deepseek41"]
        d = fam["models"]["IST-DAS-1.75bpw"]
        self.assertEqual(d["recipe"], "ista")
        self.assertEqual(d["shards"], [f"DeepSeek-V4.1-Flash-1017-GSQ-RCO-IQ1_M-{i:05d}-of-00004.gguf" for i in range(1, 5)])
        self.assertEqual(d["shared"], fam["models"]["IST-DAS-2.00bpw"]["shared"])              # the same Engram, drafter and metadata shard
        self.assertEqual(setup.DSV41_ISTA_FILES[d["shards"][0]],
                         (39358830464, "6e3f0d5ff53d00428ec32c079db9e8255cb410ccaa435e5342aaa8a47fe1339d"))
        self.assertEqual(setup.DSV41_ISTA_FILES[d["shards"][3]][0], 2188841824)
        self.assertEqual(sum(setup.DSV41_ISTA_FILES[n][0] for n in d["shards"]), 120_721_120_256)
        self.assertTrue(all(n not in setup.DSV41_LEGACY_NAMES.values() for n in d["shards"]))     # no first-release names for it
        for n, (size, sha) in setup.DSV41_NEW_SHARD1.items():                                     # shard 1 after ISTA's 2026-10-26 template update
            self.assertIn(n, setup.DSV41_ISTA_FILES)
            self.assertNotEqual(setup.DSV41_ISTA_FILES[n][0], size)
            self.assertNotEqual(setup.DSV41_ISTA_FILES[n][1], sha)
        cmd = setup.dsv41_pack_cmd(Path("/m"), d["shards"], Path("/s/e.gguf"), Path("/s/m.gguf"), Path("/s/d.gguf"), Path("/p"))
        self.assertIn("--dspark-noise-token", cmd)
        self.assertNotIn("--skip-tensors", cmd)

    def test_it_is_the_smallest_and_warns_never_refuses(self):
        sizes = {m: dsv41_fit.ista_download_bytes(m) / 1e9 for m in dsv41_fit.ISTA_SETS}
        self.assertEqual(min(sizes, key=sizes.get), "IST-DAS-1.75bpw")
        self.assertAlmostEqual(sizes["IST-DAS-1.75bpw"], 239.3, delta=0.1)
        for ram in (24.0, 36.0, 64.0):
            p = dsv41_fit.plan([RTX5070], ram, None, model="IST-DAS-1.75bpw")
            self.assertIn(p["verdict"], ("fits", "tight", "spills"))
            self.assertTrue(p["lines"])
        self.assertEqual(dsv41_fit.plan([RTX5070], 36.0, None, model="IST-DAS-1.75bpw")["verdict"], "tight")      # runs where 2.00 spills
        self.assertEqual(dsv41_fit.plan([RTX5070], 36.0, None, model="IST-DAS-2.00bpw")["verdict"], "spills")

    def test_it_is_recommended_where_2_00_is_tight(self):
        self.assertEqual(dsv41_fit.recommend(64.0, 900.0), "IST-DAS-2.00bpw")
        self.assertEqual(dsv41_fit.recommend(None, None), "IST-DAS-2.00bpw")                   # unknown: the usual one
        self.assertEqual(dsv41_fit.recommend(32.0, 900.0), "IST-DAS-1.75bpw")                  # less RAM than 2.00 was measured with
        self.assertEqual(dsv41_fit.recommend(64.0, 250.0), "IST-DAS-1.75bpw")                  # disk fits 1.75 (239 + 6) but not 2.00 (257 + 6)
        self.assertEqual(dsv41_fit.recommend(64.0, 100.0), "IST-DAS-2.00bpw")                  # fits neither: no reason to prefer it

    def test_the_menu_marks_the_recommendation_and_still_lets_anyone_choose(self):
        import io
        names = list(setup.MULTI_FILE_FAMILIES["deepseek41"]["models"])
        self.assertIn("IST-DAS-1.75bpw", names)
        self.assertEqual(names.index(dsv41_fit.recommend(32.0, 900.0)) + 1, 3)


class InstallOfficial(Install):
    """install_dsv41 for an official set, the engine and the tools mocked."""

    def install_ista(self, model=ISTA, ram=64.0, **kw):
        self.packinfo_ok = True
        self.smoke_ok = True
        patches = [mock.patch.object(setup, "dsv41_pack_info", lambda exe, pack, libs: (self.packinfo_ok, "files: 6, all present and long enough")),
                   mock.patch.object(setup, "dsv41_smoke", lambda *a, **k: (self.smoke_ok, "The capital of France is Paris.")
                                     if self.smoke_ok else (False, "test question failed: the answer is empty"))]
        for p in patches:
            p.start()
            self.addCleanup(p.stop)
        return self.install(ram=ram, cards=[RTX5070], model=model, **kw)

    def test_downloads_the_set_the_engram_once_and_the_drafter(self):
        rc, out = self.install_ista()
        self.assertEqual(rc, 0, out)
        get = [c for c in self.calls if c[0] == "get"]
        folder = self.root / "models" / "deepseek-v4.1-flash-IST-DAS-2.00bpw"
        shared = self.root / "models" / "deepseek-v4.1-flash-shared"
        self.assertEqual([c[2] for c in get][:4], [folder / f"DeepSeek-V4.1-Flash-1017-GSQ-RCO-IQ2_XXS-{i:05d}-of-00004.gguf" for i in range(1, 5)])
        self.assertEqual([c[2] for c in get][4:], [shared / setup.DSV41_ISTA_ENGRAM, shared / setup.DSV41_SHARD.format(i=1),
                                                  shared / setup.DSV41_DSPARK])
        self.assertTrue(get[0][1].endswith("/DeepSeek-V4.1-Flash-1017-GSQ-RCO-IQ2_XXS-00001-of-00004.gguf"))
        self.assertNotIn("/2.00bpw/", get[0][1])             # the repository is flat
        self.assertEqual(sum(1 for c in self.calls if c[0] == "sha"), 7)
        pack = [c for c in self.calls if c[0] == "run"][-1][1]
        self.assertIn("--engram-meta", pack)
        self.assertNotIn("--skip-tensors", pack)

    def test_the_second_set_does_not_download_the_engram_again(self):
        shared = self.root / "models" / "deepseek-v4.1-flash-shared"
        shared.mkdir(parents=True)
        shared_names = (setup.DSV41_ISTA_ENGRAM, setup.DSV41_SHARD.format(i=1), setup.DSV41_DSPARK)
        for n in shared_names:
            (shared / n).write_bytes(b"x")
            (shared / (n + ".done")).write_text("ok")
        tiny = {n: (1, setup.DSV41_ALL_FILES[n][1]) for n in shared_names}      # the stand-in files are one byte long
        with mock.patch.dict(setup.DSV41_ALL_FILES, tiny):
            rc, out = self.install_ista(model="IST-DAS-2.25bpw")
        self.assertEqual(rc, 0, out)
        got = [c[2].name for c in self.calls if c[0] == "get"]
        self.assertEqual(got, [f"DeepSeek-V4.1-Flash-1017-GSQ-RCO-IQ2_XS-{i:05d}-of-00004.gguf" for i in range(1, 5)])      # only the four shards

    def test_the_first_releases_files_are_used_as_they_are_nothing_is_downloaded_but_the_small_files(self):
        own = self.root / "own"
        sub = own / "2.00bpw"
        sub.mkdir(parents=True)
        for i in range(1, 5):
            (sub / f"model-2.00bpw-{i:05d}-of-00004.gguf").write_bytes(b"GGUF")
        (sub / "engram-IQ4_NL.gguf").write_bytes(b"E")
        (own / "dspark").mkdir()
        (own / "dspark" / setup.DSV41_DSPARK).write_bytes(b"D")
        tiny = {n: (4, "0" * 64) for n in setup.DSV41_LEGACY_FILES if n.startswith("model-2.00bpw")}
        tiny["engram-IQ4_NL.gguf"] = (1, "0" * 64)
        tiny[setup.DSV41_DSPARK] = (1, "0" * 64)
        with mock.patch.dict(setup.DSV41_ALL_FILES, tiny):
            rc, out = self.install_ista(gguf_dir=str(own))
        self.assertEqual(rc, 0, out)
        got = [c[2].name for c in self.calls if c[0] == "get"]
        self.assertEqual(got, [setup.DSV41_SHARD.format(i=1)])                 # only the 5.8 MB metadata shard
        pack = [c for c in self.calls if c[0] == "run"][-1][1]
        shards = pack[pack.index("--shards") + 1:pack.index("--engram")]
        self.assertEqual(shards, [f"model-2.00bpw-{i:05d}-of-00004.gguf" for i in range(1, 5)])      # packed from the files as they are
        self.assertTrue(pack[pack.index("--engram") + 1].endswith("engram-IQ4_NL.gguf"))
        self.assertIn("model", pack[pack.index("--model") + 1] + "model")
        self.assertEqual(Path(pack[pack.index("--model") + 1]), sub)

    def test_pack_info_profile_smoke_and_the_launch_flags(self):
        rc, out = self.install_ista()
        self.assertEqual(rc, 0, out)
        a = self.cfg["args"]
        self.assertEqual(a[a.index("--dspark") + 1], "auto")                    # never "off": that still loads the drafter and takes the VRAM
        self.assertNotEqual(a[a.index("--dspark") + 1], "off")
        self.assertNotIn("--prefill-chunk", a)                                  # the engine's own default is the layer-major prompt path
        self.assertEqual(a[a.index("--dspark-conf") + 1], "0.65")                # never a floor below 0.3             # the layer-major prompt path
        self.assertNotIn("--ssd-cache", a)                                      # the store sizes itself
        self.assertEqual(a[a.index("--max-context") + 1], "8192")
        self.assertIn("checked: every file the engine needs is there", out)
        self.assertIn("test question answered sensibly", out)
        self.assertTrue(Path(a[a.index("--pack") + 1]).match("*packs/deepseek-v4.1-flash-ist-das-2.00bpw"))

    def test_an_incomplete_pack_stops_with_the_missing_file(self):
        self.packinfo_ok = False
        patches = [mock.patch.object(setup, "dsv41_pack_info", lambda exe, pack, libs: (False, "  MISSING x.gguf (1.00 GB wanted)")),
                   mock.patch.object(setup, "dsv41_smoke", lambda *a, **k: (True, "Paris"))]
        for p in patches:
            p.start()
            self.addCleanup(p.stop)
        rc, out = self.install(ram=64.0, cards=[RTX5070], model=ISTA)
        self.assertEqual(rc, 1, out)
        self.assertIn("pack is not complete", out)
        self.assertIn("MISSING", out)

    def test_a_failed_text_check_is_said_plainly_and_stops(self):
        patches = [mock.patch.object(setup, "dsv41_pack_info", lambda exe, pack, libs: (True, "all present")),
                   mock.patch.object(setup, "dsv41_smoke", lambda *a, **k: (False, "!!!!\ntest question failed: the answer is empty"))]
        for p in patches:
            p.start()
            self.addCleanup(p.stop)
        rc, out = self.install(ram=64.0, cards=[RTX5070], model=ISTA)
        self.assertEqual(rc, 1, out)
        self.assertIn("does not answer sensibly", out)
        self.assertIn("run setup again", out)
        self.assertFalse(self.cfg)                                              # no start script for a model that failed its check

    def test_a_disk_that_cannot_hold_the_set_stops(self):
        with mock.patch.object(setup, "free_gb", lambda p: 100.0):
            rc, out = self.install_ista()
        self.assertEqual(rc, 1, out)
        self.assertIn("not enough free disk space", out)


class InstallSmallest(InstallOfficial):
    def test_downloads_the_iq1_m_files_and_the_shared_ones(self):
        rc, out = self.install_ista(model="IST-DAS-1.75bpw", ram=36.0)
        self.assertEqual(rc, 0, out)
        get = [c for c in self.calls if c[0] == "get"]
        self.assertEqual([c[2].name for c in get][:4], [f"DeepSeek-V4.1-Flash-1017-GSQ-RCO-IQ1_M-{i:05d}-of-00004.gguf" for i in range(1, 5)])
        self.assertTrue(get[0][1].startswith(setup.hf(setup.DSV41_ISTA_REPO)))
        self.assertIn("cb02422c900df489cea5833e8a92171224059b3c", get[0][1])
        self.assertIn("239 GB", out)
        a = self.cfg["args"]
        self.assertEqual(a[a.index("--dspark") + 1], "auto")


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


class PicturesByDefault(Install):
    """0.2.7: DeepSeek reads pictures with its own engine's tower, on by default: setup fetches the tower's weights (mmproj-BF16.gguf, a shared file),
    packs them with the model and writes --vision on; --vision no leaves all three out."""

    def test_default_fetches_the_tower_packs_it_and_says_on(self):
        rc, out = self.install(vision=None)
        self.assertEqual(rc, 0, out)
        got = [c[2].name for c in self.calls if c[0] == "get"]
        self.assertIn(setup.DSV41_MMPROJ, got)
        self.assertEqual(got[-1], setup.DSV41_MMPROJ)
        pack = [c for c in self.calls if c[0] == "run"][-1][1]
        self.assertIn("--mmproj", pack)
        self.assertTrue(str(pack[pack.index("--mmproj") + 1]).endswith(setup.DSV41_MMPROJ))
        a = self.cfg["args"]
        self.assertEqual(a[a.index("--vision") + 1], "on")
        self.assertNotIn("cannot read pictures", out)

    def test_vision_no_leaves_the_tower_out(self):
        rc, out = self.install(vision="no")
        self.assertEqual(rc, 0, out)
        self.assertNotIn(setup.DSV41_MMPROJ, [c[2].name for c in self.calls if c[0] == "get"])
        pack = [c for c in self.calls if c[0] == "run"][-1][1]
        self.assertNotIn("--mmproj", pack)
        a = self.cfg["args"]
        self.assertEqual(a[a.index("--vision") + 1], "off")

    def test_gpu_and_cpu_are_taken_as_yes_with_a_note(self):
        rc, out = self.install(vision="cpu")
        self.assertEqual(rc, 0, out)
        self.assertIn("own tower", out)
        a = self.cfg["args"]
        self.assertEqual(a[a.index("--vision") + 1], "on")

    def test_a_pack_without_the_tower_is_made_again_with_it(self):
        pack = self.root / "data" / "packs" / "deepseek-v4.1-flash-ud-q8_k_xl"
        (pack / "tokenizer").mkdir(parents=True)
        (pack / "tokenizer" / "vocab.json").write_text("{}")
        (pack / "tensors.txt").write_text("x")
        (pack / "ds4.txt").write_text("hidden_size 5120\n")
        self.assertFalse(setup.dsv41_pack_has_tower(pack))
        rc, out = self.install(vision=None)
        self.assertEqual(rc, 0, out)
        self.assertIn("made without the picture reader", out)
        self.assertTrue([c for c in self.calls if c[0] == "run" and "--mmproj" in c[1]])
        pack.mkdir(parents=True, exist_ok=True)
        (pack / "ds4.txt").write_text("vision.num_hidden_layers 32\nimage_token_id 129264\n")
        self.assertTrue(setup.dsv41_pack_has_tower(pack))