unitycatalog_client/codegen/model_versions/
builders.rs

1// @generated — do not edit by hand.
2#![allow(unused_mut)]
3#![allow(unused_imports)]
4type BoxFut<'a, T> = ::futures::future::BoxFuture<'a, T>;
5type BoxStr<'a, T> = ::futures::stream::BoxStream<'a, T>;
6use super::super::stream_paginated;
7use super::client::*;
8use crate::Result;
9use futures::{StreamExt, TryStreamExt};
10use std::future::IntoFuture;
11use unitycatalog_common::models::model_versions::v1::*;
12/// Builder for listing model versions
13pub struct ListModelVersionsBuilder {
14    client: ModelVersionServiceClient,
15    request: ListModelVersionsRequest,
16}
17impl ListModelVersionsBuilder {
18    /// Create a new builder instance.
19    /// Obtain via the corresponding method on `ModelVersionServiceClient`.
20    pub(crate) fn new(client: ModelVersionServiceClient, full_name: impl Into<String>) -> Self {
21        let request = ListModelVersionsRequest {
22            full_name: full_name.into(),
23            ..Default::default()
24        };
25        Self { client, request }
26    }
27    /// The maximum number of results per page that should be returned.
28    pub fn with_max_results(mut self, max_results: impl Into<Option<i32>>) -> Self {
29        self.request.max_results = max_results.into();
30        self
31    }
32    /// Opaque pagination token to go to next page based on previous query.
33    pub fn with_page_token(mut self, page_token: impl Into<Option<String>>) -> Self {
34        self.request.page_token = page_token.into();
35        self
36    }
37    /** Whether to include model versions in the response for which the principal can
38    only access selective metadata for.*/
39    pub fn with_include_browse(mut self, include_browse: impl Into<Option<bool>>) -> Self {
40        self.request.include_browse = include_browse.into();
41        self
42    }
43    /// Convert paginated request into stream of results
44    pub fn into_stream(self) -> BoxStr<'static, Result<ModelVersion>> {
45        let remaining = self.request.max_results;
46        let stream = stream_paginated(
47            (self, remaining),
48            move |(mut builder, mut remaining), page_token| async move {
49                builder.request.page_token = page_token;
50                let res = builder.client.list_model_versions(&builder.request).await?;
51                if let Some(ref mut rem) = remaining {
52                    *rem -= res.model_versions.len() as i32;
53                }
54                let next_page_token = if remaining.is_some_and(|r| r <= 0) {
55                    None
56                } else {
57                    res.next_page_token.clone()
58                };
59                Ok((res, (builder, remaining), next_page_token))
60            },
61        )
62        .map_ok(|resp| futures::stream::iter(resp.model_versions.into_iter().map(Ok)))
63        .try_flatten();
64        stream.boxed()
65    }
66}
67impl IntoFuture for ListModelVersionsBuilder {
68    type Output = Result<ListModelVersionsResponse>;
69    type IntoFuture = BoxFut<'static, Self::Output>;
70    fn into_future(self) -> Self::IntoFuture {
71        let client = self.client;
72        let request = self.request;
73        Box::pin(async move { client.list_model_versions(&request).await })
74    }
75}
76/// Builder for creating a model version
77pub struct CreateModelVersionBuilder {
78    client: ModelVersionServiceClient,
79    request: CreateModelVersionRequest,
80}
81impl CreateModelVersionBuilder {
82    /// Create a new builder instance.
83    /// Obtain via the corresponding method on `ModelVersionServiceClient`.
84    pub(crate) fn new(
85        client: ModelVersionServiceClient,
86        model_name: impl Into<String>,
87        catalog_name: impl Into<String>,
88        schema_name: impl Into<String>,
89        source: impl Into<String>,
90    ) -> Self {
91        let request = CreateModelVersionRequest {
92            model_name: model_name.into(),
93            catalog_name: catalog_name.into(),
94            schema_name: schema_name.into(),
95            source: source.into(),
96            ..Default::default()
97        };
98        Self { client, request }
99    }
100    /// The run id used by the ML package that generated this model.
101    pub fn with_run_id(mut self, run_id: impl Into<Option<String>>) -> Self {
102        self.request.run_id = run_id.into();
103        self
104    }
105    /// User-provided free-form text description.
106    pub fn with_comment(mut self, comment: impl Into<Option<String>>) -> Self {
107        self.request.comment = comment.into();
108        self
109    }
110}
111impl IntoFuture for CreateModelVersionBuilder {
112    type Output = Result<ModelVersion>;
113    type IntoFuture = BoxFut<'static, Self::Output>;
114    fn into_future(self) -> Self::IntoFuture {
115        let client = self.client;
116        let request = self.request;
117        Box::pin(async move { client.create_model_version(&request).await })
118    }
119}
120/// Builder for getting a model version
121pub struct GetModelVersionBuilder {
122    client: ModelVersionServiceClient,
123    request: GetModelVersionRequest,
124}
125impl GetModelVersionBuilder {
126    /// Create a new builder instance.
127    /// Obtain via the corresponding method on `ModelVersionServiceClient`.
128    pub(crate) fn new(
129        client: ModelVersionServiceClient,
130        full_name: impl Into<String>,
131        version: i64,
132    ) -> Self {
133        let request = GetModelVersionRequest {
134            full_name: full_name.into(),
135            version,
136            ..Default::default()
137        };
138        Self { client, request }
139    }
140    /** Whether to include model versions in the response for which the principal can
141    only access selective metadata for.*/
142    pub fn with_include_browse(mut self, include_browse: impl Into<Option<bool>>) -> Self {
143        self.request.include_browse = include_browse.into();
144        self
145    }
146}
147impl IntoFuture for GetModelVersionBuilder {
148    type Output = Result<ModelVersion>;
149    type IntoFuture = BoxFut<'static, Self::Output>;
150    fn into_future(self) -> Self::IntoFuture {
151        let client = self.client;
152        let request = self.request;
153        Box::pin(async move { client.get_model_version(&request).await })
154    }
155}
156/// Builder for updating a model version
157pub struct UpdateModelVersionBuilder {
158    client: ModelVersionServiceClient,
159    request: UpdateModelVersionRequest,
160}
161impl UpdateModelVersionBuilder {
162    /// Create a new builder instance.
163    /// Obtain via the corresponding method on `ModelVersionServiceClient`.
164    pub(crate) fn new(
165        client: ModelVersionServiceClient,
166        full_name: impl Into<String>,
167        version: i64,
168    ) -> Self {
169        let request = UpdateModelVersionRequest {
170            full_name: full_name.into(),
171            version,
172            ..Default::default()
173        };
174        Self { client, request }
175    }
176    /// User-provided free-form text description.
177    pub fn with_comment(mut self, comment: impl Into<Option<String>>) -> Self {
178        self.request.comment = comment.into();
179        self
180    }
181}
182impl IntoFuture for UpdateModelVersionBuilder {
183    type Output = Result<ModelVersion>;
184    type IntoFuture = BoxFut<'static, Self::Output>;
185    fn into_future(self) -> Self::IntoFuture {
186        let client = self.client;
187        let request = self.request;
188        Box::pin(async move { client.update_model_version(&request).await })
189    }
190}
191/// Builder for deleting a model version
192pub struct DeleteModelVersionBuilder {
193    client: ModelVersionServiceClient,
194    request: DeleteModelVersionRequest,
195}
196impl DeleteModelVersionBuilder {
197    /// Create a new builder instance.
198    /// Obtain via the corresponding method on `ModelVersionServiceClient`.
199    pub(crate) fn new(
200        client: ModelVersionServiceClient,
201        full_name: impl Into<String>,
202        version: i64,
203    ) -> Self {
204        let request = DeleteModelVersionRequest {
205            full_name: full_name.into(),
206            version,
207            ..Default::default()
208        };
209        Self { client, request }
210    }
211}
212impl IntoFuture for DeleteModelVersionBuilder {
213    type Output = Result<()>;
214    type IntoFuture = BoxFut<'static, Self::Output>;
215    fn into_future(self) -> Self::IntoFuture {
216        let client = self.client;
217        let request = self.request;
218        Box::pin(async move { client.delete_model_version(&request).await })
219    }
220}
221/// Builder for model version
222pub struct FinalizeModelVersionBuilder {
223    client: ModelVersionServiceClient,
224    request: FinalizeModelVersionRequest,
225}
226impl FinalizeModelVersionBuilder {
227    /// Create a new builder instance.
228    /// Obtain via the corresponding method on `ModelVersionServiceClient`.
229    pub(crate) fn new(
230        client: ModelVersionServiceClient,
231        full_name: impl Into<String>,
232        version: i64,
233    ) -> Self {
234        let request = FinalizeModelVersionRequest {
235            full_name: full_name.into(),
236            version,
237            ..Default::default()
238        };
239        Self { client, request }
240    }
241}
242impl IntoFuture for FinalizeModelVersionBuilder {
243    type Output = Result<ModelVersion>;
244    type IntoFuture = BoxFut<'static, Self::Output>;
245    fn into_future(self) -> Self::IntoFuture {
246        let client = self.client;
247        let request = self.request;
248        Box::pin(async move { client.finalize_model_version(&request).await })
249    }
250}
unitycatalog_client/codegen/model_versions/builders.rs

unitycatalog_client/codegen/model_versions/
builders.rs
