Server Test Python

rev. 0b749be6d000fdc7ef59d1bc26f1dce00358d95c

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/lib.rs

@@ -134,134 +252,232 @@

 //! ) -> Output {
 //!     todo!()
 //! }
 //! ```
 //!
 //! See the [`operation module`](::aws_smithy_http_server::operation) for information on precisely what constitutes a handler.
 //!
 //! ## Build
 //!
 //! You can convert [`RestJsonExtrasBuilder`] into [`RestJsonExtras`] using either [`RestJsonExtrasBuilder::build`] or [`RestJsonExtrasBuilder::build_unchecked`].
 //!
 //! [`RestJsonExtrasBuilder::build`] requires you to provide a handler for every single operation in your Smithy model. It will return an error if that is not the case.
 //!
 //! [`RestJsonExtrasBuilder::build_unchecked`], instead, does not require exhaustiveness. The server will automatically return 500 Internal Server Error to all requests for operations that do not have a registered handler.
 //! [`RestJsonExtrasBuilder::build_unchecked`] is particularly useful if you are deploying your Smithy service as a collection of Lambda functions, where each Lambda is only responsible for a subset of the operations in the Smithy service (or even a single one!).
 //!
 //! # Example
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;

 //! use rest_json_extras::{RestJsonExtras, RestJsonExtrasConfig};
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = RestJsonExtrasConfig::builder().build();
 //!    let app = RestJsonExtras::builder(config)
 //!        .case_insensitive_error_operation(case_insensitive_error_operation)
 //!        .empty_struct_with_content_on_wire_op(empty_struct_with_content_on_wire_op)
 //!        .enum_query(enum_query)
 //!        .escaped_string_values(escaped_string_values)
 //!        .http_enum_payload2(http_enum_payload2)
 //!        .http_payload_traits2(http_payload_traits2)
 //!        .http_string_payload2(http_string_payload2)
 //!        .malformed_content_type_with_body2(malformed_content_type_with_body2)
 //!        .map_with_enum_key_op(map_with_enum_key_op)
 //!        .null_in_non_sparse(null_in_non_sparse)
 //!        .primitive_int_header(primitive_int_header)
 //!        .primitive_int_op(primitive_int_op)
 //!        .query_precedence(query_precedence)
 //!        .status_response(status_response)
 //!        .string_payload(string_payload)
 //!        .build()
 //!        .expect("failed to build an instance of RestJsonExtras");
 //!
 //!    let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!        .expect("unable to parse the server bind address and port");
 //!    let server = ::hyper::Server::bind(&bind).serve(app.into_make_service());
 //!    # let server = async { Ok::<_, ()>(()) };
 //!
 //!    // Run your service!
 //!    if let Err(err) = server.await {
 //!        eprintln!("server error: {:?}", err);
 //!    }
 //! }
 //!
 //! use rest_json_extras::{input, output, error};
 //!
 //! async fn case_insensitive_error_operation(input: input::CaseInsensitiveErrorOperationInput) -> Result<output::CaseInsensitiveErrorOperationOutput, error::CaseInsensitiveErrorOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn empty_struct_with_content_on_wire_op(input: input::EmptyStructWithContentOnWireOpInput) -> Result<output::EmptyStructWithContentOnWireOpOutput, error::EmptyStructWithContentOnWireOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn enum_query(input: input::EnumQueryInput) -> Result<output::EnumQueryOutput, error::EnumQueryError> {
 //!     todo!()
 //! }
 //!
 //! async fn escaped_string_values(input: input::EscapedStringValuesInput) -> Result<output::EscapedStringValuesOutput, error::EscapedStringValuesError> {
 //!     todo!()
 //! }
 //!
 //! async fn http_enum_payload2(input: input::HttpEnumPayload2Input) -> Result<output::HttpEnumPayload2Output, error::HttpEnumPayload2Error> {
 //!     todo!()
 //! }
 //!
 //! async fn http_payload_traits2(input: input::HttpPayloadTraits2Input) -> Result<output::HttpPayloadTraits2Output, error::HttpPayloadTraits2Error> {
 //!     todo!()
 //! }
 //!
 //! async fn http_string_payload2(input: input::HttpStringPayload2Input) -> Result<output::HttpStringPayload2Output, error::HttpStringPayload2Error> {
 //!     todo!()
 //! }
 //!
 //! async fn malformed_content_type_with_body2(input: input::MalformedContentTypeWithBody2Input) -> Result<output::MalformedContentTypeWithBody2Output, error::MalformedContentTypeWithBody2Error> {
 //!     todo!()
 //! }
 //!
 //! async fn map_with_enum_key_op(input: input::MapWithEnumKeyOpInput) -> Result<output::MapWithEnumKeyOpOutput, error::MapWithEnumKeyOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn null_in_non_sparse(input: input::NullInNonSparseInput) -> Result<output::NullInNonSparseOutput, error::NullInNonSparseError> {
 //!     todo!()
 //! }
 //!
 //! async fn primitive_int_header(input: input::PrimitiveIntHeaderInput) -> Result<output::PrimitiveIntHeaderOutput, error::PrimitiveIntHeaderError> {
 //!     todo!()

