#!/usr/bin/env python3 """Validate all generated SnD Floaters cases using only the Python standard library.""" from __future__ import annotations import json import math import sys from collections import defaultdict from datetime import datetime from pathlib import Path from typing import Any ROOT = Path(__file__).resolve().parents[1] TOLERANCE = 0.001001 class ValidationFailure(Exception): pass def fail(case_id: str, message: str) -> None: raise ValidationFailure(f"{case_id}: {message}") def load_json(path: Path) -> Any: return json.loads(path.read_text(encoding="utf-8")) def parse_time(value: str) -> datetime: return datetime.fromisoformat(value.replace("Z", "+00:00")) def close(left: float, right: float) -> bool: return math.isclose(left, right, abs_tol=TOLERANCE, rel_tol=0.0) def collect_bases(value: Any) -> list[dict[str, Any]]: result: list[dict[str, Any]] = [] if isinstance(value, dict): if {"kind", "evidence_ids", "rule_ids", "assumption_id"}.issubset(value): result.append(value) for nested in value.values(): result.extend(collect_bases(nested)) elif isinstance(value, list): for nested in value: result.extend(collect_bases(nested)) return result def profile_map(legs: list[dict[str, Any]], answer_format: bool) -> dict[str, float]: result: defaultdict[str, float] = defaultdict(float) for leg in legs: if not leg["included_in_scope"]: continue profile = leg["sendout_profile"] points = profile["points"] if answer_format else profile for point in points: result[point["gas_day"]] += float(point["gwh"]) return dict(result) def expected_lng_delta(case_input: dict[str, Any], answer: dict[str, Any]) -> dict[str, float]: prior_by_id = {cargo["cargo_id"]: cargo for cargo in case_input["prior_cargo_book"]} result: defaultdict[str, float] = defaultdict(float) matched: set[str] = set() for update in answer["cargo_updates"]: prior_id = update["matched_prior_cargo_id"] if prior_id is not None: if prior_id not in prior_by_id: fail(case_input["case_id"], f"unknown matched prior cargo {prior_id}") if prior_id in matched: fail(case_input["case_id"], f"prior cargo {prior_id} matched more than once") matched.add(prior_id) for day, amount in profile_map(prior_by_id[prior_id]["discharge_legs"], False).items(): result[day] -= amount for day, amount in profile_map(update["discharge_legs"], True).items(): result[day] += amount return dict(result) def validate_estimate(case_id: str, estimate: dict[str, Any], label: str) -> None: lower = estimate["lower"] central = estimate["central"] upper = estimate["upper"] values = [lower, central, upper] if all(value is None for value in values): return if any(value is None for value in values): fail(case_id, f"{label} must have either three numeric values or three null values") if not lower <= central <= upper: fail(case_id, f"{label} does not satisfy lower <= central <= upper") def validate_case(case_path: Path, answer_path: Path) -> None: case_input = load_json(case_path) answer = load_json(answer_path) case_id = case_input["case_id"] if answer["case_id"] != case_id: fail(case_id, "answer case_id does not match input") if answer["as_of"] != case_input["as_of"]: fail(case_id, "answer as_of does not match input") if answer["unit"] != "GWh": fail(case_id, "answer unit must be GWh") as_of = parse_time(case_input["as_of"]) observations = {item["observation_id"]: item for item in case_input["observations"]} rule_ids = {item["rule_id"] for item in case_input["rules"]} known_evidence = set(observations) known_evidence.update(item["cargo_id"] for item in case_input["prior_cargo_book"]) known_evidence.update(item["record_id"] for item in case_input["prior_balance"]) for section in ("capacity_schedule", "unit_conversions"): for item in case_input["reference_data"].get(section, []): if "record_id" in item: known_evidence.add(item["record_id"]) for update in answer["cargo_updates"]: for observation_id in update["source_observation_ids"]: if observation_id not in observations: fail(case_id, f"unknown source observation {observation_id}") observation = observations[observation_id] if parse_time(observation["received_at"]) > as_of: fail(case_id, f"post-cutoff observation {observation_id} used in cargo update") if observation["retracted"]: fail(case_id, f"retracted observation {observation_id} used in cargo update") validate_estimate(case_id, update["quantity_gwh"], f"{update['update_id']} quantity") quantity = update["quantity_gwh"]["central"] fraction_sum = 0.0 for leg in update["discharge_legs"]: validate_estimate(case_id, leg["discharge_fraction"], f"{leg['leg_id']} fraction") fraction = leg["discharge_fraction"]["central"] if fraction is None: continue fraction_sum += fraction if quantity is not None: allocated = sum(float(point["gwh"]) for point in leg["sendout_profile"]["points"]) allocated += float(leg["sendout_profile"]["unallocated_gwh"]) expected = quantity * fraction if not close(allocated, expected): fail( case_id, f"{leg['leg_id']} allocates {allocated} GWh but should allocate {expected} GWh", ) if quantity is not None and update["action"]["value"] != "unresolved": if not close(fraction_sum, 1.0): fail(case_id, f"{update['update_id']} discharge fractions sum to {fraction_sum}") for item_basis in collect_bases(answer): kind = item_basis["kind"] evidence_ids = item_basis["evidence_ids"] unknown_ids = set(evidence_ids) - known_evidence if unknown_ids: fail(case_id, f"basis cites unknown evidence IDs {sorted(unknown_ids)}") if kind == "observed": if not evidence_ids or item_basis["rule_ids"]: fail(case_id, "observed basis must cite evidence and must not cite a rule") elif kind in {"inferred", "calculated", "unknown"}: if not evidence_ids: fail(case_id, f"{kind} basis must cite evidence") if not item_basis["rule_ids"]: fail(case_id, f"{kind} basis must cite at least one rule") missing_rules = set(item_basis["rule_ids"]) - rule_ids if missing_rules: fail(case_id, f"{kind} basis cites missing rules {sorted(missing_rules)}") elif kind == "assumed": if not item_basis["assumption_id"]: fail(case_id, "assumed basis must cite an assumption_id") else: fail(case_id, f"invalid basis kind {kind}") prior_rows = { (row["gas_day"], row["component_id"]): row for row in case_input["prior_balance"] } input_days = case_input["scope"]["balance_gas_days"] for day in input_days: prior_residual = sum( row["contribution_gwh"] for row in case_input["prior_balance"] if row["gas_day"] == day ) if not close(prior_residual, 0.0): fail(case_id, f"prior balance on {day} has residual {prior_residual}") derived_lng_delta = expected_lng_delta(case_input, answer) answer_days = [row["gas_day"] for row in answer["daily_balance"]] if answer_days != input_days: fail(case_id, f"answer gas days {answer_days} do not match input {input_days}") for day in answer["daily_balance"]: gas_day = day["gas_day"] components = {row["component_id"]: row for row in day["components"]} if len(components) != len(day["components"]): fail(case_id, f"duplicate component on {gas_day}") if set(components) != { "domestic_production", "pipeline_imports", "lng_sendout", "demand", "exports", "storage_net", }: fail(case_id, f"wrong component set on {gas_day}") expected_delta = round(derived_lng_delta.get(gas_day, 0.0), 3) if not close(components["lng_sendout"]["delta_contribution_gwh"], expected_delta): fail(case_id, f"LNG delta on {gas_day} is not the cargo-profile difference") if not close(components["storage_net"]["delta_contribution_gwh"], -expected_delta): fail(case_id, f"storage delta on {gas_day} does not offset LNG") for component_id, row in components.items(): prior = prior_rows[(gas_day, component_id)]["contribution_gwh"] if not close(row["prior_contribution_gwh"], prior): fail(case_id, f"wrong prior {component_id} value on {gas_day}") if not close( row["prior_contribution_gwh"] + row["delta_contribution_gwh"], row["updated_contribution_gwh"], ): fail(case_id, f"component arithmetic fails for {component_id} on {gas_day}") if component_id not in {"lng_sendout", "storage_net"} and not close( row["delta_contribution_gwh"], 0.0 ): fail(case_id, f"unexpected non-LNG change to {component_id} on {gas_day}") residual = sum(row["updated_contribution_gwh"] for row in components.values()) if not close(residual, day["residual_gwh"]): fail(case_id, f"reported residual is wrong on {gas_day}") if not close(residual, 0.0): fail(case_id, f"updated balance on {gas_day} has residual {residual}") allowed_check_values = {"pass", "fail", "not_applicable"} if set(answer["quality_checks"].values()) - allowed_check_values: fail(case_id, "quality_checks contains an invalid status") if answer["assumptions"]: fail(case_id, "starter answer keys should contain no unsupported assumptions") def main() -> int: manifest = load_json(ROOT / "manifest.json") failures: list[str] = [] for entry in manifest["cases"]: try: validate_case(ROOT / entry["input_path"], ROOT / entry["answer_path"]) print(f"PASS {entry['case_id']}: {entry['title']}") except (ValidationFailure, KeyError, TypeError, ValueError) as error: failures.append(str(error)) print(f"FAIL {entry['case_id']}: {error}") print() if failures: print(f"{len(failures)} of {manifest['case_count']} cases failed validation") return 1 print(f"All {manifest['case_count']} cases passed deterministic validation") return 0 if __name__ == "__main__": sys.exit(main())