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:
parent
aff6624c5e
commit
7dd3edc68a
14 changed files with 75464 additions and 0 deletions
323
tests/test_datafiler.py
Normal file
323
tests/test_datafiler.py
Normal 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"
|
||||
Loading…
Add table
Add a link
Reference in a new issue