Server Test Python

rev. 1661690c47759989ca94986fb8d3e5132fc72dc5 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test-python/json_rpc10/rust-server-codegen-python/src/error.rs

@@ -1186,1186 +1299,1297 @@

         match &self {
             NoInputAndNoOutputError::InternalServerError(_inner) => Some(_inner),
-1188
+        }
-1189
+    }
-1190
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::NoInputAndNoOutputError
-1193
+{
     fn from(variant: crate::error::InternalServerError) -> crate::error::NoInputAndNoOutputError {
         Self::InternalServerError(variant)
-1196
+    }
-1197
+}
-1198
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::NoInputAndNoOutputError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::NoInputAndNoOutputError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-1203
             crate::error::InternalServerError {
                 message: error.to_string(),

-1206
+            }
             .into()
         })
-1209
+    }
-1210
+}
 /// See [`InternalServerError`](crate::error::InternalServerError).
 pub mod internal_server_error {
-1213
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `InternalServerError`.
         MissingMessage,
-1220
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
-1225
+            }
-1226
+        }
-1227
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::InternalServerError {
         type Error = ConstraintViolation;
-1231
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1234
+        }
-1235
+    }
     /// A builder for [`InternalServerError`](crate::error::InternalServerError).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
-1240
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-1246
+        }
         /// Consumes the builder and constructs a [`InternalServerError`](crate::error::InternalServerError).
         ///
         /// The builder fails to construct a [`InternalServerError`](crate::error::InternalServerError) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(self) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-1253
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             Ok(crate::error::InternalServerError {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
-1260
+        }
-1261
+    }
-1262
+}
 /// See [`ValidationException`](crate::error::ValidationException).
 pub mod validation_exception {
-1265
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `ValidationException`.
         MissingMessage,
-1272
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationException`"),
-1277
+            }

↧ Expand context

-1278
+        }
-1279
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::ValidationException {
         type Error = ConstraintViolation;
-1283
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1286
+        }
-1287
+    }
     /// A builder for [`ValidationException`](crate::error::ValidationException).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
         pub(crate) field_list:
             ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
-1294
+    }
     impl Builder {
         /// A summary of the validation failure.
         pub fn message(mut self, input: ::std::string::String) -> Self {

tmp-codegen-diff/codegen-server-test-python/json_rpc10/rust-server-codegen-python/src/input.rs

@@ -853,853 +913,912 @@

↥ Expand context

         /// The builder fails to construct a [`OperationWithNestedStructureInput`](crate::input::OperationWithNestedStructureInput) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(
             self,
         ) -> Result<crate::input::OperationWithNestedStructureInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-860
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::OperationWithNestedStructureInput, ConstraintViolation> {
             Ok(crate::input::OperationWithNestedStructureInput {
                 top_level: self
                     .top_level
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::TopLevel))
                     .transpose()?

                     .ok_or(ConstraintViolation::MissingTopLevel)?,
             })
-875
+        }
-876
+    }
-877
+}
 /// See [`OperationWithNestedStructureInput`](crate::input::OperationWithNestedStructureInput).
 pub mod operation_with_nested_structure_input {
-880
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `top_level` was not provided but it is required when building `OperationWithNestedStructureInput`.
         MissingTopLevel,
-887
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTopLevel => write!(f, "`top_level` was not provided but it is required when building `OperationWithNestedStructureInput`"),
-892
+            }

↧ Expand context

-893
+        }
-894
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::input::OperationWithNestedStructureInput {
         type Error = ConstraintViolation;
-898
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-901
+        }
-902
+    }
     /// A builder for [`OperationWithNestedStructureInput`](crate::input::OperationWithNestedStructureInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) top_level: ::std::option::Option<crate::model::TopLevel>,
-907
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn top_level(mut self, input: crate::model::TopLevel) -> Self {
             self.top_level = Some(input);
             self

@@ -1441,1440 +1501,1499 @@

↥ Expand context

             input: impl ::std::convert::Into<::std::string::String>,
         ) -> Self {
             self.label = Some(input.into());
             self
-1444
+        }
         /// Consumes the builder and constructs a [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput).
         ///
         /// The builder fails to construct a [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,
         ) -> Result<crate::input::EndpointWithHostLabelOperationInput, ConstraintViolation>
-1452
+        {
             self.build_enforcing_all_constraints()
-1454
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::EndpointWithHostLabelOperationInput, ConstraintViolation>
-1458
+        {
             Ok(crate::input::EndpointWithHostLabelOperationInput {

                 label: self.label.ok_or(ConstraintViolation::MissingLabel)?,
             })
-1462
+        }
-1463
+    }
-1464
+}
 /// See [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput).
 pub mod endpoint_with_host_label_operation_input {
-1467
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `label` was not provided but it is required when building `EndpointWithHostLabelOperationInput`.
         MissingLabel,
-1474
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingLabel => write!(f, "`label` was not provided but it is required when building `EndpointWithHostLabelOperationInput`"),
-1479
+            }

↧ Expand context

-1480
+        }
-1481
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::input::EndpointWithHostLabelOperationInput {
         type Error = ConstraintViolation;
-1485
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1488
+        }
-1489
+    }
     /// A builder for [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) label: ::std::option::Option<::std::string::String>,
-1494
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn label(mut self, input: ::std::string::String) -> Self {
             self.label = Some(input);
             self

tmp-codegen-diff/codegen-server-test-python/json_rpc10/rust-server-codegen-python/src/model.rs

@@ -1469,1469 +1529,1528 @@

↥ Expand context

-1469
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-1472
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-1475
+    }
-1476
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ComplexNestedErrorData> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ComplexNestedErrorData>().map(Box::new)
-1480
+    }
-1481
+}
-1482
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ComplexNestedErrorData> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-1486
+    }
-1487
+}
 impl ComplexNestedErrorData {

     /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::model::ComplexNestedErrorData).
     pub fn builder() -> crate::model::complex_nested_error_data::Builder {
         crate::model::complex_nested_error_data::Builder::default()
-1492
+    }
-1493
+}
 /// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).
 pub mod validation_exception_field {
-1496
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `path` was not provided but it is required when building `ValidationExceptionField`.
         MissingPath,
         /// `message` was not provided but it is required when building `ValidationExceptionField`.
         MissingMessage,
-1505
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {

↧ Expand context

                 ConstraintViolation::MissingPath => write!(f, "`path` was not provided but it is required when building `ValidationExceptionField`"),
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationExceptionField`"),
-1511
+            }
-1512
+        }
-1513
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::ValidationExceptionField {
         type Error = ConstraintViolation;
-1517
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1520
+        }
-1521
+    }
     /// A builder for [`ValidationExceptionField`](crate::model::ValidationExceptionField).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) path: ::std::option::Option<::std::string::String>,
         pub(crate) message: ::std::option::Option<::std::string::String>,
