outfox-openai 0.7.0

Openai for outfox
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
132
133
134
135
136
137
138
139
140
141
142

use std::fmt::{self, Display};
use std::ops::Deref;

use serde::{Deserialize, Serialize};

#[derive(Default, Debug, Deserialize, Clone, PartialEq, Serialize)]
pub struct TextObject {
    pub text: String,
}

impl From<&str> for TextObject {
    fn from(value: &str) -> Self {
        TextObject { text: value.into() }
    }
}

impl From<String> for TextObject {
    fn from(value: String) -> Self {
        TextObject { text: value }
    }
}

impl Display for TextObject {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.text)
    }
}

impl Deref for TextObject {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        &self.text
    }
}

impl AsRef<String> for TextObject {
    fn as_ref(&self) -> &String {
        &self.text
    }
}
impl AsRef<str> for TextObject {
    fn as_ref(&self) -> &str {
        &self.text
    }
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
#[serde(untagged)]
pub enum PartibleTextContent {
    /// The text contents of the message.
    Text(String),
    /// An array of content parts with a defined type. Supported options differ based on the [model](https://platform.openai.com/docs/models) being used to generate the response. Can contain text, image, or audio inputs.
    Array(Vec<TextObject>),
}
impl PartibleTextContent {
    pub fn to_texts(&self) -> Vec<String> {
        match self {
            Self::Text(text) => vec![text.clone()],
            Self::Array(parts) => parts.iter().map(|p| p.to_string()).collect(),
        }
    }
    pub fn into_texts(self) -> Vec<String> {
        match self {
            Self::Text(text) => vec![text],
            Self::Array(parts) => parts.into_iter().map(|p| p.to_string()).collect(),
        }
    }
    pub fn is_empty(&self) -> bool {
        match self {
            Self::Text(text) => text.is_empty(),
            Self::Array(parts) => parts.is_empty(),
        }
    }
}
impl Display for PartibleTextContent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Text(text) => write!(f, "{text}"),
            Self::Array(parts) => write!(
                f,
                "{}",
                parts
                    .iter()
                    .map(|p| &*p.text)
                    .collect::<Vec<_>>()
                    .join("\n")
            ),
        }
    }
}
impl From<&str> for PartibleTextContent {
    fn from(value: &str) -> Self {
        Self::Text(value.into())
    }
}

impl From<String> for PartibleTextContent {
    fn from(value: String) -> Self {
        Self::Text(value)
    }
}
impl Default for PartibleTextContent {
    fn default() -> Self {
        Self::Text("".into())
    }
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
#[serde(tag = "type")]
#[serde(rename_all = "snake_case")]
pub enum UnitaryTextContent {
    Text(TextObject),
}
impl Display for UnitaryTextContent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Text(text) => write!(f, "{text}"),
        }
    }
}
impl From<&str> for UnitaryTextContent {
    fn from(value: &str) -> Self {
        Self::Text(value.into())
    }
}

impl From<String> for UnitaryTextContent {
    fn from(value: String) -> Self {
        Self::Text(value.into())
    }
}
impl From<TextObject> for UnitaryTextContent {
    fn from(value: TextObject) -> Self {
        Self::Text(value)
    }
}
impl Default for UnitaryTextContent {
    fn default() -> Self {
        Self::Text("".into())
    }
}