"""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"