greentrain 0.1.0__py3-none-any.whl

greentrain/__init__.py

@@ -0,0 +1,110 @@
+"""greentrain: low-carbon AI training service built on iroh-tinker.
+
+greentrain places a training workload on the lowest-carbon tier that still
+meets the customer's accuracy and latency targets, runs it through
+iroh-tinker's multi-cloud launch, and emits an auditable carbon report.
+
+Trust rule: every energy and carbon number carries a provenance label
+(``measured`` or ``estimated``). An unlabelled carbon claim is a liability.
+"""
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .carbon import (
+    CarbonIntensity,
+    IntensityError,
+    JobCarbon,
+    ProvenanceViolation,
+    carbon_kg_from_kwh,
+    check_provenance,
+    compute_carbon,
+    energy_kwh,
+    load_intensity,
+    lookup_intensity,
+    parse_intensity_csv,
+)
+from .power import (
+    TIER_POWER_MODELS,
+    EstimatedTierPowerReader,
+    ExternalMeterPowerReader,
+    NvidiaSmiPowerReader,
+    PowerReader,
+    PowerReading,
+    PowerUnavailable,
+    Provenance,
+    RaplPowerReader,
+    TierPowerModel,
+    average_watts,
+    combine_provenance,
+    detect_local_tier,
+    select_power_reader,
+)
+from .report import (
+    CarbonReport,
+    build_report,
+    render_json,
+    render_markdown,
+    render_prometheus,
+    report_from_dict,
+)
+from .runner import GreenTrainRunner, RunResult, Workload
+from .subnet import (
+    TIER_CAPABILITIES,
+    NoFeasibleTier,
+    SubnetSelector,
+    Targets,
+    TierCandidate,
+    TierCapability,
+    TierPlan,
+)
+
+__all__ = [
+    "__version__",
+    # power
+    "PowerReader",
+    "PowerReading",
+    "PowerUnavailable",
+    "Provenance",
+    "NvidiaSmiPowerReader",
+    "RaplPowerReader",
+    "EstimatedTierPowerReader",
+    "ExternalMeterPowerReader",
+    "TIER_POWER_MODELS",
+    "TierPowerModel",
+    "average_watts",
+    "combine_provenance",
+    "detect_local_tier",
+    "select_power_reader",
+    # carbon
+    "CarbonIntensity",
+    "IntensityError",
+    "JobCarbon",
+    "ProvenanceViolation",
+    "carbon_kg_from_kwh",
+    "check_provenance",
+    "compute_carbon",
+    "energy_kwh",
+    "load_intensity",
+    "lookup_intensity",
+    "parse_intensity_csv",
+    # subnet
+    "SubnetSelector",
+    "Targets",
+    "TierCandidate",
+    "TierCapability",
+    "TierPlan",
+    "TIER_CAPABILITIES",
+    "NoFeasibleTier",
+    # report
+    "CarbonReport",
+    "build_report",
+    "render_json",
+    "render_markdown",
+    "render_prometheus",
+    "report_from_dict",
+    # runner
+    "GreenTrainRunner",
+    "RunResult",
+    "Workload",
+]

greentrain/carbon.py

