feat: implement NdviIndicator.harvest() with graceful degradation

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>

app/indicators/ndvi.py

@@ -84,6 +84,119 @@ class NdviIndicator(BaseIndicator):
             submit_as_batch(conn, true_color_cube, f"ndvi-truecolor-{aoi.name}"),
         ]
 
+    async def harvest(
+        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None,
+        batch_jobs: list | None = None,
+    ) -> IndicatorResult:
+        """Download completed batch job results and compute NDVI statistics."""
+        current_job, baseline_job, true_color_job = batch_jobs
+
+        results_dir = tempfile.mkdtemp(prefix="aperture_ndvi_batch_")
+
+        # Download current NDVI — required
+        try:
+            current_dir = os.path.join(results_dir, "current")
+            paths = current_job.download_results(current_dir)
+            current_path = self._find_tif(paths, current_dir)
+        except Exception as exc:
+            logger.warning("NDVI current batch download failed: %s", exc)
+            return self._fallback(aoi, time_range)
+
+        # Download baseline — optional (degrades gracefully)
+        baseline_path = None
+        try:
+            baseline_dir = os.path.join(results_dir, "baseline")
+            paths = baseline_job.download_results(baseline_dir)
+            baseline_path = self._find_tif(paths, baseline_dir)
+        except Exception as exc:
+            logger.warning("NDVI baseline batch download failed, degrading: %s", exc)
+
+        # Download true-color — optional
+        true_color_path = None
+        try:
+            tc_dir = os.path.join(results_dir, "truecolor")
+            paths = true_color_job.download_results(tc_dir)
+            true_color_path = self._find_tif(paths, tc_dir)
+        except Exception as exc:
+            logger.warning("NDVI true-color batch download failed: %s", exc)
+
+        # Compute statistics
+        current_stats = self._compute_stats(current_path)
+        current_mean = current_stats["overall_mean"]
+
+        if baseline_path:
+            baseline_stats = self._compute_stats(baseline_path)
+            baseline_mean = baseline_stats["overall_mean"]
+            change = current_mean - baseline_mean
+            confidence = (
+                ConfidenceLevel.HIGH if current_stats["valid_months"] >= 6
+                else ConfidenceLevel.MODERATE if current_stats["valid_months"] >= 3
+                else ConfidenceLevel.LOW
+            )
+            chart_data = self._build_chart_data(
+                current_stats["monthly_means"],
+                baseline_stats["monthly_means"],
+                time_range,
+            )
+        else:
+            baseline_mean = current_mean
+            change = 0.0
+            confidence = ConfidenceLevel.LOW
+            chart_data = {
+                "dates": [f"{time_range.end.year}-{m+1:02d}" for m in range(len(current_stats["monthly_means"]))],
+                "values": [round(v, 3) for v in current_stats["monthly_means"]],
+                "label": "NDVI",
+            }
+
+        status = self._classify(change)
+        trend = self._compute_trend(change) if baseline_path else TrendDirection.STABLE
+
+        if abs(change) <= 0.05:
+            headline = f"Vegetation stable (NDVI {current_mean:.2f}, \u0394{change:+.2f} vs baseline)"
+        elif change > 0:
+            headline = f"Vegetation greening (NDVI +{change:.2f} vs baseline)"
+        else:
+            headline = f"Vegetation decline (NDVI {change:.2f} vs baseline)"
+
+        self._spatial_data = SpatialData(
+            map_type="raster", label="NDVI", colormap="RdYlGn",
+            vmin=-0.2, vmax=0.9,
+        )
+        self._indicator_raster_path = current_path
+        self._true_color_path = true_color_path
+        self._ndvi_peak_band = current_stats["peak_month_band"]
+        self._render_band = current_stats["peak_month_band"]
+
+        return IndicatorResult(
+            indicator_id=self.id,
+            headline=headline,
+            status=status,
+            trend=trend,
+            confidence=confidence,
+            map_layer_path=current_path,
+            chart_data=chart_data,
+            data_source="satellite",
+            summary=(
+                f"Mean NDVI is {current_mean:.3f} compared to a {BASELINE_YEARS}-year "
+                f"baseline of {baseline_mean:.3f} (\u0394{change:+.3f}). "
+                f"Pixel-level analysis at {RESOLUTION_M}m resolution from "
+                f"{current_stats['valid_months']} monthly composites."
+            ),
+            methodology=(
+                f"Sentinel-2 L2A pixel-level NDVI = (B08 \u2212 B04) / (B08 + B04). "
+                f"Cloud-masked using SCL band (classes 4, 5, 6 retained). "
+                f"Monthly median composites at {RESOLUTION_M}m resolution. "
+                f"Baseline: {BASELINE_YEARS}-year monthly medians. "
+                f"Processed server-side via CDSE openEO batch jobs."
+            ),
+            limitations=[
+                f"Resampled to {RESOLUTION_M}m \u2014 sub-field variability not captured at this resolution.",
+                "Cloud cover reduces observation count in rainy seasons.",
+                "NDVI does not distinguish crop from natural vegetation.",
+                "Seasonal variation may mask long-term trends if analysis windows differ.",
+            ] + (["Baseline unavailable \u2014 change and trend not computed."] if not baseline_path else []),
+        )
+
     async def process(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
     ) -> IndicatorResult:
