"""The two files made next to the main run (chapter 16, clarifications 140 e, 141 and 142). Invented outcomes and invented series for the builders, the made-up set of ``conftest.py`` for the series of one programme, and the first three draws of the made-up basis through the command line. Made-up numbers only; nothing here says anything about the hypothesis. """ from __future__ import annotations import hashlib import json import math from pathlib import Path from typing import TYPE_CHECKING import numpy as np import pytest from tokenfabrikker import datafiler as df from tokenfabrikker import dommer as dm from tokenfabrikker import grunnlag as gl from tokenfabrikker import kjoring as kj from tokenfabrikker import miljo from tokenfabrikker import tilleggsfiler as tf from tokenfabrikker import verktoy as vt from tokenfabrikker.dommer import Forsyning from tokenfabrikker.kjoring import Bane, Kjoring, Scenario, Utfall from tokenfabrikker.kontantstrom import Knapphet from tokenfabrikker.utbygging import Kraft, Losning if TYPE_CHECKING: from conftest import LagInndata OPPDIKTET = Path(__file__).resolve().parent / "oppdiktet" STIGE = (1, 2) NORM, VARER = kj.SCENARIOER[1], kj.SCENARIOER[0] LAVT = Scenario("lavt", Knapphet.NORMALISERING, "lavt") """A marked scenario of the made-up set of ``conftest.py``.""" X40 = [float(v) for v in range(1, 41)] HODE: dict[str, object] = {"grunnlag": {"merke": "oppdiktet", "sjekksummer": {}}} # ------------------------------------------------------------ fordelinger.json def test_fordelingen_er_antallet_og_persentilene_0_til_100() -> None: """Forty values 1..40: h = 39 p, so p10 is 4.9, the median 20.5 and p90 36.1.""" f = tf.fordeling([*reversed(X40), None, None], "x") assert f["antall"] == 40 p = f["persentiler"] assert isinstance(p, list) assert len(p) == 101 assert p[0] == 1.0 assert p[100] == 40.0 assert p[50] == 20.5 assert p[10] == pytest.approx(4.9, rel=1e-15) assert p[90] == pytest.approx(36.1, rel=1e-15) assert p == [dm.persentil(X40, k / 100) for k in range(101)] assert p == sorted(p) def test_uten_verdier_er_antallet_null_og_ingen_persentiler() -> None: assert tf.fordeling([None, None], "x") == {"antall": 0, "persentiler": None} assert tf.fordeling([], "x") == {"antall": 0, "persentiler": None} def test_en_verdi_gir_den_i_alle_persentilene() -> None: assert tf.fordeling([None, 7.5], "x") == {"antall": 1, "persentiler": [7.5] * 101} @pytest.mark.parametrize("verdi", [math.nan, math.inf, -math.inf]) def test_en_verdi_som_ikke_er_et_endelig_tall_stanser(verdi: float) -> None: with pytest.raises(ValueError, match="A, NNV: 1 values are not finite"): tf.fordeling([1.0, verdi, 3.0], "A, NNV") def _u(NNV: float, M6: float | None, c_snitt: float | None = 400.0) -> Utfall: return Utfall( NNV=NNV, S42=2.0 * NNV, M3=0.01, 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, c_snitt=c_snitt, ) def _bane(utfall: dict[str, Utfall] | None) -> Bane: return Bane( byggbar=utfall is not None, forste_aar=2028, tidslinje={Kraft.NY_FORNYBAR: (0.0, 100.0)}, utfall={} if utfall is None else utfall, ) def _kjoring() -> Kjoring: """Forty invented draws: A always built, with M6 in the first 30; B built in the first 15.""" return Kjoring( stige=(5,), scenarioer=(VARER, NORM), losninger=(Losning.A, Losning.B), trekninger=tuple( { (Losning.A, 5): _bane( { VARER.navn: _u(100.0 + j, 0.5 if j < 30 else None), NORM.navn: _u(float(j + 1), 0.25 if j < 30 else None), } ), (Losning.B, 5): _bane( {VARER.navn: _u(-2.0, None, None), NORM.navn: _u(-3.0, None, None)} if j < 15 else None ), } for j in range(40) ), ) def test_fordelingsfila_har_hver_storrelse_per_scenario_trinn_og_losning() -> None: fil = tf.lag_fordelinger(HODE, _kjoring()) assert list(fil) == ["grunnlag", "storrelser", "prosenter", "per_scenario"] assert fil["storrelser"] == ["NNV", "S42", "M3", "M6", "c_snitt"] assert fil["prosenter"] == list(range(101)) scenarioer = fil["per_scenario"] assert isinstance(scenarioer, list) assert [s["navn"] for s in scenarioer] == [VARER.navn, NORM.navn] norm = scenarioer[1]["trinn"] assert [t["trinn"] for t in norm] == [5] a, b = norm[0]["losninger"]["A"], norm[0]["losninger"]["B"] assert list(norm[0]["losninger"]) == ["A", "B"] assert list(a) == ["NNV", "S42", "M3", "M6", "c_snitt"] assert a["NNV"] == tf.fordeling(X40, "x") assert a["S42"]["persentiler"] == [2.0 * p for p in a["NNV"]["persentiler"]] assert a["M3"] == {"antall": 40, "persentiler": [0.01] * 101} assert a["M6"] == {"antall": 30, "persentiler": [0.25] * 101} assert a["c_snitt"] == {"antall": 40, "persentiler": [400.0] * 101} assert b["NNV"] == {"antall": 15, "persentiler": [-3.0] * 101} assert b["M6"] == {"antall": 0, "persentiler": None} assert b["c_snitt"] == {"antall": 0, "persentiler": None} assert scenarioer[0]["trinn"][0]["losninger"]["A"]["NNV"]["persentiler"][0] == 100.0 # ----------------------------------------------------------------- miljo.json def test_en_serie_har_summen_per_trekning_og_persentilene_per_aar() -> None: """Five draws and two years. The sums are 11, 22, 33, 44 and 55. With five values h = 4 p: the median is the third, p10 is x_1 + 0.4 (x_2 - x_1) and p90 is x_4 + 0.6 (x_5 - x_4). """ stabel = np.array([[30.0, 3.0], [10.0, 1.0], [50.0, 5.0], [20.0, 2.0], [40.0, 4.0]]) s = tf.serie(stabel, "x") assert list(s) == ["sum", "median", "p10", "p90"] assert s["sum"] == { "median": 33.0, "p10": pytest.approx(11.0 + 0.4 * 11.0), "p90": pytest.approx(44.0 + 0.6 * 11.0), } assert s["median"] == [30.0, 3.0] assert s["p10"] == [pytest.approx(14.0), pytest.approx(1.4)] assert s["p90"] == [pytest.approx(46.0), pytest.approx(4.6)] assert s["p10"] == [ dm.persentil([10.0, 20.0, 30.0, 40.0, 50.0], 0.1), dm.persentil(X40[:5], 0.1), ] def test_medianen_av_summen_er_ikke_summen_av_medianene() -> None: """Two years that move against each other: every sum is 10, the medians per year are 5.""" stabel = np.array([[1.0, 9.0], [5.0, 5.0], [9.0, 1.0]]) s = tf.serie(stabel, "x") assert s["sum"] == {"median": 10.0, "p10": 10.0, "p90": 10.0} assert s["median"] == [5.0, 5.0] def test_en_serie_med_noe_som_ikke_er_et_tall_stanser() -> None: with pytest.raises(ValueError, match="x: 1 values are not finite"): tf.serie(np.array([[1.0, math.nan]]), "x") with pytest.raises(ValueError, match="at least one draw"): tf.serie(np.zeros((0, 3)), "x") def test_serienavnene_folger_anslagene() -> None: assert tf.serienavn(("hoved", "lav")) == ( "U_liv", "U_unngaatt.hoved", "U_med.hoved", "U_unngaatt.lav", "U_med.lav", "uttak", "uttak_egen_bruk", "forbruk_kjernekraft", "forbruk_hoyst", ) def test_en_bane_over_trekningene_teller_bare_de_som_lar_seg_bygge() -> None: """Three draws, one unbuilt; two scenarios, seven series (one estimate), two years.""" anslag = ("hoved",) def tabell(grunn: float) -> np.ndarray[tuple[int, ...], np.dtype[np.float64]]: en = np.array([[grunn * (q + 1), grunn * (q + 1) + 1.0] for q in range(7)]) return np.array([en, 10.0 * en]) per_trekning = [tabell(1.0), None, tabell(3.0)] ut = tf.miljo_for_bane(per_trekning, (VARER, NORM), anslag, "A, trinn 1") assert list(ut) == [VARER.navn, NORM.navn] v = ut[VARER.navn] assert list(v) == ["antall", "U_liv", "med_fradrag", "kjolevann"] assert v["antall"] == 2 assert v["U_liv"] == { "sum": {"median": 5.0, "p10": pytest.approx(3.4), "p90": pytest.approx(6.6)}, "median": [2.0, 3.0], "p10": [pytest.approx(1.2), pytest.approx(2.2)], "p90": [pytest.approx(2.8), pytest.approx(3.8)], } med = v["med_fradrag"] assert isinstance(med, dict) assert list(med) == ["hoved"] assert list(med["hoved"]) == ["U_unngaatt", "U_med"] assert med["hoved"]["U_unngaatt"]["median"] == [4.0, 5.0] assert med["hoved"]["U_med"]["median"] == [6.0, 7.0] vann = v["kjolevann"] assert isinstance(vann, dict) assert list(vann) == ["uttak", "uttak_egen_bruk", "forbruk_kjernekraft", "forbruk_hoyst"] assert vann["uttak"]["median"] == [8.0, 9.0] assert vann["forbruk_hoyst"]["median"] == [14.0, 15.0] u_liv_norm = ut[NORM.navn]["U_liv"] assert isinstance(u_liv_norm, dict) assert u_liv_norm["median"] == [20.0, 30.0] def test_uten_en_trekning_som_lar_seg_bygge_er_antallet_null_og_ingen_serier() -> None: ut = tf.miljo_for_bane([None, None], (NORM,), ("hoved",), "A, trinn 40") assert ut == {NORM.navn: {"antall": 0, "U_liv": None, "med_fradrag": None, "kjolevann": None}} @pytest.mark.parametrize("losning", [Losning.A, Losning.C, Losning.T_K]) def test_programmene_er_de_kjoringen_regner(oppdiktet: LagInndata, losning: Losning) -> None: """The same build-out and programme as ``kjoring.regn_bane``, also with a loss of demand.""" inn = oppdiktet() scenarioer = (VARER, NORM, LAVT) prog = tf.programmer(inn, losning, 2, scenarioer) bane = kj.regn_bane(inn, losning, 2, scenarioer) assert prog is not None assert bane.byggbar assert list(prog) == [s.navn for s in scenarioer] for s in scenarioer: assert prog[s.navn].NNV == bane.utfall[s.navn].NNV assert prog[LAVT.navn].NNV != prog[NORM.navn].NNV def test_en_bane_som_ikke_lar_seg_bygge_har_ingen_serier(oppdiktet: LagInndata) -> None: """Reactor deliveries of 100 MW a year: the third facility of A does not start by 2060.""" inn = oppdiktet(n_reaktor=100.0) assert not kj.regn_bane(inn, Losning.A, 3, (NORM,)).byggbar assert tf.programmer(inn, Losning.A, 3, (NORM,)) is None assert tf.miljo_for_trekning(inn, Losning.A, 3, (NORM,), ("hoved",)) is None @pytest.mark.parametrize("losning", [Losning.A, Losning.B, Losning.C, Losning.T_K]) def test_seriene_er_de_miljomodulen_gir(oppdiktet: LagInndata, losning: Losning) -> None: """Row by row the functions of ``miljo``, from the year after the decision year.""" inn = oppdiktet() anslag = tf.anslagene([inn]) assert anslag == ("hoved", "fast") scenarioer = (NORM, LAVT) prog = tf.programmer(inn, losning, 2, scenarioer) assert prog is not None alle = tf.miljo_for_trekning(inn, losning, 2, scenarioer, anslag) assert alle is not None aar = tf.aarene([inn]) assert aar == tuple(range(inn.heltall("T0") + 1, inn.heltall("T_slutt") + 1)) assert alle.shape == (2, 9, len(aar)) for i, s in enumerate(scenarioer): res = prog[s.navn] vann = miljo.kjolevann(inn, res) venter = [ miljo.utslipp_livslop(inn, res), miljo.unngaatt_utslipp(inn, res, anslag="hoved"), miljo.utslipp_med_fradrag(inn, res, anslag="hoved"), miljo.unngaatt_utslipp(inn, res, anslag="fast"), miljo.utslipp_med_fradrag(inn, res, anslag="fast"), vann.uttak, vann.uttak_egen_bruk, vann.forbruk_kjernekraft, vann.forbruk_hoyst, ] assert res.aar[1:] == aar for q, rad in enumerate(venter): assert alle[i, q].tolist() == rad[1:].tolist() assert rad[0] == 0.0 assert float(alle[i, 0].sum()) > 0.0 assert alle[0, 0].tolist() == alle[1, 0].tolist() assert alle[0, 1].tolist() != alle[1, 1].tolist() def test_anslagene_og_aarene_maa_vaere_like_i_alle_trekningene(oppdiktet: LagInndata) -> None: inn = oppdiktet() with pytest.raises(ValueError, match="draw 1 has another decision year or final year"): tf.aarene([inn, oppdiktet(T_slutt=2059.0)]) with pytest.raises(ValueError, match="at least one draw"): tf.anslagene([]) # ------------------------------------------------------------ the command line @pytest.fixture(scope="module") def liten(tmp_path_factory: pytest.TempPathFactory) -> Path: """A basis file with the first three made-up draws.""" data = json.loads((OPPDIKTET / "grunnlag.json").read_text(encoding="utf-8")) data["trekninger"] = data["trekninger"][:3] sti = tmp_path_factory.mktemp("grunnlag") / "grunnlag.json" sti.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8") return sti @pytest.fixture(scope="module") def tillegg(liten: Path, tmp_path_factory: pytest.TempPathFactory) -> Path: """The two files of the three draws, written on one process through the command line.""" ut = tmp_path_factory.mktemp("tillegg") assert ( vt.main(["tilleggsfiler", "--grunnlag", str(liten), "--ut", str(ut), "--stige", "1,2"]) == 0 ) return ut def _les(sti: Path) -> dict[str, object]: data: dict[str, object] = json.loads(sti.read_text(encoding="utf-8")) return data def test_kommandoen_skriver_de_to_filene_og_sjekksummene(tillegg: Path, liten: Path) -> None: assert sorted(p.name for p in tillegg.iterdir()) == [ "fordelinger.json", "miljo.json", "tillegg.json", ] hode = { "grunnlag": { "merke": "oppdiktet", "sjekksummer": {"grunnlagsfil": hashlib.sha256(liten.read_bytes()).hexdigest()}, }, "antall_trekninger": 3, "stige": [1, 2], "scenarioer": [s.navn for s in kj.SCENARIOER], "losninger": [a.value for a in Losning], } assert _les(tillegg / "tillegg.json") == { **hode, "filer": { navn: hashlib.sha256((tillegg / navn).read_bytes()).hexdigest() for navn in tf.TILLEGGSFILER }, } for navn in tf.TILLEGGSFILER: data = _les(tillegg / navn) assert {k: data[k] for k in hode} == hode assert list(data)[:5] == list(hode) def test_filene_har_formatet_til_de_seks(tillegg: Path) -> None: for navn in (*tf.TILLEGGSFILER, tf.TILLEGG): raa = (tillegg / navn).read_bytes() assert raa.endswith(b"\n") assert not raa.endswith(b"\n\n") assert b"\r" not in raa assert b"\\u" not in raa assert df.json_tekst(json.loads(raa)).encode("utf-8") == raa def test_de_seks_filene_er_ikke_blant_de_to() -> None: assert not set(tf.TILLEGGSFILER) & set(df.ALLE_FILER) assert tf.TILLEGG not in df.ALLE_FILER def test_tallene_i_filene_er_de_funksjonene_gir(tillegg: Path, liten: Path) -> None: g = gl.fra_fil(liten) kjoring = kj.kjor(g.trekninger, stige=STIGE) fordelinger = _les(tillegg / "fordelinger.json") assert fordelinger == json.loads( df.json_tekst(tf.lag_fordelinger(df.hode(g, STIGE, kj.SCENARIOER, tuple(Losning)), kjoring)) ) miljofil = _les(tillegg / "miljo.json") assert miljofil["aar"] == list(tf.aarene(g.trekninger)) anslag = tf.anslagene(g.trekninger) assert anslag == ("hoved", "fast") # the made-up basis; the freeze has the four of 17.4 assert miljofil["anslag"] == list(anslag) assert miljofil["enheter"] == { "utslipp": "tonn CO2-ekvivalenter per år", "kjolevann": "m3 per år", } per_scenario = miljofil["per_scenario"] assert isinstance(per_scenario, list) assert [s["navn"] for s in per_scenario] == [s.navn for s in kj.SCENARIOER] for i, scenario in enumerate(kj.SCENARIOER): assert [t["trinn"] for t in per_scenario[i]["trinn"]] == [1, 2] for j, n in enumerate(STIGE): losninger = per_scenario[i]["trinn"][j]["losninger"] assert list(losninger) == [a.value for a in Losning] for a in (Losning.A, Losning.T_K): prog = [tf.programmer(inn, a, n, (scenario,)) for inn in g.trekninger] byggbare = [ (inn, p[scenario.navn]) for inn, p in zip(g.trekninger, prog, strict=True) if p is not None ] celle = losninger[a.value] assert celle["antall"] == len(byggbare) assert celle["antall"] == sum(b.byggbar for b in kjoring.baner(a, n)) if not byggbare: assert celle["U_liv"] is None continue U_liv = [miljo.utslipp_livslop(inn, res)[1:] for inn, res in byggbare] assert celle["U_liv"]["median"] == [ dm.persentil([float(u[k]) for u in U_liv], 0.5) for k in range(len(U_liv[0])) ] assert celle["U_liv"]["sum"]["median"] == dm.persentil( [math.fsum(u.tolist()) for u in U_liv], 0.5 ) U_med = [ miljo.utslipp_med_fradrag(inn, res, anslag="fast")[1:] for inn, res in byggbare ] assert celle["med_fradrag"]["fast"]["U_med"]["p90"] == [ dm.persentil([float(u[k]) for u in U_med], 0.9) for k in range(len(U_med[0])) ] uttak = [miljo.kjolevann(inn, res).uttak[1:] for inn, res in byggbare] assert celle["kjolevann"]["uttak"]["p10"] == [ dm.persentil([float(u[k]) for u in uttak], 0.1) for k in range(len(uttak[0])) ] def test_to_prosesser_gir_de_samme_bytene(tillegg: Path, liten: Path, tmp_path: Path) -> None: assert ( vt.main( [ "tilleggsfiler", "--grunnlag", str(liten), "--ut", str(tmp_path), "--stige", "1,2", "--prosesser", "2", ] ) == 0 ) for navn in (*tf.TILLEGGSFILER, tf.TILLEGG): assert (tmp_path / navn).read_bytes() == (tillegg / navn).read_bytes() def test_en_fil_om_gangen_gir_de_samme_filene( tillegg: Path, liten: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str] ) -> None: felles = ["tilleggsfiler", "--grunnlag", str(liten), "--ut", str(tmp_path), "--stige", "1,2"] assert vt.main([*felles, "--filer", "fordelinger.json"]) == 0 assert sorted(p.name for p in tmp_path.iterdir()) == ["fordelinger.json", "tillegg.json"] assert list(_les(tmp_path / "tillegg.json")["filer"]) == ["fordelinger.json"] # type: ignore[call-overload] ut = capsys.readouterr().out assert ut.splitlines()[:2] == ["Laget fordelinger.json", "Laget tillegg.json"] assert "Grunnlaget er merket «oppdiktet». Skrevet: fordelinger.json, tillegg.json" in ut assert vt.main([*felles, "--filer", "miljo.json"]) == 0 for navn in (*tf.TILLEGGSFILER, tf.TILLEGG): assert (tmp_path / navn).read_bytes() == (tillegg / navn).read_bytes() def test_en_ukjent_fil_stanser_foer_noe_regnes( liten: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str] ) -> None: kode = vt.main( ["tilleggsfiler", "--grunnlag", str(liten), "--ut", str(tmp_path), "--filer", "dommer.json"] ) assert kode == 2 assert "ukjent fil dommer.json" in capsys.readouterr().err assert not list(tmp_path.iterdir()) def test_en_mappe_fra_en_annen_kjoring_stanser_foer_noe_regnes( tillegg: Path, liten: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str] ) -> None: """The folder holds an ``innhold.json`` for another ladder: nothing is computed or written.""" hode = {k: v for k, v in _les(tillegg / "tillegg.json").items() if k != "filer"} df.skriv(tmp_path / df.INNHOLD, {**hode, "stige": [1, 5], "filer": {}}) foer = sorted(p.name for p in tmp_path.iterdir()) kode = vt.main( ["tilleggsfiler", "--grunnlag", str(liten), "--ut", str(tmp_path), "--stige", "1,2"] ) assert kode == 2 assert "innhold.json" in capsys.readouterr().err assert sorted(p.name for p in tmp_path.iterdir()) == foer with pytest.raises(tf.TilleggError, match=r"miljo\.json"): tf.skriv_tilleggsfiler(gl.fra_fil(liten), tillegg, stige=(1, 5), filer=(tf.FORDELINGER,))