kalosm-parse-macro 0.4.1

A macro to derive kalosm parsing traits
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

#![allow(unused)]

use kalosm::language::{kalosm_sample, Parse, Schema};
use pretty_assertions::assert_eq;

#[derive(Parse, Schema, Clone, PartialEq, Debug)]
#[parse(rename = "empty struct")]
struct EmptyNamedStruct {}

#[test]
fn empty_struct_schema() {
    let schema = EmptyNamedStruct::schema();
    let json = serde_json::from_str::<serde_json::Value>(&schema.to_string()).unwrap();
    assert_eq!(
        json,
        serde_json::json!({
            "enum": ["empty struct"]
        })
    )
}

#[cfg(any(feature = "metal", feature = "cuda"))]
#[tokio::test]
async fn empty_struct() {
    use kalosm::language::*;

    let model = Llama::builder()
        .with_source(LlamaSource::tiny_llama_1_1b_chat())
        .build()
        .await
        .unwrap();

    let task = model
        .task("You generate json")
        .with_constraints(std::sync::Arc::new(EmptyNamedStruct::new_parser()));

    let output = task.run("What is the capital of France?").await.unwrap();

    assert_eq!(output, EmptyNamedStruct {});
}

/// A named struct
#[derive(Parse, Schema, Clone)]
struct NamedStruct {
    /// The name of the person
    #[parse(rename = "field name")]
    name: String,
    /// The age of the person
    age: u32,
}

#[test]
fn named_struct_schema() {
    let schema = NamedStruct::schema();
    let json = serde_json::from_str::<serde_json::Value>(&schema.to_string()).unwrap();
    assert_eq!(
        json,
        serde_json::json!({
            "title": "NamedStruct",
            "description": "A named struct",
            "type": "object",
            "properties": {
                "field name": {
                    "description": "The name of the person",
                    "type": "string"
                },
                "age": {
                    "description": "The age of the person",
                    "type": "integer"
                }
            },
            "required": [
                "field name",
                "age"
            ],
            "additionalProperties": false
        })
    );
}

#[cfg(any(feature = "metal", feature = "cuda"))]
#[tokio::test]
async fn named_struct() {
    use kalosm::language::*;

    let model = Llama::builder()
        .with_source(LlamaSource::tiny_llama_1_1b_chat())
        .build()
        .await
        .unwrap();

    let task = model
        .task("You generate json")
        .with_constraints(std::sync::Arc::new(NamedStruct::new_parser()));

    let output = task.run("What is the capital of France?", &model).await;
    println!("{output}");

    assert!(output.contains("\"field name\":"));
    assert!(output.contains("\"age\":"));
}

#[derive(Parse, Schema, Clone)]
struct WithStruct {
    #[parse(with = kalosm_sample::StringParser::new(1..=10))]
    name: String,
    #[parse(rename = "field name")]
    age: u32,
}

#[cfg(any(feature = "metal", feature = "cuda"))]
#[tokio::test]
async fn with_struct() {
    use kalosm::language::*;

    let model = Llama::builder()
        .with_source(LlamaSource::tiny_llama_1_1b_chat())
        .build()
        .await
        .unwrap();

    let task = model
        .task("You generate json")
        .with_constraints(std::sync::Arc::new(WithStruct::new_parser()));

    let output = task.run("What is the capital of France?", &model).await;
    println!("{output}");

    assert!(output.contains("\"name\":"));
    assert!(output.contains("\"field name\":"));
}