eierskap.py: the residual value and the sale at the final year, the levies, the private owners' cash flow and the settlement over the draws, the present value with rho_D without the debt flows, the required return before tax, and equal values in the ranking. Also the median of the petroleum cash flow in 2025 kroner, the state's cash flow next to M6, the shares shown next to each verdict, and the sources' figures for M5 (i). Made-up numbers only: 424 tests pass, 7 documented misses. The project's code and the independent reader's code agree to within one krone on 1 500 made-up paths. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
285 lines
11 KiB
Python
285 lines
11 KiB
Python
"""The parameter file is the frozen one, is read strictly, and is converted to the right units."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import copy
|
|
import json
|
|
import re
|
|
import statistics
|
|
from collections import Counter
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import pytest
|
|
|
|
from tokenfabrikker import parametere as pm
|
|
|
|
ROT = Path(__file__).resolve().parents[1]
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def raa() -> dict[str, Any]:
|
|
data: dict[str, Any] = json.loads(pm.STANDARDSTI.read_text(encoding="utf-8"))
|
|
return data
|
|
|
|
|
|
@pytest.fixture(scope="module")
|
|
def sett() -> pm.Parametersett:
|
|
return pm.les_parametere()
|
|
|
|
|
|
def _endret(raa: dict[str, Any], parameter_id: str) -> tuple[dict[str, Any], dict[str, Any]]:
|
|
"""A deep copy of the file and the entry with this id inside the copy."""
|
|
kopi = copy.deepcopy(raa)
|
|
post = next(p for p in kopi["parametere"] if p["id"] == parameter_id)
|
|
return kopi, post
|
|
|
|
|
|
# ------------------------------------------------------------------- the freeze
|
|
|
|
|
|
def test_sjekksummen_er_den_i_forhaandsregistreringen() -> None:
|
|
tekst = (ROT / "FORHANDSREGISTRERING.md").read_text(encoding="utf-8")
|
|
funnet = re.search(r"SHA-256: `([0-9a-f]{64})`", tekst)
|
|
assert funnet is not None
|
|
assert funnet.group(1) == pm.FROSSEN_SHA256
|
|
assert pm.sjekksum() == pm.FROSSEN_SHA256
|
|
|
|
|
|
def test_en_endret_fil_avvises(tmp_path: Path) -> None:
|
|
kopi = tmp_path / "parametere.json"
|
|
kopi.write_bytes(pm.STANDARDSTI.read_bytes().replace(b'"verdi": 2027', b'"verdi": 2030'))
|
|
with pytest.raises(pm.ParameterError, match="not the frozen parameter file"):
|
|
pm.les_parametere(kopi)
|
|
assert pm.les_parametere(kopi, krev_frossen=False).fast("T0") == 2030
|
|
|
|
|
|
def test_antall_og_status_som_i_forhaandsregistreringen(sett: pm.Parametersett) -> None:
|
|
"""124 parameters: 80 with source, 1 derived, 35 open assumptions, 8 choices of set-up."""
|
|
assert len(sett.parametere) == 124
|
|
assert Counter(p.status for p in sett.parametere) == {
|
|
"kilde": 80,
|
|
"avledet": 1,
|
|
"åpen forutsetning": 35,
|
|
"modellvalg": 8,
|
|
}
|
|
|
|
|
|
def test_tabellen_i_spesifikasjonen_har_de_samme_parameterne(sett: pm.Parametersett) -> None:
|
|
tekst = (ROT / "modell" / "spesifikasjon.md").read_text(encoding="utf-8")
|
|
tabell = tekst.split("<!-- PARAMETERTABELL START -->")[1].split("<!-- PARAMETERTABELL SLUTT")[0]
|
|
ider = re.findall(r"^\| `([^`]+)` \|", tabell, flags=re.MULTILINE)
|
|
assert ider == [p.id for p in sett.parametere]
|
|
|
|
|
|
# ------------------------------------------------------------ strict validation
|
|
|
|
|
|
def test_ukjent_felt_overst_er_feil(raa: dict[str, Any]) -> None:
|
|
kopi = copy.deepcopy(raa)
|
|
kopi["kommentar"] = "x"
|
|
with pytest.raises(pm.ParameterError, match=r"unknown field\(s\) \['kommentar'\]"):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
def test_ukjent_felt_i_parameter_er_feil(raa: dict[str, Any]) -> None:
|
|
kopi, post = _endret(raa, "c_N_ref")
|
|
post["verdi"] = 140000
|
|
with pytest.raises(pm.ParameterError, match=r"c_N_ref.*unknown field"):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
def test_ukjent_felt_i_fordeling_er_feil(raa: dict[str, Any]) -> None:
|
|
kopi, post = _endret(raa, "c_N_ref")
|
|
post["fordeling"]["modus"] = 140000
|
|
with pytest.raises(pm.ParameterError, match=r"unknown field\(s\) \['modus'\]"):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
def test_manglende_felt_er_feil(raa: dict[str, Any]) -> None:
|
|
kopi, post = _endret(raa, "tau_N")
|
|
del post["fordeling"]["modus"]
|
|
with pytest.raises(pm.ParameterError, match=r"missing field\(s\) \['modus'\]"):
|
|
pm.tolk_parametere(kopi)
|
|
kopi, post = _endret(raa, "tau_N")
|
|
del post["merknad"]
|
|
with pytest.raises(pm.ParameterError, match=r"missing field\(s\) \['merknad'\]"):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("felt", "verdi", "melding"),
|
|
[
|
|
("enhet", "kr/kWh", "unknown unit"),
|
|
("status", "antatt", "unknown status"),
|
|
("poster", ["K3-20"], "malformed source entries"),
|
|
("poster", [], "requires at least one source entry"),
|
|
],
|
|
)
|
|
def test_ukjent_enhet_status_og_post_er_feil(
|
|
raa: dict[str, Any], felt: str, verdi: object, melding: str
|
|
) -> None:
|
|
kopi, post = _endret(raa, "c_N_ref")
|
|
post[felt] = verdi
|
|
with pytest.raises(pm.ParameterError, match=melding):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
def test_ukjent_fordelingstype_er_feil(raa: dict[str, Any]) -> None:
|
|
kopi, post = _endret(raa, "c_N_ref")
|
|
post["fordeling"]["type"] = "normal"
|
|
with pytest.raises(pm.ParameterError, match="unknown distribution type 'normal'"):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("parameter_id", "felt", "verdi", "melding"),
|
|
[
|
|
("tau_N", "modus", 20.0, "does not hold"),
|
|
("c_N_ref", "lav", 171500, "range is empty"),
|
|
("tau_N", "form", 6, "PERT shape"),
|
|
("phi_U", "lav", 0.0, "must be positive"),
|
|
("o_xi", "sigma", -1.0, "must be positive"),
|
|
("o_xi", "avkorting", "trekk på nytt", "truncation must be"),
|
|
("L_H", "vekter", [0.2, 0.2, 0.2, 0.2, 0.3], "weights sum to"),
|
|
("L_H", "vekter", [0.5, 0.5], "same, non-zero length"),
|
|
("c_N_ref", "lav", "109000", "expected a number"),
|
|
("c_N_ref", "lav", True, "expected a number"),
|
|
],
|
|
)
|
|
def test_ugyldig_fordeling_er_feil(
|
|
raa: dict[str, Any], parameter_id: str, felt: str, verdi: object, melding: str
|
|
) -> None:
|
|
kopi, post = _endret(raa, parameter_id)
|
|
post["fordeling"][felt] = verdi
|
|
with pytest.raises(pm.ParameterError, match=melding):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
def test_duplikater_er_feil(raa: dict[str, Any], tmp_path: Path) -> None:
|
|
kopi = copy.deepcopy(raa)
|
|
kopi["parametere"].append(copy.deepcopy(kopi["parametere"][5]))
|
|
with pytest.raises(pm.ParameterError, match="duplicate parameter id"):
|
|
pm.tolk_parametere(kopi)
|
|
fil = tmp_path / "p.json"
|
|
fil.write_text('{"versjon": "1", "versjon": "2"}', encoding="utf-8")
|
|
with pytest.raises(pm.ParameterError, match="duplicate key 'versjon'"):
|
|
pm.les_parametere(fil, krev_frossen=False)
|
|
|
|
|
|
def test_ugyldig_json_og_feil_antall_trekninger(raa: dict[str, Any], tmp_path: Path) -> None:
|
|
fil = tmp_path / "p.json"
|
|
fil.write_text("{", encoding="utf-8")
|
|
with pytest.raises(pm.ParameterError, match="not valid JSON"):
|
|
pm.les_parametere(fil, krev_frossen=False)
|
|
kopi = copy.deepcopy(raa)
|
|
kopi["monte_carlo"]["antall_trekninger"] = 5000
|
|
with pytest.raises(pm.ParameterError, match="N_trekk differs"):
|
|
pm.tolk_parametere(kopi)
|
|
kopi = copy.deepcopy(raa)
|
|
kopi["monte_carlo"]["metode"] = "LHS"
|
|
with pytest.raises(pm.ParameterError, match="monte_carlo: unknown field"):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
def test_sammensatt_parameter_maa_ha_alle_feltene(raa: dict[str, Any]) -> None:
|
|
kopi, post = _endret(raa, "vind")
|
|
post["fordeling"]["degradering"] = {"type": "fast", "verdi": 0.0042}
|
|
with pytest.raises(pm.ParameterError, match="a composite must have the fields"):
|
|
pm.tolk_parametere(kopi)
|
|
kopi, post = _endret(raa, "pris_balanse")
|
|
post["enhet"] = "TWh; øre/kWh (2025-kroner)"
|
|
with pytest.raises(pm.ParameterError, match="expected a table with unit"):
|
|
pm.tolk_parametere(kopi)
|
|
|
|
|
|
# -------------------------------------------------------------- unit conversion
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("navn", "enhet", "faktor"),
|
|
[
|
|
("c_N_ref", "kr/kW", 1e3),
|
|
("f_N", "kr/kW per år", 1e3),
|
|
("v_N", "kr/MWh", 1.0),
|
|
("D_avv", "mill. kr/MW", 1e6),
|
|
("K_U", "mrd. kr", 1e9),
|
|
("D_fors", "mill. kr", 1e6),
|
|
("c_H0", "mill. kr/MW IT", 1e6),
|
|
("o_D", "mill. kr/MW IT per år", 1e6),
|
|
("c_linje", "mill. kr/km", 1e6),
|
|
("c_fast", "kr/MW per år", 1.0),
|
|
("S0", "TWh", 1e6),
|
|
("g_fornybar", "TWh per år", 1e6),
|
|
("G_server", "GW per år", 1e3),
|
|
("u_kjerne", "g CO2e/kWh", 1e-3),
|
|
("eta_N", "tonn uran per TWh", 1e-6),
|
|
("vind.investering", "kr/kW", 1e3),
|
|
("vind.drift", "kr/MWh", 1.0),
|
|
("havvind.drift", "kr/kW per år", 1e3),
|
|
("vann.fullasttimer", "t/år", 1.0),
|
|
],
|
|
)
|
|
def test_enhetsfaktorer(sett: pm.Parametersett, navn: str, enhet: str, faktor: float) -> None:
|
|
storrelse = sett.storrelse(navn)
|
|
assert (storrelse.enhet, storrelse.faktor) == (enhet, faktor)
|
|
|
|
|
|
def test_faste_verdier_i_ligningenes_enheter(sett: pm.Parametersett) -> None:
|
|
assert sett.fast("P_ref") == 1000.0
|
|
assert sett.fast("c_linje") == pytest.approx(13.4e6)
|
|
assert sett.fast("D_fors") == pytest.approx(8.202e9)
|
|
assert sett.fast("o_D_v") == pytest.approx(3.21e6)
|
|
assert sett.fast("G_server") == 25_000.0
|
|
assert sett.fast("havvind.drift") == 900_000.0
|
|
assert sett.fast("vind.levetid") == 30.0
|
|
assert sett.fast("SNKS_snitt") == pytest.approx(536.3e9)
|
|
with pytest.raises(pm.ParameterError, match="not a fixed scalar"):
|
|
sett.fast("c_N_ref")
|
|
with pytest.raises(KeyError):
|
|
sett.storrelse("finnes_ikke")
|
|
|
|
|
|
def test_lister_og_tabeller(sett: pm.Parametersett) -> None:
|
|
assert sett.liste("stige") == (1.0, 5.0, 10.0, 20.0, 40.0)
|
|
assert sett.liste("P_u_sett")[0] == 5.0
|
|
assert sett.liste("P_u_sett")[-1] == 1000.0
|
|
assert sett.karbonpris()["sentral"][2030] == 2377.0
|
|
assert sett.karbonpris()["lav"][2100] == 8547.0
|
|
petroleum = sett.petroleumsinntekt()
|
|
assert petroleum[2022] == pytest.approx(1285.223e9)
|
|
assert sum(petroleum.values()) / 10 == pytest.approx(482.4e9, rel=1e-3)
|
|
# in 2025 kroner the average is the denominator of M6, and the median lies between 2019
|
|
# and 2021 (clarification 53); in current prices it is 272.2 mrd. kr
|
|
faste = sett.petroleumsinntekt(faste_kroner=True)
|
|
assert faste[2025] == petroleum[2025]
|
|
assert faste[2016] == pytest.approx(124.779e9 * 137.7 / 103.6)
|
|
assert sum(faste.values()) / 10 == pytest.approx(sett.fast("SNKS_snitt"), rel=1e-4)
|
|
assert statistics.median(faste.values()) == pytest.approx(330.1e9, rel=1e-3)
|
|
assert statistics.median(petroleum.values()) == pytest.approx(272.2e9, rel=1e-3)
|
|
with pytest.raises(pm.ParameterError, match="not a table"):
|
|
sett.tabell("c_N_ref")
|
|
|
|
|
|
def test_prisene_regnes_om_til_2025_kroner_per_mwh(sett: pm.Parametersett) -> None:
|
|
scenarioer = sett.pris_balanse()
|
|
assert len(scenarioer) == 12
|
|
svakest = scenarioer[-1]
|
|
assert svakest.navn.startswith("N11")
|
|
assert svakest.balanse == pytest.approx(-3.6e6)
|
|
assert svakest.pris["NO1"] == pytest.approx(76.8 * 10 * 137.7 / 129.6)
|
|
assert set(svakest.pris) == {"NO1", "NO2", "NO3", "NO4", "NO5", "Norge"}
|
|
|
|
|
|
def test_alle_storrelser_og_rekkefolgen(sett: pm.Parametersett) -> None:
|
|
"""136 scalar quantities with the composites split; 87 of them are drawn, in file order."""
|
|
assert len(sett.storrelser()) == 136
|
|
stokastiske = [s.navn for s in sett.stokastiske()]
|
|
assert len(stokastiske) == 87
|
|
assert stokastiske[:4] == ["c_N_ref", "w_xi", "u_xi", "o_xi"]
|
|
assert stokastiske[-1] == "eps_e"
|
|
plass = stokastiske.index("vann.investering")
|
|
assert stokastiske[plass : plass + 2] == ["vann.investering", "vann.drift"]
|
|
assert sett.monte_carlo.froe == 20261111
|
|
assert sett.monte_carlo.antall_trekninger == 10_000
|
|
assert len(sett.foelsomheter) == 29
|