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>
246 lines
9.3 KiB
Python
246 lines
9.3 KiB
Python
"""The basis of a run (chapter 12; chapter 16, clarification 127).
|
|
|
|
Made-up numbers only: the made-up basis file in ``tests/oppdiktet`` and variants of it. The
|
|
basis from the freeze is only tried up to its guard: until the EEA assessment per ownership
|
|
form is written down, it stops before it reads anything.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import re
|
|
from pathlib import Path
|
|
from typing import TYPE_CHECKING
|
|
|
|
import pytest
|
|
|
|
from tokenfabrikker import grunnlag as gl
|
|
from tokenfabrikker import parametere
|
|
from tokenfabrikker.dommer import Dom
|
|
from tokenfabrikker.utbygging import Losning
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Callable
|
|
|
|
GRUNNLAGSFIL = Path(__file__).resolve().parent / "oppdiktet" / "grunnlag.json"
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def grunnlag() -> gl.Grunnlag:
|
|
return gl.fra_fil(GRUNNLAGSFIL)
|
|
|
|
|
|
def _raa() -> dict[str, object]:
|
|
data: dict[str, object] = json.loads(GRUNNLAGSFIL.read_text(encoding="utf-8"))
|
|
return data
|
|
|
|
|
|
def _skriv(tmp_path: Path, data: object) -> Path:
|
|
sti = tmp_path / "grunnlag.json"
|
|
sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
|
|
return sti
|
|
|
|
|
|
def test_grunnlagsfila_er_merket_oppdiktet_med_sin_sjekksum(grunnlag: gl.Grunnlag) -> None:
|
|
import hashlib # noqa: PLC0415
|
|
|
|
assert grunnlag.merke == "oppdiktet"
|
|
assert grunnlag.sjekksummer == {
|
|
"grunnlagsfil": hashlib.sha256(GRUNNLAGSFIL.read_bytes()).hexdigest()
|
|
}
|
|
assert grunnlag.merkelapp == {"merke": "oppdiktet", "sjekksummer": dict(grunnlag.sjekksummer)}
|
|
assert grunnlag.antall >= 40
|
|
assert set(grunnlag.M5) == set(Losning)
|
|
assert grunnlag.M5[Losning.C] is Dom.HOLDER
|
|
assert set(grunnlag.karbonbaner) == {"lav", "hoy"}
|
|
|
|
|
|
def test_trukne_verdier_i_filas_enhet_og_tallsettet_i_ligningenes(grunnlag: gl.Grunnlag) -> None:
|
|
"""c_N_ref stands in kr/kW in the file, and in kr/MW in the equations."""
|
|
raa = _raa()
|
|
storrelser = raa["storrelser"]
|
|
assert isinstance(storrelser, list)
|
|
trukne = [s["navn"] for s in storrelser if s["verdi"] is None]
|
|
assert list(grunnlag.storrelser) == trukne
|
|
assert list(grunnlag.status) == trukne
|
|
assert grunnlag.faktorer["c_N_ref"] == 1000.0
|
|
for omega, inn in enumerate(grunnlag.trekninger):
|
|
assert inn["c_N_ref"] == grunnlag.storrelser["c_N_ref"][omega] * 1000.0
|
|
assert inn["y_obs"] == grunnlag.storrelser["y_obs"][omega] * 1e6
|
|
assert inn["eps_d"] == grunnlag.eps_d
|
|
assert len(inn.u_eksport) == round(inn["T_slutt"] - inn["T0"])
|
|
assert grunnlag.y_obs_maks == 229e6
|
|
assert all(len(x) == grunnlag.antall for x in grunnlag.storrelser.values())
|
|
|
|
|
|
def test_de_forste_N_trekningene(grunnlag: gl.Grunnlag) -> None:
|
|
tre = grunnlag.de_forste(3)
|
|
assert tre.trekninger == grunnlag.trekninger[:3]
|
|
assert tre.storrelser["p_v"] == grunnlag.storrelser["p_v"][:3]
|
|
assert tre.sjekksummer == grunnlag.sjekksummer
|
|
for feil in (0, grunnlag.antall + 1):
|
|
with pytest.raises(gl.GrunnlagError, match="antall trekninger"):
|
|
grunnlag.de_forste(feil)
|
|
|
|
|
|
def test_faste_verdier_settes_etter_trekningen_i_filas_enhet(grunnlag: gl.Grunnlag) -> None:
|
|
"""Clarification 130: a fixed value in the file's unit, set after the draw (116)."""
|
|
med = grunnlag.med_verdier({"c_N_ref": 90_000.0, "eps_d": 0.5})
|
|
for gammel, ny in zip(grunnlag.trekninger, med.trekninger, strict=True):
|
|
assert ny["c_N_ref"] == 90e6
|
|
assert ny["eps_d"] == 0.5
|
|
assert ny["p_v"] == gammel["p_v"]
|
|
assert ny.med({"c_N_ref": gammel["c_N_ref"], "eps_d": gammel["eps_d"]}) == gammel
|
|
# the table of drawn values keeps the drawn values
|
|
assert med.storrelser == grunnlag.storrelser
|
|
assert med.eps_d == 0.5
|
|
assert grunnlag.med_verdier({}) is grunnlag
|
|
with pytest.raises(gl.GrunnlagError, match="ukjent størrelse: finnes_ikke"):
|
|
grunnlag.med_verdier({"finnes_ikke": 1.0})
|
|
|
|
|
|
def test_grunnlaget_fra_frysen_stanser_foer_noe_leses_uten_EOS_vurderingen() -> None:
|
|
"""Clarification 127, «Mangler før del 6»: the guard comes before any file is read."""
|
|
with pytest.raises(gl.GrunnlagError, match=r"EØS-vurderingen per eierform er ikke fastsatt"):
|
|
gl.fra_frys(None, parametere=Path("/finnes/ikke.json"), data=Path("/finnes/ikke"))
|
|
with pytest.raises(gl.GrunnlagError, match=r"avklaring 127"):
|
|
gl.fra_frys(None)
|
|
|
|
|
|
def test_den_frosne_sjekksummen_er_den_i_parameterkoden() -> None:
|
|
assert gl.FROSSEN_SJEKKSUM == parametere.FROSSEN_SHA256
|
|
|
|
|
|
def _uten(felt: str) -> Callable[[dict[str, object]], None]:
|
|
def endre(data: dict[str, object]) -> None:
|
|
del data[felt]
|
|
|
|
return endre
|
|
|
|
|
|
def _sett(felt: str, *args: object, verdi: object = None) -> Callable[[dict[str, object]], None]:
|
|
ny = args[0] if args else verdi
|
|
|
|
def endre(data: dict[str, object]) -> None:
|
|
data[felt] = ny
|
|
|
|
return endre
|
|
|
|
|
|
def _forste_trekning(endring: Callable[[dict[str, object]], object]) -> Callable[..., None]:
|
|
def endre(data: dict[str, object]) -> None:
|
|
trekninger = data["trekninger"]
|
|
assert isinstance(trekninger, list)
|
|
endring(trekninger[0])
|
|
|
|
return endre
|
|
|
|
|
|
def _forste_storrelse(endring: Callable[[dict[str, object]], object]) -> Callable[..., None]:
|
|
def endre(data: dict[str, object]) -> None:
|
|
storrelser = data["storrelser"]
|
|
assert isinstance(storrelser, list)
|
|
endring(storrelser[0])
|
|
|
|
return endre
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("endring", "melding"),
|
|
[
|
|
(_sett("ekstra", 1), "grunnlagsfila: ukjent felt: ekstra"),
|
|
(_uten("eos"), "grunnlagsfila: feltet mangler: eos"),
|
|
(_sett("merke", "frosset"), "merke: en grunnlagsfil skal være merket 'oppdiktet'"),
|
|
(_sett("y_obs_maks", "229"), "y_obs_maks: skal være et tall"),
|
|
(_sett("y_obs_maks", verdi=True), "y_obs_maks: skal være et tall"),
|
|
(_sett("trekninger", []), "trekninger: skal ha minst én trekning"),
|
|
(_sett("M5", {"A": "holder"}), "M5: feltet mangler: B"),
|
|
(_sett("eos", {"direkte": "består"}), "eos: feltet mangler: heleid_selskap"),
|
|
(
|
|
_forste_trekning(lambda t: t.update(verdier=[1.0])),
|
|
"trekninger[0].verdier: skal ha 16 tall, har 1",
|
|
),
|
|
(
|
|
_forste_trekning(lambda t: t.pop("u_eksport")),
|
|
"trekninger[0]: feltet mangler: u_eksport",
|
|
),
|
|
(
|
|
_forste_trekning(lambda t: t.update(u_eksport=["0.5"])),
|
|
"trekninger[0].u_eksport[0]: skal være et tall",
|
|
),
|
|
(
|
|
_forste_storrelse(lambda s: s.update(status="kanskje")),
|
|
"storrelser[0].status: ukjent status 'kanskje'",
|
|
),
|
|
(
|
|
_forste_storrelse(lambda s: s.update(faktor=0.0)),
|
|
"storrelser[0].faktor: skal være positiv",
|
|
),
|
|
(_forste_storrelse(lambda s: s.update(enhet="år")), "storrelser[0]: ukjent felt: enhet"),
|
|
],
|
|
)
|
|
def test_grunnlagsfila_leses_strengt(
|
|
tmp_path: Path, endring: Callable[[dict[str, object]], None], melding: str
|
|
) -> None:
|
|
data = _raa()
|
|
endring(data)
|
|
with pytest.raises(gl.GrunnlagError, match=re.escape(melding)):
|
|
gl.fra_fil(_skriv(tmp_path, data))
|
|
|
|
|
|
def test_ukjent_dom_i_M5_og_ukjent_vurdering_i_EOS(tmp_path: Path) -> None:
|
|
data = _raa()
|
|
m5 = data["M5"]
|
|
assert isinstance(m5, dict)
|
|
m5["A"] = "holder kanskje"
|
|
with pytest.raises(gl.GrunnlagError, match=re.escape("M5.A: ukjent dom 'holder kanskje'")):
|
|
gl.fra_fil(_skriv(tmp_path, data))
|
|
data = _raa()
|
|
eos = data["eos"]
|
|
assert isinstance(eos, dict)
|
|
eos["direkte"] = "ja"
|
|
with pytest.raises(gl.GrunnlagError, match=re.escape("eos.direkte: ukjent vurdering 'ja'")):
|
|
gl.fra_fil(_skriv(tmp_path, data))
|
|
|
|
|
|
def test_tabellene_leses_strengt(tmp_path: Path) -> None:
|
|
data = _raa()
|
|
tabeller = data["tabeller"]
|
|
assert isinstance(tabeller, dict)
|
|
tabeller["bortfall"] = {"lavt": [0.1, 0.2]}
|
|
with pytest.raises(gl.GrunnlagError, match=re.escape("tabeller.bortfall: ukjent felt: lavt")):
|
|
gl.fra_fil(_skriv(tmp_path, data))
|
|
data = _raa()
|
|
tabeller = data["tabeller"]
|
|
assert isinstance(tabeller, dict)
|
|
tabeller["karbonpris"] = {"to tusen": 1.0}
|
|
with pytest.raises(gl.GrunnlagError, match="nøkkelen skal være et årstall"):
|
|
gl.fra_fil(_skriv(tmp_path, data))
|
|
|
|
|
|
def test_et_felt_to_ganger_og_tall_JSON_ikke_tillater_er_feil(tmp_path: Path) -> None:
|
|
sti = tmp_path / "grunnlag.json"
|
|
sti.write_text('{"merke": "oppdiktet", "merke": "oppdiktet"}', encoding="utf-8")
|
|
with pytest.raises(gl.GrunnlagError, match="feltet 'merke' står to ganger"):
|
|
gl.fra_fil(sti)
|
|
sti.write_text('{"y_obs_maks": NaN}', encoding="utf-8")
|
|
with pytest.raises(gl.GrunnlagError, match="NaN er ikke et tall JSON tillater"):
|
|
gl.fra_fil(sti)
|
|
|
|
|
|
def test_rho_N_trukket_krever_rho_D_trukket(tmp_path: Path) -> None:
|
|
"""Clarification 115 c: a threshold in rho_N is read in the two halves by rho_D."""
|
|
data = _raa()
|
|
storrelser = data["storrelser"]
|
|
trekninger = data["trekninger"]
|
|
assert isinstance(storrelser, list)
|
|
assert isinstance(trekninger, list)
|
|
trukne = [s["navn"] for s in storrelser if s["verdi"] is None]
|
|
i = trukne.index("rho_D")
|
|
for s in storrelser:
|
|
if s["navn"] == "rho_D":
|
|
s["verdi"] = 0.08
|
|
for t in trekninger:
|
|
del t["verdier"][i]
|
|
with pytest.raises(gl.GrunnlagError, match="trenger de trukne verdiene av rho_D"):
|
|
gl.fra_fil(_skriv(tmp_path, data))
|