microsoft_cognitive_computer_vision/operations/
detect_objects.rs1use http_api_client_endpoint::{
4 http::{
5 header::{ACCEPT, CONTENT_TYPE},
6 Method,
7 },
8 Body, Endpoint, Request, Response, MIME_APPLICATION_JSON,
9};
10use serde::{Deserialize, Serialize};
11use url::Url;
12
13use crate::{
14 data_types::{
15 ImageInput, Metadata, ModelVersion, ModelVersionInput, Object, RequestId, SubscriptionKey,
16 },
17 operations::{
18 common::{endpoint_parse_response, EndpointError, EndpointRet},
19 MODEL_VERSION_QUERY_NAME, SUBSCRIPTION_KEY_HEADER_KEY_NAME,
20 },
21 EndpointUrl,
22};
23
24#[derive(Debug, Clone)]
28pub struct DetectObjects {
29 endpoint_url: EndpointUrl,
30 subscription_key: SubscriptionKey,
31 image: ImageInput,
32 model_version: Option<ModelVersionInput>,
33}
34impl DetectObjects {
35 pub fn new(
36 endpoint_url: EndpointUrl,
37 subscription_key: impl AsRef<str>,
38 image: ImageInput,
39 model_version: impl Into<Option<ModelVersionInput>>,
40 ) -> Self {
41 Self {
42 endpoint_url,
43 subscription_key: subscription_key.as_ref().to_owned(),
44 image,
45 model_version: model_version.into(),
46 }
47 }
48}
49
50impl Endpoint for DetectObjects {
51 type RenderRequestError = EndpointError;
52
53 type ParseResponseOutput = EndpointRet<DetectObjectsResponseBodyOkJson>;
54 type ParseResponseError = EndpointError;
55
56 fn render_request(&self) -> Result<Request<Body>, Self::RenderRequestError> {
57 let url = format!("{}vision/v3.2/detect", self.endpoint_url.url());
58 let mut url = Url::parse(&url).map_err(EndpointError::MakeRequestUrlFailed)?;
59
60 if let Some(model_version) = &self.model_version {
61 url.query_pairs_mut()
62 .append_pair(MODEL_VERSION_QUERY_NAME, model_version.to_string().as_str());
63 }
64
65 let (body, content_type) = self
66 .image
67 .to_request_body_and_content_type()
68 .map_err(EndpointError::ImageInputToRequestBodyFailed)?;
69
70 let request = Request::builder()
71 .method(Method::POST)
72 .uri(url.as_str())
73 .header(SUBSCRIPTION_KEY_HEADER_KEY_NAME, &self.subscription_key)
74 .header(CONTENT_TYPE, content_type)
75 .header(ACCEPT, MIME_APPLICATION_JSON)
76 .body(body)
77 .map_err(EndpointError::MakeRequestFailed)?;
78
79 Ok(request)
80 }
81
82 fn parse_response(
83 &self,
84 response: Response<Body>,
85 ) -> Result<Self::ParseResponseOutput, Self::ParseResponseError> {
86 endpoint_parse_response(response)
87 }
88}
89
90#[derive(Serialize, Deserialize, Debug, Clone)]
94#[serde(rename_all = "camelCase")]
95pub struct DetectObjectsResponseBodyOkJson {
96 pub objects: Vec<Object>,
97 pub request_id: RequestId,
98 pub metadata: Metadata,
99 pub model_version: ModelVersion,
100}
101
102#[cfg(test)]
103mod tests {
104 use super::*;
105
106 #[test]
107 fn de_response_body_ok_json() {
108 match serde_json::from_str::<DetectObjectsResponseBodyOkJson>(include_str!(
109 "../../tests/response_body_files/detect_objects_ok.json"
110 )) {
111 Ok(ok_json) => {
112 assert_eq!(ok_json.objects.len(), 2);
113 }
114 Err(err) => panic!("{}", err),
115 }
116 }
117}