tariffkit 0.2.0__py3-none-any.whl

tariffkit/config.py

@@ -0,0 +1,296 @@
+"""User-facing configuration."""
+
+from __future__ import annotations
+
+import json
+import os
+import tomllib
+from dataclasses import dataclass, field, replace
+from datetime import date, timedelta
+from pathlib import Path
+from typing import Any, Literal
+
+from .errors import ConfigError
+from .models import Supplier
+
+AccPlusSegment = Literal["residential", "residential_low_income", "none"]
+Discount = Literal["none", "care", "fera"]
+#: PG&E's Code B (basic) and Code H (all-electric) baseline quantity columns.
+BaselineCode = Literal["basic", "all_electric"]
+
+#: Interconnection-application year -> NBT vintage. Systems that do not qualify
+#: for a nine-year lock use the floating vintage, NBT00.
+VINTAGE_BY_YEAR = {
+    2023: "NBT23",
+    2024: "NBT24",
+    2025: "NBT25",
+    2026: "NBT26",
+}
+FLOATING_VINTAGE = "NBT00"
+
+LOCK_YEARS = 9
+_ONE_DAY = timedelta(days=1)
+
+
+@dataclass(frozen=True, slots=True)
+class CcaConfig:
+    """Settings for customers whose generation comes from a CCA or ESP.
+
+    PG&E still delivers, so the delivery half of both the import price and the
+    export credit continues to come from PG&E's tariff. Generation comes from
+    the CCA, and this package ships no CCA rate data -- supply it here.
+    """
+
+    name: str = ""
+    #: Vendored rate card to price generation from, e.g. ``"mce"``. Without one,
+    #: supply ``generation_rates`` directly.
+    rate_card: str | None = None
+    #: Product tier on that rate card, e.g. MCE's light_green / deep_green.
+    option: str = "light_green"
+    #: Vintage year for the PCIA the customer pays in place of the bundled PCIA.
+    pcia_vintage: int | None = None
+    #: PCIA in $/kWh, taken straight from a bill. Overrides ``pcia_vintage``,
+    #: which only covers the vintages published on the E-ELEC sheet.
+    pcia_rate: float | None = None
+    #: Schedule E-FFS franchise fee surcharge, $/kWh. Not published on the
+    #: E-ELEC sheet, so it must be supplied rather than guessed.
+    franchise_fee_surcharge: float | None = None
+    #: CCA generation charge by season and TOU period, e.g.
+    #: ``{"summer": {"peak": 0.123, ...}, "winter": {...}}``.
+    generation_rates: dict[str, dict[str, float]] = field(default_factory=dict)
+    #: Per-kWh export compensation the CCA pays, if any. Under NBT the PG&E
+    #: file's generation component does not apply to CCA customers.
+    export_generation_rate: float | None = None
+
+    @property
+    def complete(self) -> bool:
+        has_generation = bool(self.generation_rates) or self.rate_card is not None
+        # A PCIA vintage supplies both the PCIA and the matching E-FFS value
+        # from the vendored tariff sheet.  Requiring the surcharge to be copied
+        # into every profile made the otherwise valid ``rate_card + pcia_vintage``
+        # form look incomplete, even though RetailTariff can price it exactly.
+        has_pcia = self.pcia_rate is not None or self.pcia_vintage is not None
+        has_franchise_fee = (
+            self.franchise_fee_surcharge is not None or self.pcia_vintage is not None
+        )
+        return has_generation and has_pcia and has_franchise_fee
+
+
+@dataclass(frozen=True, slots=True)
+class Config:
+    """Everything needed to price a kWh for one service agreement."""
+
+    utility: str = "PGE"
+    tariff: str = "E-ELEC"
+    supplier: Supplier = Supplier.BUNDLED
+
+    #: Calendar year of the completed interconnection application. Selects both
+    #: the NBT vintage and the ACC Plus row.
+    interconnection_year: int | None = 2026
+    #: Permission-To-Operate date. Starts the nine-year rate lock.
+    pto_date: date | None = date(2026, 6, 3)
+    #: Overrides the vintage derived from ``interconnection_year``.
+    vintage: str | None = None
+
+    acc_plus_segment: AccPlusSegment = "residential"
+    discount: Discount = "none"
+    base_services_charge_tier: Literal[1, 2, 3] = 3
+
+    #: Baseline territory letter, printed on the bill as e.g. "Baseline
+    #: Territory X". Only schedules with a baseline allowance use it -- E-TOU-C
+    #: among those vendored -- and only when computing a whole bill.
+    baseline_territory: str | None = None
+    #: "basic" for a gas-heated home, "all_electric" where space heating is
+    #: electric. PG&E prints this as Code B or Code H; the bill's "Heat Source"
+    #: line says which.
+    baseline_code: BaselineCode = "basic"
+
+    cca: CcaConfig | None = None
+
+    #: Net Surplus Compensation rate, $/kWh, for the annual true-up.
+    #:
+    #: Left unset because for a CCA account nobody publishes one in advance: MCE
+    #: determines its Solar Billing Plan rate at cash-out. When this is ``None``
+    #: the true-up falls back to PG&E's published series as a stand-in and marks
+    #: the result estimated. Set it once a real cash-out statement says what was
+    #: actually paid.
+    nsc_rate: float | None = None
+
+    def __post_init__(self) -> None:
+        # Coerce the string forms of the enums. Supplier is a StrEnum, so a
+        # plain "cca" compares equal to Supplier.CCA but is not it -- and every
+        # branch that matters tests identity. Constructing Config directly with
+        # a string therefore priced a CCA customer as bundled, silently and with
+        # entirely plausible numbers. from_dict already coerced; direct
+        # construction did not, which is the path library callers take.
+        # Written through the value rather than as an isinstance guard: the
+        # annotation promises a Supplier, so mypy reads any such guard as dead
+        # code. That promise is exactly what is not enforced at runtime -- a
+        # caller passing "cca" got a str, which compares equal to Supplier.CCA
+        # but is not it, and every branch that matters tests identity.
+        # Supplier(Supplier.CCA) is Supplier.CCA, so this is a no-op when the
+        # annotation was honoured and a coercion when it was not.
+        object.__setattr__(self, "supplier", Supplier(self.supplier))
+        if self.supplier is Supplier.CCA and self.cca is None:
+            raise ConfigError("supplier='cca' requires a CcaConfig")
+        if self.vintage is None and self.interconnection_year is None:
+            raise ConfigError("set either interconnection_year or vintage")
+        if self.discount != "none" and self.acc_plus_segment == "residential":
+            # CARE/FERA customers qualify for the much larger low-income ACC
+            # Plus adder; silently applying the standard one would understate
+            # the export credit by several cents per kWh.
+            raise ConfigError(
+                f"discount={self.discount!r} implies acc_plus_segment="
+                "'residential_low_income'; set it explicitly"
+            )
+
+    @property
+    def resolved_vintage(self) -> str:
+        """The NBT vintage whose matrix applies to this customer."""
+        if self.vintage is not None:
+            return self.vintage
+        assert self.interconnection_year is not None
+        return VINTAGE_BY_YEAR.get(self.interconnection_year, FLOATING_VINTAGE)
+
+    @property
+    def lock_end(self) -> date | None:
+        """Last date covered by the nine-year rate lock, inclusive.
+
+        ``None`` for a floating (NBT00) customer, who has no lock at all.
+        """
+        if self.pto_date is None or self.resolved_vintage == FLOATING_VINTAGE:
+            return None
+        return self.pto_date.replace(year=self.pto_date.year + LOCK_YEARS) - _ONE_DAY
+
+    def with_(self, **changes: Any) -> Config:
+        return replace(self, **changes)
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any]) -> Config:
+        data = dict(raw)
+        unknown = set(data) - {f.name for f in cls.__dataclass_fields__.values()}
+        if unknown:
+            raise ConfigError(f"unknown config keys: {sorted(unknown)}")
+        try:
+            cca_value = data.get("cca")
+            if isinstance(cca_value, dict):
+                cca_raw = cca_value
+                unknown_cca = set(cca_raw) - {
+                    f.name for f in CcaConfig.__dataclass_fields__.values()
+                }
+                if unknown_cca:
+                    raise ConfigError(f"unknown CCA config keys: {sorted(unknown_cca)}")
+                data["cca"] = CcaConfig(**cca_raw)
+            elif cca_value is not None and not isinstance(cca_value, CcaConfig):
+                raise ConfigError("cca must be an object")
+            if "supplier" in data:
+                data["supplier"] = Supplier(data["supplier"])
+            value = data.get("pto_date")
+            if isinstance(value, str):
+                data["pto_date"] = date.fromisoformat(value)
+            return cls(**data)
+        except (TypeError, ValueError) as exc:
+            raise ConfigError(f"invalid config: {exc}") from exc
+
+    def to_dict(self) -> dict[str, Any]:
+        """A JSON-compatible representation suitable for API request bodies."""
+        data: dict[str, Any] = {
+            "utility": self.utility,
+            "tariff": self.tariff,
+            "supplier": self.supplier.value,
+            "interconnection_year": self.interconnection_year,
+            "pto_date": self.pto_date.isoformat() if self.pto_date else None,
+            "vintage": self.vintage,
+            "acc_plus_segment": self.acc_plus_segment,
+            "discount": self.discount,
+            "base_services_charge_tier": self.base_services_charge_tier,
+            "baseline_territory": self.baseline_territory,
+            "baseline_code": self.baseline_code,
+            "nsc_rate": self.nsc_rate,
+        }
+        if self.cca is not None:
+            data["cca"] = {
+                "name": self.cca.name,
+                "rate_card": self.cca.rate_card,
+                "option": self.cca.option,
+                "pcia_vintage": self.cca.pcia_vintage,
+                "pcia_rate": self.cca.pcia_rate,
+                "franchise_fee_surcharge": self.cca.franchise_fee_surcharge,
+                "generation_rates": self.cca.generation_rates,
+                "export_generation_rate": self.cca.export_generation_rate,
+            }
+        return data
+
+    @classmethod
+    def from_toml(cls, path: str | Path) -> Config:
+        with Path(path).open("rb") as handle:
+            table = tomllib.load(handle)
+        # The shared user config also carries integration settings such as the
+        # default account profile and MQTT broker. They are not pricing fields
+        # and must not make a stateless Config unusable.
+        for section in ("account", "mqtt", "home_assistant", "influxdb"):
+            table.pop(section, None)
+        for key in ("profile", "default_profile", "account_profile"):
+            table.pop(key, None)
+        return cls.from_dict(table)
+
+    @classmethod
+    def from_env(cls, base: Config | None = None) -> Config:
+        """Overlay ``TARIFFKIT_*`` environment variables onto ``base``."""
+        config = base or cls()
+        overrides: dict[str, Any] = {}
+        if value := os.environ.get("TARIFFKIT_UTILITY"):
+            overrides["utility"] = value
+        if value := os.environ.get("TARIFFKIT_TARIFF"):
+            overrides["tariff"] = value
+        if value := os.environ.get("TARIFFKIT_SUPPLIER"):
+            overrides["supplier"] = Supplier(value)
+        if value := os.environ.get("TARIFFKIT_VINTAGE"):
+            overrides["vintage"] = value
+        if value := os.environ.get("TARIFFKIT_INTERCONNECTION_YEAR"):
+            overrides["interconnection_year"] = int(value)
+        if value := os.environ.get("TARIFFKIT_PTO_DATE"):
+            overrides["pto_date"] = date.fromisoformat(value)
+        if value := os.environ.get("TARIFFKIT_ACC_PLUS_SEGMENT"):
+            overrides["acc_plus_segment"] = value
+        if value := os.environ.get("TARIFFKIT_DISCOUNT"):
+            overrides["discount"] = value
+        if value := os.environ.get("TARIFFKIT_BSC_TIER"):
+            overrides["base_services_charge_tier"] = int(value)
+        if value := os.environ.get("TARIFFKIT_BASELINE_TERRITORY"):
+            overrides["baseline_territory"] = value
+        if value := os.environ.get("TARIFFKIT_BASELINE_CODE"):
+            overrides["baseline_code"] = value
+        if value := os.environ.get("TARIFFKIT_NSC_RATE"):
+            overrides["nsc_rate"] = float(value)
+        if value := os.environ.get("TARIFFKIT_CCA_JSON"):
+            try:
+                cca_raw = json.loads(value)
+            except json.JSONDecodeError as exc:
+                raise ConfigError("TARIFFKIT_CCA_JSON is not valid JSON") from exc
+            if not isinstance(cca_raw, dict):
+                raise ConfigError("TARIFFKIT_CCA_JSON must be a JSON object")
+            unknown_cca = set(cca_raw) - {f.name for f in CcaConfig.__dataclass_fields__.values()}
+            if unknown_cca:
+                raise ConfigError(f"unknown CCA config keys: {sorted(unknown_cca)}")
+            overrides["cca"] = CcaConfig(**cca_raw)
+        return replace(config, **overrides) if overrides else config
+
+    @classmethod
+    def load(cls, path: str | Path | None = None) -> Config:
+        """Load from ``path``, else the default config file, else defaults.
+
+        Environment variables overlay whichever source is used.
+        """
+        if path is not None:
+            return cls.from_env(cls.from_toml(path))
+        default = default_config_path()
+        if default.is_file():
+            return cls.from_env(cls.from_toml(default))
+        return cls.from_env()
+
+
+def default_config_path() -> Path:
+    root = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(root) if root else Path.home() / ".config"
+    return base / "tariffkit" / "config.toml"

