oaapi 0.2.0

An unofficial Rust client for the OpenAI API.
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

use crate::macros::{
    impl_display_for_serialize, impl_enum_string_serialization,
};
use serde::{Deserialize, Serialize};
use std::fmt::{Debug, Display};

/// The response format of chat.
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct ResponseFormat {
    /// The type of response format.
    #[serde(rename = "type")]
    pub _type: ResponseFormatType,
}

impl From<ResponseFormatType> for ResponseFormat {
    fn from(_type: ResponseFormatType) -> Self {
        Self {
            _type,
        }
    }
}

impl_display_for_serialize!(ResponseFormat);

/// The response format type of chat.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ResponseFormatType {
    /// "text"
    Text,
    /// "json_object"
    Json,
}

impl Default for ResponseFormatType {
    fn default() -> Self {
        Self::Text
    }
}

impl Display for ResponseFormatType {
    fn fmt(
        &self,
        f: &mut std::fmt::Formatter<'_>,
    ) -> std::fmt::Result {
        match self {
            | ResponseFormatType::Text => {
                write!(f, "text")
            },
            | ResponseFormatType::Json => {
                write!(f, "json_object")
            },
        }
    }
}

impl_enum_string_serialization!(
    ResponseFormatType,
    Text => "text",
    Json => "json_object"
);

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn serialization() {
        assert_eq!(
            serde_json::to_string(&ResponseFormat::from(
                ResponseFormatType::Text
            ))
            .unwrap(),
            "{\"type\":\"text\"}"
        );

        assert_eq!(
            serde_json::to_string(&ResponseFormat::from(
                ResponseFormatType::Json
            ))
            .unwrap(),
            "{\"type\":\"json_object\"}"
        );
    }

    #[test]
    fn deserialization() {
        assert_eq!(
            serde_json::from_str::<ResponseFormat>("{\"type\":\"text\"}")
                .unwrap(),
            ResponseFormatType::Text.into()
        );

        assert_eq!(
            serde_json::from_str::<ResponseFormat>(
                "{\"type\":\"json_object\"}"
            )
            .unwrap(),
            ResponseFormatType::Json.into()
        );
    }
}