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++
"""Fixes after the TUI stress re-run on 67a48427b: a failed start cleans up and quotes this attempt's logs, the Folder text, the save/restart order,
the saved config without --mtp when drafting is off, and the reused-pack line."""
import json
import os
import socket
import tempfile
import unittest
from pathlib import Path
from unittest import mock
from strata_cli.launch import settings as S
from strata_cli.launch import runner as R
from strata_cli.launch.catalog import Catalog
from strata_cli.launch.runner import LaunchError, Runner
from tests.terminal.launch_support import HW_12, Home, catalog
class FailedStart(unittest.TestCase):
def setUp(self):
self.home = Home().__enter__()
self.addCleanup(self.home.__exit__, None, None, None)
p = mock.patch.object(Catalog, "hardware", lambda self, fresh=False: dict(HW_12, disk_free_gb=500.0))
p.start()
self.addCleanup(p.stop)
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.base = Path(self.tmp.name)
def runner(self, port=8080):
s = S.LaunchSettings(family="qwen", model="IQ3_XXS", context=32768, name="gyro", port=port)
r = Runner(s, catalog=catalog())
r.said = []
r.emit_cb = lambda e: r.said.append(e.text)
return r
def test_a_busy_port_is_said_before_anything_starts(self):
with socket.socket() as srv:
srv.bind(("127.0.0.1", 0))
srv.listen(1)
port = srv.getsockname()[1]
r = self.runner(port)
with mock.patch("strata_control.runtime.status", return_value={"state": "stopped"}), \
mock.patch("strata_control.runtime.start", side_effect=AssertionError("must not start")):
with self.assertRaises(LaunchError) as cm:
r.start()
self.assertIn(f"Port {port} is already in use by another program.", cm.exception.text)
self.assertIn("--port", cm.exception.next)
def test_the_cause_comes_from_this_attempts_server_log_not_the_old_engine_log(self):
engine = self.base / "engine.log"
server = self.base / "srv.log"
engine.write_text("strata verify: captured the 2-token window\nlong ago error: old cause\n")
server.write_text("")
cfg = self.base / "cfg.json"
cfg.write_text(json.dumps({"log": str(engine)}))
marks = {str(engine): engine.stat().st_size, str(server): 0}
with open(server, "a") as f:
f.write("server.py: error: port 8190 is already in use - is Strata (or another server) already running?\n")
text, nxt = R.explain_engine_exit({"state": "failed", "error": "server_exited", "engine_exit_code": 2}, cfg, marks=marks, server_log=server)
self.assertIn("Port 8190 is already in use by another program.", text)
self.assertIn("--port 8191", nxt)
self.assertNotIn("old cause", text + nxt)
self.assertNotIn("captured the 2-token", text + nxt)
def test_an_old_engine_log_is_never_quoted_when_this_attempt_wrote_nothing(self):
engine = self.base / "engine.log"
engine.write_text("error: from the earlier successful run\n")
cfg = self.base / "cfg.json"
cfg.write_text(json.dumps({"log": str(engine)}))
marks = {str(engine): engine.stat().st_size}
text, _ = R.explain_engine_exit({"state": "failed", "error": "server_exited"}, cfg, marks=marks, server_log=None)
self.assertNotIn("earlier successful run", text)
def test_a_failed_start_ends_its_own_host(self):
r = self.runner()
r.config_path = None
calls = []
with mock.patch("strata_control.runtime.status", return_value={"state": "stopped"}), \
mock.patch.object(Runner, "check_port_free"), \
mock.patch("strata_control.runtime.start", return_value={"ok": False, "state": "failed", "error": "server_exited", "engine_exit_code": 2}), \
mock.patch("strata_control.runtime.stop", side_effect=lambda n, timeout=0: calls.append(("stop", n))), \
mock.patch("strata_control.runtime.cleanup", side_effect=lambda n=None: calls.append(("cleanup", n))):
with self.assertRaises(LaunchError):
r.start()
self.assertEqual(calls, [("stop", "launch-gyro"), ("cleanup", "launch-gyro")])
def test_a_start_that_raises_also_ends_its_host(self):
r = self.runner()
calls = []
with mock.patch("strata_control.runtime.status", return_value={"state": "stopped"}), \
mock.patch.object(Runner, "check_port_free"), \
mock.patch("strata_control.runtime.start", side_effect=RuntimeError("runtime host failed to start")), \
mock.patch("strata_control.runtime.stop", side_effect=lambda n, timeout=0: calls.append("stop")), \
mock.patch("strata_control.runtime.cleanup", side_effect=lambda n=None: calls.append("cleanup")):
with self.assertRaises(LaunchError):
r.start()
self.assertEqual(calls, ["stop", "cleanup"])
class FolderChangeMovesNothing(unittest.TestCase):
"""The Folder step text: changing the folder never moves the models Strata already keeps (only --move-data / strata models move do)."""
def setUp(self):
self.home = Home().__enter__()
self.addCleanup(self.home.__exit__, None, None, None)
p = mock.patch.object(Catalog, "hardware", lambda self, fresh=False: dict(HW_12, disk_free_gb=500.0))
p.start()
self.addCleanup(p.stop)
def test_start_passes_no_move_flag_unless_asked(self):
s = S.LaunchSettings(family="qwen", model="IQ3_XXS", context=32768, data_dir=str(self.home.base / "new"))
self.assertNotIn("--move-data", Runner(s, catalog=catalog()).setup_args())
self.assertIn("--move-data", Runner(s, catalog=catalog(), move_data=True).setup_args())
def test_setup_keeps_the_existing_models_where_they_are(self):
import contextlib
import io
import setup
base = self.home.base
old, new, root = base / "old-data", base / "new-data", base / "Strata"
root.mkdir()
weights = old / "models" / "Q2_0" / "w.gguf"
weights.parent.mkdir(parents=True)
weights.write_bytes(b"x" * 100)
env = {"APPDATA": str(base / "appdata"), "XDG_CONFIG_HOME": str(base / "appdata")}
with mock.patch.dict(os.environ, env), mock.patch.object(setup, "ROOT", root), mock.patch.object(setup, "_CONTROL_HOME", None):
os.environ.pop("STRATA_SETTINGS_FILE", None)
setup.settings_path().parent.mkdir(parents=True, exist_ok=True)
setup.settings_path().write_text(json.dumps({"data_dir": str(old), "installs": []}), encoding="utf-8")
with contextlib.redirect_stdout(io.StringIO()):
setup.data_folder(str(new), move=False, yes=True, set_default=True)
self.assertTrue(weights.is_file())
self.assertFalse((new / "models").exists())
def test_the_screen_text_says_they_stay(self):
src = open(os.path.join(os.path.dirname(R.__file__), "screens.py"), encoding="utf-8").read()
self.assertIn("stay there and keep working", src)
self.assertNotIn("are moved into this folder when you start", src)
class SaveWaitsForRestartAnswer(unittest.TestCase):
"""Save as a preset and launch: nothing is saved before the restart question is answered Restart."""
def _runner(self, **kw):
s = S.LaunchSettings(family="qwen", model="IQ3_XXS", context=32768, name="gyro")
return Runner(s, catalog=catalog(), **kw)
def setUp(self):
self.home = Home().__enter__()
self.addCleanup(self.home.__exit__, None, None, None)
p = mock.patch.object(Catalog, "hardware", lambda self, fresh=False: dict(HW_12, disk_free_gb=500.0))
p.start()
self.addCleanup(p.stop)
def rows(self, r):
return [{"profile": "launch-gyro", "name": "gyro", "port": 8080,
"choices": {**r.choices(), "context": 65536, "family": "qwen", "model": "IQ3_XXS"}}]
def test_cancel_saves_nothing_and_the_question_names_the_running_model(self):
saved, asked = [], []
r = self._runner(confirm_restart=lambda q, d: asked.append((q, d)) or False, after_check=lambda: saved.append(1))
with mock.patch.object(Runner, "serving_launches", lambda self: self.rows_):
Runner.rows_ = self.rows(r)
with self.assertRaises(LaunchError):
r.run()
self.assertEqual(saved, [])
self.assertIn("is running on port 8080 with 64K. Restart it with these settings?", asked[0][0])
self.assertIn("IQ3_XXS", asked[0][0])
self.assertEqual(asked[0][1], "Answers in progress stop.")
def test_restart_saves_after_the_answer(self):
order = []
r = self._runner(confirm_restart=lambda q, d: order.append("asked") or True, after_check=lambda: order.append("saved"))
Runner.rows_ = self.rows(r)
with mock.patch.object(Runner, "serving_launches", lambda self: self.rows_), mock.patch.object(Runner, "ensure_engine", side_effect=RuntimeError("went on")):
with self.assertRaises(RuntimeError):
r.run()
self.assertEqual(order, ["asked", "saved"])
def test_nothing_running_saves_at_once(self):
saved = []
r = self._runner(after_check=lambda: saved.append(1))
with mock.patch.object(Runner, "serving_launches", lambda self: []), mock.patch.object(Runner, "ensure_engine", side_effect=RuntimeError("went on")):
with self.assertRaises(RuntimeError):
r.run()
self.assertEqual(saved, [1])
def test_the_save_screen_no_longer_writes_the_preset_itself(self):
import asyncio
from strata_cli.launch import store
from tests.terminal.test_launch_tui import Base, FakeRunner, press, make_ctx
from strata_cli.launch.app import LaunchApp
class Case(Base):
def runTest(self):
pass
case = Case()
case.setUp()
self.addCleanup(case.tearDown)
seen = {}
class Holding(FakeRunner):
def run(self, start=True):
seen["presets_during_run"] = [p.name for p in store.list_presets()]
return super().run(start)
with mock.patch("strata_cli.launch.app.Runner", Holding):
async def go():
app = LaunchApp(make_ctx())
async with app.run_test(size=(110, 34)) as pilot:
await pilot.pause(0.2)
await press(pilot, *("enter",) * 7, "n", "enter")
self.assertEqual(store.list_presets(), []) # still nothing on the Save screen
await press(pilot, "enter")
await pilot.pause(0.8)
return [p.name for p in store.list_presets()]
after = asyncio.run(go())
self.assertEqual(seen["presets_during_run"], []) # not saved before the runner's check
self.assertEqual(after, ["IQ3_S 32K"]) # saved once the run went on
class DraftingOffConfig(unittest.TestCase):
"""B10: the saved launch config has no --mtp in args when "mtp" is false, whatever made it false."""
BASE = {"args": ["--model", "m.gguf", "--mtp", "C:/x/mtp", "--spec-min-p", "0.5", "--batch-mtp", "--max-context", "32768"], "exe": "x"}
def derive(self, base, **kw):
from strata_control import tune_knobs
s = S.LaunchSettings(family="gyro", model="Gyro-S", context=32768, **kw)
return R.derive_config(base, s, bool_flags=tune_knobs.BOOL_FLAGS)
def test_drafting_off_and_mtp_off(self):
for kw in ({"drafting": "off"}, {"mtp": "off"}, {"drafting": "off", "extra": {"prefill": "4096"}}):
with self.subTest(kw=kw):
cfg = self.derive(self.BASE, **kw)
self.assertIs(cfg["mtp"], False)
self.assertNotIn("--mtp", cfg["args"])
self.assertIn("--max-context", cfg["args"])
def test_an_installed_config_that_already_says_mtp_false(self):
cfg = self.derive({**self.BASE, "mtp": False})
self.assertIs(cfg["mtp"], False)
self.assertNotIn("--mtp", cfg["args"])
self.assertNotIn("--spec-min-p", cfg["args"])
def test_mtp_stays_when_it_is_on(self):
cfg = self.derive(self.BASE)
self.assertIn("--mtp", cfg["args"])
class ReusedDataLine(unittest.TestCase):
"""C08 note: one line says where the pack and the draft layer are read from."""
def setUp(self):
self.home = Home().__enter__()
self.addCleanup(self.home.__exit__, None, None, None)
p = mock.patch.object(Catalog, "hardware", lambda self, fresh=False: dict(HW_12, disk_free_gb=500.0))
p.start()
self.addCleanup(p.stop)
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
self.base = Path(self.tmp.name)
def runner(self, cfg_args, **fields):
cfg = self.base / "strata-x.json"
cfg.write_text(json.dumps({"args": cfg_args}))
s = S.LaunchSettings(family="qwen", model="Q2_0", context=32768, **fields)
r = Runner(s, catalog=catalog())
r.said = []
r.emit_cb = lambda e: r.said.append(e.text)
return r, cfg
def test_pack_and_draft_layer_from_the_old_folder_are_named(self):
old = self.base / "dl-data"
r, cfg = self.runner(["--pack", str(old / "packs" / "x"), "--mtp", str(old / "mtp" / "rt")],
model_path=str(self.base / "docs"), data_dir=str(self.base / "c08-data"))
r.say_reused_data(cfg)
self.assertEqual(len(r.said), 1)
self.assertIn("the prepared pack and the draft layer are read from", r.said[0].lower())
self.assertIn("dl-data", r.said[0])
self.assertIn("nothing was copied", r.said[0])
def test_no_line_when_they_are_in_the_given_folder_or_nothing_was_given(self):
new = self.base / "c08-data"
r, cfg = self.runner(["--pack", str(new / "packs" / "x")], model_path=str(self.base / "docs"), data_dir=str(new))
r.say_reused_data(cfg)
self.assertEqual(r.said, [])
r, cfg = self.runner(["--pack", str(self.base / "o" / "packs" / "x")], model_path=str(self.base / "docs"))
r.say_reused_data(cfg)
self.assertEqual(r.said, [])
if __name__ == "__main__":
unittest.main()