glide-rs 0.1.0

A minimal EinStack client.
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

//! Language service, its request and response types.
//!

use std::fmt;
use std::sync::Arc;

use reqwest::Method;

use crate::config::Config;
use crate::lang::chat::{ChatRequest, ChatResponse};
use crate::lang::list::RouterConfigs;
#[cfg(feature = "streaming")]
#[cfg_attr(docsrs, doc(cfg(feature = "streaming")))]
pub use crate::lang::stream::Chat;
use crate::Result;

pub mod chat;
pub mod list;

#[cfg(feature = "streaming")]
mod stream;

/// APIs for `/v1/language` endpoints.
#[derive(Clone)]
pub struct Language(pub(crate) Arc<Config>);

impl Language {
    /// Retrieves a list of all `router` configs.
    ///
    /// `GET /v1/language`
    ///
    /// # Errors
    ///
    /// Returns an [`Error`] if the response [`StatusCode`] is not in the 200-299 range.
    ///
    /// [`Error`]: crate::Error
    /// [`StatusCode`]: reqwest::StatusCode
    pub async fn list(&self) -> Result<RouterConfigs> {
        let request = self.0.create(Method::GET, "/v1/language/");
        let response = self.0.send(request).await?;
        let content = response.json::<RouterConfigs>().await?;
        Ok(content)
    }

    /// Sends a single chat request to a specified `router` and retrieves the response.
    ///
    /// `POST /v1/language/{router}/chat`
    ///
    /// # Errors
    ///
    /// Returns an [`Error`] if the response [`StatusCode`] is not in the 200-299 range.
    ///
    /// [`Error`]: crate::Error
    /// [`StatusCode`]: reqwest::StatusCode
    pub async fn chat(&self, router: &str, data: ChatRequest) -> Result<ChatResponse> {
        let path = format!("/v1/language/{router}/chat");

        let request = self.0.create(Method::POST, &path);
        let response = self.0.send(request.json(&data)).await?;
        let content = response.json::<ChatResponse>().await?;

        Ok(content)
    }

    /// Establishes a `WebSocket` connection for streaming chat messages from a specified `router`.
    ///
    /// `GET /v1/language/{router}/chatStream`
    ///
    /// # Errors
    ///
    /// Returns an [`Error`] if the response [`StatusCode`] is not in the 200-299 range.
    ///
    /// [`Error`]: crate::Error
    /// [`StatusCode`]: reqwest::StatusCode
    #[cfg(feature = "streaming")]
    #[cfg_attr(docsrs, doc(cfg(feature = "streaming")))]
    pub async fn stream(&self, router: &str) -> Result<Chat> {
        use reqwest_websocket::RequestBuilderExt as _;
        let path = format!("/v1/language/{router}/chatStream");

        let request = self.0.create(Method::GET, &path).upgrade();
        let response = request.send().await?;
        let websocket = response.into_websocket().await?;

        Ok(Chat::new(websocket))
    }
}

impl fmt::Debug for Language {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self.0, f)
    }
}

#[cfg(test)]
mod test {
    use crate::lang::chat::ChatRequest;
    use crate::{Client, Result};

    #[tokio::test]
    async fn list() -> Result<()> {
        let glide = Client::default();
        let response = glide.lang.list().await?;
        assert!(response.routers.len() > 0);

        Ok(())
    }

    #[tokio::test]
    async fn chat() -> Result<()> {
        let glide = Client::default();

        let router = "myrouter";
        let request = ChatRequest::new("Hello!");
        let _ = glide.lang.chat(router, request).await?;

        Ok(())
    }

    #[tokio::test]
    #[cfg(feature = "streaming")]
    async fn stream() -> Result<()> {
        let glide = Client::default();

        let router = "myrouter";
        let _ws = glide.lang.stream(router).await?;
        // let (tx, rx) = ws.split();
        // TODO: Test streaming chat.

        Ok(())
    }
}