↧ Expand context

 //! }
 //!
 //! async fn primitive_int_op(input: input::PrimitiveIntOpInput) -> Result<output::PrimitiveIntOpOutput, error::PrimitiveIntOpError> {
 //!     todo!()
 //! }
 //!
 //! async fn query_precedence(input: input::QueryPrecedenceInput) -> Result<output::QueryPrecedenceOutput, error::QueryPrecedenceError> {
 //!     todo!()
 //! }
 //!
 //! async fn status_response(input: input::StatusResponseInput) -> Result<output::StatusResponseOutput, error::StatusResponseError> {
 //!     todo!()
 //! }
 //!
 //! async fn string_payload(input: input::StringPayloadInput) -> Result<output::StringPayloadOutput, error::StringPayloadError> {
 //!     todo!()
 //! }
 //!
 //! ```
 //!

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

@@ -1,1 +31,138 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[::pyo3::pyclass]
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct EmptyStruct {}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl EmptyStruct {
     #[new]
     pub fn new() -> Self {
         Self {}
-+
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-+
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-+
+    }
-+
+}
 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)
-+
+    }
-+
+}
-+
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EmptyStruct> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-+
+    }
-+
+}
 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()
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum SingleElementUnion {
     #[allow(missing_docs)] // documentation missing in model
     A(::std::string::String),
-+
+}
 impl SingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_a(&self) -> ::std::result::Result<&::std::string::String, &Self> {
         if let SingleElementUnion::A(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-+
+        }
-+
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     pub fn is_a(&self) -> bool {
         self.as_a().is_ok()
-+
+    }
-+
+}
 #[pyo3::pyclass(name = "SingleElementUnion")]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct PyUnionMarkerSingleElementUnion(pub SingleElementUnion);
 #[::pyo3::pymethods]
 impl PyUnionMarkerSingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     #[staticmethod]
     /// Creates a new union instance of [`A`](crate::model::SingleElementUnion::A)
     /// :param data str:
     /// :rtype SingleElementUnion:
     pub fn a(data: ::std::string::String) -> Self {
         Self(SingleElementUnion::A(data))
-+
+    }
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// :rtype str:
     pub fn as_a(&self) -> ::pyo3::PyResult<::std::string::String> {
         match self.0.as_a() {
             Ok(variant) => Ok(variant.clone()),
             Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(
                 r"SingleElementUnion variant is not of type str",
             )),
-+
+        }
-+
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     /// :rtype bool:
     pub fn is_a(&self) -> bool {
         self.0.is_a()
-+
+    }
-+
+}
 impl ::pyo3::IntoPy<::pyo3::PyObject> for SingleElementUnion {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         PyUnionMarkerSingleElementUnion(self).into_py(py)
-+
+    }
-+
+}
 impl<'source> ::pyo3::FromPyObject<'source> for SingleElementUnion {
     fn extract(obj: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         let data: PyUnionMarkerSingleElementUnion = obj.extract()?;
         Ok(data.0)
-+
+    }
-+
+}
-+
 #[::pyo3::pyclass]
 /// :param path str:
 /// :param message str:
 /// :rtype None:
 /// Describes one specific validation failure for an input member.
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ValidationExceptionField {
     #[pyo3(get, set)]

↧ Expand context

     /// :type str:
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub path: ::std::string::String,
     #[pyo3(get, set)]
     /// :type str:
     /// A detailed description of the validation failure.
     pub message: ::std::string::String,
-126
+}
 impl ValidationExceptionField {
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub fn path(&self) -> &str {
         use std::ops::Deref;
         self.path.deref()
-132
+    }
     /// A detailed description of the validation failure.
     pub fn message(&self) -> &str {
         use std::ops::Deref;
         self.message.deref()
-137
+    }
-138
+}

@@ -46,153 +448,469 @@

↥ Expand context

-153
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ValidationExceptionField> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ValidationExceptionField>().map(Box::new)
-157
+    }
-158
+}
-159
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ValidationExceptionField> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-163
+    }
-164
+}
 impl ValidationExceptionField {
     /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
     pub fn builder() -> crate::model::validation_exception_field::Builder {
         crate::model::validation_exception_field::Builder::default()
-169
+    }
-170
+}
-171
 #[::pyo3::pyclass]

 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone,
     ::std::cmp::Eq,
     ::std::cmp::Ord,
     ::std::cmp::PartialEq,
     ::std::cmp::PartialOrd,
     ::std::fmt::Debug,
     ::std::hash::Hash,
 )]
 pub enum StringEnum {
 pub enum EnumWithEscapedChars {
     /// this needs#tobe escaped
     HasQuotes,
     #[allow(missing_docs)] // documentation missing in model
     V,
     Normal,
-188
+}
 ///
 pub(crate) mod string_enum_internal {
 pub(crate) mod enum_with_escaped_chars_internal {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-193
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#StringEnum' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#
                 r#"Value provided for 'aws.protocoltests.restjson#EnumWithEscapedChars' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#
-199
+            )
-200
+        }
-201
+    }
-202
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#,
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#,
                     &path
                 ),
                 path,