tariffkit/data/__init__.py

@@ -0,0 +1,40 @@
+"""Access to the vendored rate data shipped inside the package."""
+
+from __future__ import annotations
+
+import gzip
+import json
+from importlib.resources import files
+from typing import Any
+
+from ..errors import DataError
+
+
+def _resource(relative: str) -> Any:
+    resource = files(__package__)
+    for part in relative.split("/"):
+        resource = resource / part
+    return resource
+
+
+def read_data_text(relative: str) -> str:
+    """Read a text data file, e.g. ``holidays.toml``."""
+    try:
+        text: str = _resource(relative).read_text(encoding="utf-8")
+        return text
+    except FileNotFoundError as exc:
+        raise DataError(f"vendored data file missing: {relative}") from exc
+
+
+def read_data_json_gz(relative: str) -> dict[str, Any]:
+    """Read a gzipped JSON data file, e.g. ``export/pge/nbt26.json.gz``."""
+    try:
+        raw = _resource(relative).read_bytes()
+    except FileNotFoundError as exc:
+        raise DataError(f"vendored data file missing: {relative}") from exc
+    payload: dict[str, Any] = json.loads(gzip.decompress(raw))
+    return payload
+
+
+def data_exists(relative: str) -> bool:
+    return bool(_resource(relative).is_file())

