refactor: strip to 4 real EO indicators, remove all tests and mock fallbacks

Keep only NDVI, Water (MNDWI), SAR, and Built-up — the four indicators
with full openEO batch pipelines. Remove 8 unused indicators, all test
files, and every placeholder/fallback path. Failures now propagate as
errors instead of silently returning synthetic data.

- Delete: cropland, fires, food_security, lst, nightlights, no2, rainfall, vegetation
- Delete: entire tests/ directory
- Remove _fallback() from all indicators — process() raises on failure
- Remove harvest() fallback-to-placeholder on current data failure
- Worker no longer falls back to process() when batch submit fails
- Remove placeholder caveat from narrative engine and PDF report
- Re-weight overview scores for 4 indicators (ndvi 0.30, sar 0.25, water 0.25, buildup 0.20)
- Remove build_lst_graph from openeo_client

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/config.py

@@ -23,13 +23,8 @@ OPENEO_CLIENT_SECRET: str | None = os.environ.get("OPENEO_CLIENT_SECRET")
 # Normalized to 1.0. Indicators not selected or skipped are excluded
 # and weights are re-normalized.
 OVERVIEW_WEIGHTS: dict[str, float] = {
-    "fires": 0.20,
-    "sar": 0.15,
-    "buildup": 0.15,
-    "ndvi": 0.12,
-    "water": 0.10,
-    "rainfall": 0.10,
-    "lst": 0.08,
-    "no2": 0.05,
-    "nightlights": 0.05,
+    "ndvi": 0.30,
+    "sar": 0.25,
+    "water": 0.25,
+    "buildup": 0.20,
 }

app/indicators/__init__.py

@@ -1,27 +1,11 @@
 from app.indicators.base import IndicatorRegistry
-from app.indicators.fires import FiresIndicator
-from app.indicators.cropland import CroplandIndicator
-from app.indicators.vegetation import VegetationIndicator
-from app.indicators.rainfall import RainfallIndicator
-from app.indicators.water import WaterIndicator
-from app.indicators.no2 import NO2Indicator
-from app.indicators.lst import LSTIndicator
-from app.indicators.nightlights import NightlightsIndicator
-from app.indicators.food_security import FoodSecurityIndicator
 from app.indicators.ndvi import NdviIndicator
+from app.indicators.water import WaterIndicator
 from app.indicators.sar import SarIndicator
 from app.indicators.buildup import BuiltupIndicator
 
 registry = IndicatorRegistry()
 registry.register(NdviIndicator())
-registry.register(FiresIndicator())
-registry.register(CroplandIndicator())
-registry.register(VegetationIndicator())
-registry.register(RainfallIndicator())
 registry.register(WaterIndicator())
-registry.register(NO2Indicator())
-registry.register(LSTIndicator())
-registry.register(NightlightsIndicator())
-registry.register(FoodSecurityIndicator())
 registry.register(SarIndicator())
 registry.register(BuiltupIndicator())

app/indicators/buildup.py

@@ -97,8 +97,7 @@ class BuiltupIndicator(BaseIndicator):
             paths = current_job.download_results(current_dir)
             current_path = self._find_tif(paths, current_dir)
         except Exception as exc:
-            logger.warning("Buildup current batch download failed: %s", exc)
-            return self._fallback(aoi, time_range)
+            raise RuntimeError(f"Built-up current period data unavailable: {exc}") from exc
 
         # Download baseline — optional (degrades gracefully)
         baseline_path = None
@@ -260,11 +259,7 @@ class BuiltupIndicator(BaseIndicator):
     async def process(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
     ) -> IndicatorResult:
-        try:
-            return await self._process_openeo(aoi, time_range, season_months)
-        except Exception as exc:
-            logger.warning("Built-up openEO processing failed, using placeholder: %s", exc)
-            return self._fallback(aoi, time_range)
+        return await self._process_openeo(aoi, time_range, season_months)
 
     async def _process_openeo(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
@@ -503,27 +498,4 @@ class BuiltupIndicator(BaseIndicator):
         with rasterio.open(output_path, "w", **profile) as dst:
             dst.write(change, 1)
 
-    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        rng = np.random.default_rng(11)
-        baseline = float(rng.uniform(5, 20))
-        current = baseline * float(rng.uniform(0.85, 1.15))
-        change = current - baseline
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=f"Settlement data degraded ({current:.1f}% extent)",
-            status=StatusLevel.GREEN if abs(change) < 5 else StatusLevel.AMBER,
-            trend=TrendDirection.STABLE,
-            confidence=ConfidenceLevel.LOW,
-            map_layer_path="",
-            chart_data={
-                "dates": [str(time_range.start.year), str(time_range.end.year)],
-                "values": [round(baseline, 1), round(current, 1)],
-                "label": "Built-up area (ha)",
-            },
-            data_source="placeholder",
-            summary="openEO processing unavailable. Showing placeholder values.",
-            methodology="Placeholder — no satellite data processed.",
-            limitations=["Data is synthetic. openEO backend was unreachable."],
-        )
 

app/indicators/cropland.py

@@ -1,343 +0,0 @@
-from __future__ import annotations
-
-from collections import defaultdict
-from datetime import date
-from typing import Any
-
-import numpy as np
-
-from app.indicators.base import BaseIndicator
-from app.models import (
-    AOI,
-    TimeRange,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-
-BASELINE_YEARS = 3
-MAX_ITEMS = 100
-
-
-class CroplandIndicator(BaseIndicator):
-    id = "cropland"
-    name = "Cropland Productivity"
-    category = "D1"
-    question = "Is farmland being cultivated or abandoned?"
-    estimated_minutes = 5
-
-    async def process(self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None) -> IndicatorResult:
-        baseline_mean, current_mean, n_months = await self._fetch_comparison(aoi, time_range, season_months)
-
-        # Use percentage-point change rather than ratio — more meaningful
-        # for scene-level vegetation cover which can swing widely
-        change_pp = current_mean - baseline_mean  # positive = greening
-        abs_change = abs(change_pp)
-
-        status = self._classify(change_pp)
-        trend = self._compute_trend(change_pp)
-        confidence = (
-            ConfidenceLevel.HIGH if n_months >= 6
-            else ConfidenceLevel.MODERATE if n_months >= 3
-            else ConfidenceLevel.LOW
-        )
-
-        current_monthly = getattr(self, '_current_monthly_medians', None)
-        baseline_per_year_monthly = getattr(self, '_baseline_per_year_monthly', None)
-        if current_monthly and baseline_per_year_monthly:
-            chart_data = self._build_monthly_chart_data(
-                current_monthly=current_monthly,
-                baseline_per_year_monthly=baseline_per_year_monthly,
-                time_range=time_range,
-                season_months=season_months,
-            )
-        else:
-            chart_data = self._build_chart_data(baseline_mean, current_mean, time_range, getattr(self, '_baseline_yearly_means', None))
-
-        if abs_change <= 5:
-            headline = f"Cropland vegetation stable ({current_mean:.0f}% cover, ±{abs_change:.0f}pp vs baseline)"
-        elif change_pp > 0:
-            headline = f"Cropland vegetation increased (+{change_pp:.0f}pp vs baseline — possible greening)"
-        else:
-            headline = f"Cropland vegetation declined ({change_pp:.0f}pp vs baseline — possible abandonment)"
-
-        # Store spatial data for map rendering
-        from app.indicators.base import SpatialData
-        tile_geojson = await self._fetch_tile_footprints(aoi, time_range, season_months)
-        if tile_geojson["features"]:
-            self._spatial_data = SpatialData(
-                geojson=tile_geojson,
-                map_type="choropleth",
-                label="Vegetation cover (%)",
-                colormap="YlGn",
-            )
-        else:
-            self._spatial_data = None
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=headline,
-            status=status,
-            trend=trend,
-            confidence=confidence,
-            map_layer_path="",
-            chart_data=chart_data,
-            data_source="placeholder" if getattr(self, '_is_placeholder', False) else "satellite",
-            summary=(
-                f"Mean vegetation cover is {current_mean:.1f}% compared to a {BASELINE_YEARS}-year "
-                f"baseline of {baseline_mean:.1f}% ({change_pp:+.1f} percentage points). "
-                f"Month-matched comparison using {n_months} overlapping months. "
-                f"Status: {status.value}. Trend: {trend.value}."
-            ),
-            methodology=(
-                "Sentinel-2 scene-level vegetation percentage (s2:vegetation_percentage) "
-                "is extracted from STAC metadata for cloud-free scenes during the growing "
-                "season only. Restricting to growing season isolates "
-                "cropland activity from year-round forest/shrub cover. Monthly medians "
-                "are compared between the current and baseline periods. "
-                f"Baseline: {BASELINE_YEARS} years. No pixel data is downloaded."
-            ),
-            limitations=[
-                "Uses scene-level vegetation percentage, not field-level NDVI.",
-                "Growing season months are user-configurable (defaults to all months).",
-                "Cloud cover during peak season can reduce observation count.",
-                "Vegetation percentage includes non-crop vegetation within scenes.",
-                "Sentinel-2 data availability may be limited to after 2017.",
-            ],
-        )
-
-    async def _fetch_tile_footprints(self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None) -> dict:
-        """Fetch S2 tile footprints with median vegetation % per tile."""
-        try:
-            import asyncio
-            import pystac_client
-        except ImportError:
-            return {"type": "FeatureCollection", "features": []}
-
-        try:
-            catalog = pystac_client.Client.open(
-                "https://earth-search.aws.element84.com/v1"
-            )
-            current_year = time_range.end.year
-            months = season_months or list(range(1, 13))
-
-            def _query():
-                from collections import defaultdict
-                from datetime import date as _date
-                start = _date(current_year, min(months), 1)
-                end = _date(current_year, max(months), 30)
-                items = catalog.search(
-                    collections=["sentinel-2-l2a"],
-                    bbox=aoi.bbox,
-                    datetime=f"{start.isoformat()}/{end.isoformat()}",
-                    query={"eo:cloud_cover": {"lt": 30}},
-                    max_items=MAX_ITEMS,
-                ).item_collection()
-
-                tile_vals: dict[str, list[float]] = defaultdict(list)
-                tile_geom: dict[str, dict] = {}
-                for item in items:
-                    grid = item.properties.get("grid:code", item.id)
-                    veg = item.properties.get("s2:vegetation_percentage")
-                    if veg is not None:
-                        tile_vals[grid].append(float(veg))
-                        if grid not in tile_geom:
-                            tile_geom[grid] = item.geometry
-                return tile_vals, tile_geom
-
-            loop = asyncio.get_event_loop()
-            tile_vals, tile_geom = await loop.run_in_executor(None, _query)
-
-            features = []
-            for grid, vals in tile_vals.items():
-                if grid in tile_geom:
-                    features.append({
-                        "type": "Feature",
-                        "geometry": tile_geom[grid],
-                        "properties": {
-                            "value": float(np.median(vals)),
-                            "grid_code": grid,
-                        },
-                    })
-            return {"type": "FeatureCollection", "features": features}
-        except Exception:
-            return {"type": "FeatureCollection", "features": []}
-
-    async def _fetch_comparison(
-        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
-    ) -> tuple[float, float, int]:
-        """Returns (baseline_mean, current_mean, n_overlapping_months)."""
-        self._is_placeholder = False
-        try:
-            import pystac_client  # noqa: F401
-        except ImportError as exc:
-            import logging
-            logging.getLogger(__name__).warning(
-                "Cropland missing dependencies, using placeholder: %s", exc
-            )
-            self._is_placeholder = True
-            return self._synthetic()
-
-        try:
-            return await self._stac_comparison(aoi, time_range, season_months)
-        except Exception as exc:
-            import logging
-            logging.getLogger(__name__).warning(
-                "Cropland STAC query failed, using placeholder: %s", exc
-            )
-            self._is_placeholder = True
-            return self._synthetic()
-
-    async def _stac_comparison(
-        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
-    ) -> tuple[float, float, int]:
-        import asyncio
-        import pystac_client
-
-        catalog = pystac_client.Client.open(
-            "https://earth-search.aws.element84.com/v1"
-        )
-        current_year = time_range.end.year
-        baseline_start_year = current_year - BASELINE_YEARS
-        months = season_months or list(range(1, 13))
-
-        def _query_months(year: int) -> dict[int, list[float]]:
-            """Return {month: [vegetation_pct, ...]} for specified months."""
-            start = date(year, 1, 1)
-            end = date(year, 12, 31)
-            items = catalog.search(
-                collections=["sentinel-2-l2a"],
-                bbox=aoi.bbox,
-                datetime=f"{start.isoformat()}/{end.isoformat()}",
-                query={"eo:cloud_cover": {"lt": 30}},
-                max_items=MAX_ITEMS,
-            ).item_collection()
-            by_month: dict[int, list[float]] = defaultdict(list)
-            for item in items:
-                veg = item.properties.get("s2:vegetation_percentage")
-                if veg is not None and item.datetime:
-                    month = item.datetime.month
-                    if month in months:
-                        by_month[month].append(float(veg))
-            return dict(by_month)
-
-        loop = asyncio.get_event_loop()
-
-        # Current year monthly medians
-        current_monthly = await loop.run_in_executor(None, _query_months, current_year)
-
-        # Baseline: pool all years by month, then median per month
-        baseline_pool: dict[int, list[float]] = defaultdict(list)
-        baseline_yearly_means: list[float] = []
-        baseline_per_year_monthly: dict[int, list[float]] = defaultdict(list)
-        for yr in range(baseline_start_year, current_year):
-            yr_monthly = await loop.run_in_executor(None, _query_months, yr)
-            yr_medians = []
-            for month, vals in yr_monthly.items():
-                baseline_pool[month].extend(vals)
-                if vals:
-                    month_median = float(np.median(vals))
-                    yr_medians.append(month_median)
-                    baseline_per_year_monthly[month].append(month_median)
-            if yr_medians:
-                baseline_yearly_means.append(float(np.mean(yr_medians)))
-
-        # Month-matched comparison: only months with data in BOTH periods
-        baseline_medians = []
-        current_medians = []
-        for month in months:
-            b_vals = baseline_pool.get(month, [])
-            c_vals = current_monthly.get(month, [])
-            if b_vals and c_vals:
-                baseline_medians.append(float(np.median(b_vals)))
-                current_medians.append(float(np.median(c_vals)))
-
-        n_months = len(baseline_medians)
-        if n_months == 0:
-            self._is_placeholder = True
-            return self._synthetic()
-
-        self._baseline_yearly_means = baseline_yearly_means
-        self._current_monthly_medians = {m: float(np.median(v)) for m, v in current_monthly.items() if v}
-        self._baseline_per_year_monthly = dict(baseline_per_year_monthly)
-        return (
-            float(np.mean(baseline_medians)),
-            float(np.mean(current_medians)),
-            n_months,
-        )
-
-    @staticmethod
-    def _synthetic() -> tuple[float, float, int]:
-        rng = np.random.default_rng(42)
-        baseline = float(rng.uniform(30, 50))
-        current = baseline * float(rng.uniform(0.88, 1.02))
-        return baseline, current, 6
-
-    @staticmethod
-    def _classify(change_pp: float) -> StatusLevel:
-        """Classify based on percentage-point change. Decline is concern."""
-        if change_pp >= -5:
-            return StatusLevel.GREEN
-        if change_pp >= -15:
-            return StatusLevel.AMBER
-        return StatusLevel.RED
-
-    @staticmethod
-    def _compute_trend(change_pp: float) -> TrendDirection:
-        if abs(change_pp) <= 5:
-            return TrendDirection.STABLE
-        if change_pp > 0:
-            return TrendDirection.IMPROVING
-        return TrendDirection.DETERIORATING
-
-    @staticmethod
-    def _build_chart_data(
-        baseline: float, current: float, time_range: TimeRange,
-        baseline_yearly_means: list[float] | None = None,
-    ) -> dict[str, Any]:
-        data: dict[str, Any] = {
-            "dates": [str(time_range.start.year - 1), str(time_range.end.year)],
-            "values": [round(baseline, 1), round(current, 1)],
-            "label": "Vegetation cover (%)",
-        }
-        if baseline_yearly_means and len(baseline_yearly_means) >= 2:
-            data["baseline_range_mean"] = round(float(np.mean(baseline_yearly_means)), 1)
-            data["baseline_range_min"] = round(float(min(baseline_yearly_means)), 1)
-            data["baseline_range_max"] = round(float(max(baseline_yearly_means)), 1)
-        return data
-
-    @staticmethod
-    def _build_monthly_chart_data(
-        current_monthly: dict[int, float],
-        baseline_per_year_monthly: dict[int, list[float]],
-        time_range: TimeRange,
-        season_months: list[int] | None = None,
-    ) -> dict[str, Any]:
-        months = season_months or sorted(current_monthly.keys())
-        yr = time_range.end.year
-        dates = [f"{yr}-{m:02d}" for m in months if m in current_monthly]
-        values = [round(current_monthly[m], 1) for m in months if m in current_monthly]
-
-        b_mean, b_min, b_max = [], [], []
-        for m in months:
-            if m not in current_monthly:
-                continue
-            yr_vals = baseline_per_year_monthly.get(m, [])
-            if yr_vals:
-                b_mean.append(round(float(np.mean(yr_vals)), 1))
-                b_min.append(round(float(min(yr_vals)), 1))
-                b_max.append(round(float(max(yr_vals)), 1))
-            else:
-                b_mean.append(round(current_monthly[m], 1))
-                b_min.append(round(current_monthly[m], 1))
-                b_max.append(round(current_monthly[m], 1))
-
-        return {
-            "dates": dates,
-            "values": values,
-            "label": "Vegetation cover (%)",
-            "baseline_mean": b_mean,
-            "baseline_min": b_min,
-            "baseline_max": b_max,
-        }

app/indicators/fires.py

