unitycatalog_client/codegen/registered_models/
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::registered_models::v1::*;
12/// Builder for listing registered models
13pub struct ListRegisteredModelsBuilder {
14    client: RegisteredModelServiceClient,
15    request: ListRegisteredModelsRequest,
16}
17impl ListRegisteredModelsBuilder {
18    /// Create a new builder instance.
19    /// Obtain via the corresponding method on `RegisteredModelServiceClient`.
20    pub(crate) fn new(client: RegisteredModelServiceClient) -> Self {
21        let request = ListRegisteredModelsRequest {
22            ..Default::default()
23        };
24        Self { client, request }
25    }
26    /// Name of parent catalog for models of interest.
27    pub fn with_catalog_name(mut self, catalog_name: impl Into<Option<String>>) -> Self {
28        self.request.catalog_name = catalog_name.into();
29        self
30    }
31    /// Name of parent schema for models of interest.
32    pub fn with_schema_name(mut self, schema_name: impl Into<Option<String>>) -> Self {
33        self.request.schema_name = schema_name.into();
34        self
35    }
36    /// The maximum number of results per page that should be returned.
37    pub fn with_max_results(mut self, max_results: impl Into<Option<i32>>) -> Self {
38        self.request.max_results = max_results.into();
39        self
40    }
41    /// Opaque pagination token to go to next page based on previous query.
42    pub fn with_page_token(mut self, page_token: impl Into<Option<String>>) -> Self {
43        self.request.page_token = page_token.into();
44        self
45    }
46    /** Whether to include registered models in the response for which the principal
47    can only access selective metadata for.*/
48    pub fn with_include_browse(mut self, include_browse: impl Into<Option<bool>>) -> Self {
49        self.request.include_browse = include_browse.into();
50        self
51    }
52    /// Convert paginated request into stream of results
53    pub fn into_stream(self) -> BoxStr<'static, Result<RegisteredModel>> {
54        let remaining = self.request.max_results;
55        let stream = stream_paginated(
56            (self, remaining),
57            move |(mut builder, mut remaining), page_token| async move {
58                builder.request.page_token = page_token;
59                let res = builder
60                    .client
61                    .list_registered_models(&builder.request)
62                    .await?;
63                if let Some(ref mut rem) = remaining {
64                    *rem -= res.registered_models.len() as i32;
65                }
66                let next_page_token = if remaining.is_some_and(|r| r <= 0) {
67                    None
68                } else {
69                    res.next_page_token.clone()
70                };
71                Ok((res, (builder, remaining), next_page_token))
72            },
73        )
74        .map_ok(|resp| futures::stream::iter(resp.registered_models.into_iter().map(Ok)))
75        .try_flatten();
76        stream.boxed()
77    }
78}
79impl IntoFuture for ListRegisteredModelsBuilder {
80    type Output = Result<ListRegisteredModelsResponse>;
81    type IntoFuture = BoxFut<'static, Self::Output>;
82    fn into_future(self) -> Self::IntoFuture {
83        let client = self.client;
84        let request = self.request;
85        Box::pin(async move { client.list_registered_models(&request).await })
86    }
87}
88/// Builder for creating a registered model
89pub struct CreateRegisteredModelBuilder {
90    client: RegisteredModelServiceClient,
91    request: CreateRegisteredModelRequest,
92}
93impl CreateRegisteredModelBuilder {
94    /// Create a new builder instance.
95    /// Obtain via the corresponding method on `RegisteredModelServiceClient`.
96    pub(crate) fn new(
97        client: RegisteredModelServiceClient,
98        name: impl Into<String>,
99        catalog_name: impl Into<String>,
100        schema_name: impl Into<String>,
101    ) -> Self {
102        let request = CreateRegisteredModelRequest {
103            name: name.into(),
104            catalog_name: catalog_name.into(),
105            schema_name: schema_name.into(),
106            ..Default::default()
107        };
108        Self { client, request }
109    }
110    /// User-provided free-form text description.
111    pub fn with_comment(mut self, comment: impl Into<Option<String>>) -> Self {
112        self.request.comment = comment.into();
113        self
114    }
115}
116impl IntoFuture for CreateRegisteredModelBuilder {
117    type Output = Result<RegisteredModel>;
118    type IntoFuture = BoxFut<'static, Self::Output>;
119    fn into_future(self) -> Self::IntoFuture {
120        let client = self.client;
121        let request = self.request;
122        Box::pin(async move { client.create_registered_model(&request).await })
123    }
124}
125/// Builder for getting a registered model
126pub struct GetRegisteredModelBuilder {
127    client: RegisteredModelServiceClient,
128    request: GetRegisteredModelRequest,
129}
130impl GetRegisteredModelBuilder {
131    /// Create a new builder instance.
132    /// Obtain via the corresponding method on `RegisteredModelServiceClient`.
133    pub(crate) fn new(client: RegisteredModelServiceClient, full_name: impl Into<String>) -> Self {
134        let request = GetRegisteredModelRequest {
135            full_name: full_name.into(),
136            ..Default::default()
137        };
138        Self { client, request }
139    }
140    /** Whether to include registered models in the response for which the principal
141    can 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 GetRegisteredModelBuilder {
148    type Output = Result<RegisteredModel>;
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_registered_model(&request).await })
154    }
155}
156/// Builder for updating a registered model
157pub struct UpdateRegisteredModelBuilder {
158    client: RegisteredModelServiceClient,
159    request: UpdateRegisteredModelRequest,
160}
161impl UpdateRegisteredModelBuilder {
162    /// Create a new builder instance.
163    /// Obtain via the corresponding method on `RegisteredModelServiceClient`.
164    pub(crate) fn new(client: RegisteredModelServiceClient, full_name: impl Into<String>) -> Self {
165        let request = UpdateRegisteredModelRequest {
166            full_name: full_name.into(),
167            ..Default::default()
168        };
169        Self { client, request }
170    }
171    /// New name for the registered model.
172    pub fn with_new_name(mut self, new_name: impl Into<Option<String>>) -> Self {
173        self.request.new_name = new_name.into();
174        self
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    /// Username of new owner of the registered model.
182    pub fn with_owner(mut self, owner: impl Into<Option<String>>) -> Self {
183        self.request.owner = owner.into();
184        self
185    }
186}
187impl IntoFuture for UpdateRegisteredModelBuilder {
188    type Output = Result<RegisteredModel>;
189    type IntoFuture = BoxFut<'static, Self::Output>;
190    fn into_future(self) -> Self::IntoFuture {
191        let client = self.client;
192        let request = self.request;
193        Box::pin(async move { client.update_registered_model(&request).await })
194    }
195}
196/// Builder for deleting a registered model
197pub struct DeleteRegisteredModelBuilder {
198    client: RegisteredModelServiceClient,
199    request: DeleteRegisteredModelRequest,
200}
201impl DeleteRegisteredModelBuilder {
202    /// Create a new builder instance.
203    /// Obtain via the corresponding method on `RegisteredModelServiceClient`.
204    pub(crate) fn new(client: RegisteredModelServiceClient, full_name: impl Into<String>) -> Self {
205        let request = DeleteRegisteredModelRequest {
206            full_name: full_name.into(),
207            ..Default::default()
208        };
209        Self { client, request }
210    }
211    /// Force deletion even if the registered model still has model versions.
212    pub fn with_force(mut self, force: impl Into<Option<bool>>) -> Self {
213        self.request.force = force.into();
214        self
215    }
216}
217impl IntoFuture for DeleteRegisteredModelBuilder {
218    type Output = Result<()>;
219    type IntoFuture = BoxFut<'static, Self::Output>;
220    fn into_future(self) -> Self::IntoFuture {
221        let client = self.client;
222        let request = self.request;
223        Box::pin(async move { client.delete_registered_model(&request).await })
224    }
225}
unitycatalog_client/codegen/registered_models/builders.rs

unitycatalog_client/codegen/registered_models/
builders.rs
