zai-rs 0.1.15

一个 Rust SDK, 用于调用 智普AI 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
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

use serde::{Deserialize, Serialize};
use validator::Validate;

use super::types::UploadUrlResponse;
use crate::{ZaiResult, client::http::HttpClient};

/// Single URL upload detail
#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
pub struct UploadUrlDetail {
    /// Source URL to fetch
    #[validate(url)]
    pub url: String,
    /// Slice type (integer)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub knowledge_type: Option<i64>,
    /// Custom separators
    #[serde(skip_serializing_if = "Option::is_none")]
    pub custom_separator: Option<Vec<String>>,
    /// Sentence size
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(range(min = 1))]
    pub sentence_size: Option<u32>,
    /// Callback URL
    #[serde(skip_serializing_if = "Option::is_none")]
    #[validate(url)]
    pub callback_url: Option<String>,
    /// Callback headers
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback_header: Option<std::collections::BTreeMap<String, String>>,
}

impl UploadUrlDetail {
    pub fn new(url: impl Into<String>) -> Self {
        Self {
            url: url.into(),
            knowledge_type: None,
            custom_separator: None,
            sentence_size: None,
            callback_url: None,
            callback_header: None,
        }
    }
    pub fn with_knowledge_type(mut self, t: i64) -> Self {
        self.knowledge_type = Some(t);
        self
    }
    pub fn with_custom_separator(mut self, seps: Vec<String>) -> Self {
        self.custom_separator = Some(seps);
        self
    }
    pub fn with_sentence_size(mut self, size: u32) -> Self {
        self.sentence_size = Some(size);
        self
    }
    pub fn with_callback_url(mut self, url: impl Into<String>) -> Self {
        self.callback_url = Some(url.into());
        self
    }
    pub fn with_callback_header(
        mut self,
        headers: std::collections::BTreeMap<String, String>,
    ) -> Self {
        self.callback_header = Some(headers);
        self
    }
}

/// Upload URL request body
#[derive(Debug, Clone, Serialize, Deserialize, Validate)]
pub struct UploadUrlBody {
    /// Upload detail list (at least 1)
    #[validate(length(min = 1))]
    pub upload_detail: Vec<UploadUrlDetail>,
    /// Knowledge base id
    #[validate(length(min = 1))]
    pub knowledge_id: String,
}

impl UploadUrlBody {
    pub fn new(knowledge_id: impl Into<String>) -> Self {
        Self {
            upload_detail: Vec::new(),
            knowledge_id: knowledge_id.into(),
        }
    }
    pub fn add_detail(mut self, detail: UploadUrlDetail) -> Self {
        self.upload_detail.push(detail);
        self
    }
    pub fn add_url(mut self, url: impl Into<String>) -> Self {
        self.upload_detail.push(UploadUrlDetail::new(url));
        self
    }
}

/// Upload URL request (POST /llm-application/open/document/upload_url)
pub struct DocumentUploadUrlRequest {
    /// Bearer API key
    pub key: String,
    url: String,
    body: UploadUrlBody,
}

impl DocumentUploadUrlRequest {
    pub fn new(key: String, body: UploadUrlBody) -> Self {
        let url =
            "https://open.bigmodel.cn/api/llm-application/open/document/upload_url".to_string();
        Self { key, url, body }
    }

    pub fn body_mut(&mut self) -> &mut UploadUrlBody {
        &mut self.body
    }

    /// Validate and send
    pub async fn send(&self) -> ZaiResult<UploadUrlResponse> {
        self.body.validate()?;
        let resp = self.post().await?;
        let parsed = resp.json::<UploadUrlResponse>().await?;
        Ok(parsed)
    }
}

impl HttpClient for DocumentUploadUrlRequest {
    type Body = UploadUrlBody;
    type ApiUrl = String;
    type ApiKey = String;

    fn api_url(&self) -> &Self::ApiUrl {
        &self.url
    }
    fn api_key(&self) -> &Self::ApiKey {
        &self.key
    }
    fn body(&self) -> &Self::Body {
        &self.body
    }
}