rustev-runtime 0.4.0

Rustev's runtime: bounded execution of compiled plans through backend seams, with honest cost, cancellation and evidence.
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

//! Package-local synthetic generation fixtures.
use rustev_contract::definition::{Definition, Determinism, Operation};
use rustev_contract::descriptor::{
    BackendDescriptor, InputExcess, InputLimit, OperationSupport, OutputKind,
};
use rustev_contract::execution::{CostPolicy, ExecutionPolicy, StepExecution};
use rustev_contract::ids::ArtifactId;
use rustev_contract::schema;
use rustev_contract::snapshot::{Entry, Snapshot};
use rustev_contract::time::Timestamp;
use serde_json::json;

pub fn generation_definition() -> Definition {
    serde_json::from_value(json!({
        "schema": "rustev.definition/2",
        "name": "support-routing", "version": "1.0.0", "package": "rustev-reference",
        "inputs": [], "steps": [],
        "policy": {"on_unresolved": [], "rules": [], "adjustments": []},
        "limits": {"max_semantic_requests": 3, "on_excess": "refuse",
            "max_projection_bytes": 65536, "distribution_tolerance": "0.000001",
            "deadline_ms": 2000}
    }))
    .unwrap()
}

pub fn artifact(c: char) -> ArtifactId {
    ArtifactId::parse(&format!("sha256:{}", c.to_string().repeat(64))).unwrap()
}

pub fn ts(ms: i64) -> Timestamp {
    Timestamp::from_ms(ms).unwrap()
}

pub fn support(op: Operation, output: OutputKind, max: u64) -> OperationSupport {
    OperationSupport {
        isolation: None,
        screen: None,
        operation: op,
        output,
        max_options: max,
    }
}

pub fn linear_head() -> BackendDescriptor {
    BackendDescriptor {
        ranking: None,
        schema: schema::BACKEND.into(),
        backend_id: "synthetic-linear-head".into(),
        artifact: artifact('a'),
        operations: vec![
            support(Operation::Classify, OutputKind::Logits, 16),
            support(Operation::Proposition, OutputKind::Logits, 2),
            support(Operation::Rubric, OutputKind::Logits, 8),
        ],
        input_limit: InputLimit {
            max_bytes: 65_536,
            on_excess: InputExcess::Refuse,
        },
        determinism: Determinism::Tolerance,
    }
}

pub fn execution(cost: CostPolicy, steps: Vec<StepExecution>) -> ExecutionPolicy {
    ExecutionPolicy {
        schema: schema::EXECUTION.into(),
        max_attempts_per_decision: 1_000,
        cost,
        optimization: None,
        steps,
    }
}

pub fn snapshot(entries: Vec<Entry>) -> Snapshot {
    Snapshot {
        schema: schema::SNAPSHOT.into(),
        entries,
    }
}