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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
//! Moderations API client.
use super::{map_api_error, Client};
use crate::builders::moderations::{ModerationBuilder, ModerationInput};
use crate::errors::Result;
use crate::interceptor::{AfterResponseContext, BeforeRequestContext, ErrorContext};
use crate::semantic_conventions::operation_names;
use crate::time::Instant;
use crate::Error;
use openai_client_base::apis::moderations_api;
use openai_client_base::models::CreateModeration200Response;
/// Client for moderations API.
#[derive(Debug, Clone, Copy)]
#[allow(dead_code)]
pub struct ModerationsClient<'a, T = ()> {
pub(super) client: &'a Client<T>,
}
impl_interceptor_helpers!(ModerationsClient<'_, T>);
impl<T: Default + crate::MaybeSend + crate::MaybeSync> ModerationsClient<'_, T> {
/// Create a moderation builder for checking text content.
///
/// # Example
///
/// ```rust,no_run
/// use openai_ergonomic::Client;
///
/// # async fn example() -> openai_ergonomic::Result<()> {
/// let client = Client::from_env()?.build();
/// let builder = client.moderations().builder("Text to check");
/// let response = client.moderations().create(builder).await?;
/// println!("Response: {response}");
/// # Ok(())
/// # }
/// ```
#[must_use]
pub fn builder(&self, input: impl Into<ModerationInput>) -> ModerationBuilder {
ModerationBuilder::new(input)
}
/// Convenience method for moderating a single text input.
///
/// # Example
///
/// ```rust,no_run
/// use openai_client_base::models::CreateModeration200Response;
/// use openai_ergonomic::Client;
///
/// # async fn example() -> openai_ergonomic::Result<()> {
/// let client = Client::from_env()?.build();
/// let builder = client.moderations().check("Hello world");
/// let response = client.moderations().create(builder).await?;
///
/// if let CreateModeration200Response::CreateModerationResponse(moderation) = response {
/// if moderation.results[0].flagged {
/// println!("Content was flagged for moderation");
/// }
/// }
/// # Ok(())
/// # }
/// ```
#[must_use]
pub fn check(&self, input: impl Into<ModerationInput>) -> ModerationBuilder {
ModerationBuilder::new(input)
}
/// Execute a moderation request built with [`ModerationBuilder`].
///
/// The answer is the classification (`CreateModerationResponse`) or, for
/// `omni-moderation-csam-latest`, the CSAM result (`CreateCsamModerationResponse`).
///
/// # Example
///
/// ```rust,no_run
/// use openai_client_base::models::CreateModeration200Response;
/// use openai_ergonomic::Client;
///
/// # async fn example() -> openai_ergonomic::Result<()> {
/// let client = Client::from_env()?.build();
///
/// let builder = client
/// .moderations()
/// .check("Is this content appropriate?")
/// .model("text-moderation-latest");
///
/// // `omni-moderation-csam-latest` answers with `CreateCsamModerationResponse` instead.
/// let CreateModeration200Response::CreateModerationResponse(response) =
/// client.moderations().create(builder).await?
/// else {
/// return Ok(());
/// };
///
/// println!("Model: {}", response.model);
/// for result in response.results {
/// println!("Flagged: {}", result.flagged);
/// println!("Hate: {}", result.categories.hate);
/// println!("Violence: {}", result.categories.violence);
/// }
/// # Ok(())
/// # }
/// ```
///
/// # Errors
///
/// Returns an error if the API request fails or the response cannot be parsed.
pub async fn create(&self, builder: ModerationBuilder) -> Result<CreateModeration200Response> {
let request = builder.build()?;
// Prepare interceptor context
let mut state = T::default();
let operation = operation_names::MODERATION;
let model = request
.model
.as_ref()
.map_or_else(|| "text-moderation-latest".to_string(), ToString::to_string);
let request_json = serde_json::to_string(&request).unwrap_or_default();
// Call before_request hook
self.call_before_request(operation, &model, &request_json, &mut state)
.await?;
let start_time = Instant::now();
// Make the API call
let response = match moderations_api::create_moderation()
.configuration(&self.client.base_configuration)
.create_moderation_request(&request)
.call()
.await
{
Ok(resp) => resp,
Err(e) => {
let error = self
.handle_api_error(e, operation, &model, &request_json, &state)
.await;
return Err(error);
}
};
let duration = start_time.elapsed();
// Call after_response hook
self.call_after_response(
&response,
operation,
&model,
&request_json,
&state,
duration,
None,
None,
)
.await;
Ok(response)
}
}