-215
+            }
-216
+        }
-217
+    }
-218
+}
 impl ::std::convert::TryFrom<&str> for StringEnum {
     type Error = crate::model::string_enum_internal::ConstraintViolation;
 impl ::std::convert::TryFrom<&str> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "enumvalue" => Ok(StringEnum::V),
             _ => Err(crate::model::string_enum_internal::ConstraintViolation(
                 s.to_owned(),
             )),
             "has\"quotes" => Ok(EnumWithEscapedChars::HasQuotes),
             "normal" => Ok(EnumWithEscapedChars::Normal),
             _ => Err(
                 crate::model::enum_with_escaped_chars_internal::ConstraintViolation(s.to_owned()),
             ),
-230
+        }
-231
+    }
-232
+}
 impl ::std::convert::TryFrom<::std::string::String> for StringEnum {
     type Error = crate::model::string_enum_internal::ConstraintViolation;
 impl ::std::convert::TryFrom<::std::string::String> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-238
+    {
         s.as_str().try_into()
-240
+    }
-241
+}
 impl std::str::FromStr for StringEnum {
     type Err = crate::model::string_enum_internal::ConstraintViolation;
 impl std::str::FromStr for EnumWithEscapedChars {
     type Err = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-246
+    }
-247
+}
 impl StringEnum {
 impl EnumWithEscapedChars {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             StringEnum::V => "enumvalue",
             EnumWithEscapedChars::HasQuotes => "has\"quotes",
             EnumWithEscapedChars::Normal => "normal",
-254
+        }
-255
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["enumvalue"]
         &["has\"quotes", "normal"]
-259
+    }
-260
+}
 impl ::std::convert::AsRef<str> for StringEnum {
 impl ::std::convert::AsRef<str> for EnumWithEscapedChars {
     fn as_ref(&self) -> &str {
         self.as_str()
-264
+    }
-265
+}
 #[::pyo3::pymethods]
 impl StringEnum {
 impl EnumWithEscapedChars {
     #[getter]
     pub fn name(&self) -> &str {
         match self {
             StringEnum::V => "V",
             EnumWithEscapedChars::HasQuotes => "HasQuotes",
             EnumWithEscapedChars::Normal => "Normal",
-273
+        }
-274
+    }
     #[getter]
     pub fn value(&self) -> &str {
         self.as_str()
-278
+    }
     fn __repr__(&self) -> String {
         self.as_str().to_owned()
-281
+    }
     fn __str__(&self) -> String {
         self.as_str().to_owned()
-284
+    }
-285
+}
 impl crate::constrained::Constrained for StringEnum {
 impl crate::constrained::Constrained for EnumWithEscapedChars {
     type Unconstrained = ::std::string::String;
-288
+}
-289
 impl ::std::convert::From<::std::string::String>
     for crate::constrained::MaybeConstrained<crate::model::StringEnum>
     for crate::constrained::MaybeConstrained<crate::model::EnumWithEscapedChars>
-292
+{
     fn from(value: ::std::string::String) -> Self {
         Self::Unconstrained(value)
-295
+    }
-296
+}
-297
 #[::pyo3::pyclass]
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct EmptyStruct {}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl EmptyStruct {
     #[new]
     pub fn new() -> Self {
         Self {}
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 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)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EmptyStruct> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 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()
--
+    }
--
+}
--
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum SingleElementUnion {
     #[allow(missing_docs)] // documentation missing in model
     A(::std::string::String),
--
+}
 impl SingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_a(&self) -> ::std::result::Result<&::std::string::String, &Self> {
         if let SingleElementUnion::A(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
--
+        }
--
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     pub fn is_a(&self) -> bool {
         self.as_a().is_ok()
--
+    }
--
+}
 #[pyo3::pyclass(name = "SingleElementUnion")]
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct PyUnionMarkerSingleElementUnion(pub SingleElementUnion);
 #[::pyo3::pymethods]
 impl PyUnionMarkerSingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     #[staticmethod]
     /// Creates a new union instance of [`A`](crate::model::SingleElementUnion::A)
     /// :param data str:
     /// :rtype SingleElementUnion:
     pub fn a(data: ::std::string::String) -> Self {
         Self(SingleElementUnion::A(data))
--
+    }
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// :rtype str:
     pub fn as_a(&self) -> ::pyo3::PyResult<::std::string::String> {
         match self.0.as_a() {
             Ok(variant) => Ok(variant.clone()),
             Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(
                 r"SingleElementUnion variant is not of type str",
             )),
--
+        }
--
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     /// :rtype bool:
     pub fn is_a(&self) -> bool {
         self.0.is_a()
--
+    }
--
+}
 impl ::pyo3::IntoPy<::pyo3::PyObject> for SingleElementUnion {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         PyUnionMarkerSingleElementUnion(self).into_py(py)
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source> for SingleElementUnion {
     fn extract(obj: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         let data: PyUnionMarkerSingleElementUnion = obj.extract()?;
         Ok(data.0)
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone,
     ::std::cmp::Eq,
     ::std::cmp::Ord,
     ::std::cmp::PartialEq,
     ::std::cmp::PartialOrd,
     ::std::fmt::Debug,
     ::std::hash::Hash,
 )]
 pub enum EnumWithEscapedChars {
     /// this needs#tobe escaped
     HasQuotes,
 pub enum StringEnum {
     #[allow(missing_docs)] // documentation missing in model
     Normal,
     V,
-312
+}
 ///
 pub(crate) mod enum_with_escaped_chars_internal {
 pub(crate) mod string_enum_internal {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-317
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#EnumWithEscapedChars' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#
                 r#"Value provided for 'aws.protocoltests.restjson#StringEnum' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#
-323
+            )
-324
+        }
-325
+    }
-326
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#,
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#,
                     &path
                 ),
                 path,
-339
+            }
-340
+        }
-341
+    }
-342
+}
 impl ::std::convert::TryFrom<&str> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
 impl ::std::convert::TryFrom<&str> for StringEnum {
     type Error = crate::model::string_enum_internal::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "has\"quotes" => Ok(EnumWithEscapedChars::HasQuotes),
             "normal" => Ok(EnumWithEscapedChars::Normal),
             _ => Err(
                 crate::model::enum_with_escaped_chars_internal::ConstraintViolation(s.to_owned()),
             ),
             "enumvalue" => Ok(StringEnum::V),
             _ => Err(crate::model::string_enum_internal::ConstraintViolation(
                 s.to_owned(),
             )),
-353
+        }
-354
+    }
-355
+}
 impl ::std::convert::TryFrom<::std::string::String> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
 impl ::std::convert::TryFrom<::std::string::String> for StringEnum {
     type Error = crate::model::string_enum_internal::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-361
+    {
         s.as_str().try_into()
-363
+    }
-364
+}
 impl std::str::FromStr for EnumWithEscapedChars {
     type Err = crate::model::enum_with_escaped_chars_internal::ConstraintViolation;
 impl std::str::FromStr for StringEnum {
     type Err = crate::model::string_enum_internal::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-369
+    }
-370
+}
 impl EnumWithEscapedChars {
 impl StringEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             EnumWithEscapedChars::HasQuotes => "has\"quotes",
             EnumWithEscapedChars::Normal => "normal",
             StringEnum::V => "enumvalue",
-376
+        }
-377
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["has\"quotes", "normal"]
         &["enumvalue"]