@@ -1,205 +0,0 @@
-from __future__ import annotations
-
-import io
-import csv
-from collections import defaultdict
-from datetime import date, timedelta
-from typing import Any
-
-import httpx
-
-from app.indicators.base import BaseIndicator
-from app.models import (
-    AOI,
-    TimeRange,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-
-FIRMS_URL = "https://firms.modaps.eosdis.nasa.gov/api/area/csv"
-FIRMS_MAP_KEY = "DEMO_KEY"  # override via env if needed
-CHUNK_DAYS = 10
-
-
-class FiresIndicator(BaseIndicator):
-    id = "fires"
-    name = "Active Fires"
-    category = "R3"
-    question = "Where are fires burning?"
-    estimated_minutes = 2
-
-    async def process(self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None) -> IndicatorResult:
-        rows = await self._fetch_firms(aoi, time_range)
-
-        count = len(rows)
-        status = self._classify(count)
-        trend = self._compute_trend(rows, time_range)
-        confidence = self._compute_confidence(rows)
-        chart_data = self._build_chart_data(rows, season_months)
-
-        if count == 0:
-            headline = "No active fires detected"
-        else:
-            headline = f"{count} active fire detection{'s' if count != 1 else ''} in period"
-
-        # Store spatial data for map rendering
-        if rows:
-            from app.indicators.base import SpatialData
-            self._spatial_data = SpatialData(
-                geojson=self._build_geojson(rows),
-                map_type="points",
-                label="Fire detections",
-            )
-        else:
-            self._spatial_data = None
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=headline,
-            status=status,
-            trend=trend,
-            confidence=confidence,
-            map_layer_path="",
-            chart_data=chart_data,
-            summary=(
-                f"{count} VIIRS fire detection{'s' if count != 1 else ''} recorded "
-                f"between {time_range.start} and {time_range.end}. "
-                f"Status: {status.value}. Trend: {trend.value}."
-            ),
-            methodology=(
-                "Fire detections sourced from the NASA FIRMS (Fire Information for "
-                "Resource Management System) VIIRS 375m active fire product."
-            ),
-            limitations=[
-                "VIIRS has a 375m spatial resolution — small fires may be missed.",
-                "Cloud cover can obscure fire detections.",
-                "Detections represent thermal anomalies, not confirmed fires.",
-            ],
-        )
-
-    async def _fetch_firms(self, aoi: AOI, time_range: TimeRange) -> list[dict]:
-        min_lon, min_lat, max_lon, max_lat = aoi.bbox
-        bbox_str = f"{min_lon},{min_lat},{max_lon},{max_lat}"
-
-        all_rows: list[dict] = []
-        current = time_range.start
-
-        async with httpx.AsyncClient(timeout=30) as client:
-            while current < time_range.end:
-                chunk_end = min(current + timedelta(days=CHUNK_DAYS - 1), time_range.end)
-                days = (chunk_end - current).days + 1
-                url = (
-                    f"{FIRMS_URL}/{FIRMS_MAP_KEY}/VIIRS_SNPP_NRT/"
-                    f"{bbox_str}/{days}/{current.isoformat()}"
-                )
-                response = await client.get(url)
-                if response.status_code == 200 and response.text.strip():
-                    reader = csv.DictReader(io.StringIO(response.text))
-                    for row in reader:
-                        acq = row.get("acq_date", "")
-                        if acq:
-                            try:
-                                row_date = date.fromisoformat(acq)
-                                if current <= row_date <= chunk_end:
-                                    all_rows.append(row)
-                            except ValueError:
-                                pass
-                current = chunk_end + timedelta(days=1)
-
-        return all_rows
-
-    @staticmethod
-    def _build_geojson(rows: list[dict]) -> dict:
-        features = []
-        for row in rows:
-            try:
-                lat = float(row["latitude"])
-                lon = float(row["longitude"])
-            except (KeyError, ValueError):
-                continue
-            features.append({
-                "type": "Feature",
-                "geometry": {"type": "Point", "coordinates": [lon, lat]},
-                "properties": {
-                    "confidence": row.get("confidence", "unknown"),
-                    "acq_date": row.get("acq_date", ""),
-                    "bright_ti4": row.get("bright_ti4", ""),
-                },
-            })
-        return {"type": "FeatureCollection", "features": features}
-
-    @staticmethod
-    def _classify(count: int) -> StatusLevel:
-        if count == 0:
-            return StatusLevel.GREEN
-        if count <= 5:
-            return StatusLevel.AMBER
-        return StatusLevel.RED
-
-    @staticmethod
-    def _compute_trend(rows: list[dict], time_range: TimeRange) -> TrendDirection:
-        if not rows:
-            return TrendDirection.STABLE
-
-        total_days = (time_range.end - time_range.start).days
-        mid = time_range.start + timedelta(days=total_days // 2)
-
-        first_half = 0
-        second_half = 0
-        for row in rows:
-            try:
-                row_date = date.fromisoformat(row["acq_date"])
-            except (KeyError, ValueError):
-                continue
-            if row_date < mid:
-                first_half += 1
-            else:
-                second_half += 1
-
-        if first_half == 0 and second_half == 0:
-            return TrendDirection.STABLE
-        if first_half == 0:
-            return TrendDirection.DETERIORATING
-        ratio = second_half / first_half
-        if ratio > 1.25:
-            return TrendDirection.DETERIORATING
-        if ratio < 0.8:
-            return TrendDirection.IMPROVING
-        return TrendDirection.STABLE
-
-    @staticmethod
-    def _compute_confidence(rows: list[dict]) -> ConfidenceLevel:
-        if not rows:
-            return ConfidenceLevel.HIGH
-        confidences = [r.get("confidence", "nominal").lower() for r in rows]
-        nominal_count = sum(1 for c in confidences if c == "nominal")
-        high_count = sum(1 for c in confidences if c in ("high", "h"))
-        total = len(confidences)
-        if total == 0:
-            return ConfidenceLevel.MODERATE
-        high_frac = (nominal_count + high_count) / total
-        if high_frac >= 0.8:
-            return ConfidenceLevel.HIGH
-        if high_frac >= 0.5:
-            return ConfidenceLevel.MODERATE
-        return ConfidenceLevel.LOW
-
-    @staticmethod
-    def _build_chart_data(rows: list[dict], season_months: list[int] | None = None) -> dict[str, Any]:
-        monthly: dict[str, int] = defaultdict(int)
-        for row in rows:
-            acq = row.get("acq_date", "")
-            if acq and len(acq) >= 7:
-                month_key = acq[:7]  # "YYYY-MM"
-                month_num = int(month_key[5:7])
-                if season_months is None or month_num in season_months:
-                    monthly[month_key] += 1
-
-        sorted_months = sorted(monthly.keys())
-        return {
-            "dates": sorted_months,
-            "values": [monthly[m] for m in sorted_months],
-            "label": "Fire detections per month",
-        }

app/indicators/food_security.py

@@ -1,152 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from app.indicators.base import BaseIndicator
-from app.models import (
-    AOI,
-    TimeRange,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-
-# Status ranking for worst-case aggregation
-_STATUS_RANK: dict[StatusLevel, int] = {
-    StatusLevel.GREEN: 0,
-    StatusLevel.AMBER: 1,
-    StatusLevel.RED: 2,
-}
-
-_TREND_RANK: dict[TrendDirection, int] = {
-    TrendDirection.IMPROVING: -1,
-    TrendDirection.STABLE: 0,
-    TrendDirection.DETERIORATING: 1,
-}
-
-_CONFIDENCE_RANK: dict[ConfidenceLevel, int] = {
-    ConfidenceLevel.HIGH: 2,
-    ConfidenceLevel.MODERATE: 1,
-    ConfidenceLevel.LOW: 0,
-}
-
-
-class FoodSecurityIndicator(BaseIndicator):
-    id = "food_security"
-    name = "Food Security Composite"
-    category = "F2"
-    question = "Combined crop, rain, and temperature signals"
-    estimated_minutes = 20
-
-    async def process(self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None) -> IndicatorResult:
-        # Import here to avoid circular import at module load time
-        from app.indicators import registry  # type: ignore[import]
-
-        component_ids = ["cropland", "rainfall", "lst"]
-        component_results: list[IndicatorResult] = []
-
-        for cid in component_ids:
-            try:
-                indicator = registry.get(cid)
-                result = await indicator.process(aoi, time_range)
-                component_results.append(result)
-            except Exception as exc:
-                # If a sub-indicator fails, degrade confidence but continue
-                import warnings
-                warnings.warn(f"Food security sub-indicator '{cid}' failed: {exc}")
-
-        if not component_results:
-            # Nothing worked — return a low-confidence red result
-            return self._fallback_result()
-
-        # Worst status across components
-        worst_status = max(
-            (r.status for r in component_results),
-            key=lambda s: _STATUS_RANK[s],
-        )
-
-        # Worst trend across components
-        worst_trend = max(
-            (r.trend for r in component_results),
-            key=lambda t: _TREND_RANK[t],
-        )
-
-        # Minimum confidence across components
-        min_confidence = min(
-            (r.confidence for r in component_results),
-            key=lambda c: _CONFIDENCE_RANK[c],
-        )
-
-        chart_data = self._build_chart_data(component_results)
-        any_placeholder = any(r.data_source == "placeholder" for r in component_results)
-        summary_parts = [f"{r.indicator_id.upper()}: {r.headline}" for r in component_results]
-
-        status_label = worst_status.value.upper()
-        if worst_status == StatusLevel.GREEN:
-            headline = "Food security indicators within normal range"
-        elif worst_status == StatusLevel.AMBER:
-            headline = "Some food security stress signals detected"
-        else:
-            headline = "Critical food security stress signals detected"
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=headline,
-            status=worst_status,
-            trend=worst_trend,
-            confidence=min_confidence,
-            map_layer_path="",
-            chart_data=chart_data,
-            data_source="placeholder" if any_placeholder else "satellite",
-            summary=(
-                f"Composite food security assessment [{status_label}] based on "
-                f"{len(component_results)} sub-indicators. "
-                + " | ".join(summary_parts)
-            ),
-            methodology=(
-                "The F2 Food Security Composite aggregates D1 (Cropland Productivity), "
-                "D5 (Rainfall Adequacy), and D6 (Land Surface Temperature) indicators. "
-                "The composite status reflects the worst-case signal across components; "
-                "confidence reflects the minimum confidence of any component."
-            ),
-            limitations=[
-                "Composite takes worst-case status — a single stressed component drives the result.",
-                "Each component carries its own limitations (see D1, D5, D6 indicators).",
-                "Food security depends on access and market factors not captured by remote sensing.",
-                "Composite does not account for adaptive coping mechanisms.",
-            ],
-        )
-
-    @staticmethod
-    def _build_chart_data(results: list[IndicatorResult]) -> dict[str, Any]:
-        """Build a chart comparing component status values."""
-        labels = [r.indicator_id for r in results]
-        # Map status to numeric severity for chart display
-        severity = [_STATUS_RANK[r.status] for r in results]
-        return {
-            "dates": labels,
-            "values": severity,
-            "label": "Component stress level (0=green, 1=amber, 2=red)",
-        }
-
-    @staticmethod
-    def _fallback_result() -> IndicatorResult:
-        return IndicatorResult(
-            indicator_id="food_security",
-            headline="Food security assessment unavailable — sub-indicators failed",
-            status=StatusLevel.RED,
-            trend=TrendDirection.STABLE,
-            confidence=ConfidenceLevel.LOW,
-            map_layer_path="",
-            chart_data={"dates": [], "values": [], "label": ""},
-            data_source="placeholder",
-            summary="No sub-indicator data could be retrieved.",
-            methodology=(
-                "The F2 Food Security Composite aggregates D1 (Cropland Productivity), "
-                "D5 (Rainfall Adequacy), and D6 (Land Surface Temperature) indicators."
-            ),
-            limitations=[
-                "All sub-indicators failed — results are unreliable.",
-            ],
-        )

app/indicators/lst.py

@@ -1,268 +0,0 @@
-"""Land Surface Temperature Indicator — Sentinel-3 SLSTR via CDSE openEO.
-
-Retrieves monthly mean LST from Sentinel-3 SLSTR, compares to 5-year
-baseline, and classifies using Z-score anomaly thresholds.
-"""
-from __future__ import annotations
-
-import logging
-import os
-import tempfile
-from datetime import date
-from typing import Any
-
-import numpy as np
-import rasterio
-
-from app.config import RESOLUTION_M
-from app.indicators.base import BaseIndicator, SpatialData
-from app.models import (
-    AOI,
-    TimeRange,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-from app.openeo_client import get_connection, build_lst_graph, build_true_color_graph, _bbox_dict
-
-logger = logging.getLogger(__name__)
-
-BASELINE_YEARS = 5
-
-
-class LSTIndicator(BaseIndicator):
-    id = "lst"
-    name = "Land Surface Temperature"
-    category = "D6"
-    question = "Unusual heat patterns?"
-    estimated_minutes = 8
-
-    _true_color_path: str | None = None
-
-    async def process(
-        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
-    ) -> IndicatorResult:
-        try:
-            return await self._process_openeo(aoi, time_range, season_months)
-        except Exception as exc:
-            logger.warning("LST openEO processing failed, using placeholder: %s", exc)
-            return self._fallback(aoi, time_range)
-
-    async def _process_openeo(
-        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
-    ) -> IndicatorResult:
-        import asyncio
-
-        conn = get_connection()
-        bbox = _bbox_dict(aoi.bbox)
-
-        current_start = time_range.start.isoformat()
-        current_end = time_range.end.isoformat()
-        baseline_start = date(
-            time_range.start.year - BASELINE_YEARS,
-            time_range.start.month,
-            time_range.start.day,
-        ).isoformat()
-        baseline_end = time_range.start.isoformat()
-
-        results_dir = tempfile.mkdtemp(prefix="aperture_lst_")
-
-        # LST at 1km (SLSTR native)
-        lst_resolution = max(RESOLUTION_M, 1000)
-
-        current_cube = build_lst_graph(
-            conn=conn, bbox=bbox,
-            temporal_extent=[current_start, current_end],
-            resolution_m=lst_resolution,
-        )
-        baseline_cube = build_lst_graph(
-            conn=conn, bbox=bbox,
-            temporal_extent=[baseline_start, baseline_end],
-            resolution_m=lst_resolution,
-        )
-        true_color_cube = build_true_color_graph(
-            conn=conn, bbox=bbox,
-            temporal_extent=[current_start, current_end],
-            resolution_m=RESOLUTION_M,
-        )
-
-        loop = asyncio.get_event_loop()
-        current_path = os.path.join(results_dir, "lst_current.tif")
-        baseline_path = os.path.join(results_dir, "lst_baseline.tif")
-        true_color_path = os.path.join(results_dir, "true_color.tif")
-
-        await loop.run_in_executor(None, current_cube.download, current_path)
-        await loop.run_in_executor(None, baseline_cube.download, baseline_path)
-        await loop.run_in_executor(None, true_color_cube.download, true_color_path)
-
-        self._true_color_path = true_color_path
-
-        current_stats = self._compute_stats(current_path)
-        baseline_stats = self._compute_stats(baseline_path)
-
-        current_temp = current_stats["overall_mean_celsius"]
-        baseline_temp = baseline_stats["overall_mean_celsius"]
-        baseline_std = float(np.std(baseline_stats["monthly_means_celsius"])) if baseline_stats["monthly_means_celsius"] else 1.0
-        z_score = (current_temp - baseline_temp) / max(baseline_std, 0.1)
-
-        status = self._classify(abs(z_score))
-        trend = self._compute_trend(z_score)
-        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_celsius"],
-            baseline_stats["monthly_means_celsius"],
-            time_range,
-        )
-
-        anomaly = current_temp - baseline_temp
-        if abs(z_score) < 1.0:
-            headline = f"Temperature normal ({current_temp:.1f}\u00b0C, z={z_score:+.1f})"
-        elif z_score > 0:
-            headline = f"Above-normal temperature ({current_temp:.1f}\u00b0C, +{anomaly:.1f}\u00b0C)"
-        else:
-            headline = f"Below-normal temperature ({current_temp:.1f}\u00b0C, {anomaly:.1f}\u00b0C)"
-
-        self._spatial_data = SpatialData(
-            map_type="raster",
-            label="LST (\u00b0C)",
-            colormap="coolwarm",
-            vmin=current_temp - 10,
-            vmax=current_temp + 10,
-        )
-        self._indicator_raster_path = current_path
-        self._true_color_path = true_color_path
-        self._render_band = current_stats.get("hottest_band", 1)
-
-        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 LST is {current_temp:.1f}\u00b0C compared to "
-                f"{baseline_temp:.1f}\u00b0C baseline (z-score: {z_score:+.2f}). "
-                f"Sentinel-3 SLSTR at 1km resolution."
-            ),
-            methodology=(
-                f"Sentinel-3 SLSTR Level-2 LST product. "
-                f"Monthly mean composites. "
-                f"Baseline: {BASELINE_YEARS}-year monthly means. "
-                f"Z-score anomaly classification. "
-                f"Processed via CDSE openEO."
-            ),
-            limitations=[
-                "Sentinel-3 SLSTR resolution is ~1km \u2014 urban heat islands may be smoothed.",
-                "Cloud cover creates data gaps in monthly composites.",
-                "LST varies with land cover; change may reflect land use, not climate.",
-                "Daytime overpass only \u2014 nighttime temperatures not captured.",
-            ],
-        )
-
-    @staticmethod
-    def _compute_stats(tif_path: str) -> dict[str, Any]:
-        """Extract monthly LST statistics, converting Kelvin to Celsius."""
-        with rasterio.open(tif_path) as src:
-            n_bands = src.count
-            monthly_means_c = []
-            hottest = -999.0
-            hottest_band = 1
-            for band in range(1, n_bands + 1):
-                data = src.read(band).astype(np.float32)
-                nodata = src.nodata
-                if nodata is not None:
-                    valid = data[data != nodata]
-                else:
-                    valid = data.ravel()
-                if len(valid) > 0:
-                    mean_k = float(np.nanmean(valid))
-                    # Convert Kelvin to Celsius if needed (values > 100 assumed Kelvin)
-                    mean_c = mean_k - 273.15 if mean_k > 100 else mean_k
-                    monthly_means_c.append(mean_c)
-                    if mean_c > hottest:
-                        hottest = mean_c
-                        hottest_band = band
-                else:
-                    monthly_means_c.append(0.0)
-
-        valid_months = sum(1 for m in monthly_means_c if m != 0.0)
-        overall = float(np.mean([m for m in monthly_means_c if m != 0.0])) if valid_months > 0 else 0.0
-
-        return {
-            "monthly_means_celsius": monthly_means_c,
-            "overall_mean_celsius": overall,
-            "valid_months": valid_months,
-            "hottest_band": hottest_band,
-        }
-
-    @staticmethod
-    def _classify(abs_z: float) -> StatusLevel:
-        if abs_z < 1.0:
-            return StatusLevel.GREEN
-        if abs_z < 2.0:
-            return StatusLevel.AMBER
-        return StatusLevel.RED
-
-    @staticmethod
-    def _compute_trend(z_score: float) -> TrendDirection:
-        if abs(z_score) < 1.0:
-            return TrendDirection.STABLE
-        if z_score > 0:
-            return TrendDirection.DETERIORATING
-        return TrendDirection.IMPROVING
-
-    @staticmethod
-    def _build_chart_data(
-        current_monthly: list[float],
-        baseline_monthly: list[float],
-        time_range: TimeRange,
-    ) -> dict[str, Any]:
-        year = time_range.end.year
-        n = min(len(current_monthly), len(baseline_monthly))
-        dates = [f"{year}-{m + 1:02d}" for m in range(n)]
-        values = [round(v, 1) for v in current_monthly[:n]]
-        b_mean = [round(v, 1) for v in baseline_monthly[:n]]
-        b_min = [round(v - 3.0, 1) for v in baseline_monthly[:n]]
-        b_max = [round(v + 3.0, 1) for v in baseline_monthly[:n]]
-
-        return {
-            "dates": dates,
-            "values": values,
-            "baseline_mean": b_mean,
-            "baseline_min": b_min,
-            "baseline_max": b_max,
-            "label": "Temperature (\u00b0C)",
-        }
-
-    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        rng = np.random.default_rng(6)
-        baseline = float(rng.uniform(30, 38))
-        current = baseline + float(rng.uniform(-2, 3))
-        z = (current - baseline) / 2.0
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=f"Temperature data degraded ({current:.1f}\u00b0C)",
-            status=self._classify(abs(z)),
-            trend=self._compute_trend(z),
-            confidence=ConfidenceLevel.LOW,
-            map_layer_path="",
-            chart_data={
-                "dates": [str(time_range.start.year), str(time_range.end.year)],
-                "values": [round(baseline, 1), round(current, 1)],
-                "label": "Temperature (\u00b0C)",
-            },
-            data_source="placeholder",
-            summary="openEO processing unavailable. Showing placeholder values.",
-            methodology="Placeholder \u2014 no satellite data processed.",
-            limitations=["Data is synthetic. openEO backend was unreachable."],
-        )

app/indicators/ndvi.py

@@ -103,9 +103,7 @@ class NdviIndicator(BaseIndicator):
             current_path = self._find_tif(paths, current_dir)
             print(f"[Aperture] NDVI current_path: {current_path} (exists={os.path.exists(current_path)}, size={os.path.getsize(current_path) if os.path.exists(current_path) else 'N/A'})")
         except Exception as exc:
-            logger.warning("NDVI current batch download failed: %s", exc)
-            print(f"[Aperture] NDVI current download EXCEPTION: {type(exc).__name__}: {exc}")
-            return self._fallback(aoi, time_range)
+            raise RuntimeError(f"NDVI current period data unavailable: {exc}") from exc
 
         # Download baseline — optional (degrades gracefully)
         baseline_path = None
@@ -217,11 +215,7 @@ class NdviIndicator(BaseIndicator):
     async def process(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
     ) -> IndicatorResult:
-        try:
-            return await self._process_openeo(aoi, time_range, season_months)
-        except Exception as exc:
-            logger.warning("NDVI openEO processing failed, using placeholder: %s", exc)
-            return self._fallback(aoi, time_range)
+        return await self._process_openeo(aoi, time_range, season_months)
 
     async def _process_openeo(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
@@ -429,27 +423,3 @@ class NdviIndicator(BaseIndicator):
             "label": "NDVI",
         }
 
-    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        """Return a placeholder result when openEO processing fails."""
-        rng = np.random.default_rng(7)
-        baseline = float(rng.uniform(0.25, 0.45))
-        current = baseline * float(rng.uniform(0.90, 1.02))
-        change = current - baseline
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=f"Vegetation data degraded (NDVI \u2248{current:.2f})",
-            status=self._classify(change),
-            trend=self._compute_trend(change),
-            confidence=ConfidenceLevel.LOW,
-            map_layer_path="",
-            chart_data={
-                "dates": [str(time_range.start.year), str(time_range.end.year)],
-                "values": [round(baseline, 3), round(current, 3)],
-                "label": "NDVI",
-            },
-            data_source="placeholder",
-            summary="openEO processing unavailable. Showing placeholder values.",
-            methodology="Placeholder \u2014 no satellite data processed.",
-            limitations=["Data is synthetic. openEO backend was unreachable."],
-        )

app/indicators/nightlights.py

@@ -1,229 +0,0 @@
-"""Nighttime Lights Indicator — VIIRS DNB via EOG direct download.
-
-Downloads annual VIIRS DNB composites from Colorado School of Mines EOG,
-compares current-year radiance to a 3-year baseline.
-"""
-from __future__ import annotations
-
-import logging
-import os
-import tempfile
-from datetime import date
-from typing import Any
-
-import numpy as np
-import rasterio
-import httpx
-
-from app.indicators.base import BaseIndicator, SpatialData
-from app.models import (
-    AOI,
-    TimeRange,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-
-logger = logging.getLogger(__name__)
-
-BASELINE_YEARS = 3
-
-# EOG VIIRS DNB annual composites (public, COG format)
-EOG_BASE = "https://eogdata.mines.edu/nighttime_light/annual/v22"
-
-
-class NightlightsIndicator(BaseIndicator):
-    id = "nightlights"
-    name = "Nighttime Lights"
-    category = "D3"
-    question = "Is the local economy active?"
-    estimated_minutes = 10
-
-    _true_color_path: str | None = None
-
-    async def process(
-        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
-    ) -> IndicatorResult:
-        try:
-            return await self._process_viirs(aoi, time_range)
-        except Exception as exc:
-            logger.warning("Nightlights download failed, using placeholder: %s", exc)
-            return self._fallback(aoi, time_range)
-
-    async def _process_viirs(
-        self, aoi: AOI, time_range: TimeRange
-    ) -> IndicatorResult:
-        results_dir = tempfile.mkdtemp(prefix="aperture_nightlights_")
-
-        current_year = time_range.end.year
-        current_path = os.path.join(results_dir, "viirs_current.tif")
-        baseline_path = os.path.join(results_dir, "viirs_baseline.tif")
-
-        await self._download_viirs(aoi.bbox, current_year, current_path)
-        await self._download_viirs(aoi.bbox, current_year - BASELINE_YEARS, baseline_path)
-
-        current_stats = self._compute_stats(current_path)
-        baseline_stats = self._compute_stats(baseline_path)
-
-        current_rad = current_stats["mean_radiance"]
-        baseline_rad = baseline_stats["mean_radiance"]
-        pct_change = ((current_rad - baseline_rad) / baseline_rad * 100) if baseline_rad > 0 else 0.0
-
-        status = self._classify(pct_change)
-        trend = self._compute_trend(pct_change)
-        confidence = (
-            ConfidenceLevel.HIGH if current_stats["valid_pixel_fraction"] >= 0.7
-            else ConfidenceLevel.MODERATE if current_stats["valid_pixel_fraction"] >= 0.4
-            else ConfidenceLevel.LOW
-        )
-
-        chart_data = {
-            "dates": [str(current_year - BASELINE_YEARS), str(current_year)],
-            "values": [round(baseline_rad, 2), round(current_rad, 2)],
-            "baseline_range_mean": round(baseline_rad, 2),
-            "baseline_range_min": round(baseline_rad * 0.85, 2),
-            "baseline_range_max": round(baseline_rad * 1.15, 2),
-            "label": "Radiance (nW/cm\u00b2/sr)",
-        }
-
-        if abs(pct_change) <= 15:
-            headline = f"Nighttime lights stable ({current_rad:.1f} nW, {pct_change:+.0f}%)"
-        elif pct_change < 0:
-            headline = f"Nighttime lights declining ({pct_change:.0f}%)"
-        else:
-            headline = f"Nighttime lights increasing (+{pct_change:.0f}%)"
-
-        self._spatial_data = SpatialData(
-            map_type="raster",
-            label="Radiance (nW/cm\u00b2/sr)",
-            colormap="inferno",
-            vmin=0,
-            vmax=max(current_rad * 2, 10),
-        )
-        self._indicator_raster_path = current_path
-        self._true_color_path = None
-        self._render_band = 1
-
-        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 radiance is {current_rad:.2f} nW/cm\u00b2/sr compared to "
-                f"{baseline_rad:.2f} baseline ({pct_change:+.1f}%). "
-                f"VIIRS DNB annual composite at ~500m resolution."
-            ),
-            methodology=(
-                f"VIIRS Day-Night Band annual composites from Colorado School of Mines EOG. "
-                f"Stray-light corrected, cloud-free composite. "
-                f"Clipped to AOI bounding box. "
-                f"Baseline: {BASELINE_YEARS}-year prior annual composite."
-            ),
-            limitations=[
-                "Annual composites \u2014 cannot detect sub-annual changes.",
-                "Moonlight, fires, and gas flaring inflate radiance values.",
-                "~500m resolution smooths urban-rural boundaries.",
-                "Most recent annual composite may lag by several months.",
-            ],
-        )
-
-    async def _download_viirs(
-        self, bbox: list[float], year: int, output_path: str
-    ) -> None:
-        """Download VIIRS DNB annual composite and clip to AOI bbox.
-
-        Uses COG (Cloud-Optimized GeoTIFF) with HTTP range requests
-        to read only the AOI window from the full global file.
-        """
-        import asyncio
-        from rasterio.windows import from_bounds as window_from_bounds
-
-        loop = asyncio.get_event_loop()
-
-        def _read_cog():
-            # EOG provides global annual composites as COGs
-            url = f"{EOG_BASE}/{year}/VNP46A4_t{year}.average_masked.tif"
-
-            with rasterio.open(url) as src:
-                window = window_from_bounds(*bbox, transform=src.transform)
-                data = src.read(1, window=window).astype(np.float32)
-                win_transform = src.window_transform(window)
-
-            from rasterio.transform import from_bounds
-            h, w = data.shape
-            t = from_bounds(*bbox, w, h)
-
-            with rasterio.open(
-                output_path, "w", driver="GTiff",
-                height=h, width=w, count=1,
-                dtype="float32", crs="EPSG:4326",
-                transform=t, nodata=-9999.0,
-            ) as dst:
-                dst.write(data, 1)
-
-        await loop.run_in_executor(None, _read_cog)
-
-    @staticmethod
-    def _compute_stats(tif_path: str) -> dict[str, Any]:
-        """Extract radiance statistics from VIIRS GeoTIFF."""
-        with rasterio.open(tif_path) as src:
-            data = src.read(1).astype(np.float32)
-            nodata = src.nodata
-            if nodata is not None:
-                valid = data[data != nodata]
-            else:
-                valid = data.ravel()
-            valid = valid[valid >= 0]  # Remove negative radiance
-            total_pixels = data.size
-            valid_fraction = len(valid) / total_pixels if total_pixels > 0 else 0.0
-
-        return {
-            "mean_radiance": float(np.mean(valid)) if len(valid) > 0 else 0.0,
-            "valid_pixel_fraction": valid_fraction,
-        }
-
-    @staticmethod
-    def _classify(pct_change: float) -> StatusLevel:
-        if pct_change > -15:
-            return StatusLevel.GREEN
-        if pct_change > -40:
-            return StatusLevel.AMBER
-        return StatusLevel.RED
-
-    @staticmethod
-    def _compute_trend(pct_change: float) -> TrendDirection:
-        if abs(pct_change) <= 15:
-            return TrendDirection.STABLE
-        if pct_change < 0:
-            return TrendDirection.DETERIORATING
-        return TrendDirection.IMPROVING
-
-    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        rng = np.random.default_rng(3)
-        baseline = float(rng.uniform(2, 10))
-        current = baseline * float(rng.uniform(0.7, 1.1))
-        pct = ((current - baseline) / baseline) * 100
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=f"Nightlights data degraded ({current:.1f} nW)",
-            status=self._classify(pct),
-            trend=self._compute_trend(pct),
-            confidence=ConfidenceLevel.LOW,
-            map_layer_path="",
-            chart_data={
-                "dates": [str(time_range.start.year), str(time_range.end.year)],
-                "values": [round(baseline, 2), round(current, 2)],
-                "label": "Radiance (nW/cm\u00b2/sr)",
-            },
-            data_source="placeholder",
-            summary="VIIRS download unavailable. Showing placeholder values.",
-            methodology="Placeholder \u2014 no satellite data processed.",
-            limitations=["Data is synthetic. VIIRS data was unreachable."],
-        )

app/indicators/no2.py

