greenpick 0.1.3__tar.gz → 0.1.5__tar.gz

{greenpick-0.1.3/src/greenpick.egg-info → greenpick-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.1.3
+Version: 0.1.5
 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

{greenpick-0.1.3 → greenpick-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "greenpick"
-version = "0.1.3"
+version = "0.1.5"
 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.1.5/src/greenpick/__init__.py

@@ -0,0 +1,15 @@
+"""GreenPick — design-time sustainability co-pilot (MCP server).
+
+Greener cloud-region choices with honest carbon + cost + latency tradeoffs,
+delivered inside the vibe-coding loop. Directional guidance, not audited accounting.
+"""
+
+__version__ = "0.1.5"
+
+# 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.
+# Keep the HTTP libraries at WARNING (no request lines) for every entry point that imports us.
+import logging as _logging
+
+for _name in ("httpx", "httpcore"):
+    _logging.getLogger(_name).setLevel(_logging.WARNING)

greenpick-0.1.5/src/greenpick/data/_net.py

@@ -0,0 +1,23 @@
+"""Shared networking helpers for the live carbon sources.
+
+Two jobs:
+- `describe_error`: a log-safe summary of a failed request. httpx exception messages embed the
+  full request URL, and our data sources pass their API key / token as a URL query parameter, so
+  logging the exception verbatim would write the secret into the MCP client's log files.
+- Shared timeouts, so one slow upstream can't freeze a tool call.
+"""
+from __future__ import annotations
+
+import httpx
+
+# Per-step limits for a single HTTP request (connect / read / write / pool).
+REQUEST_TIMEOUT = httpx.Timeout(8.0, connect=5.0)
+# Hard ceiling for ONE request end-to-end. httpx timeouts are per-step, so a server that trickles
+# bytes can stretch a request far past them; asyncio.wait_for enforces a true wall-clock limit.
+REQUEST_DEADLINE_S = 15.0
+
+
+def describe_error(e: BaseException) -> str:
+    """Error type plus HTTP status (if any) — never the URL, which carries the credential."""
+    status = getattr(getattr(e, "response", None), "status_code", None)
+    return f"{type(e).__name__}" + (f" (HTTP {status})" if status else "")

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/data/eia_repository.py

@@ -14,6 +14,7 @@ Carbon intensity = sum(gen_fuel * factor_fuel) / sum(gen_fuel).  Directional, no
 """
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
 from datetime import datetime, timezone
@@ -23,6 +24,7 @@ import httpx
 from ..models import CarbonReading, Provider, HourlyCarbon
 from .mock_repository import MockCarbonRepository
 from .static_data import region_meta, emission_factors
+from ._net import REQUEST_TIMEOUT, REQUEST_DEADLINE_S, describe_error
 
 log = logging.getLogger("greenpick.eia")
 
@@ -78,8 +80,9 @@ class EIARepository:
                 "sort[0][direction]": "desc",
                 "length": "2000",   # ~5-7 days of hourly rows x fuels — enough for a daily pattern
             }
-            async with httpx.AsyncClient(timeout=12) as client:
-                resp = await client.get(_URL, params=params)
+            async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+                resp = await asyncio.wait_for(client.get(_URL, params=params),
+                                              timeout=REQUEST_DEADLINE_S)
             if resp.status_code in (401, 403):
                 log.warning("EIA rejected the key (HTTP %s) — using mock. Check EIA_API_KEY.",
                             resp.status_code)
@@ -87,7 +90,8 @@ class EIARepository:
             resp.raise_for_status()
             return resp.json().get("response", {}).get("data", [])
         except Exception as e:
-            log.debug("EIA call failed for BA %s (%s) — mock fallback", ba, e)
+            # describe_error, not e: the exception text embeds the URL, which carries the key.
+            log.debug("EIA call failed for BA %s (%s) — mock fallback", ba, describe_error(e))
             return None
 
     async def carbon_history(self, provider: Provider, region: str) -> list[HourlyCarbon]:

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/data/electricitymaps_repository.py

@@ -13,6 +13,7 @@ API: GET https://api.electricitymap.org/v3/carbon-intensity/latest?zone=XX
 """
 from __future__ import annotations
 
+import asyncio
 import logging
 import time
 from datetime import datetime, timezone
@@ -22,6 +23,7 @@ import httpx
 from ..models import CarbonReading, Provider, HourlyCarbon
 from .mock_repository import MockCarbonRepository
 from .static_data import region_meta
+from ._net import REQUEST_TIMEOUT, REQUEST_DEADLINE_S, describe_error
 
 log = logging.getLogger("greenpick.electricitymaps")
 
@@ -66,9 +68,11 @@ class ElectricityMapsRepository:
             })
 
         try:
-            async with httpx.AsyncClient(timeout=8) as client:
-                resp = await client.get(_BASE, params={"zone": zone},
-                                        headers={"auth-token": self._token})
+            async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+                resp = await asyncio.wait_for(
+                    client.get(_BASE, params={"zone": zone}, headers={"auth-token": self._token}),
+                    timeout=REQUEST_DEADLINE_S,
+                )
 
             if resp.status_code in (401, 403):
                 # Config problem, not a per-region issue. Warn once, then stop trying.
@@ -100,5 +104,6 @@ class ElectricityMapsRepository:
 
         except Exception as e:
             # Network/parse/rate-limit -> mock fallback rather than erroring the tool.
-            log.debug("Electricity Maps call failed for zone %s (%s) — mock fallback", zone, e)
+            log.debug("Electricity Maps call failed for zone %s (%s) — mock fallback",
+                      zone, describe_error(e))
             return await self._fallback.carbon_now(provider, region)

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/data/entsoe_repository.py

@@ -14,6 +14,7 @@ Response: XML with <TimeSeries> per production type:
 """
 from __future__ import annotations
 
+import asyncio
 import logging
 import re
 import time
@@ -25,11 +26,17 @@ import httpx
 from ..models import CarbonReading, Provider, HourlyCarbon, ForecastHour
 from .mock_repository import MockCarbonRepository
 from .static_data import region_meta, emission_factors
+from ._net import REQUEST_TIMEOUT, REQUEST_DEADLINE_S, describe_error
 
 log = logging.getLogger("greenpick.entsoe")
 
 _URL = "https://web-api.tp.entsoe.eu/api"
 
+# Retry policy for a slow/flaky upstream, bounded so a tool call never hangs on it:
+_ATTEMPTS = 3
+_FETCH_BUDGET_S = 20.0        # total wall-clock for ALL attempts + backoff of one fetch
+_OUTAGE_COOLDOWN_S = 300.0    # after a failed fetch, skip that zone (labelled fallback) this long
+
 
 def _strip_ns(tag: str) -> str:
     """ENTSO-E XML is namespaced; strip '{ns}tag' -> 'tag' for simple matching."""
@@ -70,6 +77,7 @@ class ENTSOERepository:
         self._cache: dict[str, tuple[float, CarbonReading]] = {}  # EIC -> (fetched_at, reading)
         self._fallback = MockCarbonRepository()
         self._warned_no_token = False
+        self._down_until: dict[str, float] = {}   # EIC -> epoch secs; skip the zone until then
 
     async def carbon_now(self, provider: Provider, region: str) -> CarbonReading:
         meta = region_meta(provider, region) or {}
@@ -114,28 +122,57 @@ class ENTSOERepository:
             "periodEnd": now.strftime("%Y%m%d%H%M"),
         }
 
-        # ENTSO-E is occasionally slow / empty for a given zone (their docs warn about response
-        # times). Retry a couple of times before degrading to mock, since a transient miss would
-        # otherwise show a region as mock for the whole cache window.
-        import asyncio
-        attempts = 3
-        for attempt in range(1, attempts + 1):
+        return await self._get_bounded(eic, params, label="A75")
+
+    def _is_down(self, eic: str) -> bool:
+        return time.time() < self._down_until.get(eic, 0.0)
+
+    async def _get_bounded(self, eic: str, params: dict, label: str,
+                           no_match_is_final: bool = False) -> str | None:
+        """GET with retries inside ONE wall-clock budget, and outage memory.
+
+        ENTSO-E is occasionally slow or empty for a zone (their docs warn about response times), so
+        we retry — but every attempt and backoff shares a single _FETCH_BUDGET_S, so a struggling
+        upstream degrades this call to the labelled fallback in seconds rather than freezing the tool.
+        If the zone still fails, remember it for _OUTAGE_COOLDOWN_S: the next calls (e.g. the other
+        regions in a ranking, then the timing lookup) fall back immediately instead of each waiting
+        out their own retry cycle. Returns the body text, or None (callers fall back)."""
+        if self._is_down(eic):
+            return None
+        deadline = time.monotonic() + _FETCH_BUDGET_S
+        for attempt in range(1, _ATTEMPTS + 1):
+            remaining = deadline - time.monotonic()
+            if remaining <= 0.5:
+                break
             try:
-                async with httpx.AsyncClient(timeout=15) as client:
-                    resp = await client.get(_URL, params=params)
+                async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+                    resp = await asyncio.wait_for(client.get(_URL, params=params),
+                                                  timeout=min(remaining, REQUEST_DEADLINE_S))
                 if resp.status_code in (401, 403):
-                    log.warning("ENTSO-E rejected the token (HTTP %s) — using mock. Check ENTSOE_TOKEN.",
-                                resp.status_code)
+                    log.warning("ENTSO-E rejected the token (HTTP %s) on %s — using fallback. "
+                                "Check ENTSOE_TOKEN.", resp.status_code, label)
                     return None   # auth: don't retry
                 resp.raise_for_status()
                 if resp.text and "<TimeSeries" in resp.text:
                     return resp.text
-                # 200 but no usable generation (transient empty) -> retry
-                log.debug("ENTSO-E empty for %s (attempt %d/%d)", eic, attempt, attempts)
+                # 'No matching data' (common for A65 in some zones) means "not offered", not an
+                # outage: bail quietly without retrying or marking the zone down.
+                if no_match_is_final and "No matching data" in resp.text:
+                    log.debug("ENTSO-E %s: no matching data for %s", label, eic)
+                    return None
+                log.debug("ENTSO-E %s empty for %s (attempt %d/%d)", label, eic, attempt, _ATTEMPTS)
             except Exception as e:
-                log.debug("ENTSO-E call failed for %s (attempt %d/%d): %s", eic, attempt, attempts, e)
-            if attempt < attempts:
-                await asyncio.sleep(0.6 * attempt)   # brief backoff: 0.6s, 1.2s
+                # describe_error, not e: the exception text embeds the URL, which carries the token.
+                log.debug("ENTSO-E %s failed for %s (attempt %d/%d): %s",
+                          label, eic, attempt, _ATTEMPTS, describe_error(e))
+            if attempt < _ATTEMPTS:
+                pause = 0.6 * attempt   # brief backoff: 0.6s, 1.2s — inside the same budget
+                if deadline - time.monotonic() <= pause + 0.5:
+                    break
+                await asyncio.sleep(pause)
+        self._down_until[eic] = time.time() + _OUTAGE_COOLDOWN_S
+        log.info("ENTSO-E unavailable for %s — using the labelled fallback for the next %ds.",
+                 eic, int(_OUTAGE_COOLDOWN_S))
         return None
 
     async def _fetch_forecast_xml(self, eic: str, document_type: str, hours_ahead: int,
@@ -153,31 +190,7 @@ class ENTSOERepository:
             "periodEnd": end.strftime("%Y%m%d%H%M"),
         }
         params["outBiddingZone_Domain" if load else "in_Domain"] = eic
-
-        import asyncio
-        attempts = 3
-        for attempt in range(1, attempts + 1):
-            try:
-                async with httpx.AsyncClient(timeout=15) as client:
-                    resp = await client.get(_URL, params=params)
-                if resp.status_code in (401, 403):
-                    log.warning("ENTSO-E rejected the token (HTTP %s) on forecast — using fallback.",
-                                resp.status_code)
-                    return None
-                resp.raise_for_status()
-                if resp.text and "<TimeSeries" in resp.text:
-                    return resp.text
-                # 'No matching data' (common for A65 in some zones) is not retryable — bail quietly.
-                if "No matching data" in resp.text:
-                    log.debug("ENTSO-E %s: no matching data for %s", document_type, eic)
-                    return None
-                log.debug("ENTSO-E %s empty for %s (attempt %d/%d)", document_type, eic, attempt, attempts)
-            except Exception as e:
-                log.debug("ENTSO-E %s failed for %s (attempt %d/%d): %s",
-                          document_type, eic, attempt, attempts, e)
-            if attempt < attempts:
-                await asyncio.sleep(0.6 * attempt)
-        return None
+        return await self._get_bounded(eic, params, label=document_type, no_match_is_final=True)
 
     async def renewable_forecast(self, provider: Provider, region: str, hours_ahead: int = 24
                                  ) -> list[ForecastHour]:

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/data/regions.json

@@ -6,8 +6,7 @@
     "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" },
-    "us-east-nyc":    { "name": "New York (NYISO)", "lat": 40.71, "lon": -74.01, "zone": "US-NY-NYIS", "eia_ba": "NYIS", "jurisdiction": "US" }
+    "ap-southeast-2": { "name": "Sydney",        "lat": -33.87, "lon": 151.21, "zone": "AU-NSW", "jurisdiction": "AU" }
   },
   "gcp": {
     "us-central1":    { "name": "Iowa",          "lat": 41.26, "lon": -95.86, "zone": "US-MIDW-MISO", "eia_ba": "MISO", "jurisdiction": "US" },

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/models.py

@@ -164,6 +164,7 @@ class TrainingCarbonAdvice(BaseModel):
     gpu_name: str
     gpu_count: int
     gpu_hours: float                              # total accelerator-hours for the run
+    wall_clock_hours: Optional[float] = None      # ~gpu_hours / gpu_count (GPUs run in parallel)
     utilization: float
     est_energy_kwh: float
     # Placement:

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/server.py

@@ -314,7 +314,9 @@ async def estimate_training_carbon(
     top_n_regions: int = 5,
 ) -> dict:
     """Carbon of a GPU training run, with greener WHERE (region) and WHEN (hours) guidance.
