artifactize-core 0.13.0

The library behind artifactize: Artifacts, evals, reviews, the monitor and review models, and the shared operations every interface calls.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Scheduling policy for speculative work and deferred sign-offs.
use std::collections::{BTreeMap, BTreeSet};

use crate::{
    config::{EvalId, Gate, ProfileKind, RepoConfig},
    graph::{Evidence, Graph, Readiness},
    store::{Request, Run},
};

pub(super) fn deferred(config: &RepoConfig, run: &Run, requests: &[Request]) -> BTreeSet<EvalId> {
    if !run.modes.defer_human || run.reuse_only.contains(&ProfileKind::Human) {
        return BTreeSet::new();
    }
    requests
        .iter()
        .filter(|request| request.profile.kind() == ProfileKind::Human)
        .filter(|request| {
            config
                .evals
                .iter()
                .find(|eval| eval.id == request.eval_id)
                .is_some_and(|eval| eval.declaration.gate != Some(Gate::Blocking))
        })
        .map(|request| request.eval_id.clone())
        .collect()
}

/// Longest remaining dependency path is counted in eval obligations, not wall-clock
/// guesses. Artifact cycle peers do not gate one another; each Eval uses its own references.
pub(super) fn order(
    graph: &Graph<'_>,
    requests: &[Request],
    evidence: &BTreeMap<EvalId, Evidence>,
) -> Vec<usize> {
    let evaluation = graph.evaluate(evidence);
    let predecessors: BTreeMap<_, BTreeSet<_>> = requests
        .iter()
        .map(|request| {
            (
                request.eval_id.clone(),
                graph.gates(&request.eval_id).into_iter().cloned().collect(),
            )
        })
        .collect();
    let mut successors: BTreeMap<EvalId, BTreeSet<EvalId>> = predecessors
        .keys()
        .map(|id| (id.clone(), BTreeSet::new()))
        .collect();
    for (id, gates) in &predecessors {
        for gate in gates {
            successors
                .entry(gate.clone())
                .or_default()
                .insert(id.clone());
        }
    }
    let weight = |id: &EvalId| {
        let eval = &evaluation.evals[id.as_str()];
        usize::from(
            eval.status != crate::graph::EvalStatus::Blocked
                && !matches!(
                    evidence.get(id),
                    Some(Evidence::Current(_)) | Some(Evidence::OperationalError)
                ),
        )
    };
    let mut pending: BTreeMap<_, _> = successors
        .iter()
        .map(|(id, next)| (id.clone(), next.len()))
        .collect();
    let mut ready: Vec<_> = pending
        .iter()
        .filter_map(|(id, count)| (*count == 0).then_some(id.clone()))
        .collect();
    let mut lengths: BTreeMap<_, _> = pending.keys().map(|id| (id.clone(), weight(id))).collect();
    // Reverse topological reduction avoids recursion even for long Artifact chains.
    while let Some(id) = ready.pop() {
        let tail = lengths[&id];
        for gate in predecessors.get(&id).into_iter().flatten() {
            let length = lengths.get_mut(gate).expect("indexed gate");
            *length = (*length).max(weight(gate) + tail);
            let count = pending.get_mut(gate).expect("indexed gate");
            *count -= 1;
            if *count == 0 {
                ready.push(gate.clone());
            }
        }
    }
    let mut order: Vec<_> = (0..requests.len()).collect();
    order.sort_by_key(|&index| {
        let id = &requests[index].eval_id;
        (
            evaluation.evals[id.as_str()].readiness != Readiness::Ready,
            std::cmp::Reverse(lengths[id]),
            index,
        )
    });
    order
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum Stop {
    Blocked,
    Yield,
}