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: DeepSeek Speed choice, Faster (--experts 5, the default on a PC with 16 GB of graphics memory or less) or Full quality (--experts 6): a Speed step in the guided screens, --speed and --full-quality, plain words in --plan and the summary, the quality note; tests, docs
Niko1221bc1a3ba2ed14
diff --git a/docs/DEEPSEEK41.md b/docs/DEEPSEEK41.mdindex 14099136a..a6041d6a5 100644--- a/docs/DEEPSEEK41.md+++ b/docs/DEEPSEEK41.md@@ -88,6 +88,12 @@ The server speaks to the engine as it does for the other models, so `/v1/chat/coNot in this version: several requests at once (`--parallel` is ignored with a warning) and pictures (`--vision` is ignored with a warning).+## Speed: Faster or Full quality++DeepSeek picks 6 experts for every word it writes. **Faster** uses 5 of them (engine flag `--experts 5`): a small quality change, usually not noticeable, and answers come sooner. It is the default on a PC with 16 GB of graphics memory or less. **Full quality** uses all 6 (`--experts 6`).++In `strata launch` the guided screens have a Speed step for DeepSeek; with flags use `--speed faster|full`, or `--full-quality` in scripts. `strata launch --plan` shows which one this PC gets.+## Tuning`strata launch --tune quick` (or `thorough`, or the Tuning screen) works for DeepSeek with its own short tuner, `tools/dsv41/tune.py`. It startsdiff --git a/strata_cli/launch/app.py b/strata_cli/launch/app.pyindex 058239edf..f27dab0ec 100644--- a/strata_cli/launch/app.py+++ b/strata_cli/launch/app.py@@ -24,11 +24,11 @@ from strata_cli.launch import storefrom strata_cli.launch.catalog import Catalogfrom strata_cli.launch.runner import Cancelled, Event, LaunchError, Result, Runner, read_configfrom strata_cli.launch.screens import (AccessScreen, AdvancedScreen, CardsScreen, ConfirmScreen, ContextScreen, FolderScreen,- ModelScreen, ParallelScreen, PicturesScreen, RunScreen, SaveScreen, StartScreen,+ ModelScreen, ParallelScreen, PicturesScreen, RunScreen, SaveScreen, SpeedScreen, StartScreen,TuningScreen, flow_for)from strata_cli.launch.widgets import CSS, Glyphs-SCREENS = {"model": ModelScreen, "cards": CardsScreen, "folder": FolderScreen, "context": ContextScreen, "pictures": PicturesScreen,+SCREENS = {"model": ModelScreen, "cards": CardsScreen, "folder": FolderScreen, "context": ContextScreen, "pictures": PicturesScreen, "speed": SpeedScreen,"parallel": ParallelScreen, "tuning": TuningScreen, "advanced": AdvancedScreen, "access": AccessScreen, "save": SaveScreen}diff --git a/strata_cli/launch/catalog.py b/strata_cli/launch/catalog.pyindex 9f8e9359c..ef943d2cd 100644--- a/strata_cli/launch/catalog.py+++ b/strata_cli/launch/catalog.py@@ -151,6 +151,11 @@ class Computer:"If something fails, start again with --vision off to turn pictures off, and tell us at https://github.com/Niko1221/Strata/issues (say it is a B-series card and attach the engine log).")return None+ @property+ def total_vram_gb(self) -> float:+ """The graphics memory of all the cards that can be used together."""+ return sum(float(g.get("vram_gb") or 0) for g in self.usable_gpus)+@propertydef main_vram_gb(self) -> float:return max((float(g.get("vram_gb") or 0) for g in self.usable_gpus), default=0.0)diff --git a/strata_cli/launch/cmd.py b/strata_cli/launch/cmd.pyindex 8df981b91..97834ddcf 100644--- a/strata_cli/launch/cmd.py+++ b/strata_cli/launch/cmd.py@@ -105,6 +105,10 @@ def add_parsers(sp: argparse._SubParsersAction) -> list[argparse.ArgumentParser]help="which drafter guesses words ahead to make answers faster: auto (recommended: Strata picks from what it measured on cards like yours; ""that is the MTP today), mtp, dflash2 (Qwen3.8-Flash-Next only; downloads a 1.2 GB drafter once) or off. If DFlash2 cannot run ""(not enough graphics memory, or a model it is not for) the MTP is used and the start says why")+ g.add_argument("--speed", type=_choice("a speed", S.SPEED_MODES), metavar="faster|full",+ help="DeepSeek: faster uses 5 of 6 experts per word (a small quality change, usually not noticeable; the default on a PC with 16 GB "+ "of graphics memory or less), full uses all 6")+ g.add_argument("--full-quality", action="store_true", help="DeepSeek: all 6 experts per word (the same as --speed full), for scripts")g.add_argument("--gpu", metavar="LIST", help="graphics card numbers to use, e.g. 0 or 0,1 (default: the engine's choice)")g.add_argument("--gpu-roles", metavar="LIST", help="a role for each graphics card: main, helper or off, e.g. 1=main,0=helper (cards you do not name are off). ""Main does the last steps of every answer; a helper holds part of the model")@@ -233,6 +237,12 @@ def settings_from_args(a: argparse.Namespace, catalog=None) -> tuple[S.LaunchSets.mtp = a.mtpif a.drafting:s.drafting = a.drafting+ if getattr(a, "full_quality", False):+ if getattr(a, "speed", None) == "faster":+ notices.append(S.Notice("warn", "--full-quality and --speed faster were both given; full quality is used.", ""))+ s.speed = "full"+ elif getattr(a, "speed", None):+ s.speed = a.speedif a.gpu and getattr(a, "gpu_roles", None):raise ValueError("Use --gpu (which cards) or --gpu-roles (a role for each card), not both.")if a.gpu:@@ -337,6 +347,9 @@ def apply_defaults(s: S.LaunchSettings, catalog) -> tuple[S.LaunchSettings, listif s.vision not in (None, "off"):notices.append(S.Notice("warn", "DeepSeek-V4.1-Flash cannot read pictures in this Strata version, so pictures are off.", ""))s.vision = "off" # (tuning is DeepSeek's own short tune: tools/dsv41/tune.py, run by the launch)+ elif s.speed:+ notices.append(S.Notice("warn", "--speed and --full-quality are for DeepSeek; this model uses all its experts, so they are not used.", ""))+ s.speed = Nonenotices += S.check_context(s, max_fit_tokens=None)if s.access != "local" and not s.api_key and not s.no_key:from strata_cli.launch import access@@ -694,7 +707,7 @@ def run_launch(a: argparse.Namespace) -> int:s, notices = settings_from_args(a, catalog)if not machine:_interrupted_move_notice()- have_choices = bool(a.preset or a.model or a.model_path or a.context or a.vision or a.parallel or a.access or a.tune or a.drafting)+ have_choices = bool(a.preset or a.model or a.model_path or a.context or a.vision or a.parallel or a.access or a.tune or a.drafting or getattr(a, "speed", None) or getattr(a, "full_quality", False))interactive = sys.stdin.isatty() and sys.stdout.isatty() and not a.no_tui and not machine and not a.planplain_questions = Falseno_screens_package = None@@ -756,6 +769,8 @@ def run_launch(a: argparse.Namespace) -> int:_say(f" download {(plan.get('download') or {}).get('text', '')}")if plan.get("drafting"):_say(f" drafting {plan['drafting'].replace('Drafting: ', '', 1)}")+ if plan.get("speed"):+ _say(f" speed {plan['speed'].replace('Speed: ', '', 1)}")_placement_lines(plan.get("placement"))_say(f" tuning {s.tune} access {S.ACCESS_WORDS[s.access]}, port {s.port}"+ (" API key on" if s.api_key else ""))@@ -824,6 +839,11 @@ def run_launch(a: argparse.Namespace) -> int:from strata_cli.launch import access_say(f" {'API key':<14} {access.mask_key(result.key)} (show it: strata launch --show-key"+ (f" --preset \"{s.name}\")" if (a.preset or a.save_preset) else ")"))+ speed_line = runner.speed_line() if hasattr(runner, "speed_line") else ""+ if speed_line and not isinstance(speed_line, str):+ speed_line = ""+ if speed_line:+ _say(f" {'Speed':<14} {speed_line.replace('Speed: ', '', 1)}")engine_log = _engine_log_of(result.config)if engine_log:_say(f" {'Engine log':<14} {engine_log} (follow it: strata logs --follow)")diff --git a/strata_cli/launch/runner.py b/strata_cli/launch/runner.pyindex 73f4d1806..11ccfa7c7 100644--- a/strata_cli/launch/runner.py+++ b/strata_cli/launch/runner.py@@ -398,7 +398,25 @@ def cards_for_launch(s: S.LaunchSettings, catalog, ram_gb: float | None = None,return None-def derive_config(base: dict, s: S.LaunchSettings, *, bool_flags: frozenset[str], log: str | None = None, gpus: "list[int] | dict | None" = None) -> dict:+def apply_experts(cfg: dict, experts: int | None) -> None:+ """DeepSeek's speed choice as the engine flag: --experts 5 (Faster) or --experts 6 (Full quality), replacing one already in the saved args."""+ if experts is None or not isinstance(cfg.get("args"), list):+ return+ args, out, i = [str(x) for x in cfg["args"]], [], 0+ while i < len(args):+ if args[i] == "--experts":+ i += 2+ continue+ if args[i].startswith("--experts="):+ i += 1+ continue+ out.append(args[i])+ i += 1+ cfg["args"] = out + ["--experts", str(int(experts))]+++def derive_config(base: dict, s: S.LaunchSettings, *, bool_flags: frozenset[str], log: str | None = None, gpus: "list[int] | dict | None" = None,+ experts: int | None = None) -> dict:"""The private run config of this launch: the installed one plus the choices that are not setup's (host, port, key, cards, advanced)."""from strata_control import tune_knobscfg = json.loads(json.dumps(base))@@ -434,6 +452,7 @@ def derive_config(base: dict, s: S.LaunchSettings, *, bool_flags: frozenset[str]cfg["env"] = tune_knobs.apply_to_env(dict(cfg.get("env") or {}), e_changes)from strata_control import draft_layerdraft_layer.apply(cfg) # "mtp": false (from the installed config too) never sits beside --mtp in the saved args (B10)+ apply_experts(cfg, experts)return cfg@@ -1284,7 +1303,8 @@ class Runner:from strata_control import tune_knobsbase = read_config(base_path)cfg = derive_config(base, self.s, bool_flags=tune_knobs.BOOL_FLAGS,- log=str(launch_dir() / f"{self.name}.engine.log"), gpus=cards_for_launch(self.s, self.catalog, base=base))+ log=str(launch_dir() / f"{self.name}.engine.log"), gpus=cards_for_launch(self.s, self.catalog, base=base),+ experts=self.experts_flag())self.use_own_dsv41_engine(cfg)wait = self.start_wait()if wait > 600 and not cfg.get("engine_ready_s"): # the server's own wait for the engine (900 s) must not end before the start's@@ -1894,11 +1914,38 @@ class Runner:model = {"title": title, "family": s.family, "model": s.model, "model_gb": row.download_gb if row is not None else None,"own_files": bool(s.model_path), "folder": s.model_path}out = {"profile": self.profile, "settings": s.to_dict(with_key=False), "warnings": warns,- "flags": S.flags_text(s), "steps": list(STAGES), "model": model, "download": download, "drafting": self.drafting_plan_line()}+ "flags": S.flags_text(s), "steps": list(STAGES), "model": model, "download": download, "drafting": self.drafting_plan_line(),+ "speed": self.speed_line()}if self.multi_file():out["placement"] = self.placement()return out+ def resolved_speed(self) -> tuple[str, bool] | None:+ """DeepSeek's speed: ("faster" | "full", whether it is the default for this PC); None for any other model. Faster is the default on a PC+ with 16 GB of graphics memory or less."""+ if not self.multi_file():+ return None+ try:+ default = S.faster_default(self.catalog.computer().total_vram_gb)+ except Exception: # noqa: BLE001 - when the cards cannot be read, the engine's own default stands+ default = False+ if self.s.speed in S.SPEED_MODES:+ return self.s.speed, (self.s.speed == "faster") == default+ return ("faster" if default else "full"), True++ def experts_flag(self) -> int | None:+ """The value of the engine's --experts for this launch (5 or 6), None for a model that has no such choice."""+ speed = self.resolved_speed()+ return None if speed is None else (5 if speed[0] == "faster" else 6)++ def speed_line(self) -> str:+ """The speed line of --plan and of the summary, in plain words, with the quality note when it is Faster."""+ speed = self.resolved_speed()+ if speed is None:+ return ""+ text = "Speed: " + S.speed_words(speed[0], speed[1])+ return text + (". " + S.FASTER_NOTE if speed[0] == "faster" else "")+def drafting_plan_line(self) -> str:"""The drafting line of --plan: what drafts, or why not what was asked for. Nothing is changed or downloaded."""from strata_control import draftingdiff --git a/strata_cli/launch/screens.py b/strata_cli/launch/screens.pyindex a17bbd544..c2bfa4134 100644--- a/strata_cli/launch/screens.py+++ b/strata_cli/launch/screens.py@@ -30,11 +30,16 @@ STEPS = (("model", "Model"), ("cards", "Cards"), ("folder", "Folder"), ("context("parallel", "Parallel"), ("tuning", "Tuning"), ("advanced", "Advanced"), ("access", "Access"), ("save", "Save"))+STEP_LABELS = {**dict(STEPS), "speed": "Speed"}++def flow_for(ctx) -> list[str]:- """The steps of this computer: the Cards step exists only when two or more graphics cards can be used."""+ """The steps of this computer: the Cards step exists only when two or more graphics cards can be used; the Speed step only for DeepSeek."""ids = [sid for sid, _ in STEPS]if len(ctx.computer.usable_gpus) < 2:ids.remove("cards")+ if getattr(ctx.settings, "family", None) == "deepseek41":+ ids.insert(ids.index("context") + 1, "speed")return ids@@ -111,7 +116,7 @@ class Base(Screen):out.append("STRATA ", style=f"bold {ACCENT}")out.append(f"{self.title_line}", style=f"bold {ACCENT}")if self.step_id in flow:- labels = dict(STEPS)+ labels = STEP_LABELSn = flow.index(self.step_id)if self.width() >= 118:out.append(" ")@@ -1023,6 +1028,43 @@ class PicturesScreen(Base):self.ctx.settings.vision = key+# ------------------------------------------------------------------------------------------------ DeepSeek: speed++class SpeedScreen(Base):+ step_id = "speed"+ help_text = ("DeepSeek picks 6 experts for every word it writes. Faster uses 5 of them: answers come sooner, with a small quality change that is "+ "usually not noticeable. Full quality uses all 6. Faster is the default on a PC with 16 GB of graphics memory or less.")++ def body(self) -> ComposeResult:+ yield Static(Text("Speed or full quality?", style=f"bold {ACCENT}"), markup=False)+ yield Menu(id="menu")++ def default_faster(self) -> bool:+ return S.faster_default(self.ctx.computer.total_vram_gb)++ def on_mount(self) -> None:+ s = self.ctx.settings+ faster_default = self.default_faster()+ here = Cell("default on this PC", "")+ items = [Item(["Faster", here if faster_default else Cell("", "")], key="faster"),+ Item(["Full quality", here if not faster_default else Cell("", "")], key="full")]+ sel = 0 if (s.speed or ("faster" if faster_default else "full")) == "faster" else 1+ self.query_one(Menu).columns = [("", 24), ("", 0)]+ self.query_one(Menu).set_items(items, sel)+ self.paint()++ def explain(self) -> Text:+ key = self.menu().current.key if self.menu() and self.menu().current else "faster"+ if key == "faster":+ return Text(S.FASTER_NOTE + " It is the default on a PC with 16 GB of graphics memory or less.", style=MUTE)+ return Text("Full quality uses all 6 experts per word. Answers are a little slower; pick it when the last bit of quality matters more.", style=MUTE)++ def commit(self) -> None:+ key = self.menu().current.key+ default = "faster" if self.default_faster() else "full"+ self.ctx.settings.speed = None if key == default else key # the default stays "the default for this PC" in a saved preset++# ------------------------------------------------------------------------------------------------ 6 parallelclass ParallelScreen(Base):@@ -1492,6 +1534,8 @@ class SaveScreen(Base):lines = [("Model", (r.title if r else (s.model or "?")) + (" (your files)" if s.model_path else "")),("Context", S.context_label(s.context) + f", memory {s.kv or 'int8'}"),("Pictures", "on" if s.vision != "off" else "off"),+ *([("Speed", S.speed_words(s.speed or ("faster" if S.faster_default(self.ctx.computer.total_vram_gb) else "full"),+ s.speed is None))] if s.family == "deepseek41" else []),("Parallel", f"{s.parallel} at a time" if s.parallel else f"fit to your card ({S.fit_parallel(self.ctx.computer.main_vram_gb)})"),("Tuning", ({"quick": "quick (about 5-10 min)", "thorough": "thorough (about 10-15 min)", "skip": "skipped"} if s.family == "deepseek41"else {"quick": "quick (about 20 min)", "thorough": "thorough (up to 2 h)", "skip": "skipped"})[s.tune]),diff --git a/strata_cli/launch/settings.py b/strata_cli/launch/settings.pyindex dd175f286..92b088df8 100644--- a/strata_cli/launch/settings.py+++ b/strata_cli/launch/settings.py@@ -28,6 +28,21 @@ VISION_MODES = ("off", "on", "gpu", "cpu")MTP_MODES = ("on", "off")#: strata_control/drafting.py MODES (tests/terminal/test_drafting.py keeps the two the same)DRAFTING_MODES = ("auto", "mtp", "dflash2", "off")+SPEED_MODES = ("faster", "full") # DeepSeek: 5 experts per word (Faster) or all 6 (Full quality)+FASTER_VRAM_GB = 16.5 # Faster is the default on a PC with this much graphics memory or less (the owner's 0.2.4.3 decision)+FASTER_NOTE = "Faster uses 5 of 6 experts per word: a small quality change, usually not noticeable."+++def faster_default(total_vram_gb: float | None) -> bool:+ """Faster is the default on a PC with 16 GB of graphics memory or less, in all (the cards that can be used together)."""+ return bool(total_vram_gb) and float(total_vram_gb) <= FASTER_VRAM_GB+++def speed_words(speed: str, default: bool) -> str:+ """The plain words for the chosen speed, for --plan and the summary."""+ if speed == "faster":+ return "Faster" + (" (default on this PC)" if default else "")+ return "Full quality" + (" (default on this PC)" if default else "") + ": all 6 experts per word"KV_MODES = ("int8", "q4_0", "k8v4", "fp16")DEFAULT_PORT = 8080@@ -90,6 +105,7 @@ class LaunchSettings:kv: str | None = None # None = int8 above 8K, as setupvision: str | None = None # None = the default (on when the model can read pictures and the engine has the reader), off | on | gpu | cpuparallel: int | None = None # None = fit to the card+ speed: str | None = None # DeepSeek only: None = the default for this PC (faster up to 16 GB of graphics memory); faster | fulldrafting: str | None = None # None = Auto (recommended): the table in strata_control/drafting.py; mtp | dflash2 | off choose one. Saved in the launch configmtp: str | None = None # None = as installed (draft layer on); "off" starts without it (less graphics memory and RAM, slower); "on" overrides an installed "off"tune: str = "skip" # quick | thorough | skip@@ -293,6 +309,10 @@ def flags_text(s: LaunchSettings, *, preset: str | None = None) -> str:parts.append(f"--mtp {s.mtp}")if s.drafting:parts.append(f"--drafting {s.drafting}")+ if s.speed == "full":+ parts.append("--full-quality")+ elif s.speed == "faster":+ parts.append("--speed faster")parts.append(f"--tune {s.tune}")if s.tune_allow_small:parts.append("--tune-allow-small")diff --git a/tests/terminal/test_launch_speed.py b/tests/terminal/test_launch_speed.pynew file mode 100644index 000000000..557f8d6bb--- /dev/null+++ b/tests/terminal/test_launch_speed.py@@ -0,0 +1,163 @@+"""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 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+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, 16.4):+ self.assertTrue(S.faster_default(gb), gb)+ for gb in (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 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, vram_gb, **kw):+ cat = mock.Mock()+ cat.strata.multi_family.return_value = True+ cat.computer.return_value = mock.Mock(total_vram_gb=vram_gb)+ return Runner(S.LaunchSettings(family="deepseek41", model="IST-DAS-2.00bpw", **kw), catalog=cat, emit=lambda e: None)++ def test_a_12_gb_pc_gets_faster_and_a_big_one_full_quality_by_default(self):+ self.assertEqual(self.runner(12).resolved_speed(), ("faster", True))+ self.assertEqual(self.runner(12).experts_flag(), 5)+ self.assertEqual(self.runner(96).resolved_speed(), ("full", True))+ self.assertEqual(self.runner(96).experts_flag(), 6)++ def test_a_choice_wins_over_the_default(self):+ self.assertEqual(self.runner(12, speed="full").resolved_speed(), ("full", False))+ self.assertEqual(self.runner(12, speed="full").experts_flag(), 6)+ self.assertEqual(self.runner(96, speed="faster").experts_flag(), 5)++ 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_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"+ 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"+ 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 S.faster_default(ctx.computer.total_vram_gb) else "faster")+ await press(pilot, "down")+ screen.commit()+ self.assertIn(ctx.settings.speed, (None, "full"))+ asyncio.run(go())+++if __name__ == "__main__":+ unittest.main()