feat: add four-factor confidence scoring model

app/analysis/confidence.py

@@ -0,0 +1,78 @@
+"""Four-factor confidence scoring for EO indicators."""
+from __future__ import annotations
+
+from typing import Any
+
+from app.models import ConfidenceLevel
+
+
+def score_temporal_coverage(valid_months: int) -> float:
+    if valid_months >= 10:
+        return 1.0
+    if valid_months >= 7:
+        return 0.75
+    if valid_months >= 4:
+        return 0.5
+    return 0.25
+
+
+def score_observation_density(mean_obs: float) -> float:
+    if mean_obs > 10:
+        return 1.0
+    if mean_obs >= 6:
+        return 0.75
+    if mean_obs >= 3:
+        return 0.5
+    return 0.25
+
+
+def score_baseline_depth(years_with_data: int) -> float:
+    if years_with_data >= 5:
+        return 1.0
+    if years_with_data >= 4:
+        return 0.75
+    if years_with_data >= 2:
+        return 0.5
+    return 0.25
+
+
+def score_spatial_completeness(fraction: float) -> float:
+    if fraction > 0.9:
+        return 1.0
+    if fraction > 0.75:
+        return 0.75
+    if fraction >= 0.5:
+        return 0.5
+    return 0.25
+
+
+def compute_confidence(
+    valid_months: int,
+    mean_obs_per_composite: float,
+    baseline_years_with_data: int,
+    spatial_completeness: float,
+) -> dict[str, Any]:
+    temporal = score_temporal_coverage(valid_months)
+    obs = score_observation_density(mean_obs_per_composite)
+    baseline = score_baseline_depth(baseline_years_with_data)
+    spatial = score_spatial_completeness(spatial_completeness)
+
+    score = temporal * 0.3 + obs * 0.2 + baseline * 0.3 + spatial * 0.2
+
+    if score > 0.7:
+        level = ConfidenceLevel.HIGH
+    elif score >= 0.4:
+        level = ConfidenceLevel.MODERATE
+    else:
+        level = ConfidenceLevel.LOW
+
+    return {
+        "level": level,
+        "score": round(score, 3),
+        "factors": {
+            "temporal": temporal,
+            "observation_density": obs,
+            "baseline_depth": baseline,
+            "spatial_completeness": spatial,
+        },
+    }

tests/test_confidence.py

@@ -0,0 +1,71 @@
+"""Tests for four-factor confidence scoring."""
+import pytest
+
+
+def test_score_temporal_coverage():
+    from app.analysis.confidence import score_temporal_coverage
+    assert score_temporal_coverage(0) == 0.25
+    assert score_temporal_coverage(3) == 0.25
+    assert score_temporal_coverage(5) == 0.5
+    assert score_temporal_coverage(8) == 0.75
+    assert score_temporal_coverage(12) == 1.0
+
+
+def test_score_observation_density():
+    from app.analysis.confidence import score_observation_density
+    assert score_observation_density(1.0) == 0.25
+    assert score_observation_density(4.0) == 0.5
+    assert score_observation_density(8.0) == 0.75
+    assert score_observation_density(15.0) == 1.0
+
+
+def test_score_baseline_depth():
+    from app.analysis.confidence import score_baseline_depth
+    assert score_baseline_depth(1) == 0.25
+    assert score_baseline_depth(3) == 0.5
+    assert score_baseline_depth(4) == 0.75
+    assert score_baseline_depth(5) == 1.0
+
+
+def test_score_spatial_completeness():
+    from app.analysis.confidence import score_spatial_completeness
+    assert score_spatial_completeness(0.3) == 0.25
+    assert score_spatial_completeness(0.6) == 0.5
+    assert score_spatial_completeness(0.85) == 0.75
+    assert score_spatial_completeness(0.95) == 1.0
+
+
+def test_compute_confidence_high():
+    from app.analysis.confidence import compute_confidence
+    from app.models import ConfidenceLevel
+    result = compute_confidence(
+        valid_months=12, mean_obs_per_composite=15.0,
+        baseline_years_with_data=5, spatial_completeness=0.95,
+    )
+    assert result["level"] == ConfidenceLevel.HIGH
+    assert result["score"] > 0.7
+
+
+def test_compute_confidence_low():
+    from app.analysis.confidence import compute_confidence
+    from app.models import ConfidenceLevel
+    result = compute_confidence(
+        valid_months=2, mean_obs_per_composite=1.5,
+        baseline_years_with_data=1, spatial_completeness=0.3,
+    )
+    assert result["level"] == ConfidenceLevel.LOW
+    assert result["score"] < 0.4
+
+
+def test_compute_confidence_returns_factors():
+    from app.analysis.confidence import compute_confidence
+    result = compute_confidence(
+        valid_months=6, mean_obs_per_composite=5.0,
+        baseline_years_with_data=3, spatial_completeness=0.8,
+    )
+    assert "factors" in result
+    factors = result["factors"]
+    assert "temporal" in factors
+    assert "observation_density" in factors
+    assert "baseline_depth" in factors
+    assert "spatial_completeness" in factors