-381
+    }
-382
+}
 impl ::std::convert::AsRef<str> for EnumWithEscapedChars {
 impl ::std::convert::AsRef<str> for StringEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-386
+    }
-387
+}
 #[::pyo3::pymethods]
 impl EnumWithEscapedChars {
 impl StringEnum {
     #[getter]
     pub fn name(&self) -> &str {
         match self {
             EnumWithEscapedChars::HasQuotes => "HasQuotes",
             EnumWithEscapedChars::Normal => "Normal",
             StringEnum::V => "V",
-394
+        }
-395
+    }
     #[getter]
     pub fn value(&self) -> &str {
         self.as_str()
-399
+    }
     fn __repr__(&self) -> String {
         self.as_str().to_owned()
-402
+    }
     fn __str__(&self) -> String {
         self.as_str().to_owned()
-405
+    }
-406
+}
 impl crate::constrained::Constrained for EnumWithEscapedChars {
 impl crate::constrained::Constrained for StringEnum {
     type Unconstrained = ::std::string::String;
-409
+}
-410
 impl ::std::convert::From<::std::string::String>
     for crate::constrained::MaybeConstrained<crate::model::EnumWithEscapedChars>
     for crate::constrained::MaybeConstrained<crate::model::StringEnum>
-413
+{
     fn from(value: ::std::string::String) -> Self {
         Self::Unconstrained(value)
-416
+    }
-417
+}
 /// See [`EmptyStruct`](crate::model::EmptyStruct).
 ///
 pub mod empty_struct {
-421
     impl ::std::convert::From<Builder> for crate::model::EmptyStruct {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`EmptyStruct`](crate::model::EmptyStruct).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`EmptyStruct`](crate::model::EmptyStruct).
         pub fn build(self) -> crate::model::EmptyStruct {
             self.build_enforcing_required_and_enum_traits()
-+
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::model::EmptyStruct {
             crate::model::EmptyStruct {}
-+
+        }
-+
+    }
-+
+}
 /// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).
 ///
 pub mod validation_exception_field {
-443
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
-446
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `path` was not provided but it is required when building `ValidationExceptionField`.

↧ Expand context

         MissingPath,
         /// `message` was not provided but it is required when building `ValidationExceptionField`.
         MissingMessage,
-453
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 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`"),
-459
+            }
-460
+        }
-461
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::ValidationExceptionField {
         type Error = ConstraintViolation;
-465
         fn try_from(builder: Builder) -> Result<Self, Self::Error> {
             builder.build()
-468
+        }
-469
+    }

@@ -453,474 +534,533 @@

↥ Expand context

         pub(crate) message: ::std::option::Option<::std::string::String>,
-475
+    }
     impl Builder {
         /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
         pub fn path(mut self, input: ::std::string::String) -> Self {
             self.path = Some(input);
             self
-481
+        }
         /// A detailed description of the validation failure.
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-486
+        }
         /// Consumes the builder and constructs a [`ValidationExceptionField`](crate::model::ValidationExceptionField).
         ///
         /// The builder fails to construct a [`ValidationExceptionField`](crate::model::ValidationExceptionField) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(self) -> Result<crate::model::ValidationExceptionField, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-493
+        }

         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::model::ValidationExceptionField, ConstraintViolation> {
             Ok(crate::model::ValidationExceptionField {
                 path: self.path.ok_or(ConstraintViolation::MissingPath)?,
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
-501
+        }
-502
+    }
-503
+}
 /// See [`EmptyStruct`](crate::model::EmptyStruct).
 ///
 pub mod empty_struct {
--
     impl ::std::convert::From<Builder> for crate::model::EmptyStruct {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`EmptyStruct`](crate::model::EmptyStruct).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`EmptyStruct`](crate::model::EmptyStruct).
         pub fn build(self) -> crate::model::EmptyStruct {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::model::EmptyStruct {
             crate::model::EmptyStruct {}
--
+        }
--
+    }
--
+}
 ///
 pub(crate) mod map_with_enum_key_internal {
-506
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub(crate) enum ConstraintViolation {
         #[doc(hidden)]
         Key(crate::model::string_enum_internal::ConstraintViolation),
-512
+    }
-513

↧ Expand context

     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 Self::Key(key_constraint_violation) => write!(f, "{}", key_constraint_violation),
-518
+            }
-519
+        }
-520
+    }
-521
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 Self::Key(key_constraint_violation) => {
                     key_constraint_violation.as_validation_exception_field(path)
-531
+                }
-532
+            }
-533
+        }

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

@@ -1,1 +454,31 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 static CONTENT_TYPE_HTTPSTRINGPAYLOAD2: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input) using modelled bindings.
     pub struct HttpStringPayload2InputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpStringPayload2Input, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpStringPayload2InputFuture {
     type Output = Result<
         crate::input::HttpStringPayload2Input,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
--
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
--
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpStringPayload2Input
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpStringPayload2InputFuture;
--
     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_HTTPSTRINGPAYLOAD2,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_string_payload2::de_http_string_payload2_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,
--
+                )
             },
         );
         HttpStringPayload2InputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpStringPayload2Output
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_string_payload2::ser_http_string_payload2_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))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpStringPayload2Error
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_string_payload2::ser_http_string_payload2_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 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))
--
+            }
--
+        }
--
+    }
--
+}
--
 static CONTENT_TYPE_HTTPENUMPAYLOAD2: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input) using modelled bindings.
     pub struct HttpEnumPayload2InputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpEnumPayload2Input, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpEnumPayload2InputFuture {
     type Output = Result<
         crate::input::HttpEnumPayload2Input,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
--
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
--
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpEnumPayload2Input
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpEnumPayload2InputFuture;
--
     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_HTTPENUMPAYLOAD2,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_enum_payload2::de_http_enum_payload2_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,
--
+                )
             },
         );
         HttpEnumPayload2InputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpEnumPayload2Output
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_enum_payload2::ser_http_enum_payload2_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))
--
+            }
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpEnumPayload2Error
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_enum_payload2::ser_http_enum_payload2_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 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))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHBODY2: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithBody2Input`](crate::input::MalformedContentTypeWithBody2Input) using modelled bindings.
     pub struct MalformedContentTypeWithBody2InputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithBody2Input, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedContentTypeWithBody2InputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithBody2Input,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
--
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
--
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithBody2Input
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithBody2InputFuture;
--
     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_MALFORMEDCONTENTTYPEWITHBODY2,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_content_type_with_body2::de_malformed_content_type_with_body2_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,
--
+                )
             },
         );
         MalformedContentTypeWithBody2InputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithBody2Output
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_body2::ser_malformed_content_type_with_body2_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))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedContentTypeWithBody2Error
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_body2::ser_malformed_content_type_with_body2_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
--
+            }
--
+        }
--
+    }
--
+}
--
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadTraits2Input`](crate::input::HttpPayloadTraits2Input) using modelled bindings.
     pub struct HttpPayloadTraits2InputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraits2Input, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpPayloadTraits2InputFuture {
     type Output = Result<
         crate::input::HttpPayloadTraits2Input,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
--
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
--
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadTraits2Input
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadTraits2InputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_http_payload_traits2::de_http_payload_traits2_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,
--
+                )
             },
         );
         HttpPayloadTraits2InputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadTraits2Output
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits2::ser_http_payload_traits2_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))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpPayloadTraits2Error
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits2::ser_http_payload_traits2_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 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))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_QUERYPRECEDENCE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput) using modelled bindings.
     pub struct QueryPrecedenceInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryPrecedenceInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8
+    }
-9
+}
-10
 impl std::future::Future for QueryPrecedenceInputFuture {

↧ Expand context

     type Output = Result<
         crate::input::QueryPrecedenceInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-16
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         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::QueryPrecedenceInput
 where

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/operation_shape.rs

@@ -1,1 +185,31 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 pub struct HttpStringPayload2;
--
 impl ::aws_smithy_http_server::operation::OperationShape for HttpStringPayload2 {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#HttpStringPayload2",
             "aws.protocoltests.restjson",
             "HttpStringPayload2",
         );
--
     type Input = crate::input::HttpStringPayload2Input;
     type Output = crate::output::HttpStringPayload2Output;
     type Error = crate::error::HttpStringPayload2Error;
--
+}
--
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for HttpStringPayload2 {
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;
--
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
--
+    }
--
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
--
+    }
--
+}
--
 #[allow(missing_docs)] // documentation missing in model
 pub struct HttpEnumPayload2;
--
 impl ::aws_smithy_http_server::operation::OperationShape for HttpEnumPayload2 {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#HttpEnumPayload2",
             "aws.protocoltests.restjson",
             "HttpEnumPayload2",
         );
--
     type Input = crate::input::HttpEnumPayload2Input;
     type Output = crate::output::HttpEnumPayload2Output;
     type Error = crate::error::HttpEnumPayload2Error;
--
+}
--
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for HttpEnumPayload2 {
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;
--
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
--
+    }
--
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
--
+    }
--
+}
--
 #[allow(missing_docs)] // documentation missing in model
 pub struct MalformedContentTypeWithBody2;
--
 impl ::aws_smithy_http_server::operation::OperationShape for MalformedContentTypeWithBody2 {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#MalformedContentTypeWithBody2",
             "aws.protocoltests.restjson",
             "MalformedContentTypeWithBody2",
         );
--
     type Input = crate::input::MalformedContentTypeWithBody2Input;
     type Output = crate::output::MalformedContentTypeWithBody2Output;
     type Error = crate::error::MalformedContentTypeWithBody2Error;
--
+}
--
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity
     for MalformedContentTypeWithBody2
--
+{
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;
--
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
--
+    }
--
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
--
+    }
--
+}
--
 /// This example serializes a blob shape in the payload. In this example, no JSON document is synthesized because the payload is not a structure or a union type.
 pub struct HttpPayloadTraits2;
--
 impl ::aws_smithy_http_server::operation::OperationShape for HttpPayloadTraits2 {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#HttpPayloadTraits2",
             "aws.protocoltests.restjson",
             "HttpPayloadTraits2",
         );
--
     type Input = crate::input::HttpPayloadTraits2Input;
     type Output = crate::output::HttpPayloadTraits2Output;
     type Error = crate::error::HttpPayloadTraits2Error;
--
+}
--
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for HttpPayloadTraits2 {
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;
--
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
--
+    }
--
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
--
+    }
--
+}
--
 #[allow(missing_docs)] // documentation missing in model
 pub struct QueryPrecedence;
-4
 impl ::aws_smithy_http_server::operation::OperationShape for QueryPrecedence {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#QueryPrecedence",
             "aws.protocoltests.restjson",
             "QueryPrecedence",
         );

↧ Expand context

-12
     type Input = crate::input::QueryPrecedenceInput;
     type Output = crate::output::QueryPrecedenceOutput;
     type Error = crate::error::QueryPrecedenceError;
-16
+}
-17
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for QueryPrecedence {
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;
-30
     fn request_fmt() -> Self::RequestFmt {

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

@@ -1,1 +242,31 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[::pyo3::pyclass]
 /// :param payload typing.Optional\[str\]:
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct HttpStringPayload2Output {
     #[pyo3(get, set)]
     /// :type typing.Optional\[str\]:
     #[allow(missing_docs)] // documentation missing in model
     pub payload: ::std::option::Option<::std::string::String>,
--
+}
 impl HttpStringPayload2Output {
     #[allow(missing_docs)] // documentation missing in model
     pub fn payload(&self) -> ::std::option::Option<&str> {
         self.payload.as_deref()
--
+    }
--
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl HttpStringPayload2Output {
     #[new]
     pub fn new(payload: ::std::option::Option<::std::string::String>) -> Self {
         Self { payload }
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<HttpStringPayload2Output> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<HttpStringPayload2Output>().map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<HttpStringPayload2Output> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl HttpStringPayload2Output {
     /// Creates a new builder-style object to manufacture [`HttpStringPayload2Output`](crate::output::HttpStringPayload2Output).
     pub fn builder() -> crate::output::http_string_payload2_output::Builder {
         crate::output::http_string_payload2_output::Builder::default()
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 /// :param payload typing.Optional\[rest_json_extras.model.StringEnum\]:
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct HttpEnumPayload2Output {
     #[pyo3(get, set)]
     /// :type typing.Optional\[rest_json_extras.model.StringEnum\]:
     #[allow(missing_docs)] // documentation missing in model
     pub payload: ::std::option::Option<crate::model::StringEnum>,
--
+}
 impl HttpEnumPayload2Output {
     #[allow(missing_docs)] // documentation missing in model
     pub fn payload(&self) -> ::std::option::Option<&crate::model::StringEnum> {
         self.payload.as_ref()
--
+    }
--
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl HttpEnumPayload2Output {
     #[new]
     pub fn new(payload: ::std::option::Option<crate::model::StringEnum>) -> Self {
         Self { payload }
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<HttpEnumPayload2Output> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<HttpEnumPayload2Output>().map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<HttpEnumPayload2Output> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl HttpEnumPayload2Output {
     /// Creates a new builder-style object to manufacture [`HttpEnumPayload2Output`](crate::output::HttpEnumPayload2Output).
     pub fn builder() -> crate::output::http_enum_payload2_output::Builder {
         crate::output::http_enum_payload2_output::Builder::default()
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct MalformedContentTypeWithBody2Output {}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl MalformedContentTypeWithBody2Output {
     #[new]
     pub fn new() -> Self {
         Self {}
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source>
     for std::boxed::Box<MalformedContentTypeWithBody2Output>
--
+{
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<MalformedContentTypeWithBody2Output>()
             .map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<MalformedContentTypeWithBody2Output> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl MalformedContentTypeWithBody2Output {
     /// Creates a new builder-style object to manufacture [`MalformedContentTypeWithBody2Output`](crate::output::MalformedContentTypeWithBody2Output).
     pub fn builder() -> crate::output::malformed_content_type_with_body2_output::Builder {
         crate::output::malformed_content_type_with_body2_output::Builder::default()
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 /// :param foo typing.Optional\[str\]:
 /// :param blob typing.Optional\[rest_json_extras.types.Blob\]:
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct HttpPayloadTraits2Output {
     #[pyo3(get, set)]
     /// :type typing.Optional\[str\]:
     #[allow(missing_docs)] // documentation missing in model
     pub foo: ::std::option::Option<::std::string::String>,
     #[pyo3(get, set)]
     /// :type typing.Optional\[rest_json_extras.types.Blob\]:
     #[allow(missing_docs)] // documentation missing in model
     pub blob: ::std::option::Option<::aws_smithy_http_server_python::types::Blob>,
--
+}
 impl HttpPayloadTraits2Output {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(&self) -> ::std::option::Option<&str> {
         self.foo.as_deref()
--
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn blob(&self) -> ::std::option::Option<&::aws_smithy_http_server_python::types::Blob> {
         self.blob.as_ref()
--
+    }
--
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl HttpPayloadTraits2Output {
     #[new]
     pub fn new(
         foo: ::std::option::Option<::std::string::String>,
         blob: ::std::option::Option<::aws_smithy_http_server_python::types::Blob>,
     ) -> Self {
         Self { foo, blob }
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<HttpPayloadTraits2Output> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<HttpPayloadTraits2Output>().map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<HttpPayloadTraits2Output> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl HttpPayloadTraits2Output {
     /// Creates a new builder-style object to manufacture [`HttpPayloadTraits2Output`](crate::output::HttpPayloadTraits2Output).
     pub fn builder() -> crate::output::http_payload_traits2_output::Builder {
         crate::output::http_payload_traits2_output::Builder::default()
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct QueryPrecedenceOutput {}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]

↧ Expand context

 impl QueryPrecedenceOutput {
     #[new]
     pub fn new() -> Self {
         Self {}
-16
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-19
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-22
+    }
-23
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<QueryPrecedenceOutput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<QueryPrecedenceOutput>().map(Box::new)
-27
+    }
-28
+}
-29
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<QueryPrecedenceOutput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {

@@ -775,564 +965,623 @@

↥ Expand context

 #[::pyo3::pymethods]
 impl StringPayloadOutput {
     #[new]
     pub fn new(payload: ::std::option::Option<::std::string::String>) -> Self {
         Self { payload }
-569
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-572
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-575
+    }
-576
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<StringPayloadOutput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<StringPayloadOutput>().map(Box::new)
-580
+    }
-581
+}
-582
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<StringPayloadOutput> {

     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-586
+    }
-587
+}
 impl StringPayloadOutput {
     /// Creates a new builder-style object to manufacture [`StringPayloadOutput`](crate::output::StringPayloadOutput).
     pub fn builder() -> crate::output::string_payload_output::Builder {
         crate::output::string_payload_output::Builder::default()
-592
+    }
-593
+}
 /// See [`HttpStringPayload2Output`](crate::output::HttpStringPayload2Output).
 ///
 pub mod http_string_payload2_output {
--
     impl ::std::convert::From<Builder> for crate::output::HttpStringPayload2Output {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpStringPayload2Output`](crate::output::HttpStringPayload2Output).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) payload: ::std::option::Option<::std::string::String>,