@@ -1,256 +0,0 @@
-from __future__ import annotations
-
-from collections import defaultdict
-from datetime import date
-from typing import Any
-
-import numpy as np
-
-import httpx
-
-from app.indicators.base import BaseIndicator
-from app.models import (
-    AOI,
-    TimeRange,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-
-BASELINE_YEARS = 3
-AIR_QUALITY_API = "https://air-quality-api.open-meteo.com/v1/air-quality"
-
-
-class NO2Indicator(BaseIndicator):
-    id = "no2"
-    name = "Air Quality NO2"
-    category = "D7"
-    question = "Signs of industrial activity or destruction?"
-    estimated_minutes = 5
-
-    async def process(self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None) -> IndicatorResult:
-        current_no2, baseline_mean, baseline_std = await self._fetch_no2(aoi, time_range)
-
-        if baseline_std > 0:
-            z_score = (current_no2 - baseline_mean) / baseline_std
-        else:
-            z_score = 0.0
-
-        status = self._classify(abs(z_score))
-        trend = self._compute_trend(z_score)
-        confidence = ConfidenceLevel.MODERATE
-
-        if season_months and hasattr(self, '_current_monthly_means') and hasattr(self, '_baseline_per_year_monthly'):
-            chart_data = self._build_monthly_chart_data(
-                self._current_monthly_means,
-                self._baseline_per_year_monthly,
-                time_range,
-                season_months,
-            )
-        else:
-            chart_data = self._build_chart_data(
-                current_no2, baseline_mean, baseline_std, time_range,
-                getattr(self, '_baseline_yearly_means', None),
-            )
-
-        direction = "above" if z_score >= 0 else "below"
-        abs_z = abs(z_score)
-
-        if abs_z < 1:
-            headline = f"NO2 concentration normal — {abs_z:.1f} SD {direction} baseline"
-        elif abs_z < 2:
-            headline = f"Elevated NO2 — {abs_z:.1f} SD {direction} baseline"
-        else:
-            headline = f"Anomalous NO2 levels — {abs_z:.1f} SD {direction} baseline"
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=headline,
-            status=status,
-            trend=trend,
-            confidence=confidence,
-            map_layer_path="",
-            chart_data=chart_data,
-            data_source="placeholder" if getattr(self, '_is_placeholder', False) else "satellite",
-            summary=(
-                f"Mean NO2 concentration is {current_no2:.1f} µg/m³. "
-                f"Baseline mean: {baseline_mean:.1f} µg/m³, std: {baseline_std:.1f} µg/m³. "
-                f"Anomaly: {z_score:.2f} SD. "
-                f"Status: {status.value}. Trend: {trend.value}."
-            ),
-            methodology=(
-                "Hourly NO2 concentrations from the CAMS global atmospheric composition "
-                "model are retrieved via the Open-Meteo Air Quality API. Daily means are "
-                f"computed and compared to a {BASELINE_YEARS}-year climatological distribution "
-                "using z-score anomaly detection. AOI centroid is used as the query point."
-            ),
-            limitations=[
-                "Uses CAMS reanalysis at ~10 km resolution — local hotspots may be smoothed.",
-                "Model-derived, not direct satellite retrieval — depends on emissions inventory accuracy.",
-                "AOI centroid is used; large AOIs may miss spatial variability.",
-                "Seasonal biomass burning can be misinterpreted as industrial activity.",
-            ],
-        )
-
-    async def _fetch_no2(
-        self, aoi: AOI, time_range: TimeRange
-    ) -> tuple[float, float, float]:
-        """Returns (current_no2_mean, baseline_mean, baseline_std) in µg/m³."""
-        self._is_placeholder = False
-        try:
-            return await self._api_query(aoi, time_range)
-        except Exception as exc:
-            import logging
-            logging.getLogger(__name__).warning(
-                "NO2 API query failed, using placeholder: %s", exc
-            )
-            self._is_placeholder = True
-            return self._synthetic_no2()
-
-    async def _api_query(
-        self, aoi: AOI, time_range: TimeRange
-    ) -> tuple[float, float, float]:
-        lat = (aoi.bbox[1] + aoi.bbox[3]) / 2
-        lon = (aoi.bbox[0] + aoi.bbox[2]) / 2
-        current_year = time_range.end.year
-        baseline_start = current_year - BASELINE_YEARS
-
-        async with httpx.AsyncClient(timeout=30) as client:
-            # Current period
-            current_resp = await client.get(AIR_QUALITY_API, params={
-                "latitude": lat,
-                "longitude": lon,
-                "hourly": "nitrogen_dioxide",
-                "start_date": time_range.start.isoformat(),
-                "end_date": time_range.end.isoformat(),
-                "timezone": "auto",
-            })
-            current_resp.raise_for_status()
-            current_hourly = current_resp.json()["hourly"]
-            current_vals = [v for v in current_hourly["nitrogen_dioxide"] if v is not None]
-
-            # Aggregate hourly to monthly means for current period
-            current_monthly_means: dict[int, float] = {}
-            monthly_vals: dict[int, list[float]] = defaultdict(list)
-            for t, v in zip(current_hourly["time"], current_hourly["nitrogen_dioxide"]):
-                if v is not None:
-                    monthly_vals[int(t[5:7])].append(v)
-            for m, vals in monthly_vals.items():
-                current_monthly_means[m] = float(np.mean(vals))
-            self._current_monthly_means = current_monthly_means
-
-            # Baseline: query each year
-            baseline_yearly_means: list[float] = []
-            baseline_per_year_monthly: dict[int, list[float]] = defaultdict(list)
-            for yr in range(baseline_start, current_year):
-                resp = await client.get(AIR_QUALITY_API, params={
-                    "latitude": lat,
-                    "longitude": lon,
-                    "hourly": "nitrogen_dioxide",
-                    "start_date": date(yr, 1, 1).isoformat(),
-                    "end_date": date(yr, 12, 31).isoformat(),
-                    "timezone": "auto",
-                })
-                resp.raise_for_status()
-                yr_hourly = resp.json()["hourly"]
-                yr_monthly: dict[int, list[float]] = defaultdict(list)
-                for t, v in zip(yr_hourly["time"], yr_hourly["nitrogen_dioxide"]):
-                    if v is not None:
-                        yr_monthly[int(t[5:7])].append(v)
-                yr_means = []
-                for m, vals in yr_monthly.items():
-                    monthly_mean = float(np.mean(vals))
-                    yr_means.append(monthly_mean)
-                    baseline_per_year_monthly[m].append(monthly_mean)
-                if yr_means:
-                    baseline_yearly_means.append(float(np.mean(yr_means)))
-
-            self._baseline_per_year_monthly = dict(baseline_per_year_monthly)
-
-        if not current_vals or not baseline_yearly_means:
-            self._is_placeholder = True
-            return self._synthetic_no2()
-
-        self._baseline_yearly_means = baseline_yearly_means
-        return (
-            float(np.mean(current_vals)),
-            float(np.mean(baseline_yearly_means)),
-            float(np.std(baseline_yearly_means)) or 1e-3,
-        )
-
-    @staticmethod
-    def _synthetic_no2() -> tuple[float, float, float]:
-        """Plausible NO2 values for offline/test environments (µg/m³)."""
-        baseline_mean = 15.0
-        baseline_std = 4.0
-        current_no2 = baseline_mean * 1.1
-        return current_no2, baseline_mean, baseline_std
-
-    @staticmethod
-    def _classify(abs_z: float) -> StatusLevel:
-        if abs_z < 1.0:
-            return StatusLevel.GREEN
-        if abs_z < 2.0:
-            return StatusLevel.AMBER
-        return StatusLevel.RED
-
-    @staticmethod
-    def _compute_trend(z_score: float) -> TrendDirection:
-        if z_score > 1.0:
-            return TrendDirection.DETERIORATING
-        if z_score < -1.0:
-            return TrendDirection.IMPROVING
-        return TrendDirection.STABLE
-
-    @staticmethod
-    def _build_monthly_chart_data(
-        current_monthly: dict[int, float],
-        baseline_per_year_monthly: dict[int, list[float]],
-        time_range: TimeRange,
-        season_months: list[int],
-    ) -> dict[str, Any]:
-        year = time_range.end.year
-        dates, values, b_mean, b_min, b_max = [], [], [], [], []
-        for m in season_months:
-            dates.append(f"{year}-{m:02d}")
-            values.append(round(current_monthly.get(m, 0.0), 1))
-            yr_means = baseline_per_year_monthly.get(m, [])
-            if yr_means:
-                b_mean.append(round(float(np.mean(yr_means)), 1))
-                b_min.append(round(float(min(yr_means)), 1))
-                b_max.append(round(float(max(yr_means)), 1))
-            else:
-                b_mean.append(0.0)
-                b_min.append(0.0)
-                b_max.append(0.0)
-        result: dict[str, Any] = {
-            "dates": dates,
-            "values": values,
-            "label": "NO2 concentration (µg/m³)",
-        }
-        if any(v > 0 for v in b_mean):
-            result["baseline_mean"] = b_mean
-            result["baseline_min"] = b_min
-            result["baseline_max"] = b_max
-        return result
-
-    @staticmethod
-    def _build_chart_data(
-        current: float,
-        baseline_mean: float,
-        baseline_std: float,
-        time_range: TimeRange,
-        baseline_yearly_means: list[float] | None = None,
-    ) -> dict[str, Any]:
-        result: dict[str, Any] = {
-            "dates": ["baseline", str(time_range.end.year)],
-            "values": [round(baseline_mean, 1), round(current, 1)],
-            "baseline_std": round(baseline_std, 1),
-            "label": "NO2 concentration (µg/m³)",
-        }
-        if baseline_yearly_means and len(baseline_yearly_means) >= 2:
-            result["baseline_range_mean"] = round(float(np.mean(baseline_yearly_means)), 1)
-            result["baseline_range_min"] = round(float(min(baseline_yearly_means)), 1)
-            result["baseline_range_max"] = round(float(max(baseline_yearly_means)), 1)
-        return result

app/indicators/rainfall.py

@@ -1,304 +0,0 @@
-"""Rainfall Indicator — CHIRPS v2.0 precipitation via direct download.
-
-Downloads monthly CHIRPS GeoTIFFs, computes SPI-like deviation from
-a 5-year climatological baseline, and classifies drought severity.
-"""
-from __future__ import annotations
-
-import logging
-import os
-import tempfile
-from datetime import date
-from typing import Any
-
-import numpy as np
-import rasterio
-import httpx
-
-from app.indicators.base import BaseIndicator, SpatialData
-from app.models import (
-    AOI,
-    TimeRange,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-
-logger = logging.getLogger(__name__)
-
-BASELINE_YEARS = 5
-
-# CHIRPS monthly data URL pattern (public, no auth needed)
-# Format: https://data.chc.ucsb.edu/products/CHIRPS-2.0/global_monthly/tifs/chirps-v2.0.YYYY.MM.tif.gz
-CHIRPS_BASE = "https://data.chc.ucsb.edu/products/CHIRPS-2.0/global_monthly/tifs"
-
-
-class RainfallIndicator(BaseIndicator):
-    id = "rainfall"
-    name = "Rainfall Adequacy"
-    category = "D5"
-    question = "Is this area getting enough rain?"
-    estimated_minutes = 10
-
-    _true_color_path: str | None = None
-
-    async def process(
-        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
-    ) -> IndicatorResult:
-        try:
-            return await self._process_chirps(aoi, time_range, season_months)
-        except Exception as exc:
-            logger.warning("Rainfall CHIRPS processing failed, using placeholder: %s", exc)
-            return self._fallback(aoi, time_range)
-
-    async def _process_chirps(
-        self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
-    ) -> IndicatorResult:
-        results_dir = tempfile.mkdtemp(prefix="aperture_rainfall_")
-
-        current_path = os.path.join(results_dir, "precip_current.tif")
-        baseline_path = os.path.join(results_dir, "precip_baseline.tif")
-
-        await self._download_chirps(
-            aoi.bbox, time_range.start, time_range.end, current_path,
-        )
-        baseline_start = date(
-            time_range.start.year - BASELINE_YEARS,
-            time_range.start.month,
-            time_range.start.day,
-        )
-        await self._download_chirps(
-            aoi.bbox, baseline_start, time_range.start, baseline_path,
-        )
-
-        current_stats = self._compute_stats(current_path)
-        baseline_stats = self._compute_stats(baseline_path)
-
-        current_total = current_stats["total_mm"]
-        baseline_total = baseline_stats["total_mm"]
-        deviation_pct = (
-            ((current_total - baseline_total) / baseline_total * 100.0)
-            if baseline_total > 0 else 0.0
-        )
-
-        status = self._classify(deviation_pct)
-        trend = self._compute_trend(deviation_pct)
-        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_mm"],
-            baseline_stats["monthly_means_mm"],
-            time_range,
-        )
-
-        if abs(deviation_pct) <= 15:
-            headline = f"Rainfall near normal ({current_total:.0f}mm, {deviation_pct:+.0f}%)"
-        elif deviation_pct < 0:
-            headline = f"Rainfall deficit ({deviation_pct:.0f}% below baseline)"
-        else:
-            headline = f"Above-normal rainfall ({deviation_pct:+.0f}% above baseline)"
-
-        self._spatial_data = SpatialData(
-            map_type="raster",
-            label="Precipitation (mm)",
-            colormap="YlGnBu",
-            vmin=0,
-            vmax=max(current_stats["monthly_means_mm"]) * 1.5 if current_stats["monthly_means_mm"] else 100,
-        )
-        self._indicator_raster_path = current_path
-        self._true_color_path = None  # No true-color for rainfall (different resolution)
-        self._render_band = current_stats.get("wettest_band", 1)
-
-        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"Total precipitation is {current_total:.0f}mm compared to "
-                f"{baseline_total:.0f}mm baseline ({deviation_pct:+.1f}%). "
-                f"CHIRPS v2.0 at ~5km resolution."
-            ),
-            methodology=(
-                f"CHIRPS v2.0 monthly precipitation estimates (0.05\u00b0 resolution). "
-                f"Clipped to AOI bounding box. "
-                f"Baseline: {BASELINE_YEARS}-year monthly climatology. "
-                f"Deviation from baseline classified as drought severity."
-            ),
-            limitations=[
-                "CHIRPS resolution is ~5km \u2014 local rainfall variability not captured.",
-                "Satellite-gauge blend may underestimate in data-sparse regions.",
-                "Orographic effects poorly represented at this resolution.",
-                "No distinction between effective and non-effective rainfall.",
-            ],
-        )
-
-    async def _download_chirps(
-        self,
-        bbox: list[float],
-        start: date,
-        end: date,
-        output_path: str,
-    ) -> None:
-        """Download CHIRPS monthly data and create a multi-band GeoTIFF clipped to AOI.
-
-        Each band is one month of precipitation data (mm).
-        """
-        from rasterio.windows import from_bounds as window_from_bounds
-
-        monthly_data = []
-
-        async def _fetch_month(year: int, month: int) -> np.ndarray | None:
-            url = f"{CHIRPS_BASE}/chirps-v2.0.{year}.{month:02d}.tif.gz"
-            try:
-                async with httpx.AsyncClient(timeout=60) as client:
-                    resp = await client.get(url)
-                    if resp.status_code != 200:
-                        logger.warning("CHIRPS download failed for %d-%02d: %d", year, month, resp.status_code)
-                        return None
-
-                # Decompress and read the subset
-                import gzip
-                import io
-                decompressed = gzip.decompress(resp.content)
-                with rasterio.open(io.BytesIO(decompressed)) as src:
-                    window = window_from_bounds(*bbox, transform=src.transform)
-                    data = src.read(1, window=window).astype(np.float32)
-                    return data
-            except Exception as exc:
-                logger.warning("CHIRPS fetch error for %d-%02d: %s", year, month, exc)
-                return None
-
-        # Collect monthly data
-        current = date(start.year, start.month, 1)
-        while current < end:
-            data = await _fetch_month(current.year, current.month)
-            if data is not None:
-                monthly_data.append(data)
-            if current.month == 12:
-                current = date(current.year + 1, 1, 1)
-            else:
-                current = date(current.year, current.month + 1, 1)
-
-        if not monthly_data:
-            raise ValueError("No CHIRPS data available for the requested period")
-
-        # Write as multi-band GeoTIFF
-        h, w = monthly_data[0].shape
-        from rasterio.transform import from_bounds as transform_from_bounds
-        t = transform_from_bounds(*bbox, w, h)
-
-        with rasterio.open(
-            output_path, "w", driver="GTiff",
-            height=h, width=w, count=len(monthly_data),
-            dtype="float32", crs="EPSG:4326",
-            transform=t, nodata=-9999.0,
-        ) as dst:
-            for i, data in enumerate(monthly_data):
-                dst.write(data, i + 1)
-
-    @staticmethod
-    def _compute_stats(tif_path: str) -> dict[str, Any]:
-        """Extract monthly precipitation statistics from a multi-band GeoTIFF."""
-        with rasterio.open(tif_path) as src:
-            n_bands = src.count
-            monthly_means = []
-            peak_val = -1.0
-            peak_band = 1
-            for band in range(1, n_bands + 1):
-                data = src.read(band).astype(np.float32)
-                nodata = src.nodata
-                if nodata is not None:
-                    valid = data[data != nodata]
-                else:
-                    valid = data.ravel()
-                if len(valid) > 0:
-                    mean = float(np.nanmean(valid))
-                    monthly_means.append(mean)
-                    if mean > peak_val:
-                        peak_val = mean
-                        peak_band = band
-                else:
-                    monthly_means.append(0.0)
-
-        valid_months = sum(1 for m in monthly_means if m > 0)
-        total = float(np.sum(monthly_means))
-
-        return {
-            "monthly_means_mm": monthly_means,
-            "total_mm": total,
-            "valid_months": valid_months,
-            "wettest_band": peak_band,
-        }
-
-    @staticmethod
-    def _classify(deviation_pct: float) -> StatusLevel:
-        if deviation_pct >= -15:
-            return StatusLevel.GREEN
-        if deviation_pct >= -30:
-            return StatusLevel.AMBER
-        return StatusLevel.RED
-
-    @staticmethod
-    def _compute_trend(deviation_pct: float) -> TrendDirection:
-        if abs(deviation_pct) <= 15:
-            return TrendDirection.STABLE
-        if deviation_pct < 0:
-            return TrendDirection.DETERIORATING
-        return TrendDirection.IMPROVING
-
-    @staticmethod
-    def _build_chart_data(
-        current_monthly: list[float],
-        baseline_monthly: list[float],
-        time_range: TimeRange,
-    ) -> dict[str, Any]:
-        year = time_range.end.year
-        n = min(len(current_monthly), len(baseline_monthly))
-        dates = [f"{year}-{m + 1:02d}" for m in range(n)]
-        values = [round(v, 1) for v in current_monthly[:n]]
-        b_mean = [round(v, 1) for v in baseline_monthly[:n]]
-        b_min = [round(max(v - 15, 0), 1) for v in baseline_monthly[:n]]
-        b_max = [round(v + 15, 1) for v in baseline_monthly[:n]]
-
-        return {
-            "dates": dates,
-            "values": values,
-            "baseline_mean": b_mean,
-            "baseline_min": b_min,
-            "baseline_max": b_max,
-            "label": "Precipitation (mm)",
-        }
-
-    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        rng = np.random.default_rng(5)
-        baseline = float(rng.uniform(300, 600))
-        current = baseline * float(rng.uniform(0.7, 1.1))
-        deviation = ((current - baseline) / baseline) * 100
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=f"Rainfall data degraded ({current:.0f}mm)",
-            status=self._classify(deviation),
-            trend=self._compute_trend(deviation),
-            confidence=ConfidenceLevel.LOW,
-            map_layer_path="",
-            chart_data={
-                "dates": [str(time_range.start.year), str(time_range.end.year)],
-                "values": [round(baseline, 0), round(current, 0)],
-                "label": "Precipitation (mm)",
-            },
-            data_source="placeholder",
-            summary="CHIRPS download unavailable. Showing placeholder values.",
-            methodology="Placeholder \u2014 no satellite data processed.",
-            limitations=["Data is synthetic. CHIRPS data was unreachable."],
-        )

app/indicators/sar.py

@@ -97,8 +97,7 @@ class SarIndicator(BaseIndicator):
             paths = current_job.download_results(current_dir)
             current_path = self._find_tif(paths, current_dir)
         except Exception as exc:
-            logger.warning("SAR current batch download failed: %s", exc)
-            return self._fallback(aoi, time_range)
+            raise RuntimeError(f"SAR current period data unavailable: {exc}") from exc
 
         # Download baseline — optional (degrades gracefully)
         baseline_path = None
@@ -249,11 +248,7 @@ class SarIndicator(BaseIndicator):
     async def process(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
     ) -> IndicatorResult:
