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

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

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

    let suites: Vec<RunnableSuite> = all
        .into_iter()
        .map(|(name, grammar, valids, invalids)| {
            let mut cases: Vec<RunnableCase> = Vec::with_capacity(valids.len() + invalids.len());

            for case in valids.into_iter().chain(invalids.into_iter()) {
                let g = grammar.clone();
                let desc = case.description.to_string();
                let input = case.input.to_string();
                cases.push(RunnableCase {
                    desc,
                    input,
                    run: Box::new(move || {
                        let result = parseable::run_parse_test(&g, &case);
                        match result {
                            parseable::ParseResult::Pass { .. } => (true, String::new()),
                            parseable::ParseResult::Fail {
                                failing_prefix,
                                error,
                                ..
                            } => (false, format!("Failing prefix: '{}'\nError: {}", failing_prefix, error)),
                        }
                    }),
                });
            }

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

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