greenpick 0.1.2__tar.gz → 0.1.4__tar.gz

{greenpick-0.1.2/src/greenpick.egg-info → greenpick-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.1.2
+Version: 0.1.4
 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
@@ -193,8 +193,9 @@ See `docs/user-questions-backlog.md`.
 - Instance-family efficiency: directional perf-per-watt multipliers (`data/instance_families.json`).
 - Latency: great-circle distance from region coordinates to the user's location.
 
-Set `EIA_API_KEY` and `ENTSOE_TOKEN` in `.env` (both free) for live carbon; `GREENPICK_CARBON_SOURCE`
-selects the source (`auto` routes US→EIA, EU→ENTSO-E, else mock).
+Set `EIA_API_KEY` and `ENTSOE_TOKEN` (both free) for live carbon — see
+[Turn on live data](#turn-on-live-data); `GREENPICK_CARBON_SOURCE` selects the source (`auto` routes
+US→EIA, EU→ENTSO-E, else mock).
 
 The data layer is a swappable repository (`MOCK` by default, works offline). Nothing here invents
 numbers: the LLM writes the *rationale*, the code supplies the *figures*.

{greenpick-0.1.2 → greenpick-0.1.4}/README.md

@@ -163,8 +163,9 @@ See `docs/user-questions-backlog.md`.
 - Instance-family efficiency: directional perf-per-watt multipliers (`data/instance_families.json`).
 - Latency: great-circle distance from region coordinates to the user's location.
 
-Set `EIA_API_KEY` and `ENTSOE_TOKEN` in `.env` (both free) for live carbon; `GREENPICK_CARBON_SOURCE`
-selects the source (`auto` routes US→EIA, EU→ENTSO-E, else mock).
+Set `EIA_API_KEY` and `ENTSOE_TOKEN` (both free) for live carbon — see
+[Turn on live data](#turn-on-live-data); `GREENPICK_CARBON_SOURCE` selects the source (`auto` routes
+US→EIA, EU→ENTSO-E, else mock).
 
 The data layer is a swappable repository (`MOCK` by default, works offline). Nothing here invents
 numbers: the LLM writes the *rationale*, the code supplies the *figures*.

{greenpick-0.1.2 → greenpick-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "greenpick"
-version = "0.1.2"
+version = "0.1.4"
 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.2 → greenpick-0.1.4}/src/greenpick/__init__.py

@@ -4,4 +4,4 @@ Greener cloud-region choices with honest carbon + cost + latency tradeoffs,
 delivered inside the vibe-coding loop. Directional guidance, not audited accounting.
 """
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"

{greenpick-0.1.2 → greenpick-0.1.4}/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.2 → greenpick-0.1.4}/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.2 → greenpick-0.1.4}/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.2 → greenpick-0.1.4}/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.2 → greenpick-0.1.4}/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.2 → greenpick-0.1.4}/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.2 → greenpick-0.1.4}/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.2 → greenpick-0.1.4/src/greenpick.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenpick
-Version: 0.1.2
+Version: 0.1.4
 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
@@ -193,8 +193,9 @@ See `docs/user-questions-backlog.md`.
 - Instance-family efficiency: directional perf-per-watt multipliers (`data/instance_families.json`).
 - Latency: great-circle distance from region coordinates to the user's location.
 
-Set `EIA_API_KEY` and `ENTSOE_TOKEN` in `.env` (both free) for live carbon; `GREENPICK_CARBON_SOURCE`
-selects the source (`auto` routes US→EIA, EU→ENTSO-E, else mock).
+Set `EIA_API_KEY` and `ENTSOE_TOKEN` (both free) for live carbon — see
+[Turn on live data](#turn-on-live-data); `GREENPICK_CARBON_SOURCE` selects the source (`auto` routes
+US→EIA, EU→ENTSO-E, else mock).
 
 The data layer is a swappable repository (`MOCK` by default, works offline). Nothing here invents
 numbers: the LLM writes the *rationale*, the code supplies the *figures*.

{greenpick-0.1.2 → greenpick-0.1.4}/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,74 @@ 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"]