tariffkit/data/cca/mce/2023-01-01.toml

@@ -0,0 +1,61 @@
+# Marin Clean Energy (MCE) residential generation rates.
+#
+# Source: https://mcecleanenergy.org/wp-content/uploads/2025/09/MCE-website-rate-table_RES_as-of-4.1.26.pdf
+# Solar Billing Plan tariff: https://mcecleanenergy.org/wp-content/uploads/2024/12/MCE-Solar-Billing-Plan-Tariff_120424.pdf
+#
+# GENERATED by `python -m tools.regen cca` -- do not hand-edit the rate tables.
+#
+# A CCA supplies generation only; delivery stays with the utility, so these
+# are generation rates alone and pair with that utility's tariff sheet.
+#
+# These may currently equal the utility's own generation component exactly.
+# That is parity today, not an alias: they are vendored separately so a
+# divergence shows up rather than being silently inherited. Regeneration
+# reports the parity status of every rate it writes.
+
+schema = 1
+provider = "MCE"
+name = "Marin Clean Energy"
+utility = "PGE"
+schedules = ["E-ELEC", "E-TOU-C", "EV2-A"]
+effective = "2023-01-01"
+currency = "USD/kWh"
+source_url = "https://mcecleanenergy.org/wp-content/uploads/2025/09/MCE-website-rate-table_RES_as-of-4.1.26.pdf"
+
+# Checksum of the document these values were read from. A scheduled check
+# compares it so a republished card is noticed even when it cannot be
+# parsed -- detection does not need a text layer, only bytes.
+source_sha256 = "db92362d02205c24ccaed4c42e5508d5f4fd7077226b88cea3900acec9c55270"
+source_read_on = "2026-08-12"
+
+[options]
+light_green = 0.0
+deep_green = 0.01
+
+[generation.eelec.summer]
+peak = 0.301
+part_peak = 0.199
+off_peak = 0.152
+
+[generation.eelec.winter]
+peak = 0.134
+part_peak = 0.113
+off_peak = 0.099
+
+[generation.etouc.summer]
+peak = 0.195
+off_peak = 0.144
+
+[generation.etouc.winter]
+peak = 0.149
+off_peak = 0.135
+
+[generation.ev2a.summer]
+peak = 0.21
+part_peak = 0.167
+off_peak = 0.128
+
+[generation.ev2a.winter]
+peak = 0.155
+part_peak = 0.144
+off_peak = 0.121

