greenpick 0.2.1__tar.gz → 0.4.0__tar.gz

{greenpick-0.2.1/src/greenpick.egg-info → greenpick-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.2.1
+Version: 0.4.0
 Summary: Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs.
 Author-email: "Data Science Advisers, LLC" <info@datascienceadvisers.com>
 License-Expression: MIT
@@ -52,7 +52,8 @@ environment (Cursor / Claude Code / Kiro). Ask it where to deploy, when to run a
 right-size — and it answers with an honest **carbon + cost + latency** tradeoff, in-editor, in
 seconds. (It responds when you ask; auto-nudging on infra-code changes is on the roadmap.)
 
-> **Status: working — 15 tools.** Live carbon for US (EIA-930) and EU (ENTSO-E), cross-cloud cost
+> **Status: working — 15 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
+> IESO — no key needed), cross-cloud cost
 > parity (Vantage-refreshed), per-axis R/Y/G ratings, carbon-aware scheduling + day-ahead forecast,
 > GPU-training **and LLM-inference** carbon, right-sizing, serving-pattern and data-locality/residency
 > checks — all shipped. Offline or without API keys, falls back to clearly-labelled *typical* values:
@@ -123,7 +124,7 @@ backfire guards** — is the part nothing else puts together.
 
 ## Scope
 
-- Providers: **AWS, GCP, Azure** regions.
+- Providers: **AWS, GCP, Azure** — 25 regions across the US, Europe, Canada, Asia and Australia.
 - Workloads: long-running **web/API services**, **GPU training** runs, and **deferrable jobs**
   (ETL / batch / backups) — placement and timing for each.
 - Carbon = **grid carbon intensity by region** (directional, point-in-time; live US + EU), plus a
@@ -187,12 +188,19 @@ See `docs/user-questions-backlog.md`.
 
 - **EIA-930** (US balancing authorities) and **ENTSO-E** (EU zones) — live grid carbon,
   auto-routed by region. Both also drive `cleanest_hours_to_run` from recent hourly history.
+- **Hydro-Québec** (Montreal / Québec City regions) and **IESO** (Toronto regions) — live hourly
+  generation by source, public, **no key needed**. Hydro-Québec figures arrive 1.5–6 h late, so the
+  latest complete hour is used and its timestamp shown.
 - **Typical** — the offline default and fallback: for each region, this calendar month's average
   intensity and average hour-of-day profile (UTC), computed from 12 months of real hourly EIA-930 /
   ENTSO-E data (`data/typical.json`, refreshed by `scripts/refresh_typical.py`). Labelled
   `quality: "typical"` — a realistic norm, never presented as a current reading.
-- **Mock** — a hand-set illustrative value, labelled `quality: "mock"`, used only for regions no free
-  source covers (e.g. Sydney).
+- **Annual** — for Singapore, Tokyo and Mumbai/Pune, where no free hourly data exists: the country's
+  yearly lifecycle grid intensity from [Ember](https://ember-energy.org/) (via Our World in Data,
+  CC BY 4.0), with source and year (`data/annual.json`). Labelled `quality: "annual_average"`; fine for
+  comparing regions, but carries no timing signal.
+- **Mock** — a hand-set illustrative value, labelled `quality: "mock"`, used only where nothing else
+  exists (currently Sydney).
 - Cost: a **dated static pricing table** (`data/pricing.json`), refreshed from live Vantage
   pricing via `scripts/refresh_pricing.py` using one matched method across all three clouds.
 - Instance-family efficiency: directional perf-per-watt multipliers (`data/instance_families.json`).
