Function build_stats

patch_memory/src/lib.rs:212–261

(records: &[PatchRecord])

}

fn build_stats(records: &[PatchRecord]) -> PatchStats {
    if records.is_empty() {
        return PatchStats::default();
    }

    let mut success = 0usize;
    let mut rollback = 0usize;
    let mut model_totals: HashMap<String, (usize, usize)> = HashMap::new();
    let mut edit_totals: HashMap<String, (usize, usize)> = HashMap::new();

    for r in records {
        let ok = is_success(r);
        if ok {
            success += 1;
        }
        if r.rollback_occurred {
            rollback += 1;
        }

        let m = model_totals.entry(r.model_used.clone()).or_insert((0, 0));
        m.0 += 1;
        if ok {
            m.1 += 1;
        }

        let key = format!("{:?}", r.edit_type);
        let e = edit_totals.entry(key).or_insert((0, 0));
        e.0 += 1;
        if ok {
            e.1 += 1;
        }
    }

    let model_success_rate = model_totals
        .into_iter()
        .map(|(k, (t, s))| (k, s as f32 / t as f32))
        .collect();
    let edit_type_success_rate = edit_totals
        .into_iter()
        .map(|(k, (t, s))| (k, s as f32 / t as f32))
        .collect();

    PatchStats {
        total_patches: records.len(),
        success_rate: success as f32 / records.len() as f32,
        rollback_frequency: rollback as f32 / records.len() as f32,
        model_success_rate,
        edit_type_success_rate,
    }
}

fn build_model_performance(records: &[PatchRecord]) -> Vec<ModelPerformance> {
    let mut grouped: HashMap<String, (usize, usize)> = HashMap::new();