tokenfabrikker/tests/test_datafiler.py
Kjell Tore Guttormsen 5a54fba628
feat(dommer): the power solutions compared on equal terms, and the axes of the surfaces (clarifications 134, 135 and 137)
M7 gives, for each of the five solutions, the share of the draws in which it
is best alone and in which it shares the place, with no verdict on A; part II
and the thresholds for M7 are gone. T-F and T-K share the place where they
are the same path. The surfaces carry the classes along their axes, and
kontroll prints a line per file. The made-up reference files are
regenerated: everything outside the comparison is unchanged to the last
digit. Nothing is computed on the frozen parameters.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-13 23:03:05 +01:00

436 lines
16 KiB
Python

"""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 pathlib import Path
from typing import TYPE_CHECKING
import pytest
from tokenfabrikker import datafiler as df
from tokenfabrikker import grunnlag as gl
from tokenfabrikker import kjoring as kj
from tokenfabrikker import terskler
from tokenfabrikker.dommer import Dom, Forsyning
from tokenfabrikker.kjoring import Bane, Kjoring, Utfall
from tokenfabrikker.utbygging import Kraft, Losning
if TYPE_CHECKING:
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",
"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
# M7 is the comparison: A is best in all 40 draws, B cannot be built in 25 (135 f)
assert norm["trinn"][0]["M7"] == {
"A": {
"best_alene": 1.0,
"deler_plassen": 0.0,
"ikke_byggbar": 0.0,
"best_alene_blant_byggbare": 1.0,
},
"B": {
"best_alene": 0.0,
"deler_plassen": 0.0,
"ikke_byggbar": 0.625,
"best_alene_blant_byggbare": 0.0,
},
"delt": {"andel": 0.0, "par": [{"losninger": ["A", "B"], "andel": 0.0}]},
"ingen": {"andel": 0.0},
}
assert norm["trinn"][0]["M7"] == df.sammenligning(sd.M7[5])
assert list(norm) == [
"navn",
"teller",
"trinn",
"del_I",
"del_I_avgjort",
"betingelser",
]
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_sammenligningen_i_M7_staar_i_fast_rekkefolge_med_delt_og_ingen_sist() -> None:
"""Clarification 137 d: the four shares per solution, then «delt» with the pairs, «ingen»."""
m7 = kj.Sammenligning(
losninger={
Losning.A: kj.Bestandel(0.25, 0.25, 0.5, 0.5),
Losning.C: kj.Bestandel(0.25, 0.25, 0.0, 0.25),
Losning.T_K: kj.Bestandel(0.0, 0.0, 1.0, None),
},
delt=0.25,
par={
(Losning.A, Losning.C): 0.25,
(Losning.A, Losning.T_K): 0.0,
(Losning.C, Losning.T_K): 0.0,
},
ingen=0.25,
)
lest = _lest(df.sammenligning(m7))
assert isinstance(lest, dict)
assert list(lest) == ["A", "C", "T-K", "delt", "ingen"]
assert lest["T-K"] == {
"best_alene": 0.0,
"deler_plassen": 0.0,
"ikke_byggbar": 1.0,
"best_alene_blant_byggbare": None,
}
assert lest["delt"] == {
"andel": 0.25,
"par": [
{"losninger": ["A", "C"], "andel": 0.25},
{"losninger": ["A", "T-K"], "andel": 0.0},
{"losninger": ["C", "T-K"], "andel": 0.0},
],
}
assert lest["ingen"] == {"andel": 0.25}
alene = [lest[a]["best_alene"] for a in ("A", "C", "T-K")]
assert math.fsum([*alene, lest["delt"]["andel"], lest["ingen"]["andel"]]) == 1.0
def test_aksene_i_flatene_har_antall_og_median_per_klasse() -> None:
"""Clarification 134: five classes as the surface makes them; a class without draws is empty.
Ten values: the class is floor(5 r / 10), two draws per class, the median the midpoint.
Three distinct values in six draws: the classes 0, 1 and 3 (floor(5 r / 6) for r = 0, 2, 4).
"""
x = [10.0, 1.0, 9.0, 2.0, 8.0, 3.0, 7.0, 4.0, 6.0, 5.0]
assert df.akse(x) == [
{"antall": 2, "median": 1.5},
{"antall": 2, "median": 3.5},
{"antall": 2, "median": 5.5},
{"antall": 2, "median": 7.5},
{"antall": 2, "median": 9.5},
]
assert df.akse([1.0, 1.0, 2.0, 2.0, 3.0, 3.0]) == [
{"antall": 2, "median": 1.0},
{"antall": 2, "median": 2.0},
{"antall": 0, "median": None},
{"antall": 2, "median": 3.0},
{"antall": 0, "median": None},
]
assert df.akse([]) == [{"antall": 0, "median": None}] * 5
# the counts are those of the surface's cells summed along the other axis
y = [float(j % 3) for j in range(10)]
flate = terskler.flate(x, y, [1.0] * 10)
assert [sum(r.antall for r in rad) for rad in flate] == [k["antall"] for k in df.akse(x)] # type: ignore[index]
assert [sum(rad[j].antall for rad in flate) for j in range(5)] == [
k["antall"] # type: ignore[index]
for k in df.akse(y)
]
def test_hovedkjoringen_sier_fra_om_hver_fil_etter_hvert(tmp_path: Path) -> None:
"""Clarification 134: a line per file as it is made; the files are those it writes."""
sti = Path(__file__).resolve().parent / "oppdiktet" / "grunnlag.json"
data = json.loads(sti.read_text(encoding="utf-8"))
data["trekninger"] = data["trekninger"][:1]
liten = tmp_path / "grunnlag.json"
liten.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
laget: list[str] = []
skrevet = df.skriv_hovedkjoring(
gl.fra_fil(liten),
tmp_path / "ut",
stige=(1,),
filer=(df.DOMMER, df.TIDSLINJE),
laget=laget.append,
)
assert laget == list(skrevet) == [df.DOMMER, df.TIDSLINJE]
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"