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++
"""DeepSeek's speed choice (0.2.4.3): Faster (--experts 5, the default on a PC with 16 GB of graphics memory or less) or Full quality (--experts 6)."""
from __future__ import annotations
import asyncio
import json
import unittest
from pathlib import Path
from unittest import mock
from strata_cli.launch import settings as S
from strata_cli.launch.app import LaunchApp
from strata_cli.launch.runner import (Runner, apply_experts, derive_config, dsv41_engine_version, engine_takes_experts, experts_from_log,
faster_by_default, used_vram_gb, uses_integrated_gpu)
from strata_cli.launch.screens import SpeedScreen, flow_for
from tests.terminal import test_launch as TL
from tests.terminal.launch_support import Home, text_of
from tests.terminal.test_launch_tui import SIZE, make_ctx, press
run_cli = TL.run_cli
class Words(unittest.TestCase):
def test_the_default_is_faster_up_to_16_gb_of_graphics_memory(self):
for gb in (8, 12, 15.9, 16.0): # the engine's rule: 16 GiB or less (17,179,869,184 bytes)
self.assertTrue(S.faster_default(gb), gb)
for gb in (16.01, 16.4, 20, 24, 48, 0, None):
self.assertFalse(S.faster_default(gb), gb)
def test_plain_words_and_the_quality_note(self):
self.assertEqual(S.speed_words("faster", True), "Faster (default on this PC)")
self.assertEqual(S.speed_words("faster", False), "Faster")
self.assertEqual(S.speed_words("full", False), "Full quality: all 6 experts per word")
self.assertEqual(S.FASTER_NOTE, "Faster uses 5 of 6 experts per word: a small quality change, usually not noticeable.")
def test_the_flags_text_says_the_same(self):
self.assertNotIn("--speed", S.flags_text(S.LaunchSettings(family="deepseek41", model="IST-DAS-2.00bpw")))
self.assertIn("--full-quality", S.flags_text(S.LaunchSettings(family="deepseek41", model="IST-DAS-2.00bpw", speed="full")))
self.assertIn("--speed faster", S.flags_text(S.LaunchSettings(family="deepseek41", model="IST-DAS-2.00bpw", speed="faster")))
class Units(unittest.TestCase):
"""The catalog's vram_gb is GiB, the engine's unit: checked through the code that reads the cards (#3843-style: exact MiB values)."""
def nvidia(self, *mib):
text = "\n".join(f"{i}, NVIDIA GeForce RTX {i}, {m}, 8.9, 580.97" for i, m in enumerate(mib))
import setup
from tools import strata_mcp
with mock.patch.object(setup, "out", return_value=text), mock.patch.object(strata_mcp, "run_quiet", return_value=text):
return setup.gpus(), strata_mcp.own_nvidia_gpus()
def total(self, cards):
return sum(round(c["vram_gb"], 1) for c in cards) # the catalog rounds each card to 0.1 GiB
def test_nvidia_mib_is_divided_by_1024(self):
for cards in self.nvidia(16376):
self.assertAlmostEqual(cards[0]["vram_gb"], 16376 / 1024)
def test_16_gb_cards_count_as_16_gib_or_less(self):
for mib in (16376, 16384, 16380): # RTX 4080 / 4060 Ti 16 GB, an exact 16 GiB card, in between
for cards in self.nvidia(mib):
self.assertTrue(S.faster_default(self.total(cards)), mib)
for mib in (12288, 12282, 8188): # RTX 3060, 12 GiB, 8 GB
for cards in self.nvidia(mib):
self.assertTrue(S.faster_default(self.total(cards)), mib)
def test_bigger_cards_and_sums_over_16_gib_do_not(self):
for mib in (24564, 24576, 20475, 32607):
for cards in self.nvidia(mib):
self.assertFalse(S.faster_default(self.total(cards)), mib)
for cards in self.nvidia(8188, 8188): # two 8 GB cards: 15.99 GiB together
self.assertTrue(S.faster_default(self.total(cards)))
for cards in self.nvidia(12288, 8188): # 12 + 8: over
self.assertFalse(S.faster_default(self.total(cards)))
def test_an_amd_16_gb_card_counts(self):
for size in (17179869184, 17163091968): # 16 GiB exactly, and a 16 GB card's 16,368 MiB
self.assertTrue(S.faster_default(round(size / 2 ** 30, 1)), size)
self.assertFalse(S.faster_default(round(34342961152 / 2 ** 30, 1))) # a 32 GB card
class EngineFlag(unittest.TestCase):
def test_experts_replaces_the_saved_value_and_goes_last(self):
cfg = {"args": ["--pack", "p", "--experts", "6", "--dspark", "auto"]}
apply_experts(cfg, 5)
self.assertEqual(cfg["args"], ["--pack", "p", "--dspark", "auto", "--experts", "5"])
cfg = {"args": ["--experts=5", "--pack", "p"]}
apply_experts(cfg, 6)
self.assertEqual(cfg["args"], ["--pack", "p", "--experts", "6"])
cfg = {"args": ["--pack", "p"]}
apply_experts(cfg, None)
self.assertEqual(cfg["args"], ["--pack", "p"])
def test_derive_config_passes_it(self):
base = {"exe": "x", "args": ["--pack", "p"]}
cfg = derive_config(base, S.LaunchSettings(), bool_flags=frozenset(), experts=5)
self.assertEqual(cfg["args"][-2:], ["--experts", "5"])
self.assertEqual(derive_config(base, S.LaunchSettings(), bool_flags=frozenset())["args"], ["--pack", "p"])
class Resolve(unittest.TestCase):
def runner(self, *cards, **kw):
cat = mock.Mock()
cat.strata.multi_family.return_value = True
gpus = [{"index": i, "vram_gb": gb} for i, gb in enumerate(cards)]
cat.computer.return_value = mock.Mock(usable_gpus=gpus)
r = Runner(S.LaunchSettings(family="deepseek41", model="IST-DAS-2.00bpw", **kw), catalog=cat, emit=lambda e: None)
r.dsv41_engine_found = lambda: (Path(self.engine), True)
return r
engine = "/x/engine-dsv41/0.1.50-linux-x86_64-cuda-cuda13/strata-dsv41"
def test_a_12_gb_pc_gets_faster_and_a_big_one_full_quality_in_the_words(self):
self.assertEqual(self.runner(12).resolved_speed(), ("faster", True))
self.assertEqual(self.runner(96).resolved_speed(), ("full", True))
self.assertEqual(self.runner(8, 8).resolved_speed(), ("faster", True)) # summed over the cards, as the engine sums them
self.assertEqual(self.runner(12, 12).resolved_speed(), ("full", True))
def test_nothing_is_passed_to_the_engine_unless_the_person_chose(self):
for cards in ((12,), (96,), (8, 8)):
self.assertIsNone(self.runner(*cards).experts_flag(), cards) # the engine's --experts auto decides: one rule
self.assertEqual(self.runner(12, speed="full").experts_flag(), 6)
self.assertEqual(self.runner(96, speed="faster").experts_flag(), 5)
def test_a_choice_wins_over_the_default_in_the_words(self):
self.assertEqual(self.runner(12, speed="full").resolved_speed(), ("full", False))
def test_only_the_cards_the_launch_uses_are_summed(self):
comp = mock.Mock(usable_gpus=[{"index": 0, "vram_gb": 12}, {"index": 1, "vram_gb": 24}])
self.assertEqual(used_vram_gb(comp, S.LaunchSettings()), 36)
self.assertEqual(used_vram_gb(comp, S.LaunchSettings(gpus=[0])), 12)
self.assertEqual(used_vram_gb(comp, S.LaunchSettings(gpu_roles={"0": "main", "1": "off"})), 12)
def test_an_integrated_gpu_is_faster_by_default_whatever_its_memory(self): # Strix Halo: 96 GB of shared memory, the engine says 5
halo = {"index": 0, "vram_gb": 96, "vendor": "amd", "uma": True, "name": "AMD Radeon 8060S (gfx1151)"}
comp = mock.Mock(usable_gpus=[halo])
s = S.LaunchSettings()
self.assertTrue(uses_integrated_gpu(comp, s))
self.assertTrue(faster_by_default(comp, s))
for key in ("integrated", "unified_memory"):
other = {"index": 0, "vram_gb": 64, "vendor": "amd", key: True}
self.assertTrue(faster_by_default(mock.Mock(usable_gpus=[other]), s), key)
big = {"index": 0, "vram_gb": 96, "vendor": "amd"} # a 96 GB discrete card is still Full quality
self.assertFalse(faster_by_default(mock.Mock(usable_gpus=[big]), s))
mac = {"index": 0, "vram_gb": 0, "vendor": "apple", "unified_gb": 64}
self.assertFalse(uses_integrated_gpu(mock.Mock(usable_gpus=[mac]), s)) # DeepSeek is not on the Mac
two = mock.Mock(usable_gpus=[{"index": 0, "vram_gb": 24, "vendor": "nvidia"}, {"index": 1, "vram_gb": 32, "vendor": "amd", "uma": True}])
self.assertFalse(uses_integrated_gpu(two, S.LaunchSettings(gpus=[0]))) # only the cards this launch uses count
self.assertTrue(uses_integrated_gpu(two, S.LaunchSettings(gpus=[1])))
def test_the_label_and_the_plan_say_faster_on_strix_halo_and_the_guard_still_holds(self):
cat = mock.Mock()
cat.strata.multi_family.return_value = True
cat.computer.return_value = mock.Mock(usable_gpus=[{"index": 0, "vram_gb": 96, "vendor": "amd", "uma": True}])
r = Runner(S.LaunchSettings(family="deepseek41", model="IST-DAS-2.00bpw"), catalog=cat, emit=lambda e: None)
r.dsv41_engine_found = lambda: (Path(self.engine), True)
self.assertEqual(r.resolved_speed(), ("faster", True))
self.assertIn("Faster (default on this PC)", r.speed_line())
self.assertIsNone(r.experts_flag()) # not chosen: the engine's auto rule decides
r.dsv41_engine_found = lambda: (Path("/x/engine-dsv41/0.1.49.2-a/strata-dsv41"), True)
self.assertIsNone(r.resolved_speed()) # engine below 0.1.50: no line, no flag
self.assertEqual(r.speed_line(), "")
def test_the_engines_own_line_wins_in_the_summary(self):
r = self.runner(12)
self.assertIn("Faster (default on this PC)", r.speed_line(5))
self.assertIn("Full quality (default on this PC)", r.speed_line(6)) # the engine said 6 although the rule here said Faster
self.assertIn("Full quality: all 6 experts per word", self.runner(12, speed="full").speed_line(5)) # a choice stays what was chosen
def test_the_number_is_read_back_from_the_engine_log(self):
import tempfile
from pathlib import Path
with tempfile.TemporaryDirectory() as d:
log = Path(d) / "e.log"
log.write_text("ds4: loading\nds4: experts per word: 6\nlater\nds4: experts per word: 5\n", encoding="utf-8")
self.assertEqual(experts_from_log(log), 5)
log.write_text("nothing here\n", encoding="utf-8")
self.assertIsNone(experts_from_log(log))
self.assertIsNone(experts_from_log(Path(d) / "missing.log"))
def test_the_line_has_the_note_only_for_faster(self):
self.assertIn(S.FASTER_NOTE, self.runner(12).speed_line())
self.assertIn("Faster (default on this PC)", self.runner(12).speed_line())
self.assertEqual(self.runner(12, speed="full").speed_line(), "Speed: Full quality: all 6 experts per word")
def test_an_engine_older_than_0_1_50_gets_no_experts_flag_and_no_speed(self):
old = "/x/engine-dsv41/0.1.49.2-linux-x86_64-cuda-cuda13/strata-dsv41"
r = self.runner(12, speed="full")
r.dsv41_engine_found = lambda: (Path(old), True)
self.assertFalse(r.speed_engine_ok())
self.assertIsNone(r.experts_flag()) # an explicit choice too: this engine would not understand the flag
self.assertIsNone(r.resolved_speed())
self.assertEqual(r.speed_line(), "") # no line in --plan, no error
r.dsv41_engine_found = lambda: (None, None) # no engine yet: nothing either
self.assertIsNone(r.experts_flag())
self.assertEqual(self.runner(12, speed="full").experts_flag(), 6)
self.assertEqual(r.experts_flag(self.engine), 6) # the config's engine decides in build_config (after the self-upgrade)
def test_the_version_comes_from_the_package_folder(self):
for name, want in (("0.1.49.2", False), ("0.1.49.9", False), ("0.1.50", True), ("0.1.50.1", True), ("0.2.0", True), ("0.1.49", False)):
exe = f"/x/engine-dsv41/{name}-windows-x86_64-cuda-cuda13/strata-dsv41.exe"
self.assertEqual(engine_takes_experts(exe), want, name)
self.assertEqual(dsv41_engine_version("/x/engine-dsv41/0.1.50-a/strata-dsv41"), (0, 1, 50))
self.assertFalse(engine_takes_experts(None))
self.assertFalse(engine_takes_experts("/nowhere/strata-dsv41")) # a name that says nothing and a program that is not there
def test_a_build_of_your_own_is_asked_for_its_version(self):
done = mock.Mock(stdout="strata-dsv41 0.1.50.1 (abc)\n", stderr="")
with mock.patch("strata_cli.launch.runner.subprocess.run", return_value=done):
self.assertTrue(engine_takes_experts("/home/me/build/strata-dsv41"))
done = mock.Mock(stdout="strata-dsv41 0.1.49.2\n", stderr="")
with mock.patch("strata_cli.launch.runner.subprocess.run", return_value=done):
self.assertFalse(engine_takes_experts("/home/me/build/strata-dsv41"))
def test_another_model_has_no_speed(self):
cat = mock.Mock()
cat.strata.multi_family.return_value = False
r = Runner(S.LaunchSettings(family="qwen", model="IQ3_S"), catalog=cat, emit=lambda e: None)
self.assertIsNone(r.resolved_speed())
self.assertIsNone(r.experts_flag())
self.assertEqual(r.speed_line(), "")
class Flags(unittest.TestCase):
def plan(self, *args):
code, out, err = run_cli(["launch", "--plan", "--output", "json", "--model", "ist-das-2.00bpw", "--family", "deepseek41", *args])
self.assertEqual(code, 0, err + out)
return json.loads(out)["plan"]
def test_plan_names_the_speed_in_plain_words(self):
with mock.patch.object(Runner, "resolved_speed", return_value=("faster", True)):
p = self.plan()
self.assertIn("Faster (default on this PC)", p["speed"])
self.assertIn(S.FASTER_NOTE, p["speed"])
def test_full_quality_flag_and_speed_flag(self):
self.assertEqual(self.plan("--full-quality")["settings"]["speed"], "full")
self.assertEqual(self.plan("--speed", "full")["settings"]["speed"], "full")
self.assertEqual(self.plan("--speed", "faster")["settings"]["speed"], "faster")
self.assertIn("--full-quality", self.plan("--full-quality")["flags"])
def test_both_flags_say_so_and_full_quality_wins(self):
p = self.plan("--full-quality", "--speed", "faster")
self.assertEqual(p["settings"]["speed"], "full")
self.assertTrue(any("full quality is used" in w for w in p["warnings"]))
def test_another_model_warns_and_drops_it(self):
code, out, err = run_cli(["launch", "--plan", "--output", "json", "--model", "q2_0", "--full-quality"])
p = json.loads(out)["plan"]
self.assertIsNone(p["settings"]["speed"])
self.assertTrue(any("for DeepSeek" in w for w in p["warnings"]))
def test_human_plan_prints_a_speed_line(self):
with mock.patch.object(Runner, "resolved_speed", return_value=("faster", True)):
code, out, err = run_cli(["launch", "--plan", "--model", "ist-das-2.00bpw", "--family", "deepseek41"])
self.assertIn(" speed Faster (default on this PC)", out)
class Screen(unittest.TestCase):
def setUp(self):
self.home = Home().__enter__()
self.addCleanup(self.home.__exit__, None, None, None)
def test_the_step_exists_only_for_deepseek(self):
ctx = make_ctx()
self.assertNotIn("speed", flow_for(ctx))
ctx.settings.family = "deepseek41"
with mock.patch.object(Runner, "speed_engine_ok", return_value=False): # engine 0.1.49.2 or none: the step is not there
self.assertNotIn("speed", flow_for(ctx))
ctx._speed_ok = None
with mock.patch.object(Runner, "speed_engine_ok", return_value=True):
flow = flow_for(ctx)
self.assertEqual(flow[flow.index("context") + 1], "speed")
def test_the_screen_offers_two_choices_and_remembers_only_a_change(self):
ctx = make_ctx()
ctx.settings.family, ctx.settings.model = "deepseek41", "IST-DAS-2.00bpw"
faster_here = faster_by_default(ctx.computer, ctx.settings)
ctx._speed_ok = True
app = LaunchApp(ctx)
async def go():
async with app.run_test(size=SIZE) as pilot:
await pilot.pause(0.2)
app.goto("speed")
await pilot.pause(0.3)
t = text_of(app)
self.assertIn("Faster", t)
self.assertIn("Full quality", t)
self.assertIn(S.FASTER_NOTE, t)
screen = app.screen
self.assertIsInstance(screen, SpeedScreen)
screen.commit()
self.assertEqual(ctx.settings.speed, None if faster_here else "faster")
await press(pilot, "down")
screen.commit()
self.assertIn(ctx.settings.speed, (None, "full"))
asyncio.run(go())
if __name__ == "__main__":
unittest.main()