-1527
+    }
     impl Builder {

@@ -1813,1812 +1873,1871 @@

↥ Expand context

-1812
+        }
         /// Consumes the builder and constructs a [`TopLevel`](crate::model::TopLevel).
         ///
         /// The builder fails to construct a [`TopLevel`](crate::model::TopLevel) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::model::TopLevel, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-1819
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::TopLevel, ConstraintViolation> {
             Ok(crate::model::TopLevel {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),

                 ),
             })
-1834
+        }
-1835
+    }
-1836
+}
 /// See [`TopLevel`](crate::model::TopLevel).
 pub mod top_level {
-1839
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `dialog` was not provided but it is required when building `TopLevel`.
         MissingDialog,
-1846
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingDialog => write!(
                     f,

↧ Expand context

                     "`dialog` was not provided but it is required when building `TopLevel`"
                 ),
-1854
+            }
-1855
+        }
-1856
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::TopLevel {
         type Error = ConstraintViolation;
-1860
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1863
+        }
-1864
+    }
     /// A builder for [`TopLevel`](crate::model::TopLevel).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) dialog: ::std::option::Option<crate::model::Dialog>,
         pub(crate) dialog_list: ::std::option::Option<::std::vec::Vec<crate::model::Dialog>>,
         pub(crate) dialog_map: ::std::option::Option<
             ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,

tmp-codegen-diff/codegen-server-test-python/json_rpc10/rust-server-codegen-python/src/operation.rs

@@ -27,27 +87,86 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28
+    }
-29
+}
-30
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::OperationWithNestedStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-43
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = OperationWithNestedStructureInputFuture;
-46

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHNESTEDSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-54
+            }
             crate::protocol_serde::shape_operation_with_nested_structure::de_operation_with_nested_structure_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OperationWithNestedStructureInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-67
+        }
-68
+    }
-69
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::OperationWithNestedStructureOutput
-74
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_nested_structure::ser_operation_with_nested_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-81
+                        }
-82
+                    }
-83
+    }
-84
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -130,129 +190,188 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-130
+    }
-131
+}
-132
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::OperationWithRequiredMembersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-141
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-145
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = OperationWithRequiredMembersInputFuture;
-148

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHREQUIREDMEMBERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-156
+            }
             crate::protocol_serde::shape_operation_with_required_members::de_operation_with_required_members_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OperationWithRequiredMembersInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-169
+        }
-170
+    }
-171
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::OperationWithRequiredMembersOutput
-176
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_required_members::ser_operation_with_required_members_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-183
+                        }
-184
+                    }
-185
+    }
-186
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -233,231 +293,290 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-232
+    }
-233
+}
-234
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::OperationWithDefaultsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-243
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-247
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = OperationWithDefaultsInputFuture;
-250

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHDEFAULTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-258
+            }
             crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OperationWithDefaultsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-271
+        }
-272
+    }
-273
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::OperationWithDefaultsOutput
-278
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-285
+                        }
-286
+                    }
-287
+    }
-288
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -336,333 +396,392 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-334
+    }
-335
+}
-336
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::ContentTypeParametersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-345
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-349
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = ContentTypeParametersInputFuture;
-352

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONTENTTYPEPARAMETERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-360
+            }
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         ContentTypeParametersInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-373
+        }
-374
+    }
-375
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::ContentTypeParametersOutput
-380
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-387
+                        }
-388
+                    }
-389
+    }
-390
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -439,435 +499,494 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-436
+    }
-437
+}
-438
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::PutWithContentEncodingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-447
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-451
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = PutWithContentEncodingInputFuture;
-454

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTWITHCONTENTENCODING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-462
+            }
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         PutWithContentEncodingInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-475
+        }
-476
+    }
-477
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::PutWithContentEncodingOutput
-482
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-489
+                        }
-490
+                    }
-491
+    }
-492
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -542,537 +602,596 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-538
+    }
-539
+}
-540
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::HostWithPathOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-549
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-553
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = HostWithPathOperationInputFuture;
-556

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HOSTWITHPATHOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-564
+            }
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         HostWithPathOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-577
+        }
-578
+    }
-579
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::HostWithPathOperationOutput
-584
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-591
+                        }
-592
+                    }
-593
+    }
-594
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -645,639 +705,698 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-640
+    }
-641
+}
-642
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::EndpointWithHostLabelOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-651
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-655
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EndpointWithHostLabelOperationInputFuture;
-658

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-666
+            }
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EndpointWithHostLabelOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-679
+        }
-680
+    }
-681
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::EndpointWithHostLabelOperationOutput
-686
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-693
+                        }
-694
+                    }
-695
+    }
-696
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -750,743 +810,802 @@

↥ Expand context

-743
+}
-744
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::EndpointOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-753
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-757
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EndpointOperationInputFuture;
-760
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-768
+            }
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
                 request,
-771
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EndpointOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-783
+        }
-784
+    }
-785
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::EndpointOperationOutput
-790
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,

@@ -869,861 +931,921 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-864
+    }
-865
+}
-866
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::JsonUnionsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-875
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-879
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = JsonUnionsInputFuture;
-882
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONUNIONS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-890
+            }
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         JsonUnionsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-902
+        }
-903
+    }
-904
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::JsonUnionsOutput
-909
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-921
+                )

@@ -990,980 +1050,1039 @@

↥ Expand context