@@ -238,6 +246,7 @@ Connect it to an MCP client (e.g. Kiro / Claude Code / Cursor) by pointing the c
 GreenPick runs on labelled typical values until you give it two free keys:
 [EIA](https://www.eia.gov/opendata/register.php) (US grid) and
 [ENTSO-E](https://transparency.entsoe.eu/) (EU grid). Pass them as environment variables.
+Canadian regions are live with just `GREENPICK_CARBON_SOURCE=auto` — their sources need no key.
 (A `.env` file works for a source checkout; if you installed with `pip install greenpick`, use one
 of the options below.)
 
@@ -295,8 +304,9 @@ Top-level `await` works in Jupyter. In a plain script, put the `with` block insi
 and run it with `asyncio.run(...)`.
 
 Every carbon figure includes a `quality` field: `live` means a current reading, `typical` means
-this month's average from last year's real data, and `mock` means a hand-set value for a region
-with no real data. Check it to confirm live data is on. A result that isn't live also includes a
+this month's average from last year's real data, `annual_average` means a sourced yearly national
+figure (regions with no free hourly data), and `mock` means a hand-set value. Check it to confirm
+live data is on. A result that isn't live also includes a
 `live_data_hint` saying why (no key set, the source didn't respond, or no free source covers that
 region) and what to do about it.
 

{greenpick-0.2.1 → greenpick-0.4.0}/README.md

@@ -22,7 +22,8 @@ environment (Cursor / Claude Code / Kiro). Ask it where to deploy, when to run a
 right-size — and it answers with an honest **carbon + cost + latency** tradeoff, in-editor, in
 seconds. (It responds when you ask; auto-nudging on infra-code changes is on the roadmap.)
 
-> **Status: working — 15 tools.** Live carbon for US (EIA-930) and EU (ENTSO-E), cross-cloud cost
+> **Status: working — 15 tools.** Live carbon for US (EIA-930), EU (ENTSO-E) and Canada (Hydro-Québec,
+> IESO — no key needed), cross-cloud cost
 > parity (Vantage-refreshed), per-axis R/Y/G ratings, carbon-aware scheduling + day-ahead forecast,
 > GPU-training **and LLM-inference** carbon, right-sizing, serving-pattern and data-locality/residency
 > checks — all shipped. Offline or without API keys, falls back to clearly-labelled *typical* values:
@@ -93,7 +94,7 @@ backfire guards** — is the part nothing else puts together.
 
 ## Scope
 
-- Providers: **AWS, GCP, Azure** regions.
+- Providers: **AWS, GCP, Azure** — 25 regions across the US, Europe, Canada, Asia and Australia.
 - Workloads: long-running **web/API services**, **GPU training** runs, and **deferrable jobs**
   (ETL / batch / backups) — placement and timing for each.
 - Carbon = **grid carbon intensity by region** (directional, point-in-time; live US + EU), plus a
@@ -157,12 +158,19 @@ See `docs/user-questions-backlog.md`.
 
 - **EIA-930** (US balancing authorities) and **ENTSO-E** (EU zones) — live grid carbon,
   auto-routed by region. Both also drive `cleanest_hours_to_run` from recent hourly history.
+- **Hydro-Québec** (Montreal / Québec City regions) and **IESO** (Toronto regions) — live hourly
+  generation by source, public, **no key needed**. Hydro-Québec figures arrive 1.5–6 h late, so the
+  latest complete hour is used and its timestamp shown.
 - **Typical** — the offline default and fallback: for each region, this calendar month's average
   intensity and average hour-of-day profile (UTC), computed from 12 months of real hourly EIA-930 /
   ENTSO-E data (`data/typical.json`, refreshed by `scripts/refresh_typical.py`). Labelled
   `quality: "typical"` — a realistic norm, never presented as a current reading.
-- **Mock** — a hand-set illustrative value, labelled `quality: "mock"`, used only for regions no free
-  source covers (e.g. Sydney).
+- **Annual** — for Singapore, Tokyo and Mumbai/Pune, where no free hourly data exists: the country's
+  yearly lifecycle grid intensity from [Ember](https://ember-energy.org/) (via Our World in Data,
+  CC BY 4.0), with source and year (`data/annual.json`). Labelled `quality: "annual_average"`; fine for
+  comparing regions, but carries no timing signal.
+- **Mock** — a hand-set illustrative value, labelled `quality: "mock"`, used only where nothing else
+  exists (currently Sydney).
 - Cost: a **dated static pricing table** (`data/pricing.json`), refreshed from live Vantage
   pricing via `scripts/refresh_pricing.py` using one matched method across all three clouds.
 - Instance-family efficiency: directional perf-per-watt multipliers (`data/instance_families.json`).
@@ -208,6 +216,7 @@ Connect it to an MCP client (e.g. Kiro / Claude Code / Cursor) by pointing the c
 GreenPick runs on labelled typical values until you give it two free keys:
 [EIA](https://www.eia.gov/opendata/register.php) (US grid) and
 [ENTSO-E](https://transparency.entsoe.eu/) (EU grid). Pass them as environment variables.
+Canadian regions are live with just `GREENPICK_CARBON_SOURCE=auto` — their sources need no key.
 (A `.env` file works for a source checkout; if you installed with `pip install greenpick`, use one
 of the options below.)
 
@@ -265,8 +274,9 @@ Top-level `await` works in Jupyter. In a plain script, put the `with` block insi
 and run it with `asyncio.run(...)`.
 
 Every carbon figure includes a `quality` field: `live` means a current reading, `typical` means
-this month's average from last year's real data, and `mock` means a hand-set value for a region
-with no real data. Check it to confirm live data is on. A result that isn't live also includes a
+this month's average from last year's real data, `annual_average` means a sourced yearly national
+figure (regions with no free hourly data), and `mock` means a hand-set value. Check it to confirm
+live data is on. A result that isn't live also includes a
 `live_data_hint` saying why (no key set, the source didn't respond, or no free source covers that
 region) and what to do about it.
 

{greenpick-0.2.1 → greenpick-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "greenpick"
-version = "0.2.1"
+version = "0.4.0"
 description = "Design-time sustainability co-pilot (MCP server): greener, cheaper cloud infrastructure decisions with carbon + cost + latency tradeoffs."
 readme = "README.md"
 requires-python = ">=3.11"

{greenpick-0.2.1 → greenpick-0.4.0}/src/greenpick/__init__.py

@@ -4,7 +4,7 @@ Greener cloud-region choices with honest carbon + cost + latency tradeoffs,
 delivered inside the vibe-coding loop. Directional guidance, not audited accounting.
 """
 
-__version__ = "0.2.1"
+__version__ = "0.4.0"
 
 # httpx logs every request URL at INFO, and our live sources pass their API key / token as a URL
 # query parameter — so at the default log level the secret would land in the MCP client's logs.

greenpick-0.4.0/src/greenpick/data/annual.json

@@ -0,0 +1,13 @@
+{
+ "_comment": "Yearly average grid carbon intensity for regions with no free hourly data source. Lifecycle gCO2e/kWh (full lifecycle incl. upstream methane), the same basis as GreenPick's per-fuel factors, so these compare fairly with live/typical regions. National figures: no hourly or sub-national lifecycle data is freely available for these grids. Used with quality='annual_average'; no hourly profile, so no timing advice.",
+ "_source": "Ember yearly electricity data (lifecycle CO2 intensity of electricity generation), via Our World in Data grapher 'carbon-intensity-electricity'. CC BY 4.0.",
+ "_as_of": "2026-10-27",
+ "zones": {
+  "SG": { "country": "Singapore", "g_co2_per_kwh": 497.1, "year": 2025,
+          "note": "About 95% natural gas; a yearly figure is a fair description of this steady grid." },
+  "JP": { "country": "Japan", "g_co2_per_kwh": 477.3, "year": 2025,
+          "note": "National average; the Tokyo (TEPCO) area mix differs somewhat and varies by hour." },
+  "IN": { "country": "India", "g_co2_per_kwh": 670.1, "year": 2025,
+          "note": "National average; Maharashtra (Mumbai, Pune) runs about 6% above it on Ember's state-level data." }
+ }
+}

{greenpick-0.2.1 → greenpick-0.4.0}/src/greenpick/data/auto_repository.py

@@ -1,10 +1,11 @@
 """Auto router: pick the right live source per region.
 
-- US regions (have an `eia_ba`)      -> EIA
-- EU regions (have an `entsoe_eic`)  -> ENTSO-E
-- anything else                      -> mock (honestly labelled)
+- US regions (have an `eia_ba`)        -> EIA
+- EU regions (have an `entsoe_eic`)    -> ENTSO-E
+- Canadian regions (have a `ca_source`) -> Hydro-Québec / IESO (no key needed)
+- anything else                        -> typical / mock fallback (honestly labelled)
 
-Lets a single GREENPICK_CARBON_SOURCE=auto give live data on both continents.
+Lets a single GREENPICK_CARBON_SOURCE=auto give live data on all three.
 """
 from __future__ import annotations
 
@@ -12,6 +13,7 @@ from ..models import CarbonReading, Provider, HourlyCarbon, ForecastHour
 from .typical_repository import TypicalCarbonRepository
 from .eia_repository import EIARepository
 from .entsoe_repository import ENTSOERepository
+from .canada_repository import CanadaRepository
 from .static_data import region_meta
 
 
@@ -19,23 +21,24 @@ class AutoRepository:
     def __init__(self, eia_key: str, entsoe_token: str, cache_ttl_seconds: int = 1800) -> None:
         self._eia = EIARepository(eia_key, cache_ttl_seconds)
         self._entsoe = ENTSOERepository(entsoe_token, cache_ttl_seconds)
+        self._canada = CanadaRepository(cache_ttl_seconds)
         self._mock = TypicalCarbonRepository()
 
-    async def carbon_now(self, provider: Provider, region: str) -> CarbonReading:
+    def _route(self, provider: Provider, region: str):
         meta = region_meta(provider, region) or {}
         if meta.get("eia_ba"):
-            return await self._eia.carbon_now(provider, region)
+            return self._eia
         if meta.get("entsoe_eic"):
-            return await self._entsoe.carbon_now(provider, region)
-        return await self._mock.carbon_now(provider, region)
+            return self._entsoe
+        if meta.get("ca_source"):
+            return self._canada
+        return self._mock
+
+    async def carbon_now(self, provider: Provider, region: str) -> CarbonReading:
+        return await self._route(provider, region).carbon_now(provider, region)
 
     async def carbon_history(self, provider: Provider, region: str) -> list[HourlyCarbon]:
-        meta = region_meta(provider, region) or {}
-        if meta.get("eia_ba"):
-            return await self._eia.carbon_history(provider, region)
-        if meta.get("entsoe_eic"):
-            return await self._entsoe.carbon_history(provider, region)
-        return await self._mock.carbon_history(provider, region)
+        return await self._route(provider, region).carbon_history(provider, region)
 
     async def renewable_forecast(self, provider: Provider, region: str, hours_ahead: int = 24
                                  ) -> list[ForecastHour]:

greenpick-0.4.0/src/greenpick/data/canada_repository.py

@@ -0,0 +1,205 @@
+"""Canadian carbon sources: Hydro-Québec (Québec) and IESO (Ontario). Both free, no key.
+
+- Hydro-Québec open data: hourly generation by source (hydraulique, eolien, solaire, thermique,
+  autres) for the last ~48h, via the opendatasoft API. Values lag 1.5-6h; the newest hours come
+  back empty until filled, so we use the latest hour that has a total.
+- IESO: today's hourly output per generator, with each generator's fuel type
+  (PUB_GenOutputCapability.xml, updated hourly). Hours are "hour ending" in Eastern Standard Time
+  all year, so hour h of date D starts at D + (h-1)h EST = D + (h+4)h UTC.
+
+Both are weighted with GreenPick's own per-fuel factors (emission_factors.json ->
+canada_fuel_to_factor), the same way EIA and ENTSO-E mixes are, so regions compare fairly.
+Production-based (imports/exports not traced), like the other sources. Falls back to the typical
+monthly values when a fetch fails, with the same bounded timeouts and outage memory as ENTSO-E.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+from xml.etree import ElementTree as ET
+
+import httpx
+
+from ..models import CarbonReading, HourlyCarbon, Provider
+from ._net import REQUEST_DEADLINE_S, REQUEST_TIMEOUT, describe_error
+from .static_data import emission_factors, region_meta
+from .typical_repository import TypicalCarbonRepository
+
+log = logging.getLogger("greenpick.canada")
+
+HQ_LIVE_URL = ("https://donnees.hydroquebec.com/api/explore/v2.1/catalog/datasets/"
+               "production-electricite-quebec/records")
+IESO_LIVE_URL = "https://reports-public.ieso.ca/public/GenOutputCapability/PUB_GenOutputCapability.xml"
+_OUTAGE_COOLDOWN_S = 300.0
+_EST = timezone(timedelta(hours=-5))   # IESO publishes in EST year-round (no DST)
+LABEL = {"hq": "Hydro-Québec", "ieso": "IESO"}
+
+
+def _factors(source: str) -> dict[str, float]:
+    return emission_factors()["canada_fuel_to_factor"][source]
+
+
+def mix_to_intensity(source: str, mix: dict[str, float]) -> Optional[float]:
+    """Weighted gCO2/kWh for a {fuel: MW} mix, ignoring unknown fuels and non-positive values."""
+    f = _factors(source)
+    parts = [(mw, f[fuel]) for fuel, mw in mix.items() if fuel in f and mw and mw > 0]
+    total = sum(mw for mw, _ in parts)
+    return round(sum(mw * g for mw, g in parts) / total, 1) if total > 0 else None
+
+
+def hour_utc(timestamp: str) -> Optional[str]:
+    """'2026-10-26T09:30:00+00:00' -> '2026-10-26T09' (UTC, floored to the hour)."""
+    try:
+        dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+    except (ValueError, AttributeError):
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H")
+
+
+def hq_rows_to_hourly(rows: list[dict], prefix: str = "valeurs_") -> dict[str, float]:
+    """Hydro-Québec records -> {UTC hour: gCO2/kWh}. Live rows use 'valeurs_<source>' fields,
+    history rows use the bare source names (prefix='')."""
+    out: dict[str, float] = {}
+    for r in rows:
+        if not r.get(f"{prefix}total"):
+            continue                       # not filled in yet
+        period = hour_utc(r.get("date", ""))
+        mix = {k: r.get(f"{prefix}{k}") or 0.0 for k in _factors("hq")}
+        g = mix_to_intensity("hq", mix)
+        if period and g is not None:
+            out[period] = g
+    return out
+
+
+def ieso_period(day: str, hour_ending: int) -> Optional[str]:
+    """IESO date + hour-ending (1..24, EST) -> UTC hour the interval starts, 'YYYY-MM-DDTHH'."""
+    try:
+        start = datetime.strptime(day, "%Y-%m-%d").replace(tzinfo=_EST) + timedelta(hours=hour_ending - 1)
+    except ValueError:
+        return None
+    return start.astimezone(timezone.utc).strftime("%Y-%m-%dT%H")
+
+
+def _strip(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1]
+
+
+def ieso_generators_to_hourly(xml_text: str) -> dict[str, float]:
+    """PUB_GenOutputCapability.xml (per-generator, today) -> {UTC hour: gCO2/kWh}."""
+    root = ET.fromstring(xml_text)
+    day = next((e.text for e in root.iter() if _strip(e.tag) == "Date" and e.text), None)
+    if not day:
+        return {}
+    by_hour: dict[int, dict[str, float]] = {}
+    for gen in root.iter():
+        if _strip(gen.tag) != "Generator":
+            continue
+        fuel = next((c.text for c in gen if _strip(c.tag) == "FuelType"), None)
+        outputs = next((c for c in gen if _strip(c.tag) == "Outputs"), None)
+        if not fuel or outputs is None:
+            continue
+        for out in outputs:
+            vals = {_strip(c.tag): c.text for c in out}
+            try:
+                h, mw = int(vals.get("Hour") or 0), float(vals.get("EnergyMW") or "nan")
+            except ValueError:
+                continue
+            if h and mw == mw:            # skip hours not reported yet (NaN)
+                bucket = by_hour.setdefault(h, {})
+                bucket[fuel] = bucket.get(fuel, 0.0) + mw
+    out: dict[str, float] = {}
+    for h, mix in by_hour.items():
+        g = mix_to_intensity("ieso", mix)
+        period = ieso_period(day, h)
+        if g is not None and period and sum(mix.values()) > 0:
+            out[period] = g
+    return out
+
+
+def ieso_fuel_hourly_to_hourly(xml_text: str) -> dict[str, float]:
+    """PUB_GenOutputbyFuelHourly_<year>.xml (yearly, by fuel) -> {UTC hour: gCO2/kWh}."""
+    root = ET.fromstring(xml_text)
+    out: dict[str, float] = {}
+    for daily in root.iter():
+        if _strip(daily.tag) != "DailyData":
+            continue
+        day = next((c.text for c in daily if _strip(c.tag) == "Day"), None)
+        for hourly in daily:
+            if _strip(hourly.tag) != "HourlyData":
+                continue
+            hour = next((c.text for c in hourly if _strip(c.tag) == "Hour"), None)
+            mix: dict[str, float] = {}
+            for ft in hourly:
+                if _strip(ft.tag) != "FuelTotal":
+                    continue
+                fuel = next((c.text for c in ft if _strip(c.tag) == "Fuel"), None)
+                val = next((o.text for o in ft.iter() if _strip(o.tag) == "Output"), None)
+                try:
+                    mix[fuel] = float(val)  # type: ignore[index]
+                except (TypeError, ValueError):
+                    continue
+            g = mix_to_intensity("ieso", mix)
+            period = ieso_period(day or "", int(hour)) if hour and hour.isdigit() else None
+            if g is not None and period:
+                out[period] = g
+    return out
+
+
+class CanadaRepository:
+    """Live Québec (Hydro-Québec) and Ontario (IESO) carbon, keyed off a region's ca_source."""
+
+    def __init__(self, cache_ttl_seconds: int = 1800) -> None:
+        self._ttl = cache_ttl_seconds
+        self._fallback = TypicalCarbonRepository()
+        self._cache: dict[str, tuple[float, dict[str, float]]] = {}
+        self._down_until: dict[str, float] = {}
+
+    async def _fetch(self, source: str) -> Optional[dict[str, float]]:
+        hit = self._cache.get(source)
+        if hit and time.time() - hit[0] < self._ttl:
+            return hit[1]
+        if time.time() < self._down_until.get(source, 0.0):
+            return None
+        try:
+            async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+                if source == "hq":
+                    params = {"limit": "48", "order_by": "date desc", "where": "valeurs_total>0"}
+                    resp = await asyncio.wait_for(client.get(HQ_LIVE_URL, params=params),
+                                                  timeout=REQUEST_DEADLINE_S)
+                    resp.raise_for_status()
+                    hourly = hq_rows_to_hourly(resp.json().get("results", []))
+                else:
+                    resp = await asyncio.wait_for(client.get(IESO_LIVE_URL), timeout=REQUEST_DEADLINE_S)
+                    resp.raise_for_status()
+                    hourly = ieso_generators_to_hourly(resp.text)
+        except Exception as e:
+            log.debug("%s fetch failed (%s) — typical fallback", LABEL[source], describe_error(e))
+            hourly = {}
+        if not hourly:
+            self._down_until[source] = time.time() + _OUTAGE_COOLDOWN_S
+            return None
+        self._cache[source] = (time.time(), hourly)
+        return hourly
+
+    async def carbon_now(self, provider: Provider, region: str) -> CarbonReading:
+        source = (region_meta(provider, region) or {}).get("ca_source")
+        hourly = await self._fetch(source) if source else None
+        if not hourly:
+            return await self._fallback.carbon_now(provider, region)
+        latest = max(hourly)
+        cached = self._cache.get(source, (0.0, {}))[0] < time.time() - 5
+        return CarbonReading(region=region, provider=provider, g_co2_per_kwh=hourly[latest],
+                             source=source, timestamp=latest,  # type: ignore[arg-type]
+                             quality="cached" if cached else "live")
+
+    async def carbon_history(self, provider: Provider, region: str) -> list[HourlyCarbon]:
+        source = (region_meta(provider, region) or {}).get("ca_source")
+        hourly = await self._fetch(source) if source else None
+        if not hourly:
+            return await self._fallback.carbon_history(provider, region)
+        return [HourlyCarbon(period=p, g_co2_per_kwh=g) for p, g in sorted(hourly.items())]

{greenpick-0.2.1 → greenpick-0.4.0}/src/greenpick/data/emission_factors.json

@@ -18,6 +18,11 @@
     "NUC": "Nuclear", "WAT": "Hydro", "WND": "Wind", "SUN": "Solar",
     "GEO": "Geothermal", "BIO": "Biomass"
   },
+  "_comment_canada": "Maps Canadian operators' published source categories to the same per-fuel factors above. hq = Hydro-Québec open data (hydraulique/eolien/solaire/thermique/autres; Québec thermal is mostly oil/diesel, 'autres' is biomass/biogas/small hydro). ieso = Ontario IESO fuel types.",
+  "canada_fuel_to_factor": {
+    "hq":   { "hydraulique": 24, "eolien": 11, "solaire": 48, "thermique": 650, "autres": 230 },
+    "ieso": { "NUCLEAR": 12, "GAS": 490, "HYDRO": 24, "WIND": 11, "SOLAR": 48, "BIOFUEL": 230, "OTHER": 700 }
+  },
   "_comment_entsoe": "Maps ENTSO-E A75 psrType codes to the same per-fuel factors above, so the EU source reuses one emission-factor table. B-codes per ENTSO-E standard.",
   "entsoe_psrtype_to_factor": {
     "B01": 230, "B02": 820, "B03": 490, "B04": 490, "B05": 820, "B06": 650,

{greenpick-0.2.1 → greenpick-0.4.0}/src/greenpick/data/mock_repository.py

@@ -19,6 +19,8 @@ _ZONE_INTENSITY = {
     "SE": 25,
     "FI": 70,
     "AU-NSW": 580,
+    "CA-QC": 30,
+    "CA-ON": 80,
 }
 _DEFAULT = 400
 

{greenpick-0.2.1 → greenpick-0.4.0}/src/greenpick/data/regions.json

@@ -6,16 +6,30 @@
     "us-west-2":      { "name": "Oregon",        "lat": 45.87, "lon": -119.69, "zone": "US-NW-PACW", "eia_ba": "BPAT", "jurisdiction": "US" },
     "eu-west-1":      { "name": "Ireland",       "lat": 53.41, "lon": -8.24,  "zone": "IE", "entsoe_eic": "10Y1001A1001A59C", "jurisdiction": "EEA" },
     "eu-north-1":     { "name": "Stockholm",     "lat": 59.33, "lon": 18.07,  "zone": "SE", "entsoe_eic": "10YSE-1--------K", "jurisdiction": "EEA" },
-    "ap-southeast-2": { "name": "Sydney",        "lat": -33.87, "lon": 151.21, "zone": "AU-NSW", "jurisdiction": "AU" }
+    "ap-southeast-2": { "name": "Sydney",        "lat": -33.87, "lon": 151.21, "zone": "AU-NSW", "jurisdiction": "AU" },
+    "ca-central-1":   { "name": "Montreal",      "lat": 45.50, "lon": -73.57, "zone": "CA-QC", "ca_source": "hq", "jurisdiction": "CA" },
+    "ap-southeast-1": { "name": "Singapore",     "lat": 1.29,  "lon": 103.85, "zone": "SG", "annual_zone": "SG", "jurisdiction": "SG" },
+    "ap-northeast-1": { "name": "Tokyo",         "lat": 35.68, "lon": 139.69, "zone": "JP-TK", "annual_zone": "JP", "jurisdiction": "JP" },
+    "ap-south-1":     { "name": "Mumbai",        "lat": 19.08, "lon": 72.88,  "zone": "IN-WE", "annual_zone": "IN", "jurisdiction": "IN" }
   },
   "gcp": {
     "us-central1":    { "name": "Iowa",          "lat": 41.26, "lon": -95.86, "zone": "US-MIDW-MISO", "eia_ba": "MISO", "jurisdiction": "US" },
     "europe-north1":  { "name": "Finland",       "lat": 60.57, "lon": 27.19,  "zone": "FI", "entsoe_eic": "10YFI-1--------U", "jurisdiction": "EEA" },
-    "us-west1":       { "name": "Oregon",        "lat": 45.60, "lon": -121.18, "zone": "US-NW-PACW", "eia_ba": "BPAT", "jurisdiction": "US" }
+    "us-west1":       { "name": "Oregon",        "lat": 45.60, "lon": -121.18, "zone": "US-NW-PACW", "eia_ba": "BPAT", "jurisdiction": "US" },
+    "northamerica-northeast1": { "name": "Montreal", "lat": 45.50, "lon": -73.57, "zone": "CA-QC", "ca_source": "hq", "jurisdiction": "CA" },
+    "northamerica-northeast2": { "name": "Toronto",  "lat": 43.65, "lon": -79.38, "zone": "CA-ON", "ca_source": "ieso", "jurisdiction": "CA" },
+    "asia-southeast1": { "name": "Singapore",    "lat": 1.35,  "lon": 103.70, "zone": "SG", "annual_zone": "SG", "jurisdiction": "SG" },
+    "asia-northeast1": { "name": "Tokyo",        "lat": 35.68, "lon": 139.69, "zone": "JP-TK", "annual_zone": "JP", "jurisdiction": "JP" },
+    "asia-south1":     { "name": "Mumbai",       "lat": 19.08, "lon": 72.88,  "zone": "IN-WE", "annual_zone": "IN", "jurisdiction": "IN" }
   },
   "azure": {
     "eastus":         { "name": "Virginia",      "lat": 37.37, "lon": -79.82, "zone": "US-MIDA-PJM", "eia_ba": "PJM", "jurisdiction": "US" },
     "northeurope":    { "name": "Ireland",       "lat": 53.35, "lon": -6.26,  "zone": "IE", "entsoe_eic": "10Y1001A1001A59C", "jurisdiction": "EEA" },
-    "swedencentral":  { "name": "Sweden",        "lat": 60.67, "lon": 17.14,  "zone": "SE", "entsoe_eic": "10YSE-1--------K", "jurisdiction": "EEA" }
+    "swedencentral":  { "name": "Sweden",        "lat": 60.67, "lon": 17.14,  "zone": "SE", "entsoe_eic": "10YSE-1--------K", "jurisdiction": "EEA" },
+    "canadaeast":     { "name": "Quebec City",   "lat": 46.81, "lon": -71.21, "zone": "CA-QC", "ca_source": "hq", "jurisdiction": "CA" },
+    "canadacentral":  { "name": "Toronto",       "lat": 43.65, "lon": -79.38, "zone": "CA-ON", "ca_source": "ieso", "jurisdiction": "CA" },
+    "southeastasia":  { "name": "Singapore",     "lat": 1.28,  "lon": 103.83, "zone": "SG", "annual_zone": "SG", "jurisdiction": "SG" },
+    "japaneast":      { "name": "Tokyo",         "lat": 35.68, "lon": 139.77, "zone": "JP-TK", "annual_zone": "JP", "jurisdiction": "JP" },
+    "centralindia":   { "name": "Pune",          "lat": 18.52, "lon": 73.86,  "zone": "IN-WE", "annual_zone": "IN", "jurisdiction": "IN" }
   }
 }

{greenpick-0.2.1 → greenpick-0.4.0}/src/greenpick/data/static_data.py

@@ -76,6 +76,15 @@ def typical() -> dict:
     return json.loads(path.read_text(encoding="utf-8"))
 
 
+@lru_cache(maxsize=1)
+def annual() -> dict:
+    """Yearly average intensity for regions with no free hourly source (lifecycle, sourced)."""
+    path = _DATA_DIR / "annual.json"
+    if not path.exists():
+        return {}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
 @lru_cache(maxsize=1)
 def gpu_power() -> dict:
     """Directional GPU/accelerator power model (TDP + utilization + host overhead) for training."""