use std::collections::BTreeMap;
use anyhow::Result;
use chrono::{DateTime, Utc};
use serde::Deserialize;
use super::super::calibration::{self, HumanScores};
use super::super::grader::{Criterion, Score};
use super::{Store, Windowed};
pub(crate) struct ScoredWeek {
pub start: DateTime<Utc>,
pub end: DateTime<Utc>,
pub pull_requests: Vec<ScoredPullRequest>,
}
pub(crate) struct ScoredPullRequest {
pub repository: String,
pub harness: String,
pub model: String,
pub scores: Vec<(Criterion, bool)>,
}
pub(crate) struct ScoreHistory {
pub weeks: Vec<ScoredWeek>,
pub calibrated: BTreeMap<Criterion, bool>,
}
pub(crate) fn read_scores() -> Result<ScoreHistory> {
Store::open()?.scores()
}
#[derive(Deserialize)]
struct Sampled {
window_start: Option<DateTime<Utc>>,
window_end: DateTime<Utc>,
#[serde(default)]
sample: Vec<SampledPullRequest>,
}
impl Windowed for Sampled {
fn window_end(&self) -> DateTime<Utc> {
self.window_end
}
}
#[derive(Deserialize)]
struct SampledPullRequest {
url: String,
repository: String,
harness: String,
model: String,
#[serde(default)]
for_you: bool,
#[serde(default)]
assessment: Option<Assessed>,
#[serde(default)]
mine: Option<HumanScores>,
}
#[derive(Deserialize)]
struct Assessed {
scores: Vec<Score>,
}
impl Store {
pub fn scores(&self) -> Result<ScoreHistory> {
let weeks: Vec<_> = self
.ordered::<Sampled>()?
.into_iter()
.map(|checkpoint| checkpoint.value)
.collect();
let calibration = calibration::measure_pairs(
weeks.iter().flat_map(|week| &week.sample).filter_map(|pr| {
Some((
pr.url.as_str(),
pr.mine.as_ref()?,
pr.assessment.as_ref()?.scores.as_slice(),
))
}),
);
Ok(ScoreHistory {
calibrated: calibration
.into_iter()
.map(|(criterion, state)| (criterion, state.calibrated))
.collect(),
weeks: weeks
.into_iter()
.filter_map(|week| {
Some(ScoredWeek {
start: week.window_start?,
end: week.window_end,
pull_requests: week
.sample
.into_iter()
.map(|pr| ScoredPullRequest {
scores: match (&pr.assessment, pr.for_you && pr.mine.is_none()) {
(Some(assessed), false) => assessed
.scores
.iter()
.map(|score| (score.criterion, score.passed))
.collect(),
_ => Vec::new(),
},
repository: pr.repository,
harness: pr.harness,
model: pr.model,
})
.collect(),
})
})
.collect(),
})
}
}