-980
+}
-981
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::GreetingWithErrorsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-990
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-994
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = GreetingWithErrorsInputFuture;
-997
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GREETINGWITHERRORS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1005
+            }
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
-1008
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         GreetingWithErrorsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1020
+        }
-1021
+    }
-1022
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::GreetingWithErrorsOutput
-1027
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1034
+                        }
-1035
+                    }
-1036
+    }
-1037
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1103,1092 +1163,1151 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1093
+    }
-1094
+}
-1095
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::SimpleScalarPropertiesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1104
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1108
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = SimpleScalarPropertiesInputFuture;
-1111

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1119
+            }
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         SimpleScalarPropertiesInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1132
+        }
-1133
+    }
-1134
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::SimpleScalarPropertiesOutput
-1139
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1146
+                        }
-1147
+                    }
-1148
+    }
-1149
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1206,1194 +1266,1253 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1195
+    }
-1196
+}
-1197
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::EmptyInputAndEmptyOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1206
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1210
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EmptyInputAndEmptyOutputInputFuture;
-1213

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYINPUTANDEMPTYOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1221
+            }
             crate::protocol_serde::shape_empty_input_and_empty_output::de_empty_input_and_empty_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EmptyInputAndEmptyOutputInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1234
+        }
-1235
+    }
-1236
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::EmptyInputAndEmptyOutputOutput
-1241
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_input_and_empty_output::ser_empty_input_and_empty_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1248
+                        }
-1249
+                    }
-1250
+    }
-1251
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1311,1298 +1371,1357 @@

↥ Expand context

-1298
+}
-1299
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::NoInputAndOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1308
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1312
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = NoInputAndOutputInputFuture;
-1315
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NOINPUTANDOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1323
+            }
             crate::protocol_serde::shape_no_input_and_output::de_no_input_and_output_http_request(
                 request,
-1326
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         NoInputAndOutputInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1338
+        }
-1339
+    }
-1340
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::NoInputAndOutputOutput
-1345
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_output::ser_no_input_and_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1352
+                        }
-1353
+                    }
-1354
+    }
-1355
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1424,1410 +1484,1469 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1411
+    }
-1412
+}
-1413
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::NoInputAndNoOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1422
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1426
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = NoInputAndNoOutputInputFuture;
-1429

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NOINPUTANDNOOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1437
+            }
             crate::protocol_serde::shape_no_input_and_no_output::de_no_input_and_no_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         NoInputAndNoOutputInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1450
+        }
-1451
+    }
-1452
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::NoInputAndNoOutputOutput
-1457
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_no_output::ser_no_input_and_no_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1464
+                        }
-1465
+                    }
-1466
+    }
-1467
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

tmp-codegen-diff/codegen-server-test-python/json_rpc10/rust-server-codegen-python/src/output.rs

@@ -1091,1091 +1151,1150 @@

↥ Expand context

-1091
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-1094
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-1097
+    }
-1098
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<NoInputAndNoOutputOutput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<NoInputAndNoOutputOutput>().map(Box::new)
-1102
+    }
-1103
+}
-1104
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<NoInputAndNoOutputOutput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-1108
+    }
-1109
+}
 impl NoInputAndNoOutputOutput {

     /// Creates a new builder-style object to manufacture [`NoInputAndNoOutputOutput`](crate::output::NoInputAndNoOutputOutput).
     pub fn builder() -> crate::output::no_input_and_no_output_output::Builder {
         crate::output::no_input_and_no_output_output::Builder::default()
-1114
+    }
-1115
+}
 /// See [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
 pub mod operation_with_nested_structure_output {
-1118
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `dialog` was not provided but it is required when building `OperationWithNestedStructureOutput`.
         MissingDialog,
-1125
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingDialog => write!(f, "`dialog` was not provided but it is required when building `OperationWithNestedStructureOutput`"),
-1130
+            }

↧ Expand context

-1131
+        }
-1132
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::output::OperationWithNestedStructureOutput {
         type Error = ConstraintViolation;
-1136
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1139
+        }
-1140
+    }
     /// A builder for [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) dialog: ::std::option::Option<crate::model::Dialog>,
         pub(crate) dialog_list: ::std::option::Option<::std::vec::Vec<crate::model::Dialog>>,
         pub(crate) dialog_map: ::std::option::Option<
             ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
         >,
-1149
+    }
     impl Builder {

@@ -1173,1172 +1233,1231 @@

↥ Expand context

         ///
         pub fn build(
             self,
         ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
-1176
+        {
             self.build_enforcing_required_and_enum_traits()
-1178
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
-1182
+        {
             Ok(crate::output::OperationWithNestedStructureOutput {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),

                 ),
             })
-1194
+        }
-1195
+    }
-1196
+}
 /// See [`OperationWithRequiredMembersOutput`](crate::output::OperationWithRequiredMembersOutput).
 pub mod operation_with_required_members_output {
-1199
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `required_string` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredString,
         /// `required_boolean` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredBoolean,
         /// `required_list` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredList,
         /// `required_timestamp` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredTimestamp,

↧ Expand context

         /// `required_blob` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredBlob,
         /// `required_byte` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredByte,
         /// `required_short` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredShort,
         /// `required_integer` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredInteger,
         /// `required_long` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredLong,
         /// `required_float` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredFloat,
         /// `required_double` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredDouble,
         /// `required_map` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredMap,
-1228
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/src/error.rs

@@ -1524,1524 +1637,1635 @@

↥ Expand context

 impl ::std::error::Error for EmptyOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             EmptyOperationError::InternalServerError(_inner) => Some(_inner),
-1528
+        }
-1529
+    }
-1530
+}
 impl ::std::convert::From<crate::error::InternalServerError> for crate::error::EmptyOperationError {
     fn from(variant: crate::error::InternalServerError) -> crate::error::EmptyOperationError {
         Self::InternalServerError(variant)
-1534
+    }
-1535
+}
-1536
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::EmptyOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::EmptyOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-1541
             crate::error::InternalServerError {
                 message: error.to_string(),

-1544
+            }
             .into()
         })
-1547
+    }
-1548
+}
 /// See [`InternalServerError`](crate::error::InternalServerError).
 pub mod internal_server_error {
-1551
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `InternalServerError`.
         MissingMessage,
-1558
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
-1563
+            }
-1564
+        }
-1565
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::InternalServerError {
         type Error = ConstraintViolation;
-1569
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1572
+        }
-1573
+    }
     /// A builder for [`InternalServerError`](crate::error::InternalServerError).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
