unitycatalog_client/codegen/registered_models/
builders.rs

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

unitycatalog_client/codegen/registered_models/
builders.rs
