Fix rerun activity weather and HR context

Author: seanap

chronicle/activity_pipeline.py

@@ -2272,6 +2272,14 @@ def _get_garmin_metrics(client: Any | None) -> dict[str, Any]:
 def _merge_hr_cadence_from_strava(training: dict[str, Any], detailed_activity: dict[str, Any]) -> tuple[Any, Any]:
     average_hr = training.get("average_hr", "N/A")
     running_cadence = training.get("running_cadence", "N/A")
+    garmin_last = training.get("garmin_last_activity") if isinstance(training.get("garmin_last_activity"), dict) else {}
+    if training.get("_garmin_activity_aligned"):
+        garmin_average_hr = garmin_last.get("average_hr")
+        if garmin_average_hr not in {None, "", "N/A"}:
+            average_hr = garmin_average_hr
+        garmin_cadence = garmin_last.get("cadence_spm")
+        if garmin_cadence not in {None, "", "N/A"}:
+            running_cadence = garmin_cadence
 
     strava_hr = detailed_activity.get("average_heartrate")
     if average_hr == "N/A" and isinstance(strava_hr, (int, float)):

chronicle/stat_modules/garmin_metrics.py

@@ -613,6 +613,9 @@ def _build_garmin_last_activity_context(
         "max_hr": int(round(_as_float(last_activity.get("maxHR")) or 0))
         if isinstance(last_activity.get("maxHR"), (int, float))
         else "N/A",
+        "cadence_spm": int(round(_as_float(last_activity.get("averageRunningCadenceInStepsPerMinute")) or 0))
+        if isinstance(last_activity.get("averageRunningCadenceInStepsPerMinute"), (int, float))
+        else "N/A",
         "avg_power_w": int(round(avg_power)) if avg_power is not None else "N/A",
         "norm_power_w": int(round(norm_power)) if norm_power is not None else "N/A",
         "max_power_w": int(round(max_power)) if max_power is not None else "N/A",

chronicle/stat_modules/misery_index.py

@@ -752,12 +752,25 @@ def get_misery_index_details_for_activity(
         return None
 
     lat, lon = start_latlng
+    weather_data: dict[str, Any] | None = None
+    aqi: int | None = None
+    weather_error: requests.RequestException | None = None
+    aqi_error: requests.RequestException | None = None
     try:
         weather_data = _get_weather_data(weather_api_key, float(lat), float(lon), activity_time)
+    except requests.RequestException as exc:
+        weather_error = exc
+        logger.error("Weather API weather request failed: %s", exc)
+    try:
         aqi = _get_air_quality_index(weather_api_key, float(lat), float(lon))
     except requests.RequestException as exc:
-        logger.error("Weather API request failed: %s", exc)
-        return None
+        aqi_error = exc
+        logger.error("Weather API AQI request failed: %s", exc)
+
+    if weather_data is None and aqi is None and (weather_error is not None or aqi_error is not None):
+        if weather_error is not None:
+            raise weather_error
+        raise aqi_error if aqi_error is not None else requests.RequestException("Weather API request failed")
 
     if not weather_data:
         return {

tests/test_activity_pipeline.py

@@ -161,6 +161,48 @@ def test_description_context_exposes_activity_badges(self) -> None:
         self.assertEqual(context.get("smashrun_activity_badges"), ["Two by 365 by 10k"])
         self.assertEqual(context.get("smashrun", {}).get("activity_badges"), ["Two by 365 by 10k"])
 
+    def test_description_context_uses_aligned_garmin_activity_hr_and_cadence(self) -> None:
+        context = _build_description_context(
+            detailed_activity={
+                "id": 17455368360,
+                "name": "Lunch Run",
+                "type": "Run",
+                "sport_type": "Run",
+                "distance": 8046.72,
+                "moving_time": 2400,
+                "elapsed_time": 2460,
+                "average_speed": 3.3528,
+                "average_heartrate": 151,
+                "average_cadence": 88.0,
+                "start_latlng": [33.75, -84.39],
+            },
+            training={
+                "average_hr": 143,
+                "running_cadence": 176,
+                "_garmin_activity_aligned": True,
+                "garmin_last_activity": {
+                    "activity_id": 3002,
+                    "average_hr": 167,
+                    "cadence_spm": 182,
+                },
+                "garmin_segment_notables": [],
+            },
+            intervals_payload={},
+            week={"gap": "8:00/mi", "distance": 10.0, "elevation": 100.0, "duration": "1:20:00", "beers_earned": 6.0, "calories": 1000, "run_count": 2},
+            month={"gap": "8:10/mi", "distance": 40.0, "elevation": 400.0, "duration": "5:20:00", "beers_earned": 25.0, "calories": 4000, "run_count": 8},
+            year={"gap": "8:20/mi", "distance": 80.0, "elevation": 800.0, "duration": "10:40:00", "beers_earned": 50.0, "calories": 8000, "run_count": 16},
+            longest_streak=None,
+            notables=[],
+            latest_elevation_feet=None,
+            misery_index=None,
+            misery_index_description=None,
+            air_quality_index=None,
+            aqi_description=None,
+        )
+
+        self.assertEqual(context.get("activity", {}).get("average_hr"), 167)
+        self.assertEqual(context.get("activity", {}).get("cadence_spm"), 182)
+
 
 class TestActivitySmashrunBadges(unittest.TestCase):
     def test_extract_activity_smashrun_badges_matches_smashrun_and_strava_ids(self) -> None:

tests/test_garmin_metrics.py

@@ -300,6 +300,7 @@ def test_fetch_training_status_returns_expanded_fields(self) -> None:
         self.assertEqual(last_activity["distance_miles"], "8.02 mi")
         self.assertEqual(last_activity["activity_id"], 21922402831)
         self.assertEqual(last_activity["average_pace"], "7:19/mi")
+        self.assertEqual(last_activity["cadence_spm"], 176)
         self.assertIn("Z1", last_activity["hr_zone_summary"])
         self.assertEqual(last_activity["total_sets"], 2)
         self.assertEqual(last_activity["active_sets"], 2)

tests/test_misery_index.py

@@ -1,9 +1,13 @@
 import unittest
+from unittest.mock import patch
+
+import requests
 
 from chronicle.stat_modules.misery_index import (
     calculate_misery_index,
     calculate_misery_index_components,
     get_aqi_description,
+    get_misery_index_details_for_activity,
     get_misery_index_description,
 )
 
@@ -240,6 +244,43 @@ def test_aqi_description(self) -> None:
         self.assertEqual(get_aqi_description(1), "😃")
         self.assertEqual(get_aqi_description(99), "Unknown")
 
+    def test_activity_details_keep_weather_when_aqi_lookup_fails(self) -> None:
+        activity = {
+            "start_date": "2026-03-07T12:00:00Z",
+            "start_latlng": [33.75, -84.39],
+        }
+        with patch(
+            "chronicle.stat_modules.misery_index._get_weather_data",
+            return_value={
+                "temp_f": 62.0,
+                "dewpoint_f": 48.0,
+                "humidity": 55.0,
+                "wind_mph": 4.0,
+                "cloud": 20.0,
+                "precip_in": 0.0,
+                "is_day": True,
+                "chance_of_rain": 5.0,
+                "chance_of_snow": 0.0,
+                "will_it_rain": False,
+                "will_it_snow": False,
+                "condition_text": "Sunny",
+                "heatindex_f": 62.0,
+                "windchill_f": 62.0,
+                "tz_id": "America/New_York",
+            },
+        ), patch(
+            "chronicle.stat_modules.misery_index._get_air_quality_index",
+            side_effect=requests.RequestException("aqi unavailable"),
+        ):
+            details = get_misery_index_details_for_activity(activity, "weather-key")
+
+        self.assertIsNotNone(details)
+        assert details is not None
+        self.assertIsInstance(details["misery_index"], float)
+        self.assertEqual(details["aqi"], None)
+        self.assertEqual(details["aqi_description"], "Unknown")
+        self.assertEqual(details["weather"]["temp_f"], 62.0)
+
 
 if __name__ == "__main__":
     unittest.main()