-1578
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-1584
+        }
         /// Consumes the builder and constructs a [`InternalServerError`](crate::error::InternalServerError).
         ///
         /// The builder fails to construct a [`InternalServerError`](crate::error::InternalServerError) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(self) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-1591
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             Ok(crate::error::InternalServerError {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
-1598
+        }
-1599
+    }
-1600
+}
 /// See [`ValidationException`](crate::error::ValidationException).
 pub mod validation_exception {
-1603
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `ValidationException`.
         MissingMessage,
-1610
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationException`"),
-1615
+            }

↧ Expand context

-1616
+        }
-1617
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::ValidationException {
         type Error = ConstraintViolation;
-1621
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1624
+        }
-1625
+    }
     /// A builder for [`ValidationException`](crate::error::ValidationException).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
         pub(crate) field_list:
             ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
-1632
+    }
     impl Builder {
         /// A summary of the validation failure.
         pub fn message(mut self, input: ::std::string::String) -> Self {

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/src/input.rs

@@ -1695,1695 +1755,1754 @@

↥ Expand context

             input: impl ::std::convert::Into<::std::string::String>,
         ) -> Self {
             self.label = Some(input.into());
             self
-1699
+        }
         /// Consumes the builder and constructs a [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput).
         ///
         /// The builder fails to construct a [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(
             self,
         ) -> Result<crate::input::EndpointWithHostLabelOperationInput, ConstraintViolation>
-1707
+        {
             self.build_enforcing_all_constraints()
-1709
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::EndpointWithHostLabelOperationInput, ConstraintViolation>
-1713
+        {
             Ok(crate::input::EndpointWithHostLabelOperationInput {

                 label: self.label.ok_or(ConstraintViolation::MissingLabel)?,
             })
-1717
+        }
-1718
+    }
-1719
+}
 /// See [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput).
 pub mod endpoint_with_host_label_operation_input {
-1722
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `label` was not provided but it is required when building `EndpointWithHostLabelOperationInput`.
         MissingLabel,
-1729
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingLabel => write!(f, "`label` was not provided but it is required when building `EndpointWithHostLabelOperationInput`"),
-1734
+            }

↧ Expand context

-1735
+        }
-1736
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::input::EndpointWithHostLabelOperationInput {
         type Error = ConstraintViolation;
-1740
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1743
+        }
-1744
+    }
     /// A builder for [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) label: ::std::option::Option<::std::string::String>,
-1749
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn label(mut self, input: ::std::string::String) -> Self {
             self.label = Some(input);
             self

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/src/model.rs

@@ -1299,1299 +1359,1358 @@

↥ Expand context

-1299
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-1302
+    }
-1303
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<EmptyStruct> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<EmptyStruct>().map(Box::new)
-1307
+    }
-1308
+}
-1309
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EmptyStruct> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-1313
+    }
-1314
+}
 impl crate::constrained::Constrained for crate::model::EmptyStruct {
     type Unconstrained = crate::model::empty_struct_internal::Builder;
-1317
+}
 impl EmptyStruct {

     /// Creates a new builder-style object to manufacture [`EmptyStruct`](crate::model::EmptyStruct).
     pub fn builder() -> crate::model::empty_struct::Builder {
         crate::model::empty_struct::Builder::default()
-1322
+    }
-1323
+}
 /// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).
 pub mod validation_exception_field {
-1326
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `path` was not provided but it is required when building `ValidationExceptionField`.
         MissingPath,
         /// `message` was not provided but it is required when building `ValidationExceptionField`.
         MissingMessage,
-1335
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {

↧ Expand context

                 ConstraintViolation::MissingPath => write!(f, "`path` was not provided but it is required when building `ValidationExceptionField`"),
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationExceptionField`"),
-1341
+            }
-1342
+        }
-1343
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::ValidationExceptionField {
         type Error = ConstraintViolation;
-1347
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1350
+        }
-1351
+    }
     /// A builder for [`ValidationExceptionField`](crate::model::ValidationExceptionField).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) path: ::std::option::Option<::std::string::String>,
         pub(crate) message: ::std::option::Option<::std::string::String>,
-1357
+    }
     impl Builder {

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/src/operation.rs

@@ -27,27 +87,86 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28
+    }
-29
+}
-30
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::ContentTypeParametersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-43
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = ContentTypeParametersInputFuture;
-46

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONTENTTYPEPARAMETERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-54
+            }
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         ContentTypeParametersInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-67
+        }
-68
+    }
-69
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::ContentTypeParametersOutput
-74
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-81
+                        }
-82
+                    }
-83
+    }
-84
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -130,129 +190,188 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-130
+    }
-131
+}
-132
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::PutWithContentEncodingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-141
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-145
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = PutWithContentEncodingInputFuture;
-148

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTWITHCONTENTENCODING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-156
+            }
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         PutWithContentEncodingInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-169
+        }
-170
+    }
-171
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::PutWithContentEncodingOutput
-176
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-183
+                        }
-184
+                    }
-185
+    }
-186
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -235,233 +295,292 @@

↥ Expand context

-233
+}
-234
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::FractionalSecondsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-243
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-247
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = FractionalSecondsInputFuture;
-250
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_FRACTIONALSECONDS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-258
+            }
             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(
                 request,
-261
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         FractionalSecondsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-273
+        }
-274
+    }
-275
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::FractionalSecondsOutput
-280
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,

@@ -356,353 +416,412 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-354
+    }
-355
+}
-356
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::DatetimeOffsetsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-365
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-369
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = DatetimeOffsetsInputFuture;
-372

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DATETIMEOFFSETS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-380
+            }
             crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         DatetimeOffsetsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-393
+        }
-394
+    }
-395
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::DatetimeOffsetsOutput
-400
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,

