feat(verktoy): the tools of chapter 12 and the data files of the main run, on made-up numbers (clarifications 126 to 133)

grunnlag.py holds what a run needs besides the model code, from a made-up
basis file or from the freeze (which stops until the EEA assessment is
written down). datafiler.py writes the six files in a fixed format without
rounding and compares two folders. verktoy.py is the command line:
hovedkjoring, kontroll, scenario, folsomhet, terskel, sammenlign,
arbeidskopi. tests/oppdiktet holds a made-up basis of 200 draws and the files
written from it; they are reproduced byte for byte with 1 and 8 processes and
in a new process. Nothing is computed on the frozen parameters.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-13 21:55:03 +01:00
commit 7dd3edc68a
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
14 changed files with 75464 additions and 0 deletions

323
tests/test_datafiler.py Normal file
View file

@ -0,0 +1,323 @@
"""The data files of the main run and the comparison of ``kontroll`` (clarifications 128, 129).
Invented outcomes per draw for the builders, and made-up files for the comparison. The files
of a real (made-up) run are tested in ``test_verktoy.py``. Nothing here says anything about
the hypothesis.
"""
from __future__ import annotations
import json
import math
import shutil
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import datafiler as df
from tokenfabrikker import kjoring as kj
from tokenfabrikker.dommer import Dom, Forsyning
from tokenfabrikker.kjoring import Bane, Kjoring, Utfall
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
from pathlib import Path
from tokenfabrikker.kjoring import Scenario
NORM, VARER = kj.SCENARIOER[1], kj.SCENARIOER[0]
X40 = [float(v) for v in range(1, 41)]
"""An invented quantity over forty draws: its 10th percentile is 4.9 and its 90th 36.1."""
def _u(NNV: float, M6: float | None = 0.3) -> Utfall:
return Utfall(
NNV=NNV,
S42=1.0,
M3=0.0,
M4=Forsyning(ikke_svakere_uten_tiltak=True, svakere_ogsaa_med_tiltak=False),
M6=M6,
M6_snitt=M6,
M6_median=M6,
M6_2050=None,
M6_topp=0.0 if M6 is None else M6,
stabilt_aar=None if M6 is None else 2040,
toppaar=2040,
)
def _bane(utfall: Utfall | None, scenarioer: tuple[Scenario, ...]) -> Bane:
return Bane(
byggbar=utfall is not None,
forste_aar=2028,
tidslinje={Kraft.NY_FORNYBAR: (0.0, 100.0, 1000.0)},
utfall={} if utfall is None else dict.fromkeys((s.navn for s in scenarioer), utfall),
)
def _kjoring() -> Kjoring:
"""Forty invented draws of A and B on step 5: A positive in the first 28, B mostly unbuilt."""
scenarioer = (VARER, NORM)
return Kjoring(
stige=(5,),
scenarioer=scenarioer,
losninger=(Losning.A, Losning.B),
trekninger=tuple(
{
(Losning.A, 5): _bane(_u(1.0 + j if j < 28 else -1.0 - j), scenarioer),
(Losning.B, 5): _bane(_u(-2.0) if j < 15 else None, scenarioer),
}
for j in range(40)
),
)
M5 = {Losning.A: Dom.HOLDER, Losning.B: Dom.BETINGELSER}
STORRELSER = {"x": X40, "z": [41.0 - v for v in X40]}
STATUS = {"x": "kilde", "z": "åpen forutsetning"}
HODE: dict[str, object] = {"grunnlag": {"merke": "oppdiktet", "sjekksummer": {}}}
# ------------------------------------------------------------------- the format
def test_formatet_er_utf8_lf_innrykk_en_og_ingen_koder() -> None:
tekst = df.json_tekst({"b": [1, 2.5], "a": "ø «holder»", "c": None, "d": (0.1,)})
assert tekst == (
'{\n "b": [\n 1,\n 2.5\n ],\n "a": "ø «holder»",\n "c": null,\n "d": [\n 0.1\n ]\n}\n'
)
assert "\r" not in tekst
assert tekst.endswith("}\n")
assert not tekst.endswith("\n\n")
def test_ingen_avrunding_og_ingen_uendelighet() -> None:
tall = [0.1 + 0.2, 1 / 3, 2.0**-1074, 1e300, -123456.78901234567]
assert json.loads(df.json_tekst(tall)) == tall
assert all(str(x) in df.json_tekst(tall) for x in tall)
for feil in (math.inf, -math.inf, math.nan):
with pytest.raises(ValueError, match="cannot be written"):
df.json_tekst({"x": [feil]})
with pytest.raises(TypeError, match="not a plain JSON value"):
df.json_tekst({"x": {1, 2}})
def test_rekkefolgen_i_stigen_scenarioene_og_losningene() -> None:
stige, scenarioer, losninger = df.ordne(
(5, 1, 2), (kj.SCENARIOER[3], NORM, VARER), (Losning.T_K, Losning.A, Losning.B_MERKET)
)
assert stige == (1, 2, 5)
assert scenarioer == (VARER, NORM, kj.SCENARIOER[3])
assert losninger == (Losning.A, Losning.B_MERKET, Losning.T_K)
with pytest.raises(ValueError, match="stands twice"):
df.ordne((1, 1), (NORM,), (Losning.A,))
# ---------------------------------------------------------------- the builders
def _lest(data: object) -> object:
return json.loads(df.json_tekst(data))
def test_dommer_json_har_tallene_sett_dommer_gir() -> None:
kjoring = _kjoring()
dommer = kj.sett_dommer(kjoring, M5, storrelser=STORRELSER, status=STATUS)
data = df.lag_dommer(HODE, kjoring, dommer)
lest = _lest(data)
assert lest == data | {} # every float reads back to the same float
assert isinstance(lest, dict)
assert list(lest) == [
"grunnlag",
"trinn",
"grunnlag_for_trinnet",
"teller",
"del_I",
"del_II",
"per_scenario",
]
assert (lest["trinn"], lest["grunnlag_for_trinnet"]) == (5, "25 %-trinnet")
assert (lest["teller"], lest["del_I"]) == ("normalisering", dommer.del_I.value)
assert [s["navn"] for s in lest["per_scenario"]] == ["knapphet varer", "normalisering"]
norm = lest["per_scenario"][1]
sd = dommer.scenarioer["normalisering"]
a = norm["trinn"][0]["losninger"]["A"]
assert list(a) == ["M1", "M2", "M3", "M4", "M5", "M6", "median_M1", "ved_siden_av_M6"]
m1 = sd.per_trinn[5][Losning.A].maal["M1"]
assert a["M1"] == {
"dom": m1.dom.value,
"andel_holder": m1.andel_holder,
"andel_holder_ikke": None,
"ikke_byggbar": 0.0,
"oppfylt_blant_byggbare": m1.oppfylt_blant_byggbare,
}
assert a["median_M1"] == sd.per_trinn[5][Losning.A].median_M1
assert a["M5"] == "holder"
# B cannot be built in 25 of 40 draws: the median in M1 has no value
assert sd.per_trinn[5][Losning.B].median_M1 == -math.inf
assert norm["trinn"][0]["losninger"]["B"]["median_M1"] is None
assert norm["trinn"][0]["M7"]["dom"] == sd.M7[5].dom.value
ved = kj.ved_siden_av_m6(kjoring.utfall(NORM, Losning.A, 5))["snitt"]
assert a["ved_siden_av_M6"]["snitt"] == {
"antall": ved.antall,
"median": ved.median,
"p10": ved.persentiler[0] if ved.persentiler else None,
"p90": ved.persentiler[1] if ved.persentiler else None,
}
# the conditions of A with the threshold that counts, and taken together
b = norm["betingelser"]["A"]
assert (b["felt"], b["maal"], b["kan_navngis"]) == (False, ["M1"], True)
terskel = b["terskler"]["M1"][0]
assert list(terskel) == [
"storrelse",
"retning",
"verdi",
"sannsynlighet",
"andel_oppfylt",
"teller",
"kilde",
"indeks",
"paavist",
"begge_halvdeler",
]
assert (terskel["storrelse"], terskel["retning"], terskel["verdi"]) == ("x", "høyst", 35.0)
assert terskel["teller"] is True
assert b["samtidig"]["valgt"]["M1"] == terskel
assert norm["del_I"] == "holder under betingelser"
assert norm["del_I_avgjort"] is True
def test_dommer_json_uten_terskler_sier_at_del_I_ikke_er_avgjort() -> None:
kjoring = _kjoring()
lest = _lest(df.lag_dommer(HODE, kjoring, kj.sett_dommer(kjoring, M5)))
assert isinstance(lest, dict)
norm = lest["per_scenario"][1]
assert (norm["del_I"], norm["del_I_avgjort"], norm["betingelser"]) == (
"holder under betingelser",
False,
None,
)
def test_tidslinje_json_har_tallene_over_trekningene() -> None:
kjoring = _kjoring()
lest = _lest(df.lag_tidslinje(HODE, kjoring))
assert isinstance(lest, dict)
assert lest["typer"] == [*(x.value for x in Kraft), "alle"]
linje = kj.tidslinje_over_trekningene(kjoring, Losning.B, 5)
rader = lest["per_losning"]["B"][0]["typer"]["ny fornybar kraft"]
assert lest["per_losning"]["B"][0]["trinn"] == 5
assert [r["aar"] for r in rader] == [2028, 2029, 2030]
for r, x in zip(rader, linje[Kraft.NY_FORNYBAR.value], strict=True):
assert r == {
"aar": x.aar,
"median": x.median,
"p10": x.persentiler[0],
"p90": x.persentiler[1],
"andel_minst_100_MW": x.andel_minst[0],
"andel_minst_1000_MW": x.andel_minst[1],
}
assert isinstance(rader[0]["aar"], int)
def test_d_stjerne_med_den_faste_eps_d_og_med_0_5_og_2() -> None:
assert df.d_stjerne(0.6, 1.0) == [
{"eps_d": 1.0, "d_stjerne": 0.4},
{"eps_d": 0.5, "d_stjerne": 0.8},
{"eps_d": 2.0, "d_stjerne": 0.2},
]
assert [x["d_stjerne"] for x in df.d_stjerne(None, 1.0)] == [None, None, None] # type: ignore[index]
# --------------------------------------------------------------- the comparison
def _mappe(sti: Path, filer: dict[str, object]) -> Path:
sti.mkdir()
for navn, data in filer.items():
df.skriv(sti / navn, data)
return sti
FILER: dict[str, object] = {
"dommer.json": {"trinn": 5, "andel": 0.1 + 0.2, "dom": "holder", "x": [1.5, None, True]},
"innhold.json": {"stige": [1, 5], "filer": {"dommer.json": "abc"}},
}
def test_like_mapper_er_identiske(tmp_path: Path) -> None:
a, b = _mappe(tmp_path / "a", FILER), _mappe(tmp_path / "b", FILER)
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert (r.dom, r.storste_avvik, r.hvor) == ("identisk", 0.0, None)
assert [f.dom for f in r.filer] == ["identisk", "identisk"]
def test_siste_siffer_er_innenfor_toleransen(tmp_path: Path) -> None:
andel = 0.1 + 0.2
ny = math.nextafter(andel, 1.0)
a = _mappe(tmp_path / "a", FILER)
b = _mappe(tmp_path / "b", {**FILER, "dommer.json": {**FILER["dommer.json"], "andel": ny}}) # type: ignore[dict-item]
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert r.dom == "innenfor toleranse"
assert r.filer[0].dom == "innenfor toleranse"
assert r.storste_avvik == abs(ny - andel) / ny
assert r.hvor == "dommer.json:$.andel"
@pytest.mark.parametrize(
("endring", "forskjell"),
[
({"andel": 0.30000001}, "$.andel"),
({"dom": "holder ikke"}, "$.dom"),
({"trinn": 5.0}, "$.trinn: heltall mot desimaltall"),
({"trinn": 6}, "$.trinn"),
({"x": [1.5, None, 1]}, "$.x[2]: sannhetsverdi mot heltall"),
({"x": [1.5, None]}, "$.x: 3 mot 2 elementer"),
],
)
def test_alt_annet_er_endret(tmp_path: Path, endring: dict[str, object], forskjell: str) -> None:
dommer = FILER["dommer.json"]
assert isinstance(dommer, dict)
a = _mappe(tmp_path / "a", FILER)
b = _mappe(tmp_path / "b", {**FILER, "dommer.json": {**dommer, **endring}})
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert r.dom == "endret"
assert r.filer[0].forskjell is not None
assert r.filer[0].forskjell.startswith(forskjell)
def test_feltenes_rekkefolge_og_et_felt_som_mangler_er_endret(tmp_path: Path) -> None:
dommer = FILER["dommer.json"]
assert isinstance(dommer, dict)
snudd = dict(reversed(list(dommer.items())))
uten = {k: v for k, v in dommer.items() if k != "dom"}
for nr, endret in enumerate((snudd, uten)):
a = _mappe(tmp_path / f"a{nr}", FILER)
b = _mappe(tmp_path / f"b{nr}", {**FILER, "dommer.json": endret})
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert r.dom == "endret"
assert r.filer[0].forskjell == "$: ulike felt eller ulik rekkefølge"
def test_en_fil_som_mangler_er_endret(tmp_path: Path) -> None:
a = _mappe(tmp_path / "a", FILER)
b = _mappe(tmp_path / "b", {"innhold.json": FILER["innhold.json"]})
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert r.dom == "endret"
assert r.filer[0].forskjell == "den lagrede fila finnes ikke"
def test_sjekksummene_i_innhold_holdes_utenfor_den_tolerante_proven(tmp_path: Path) -> None:
a = _mappe(tmp_path / "a", FILER)
b = _mappe(
tmp_path / "b",
{**FILER, "innhold.json": {"stige": [1, 5], "filer": {"dommer.json": "def"}}},
)
r = df.sammenlign_mapper(a, b, filer=tuple(FILER))
assert [f.dom for f in r.filer] == ["identisk", "innenfor toleranse"]
assert r.dom == "innenfor toleranse"
c = tmp_path / "c"
shutil.copytree(b, c)
df.skriv(c / "innhold.json", {"stige": [1, 6], "filer": {"dommer.json": "def"}})
assert df.sammenlign_mapper(a, c, filer=tuple(FILER)).dom == "endret"