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: pilot tests for every screen, run screen state fix, no auto focus
Niko12218251089c1f1e
diff --git a/strata_cli/launch/app.py b/strata_cli/launch/app.pyindex 017563dd2..b5c24fc64 100644--- a/strata_cli/launch/app.py+++ b/strata_cli/launch/app.py@@ -236,7 +236,7 @@ class LaunchApp(App):screen = self.run_screenif screen is not None:try:- self.call_from_thread(screen.on_event, ev)+ self.call_from_thread(screen.handle_event, ev)except Exception: # noqa: BLE001 - the app is closingpassdiff --git a/strata_cli/launch/screens.py b/strata_cli/launch/screens.pyindex 9a28af77b..796d3fda0 100644--- a/strata_cli/launch/screens.py+++ b/strata_cli/launch/screens.py@@ -57,8 +57,10 @@ class Base(Screen):Binding("down", "move(1)", show=False), Binding("up", "move(-1)", show=False),Binding("pagedown", "page(1)", show=False), Binding("pageup", "page(-1)", show=False),Binding("enter", "next", "Next", show=False),+ Binding("home", "edge(0)", show=False), Binding("end", "edge(1)", show=False),]+ AUTO_FOCUS = ""step_id = ""title_line = "Set up"hints = "↑↓ choose Enter next Esc back ? help q quit"@@ -159,6 +161,14 @@ class Base(Screen):self.on_cursor()self.paint()+ def action_edge(self, last: int) -> None:+ m = self.menu()+ if m is not None and not self.input_open() and m.items:+ m.index = len(m.items) - 1 if last else 0+ m._refresh()+ self.on_cursor()+ self.paint()+def action_page(self, step: int) -> None:m = self.menu()if m is not None:@@ -170,7 +180,7 @@ class Base(Screen):passdef input_open(self) -> bool:- return any(i.has_class("open") for i in self.query(".field"))+ return any(i.has_class("open") and not i.has_class("always") for i in self.query(".field"))def action_help(self) -> None:self.say(self.help_text)@@ -385,6 +395,7 @@ class ModelScreen(Base):sel = im = self.query_one(Menu)m.columns = self.widths()+ m.show_header = Truem.window = max(4, (self.size.height or 30) - 12)m.set_items(items, sel if (initial or not m.items) else None)@@ -541,7 +552,7 @@ class FolderScreen(Base):def body(self) -> ComposeResult:yield Static(Text("Where should the model files be stored?", style=f"bold {ACCENT}"), markup=False)yield Static("", id="folderinfo", markup=False)- yield Input(id="folderpath", classes="field open")+ yield Input(id="folderpath", classes="field open always")def on_mount(self) -> None:s = self.ctx.settings@@ -882,7 +893,7 @@ class AdvancedScreen(Base):if self.filter and self.filter.lower() not in r.name.lower() and self.filter.lower() not in r.description.lower():continued, t, y = r.cells()[1:]- desc = r.description + (" [experimental]" if r.experimental else "")+ desc = ("[experimental] " if r.experimental else "") + r.descriptionitems.append(Item([r.name, d, t, Cell(y, ACCENT if y != "-" else ""), Cell(desc, WARN if r.experimental else (BAD if not r.known else ""))],key=r.name))items.append(Item([Cell("+ Add a setting by name…", ""), "", "", "", Cell("for flags of newer engine versions", MUTE)], key="__add__"))@@ -1155,12 +1166,13 @@ class AccessScreen(Base):class SaveScreen(Base):step_id = "save"- hints = "↑↓ choose Enter do it Esc back ? help"+ hints = "↑↓ choose Enter do it Tab rename Esc back ? help"+ BINDINGS = Base.BINDINGS + [Binding("tab", "rename", show=False)]help_text = "Save remembers all your choices under a name so next time you start with one key. Launch downloads what is missing, tunes if you asked, and starts serving."def body(self) -> ComposeResult:yield Static("", id="summary", markup=False)- yield Input(id="name", classes="field open")+ yield Input(id="name", classes="field open always")yield Menu(id="menu")def on_mount(self) -> None:@@ -1197,8 +1209,14 @@ class SaveScreen(Base):def explain(self) -> Text:return Text("Press Enter on the first choice to save and start. The first start may download the model and tune; the monitor opens when it is serving.", style=MUTE)- def action_move(self, step: int) -> None:- super().action_move(step)+ def action_rename(self) -> None:+ self.query_one("#name", Input).focus()+ self.say("Type the preset's name and press Enter.")++ def on_input_submitted(self, event: Input.Submitted) -> None:+ if event.input.id == "name":+ self.set_focus(None)+ self.say("")def action_next(self) -> None:name = self.query_one("#name", Input).value.strip() or self.ctx.default_name()@@ -1237,10 +1255,13 @@ class RunScreen(Base):yield Static("", id="stages", markup=False)yield Static("", id="tunepanel", markup=False)- def on_mount(self) -> None:+ def __init__(self) -> None:+ super().__init__()self.state: dict[str, dict] = {k: {"text": "", "pct": None, "status": "wait"} for k, _ in self.STAGE_WORDS}self.failed: str | None = Noneself.tune_info: dict = {}++ def on_mount(self) -> None:self.paint()def head_text(self) -> Text:@@ -1250,7 +1271,7 @@ class RunScreen(Base):out.append(f" {s.name or ''}", style=MUTE)return out- def on_event(self, ev) -> None:+ def handle_event(self, ev) -> None:if ev.stage == "done":returnst = self.state.get(ev.stage)diff --git a/strata_cli/launch/widgets.py b/strata_cli/launch/widgets.pyindex a26367347..95e8ed38f 100644--- a/strata_cli/launch/widgets.py+++ b/strata_cli/launch/widgets.py@@ -54,7 +54,7 @@ Screen {{ background: {BG}; color: {FG}; }}#body {{ height: 1fr; }}#explain {{ height: auto; max-height: 4; color: {MUTE}; }}#hints {{ height: 1; color: {MUTE}; }}-#message {{ height: 1; color: {MUTE}; }}+#message {{ height: auto; max-height: 3; color: {MUTE}; }}Menu {{ height: auto; max-height: 100%; }}.field {{ height: 3; border: solid {ACCENT}; display: none; }}.field.open {{ display: block; }}diff --git a/tests/terminal/test_launch_tui.py b/tests/terminal/test_launch_tui.pynew file mode 100644index 000000000..3f3cd10aa--- /dev/null+++ b/tests/terminal/test_launch_tui.py@@ -0,0 +1,795 @@+"""The `strata launch` screens, driven with Textual's pilot: every screen, its keys and what it writes into the settings."""++from __future__ import annotations++import asyncio+import json+import os+import threading+import time+import unittest+from pathlib import Path+from unittest import mock++from strata_cli.launch import access, settings as S, store+from strata_cli.launch.app import Ctx, LaunchApp, run_monitor+from strata_cli.launch.runner import Cancelled, Event, LaunchError, Result+from strata_cli.launch.widgets import Glyphs+from tests.terminal.launch_support import HW_12, HW_24, HW_2X16, Home, catalog, text_of++SIZE = (110, 34)+++def flat(app) -> str:+ return " ".join(text_of(app).split())+++def make_ctx(hw=None, settings=None):+ cat = catalog(hw or HW_12)+ comp = cat.computer()+ return Ctx(catalog=cat, computer=comp, rows=cat.rows(comp.raw), settings=settings or S.LaunchSettings(), glyphs=Glyphs(True))+++class FakeRunner:+ """Stands in for the real Runner: emits the same events, installs nothing, starts nothing."""++ instances: list = []+ behaviour = "ok"+ hold = 0++ def __init__(self, s, *, catalog=None, emit=None, cancel=None, feed=None, **kw):+ self.s, self.emit_cb, self.cancel, self.feed = s, emit, cancel, feed+ FakeRunner.instances.append(self)++ def run(self, start=True):+ e = self.emit_cb+ e(Event("engine", "Engine 0.1.45 (cuda) is installed.", 100))+ e(Event("model", "Downloading 12.0 of 75.8 GB", 15.8))+ if FakeRunner.behaviour == "wait":+ while not self.cancel.is_set():+ time.sleep(0.02)+ raise Cancelled()+ if FakeRunner.behaviour == "fail":+ raise LaunchError("The model could not be installed. Not enough disk space.", "Free some space and run it again.", 6)+ if getattr(FakeRunner, "hold", 0):+ time.sleep(FakeRunner.hold)+ e(Event("model", "Model is ready.", 100))+ e(Event("config", "Settings are saved.", 100))+ if self.s.tune != "skip":+ e(Event("tune", "Tuning", 40.0, data={"round": (2, 5), "minutes_left": 12,+ "speeds": [{"label": "Default settings", "decode_tok_s": 83.0},+ {"label": "Longer prompt chunks", "decode_tok_s": 85.1}]}))+ if getattr(FakeRunner, "hold", 0):+ time.sleep(FakeRunner.hold)+ e(Event("tune", "Done: answers are about 3% faster with the tuned settings.", 100))+ e(Event("start", "The model is loaded and answering.", 100))+ urls = [f"http://127.0.0.1:{self.s.port}"]+ return Result("launch-x", urls, self.s.api_key, "faster", [], "/nonexistent.json")+++async def press(pilot, *keys, pause=0.12):+ for k in keys:+ await pilot.press(k)+ await pilot.pause(pause)+++async def typed(pilot, text):+ for ch in text:+ await pilot.press(ch)+ await pilot.pause(0.1)+++class Base(unittest.TestCase):+ def setUp(self):+ self.home = Home().__enter__()+ self.addCleanup(self.home.__exit__, None, None, None)+ FakeRunner.instances.clear()+ FakeRunner.behaviour = "ok"+ p = mock.patch("strata_cli.launch.app.Runner", FakeRunner)+ p.start()+ self.addCleanup(p.stop)+ p = mock.patch.object(access, "lan_ips", return_value=["192.168.1.5"])+ p.start()+ self.addCleanup(p.stop)++ def run_app(self, coro, ctx=None, auto_run=False):+ ctx = ctx or make_ctx()+ app = LaunchApp(ctx, auto_run=auto_run)++ 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())+++class StartScreenTests(Base):+ def test_no_presets_offers_the_two_ways_in(self):+ async def case(app, pilot, ctx):+ t = text_of(app)+ self.assertIn("No saved presets yet", t)+ self.assertIn("Set up from the beginning", t)+ self.assertIn("Use model files I already have", t)+ self.assertIn("RTX 5070 12 GB", t) # the computer, top right+ self.assertIn("q quit", t)+ self.run_app(case)++ def test_presets_are_listed_with_their_columns(self):+ store.save(S.LaunchSettings(name="IQ3_XXS 128K", family="qwen", model="IQ3_XXS", context=131072, parallel=1, tuned_preset="x", tuned_at="2026-10-16"))+ store.save(S.LaunchSettings(name="Coder 64K", family="coder", model="IQ1_M", context=65536, parallel=2))++ async def case(app, pilot, ctx):+ t = text_of(app)+ self.assertIn("Start from a saved preset", t)+ self.assertIn("IQ3_XXS 128K", t)+ self.assertIn("128K", t)+ self.assertIn("1 request", t)+ self.assertIn("2 requests", t)+ self.assertIn("tuned 10-16", t)+ self.assertIn("not tuned", t)+ self.assertIn("e edit preset", t)+ self.run_app(case)++ def test_enter_on_a_preset_launches_it_and_opens_the_run_screen(self):+ store.save(S.LaunchSettings(name="Office", family="qwen", model="IQ3_XXS", context=65536, tune="quick"))++ async def case(app, pilot, ctx):+ await press(pilot, "enter")+ await pilot.pause(0.6)+ self.assertEqual(FakeRunner.instances[0].s.name, "Office")+ self.assertEqual(app.result.profile, "launch-x")+ self.run_app(case)++ def test_delete_asks_then_removes_only_the_preset(self):+ store.save(S.LaunchSettings(name="Old", family="qwen", model="Q2_0", context=32768))++ async def case(app, pilot, ctx):+ await press(pilot, "d")+ t = text_of(app)+ self.assertIn("Delete the preset 'Old'?", t)+ self.assertIn("Only the saved choices go", t)+ await press(pilot, "enter") # first option: Delete it+ self.assertEqual(store.list_presets(), [])+ self.assertIn("No saved presets yet", text_of(app))+ self.run_app(case)++ def test_delete_can_be_cancelled(self):+ store.save(S.LaunchSettings(name="Keep", family="qwen", model="Q2_0", context=32768))++ async def case(app, pilot, ctx):+ await press(pilot, "d", "escape")+ self.assertEqual([p.name for p in store.list_presets()], ["Keep"])+ self.run_app(case)++ def test_edit_opens_setup_with_the_preset_loaded(self):+ store.save(S.LaunchSettings(name="E", family="swift", model="IQ2_XS", context=65536, parallel=2))++ async def case(app, pilot, ctx):+ await press(pilot, "e")+ t = text_of(app)+ self.assertIn("Which model?", t)+ self.assertEqual((ctx.settings.family, ctx.settings.model), ("swift", "IQ2_XS"))+ self.run_app(case)++ def test_q_leaves(self):+ async def case(app, pilot, ctx):+ await press(pilot, "q")+ await pilot.pause(0.2)+ self.assertFalse(app.is_running)+ self.run_app(case)++ def test_help_is_in_words(self):+ async def case(app, pilot, ctx):+ await press(pilot, "question_mark")+ self.assertIn("A preset remembers", text_of(app))+ self.run_app(case)+++class ModelStep(Base):+ def go(self):+ async def start(app, pilot, ctx):+ await press(pilot, "enter")+ return start++ def test_the_list_shows_real_figures_and_the_recommendation(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter")+ t = text_of(app)+ self.assertIn("Which model?", t)+ for col in ("Model", "Download", "Needs (graphics + RAM)", "On this computer"):+ self.assertIn(col, t)+ self.assertIn("IQ3_XXS", t)+ line = next(l for l in t.splitlines() if "IQ3_XXS" in l and "Qwen3.8-Flash-Next IQ3_XXS" in l)+ self.assertIn("76 GB", line) # setup.py's download_gb 75.8+ self.assertIn("12 GB + 36 GB", line) # fitOn: 12 on the card, 35.9 in RAM+ self.assertIn("(recommended)", line)+ self.assertIn("› ", line) # the cursor starts on the recommendation+ self.assertIn("does not fit (can still try)", t) # NVFP4: a warning, not a block+ self.assertIn("The n-gram table stays on your SSD", t)+ self.run_app(case)++ def test_choosing_a_model_and_going_on(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "up", "up", "enter")+ self.assertEqual((ctx.settings.family, ctx.settings.model), ("qwen", "Q2_0"))+ self.assertIn("Where should the model files be stored?", text_of(app))+ self.run_app(case)++ def test_a_model_that_does_not_fit_can_still_be_chosen(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "end", "enter")+ self.assertEqual(ctx.settings.model, "NVFP4-NVIDIA")+ self.assertIn("Where should the model files be stored?", text_of(app))+ self.assertTrue(any("does not fit" in n for n in ctx.notes))+ self.run_app(case)++ def test_own_files_are_checked_with_the_fingerprint_table(self):+ plan = {"candidate_selection": {"family": "qwen", "model": "IQ3_XXS"}, "issues": [], "file_count": 2, "total_bytes": 44_000_000_000}++ async def case(app, pilot, ctx):+ await press(pilot, "enter", "o")+ self.assertIn("Type or paste the folder", text_of(app))+ with mock.patch("strata_control.models.plan_import", return_value=plan) as pi:+ await typed(pilot, "/data/models/IQ3_XXS")+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.model_path, str(Path("/data/models/IQ3_XXS")))+ self.assertEqual((ctx.settings.family, ctx.settings.model), ("qwen", "IQ3_XXS"))+ self.assertIn("These files are qwen IQ3_XXS (2 file(s), 44 GB)", text_of(app))+ await press(pilot, "enter")+ self.assertIn("Your model files stay where they are", text_of(app))+ self.run_app(case)++ def test_own_files_that_are_not_a_known_model_say_why(self):+ plan = {"candidate_selection": None, "issues": ["incomplete_or_invalid_shard_set"], "file_count": 1, "total_bytes": 1}++ async def case(app, pilot, ctx):+ await press(pilot, "enter", "o")+ with mock.patch("strata_control.models.plan_import", return_value=plan):+ await typed(pilot, "/x")+ await press(pilot, "enter")+ t = flat(app)+ self.assertIn("some shards are missing", t)+ self.assertIn("pick a model from the list", t)+ self.assertIsNone(ctx.settings.model_path)+ self.run_app(case)++ def test_own_files_path_from_the_start_screen(self):+ async def case(app, pilot, ctx):+ await press(pilot, "down", "enter")+ self.assertIn("Type or paste the folder", text_of(app))+ await press(pilot, "escape")+ self.assertIn("Which model?", text_of(app))+ self.run_app(case)++ def test_escape_goes_back_to_the_start(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "escape")+ self.assertIn("Set up from the beginning", text_of(app))+ self.run_app(case)+++class FolderStep(Base):+ def test_default_folder_and_free_space_and_change(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter")+ t = text_of(app)+ self.assertIn("Where should the model files be stored?", t)+ self.assertIn("Needs about", t)+ self.assertIn("Free space in that folder's drive", t)+ f = app.screen.query_one("#folderpath")+ f.value = ""+ await typed(pilot, "D:/Strata-data")+ self.assertEqual(f.value, "D:/Strata-data")+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.data_dir, "D:/Strata-data")+ self.assertIn("How much text should it remember at once?", text_of(app))+ self.run_app(case)++ def test_keeping_the_default_stores_nothing(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter", "enter")+ self.assertIsNone(ctx.settings.data_dir)+ self.run_app(case)++ def test_not_enough_space_is_a_warning_you_can_go_past(self):+ async def case(app, pilot, ctx):+ with mock.patch.object(type(ctx.catalog), "disk_free", return_value=10.0):+ await press(pilot, "enter", "enter")+ t = text_of(app)+ self.assertIn("Not enough for", t)+ await press(pilot, "enter")+ self.assertIn("How much text", text_of(app))+ self.run_app(case)+++class ContextStep(Base):+ def reach(self):+ async def f(app, pilot, ctx):+ await press(pilot, "enter", "enter", "enter")+ return f++ def test_sizes_words_memory_and_recommendation(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter", "enter")+ t = text_of(app)+ for size in ("8K", "32K", "64K", "128K", "256K", "512K", "Custom"):+ self.assertIn(size, t)+ self.assertIn("about 98,000 words", t)+ self.assertIn("recommended", t)+ self.assertIn("+1.8 GB", t) # 128K at 8-bit: 131072 x 13 x 1056 bytes+ self.assertIn("experimental: rope scaling", t)+ self.assertIn("Conversation memory: 8-bit", t)+ self.run_app(case)++ def test_choose_128k(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter", "enter", "down", "down", "enter")+ self.assertEqual(ctx.settings.context, 131072)+ self.assertIn("Should the model read pictures?", text_of(app))+ self.run_app(case)++ def test_memory_format_toggle_changes_the_figures(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter", "enter", "m")+ self.assertEqual(ctx.settings.kv, "q4_0")+ t = text_of(app)+ self.assertIn("4-bit", t)+ self.assertIn("+0.2 GB", t) # 32K at 4-bit+ await press(pilot, "m")+ self.assertEqual(ctx.settings.kv, "int8")+ self.run_app(case)++ def test_custom_size(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter", "enter", "c")+ await typed(pilot, "100k")+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.context, 102400)+ self.assertIn("100K", text_of(app))+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.context, 102400)+ self.run_app(case)++ def test_bad_custom_size_is_explained(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter", "enter", "c")+ await typed(pilot, "lots")+ await press(pilot, "enter")+ self.assertIn("is not a context size", text_of(app))+ self.run_app(case)++ def test_bigger_card_recommends_more(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter", "enter")+ t = text_of(app)+ line = next(l for l in t.splitlines() if "128K" in l)+ self.assertIn("recommended", line)+ self.run_app(case, ctx=make_ctx(HW_24))+++class PicturesParallelTuning(Base):+ def reach_pictures(self):+ return ("enter", "enter", "enter", "enter")++ def test_pictures_default_off_and_on(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach_pictures())+ t = text_of(app)+ self.assertIn("No pictures", t)+ self.assertIn("0.9 GB download", t)+ self.assertIn("runs on the CPU", t) # a 12 GB card+ await press(pilot, "down", "enter")+ self.assertEqual(ctx.settings.vision, "on")+ self.assertIn("How many requests at the same time?", text_of(app))+ self.run_app(case)++ def test_pictures_not_offered_for_a_model_without_them(self):+ store.save(S.LaunchSettings(name="G", family="gyro", model="Gyro-S", context=32768))++ async def case(app, pilot, ctx):+ await press(pilot, "e", "enter", "enter", "enter")+ self.assertEqual((ctx.settings.family, ctx.settings.model), ("gyro", "Gyro-S"))+ t = flat(app)+ self.assertIn("not available for this model yet", t)+ self.assertIn("This model cannot read pictures yet", t)+ await press(pilot, "down", "enter") # the greyed row is skipped+ self.assertEqual(ctx.settings.vision, "off")+ self.run_app(case)++ def test_parallel_fit_to_card_and_warnings(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach_pictures(), "enter")+ t = text_of(app)+ self.assertIn("Fit to my graphics card (1)", t)+ self.assertIn("may not fit: slower answers", t)+ self.assertIn("12 GB: 1, 20 GB: 2, 24 GB: 3, 32 GB or more: 4", " ".join(t.split()))+ await press(pilot, "down", "down", "down", "enter")+ self.assertEqual(ctx.settings.parallel, 3)+ self.assertIn("Tune for the best speed", text_of(app))+ self.run_app(case)++ def test_parallel_default_is_fit_to_card(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach_pictures(), "enter", "enter")+ self.assertIsNone(ctx.settings.parallel)+ self.run_app(case)++ def test_bigger_card_fits_more(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach_pictures(), "enter")+ self.assertIn("Fit to my graphics card (3)", text_of(app))+ self.run_app(case, ctx=make_ctx(HW_24))++ def test_tuning_choices_and_the_answer_changing_tick(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach_pictures(), "enter", "enter")+ t = text_of(app)+ self.assertIn("Quick", t)+ self.assertIn("about 20 minutes", t)+ self.assertIn("Thorough", t)+ self.assertIn("up to 2 hours", t)+ self.assertIn("Skip", t)+ self.assertIn("[ ] Allow settings that change answers very slightly", t)+ line = next(l for l in t.splitlines() if "›" in l)+ self.assertIn("Quick", line) # a first setup recommends tuning+ await press(pilot, "a")+ self.assertIn("[x] Allow settings", text_of(app))+ self.assertTrue(ctx.settings.tune_allow_small)+ await press(pilot, "down", "enter")+ self.assertEqual(ctx.settings.tune, "thorough")+ self.run_app(case)++ def test_tuning_skip(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach_pictures(), "enter", "enter", "down", "down", "enter")+ self.assertEqual(ctx.settings.tune, "skip")+ self.run_app(case)+++class AdvancedStep(Base):+ HELP = " --prefill N prompt chunk size (default 2048)\n --kv fp16|int8 KV storage\n --native-rope experimental pinned rotary\n"++ def reach(self):+ return ("enter", "enter", "enter", "enter", "enter", "enter", "enter")++ def ctx_with_engine(self):+ ctx = make_ctx()+ ctx.settings.family, ctx.settings.model = "qwen", "IQ3_XXS"+ base = {"exe": "component:strata-engine", "args": ["--max-context", "32768", "--kv", "int8", "--prefill", "auto"]}+ p1 = mock.patch.object(Ctx, "base_config", lambda self: base)+ p2 = mock.patch.object(Ctx, "engine_exe", lambda self: "/engine/strata")+ p3 = mock.patch("strata_cli.launch.params.engine_help_text", return_value=self.HELP)+ for p in (p1, p2, p3):+ p.start()+ self.addCleanup(p.stop)+ return ctx++ def test_table_columns_command_and_same_as_line(self):+ ctx = self.ctx_with_engine()++ async def case(app, pilot, ctx):+ await press(pilot, *self.reach())+ t = text_of(app)+ for col in ("Setting", "Default", "Tuned", "Yours", "What it does"):+ self.assertIn(col, t)+ self.assertIn("--max-context", t)+ self.assertIn("--prefill", t)+ self.assertIn("--native-rope", t)+ self.assertIn("[experimental]", t)+ self.assertIn("+ Add a setting by name", t)+ self.assertIn("Command that will run", t)+ self.assertIn("Same as: strata launch --model iq3_xxs", t)+ self.run_app(case, ctx=ctx)++ def test_edit_a_value_then_reset_it(self):+ ctx = self.ctx_with_engine()++ async def case(app, pilot, ctx):+ await press(pilot, *self.reach())+ names = [it.key for it in app.screen.menu().items]+ idx = names.index("--prefill")+ for _ in range(idx):+ await press(pilot, "down")+ await press(pilot, "enter")+ self.assertIn("Type the value for --prefill", text_of(app))+ await typed(pilot, "65536")+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.extra, {"--prefill": "65536"})+ self.assertIn("65536", text_of(app))+ self.assertIn("--set prefill=65536", text_of(app))+ await press(pilot, "delete")+ self.assertEqual(ctx.settings.extra, {})+ self.assertIn("back to the tuned value", text_of(app))+ self.run_app(case, ctx=ctx)++ def test_add_by_name_warns_about_an_unknown_flag_but_keeps_it(self):+ ctx = self.ctx_with_engine()++ async def case(app, pilot, ctx):+ await press(pilot, *self.reach())+ await press(pilot, "a")+ await typed(pilot, "prefil=1")+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.extra, {"--prefil": "1"})+ t = text_of(app)+ self.assertIn("does not list --prefil", t)+ self.assertIn("Did you mean --prefill", t)+ self.assertIn("--prefil", t)+ self.run_app(case, ctx=ctx)++ def test_add_an_environment_setting(self):+ ctx = self.ctx_with_engine()++ async def case(app, pilot, ctx):+ await press(pilot, *self.reach(), "a")+ await typed(pilot, "STRATA_PIN_BY_NEED=1")+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.extra, {"STRATA_PIN_BY_NEED": "1"})+ self.run_app(case, ctx=ctx)++ def test_experimental_filter_and_text_filter(self):+ ctx = self.ctx_with_engine()++ async def case(app, pilot, ctx):+ await press(pilot, *self.reach(), "x")+ keys = [it.key for it in app.screen.menu().items]+ self.assertIn("--native-rope", keys)+ self.assertNotIn("--max-context", keys)+ await press(pilot, "x", "slash")+ await typed(pilot, "kv")+ await press(pilot, "enter")+ keys = [it.key for it in app.screen.menu().items]+ self.assertIn("--kv", keys)+ self.assertNotIn("--native-rope", keys)+ self.run_app(case, ctx=ctx)++ def test_next_and_back(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach(), "n")+ self.assertIn("Who can use it?", text_of(app))+ await press(pilot, "escape")+ self.assertIn("All settings", text_of(app))+ self.run_app(case)++ def test_works_before_the_engine_is_installed(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach())+ t = text_of(app)+ self.assertIn("The engine is not installed yet", t)+ self.assertIn("Command that will run", t)+ self.run_app(case)++ def test_copy_does_not_crash(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach(), "c")+ self.assertTrue(any(w in text_of(app) for w in ("Copied", "does not allow copying")))+ self.run_app(case)+++class AccessStep(Base):+ REACH = ("enter",) * 8++ def test_four_ways_and_what_each_needs(self):+ async def case(app, pilot, ctx):+ with mock.patch.object(access, "find_cloudflared", return_value=None), \+ mock.patch.object(access, "tailscale_status", return_value={"installed": False, "running": False, "ip": None, "name": None}):+ await press(pilot, *self.REACH[:7], "n")+ t = text_of(app)+ self.assertIn("This computer only", t)+ self.assertIn("http://127.0.0.1:8080", t)+ self.assertIn("http://192.168.1.5:8080", t)+ self.assertIn("cloudflared is not installed", t)+ self.assertIn("Tailscale is not installed", t)+ self.assertIn("Port [ 8080 ]", t)+ self.assertIn("API key [ off ]", t)+ self.run_app(case)++ def reach(self):+ return self.REACH[:7] + ("n",)++ def test_lan_makes_a_key_and_keeps_the_port(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach(), "down")+ t = text_of(app)+ self.assertTrue(ctx.settings.api_key.startswith("sk-strata-"))+ self.assertIn("API key [ on ]", t)+ self.assertIn("An API key was made for you", t)+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.access, "lan")+ self.assertIn("Save as preset, then launch", text_of(app))+ self.run_app(case)++ def test_cloudflare_without_the_helper_says_how_to_install_it_and_does_not_block(self):+ async def case(app, pilot, ctx):+ with mock.patch.object(access, "find_cloudflared", return_value=None):+ await press(pilot, *self.reach(), "down", "down")+ t = text_of(app)+ self.assertIn("cloudflared is not installed on this computer", t)+ self.assertIn("quick tunnel", t)+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.access, "cloudflare")+ self.assertIn("Save as preset, then launch", text_of(app))+ self.assertTrue(any("cloudflared" in w for w in ctx.warnings()))+ self.run_app(case)++ def test_tailscale_found(self):+ async def case(app, pilot, ctx):+ with mock.patch.object(access, "tailscale_status", return_value={"installed": True, "running": True, "ip": "100.64.0.1", "name": "pc.tail.ts.net"}):+ await press(pilot, *self.reach(), "down", "down", "down")+ self.assertIn("http://pc.tail.ts.net:8080", text_of(app))+ self.run_app(case)++ def test_port_change_and_bad_port(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach(), "p")+ app.screen.query_one("#portfield").value = ""+ await typed(pilot, "abc")+ await press(pilot, "enter")+ self.assertIn("is not a port number", text_of(app))+ app.screen.query_one("#portfield").value = ""+ await typed(pilot, "9090")+ await press(pilot, "enter")+ self.assertEqual(ctx.settings.port, 9090)+ self.assertIn("http://127.0.0.1:9090", text_of(app))+ self.run_app(case)++ def test_key_toggle_and_new_key(self):+ async def case(app, pilot, ctx):+ await press(pilot, *self.reach(), "down")+ first = ctx.settings.api_key+ await press(pilot, "k")+ self.assertNotEqual(ctx.settings.api_key, first)+ await press(pilot, "t")+ self.assertIsNone(ctx.settings.api_key)+ self.assertIn("will not start on a network without one", text_of(app))+ await press(pilot, "t")+ self.assertTrue(ctx.settings.api_key)+ self.run_app(case)+++class SaveAndRun(Base):+ def reach(self):+ return ("enter",) * 8 + ("n", "enter")++ def test_summary_and_save_then_launch(self):+ async def case(app, pilot, ctx):+ await press(pilot, *("enter",) * 7, "n", "enter")+ t = text_of(app)+ self.assertIn("Save as preset, then launch", t)+ self.assertIn("Qwen3.8-Flash-Next IQ3_XXS", t)+ self.assertIn("32K, memory int8", t)+ self.assertIn("quick (about 20 min)", t)+ self.assertIn("This computer only, port 8080", t)+ await press(pilot, "enter") # Save as a preset and launch+ await pilot.pause(0.8)+ self.assertEqual([p.name for p in store.list_presets()], ["IQ3_XXS 32K"])+ self.assertEqual(FakeRunner.instances[0].s.name, "IQ3_XXS 32K")+ self.assertIsNotNone(app.result)+ self.run_app(case)++ def test_launch_without_saving(self):+ async def case(app, pilot, ctx):+ await press(pilot, *("enter",) * 7, "n", "enter", "down", "enter")+ await pilot.pause(0.8)+ self.assertEqual(store.list_presets(), [])+ self.assertIsNotNone(app.result)+ self.run_app(case)++ def test_save_and_stop_here(self):+ async def case(app, pilot, ctx):+ await press(pilot, *("enter",) * 7, "n", "enter", "down", "down", "enter")+ await pilot.pause(0.3)+ self.assertEqual(len(store.list_presets()), 1)+ self.assertEqual(FakeRunner.instances, [])+ self.assertTrue(app.stopped_after_save)+ self.run_app(case)++ def test_the_name_can_be_typed(self):+ async def case(app, pilot, ctx):+ await press(pilot, *("enter",) * 7, "n", "enter")+ f = app.screen.query_one("#name")+ f.value = ""+ f.focus()+ await typed(pilot, "My preset")+ app.screen.set_focus(None)+ await press(pilot, "enter")+ await pilot.pause(0.5)+ self.assertEqual([p.name for p in store.list_presets()], ["My preset"])+ self.run_app(case)++ def test_run_screen_shows_the_stages_and_the_tuning_table(self):+ shown = {}++ async def case(app, pilot, ctx):+ store.save(S.LaunchSettings(name="T", family="qwen", model="IQ3_XXS", context=32768, tune="quick"))+ FakeRunner.behaviour = "ok"+ FakeRunner.hold = 1.5+ self.addCleanup(setattr, FakeRunner, "hold", 0)+ app.start_preset("T")+ await pilot.pause(0.05)+ for _ in range(100):+ t = text_of(app)+ if "Default settings" in t:+ shown["t"] = t+ break+ await pilot.pause(0.02)+ await pilot.pause(0.5)+ self.run_app(case)+ t = shown.get("t", "")+ self.assertIn("Tuning", t)+ self.assertIn("measurement 2 of 5", t)+ self.assertIn("Default settings", t)+ self.assertIn("83.0 tokens/s", t)+ self.assertIn("Close other heavy programs while it measures", t)++ def test_failure_says_what_it_means_and_retry_works(self):+ async def case(app, pilot, ctx):+ store.save(S.LaunchSettings(name="T", family="qwen", model="IQ3_XXS", context=32768))+ FakeRunner.behaviour = "fail"+ app.start_preset("T")+ await pilot.pause(0.6)+ t = flat(app)+ self.assertIn("Not enough disk space", t)+ self.assertIn("Press r to try again", t)+ FakeRunner.behaviour = "ok"+ await press(pilot, "r")+ await pilot.pause(0.8)+ self.assertIsNotNone(app.result)+ self.run_app(case)++ def test_stop_asks_and_cancels(self):+ async def case(app, pilot, ctx):+ store.save(S.LaunchSettings(name="T", family="qwen", model="IQ3_XXS", context=32768))+ FakeRunner.behaviour = "wait"+ app.start_preset("T")+ await pilot.pause(0.4)+ await press(pilot, "s")+ self.assertIn("Stop now?", text_of(app))+ self.assertIn("Files already downloaded are kept", flat(app))+ await press(pilot, "enter") # Stop+ await pilot.pause(0.6)+ self.assertIn("Stopped. Nothing was started.", text_of(app))+ self.run_app(case)+++class CardsStep(Base):+ def test_cards_step_only_with_two_cards(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter", "enter")+ t = text_of(app)+ self.assertIn("Which graphics cards should it use?", t)+ self.assertIn("Step 2 of 10", t)+ self.assertIn("Let Strata choose (recommended)", t)+ await press(pilot, "down", "enter")+ self.assertEqual(ctx.settings.gpus, [0])+ self.assertIn("Where should the model files be stored?", text_of(app))+ self.run_app(case, ctx=make_ctx(HW_2X16))++ def test_one_card_has_nine_steps(self):+ async def case(app, pilot, ctx):+ await press(pilot, "enter")+ self.assertIn("Step 1 of 9", text_of(app))+ self.run_app(case)+++class NarrowTerminal(Base):+ def test_80_columns_still_readable(self):+ ctx = make_ctx()+ app = LaunchApp(ctx)++ async def go():+ async with app.run_test(size=(80, 24)) as pilot:+ await pilot.pause(0.2)+ await press(pilot, "enter")+ t = text_of(app)+ self.assertIn("Which model?", t)+ self.assertIn("Step 1 of 9", t)+ self.assertIn("Enter next", t)+ await press(pilot, "enter", "enter")+ self.assertIn("How much text", text_of(app))+ asyncio.run(go())+++if __name__ == "__main__":+ unittest.main()