@@ -476,472 +536,531 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-473
+    }
-474
+}
-475
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::HostWithPathOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-484
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-488
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = HostWithPathOperationInputFuture;
-491

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HOSTWITHPATHOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-499
+            }
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         HostWithPathOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-512
+        }
-513
+    }
-514
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::HostWithPathOperationOutput
-519
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-526
+                        }
-527
+                    }
-528
+    }
-529
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -579,574 +639,633 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-575
+    }
-576
+}
-577
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::EndpointWithHostLabelOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-586
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-590
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EndpointWithHostLabelOperationInputFuture;
-593

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-601
+            }
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EndpointWithHostLabelOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-614
+        }
-615
+    }
-616
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::EndpointWithHostLabelOperationOutput
-621
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-628
+                        }
-629
+                    }
-630
+    }
-631
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -684,678 +744,737 @@

↥ Expand context

-678
+}
-679
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::EndpointOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-688
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-692
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EndpointOperationInputFuture;
-695
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-703
+            }
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
                 request,
-706
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EndpointOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-718
+        }
-719
+    }
-720
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::EndpointOperationOutput
-725
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,

@@ -803,796 +865,856 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-799
+    }
-800
+}
-801
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::JsonUnionsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-810
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-814
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = JsonUnionsInputFuture;
-817
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONUNIONS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-825
+            }
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         JsonUnionsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-837
+        }
-838
+    }
-839
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::JsonUnionsOutput
-844
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-856
+                )

@@ -924,915 +984,974 @@

↥ Expand context

-915
+}
-916
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::GreetingWithErrorsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-925
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-929
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = GreetingWithErrorsInputFuture;
-932
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GREETINGWITHERRORS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-940
+            }
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
-943
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         GreetingWithErrorsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-955
+        }
-956
+    }
-957
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::GreetingWithErrorsOutput
-962
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-969
+                        }
-970
+                    }
-971
+    }
-972
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1037,1027 +1097,1086 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1028
+    }
-1029
+}
-1030
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::SparseNullsOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1039
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1043
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = SparseNullsOperationInputFuture;
-1046

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SPARSENULLSOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1054
+            }
             crate::protocol_serde::shape_sparse_nulls_operation::de_sparse_nulls_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         SparseNullsOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1067
+        }
-1068
+    }
-1069
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::SparseNullsOperationOutput
-1074
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_nulls_operation::ser_sparse_nulls_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1081
+                        }
-1082
+                    }
-1083
+    }
-1084
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1140,1129 +1200,1188 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1130
+    }
-1131
+}
-1132
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::NullOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1141
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1145
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = NullOperationInputFuture;
-1148

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NULLOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1156
+            }
             crate::protocol_serde::shape_null_operation::de_null_operation_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         NullOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1169
+        }
-1170
+    }
-1171
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::NullOperationOutput
-1176
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_null_operation::ser_null_operation_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-1188
+                )

@@ -1254,1242 +1316,1302 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1245
+    }
-1246
+}
-1247
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::JsonEnumsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1256
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1260
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = JsonEnumsInputFuture;
-1263
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONENUMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1271
+            }
             crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         JsonEnumsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1283
+        }
-1284
+    }
-1285
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::JsonEnumsOutput
-1290
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_enums::ser_json_enums_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-1302
+                )

@@ -1373,1359 +1433,1418 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1360
+    }
-1361
+}
-1362
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::PutAndGetInlineDocumentsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1371
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1375
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = PutAndGetInlineDocumentsInputFuture;
-1378

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTANDGETINLINEDOCUMENTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1386
+            }
             crate::protocol_serde::shape_put_and_get_inline_documents::de_put_and_get_inline_documents_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         PutAndGetInlineDocumentsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1399
+        }
-1400
+    }
-1401
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::PutAndGetInlineDocumentsOutput
-1406
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_and_get_inline_documents::ser_put_and_get_inline_documents_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1413
+                        }
-1414
+                    }
-1415
+    }
-1416
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1476,1461 +1536,1520 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1462
+    }
-1463
+}
-1464
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::OperationWithOptionalInputOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1473
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1477
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = OperationWithOptionalInputOutputInputFuture;
-1480

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHOPTIONALINPUTOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1488
+            }
             crate::protocol_serde::shape_operation_with_optional_input_output::de_operation_with_optional_input_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OperationWithOptionalInputOutputInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1501
+        }
-1502
+    }
-1503
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::OperationWithOptionalInputOutputOutput
-1508
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_optional_input_output::ser_operation_with_optional_input_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1515
+                        }
-1516
+                    }
-1517
+    }
-1518
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1579,1563 +1639,1622 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1564
+    }
-1565
+}
-1566
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::SimpleScalarPropertiesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1575
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1579
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = SimpleScalarPropertiesInputFuture;
-1582

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1590
+            }
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         SimpleScalarPropertiesInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1603
+        }
-1604
+    }
-1605
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::SimpleScalarPropertiesOutput
-1610
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1617
+                        }
-1618
+                    }
-1619
+    }
-1620
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1682,1665 +1742,1724 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1666
+    }
-1667
+}
-1668
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::KitchenSinkOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1677
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1681
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = KitchenSinkOperationInputFuture;
-1684

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_KITCHENSINKOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1692
+            }
             crate::protocol_serde::shape_kitchen_sink_operation::de_kitchen_sink_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         KitchenSinkOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1705
+        }
-1706
+    }
-1707
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::KitchenSinkOperationOutput
-1712
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_kitchen_sink_operation::ser_kitchen_sink_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1719
+                        }
-1720
+                    }
-1721
+    }
-1722
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1785,1767 +1845,1826 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1768
+    }
-1769
+}
-1770
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::EmptyOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1779
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1783
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EmptyOperationInputFuture;
-1786

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1794
+            }
             crate::protocol_serde::shape_empty_operation::de_empty_operation_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EmptyOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1807
+        }
-1808
+    }
-1809
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::EmptyOperationOutput
-1814
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_operation::ser_empty_operation_http_response(self)
-1817
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/src/error.rs

@@ -502,502 +615,613 @@

↥ Expand context

-502
+        }
-503
+    }
-504
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::TypeComplexityOperationError
-507
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::TypeComplexityOperationError {
         Self::InternalServerError(variant)
-512
+    }
-513
+}
-514
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::TypeComplexityOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::TypeComplexityOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-519
             crate::error::InternalServerError {
                 message: error.to_string(),

-522
+            }
             .into()
         })
