M6-T03: add pricing profile framework + strategy registry
- app/integrations/pricing: profiles.py (pydantic ManualProfile/TibberProfile, load_profile/list_profiles/validate_values), manual.yaml + tibber.yaml (structure-only, no price values), strategies.py (register/get_strategy, manual dual-tariff + tibber strategies, all Decimal). - tibber strategy matches nearest tibber_price with starts_at <= t0. - tests for profiles + strategies (hand-checked dual-tariff & tibber math).
This commit is contained in:
@@ -0,0 +1,11 @@
|
||||
"""Pricing profile framework and strategy registry.
|
||||
|
||||
This package provides:
|
||||
|
||||
- ``profiles``: Pydantic models describing the structure of pricing profiles
|
||||
(``ManualProfile`` / ``TibberProfile``), YAML loaders, and contract-values
|
||||
validation (``load_profile`` / ``list_profiles`` / ``validate_values``).
|
||||
- ``strategies``: A lightweight registry of price-calculation strategies
|
||||
(``register_strategy`` / ``get_strategy``), with built-in implementations for
|
||||
the ``manual`` (fixed dual-tariff) and ``tibber`` (dynamic API) kinds.
|
||||
"""
|
||||
@@ -0,0 +1,393 @@
|
||||
"""Pricing profile loader, validator, and contract-values checker.
|
||||
|
||||
A *pricing profile* is a YAML file that describes the **structure** of an energy
|
||||
contract — which fields exist, their units, and which have defaults. Actual
|
||||
pricing values (the numbers the user fills in via the UI) are stored in the DB
|
||||
as ``EnergyContractVersion.values`` (a JSON blob) and must conform to the
|
||||
corresponding profile's structure.
|
||||
|
||||
Profiles live in ``app/integrations/pricing/profiles/<kind>.yaml`` and are
|
||||
located at runtime relative to *this file* (not CWD), matching the pattern
|
||||
established by the Modbus profile loader.
|
||||
|
||||
Design notes
|
||||
------------
|
||||
- **Purely data + functions** — no abstract base classes or inheritance.
|
||||
- Two Pydantic models — ``ManualProfile`` and ``TibberProfile`` — capture the
|
||||
different structures of the two supported kinds. A thin union dispatcher in
|
||||
``load_profile`` picks the right one.
|
||||
- ``validate_values(kind, values)`` fills in fields that carry a ``default`` and
|
||||
raises ``ProfileValidationError`` for missing required fields or wrong types.
|
||||
- All errors are subclasses of built-ins so callers need not import this module
|
||||
just to catch them.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from typing import Any, Optional
|
||||
|
||||
import yaml
|
||||
from pydantic import BaseModel, ValidationError, model_validator
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Directory containing the YAML profiles, located relative to *this* file.
|
||||
_PROFILES_DIR = Path(__file__).parent / "profiles"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Custom exceptions
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class ProfileNotFoundError(FileNotFoundError):
|
||||
"""Raised when the requested profile YAML file does not exist."""
|
||||
|
||||
|
||||
class ProfileValidationError(ValueError):
|
||||
"""Raised when a profile YAML fails Pydantic validation or when contract
|
||||
values do not conform to the profile structure."""
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Leaf-node models (a single pricing field: unit + optional default)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class FieldSpec(BaseModel):
|
||||
"""Specification for a single numeric pricing field."""
|
||||
|
||||
unit: str
|
||||
"""Physical / monetary unit string (e.g. ``"EUR/kWh"``, ``"EUR/month"``)."""
|
||||
|
||||
default: Optional[float] = None
|
||||
"""Default value used when the field is absent from contract values.
|
||||
``None`` means the field is required (no default)."""
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# ManualProfile — fixed / variable dual-tariff contract structure
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class ManualBuySpec(BaseModel):
|
||||
normal: FieldSpec # high-tariff buy price (delivered_2 registers)
|
||||
dal: FieldSpec # low-tariff buy price (delivered_1 registers)
|
||||
|
||||
|
||||
class ManualSellSpec(BaseModel):
|
||||
normal: FieldSpec # high-tariff sell / return price
|
||||
dal: FieldSpec # low-tariff sell / return price
|
||||
|
||||
|
||||
class ManualEnergySpec(BaseModel):
|
||||
dual_tariff: bool # always True for manual profiles
|
||||
buy: ManualBuySpec
|
||||
sell: ManualSellSpec
|
||||
energy_tax: FieldSpec # added to buy price; includes VAT
|
||||
ode: FieldSpec # currently merged into energy_tax; default 0
|
||||
|
||||
|
||||
class ManualStandingSpec(BaseModel):
|
||||
network_fee: FieldSpec # EUR/month
|
||||
management_fee: FieldSpec # EUR/month
|
||||
|
||||
|
||||
class ManualCreditsSpec(BaseModel):
|
||||
heffingskorting: FieldSpec # EUR/year — energy-tax credit deducted at summary
|
||||
|
||||
|
||||
class ManualProfile(BaseModel):
|
||||
"""Complete structure description for a ``manual`` pricing contract."""
|
||||
|
||||
kind: str
|
||||
label: str
|
||||
energy: ManualEnergySpec
|
||||
standing: ManualStandingSpec
|
||||
credits: ManualCreditsSpec
|
||||
|
||||
@model_validator(mode="after")
|
||||
def _check_kind(self) -> "ManualProfile":
|
||||
if self.kind != "manual":
|
||||
raise ValueError(f"ManualProfile requires kind='manual', got {self.kind!r}")
|
||||
return self
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# TibberProfile — dynamic Tibber API contract structure
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class TibberEnergySpec(BaseModel):
|
||||
source: str # must be "tibber_api"
|
||||
energy_tax: FieldSpec # subtracted from total to derive sell price
|
||||
sell_adjust: FieldSpec # additional sell-price adjustment; default 0
|
||||
|
||||
|
||||
class TibberStandingSpec(BaseModel):
|
||||
management_fee: FieldSpec # EUR/month; has a default
|
||||
network_fee: FieldSpec # EUR/month
|
||||
|
||||
|
||||
class TibberCreditsSpec(BaseModel):
|
||||
heffingskorting: FieldSpec # EUR/year
|
||||
|
||||
|
||||
class TibberProfile(BaseModel):
|
||||
"""Complete structure description for a ``tibber`` pricing contract."""
|
||||
|
||||
kind: str
|
||||
label: str
|
||||
energy: TibberEnergySpec
|
||||
standing: TibberStandingSpec
|
||||
credits: TibberCreditsSpec
|
||||
|
||||
@model_validator(mode="after")
|
||||
def _check_kind(self) -> "TibberProfile":
|
||||
if self.kind != "tibber":
|
||||
raise ValueError(f"TibberProfile requires kind='tibber', got {self.kind!r}")
|
||||
return self
|
||||
|
||||
|
||||
# A union type for type hints where either profile is acceptable.
|
||||
AnyProfile = ManualProfile | TibberProfile
|
||||
|
||||
# Map kind → Pydantic model class used for validation.
|
||||
_PROFILE_MODELS: dict[str, type[ManualProfile] | type[TibberProfile]] = {
|
||||
"manual": ManualProfile,
|
||||
"tibber": TibberProfile,
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Public API
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def load_profile(kind: str) -> AnyProfile:
|
||||
"""Load and validate a pricing profile by kind name.
|
||||
|
||||
The profile file is expected at
|
||||
``app/integrations/pricing/profiles/<kind>.yaml``.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
kind:
|
||||
Profile kind without extension (``"manual"`` or ``"tibber"``).
|
||||
|
||||
Returns
|
||||
-------
|
||||
ManualProfile | TibberProfile
|
||||
Validated profile model.
|
||||
|
||||
Raises
|
||||
------
|
||||
ProfileNotFoundError
|
||||
If ``profiles/<kind>.yaml`` does not exist.
|
||||
ProfileValidationError
|
||||
If the YAML is syntactically valid but fails schema validation.
|
||||
"""
|
||||
path = _PROFILES_DIR / f"{kind}.yaml"
|
||||
if not path.exists():
|
||||
raise ProfileNotFoundError(
|
||||
f"Pricing profile '{kind}' not found (looked for {path})"
|
||||
)
|
||||
|
||||
with path.open("r", encoding="utf-8") as fh:
|
||||
raw = yaml.safe_load(fh)
|
||||
|
||||
if not isinstance(raw, dict):
|
||||
raise ProfileValidationError(
|
||||
f"Profile '{kind}': expected a YAML mapping, got {type(raw).__name__}"
|
||||
)
|
||||
|
||||
# Choose the right Pydantic model based on the ``kind`` field in the YAML.
|
||||
yaml_kind = raw.get("kind", kind)
|
||||
model_cls = _PROFILE_MODELS.get(yaml_kind)
|
||||
if model_cls is None:
|
||||
raise ProfileValidationError(
|
||||
f"Profile '{kind}' has unknown kind={yaml_kind!r}; "
|
||||
f"supported: {list(_PROFILE_MODELS)}"
|
||||
)
|
||||
|
||||
try:
|
||||
return model_cls.model_validate(raw)
|
||||
except ValidationError as exc:
|
||||
raise ProfileValidationError(
|
||||
f"Profile '{kind}' failed validation: {exc}"
|
||||
) from exc
|
||||
|
||||
|
||||
def list_profiles() -> list[dict[str, Any]]:
|
||||
"""Return structural data for all available pricing profiles.
|
||||
|
||||
Scans ``app/integrations/pricing/profiles/*.yaml``, loads each, and returns
|
||||
a list of dicts (Pydantic model dumps). Profiles that fail to load are
|
||||
skipped with a warning.
|
||||
|
||||
Returns
|
||||
-------
|
||||
list[dict[str, Any]]
|
||||
One entry per valid profile, suitable for JSON serialisation and
|
||||
front-end form rendering.
|
||||
"""
|
||||
results: list[dict[str, Any]] = []
|
||||
if not _PROFILES_DIR.exists():
|
||||
return results
|
||||
|
||||
for path in sorted(_PROFILES_DIR.glob("*.yaml")):
|
||||
kind = path.stem
|
||||
try:
|
||||
profile = load_profile(kind)
|
||||
results.append(profile.model_dump())
|
||||
except (ProfileNotFoundError, ProfileValidationError, Exception) as exc:
|
||||
logger.warning("Skipping malformed pricing profile '%s': %s", kind, exc)
|
||||
|
||||
return results
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Contract-values validation
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _fill_defaults_manual(values: dict[str, Any], profile: ManualProfile) -> dict[str, Any]:
|
||||
"""Return a copy of *values* with any ``ode`` default applied if missing."""
|
||||
filled = dict(values)
|
||||
|
||||
energy = dict(filled.get("energy", {}))
|
||||
|
||||
# Apply default for ode (default=0) if absent.
|
||||
if "ode" not in energy and profile.energy.ode.default is not None:
|
||||
energy["ode"] = profile.energy.ode.default
|
||||
|
||||
filled["energy"] = energy
|
||||
return filled
|
||||
|
||||
|
||||
def _fill_defaults_tibber(values: dict[str, Any], profile: TibberProfile) -> dict[str, Any]:
|
||||
"""Return a copy of *values* with sell_adjust and management_fee defaults applied."""
|
||||
filled = dict(values)
|
||||
|
||||
energy = dict(filled.get("energy", {}))
|
||||
# Apply default for sell_adjust (default=0) if absent.
|
||||
if "sell_adjust" not in energy and profile.energy.sell_adjust.default is not None:
|
||||
energy["sell_adjust"] = profile.energy.sell_adjust.default
|
||||
filled["energy"] = energy
|
||||
|
||||
standing = dict(filled.get("standing", {}))
|
||||
# Apply default for management_fee if absent.
|
||||
if (
|
||||
"management_fee" not in standing
|
||||
and profile.standing.management_fee.default is not None
|
||||
):
|
||||
standing["management_fee"] = profile.standing.management_fee.default
|
||||
filled["standing"] = standing
|
||||
|
||||
return filled
|
||||
|
||||
|
||||
def _require_numeric(section: str, key: str, container: dict[str, Any]) -> None:
|
||||
"""Assert that *container[key]* exists and is a number; raise ProfileValidationError."""
|
||||
if key not in container:
|
||||
raise ProfileValidationError(
|
||||
f"Contract values missing required field '{section}.{key}'"
|
||||
)
|
||||
val = container[key]
|
||||
if not isinstance(val, (int, float)):
|
||||
raise ProfileValidationError(
|
||||
f"Contract values field '{section}.{key}' must be a number, "
|
||||
f"got {type(val).__name__!r}"
|
||||
)
|
||||
|
||||
|
||||
def _validate_manual_values(values: dict[str, Any], profile: ManualProfile) -> dict[str, Any]:
|
||||
"""Validate and fill-defaults for manual contract values.
|
||||
|
||||
Returns the filled values dict on success. Raises ProfileValidationError
|
||||
on missing required fields or wrong types.
|
||||
"""
|
||||
filled = _fill_defaults_manual(values, profile)
|
||||
energy = filled.get("energy", {})
|
||||
buy = energy.get("buy", {})
|
||||
sell = energy.get("sell", {})
|
||||
standing = filled.get("standing", {})
|
||||
credits = filled.get("credits", {})
|
||||
|
||||
# Required energy.buy fields.
|
||||
_require_numeric("energy.buy", "normal", buy)
|
||||
_require_numeric("energy.buy", "dal", buy)
|
||||
# Required energy.sell fields.
|
||||
_require_numeric("energy.sell", "normal", sell)
|
||||
_require_numeric("energy.sell", "dal", sell)
|
||||
# Required energy fields.
|
||||
_require_numeric("energy", "energy_tax", energy)
|
||||
_require_numeric("energy", "ode", energy)
|
||||
# Required standing fields.
|
||||
_require_numeric("standing", "network_fee", standing)
|
||||
_require_numeric("standing", "management_fee", standing)
|
||||
# Required credits fields.
|
||||
_require_numeric("credits", "heffingskorting", credits)
|
||||
|
||||
return filled
|
||||
|
||||
|
||||
def _validate_tibber_values(values: dict[str, Any], profile: TibberProfile) -> dict[str, Any]:
|
||||
"""Validate and fill-defaults for tibber contract values.
|
||||
|
||||
Returns the filled values dict on success. Raises ProfileValidationError
|
||||
on missing required fields or wrong types.
|
||||
"""
|
||||
filled = _fill_defaults_tibber(values, profile)
|
||||
energy = filled.get("energy", {})
|
||||
standing = filled.get("standing", {})
|
||||
credits = filled.get("credits", {})
|
||||
|
||||
# Required energy fields.
|
||||
_require_numeric("energy", "energy_tax", energy)
|
||||
_require_numeric("energy", "sell_adjust", energy)
|
||||
# Required standing fields.
|
||||
_require_numeric("standing", "management_fee", standing)
|
||||
_require_numeric("standing", "network_fee", standing)
|
||||
# Required credits fields.
|
||||
_require_numeric("credits", "heffingskorting", credits)
|
||||
|
||||
return filled
|
||||
|
||||
|
||||
def validate_values(kind: str, values: dict[str, Any]) -> dict[str, Any]:
|
||||
"""Validate a contract-values dict against the named profile structure.
|
||||
|
||||
Fields that carry a ``default`` in the profile (e.g. ``ode``,
|
||||
``sell_adjust``, tibber ``management_fee``) are silently filled in when
|
||||
absent from *values*. Fields with no default that are absent, or fields
|
||||
whose value is not a number, cause a ``ProfileValidationError``.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
kind:
|
||||
Profile kind (``"manual"`` or ``"tibber"``).
|
||||
values:
|
||||
Contract values dict as stored in ``EnergyContractVersion.values``.
|
||||
|
||||
Returns
|
||||
-------
|
||||
dict[str, Any]
|
||||
A (possibly mutated) copy of *values* with defaults applied.
|
||||
|
||||
Raises
|
||||
------
|
||||
ProfileNotFoundError
|
||||
If the profile YAML for *kind* does not exist.
|
||||
ProfileValidationError
|
||||
If required fields are missing or have wrong types.
|
||||
"""
|
||||
profile = load_profile(kind)
|
||||
if isinstance(profile, ManualProfile):
|
||||
return _validate_manual_values(values, profile)
|
||||
if isinstance(profile, TibberProfile):
|
||||
return _validate_tibber_values(values, profile)
|
||||
# Unreachable with current kinds, but guard for future extensions.
|
||||
raise ProfileValidationError(f"No validator implemented for kind={kind!r}")
|
||||
@@ -0,0 +1,20 @@
|
||||
kind: manual
|
||||
label: 固定 / 可变费率（NL，双费率）
|
||||
|
||||
energy:
|
||||
dual_tariff: true # use delivered_1/2, returned_1/2 for low/high tariffs
|
||||
buy:
|
||||
normal: { unit: EUR/kWh } # high-tariff buy price (delivered_2 register)
|
||||
dal: { unit: EUR/kWh } # low-tariff buy price (delivered_1 register)
|
||||
sell:
|
||||
normal: { unit: EUR/kWh } # high-tariff sell / return price
|
||||
dal: { unit: EUR/kWh } # low-tariff sell / return price (currently equal to normal)
|
||||
energy_tax: { unit: EUR/kWh } # energy tax added to buy price (incl. VAT)
|
||||
ode: { unit: EUR/kWh, default: 0 } # currently merged into energy_tax
|
||||
|
||||
standing: # fixed charges; UI fills per month, engine prorates to days
|
||||
network_fee: { unit: EUR/month }
|
||||
management_fee: { unit: EUR/month }
|
||||
|
||||
credits:
|
||||
heffingskorting: { unit: EUR/year } # energy-tax credit; deducted at summary layer
|
||||
@@ -0,0 +1,14 @@
|
||||
kind: tibber
|
||||
label: Tibber 动态电价（15 分钟）
|
||||
|
||||
energy:
|
||||
source: tibber_api # buy = total (from API); sell = total − energy_tax − sell_adjust
|
||||
energy_tax: { unit: EUR/kWh } # subtracted from total to derive sell price (incl. VAT)
|
||||
sell_adjust: { unit: EUR/kWh, default: 0 } # additional sell-price adjustment (residual spread)
|
||||
|
||||
standing: # fixed charges; UI fills per month, engine prorates to days
|
||||
management_fee: { unit: EUR/month, default: 5.99 }
|
||||
network_fee: { unit: EUR/month }
|
||||
|
||||
credits:
|
||||
heffingskorting: { unit: EUR/year } # energy-tax credit; deducted at summary layer
|
||||
@@ -0,0 +1,288 @@
|
||||
"""Price-calculation strategy registry and built-in implementations.
|
||||
|
||||
A *strategy* is a plain function registered under a ``kind`` string. Given
|
||||
per-register kWh deltas, the period start time, the active contract-version
|
||||
values, and a DB session, it returns a result dict with:
|
||||
|
||||
{
|
||||
"import_cost": Decimal, # total cost of electricity drawn from grid
|
||||
"export_revenue": Decimal, # total revenue from electricity fed to grid
|
||||
"net_cost": Decimal, # import_cost − export_revenue
|
||||
"pricing": dict, # snapshot of the price inputs used (for auditing)
|
||||
}
|
||||
|
||||
**Import and export are kept separate throughout** — net_cost is only derived
|
||||
at the end. This supports the Dutch no-netting rule (saldering afgebouwd).
|
||||
|
||||
**All monetary arithmetic uses Decimal** converted via ``Decimal(str(x))`` to
|
||||
avoid float binary rounding errors.
|
||||
|
||||
Design notes
|
||||
------------
|
||||
- **Purely data + functions**: no ABC, no class hierarchy. A ``dict``-based
|
||||
registry is the simplest structure that supports the two current kinds and
|
||||
leaves the door open for future additions (e.g. ``octopus``, ``frank``).
|
||||
- ``deltas`` is a plain dataclass ``PeriodDeltas`` — typed, but no ORM.
|
||||
- Tibber strategy queries ``TibberPrice`` directly from the session; it does not
|
||||
call the Tibber API (that is T05's job).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime
|
||||
from decimal import Decimal
|
||||
from typing import Any, Callable
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Shared data types
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@dataclass
|
||||
class PeriodDeltas:
|
||||
"""Per-register kWh deltas for one 15-minute billing period.
|
||||
|
||||
All values are ``Decimal`` and represent ``end_reading − start_reading``
|
||||
for the corresponding cumulative energy register.
|
||||
|
||||
Attributes
|
||||
----------
|
||||
d1: Decimal
|
||||
Delivered (consumed) kWh on the low/dal tariff register (delivered_1).
|
||||
d2: Decimal
|
||||
Delivered (consumed) kWh on the normal/high tariff register (delivered_2).
|
||||
r1: Decimal
|
||||
Returned (fed-to-grid) kWh on the low/dal tariff register (returned_1).
|
||||
r2: Decimal
|
||||
Returned (fed-to-grid) kWh on the normal/high tariff register (returned_2).
|
||||
"""
|
||||
|
||||
d1: Decimal # delivered low-tariff
|
||||
d2: Decimal # delivered high-tariff
|
||||
r1: Decimal # returned low-tariff
|
||||
r2: Decimal # returned high-tariff
|
||||
|
||||
|
||||
# Strategy callable signature.
|
||||
StrategyFn = Callable[
|
||||
[PeriodDeltas, datetime, dict[str, Any], Session],
|
||||
dict[str, Any],
|
||||
]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Registry
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
_REGISTRY: dict[str, StrategyFn] = {}
|
||||
|
||||
|
||||
def register_strategy(kind: str, fn: StrategyFn) -> None:
|
||||
"""Register *fn* as the price-calculation strategy for *kind*.
|
||||
|
||||
Overwrites any previously registered strategy for the same kind (allows
|
||||
monkey-patching in tests).
|
||||
"""
|
||||
_REGISTRY[kind] = fn
|
||||
|
||||
|
||||
def get_strategy(kind: str) -> StrategyFn:
|
||||
"""Return the registered strategy for *kind*.
|
||||
|
||||
Raises
|
||||
------
|
||||
KeyError
|
||||
If no strategy is registered for *kind*.
|
||||
"""
|
||||
if kind not in _REGISTRY:
|
||||
raise KeyError(
|
||||
f"No price strategy registered for kind={kind!r}. "
|
||||
f"Available: {sorted(_REGISTRY)}"
|
||||
)
|
||||
return _REGISTRY[kind]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _to_decimal(value: Any) -> Decimal:
|
||||
"""Convert *value* to Decimal via str() to avoid float binary rounding."""
|
||||
return Decimal(str(value))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Manual strategy — fixed dual-tariff
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _manual_strategy(
|
||||
deltas: PeriodDeltas,
|
||||
t0: datetime,
|
||||
values: dict[str, Any],
|
||||
session: Session,
|
||||
) -> dict[str, Any]:
|
||||
"""Calculate billing costs for one period using fixed dual-tariff rates.
|
||||
|
||||
Formula (§3.4):
|
||||
- ``buy_dal = energy.buy.dal + energy.energy_tax + energy.ode``
|
||||
- ``buy_normal = energy.buy.normal + energy.energy_tax + energy.ode``
|
||||
- ``import_cost = Δd1 × buy_dal + Δd2 × buy_normal``
|
||||
- ``sell_dal = energy.sell.dal`` (no tax on return price)
|
||||
- ``sell_normal = energy.sell.normal``
|
||||
- ``export_revenue = Δr1 × sell_dal + Δr2 × sell_normal``
|
||||
- ``net_cost = import_cost − export_revenue``
|
||||
|
||||
The ``pricing`` snapshot contains all per-unit prices used so that the
|
||||
result is fully auditable without re-querying the contract version.
|
||||
"""
|
||||
energy = values.get("energy", {})
|
||||
buy = energy.get("buy", {})
|
||||
sell = energy.get("sell", {})
|
||||
|
||||
energy_tax = _to_decimal(energy.get("energy_tax", 0))
|
||||
ode = _to_decimal(energy.get("ode", 0))
|
||||
|
||||
buy_dal_base = _to_decimal(buy.get("dal", 0))
|
||||
buy_normal_base = _to_decimal(buy.get("normal", 0))
|
||||
sell_dal = _to_decimal(sell.get("dal", 0))
|
||||
sell_normal = _to_decimal(sell.get("normal", 0))
|
||||
|
||||
# Effective buy prices including all taxes.
|
||||
buy_dal = buy_dal_base + energy_tax + ode
|
||||
buy_normal = buy_normal_base + energy_tax + ode
|
||||
|
||||
import_cost = deltas.d1 * buy_dal + deltas.d2 * buy_normal
|
||||
export_revenue = deltas.r1 * sell_dal + deltas.r2 * sell_normal
|
||||
net_cost = import_cost - export_revenue
|
||||
|
||||
pricing_snapshot = {
|
||||
"kind": "manual",
|
||||
"buy_dal": str(buy_dal),
|
||||
"buy_normal": str(buy_normal),
|
||||
"sell_dal": str(sell_dal),
|
||||
"sell_normal": str(sell_normal),
|
||||
"energy_tax": str(energy_tax),
|
||||
"ode": str(ode),
|
||||
}
|
||||
|
||||
return {
|
||||
"import_cost": import_cost,
|
||||
"export_revenue": export_revenue,
|
||||
"net_cost": net_cost,
|
||||
"pricing": pricing_snapshot,
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tibber strategy — dynamic 15-minute spot price
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
class TibberPriceNotFoundError(LookupError):
|
||||
"""Raised when no TibberPrice row covers the requested period start.
|
||||
|
||||
The billing engine (T07) catches this to mark the period as ``degraded``
|
||||
or skip it until a price becomes available.
|
||||
"""
|
||||
|
||||
|
||||
def _tibber_strategy(
|
||||
deltas: PeriodDeltas,
|
||||
t0: datetime,
|
||||
values: dict[str, Any],
|
||||
session: Session,
|
||||
) -> dict[str, Any]:
|
||||
"""Calculate billing costs for one period using Tibber dynamic pricing.
|
||||
|
||||
Price lookup:
|
||||
Takes the most recent ``TibberPrice`` row where ``starts_at ≤ t0``
|
||||
(i.e. the slot that was in effect at *t0*). This is a DESC LIMIT 1
|
||||
query on ``starts_at``.
|
||||
|
||||
Formula (§3.4):
|
||||
- ``buy = total`` (Tibber's all-inclusive price, already includes tax)
|
||||
- ``sell = total − energy_tax − sell_adjust``
|
||||
- ``import_cost = (Δd1 + Δd2) × buy``
|
||||
- ``export_revenue = (Δr1 + Δr2) × sell``
|
||||
- ``net_cost = import_cost − export_revenue``
|
||||
|
||||
Tibber does not differentiate tariff slots (dal vs normal) — the 15-minute
|
||||
API price applies to the full delivered/returned volume.
|
||||
|
||||
Negative ``total`` (extreme negative spot prices):
|
||||
When ``total`` is negative the ``sell`` price will also be negative,
|
||||
meaning ``export_revenue`` becomes negative (feeding to grid *costs*
|
||||
money). This is the mathematically correct outcome and is left as-is.
|
||||
|
||||
Raises
|
||||
------
|
||||
TibberPriceNotFoundError
|
||||
If no ``TibberPrice`` row exists with ``starts_at ≤ t0``. The caller
|
||||
(T07 billing engine) should catch this and mark the period as
|
||||
``degraded`` or skip it for later recomputation.
|
||||
"""
|
||||
from app.models.energy import TibberPrice # local import to avoid circular
|
||||
from sqlalchemy import desc
|
||||
|
||||
price_row: TibberPrice | None = (
|
||||
session.query(TibberPrice)
|
||||
.filter(TibberPrice.starts_at <= t0)
|
||||
.order_by(desc(TibberPrice.starts_at))
|
||||
.first()
|
||||
)
|
||||
|
||||
if price_row is None:
|
||||
raise TibberPriceNotFoundError(
|
||||
f"No TibberPrice found covering t0={t0.isoformat()!r}; "
|
||||
"period cannot be billed until price data is available."
|
||||
)
|
||||
|
||||
energy = values.get("energy", {})
|
||||
energy_tax = _to_decimal(energy.get("energy_tax", 0))
|
||||
sell_adjust = _to_decimal(energy.get("sell_adjust", 0))
|
||||
|
||||
total = _to_decimal(price_row.total)
|
||||
buy = total
|
||||
sell = total - energy_tax - sell_adjust
|
||||
|
||||
total_delivered = deltas.d1 + deltas.d2
|
||||
total_returned = deltas.r1 + deltas.r2
|
||||
|
||||
import_cost = total_delivered * buy
|
||||
export_revenue = total_returned * sell
|
||||
net_cost = import_cost - export_revenue
|
||||
|
||||
pricing_snapshot = {
|
||||
"kind": "tibber",
|
||||
"tibber_price_starts_at": price_row.starts_at.isoformat(),
|
||||
"tibber_price_id": price_row.id,
|
||||
"total": str(total),
|
||||
"buy": str(buy),
|
||||
"sell": str(sell),
|
||||
"energy_tax": str(energy_tax),
|
||||
"sell_adjust": str(sell_adjust),
|
||||
}
|
||||
|
||||
return {
|
||||
"import_cost": import_cost,
|
||||
"export_revenue": export_revenue,
|
||||
"net_cost": net_cost,
|
||||
"pricing": pricing_snapshot,
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Register built-in strategies at module import time
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
register_strategy("manual", _manual_strategy)
|
||||
register_strategy("tibber", _tibber_strategy)
|
||||
Reference in New Issue
Block a user