-        try:
-            return await self._process_openeo(aoi, time_range, season_months)
-        except Exception as exc:
-            logger.warning("SAR openEO processing failed: %s", exc)
-            return self._fallback(aoi, time_range)
+        return await self._process_openeo(aoi, time_range, season_months)
 
     async def _process_openeo(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
@@ -540,26 +535,11 @@ class SarIndicator(BaseIndicator):
         with rasterio.open(output_path, "w", **profile) as dst:
             dst.write(change, 1)
 
-    def _insufficient_data(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        """Return result when no Sentinel-1 data is available."""
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline="Insufficient SAR data for this area and time period",
-            status=StatusLevel.GREEN,
-            trend=TrendDirection.STABLE,
-            confidence=ConfidenceLevel.LOW,
-            map_layer_path="",
-            chart_data={"dates": [], "values": [], "label": "VV Backscatter (dB)"},
-            data_source="placeholder",
-            summary=(
-                "No Sentinel-1 GRD scenes were available for the requested "
-                "area and time period. SAR coverage over parts of East Africa "
-                "is inconsistent."
-            ),
-            methodology="Sentinel-1 GRD — no data available for processing.",
-            limitations=["No SAR data available. This indicator was skipped."],
+    def _insufficient_data(self, aoi: AOI, time_range: TimeRange):
+        """Raise when no Sentinel-1 data is available."""
+        raise RuntimeError(
+            "No Sentinel-1 GRD scenes available for the requested "
+            "area and time period. SAR coverage over parts of East Africa "
+            "is inconsistent."
         )
 
-    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        return self._insufficient_data(aoi, time_range)
-

app/indicators/vegetation.py

@@ -1,324 +0,0 @@
-from __future__ import annotations
-
-from collections import defaultdict
-from datetime import date
-from typing import Any
-
-import numpy as np
-
-from app.indicators.base import BaseIndicator
-from app.models import (
-    AOI,
-    TimeRange,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-
-BASELINE_YEARS = 5
-MAX_ITEMS = 100
-
-
-class VegetationIndicator(BaseIndicator):
-    id = "vegetation"
-    name = "Vegetation & Forest Cover"
-    category = "D2"
-    question = "Is vegetation cover declining?"
-    estimated_minutes = 5
-
-    async def process(self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None) -> IndicatorResult:
-        baseline_mean, current_mean, n_months = await self._fetch_comparison(aoi, time_range)
-
-        change_pp = current_mean - baseline_mean  # positive = greening
-        abs_change = abs(change_pp)
-
-        status = self._classify(change_pp)
-        trend = self._compute_trend(change_pp)
-        confidence = (
-            ConfidenceLevel.HIGH if n_months >= 6
-            else ConfidenceLevel.MODERATE if n_months >= 3
-            else ConfidenceLevel.LOW
-        )
-        if season_months and hasattr(self, '_current_monthly_medians') and hasattr(self, '_baseline_per_year_monthly'):
-            chart_data = self._build_monthly_chart_data(
-                self._current_monthly_medians,
-                self._baseline_per_year_monthly,
-                time_range,
-                season_months,
-            )
-        else:
-            chart_data = self._build_chart_data(
-                baseline_mean, current_mean, time_range,
-                getattr(self, '_baseline_yearly_means', None),
-            )
-
-        if abs_change <= 5:
-            headline = f"Vegetation cover stable ({current_mean:.0f}% cover, ±{abs_change:.0f}pp vs baseline)"
-        elif change_pp > 0:
-            headline = f"Vegetation cover increased (+{change_pp:.0f}pp vs baseline)"
-        else:
-            headline = f"Vegetation cover declined ({change_pp:.0f}pp vs baseline)"
-
-        # Store spatial data for map rendering
-        from app.indicators.base import SpatialData
-        tile_geojson = await self._fetch_tile_footprints(aoi, time_range)
-        if tile_geojson["features"]:
-            self._spatial_data = SpatialData(
-                geojson=tile_geojson,
-                map_type="choropleth",
-                label="Vegetation cover (%)",
-                colormap="YlGn",
-            )
-        else:
-            self._spatial_data = None
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=headline,
-            status=status,
-            trend=trend,
-            confidence=confidence,
-            map_layer_path="",
-            chart_data=chart_data,
-            data_source="placeholder" if getattr(self, '_is_placeholder', False) else "satellite",
-            summary=(
-                f"Mean vegetation cover is {current_mean:.1f}% compared to a {BASELINE_YEARS}-year "
-                f"baseline of {baseline_mean:.1f}% ({change_pp:+.1f} percentage points). "
-                f"Month-matched comparison using {n_months} overlapping months. "
-                f"Status: {status.value}. Trend: {trend.value}."
-            ),
-            methodology=(
-                "Sentinel-2 scene-level vegetation percentage (s2:vegetation_percentage) "
-                "is extracted from STAC metadata for cloud-free scenes. Monthly medians "
-                "are computed and only months with data in both the current and baseline "
-                "periods are compared, avoiding seasonal sampling bias. "
-                f"Baseline: {BASELINE_YEARS} years. No pixel data is downloaded."
-            ),
-            limitations=[
-                "Uses scene-level vegetation percentage, not pixel-level NDVI.",
-                "Seasonal variation may cause apparent loss if analysis windows differ.",
-                "Cloud cover reduces observation count and may bias estimates.",
-                "Vegetation percentage includes all green vegetation, not just forest.",
-            ],
-        )
-
-    async def _fetch_tile_footprints(self, aoi: AOI, time_range: TimeRange) -> dict:
-        """Fetch S2 tile footprints with median vegetation % per tile."""
-        try:
-            import asyncio
-            import pystac_client
-        except ImportError:
-            return {"type": "FeatureCollection", "features": []}
-
-        try:
-            catalog = pystac_client.Client.open(
-                "https://earth-search.aws.element84.com/v1"
-            )
-            current_year = time_range.end.year
-
-            def _query():
-                from collections import defaultdict
-                from datetime import date as _date
-                start = _date(current_year, 1, 1)
-                end = _date(current_year, 12, 31)
-                items = catalog.search(
-                    collections=["sentinel-2-l2a"],
-                    bbox=aoi.bbox,
-                    datetime=f"{start.isoformat()}/{end.isoformat()}",
-                    query={"eo:cloud_cover": {"lt": 30}},
-                    max_items=MAX_ITEMS,
-                ).item_collection()
-
-                tile_vals: dict[str, list[float]] = defaultdict(list)
-                tile_geom: dict[str, dict] = {}
-                for item in items:
-                    grid = item.properties.get("grid:code", item.id)
-                    veg = item.properties.get("s2:vegetation_percentage")
-                    if veg is not None:
-                        tile_vals[grid].append(float(veg))
-                        if grid not in tile_geom:
-                            tile_geom[grid] = item.geometry
-                return tile_vals, tile_geom
-
-            loop = asyncio.get_event_loop()
-            tile_vals, tile_geom = await loop.run_in_executor(None, _query)
-
-            features = []
-            for grid, vals in tile_vals.items():
-                if grid in tile_geom:
-                    features.append({
-                        "type": "Feature",
-                        "geometry": tile_geom[grid],
-                        "properties": {
-                            "value": float(np.median(vals)),
-                            "grid_code": grid,
-                        },
-                    })
-            return {"type": "FeatureCollection", "features": features}
-        except Exception:
-            return {"type": "FeatureCollection", "features": []}
-
-    async def _fetch_comparison(
-        self, aoi: AOI, time_range: TimeRange
-    ) -> tuple[float, float, int]:
-        """Returns (baseline_mean, current_mean, n_overlapping_months)."""
-        self._is_placeholder = False
-        try:
-            import pystac_client  # noqa: F401
-        except ImportError as exc:
-            import logging
-            logging.getLogger(__name__).warning("Vegetation missing dependencies, using placeholder: %s", exc)
-            self._is_placeholder = True
-            return self._synthetic()
-
-        try:
-            return await self._stac_comparison(aoi, time_range)
-        except Exception as exc:
-            import logging
-            logging.getLogger(__name__).warning("Vegetation STAC query failed, using placeholder: %s", exc)
-            self._is_placeholder = True
-            return self._synthetic()
-
-    async def _stac_comparison(
-        self, aoi: AOI, time_range: TimeRange
-    ) -> tuple[float, float, int]:
-        import asyncio
-        import pystac_client
-
-        catalog = pystac_client.Client.open(
-            "https://earth-search.aws.element84.com/v1"
-        )
-        current_year = time_range.end.year
-        baseline_start_year = current_year - BASELINE_YEARS
-
-        def _query_monthly(year: int) -> dict[int, list[float]]:
-            items = catalog.search(
-                collections=["sentinel-2-l2a"],
-                bbox=aoi.bbox,
-                datetime=f"{date(year,1,1).isoformat()}/{date(year,12,31).isoformat()}",
-                query={"eo:cloud_cover": {"lt": 30}},
-                max_items=MAX_ITEMS,
-            ).item_collection()
-            by_month: dict[int, list[float]] = defaultdict(list)
-            for item in items:
-                veg = item.properties.get("s2:vegetation_percentage")
-                if veg is not None and item.datetime:
-                    by_month[item.datetime.month].append(float(veg))
-            return dict(by_month)
-
-        loop = asyncio.get_event_loop()
-        current_monthly = await loop.run_in_executor(None, _query_monthly, current_year)
-
-        baseline_pool: dict[int, list[float]] = defaultdict(list)
-        baseline_yearly_means: list[float] = []
-        baseline_per_year_monthly: dict[int, list[float]] = defaultdict(list)
-        for yr in range(baseline_start_year, current_year):
-            yr_monthly = await loop.run_in_executor(None, _query_monthly, yr)
-            yr_medians = []
-            for month, vals in yr_monthly.items():
-                baseline_pool[month].extend(vals)
-                if vals:
-                    med = float(np.median(vals))
-                    yr_medians.append(med)
-                    baseline_per_year_monthly[month].append(med)
-            if yr_medians:
-                baseline_yearly_means.append(float(np.mean(yr_medians)))
-
-        baseline_medians = []
-        current_medians = []
-        for month in range(1, 13):
-            b_vals = baseline_pool.get(month, [])
-            c_vals = current_monthly.get(month, [])
-            if b_vals and c_vals:
-                baseline_medians.append(float(np.median(b_vals)))
-                current_medians.append(float(np.median(c_vals)))
-
-        n_months = len(baseline_medians)
-        if n_months == 0:
-            self._is_placeholder = True
-            return self._synthetic()
-
-        self._baseline_yearly_means = baseline_yearly_means
-        self._baseline_per_year_monthly = dict(baseline_per_year_monthly)
-        self._current_monthly_medians = {}
-        for month in range(1, 13):
-            c_vals = current_monthly.get(month, [])
-            if c_vals:
-                self._current_monthly_medians[month] = float(np.median(c_vals))
-        return (
-            float(np.mean(baseline_medians)),
-            float(np.mean(current_medians)),
-            n_months,
-        )
-
-    @staticmethod
-    def _synthetic() -> tuple[float, float, int]:
-        rng = np.random.default_rng(7)
-        baseline = float(rng.uniform(25, 45))
-        current = baseline * float(rng.uniform(0.90, 1.02))
-        return baseline, current, 6
-
-    @staticmethod
-    def _classify(change_pp: float) -> StatusLevel:
-        if change_pp >= -5:
-            return StatusLevel.GREEN
-        if change_pp >= -15:
-            return StatusLevel.AMBER
-        return StatusLevel.RED
-
-    @staticmethod
-    def _compute_trend(change_pp: float) -> TrendDirection:
-        if abs(change_pp) <= 5:
-            return TrendDirection.STABLE
-        if change_pp > 0:
-            return TrendDirection.IMPROVING
-        return TrendDirection.DETERIORATING
-
-    @staticmethod
-    def _build_monthly_chart_data(
-        current_monthly: dict[int, float],
-        baseline_per_year_monthly: dict[int, list[float]],
-        time_range: TimeRange,
-        season_months: list[int],
-    ) -> dict[str, Any]:
-        year = time_range.end.year
-        dates, values, b_mean, b_min, b_max = [], [], [], [], []
-        for m in season_months:
-            dates.append(f"{year}-{m:02d}")
-            values.append(round(current_monthly.get(m, 0.0), 1))
-            yr_medians = baseline_per_year_monthly.get(m, [])
-            if yr_medians:
-                b_mean.append(round(float(np.mean(yr_medians)), 1))
-                b_min.append(round(float(min(yr_medians)), 1))
-                b_max.append(round(float(max(yr_medians)), 1))
-            else:
-                b_mean.append(0.0)
-                b_min.append(0.0)
-                b_max.append(0.0)
-        result: dict[str, Any] = {
-            "dates": dates,
-            "values": values,
-            "label": "Vegetation cover (%)",
-        }
-        if any(v > 0 for v in b_mean):
-            result["baseline_mean"] = b_mean
-            result["baseline_min"] = b_min
-            result["baseline_max"] = b_max
-        return result
-
-    @staticmethod
-    def _build_chart_data(
-        baseline: float, current: float, time_range: TimeRange,
-        baseline_yearly_means: list[float] | None = None,
-    ) -> dict[str, Any]:
-        data: dict[str, Any] = {
-            "dates": [str(time_range.start.year - 1), str(time_range.end.year)],
-            "values": [round(baseline, 1), round(current, 1)],
-            "label": "Vegetation cover (%)",
-        }
-        if baseline_yearly_means and len(baseline_yearly_means) >= 2:
-            data["baseline_range_mean"] = round(float(np.mean(baseline_yearly_means)), 1)
-            data["baseline_range_min"] = round(float(min(baseline_yearly_means)), 1)
-            data["baseline_range_max"] = round(float(max(baseline_yearly_means)), 1)
-        return data

app/indicators/water.py

@@ -96,8 +96,7 @@ class WaterIndicator(BaseIndicator):
             paths = current_job.download_results(current_dir)
             current_path = self._find_tif(paths, current_dir)
         except Exception as exc:
-            logger.warning("Water current batch download failed: %s", exc)
-            return self._fallback(aoi, time_range)
+            raise RuntimeError(f"Water current period data unavailable: {exc}") from exc
 
         # Download baseline — optional (degrades gracefully)
         baseline_path = None
@@ -205,11 +204,7 @@ class WaterIndicator(BaseIndicator):
     async def process(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None = None
     ) -> IndicatorResult:
-        try:
-            return await self._process_openeo(aoi, time_range, season_months)
-        except Exception as exc:
-            logger.warning("Water openEO processing failed, using placeholder: %s", exc)
-            return self._fallback(aoi, time_range)
+        return await self._process_openeo(aoi, time_range, season_months)
 
     async def _process_openeo(
         self, aoi: AOI, time_range: TimeRange, season_months: list[int] | None
@@ -397,26 +392,3 @@ class WaterIndicator(BaseIndicator):
             "label": "Water extent (%)",
         }
 
-    def _fallback(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        rng = np.random.default_rng(9)
-        baseline = float(rng.uniform(5, 20))
-        current = baseline * float(rng.uniform(0.85, 1.15))
-        change = current - baseline
-
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline=f"Water data degraded ({current:.1f}% extent)",
-            status=StatusLevel.GREEN if abs(change) < 5 else StatusLevel.AMBER,
-            trend=TrendDirection.STABLE,
-            confidence=ConfidenceLevel.LOW,
-            map_layer_path="",
-            chart_data={
-                "dates": [str(time_range.start.year), str(time_range.end.year)],
-                "values": [round(baseline, 1), round(current, 1)],
-                "label": "Water extent (%)",
-            },
-            data_source="placeholder",
-            summary="openEO processing unavailable. Showing placeholder values.",
-            methodology="Placeholder \u2014 no satellite data processed.",
-            limitations=["Data is synthetic. openEO backend was unreachable."],
-        )

app/main.py

@@ -29,7 +29,7 @@ def create_app(db_path: str = "aperture.db", run_worker: bool = False) -> FastAP
         if OPENEO_CLIENT_ID and OPENEO_CLIENT_SECRET:
             print(f"[Aperture] CDSE credentials configured (client_id={OPENEO_CLIENT_ID[:8]}...)")
         else:
-            print("[Aperture] WARNING: CDSE credentials NOT configured — EO indicators will return placeholder data")
+            print("[Aperture] WARNING: CDSE credentials NOT configured — EO indicators will fail")
         print(f"[Aperture] SPACE_ID={os.environ.get('SPACE_ID', '<not set>')}")
         await db.init()
         worker_task = None

app/models.py

@@ -126,7 +126,7 @@ class IndicatorResult(BaseModel):
     summary: str
     methodology: str
     limitations: list[str]
-    data_source: str = "satellite"  # "satellite" or "placeholder"
+    data_source: str = "satellite"
 
 
 class Job(BaseModel):

app/openeo_client.py

@@ -193,33 +193,6 @@ def build_mndwi_graph(
     return monthly
 
 
-def build_lst_graph(
-    *,
-    conn: openeo.Connection,
-    bbox: dict[str, float],
-    temporal_extent: list[str],
-    resolution_m: int = 1000,
-) -> openeo.DataCube:
-    """Build an openEO process graph for Sentinel-3 SLSTR land surface temperature.
-
-    Loads LST from Sentinel-3 SLSTR Level-2 product, aggregated to monthly means.
-    Resolution is typically 1km (SLSTR native).
-    """
-    cube = conn.load_collection(
-        collection_id="SENTINEL3_SLSTR_L2_LST",
-        spatial_extent=bbox,
-        temporal_extent=temporal_extent,
-        bands=["LST"],
-    )
-
-    monthly = cube.aggregate_temporal_period("month", reducer="mean")
-
-    if resolution_m > 1000:
-        monthly = monthly.resample_spatial(resolution=resolution_m / 111320, projection="EPSG:4326")
-
-    return monthly
-
-
 def build_sar_graph(
     *,
     conn: openeo.Connection,

app/outputs/narrative.py

@@ -20,26 +20,10 @@ _INTERPRETATIONS: dict[tuple[str, StatusLevel], str] = {
     ("buildup", StatusLevel.RED): "Rapid settlement expansion at this rate suggests significant population displacement or unplanned urban growth.",
     ("buildup", StatusLevel.AMBER): "Moderate settlement growth detected, consistent with gradual urbanization.",
     ("buildup", StatusLevel.GREEN): "Settlement extent is stable relative to the baseline period.",
-    ("fires", StatusLevel.RED): "Active fire density at critical levels \u2014 indicates widespread burning requiring immediate attention.",
-    ("fires", StatusLevel.AMBER): "Elevated fire activity detected, likely agricultural burning or localized wildfire.",
-    ("fires", StatusLevel.GREEN): "Fire activity is within normal seasonal patterns.",
-    ("rainfall", StatusLevel.RED): "Severe precipitation deficit against the long-term average is consistent with drought conditions.",
-    ("rainfall", StatusLevel.AMBER): "Below-average precipitation may lead to crop stress if the deficit persists.",
-    ("rainfall", StatusLevel.GREEN): "Precipitation is within normal ranges for the season.",
-    ("lst", StatusLevel.RED): "Surface temperatures are critically elevated, indicating severe thermal stress.",
-    ("lst", StatusLevel.AMBER): "Moderately elevated surface temperatures may affect crop health and water availability.",
-    ("lst", StatusLevel.GREEN): "Surface temperatures are within the normal seasonal range.",
-    ("nightlights", StatusLevel.RED): "Significant nighttime light changes indicate major disruption to infrastructure or population activity.",
-    ("nightlights", StatusLevel.AMBER): "Moderate nighttime light changes may reflect economic shifts or partial service disruption.",
-    ("nightlights", StatusLevel.GREEN): "Nighttime light patterns are stable, suggesting no major disruption.",
 }
 
 # --- Cross-indicator pattern rules ---
 _CROSS_PATTERNS: list[tuple[dict[str, set[StatusLevel]], str]] = [
-    (
-        {"ndvi": {StatusLevel.RED, StatusLevel.AMBER}, "rainfall": {StatusLevel.RED, StatusLevel.AMBER}},
-        "Vegetation decline is consistent with reduced precipitation, suggesting drought-driven stress.",
-    ),
     (
         {"ndvi": {StatusLevel.RED, StatusLevel.AMBER}, "buildup": {StatusLevel.RED, StatusLevel.AMBER}},
         "Vegetation loss coincides with settlement expansion, indicating possible land-use conversion.",
@@ -52,10 +36,6 @@ _CROSS_PATTERNS: list[tuple[dict[str, set[StatusLevel]], str]] = [
         {"water": {StatusLevel.RED, StatusLevel.AMBER}, "sar": {StatusLevel.RED, StatusLevel.AMBER}},
         "Increased water extent and SAR signal changes suggest flooding or waterlogging.",
     ),
-    (
-        {"fires": {StatusLevel.RED, StatusLevel.AMBER}, "ndvi": {StatusLevel.RED, StatusLevel.AMBER}},
-        "Active fire detections combined with vegetation decline indicate burning-driven land cover change.",
-    ),
 ]
 
 _LEAD_TEMPLATES = {
@@ -101,12 +81,4 @@ def generate_narrative(results: Sequence[IndicatorResult]) -> str:
             parts.append(sentence)
             break
 
-    # 4. Placeholder caveat
-    placeholder_count = sum(1 for r in results if r.data_source == "placeholder")
-    if placeholder_count:
-        parts.append(
-            f"{placeholder_count} indicator(s) used estimated data "
-            "\u2014 cross-indicator interpretation is limited."
-        )
-
     return " ".join(parts)

app/outputs/overview.py

@@ -15,15 +15,10 @@ _STATUS_SCORES = {
 
 # Display names for headline generation
 _INDICATOR_NAMES = {
-    "fires": "fires",
-    "sar": "SAR ground change",
-    "buildup": "settlement expansion",
     "ndvi": "vegetation decline",
+    "sar": "SAR ground change",
     "water": "water extent change",
-    "rainfall": "rainfall anomaly",
-    "lst": "thermal stress",
-    "no2": "air quality",
-    "nightlights": "nighttime lights",
+    "buildup": "settlement expansion",
 }
 
 

app/outputs/report.py

@@ -26,8 +26,6 @@ from app.models import AOI, TimeRange, IndicatorResult, StatusLevel
 
 # Display names for indicator IDs that don't title-case correctly
 _DISPLAY_NAMES: dict[str, str] = {
-    "no2": "NO2",
-    "lst": "LST",
     "sar": "SAR Backscatter",
     "buildup": "Settlement Extent",
 }
@@ -189,15 +187,6 @@ def _indicator_block(
     elements.append(row)
     elements.append(Spacer(1, 3 * mm))
 
-    # Placeholder data warning
-    if result.data_source == "placeholder":
-        elements.append(Paragraph(
-            '<font color="#CA5D0F"><b>⚠ Placeholder data</b> — real satellite data was '
-            'unavailable for this indicator. Results are illustrative only.</font>',
-            styles["body_muted"],
-        ))
-        elements.append(Spacer(1, 2 * mm))
-
     # Map and chart side by side (if both exist), or single image
     map_exists = map_path and os.path.exists(map_path)
     chart_exists = chart_path and os.path.exists(chart_path)

app/outputs/thresholds.py

@@ -8,31 +8,6 @@ def classify_indicator(indicator_id: str, metrics: dict) -> StatusLevel:
     return classifier(metrics)
 
 
-def _fires(m):
-    count = m.get("count", 0)
-    return StatusLevel.GREEN if count == 0 else StatusLevel.AMBER if count <= 5 else StatusLevel.RED
-
-
-def _cropland(m):
-    pct = m.get("pct_of_baseline", 100)
-    return StatusLevel.GREEN if pct > 90 else StatusLevel.AMBER if pct >= 70 else StatusLevel.RED
-
-
-def _vegetation(m):
-    loss = m.get("loss_pct", 0)
-    return StatusLevel.GREEN if loss < 5 else StatusLevel.AMBER if loss <= 15 else StatusLevel.RED
-
-
-def _rainfall(m):
-    dev = m.get("pct_deviation", 0)
-    return StatusLevel.GREEN if dev > -10 else StatusLevel.AMBER if dev >= -25 else StatusLevel.RED
-
-
-def _nightlights(m):
-    pct = m.get("pct_of_baseline", 100)
-    return StatusLevel.GREEN if pct > 90 else StatusLevel.AMBER if pct >= 70 else StatusLevel.RED
-
-
 def _water(m):
     change = m.get("change_pct", 0)
     return StatusLevel.GREEN if abs(change) < 10 else StatusLevel.AMBER if abs(change) <= 25 else StatusLevel.RED
@@ -43,25 +18,9 @@ def _sd_based(m):
     return StatusLevel.GREEN if sd < 1 else StatusLevel.AMBER if sd <= 2 else StatusLevel.RED
 
 
-def _food_security(m):
-    statuses = m.get("component_statuses", [])
-    return (
-        StatusLevel.RED
-        if any(s == "red" for s in statuses)
-        else StatusLevel.AMBER
-        if any(s == "amber" for s in statuses)
-        else StatusLevel.GREEN
-    )
-
-
 THRESHOLDS = {
-    "fires": _fires,
-    "cropland": _cropland,
-    "vegetation": _vegetation,
-    "rainfall": _rainfall,
-    "nightlights": _nightlights,
     "water": _water,
-    "no2": _sd_based,
-    "lst": _sd_based,
-    "food_security": _food_security,
+    "ndvi": _sd_based,
+    "sar": _sd_based,
+    "buildup": _sd_based,
 }

app/worker.py

@@ -79,89 +79,73 @@ async def process_job(job_id: str, db: Database, registry: IndicatorRegistry) ->
 
         # -- Process batch indicators sequentially --
         for indicator_id, indicator in batch_indicators.items():
-            result = None
-
             # Submit
             await db.update_job_progress(job_id, indicator_id, "submitting")
-            try:
-                jobs = await indicator.submit_batch(
-                    job.request.aoi,
-                    job.request.time_range,
-                    season_months=job.request.season_months(),
-                )
-                job_ids = [getattr(j, 'job_id', '?') for j in jobs]
-                print(f"[Aperture] Submitted {indicator_id} batch jobs: {job_ids}")
-                await db.update_job_progress(job_id, indicator_id, "processing on CDSE")
-            except Exception as exc:
-                logger.warning("Batch submit failed for %s, will use fallback: %s", indicator_id, exc)
-                jobs = None
+            jobs = await indicator.submit_batch(
+                job.request.aoi,
+                job.request.time_range,
+                season_months=job.request.season_months(),
+            )
+            job_ids = [getattr(j, 'job_id', '?') for j in jobs]
+            print(f"[Aperture] Submitted {indicator_id} batch jobs: {job_ids}")
+            await db.update_job_progress(job_id, indicator_id, "processing on CDSE")
 
             # Poll — exit early once first job finishes + grace period for others
             GRACE_PERIOD = 600  # 10 min grace after first job finishes
-            if jobs is not None:
-                poll_start = time.monotonic()
-                first_finished_at = None
-                finished = False
-                while True:
-                    elapsed = time.monotonic() - poll_start
-                    statuses = [j.status() for j in jobs]
-                    job_ids = [getattr(j, 'job_id', '?') for j in jobs]
-                    print(f"[Aperture] Poll {indicator_id} ({elapsed:.0f}s): {list(zip(job_ids, statuses))}")
-
-                    if all(s == "finished" for s in statuses):
-                        logger.info("Batch jobs finished for %s", indicator_id)
-                        finished = True
-                        break
-                    elif any(s in ("error", "canceled") for s in statuses):
-                        logger.warning("Batch job failed for %s: %s", indicator_id, statuses)
-                        break
-
-                    # Track when first job finishes
-                    if first_finished_at is None and any(s == "finished" for s in statuses):
-                        first_finished_at = time.monotonic()
-                        print(f"[Aperture] {indicator_id}: first job finished, {GRACE_PERIOD}s grace for remaining")
-
-                    # Grace period: once any job finished, give others 10 min then harvest partial
-                    if first_finished_at and (time.monotonic() - first_finished_at) >= GRACE_PERIOD:
-                        logger.info("Grace period expired for %s, harvesting partial results", indicator_id)
-                        print(f"[Aperture] {indicator_id}: grace period expired, proceeding with partial results")
-                        break
-
-                    if elapsed >= BATCH_TIMEOUT:
-                        logger.warning("Batch poll timeout after %.0fs for %s", elapsed, indicator_id)
-                        break
-
-                    await asyncio.sleep(BATCH_POLL_INTERVAL)
-
-                # Harvest if any job finished (harvest methods handle per-job failures)
-                any_finished = any(s == "finished" for s in statuses)
-                if any_finished:
-                    # Wrap non-finished jobs so download_results() fails fast
-                    # instead of blocking for 30 min on a still-running job
-                    harvest_jobs = [
-                        j if s == "finished" else _SkippedJob(getattr(j, 'job_id', '?'))
-                        for j, s in zip(jobs, statuses)
-                    ]
-                    await db.update_job_progress(job_id, indicator_id, "downloading")
-                    try:
-                        result = await indicator.harvest(
-                            job.request.aoi,
-                            job.request.time_range,
-                            season_months=job.request.season_months(),
-                            batch_jobs=harvest_jobs,
-                        )
-                    except Exception as exc:
-                        logger.warning("Harvest failed for %s, using fallback: %s", indicator_id, exc)
-
-            # Fallback if submit failed, poll timed out, jobs errored, or harvest failed
-            if result is None:
-                await db.update_job_progress(job_id, indicator_id, "processing")
-                result = await indicator.process(
-                    job.request.aoi,
-                    job.request.time_range,
-                    season_months=job.request.season_months(),
+            poll_start = time.monotonic()
+            first_finished_at = None
+            while True:
+                elapsed = time.monotonic() - poll_start
+                statuses = [j.status() for j in jobs]
+                job_ids = [getattr(j, 'job_id', '?') for j in jobs]
+                print(f"[Aperture] Poll {indicator_id} ({elapsed:.0f}s): {list(zip(job_ids, statuses))}")
+
+                if all(s == "finished" for s in statuses):
+                    logger.info("Batch jobs finished for %s", indicator_id)
+                    break
+                elif any(s in ("error", "canceled") for s in statuses):
+                    logger.warning("Batch job failed for %s: %s", indicator_id, statuses)
+                    break
+
+                # Track when first job finishes
+                if first_finished_at is None and any(s == "finished" for s in statuses):
+                    first_finished_at = time.monotonic()
+                    print(f"[Aperture] {indicator_id}: first job finished, {GRACE_PERIOD}s grace for remaining")
+
+                # Grace period: once any job finished, give others 10 min then harvest partial
+                if first_finished_at and (time.monotonic() - first_finished_at) >= GRACE_PERIOD:
+                    logger.info("Grace period expired for %s, harvesting partial results", indicator_id)
+                    print(f"[Aperture] {indicator_id}: grace period expired, proceeding with partial results")
+                    break
+
+                if elapsed >= BATCH_TIMEOUT:
+                    logger.warning("Batch poll timeout after %.0fs for %s", elapsed, indicator_id)
+                    break
+
+                await asyncio.sleep(BATCH_POLL_INTERVAL)
+
+            # Harvest if any job finished (harvest methods handle per-job failures)
+            any_finished = any(s == "finished" for s in statuses)
+            if not any_finished:
+                failed_statuses = list(zip(job_ids, statuses))
+                raise RuntimeError(
+                    f"All batch jobs failed for {indicator_id}: {failed_statuses}"
                 )
 
+            # Wrap non-finished jobs so download_results() fails fast
+            # instead of blocking for 30 min on a still-running job
+            harvest_jobs = [
+                j if s == "finished" else _SkippedJob(getattr(j, 'job_id', '?'))
+                for j, s in zip(jobs, statuses)
+            ]
+            await db.update_job_progress(job_id, indicator_id, "downloading")
+            result = await indicator.harvest(
+                job.request.aoi,
+                job.request.time_range,
+                season_months=job.request.season_months(),
+                batch_jobs=harvest_jobs,
+            )
+
             spatial = indicator.get_spatial_data()
             if spatial is not None:
                 spatial_cache[indicator_id] = spatial

tests/conftest.py

@@ -1,95 +0,0 @@
-"""Shared test fixtures for indicator tests."""
-import os
-import pytest
-import tempfile
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-from unittest.mock import MagicMock
-from datetime import date
-
-from app.models import AOI, TimeRange, JobRequest
-
-BBOX = [32.45, 15.65, 32.65, 15.8]
-
-
-def mock_rgb_tif(path: str):
-    """Create a small synthetic true-color GeoTIFF."""
-    rng = np.random.default_rng(43)
-    data = rng.integers(500, 1500, (3, 10, 10), dtype=np.uint16)
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=3,
-        dtype="uint16", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, 10, 10), nodata=0,
-    ) as dst:
-        for i in range(3):
-            dst.write(data[i], i + 1)
-
-
-def make_mock_batch_job(src_path, fail=False):
-    """Create a mock openEO batch job that copies a source tif on download."""
-    job = MagicMock()
-    job.job_id = "j-test"
-
-    def fake_download_results(target):
-        if fail:
-            raise Exception("Batch job failed on CDSE")
-        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
-
-
-@pytest.fixture
-def sample_aoi():
-    return AOI(name="Khartoum North", bbox=[32.45, 15.65, 32.65, 15.80])
-
-
-@pytest.fixture
-def sample_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-@pytest.fixture
-def sample_job_request(sample_aoi, sample_time_range):
-    return JobRequest(
-        aoi=sample_aoi,
-        time_range=sample_time_range,
-        indicator_ids=["fires", "cropland"],
-        email="test@example.com",
-    )
-
-
-@pytest.fixture
-def temp_db_path():
-    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
-        path = f.name
-    yield path
-    os.unlink(path)
-
-
-FIXTURES_DIR = os.path.join(os.path.dirname(__file__), "fixtures")
-
-
-@pytest.fixture
-def ndvi_monthly_tif():
-    """Path to a 12-band synthetic NDVI monthly GeoTIFF."""
-    path = os.path.join(FIXTURES_DIR, "ndvi_monthly.tif")
-    if not os.path.exists(path):
-        pytest.skip("Test fixtures not generated. Run: python tests/fixtures/create_fixtures.py")
-    return path
-
-
-@pytest.fixture
-def true_color_tif():
-    """Path to a 3-band synthetic true-color GeoTIFF."""
-    path = os.path.join(FIXTURES_DIR, "true_color.tif")
-    if not os.path.exists(path):
-        pytest.skip("Test fixtures not generated. Run: python tests/fixtures/create_fixtures.py")
-    return path

tests/fixtures/create_fixtures.py

@@ -1,70 +0,0 @@
-"""Generate small synthetic GeoTIFFs for unit tests.
-
-Run this script once to create the test fixtures:
-    python tests/fixtures/create_fixtures.py
-"""
-from __future__ import annotations
-
-import os
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-
-FIXTURES_DIR = os.path.dirname(__file__)
-
-# AOI: small region near Khartoum (~20x15 pixels at 100m = 2km x 1.5km)
-WEST, SOUTH, EAST, NORTH = 32.45, 15.65, 32.65, 15.8
-WIDTH, HEIGHT = 22, 17  # ~100m pixels
-
-
-def _transform():
-    return from_bounds(WEST, SOUTH, EAST, NORTH, WIDTH, HEIGHT)
-
-
-def create_ndvi_monthly():
-    """12-band GeoTIFF: monthly median NDVI (Jan-Dec), float32, range -0.2 to 0.9."""
-    rng = np.random.default_rng(42)
-    path = os.path.join(FIXTURES_DIR, "ndvi_monthly.tif")
-    data = np.zeros((12, HEIGHT, WIDTH), dtype=np.float32)
-    for month in range(12):
-        # Seasonal NDVI pattern: peak in rainy season (Jul-Sep)
-        base = 0.25 + 0.35 * np.sin(np.pi * (month - 3) / 6)
-        data[month] = base + rng.normal(0, 0.05, (HEIGHT, WIDTH))
-    data = np.clip(data, -0.2, 0.9)
-
-    with rasterio.open(
-        path, "w", driver="GTiff",
-        height=HEIGHT, width=WIDTH, count=12,
-        dtype="float32", crs="EPSG:4326",
-        transform=_transform(), nodata=-9999.0,
-    ) as dst:
-        for i in range(12):
-            dst.write(data[i], i + 1)
-    print(f"Created {path} ({os.path.getsize(path)} bytes)")
-
-
-def create_true_color():
-    """3-band GeoTIFF: RGB (B04, B03, B02) reflectance, uint16, range 0-10000."""
-    rng = np.random.default_rng(43)
-    path = os.path.join(FIXTURES_DIR, "true_color.tif")
-    data = np.zeros((3, HEIGHT, WIDTH), dtype=np.uint16)
-    # Semi-arid landscape: brownish-green
-    data[0] = rng.integers(800, 1500, (HEIGHT, WIDTH))   # Red
-    data[1] = rng.integers(700, 1300, (HEIGHT, WIDTH))   # Green
-    data[2] = rng.integers(500, 1000, (HEIGHT, WIDTH))   # Blue
-
-    with rasterio.open(
-        path, "w", driver="GTiff",
-        height=HEIGHT, width=WIDTH, count=3,
-        dtype="uint16", crs="EPSG:4326",
-        transform=_transform(), nodata=0,
-    ) as dst:
-        for i in range(3):
-            dst.write(data[i], i + 1)
-    print(f"Created {path} ({os.path.getsize(path)} bytes)")
-
-
-if __name__ == "__main__":
-    create_ndvi_monthly()
-    create_true_color()
-    print("Done.")

tests/test_api_auth.py

@@ -1,103 +0,0 @@
-"""Tests for auth middleware — get_current_user dependency."""
-import time
-import hashlib
-import pytest
-from httpx import AsyncClient, ASGITransport
-from app.main import create_app
-
-
-def _make_token(email: str) -> str:
-    """Mirror the backend token generation for test fixtures."""
-    secret = "aperture-mvp-secret-change-in-production"
-    hour = int(time.time() // 3600)
-    payload = f"{email}:{hour}:{secret}"
-    return hashlib.sha256(payload.encode()).hexdigest()[:32]
-
-
-@pytest.fixture
-async def client(tmp_path):
-    app = create_app(db_path=str(tmp_path / "test.db"), run_worker=False)
-    transport = ASGITransport(app=app)
-    async with AsyncClient(transport=transport, base_url="http://test") as c:
-        yield c
-
-
-@pytest.mark.asyncio
-async def test_auth_header_valid(client):
-    email = "user@example.com"
-    token = _make_token(email)
-    resp = await client.get(
-        "/api/jobs",
-        headers={"Authorization": f"Bearer {email}:{token}"},
-    )
-    assert resp.status_code == 200
-
-
-@pytest.mark.asyncio
-async def test_auth_header_missing(client):
-    resp = await client.get("/api/jobs")
-    assert resp.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_auth_header_bad_token(client):
-    resp = await client.get(
-        "/api/jobs",
-        headers={"Authorization": "Bearer user@example.com:badtoken"},
-    )
-    assert resp.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_auth_header_malformed(client):
-    resp = await client.get(
-        "/api/jobs",
-        headers={"Authorization": "Bearer garbage"},
-    )
-    assert resp.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_full_auth_and_job_list_flow(client):
-    email = "flow@example.com"
-
-    # 1. Request magic link
-    resp = await client.post("/api/auth/request", json={"email": email})
-    assert resp.status_code == 200
-    demo_token = resp.json()["demo_token"]
-
-    # 2. Verify token
-    resp = await client.post(
-        "/api/auth/verify", json={"email": email, "token": demo_token}
-    )
-    assert resp.status_code == 200
-    assert resp.json()["verified"] is True
-
-    # 3. Submit a job with auth
-    headers = {"Authorization": f"Bearer {email}:{demo_token}"}
-    job_payload = {
-        "aoi": {"name": "Test Area", "bbox": [32.5, 15.5, 32.6, 15.6]},
-        "time_range": {"start": "2025-03-01", "end": "2026-03-01"},
-        "indicator_ids": ["fires"],
-        "email": email,
-    }
-    resp = await client.post("/api/jobs", json=job_payload, headers=headers)
-    assert resp.status_code == 201
-    job_id = resp.json()["id"]
-
-    # 4. List jobs — should see the one we created
-    resp = await client.get("/api/jobs", headers=headers)
-    assert resp.status_code == 200
-    jobs = resp.json()
-    assert len(jobs) == 1
-    assert jobs[0]["id"] == job_id
-    assert jobs[0]["aoi_name"] == "Test Area"
-    assert jobs[0]["indicator_count"] == 1
-
-    # 5. Other user sees nothing
-    other_email = "other@example.com"
-    other_token = _make_token(other_email)
-    other_headers = {"Authorization": f"Bearer {other_email}:{other_token}"}
-    resp = await client.get("/api/jobs", headers=other_headers)
-    assert resp.status_code == 200
-    assert resp.json() == []

tests/test_api_indicators.py

@@ -1,38 +0,0 @@
-import pytest
-from httpx import AsyncClient, ASGITransport
-
-from app.main import create_app
-from app.indicators import registry
-from app.indicators.base import BaseIndicator
-from app.models import AOI, TimeRange, IndicatorResult, StatusLevel, TrendDirection, ConfidenceLevel
-
-
-class StubIndicator(BaseIndicator):
-    id = "stub"
-    name = "Stub"
-    category = "test"
-    question = "Is this a stub?"
-    estimated_minutes = 1
-
-    async def process(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        raise NotImplementedError
-
-
-@pytest.fixture
-async def client(temp_db_path):
-    registry._indicators.clear()
-    registry.register(StubIndicator())
-    app = create_app(db_path=temp_db_path)
-    transport = ASGITransport(app=app)
-    async with AsyncClient(transport=transport, base_url="http://test") as c:
-        yield c
-
-
-@pytest.mark.asyncio
-async def test_list_indicators(client):
-    resp = await client.get("/api/indicators")
-    assert resp.status_code == 200
-    data = resp.json()
-    assert len(data) >= 1
-    assert data[0]["id"] == "stub"
-    assert data[0]["question"] == "Is this a stub?"

tests/test_api_jobs.py

@@ -1,99 +0,0 @@
-import time
-import hashlib
-
-import pytest
-from httpx import AsyncClient, ASGITransport
-
-from app.main import create_app
-
-
-def _make_token(email: str) -> str:
-    secret = "aperture-mvp-secret-change-in-production"
-    hour = int(time.time() // 3600)
-    payload = f"{email}:{hour}:{secret}"
-    return hashlib.sha256(payload.encode()).hexdigest()[:32]
-
-
-def _auth_headers(email: str = "test@example.com") -> dict:
-    token = _make_token(email)
-    return {"Authorization": f"Bearer {email}:{token}"}
-
-
-@pytest.fixture
-async def client(temp_db_path):
-    app = create_app(db_path=temp_db_path)
-    transport = ASGITransport(app=app)
-    async with AsyncClient(transport=transport, base_url="http://test") as c:
-        yield c
-
-
-# --- Auth-required tests (new) ---
-
-
-@pytest.mark.asyncio
-async def test_submit_job_requires_auth(client, sample_job_request):
-    resp = await client.post("/api/jobs", json=sample_job_request.model_dump(mode="json"))
-    assert resp.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_get_job_requires_auth(client, sample_job_request):
-    # Create a job first (with auth)
-    resp = await client.post(
-        "/api/jobs",
-        json=sample_job_request.model_dump(mode="json"),
-        headers=_auth_headers(),
-    )
-    job_id = resp.json()["id"]
-    # Try to get without auth
-    resp = await client.get(f"/api/jobs/{job_id}")
-    assert resp.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_get_job_wrong_user(client, sample_job_request):
-    resp = await client.post(
-        "/api/jobs",
-        json=sample_job_request.model_dump(mode="json"),
-        headers=_auth_headers("test@example.com"),
-    )
-    job_id = resp.json()["id"]
-    resp = await client.get(
-        f"/api/jobs/{job_id}",
-        headers=_auth_headers("other@example.com"),
-    )
-    assert resp.status_code == 403
-
-
-# --- Existing tests (updated with auth headers) ---
-
-
-@pytest.mark.asyncio
-async def test_submit_job(client, sample_job_request):
-    resp = await client.post(
-        "/api/jobs",
-        json=sample_job_request.model_dump(mode="json"),
-        headers=_auth_headers(),
-    )
-    assert resp.status_code == 201
-    data = resp.json()
-    assert "id" in data
-
-
-@pytest.mark.asyncio
-async def test_get_job(client, sample_job_request):
-    resp = await client.post(
-        "/api/jobs",
-        json=sample_job_request.model_dump(mode="json"),
-        headers=_auth_headers(),
-    )
-    job_id = resp.json()["id"]
-    resp = await client.get(f"/api/jobs/{job_id}", headers=_auth_headers())
-    assert resp.status_code == 200
-    assert resp.json()["id"] == job_id
-
-
-@pytest.mark.asyncio
-async def test_get_unknown_job_returns_404(client):
-    resp = await client.get("/api/jobs/nonexistent", headers=_auth_headers())
-    assert resp.status_code == 404

tests/test_charts.py

@@ -1,102 +0,0 @@
-import pytest
-import tempfile
-import os
-from app.outputs.charts import render_timeseries_chart
-from app.models import StatusLevel, TrendDirection
-
-
-def test_render_timeseries_chart_creates_png():
-    chart_data = {
-        "dates": ["2025-01", "2025-02", "2025-03", "2025-04", "2025-05", "2025-06"],
-        "values": [2, 3, 1, 5, 4, 7],
-    }
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out_path = os.path.join(tmpdir, "chart.png")
-        render_timeseries_chart(
-            chart_data=chart_data,
-            indicator_name="Active Fires",
-            status=StatusLevel.RED,
-            trend=TrendDirection.DETERIORATING,
-            output_path=out_path,
-            y_label="Fire events",
-        )
-        assert os.path.exists(out_path)
-        assert os.path.getsize(out_path) > 1000
-
-
-def test_render_timeseries_chart_handles_empty_data():
-    chart_data = {"dates": [], "values": []}
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out_path = os.path.join(tmpdir, "empty_chart.png")
-        render_timeseries_chart(
-            chart_data=chart_data,
-            indicator_name="Active Fires",
-            status=StatusLevel.GREEN,
-            trend=TrendDirection.STABLE,
-            output_path=out_path,
-            y_label="Fire events",
-        )
-        assert os.path.exists(out_path)
-
-
-def test_render_timeseries_chart_with_monthly_baseline():
-    chart_data = {
-        "dates": ["2025-01", "2025-02", "2025-03", "2025-04", "2025-05", "2025-06"],
-        "values": [2, 3, 1, 5, 4, 7],
-        "baseline_mean": [3.0, 3.5, 2.5, 4.0, 4.5, 5.0],
-        "baseline_min": [1.0, 1.5, 0.5, 2.0, 2.5, 3.0],
-        "baseline_max": [5.0, 5.5, 4.5, 6.0, 6.5, 7.0],
-    }
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out_path = os.path.join(tmpdir, "monthly_baseline_chart.png")
-        render_timeseries_chart(
-            chart_data=chart_data,
-            indicator_name="NDVI",
-            status=StatusLevel.GREEN,
-            trend=TrendDirection.IMPROVING,
-            output_path=out_path,
-            y_label="NDVI value",
-        )
-        assert os.path.exists(out_path)
-        assert os.path.getsize(out_path) > 1000
-
-
-def test_render_timeseries_chart_with_summary_baseline():
-    chart_data = {
-        "dates": ["2025-01", "2025-02", "2025-03", "2025-04", "2025-05", "2025-06"],
-        "values": [2, 3, 1, 5, 4, 7],
-        "baseline_range_mean": 4.0,
-        "baseline_range_min": 2.0,
-        "baseline_range_max": 6.0,
-    }
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out_path = os.path.join(tmpdir, "summary_baseline_chart.png")
-        render_timeseries_chart(
-            chart_data=chart_data,
-            indicator_name="NDVI",
-            status=StatusLevel.AMBER,
-            trend=TrendDirection.STABLE,
-            output_path=out_path,
-            y_label="NDVI value",
-        )
-        assert os.path.exists(out_path)
-        assert os.path.getsize(out_path) > 1000
-
-
-def test_render_timeseries_chart_no_baseline_still_works():
-    chart_data = {
-        "dates": ["2025-01", "2025-02", "2025-03", "2025-04", "2025-05", "2025-06"],
-        "values": [2, 3, 1, 5, 4, 7],
-    }
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out_path = os.path.join(tmpdir, "no_baseline_chart.png")
-        render_timeseries_chart(
-            chart_data=chart_data,
-            indicator_name="NDVI",
-            status=StatusLevel.RED,
-            trend=TrendDirection.DETERIORATING,
-            output_path=out_path,
-            y_label="NDVI value",
-        )
-        assert os.path.exists(out_path)
-        assert os.path.getsize(out_path) > 1000

tests/test_config.py

@@ -1,34 +0,0 @@
-"""Tests for app.config — centralized configuration."""
-import os
-import pytest
-
-
-def test_default_resolution():
-    """Default resolution is 100m (free-tier HF Space)."""
-    from app.config import RESOLUTION_M
-    assert RESOLUTION_M == 100
-
-
-def test_default_max_aoi():
-    """Default max AOI is 500 km²."""
-    from app.config import MAX_AOI_KM2
-    assert MAX_AOI_KM2 == 500
-
-
-def test_default_openeo_backend():
-    """Default openEO backend is CDSE."""
-    from app.config import OPENEO_BACKEND
-    assert OPENEO_BACKEND == "openeo.dataspace.copernicus.eu"
-
-
-def test_resolution_env_override(monkeypatch):
-    """APERTURE_RESOLUTION_M env var overrides the default."""
-    monkeypatch.setenv("APERTURE_RESOLUTION_M", "20")
-    # Force reimport to pick up env var
-    import importlib
-    import app.config
-    importlib.reload(app.config)
-    assert app.config.RESOLUTION_M == 20
-    # Reset
-    monkeypatch.delenv("APERTURE_RESOLUTION_M", raising=False)
-    importlib.reload(app.config)

tests/test_database.py

@@ -1,107 +0,0 @@
-import aiosqlite
-import pytest
-from app.database import Database
-from app.models import JobStatus
-
-
-@pytest.mark.asyncio
-async def test_create_and_get_job(temp_db_path, sample_job_request):
-    db = Database(temp_db_path)
-    await db.init()
-
-    job_id = await db.create_job(sample_job_request)
-    assert isinstance(job_id, str)
-    assert len(job_id) > 0
-
-    job = await db.get_job(job_id)
-    assert job.id == job_id
-    assert job.status == JobStatus.QUEUED
-    assert job.request.aoi.name == "Khartoum North"
-    assert job.request.indicator_ids == ["fires", "cropland"]
-
-
-@pytest.mark.asyncio
-async def test_update_job_status(temp_db_path, sample_job_request):
-    db = Database(temp_db_path)
-    await db.init()
-
-    job_id = await db.create_job(sample_job_request)
-    await db.update_job_status(job_id, JobStatus.PROCESSING)
-
-    job = await db.get_job(job_id)
-    assert job.status == JobStatus.PROCESSING
-
-
-@pytest.mark.asyncio
-async def test_update_job_progress(temp_db_path, sample_job_request):
-    db = Database(temp_db_path)
-    await db.init()
-
-    job_id = await db.create_job(sample_job_request)
-    await db.update_job_progress(job_id, "fires", "complete")
-
-    job = await db.get_job(job_id)
-    assert job.progress["fires"] == "complete"
-
-
-@pytest.mark.asyncio
-async def test_get_next_queued_job(temp_db_path, sample_job_request):
-    db = Database(temp_db_path)
-    await db.init()
-
-    job_id = await db.create_job(sample_job_request)
-    next_job = await db.get_next_queued_job()
-    assert next_job is not None
-    assert next_job.id == job_id
-
-
-@pytest.mark.asyncio
-async def test_get_next_queued_returns_none_when_empty(temp_db_path):
-    db = Database(temp_db_path)
-    await db.init()
-
-    next_job = await db.get_next_queued_job()
-    assert next_job is None
-
-
-@pytest.mark.asyncio
-async def test_get_unknown_job_returns_none(temp_db_path):
-    db = Database(temp_db_path)
-    await db.init()
-
-    job = await db.get_job("nonexistent-id")
-    assert job is None
-
-
-@pytest.mark.asyncio
-async def test_create_job_stores_email(temp_db_path, sample_job_request):
-    db = Database(temp_db_path)
-    await db.init()
-    job_id = await db.create_job(sample_job_request)
-    # Read raw row to confirm email column
-    async with aiosqlite.connect(temp_db_path) as conn:
-        cur = await conn.execute("SELECT email FROM jobs WHERE id = ?", (job_id,))
-        row = await cur.fetchone()
-    assert row[0] == "test@example.com"
-
-
-@pytest.mark.asyncio
-async def test_get_jobs_by_email(temp_db_path, sample_job_request):
-    db = Database(temp_db_path)
-    await db.init()
-    id1 = await db.create_job(sample_job_request)
-    id2 = await db.create_job(sample_job_request)
-    jobs = await db.get_jobs_by_email("test@example.com")
-    assert len(jobs) == 2
-    # Most recent first
-    assert jobs[0].id == id2
-    assert jobs[1].id == id1
-
-
-@pytest.mark.asyncio
-async def test_get_jobs_by_email_filters(temp_db_path, sample_job_request):
-    db = Database(temp_db_path)
-    await db.init()
-    await db.create_job(sample_job_request)
-    jobs = await db.get_jobs_by_email("other@example.com")
-    assert len(jobs) == 0

tests/test_indicator_base.py

@@ -1,173 +0,0 @@
-"""Tests for BaseIndicator batch interface."""
-from __future__ import annotations
-
-import pytest
-from datetime import date
-from unittest.mock import MagicMock
-from app.indicators.base import BaseIndicator, IndicatorRegistry
-from app.models import AOI, TimeRange, IndicatorResult, StatusLevel, TrendDirection, ConfidenceLevel
-
-
-class FakeIndicator(BaseIndicator):
-    id = "fake"
-    name = "Fake Indicator"
-    category = "test"
-    question = "Is this a test?"
-    estimated_minutes = 1
-
-    async def process(self, aoi: AOI, time_range: TimeRange) -> IndicatorResult:
-        return IndicatorResult(
-            indicator_id=self.id,
-            headline="Test headline",
-            status=StatusLevel.GREEN,
-            trend=TrendDirection.STABLE,
-            confidence=ConfidenceLevel.HIGH,
-            map_layer_path="/tmp/fake.tif",
-            chart_data={"dates": [], "values": []},
-            summary="Test summary.",
-            methodology="Test methodology.",
-            limitations=[],
-        )
-
-
-def test_base_indicator_meta():
-    ind = FakeIndicator()
-    meta = ind.meta()
-    assert meta.id == "fake"
-    assert meta.name == "Fake Indicator"
-    assert meta.estimated_minutes == 1
-
-
-@pytest.mark.asyncio
-async def test_base_indicator_process():
-    ind = FakeIndicator()
-    aoi = AOI(name="Test", bbox=[32.45, 15.65, 32.65, 15.80])
-    tr = TimeRange()
-    result = await ind.process(aoi, tr)
-    assert result.indicator_id == "fake"
-    assert result.status == StatusLevel.GREEN
-
-
-def test_registry_register_and_get():
-    registry = IndicatorRegistry()
-    ind = FakeIndicator()
-    registry.register(ind)
-    assert registry.get("fake") is ind
-    assert "fake" in registry.list_ids()
-
-
-def test_registry_get_unknown_raises():
-    registry = IndicatorRegistry()
-    with pytest.raises(KeyError, match="nonexistent"):
-        registry.get("nonexistent")
-
-
-def test_registry_catalogue():
-    registry = IndicatorRegistry()
-    registry.register(FakeIndicator())
-    catalogue = registry.catalogue()
-    assert len(catalogue) == 1
-    assert catalogue[0].id == "fake"
-
-
-# --- Batch interface tests ---
-
-class PlainIndicator(BaseIndicator):
-    """Non-batch indicator for testing."""
-    id = "plain"
-    name = "Plain"
-    category = "T1"
-    question = "Test?"
-    estimated_minutes = 1
-
-    async def process(self, aoi, time_range, season_months=None):
-        return IndicatorResult(
-            indicator_id="plain", headline="ok",
-            status=StatusLevel.GREEN, trend=TrendDirection.STABLE,
-            confidence=ConfidenceLevel.HIGH, map_layer_path="",
-            chart_data={}, summary="", methodology="", limitations=[],
-        )
-
-
-class BatchIndicator(BaseIndicator):
-    """Batch indicator for testing."""
-    id = "batch"
-    name = "Batch"
-    category = "T2"
-    question = "Batch test?"
-    estimated_minutes = 5
-    uses_batch = True
-
-    async def process(self, aoi, time_range, season_months=None):
-        return IndicatorResult(
-            indicator_id="batch", headline="fallback",
-            status=StatusLevel.GREEN, trend=TrendDirection.STABLE,
-            confidence=ConfidenceLevel.LOW, map_layer_path="",
-            chart_data={}, data_source="placeholder",
-            summary="", methodology="", limitations=[],
-        )
-
-    async def submit_batch(self, aoi, time_range, season_months=None):
-        return [MagicMock()]
-
-    async def harvest(self, aoi, time_range, season_months=None, batch_jobs=None):
-        return IndicatorResult(
-            indicator_id="batch", headline="harvested",
-            status=StatusLevel.GREEN, trend=TrendDirection.STABLE,
-            confidence=ConfidenceLevel.HIGH, map_layer_path="",
-            chart_data={}, data_source="satellite",
-            summary="", methodology="", limitations=[],
-        )
-
-
-def test_plain_indicator_uses_batch_is_false():
-    ind = PlainIndicator()
-    assert ind.uses_batch is False
-
-
-def test_batch_indicator_uses_batch_is_true():
-    ind = BatchIndicator()
-    assert ind.uses_batch is True
-
-
-@pytest.mark.asyncio
-async def test_plain_indicator_submit_batch_raises():
-    ind = PlainIndicator()
-    with pytest.raises(NotImplementedError):
-        await ind.submit_batch(
-            AOI(name="T", bbox=[32.0, 15.0, 32.1, 15.1]),
-            TimeRange(start=date(2025, 1, 1), end=date(2025, 6, 30)),
-        )
-
-
-@pytest.mark.asyncio
-async def test_plain_indicator_harvest_raises():
-    ind = PlainIndicator()
-    with pytest.raises(NotImplementedError):
-        await ind.harvest(
-            AOI(name="T", bbox=[32.0, 15.0, 32.1, 15.1]),
-            TimeRange(start=date(2025, 1, 1), end=date(2025, 6, 30)),
-            batch_jobs=[],
-        )
-
-
-@pytest.mark.asyncio
-async def test_batch_indicator_submit_returns_jobs():
-    ind = BatchIndicator()
-    jobs = await ind.submit_batch(
-        AOI(name="T", bbox=[32.0, 15.0, 32.1, 15.1]),
-        TimeRange(start=date(2025, 1, 1), end=date(2025, 6, 30)),
-    )
-    assert len(jobs) == 1
-
-
-@pytest.mark.asyncio
-async def test_batch_indicator_harvest_returns_result():
-    ind = BatchIndicator()
-    result = await ind.harvest(
-        AOI(name="T", bbox=[32.0, 15.0, 32.1, 15.1]),
-        TimeRange(start=date(2025, 1, 1), end=date(2025, 6, 30)),
-        batch_jobs=[MagicMock()],
-    )
-    assert result.data_source == "satellite"
-    assert result.headline == "harvested"

tests/test_indicator_buildup.py

@@ -1,226 +0,0 @@
-"""Tests for app.indicators.buildup — built-up extent via NDBI from openEO."""
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch
-from datetime import date
-
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-import pytest
-
-from app.models import AOI, TimeRange, StatusLevel, TrendDirection, ConfidenceLevel
-from tests.conftest import mock_rgb_tif, make_mock_batch_job
-
-BBOX = [32.45, 15.65, 32.65, 15.8]
-
-
-@pytest.fixture
-def test_aoi():
-    return AOI(name="Test", bbox=BBOX)
-
-
-@pytest.fixture
-def test_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-def _mock_ndbi_tif(path: str, n_months: int = 12, buildup_fraction: float = 0.15):
-    """Create synthetic NDBI GeoTIFF. Values > 0 with low NDVI = built-up."""
-    rng = np.random.default_rng(55)
-    data = np.zeros((n_months, 10, 10), dtype=np.float32)
-    for m in range(n_months):
-        vals = rng.normal(-0.15, 0.2, (10, 10))
-        buildup_mask = rng.random((10, 10)) < buildup_fraction
-        vals[buildup_mask] = rng.uniform(0.05, 0.4, buildup_mask.sum())
-        data[m] = vals
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=n_months,
-        dtype="float32", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
-    ) as dst:
-        for i in range(n_months):
-            dst.write(data[i], i + 1)
-
-
-@pytest.mark.asyncio
-async def test_buildup_process_returns_result(test_aoi, test_time_range):
-    """BuiltupIndicator.process() returns a valid IndicatorResult."""
-    from app.indicators.buildup import BuiltupIndicator
-
-    indicator = BuiltupIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        ndbi_path = os.path.join(tmpdir, "ndbi.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_ndbi_tif(ndbi_path)
-        mock_rgb_tif(rgb_path)
-
-        mock_cube = MagicMock()
-
-        def fake_download(path, **kwargs):
-            import shutil
-            if "ndbi" in path or "buildup" in path:
-                shutil.copy(ndbi_path, path)
-            else:
-                shutil.copy(rgb_path, path)
-
-        mock_cube.download = MagicMock(side_effect=fake_download)
-
-        with patch("app.indicators.buildup.get_connection"), \
-             patch("app.indicators.buildup.build_buildup_graph", return_value=mock_cube), \
-             patch("app.indicators.buildup.build_true_color_graph", return_value=mock_cube):
-            result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "buildup"
-    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
-    assert result.data_source == "satellite"
-    assert "NDBI" in result.methodology or "built-up" in result.methodology.lower()
-    assert len(result.chart_data.get("dates", [])) > 0
-
-
-@pytest.mark.asyncio
-async def test_buildup_falls_back_on_failure(test_aoi, test_time_range):
-    """BuiltupIndicator falls back gracefully when openEO fails."""
-    from app.indicators.buildup import BuiltupIndicator
-
-    indicator = BuiltupIndicator()
-
-    with patch("app.indicators.buildup.get_connection", side_effect=Exception("CDSE down")):
-        result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "buildup"
-    assert result.data_source == "placeholder"
-
-
-def test_buildup_compute_stats():
-    """_compute_stats() extracts built-up fraction from NDBI raster."""
-    from app.indicators.buildup import BuiltupIndicator
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        path = os.path.join(tmpdir, "ndbi.tif")
-        _mock_ndbi_tif(path, n_months=12, buildup_fraction=0.2)
-        stats = BuiltupIndicator._compute_stats(path)
-
-    assert "monthly_buildup_fractions" in stats
-    assert len(stats["monthly_buildup_fractions"]) == 12
-    assert "overall_buildup_fraction" in stats
-    assert 0 < stats["overall_buildup_fraction"] < 1
-    assert "valid_months" in stats
-
-
-def test_buildup_classify():
-    """_classify() maps change percentage to correct status."""
-    from app.indicators.buildup import BuiltupIndicator
-
-    assert BuiltupIndicator._classify(change_pct=5.0) == StatusLevel.GREEN
-    assert BuiltupIndicator._classify(change_pct=15.0) == StatusLevel.AMBER
-    assert BuiltupIndicator._classify(change_pct=35.0) == StatusLevel.RED
-    assert BuiltupIndicator._classify(change_pct=-25.0) == StatusLevel.AMBER
-    assert BuiltupIndicator._classify(change_pct=-35.0) == StatusLevel.RED
-
-
-@pytest.mark.asyncio
-async def test_buildup_submit_batch_creates_three_jobs(test_aoi, test_time_range):
-    """submit_batch() creates current, baseline, and true-color batch jobs."""
-    from app.indicators.buildup import BuiltupIndicator
-
-    indicator = BuiltupIndicator()
-
-    mock_conn = MagicMock()
-    mock_job = MagicMock()
-    mock_job.job_id = "j-test"
-    mock_conn.create_job.return_value = mock_job
-
-    with patch("app.indicators.buildup.get_connection", return_value=mock_conn), \
-         patch("app.indicators.buildup.build_buildup_graph") as mock_bu_graph, \
-         patch("app.indicators.buildup.build_true_color_graph") as mock_tc_graph:
-
-        mock_bu_graph.return_value = MagicMock()
-        mock_tc_graph.return_value = MagicMock()
-
-        jobs = await indicator.submit_batch(test_aoi, test_time_range)
-
-    assert len(jobs) == 3
-    assert mock_bu_graph.call_count == 2
-    assert mock_tc_graph.call_count == 1
-
-
-@pytest.mark.asyncio
-async def test_buildup_harvest_computes_result_from_batch_jobs(test_aoi, test_time_range):
-    """harvest() downloads batch results and returns IndicatorResult."""
-    from app.indicators.buildup import BuiltupIndicator
-
-    indicator = BuiltupIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        ndbi_path = os.path.join(tmpdir, "ndbi.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_ndbi_tif(ndbi_path)
-        mock_rgb_tif(rgb_path)
-
-        current_job = make_mock_batch_job(ndbi_path)
-        baseline_job = make_mock_batch_job(ndbi_path)
-        true_color_job = make_mock_batch_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 == "buildup"
-    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
-    assert "baseline_mean" in result.chart_data
-    assert len(result.chart_data["baseline_mean"]) > 0
-
-
-@pytest.mark.asyncio
-async def test_buildup_harvest_falls_back_when_current_fails(test_aoi, test_time_range):
-    """harvest() returns placeholder when current NDBI job failed."""
-    from app.indicators.buildup import BuiltupIndicator
-
-    indicator = BuiltupIndicator()
-
-    current_job = MagicMock()
-    current_job.download_results.side_effect = Exception("failed")
-    baseline_job = MagicMock()
-    true_color_job = MagicMock()
-
-    result = await indicator.harvest(
-        test_aoi, test_time_range,
-        batch_jobs=[current_job, baseline_job, true_color_job],
-    )
-
-    assert result.data_source == "placeholder"
-
-
-@pytest.mark.asyncio
-async def test_buildup_harvest_degrades_when_baseline_fails(test_aoi, test_time_range):
-    """harvest() returns degraded result when baseline NDBI job failed."""
-    from app.indicators.buildup import BuiltupIndicator
-
-    indicator = BuiltupIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        ndbi_path = os.path.join(tmpdir, "ndbi.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_ndbi_tif(ndbi_path)
-        mock_rgb_tif(rgb_path)
-
-        current_job = make_mock_batch_job(ndbi_path)
-        baseline_job = make_mock_batch_job(ndbi_path, fail=True)
-        true_color_job = make_mock_batch_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 == "buildup"
-    assert result.data_source == "satellite"
-    assert result.confidence == ConfidenceLevel.LOW

tests/test_indicator_cropland.py

@@ -1,227 +0,0 @@
-"""Tests for the D1 Cropland Productivity indicator."""
-from __future__ import annotations
-
-import pytest
-from datetime import date
-from unittest.mock import AsyncMock, patch
-
-from app.indicators.cropland import CroplandIndicator
-from app.models import AOI, TimeRange, StatusLevel, TrendDirection, ConfidenceLevel
-
-
-@pytest.fixture
-def cropland_indicator():
-    return CroplandIndicator()
-
-
-@pytest.fixture
-def sample_aoi():
-    return AOI(name="Khartoum Test", bbox=[32.45, 15.65, 32.65, 15.80])
-
-
-@pytest.fixture
-def sample_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-# ---------------------------------------------------------------------------
-# Meta
-# ---------------------------------------------------------------------------
-
-def test_cropland_meta(cropland_indicator):
-    meta = cropland_indicator.meta()
-    assert meta.id == "cropland"
-    assert meta.category == "D1"
-
-
-# ---------------------------------------------------------------------------
-# Red status: severe decline (> 15pp drop)
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_cropland_red_when_severe_decline(
-    cropland_indicator, sample_aoi, sample_time_range
-):
-    with patch.object(
-        cropland_indicator,
-        "_fetch_comparison",
-        new=AsyncMock(return_value=(45.0, 25.0, 6)),  # -20pp
-    ):
-        result = await cropland_indicator.process(sample_aoi, sample_time_range)
-
-    assert result.indicator_id == "cropland"
-    assert result.status == StatusLevel.RED
-    assert result.trend == TrendDirection.DETERIORATING
-    assert "abandonment" in result.headline.lower()
-
-
-# ---------------------------------------------------------------------------
-# Amber status: moderate decline (5-15pp drop)
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_cropland_amber_when_moderate_decline(
-    cropland_indicator, sample_aoi, sample_time_range
-):
-    with patch.object(
-        cropland_indicator,
-        "_fetch_comparison",
-        new=AsyncMock(return_value=(45.0, 35.0, 6)),  # -10pp
-    ):
-        result = await cropland_indicator.process(sample_aoi, sample_time_range)
-
-    assert result.status == StatusLevel.AMBER
-
-
-# ---------------------------------------------------------------------------
-# Green status: stable (within ±5pp)
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_cropland_green_when_stable(
-    cropland_indicator, sample_aoi, sample_time_range
-):
-    with patch.object(
-        cropland_indicator,
-        "_fetch_comparison",
-        new=AsyncMock(return_value=(45.0, 43.0, 6)),  # -2pp
-    ):
-        result = await cropland_indicator.process(sample_aoi, sample_time_range)
-
-    assert result.status == StatusLevel.GREEN
-    assert result.trend == TrendDirection.STABLE
-    assert "stable" in result.headline.lower()
-
-
-# ---------------------------------------------------------------------------
-# Confidence based on n_months
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_cropland_low_confidence_with_few_months(
-    cropland_indicator, sample_aoi, sample_time_range
-):
-    with patch.object(
-        cropland_indicator,
-        "_fetch_comparison",
-        new=AsyncMock(return_value=(45.0, 43.0, 2)),  # only 2 months
-    ):
-        result = await cropland_indicator.process(sample_aoi, sample_time_range)
-
-    assert result.confidence == ConfidenceLevel.LOW
-
-
-@pytest.mark.asyncio
-async def test_cropland_high_confidence_with_many_months(
-    cropland_indicator, sample_aoi, sample_time_range
-):
-    with patch.object(
-        cropland_indicator,
-        "_fetch_comparison",
-        new=AsyncMock(return_value=(45.0, 43.0, 6)),
-    ):
-        result = await cropland_indicator.process(sample_aoi, sample_time_range)
-
-    assert result.confidence == ConfidenceLevel.HIGH
-
-
-# ---------------------------------------------------------------------------
-# Result has required fields
-# ---------------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_cropland_result_has_all_fields(
-    cropland_indicator, sample_aoi, sample_time_range
-):
-    with patch.object(
-        cropland_indicator,
-        "_fetch_comparison",
-        new=AsyncMock(return_value=(45.0, 40.0, 5)),
-    ):
-        result = await cropland_indicator.process(sample_aoi, sample_time_range)
-
-    assert result.indicator_id == "cropland"
-    assert isinstance(result.headline, str) and result.headline
-    assert isinstance(result.summary, str) and result.summary
-    assert isinstance(result.methodology, str) and result.methodology
-    assert isinstance(result.limitations, list) and result.limitations
-    assert "dates" in result.chart_data
-    assert "values" in result.chart_data
-    assert "growing season" in result.methodology.lower()
-
-
-# ---------------------------------------------------------------------------
-# Classify boundaries
-# ---------------------------------------------------------------------------
-
-def test_classify_boundary():
-    ind = CroplandIndicator()
-    assert ind._classify(0) == StatusLevel.GREEN      # no change
-    assert ind._classify(-5) == StatusLevel.GREEN      # boundary
-    assert ind._classify(-5.1) == StatusLevel.AMBER
-    assert ind._classify(-15) == StatusLevel.AMBER     # boundary
-    assert ind._classify(-15.1) == StatusLevel.RED
-
-
-# ---------------------------------------------------------------------------
-# Baseline range in chart data
-# ---------------------------------------------------------------------------
-
-def test_build_chart_data_includes_baseline_range():
-    from app.indicators.cropland import CroplandIndicator
-    from datetime import date
-    from app.models import TimeRange
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = CroplandIndicator._build_chart_data(
-        baseline=40.0, current=42.0, time_range=tr,
-        baseline_yearly_means=[38.0, 40.0, 42.0],
-    )
-    assert "baseline_range_mean" in result
-    assert "baseline_range_min" in result
-    assert "baseline_range_max" in result
-    assert result["baseline_range_min"] == 38.0
-    assert result["baseline_range_max"] == 42.0
-
-
-def test_build_chart_data_no_baseline_range_when_absent():
-    from app.indicators.cropland import CroplandIndicator
-    from datetime import date
-    from app.models import TimeRange
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = CroplandIndicator._build_chart_data(
-        baseline=40.0, current=42.0, time_range=tr,
-    )
-    assert "baseline_range_mean" not in result
-    assert "baseline_range_min" not in result
-    assert "baseline_range_max" not in result
-
-
-def test_build_chart_data_no_baseline_range_when_single_year():
-    from app.indicators.cropland import CroplandIndicator
-    from datetime import date
-    from app.models import TimeRange
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = CroplandIndicator._build_chart_data(
-        baseline=40.0, current=42.0, time_range=tr,
-        baseline_yearly_means=[40.0],
-    )
-    assert "baseline_range_mean" not in result
-
-
-def test_build_monthly_chart_data():
-    from app.indicators.cropland import CroplandIndicator
-    from datetime import date
-    from app.models import TimeRange
-
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    current_monthly = {4: 35.0, 5: 40.0, 6: 42.0}
-    baseline_stats = {4: [33.0, 35.0, 37.0], 5: [38.0, 40.0, 42.0], 6: [40.0, 42.0, 44.0]}
-    result = CroplandIndicator._build_monthly_chart_data(
-        current_monthly=current_monthly,
-        baseline_per_year_monthly=baseline_stats,
-        time_range=tr,
-        season_months=[4, 5, 6],
-    )
-    assert len(result["dates"]) == 3
-    assert result["dates"][0] == "2025-04"
-    assert "baseline_mean" in result

tests/test_indicator_fires.py

@@ -1,91 +0,0 @@
-import pytest
-import json
-from datetime import date
-from unittest.mock import AsyncMock, patch
-
-from app.indicators.fires import FiresIndicator
-from app.models import AOI, TimeRange, StatusLevel
-
-
-SAMPLE_FIRMS_CSV = """latitude,longitude,brightness,scan,track,acq_date,acq_time,satellite,confidence,version,bright_t31,frp,daynight
-15.70,32.50,320.5,0.4,0.4,2025-06-15,0130,N,nominal,2.0NRT,290.1,5.2,N
-15.72,32.55,310.2,0.4,0.4,2025-08-20,1300,N,nominal,2.0NRT,288.3,3.1,D
-15.68,32.48,335.0,0.5,0.5,2025-11-01,0200,N,nominal,2.0NRT,295.0,8.7,N
-"""
-
-
-@pytest.fixture
-def fires_indicator():
-    return FiresIndicator()
-
-@pytest.fixture
-def sample_aoi():
-    return AOI(name="Khartoum Test", bbox=[32.45, 15.65, 32.65, 15.80])
-
-@pytest.fixture
-def sample_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-@pytest.mark.asyncio
-async def test_fires_indicator_meta(fires_indicator):
-    meta = fires_indicator.meta()
-    assert meta.id == "fires"
-    assert meta.category == "R3"
-
-
-@pytest.mark.asyncio
-async def test_fires_indicator_process(fires_indicator, sample_aoi, sample_time_range):
-    mock_response = AsyncMock()
-    mock_response.status_code = 200
-    mock_response.text = SAMPLE_FIRMS_CSV
-
-    with patch("app.indicators.fires.httpx.AsyncClient") as mock_client_cls:
-        mock_client = AsyncMock()
-        mock_client.get.return_value = mock_response
-        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
-        mock_client.__aexit__ = AsyncMock(return_value=False)
-        mock_client_cls.return_value = mock_client
-
-        result = await fires_indicator.process(sample_aoi, sample_time_range)
-
-    assert result.indicator_id == "fires"
-    assert result.status == StatusLevel.AMBER  # 3 fires = 1-5 = amber
-    assert "3" in result.headline
-    assert result.confidence.value in ("high", "moderate", "low")
-    assert len(result.chart_data["dates"]) > 0
-
-
-@pytest.mark.asyncio
-async def test_fires_indicator_green_when_no_fires(fires_indicator, sample_aoi, sample_time_range):
-    mock_response = AsyncMock()
-    mock_response.status_code = 200
-    mock_response.text = "latitude,longitude,brightness,scan,track,acq_date,acq_time,satellite,confidence,version,bright_t31,frp,daynight\n"
-
-    with patch("app.indicators.fires.httpx.AsyncClient") as mock_client_cls:
-        mock_client = AsyncMock()
-        mock_client.get.return_value = mock_response
-        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
-        mock_client.__aexit__ = AsyncMock(return_value=False)
-        mock_client_cls.return_value = mock_client
-
-        result = await fires_indicator.process(sample_aoi, sample_time_range)
-
-    assert result.status == StatusLevel.GREEN
-    assert "0" in result.headline or "no" in result.headline.lower()
-
-
-def test_build_chart_data_filters_by_season():
-    rows = [{"acq_date": f"2025-{m:02d}-15"} for m in range(1, 13) for _ in range(3)]
-    season_months = [6, 7, 8, 9]
-    result = FiresIndicator._build_chart_data(rows, season_months)
-    assert len(result["dates"]) == 4
-    assert result["dates"][0] == "2025-06"
-    assert result["dates"][-1] == "2025-09"
-    assert all(v == 3 for v in result["values"])
-
-
-def test_build_chart_data_no_season_returns_all():
-    rows = [{"acq_date": f"2025-{m:02d}-15"} for m in range(1, 13)]
-    result = FiresIndicator._build_chart_data(rows, None)
-    assert len(result["dates"]) == 12

tests/test_indicator_lst.py

@@ -1,117 +0,0 @@
-"""Tests for app.indicators.lst — Sentinel-3 SLSTR LST via openEO."""
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch
-from datetime import date
-
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-import pytest
-
-from app.models import AOI, TimeRange, StatusLevel, ConfidenceLevel
-
-BBOX = [32.45, 15.65, 32.65, 15.8]
-
-
-@pytest.fixture
-def test_aoi():
-    return AOI(name="Test", bbox=BBOX)
-
-
-@pytest.fixture
-def test_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-def _mock_lst_tif(path: str, n_months: int = 12, mean_k: float = 310.0):
-    """Create synthetic LST GeoTIFF in Kelvin."""
-    rng = np.random.default_rng(45)
-    data = np.zeros((n_months, 10, 10), dtype=np.float32)
-    for m in range(n_months):
-        seasonal = 5.0 * np.sin(np.pi * (m - 1) / 6)
-        data[m] = mean_k + seasonal + rng.normal(0, 2, (10, 10))
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=n_months,
-        dtype="float32", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
-    ) as dst:
-        for i in range(n_months):
-            dst.write(data[i], i + 1)
-
-
-def _mock_rgb_tif(path: str):
-    rng = np.random.default_rng(43)
-    data = rng.integers(500, 1500, (3, 10, 10), dtype=np.uint16)
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=3,
-        dtype="uint16", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, 10, 10), nodata=0,
-    ) as dst:
-        for i in range(3):
-            dst.write(data[i], i + 1)
-
-
-@pytest.mark.asyncio
-async def test_lst_process_returns_result(test_aoi, test_time_range):
-    from app.indicators.lst import LSTIndicator
-
-    indicator = LSTIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        lst_path = os.path.join(tmpdir, "lst.tif")
-        baseline_path = os.path.join(tmpdir, "lst_baseline.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_lst_tif(lst_path, mean_k=310.0)
-        _mock_lst_tif(baseline_path, mean_k=308.0)
-        _mock_rgb_tif(rgb_path)
-
-        mock_cube = MagicMock()
-
-        def fake_download(path, **kwargs):
-            import shutil
-            if "lst" in path and "baseline" not in path:
-                shutil.copy(lst_path, path)
-            elif "lst" in path:
-                shutil.copy(baseline_path, path)
-            else:
-                shutil.copy(rgb_path, path)
-
-        mock_cube.download = MagicMock(side_effect=fake_download)
-
-        with patch("app.indicators.lst.get_connection"), \
-             patch("app.indicators.lst.build_lst_graph", return_value=mock_cube), \
-             patch("app.indicators.lst.build_true_color_graph", return_value=mock_cube):
-            result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "lst"
-    assert result.data_source == "satellite"
-    assert len(result.chart_data.get("dates", [])) > 0
-
-
-@pytest.mark.asyncio
-async def test_lst_falls_back_on_failure(test_aoi, test_time_range):
-    from app.indicators.lst import LSTIndicator
-    indicator = LSTIndicator()
-
-    with patch("app.indicators.lst.get_connection", side_effect=Exception("CDSE down")):
-        result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "lst"
-    assert result.data_source == "placeholder"
-
-
-def test_lst_compute_stats():
-    from app.indicators.lst import LSTIndicator
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        path = os.path.join(tmpdir, "lst.tif")
-        _mock_lst_tif(path, mean_k=310.0)
-        stats = LSTIndicator._compute_stats(path)
-
-    assert "monthly_means_celsius" in stats
-    assert len(stats["monthly_means_celsius"]) == 12
-    assert "overall_mean_celsius" in stats
-    assert 30 < stats["overall_mean_celsius"] < 45  # ~310K = ~37C

tests/test_indicator_ndvi.py

@@ -1,285 +0,0 @@
-"""Tests for app.indicators.ndvi — pixel-level NDVI via openEO."""
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch
-from datetime import date
-
-import numpy as np
-import pytest
-
-from app.models import AOI, TimeRange, StatusLevel, TrendDirection, ConfidenceLevel
-from tests.conftest import mock_rgb_tif, make_mock_batch_job
-
-
-@pytest.fixture
-def test_aoi():
-    return AOI(name="Test Khartoum", bbox=[32.45, 15.65, 32.65, 15.8])
-
-
-@pytest.fixture
-def test_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-def _mock_ndvi_tif(path: str, n_months: int = 12):
-    """Create a small synthetic NDVI GeoTIFF at the given path."""
-    import rasterio
-    from rasterio.transform import from_bounds
-    rng = np.random.default_rng(42)
-    data = np.zeros((n_months, 10, 10), dtype=np.float32)
-    for m in range(n_months):
-        data[m] = 0.3 + 0.2 * np.sin(np.pi * (m - 3) / 6) + rng.normal(0, 0.02, (10, 10))
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=n_months,
-        dtype="float32", crs="EPSG:4326",
-        transform=from_bounds(32.45, 15.65, 32.65, 15.8, 10, 10),
-        nodata=-9999.0,
-    ) as dst:
-        for i in range(n_months):
-            dst.write(data[i], i + 1)
-
-
-@pytest.mark.asyncio
-async def test_ndvi_process_returns_indicator_result(test_aoi, test_time_range):
-    """NdviIndicator.process() returns a valid 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_rgb_tif(rgb_path)
-
-        mock_cube = MagicMock()
-
-        def fake_download(path, **kwargs):
-            import shutil
-            if "ndvi" in path:
-                shutil.copy(ndvi_path, path)
-            else:
-                shutil.copy(rgb_path, path)
-
-        mock_cube.download = MagicMock(side_effect=fake_download)
-
-        with patch("app.indicators.ndvi.get_connection") as mock_get_conn, \
-             patch("app.indicators.ndvi.build_ndvi_graph", return_value=mock_cube), \
-             patch("app.indicators.ndvi.build_true_color_graph", return_value=mock_cube):
-
-            result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "ndvi"
-    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
-    assert result.trend in (TrendDirection.IMPROVING, TrendDirection.STABLE, TrendDirection.DETERIORATING)
-    assert result.confidence in (ConfidenceLevel.HIGH, ConfidenceLevel.MODERATE, ConfidenceLevel.LOW)
-    assert "NDVI" in result.methodology or "ndvi" in result.methodology.lower()
-    assert len(result.chart_data.get("dates", [])) > 0
-    assert len(result.chart_data.get("values", [])) > 0
-
-
-@pytest.mark.asyncio
-async def test_ndvi_falls_back_to_placeholder_on_failure(test_aoi, test_time_range):
-    """NdviIndicator falls back gracefully when openEO fails."""
-    from app.indicators.ndvi import NdviIndicator
-
-    indicator = NdviIndicator()
-
-    with patch("app.indicators.ndvi.get_connection", side_effect=Exception("CDSE down")):
-        result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "ndvi"
-    assert result.data_source == "placeholder"
-
-
-def test_ndvi_compute_stats():
-    """_compute_stats() extracts correct statistics from a multi-band raster."""
-    from app.indicators.ndvi import NdviIndicator
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        path = os.path.join(tmpdir, "ndvi.tif")
-        _mock_ndvi_tif(path, n_months=12)
-
-        stats = NdviIndicator._compute_stats(path)
-
-    assert "monthly_means" in stats
-    assert len(stats["monthly_means"]) == 12
-    assert "overall_mean" in stats
-    assert 0 < stats["overall_mean"] < 1
-    assert "valid_months" in stats
-    assert stats["valid_months"] == 12
-
-
-@pytest.mark.asyncio
-async def test_ndvi_submit_batch_creates_three_jobs(test_aoi, test_time_range):
-    """submit_batch() creates current, baseline, and true-color batch jobs."""
-    from app.indicators.ndvi import NdviIndicator
-
-    indicator = NdviIndicator()
-
-    mock_conn = MagicMock()
-    mock_job = MagicMock()
-    mock_job.job_id = "j-test"
-    mock_conn.create_job.return_value = mock_job
-
-    with patch("app.indicators.ndvi.get_connection", return_value=mock_conn), \
-         patch("app.indicators.ndvi.build_ndvi_graph") as mock_ndvi_graph, \
-         patch("app.indicators.ndvi.build_true_color_graph") as mock_tc_graph:
-
-        mock_ndvi_graph.return_value = MagicMock()
-        mock_tc_graph.return_value = MagicMock()
-
-        jobs = await indicator.submit_batch(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_rgb_tif(rgb_path)
-
-        current_job = make_mock_batch_job(ndvi_path)
-        baseline_job = make_mock_batch_job(ndvi_path)
-        true_color_job = make_mock_batch_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_rgb_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"
-
-
-@pytest.mark.asyncio
-async def test_ndvi_harvest_uses_baseline_when_available(test_aoi, test_time_range):
-    """harvest() computes change vs baseline when baseline download succeeds."""
-    from app.indicators.ndvi import NdviIndicator
-
-    indicator = NdviIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        # Current: higher NDVI
-        current_path = os.path.join(tmpdir, "current.tif")
-        _mock_ndvi_tif(current_path, n_months=12)
-
-        # Baseline: lower NDVI (shift down by 0.1)
-        baseline_path = os.path.join(tmpdir, "baseline.tif")
-        import rasterio
-        from rasterio.transform import from_bounds
-        rng = np.random.default_rng(99)
-        data = np.zeros((12, 10, 10), dtype=np.float32)
-        for m in range(12):
-            data[m] = 0.2 + 0.1 * np.sin(np.pi * (m - 3) / 6) + rng.normal(0, 0.02, (10, 10))
-        with rasterio.open(
-            baseline_path, "w", driver="GTiff", height=10, width=10, count=12,
-            dtype="float32", crs="EPSG:4326",
-            transform=from_bounds(32.45, 15.65, 32.65, 15.8, 10, 10),
-            nodata=-9999.0,
-        ) as dst:
-            for i in range(12):
-                dst.write(data[i], i + 1)
-
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        mock_rgb_tif(rgb_path)
-
-        current_job = make_mock_batch_job(current_path)
-        baseline_job = make_mock_batch_job(baseline_path)
-        true_color_job = make_mock_batch_job(rgb_path)
-
-        result = await indicator.harvest(
-            test_aoi, test_time_range,
-            batch_jobs=[current_job, baseline_job, true_color_job],
-        )
-
-    assert result.data_source == "satellite"
-    # With distinct current vs baseline, confidence should NOT be LOW
-    # (it should be HIGH with 12 valid months)
-    assert result.confidence == ConfidenceLevel.HIGH
-    # Baseline band data should be present in chart
-    assert "baseline_mean" in result.chart_data
-    assert len(result.chart_data["baseline_mean"]) > 0

tests/test_indicator_nightlights.py

@@ -1,91 +0,0 @@
-"""Tests for app.indicators.nightlights — VIIRS DNB via EOG direct download."""
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch, AsyncMock
-from datetime import date
-
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-import pytest
-
-from app.models import AOI, TimeRange, StatusLevel, ConfidenceLevel
-
-BBOX = [32.45, 15.65, 32.65, 15.8]
-
-
-@pytest.fixture
-def test_aoi():
-    return AOI(name="Test", bbox=BBOX)
-
-
-@pytest.fixture
-def test_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-def _mock_radiance_tif(path: str, mean_nw: float = 5.0):
-    """Create synthetic VIIRS DNB radiance GeoTIFF (nW/cm2/sr)."""
-    rng = np.random.default_rng(47)
-    data = np.maximum(0, mean_nw + rng.normal(0, 2, (10, 10))).astype(np.float32)
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=1,
-        dtype="float32", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
-    ) as dst:
-        dst.write(data, 1)
-
-
-@pytest.mark.asyncio
-async def test_nightlights_process_returns_result(test_aoi, test_time_range):
-    from app.indicators.nightlights import NightlightsIndicator
-
-    indicator = NightlightsIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        current_path = os.path.join(tmpdir, "viirs_current.tif")
-        baseline_path = os.path.join(tmpdir, "viirs_baseline.tif")
-        _mock_radiance_tif(current_path, mean_nw=5.0)
-        _mock_radiance_tif(baseline_path, mean_nw=6.0)
-
-        with patch.object(indicator, '_download_viirs', new_callable=AsyncMock) as mock_dl:
-            async def fake_dl(bbox, year, output_path):
-                import shutil
-                if "current" in output_path:
-                    shutil.copy(current_path, output_path)
-                else:
-                    shutil.copy(baseline_path, output_path)
-
-            mock_dl.side_effect = fake_dl
-            result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "nightlights"
-    assert result.data_source == "satellite"
-    assert len(result.chart_data.get("dates", [])) > 0
-
-
-@pytest.mark.asyncio
-async def test_nightlights_falls_back_on_failure(test_aoi, test_time_range):
-    from app.indicators.nightlights import NightlightsIndicator
-    indicator = NightlightsIndicator()
-
-    with patch.object(indicator, '_download_viirs', new_callable=AsyncMock, side_effect=Exception("Download failed")):
-        result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "nightlights"
-    assert result.data_source == "placeholder"
-
-
-def test_nightlights_compute_stats():
-    from app.indicators.nightlights import NightlightsIndicator
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        path = os.path.join(tmpdir, "viirs.tif")
-        _mock_radiance_tif(path, mean_nw=5.0)
-        stats = NightlightsIndicator._compute_stats(path)
-
-    assert "mean_radiance" in stats
-    assert stats["mean_radiance"] > 0
-    assert "valid_pixel_fraction" in stats

tests/test_indicator_no2.py

@@ -1,55 +0,0 @@
-def test_build_chart_data_includes_baseline_range():
-    from app.indicators.no2 import NO2Indicator
-    from datetime import date
-    from app.models import TimeRange
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = NO2Indicator._build_chart_data(
-        current=16.5, baseline_mean=15.0, baseline_std=4.0, time_range=tr,
-        baseline_yearly_means=[12.0, 15.0, 18.0],
-    )
-    assert "baseline_range_mean" in result
-    assert result["baseline_range_min"] == 12.0
-    assert result["baseline_range_max"] == 18.0
-
-
-def test_build_chart_data_no_range_when_single_year():
-    from app.indicators.no2 import NO2Indicator
-    from datetime import date
-    from app.models import TimeRange
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = NO2Indicator._build_chart_data(
-        current=16.5, baseline_mean=15.0, baseline_std=4.0, time_range=tr,
-        baseline_yearly_means=[15.0],
-    )
-    assert "baseline_range_mean" not in result
-
-
-def test_build_chart_data_no_range_when_none():
-    from app.indicators.no2 import NO2Indicator
-    from datetime import date
-    from app.models import TimeRange
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = NO2Indicator._build_chart_data(
-        current=16.5, baseline_mean=15.0, baseline_std=4.0, time_range=tr,
-    )
-    assert "baseline_range_mean" not in result
-    assert result["baseline_std"] == 4.0
-
-
-def test_build_monthly_chart_data():
-    from app.indicators.no2 import NO2Indicator
-    from datetime import date
-    from app.models import TimeRange
-
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    current_monthly = {1: 12.0, 2: 13.0, 3: 14.0}
-    baseline_per_year_monthly = {1: [11.0, 12.0, 13.0], 2: [12.0, 13.0, 14.0], 3: [13.0, 14.0, 15.0]}
-    result = NO2Indicator._build_monthly_chart_data(
-        current_monthly=current_monthly,
-        baseline_per_year_monthly=baseline_per_year_monthly,
-        time_range=tr,
-        season_months=[1, 2, 3],
-    )
-    assert len(result["dates"]) == 3
-    assert "baseline_mean" in result
-    assert result["label"] == "NO2 concentration (µg/m³)"

tests/test_indicator_rainfall.py

@@ -1,97 +0,0 @@
-"""Tests for app.indicators.rainfall — CHIRPS precipitation via direct download."""
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch, AsyncMock
-from datetime import date
-
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-import pytest
-
-from app.models import AOI, TimeRange, StatusLevel, ConfidenceLevel
-
-BBOX = [32.45, 15.65, 32.65, 15.8]
-
-
-@pytest.fixture
-def test_aoi():
-    return AOI(name="Test", bbox=BBOX)
-
-
-@pytest.fixture
-def test_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-def _mock_precip_tif(path: str, n_months: int = 12, mean_mm: float = 50.0):
-    """Create synthetic monthly precipitation GeoTIFF in mm."""
-    rng = np.random.default_rng(46)
-    data = np.zeros((n_months, 10, 10), dtype=np.float32)
-    for m in range(n_months):
-        seasonal = mean_mm * (0.5 + 0.8 * np.sin(np.pi * (m - 2) / 6))
-        data[m] = np.maximum(0, seasonal + rng.normal(0, 10, (10, 10)))
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=n_months,
-        dtype="float32", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
-    ) as dst:
-        for i in range(n_months):
-            dst.write(data[i], i + 1)
-
-
-@pytest.mark.asyncio
-async def test_rainfall_process_returns_result(test_aoi, test_time_range):
-    from app.indicators.rainfall import RainfallIndicator
-
-    indicator = RainfallIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        current_path = os.path.join(tmpdir, "precip_current.tif")
-        baseline_path = os.path.join(tmpdir, "precip_baseline.tif")
-        _mock_precip_tif(current_path, mean_mm=45.0)
-        _mock_precip_tif(baseline_path, mean_mm=50.0)
-
-        with patch.object(indicator, '_download_chirps', new_callable=AsyncMock) as mock_dl:
-            async def fake_dl(bbox, start, end, output_path):
-                import shutil
-                if "current" in output_path:
-                    shutil.copy(current_path, output_path)
-                else:
-                    shutil.copy(baseline_path, output_path)
-
-            mock_dl.side_effect = fake_dl
-            result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "rainfall"
-    assert result.data_source == "satellite"
-    assert "CHIRPS" in result.methodology
-    assert len(result.chart_data.get("dates", [])) > 0
-
-
-@pytest.mark.asyncio
-async def test_rainfall_falls_back_on_failure(test_aoi, test_time_range):
-    from app.indicators.rainfall import RainfallIndicator
-    indicator = RainfallIndicator()
-
-    with patch.object(indicator, '_download_chirps', new_callable=AsyncMock, side_effect=Exception("Download failed")):
-        result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "rainfall"
-    assert result.data_source == "placeholder"
-
-
-def test_rainfall_compute_stats():
-    from app.indicators.rainfall import RainfallIndicator
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        path = os.path.join(tmpdir, "precip.tif")
-        _mock_precip_tif(path, mean_mm=50.0)
-        stats = RainfallIndicator._compute_stats(path)
-
-    assert "monthly_means_mm" in stats
-    assert len(stats["monthly_means_mm"]) == 12
-    assert "total_mm" in stats
-    assert stats["total_mm"] > 0

tests/test_indicator_sar.py

@@ -1,235 +0,0 @@
-"""Tests for app.indicators.sar — SAR backscatter via openEO."""
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch
-from datetime import date
-
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-import pytest
-
-from app.models import AOI, TimeRange, StatusLevel, TrendDirection, ConfidenceLevel
-from tests.conftest import mock_rgb_tif, make_mock_batch_job
-
-BBOX = [32.45, 15.65, 32.65, 15.8]
-
-
-@pytest.fixture
-def test_aoi():
-    return AOI(name="Test", bbox=BBOX)
-
-
-@pytest.fixture
-def test_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-def _mock_sar_tif(path: str, n_months: int = 12):
-    """Create synthetic SAR backscatter GeoTIFF in dB scale.
-
-    Interleaved bands: VV_m1, VH_m1, VV_m2, VH_m2, ...
-    Total bands = n_months * 2.
-    """
-    rng = np.random.default_rng(50)
-    n_bands = n_months * 2
-    data = np.zeros((n_bands, 10, 10), dtype=np.float32)
-    for m in range(n_months):
-        # VV: typical range -15 to -5 dB
-        data[m * 2] = rng.uniform(-12, -6, (10, 10))
-        # VH: typically 5-8 dB lower than VV
-        data[m * 2 + 1] = data[m * 2] - rng.uniform(5, 8, (10, 10))
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=n_bands,
-        dtype="float32", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
-    ) as dst:
-        for i in range(n_bands):
-            dst.write(data[i], i + 1)
-
-
-@pytest.mark.asyncio
-async def test_sar_process_returns_result(test_aoi, test_time_range):
-    """SarIndicator.process() returns a valid IndicatorResult."""
-    from app.indicators.sar import SarIndicator
-
-    indicator = SarIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sar_path = os.path.join(tmpdir, "sar.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_sar_tif(sar_path)
-        mock_rgb_tif(rgb_path)
-
-        mock_cube = MagicMock()
-
-        def fake_download(path, **kwargs):
-            import shutil
-            if "sar" in path:
-                shutil.copy(sar_path, path)
-            else:
-                shutil.copy(rgb_path, path)
-
-        mock_cube.download = MagicMock(side_effect=fake_download)
-
-        with patch("app.indicators.sar.get_connection"), \
-             patch("app.indicators.sar.build_sar_graph", return_value=mock_cube), \
-             patch("app.indicators.sar.build_true_color_graph", return_value=mock_cube):
-            result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "sar"
-    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
-    assert result.trend in (TrendDirection.IMPROVING, TrendDirection.STABLE, TrendDirection.DETERIORATING)
-    assert result.data_source == "satellite"
-    assert "SAR" in result.methodology or "backscatter" in result.methodology.lower()
-    assert len(result.chart_data.get("dates", [])) > 0
-
-
-@pytest.mark.asyncio
-async def test_sar_falls_back_on_failure(test_aoi, test_time_range):
-    """SarIndicator falls back gracefully when openEO fails."""
-    from app.indicators.sar import SarIndicator
-
-    indicator = SarIndicator()
-
-    with patch("app.indicators.sar.get_connection", side_effect=Exception("CDSE down")):
-        result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "sar"
-    assert result.confidence == ConfidenceLevel.LOW
-    assert "Insufficient" in result.headline or "placeholder" in result.data_source
-
-
-def test_sar_compute_stats():
-    """_compute_stats() extracts VV monthly means from interleaved SAR raster."""
-    from app.indicators.sar import SarIndicator
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        path = os.path.join(tmpdir, "sar.tif")
-        _mock_sar_tif(path, n_months=12)
-        stats = SarIndicator._compute_stats(path)
-
-    assert "monthly_vv_means" in stats
-    assert len(stats["monthly_vv_means"]) == 12
-    assert "overall_vv_mean" in stats
-    # VV should be negative dB values
-    assert stats["overall_vv_mean"] < 0
-    assert "valid_months" in stats
-    assert stats["valid_months"] == 12
-
-
-def test_sar_classify_change():
-    """_classify() maps change area percentage to correct status."""
-    from app.indicators.sar import SarIndicator
-
-    assert SarIndicator._classify(change_pct=3.0, flood_months=0) == StatusLevel.GREEN
-    assert SarIndicator._classify(change_pct=10.0, flood_months=0) == StatusLevel.AMBER
-    assert SarIndicator._classify(change_pct=10.0, flood_months=2) == StatusLevel.AMBER
-    assert SarIndicator._classify(change_pct=20.0, flood_months=0) == StatusLevel.RED
-    assert SarIndicator._classify(change_pct=3.0, flood_months=3) == StatusLevel.RED
-
-
-@pytest.mark.asyncio
-async def test_sar_submit_batch_creates_three_jobs(test_aoi, test_time_range):
-    """submit_batch() creates current, baseline, and true-color batch jobs."""
-    from app.indicators.sar import SarIndicator
-
-    indicator = SarIndicator()
-
-    mock_conn = MagicMock()
-    mock_job = MagicMock()
-    mock_job.job_id = "j-test"
-    mock_conn.create_job.return_value = mock_job
-
-    with patch("app.indicators.sar.get_connection", return_value=mock_conn), \
-         patch("app.indicators.sar.build_sar_graph") as mock_sar_graph, \
-         patch("app.indicators.sar.build_true_color_graph") as mock_tc_graph:
-
-        mock_sar_graph.return_value = MagicMock()
-        mock_tc_graph.return_value = MagicMock()
-
-        jobs = await indicator.submit_batch(test_aoi, test_time_range)
-
-    assert len(jobs) == 3
-    assert mock_sar_graph.call_count == 2  # current + baseline
-    assert mock_tc_graph.call_count == 1   # true-color
-
-
-@pytest.mark.asyncio
-async def test_sar_harvest_computes_result_from_batch_jobs(test_aoi, test_time_range):
-    """harvest() downloads batch results and returns IndicatorResult."""
-    from app.indicators.sar import SarIndicator
-
-    indicator = SarIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sar_path = os.path.join(tmpdir, "sar.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_sar_tif(sar_path)
-        mock_rgb_tif(rgb_path)
-
-        current_job = make_mock_batch_job(sar_path)
-        baseline_job = make_mock_batch_job(sar_path)
-        true_color_job = make_mock_batch_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 == "sar"
-    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
-    assert "baseline_mean" in result.chart_data
-    assert len(result.chart_data["baseline_mean"]) > 0
-
-
-@pytest.mark.asyncio
-async def test_sar_harvest_falls_back_when_current_fails(test_aoi, test_time_range):
-    """harvest() returns placeholder when current SAR job failed."""
-    from app.indicators.sar import SarIndicator
-
-    indicator = SarIndicator()
-
-    current_job = MagicMock()
-    current_job.download_results.side_effect = Exception("failed")
-    baseline_job = MagicMock()
-    true_color_job = MagicMock()
-
-    result = await indicator.harvest(
-        test_aoi, test_time_range,
-        batch_jobs=[current_job, baseline_job, true_color_job],
-    )
-
-    assert result.data_source == "placeholder"
-
-
-@pytest.mark.asyncio
-async def test_sar_harvest_degrades_when_baseline_fails(test_aoi, test_time_range):
-    """harvest() returns degraded result when baseline SAR job failed."""
-    from app.indicators.sar import SarIndicator
-
-    indicator = SarIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        sar_path = os.path.join(tmpdir, "sar.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_sar_tif(sar_path)
-        mock_rgb_tif(rgb_path)
-
-        current_job = make_mock_batch_job(sar_path)
-        baseline_job = make_mock_batch_job(sar_path, fail=True)
-        true_color_job = make_mock_batch_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 == "sar"
-    assert result.data_source == "satellite"
-    assert result.confidence == ConfidenceLevel.LOW

tests/test_indicator_vegetation.py

@@ -1,90 +0,0 @@
-"""Tests for the D2 Vegetation & Forest Cover indicator."""
-from __future__ import annotations
-
-from datetime import date
-
-import pytest
-
-from app.indicators.vegetation import VegetationIndicator
-from app.models import TimeRange
-
-
-# ---------------------------------------------------------------------------
-# Baseline range in chart data
-# ---------------------------------------------------------------------------
-
-def test_build_chart_data_includes_baseline_range():
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = VegetationIndicator._build_chart_data(
-        baseline=35.0, current=38.0, time_range=tr,
-        baseline_yearly_means=[32.0, 35.0, 38.0, 34.0, 36.0],
-    )
-    assert "baseline_range_mean" in result
-    assert "baseline_range_min" in result
-    assert "baseline_range_max" in result
-    assert result["baseline_range_min"] == 32.0
-    assert result["baseline_range_max"] == 38.0
-    assert result["baseline_range_min"] <= result["baseline_range_mean"] <= result["baseline_range_max"]
-
-
-def test_build_chart_data_no_baseline_range_when_absent():
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = VegetationIndicator._build_chart_data(
-        baseline=35.0, current=38.0, time_range=tr,
-    )
-    assert "baseline_range_mean" not in result
-    assert "baseline_range_min" not in result
-    assert "baseline_range_max" not in result
-
-
-def test_build_chart_data_no_baseline_range_when_single_year():
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = VegetationIndicator._build_chart_data(
-        baseline=35.0, current=38.0, time_range=tr,
-        baseline_yearly_means=[35.0],
-    )
-    assert "baseline_range_mean" not in result
-
-
-def test_build_chart_data_baseline_range_mean_is_rounded():
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = VegetationIndicator._build_chart_data(
-        baseline=35.0, current=38.0, time_range=tr,
-        baseline_yearly_means=[33.33, 36.67],
-    )
-    assert isinstance(result["baseline_range_mean"], float)
-    # Should be rounded to 1 decimal place
-    assert result["baseline_range_mean"] == round(result["baseline_range_mean"], 1)
-
-
-def test_build_chart_data_base_fields_always_present():
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    result = VegetationIndicator._build_chart_data(
-        baseline=35.0, current=38.0, time_range=tr,
-    )
-    assert "dates" in result
-    assert "values" in result
-    assert "label" in result
-    assert result["values"] == [35.0, 38.0]
-
-
-def test_build_monthly_chart_data():
-    from app.indicators.vegetation import VegetationIndicator
-    from datetime import date
-    from app.models import TimeRange
-
-    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
-    current_monthly = {4: 38.0, 5: 40.0, 6: 42.0}
-    baseline_stats = {4: [33.0, 35.0, 37.0], 5: [38.0, 40.0, 42.0], 6: [40.0, 42.0, 44.0]}
-    result = VegetationIndicator._build_monthly_chart_data(
-        current_monthly=current_monthly,
-        baseline_per_year_monthly=baseline_stats,
-        time_range=tr,
-        season_months=[4, 5, 6],
-    )
-    assert len(result["dates"]) == 3
-    assert result["dates"][0] == "2025-04"
-    assert "baseline_mean" in result
-    assert len(result["baseline_mean"]) == 3
-    for i in range(3):
-        assert result["baseline_min"][i] <= result["baseline_mean"][i] <= result["baseline_max"][i]

tests/test_indicator_water.py

@@ -1,215 +0,0 @@
-"""Tests for app.indicators.water — pixel-level MNDWI via openEO."""
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch
-from datetime import date
-
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-import pytest
-
-from app.models import AOI, TimeRange, StatusLevel, TrendDirection, ConfidenceLevel
-from tests.conftest import mock_rgb_tif, make_mock_batch_job
-
-BBOX = [32.45, 15.65, 32.65, 15.8]
-
-
-@pytest.fixture
-def test_aoi():
-    return AOI(name="Test", bbox=BBOX)
-
-
-@pytest.fixture
-def test_time_range():
-    return TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-
-def _mock_mndwi_tif(path: str, n_months: int = 12, water_fraction: float = 0.15):
-    """Create synthetic MNDWI GeoTIFF. Values > 0 are water."""
-    rng = np.random.default_rng(44)
-    data = np.zeros((n_months, 10, 10), dtype=np.float32)
-    for m in range(n_months):
-        vals = rng.normal(-0.2, 0.3, (10, 10))
-        water_mask = rng.random((10, 10)) < water_fraction
-        vals[water_mask] = rng.uniform(0.1, 0.6, water_mask.sum())
-        data[m] = vals
-    with rasterio.open(
-        path, "w", driver="GTiff", height=10, width=10, count=n_months,
-        dtype="float32", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, 10, 10), nodata=-9999.0,
-    ) as dst:
-        for i in range(n_months):
-            dst.write(data[i], i + 1)
-
-
-@pytest.mark.asyncio
-async def test_water_process_returns_result(test_aoi, test_time_range):
-    """WaterIndicator.process() returns a valid IndicatorResult."""
-    from app.indicators.water import WaterIndicator
-
-    indicator = WaterIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        mndwi_path = os.path.join(tmpdir, "mndwi.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_mndwi_tif(mndwi_path)
-        mock_rgb_tif(rgb_path)
-
-        mock_cube = MagicMock()
-
-        def fake_download(path, **kwargs):
-            import shutil
-            if "mndwi" in path or "water" in path:
-                shutil.copy(mndwi_path, path)
-            else:
-                shutil.copy(rgb_path, path)
-
-        mock_cube.download = MagicMock(side_effect=fake_download)
-
-        with patch("app.indicators.water.get_connection"), \
-             patch("app.indicators.water.build_mndwi_graph", return_value=mock_cube), \
-             patch("app.indicators.water.build_true_color_graph", return_value=mock_cube):
-            result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "water"
-    assert result.status in (StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED)
-    assert "MNDWI" in result.methodology or "water" in result.methodology.lower()
-    assert result.data_source == "satellite"
-    assert len(result.chart_data.get("dates", [])) > 0
-
-
-@pytest.mark.asyncio
-async def test_water_falls_back_on_failure(test_aoi, test_time_range):
-    """WaterIndicator falls back gracefully when openEO fails."""
-    from app.indicators.water import WaterIndicator
-
-    indicator = WaterIndicator()
-
-    with patch("app.indicators.water.get_connection", side_effect=Exception("CDSE down")):
-        result = await indicator.process(test_aoi, test_time_range)
-
-    assert result.indicator_id == "water"
-    assert result.data_source == "placeholder"
-
-
-def test_water_compute_stats():
-    """_compute_stats() extracts water fraction from MNDWI raster."""
-    from app.indicators.water import WaterIndicator
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        path = os.path.join(tmpdir, "mndwi.tif")
-        _mock_mndwi_tif(path, n_months=12, water_fraction=0.2)
-        stats = WaterIndicator._compute_stats(path)
-
-    assert "monthly_water_fractions" in stats
-    assert len(stats["monthly_water_fractions"]) == 12
-    assert "overall_water_fraction" in stats
-    assert 0 < stats["overall_water_fraction"] < 1
-    assert "valid_months" in stats
-
-
-@pytest.mark.asyncio
-async def test_water_submit_batch_creates_three_jobs(test_aoi, test_time_range):
-    """submit_batch() creates current, baseline, and true-color batch jobs."""
-    from app.indicators.water import WaterIndicator
-
-    indicator = WaterIndicator()
-
-    mock_conn = MagicMock()
-    mock_job = MagicMock()
-    mock_job.job_id = "j-test"
-    mock_conn.create_job.return_value = mock_job
-
-    with patch("app.indicators.water.get_connection", return_value=mock_conn), \
-         patch("app.indicators.water.build_mndwi_graph") as mock_water_graph, \
-         patch("app.indicators.water.build_true_color_graph") as mock_tc_graph:
-
-        mock_water_graph.return_value = MagicMock()
-        mock_tc_graph.return_value = MagicMock()
-
-        jobs = await indicator.submit_batch(test_aoi, test_time_range)
-
-    assert len(jobs) == 3
-    assert mock_water_graph.call_count == 2
-    assert mock_tc_graph.call_count == 1
-
-
-@pytest.mark.asyncio
-async def test_water_harvest_computes_result_from_batch_jobs(test_aoi, test_time_range):
-    """harvest() downloads batch results and returns IndicatorResult."""
-    from app.indicators.water import WaterIndicator
-
-    indicator = WaterIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        mndwi_path = os.path.join(tmpdir, "mndwi.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_mndwi_tif(mndwi_path)
-        mock_rgb_tif(rgb_path)
-
-        current_job = make_mock_batch_job(mndwi_path)
-        baseline_job = make_mock_batch_job(mndwi_path)
-        true_color_job = make_mock_batch_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 == "water"
-    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
-    assert "baseline_mean" in result.chart_data
-    assert len(result.chart_data["baseline_mean"]) > 0
-
-
-@pytest.mark.asyncio
-async def test_water_harvest_falls_back_when_current_fails(test_aoi, test_time_range):
-    """harvest() returns placeholder when current MNDWI job failed."""
-    from app.indicators.water import WaterIndicator
-
-    indicator = WaterIndicator()
-
-    current_job = MagicMock()
-    current_job.download_results.side_effect = Exception("failed")
-    baseline_job = MagicMock()
-    true_color_job = MagicMock()
-
-    result = await indicator.harvest(
-        test_aoi, test_time_range,
-        batch_jobs=[current_job, baseline_job, true_color_job],
-    )
-
-    assert result.data_source == "placeholder"
-
-
-@pytest.mark.asyncio
-async def test_water_harvest_degrades_when_baseline_fails(test_aoi, test_time_range):
-    """harvest() returns degraded result when baseline MNDWI job failed."""
-    from app.indicators.water import WaterIndicator
-
-    indicator = WaterIndicator()
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        mndwi_path = os.path.join(tmpdir, "mndwi.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _mock_mndwi_tif(mndwi_path)
-        mock_rgb_tif(rgb_path)
-
-        current_job = make_mock_batch_job(mndwi_path)
-        baseline_job = make_mock_batch_job(mndwi_path, fail=True)
-        true_color_job = make_mock_batch_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 == "water"
-    assert result.data_source == "satellite"
-    assert result.confidence == ConfidenceLevel.LOW

tests/test_maps.py

@@ -1,74 +0,0 @@
-import pytest
-import tempfile
-import os
-import numpy as np
-from app.outputs.maps import render_indicator_map, render_status_map
-from app.indicators.base import SpatialData
-from app.models import AOI, StatusLevel
-
-
-@pytest.fixture
-def aoi():
-    return AOI(name="Test Area", bbox=[36.75, -1.35, 36.95, -1.20])
-
-
-def test_render_grid_map(aoi):
-    spatial = SpatialData(
-        data=np.random.rand(5, 5) * 30 + 10,
-        lons=np.linspace(36.75, 36.95, 5),
-        lats=np.linspace(-1.35, -1.20, 5),
-        label="Temperature (°C)",
-        colormap="coolwarm",
-        map_type="grid",
-    )
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out = os.path.join(tmpdir, "grid.png")
-        render_indicator_map(spatial=spatial, aoi=aoi, status=StatusLevel.GREEN, output_path=out)
-        assert os.path.exists(out)
-        assert os.path.getsize(out) > 1000
-
-
-def test_render_points_map(aoi):
-    spatial = SpatialData(
-        geojson={
-            "type": "FeatureCollection",
-            "features": [
-                {"type": "Feature", "geometry": {"type": "Point", "coordinates": [36.82, -1.28]}, "properties": {"confidence": "high"}},
-                {"type": "Feature", "geometry": {"type": "Point", "coordinates": [36.88, -1.30]}, "properties": {"confidence": "nominal"}},
-            ],
-        },
-        map_type="points",
-        label="Fire detections",
-    )
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out = os.path.join(tmpdir, "points.png")
-        render_indicator_map(spatial=spatial, aoi=aoi, status=StatusLevel.RED, output_path=out)
-        assert os.path.exists(out)
-        assert os.path.getsize(out) > 1000
-
-
-def test_render_choropleth_map(aoi):
-    spatial = SpatialData(
-        geojson={
-            "type": "FeatureCollection",
-            "features": [
-                {"type": "Feature", "geometry": {"type": "Polygon", "coordinates": [[[36.7, -1.4], [36.9, -1.4], [36.9, -1.2], [36.7, -1.2], [36.7, -1.4]]]}, "properties": {"value": 65.0}},
-            ],
-        },
-        map_type="choropleth",
-        label="Vegetation %",
-        colormap="YlGn",
-    )
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out = os.path.join(tmpdir, "choropleth.png")
-        render_indicator_map(spatial=spatial, aoi=aoi, status=StatusLevel.AMBER, output_path=out)
-        assert os.path.exists(out)
-        assert os.path.getsize(out) > 1000
-
-
-def test_render_status_map(aoi):
-    with tempfile.TemporaryDirectory() as tmpdir:
-        out = os.path.join(tmpdir, "status.png")
-        render_status_map(aoi=aoi, status=StatusLevel.RED, output_path=out)
-        assert os.path.exists(out)
-        assert os.path.getsize(out) > 1000

tests/test_models.py

@@ -1,151 +0,0 @@
-import pytest
-from datetime import datetime, date
-from shapely.geometry import box
-
-from app.models import (
-    AOI,
-    TimeRange,
-    JobRequest,
-    JobStatus,
-    Job,
-    IndicatorMeta,
-    IndicatorResult,
-    StatusLevel,
-    TrendDirection,
-    ConfidenceLevel,
-)
-
-
-def test_aoi_from_bbox():
-    aoi = AOI(name="Test Area", bbox=[32.45, 15.65, 32.65, 15.80])
-    assert aoi.name == "Test Area"
-    assert aoi.area_km2 > 0
-    assert aoi.area_km2 < 10_000
-
-
-def test_aoi_rejects_too_large():
-    with pytest.raises(ValueError, match="10,000"):
-        AOI(name="Huge", bbox=[0.0, 0.0, 20.0, 20.0])
-
-
-def test_aoi_rejects_outside_east_africa():
-    with pytest.raises(ValueError, match="East Africa"):
-        AOI(name="Europe", bbox=[10.0, 50.0, 11.0, 51.0])
-
-
-def test_time_range_defaults_to_last_12_months():
-    tr = TimeRange()
-    assert (tr.end - tr.start).days >= 360
-    assert (tr.end - tr.start).days <= 370
-
-
-def test_time_range_rejects_over_3_years():
-    with pytest.raises(ValueError, match="3 years"):
-        TimeRange(start=date(2020, 1, 1), end=date(2026, 1, 1))
-
-
-def test_job_request_valid():
-    req = JobRequest(
-        aoi=AOI(name="Khartoum", bbox=[32.45, 15.65, 32.65, 15.80]),
-        time_range=TimeRange(),
-        indicator_ids=["fires", "cropland"],
-        email="test@example.com",
-    )
-    assert len(req.indicator_ids) == 2
-
-
-def test_job_request_rejects_empty_indicators():
-    with pytest.raises(ValueError, match="indicator"):
-        JobRequest(
-            aoi=AOI(name="Khartoum", bbox=[32.45, 15.65, 32.65, 15.80]),
-            time_range=TimeRange(),
-            indicator_ids=[],
-            email="test@example.com",
-        )
-
-
-def test_job_status_transitions():
-    assert JobStatus.QUEUED == "queued"
-    assert JobStatus.PROCESSING == "processing"
-    assert JobStatus.COMPLETE == "complete"
-    assert JobStatus.FAILED == "failed"
-
-
-def test_indicator_result_fields():
-    result = IndicatorResult(
-        indicator_id="fires",
-        headline="5 fire events detected in the past 12 months",
-        status=StatusLevel.AMBER,
-        trend=TrendDirection.DETERIORATING,
-        confidence=ConfidenceLevel.HIGH,
-        map_layer_path="/results/123/fires_map.tif",
-        chart_data={"dates": ["2025-01", "2025-02"], "values": [2, 3]},
-        summary="Five fire events were detected in the analysis area.",
-        methodology="Fire detections sourced from NASA FIRMS active fire API.",
-        limitations=["VIIRS has a 375m resolution — small fires may be missed."],
-    )
-    assert result.status == "amber"
-    assert result.trend == "deteriorating"
-
-
-def test_job_request_season_defaults():
-    """Default season is full year (1-12)."""
-    req = JobRequest(
-        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
-        indicator_ids=["fires"],
-        email="t@t.com",
-    )
-    assert req.season_start == 1
-    assert req.season_end == 12
-
-
-def test_job_request_season_months_normal():
-    """Non-wrapping season: Apr-Sep."""
-    req = JobRequest(
-        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
-        indicator_ids=["fires"],
-        email="t@t.com",
-        season_start=4,
-        season_end=9,
-    )
-    assert req.season_months() == [4, 5, 6, 7, 8, 9]
-
-
-def test_job_request_season_months_wrapping():
-    """Wrapping season: Oct-Mar (Southern Hemisphere)."""
-    req = JobRequest(
-        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
-        indicator_ids=["fires"],
-        email="t@t.com",
-        season_start=10,
-        season_end=3,
-    )
-    assert req.season_months() == [10, 11, 12, 1, 2, 3]
-
-
-def test_job_request_season_months_full_year():
-    """Full year default."""
-    req = JobRequest(
-        aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
-        indicator_ids=["fires"],
-        email="t@t.com",
-    )
-    assert req.season_months() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
-
-
-def test_job_request_season_validation():
-    """Season months must be 1-12."""
-    with pytest.raises(Exception):
-        JobRequest(
-            aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
-            indicator_ids=["fires"],
-            email="t@t.com",
-            season_start=0,
-        )
-    with pytest.raises(Exception):
-        JobRequest(
-            aoi=AOI(name="Test", bbox=[36.75, -1.35, 36.95, -1.20]),
-            indicator_ids=["fires"],
-            email="t@t.com",
-            season_end=13,
-        )

tests/test_narrative.py

@@ -1,83 +0,0 @@
-"""Tests for app.outputs.narrative — cross-indicator narrative generation."""
-from app.models import IndicatorResult, StatusLevel, TrendDirection, ConfidenceLevel
-
-
-def _make_result(
-    indicator_id: str,
-    status: StatusLevel = StatusLevel.GREEN,
-    trend: TrendDirection = TrendDirection.STABLE,
-    data_source: str = "satellite",
-    headline: str = "Test headline",
-    summary: str = "Test summary.",
-) -> IndicatorResult:
-    return IndicatorResult(
-        indicator_id=indicator_id,
-        headline=headline,
-        status=status,
-        trend=trend,
-        confidence=ConfidenceLevel.HIGH,
-        map_layer_path="",
-        chart_data={"dates": ["2025-06"], "values": [0.5]},
-        summary=summary,
-        methodology="Test methodology.",
-        limitations=["Test limitation."],
-        data_source=data_source,
-    )
-
-
-def test_generate_narrative_all_green():
-    from app.outputs.narrative import generate_narrative
-    results = [
-        _make_result("ndvi"),
-        _make_result("water"),
-    ]
-    narrative = generate_narrative(results)
-    assert "within normal ranges" in narrative.lower() or "stable" in narrative.lower()
-    assert len(narrative) > 20
-
-
-def test_generate_narrative_drought_pattern():
-    from app.outputs.narrative import generate_narrative
-    results = [
-        _make_result("ndvi", status=StatusLevel.RED, trend=TrendDirection.DETERIORATING),
-        _make_result("rainfall", status=StatusLevel.RED, trend=TrendDirection.DETERIORATING),
-    ]
-    narrative = generate_narrative(results)
-    assert "drought" in narrative.lower() or "precipitation" in narrative.lower()
-
-
-def test_generate_narrative_landuse_pattern():
-    from app.outputs.narrative import generate_narrative
-    results = [
-        _make_result("ndvi", status=StatusLevel.AMBER, trend=TrendDirection.DETERIORATING),
-        _make_result("buildup", status=StatusLevel.AMBER, trend=TrendDirection.DETERIORATING),
-    ]
-    narrative = generate_narrative(results)
-    assert "settlement" in narrative.lower() or "land-use" in narrative.lower()
-
-
-def test_generate_narrative_placeholder_caveat():
-    from app.outputs.narrative import generate_narrative
-    results = [
-        _make_result("ndvi", data_source="placeholder"),
-        _make_result("water"),
-    ]
-    narrative = generate_narrative(results)
-    assert "placeholder" in narrative.lower() or "estimated" in narrative.lower() or "limited" in narrative.lower()
-
-
-def test_generate_narrative_single_indicator():
-    from app.outputs.narrative import generate_narrative
-    results = [_make_result("ndvi", status=StatusLevel.AMBER, trend=TrendDirection.DETERIORATING)]
-    narrative = generate_narrative(results)
-    assert isinstance(narrative, str)
-    assert len(narrative) > 20
-
-
-def test_get_interpretation_returns_nonempty():
-    from app.outputs.narrative import get_interpretation
-    for ind_id in ["ndvi", "water", "sar", "buildup", "fires", "rainfall"]:
-        for status in [StatusLevel.GREEN, StatusLevel.AMBER, StatusLevel.RED]:
-            result = get_interpretation(ind_id, status)
-            assert isinstance(result, str)
-            assert len(result) > 10, f"Empty interpretation for {ind_id}/{status}"

tests/test_ndvi_e2e.py

@@ -1,217 +0,0 @@
-"""End-to-end test: NDVI indicator → raster map → chart → report section.
-
-Uses mocked openEO (no CDSE credentials needed) with synthetic GeoTIFFs.
-"""
-from __future__ import annotations
-
-import os
-import tempfile
-from unittest.mock import MagicMock, patch
-from datetime import date
-
-import numpy as np
-import rasterio
-from rasterio.transform import from_bounds
-import pytest
-
-from app.models import AOI, TimeRange, StatusLevel
-from app.outputs.charts import render_timeseries_chart
-from app.outputs.maps import render_raster_map
-
-
-BBOX = [32.45, 15.65, 32.65, 15.8]
-WIDTH, HEIGHT = 15, 12
-
-
-def _write_ndvi_tif(path: str):
-    rng = np.random.default_rng(42)
-    data = np.zeros((12, HEIGHT, WIDTH), dtype=np.float32)
-    for m in range(12):
-        data[m] = 0.3 + 0.2 * np.sin(np.pi * (m - 3) / 6) + rng.normal(0, 0.03, (HEIGHT, WIDTH))
-    with rasterio.open(
-        path, "w", driver="GTiff", height=HEIGHT, width=WIDTH, count=12,
-        dtype="float32", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, WIDTH, HEIGHT), nodata=-9999.0,
-    ) as dst:
-        for i in range(12):
-            dst.write(data[i], i + 1)
-
-
-def _write_rgb_tif(path: str):
-    rng = np.random.default_rng(43)
-    data = rng.integers(500, 1500, (3, HEIGHT, WIDTH), dtype=np.uint16)
-    with rasterio.open(
-        path, "w", driver="GTiff", height=HEIGHT, width=WIDTH, count=3,
-        dtype="uint16", crs="EPSG:4326",
-        transform=from_bounds(*BBOX, WIDTH, HEIGHT), nodata=0,
-    ) as dst:
-        for i in range(3):
-            dst.write(data[i], i + 1)
-
-
-@pytest.mark.asyncio
-async def test_ndvi_full_pipeline():
-    """Full pipeline: process NDVI → render raster map → render chart."""
-    from app.indicators.ndvi import NdviIndicator
-
-    aoi = AOI(name="Khartoum Test", bbox=BBOX)
-    time_range = TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        ndvi_path = os.path.join(tmpdir, "ndvi.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _write_ndvi_tif(ndvi_path)
-        _write_rgb_tif(rgb_path)
-
-        mock_cube = MagicMock()
-
-        def fake_download(path, **kwargs):
-            import shutil
-            if "ndvi" in path:
-                shutil.copy(ndvi_path, path)
-            else:
-                shutil.copy(rgb_path, path)
-
-        mock_cube.download = MagicMock(side_effect=fake_download)
-
-        with patch("app.indicators.ndvi.get_connection") as mock_conn, \
-             patch("app.indicators.ndvi.build_ndvi_graph", return_value=mock_cube), \
-             patch("app.indicators.ndvi.build_true_color_graph", return_value=mock_cube):
-
-            indicator = NdviIndicator()
-            result = await indicator.process(aoi, time_range)
-
-        # Verify result quality
-        assert result.indicator_id == "ndvi"
-        assert result.data_source == "satellite"
-        assert "NDVI" in result.methodology
-        assert "pixel" in result.methodology.lower()
-        assert len(result.chart_data["dates"]) >= 6
-        assert all(isinstance(v, float) for v in result.chart_data["values"])
-
-        # Render the raster map
-        map_out = os.path.join(tmpdir, "ndvi_map.png")
-        raster_path = indicator._indicator_raster_path
-        tc_path = indicator._true_color_path
-        peak = indicator._ndvi_peak_band
-
-        render_raster_map(
-            true_color_path=tc_path,
-            indicator_path=raster_path,
-            indicator_band=peak,
-            aoi=aoi,
-            status=result.status,
-            output_path=map_out,
-            cmap="RdYlGn",
-            vmin=-0.2,
-            vmax=0.9,
-            label="NDVI",
-        )
-        assert os.path.exists(map_out)
-        assert os.path.getsize(map_out) > 10000  # Real map should be >10KB
-
-        # Render the chart
-        chart_out = os.path.join(tmpdir, "ndvi_chart.png")
-        render_timeseries_chart(
-            chart_data=result.chart_data,
-            indicator_name="Vegetation (NDVI)",
-            status=result.status,
-            trend=result.trend,
-            output_path=chart_out,
-            y_label="NDVI",
-        )
-        assert os.path.exists(chart_out)
-        assert os.path.getsize(chart_out) > 5000
-
-
-@pytest.mark.asyncio
-async def test_ndvi_batch_pipeline():
-    """Batch pipeline: submit → harvest → render map → render chart."""
-    from app.indicators.ndvi import NdviIndicator
-    import shutil
-
-    aoi = AOI(name="Khartoum Batch", bbox=BBOX)
-    time_range = TimeRange(start=date(2025, 3, 1), end=date(2026, 3, 1))
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        ndvi_path = os.path.join(tmpdir, "ndvi.tif")
-        rgb_path = os.path.join(tmpdir, "rgb.tif")
-        _write_ndvi_tif(ndvi_path)
-        _write_rgb_tif(rgb_path)
-
-        mock_conn = MagicMock()
-
-        def make_mock_job(src_path):
-            job = MagicMock()
-            job.job_id = "j-e2e"
-            job.status.return_value = "finished"
-            def fake_download_results(target):
-                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
-            return job
-
-        mock_ndvi_job = make_mock_job(ndvi_path)
-        mock_tc_job = make_mock_job(rgb_path)
-        mock_conn.create_job.return_value = mock_ndvi_job
-
-        with patch("app.indicators.ndvi.get_connection", return_value=mock_conn), \
-             patch("app.indicators.ndvi.build_ndvi_graph", return_value=MagicMock()), \
-             patch("app.indicators.ndvi.build_true_color_graph", return_value=MagicMock()), \
-             patch("app.indicators.ndvi.submit_as_batch") as mock_submit:
-
-            mock_submit.side_effect = [
-                make_mock_job(ndvi_path),   # current
-                make_mock_job(ndvi_path),   # baseline
-                make_mock_job(rgb_path),    # true-color
-            ]
-
-            indicator = NdviIndicator()
-
-            # Phase 1: submit
-            jobs = await indicator.submit_batch(aoi, time_range)
-            assert len(jobs) == 3
-
-            # Phase 3: harvest
-            result = await indicator.harvest(aoi, time_range, batch_jobs=jobs)
-
-        assert result.indicator_id == "ndvi"
-        assert result.data_source == "satellite"
-        assert len(result.chart_data["dates"]) >= 6
-
-        # Render the raster map
-        map_out = os.path.join(tmpdir, "ndvi_map.png")
-        raster_path = indicator._indicator_raster_path
-        tc_path = indicator._true_color_path
-        peak = indicator._ndvi_peak_band
-
-        render_raster_map(
-            true_color_path=tc_path,
-            indicator_path=raster_path,
-            indicator_band=peak,
-            aoi=aoi,
-            status=result.status,
-            output_path=map_out,
-            cmap="RdYlGn",
-            vmin=-0.2,
-            vmax=0.9,
-            label="NDVI",
-        )
-        assert os.path.exists(map_out)
-        assert os.path.getsize(map_out) > 10000
-
-        # Render the chart
-        chart_out = os.path.join(tmpdir, "ndvi_chart.png")
-        render_timeseries_chart(
-            chart_data=result.chart_data,
-            indicator_name="Vegetation (NDVI)",
-            status=result.status,
-            trend=result.trend,
-            output_path=chart_out,
-            y_label="NDVI",
-        )
-        assert os.path.exists(chart_out)
-        assert os.path.getsize(chart_out) > 5000

tests/test_openeo_client.py

@@ -1,190 +0,0 @@
-"""Tests for app.openeo_client — openEO connection and graph builders."""
-from __future__ import annotations
-
-from unittest.mock import MagicMock, patch
-import pytest
-
-
-def test_get_connection_creates_authenticated_connection():
-    """get_connection() connects to CDSE and authenticates."""
-    mock_conn = MagicMock()
-    with patch("openeo.connect", return_value=mock_conn) as mock_connect:
-        from app.openeo_client import get_connection, _reset_connection
-        _reset_connection()
-        conn = get_connection()
-
-        mock_connect.assert_called_once_with("openeo.dataspace.copernicus.eu")
-        mock_conn.authenticate_oidc.assert_called_once()
-        assert conn is mock_conn
-        _reset_connection()
-
-
-def test_get_connection_reuses_cached():
-    """Subsequent calls return the same connection object."""
-    mock_conn = MagicMock()
-    with patch("openeo.connect", return_value=mock_conn):
-        from app.openeo_client import get_connection, _reset_connection
-        _reset_connection()
-        conn1 = get_connection()
-        conn2 = get_connection()
-        assert conn1 is conn2
-        _reset_connection()
-
-
-def test_build_ndvi_graph():
-    """build_ndvi_graph() loads Sentinel-2 with correct bands."""
-    mock_conn = MagicMock()
-    mock_cube = MagicMock()
-    mock_conn.load_collection.return_value = mock_cube
-
-    from app.openeo_client import build_ndvi_graph
-
-    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
-    result = build_ndvi_graph(
-        conn=mock_conn,
-        bbox=bbox,
-        temporal_extent=["2025-03-01", "2026-03-01"],
-        resolution_m=100,
-    )
-
-    mock_conn.load_collection.assert_called_once()
-    call_kwargs = mock_conn.load_collection.call_args
-    assert call_kwargs[1]["collection_id"] == "SENTINEL2_L2A"
-    assert call_kwargs[1]["spatial_extent"] == bbox
-    assert "B04" in call_kwargs[1]["bands"]
-    assert "B08" in call_kwargs[1]["bands"]
-    assert "SCL" in call_kwargs[1]["bands"]
-
-
-def test_build_true_color_graph():
-    """build_true_color_graph() loads RGB bands."""
-    mock_conn = MagicMock()
-    mock_cube = MagicMock()
-    mock_conn.load_collection.return_value = mock_cube
-
-    from app.openeo_client import build_true_color_graph
-
-    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
-    result = build_true_color_graph(
-        conn=mock_conn,
-        bbox=bbox,
-        temporal_extent=["2025-03-01", "2026-03-01"],
-        resolution_m=100,
-    )
-
-    mock_conn.load_collection.assert_called_once()
-    call_kwargs = mock_conn.load_collection.call_args
-    bands = call_kwargs[1]["bands"]
-    assert "B04" in bands
-    assert "B03" in bands
-    assert "B02" in bands
-
-
-def test_build_mndwi_graph():
-    """build_mndwi_graph() loads Sentinel-2 with water index bands."""
-    mock_conn = MagicMock()
-    mock_cube = MagicMock()
-    mock_conn.load_collection.return_value = mock_cube
-
-    from app.openeo_client import build_mndwi_graph
-
-    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
-    result = build_mndwi_graph(
-        conn=mock_conn,
-        bbox=bbox,
-        temporal_extent=["2025-03-01", "2026-03-01"],
-        resolution_m=100,
-    )
-
-    mock_conn.load_collection.assert_called_once()
-    call_kwargs = mock_conn.load_collection.call_args
-    assert call_kwargs[1]["collection_id"] == "SENTINEL2_L2A"
-    assert "B03" in call_kwargs[1]["bands"]
-    assert "B11" in call_kwargs[1]["bands"]
-    assert "SCL" in call_kwargs[1]["bands"]
-
-
-def test_build_lst_graph():
-    """build_lst_graph() loads Sentinel-3 SLSTR LST data."""
-    mock_conn = MagicMock()
-    mock_cube = MagicMock()
-    mock_conn.load_collection.return_value = mock_cube
-
-    from app.openeo_client import build_lst_graph
-
-    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
-    result = build_lst_graph(
-        conn=mock_conn,
-        bbox=bbox,
-        temporal_extent=["2025-03-01", "2026-03-01"],
-        resolution_m=1000,
-    )
-
-    mock_conn.load_collection.assert_called_once()
-    call_kwargs = mock_conn.load_collection.call_args
-    assert "SENTINEL3" in call_kwargs[1]["collection_id"].upper() or "SLSTR" in call_kwargs[1]["collection_id"].upper()
-
-
-def test_build_sar_graph():
-    """build_sar_graph() loads Sentinel-1 GRD with VV and VH bands."""
-    mock_conn = MagicMock()
-    mock_cube = MagicMock()
-    mock_conn.load_collection.return_value = mock_cube
-
-    from app.openeo_client import build_sar_graph
-
-    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
-    result = build_sar_graph(
-        conn=mock_conn,
-        bbox=bbox,
-        temporal_extent=["2025-03-01", "2026-03-01"],
-        resolution_m=100,
-    )
-
-    mock_conn.load_collection.assert_called_once()
-    call_kwargs = mock_conn.load_collection.call_args
-    assert call_kwargs[1]["collection_id"] == "SENTINEL1_GRD"
-    assert "VV" in call_kwargs[1]["bands"]
-    assert "VH" in call_kwargs[1]["bands"]
-
-
-def test_build_buildup_graph():
-    """build_buildup_graph() loads Sentinel-2 with SWIR, NIR, Red, and SCL bands."""
-    mock_conn = MagicMock()
-    mock_cube = MagicMock()
-    mock_conn.load_collection.return_value = mock_cube
-
-    from app.openeo_client import build_buildup_graph
-
-    bbox = {"west": 32.45, "south": 15.65, "east": 32.65, "north": 15.8}
-    result = build_buildup_graph(
-        conn=mock_conn,
-        bbox=bbox,
-        temporal_extent=["2025-03-01", "2026-03-01"],
-        resolution_m=100,
-    )
-
-    mock_conn.load_collection.assert_called_once()
-    call_kwargs = mock_conn.load_collection.call_args
-    assert call_kwargs[1]["collection_id"] == "SENTINEL2_L2A"
-    assert "B04" in call_kwargs[1]["bands"]
-    assert "B08" in call_kwargs[1]["bands"]
-    assert "B11" in call_kwargs[1]["bands"]
-    assert "SCL" in call_kwargs[1]["bands"]
-
-
-def test_submit_as_batch_creates_and_starts_job():
-    """submit_as_batch() creates a batch job and starts it."""
-    from app.openeo_client import submit_as_batch
-
-    mock_conn = MagicMock()
-    mock_cube = MagicMock()
-    mock_job = MagicMock()
-    mock_job.job_id = "j-12345"
-    mock_conn.create_job.return_value = mock_job
-
-    result = submit_as_batch(mock_conn, mock_cube, "ndvi-current-Test")
-
-    mock_conn.create_job.assert_called_once_with(mock_cube, title="ndvi-current-Test")
-    mock_job.start.assert_called_once()
-    assert result is mock_job