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++
"""The model catalog, the computer's figures and the fit words for `strata launch`.
There is ONE catalog: setup.py's MODELS / FAMILIES / CONTEXTS, which the desktop app reads through tools/strata_mcp.py
(`Strata.model_table`, `Strata.hardware`, `Strata.recommend`; the app page's own fit arithmetic is
apps/host/src/lib/native-fit.ts `fitOn`). This module loads that same file from the installer folder and ports `fitOn` line by
line; it holds no table of its own. Without the installer files (a Terminal bundle made before launch existed) it says so in
words instead of guessing.
"""
from __future__ import annotations
import importlib.util
import json
import os
import sys
from dataclasses import dataclass, field
from pathlib import Path
from typing import Any
from strata_cli.launch import settings as S
class CatalogUnavailable(RuntimeError):
"""The installer files (setup.py, tools/strata_mcp.py) are not there; the message is for the user."""
# --- apps/host/src/lib/native-fit.ts, ported (same constants, same rules) ------------------------------------------------
DENSE_GB = 5.0
SYSTEM_ROOM_GB = 10.0
DENSE_EXTRA_GB = 1.0
def _round1(n: float) -> float:
return round(n * 10) / 10
def memory_needed(v: dict) -> float:
if isinstance(v.get("memory_gb"), (int, float)):
return float(v["memory_gb"])
if v.get("mem_total") and isinstance(v.get("ram_needed_gb"), (int, float)):
return float(v["ram_needed_gb"])
return _round1(float(v.get("experts_gb") or v.get("ram_needed_gb") or 0) + DENSE_EXTRA_GB)
def fit_on(v: dict, ram_gb: float | None, vram_gb: float | None) -> dict[str, Any]:
"""native-fit.ts `fitOn`: where the weights go on this computer. Returns memoryGb, vramUseGb, ramUseGb, spillGb, known."""
memory = memory_needed(v)
vram = float(vram_gb or 0)
if not ram_gb or ram_gb <= 0:
return {"memoryGb": memory, "vramUseGb": 0.0, "ramUseGb": 0.0, "spillGb": 0.0, "known": False}
experts = max(0.0, memory - DENSE_EXTRA_GB)
on_gpu = max(0.0, min(experts, vram - DENSE_GB))
ram_room = max(0.0, float(ram_gb) - SYSTEM_ROOM_GB)
spill = max(0.0, experts - on_gpu - ram_room)
in_ram = max(0.0, experts - on_gpu - spill)
vram_use = min(vram, DENSE_GB + on_gpu) if vram > 0 else 0.0
return {"memoryGb": memory, "vramUseGb": _round1(vram_use),
"ramUseGb": _round1(in_ram + (DENSE_EXTRA_GB if vram <= 0 else 0)), "spillGb": _round1(spill), "known": True}
# --- the verdict words ---------------------------------------------------------------------------------------------------
FITS, TIGHT, NO = "fits", "tight", "no"
def verdict(on_this_pc: str | None) -> tuple[str, str]:
"""(category, plain words) from the catalog's own `on_this_pc` text (setup.py `--check`'s rules, through strata_mcp).
Never a block: `no` still lets the person try, and the screen says so."""
text = (on_this_pc or "").strip()
low = text.lower()
if not text:
return TIGHT, "not checked (this computer's memory could not be read)"
if low.startswith("does not fit"):
return NO, "too big (can still try)"
if "free disk space" in low: # DeepSeek: fits in memory, not on the disk (still allowed)
return TIGHT, "tight: needs more disk space"
if "low-ram mode" in low:
return FITS, "fits, a bit slower"
if "part of its experts" in low or "read from the ssd" in low:
base = "slow here" in low
return (TIGHT, "tight: much read from SSD") if base else (FITS, "fits, part read from SSD")
if low.startswith("tight"):
return TIGHT, "tight: close other programs"
if "fits" in low:
return FITS, "fits"
return TIGHT, text
@dataclass
class ModelRow:
family: str
family_title: str
model: str
id: str # the run config's tag (strata-<id>.json)
about: str
download_gb: float
need_vram_gb: float
need_ram_gb: float
spill_gb: float
verdict: str
words: str
experimental: bool
images: bool
installed: bool
recommended: bool = False
mem_total: bool = False
memory_gb: float = 0.0
@property
def title(self) -> str:
return f"{self.family_title} {self.model}"
@dataclass
class Computer:
ram_gb: float | None = None
gpus: list[dict] = field(default_factory=list)
disk_free_gb: float | None = None
os: str = ""
avx2: bool | None = None
raw: dict = field(default_factory=dict)
engine_vendor: str | None = None # the make of card the engine drives (nvidia, amd, intel, apple); None: the cards name none
@property
def usable_gpus(self) -> list[dict]:
"""The cards that count and the engine can drive (strata_control/gpu_fit.py: an integrated chip, a tiny card or a card of another
make is left out), the largest first. One engine drives one make, so a model is never split across makes."""
from strata_control import gpu_fit
return gpu_fit.usable_cards(gpu_fit.for_vendor(self.gpus, self.engine_vendor)[0])[0]
@property
def ignored_gpus(self) -> list[dict]:
from strata_control import gpu_fit
mine, others = gpu_fit.for_vendor(self.gpus, self.engine_vendor)
return gpu_fit.usable_cards(mine)[1] + [{**c, "why_ignored": "another make of card than this engine drives"} for c in others]
@property
def other_vendor_note(self) -> str | None:
"""One plain line when a card of another make is the bigger one (None otherwise)."""
from strata_control import gpu_fit
return gpu_fit.other_vendor_note(self.gpus, self.engine_vendor)
@property
def new_card_note(self) -> tuple[str, str] | None:
"""(what, what to do) when a usable card is an Intel Arc B-series (Battlemage): allowed, but new to Strata and untested by the maintainers."""
import re
from strata_control import gpu_fit
for c in gpu_fit.usable_cards(gpu_fit.for_vendor(self.gpus, self.engine_vendor)[0])[0]:
if c.get("vendor") == "intel" and re.search(r"Arc (?:Pro )?B\d", str(c.get("name", ""))):
return (f"The {str(c['name']).replace('Intel ', '')} is a B-series Arc card. It is new to Strata and we have not tested it ourselves, so pictures or long answers may fail on it.",
"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 main_vram_gb(self) -> float:
return max((float(g.get("vram_gb") or 0) for g in self.usable_gpus), default=0.0)
def line(self, data_dir: str | None = None) -> str:
g = self.usable_gpus
if g and g[0].get("unified_gb"): # a Mac: one pool of memory, the chip is the graphics
disk = f"{self.disk_free_gb:,.0f} GB free" if self.disk_free_gb is not None else ""
return " · ".join(x for x in (g[0].get("name", "Apple silicon"), f"{self.ram_gb:.0f} GB unified memory" if self.ram_gb else "memory unknown", disk) if x)
card = (f"{g[0].get('name', 'GPU').replace('NVIDIA GeForce ', '').replace('AMD Radeon ', '')} {g[0].get('vram_gb', 0):.0f} GB"
+ (f" x{len(g)}" if len(g) > 1 else "")) if g else "no usable graphics card found"
ram = f"{self.ram_gb:.0f} GB RAM" if self.ram_gb else "RAM unknown"
disk = f"{self.disk_free_gb:,.0f} GB free" if self.disk_free_gb is not None else ""
return " · ".join(x for x in (card, ram, disk) if x)
def installer_folder(explicit: str | os.PathLike | None = None) -> Path:
"""Where setup.py and tools/ are: this Terminal's own folder (the bundle, or a source checkout)."""
if explicit:
return Path(explicit)
return Path(__file__).resolve().parents[2]
def install_places(explicit: str | os.PathLike | None = None, src: str | os.PathLike | None = None) -> list:
"""Every folder with run configs, main one first: the SAME discovery `strata models list` and the own-files import use
(strata_control/discovery.py). An explicit folder (the argument, or STRATA_INSTALL_DIR) is the only one."""
from strata_control import discovery
return discovery.places(here=installer_folder(src), explicit=explicit)
def install_root(explicit: str | os.PathLike | None = None, src: str | os.PathLike | None = None) -> Path:
"""Where run configs of installed models live: the main place found by the shared discovery, else the folder a new model is
installed into (beside the components folder, what the app uses)."""
from strata_control import discovery
if explicit:
return Path(explicit)
env = os.environ.get("STRATA_INSTALL_DIR")
if env:
return Path(env)
return discovery.find_install(here=installer_folder(src))[0]
# Intel Arc cards by PCI id: (name, memory in GB). The kernel does not tell an ordinary user how much memory the card has, so the common
# cards are listed; an id that is not here is shown as "Intel Arc" with no size and is treated as a small card. (A770: the 8 GB model shares
# the id of the 16 GB one, so the smaller figure is used.)
INTEL_ARC = {"0x56a1": ("Arc A750", 8.0), "0x56a2": ("Arc A580", 8.0), "0x56a0": ("Arc A770", 8.0), "0x56a5": ("Arc A380", 6.0),
"0x56a6": ("Arc A310", 4.0), "0xe20b": ("Arc B580", 12.0), "0xe20c": ("Arc B570", 10.0), "0xe223": ("Arc Pro B70", 32.0)}
def intel_arc_cards(root: str = "/sys/class/drm") -> list[dict]:
"""The Intel Arc cards on this Linux computer, read from the kernel's device list (empty elsewhere)."""
cards: list[dict] = []
try:
for dev in sorted(Path(root).glob("card[0-9]/device")):
if (dev / "vendor").read_text().strip() != "0x8086":
continue
did = (dev / "device").read_text().strip().lower()
if did not in INTEL_ARC:
continue
name, gb = INTEL_ARC[did]
cards.append({"vendor": "intel", "name": "Intel " + name, "vram_gb": gb, "usable": True, "index": len(cards)})
except OSError:
pass
return cards
class Catalog:
"""setup.py's tables through strata_mcp's `Strata` object (the app's own catalog code)."""
def __init__(self, src: str | os.PathLike | None = None, root: str | os.PathLike | None = None,
hardware: dict | None = None):
self.src = installer_folder(src)
self.places = install_places(root, self.src)
self.root = Path(root) if root else (self.places[0].path if self.places else install_root(None, self.src))
mcp = self.src / "tools" / "strata_mcp.py"
if not mcp.is_file() or not (self.src / "setup.py").is_file():
raise CatalogUnavailable(
"This Terminal does not carry the model list. Install it again with the one-line installer, "
"or run `strata launch` from a full Strata folder (the folder with setup.py).")
self.root.mkdir(parents=True, exist_ok=True)
name = "strata_mcp_for_launch"
mod = sys.modules.get(name)
if mod is None:
if str(self.src) not in sys.path:
sys.path.insert(0, str(self.src))
spec = importlib.util.spec_from_file_location(name, mcp)
mod = importlib.util.module_from_spec(spec)
sys.modules[name] = mod
real = sys.stdout
sys.stdout = sys.stderr # the module must not print into a screen
try:
spec.loader.exec_module(mod)
finally:
sys.stdout = real
self.mcp = mod
self.strata = mod.Strata(self.root, self.src)
self._mcp_data_dir = self.strata.data_dir
self.strata.data_dir = self.data_dir # one answer to "where is the data folder" for every caller, the app's included
self._hardware_override = hardware
# ---- the computer
def hardware(self, fresh: bool = False) -> dict:
if self._hardware_override is not None:
hw = dict(self._hardware_override)
hw.setdefault("disk_free_gb", self.strata.disk_free(self.strata.data_dir()))
return hw
hw = dict(self.strata.hardware(fresh=fresh))
hw["gpus"] = self._admit_old_nvidia(list(hw.get("gpus") or []))
if not hw.get("gpus") and not str(hw.get("os", "")).startswith("Windows"):
arc = intel_arc_cards()
if arc:
hw["gpus"] = arc # the shared hardware reader knows NVIDIA and AMD only; an Arc is added here
return hw
@staticmethod
def _admit_old_nvidia(gpus: list[dict]) -> list[dict]:
"""Pascal / Volta cards (P100, P40, V100: compute capability 6.0-7.0) run on the experimental CUDA 12 engine. setup.py admits them when they
are the only kind of graphics card in the computer (`old_gpus_opt_in`: "it is the only kind of NVIDIA GPU in this PC"); the shared hardware
reader does not, so the screens said "no usable graphics card found" and left out the Cards step on a computer with several V100s.
A newer NVIDIA card or a usable AMD card keeps the old cards out of the way, exactly as in setup."""
def arch(g: dict) -> int:
try:
return int(g.get("arch"))
except (TypeError, ValueError):
return 0
old = [g for g in gpus if g.get("vendor") == "nvidia" and 60 <= arch(g) <= 70 and not g.get("usable", True)]
if not old:
return gpus
if any(g.get("usable", True) for g in gpus):
return gpus
return [({**g, "usable": True, "problem": None,
"note": "experimental: the CUDA 12 engine (docs/OLDER_GPUS.md)"} if g in old else g) for g in gpus]
def computer(self, fresh: bool = False) -> Computer:
hw = self.hardware(fresh)
return Computer(ram_gb=hw.get("ram_gb"), gpus=list(hw.get("gpus") or []), disk_free_gb=hw.get("disk_free_gb"),
os=str(hw.get("os") or ""), avx2=(hw.get("cpu") or {}).get("avx2"), raw=hw,
engine_vendor=self.engine_vendor(hw))
def installed_backend(self) -> str | None:
"""The installed engine's backend (cuda, hip, sycl, cpu, metal), None when there is no usable engine yet."""
try:
from strata_control import engine_component as ec
rep = ec.status()
if rep.get("usable"):
return (rep.get("engine") or {}).get("backend")
except Exception: # noqa: BLE001
pass
return None
def engine_vendor(self, hw: dict | None = None) -> str | None:
"""The make of card the engine drives: the installed engine's; with none installed, the engine setup would fetch (NVIDIA first when the
computer has several makes)."""
from strata_control import gpu_fit
hw = hw if hw is not None else self.hardware()
return gpu_fit.pick_vendor(list(hw.get("gpus") or []), self.installed_backend())
# ---- the tables
def tables(self):
models, families, contexts, source = self.strata.tables()
return models, families, list(contexts), source
def contexts(self) -> list[int]:
return [int(c) for c in self.tables()[2]]
def contexts_for(self, family: str | None, model: str | None = None) -> list[int]:
"""The context sizes to offer for this model: DeepSeek-V4.1-Flash goes up to 1M (its installed pack's own limit when it has one), the
others keep the shared list."""
if family and self.strata.multi_family(family):
from strata_control import dsv41_context
return dsv41_context.choices(self.pack_limit(family, model))
return self.contexts()
def pack_limit(self, family: str | None, model: str | None) -> int | None:
"""The installed DeepSeek pack's own context limit (ds4.txt), None when it is not installed or the file does not say."""
if not (family and model and self.strata.multi_family(family)):
return None
try:
from strata_control import dsv41_context
from strata_cli.launch.runner import read_config
path = self.installed_config(self.tag_of(family, model))
return dsv41_context.limit_of_config(read_config(path)) if path else None
except Exception: # noqa: BLE001 - no file, no limit: the choices stay as they are
return None
def recommendation(self, hw: dict | None = None) -> dict:
return self.strata.recommend(hw or self.hardware())
def rows(self, hw: dict | None = None) -> list[ModelRow]:
hw = hw or self.hardware()
comp = Computer(ram_gb=hw.get("ram_gb"), gpus=list(hw.get("gpus") or []), engine_vendor=self.engine_vendor(hw))
vram = comp.main_vram_gb
rec = self.recommendation(hw)
out: list[ModelRow] = []
own = self.strata.own_families() # Qwen3.6 is listed for the app; the Terminal's launch list is Flash-Next's
dsv41 = None
for fam in self.strata.model_table(hw):
if fam["family"] in own and not own[fam["family"]].get("multi_file"):
continue
for size in fam["sizes"]:
f = fit_on(size, hw.get("ram_gb"), vram)
if size.get("multi_file"): # DeepSeek-V4.1-Flash: shared over every card (strata_control/dsv41_fit.py)
dsv41 = self.strata.dsv41_plan(hw, model=size["model"])
f = {"vramUseGb": _round1(dsv41["vram_experts_gb"] + sum(c["dense_gb"] for c in dsv41["cards"])),
"ramUseGb": _round1(dsv41.get("ram_needed_gb") or dsv41["cpu_experts_gb"]), "spillGb": _round1(dsv41.get("spill_gb") or 0.0)}
cat, words = verdict(size.get("on_this_pc"))
out.append(ModelRow(
family=fam["family"], family_title=fam["title"], model=size["model"], id=size["id"],
about=size["about"], download_gb=float(size["download_gb"]), need_vram_gb=f["vramUseGb"],
need_ram_gb=f["ramUseGb"], spill_gb=f["spillGb"], verdict=cat, words=words,
experimental=bool(size.get("experimental") or fam.get("experimental")), images=bool(size.get("images")),
installed=bool(size.get("installed")) or self.installed_config(str(size["id"])) is not None, mem_total=bool(size.get("mem_total")),
memory_gb=float(size.get("memory_gb") or 0),
recommended=(rec.get("family") == fam["family"] and rec.get("model") == size["model"])))
return out
def resolve(self, model: str, family: str | None = None) -> tuple[str, str]:
"""`iq3_xxs` or `IQ3_XXS` (and an optional family) -> (family, model); raises ValueError with the closest match."""
models, families, _ctx, _src = self.tables()
names = list(models)
for fam_name, fam_d in families.items(): # DeepSeek-V4.1-Flash's size is not one of setup's MODELS
if fam_d.get("multi_file"):
names += [m for m in self.strata.sizes_of(models, fam_name) if m not in names]
match = next((n for n in names if n.lower() == model.lower()), None)
if match is None:
near = S.closest(model, names)
raise ValueError(f"There is no model called '{model}'." + (f" Did you mean '{near}'?" if near else "")
+ " Models: " + ", ".join(names) + ".")
if family is not None and family not in families:
near = S.closest(family, list(families))
raise ValueError(f"There is no model family called '{family}'." + (f" Did you mean '{near}'?" if near else "")
+ " Families: " + ", ".join(families) + ".")
offered = [f for f in families if match in self.strata.sizes_of(models, f)]
if family is not None:
if family not in offered:
raise ValueError(f"{families[family]['title']} has no size {match}. It offers: "
+ ", ".join(self.strata.sizes_of(models, family)) + ".")
return family, match
if not offered:
raise ValueError(f"{match} is not offered by any model family here.")
return ("qwen" if "qwen" in offered else offered[0]), match
def tag_of(self, family: str, model: str) -> str:
_m, families, _c, _s = self.tables()
return (families[family].get("tag", "") + model).lower()
def model_folder(self, base: Path, family: str, model: str) -> Path:
"""The folder a model's files are in under `base/models`. setup.py names it with the case kept (`models/IQ3_S`), the run-config tag is
lower case (`iq3_s`): on a case-sensitive disk the two are different folders, so the one that exists wins, and a folder that differs
only in case is found (#3996). When none exists yet it is setup's own name, because that is where the download will go."""
_m, families, _c, _s = self.tables()
models = Path(base) / "models"
own = models / (families[family].get("tag", "") + model)
lower = models / self.tag_of(family, model)
for candidate in (own, lower):
if candidate.is_dir():
return candidate
try:
for entry in models.iterdir():
if entry.name.lower() == lower.name and entry.is_dir():
return entry
except OSError:
pass
return own
def kv_gb(self, tokens: int, kv: str = "int8") -> float:
"""The conversation memory for this many tokens, in GB (setup.py's UD_FIT_KV_BYTES: 13 attention layers)."""
mod = self.strata.setup_module()
table = getattr(mod, "UD_FIT_KV_BYTES", None) or {"fp16": 2112, "int8": 1056, "q4_0": 576, "k8v4": 816}
return tokens * 13 * table.get(kv, 1056) / 1e9
def max_context(self, family: str, model: str, hw: dict | None = None) -> int | None:
"""The recommended context for this computer and model (setup.py: VRAM rule, then the RAM rule)."""
hw = hw or self.hardware()
if self.strata.multi_family(family): # DeepSeek-V4.1-Flash: the context the engine was checked at
return int(getattr(self.strata.setup_module(), "DSV41_CONTEXT", 8192))
if hw.get("mac") and hw.get("ram_gb"): # a Mac: the context by unified memory (strata_control/mac_fit.py)
mac = self.strata.mac()
if mac is not None:
return int(mac.recommend_context(float(hw["ram_gb"])))
usable = [g for g in hw.get("gpus") or [] if g.get("usable", True)]
vram = max((float(g.get("vram_gb") or 0) for g in usable), default=12.0)
rec = 32768 if vram < 14 else 65536 if vram < 20 else 131072
if usable and all(g.get("vendor") == "intel" for g in usable):
rec = 8192 if vram < 10 else 16384 if vram < 20 else 32768 # an Arc keeps the session and the experts in the same memory
mod = self.strata.setup_module()
models = self.tables()[0]
if mod is not None and models[model].get("budget"):
try:
if mod.unsloth_budget(model, hw.get("ram_gb") or 0.0):
rec = 8192 if vram < 14 else 32768
except Exception: # noqa: BLE001
pass
if mod is not None and hasattr(mod, "ram_ctx") and hw.get("ram_gb"):
try:
rec = min(rec, int(mod.ram_ctx(model, hw["ram_gb"], False)))
except Exception: # noqa: BLE001
pass
if usable: # 0.2.2: a model a few hundred MiB short on this card gets the next context down
from strata_control import vram_fit
best = max(usable, key=lambda g: float(g.get("vram_gb") or 0))
rec = vram_fit.fit_context(f"{family} {model}", float(best.get("vram_gb") or 0), rec, "int8", 300,
str(best.get("vendor") or ""))
return rec
# ---- pictures
def engine_backend(self) -> str | None:
"""The installed engine's backend (cuda, hip, sycl, cpu, metal), else the one this computer's graphics card needs, else None."""
installed = self.installed_backend()
if installed:
return installed
for g in self.computer().usable_gpus:
v = str(g.get("vendor") or "").lower()
if g.get("unified_gb") or v == "apple":
return "metal"
return {"nvidia": "cuda", "amd": "hip", "intel": "sycl"}.get(v)
return None
def reader_state(self) -> str:
""""present" when the installed engine carries the picture reader (strata-vision), "missing" when an engine is installed without it,
"unknown" before any engine is installed (the first launch fetches one that has it)."""
try:
from strata_control import engine_component as ec
rep = ec.status()
exe = (rep.get("engine") or {}).get("exe") if rep.get("usable") else None
except Exception: # noqa: BLE001
exe = None
if not exe:
return "unknown"
from strata_control import vision_reader as VR
found = VR.find(Path(str(exe)).parent, os.name == "nt")
return "present" if (found["cpu"] or found["gpu"]) else "missing"
def picture_default(self, images: bool) -> str:
"""The picture setting nobody chose: off for a model that cannot read pictures or an engine without the reader; else on, with the
reader the one rule of strata_control/vision_reader.py gives: the CPU reader under 24 GB of graphics memory, the GPU reader from 24 GB,
on every make of card (owner decision 2026-10-18); on a Mac the Metal reader (unified memory). Without a usable graphics card there is nothing to read on: the CPU reader."""
from strata_control import vision_reader as VR
if not images or self.reader_state() == "missing":
return "off"
if self.is_mac():
return VR.default_mode(None, unified=True) # a Mac (unified memory): the Metal reader, nothing to keep free for a card
comp = self.computer()
vram = comp.main_vram_gb
return VR.default_mode(vram, "intel" if comp.engine_vendor == "intel" else "") if vram > 0 else "cpu" # no usable card: nothing to read on, the CPU reader
def is_mac(self) -> bool:
"""An Apple Silicon Mac: the chip's memory is the system's (the Metal engine; strata_control/vision_reader.py)."""
return self.engine_backend() == "metal"
# ---- installed models
def installed_configs(self) -> list[dict]:
out, seen = [], set()
for path in self.strata.configs():
seen.add(path.name)
d = self.strata.describe_config(path)
d["path"] = str(path)
out.append(d)
for place in self.places:
if place.path == self.root:
continue
from strata_control import discovery
for path in discovery.config_files(place.path):
if path.name in seen:
continue
seen.add(path.name)
d = self.strata.describe_config(path)
d["path"] = str(path)
out.append(d)
return out
def installed_config(self, tag: str) -> Path | None:
name = f"strata-{tag.lower()}.json"
for folder in [self.root, *[p.path for p in self.places if p.path != self.root]]:
p = folder / name
if p.is_file():
return p
return None
def data_dir_choice(self) -> tuple[Path, str]:
"""(the data folder, where it came from): the person's own setting, the desktop app's folder, a Documents/Strata that holds models,
else the default beside the install. The same rule for every command."""
from strata_control import discovery
return discovery.data_dir(Path(self._mcp_data_dir()))
def data_dir(self) -> Path:
return self.data_dir_choice()[0]
def data_dir_for(self, family: str | None, model: str | None) -> Path:
"""Where this model's files are: the folder its installed run config names, else the data folder."""
if family and model:
path = self.installed_config(self.tag_of(family, model))
if path is not None:
try:
from strata_control import discovery
found = discovery.footprint(json.loads(path.read_text(encoding="utf-8-sig")), path).data_dir
if found is not None:
return found
except (OSError, ValueError):
pass
return self.data_dir()
def disk_free(self, path: str | os.PathLike) -> float | None:
return self.strata.disk_free(Path(path))