tariffkit 0.2.0__py3-none-any.whl

tariffkit/billing/ledger.py

@@ -0,0 +1,365 @@
+"""Export credit balances carried across billing cycles.
+
+A single cycle's charges come from :mod:`tariffkit.billing.engine`, which is
+pure. This is the stateful layer above it: credits earned but not spent in a
+cycle bank, and offset later charges.
+
+Credits are not fungible. PG&E's statement states the rule directly:
+
+    1. Energy Produced credits can only offset Energy Produced charges
+    2. Energy Delivered credits can only offset Energy Delivered charges
+    3. Energy Export Bonus Credit can offset any and all electric charges
+
+So a balance is three buckets, not a number, and applying it needs each charge
+classified by which bucket may offset it.
+
+**One bank at a time.** A CCA customer has two, kept separately: PG&E's and the
+CCA's, each with its own balance and its own charges to offset. A :class:`Bill`
+merges both providers, so applying this to one straight off the billing engine
+gives an approximation -- the two banks spend in an order a merged view cannot
+reproduce. Feed one provider's charges and credits to get an exact answer; this
+must be done for each half of a real statement.
+
+Scope: this models carryover within a year. Closing a year -- the annual
+true-up, and Net Surplus Compensation -- lives in
+:mod:`tariffkit.billing.trueup`, which is built from tariff text rather than
+reconciled against a statement, because no true-up has happened on this account
+yet.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass, field, replace
+from enum import StrEnum
+from typing import Any
+
+from .models import Bill, BillingPeriod
+
+
+class CreditBucket(StrEnum):
+    """Which charges a credit may offset."""
+
+    #: PG&E's "Energy Produced" credits, and a CCA's Energy Export Credit.
+    GENERATION = "generation"
+    #: PG&E's "Energy Delivered" credits.
+    DELIVERY = "delivery"
+    #: Offsets anything not explicitly non-bypassable.
+    BONUS = "bonus"
+
+
+#: Export credit component -> the bucket it banks into.
+#:
+#: Verified against the 2026-08-04 statement, whose credit bank splits into
+#: "Energy Delivered Credits" $6.25 (the ``delivery`` component) and "Bonus
+#: Credits" $1.71 (``acc_plus``), and whose CCA page reports an Energy Export
+#: Credit of $9.63 (``cca_generation``).
+#:
+CREDIT_BUCKETS: dict[str, CreditBucket] = {
+    "delivery": CreditBucket.DELIVERY,
+    "generation": CreditBucket.GENERATION,
+    "cca_generation": CreditBucket.GENERATION,
+    "acc_plus": CreditBucket.BONUS,
+}
+
+#: Export-side components a statement spends inside the cycle instead of banking.
+#:
+#: MCE's 10% Solar Bonus Credit is the one vendored. The library computes it as
+#: part of the export credit, but the statement prints it on the *charges* side,
+#: between the cost relief credit and "Net Charges" -- so it reduces that
+#: cycle's generation charges and never reaches the bank. Banking it instead
+#: overstates both credits earned and credits applied, by $0.96 on the
+#: 2026-08-04 statement, while coincidentally still landing on the right closing
+#: balance because it was spent the same cycle.
+CHARGE_OFFSETS: dict[str, CreditBucket] = {
+    "cca_solar_bonus": CreditBucket.GENERATION,
+}
+
+#: Charge component -> the bucket whose credits may offset it.
+#:
+#: Anything absent is treated as non-offsettable. That is deliberate: a new
+#: component defaults to being payable in cash rather than silently becoming
+#: creditable.
+CHARGE_BUCKETS: dict[str, CreditBucket] = {
+    # Generation, whoever supplies it.
+    "generation": CreditBucket.GENERATION,
+    "cca_generation": CreditBucket.GENERATION,
+    "cca_cost_relief_credit": CreditBucket.GENERATION,
+    # Delivery. The statement bills these as its "Energy Delivered" block.
+    "distribution": CreditBucket.DELIVERY,
+    "transmission": CreditBucket.DELIVERY,
+    "transmission_rate_adjustments": CreditBucket.DELIVERY,
+    "reliability_services": CreditBucket.DELIVERY,
+    "wildfire_hardening": CreditBucket.DELIVERY,
+    "recovery_bond_charge": CreditBucket.DELIVERY,
+    "recovery_bond_credit": CreditBucket.DELIVERY,
+    "new_system_generation": CreditBucket.DELIVERY,
+    "bundled_pcia": CreditBucket.DELIVERY,
+}
+
+#: Charges no export credit may offset, so they are payable in cash.
+#:
+#: The five non-bypassable charges are non-bypassable in the tariff's own sense
+#: -- that is what the term means -- so not even a bonus credit reaches them.
+#: PCIA, the franchise fee surcharge and the Base Services Charge are listed
+#: here as the conservative reading; see ``SCOPING_VERIFIED``.
+NON_OFFSETTABLE = frozenset(
+    {
+        "public_purpose_programs",
+        "wildfire_fund_charge",
+        "competition_transition_charges",
+        "nuclear_decommissioning",
+        "energy_cost_recovery",
+        "pcia",
+        "franchise_fee_surcharge",
+        "baseline_credit",
+    }
+)
+
+#: False while the classification above is only partly reconciled.
+#:
+#: What a statement has confirmed: which components bank into which bucket, and
+#: that unspent credit carries forward capped by the charges available to offset.
+#:
+#: What it has not: where the boundary of an "Energy Delivered charge" actually
+#: falls. Confirming that needs a cycle whose credits *exceed* the charges they
+#: may offset, so the cap binds and the leftover is visible. On the statements
+#: reconciled so far the PG&E credits were smaller than the delivery charges, so
+#: the cap never bound and any classification would have produced the same bill.
+SCOPING_VERIFIED = False
+
+
+@dataclass(frozen=True, slots=True)
+class CreditBalances:
+    """A credit bank, by bucket. Never negative."""
+
+    generation: float = 0.0
+    delivery: float = 0.0
+    bonus: float = 0.0
+
+    def __post_init__(self) -> None:
+        for bucket in CreditBucket:
+            if self[bucket] < -1e-9:
+                raise ValueError(f"{bucket} balance is negative: {self[bucket]}")
+
+    def __getitem__(self, bucket: CreditBucket) -> float:
+        return float(getattr(self, str(bucket)))
+
+    def with_bucket(self, bucket: CreditBucket, value: float) -> CreditBalances:
+        return replace(self, **{str(bucket): value})
+
+    @property
+    def total(self) -> float:
+        return self.generation + self.delivery + self.bonus
+
+    def to_dict(self) -> dict[str, float]:
+        return {
+            "generation": round(self.generation, 4),
+            "delivery": round(self.delivery, 4),
+            "bonus": round(self.bonus, 4),
+            "total": round(self.total, 4),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class LedgerEntry:
+    """One cycle, after credits are applied."""
+
+    period: BillingPeriod
+    opening: CreditBalances
+    earned: CreditBalances
+    applied: CreditBalances
+    closing: CreditBalances
+    #: Charges left after credits, i.e. what is actually owed.
+    cash_due: float
+    #: Charges before any credit was applied.
+    gross_charges: float
+    #: The part of ``gross_charges`` no credit could reach.
+    non_offsettable: float
+    #: Metered energy for the cycle. Carried here because the annual true-up
+    #: tests surplus in kilowatt-hours rather than dollars -- both PG&E and MCE
+    #: define a Net Surplus Generator as one whose exported energy exceeds its
+    #: imported energy over the period.
+    imported_kwh: float = 0.0
+    exported_kwh: float = 0.0
+    #: False while the charge classification is only partly reconciled against a
+    #: statement; see ``SCOPING_VERIFIED``.
+    complete: bool = SCOPING_VERIFIED
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "period": self.period.to_dict(),
+            "opening": self.opening.to_dict(),
+            "earned": self.earned.to_dict(),
+            "applied": self.applied.to_dict(),
+            "closing": self.closing.to_dict(),
+            "cash_due": round(self.cash_due, 2),
+            "gross_charges": round(self.gross_charges, 2),
+            "non_offsettable": round(self.non_offsettable, 2),
+            "imported_kwh": round(self.imported_kwh, 3),
+            "exported_kwh": round(self.exported_kwh, 3),
+            "complete": self.complete,
+        }
+
+
+def credits_earned(bill: Bill) -> CreditBalances:
+    """Split a cycle's export credits into buckets.
+
+    ``Bill.export_components`` holds credits as negative numbers so a bill sums
+    directly; a bank holds them positive.
+    """
+    totals: dict[CreditBucket, float] = dict.fromkeys(CreditBucket, 0.0)
+    for name, value in bill.export_components.items():
+        bucket = CREDIT_BUCKETS.get(name)
+        if bucket is not None:
+            totals[bucket] += abs(value)
+    return CreditBalances(
+        generation=totals[CreditBucket.GENERATION],
+        delivery=totals[CreditBucket.DELIVERY],
+        bonus=totals[CreditBucket.BONUS],
+    )
+
+
+def charges_by_bucket(
+    bill: Bill,
+) -> tuple[dict[CreditBucket, float], float, dict[CreditBucket, float]]:
+    """``({bucket: offsettable charges}, non-offsettable charges, {bucket: unspent})``.
+
+    A component that nets out negative -- ``cca_cost_relief_credit``, or the
+    recovery bond credit -- reduces its bucket rather than creating charge to
+    offset elsewhere, which is how the statement prints it.
+
+    Fixed charges are offsettable, but only by the bonus bucket. This was the
+    other way round on the evidence then available -- "no reconciled statement
+    has shown a credit reaching it" -- and the 2026-07-07 statement falsified
+    it: it applies $1.59 of bonus credit where the energy charges alone leave
+    room for $0.92, and PG&E's own wording is that the bonus offsets anything
+    not explicitly non-bypassable. The Base Services Charge is not
+    non-bypassable; the charges printed as Non-Bypassable Charges are, and they
+    stay out of reach.
+    """
+    offsettable: dict[CreditBucket, float] = dict.fromkeys(CreditBucket, 0.0)
+    non_offsettable = 0.0
+    offsettable[CreditBucket.BONUS] += sum(bill.fixed_components.values())
+
+    for name, value in bill.import_components.items():
+        bucket = CHARGE_BUCKETS.get(name)
+        if bucket is None or name in NON_OFFSETTABLE:
+            non_offsettable += value
+        else:
+            offsettable[bucket] += value
+
+    # Spent in-cycle rather than banked; held negative on the export side.
+    for name, value in bill.export_components.items():
+        bucket = CHARGE_OFFSETS.get(name)
+        if bucket is not None:
+            offsettable[bucket] -= abs(value)
+
+    # An in-cycle offset can wipe out its bucket's charges but no more. The
+    # excess must not leak into non_offsettable: those are the non-bypassable
+    # charges, the ones nothing is allowed to reduce, and a generation-scoped
+    # offset reaching them would be exactly backwards. It banks instead, which
+    # is the rule the statement gives for any credit it cannot spend --
+    # "saved to help offset future bill charges".
+    unspent: dict[CreditBucket, float] = dict.fromkeys(CreditBucket, 0.0)
+    for bucket, value in offsettable.items():
+        if value < 0.0:
+            unspent[bucket] = -value
+            offsettable[bucket] = 0.0
+    return offsettable, non_offsettable, unspent
+
+
+def apply_credits(bill: Bill, opening: CreditBalances | None = None) -> LedgerEntry:
+    """Offset one cycle's charges with banked and newly earned credits.
+
+    Scoped buckets are spent first, then the bonus bucket against whatever
+    remains, because the bonus is the only one that can offset anything. Doing
+    it the other way round would burn the flexible credit on charges a scoped
+    one could have covered, and strand the scoped credit.
+    """
+    opening = opening or CreditBalances()
+    offsettable, non_offsettable, unspent = charges_by_bucket(bill)
+
+    # An in-cycle offset larger than the charges it was meant to cover banks the
+    # remainder rather than being lost or turned into cash owed.
+    earned = credits_earned(bill)
+    for bucket, value in unspent.items():
+        if value:
+            earned = earned.with_bucket(bucket, earned[bucket] + value)
+
+    available = CreditBalances(
+        generation=opening.generation + earned.generation,
+        delivery=opening.delivery + earned.delivery,
+        bonus=opening.bonus + earned.bonus,
+    )
+    applied = CreditBalances()
+    remaining = dict(offsettable)
+
+    for bucket in (CreditBucket.GENERATION, CreditBucket.DELIVERY):
+        spend = min(available[bucket], remaining[bucket])
+        applied = applied.with_bucket(bucket, spend)
+        remaining[bucket] -= spend
+
+    # The bonus reaches anything still standing, except charges the tariff makes
+    # non-bypassable -- that is what "non-bypassable" means.
+    bonus_spend = min(available.bonus, sum(remaining.values()))
+    applied = applied.with_bucket(CreditBucket.BONUS, bonus_spend)
+
+    closing = CreditBalances(
+        generation=available.generation - applied.generation,
+        delivery=available.delivery - applied.delivery,
+        bonus=available.bonus - applied.bonus,
+    )
+    gross = sum(offsettable.values()) + non_offsettable
+    return LedgerEntry(
+        period=bill.period,
+        opening=opening,
+        earned=earned,
+        applied=applied,
+        closing=closing,
+        cash_due=gross - applied.total,
+        gross_charges=gross,
+        non_offsettable=non_offsettable,
+        imported_kwh=sum(b.imported for b in bill.buckets),
+        exported_kwh=sum(b.exported for b in bill.buckets),
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class Ledger:
+    """A run of cycles with the bank carried between them."""
+
+    entries: tuple[LedgerEntry, ...] = field(default_factory=tuple)
+
+    @property
+    def closing(self) -> CreditBalances:
+        return self.entries[-1].closing if self.entries else CreditBalances()
+
+    @property
+    def cash_due(self) -> float:
+        return sum(e.cash_due for e in self.entries)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "entries": [e.to_dict() for e in self.entries],
+            "closing": self.closing.to_dict(),
+            "cash_due": round(self.cash_due, 2),
+        }
+
+
+def run_ledger(bills: Iterable[Bill], opening: CreditBalances | None = None) -> Ledger:
+    """Fold ``bills`` in order, carrying the bank between cycles.
+
+    Bills are sorted by period start, so a caller need not pre-order them. They
+    are not checked for gaps or overlaps: a ledger over a discontinuous run is
+    the caller's business, and a mid-year starting balance is a legitimate way
+    to begin partway through a program year.
+    """
+    balances = opening or CreditBalances()
+    entries: list[LedgerEntry] = []
+    ordered: Sequence[Bill] = sorted(bills, key=lambda b: b.period.start)
+    for bill in ordered:
+        entry = apply_credits(bill, balances)
+        entries.append(entry)
+        balances = entry.closing
+    return Ledger(tuple(entries))

tariffkit/billing/models.py

@@ -0,0 +1,274 @@
+"""Value types for bill computation."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from datetime import UTC, date, datetime, timedelta
+from typing import Any
+
+from ..models import Season, TouPeriod
+from ..timeutil import PACIFIC, to_pacific
+
+
+@dataclass(frozen=True, slots=True)
+class IntervalReading:
+    """Metered energy over one interval.
+
+    ``imported`` and ``exported`` are what crossed the meter, in kWh. Under the
+    Net Billing Tariff the meter has already netted within the interval, so in
+    real AMI data at most one of them is non-zero. Both are kept because the
+    distinction is what the tariff prices differently, and because gross
+    inverter data has to be netted before it can be billed.
+    """
+
+    start: datetime
+    imported: float = 0.0
+    exported: float = 0.0
+    duration: timedelta = timedelta(hours=1)
+    #: True when this interval's energy was reconstructed across a gap in the
+    #: source rather than measured over the interval itself. The total stays
+    #: right -- a cumulative counter only depends on its endpoints -- but the
+    #: shape does not, and the shape is what a time-of-use tariff prices. A
+    #: three-day outage spread evenly gives peak hours 5/24 of the energy where
+    #: the real day gives them nearly a third, which is a real dollar on a
+    #: cycle whose total is exact to 0.05 kWh.
+    estimated: bool = False
+
+    def __post_init__(self) -> None:
+        if self.imported < 0 or self.exported < 0:
+            raise ValueError(
+                f"readings must be non-negative; got imported={self.imported}, "
+                f"exported={self.exported}. Net readings should go through "
+                f"IntervalReading.from_net()."
+            )
+        if self.duration <= timedelta(0):
+            raise ValueError(f"duration must be positive, got {self.duration}")
+
+    @property
+    def end(self) -> datetime:
+        return self.start + self.duration
+
+    @property
+    def net(self) -> float:
+        """Positive when importing, negative when exporting."""
+        return self.imported - self.exported
+
+    @classmethod
+    def from_net(
+        cls, start: datetime, net_kwh: float, duration: timedelta = timedelta(hours=1)
+    ) -> IntervalReading:
+        """Build from a single signed value, positive meaning import."""
+        if net_kwh >= 0:
+            return cls(start, imported=net_kwh, duration=duration)
+        return cls(start, exported=-net_kwh, duration=duration)
+
+    @classmethod
+    def from_gross(
+        cls,
+        start: datetime,
+        consumption_kwh: float,
+        production_kwh: float,
+        duration: timedelta = timedelta(hours=1),
+    ) -> IntervalReading:
+        """Net gross site load against gross generation.
+
+        Use for inverter or CT-clamp data, which reports both sides
+        independently. Real AMI data is already netted -- do not double-net it.
+        """
+        return cls.from_net(start, consumption_kwh - production_kwh, duration)
+
+
+@dataclass(frozen=True, slots=True)
+class BillingPeriod:
+    """A meter-read-to-meter-read cycle.
+
+    Both ends are inclusive dates, matching how a statement prints them. The
+    Base Services Charge is billed per day over ``days``, which is why this is
+    not a calendar month -- a real cycle is 27 to 33 days.
+    """
+
+    start: date
+    end: date
+
+    def __post_init__(self) -> None:
+        if self.end < self.start:
+            raise ValueError(f"period ends before it starts: {self.start} to {self.end}")
+
+    @property
+    def days(self) -> int:
+        return (self.end - self.start).days + 1
+
+    def contains(self, moment: datetime) -> bool:
+        return self.start <= to_pacific(moment).date() <= self.end
+
+    @property
+    def elapsed(self) -> timedelta:
+        """Real time the cycle spans, which is not ``days`` times 24 hours.
+
+        A cycle containing a DST transition is an hour longer or shorter. Use
+        this to ask how much metered data *should* be there; use ``days`` for
+        anything billed per calendar day, like the Base Services Charge.
+        """
+        opens = datetime(self.start.year, self.start.month, self.start.day, tzinfo=PACIFIC)
+        # Wall-clock arithmetic is right here: the cycle closes at the next local
+        # midnight, however many real hours away that falls.
+        closes = datetime(self.end.year, self.end.month, self.end.day, tzinfo=PACIFIC) + timedelta(
+            days=1
+        )
+        return closes.astimezone(UTC) - opens.astimezone(UTC)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "start": self.start.isoformat(),
+            "end": self.end.isoformat(),
+            "days": self.days,
+        }
+
+    @classmethod
+    def from_readings(cls, readings: Sequence[IntervalReading]) -> BillingPeriod:
+        """Infer the cycle from the data's own span."""
+        if not readings:
+            raise ValueError("cannot infer a billing period from no readings")
+        starts = [to_pacific(r.start) for r in readings]
+        return cls(min(starts).date(), max(starts).date())
+
+
+@dataclass(frozen=True, slots=True)
+class UsageBucket:
+    """Energy in one season and TOU period, at one rate.
+
+    Mirrors a printed bill line -- "Off Peak 22.903000 kWh @ $0.11878" -- so a
+    computed bill can be compared against a statement line by line.
+    """
+
+    season: Season
+    period: TouPeriod
+    imported: float = 0.0
+    exported: float = 0.0
+    import_charge: float = 0.0
+    export_credit: float = 0.0
+
+    @property
+    def import_rate(self) -> float | None:
+        """Effective $/kWh, or None when nothing was imported."""
+        return self.import_charge / self.imported if self.imported else None
+
+    @property
+    def export_rate(self) -> float | None:
+        return self.export_credit / self.exported if self.exported else None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "season": str(self.season),
+            "period": str(self.period),
+            "imported_kwh": round(self.imported, 6),
+            "exported_kwh": round(self.exported, 6),
+            "import_charge": round(self.import_charge, 4),
+            "export_credit": round(self.export_credit, 4),
+            "import_rate": None if self.import_rate is None else round(self.import_rate, 5),
+            "export_rate": None if self.export_rate is None else round(self.export_rate, 5),
+        }
+
+
+#: Per-kWh charges a statement prints as taxes rather than as energy charges.
+#: In ``import_components`` and in ``total``, but outside ``energy_charges``.
+TAX_COMPONENTS = frozenset({"energy_commission_tax"})
+
+
+@dataclass(frozen=True, slots=True)
+class Bill:
+    """A computed statement.
+
+    Charges are positive, credits negative, so every collection here sums
+    directly into ``total``.
+    """
+
+    period: BillingPeriod
+    buckets: tuple[UsageBucket, ...] = ()
+    #: Import charges by rate component, e.g. distribution, cca_generation.
+    import_components: dict[str, float] = field(default_factory=dict)
+    #: Export credits by component, e.g. delivery, cca_generation, acc_plus.
+    export_components: dict[str, float] = field(default_factory=dict)
+    #: Charges that do not scale with energy, e.g. the Base Services Charge.
+    fixed_components: dict[str, float] = field(default_factory=dict)
+    #: Set when the readings did not cover the period cleanly. Independent of
+    #: ``complete``: patchy meter data does not make the rates uncertain.
+    warnings: tuple[str, ...] = ()
+    #: False when any priced hour was itself incomplete or inexact -- a statement
+    #: about the *rates*, not the readings. A bill can be fully priced and still
+    #: carry coverage warnings, or cover the period perfectly and still be priced
+    #: from an unverified CCA export credit. Check both before trusting a total.
+    complete: bool = True
+
+    @property
+    def imported_kwh(self) -> float:
+        return sum(b.imported for b in self.buckets)
+
+    @property
+    def exported_kwh(self) -> float:
+        return sum(b.exported for b in self.buckets)
+
+    @property
+    def energy_charges(self) -> float:
+        """The per-kWh charges for energy, as a statement's own lines total.
+
+        Excludes statutory taxes, which are per-kWh but not energy charges and
+        print on their own line: the July 2026 statement's six energy lines come
+        to $8.90 and its Energy Commission Tax is separate. They are still in
+        ``import_components`` and still in ``total`` -- they are simply not what
+        this figure means.
+        """
+        return sum(
+            value for name, value in self.import_components.items() if name not in TAX_COMPONENTS
+        )
+
+    @property
+    def export_credits(self) -> float:
+        """Negative: credits reduce the bill."""
+        return sum(self.export_components.values())
+
+    @property
+    def fixed_charges(self) -> float:
+        return sum(self.fixed_components.values())
+
+    @property
+    def total(self) -> float:
+        return self.energy_charges + self.taxes + self.export_credits + self.fixed_charges
+
+    @property
+    def taxes(self) -> float:
+        """Statutory per-kWh charges, which a statement prints on their own line.
+
+        Separate from ``energy_charges`` because they are not charges for energy
+        and a statement does not total them with the energy lines -- but they are
+        owed, so they are in ``total``.
+        """
+        return sum(
+            value for name, value in self.import_components.items() if name in TAX_COMPONENTS
+        )
+
+    @property
+    def effective_import_rate(self) -> float | None:
+        """Blended $/kWh actually paid for energy, credits included.
+
+        Not a marginal rate -- do not dispatch on it.
+        """
+        return self.energy_charges / self.imported_kwh if self.imported_kwh else None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "period": self.period.to_dict(),
+            "imported_kwh": round(self.imported_kwh, 4),
+            "exported_kwh": round(self.exported_kwh, 4),
+            "buckets": [b.to_dict() for b in self.buckets],
+            "import_components": {k: round(v, 4) for k, v in self.import_components.items()},
+            "export_components": {k: round(v, 4) for k, v in self.export_components.items()},
+            "fixed_components": {k: round(v, 4) for k, v in self.fixed_components.items()},
+            "energy_charges": round(self.energy_charges, 2),
+            "export_credits": round(self.export_credits, 2),
+            "fixed_charges": round(self.fixed_charges, 2),
+            "total": round(self.total, 2),
+            "complete": self.complete,
+            "warnings": list(self.warnings),
+        }