@@ -0,0 +1,311 @@
+"""Carbon accounting with per-number provenance.
+
+Accounting is deliberately trivial and auditable:
+
+    energy_kwh   = average_watts * duration_s / 3_600_000
+    carbon_kg    = energy_kwh * intensity_gco2_per_kwh / 1000
+
+The interesting part is not the arithmetic, it is the labels. Every number
+that reaches a report carries a :class:`~greentrain.power.Provenance`:
+
+* ``energy_provenance`` comes from the power reading.
+* ``carbon_provenance`` is ``measured`` only when the energy *and* the grid
+  intensity were both measured. A modelled energy figure or a dataset
+  intensity always downgrades the carbon figure to ``estimated``.
+
+:func:`check_provenance` enforces that invariant and raises
+:class:`ProvenanceViolation` when it is broken.
+"""
+from __future__ import annotations
+
+import csv
+import datetime as _dt
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .power import Provenance
+
+__all__ = [
+    "CarbonIntensity",
+    "IntensityError",
+    "JobCarbon",
+    "ProvenanceViolation",
+    "carbon_kg_from_kwh",
+    "check_provenance",
+    "compute_carbon",
+    "default_intensity_path",
+    "energy_kwh",
+    "load_intensity",
+    "lookup_intensity",
+    "parse_intensity_csv",
+]
+
+JOULES_PER_KWH = 3_600_000.0
+GRAMS_PER_KG = 1000.0
+
+DEFAULT_INTENSITY_PATH = Path(__file__).with_name("data") / "carbon_intensity.csv"
+
+_INTENSITY_COLUMNS = ("region", "provider", "gco2_per_kwh", "provenance", "retrieved", "source")
+
+
+class IntensityError(ValueError):
+    """Raised when a carbon-intensity row is missing required provenance."""
+
+
+class ProvenanceViolation(RuntimeError):
+    """Raised when a label claims more than the underlying data supports."""
+
+
+@dataclass(frozen=True)
+class CarbonIntensity:
+    """Grid carbon intensity for one region."""
+
+    region: str
+    gco2_per_kwh: float
+    provenance: Provenance = Provenance.ESTIMATED
+    provider: str = ""
+    retrieved: str = ""
+    source: str = ""
+
+    def __post_init__(self) -> None:
+        if self.gco2_per_kwh < 0:
+            raise ValueError(f"gco2_per_kwh must be >= 0, got {self.gco2_per_kwh}")
+        if not self.region:
+            raise ValueError("region must be a non-empty string")
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "region": self.region,
+            "gco2_per_kwh": self.gco2_per_kwh,
+            "provenance": self.provenance.value,
+            "provider": self.provider,
+            "retrieved": self.retrieved,
+            "source": self.source,
+        }
+
+
+@dataclass(frozen=True)
+class JobCarbon:
+    """The carbon footprint of one job, with the label for every number."""
+
+    job_id: str
+    region: str
+    device_type: str
+    device_count: int
+    duration_s: float
+    energy_kwh: float
+    carbon_kg: float
+    intensity_gco2_per_kwh: float
+    energy_provenance: Provenance
+    carbon_provenance: Provenance
+    power_source: str = ""
+    notes: tuple[str, ...] = ()
+
+    @property
+    def measured(self) -> bool:
+        return self.carbon_provenance is Provenance.MEASURED
+
+    @property
+    def gco2(self) -> float:
+        return self.carbon_kg * GRAMS_PER_KG
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "job_id": self.job_id,
+            "region": self.region,
+            "device_type": self.device_type,
+            "device_count": self.device_count,
+            "duration_s": round(self.duration_s, 3),
+            "energy_kwh": self.energy_kwh,
+            "carbon_kg": self.carbon_kg,
+            "gco2": self.gco2,
+            "intensity_gco2_per_kwh": self.intensity_gco2_per_kwh,
+            "energy_provenance": self.energy_provenance.value,
+            "carbon_provenance": self.carbon_provenance.value,
+            "power_source": self.power_source,
+            "notes": list(self.notes),
+        }
+
+
+def energy_kwh(average_watts: float, duration_s: float) -> float:
+    """Convert an average power and a duration into kWh."""
+    if average_watts < 0:
+        raise ValueError(f"average_watts must be >= 0, got {average_watts}")
+    if duration_s < 0:
+        raise ValueError(f"duration_s must be >= 0, got {duration_s}")
+    return (average_watts * duration_s) / JOULES_PER_KWH
+
+
+def carbon_kg_from_kwh(kwh: float, gco2_per_kwh: float) -> float:
+    """Convert energy plus grid intensity into kgCO2e."""
+    if kwh < 0:
+        raise ValueError(f"kwh must be >= 0, got {kwh}")
+    if gco2_per_kwh < 0:
+        raise ValueError(f"gco2_per_kwh must be >= 0, got {gco2_per_kwh}")
+    return (kwh * gco2_per_kwh) / GRAMS_PER_KG
+
+
+def compute_carbon(
+    *,
+    job_id: str,
+    region: str,
+    device_type: str,
+    device_count: int,
+    duration_s: float,
+    average_watts: float,
+    energy_provenance: Provenance,
+    power_source: str = "",
+    intensity: CarbonIntensity,
+    notes: Iterable[str] = (),
+) -> JobCarbon:
+    """Build a :class:`JobCarbon` with consistent provenance labels."""
+    kwh = energy_kwh(average_watts, duration_s)
+    kg = carbon_kg_from_kwh(kwh, intensity.gco2_per_kwh)
+
+    note_list = list(notes)
+    if energy_provenance is Provenance.MEASURED and intensity.provenance is Provenance.MEASURED:
+        carbon_provenance = Provenance.MEASURED
+    else:
+        carbon_provenance = Provenance.ESTIMATED
+        if energy_provenance is Provenance.ESTIMATED:
+            note_list.append(
+                "energy is estimated from a tier power model, so the carbon figure is estimated"
+            )
+        if intensity.provenance is Provenance.ESTIMATED:
+            note_list.append(
+                "grid carbon intensity is an estimated dataset value, "
+                "so the carbon figure is estimated"
+            )
+
+    job = JobCarbon(
+        job_id=job_id,
+        region=region,
+        device_type=device_type,
+        device_count=device_count,
+        duration_s=duration_s,
+        energy_kwh=kwh,
+        carbon_kg=kg,
+        intensity_gco2_per_kwh=intensity.gco2_per_kwh,
+        energy_provenance=energy_provenance,
+        carbon_provenance=carbon_provenance,
+        power_source=power_source,
+        notes=tuple(note_list),
+    )
+    check_provenance(job)
+    return job
+
+
+def check_provenance(job: JobCarbon) -> None:
+    """Raise if a job claims more certainty than its inputs support."""
+    if job.carbon_provenance is Provenance.MEASURED:
+        if job.energy_provenance is not Provenance.MEASURED:
+            raise ProvenanceViolation(
+                f"job {job.job_id!r} reports measured carbon from estimated energy"
+            )
+    if job.energy_kwh < 0 or job.carbon_kg < 0:
+        raise ProvenanceViolation(f"job {job.job_id!r} reports a negative footprint")
+
+
+def default_intensity_path() -> Path:
+    """Path of the bundled carbon-intensity table."""
+    return DEFAULT_INTENSITY_PATH
+
+
+def parse_intensity_csv(text: str) -> dict[str, CarbonIntensity]:
+    """Parse the intensity table.
+
+    Rows without a retrieval date are rejected: an undated intensity cannot be
+    audited, and the provenance contract does not allow shipping one.
+    """
+    out: dict[str, CarbonIntensity] = {}
+    reader = csv.DictReader(
+        line for line in text.splitlines() if line.strip() and not line.lstrip().startswith("#")
+    )
+    if reader.fieldnames is None:
+        raise IntensityError("carbon intensity table is empty")
+    missing = [c for c in _INTENSITY_COLUMNS if c not in reader.fieldnames]
+    if missing:
+        raise IntensityError(f"carbon intensity table is missing columns: {', '.join(missing)}")
+
+    for lineno, row in enumerate(reader, start=2):
+        region = (row.get("region") or "").strip()
+        if not region:
+            raise IntensityError(f"line {lineno}: region must not be empty")
+        if region in out:
+            raise IntensityError(f"line {lineno}: duplicate region {region!r}")
+
+        retrieved = (row.get("retrieved") or "").strip()
+        if not retrieved:
+            raise IntensityError(
+                f"line {lineno}: region {region!r} has no retrieval date; "
+                "undated intensity values cannot be audited"
+            )
+        try:
+            _dt.date.fromisoformat(retrieved)
+        except ValueError as exc:
+            raise IntensityError(
+                f"line {lineno}: region {region!r} has an invalid retrieval date {retrieved!r}"
+            ) from exc
+
+        raw_value = (row.get("gco2_per_kwh") or "").strip()
+        try:
+            value = float(raw_value)
+        except ValueError as exc:
+            raise IntensityError(
+                f"line {lineno}: region {region!r} has a non-numeric gco2_per_kwh {raw_value!r}"
+            ) from exc
+        if value < 0:
+            raise IntensityError(f"line {lineno}: region {region!r} has a negative intensity")
+
+        raw_provenance = (row.get("provenance") or "estimated").strip().lower()
+        try:
+            provenance = Provenance(raw_provenance)
+        except ValueError as exc:
+            raise IntensityError(
+                f"line {lineno}: region {region!r} has an unknown provenance {raw_provenance!r}"
+            ) from exc
+
+        out[region] = CarbonIntensity(
+            region=region,
+            gco2_per_kwh=value,
+            provenance=provenance,
+            provider=(row.get("provider") or "").strip(),
+            retrieved=retrieved,
+            source=(row.get("source") or "").strip(),
+        )
+    if not out:
+        raise IntensityError("carbon intensity table has no rows")
+    return out
+
+
+def load_intensity(path: str | Path | None = None) -> dict[str, CarbonIntensity]:
+    """Load the intensity table from ``path`` (bundled table by default)."""
+    target = Path(path) if path is not None else DEFAULT_INTENSITY_PATH
+    if not target.exists():
+        raise IntensityError(f"carbon intensity table not found: {target}")
+    return parse_intensity_csv(target.read_text())
+
+
+def lookup_intensity(
+    table: Mapping[str, CarbonIntensity], region: str
+) -> CarbonIntensity:
+    """Resolve a region, falling back to the ``global`` row.
+
+    The fallback is explicit: the returned intensity keeps its own region
+    name so the report shows which grid was actually used.
+    """
+    if region in table:
+        return table[region]
+    if "global" in table:
+        fallback = table["global"]
+        return CarbonIntensity(
+            region=fallback.region,
+            gco2_per_kwh=fallback.gco2_per_kwh,
+            provenance=fallback.provenance,
+            provider=fallback.provider,
+            retrieved=fallback.retrieved,
+            source=fallback.source,
+        )
+    raise IntensityError(f"no carbon intensity for region {region!r} and no global fallback")