-    Give the GPU (e.g. 'a100', 'h100', 'l4'), how many, and total GPU-hours for the run. Omit
+    Give the GPU (e.g. 'a100', 'h100', 'l4'), how many (gpu_count), and gpu_hours = TOTAL
+    accelerator-hours across ALL GPUs — e.g. 8 GPUs running for 10 hours is gpu_hours=80, not 10.
+    The output echoes wall_clock_hours (~gpu_hours / gpu_count) for reporting. Omit
     `region` to rank regions greenest-first; pass one to score just that region. Training is both
     portable and deferrable, so this combines region choice with cleanest-hours timing. Directional
     (TDP-based energy); GPU availability per region is NOT checked - verify your card is offered there.

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/services/locality_service.py

@@ -129,6 +129,10 @@ async def data_locality_check(
     warning = (f"Compute and data are separated {sep}: ~{monthly_cross_boundary_gb:,.0f} GB/mo would "
                f"cross the boundary, costing {cost_txt}, plus ~{transfer_kg:.1f} kg CO2/mo of extra "
                f"transfer. A greener-region move can be undone by this.")
+    if verdict is None:
+        # Point the caller at the optional input that turns this into a net win/backfire verdict.
+        warning += (" For a net verdict, pass carbon_saving_kg_co2_from_move (the kg CO2/mo the move "
+                    "saves, e.g. the difference between estimate_workload_carbon in the two regions).")
 
     if severity == "high":
         rec = ("High exposure. Co-locate compute with the data, or move the data to the greener "

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/services/rightsizing_service.py

@@ -22,15 +22,35 @@ _HEADROOM = 1.4
 _MIN_SAVING_PCT = 10.0
 
 
-def _rightsized_dimension(provisioned: float, utilization: Optional[float]) -> float:
-    """Target = observed usage x headroom, floored at a small minimum, never above provisioned
-    (right-sizing only shrinks here). If utilisation is unknown, leave the dimension unchanged."""
+def _needed(provisioned: float, utilization: Optional[float]) -> float:
+    """Capacity actually needed = observed usage x headroom. If utilisation is unknown, assume the
+    dimension is needed in full (we only right-size what the user told us about)."""
     if utilization is None:
         return provisioned
     u = max(0.0, min(1.0, utilization))
-    target = provisioned * u * _HEADROOM
-    target = max(0.5, target)              # floor: don't suggest sub-0.5 vCPU/GB
-    return min(provisioned, round(target, 1))
+    return provisioned * u * _HEADROOM
+
+
+# Standard instance shapes shared by AWS / GCP / Azure: vCPU counts step in powers of two (plus the
+# common 48/96/192), and memory comes at ~2 GB/vCPU (compute-optimised), ~4 GB/vCPU (general
+# purpose) or ~8 GB/vCPU (memory-optimised). Recommending only these shapes means the answer is a
+# size you can actually buy, and the saving is priced on that size — not on a fractional ideal.
+_VCPU_SIZES = (1, 2, 4, 8, 16, 32, 48, 64, 96, 128, 192)
+_GB_PER_VCPU = (2, 4, 8)
+
+
+def _standard_size(need_vcpu: float, need_ram: float,
+                   prov_vcpu: float, prov_ram: float) -> tuple[float, float]:
+    """Smallest standard shape covering both needs, never larger than what's provisioned
+    (right-sizing only shrinks or holds). Falls back to the provisioned size if nothing fits."""
+    for v in _VCPU_SIZES:
+        if v < need_vcpu or v > prov_vcpu:
+            continue
+        for ratio in _GB_PER_VCPU:
+            ram = v * ratio
+            if ram >= need_ram and ram <= prov_ram:
+                return float(v), float(ram)
+    return prov_vcpu, prov_ram
 
 
 async def rightsizing_check(
@@ -43,8 +63,9 @@ async def rightsizing_check(
     ram_utilization: Optional[float] = None,
     hours_per_month: float = 730,
 ) -> RightsizingAdvice:
-    rec_vcpu = _rightsized_dimension(vcpu, cpu_utilization)
-    rec_ram = _rightsized_dimension(ram_gb, ram_utilization)
+    rec_vcpu, rec_ram = _standard_size(
+        _needed(vcpu, cpu_utilization), _needed(ram_gb, ram_utilization), vcpu, ram_gb,
+    )
 
     now_wl = Workload(vcpu=vcpu, ram_gb=ram_gb, hours_per_month=hours_per_month)
     rs_wl = Workload(vcpu=rec_vcpu, ram_gb=rec_ram, hours_per_month=hours_per_month)
@@ -66,8 +87,9 @@ async def rightsizing_check(
         usd_txt = f"~${usd_saving:,.0f}/mo" if usd_saving is not None else "cost"
         rationale = (
             f"Over-provisioned: at ~{cpu_utilization*100:.0f}% CPU use, {vcpu:g} vCPU / {ram_gb:g} GB "
-            f"is bigger than you need. Right-size to ~{rec_vcpu:g} vCPU / {rec_ram:g} GB (keeps ~40% "
-            f"headroom) to cut ~{saving_pct:.0f}% - {usd_txt} AND ~{kg_saving:.1f} kg CO2/mo. "
+            f"is bigger than you need. Right-size to {rec_vcpu:g} vCPU / {rec_ram:g} GB (the smallest "
+            f"standard size that keeps ~40% headroom) to cut ~{saving_pct:.0f}% - {usd_txt} AND "
+            f"~{kg_saving:.1f} kg CO2/mo. "
             f"Same work, less waste: the cost and carbon win here are the same action.")
     else:
         rationale = (
@@ -88,6 +110,8 @@ async def rightsizing_check(
         rationale=rationale,
         limitations=("Directional, design-time estimate from the utilisation YOU report — not a "
                      "reading of your running fleet, and not a quote. Keeps ~40% headroom above "
-                     "observed peak; validate against real load before resizing production. Cost "
+                     "observed peak, rounded up to a standard shape (power-of-two vCPU at ~2/4/8 GB "
+                     "per vCPU) — confirm your provider offers that size in the family you need; "
+                     "validate against real load before resizing production. Cost "
                      "uses the dated static table; carbon = power model x live grid intensity."),
     )

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/services/serving_service.py

@@ -159,8 +159,13 @@ async def serving_pattern(
     recommended, rationale = _decide(single_plan, per_hub, multi_wlat, multi_blended,
                                      len(distinct_regions))
 
+    # Echo hubs with the coordinates actually used (named hubs like "eu" resolve to representative
+    # coords), so the output never shows a misleading 0,0 for a hub that was resolved by name.
+    resolved_hubs = [ServingHub(name=h.name, lat=pt.lat, lon=pt.lon, share=h.share)
+                     for h, pt in zip(hubs, points)]
+
     return ServingPatternAdvice(
-        hubs=hubs, single_region=single_plan, multi_region=per_hub,
+        hubs=resolved_hubs, single_region=single_plan, multi_region=per_hub,
         multi_region_weighted_latency_ms=multi_wlat,
         multi_region_blended_carbon_g_co2_per_kwh=multi_blended,
         recommended_pattern=recommended, data_sync_egress_note=data_sync_note,

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick/services/training_service.py

@@ -89,6 +89,9 @@ async def estimate_training_carbon(
 
     base = TrainingCarbonAdvice(
         gpu=gpu_key, gpu_name=spec["name"], gpu_count=gpu_count, gpu_hours=gpu_hours,
+        # Echo the run's duration so callers report it rather than re-deriving it (a common slip
+        # is reading gpu_hours as per-GPU and multiplying by gpu_count again).
+        wall_clock_hours=round(gpu_hours / max(1, gpu_count), 1),
         utilization=util, est_energy_kwh=energy, limitations=LIMITATIONS,
     )
 

{greenpick-0.1.3 → greenpick-0.1.5/src/greenpick.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.1.3
+Version: 0.1.5
 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

{greenpick-0.1.3 → greenpick-0.1.5}/src/greenpick.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/greenpick.egg-info/entry_points.txt
 src/greenpick.egg-info/requires.txt
 src/greenpick.egg-info/top_level.txt
 src/greenpick/data/__init__.py
+src/greenpick/data/_net.py
 src/greenpick/data/auto_repository.py
 src/greenpick/data/eia_repository.py
 src/greenpick/data/electricitymaps_repository.py

{greenpick-0.1.3 → greenpick-0.1.5}/tests/test_services.py

@@ -179,20 +179,20 @@ from greenpick.data.eia_repository import EIARepository
 
 @pytest.mark.asyncio
 async def test_eia_mix_to_carbon_intensity(monkeypatch):
-    # NYISO latest hour: 1000 MWh gas (490) + 1000 MWh nuclear (12) -> weighted mean = 251 gCO2/kWh.
+    # PJM latest hour: 1000 MWh gas (490) + 1000 MWh nuclear (12) -> weighted mean = 251 gCO2/kWh.
     def handler(request: httpx.Request) -> httpx.Response:
-        assert request.url.params.get("facets[respondent][]") == "NYIS"
+        assert request.url.params.get("facets[respondent][]") == "PJM"
         return httpx.Response(200, json={"response": {"data": [
-            {"period": "2026-10-11T18", "respondent": "NYIS", "fueltype": "NG", "value": "1000"},
-            {"period": "2026-10-11T18", "respondent": "NYIS", "fueltype": "NUC", "value": "1000"},
-            {"period": "2026-10-11T17", "respondent": "NYIS", "fueltype": "NG", "value": "9999"},  # older hour, ignored
+            {"period": "2026-10-11T18", "respondent": "PJM", "fueltype": "NG", "value": "1000"},
+            {"period": "2026-10-11T18", "respondent": "PJM", "fueltype": "NUC", "value": "1000"},
+            {"period": "2026-10-11T17", "respondent": "PJM", "fueltype": "NG", "value": "9999"},  # older hour, ignored
         ]}})
 
     orig = httpx.AsyncClient
     monkeypatch.setattr(httpx, "AsyncClient",
                         lambda *a, **k: orig(transport=_mock_transport(handler)))
     repo = EIARepository(api_key="key")
-    r = await repo.carbon_now("aws", "us-east-nyc")   # maps to BA NYIS
+    r = await repo.carbon_now("aws", "us-east-1")     # maps to BA PJM
     assert r.source == "eia"
     assert r.quality == "live"
     assert abs(r.g_co2_per_kwh - 251.0) < 0.5          # (490+12)/2
@@ -209,7 +209,7 @@ async def test_eia_non_us_region_falls_back_to_mock():
 @pytest.mark.asyncio
 async def test_eia_no_key_uses_mock():
     repo = EIARepository(api_key="")
-    r = await repo.carbon_now("aws", "us-east-nyc")
+    r = await repo.carbon_now("aws", "us-east-1")
     assert r.quality == "mock"
 
 
@@ -601,7 +601,7 @@ async def test_serving_concentrated_users_prefer_single_region():
     assert adv.single_region is not None
     assert adv.recommended_pattern == "single_region"
     # Single region should be a US region (nearest the only hub).
-    assert adv.single_region.region in {"us-east-1", "us-west-2", "us-east-nyc", "us-central1",
+    assert adv.single_region.region in {"us-east-1", "us-west-2", "us-central1",
                                         "us-west1", "eastus"}
 
 
@@ -982,7 +982,7 @@ async def test_cleanest_time_of_day_averages_across_days(monkeypatch):
     monkeypatch.setattr(httpx, "AsyncClient",
                         lambda *a, **k: orig(transport=_mock_transport(handler)))
     repo = EIARepository(api_key="k")
-    adv = await scheduling_service.cleanest_time_of_day(repo, "aws", "us-east-nyc")
+    adv = await scheduling_service.cleanest_time_of_day(repo, "aws", "us-east-1")
     assert adv.days_analyzed == 3
     assert adv.cleanest_hour_of_day == 2      # nuclear-heavy hour, every day
     assert adv.dirtiest_hour_of_day == 18     # gas-heavy hour, every day
@@ -1072,7 +1072,165 @@ async def test_cleanest_hours_eia_multihour(monkeypatch):
     monkeypatch.setattr(httpx, "AsyncClient",
                         lambda *a, **k: orig(transport=_mock_transport(handler)))
     repo = EIARepository(api_key="k")
-    hist = await repo.carbon_history("aws", "us-east-nyc")
+    hist = await repo.carbon_history("aws", "us-east-1")
     periods = {h.period: h.g_co2_per_kwh for h in hist}
     assert set(periods) == {"2026-10-12T18", "2026-10-12T19"}
     assert periods["2026-10-12T18"] < periods["2026-10-12T19"]  # nuclear-heavy hour cleaner
+
+
+# --- 0.1.4 regressions: findings from outside-agent testing ---
+
+@pytest.mark.asyncio
+async def test_rightsizing_recommends_a_standard_buyable_size():
+    from greenpick.services import rightsizing_service
+    repo = MockCarbonRepository()
+    # 8 vCPU / 32 GB at 15% CPU, 20% RAM: the raw fit is ~1.7 vCPU / ~9 GB, which no cloud sells.
+    adv = await rightsizing_service.rightsizing_check(
+        repo, "aws", "us-east-1", vcpu=8, ram_gb=32, cpu_utilization=0.15, ram_utilization=0.20,
+    )
+    assert adv.is_oversized
+    assert (adv.recommended_vcpu, adv.recommended_ram_gb) == (2.0, 16.0)   # smallest shape that fits
+    assert adv.recommended_ram_gb / adv.recommended_vcpu in (2, 4, 8)
+    assert "standard size" in adv.rationale
+
+
+@pytest.mark.asyncio
+async def test_rightsizing_unknown_ram_keeps_ram_and_picks_a_real_shape():
+    from greenpick.services import rightsizing_service
+    repo = MockCarbonRepository()
+    # RAM utilisation not given -> keep 32 GB; 2 vCPU / 32 GB isn't a standard shape, so 4 / 32.
+    adv = await rightsizing_service.rightsizing_check(
+        repo, "aws", "us-east-1", vcpu=8, ram_gb=32, cpu_utilization=0.18,
+    )
+    assert (adv.recommended_vcpu, adv.recommended_ram_gb) == (4.0, 32.0)
+
+
+@pytest.mark.asyncio
+async def test_training_echoes_wall_clock_hours():
+    from greenpick.services import training_service
+    repo = MockCarbonRepository()
+    adv = await training_service.estimate_training_carbon(
+        repo, gpu="a100", gpu_count=8, gpu_hours=150, region="eu-north-1", provider="aws",
+    )
+    # gpu_hours is TOTAL across GPUs: 150 GPU-hours on 8 GPUs runs ~18.8 h, not 150 h.
+    assert adv.wall_clock_hours == 18.8
+
+
+@pytest.mark.asyncio
+async def test_egress_points_to_saving_input_only_when_missing():
+    from greenpick.services import locality_service
+    repo = MockCarbonRepository()
+    without = await locality_service.data_locality_check(
+        repo, "aws", "us-west-2", "aws", "us-east-1", 500,
+    )
+    assert "carbon_saving_kg_co2_from_move" in without.warning
+    with_saving = await locality_service.data_locality_check(
+        repo, "aws", "us-west-2", "aws", "us-east-1", 500, carbon_saving_kg_co2_from_move=10.0,
+    )
+    assert with_saving.net_carbon_verdict is not None
+    assert "carbon_saving_kg_co2_from_move" not in with_saving.warning
+
+
+@pytest.mark.asyncio
+async def test_serving_echoes_resolved_hub_coordinates():
+    from greenpick.services import serving_service
+    repo = MockCarbonRepository()
+    hubs = [ServingHub(name="us", lat=0, lon=0, share=0.5), ServingHub(name="eu", lat=0, lon=0, share=0.5)]
+    adv = await serving_service.serving_pattern(repo, hubs, Workload(vcpu=1, ram_gb=2))
+    assert all((h.lat, h.lon) != (0.0, 0.0) for h in adv.hubs)
+
+
+def test_catalog_has_no_invented_aws_new_york_region():
+    from greenpick.data.static_data import regions
+    assert "us-east-nyc" not in regions()["aws"]
+
+
+# --- 0.1.5: secrets never reach logs; a slow upstream can't freeze a tool call ---
+
+import logging
+
+
+def test_http_libraries_do_not_log_request_urls():
+    import greenpick  # noqa: F401  (import side effect sets the levels)
+    # httpx logs full request URLs (which carry our API keys) at INFO; we keep it at WARNING.
+    assert logging.getLogger("httpx").getEffectiveLevel() >= logging.WARNING
+    assert logging.getLogger("httpcore").getEffectiveLevel() >= logging.WARNING
+
+
+@pytest.mark.asyncio
+async def test_eia_key_never_appears_in_logs(monkeypatch, caplog):
+    caplog.set_level(logging.DEBUG)
+    secret = "EIA-SECRET-123"
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(500, text="boom")   # raise_for_status -> exception text embeds URL
+
+    orig = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient",
+                        lambda *a, **k: orig(transport=_mock_transport(handler)))
+    r = await EIARepository(api_key=secret).carbon_now("aws", "us-east-1")
+    assert r.quality == "mock"
+    assert secret not in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_entsoe_token_never_appears_in_logs(monkeypatch, caplog):
+    caplog.set_level(logging.DEBUG)
+    secret = "ENTSOE-SECRET-456"
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(503, text="unavailable")
+
+    orig = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient",
+                        lambda *a, **k: orig(transport=_mock_transport(handler)))
+    monkeypatch.setattr("greenpick.data.entsoe_repository.asyncio.sleep", _no_sleep)
+    r = await ENTSOERepository(token=secret).carbon_now("aws", "eu-north-1")
+    assert r.quality == "mock"
+    assert secret not in caplog.text
+
+
+async def _no_sleep(_seconds):
+    return None
+
+
+@pytest.mark.asyncio
+async def test_entsoe_slow_upstream_is_bounded(monkeypatch):
+    import asyncio, time as _time
+    from greenpick.data import entsoe_repository as er
+
+    async def handler(request: httpx.Request) -> httpx.Response:
+        await asyncio.sleep(30)   # an upstream that never answers in time
+        return httpx.Response(200, text="")
+
+    orig = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient",
+                        lambda *a, **k: orig(transport=_mock_transport(handler)))
+    monkeypatch.setattr(er, "_FETCH_BUDGET_S", 1.0)
+    start = _time.monotonic()
+    r = await ENTSOERepository(token="t").carbon_now("aws", "eu-north-1")
+    assert r.quality == "mock"                    # degraded to the labelled fallback...
+    assert _time.monotonic() - start < 3.0        # ...within the budget, not 30s+
+
+
+@pytest.mark.asyncio
+async def test_entsoe_remembers_an_outage(monkeypatch):
+    calls = {"n": 0}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls["n"] += 1
+        raise httpx.ConnectError("down", request=request)
+
+    orig = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient",
+                        lambda *a, **k: orig(transport=_mock_transport(handler)))
+    monkeypatch.setattr("greenpick.data.entsoe_repository.asyncio.sleep", _no_sleep)
+    repo = ENTSOERepository(token="t")
+    await repo.carbon_now("aws", "eu-north-1")
+    after_first = calls["n"]
+    assert after_first >= 1
+    # Same zone again (now, and as history): skipped immediately, no new upstream calls.
+    again = await repo.carbon_now("aws", "eu-north-1")
+    await repo.carbon_history("aws", "eu-north-1")
+    assert again.quality == "mock"
+    assert calls["n"] == after_first

greenpick-0.1.3/src/greenpick/__init__.py

@@ -1,7 +0,0 @@
-"""GreenPick — design-time sustainability co-pilot (MCP server).
-
-Greener cloud-region choices with honest carbon + cost + latency tradeoffs,
-delivered inside the vibe-coding loop. Directional guidance, not audited accounting.
-"""
-
-__version__ = "0.1.3"