--
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn payload(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.payload = input;
             self
--
+        }
         /// Consumes the builder and constructs a [`HttpStringPayload2Output`](crate::output::HttpStringPayload2Output).
         pub fn build(self) -> crate::output::HttpStringPayload2Output {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::output::HttpStringPayload2Output {
             crate::output::HttpStringPayload2Output {
                 payload: self.payload,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`HttpEnumPayload2Output`](crate::output::HttpEnumPayload2Output).
 ///
 pub mod http_enum_payload2_output {
--
     impl ::std::convert::From<Builder> for crate::output::HttpEnumPayload2Output {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpEnumPayload2Output`](crate::output::HttpEnumPayload2Output).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) payload: ::std::option::Option<crate::model::StringEnum>,
--
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn payload(mut self, input: ::std::option::Option<crate::model::StringEnum>) -> Self {
             self.payload = input;
             self
--
+        }
         /// Consumes the builder and constructs a [`HttpEnumPayload2Output`](crate::output::HttpEnumPayload2Output).
         pub fn build(self) -> crate::output::HttpEnumPayload2Output {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::output::HttpEnumPayload2Output {
             crate::output::HttpEnumPayload2Output {
                 payload: self.payload,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`MalformedContentTypeWithBody2Output`](crate::output::MalformedContentTypeWithBody2Output).
 ///
 pub mod malformed_content_type_with_body2_output {
--
     impl ::std::convert::From<Builder> for crate::output::MalformedContentTypeWithBody2Output {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`MalformedContentTypeWithBody2Output`](crate::output::MalformedContentTypeWithBody2Output).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`MalformedContentTypeWithBody2Output`](crate::output::MalformedContentTypeWithBody2Output).
         pub fn build(self) -> crate::output::MalformedContentTypeWithBody2Output {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::output::MalformedContentTypeWithBody2Output {
             crate::output::MalformedContentTypeWithBody2Output {}
--
+        }
--
+    }
--
+}
 /// See [`HttpPayloadTraits2Output`](crate::output::HttpPayloadTraits2Output).
 ///
 pub mod http_payload_traits2_output {
--
     impl ::std::convert::From<Builder> for crate::output::HttpPayloadTraits2Output {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpPayloadTraits2Output`](crate::output::HttpPayloadTraits2Output).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) foo: ::std::option::Option<::std::string::String>,
         pub(crate) blob: ::std::option::Option<::aws_smithy_http_server_python::types::Blob>,
--
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn foo(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.foo = input;
             self
--
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn blob(
             mut self,
             input: ::std::option::Option<::aws_smithy_http_server_python::types::Blob>,
         ) -> Self {
             self.blob = input;
             self
--
+        }
         /// Consumes the builder and constructs a [`HttpPayloadTraits2Output`](crate::output::HttpPayloadTraits2Output).
         pub fn build(self) -> crate::output::HttpPayloadTraits2Output {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::output::HttpPayloadTraits2Output {
             crate::output::HttpPayloadTraits2Output {
                 foo: self.foo,
                 blob: self.blob,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
 ///
 pub mod query_precedence_output {
-597
     impl ::std::convert::From<Builder> for crate::output::QueryPrecedenceOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-601
+        }
-602
+    }
     /// A builder for [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).

↧ Expand context

     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
         pub fn build(self) -> crate::output::QueryPrecedenceOutput {
             self.build_enforcing_required_and_enum_traits()
-610
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::output::QueryPrecedenceOutput {
             crate::output::QueryPrecedenceOutput {}
-613
+        }
-614
+    }
-615
+}
 /// See [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
 ///
 pub mod empty_struct_with_content_on_wire_op_output {
-619
     impl ::std::convert::From<Builder> for crate::output::EmptyStructWithContentOnWireOpOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-623
+        }

Pages: 1 2 3 4 5 6 7 8 9 10