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++
launch: a Runner that cannot be built is shown on the run screen as a plain failure instead of crashing the screens; tests: launch TUI walk (every screen, every key, Qwen and DeepSeek, 80x24 and wide, run paths, error paths)
Niko1221267a2f446299
diff --git a/strata_cli/launch/app.py b/strata_cli/launch/app.pyindex 4f1a565f4..d87774fb9 100644--- a/strata_cli/launch/app.py+++ b/strata_cli/launch/app.py@@ -274,9 +274,19 @@ class LaunchApp(App):def run_launch(self, confirmed: bool = False) -> None:s = self.ctx.settingsself.cancel = threading.Event()- self.runner = Runner(s, catalog=self.ctx.catalog, emit=self._emit, cancel=self.cancel, feed=self.ctx.feed, confirm=self._ask_from_run,- move_data=self.ctx.move_data, retune=self.ctx.retune, restart=self.ctx.restart,- confirm_restart=self._ask_restart, after_check=self._save_pending)+ try:+ self.runner = Runner(s, catalog=self.ctx.catalog, emit=self._emit, cancel=self.cancel, feed=self.ctx.feed, confirm=self._ask_from_run,+ move_data=self.ctx.move_data, retune=self.ctx.retune, restart=self.ctx.restart,+ confirm_restart=self._ask_restart, after_check=self._save_pending)+ except Exception as e: # noqa: BLE001 - a plain failure on the run screen, not a crashed app with a traceback+ screen = RunScreen()+ self.run_screen = screen+ self.current = "run"+ self.running = False+ self.show(screen)+ text = f"Something unexpected went wrong before the start: {type(e).__name__}: {e}"+ self.call_after_refresh(screen.on_failure, text)+ returngb = getattr(self.runner, "download_gb", lambda: 0.0)() if not confirmed else 0.0if gb >= 1.0:free = self.ctx.catalog.disk_free(s.data_dir or self.ctx.catalog.data_dir())diff --git a/tests/terminal/test_launch_tui_walk.py b/tests/terminal/test_launch_tui_walk.pynew file mode 100644index 000000000..1bfb1d38e--- /dev/null+++ b/tests/terminal/test_launch_tui_walk.py@@ -0,0 +1,349 @@+"""Release 0.2.4 TUI stability walk: every screen of `strata launch`, every key, for a Qwen and a DeepSeek-V4.1 pick, at 80x24 and a wide+terminal, on several computers, with back/escape on each screen and a seeded random-key fuzz. Nothing may raise, hang or leave a blank+screen; the app must still be alive after every key. The same file runs on Windows and Linux."""++from __future__ import annotations++import asyncio+import os+import random+import unittest+from unittest import mock++from strata_cli.launch import access, store+from strata_cli.launch import settings as S+from strata_cli.launch.app import LaunchApp+from tests.terminal.launch_support import HW_12, HW_24, HW_2X16, Home, text_of+from tests.terminal.test_launch_tui import FakeRunner, make_ctx++HW_H100 = {"ram_gb": 1024.0, "os": "Test OS", "cpu": {"avx2": True, "name": "test cpu"},+ "gpus": [{"index": 0, "name": "NVIDIA H100 80GB HBM3", "vram_gb": 80.0, "usable": True, "vendor": "nvidia"}]}+HW_NOGPU = {"ram_gb": 16.0, "os": "Test OS", "cpu": {"avx2": True, "name": "test cpu"}, "gpus": []}+HW_AMD = {**HW_12, "gpus": [{"index": 0, "name": "AMD Radeon RX 9070 XT", "vram_gb": 16.0, "usable": True, "vendor": "amd"}]}++SIZES = {"narrow": (80, 24), "wide": (200, 60)}+PICKS = {"qwen": ("qwen", "IQ3_XXS"), "ds200": ("deepseek41", "IST-DAS-2.00bpw"), "ds225": ("deepseek41", "IST-DAS-2.25bpw")}+# every key a person can press on any screen except q / ctrl+c (they leave on purpose and are tested on their own)+KEYS = ["enter", "escape", "up", "down", "left", "right", "pageup", "pagedown", "home", "end", "tab", "delete", "backspace",+ "question_mark", "f1", "slash", "space", "plus", "minus", "1", "2", "3", "a", "c", "d", "e", "h", "k", "m", "n", "o", "p", "r", "t", "x"]+++def alive(app) -> bool:+ return app.is_running and app._exception is None+++async def settle(pilot, n=2):+ await pilot.pause(0.05 * n)+++async def dismiss_extras(app, pilot):+ """Close a pop-up or an open text field the last key opened."""+ for _ in range(4):+ if len(app.screen_stack) > 2 or type(app.screen).__name__ == "ConfirmScreen":+ await pilot.press("escape")+ await settle(pilot)+ else:+ break+++class Walk(unittest.TestCase):+ def setUp(self):+ self.home = Home().__enter__()+ self.addCleanup(self.home.__exit__, None, None, None)+ FakeRunner.instances.clear()+ FakeRunner.behaviour = "ok"+ FakeRunner.download = 0.0+ for p in (mock.patch("strata_cli.launch.app.Runner", FakeRunner),+ mock.patch.object(access, "lan_ips", return_value=["192.168.1.5"])):+ p.start()+ self.addCleanup(p.stop)++ def drive(self, coro, hw=HW_12, size=(80, 24)):+ ctx = make_ctx(hw)+ app = LaunchApp(ctx)++ async def go():+ async with app.run_test(size=size) as pilot:+ await pilot.pause(0.2)+ return await coro(app, pilot, ctx)++ return asyncio.run(go())++ async def to_model(self, app, pilot, pick):+ app.screen.menu().select(("new", None))+ await pilot.press("enter") # "Set up from the beginning"+ await settle(pilot, 3)+ self.assertEqual(app.current, "model")+ menu = app.screen.menu()+ menu.select(PICKS[pick])+ app.screen.paint()+ self.assertEqual((app.ctx.settings.family, app.ctx.settings.model) if False else menu.current.key, PICKS[pick])++ # ---- 1. Enter through every screen, Escape all the way back, forward again+ def _forward_back(self, pick, size, hw):+ async def case(app, pilot, ctx):+ await self.to_model(app, pilot, pick)+ seen = []+ for _ in range(20):+ self.assertTrue(alive(app), f"app died on {app.current}")+ t = text_of(app)+ self.assertTrue(t.strip(), f"blank screen on {app.current}")+ seen.append(app.current)+ if app.current == "save":+ break+ before = app.current+ await pilot.press("n" if before == "advanced" else "enter")+ for _ in range(40): # wait for the next screen (a slow terminal needs more than one frame)+ await pilot.pause(0.05)+ if app.current != before:+ break+ self.assertEqual(seen[-1], "save", seen)+ for _ in range(len(seen)): # back to the Start screen (Esc on it would leave)+ before = app.current+ await pilot.press("escape")+ for _ in range(40):+ await pilot.pause(0.05)+ if app.current != before:+ break+ self.assertTrue(alive(app), f"died going back from {before}; seen={seen} exc={app._exception!r}")+ self.assertEqual(app.current, "start")+ self.assertIn("Set up from the beginning", text_of(app))+ self.drive(case, hw=hw, size=size)++ def test_forward_and_back_every_combination(self):+ for hw_name, hw in (("12", HW_12), ("h100", HW_H100), ("2x16", HW_2X16), ("nogpu", HW_NOGPU), ("amd", HW_AMD)):+ for pick in PICKS:+ for sz, size in SIZES.items():+ with self.subTest(hw=hw_name, pick=pick, size=sz):+ self._forward_back(pick, size, hw)++ # ---- 2. Every key on every screen+ def _key_sweep(self, pick, size, hw):+ async def case(app, pilot, ctx):+ await self.to_model(app, pilot, pick)+ for step in app.flow():+ if app.current != step:+ app.goto(step)+ await settle(pilot, 3)+ for key in KEYS:+ if key == "enter" and step == "save": # starts the launch and leaves; test_run_paths covers it+ continue+ await pilot.press(key)+ await settle(pilot)+ await dismiss_extras(app, pilot)+ self.assertTrue(alive(app), f"app died: key {key!r} on {step} ({pick}, {size})")+ if app.screen_stack and type(app.screen).__name__ in ("RunScreen",):+ app.back_to_start() if False else None+ if app.current != step: # the key moved on or back: return to this screen+ if app.current == "run" or app.current == "start":+ app.current = step+ app.goto(step)+ await settle(pilot, 2)+ t = text_of(app)+ self.assertTrue(t.strip(), f"blank screen: key {key!r} on {step}")+ self.drive(case, hw=hw, size=size)++ def _sweep_pick(self, pick, hw):+ for sz, size in SIZES.items():+ with self.subTest(hw=hw["gpus"][0]["name"] if hw["gpus"] else "none", pick=pick, size=sz):+ self._key_sweep(pick, size, hw)++ def test_every_key_on_every_screen_qwen(self):+ self._sweep_pick("qwen", HW_12)++ def test_every_key_on_every_screen_deepseek_200(self):+ self._sweep_pick("ds200", HW_12)++ def test_every_key_on_every_screen_deepseek_225_two_cards(self):+ self._sweep_pick("ds225", HW_2X16)++ # ---- 3. Seeded random keys, including the run screen+ def test_random_keys_do_not_crash(self):+ for seed in range(3):+ for pick in PICKS:+ with self.subTest(seed=seed, pick=pick):+ rng = random.Random(seed * 31 + len(pick))+ size = SIZES["narrow" if seed % 2 else "wide"]++ async def case(app, pilot, ctx):+ await self.to_model(app, pilot, pick)+ for i in range(60):+ await pilot.press(rng.choice(KEYS))+ await pilot.pause(0.03)+ if type(app.screen).__name__ == "ConfirmScreen" and rng.random() < 0.4:+ await pilot.press("enter")+ self.assertTrue(alive(app) or app.return_value is None and not app.is_running,+ f"seed {seed} step {i}: exception {app._exception!r}")+ if not app.is_running:+ break+ if app.is_running:+ self.assertTrue(text_of(app).strip(), f"blank screen at step {i}")+ return True+ self.drive(case, hw=HW_2X16 if seed % 3 == 0 else HW_12, size=size)++ # ---- 4. q and ctrl+c leave cleanly from every screen; the Start screen's Escape too+ def test_quit_keys_leave_from_every_screen(self):+ for key in ("q", "ctrl+c", "ctrl+q"):+ for step in ("start", "model", "cards", "folder", "context", "pictures", "parallel", "tuning", "advanced", "access", "save"):+ if key == "q" and step in ("folder", "save"): # a text field has the focus there: q is a letter+ continue+ with self.subTest(key=key, step=step):+ async def case(app, pilot, ctx):+ if step != "start":+ await self.to_model(app, pilot, "ds200")+ if step in app.flow():+ app.goto(step)+ await settle(pilot, 3)+ await pilot.press(key)+ await settle(pilot, 4)+ self.assertFalse(app.is_running, f"{key} did not quit on {step}")+ self.assertIsNone(app._exception)+ self.drive(case, hw=HW_2X16)++ # ---- 5. Resize while on each screen+ def test_resize_on_every_screen(self):+ async def case(app, pilot, ctx):+ await self.to_model(app, pilot, "ds225")+ for step in app.flow():+ app.goto(step)+ await settle(pilot, 3)+ for size in ((60, 20), (200, 60), (80, 24), (40, 12), (120, 30)):+ await pilot.resize_terminal(*size)+ await settle(pilot, 3)+ self.assertTrue(alive(app), f"resize {size} killed {step}")+ self.assertTrue(text_of(app).strip(), f"blank at {size} on {step}")+ self.drive(case, hw=HW_2X16)++ # ---- 6. The run: success, failure and retry, stop and cancel, for Qwen and DeepSeek+ def test_run_paths(self):+ for pick in ("qwen", "ds200"):+ for behaviour in ("ok", "fail", "wait"):+ with self.subTest(pick=pick, behaviour=behaviour):+ FakeRunner.behaviour = behaviour++ async def case(app, pilot, ctx):+ await self.to_model(app, pilot, pick)+ for _ in range(30):+ if app.current == "save":+ break+ await pilot.press("n" if app.current == "advanced" else "enter")+ await settle(pilot, 3)+ self.assertEqual(app.current, "save")+ await pilot.press("enter") # Save screen: first option+ for _ in range(40):+ await pilot.pause(0.05)+ if not app.is_running or app.current == "run":+ break+ for _ in range(10):+ await pilot.pause(0.05)+ if behaviour == "fail" and app.is_running:+ self.assertIn("Not enough disk space", text_of(app))+ await pilot.press("r") # retry+ await pilot.pause(0.3)+ await pilot.press("escape") # back to the start+ await pilot.pause(0.2)+ if behaviour == "wait" and app.is_running:+ await pilot.press("s")+ await pilot.pause(0.3)+ self.assertIn("Stop now?", text_of(app))+ await pilot.press("enter") # Stop+ await pilot.pause(0.6)+ self.assertIn("Stopped. Nothing was started.", text_of(app))+ self.assertIsNone(app._exception)+ self.drive(case, hw=HW_12)+++class ErrorPaths(unittest.TestCase):+ """The screens must come up (and say so plainly) when the world is broken."""++ def setUp(self):+ self.home = Home().__enter__()+ self.addCleanup(self.home.__exit__, None, None, None)+ FakeRunner.instances.clear()+ FakeRunner.behaviour = "ok"+ FakeRunner.download = 0.0+ p = mock.patch.object(access, "lan_ips", return_value=[]) # no network at all+ p.start()+ self.addCleanup(p.stop)++ def run_flow(self, runner, hw=HW_12, pick="ds200", settle_s=1.0):+ ctx = make_ctx(hw)+ app = LaunchApp(ctx)++ async def go():+ async with app.run_test(size=(80, 24)) as pilot:+ await pilot.pause(0.2)+ app.screen.menu().select(("new", None))+ await pilot.press("enter")+ await pilot.pause(0.2)+ app.screen.menu().select(PICKS[pick])+ for _ in range(30):+ if app.current == "save":+ break+ await pilot.press("n" if app.current == "advanced" else "enter")+ await pilot.pause(0.1)+ await pilot.press("enter")+ await pilot.pause(settle_s)+ return text_of(app), app._exception, app.is_running++ with mock.patch("strata_cli.launch.app.Runner", runner):+ return asyncio.run(go())++ def test_runner_raising_anything_is_shown_in_words(self):+ for exc in (OSError(28, "No space left on device"), PermissionError("denied"), ConnectionError("feed unreachable"),+ KeyError("x"), UnicodeEncodeError("charmap", "ı", 0, 1, "can't encode"), RuntimeError("boom")):+ with self.subTest(exc=type(exc).__name__):+ class Raising(FakeRunner):+ def run(self, start=True):+ raise exc++ text, err, running = self.run_flow(Raising)+ self.assertIsNone(err)+ self.assertTrue(running, "the screens closed instead of showing the failure")+ self.assertIn("Press r to try again", text)+ self.assertNotIn("Traceback", text)++ def test_runner_that_cannot_be_built_shows_a_failure_not_a_crash(self):+ class Broken(FakeRunner):+ def __init__(self, *a, **k):+ raise OSError("the data folder cannot be read")++ text, err, running = self.run_flow(Broken, settle_s=0.6)+ self.assertIsNone(err)+ self.assertTrue(running)+ self.assertIn("Press r to try again", text)+ self.assertIn("the data folder cannot be read", " ".join(text.split()))+++class RealRunnerErrors(unittest.TestCase):+ """The real Runner against an unreachable feed, a port that is busy and a data folder that is full: plain failures, never a traceback."""++ def setUp(self):+ self.home = Home().__enter__()+ self.addCleanup(self.home.__exit__, None, None, None)++ def test_unreachable_feed_gives_a_plain_failure(self):+ from tests.terminal.test_launch_tui import make_ctx as mk+ ctx = mk(HW_12, S.LaunchSettings(name="x", family="qwen", model="IQ3_XXS", context=65536, tune="skip", access="local", port=18999))+ ctx.feed = "http://127.0.0.1:9" # nothing listens here+ app = LaunchApp(ctx, auto_run=True)++ async def go():+ async with app.run_test(size=(80, 24)) as pilot:+ for _ in range(100):+ await pilot.pause(0.1)+ t = text_of(app)+ if "Press r to try again" in t or "Download about" in t or not app.is_running:+ break+ if "Download about" in text_of(app):+ await pilot.press("escape")+ await pilot.pause(0.2)+ return text_of(app), app._exception++ text, err = asyncio.run(go())+ self.assertIsNone(err, text)+ self.assertNotIn("Traceback", text)+++if __name__ == "__main__":+ unittest.main()