Skip to main content

unitycatalog_client/codegen/model_versions/
client.rs

1// @generated — do not edit by hand.
2#![allow(unused_imports)]
3use crate::Result;
4use olai_http::CloudClient;
5use unitycatalog_common::models::model_versions::v1::*;
6use url::Url;
7/// HTTP client for service operations
8#[derive(Clone)]
9pub struct ModelVersionServiceClient {
10    pub(crate) client: CloudClient,
11    pub(crate) base_url: Url,
12}
13impl ModelVersionServiceClient {
14    /// Create a new client instance
15    pub fn new(client: CloudClient, mut base_url: Url) -> Self {
16        if !base_url.path().ends_with('/') {
17            base_url.set_path(&format!("{}/", base_url.path()));
18        }
19        Self { client, base_url }
20    }
21    /// List model versions
22    ///
23    /// List the model versions of the specified registered model. If the caller is
24    /// the metastore admin, all model versions are returned. Otherwise, the caller
25    /// must have the appropriate privileges on the parent model.
26    pub async fn list_model_versions(
27        &self,
28        request: &ListModelVersionsRequest,
29    ) -> Result<ListModelVersionsResponse> {
30        let formatted_path = format!("models/{}/versions", request.full_name);
31        let mut url = self.base_url.join(&formatted_path)?;
32        if let Some(ref value) = request.max_results {
33            url.query_pairs_mut()
34                .append_pair("max_results", &value.to_string());
35        }
36        if let Some(ref value) = request.page_token {
37            url.query_pairs_mut()
38                .append_pair("page_token", &value.to_string());
39        }
40        if let Some(ref value) = request.include_browse {
41            url.query_pairs_mut()
42                .append_pair("include_browse", &value.to_string());
43        }
44        let response = self.client.get(url).send().await?;
45        if !response.status().is_success() {
46            return Err(crate::error::parse_error_response(response).await);
47        }
48        let result = response.bytes().await?;
49        Ok(serde_json::from_slice(&result)?)
50    }
51    /// Create a model version
52    ///
53    /// Creates a new model version in PENDING_REGISTRATION status. The server
54    /// assigns the version number and a storage location for the artifacts. The
55    /// caller must be a metastore admin or the owner of the parent registered model.
56    pub async fn create_model_version(
57        &self,
58        request: &CreateModelVersionRequest,
59    ) -> Result<ModelVersion> {
60        let url = self.base_url.join("models/versions")?;
61        let response = self.client.post(url).json(request).send().await?;
62        if !response.status().is_success() {
63            return Err(crate::error::parse_error_response(response).await);
64        }
65        let result = response.bytes().await?;
66        Ok(serde_json::from_slice(&result)?)
67    }
68    /// Get a model version
69    ///
70    /// Gets a model version by its parent model name and version number.
71    pub async fn get_model_version(
72        &self,
73        request: &GetModelVersionRequest,
74    ) -> Result<ModelVersion> {
75        let formatted_path = format!("models/{}/versions/{}", request.full_name, request.version);
76        let mut url = self.base_url.join(&formatted_path)?;
77        if let Some(ref value) = request.include_browse {
78            url.query_pairs_mut()
79                .append_pair("include_browse", &value.to_string());
80        }
81        let response = self.client.get(url).send().await?;
82        if !response.status().is_success() {
83            return Err(crate::error::parse_error_response(response).await);
84        }
85        let result = response.bytes().await?;
86        Ok(serde_json::from_slice(&result)?)
87    }
88    /// Update a model version
89    ///
90    /// Updates the model version that matches the supplied name and version.
91    pub async fn update_model_version(
92        &self,
93        request: &UpdateModelVersionRequest,
94    ) -> Result<ModelVersion> {
95        let formatted_path = format!("models/{}/versions/{}", request.full_name, request.version);
96        let url = self.base_url.join(&formatted_path)?;
97        let response = self.client.patch(url).json(request).send().await?;
98        if !response.status().is_success() {
99            return Err(crate::error::parse_error_response(response).await);
100        }
101        let result = response.bytes().await?;
102        Ok(serde_json::from_slice(&result)?)
103    }
104    /// Delete a model version
105    ///
106    /// Deletes the model version that matches the supplied name and version. For the
107    /// deletion to succeed, the caller must be the owner of the parent registered
108    /// model.
109    pub async fn delete_model_version(&self, request: &DeleteModelVersionRequest) -> Result<()> {
110        let formatted_path = format!("models/{}/versions/{}", request.full_name, request.version);
111        let url = self.base_url.join(&formatted_path)?;
112        let response = self.client.delete(url).send().await?;
113        if !response.status().is_success() {
114            return Err(crate::error::parse_error_response(response).await);
115        }
116        Ok(())
117    }
118    /// Finalize a model version
119    ///
120    /// Transitions a model version to READY once all artifacts have been written to
121    /// its storage location.
122    pub async fn finalize_model_version(
123        &self,
124        request: &FinalizeModelVersionRequest,
125    ) -> Result<ModelVersion> {
126        let formatted_path = format!(
127            "models/{}/versions/{}/finalize",
128            request.full_name, request.version
129        );
130        let url = self.base_url.join(&formatted_path)?;
131        let response = self.client.patch(url).json(request).send().await?;
132        if !response.status().is_success() {
133            return Err(crate::error::parse_error_response(response).await);
134        }
135        let result = response.bytes().await?;
136        Ok(serde_json::from_slice(&result)?)
137    }
138}