feat(verktoy): the command tilleggsfiler writes fordelinger.json and miljo.json
Clarifications 140 (e), 141 and 142. fordelinger.json is read off the run over the draws; miljo.json has a pass of its own with the same build-out and programme per scenario, and S32, S53 and S54 from the functions of miljo. None of the modules behind the six files of the main run is edited. 30 tests on made-up numbers; not run on the freeze. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
parent
de8fa552d2
commit
1c9afbd146
3 changed files with 991 additions and 2 deletions
453
src/tokenfabrikker/tilleggsfiler.py
Normal file
453
src/tokenfabrikker/tilleggsfiler.py
Normal file
|
|
@ -0,0 +1,453 @@
|
|||
"""The two files made next to the main run: ``fordelinger.json`` and ``miljo.json``.
|
||||
|
||||
Chapter 16, clarifications 140 (e), 141 and 142. The six files of the main run
|
||||
hold shares and medians. ``fordelinger.json`` holds, for the figures, the
|
||||
percentiles 0 to 100 over the draws of five quantities the verdicts and the
|
||||
surfaces build on. ``miljo.json`` holds what clarifications 15 and 16 of the
|
||||
pre-registration require reported per solution and that no other file has:
|
||||
the life-cycle emissions per year (S32), the emissions "with deduction" (S53)
|
||||
and cooling water (S54). Neither enters any verdict, and neither belongs to
|
||||
the six files: ``innhold.json`` and ``kontroll`` are as before, and the
|
||||
checksums of the two stand in ``tillegg.json``.
|
||||
|
||||
``fordelinger.json`` is read off the run over the draws as the main run
|
||||
computes it (``kjoring.kjor``). ``miljo.json`` needs the programme year by
|
||||
year, which the run does not keep, so it has a pass of its own: the same
|
||||
build-out and the same programme per scenario as ``kjoring.regn_bane``, and
|
||||
from them the series with the functions of ``miljo``. Nothing here computes a
|
||||
figure of its own beyond the difference U_liv - U_unngaatt (as
|
||||
``miljo.utslipp_med_fradrag``), the sum over the years and the percentiles
|
||||
(``dommer.persentil``).
|
||||
|
||||
The format and the head are those of ``datafiler``. A value that is not a
|
||||
finite number stops the command: it is never sorted in or left out silently.
|
||||
With several processes the draws are shared out and put together in their
|
||||
order, so the files have the same bytes however many processes there are.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import math
|
||||
from concurrent.futures import ProcessPoolExecutor
|
||||
from dataclasses import dataclass
|
||||
from typing import TYPE_CHECKING, Final, cast
|
||||
|
||||
import numpy as np
|
||||
|
||||
from tokenfabrikker import datafiler as df
|
||||
from tokenfabrikker import dommer as dm
|
||||
from tokenfabrikker import kjoring as kj
|
||||
from tokenfabrikker import kontantstrom as ks
|
||||
from tokenfabrikker import miljo
|
||||
from tokenfabrikker.utbygging import Losning
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Callable, Iterable, Mapping, Sequence
|
||||
from pathlib import Path
|
||||
|
||||
import numpy.typing as npt
|
||||
|
||||
from tokenfabrikker.datafiler import Json
|
||||
from tokenfabrikker.grunnlag import Grunnlag
|
||||
from tokenfabrikker.inndata import Inndata
|
||||
from tokenfabrikker.kjoring import Kjoring, Scenario
|
||||
from tokenfabrikker.kontantstrom import Programresultat
|
||||
|
||||
Tabell = npt.NDArray[np.float64]
|
||||
|
||||
FORDELINGER: Final = "fordelinger.json"
|
||||
MILJO: Final = "miljo.json"
|
||||
TILLEGG: Final = "tillegg.json"
|
||||
|
||||
TILLEGGSFILER: Final = (FORDELINGER, MILJO)
|
||||
"""The two files with figures, in the order they are written."""
|
||||
|
||||
PROSENTER: Final = tuple(range(101))
|
||||
"""The percentiles of ``fordelinger.json``, in per cent (clarification 140 e)."""
|
||||
|
||||
FORDELTE: Final = ("NNV", "S42", "M3", "M6", "c_snitt")
|
||||
"""The five quantities of ``fordelinger.json``, by their names in ``kjoring.Utfall``."""
|
||||
|
||||
NULLANSLAG: Final = "null"
|
||||
"""The estimate of u_alt that is zero: U_med is U_liv there, so it is left out (141)."""
|
||||
|
||||
VANNSERIER: Final = ("uttak", "uttak_egen_bruk", "forbruk_kjernekraft", "forbruk_hoyst")
|
||||
"""The four series of cooling water, by their names in ``miljo.Kjolevann``."""
|
||||
|
||||
ENHETER: Final = {
|
||||
"utslipp": "tonn CO2-ekvivalenter per år",
|
||||
"kjolevann": "m3 per år",
|
||||
}
|
||||
|
||||
|
||||
class TilleggError(ValueError):
|
||||
"""The two files cannot be made as asked; the message is shown to the user as it stands."""
|
||||
|
||||
|
||||
# --------------------------------------------------------------- fordelinger.json
|
||||
|
||||
|
||||
def fordeling(verdier: Iterable[float | None], hvor: str) -> dict[str, Json]:
|
||||
"""The count of the values and their percentiles 0 to 100; no percentiles without a value.
|
||||
|
||||
None is a draw without a value. A value that is not a finite number is an error.
|
||||
"""
|
||||
tall = [float(v) for v in verdier if v is not None]
|
||||
ikke_tall = [v for v in tall if not math.isfinite(v)]
|
||||
if ikke_tall:
|
||||
msg = (
|
||||
f"{hvor}: {len(ikke_tall)} values are not finite numbers (the first is {ikke_tall[0]})"
|
||||
)
|
||||
raise ValueError(msg)
|
||||
tall.sort()
|
||||
return {
|
||||
"antall": len(tall),
|
||||
"persentiler": [dm.persentil(tall, p / 100) for p in PROSENTER] if tall else None,
|
||||
}
|
||||
|
||||
|
||||
def lag_fordelinger(hodet: Mapping[str, Json], kjoring: Kjoring) -> dict[str, Json]:
|
||||
"""``fordelinger.json`` (clarifications 140 e and 142 c)."""
|
||||
per_scenario = []
|
||||
for scenario in kjoring.scenarioer:
|
||||
per_trinn = []
|
||||
for n in kjoring.stige:
|
||||
losninger: dict[str, Json] = {}
|
||||
for a in kjoring.losninger:
|
||||
utfall = kjoring.utfall(scenario, a, n)
|
||||
losninger[a.value] = {
|
||||
navn: fordeling(
|
||||
(
|
||||
None if u is None else cast("float | None", getattr(u, navn))
|
||||
for u in utfall
|
||||
),
|
||||
f"{scenario.navn}, trinn {n}, {a.value}, {navn}",
|
||||
)
|
||||
for navn in FORDELTE
|
||||
}
|
||||
per_trinn.append({"trinn": n, "losninger": losninger})
|
||||
per_scenario.append({"navn": scenario.navn, "trinn": per_trinn})
|
||||
return {
|
||||
**hodet,
|
||||
"storrelser": list(FORDELTE),
|
||||
"prosenter": list(PROSENTER),
|
||||
"per_scenario": per_scenario,
|
||||
}
|
||||
|
||||
|
||||
# --------------------------------------------------------------------- miljo.json
|
||||
|
||||
|
||||
def anslagene(trekninger: Sequence[Inndata]) -> tuple[str, ...]:
|
||||
"""The estimates of u_alt in the order of the table, without zero; the same in every draw."""
|
||||
if not trekninger:
|
||||
msg = "the run needs at least one draw"
|
||||
raise ValueError(msg)
|
||||
anslag = tuple(navn for navn in trekninger[0].u_alt if navn != NULLANSLAG)
|
||||
for i, inn in enumerate(trekninger):
|
||||
if tuple(navn for navn in inn.u_alt if navn != NULLANSLAG) != anslag:
|
||||
msg = f"draw {i} has other estimates of u_alt than the first draw"
|
||||
raise ValueError(msg)
|
||||
return anslag
|
||||
|
||||
|
||||
def aarene(trekninger: Sequence[Inndata]) -> tuple[int, ...]:
|
||||
"""The years T_0 + 1 to T_s; the same in every draw."""
|
||||
forste = (trekninger[0].heltall("T0"), trekninger[0].heltall("T_slutt"))
|
||||
for i, inn in enumerate(trekninger):
|
||||
if (inn.heltall("T0"), inn.heltall("T_slutt")) != forste:
|
||||
msg = f"draw {i} has another decision year or final year than the first draw"
|
||||
raise ValueError(msg)
|
||||
return tuple(range(forste[0] + 1, forste[1] + 1))
|
||||
|
||||
|
||||
def serienavn(anslag: Sequence[str]) -> tuple[str, ...]:
|
||||
"""The names of the rows ``miljoserier`` gives, in its order."""
|
||||
med_fradrag = [f"{navn}.{a}" for a in anslag for navn in ("U_unngaatt", "U_med")]
|
||||
return ("U_liv", *med_fradrag, *VANNSERIER)
|
||||
|
||||
|
||||
def miljoserier(inn: Inndata, res: Programresultat, anslag: Sequence[str]) -> Tabell:
|
||||
"""S32, S53 and S54 for one programme: one row per series, one column per year from T_0 + 1.
|
||||
|
||||
The rows are U_liv, then U_unngaatt and U_med for each estimate, then the
|
||||
four series of cooling water (``serienavn``). The year T_0 is left out,
|
||||
and a value there is an error: nothing is in operation in the decision year.
|
||||
"""
|
||||
U_liv = miljo.utslipp_livslop(inn, res)
|
||||
rader = [U_liv]
|
||||
for a in anslag:
|
||||
unngaatt = miljo.unngaatt_utslipp(inn, res, anslag=a)
|
||||
rader += [unngaatt, U_liv - unngaatt]
|
||||
vann = miljo.kjolevann(inn, res)
|
||||
rader += [cast("Tabell", getattr(vann, navn)) for navn in VANNSERIER]
|
||||
tabell = np.array(rader, dtype=np.float64)
|
||||
if res.aar[0] != res.plan.T_0 or np.any(tabell[:, 0] != 0.0):
|
||||
msg = f"{res.losning.value}: a series has a value in the decision year {res.aar[0]}"
|
||||
raise ValueError(msg)
|
||||
return tabell[:, 1:]
|
||||
|
||||
|
||||
def programmer(
|
||||
inn: Inndata, losning: Losning, trinn: int, scenarioer: Sequence[Scenario]
|
||||
) -> dict[str, Programresultat] | None:
|
||||
"""The programme per scenario for one solution on one step in one draw; None when unbuildable.
|
||||
|
||||
The same build-out and the same programme as ``kjoring.regn_bane`` (clarification 95).
|
||||
"""
|
||||
dim = ks.dimensjoner(inn, losning)
|
||||
plan = ks.lag_plan(inn, losning, dim, N_anlegg=trinn)
|
||||
if not plan.gjennomforbar:
|
||||
return None
|
||||
return {
|
||||
s.navn: ks.regn_program(
|
||||
inn,
|
||||
losning,
|
||||
plan,
|
||||
s.knapphet,
|
||||
dim=dim,
|
||||
bortfall=None if s.bortfall is None else ks.bortfall_i_scenario(inn, s.bortfall),
|
||||
)
|
||||
for s in scenarioer
|
||||
}
|
||||
|
||||
|
||||
def miljo_for_trekning(
|
||||
inn: Inndata,
|
||||
losning: Losning,
|
||||
trinn: int,
|
||||
scenarioer: Sequence[Scenario],
|
||||
anslag: Sequence[str],
|
||||
) -> Tabell | None:
|
||||
"""The series of every scenario for one path in one draw: scenario, series, year; or None."""
|
||||
prog = programmer(inn, losning, trinn, scenarioer)
|
||||
if prog is None:
|
||||
return None
|
||||
return np.array([miljoserier(inn, prog[s.navn], anslag) for s in scenarioer], dtype=np.float64)
|
||||
|
||||
|
||||
def _navn_p() -> list[str]:
|
||||
return [f"p{round(100 * p)}" for p in kj.PERSENTILER]
|
||||
|
||||
|
||||
def _tre(sortert: list[float]) -> tuple[float, ...]:
|
||||
"""The median and the percentiles of the timeline (clarification 99) of sorted values."""
|
||||
return (dm.persentil(sortert, 0.5), *(dm.persentil(sortert, p) for p in kj.PERSENTILER))
|
||||
|
||||
|
||||
def serie(stabel: Tabell, hvor: str) -> dict[str, Json]:
|
||||
"""One series over the draws: ``stabel`` has one row per draw and one column per year.
|
||||
|
||||
The sum over the years is taken per draw, as an exactly rounded sum, before
|
||||
its percentiles. Each year has the median and the percentiles over the draws.
|
||||
"""
|
||||
if stabel.ndim != 2 or stabel.shape[0] == 0: # noqa: PLR2004
|
||||
msg = f"{hvor}: a series needs at least one draw, one row per draw"
|
||||
raise ValueError(msg)
|
||||
if not np.all(np.isfinite(stabel)):
|
||||
msg = f"{hvor}: {int(np.sum(~np.isfinite(stabel)))} values are not finite numbers"
|
||||
raise ValueError(msg)
|
||||
navn = ("median", *_navn_p())
|
||||
summer = sorted(math.fsum(rad) for rad in stabel.tolist())
|
||||
per_aar = [_tre(np.sort(stabel[:, j]).tolist()) for j in range(stabel.shape[1])]
|
||||
return {
|
||||
"sum": dict(zip(navn, _tre(summer), strict=True)),
|
||||
**{n: [verdier[i] for verdier in per_aar] for i, n in enumerate(navn)},
|
||||
}
|
||||
|
||||
|
||||
def miljo_for_bane(
|
||||
per_trekning: Sequence[Tabell | None],
|
||||
scenarioer: Sequence[Scenario],
|
||||
anslag: Sequence[str],
|
||||
hvor: str,
|
||||
) -> dict[str, dict[str, Json]]:
|
||||
"""One solution on one step, per scenario: the count and the series over the draws.
|
||||
|
||||
``per_trekning`` holds what ``miljo_for_trekning`` gave per draw. Without a
|
||||
draw where the path can be built, the count is zero and the series are None.
|
||||
"""
|
||||
byggbare = [t for t in per_trekning if t is not None]
|
||||
ut: dict[str, dict[str, Json]] = {}
|
||||
for i, scenario in enumerate(scenarioer):
|
||||
if not byggbare:
|
||||
ut[scenario.navn] = {"antall": 0, "U_liv": None, "med_fradrag": None, "kjolevann": None}
|
||||
continue
|
||||
stabel = np.stack([t[i] for t in byggbare])
|
||||
rader = {
|
||||
navn: serie(stabel[:, q, :], f"{hvor}, {scenario.navn}, {navn}")
|
||||
for q, navn in enumerate(serienavn(anslag))
|
||||
}
|
||||
ut[scenario.navn] = {
|
||||
"antall": len(byggbare),
|
||||
"U_liv": rader["U_liv"],
|
||||
"med_fradrag": {
|
||||
a: {navn: rader[f"{navn}.{a}"] for navn in ("U_unngaatt", "U_med")} for a in anslag
|
||||
},
|
||||
"kjolevann": {navn: rader[navn] for navn in VANNSERIER},
|
||||
}
|
||||
return ut
|
||||
|
||||
|
||||
_DELT: dict[str, tuple[Inndata, ...]] = {}
|
||||
"""The draws, set once in each process that runs jobs."""
|
||||
|
||||
|
||||
def _sett_trekninger(trekninger: tuple[Inndata, ...]) -> None:
|
||||
_DELT["trekninger"] = trekninger
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class _Bane:
|
||||
"""One solution on one step, for the draw with a given number."""
|
||||
|
||||
losning: Losning
|
||||
trinn: int
|
||||
scenarioer: tuple[Scenario, ...]
|
||||
anslag: tuple[str, ...]
|
||||
|
||||
def __call__(self, nr: int) -> Tabell | None:
|
||||
return miljo_for_trekning(
|
||||
_DELT["trekninger"][nr], self.losning, self.trinn, self.scenarioer, self.anslag
|
||||
)
|
||||
|
||||
|
||||
def lag_miljo(
|
||||
hodet: Mapping[str, Json],
|
||||
grunnlag: Grunnlag,
|
||||
stige: Sequence[int],
|
||||
scenarioer: Sequence[Scenario],
|
||||
losninger: Sequence[Losning],
|
||||
*,
|
||||
prosesser: int = 1,
|
||||
) -> dict[str, Json]:
|
||||
"""``miljo.json`` (clarifications 141 and 142 d): a pass of its own over the draws."""
|
||||
trekninger = grunnlag.trekninger
|
||||
anslag = anslagene(trekninger)
|
||||
aar = aarene(trekninger)
|
||||
numre = range(len(trekninger))
|
||||
baner = [_Bane(a, n, tuple(scenarioer), anslag) for a in losninger for n in stige]
|
||||
per_bane: dict[tuple[Losning, int], dict[str, dict[str, Json]]] = {}
|
||||
|
||||
def oppsummer(bane: _Bane, per_trekning: Sequence[Tabell | None]) -> None:
|
||||
feil = [t.shape for t in per_trekning if t is not None and t.shape[2] != len(aar)]
|
||||
if feil:
|
||||
msg = (
|
||||
f"{bane.losning.value}, step {bane.trinn}: the series do not cover {len(aar)} years"
|
||||
)
|
||||
raise ValueError(msg)
|
||||
per_bane[bane.losning, bane.trinn] = miljo_for_bane(
|
||||
per_trekning, scenarioer, anslag, f"{bane.losning.value}, trinn {bane.trinn}"
|
||||
)
|
||||
|
||||
if prosesser > 1:
|
||||
with ProcessPoolExecutor(
|
||||
max_workers=prosesser, initializer=_sett_trekninger, initargs=(trekninger,)
|
||||
) as utforer:
|
||||
for bane in baner:
|
||||
oppsummer(bane, list(utforer.map(bane, numre)))
|
||||
else:
|
||||
_sett_trekninger(trekninger)
|
||||
for bane in baner:
|
||||
oppsummer(bane, [bane(nr) for nr in numre])
|
||||
return {
|
||||
**hodet,
|
||||
"aar": list(aar),
|
||||
"anslag": list(anslag),
|
||||
"enheter": dict(ENHETER),
|
||||
"per_scenario": [
|
||||
{
|
||||
"navn": s.navn,
|
||||
"trinn": [
|
||||
{
|
||||
"trinn": n,
|
||||
"losninger": {a.value: per_bane[a, n][s.navn] for a in losninger},
|
||||
}
|
||||
for n in stige
|
||||
],
|
||||
}
|
||||
for s in scenarioer
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------- writing
|
||||
|
||||
|
||||
def _samme_hode(mappe: Path, navn: str, hodet: Mapping[str, Json]) -> None:
|
||||
"""Stop when a file in the folder is from another run (another basis, ladder or frame)."""
|
||||
sti = mappe / navn
|
||||
if not sti.is_file():
|
||||
return
|
||||
innhold = cast("dict[str, Json]", json.loads(sti.read_bytes().decode("utf-8")))
|
||||
if any(innhold.get(felt) != df.rein(verdi) for felt, verdi in hodet.items()):
|
||||
msg = (
|
||||
f"{navn} i {mappe} er ikke fra samme kjøring (annet grunnlag, andre trinn eller ramme)"
|
||||
)
|
||||
raise TilleggError(msg)
|
||||
|
||||
|
||||
def skriv_tillegg(mappe: Path, hodet: Mapping[str, Json]) -> str:
|
||||
"""Write ``tillegg.json``: the head and the SHA-256 of the two files that are in the folder."""
|
||||
sjekksummer: dict[str, Json] = {}
|
||||
for navn in TILLEGGSFILER:
|
||||
if (mappe / navn).is_file():
|
||||
_samme_hode(mappe, navn, hodet)
|
||||
sjekksummer[navn] = hashlib.sha256((mappe / navn).read_bytes()).hexdigest()
|
||||
return df.skriv(mappe / TILLEGG, {**hodet, "filer": sjekksummer})
|
||||
|
||||
|
||||
def skriv_tilleggsfiler(
|
||||
grunnlag: Grunnlag,
|
||||
mappe: Path,
|
||||
*,
|
||||
stige: Sequence[int] = kj.STIGE,
|
||||
scenarioer: Sequence[Scenario] = kj.SCENARIOER,
|
||||
losninger: Sequence[Losning] = tuple(Losning),
|
||||
prosesser: int = 1,
|
||||
filer: Sequence[str] = TILLEGGSFILER,
|
||||
laget: Callable[[str], None] | None = None,
|
||||
) -> tuple[str, ...]:
|
||||
"""Write the chosen files and ``tillegg.json``; returns the names in the order written.
|
||||
|
||||
The head is that of the six files. With ``innhold.json`` in the folder the
|
||||
head must be the same as there, and so must the head of a file of the two
|
||||
that is already there; otherwise nothing is computed (clarification 142 a).
|
||||
"""
|
||||
ukjent = [f for f in filer if f not in TILLEGGSFILER]
|
||||
if ukjent or not filer:
|
||||
msg = f"ukjent fil {', '.join(ukjent)}; filene er {', '.join(TILLEGGSFILER)}"
|
||||
raise TilleggError(msg)
|
||||
stige_, scenarioer_, losninger_ = df.ordne(stige, scenarioer, losninger)
|
||||
hodet = df.hode(grunnlag, stige_, scenarioer_, losninger_)
|
||||
for navn in (df.INNHOLD, *(f for f in TILLEGGSFILER if f not in filer)):
|
||||
_samme_hode(mappe, navn, hodet)
|
||||
skrevet: list[str] = []
|
||||
|
||||
def ferdig(navn: str, data: dict[str, Json]) -> None:
|
||||
df.skriv(mappe / navn, data)
|
||||
skrevet.append(navn)
|
||||
if laget is not None:
|
||||
laget(navn)
|
||||
|
||||
if FORDELINGER in filer:
|
||||
kjoring = kj.kjor(
|
||||
grunnlag.trekninger,
|
||||
stige=stige_,
|
||||
scenarioer=scenarioer_,
|
||||
losninger=losninger_,
|
||||
prosesser=prosesser,
|
||||
)
|
||||
ferdig(FORDELINGER, lag_fordelinger(hodet, kjoring))
|
||||
del kjoring
|
||||
if MILJO in filer:
|
||||
ferdig(
|
||||
MILJO, lag_miljo(hodet, grunnlag, stige_, scenarioer_, losninger_, prosesser=prosesser)
|
||||
)
|
||||
skriv_tillegg(mappe, hodet)
|
||||
skrevet.append(TILLEGG)
|
||||
if laget is not None:
|
||||
laget(TILLEGG)
|
||||
return tuple(skrevet)
|
||||
|
|
@ -8,7 +8,9 @@ stored ones (129). ``scenario``, ``folsomhet`` and ``terskel`` are runs of
|
|||
one's own from an input file in JSON, and ``sammenlign`` compares two folders
|
||||
that each hold a ``dommer.json`` (130). ``arbeidskopi`` copies the code, the
|
||||
tests, the parameter file, the draws, the stream, the specification and the
|
||||
map to a folder the user owns (132).
|
||||
map to a folder the user owns (132). ``tilleggsfiler`` writes the two files
|
||||
made next to the main run, ``fordelinger.json`` and ``miljo.json``, with their
|
||||
checksums in ``tillegg.json`` (140 e, 141, 142); the six files are not touched.
|
||||
|
||||
Every command that computes takes the basis from exactly one of
|
||||
``--grunnlag FIL`` (a made-up basis file) or ``--frys`` (the freeze, with the
|
||||
|
|
@ -37,6 +39,7 @@ from tokenfabrikker import datafiler as df
|
|||
from tokenfabrikker import folsomheter as fs
|
||||
from tokenfabrikker import grunnlag as gl
|
||||
from tokenfabrikker import kjoring as kj
|
||||
from tokenfabrikker import tilleggsfiler as tf
|
||||
from tokenfabrikker.parametere import ParameterError
|
||||
from tokenfabrikker.utbygging import Losning
|
||||
|
||||
|
|
@ -271,6 +274,27 @@ def kjor_hovedkjoring(valg: argparse.Namespace) -> int:
|
|||
return 0
|
||||
|
||||
|
||||
def kjor_tilleggsfiler(valg: argparse.Namespace) -> int:
|
||||
"""``tilleggsfiler``: write ``fordelinger.json`` and ``miljo.json`` (clarification 142)."""
|
||||
filer = tf.TILLEGGSFILER if valg.filer is None else tuple(valg.filer.split(","))
|
||||
ukjent = [f for f in filer if f not in tf.TILLEGGSFILER]
|
||||
if ukjent:
|
||||
msg = f"--filer: ukjent fil {', '.join(ukjent)}; filene er {', '.join(tf.TILLEGGSFILER)}"
|
||||
raise InngangsError(msg)
|
||||
stige = kj.STIGE if valg.stige is None else _stige_fra_tekst(valg.stige)
|
||||
grunnlag = hent_grunnlag(valg)
|
||||
skrevet = tf.skriv_tilleggsfiler(
|
||||
grunnlag,
|
||||
Path(valg.ut),
|
||||
stige=stige,
|
||||
prosesser=valg.prosesser,
|
||||
filer=filer,
|
||||
laget=skriv_laget,
|
||||
)
|
||||
sys.stdout.write(f"Grunnlaget er merket «{grunnlag.merke}». Skrevet: {', '.join(skrevet)}\n")
|
||||
return 0
|
||||
|
||||
|
||||
def kjor_kontroll(valg: argparse.Namespace) -> int:
|
||||
"""``kontroll``: make the six files anew and compare them with the stored ones (129)."""
|
||||
fasit = Path(valg.fasit)
|
||||
|
|
@ -598,6 +622,12 @@ def tolker() -> argparse.ArgumentParser:
|
|||
t.add_argument("--stige", metavar="1,5,10")
|
||||
t.add_argument("--filer", metavar="dommer.json,...")
|
||||
t.set_defaults(kjor=kjor_hovedkjoring)
|
||||
t = under.add_parser("tilleggsfiler", help="skriv fordelinger.json og miljo.json")
|
||||
_grunnlagsvalg(t)
|
||||
t.add_argument("--ut", required=True, metavar="MAPPE")
|
||||
t.add_argument("--stige", metavar="1,5,10")
|
||||
t.add_argument("--filer", metavar="fordelinger.json,miljo.json")
|
||||
t.set_defaults(kjor=kjor_tilleggsfiler)
|
||||
t = under.add_parser("kontroll", help="lag filene på nytt og sammenlign med de lagrede")
|
||||
_grunnlagsvalg(t)
|
||||
t.add_argument("--fasit", required=True, metavar="MAPPE")
|
||||
|
|
@ -634,7 +664,7 @@ def main(argumenter: Sequence[str] | None = None) -> int:
|
|||
return 2
|
||||
try:
|
||||
return cast("int", valg.kjor(valg))
|
||||
except (gl.GrunnlagError, InngangsError, ParameterError) as feil:
|
||||
except (gl.GrunnlagError, InngangsError, ParameterError, tf.TilleggError) as feil:
|
||||
sys.stderr.write(f"Feil: {feil}\n")
|
||||
return 2
|
||||
|
||||
|
|
|
|||
506
tests/test_tilleggsfiler.py
Normal file
506
tests/test_tilleggsfiler.py
Normal file
|
|
@ -0,0 +1,506 @@
|
|||
"""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,))
|
||||
Loading…
Add table
Add a link
Reference in a new issue