async_openai/
vector_store_files.rs1use crate::{
2 config::Config,
3 error::OpenAIError,
4 types::vectorstores::{
5 CreateVectorStoreFileRequest, DeleteVectorStoreFileResponse, ListVectorStoreFilesResponse,
6 UpdateVectorStoreFileAttributesRequest, VectorStoreFileContentResponse,
7 VectorStoreFileObject,
8 },
9 Client, RequestOptions,
10};
11
12pub struct VectorStoreFiles<'c, C: Config> {
16 client: &'c Client<C>,
17 pub vector_store_id: String,
18 pub(crate) request_options: RequestOptions,
19}
20
21impl<'c, C: Config> VectorStoreFiles<'c, C> {
22 pub fn new(client: &'c Client<C>, vector_store_id: &str) -> Self {
23 Self {
24 client,
25 vector_store_id: vector_store_id.into(),
26 request_options: RequestOptions::new(),
27 }
28 }
29
30 #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
32 pub async fn create(
33 &self,
34 request: CreateVectorStoreFileRequest,
35 ) -> Result<VectorStoreFileObject, OpenAIError> {
36 self.client
37 .post(
38 &format!("/vector_stores/{}/files", &self.vector_store_id),
39 request,
40 &self.request_options,
41 )
42 .await
43 }
44
45 #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
47 pub async fn retrieve(&self, file_id: &str) -> Result<VectorStoreFileObject, OpenAIError> {
48 self.client
49 .get(
50 &format!("/vector_stores/{}/files/{file_id}", &self.vector_store_id),
51 &self.request_options,
52 )
53 .await
54 }
55
56 #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
58 pub async fn delete(
59 &self,
60 file_id: &str,
61 ) -> Result<DeleteVectorStoreFileResponse, OpenAIError> {
62 self.client
63 .delete(
64 &format!("/vector_stores/{}/files/{file_id}", &self.vector_store_id),
65 &self.request_options,
66 )
67 .await
68 }
69
70 #[crate::byot(R = serde::de::DeserializeOwned)]
72 pub async fn list(&self) -> Result<ListVectorStoreFilesResponse, OpenAIError> {
73 self.client
74 .get(
75 &format!("/vector_stores/{}/files", &self.vector_store_id),
76 &self.request_options,
77 )
78 .await
79 }
80
81 #[crate::byot(T0 = std::fmt::Display, T1 = serde::Serialize, R = serde::de::DeserializeOwned)]
83 pub async fn update(
84 &self,
85 file_id: &str,
86 request: UpdateVectorStoreFileAttributesRequest,
87 ) -> Result<VectorStoreFileObject, OpenAIError> {
88 self.client
89 .post(
90 &format!("/vector_stores/{}/files/{file_id}", &self.vector_store_id),
91 request,
92 &self.request_options,
93 )
94 .await
95 }
96
97 #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
99 pub async fn retrieve_file_content(
100 &self,
101 file_id: &str,
102 ) -> Result<VectorStoreFileContentResponse, OpenAIError> {
103 self.client
104 .get(
105 &format!(
106 "/vector_stores/{}/files/{file_id}/content",
107 &self.vector_store_id
108 ),
109 &self.request_options,
110 )
111 .await
112 }
113}
114
115#[cfg(test)]
116mod tests {
117 use crate::types::files::{CreateFileRequest, FileInput, FilePurpose};
118 use crate::types::vectorstores::CreateVectorStoreRequest;
119 use crate::Client;
120
121 #[tokio::test]
122 async fn vector_store_file_creation_and_deletion(
123 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
124 let client = Client::new();
125
126 let file_handle = client
128 .files()
129 .create(CreateFileRequest {
130 file: FileInput::from_vec_u8(
131 String::from("meow.txt"),
132 String::from(":3").into_bytes(),
133 ),
134 purpose: FilePurpose::Assistants,
135 expires_after: None,
136 })
137 .await?;
138
139 let vector_store_handle = client
141 .vector_stores()
142 .create(CreateVectorStoreRequest {
143 file_ids: Some(vec![file_handle.id.clone()]),
144 name: None,
145 description: None,
146 expires_after: None,
147 chunking_strategy: None,
148 metadata: None,
149 })
150 .await?;
151 let vector_store_file = client
152 .vector_stores()
153 .files(&vector_store_handle.id)
154 .retrieve(&file_handle.id)
155 .await?;
156
157 assert_eq!(vector_store_file.id, file_handle.id);
158 client
160 .vector_stores()
161 .delete(&vector_store_handle.id)
162 .await?;
163
164 client.files().delete(&file_handle.id).await?;
166
167 Ok(())
168 }
169}