aufbau 0.1.0

Type-aware constrained decoding for LLMs using context-dependent grammars with typing rules
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

use crate::cli::validate::{RunnableCase, RunnableSuite, ValidateCmd};
use aufbau::validation::completable;

pub fn run(args: &ValidateCmd) {
    let all = completable::all_suites();

    let suites: Vec<RunnableSuite> = all
        .into_iter()
        .map(|(name, grammar, cases)| {
            let runnable_cases: Vec<RunnableCase> = cases
                .into_iter()
                .map(|case| {
                    let g = grammar.clone();
                    let desc = case.description.to_string();
                    let input = case.input.to_string();
                    RunnableCase {
                        desc,
                        input,
                        run: Box::new(move || {
                            let (result, _duration, _meta) =
                                completable::run_test_timed_meta(&g, &case);
                            match result {
                                completable::TestResult::Pass(_) => (true, String::new()),
                                completable::TestResult::Fail(msg) => (false, msg),
                            }
                        }),
                    }
                })
                .collect();

            RunnableSuite {
                name,
                cases: runnable_cases,
            }
        })
        .collect();

    super::run_suites("completable", suites, args);
}