-525
+    }
-526
+}
 /// See [`InternalServerError`](crate::error::InternalServerError).
 pub mod internal_server_error {
-529
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `InternalServerError`.
         MissingMessage,
-536
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
-541
+            }
-542
+        }
-543
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::InternalServerError {
         type Error = ConstraintViolation;
-547
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-550
+        }
-551
+    }
     /// A builder for [`InternalServerError`](crate::error::InternalServerError).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
-556
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-562
+        }
         /// Consumes the builder and constructs a [`InternalServerError`](crate::error::InternalServerError).
         ///
         /// The builder fails to construct a [`InternalServerError`](crate::error::InternalServerError) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(self) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-569
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             Ok(crate::error::InternalServerError {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
-576
+        }
-577
+    }
-578
+}
 /// See [`ValidationException`](crate::error::ValidationException).
 pub mod validation_exception {
-581
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `ValidationException`.
         MissingMessage,
-588
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationException`"),
-593
+            }

↧ Expand context

-594
+        }
-595
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::ValidationException {
         type Error = ConstraintViolation;
-599
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-602
+        }
-603
+    }
     /// A builder for [`ValidationException`](crate::error::ValidationException).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
         pub(crate) field_list:
             ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
-610
+    }
     impl Builder {
         /// A summary of the validation failure.
         pub fn message(mut self, input: ::std::string::String) -> Self {

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/src/input.rs

@@ -604,604 +664,663 @@

↥ Expand context

-604
+        {
             self.build_enforcing_all_constraints()
-606
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::RequiredHeaderCollectionOperationInput, ConstraintViolation>
-610
+        {
             Ok(crate::input::RequiredHeaderCollectionOperationInput {
                 required_header_list: self
                     .required_header_list
                     .ok_or(ConstraintViolation::MissingRequiredHeaderList)?,
                 required_header_set: self
                     .required_header_set
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::RequiredHeaderSet))
                     .transpose()?
                     .map(|v: crate::model::HeaderSet| v.into())

                     .ok_or(ConstraintViolation::MissingRequiredHeaderSet)?,
             })
-626
+        }
-627
+    }
-628
+}
 /// See [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
 pub mod required_header_collection_operation_input {
-631
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         MissingRequiredHeaderList,
         /// `required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         MissingRequiredHeaderSet,
-640
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {

↧ Expand context

                 ConstraintViolation::MissingRequiredHeaderList => write!(f, "`required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
                 ConstraintViolation::MissingRequiredHeaderSet => write!(f, "`required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
-646
+            }
-647
+        }
-648
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::input::RequiredHeaderCollectionOperationInput {
         type Error = ConstraintViolation;
-652
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-655
+        }
-656
+    }
     /// A builder for [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) required_header_list:
             ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         pub(crate) required_header_set:
             ::std::option::Option<::std::vec::Vec<::std::string::String>>,

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/src/model.rs

@@ -577,577 +637,636 @@

↥ Expand context

-577
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-580
+    }
-581
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<EmptyStructure> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<EmptyStructure>().map(Box::new)
-585
+    }
-586
+}
-587
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EmptyStructure> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-591
+    }
-592
+}
 impl crate::constrained::Constrained for crate::model::EmptyStructure {
     type Unconstrained = crate::model::empty_structure_internal::Builder;
-595
+}
 impl EmptyStructure {

     /// Creates a new builder-style object to manufacture [`EmptyStructure`](crate::model::EmptyStructure).
     pub fn builder() -> crate::model::empty_structure::Builder {
         crate::model::empty_structure::Builder::default()
-600
+    }
-601
+}
 /// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).
 pub mod validation_exception_field {
-604
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `path` was not provided but it is required when building `ValidationExceptionField`.
         MissingPath,
         /// `message` was not provided but it is required when building `ValidationExceptionField`.
         MissingMessage,
-613
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {

↧ Expand context

                 ConstraintViolation::MissingPath => write!(f, "`path` was not provided but it is required when building `ValidationExceptionField`"),
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationExceptionField`"),
-619
+            }
-620
+        }
-621
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::ValidationExceptionField {
         type Error = ConstraintViolation;
-625
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-628
+        }
-629
+    }
     /// A builder for [`ValidationExceptionField`](crate::model::ValidationExceptionField).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) path: ::std::option::Option<::std::string::String>,
         pub(crate) message: ::std::option::Option<::std::string::String>,
-635
+    }
     impl Builder {

@@ -778,777 +838,836 @@

↥ Expand context

         /// Consumes the builder and constructs a [`InnerShape`](crate::model::InnerShape).
         ///
         /// The builder fails to construct a [`InnerShape`](crate::model::InnerShape) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(self) -> Result<crate::model::InnerShape, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-784
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::InnerShape, ConstraintViolation> {
             Ok(crate::model::InnerShape {
                 required_inner_most_shape: self
                     .required_inner_most_shape
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::RequiredInnerMostShape))
                     .transpose()?

                     .ok_or(ConstraintViolation::MissingRequiredInnerMostShape)?,
             })
-799
+        }
-800
+    }
-801
+}
 /// See [`InnerShape`](crate::model::InnerShape).
 pub mod inner_shape {
-804
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `required_inner_most_shape` was not provided but it is required when building `InnerShape`.
         MissingRequiredInnerMostShape,
-811
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingRequiredInnerMostShape => write!(f, "`required_inner_most_shape` was not provided but it is required when building `InnerShape`"),
-816
+            }

↧ Expand context

-817
+        }
-818
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::InnerShape {
         type Error = ConstraintViolation;
-822
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-825
+        }
-826
+    }
     /// A builder for [`InnerShape`](crate::model::InnerShape).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) required_inner_most_shape: ::std::option::Option<crate::model::InnermostShape>,
-831
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn required_inner_most_shape(mut self, input: crate::model::InnermostShape) -> Self {
             self.required_inner_most_shape = Some(input);
             self

@@ -1149,1147 +1209,1206 @@

↥ Expand context

                 an_int: self.an_int.ok_or(ConstraintViolation::MissingAnInt)?,
                 a_long: self.a_long.ok_or(ConstraintViolation::MissingALong)?,
                 a_float: self.a_float.ok_or(ConstraintViolation::MissingAFloat)?,
                 a_double: self.a_double.ok_or(ConstraintViolation::MissingADouble)?,
                 a_timestamp: self
                     .a_timestamp
                     .ok_or(ConstraintViolation::MissingATimestamp)?,
                 a_document: self
                     .a_document
                     .ok_or(ConstraintViolation::MissingADocument)?,
                 a_string_list: self
                     .a_string_list
                     .ok_or(ConstraintViolation::MissingAStringList)?,
                 a_string_map: self
                     .a_string_map
                     .ok_or(ConstraintViolation::MissingAStringMap)?,
                 a_string_set: self
                     .a_string_set
                     .ok_or(ConstraintViolation::MissingAStringSet)?,
                 a_blob: self.a_blob.ok_or(ConstraintViolation::MissingABlob)?,

                 a_union: self.a_union.ok_or(ConstraintViolation::MissingAUnion)?,
             })
-1169
+        }
-1170
+    }
-1171
+}
 /// See [`InnermostShape`](crate::model::InnermostShape).
 pub mod innermost_shape {
-1174
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `a_string` was not provided but it is required when building `InnermostShape`.
         MissingAString,
         /// `a_boolean` was not provided but it is required when building `InnermostShape`.
         MissingABoolean,
         /// `a_byte` was not provided but it is required when building `InnermostShape`.
         MissingAByte,
         /// `a_short` was not provided but it is required when building `InnermostShape`.
         MissingAShort,

↧ Expand context

         /// `an_int` was not provided but it is required when building `InnermostShape`.
         MissingAnInt,
         /// `a_long` was not provided but it is required when building `InnermostShape`.
         MissingALong,
         /// `a_float` was not provided but it is required when building `InnermostShape`.
         MissingAFloat,
         /// `a_double` was not provided but it is required when building `InnermostShape`.
         MissingADouble,
         /// `a_timestamp` was not provided but it is required when building `InnermostShape`.
         MissingATimestamp,
         /// `a_document` was not provided but it is required when building `InnermostShape`.
         MissingADocument,
         /// `a_string_list` was not provided but it is required when building `InnermostShape`.
         MissingAStringList,
         /// `a_string_map` was not provided but it is required when building `InnermostShape`.
         MissingAStringMap,
         /// `a_string_set` was not provided but it is required when building `InnermostShape`.
         MissingAStringSet,
         /// `a_blob` was not provided but it is required when building `InnermostShape`.
         MissingABlob,

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/src/operation.rs

@@ -22,22 +82,81 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ResponseCodeDefaultOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ResponseCodeDefaultOperationInputFuture;
-41

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RESPONSECODEDEFAULTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_response_code_default_operation::de_response_code_default_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-59
+                )
             },
         );

↧ Expand context

         ResponseCodeDefaultOperationInputFuture {
             inner: Box::pin(fut),
-64
+        }
-65
+    }
-66
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ResponseCodeDefaultOperationOutput
-71
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_default_operation::ser_response_code_default_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-78
+                        }
-79
+                    }
-80
+    }
-81
+}

@@ -122,121 +182,180 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-122
+    }
-123
+}
-124
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ResponseCodeHttpFallbackOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-133
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-137
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ResponseCodeHttpFallbackOperationInputFuture;
-140

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RESPONSECODEHTTPFALLBACKOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-148
+            }
             crate::protocol_serde::shape_response_code_http_fallback_operation::de_response_code_http_fallback_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-158
+                )
             },
         );

↧ Expand context

         ResponseCodeHttpFallbackOperationInputFuture {
             inner: Box::pin(fut),
-163
+        }
-164
+    }
-165
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ResponseCodeHttpFallbackOperationOutput
-170
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_http_fallback_operation::ser_response_code_http_fallback_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-177
+                        }
-178
+                    }
-179
+    }
-180
+}

@@ -222,220 +282,279 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-221
+    }
-222
+}
-223
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ResponseCodeRequiredOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-232
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-236
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ResponseCodeRequiredOperationInputFuture;
-239

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RESPONSECODEREQUIREDOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-247
+            }
             crate::protocol_serde::shape_response_code_required_operation::de_response_code_required_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-257
+                )
             },
         );

↧ Expand context

         ResponseCodeRequiredOperationInputFuture {
             inner: Box::pin(fut),
-262
+        }
-263
+    }
-264
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ResponseCodeRequiredOperationOutput
-269
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_required_operation::ser_response_code_required_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-276
+                        }
-277
+                    }
-278
+    }
-279
+}

@@ -322,319 +382,378 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-320
+    }
-321
+}
-322
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RequiredHeaderCollectionOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-331
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-335
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RequiredHeaderCollectionOperationInputFuture;
-338

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_REQUIREDHEADERCOLLECTIONOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-346
+            }
             crate::protocol_serde::shape_required_header_collection_operation::de_required_header_collection_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-356
+                )
             },
         );

↧ Expand context

         RequiredHeaderCollectionOperationInputFuture {
             inner: Box::pin(fut),
-361
+        }
-362
+    }
-363
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RequiredHeaderCollectionOperationOutput
-368
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_required_header_collection_operation::ser_required_header_collection_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-375
+                        }
-376
+                    }
-377
+    }
-378
+}

@@ -422,418 +482,477 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-419
+    }
-420
+}
-421
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RequiredInnerShapeOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-430
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-434
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RequiredInnerShapeOperationInputFuture;
-437

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_REQUIREDINNERSHAPEOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-445
+            }
             crate::protocol_serde::shape_required_inner_shape_operation::de_required_inner_shape_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-455
+                )
             },
         );

↧ Expand context

         RequiredInnerShapeOperationInputFuture {
             inner: Box::pin(fut),
-460
+        }
-461
+    }
-462
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RequiredInnerShapeOperationOutput
-467
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_required_inner_shape_operation::ser_required_inner_shape_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-474
+                        }
-475
+                    }
-476
+    }
-477
+}

@@ -522,517 +582,576 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-518
+    }
-519
+}
-520
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TypeComplexityOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-529
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-533
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TypeComplexityOperationInputFuture;
-536

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TYPECOMPLEXITYOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-544
+            }
             crate::protocol_serde::shape_type_complexity_operation::de_type_complexity_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-554
+                )
             },
         );

↧ Expand context

         TypeComplexityOperationInputFuture {
             inner: Box::pin(fut),
-559
+        }
-560
+    }
-561
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TypeComplexityOperationOutput
-566
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_type_complexity_operation::ser_type_complexity_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-573
+                        }
-574
+                    }
-575
+    }
-576
+}

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/src/output.rs

@@ -368,368 +487,485 @@

↥ Expand context

-368
+    }
-369
+}
 /// See [`ResponseCodeHttpFallbackOperationOutput`](crate::output::ResponseCodeHttpFallbackOperationOutput).
 pub mod response_code_http_fallback_operation_output {
-372
     impl ::std::convert::From<Builder> for crate::output::ResponseCodeHttpFallbackOperationOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-376
+        }
-377
+    }
     /// A builder for [`ResponseCodeHttpFallbackOperationOutput`](crate::output::ResponseCodeHttpFallbackOperationOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`ResponseCodeHttpFallbackOperationOutput`](crate::output::ResponseCodeHttpFallbackOperationOutput).
         pub fn build(self) -> crate::output::ResponseCodeHttpFallbackOperationOutput {
             self.build_enforcing_required_and_enum_traits()
-385
+        }
         fn build_enforcing_required_and_enum_traits(
             self,

         ) -> crate::output::ResponseCodeHttpFallbackOperationOutput {
             crate::output::ResponseCodeHttpFallbackOperationOutput {}
-390
+        }
-391
+    }
-392
+}
 /// See [`ResponseCodeRequiredOperationOutput`](crate::output::ResponseCodeRequiredOperationOutput).
 pub mod response_code_required_operation_output {
-395
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `response_code` was not provided but it is required when building `ResponseCodeRequiredOperationOutput`.
         MissingResponseCode,
-402
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingResponseCode => write!(f, "`response_code` was not provided but it is required when building `ResponseCodeRequiredOperationOutput`"),
-407
+            }
-408
+        }
-409
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::output::ResponseCodeRequiredOperationOutput {
         type Error = ConstraintViolation;
-413
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-416
+        }
-417
+    }
     /// A builder for [`ResponseCodeRequiredOperationOutput`](crate::output::ResponseCodeRequiredOperationOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) response_code: ::std::option::Option<i32>,
-422
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn response_code(mut self, input: i32) -> Self {
             self.response_code = Some(input);
             self
-428
+        }
         /// Consumes the builder and constructs a [`ResponseCodeRequiredOperationOutput`](crate::output::ResponseCodeRequiredOperationOutput).
         ///
         /// The builder fails to construct a [`ResponseCodeRequiredOperationOutput`](crate::output::ResponseCodeRequiredOperationOutput) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(
             self,
         ) -> Result<crate::output::ResponseCodeRequiredOperationOutput, ConstraintViolation>
-436
+        {
             self.build_enforcing_required_and_enum_traits()
-438
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::output::ResponseCodeRequiredOperationOutput, ConstraintViolation>
-442
+        {
             Ok(crate::output::ResponseCodeRequiredOperationOutput {
                 response_code: self
                     .response_code
                     .ok_or(ConstraintViolation::MissingResponseCode)?,
             })
-448
+        }
-449
+    }
-450
+}
 /// See [`RequiredHeaderCollectionOperationOutput`](crate::output::RequiredHeaderCollectionOperationOutput).
 pub mod required_header_collection_operation_output {
-453
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationOutput`.
         MissingRequiredHeaderList,
         /// `required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationOutput`.
         MissingRequiredHeaderSet,
-462
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {

↧ Expand context

                 ConstraintViolation::MissingRequiredHeaderList => write!(f, "`required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationOutput`"),
                 ConstraintViolation::MissingRequiredHeaderSet => write!(f, "`required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationOutput`"),
-468
+            }
-469
+        }
-470
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::output::RequiredHeaderCollectionOperationOutput {
         type Error = ConstraintViolation;
-474
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-477
+        }
-478
+    }
     /// A builder for [`RequiredHeaderCollectionOperationOutput`](crate::output::RequiredHeaderCollectionOperationOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) required_header_list:
             ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         pub(crate) required_header_set:
             ::std::option::Option<::std::vec::Vec<::std::string::String>>,