@@ -299,6 +412,19 @@ class NdviIndicator(BaseIndicator):
             "label": "NDVI",
         }
 
+    @staticmethod
+    def _find_tif(download_paths: dict, fallback_dir: str) -> str:
+        """Find the GeoTIFF file from batch job download results."""
+        if download_paths:
+            for p in download_paths:
+                if str(p).endswith(".tif") or str(p).endswith(".tiff"):
+                    return str(p)
+        # Fallback: look for any .tif in the directory
+        for f in os.listdir(fallback_dir):
+            if f.endswith(".tif") or f.endswith(".tiff"):
+                return os.path.join(fallback_dir, f)
+        raise FileNotFoundError(f"No GeoTIFF found in {fallback_dir}")
+
     def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
         """Return a placeholder result when openEO processing fails."""
         rng = np.random.default_rng(7)

tests/test_indicator_ndvi.py

@@ -151,3 +151,115 @@ async def test_ndvi_submit_batch_creates_three_jobs(test_aoi, test_time_range):
     assert len(jobs) == 3
     assert mock_ndvi_graph.call_count == 2  # current + baseline
     assert mock_tc_graph.call_count == 1    # true-color
+
+
+@pytest.mark.asyncio
+async def test_ndvi_harvest_computes_result_from_batch_jobs(test_aoi, test_time_range):
+    """harvest() downloads batch results and returns IndicatorResult."""
+    from app.indicators.ndvi import NdviIndicator
+
+    indicator = NdviIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        ndvi_path = os.path.join(tmpdir, "ndvi.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_ndvi_tif(ndvi_path)
+        _mock_true_color_tif(rgb_path)
+
+        def make_mock_job(src_path):
+            job = MagicMock()
+            job.job_id = "j-test"
+
+            def fake_download_results(target):
+                import shutil
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            job.status.return_value = "finished"
+            return job
+
+        current_job = make_mock_job(ndvi_path)
+        baseline_job = make_mock_job(ndvi_path)
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.indicator_id == "ndvi"
+    assert result.data_source == "satellite"
+    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
+    assert result.confidence in (ConfidenceLevel.HIGH, ConfidenceLevel.MODERATE, ConfidenceLevel.LOW)
+    assert len(result.chart_data.get("dates", [])) > 0
+
+
+@pytest.mark.asyncio
+async def test_ndvi_harvest_degrades_when_baseline_fails(test_aoi, test_time_range):
+    """harvest() returns partial result when baseline job failed."""
+    from app.indicators.ndvi import NdviIndicator
+
+    indicator = NdviIndicator()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        ndvi_path = os.path.join(tmpdir, "ndvi.tif")
+        rgb_path = os.path.join(tmpdir, "rgb.tif")
+        _mock_ndvi_tif(ndvi_path)
+        _mock_true_color_tif(rgb_path)
+
+        def make_mock_job(src_path, status="finished"):
+            job = MagicMock()
+            job.job_id = "j-test"
+            job.status.return_value = status
+
+            def fake_download_results(target):
+                if status == "error":
+                    raise Exception("Batch job failed on CDSE")
+                os.makedirs(target, exist_ok=True)
+                dest = os.path.join(target, "result.tif")
+                import shutil
+                shutil.copy(src_path, dest)
+                from pathlib import Path
+                return {Path(dest): {"type": "image/tiff"}}
+            job.download_results.side_effect = fake_download_results
+            return job
+
+        current_job = make_mock_job(ndvi_path)
+        baseline_job = make_mock_job(ndvi_path, status="error")
+        true_color_job = make_mock_job(rgb_path)
+
+        result = await indicator.harvest(
+            test_aoi, test_time_range,
+            batch_jobs=[current_job, baseline_job, true_color_job],
+        )
+
+    assert result.indicator_id == "ndvi"
+    assert result.data_source == "satellite"
+    assert result.confidence == ConfidenceLevel.LOW
+    assert result.trend == TrendDirection.STABLE
+
+
+@pytest.mark.asyncio
+async def test_ndvi_harvest_falls_back_when_current_fails(test_aoi, test_time_range):
+    """harvest() returns placeholder when current NDVI job failed."""
+    from app.indicators.ndvi import NdviIndicator
+
+    indicator = NdviIndicator()
+
+    current_job = MagicMock()
+    current_job.status.return_value = "error"
+    current_job.download_results.side_effect = Exception("failed")
+    baseline_job = MagicMock()
+    baseline_job.status.return_value = "finished"
+    true_color_job = MagicMock()
+    true_color_job.status.return_value = "finished"
+
+    result = await indicator.harvest(
+        test_aoi, test_time_range,
+        batch_jobs=[current_job, baseline_job, true_color_job],
+    )
+
+    assert result.data_source == "placeholder"