tariffkit/data/cca/mce/2026-04-01.toml

@@ -0,0 +1,152 @@
+# MCE (Marin Clean Energy) residential generation rates.
+#
+# Source: MCE Light Green Residential Rates, effective April 1, 2026
+#   https://mcecleanenergy.org/wp-content/uploads/2025/09/MCE-website-rate-table_RES_as-of-4.1.26.pdf
+# Solar Billing Plan tariff (effective 2023-12-01, rev. 2024-12-04):
+#   https://mcecleanenergy.org/wp-content/uploads/2024/12/MCE-Solar-Billing-Plan-Tariff_120424.pdf
+#
+# HOW THESE WERE READ.
+#
+# The rate card is a "Microsoft: Print To PDF" export of a spreadsheet with no
+# text layer -- pdftotext, pdffonts and pypdf all come back empty, and its font
+# maps six characters to Unicode, enough to spell "Page 1". The page renders
+# perfectly, so the table is READ FROM THE RENDERED PAGE rather than parsed.
+# That is a supported way to maintain this file, not a failure: what is lost is
+# the automated extraction, not the source.
+#
+# `python -m tools.regen cca` therefore cannot rebuild this file inside a CI runner,
+# which has no reader -- but an agent session renders the page and reads it, so
+# the file is still maintainable without anyone transcribing by hand. CI detects
+# a republished card by checksum and leaves the reading to such a session. The
+# extractor exists and reads MCE's 2023 card exactly, and takes over the day
+# they publish text again.
+#
+# VERIFICATION. Every one of the 16 generation rates below was checked against
+# the rendered card on 2026-08-12 and matched. So were the cost relief credit
+# (-0.0062, through 2026-12-31) and the Deep Green premium (+0.0125).
+#
+# Three of them are independently confirmed a second way, against the July 2026
+# statement -- summer E-ELEC peak 0.26299, part-peak 0.16388, off-peak 0.11878
+# (tests/test_mce.py::test_generation_matches_the_billed_rate). The remaining
+# thirteen rest on the card alone, since no bill has exercised them yet; winter
+# first applies in October 2026.
+#
+# What this file does NOT have, unlike a PG&E snapshot, is an arithmetic check:
+# there is no published total for its components to sum to. Re-read the card
+# against these values when it changes.
+#
+# MCE calls the schedule "ELEC - Residential Time-of-Use for Qualified Electric
+# Technologies"; it pairs with PG&E's E-ELEC delivery service and appears on
+# bills as "SBP EELEC" for Solar Billing Plan customers.
+#
+# NOTE: every one of these values is currently IDENTICAL to PG&E's bundled
+# generation component. That is an OBSERVATION from the rendered card, not an
+# alias and not an assumption -- MCE prices at parity today. They are vendored
+# separately because nothing guarantees that continues, and a future divergence
+# must not go unnoticed. tests/test_mce.py asserts the parity so it fails loudly
+# if MCE moves.
+
+schema = 1
+provider = "MCE"
+name = "Marin Clean Energy"
+utility = "PGE"
+#: MCE prices each PG&E schedule separately, so a rate card is keyed by schedule
+#: rather than tied to one. Slugs match the tariff data directories.
+schedules = ["E-ELEC", "E-TOU-C", "EV2-A"]
+effective = "2026-04-01"
+currency = "USD/kWh"
+source_url = "https://mcecleanenergy.org/compare-rates-and-options/"
+
+# Checksum of the rate card these values were read from. This card has no text
+# layer, so it cannot be re-parsed -- but a scheduled check compares these bytes
+# and says whether MCE has republished, which is the half that matters. Silence
+# means the publisher has not moved, not that nobody looked.
+source_sha256 = "0c0ff13aa015eeb27fb8067e434e669a4ecfe4a2995af6f4bc2146f7465b1036"
+source_read_on = "2026-08-12"
+
+# TOU periods and season boundaries follow each PG&E schedule exactly, including
+# E-TOU-C having no part-peak at all.
+#
+# Every rate below is IDENTICAL to PG&E's generation component for the same
+# schedule, season and period. That is not an alias and not an error -- MCE
+# prices at parity today. They are vendored separately because nothing
+# guarantees that continues, and tests/test_mce.py asserts the parity so a
+# divergence fails loudly rather than going unnoticed.
+#
+# Keyed by schedule because the rates differ substantially between them: MCE
+# winter off-peak is 0.06754 on ELEC and 0.11042 on ETOUC. Applying one
+# schedule's card to another understates or overstates generation by ~2x, so an
+# uncovered schedule raises rather than falling back.
+
+[generation.eelec.summer]
+peak = 0.26299
+part_peak = 0.16388
+off_peak = 0.11878
+
+[generation.eelec.winter]
+peak = 0.10086
+part_peak = 0.08089
+off_peak = 0.06754
+
+# ETOUC/EMTOUC on MCE's table. No part-peak, matching PG&E's E-TOU-C.
+[generation.etouc.summer]
+peak = 0.20782
+off_peak = 0.10482
+
+[generation.etouc.winter]
+peak = 0.13710
+off_peak = 0.11042
+
+# EV2 on MCE's table, for PG&E's EV2-A.
+[generation.ev2a.summer]
+peak = 0.18830
+part_peak = 0.14359
+off_peak = 0.10245
+
+[generation.ev2a.winter]
+peak = 0.13143
+part_peak = 0.11894
+off_peak = 0.09546
+
+# Applied to all generation kWh. Explicitly time-limited -- the rate card says
+# "Runs through December 31, 2026" -- so it is dated rather than folded into the
+# rates above, and stops applying on its own afterwards.
+[cost_relief_credit]
+rate = -0.00620
+through = "2026-12-31"
+
+# Deep Green (100% renewable) costs the Light Green rate plus this adder.
+[options]
+light_green = 0.0
+deep_green = 0.0125
+
+[export]
+# "All customers will also receive a Solar Bonus Credit which provides an
+# additional 10% of the base export credit." -- SBP tariff section 1.
+solar_bonus_fraction = 0.10
+
+# CARE/FERA customers only, on all exports, additional to the above.
+care_fera_bonus_rate = 0.05
+care_fera_bonus_through = "2028-12-31"
+
+# MCE does not publish a machine-readable Energy Export Credit matrix; the
+# tariff says only that exports are credited at "the applicable Energy Export
+# Credit Value, which reflects the value of power to the grid at any given
+# time". Whether that equals the CPUC Avoided Cost Calculator generation
+# component (PG&E's USCA-XXPG series) was long unverified.
+#
+# It is now measured. Priced against 2,784 quarter-hourly meter intervals for the
+# 2026-06-30..2026-07-28 cycle and compared with the statement for that cycle,
+# every export component lands within 0.3% -- inside the rounding of the bill's
+# own displayed dollars:
+#
+#   MCE generation EEC   library $9.618   billed $9.63   -0.1%
+#   PG&E delivery EEC            $6.236          $6.25   -0.2%
+#   ACC Plus bonus               $1.705          $1.71   -0.3%
+#   MCE 10% solar bonus          $0.962          $0.96   +0.2%
+#
+# One summer cycle on one account, so the seasonal spread is untested; the claim
+# it supports is structural (MCE credits exports at the ACC generation component)
+# and 193 kWh spread across all three TOU periods is a fair test of that.
+export_credit_basis = "acc_generation"
+export_credit_verified = true

