openai4rs 0.1.9

A non-official Rust crate for calling the OpenAI service
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

use super::params::CompletionsParam;
use super::types::Completion;
use crate::common::types::{InParam, RetryCount, Timeout};
use crate::error::OpenAIError;
use crate::service::client::HttpClient;
use crate::service::request::{RequestBuilder, RequestSpec};
use tokio_stream::wrappers::ReceiverStream;

pub struct Completions {
    http_client: HttpClient,
}

impl Completions {
    pub(crate) fn new(http_client: HttpClient) -> Completions {
        Completions { http_client }
    }

    pub async fn create(&self, param: CompletionsParam) -> Result<Completion, OpenAIError> {
        let mut inner = param.take();
        inner
            .body
            .as_mut()
            .unwrap()
            .insert("stream".to_string(), serde_json::to_value(false).unwrap());

        let http_params = RequestSpec::new(
            |config| format!("{}/completions", config.base_url()),
            |config, builder| {
                Self::apply_request_settings(builder, inner);
                builder.bearer_auth(config.api_key());
            },
        );

        self.http_client.post_json(http_params).await
    }

    pub async fn create_stream(
        &self,
        param: CompletionsParam,
    ) -> Result<ReceiverStream<Result<Completion, OpenAIError>>, OpenAIError> {
        let mut inner = param.take();
        inner
            .body
            .as_mut()
            .unwrap()
            .insert("stream".to_string(), serde_json::to_value(true).unwrap());

        let http_params = RequestSpec::new(
            |config| format!("{}/completions", config.base_url()),
            |config, builder| {
                Self::apply_request_settings(builder, inner);
                builder.bearer_auth(config.api_key());
            },
        );
        self.http_client.post_json_stream(http_params).await
    }
}

impl Completions {
    fn apply_request_settings(builder: &mut RequestBuilder, params: InParam) {
        let body = params
            .body
            .unwrap_or_else(|| panic!("Unknown internal error, please submit an issue."));

        builder.body_fields(body);

        *builder.headers_mut() = params.headers;

        if let Some(time) = params.extensions.get::<Timeout>() {
            builder.timeout(time.0);
        }

        if let Some(retry) = params.extensions.get::<RetryCount>() {
            builder.extensions_mut().insert(retry.clone());
        }
    }
}