tmp-codegen-diff/codegen-server-test-python/naming_test_casing/rust-server-codegen-python/src/error.rs

@@ -84,84 +144,143 @@

↥ Expand context

     pub fn message(&self) -> &str {
         &self.message
-86
+    }
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "InternalServerError"
-91
+    }
-92
+}
 impl ::std::fmt::Display for InternalServerError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "InternalServerError")?;
-96
+        {
             ::std::write!(f, ": {}", &self.message)?;
-98
+        }
         Ok(())
-100
+    }
-101
+}
 impl ::std::error::Error for InternalServerError {}
 impl InternalServerError {

     /// Creates a new builder-style object to manufacture [`InternalServerError`](crate::error::InternalServerError).
     pub fn builder() -> crate::error::internal_server_error::Builder {
         crate::error::internal_server_error::Builder::default()
-107
+    }
-108
+}
 /// See [`InternalServerError`](crate::error::InternalServerError).
 pub mod internal_server_error {
-111
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `InternalServerError`.
         MissingMessage,
-118
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
-123
+            }

↧ Expand context

-124
+        }
-125
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::InternalServerError {
         type Error = ConstraintViolation;
-129
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-132
+        }
-133
+    }
     /// A builder for [`InternalServerError`](crate::error::InternalServerError).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
-138
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self

tmp-codegen-diff/codegen-server-test-python/naming_test_casing/rust-server-codegen-python/src/operation.rs

@@ -24,24 +86,84 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-27
+    }
-28
+}
-29
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::DoNothingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = DoNothingInputFuture;
-45
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DONOTHING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-53
+            }
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         DoNothingInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-65
+        }
-66
+    }
-67
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::DoNothingOutput
-72
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_do_nothing::ser_do_nothing_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-84
+                )

Pages: 1 2 3 4