tariffkit/data/export/pge/acc_plus/2023-04-15.toml

@@ -0,0 +1,43 @@
+# ACC Plus adder, Pacific Gas and Electric Schedule NBT.
+#
+# Source: https://www.pge.com/tariffs/assets/pdf/tariffbook/ELEC_SCHEDS_NBT.pdf
+#
+# GENERATED by `python -m tools.regen accplus` -- do not hand-edit.
+#
+# This is NOT present in the export-rate data files -- every row there
+# carries Sector=ALL with no customer-class differentiation -- so it is
+# read from the tariff and added on top.
+#
+# Keyed by the calendar year of the completed interconnection application,
+# then held CONSTANT for nine years from the Permission-To-Operate date.
+# The year-over-year decline below is a step-down for later applicants, not
+# a decay applied to an existing customer.
+#
+# Unlike ordinary export credits, ACC Plus applies to all charges including
+# non-bypassable charges, does not expire, and is cashed out on account
+# closure.
+
+schema = 1
+# When this version of the adder table took force. The Net Billing Tariff opened
+# on 2023-04-15 and the five-year step-down has been published unchanged since,
+# so there is one vintage -- but it is dated, because a revision must be able to
+# sit beside it rather than overwrite it.
+effective = "2023-04-15"
+unit = "USD/kWh"
+source = "Pacific Gas and Electric Schedule NBT"
+
+[residential]
+2023 = 0.02200
+2024 = 0.01760
+2025 = 0.01320
+2026 = 0.00880
+2027 = 0.00440
+
+[residential_low_income]
+2023 = 0.09000
+2024 = 0.07200
+2025 = 0.05400
+2026 = 0.03600
+2027 = 0.01800
+
+# Non-residential customers are not eligible for ACC Plus.