greentrain/cli.py

@@ -0,0 +1,224 @@
+"""``greentrain`` command line interface.
+
+Subcommands:
+
+``tiers``       list the tier power models and their provenance
+``intensity``   show the grid carbon intensity table
+``plan``        plan a workload without running it
+``run``         run a workload through iroh-tinker and report its carbon
+``report``      re-render the report of a finished job
+
+Every command supports ``--json`` for machine consumption.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+from .carbon import default_intensity_path, load_intensity
+from .power import TIER_POWER_MODELS
+from .report import (
+    render_markdown,
+    render_prometheus,
+    report_from_dict,
+)
+from .runner import GreenTrainRunner, Workload, default_candidates
+
+__all__ = ["build_parser", "main"]
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="greentrain",
+        description="Low-carbon AI training service built on iroh-tinker.",
+    )
+    parser.add_argument("--json", action="store_true", help="emit JSON on stdout")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    tiers = sub.add_parser("tiers", help="list tier power models")
+    tiers.add_argument("--json", action="store_true", help="emit JSON on stdout")
+
+    intensity = sub.add_parser("intensity", help="show grid carbon intensity")
+    intensity.add_argument("--region", help="only show one region")
+    intensity.add_argument("--json", action="store_true", help="emit JSON on stdout")
+
+    plan = sub.add_parser("plan", help="plan a workload")
+    plan.add_argument("--spec", required=True, help="path to a JSON workload spec")
+    plan.add_argument("--json", action="store_true", help="emit JSON on stdout")
+
+    run = sub.add_parser("run", help="run a workload and report its carbon")
+    run.add_argument("--spec", required=True, help="path to a JSON workload spec")
+    run.add_argument("--dry-run", action="store_true", help="plan and write the spec only")
+    run.add_argument(
+        "--format",
+        default="json",
+        choices=["json", "markdown", "prometheus"],
+        help="report rendering",
+    )
+    run.add_argument("--json", action="store_true", help="emit JSON on stdout")
+
+    report = sub.add_parser("report", help="re-render a finished job's report")
+    report.add_argument("--job-id", required=True, help="job name")
+    report.add_argument(
+        "--format",
+        default="markdown",
+        choices=["json", "markdown", "prometheus"],
+        help="report rendering",
+    )
+    report.add_argument("--json", action="store_true", help="emit JSON on stdout")
+
+    return parser
+
+
+def _load_workload(path: str) -> Workload:
+    spec_path = Path(path)
+    if not spec_path.exists():
+        raise FileNotFoundError(f"workload spec not found: {spec_path}")
+    raw = json.loads(spec_path.read_text())
+    workload = Workload.from_dict(raw)
+    if not workload.candidates:
+        workload.candidates = default_candidates()
+    return workload
+
+
+def _cmd_tiers(args: argparse.Namespace) -> int:
+    rows = [
+        {
+            "key": model.key,
+            "device_type": model.device_type,
+            "watts_per_device": model.watts_per_device,
+            "source": model.source,
+            "notes": model.notes,
+            "provenance": "estimated",
+        }
+        for model in TIER_POWER_MODELS.values()
+    ]
+    if args.json:
+        _emit_json(rows)
+        return 0
+    print("greentrain tier power models (all ESTIMATED unless a meter is attached)")
+    for row in rows:
+        print(
+            f"  {row['key']:<20} {row['device_type']:<8} "
+            f"{row['watts_per_device']:>7.1f} W   {row['source']}"
+        )
+    return 0
+
+
+def _cmd_intensity(args: argparse.Namespace) -> int:
+    table = load_intensity()
+    rows = [value.to_dict() for value in table.values()]
+    if args.region:
+        rows = [row for row in rows if row["region"] == args.region]
+        if not rows:
+            print(f"no intensity row for region {args.region!r}", file=sys.stderr)
+            return 1
+    if args.json:
+        _emit_json(rows)
+        return 0
+    print("region          gCO2eq/kWh  provenance  retrieved    provider")
+    for row in rows:
+        print(
+            f"  {row['region']:<12} {row['gco2_per_kwh']:>9.1f}  "
+            f"{row['provenance']:<10}  {row['retrieved']}  {row['provider']}"
+        )
+    print(f"source: {default_intensity_path()}")
+    return 0
+
+
+def _cmd_plan(args: argparse.Namespace) -> int:
+    workload = _load_workload(args.spec)
+    runner = GreenTrainRunner()
+    plan = runner.plan(workload)
+    if args.json:
+        _emit_json(plan)
+        return 0
+    chosen = plan.get("chosen")
+    if not chosen:
+        print("no candidate tier can meet the targets", file=sys.stderr)
+        return 1
+    print(f"job: {plan['job_id']}  region: {plan['region']}")
+    print(
+        f"chosen tier: {chosen['candidate']['device_type']} in {chosen['candidate']['region']} "
+        f"({chosen['subnet']['width_mult']}x width, {chosen['subnet']['depth_mult']}x depth)"
+    )
+    print(
+        f"estimated energy: {chosen['estimated_kwh']:.6f} kWh  "
+        f"estimated carbon: {chosen['estimated_carbon_kg']:.6f} kg CO2e (estimated)"
+    )
+    print("")
+    print("candidate                         energy kWh    carbon kg    feasible")
+    for candidate in plan["candidates"]:
+        c = candidate["candidate"]
+        print(
+            f"  {c['device_type']:<8} {c['region']:<16} "
+            f"{candidate['estimated_kwh']:>10.6f}  {candidate['estimated_carbon_kg']:>11.6f}  "
+            f"{candidate['feasible']}"
+        )
+    return 0
+
+
+def _cmd_run(args: argparse.Namespace) -> int:
+    workload = _load_workload(args.spec)
+    runner = GreenTrainRunner()
+    result = runner.run(workload, dry_run=args.dry_run)
+    if args.json or args.format == "json":
+        _emit_json(result.to_dict())
+    elif args.format == "markdown":
+        sys.stdout.write(render_markdown(result.report))
+    else:
+        sys.stdout.write(render_prometheus(result.report))
+    return 0 if result.status in ("done", "dry-run") else 1
+
+
+def _cmd_report(args: argparse.Namespace) -> int:
+    from iroh_tinker.cloud.job import JobManager
+
+    job_dir = Path(JobManager().root) / args.job_id
+    report_path = job_dir / "report.json"
+    if not report_path.exists():
+        raise FileNotFoundError(f"no report found for job {args.job_id!r} in {job_dir}")
+    report = report_from_dict(json.loads(report_path.read_text()))
+    if args.json or args.format == "json":
+        _emit_json(report.to_dict())
+    elif args.format == "markdown":
+        sys.stdout.write(render_markdown(report))
+    else:
+        sys.stdout.write(render_prometheus(report))
+    return 0
+
+
+def _emit_json(payload: Any) -> None:
+    sys.stdout.write(json.dumps(payload, indent=2) + "\n")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(list(argv) if argv is not None else None)
+    try:
+        if args.command == "tiers":
+            return _cmd_tiers(args)
+        if args.command == "intensity":
+            return _cmd_intensity(args)
+        if args.command == "plan":
+            return _cmd_plan(args)
+        if args.command == "run":
+            return _cmd_run(args)
+        if args.command == "report":
+            return _cmd_report(args)
+    except (FileNotFoundError, ValueError, RuntimeError) as exc:
+        if getattr(args, "json", False):
+            _emit_json({"error": str(exc)})
+        else:
+            print(f"error: {exc}", file=sys.stderr)
+        return 2
+    parser.error(f"unknown command {args.command!r}")
+    return 2
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

greentrain/data/carbon_intensity.csv

@@ -0,0 +1,39 @@
+# greentrain grid carbon intensity table (gCO2eq/kWh)
+#
+# PROVENANCE: every row below is an ESTIMATED value taken from public
+# annual-average grid intensity figures. They are placeholders until the
+# carbon-intensity source question (open question 1 in the product-suite plan)
+# is resolved and a licensed feed (Ember / WattTime / Electricity Maps) is wired
+# in. Do not publish customer-facing carbon claims from these numbers without
+# re-sourcing them.
+#
+# Columns:
+#   region          lookup key (GCP/AWS/Azure style region names)
+#   provider        who published the underlying figure
+#   gco2_per_kwh    grid carbon intensity, grams CO2eq per kWh
+#   provenance      measured | estimated
+#   retrieved       ISO date the value was taken from the source
+#   source          where the value came from
+#
+# The loader (greentrain.carbon.parse_intensity_csv) rejects any row without
+# a valid `retrieved` date.
+region,provider,gco2_per_kwh,provenance,retrieved,source
+us-central1,Ember,393,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+us-east1,Ember,380,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+us-east-2,Ember,440,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+us-west1,Ember,130,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+us-west2,Ember,381,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+ca-central1,Ember,127,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+eu-west-1,Ember,310,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+eu-west-2,Ember,233,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+eu-central-1,Ember,381,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+eu-north-1,Ember,41,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+eu-south-1,Ember,338,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+as-east-1,Ember,578,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+as-northeast-1,Ember,479,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+as-southeast-1,Ember,431,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+as-south-1,Ember,708,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+ap-southeast-1,Ember,584,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+me-central-1,Ember,484,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+sa-east-1,Ember,104,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/
+global,Ember,475,estimated,2026-10-01,https://ember-energy.org/data/electricity-data-explorer/