tariffkit/data/holidays.toml

@@ -0,0 +1,36 @@
+# Generated by `python -m tools.regen.export` -- do not edit by hand.
+#
+# Extracted from the DayStart==8 rows of PG&E's NBT export-rate files, so
+# the observed-date rules (Saturday -> preceding Friday, Sunday -> following
+# Monday) come from the source rather than being reimplemented here.
+# These eight holidays affect the EXPORT day type only; E-ELEC import
+# pricing makes no weekday/weekend/holiday distinction at all.
+#
+# This is the INTERSECTION across the vintage files covering each year.
+# They agree through 2036; beyond that NBT25/26/00 duplicate some holidays
+# onto the following day, and intersecting drops those artifacts. Export
+# lookups use the per-vintage calendar embedded in each matrix instead.
+
+[holidays]
+2024 = ["2024-01-01", "2024-02-19", "2024-05-27", "2024-07-04", "2024-09-02", "2024-11-11", "2024-11-28", "2024-12-25"]
+2025 = ["2025-01-01", "2025-02-17", "2025-05-26", "2025-07-04", "2025-09-01", "2025-11-11", "2025-11-27", "2025-12-25"]
+2026 = ["2026-01-01", "2026-02-16", "2026-05-25", "2026-07-03", "2026-09-07", "2026-11-11", "2026-11-26", "2026-12-25"]
+2027 = ["2027-01-01", "2027-02-15", "2027-05-31", "2027-07-05", "2027-09-06", "2027-11-11", "2027-11-25", "2027-12-24", "2027-12-31"]
+2028 = ["2028-02-21", "2028-05-29", "2028-07-04", "2028-09-04", "2028-11-10", "2028-11-23", "2028-12-25"]
+2029 = ["2029-01-01", "2029-02-19", "2029-05-28", "2029-07-04", "2029-09-03", "2029-11-12", "2029-11-22", "2029-12-25"]
+2030 = ["2030-01-01", "2030-02-18", "2030-05-27", "2030-07-04", "2030-09-02", "2030-11-11", "2030-11-28", "2030-12-25"]
+2031 = ["2031-01-01", "2031-02-17", "2031-05-26", "2031-07-04", "2031-09-01", "2031-11-11", "2031-11-27", "2031-12-25"]
+2032 = ["2032-01-01", "2032-02-16", "2032-05-31", "2032-07-05", "2032-09-06", "2032-11-11", "2032-11-25", "2032-12-24", "2032-12-31"]
+2033 = ["2033-02-21", "2033-05-30", "2033-07-04", "2033-09-05", "2033-11-11", "2033-11-24", "2033-12-26"]
+2034 = ["2034-01-02", "2034-02-20", "2034-05-29", "2034-07-04", "2034-09-04", "2034-11-10", "2034-11-23", "2034-12-25"]
+2035 = ["2035-01-01", "2035-02-19", "2035-05-28", "2035-07-04", "2035-09-03", "2035-11-12", "2035-11-22", "2035-12-25"]
+2036 = ["2036-01-01", "2036-02-18", "2036-05-26", "2036-07-04", "2036-09-01", "2036-11-11", "2036-11-27", "2036-12-25"]
+2037 = ["2037-01-01", "2037-02-16", "2037-05-25", "2037-07-03", "2037-09-07", "2037-11-11", "2037-11-26", "2037-12-25"]
+2038 = ["2038-01-01", "2038-02-15", "2038-05-31", "2038-07-05", "2038-09-06", "2038-11-11", "2038-11-25", "2038-12-24", "2038-12-31"]
+2039 = ["2039-02-21", "2039-05-30", "2039-07-04", "2039-09-05", "2039-11-11", "2039-11-24", "2039-12-26"]
+2040 = ["2040-01-02", "2040-02-20", "2040-05-28", "2040-07-04", "2040-09-03", "2040-11-12", "2040-11-22", "2040-12-25"]
+2041 = ["2041-01-01", "2041-02-18", "2041-05-27", "2041-07-04", "2041-09-02", "2041-11-11", "2041-11-28", "2041-12-25"]
+2042 = ["2042-01-01", "2042-02-17", "2042-05-26", "2042-07-04", "2042-09-01", "2042-11-11", "2042-11-27", "2042-12-25"]
+2043 = ["2043-01-01", "2043-02-16", "2043-05-25", "2043-07-03", "2043-09-07", "2043-11-11", "2043-11-26", "2043-12-25"]
+2044 = ["2044-01-01", "2044-02-15", "2044-05-30", "2044-05-31", "2044-07-04", "2044-07-05", "2044-09-05", "2044-09-06", "2044-11-11", "2044-11-24", "2044-12-26"]
+2045 = ["2045-01-02", "2045-02-20", "2045-05-29", "2045-05-30", "2045-07-04", "2045-07-05", "2045-09-04", "2045-09-05", "2045-11-10", "2045-11-23", "2045-12-25"]