Server Test Python

rev. 0b749be6d000fdc7ef59d1bc26f1dce00358d95c

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/init.pyi

@@ -23,23 +102,82 @@

     from rest_json_extras import App
-24
     @dataclass
     class Context:
         counter: int = 0
-28
     app = App()
     app.context(Context())
-31
     @app.request_middleware
     def request_middleware(request: middleware::Request):
         if request.get_header("x-amzn-id") != "secret":
             raise middleware.MiddlewareException("Unsupported `x-amz-id` header", 401)
-36
     @app.case_insensitive_error_operation
     def case_insensitive_error_operation(input: input::CaseInsensitiveErrorOperationInput, ctx: Context) -> output::CaseInsensitiveErrorOperationOutput:
         raise NotImplementedError
-40
     @app.empty_struct_with_content_on_wire_op
     def empty_struct_with_content_on_wire_op(input: input::EmptyStructWithContentOnWireOpInput, ctx: Context) -> output::EmptyStructWithContentOnWireOpOutput:

         raise NotImplementedError
-44
     @app.enum_query
     def enum_query(input: input::EnumQueryInput, ctx: Context) -> output::EnumQueryOutput:
         raise NotImplementedError
-48
     @app.escaped_string_values
     def escaped_string_values(input: input::EscapedStringValuesInput, ctx: Context) -> output::EscapedStringValuesOutput:
         raise NotImplementedError
-52
     @app.http_enum_payload2
     def http_enum_payload2(input: input::HttpEnumPayload2Input, ctx: Context) -> output::HttpEnumPayload2Output:
         raise NotImplementedError
--
     # 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.
     @app.http_payload_traits2
     def http_payload_traits2(input: input::HttpPayloadTraits2Input, ctx: Context) -> output::HttpPayloadTraits2Output:
         raise NotImplementedError
--
     @app.http_string_payload2
     def http_string_payload2(input: input::HttpStringPayload2Input, ctx: Context) -> output::HttpStringPayload2Output:
         raise NotImplementedError
--
     @app.malformed_content_type_with_body2
     def malformed_content_type_with_body2(input: input::MalformedContentTypeWithBody2Input, ctx: Context) -> output::MalformedContentTypeWithBody2Output:
         raise NotImplementedError
--
     @app.map_with_enum_key_op
     def map_with_enum_key_op(input: input::MapWithEnumKeyOpInput, ctx: Context) -> output::MapWithEnumKeyOpOutput:
         raise NotImplementedError
-56
     @app.null_in_non_sparse
     def null_in_non_sparse(input: input::NullInNonSparseInput, ctx: Context) -> output::NullInNonSparseOutput:
         raise NotImplementedError
-60
     @app.primitive_int_header
     def primitive_int_header(input: input::PrimitiveIntHeaderInput, ctx: Context) -> output::PrimitiveIntHeaderOutput:

↧ Expand context

         raise NotImplementedError
-64
     @app.primitive_int_op
     def primitive_int_op(input: input::PrimitiveIntOpInput, ctx: Context) -> output::PrimitiveIntOpOutput:
         raise NotImplementedError
-68
     @app.query_precedence
     def query_precedence(input: input::QueryPrecedenceInput, ctx: Context) -> output::QueryPrecedenceOutput:
         raise NotImplementedError
-72
     @app.status_response
     def status_response(input: input::StatusResponseInput, ctx: Context) -> output::StatusResponseOutput:
         raise NotImplementedError
-76
     @app.string_payload
     def string_payload(input: input::StringPayloadInput, ctx: Context) -> output::StringPayloadOutput:
         raise NotImplementedError
-80
     app.run()
     ```

@@ -117,97 +208,156 @@

↥ Expand context

         """
         Register a context object that will be shared between handlers.
         """
         ...
-101
-102
     def empty_struct_with_content_on_wire_op(self, func: typing.Union[typing.Callable[[rest_json_extras.input.EmptyStructWithContentOnWireOpInput, Ctx], typing.Union[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput, typing.Awaitable[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput]]], typing.Callable[[rest_json_extras.input.EmptyStructWithContentOnWireOpInput], typing.Union[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput, typing.Awaitable[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput]]]]) -> None:
         """
         Method to register `empty_struct_with_content_on_wire_op` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
-109
-110
     def enum_query(self, func: typing.Union[typing.Callable[[rest_json_extras.input.EnumQueryInput, Ctx], typing.Union[rest_json_extras.output.EnumQueryOutput, typing.Awaitable[rest_json_extras.output.EnumQueryOutput]]], typing.Callable[[rest_json_extras.input.EnumQueryInput], typing.Union[rest_json_extras.output.EnumQueryOutput, typing.Awaitable[rest_json_extras.output.EnumQueryOutput]]]]) -> None:
         """
         Method to register `enum_query` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...

-117
-118
     def escaped_string_values(self, func: typing.Union[typing.Callable[[rest_json_extras.input.EscapedStringValuesInput, Ctx], typing.Union[rest_json_extras.output.EscapedStringValuesOutput, typing.Awaitable[rest_json_extras.output.EscapedStringValuesOutput]]], typing.Callable[[rest_json_extras.input.EscapedStringValuesInput], typing.Union[rest_json_extras.output.EscapedStringValuesOutput, typing.Awaitable[rest_json_extras.output.EscapedStringValuesOutput]]]]) -> None:
         """
         Method to register `escaped_string_values` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
-125
-126
     def http_enum_payload2(self, func: typing.Union[typing.Callable[[rest_json_extras.input.HttpEnumPayload2Input, Ctx], typing.Union[rest_json_extras.output.HttpEnumPayload2Output, typing.Awaitable[rest_json_extras.output.HttpEnumPayload2Output]]], typing.Callable[[rest_json_extras.input.HttpEnumPayload2Input], typing.Union[rest_json_extras.output.HttpEnumPayload2Output, typing.Awaitable[rest_json_extras.output.HttpEnumPayload2Output]]]]) -> None:
         """
         Method to register `http_enum_payload2` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def http_payload_traits2(self, func: typing.Union[typing.Callable[[rest_json_extras.input.HttpPayloadTraits2Input, Ctx], typing.Union[rest_json_extras.output.HttpPayloadTraits2Output, typing.Awaitable[rest_json_extras.output.HttpPayloadTraits2Output]]], typing.Callable[[rest_json_extras.input.HttpPayloadTraits2Input], typing.Union[rest_json_extras.output.HttpPayloadTraits2Output, typing.Awaitable[rest_json_extras.output.HttpPayloadTraits2Output]]]]) -> None:
         """
         Method to register `http_payload_traits2` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def http_string_payload2(self, func: typing.Union[typing.Callable[[rest_json_extras.input.HttpStringPayload2Input, Ctx], typing.Union[rest_json_extras.output.HttpStringPayload2Output, typing.Awaitable[rest_json_extras.output.HttpStringPayload2Output]]], typing.Callable[[rest_json_extras.input.HttpStringPayload2Input], typing.Union[rest_json_extras.output.HttpStringPayload2Output, typing.Awaitable[rest_json_extras.output.HttpStringPayload2Output]]]]) -> None:
         """
         Method to register `http_string_payload2` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def malformed_content_type_with_body2(self, func: typing.Union[typing.Callable[[rest_json_extras.input.MalformedContentTypeWithBody2Input, Ctx], typing.Union[rest_json_extras.output.MalformedContentTypeWithBody2Output, typing.Awaitable[rest_json_extras.output.MalformedContentTypeWithBody2Output]]], typing.Callable[[rest_json_extras.input.MalformedContentTypeWithBody2Input], typing.Union[rest_json_extras.output.MalformedContentTypeWithBody2Output, typing.Awaitable[rest_json_extras.output.MalformedContentTypeWithBody2Output]]]]) -> None:
         """
         Method to register `malformed_content_type_with_body2` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def map_with_enum_key_op(self, func: typing.Union[typing.Callable[[rest_json_extras.input.MapWithEnumKeyOpInput, Ctx], typing.Union[rest_json_extras.output.MapWithEnumKeyOpOutput, typing.Awaitable[rest_json_extras.output.MapWithEnumKeyOpOutput]]], typing.Callable[[rest_json_extras.input.MapWithEnumKeyOpInput], typing.Union[rest_json_extras.output.MapWithEnumKeyOpOutput, typing.Awaitable[rest_json_extras.output.MapWithEnumKeyOpOutput]]]]) -> None:
         """
         Method to register `map_with_enum_key_op` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
-133
-134
     def middleware(self, func: typing.Callable[[rest_json_extras.middleware.Request, typing.Callable[[rest_json_extras.middleware.Request], typing.Awaitable[rest_json_extras.middleware.Response]]], typing.Awaitable[rest_json_extras.middleware.Response]]) -> None:
         """

↧ Expand context

         Register a Python function to be executed inside a Tower middleware layer.
         """
         ...
-140
-141
     def null_in_non_sparse(self, func: typing.Union[typing.Callable[[rest_json_extras.input.NullInNonSparseInput, Ctx], typing.Union[rest_json_extras.output.NullInNonSparseOutput, typing.Awaitable[rest_json_extras.output.NullInNonSparseOutput]]], typing.Callable[[rest_json_extras.input.NullInNonSparseInput], typing.Union[rest_json_extras.output.NullInNonSparseOutput, typing.Awaitable[rest_json_extras.output.NullInNonSparseOutput]]]]) -> None:
         """
         Method to register `null_in_non_sparse` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
-148
-149
     def primitive_int_header(self, func: typing.Union[typing.Callable[[rest_json_extras.input.PrimitiveIntHeaderInput, Ctx], typing.Union[rest_json_extras.output.PrimitiveIntHeaderOutput, typing.Awaitable[rest_json_extras.output.PrimitiveIntHeaderOutput]]], typing.Callable[[rest_json_extras.input.PrimitiveIntHeaderInput], typing.Union[rest_json_extras.output.PrimitiveIntHeaderOutput, typing.Awaitable[rest_json_extras.output.PrimitiveIntHeaderOutput]]]]) -> None:
         """
         Method to register `primitive_int_header` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
-156

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/input/init.pyi

@@ -1,1 +90,59 @@

 import rest_json_extras.model
 import rest_json_extras.types
 import typing
-3
 class CaseInsensitiveErrorOperationInput:
     def __init__(self) -> None:
         ...
-7
-8
 class EmptyStructWithContentOnWireOpInput:
     def __init__(self) -> None:
         ...
-12
-13
 class EnumQueryInput:
     enum: rest_json_extras.model.StringEnum
-16
     def __init__(self, r#enum: rest_json_extras.model.StringEnum) -> None:
         ...
-19
-20
 class EscapedStringValuesInput:
     enum: typing.Optional[rest_json_extras.model.EnumWithEscapedChars]
-23
     some_string: typing.Optional[str]
-25
     def __init__(self, r#enum: typing.Optional[rest_json_extras.model.EnumWithEscapedChars] = ..., some_string: typing.Optional[str] = ...) -> None:
         ...
-28
-29
 class HttpEnumPayload2Input:
     payload: typing.Optional[rest_json_extras.model.StringEnum]
--
     def __init__(self, payload: typing.Optional[rest_json_extras.model.StringEnum] = ...) -> None:
         ...
--
--
 class HttpPayloadTraits2Input:
     blob: typing.Optional[rest_json_extras.types.Blob]
--
     foo: typing.Optional[str]
--
     def __init__(self, foo: typing.Optional[str] = ..., blob: typing.Optional[rest_json_extras.types.Blob] = ...) -> None:
         ...
--
--
 class HttpStringPayload2Input:
     payload: typing.Optional[str]
--
     def __init__(self, payload: typing.Optional[str] = ...) -> None:
         ...
--
--
 class MalformedContentTypeWithBody2Input:
     salutation: typing.Optional[str]
--
     def __init__(self, salutation: typing.Optional[str] = ...) -> None:
         ...
--
--
 class MapWithEnumKeyOpInput:
     map: typing.Optional[typing.Dict[rest_json_extras.model.StringEnum, str]]
-32
     def __init__(self, map: typing.Optional[typing.Dict[rest_json_extras.model.StringEnum, str]] = ...) -> None:
         ...
-35
-36
 class NullInNonSparseInput:
     def __init__(self) -> None:
         ...

↧ Expand context

-40
-41
 class PrimitiveIntHeaderInput:
     def __init__(self) -> None:
         ...
-45
-46
 class PrimitiveIntOpInput:
     value: int
-49
     def __init__(self, value: int) -> None:
         ...
-52
-53
 class QueryPrecedenceInput:
     baz: typing.Optional[typing.Dict[str, str]]
-56
     foo: typing.Optional[str]
-58
     def __init__(self, foo: typing.Optional[str] = ..., baz: typing.Optional[typing.Dict[str, str]] = ...) -> None:

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/output/init.pyi

@@ -1,1 +88,59 @@

 import rest_json_extras.model
 import rest_json_extras.types
 import typing
-3
 class CaseInsensitiveErrorOperationOutput:
     def __init__(self) -> None:
         ...
-7
-8
 class EmptyStructWithContentOnWireOpOutput:
     empty: typing.Optional[rest_json_extras.model.EmptyStruct]
-11
     def __init__(self, empty: typing.Optional[rest_json_extras.model.EmptyStruct] = ...) -> None:
         ...
-14
-15
 class EnumQueryOutput:
     def __init__(self) -> None:
         ...
-19
-20
 class EscapedStringValuesOutput:
     enum: typing.Optional[rest_json_extras.model.EnumWithEscapedChars]
-23
     some_string: typing.Optional[str]
-25
     def __init__(self, r#enum: typing.Optional[rest_json_extras.model.EnumWithEscapedChars] = ..., some_string: typing.Optional[str] = ...) -> None:
         ...
-28
-29
 class HttpEnumPayload2Output:
     payload: typing.Optional[rest_json_extras.model.StringEnum]
--
     def __init__(self, payload: typing.Optional[rest_json_extras.model.StringEnum] = ...) -> None:
         ...
--
--
 class HttpPayloadTraits2Output:
     blob: typing.Optional[rest_json_extras.types.Blob]
--
     foo: typing.Optional[str]
--
     def __init__(self, foo: typing.Optional[str] = ..., blob: typing.Optional[rest_json_extras.types.Blob] = ...) -> None:
         ...
--
--
 class HttpStringPayload2Output:
     payload: typing.Optional[str]
--
     def __init__(self, payload: typing.Optional[str] = ...) -> None:
         ...
--
--
 class MalformedContentTypeWithBody2Output:
     def __init__(self) -> None:
         ...
--
--
 class MapWithEnumKeyOpOutput:
     map: typing.Optional[typing.Dict[rest_json_extras.model.StringEnum, str]]
-32
     def __init__(self, map: typing.Optional[typing.Dict[rest_json_extras.model.StringEnum, str]] = ...) -> None:
         ...
-35
-36
 class NullInNonSparseOutput:
     list: typing.Optional[typing.List[str]]
-39

↧ Expand context

     map: typing.Optional[typing.Dict[str, str]]
-41
     union: typing.Optional[rest_json_extras.model.SingleElementUnion]
-43
     def __init__(self, list: typing.Optional[typing.List[str]] = ..., map: typing.Optional[typing.Dict[str, str]] = ..., union: typing.Optional[rest_json_extras.model.SingleElementUnion] = ...) -> None:
         ...
-46
-47
 class PrimitiveIntHeaderOutput:
     field: int
-50
     def __init__(self, field: int) -> None:
         ...
-53
-54
 class PrimitiveIntOpOutput:
     value: int
-57
     def __init__(self, value: int) -> None:
         ...

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

@@ -15,15 +131,131 @@

↥ Expand context

         Self {}
-16
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-19
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-22
+    }
-23
+}
 impl ExtraError {
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "ExtraError"
-29
+    }
-30
+}
 impl ::std::fmt::Display for ExtraError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ExtraError")?;
         Ok(())

-35
+    }
-36
+}
 impl ::std::error::Error for ExtraError {}
 impl ExtraError {
     /// Creates a new builder-style object to manufacture [`ExtraError`](crate::error::ExtraError).
     pub fn builder() -> crate::error::extra_error::Builder {
         crate::error::extra_error::Builder::default()
-42
+    }
-43
+}
-44
 /// Error type for the `HttpStringPayload2` operation.
 /// Each variant represents an error that can occur for the `HttpStringPayload2` operation.
 /// Error type for the `QueryPrecedence` operation.
 /// Each variant represents an error that can occur for the `QueryPrecedence` operation.
 #[derive(::std::fmt::Debug)]
 pub enum HttpStringPayload2Error {
 pub enum QueryPrecedenceError {
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::error::ExtraError),
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-53
+}
 impl ::std::fmt::Display for HttpStringPayload2Error {
 impl ::std::fmt::Display for QueryPrecedenceError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             HttpStringPayload2Error::ExtraError(_inner) => _inner.fmt(f),
             HttpStringPayload2Error::InternalServerError(_inner) => _inner.fmt(f),
             QueryPrecedenceError::ExtraError(_inner) => _inner.fmt(f),
             QueryPrecedenceError::InternalServerError(_inner) => _inner.fmt(f),
-59
+        }
-60
+    }
-61
+}
 impl HttpStringPayload2Error {
     /// Returns `true` if the error kind is `HttpStringPayload2Error::ExtraError`.
 impl QueryPrecedenceError {
     /// Returns `true` if the error kind is `QueryPrecedenceError::ExtraError`.
     pub fn is_extra_error(&self) -> bool {
         matches!(&self, HttpStringPayload2Error::ExtraError(_))
         matches!(&self, QueryPrecedenceError::ExtraError(_))
-66
+    }
     /// Returns `true` if the error kind is `HttpStringPayload2Error::InternalServerError`.
     /// Returns `true` if the error kind is `QueryPrecedenceError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(&self, HttpStringPayload2Error::InternalServerError(_))
         matches!(&self, QueryPrecedenceError::InternalServerError(_))
-70
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             HttpStringPayload2Error::ExtraError(_inner) => _inner.name(),
             HttpStringPayload2Error::InternalServerError(_inner) => _inner.name(),
             QueryPrecedenceError::ExtraError(_inner) => _inner.name(),
             QueryPrecedenceError::InternalServerError(_inner) => _inner.name(),
-76
+        }
-77
+    }
-78
+}
 impl ::std::error::Error for HttpStringPayload2Error {
 impl ::std::error::Error for QueryPrecedenceError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             HttpStringPayload2Error::ExtraError(_inner) => Some(_inner),
             HttpStringPayload2Error::InternalServerError(_inner) => Some(_inner),
             QueryPrecedenceError::ExtraError(_inner) => Some(_inner),
             QueryPrecedenceError::InternalServerError(_inner) => Some(_inner),
-84
+        }
-85
+    }
-86
+}
 impl ::std::convert::From<crate::error::ExtraError> for crate::error::HttpStringPayload2Error {
     fn from(variant: crate::error::ExtraError) -> crate::error::HttpStringPayload2Error {
 impl ::std::convert::From<crate::error::ExtraError> for crate::error::QueryPrecedenceError {
     fn from(variant: crate::error::ExtraError) -> crate::error::QueryPrecedenceError {
         Self::ExtraError(variant)
-90
+    }
-91
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::HttpStringPayload2Error
     for crate::error::QueryPrecedenceError
-94
+{
     fn from(variant: crate::error::InternalServerError) -> crate::error::HttpStringPayload2Error {
     fn from(variant: crate::error::InternalServerError) -> crate::error::QueryPrecedenceError {
         Self::InternalServerError(variant)
-97
+    }
-98
+}
-99
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpStringPayload2Error {
     fn from(variant: ::pyo3::PyErr) -> crate::error::HttpStringPayload2Error {
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::QueryPrecedenceError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::QueryPrecedenceError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ExtraError>() {
                 return error.into();
-106
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
-109
+            }
             .into()
         })

↧ Expand context

-112
+    }
-113
+}
-114
 #[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 /// :param message 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 InternalServerError {
     #[pyo3(get, set)]
     /// :type str:
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::string::String,
-127
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl InternalServerError {

@@ -141,141 +579,200 @@

↥ Expand context

-141
+    }
-142
+}
 impl InternalServerError {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-147
+    }
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "InternalServerError"
-152
+    }
-153
+}
 impl ::std::fmt::Display for InternalServerError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "InternalServerError")?;
-157
+        {
             ::std::write!(f, ": {}", &self.message)?;
-159
+        }
         Ok(())

-161
+    }
-162
+}
 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()
-168
+    }
-169
+}
-170
 /// Error type for the `HttpEnumPayload2` operation.
 /// Each variant represents an error that can occur for the `HttpEnumPayload2` operation.
 #[derive(::std::fmt::Debug)]
 pub enum HttpEnumPayload2Error {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     ValidationException(crate::error::ValidationException),
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::error::ExtraError),
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
--
+}
 impl ::std::fmt::Display for HttpEnumPayload2Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             HttpEnumPayload2Error::ValidationException(_inner) => _inner.fmt(f),
             HttpEnumPayload2Error::ExtraError(_inner) => _inner.fmt(f),
             HttpEnumPayload2Error::InternalServerError(_inner) => _inner.fmt(f),
--
+        }
--
+    }
--
+}
 impl HttpEnumPayload2Error {
     /// Returns `true` if the error kind is `HttpEnumPayload2Error::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(&self, HttpEnumPayload2Error::ValidationException(_))
--
+    }
     /// Returns `true` if the error kind is `HttpEnumPayload2Error::ExtraError`.
     pub fn is_extra_error(&self) -> bool {
         matches!(&self, HttpEnumPayload2Error::ExtraError(_))
--
+    }
     /// Returns `true` if the error kind is `HttpEnumPayload2Error::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(&self, HttpEnumPayload2Error::InternalServerError(_))
--
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             HttpEnumPayload2Error::ValidationException(_inner) => _inner.name(),
             HttpEnumPayload2Error::ExtraError(_inner) => _inner.name(),
             HttpEnumPayload2Error::InternalServerError(_inner) => _inner.name(),
--
+        }
--
+    }
--
+}
 impl ::std::error::Error for HttpEnumPayload2Error {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             HttpEnumPayload2Error::ValidationException(_inner) => Some(_inner),
             HttpEnumPayload2Error::ExtraError(_inner) => Some(_inner),
             HttpEnumPayload2Error::InternalServerError(_inner) => Some(_inner),
--
+        }
--
+    }
--
+}
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::HttpEnumPayload2Error
--
+{
     fn from(variant: crate::error::ValidationException) -> crate::error::HttpEnumPayload2Error {
         Self::ValidationException(variant)
--
+    }
--
+}
 impl ::std::convert::From<crate::error::ExtraError> for crate::error::HttpEnumPayload2Error {
     fn from(variant: crate::error::ExtraError) -> crate::error::HttpEnumPayload2Error {
         Self::ExtraError(variant)
--
+    }
--
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::HttpEnumPayload2Error
--
+{
     fn from(variant: crate::error::InternalServerError) -> crate::error::HttpEnumPayload2Error {
         Self::InternalServerError(variant)
--
+    }
--
+}
--
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpEnumPayload2Error {
     fn from(variant: ::pyo3::PyErr) -> crate::error::HttpEnumPayload2Error {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {
                 return error.into();
--
+            }
             if let Ok(error) = error.extract::<crate::error::ExtraError>() {
                 return error.into();
--
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
--
+            }
             .into()
         })
--
+    }
--
+}
--
 #[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 /// :param message str:
 /// :param field_list typing.Optional\[typing.List\[rest_json_extras.model.ValidationExceptionField\]\]:
 /// :rtype None:
 /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ValidationException {
     #[pyo3(get, set)]
     /// :type str:
     /// A summary of the validation failure.
     pub message: ::std::string::String,
     #[pyo3(get, set)]
     /// :type typing.Optional\[typing.List\[rest_json_extras.model.ValidationExceptionField\]\]:
     /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
--
+}
 impl ValidationException {
     /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
         self.field_list.as_deref()
--
+    }
--
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl ValidationException {
     #[new]
     pub fn new(
         message: ::std::string::String,
         field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
     ) -> Self {
         Self {
             message,
             field_list,
--
+        }
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 impl ValidationException {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
--
+    }
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "ValidationException"
--
+    }
--
+}
 impl ::std::fmt::Display for ValidationException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ValidationException")?;
--
+        {
             ::std::write!(f, ": {}", &self.message)?;
--
+        }
         Ok(())
--
+    }
--
+}
 impl ::std::error::Error for ValidationException {}
 impl ValidationException {
     /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
     pub fn builder() -> crate::error::validation_exception::Builder {
         crate::error::validation_exception::Builder::default()
--
+    }
--
+}
--
 /// Error type for the `MalformedContentTypeWithBody2` operation.
 /// Each variant represents an error that can occur for the `MalformedContentTypeWithBody2` operation.
 #[derive(::std::fmt::Debug)]
 pub enum MalformedContentTypeWithBody2Error {
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::error::ExtraError),
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
--
+}
 impl ::std::fmt::Display for MalformedContentTypeWithBody2Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             MalformedContentTypeWithBody2Error::ExtraError(_inner) => _inner.fmt(f),
             MalformedContentTypeWithBody2Error::InternalServerError(_inner) => _inner.fmt(f),
--
+        }
--
+    }
--
+}
 impl MalformedContentTypeWithBody2Error {
     /// Returns `true` if the error kind is `MalformedContentTypeWithBody2Error::ExtraError`.
     pub fn is_extra_error(&self) -> bool {
         matches!(&self, MalformedContentTypeWithBody2Error::ExtraError(_))
--
+    }
     /// Returns `true` if the error kind is `MalformedContentTypeWithBody2Error::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             MalformedContentTypeWithBody2Error::InternalServerError(_)
--
+        )
--
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             MalformedContentTypeWithBody2Error::ExtraError(_inner) => _inner.name(),
             MalformedContentTypeWithBody2Error::InternalServerError(_inner) => _inner.name(),
--
+        }
--
+    }
--
+}
 impl ::std::error::Error for MalformedContentTypeWithBody2Error {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             MalformedContentTypeWithBody2Error::ExtraError(_inner) => Some(_inner),
             MalformedContentTypeWithBody2Error::InternalServerError(_inner) => Some(_inner),
--
+        }
--
+    }
--
+}
 impl ::std::convert::From<crate::error::ExtraError>
     for crate::error::MalformedContentTypeWithBody2Error
--
+{
     fn from(variant: crate::error::ExtraError) -> crate::error::MalformedContentTypeWithBody2Error {
         Self::ExtraError(variant)
--
+    }
--
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::MalformedContentTypeWithBody2Error
--
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::MalformedContentTypeWithBody2Error {
         Self::InternalServerError(variant)
--
+    }
--
+}
--
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::MalformedContentTypeWithBody2Error {
     fn from(variant: ::pyo3::PyErr) -> crate::error::MalformedContentTypeWithBody2Error {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ExtraError>() {
                 return error.into();
--
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
--
+            }
             .into()
         })
--
+    }
--
+}
--
 /// Error type for the `HttpPayloadTraits2` operation.
 /// Each variant represents an error that can occur for the `HttpPayloadTraits2` operation.
 #[derive(::std::fmt::Debug)]
 pub enum HttpPayloadTraits2Error {
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::error::ExtraError),
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
--
+}
 impl ::std::fmt::Display for HttpPayloadTraits2Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             HttpPayloadTraits2Error::ExtraError(_inner) => _inner.fmt(f),
             HttpPayloadTraits2Error::InternalServerError(_inner) => _inner.fmt(f),
--
+        }
--
+    }
--
+}
 impl HttpPayloadTraits2Error {
     /// Returns `true` if the error kind is `HttpPayloadTraits2Error::ExtraError`.
     pub fn is_extra_error(&self) -> bool {
         matches!(&self, HttpPayloadTraits2Error::ExtraError(_))
--
+    }
     /// Returns `true` if the error kind is `HttpPayloadTraits2Error::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(&self, HttpPayloadTraits2Error::InternalServerError(_))
--
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             HttpPayloadTraits2Error::ExtraError(_inner) => _inner.name(),
             HttpPayloadTraits2Error::InternalServerError(_inner) => _inner.name(),
--
+        }
--
+    }
--
+}
 impl ::std::error::Error for HttpPayloadTraits2Error {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             HttpPayloadTraits2Error::ExtraError(_inner) => Some(_inner),
             HttpPayloadTraits2Error::InternalServerError(_inner) => Some(_inner),
--
+        }
--
+    }
--
+}
 impl ::std::convert::From<crate::error::ExtraError> for crate::error::HttpPayloadTraits2Error {
     fn from(variant: crate::error::ExtraError) -> crate::error::HttpPayloadTraits2Error {
         Self::ExtraError(variant)
--
+    }
--
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::HttpPayloadTraits2Error
--
+{
     fn from(variant: crate::error::InternalServerError) -> crate::error::HttpPayloadTraits2Error {
         Self::InternalServerError(variant)
--
+    }
--
+}
--
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::HttpPayloadTraits2Error {
     fn from(variant: ::pyo3::PyErr) -> crate::error::HttpPayloadTraits2Error {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ExtraError>() {
                 return error.into();
--
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
--
+            }
             .into()
         })
--
+    }
--
+}
--
 /// Error type for the `QueryPrecedence` operation.
 /// Each variant represents an error that can occur for the `QueryPrecedence` operation.
 #[derive(::std::fmt::Debug)]
 pub enum QueryPrecedenceError {
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::error::ExtraError),
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
--
+}
 impl ::std::fmt::Display for QueryPrecedenceError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             QueryPrecedenceError::ExtraError(_inner) => _inner.fmt(f),
             QueryPrecedenceError::InternalServerError(_inner) => _inner.fmt(f),
--
+        }
--
+    }
--
+}
 impl QueryPrecedenceError {
     /// Returns `true` if the error kind is `QueryPrecedenceError::ExtraError`.
     pub fn is_extra_error(&self) -> bool {
         matches!(&self, QueryPrecedenceError::ExtraError(_))
--
+    }
     /// Returns `true` if the error kind is `QueryPrecedenceError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(&self, QueryPrecedenceError::InternalServerError(_))
--
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             QueryPrecedenceError::ExtraError(_inner) => _inner.name(),
             QueryPrecedenceError::InternalServerError(_inner) => _inner.name(),
--
+        }
--
+    }
--
+}
 impl ::std::error::Error for QueryPrecedenceError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             QueryPrecedenceError::ExtraError(_inner) => Some(_inner),
             QueryPrecedenceError::InternalServerError(_inner) => Some(_inner),
--
+        }
--
+    }
--
+}
 impl ::std::convert::From<crate::error::ExtraError> for crate::error::QueryPrecedenceError {
     fn from(variant: crate::error::ExtraError) -> crate::error::QueryPrecedenceError {
         Self::ExtraError(variant)
--
+    }
--
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::QueryPrecedenceError
--
+{
     fn from(variant: crate::error::InternalServerError) -> crate::error::QueryPrecedenceError {
         Self::InternalServerError(variant)
--
+    }
--
+}
--
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::QueryPrecedenceError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::QueryPrecedenceError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ExtraError>() {
                 return error.into();
--
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
--
+            }
             .into()
         })
--
+    }
--
+}
--
 /// Error type for the `EmptyStructWithContentOnWireOp` operation.
 /// Each variant represents an error that can occur for the `EmptyStructWithContentOnWireOp` operation.
 #[derive(::std::fmt::Debug)]
 pub enum EmptyStructWithContentOnWireOpError {
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::error::ExtraError),
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-179
+}
 impl ::std::fmt::Display for EmptyStructWithContentOnWireOpError {

↧ Expand context

     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             EmptyStructWithContentOnWireOpError::ExtraError(_inner) => _inner.fmt(f),
             EmptyStructWithContentOnWireOpError::InternalServerError(_inner) => _inner.fmt(f),
-185
+        }
-186
+    }
-187
+}
 impl EmptyStructWithContentOnWireOpError {
     /// Returns `true` if the error kind is `EmptyStructWithContentOnWireOpError::ExtraError`.
     pub fn is_extra_error(&self) -> bool {
         matches!(&self, EmptyStructWithContentOnWireOpError::ExtraError(_))
-192
+    }
     /// Returns `true` if the error kind is `EmptyStructWithContentOnWireOpError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             EmptyStructWithContentOnWireOpError::InternalServerError(_)
-198
+        )
-199
+    }
     /// Returns the error name string by matching the correct variant.

@@ -917,538 +976,670 @@

↥ Expand context

     fn from(variant: crate::error::ExtraError) -> crate::error::EscapedStringValuesError {
         Self::ExtraError(variant)
-540
+    }
-541
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::EscapedStringValuesError
-544
+{
     fn from(variant: crate::error::InternalServerError) -> crate::error::EscapedStringValuesError {
         Self::InternalServerError(variant)
-547
+    }
-548
+}
-549
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::EscapedStringValuesError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::EscapedStringValuesError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {
                 return error.into();
-556
+            }
             if let Ok(error) = error.extract::<crate::error::ExtraError>() {

                 return error.into();
-559
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
-562
+            }
             .into()
         })
-565
+    }
-566
+}
-567
 #[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 /// :param message str:
 /// :param field_list typing.Optional\[typing.List\[rest_json_extras.model.ValidationExceptionField\]\]:
 /// :rtype None:
 /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ValidationException {
     #[pyo3(get, set)]
     /// :type str:
     /// A summary of the validation failure.
     pub message: ::std::string::String,
     #[pyo3(get, set)]
     /// :type typing.Optional\[typing.List\[rest_json_extras.model.ValidationExceptionField\]\]:
     /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
-+
+}
 impl ValidationException {
     /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
         self.field_list.as_deref()
-+
+    }
-+
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl ValidationException {
     #[new]
     pub fn new(
         message: ::std::string::String,
         field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
     ) -> Self {
         Self {
             message,
             field_list,
-+
+        }
-+
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-+
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-+
+    }
-+
+}
 impl ValidationException {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-+
+    }
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "ValidationException"
-+
+    }
-+
+}
 impl ::std::fmt::Display for ValidationException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ValidationException")?;
-+
+        {
             ::std::write!(f, ": {}", &self.message)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 impl ::std::error::Error for ValidationException {}
 impl ValidationException {
     /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
     pub fn builder() -> crate::error::validation_exception::Builder {
         crate::error::validation_exception::Builder::default()
-+
+    }
-+
+}
-+
 /// Error type for the `PrimitiveIntOp` operation.
 /// Each variant represents an error that can occur for the `PrimitiveIntOp` operation.
 #[derive(::std::fmt::Debug)]
 pub enum PrimitiveIntOpError {
     #[allow(missing_docs)] // documentation missing in model
     ExtraError(crate::error::ExtraError),
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-649
+}
 impl ::std::fmt::Display for PrimitiveIntOpError {

↧ Expand context

     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             PrimitiveIntOpError::ExtraError(_inner) => _inner.fmt(f),
             PrimitiveIntOpError::InternalServerError(_inner) => _inner.fmt(f),
-655
+        }
-656
+    }
-657
+}
 impl PrimitiveIntOpError {
     /// Returns `true` if the error kind is `PrimitiveIntOpError::ExtraError`.
     pub fn is_extra_error(&self) -> bool {
         matches!(&self, PrimitiveIntOpError::ExtraError(_))
-662
+    }
     /// Returns `true` if the error kind is `PrimitiveIntOpError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(&self, PrimitiveIntOpError::InternalServerError(_))
-666
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             PrimitiveIntOpError::ExtraError(_inner) => _inner.name(),

@@ -1459,1153 +1518,1243 @@

↥ Expand context

             builder.build()
-1154
+        }
-1155
+    }
     /// 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>,
-1160
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-1166
+        }
         /// 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()

-1173
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             Ok(crate::error::InternalServerError {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
-1180
+        }
-1181
+    }
-1182
+}
 /// See [`CaseInsensitiveError`](crate::error::CaseInsensitiveError).
 ///
 pub mod case_insensitive_error {
-+
     impl ::std::convert::From<Builder> for crate::error::CaseInsensitiveError {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`CaseInsensitiveError`](crate::error::CaseInsensitiveError).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.message = input;
             self
-+
+        }
         /// Consumes the builder and constructs a [`CaseInsensitiveError`](crate::error::CaseInsensitiveError).
         pub fn build(self) -> crate::error::CaseInsensitiveError {
             self.build_enforcing_required_and_enum_traits()
-+
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::error::CaseInsensitiveError {
             crate::error::CaseInsensitiveError {
                 message: self.message,
-+
+            }
-+
+        }
-+
+    }
-+
+}
 /// See [`ValidationException`](crate::error::ValidationException).
 ///
 pub mod validation_exception {
-1217
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
-1220
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `ValidationException`.

↧ Expand context

         MissingMessage,
-1225
+    }
     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`"),
-1230
+            }
-1231
+        }
-1232
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::ValidationException {
         type Error = ConstraintViolation;
-1236
         fn try_from(builder: Builder) -> Result<Self, Self::Error> {
             builder.build()
-1239
+        }
-1240
+    }
     /// A builder for [`ValidationException`](crate::error::ValidationException).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {

@@ -1524,1249 +1584,0 @@

↥ Expand context

         /// A summary of the validation failure.
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-1253
+        }
         /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
         pub fn field_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
         ) -> Self {
             self.field_list = input;
             self
-1261
+        }
         /// Consumes the builder and constructs a [`ValidationException`](crate::error::ValidationException).
         ///
         /// The builder fails to construct a [`ValidationException`](crate::error::ValidationException) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(self) -> Result<crate::error::ValidationException, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-1268
+        }

         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::error::ValidationException, ConstraintViolation> {
             Ok(crate::error::ValidationException {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
                 field_list: self.field_list,
             })
-1276
+        }
-1277
+    }
-1278
+}
 /// See [`CaseInsensitiveError`](crate::error::CaseInsensitiveError).
 ///
 pub mod case_insensitive_error {
--
     impl ::std::convert::From<Builder> for crate::error::CaseInsensitiveError {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`CaseInsensitiveError`](crate::error::CaseInsensitiveError).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
--
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.message = input;
             self
--
+        }
         /// Consumes the builder and constructs a [`CaseInsensitiveError`](crate::error::CaseInsensitiveError).
         pub fn build(self) -> crate::error::CaseInsensitiveError {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::error::CaseInsensitiveError {
             crate::error::CaseInsensitiveError {
                 message: self.message,
--
+            }
--
+        }
--
+    }
--
+}

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

@@ -1,1 +266,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 HttpStringPayload2Input {
     #[pyo3(get, set)]
     /// :type typing.Optional\[str\]:
     #[allow(missing_docs)] // documentation missing in model
     pub payload: ::std::option::Option<::std::string::String>,
--
+}
 impl HttpStringPayload2Input {
     #[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 HttpStringPayload2Input {
     #[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<HttpStringPayload2Input> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<HttpStringPayload2Input>().map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<HttpStringPayload2Input> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl crate::constrained::Constrained for crate::input::HttpStringPayload2Input {
     type Unconstrained = crate::input::http_string_payload2_input_internal::Builder;
--
+}
 impl HttpStringPayload2Input {
     /// Creates a new builder-style object to manufacture [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input).
     pub fn builder() -> crate::input::http_string_payload2_input::Builder {
         crate::input::http_string_payload2_input::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 HttpEnumPayload2Input {
     #[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 HttpEnumPayload2Input {
     #[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 HttpEnumPayload2Input {
     #[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<HttpEnumPayload2Input> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<HttpEnumPayload2Input>().map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<HttpEnumPayload2Input> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl crate::constrained::Constrained for crate::input::HttpEnumPayload2Input {
     type Unconstrained = crate::input::http_enum_payload2_input_internal::Builder;
--
+}
 impl HttpEnumPayload2Input {
     /// Creates a new builder-style object to manufacture [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input).
     pub fn builder() -> crate::input::http_enum_payload2_input::Builder {
         crate::input::http_enum_payload2_input::Builder::default()
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 /// :param salutation 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 MalformedContentTypeWithBody2Input {
     #[pyo3(get, set)]
     /// :type typing.Optional\[str\]:
     #[allow(missing_docs)] // documentation missing in model
     pub salutation: ::std::option::Option<::std::string::String>,
--
+}
 impl MalformedContentTypeWithBody2Input {
     #[allow(missing_docs)] // documentation missing in model
     pub fn salutation(&self) -> ::std::option::Option<&str> {
         self.salutation.as_deref()
--
+    }
--
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl MalformedContentTypeWithBody2Input {
     #[new]
     pub fn new(salutation: ::std::option::Option<::std::string::String>) -> Self {
         Self { salutation }
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
--
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
--
+    }
--
+}
 impl<'source> ::pyo3::FromPyObject<'source>
     for std::boxed::Box<MalformedContentTypeWithBody2Input>
--
+{
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<MalformedContentTypeWithBody2Input>()
             .map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<MalformedContentTypeWithBody2Input> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl crate::constrained::Constrained for crate::input::MalformedContentTypeWithBody2Input {
     type Unconstrained = crate::input::malformed_content_type_with_body2_input_internal::Builder;
--
+}
 impl MalformedContentTypeWithBody2Input {
     /// Creates a new builder-style object to manufacture [`MalformedContentTypeWithBody2Input`](crate::input::MalformedContentTypeWithBody2Input).
     pub fn builder() -> crate::input::malformed_content_type_with_body2_input::Builder {
         crate::input::malformed_content_type_with_body2_input::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 HttpPayloadTraits2Input {
     #[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 HttpPayloadTraits2Input {
     #[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 HttpPayloadTraits2Input {
     #[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<HttpPayloadTraits2Input> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<HttpPayloadTraits2Input>().map(Box::new)
--
+    }
--
+}
--
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<HttpPayloadTraits2Input> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
--
+    }
--
+}
 impl crate::constrained::Constrained for crate::input::HttpPayloadTraits2Input {
     type Unconstrained = crate::input::http_payload_traits2_input_internal::Builder;
--
+}
 impl HttpPayloadTraits2Input {
     /// Creates a new builder-style object to manufacture [`HttpPayloadTraits2Input`](crate::input::HttpPayloadTraits2Input).
     pub fn builder() -> crate::input::http_payload_traits2_input::Builder {
         crate::input::http_payload_traits2_input::Builder::default()
--
+    }
--
+}
--
 #[::pyo3::pyclass]
 /// :param foo typing.Optional\[str\]:
 /// :param baz typing.Optional\[typing.Dict\[str, str\]\]:
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct QueryPrecedenceInput {
     #[pyo3(get, set)]
     /// :type typing.Optional\[str\]:
     #[allow(missing_docs)] // documentation missing in model

↧ Expand context

     pub foo: ::std::option::Option<::std::string::String>,
     #[pyo3(get, set)]
     /// :type typing.Optional\[typing.Dict\[str, str\]\]:
     #[allow(missing_docs)] // documentation missing in model
     pub baz: ::std::option::Option<
         ::std::collections::HashMap<::std::string::String, ::std::string::String>,
     >,
-19
+}
 impl QueryPrecedenceInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn foo(&self) -> ::std::option::Option<&str> {
         self.foo.as_deref()
-24
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn baz(
         &self,
     ) -> ::std::option::Option<
         &::std::collections::HashMap<::std::string::String, ::std::string::String>,
     > {
         self.baz.as_ref()

@@ -798,563 +1215,622 @@

↥ Expand context

     pub fn new(payload: ::std::option::Option<::std::string::String>) -> Self {
         Self { payload }
-565
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-568
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-571
+    }
-572
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<StringPayloadInput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<StringPayloadInput>().map(Box::new)
-576
+    }
-577
+}
-578
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<StringPayloadInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-582
+    }

-583
+}
 impl crate::constrained::Constrained for crate::input::StringPayloadInput {
     type Unconstrained = crate::input::string_payload_input_internal::Builder;
-586
+}
 impl StringPayloadInput {
     /// Creates a new builder-style object to manufacture [`StringPayloadInput`](crate::input::StringPayloadInput).
     pub fn builder() -> crate::input::string_payload_input::Builder {
         crate::input::string_payload_input::Builder::default()
-591
+    }
-592
+}
 /// See [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input).
 ///
 pub(crate) mod http_string_payload2_input_internal {
--
     impl ::std::convert::From<Builder> for crate::input::HttpStringPayload2Input {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {
         pub(crate) payload: ::std::option::Option<::std::string::String>,
--
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_payload(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.payload = input.map(|v| v.into());
             self
--
+        }
         /// Consumes the builder and constructs a [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input).
         pub fn build(self) -> crate::input::HttpStringPayload2Input {
             self.build_enforcing_all_constraints()
--
+        }
         fn build_enforcing_all_constraints(self) -> crate::input::HttpStringPayload2Input {
             crate::input::HttpStringPayload2Input {
                 payload: self.payload,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input).
 ///
 pub mod http_string_payload2_input {
--
     impl ::std::convert::From<Builder> for crate::input::HttpStringPayload2Input {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input).
     #[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 [`HttpStringPayload2Input`](crate::input::HttpStringPayload2Input).
         pub fn build(self) -> crate::input::HttpStringPayload2Input {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::input::HttpStringPayload2Input {
             crate::input::HttpStringPayload2Input {
                 payload: self.payload,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input).
 ///
 pub(crate) mod http_enum_payload2_input_internal {
--
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `payload` when building `HttpEnumPayload2Input`.
         #[doc(hidden)]
         Payload(crate::model::string_enum_internal::ConstraintViolation),
--
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::Payload(_) => write!(f, "constraint violation occurred building member `payload` when building `HttpEnumPayload2Input`"),
--
+            }
--
+        }
--
+    }
     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 {
                 ConstraintViolation::Payload(inner) => {
                     inner.as_validation_exception_field(path + "/payload")
--
+                }
--
+            }
--
+        }
--
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
--
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),
             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
--
+                            )
--
+        }
--
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::HttpEnumPayload2Input>
--
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
--
+        }
--
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::HttpEnumPayload2Input {
         type Error = ConstraintViolation;
--
         fn try_from(builder: Builder) -> Result<Self, Self::Error> {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {
         pub(crate) payload:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::StringEnum>>,
--
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_payload(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::StringEnum>,
                 >,
             >,
         ) -> Self {
             self.payload = input.map(|v| v.into());
             self
--
+        }
         /// Consumes the builder and constructs a [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input).
         ///
         /// The builder fails to construct a [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::input::HttpEnumPayload2Input, ConstraintViolation> {
             self.build_enforcing_all_constraints()
--
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::HttpEnumPayload2Input, ConstraintViolation> {
             Ok(crate::input::HttpEnumPayload2Input {
                 payload: self
                     .payload
                     .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::Payload))
                     .transpose()?,
             })
--
+        }
--
+    }
--
+}
 /// See [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input).
 ///
 pub mod http_enum_payload2_input {
--
     impl ::std::convert::From<Builder> for crate::input::HttpEnumPayload2Input {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input).
     #[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 [`HttpEnumPayload2Input`](crate::input::HttpEnumPayload2Input).
         pub fn build(self) -> crate::input::HttpEnumPayload2Input {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::input::HttpEnumPayload2Input {
             crate::input::HttpEnumPayload2Input {
                 payload: self.payload,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`MalformedContentTypeWithBody2Input`](crate::input::MalformedContentTypeWithBody2Input).
 ///
 pub(crate) mod malformed_content_type_with_body2_input_internal {
--
     impl ::std::convert::From<Builder> for crate::input::MalformedContentTypeWithBody2Input {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`MalformedContentTypeWithBody2Input`](crate::input::MalformedContentTypeWithBody2Input).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {
         pub(crate) salutation: ::std::option::Option<::std::string::String>,
--
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_salutation(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.salutation = input.map(|v| v.into());
             self
--
+        }
         /// Consumes the builder and constructs a [`MalformedContentTypeWithBody2Input`](crate::input::MalformedContentTypeWithBody2Input).
         pub fn build(self) -> crate::input::MalformedContentTypeWithBody2Input {
             self.build_enforcing_all_constraints()
--
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> crate::input::MalformedContentTypeWithBody2Input {
             crate::input::MalformedContentTypeWithBody2Input {
                 salutation: self.salutation,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`MalformedContentTypeWithBody2Input`](crate::input::MalformedContentTypeWithBody2Input).
 ///
 pub mod malformed_content_type_with_body2_input {
--
     impl ::std::convert::From<Builder> for crate::input::MalformedContentTypeWithBody2Input {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`MalformedContentTypeWithBody2Input`](crate::input::MalformedContentTypeWithBody2Input).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) salutation: ::std::option::Option<::std::string::String>,
--
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn salutation(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.salutation = input;
             self
--
+        }
         /// Consumes the builder and constructs a [`MalformedContentTypeWithBody2Input`](crate::input::MalformedContentTypeWithBody2Input).
         pub fn build(self) -> crate::input::MalformedContentTypeWithBody2Input {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::input::MalformedContentTypeWithBody2Input {
             crate::input::MalformedContentTypeWithBody2Input {
                 salutation: self.salutation,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`HttpPayloadTraits2Input`](crate::input::HttpPayloadTraits2Input).
 ///
 pub(crate) mod http_payload_traits2_input_internal {
--
     impl ::std::convert::From<Builder> for crate::input::HttpPayloadTraits2Input {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpPayloadTraits2Input`](crate::input::HttpPayloadTraits2Input).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) 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(crate) fn set_foo(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.foo = input.map(|v| v.into());
             self
--
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_blob(
             mut self,
             input: Option<impl ::std::convert::Into<::aws_smithy_http_server_python::types::Blob>>,
         ) -> Self {
             self.blob = input.map(|v| v.into());
             self
--
+        }
         /// Consumes the builder and constructs a [`HttpPayloadTraits2Input`](crate::input::HttpPayloadTraits2Input).
         pub fn build(self) -> crate::input::HttpPayloadTraits2Input {
             self.build_enforcing_all_constraints()
--
+        }
         fn build_enforcing_all_constraints(self) -> crate::input::HttpPayloadTraits2Input {
             crate::input::HttpPayloadTraits2Input {
                 foo: self.foo,
                 blob: self.blob,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`HttpPayloadTraits2Input`](crate::input::HttpPayloadTraits2Input).
 ///
 pub mod http_payload_traits2_input {
--
     impl ::std::convert::From<Builder> for crate::input::HttpPayloadTraits2Input {
         fn from(builder: Builder) -> Self {
             builder.build()
--
+        }
--
+    }
     /// A builder for [`HttpPayloadTraits2Input`](crate::input::HttpPayloadTraits2Input).
     #[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 [`HttpPayloadTraits2Input`](crate::input::HttpPayloadTraits2Input).
         pub fn build(self) -> crate::input::HttpPayloadTraits2Input {
             self.build_enforcing_required_and_enum_traits()
--
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::input::HttpPayloadTraits2Input {
             crate::input::HttpPayloadTraits2Input {
                 foo: self.foo,
                 blob: self.blob,
--
+            }
--
+        }
--
+    }
--
+}
 /// See [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput).
 ///
 pub(crate) mod query_precedence_input_internal {
-596
     impl ::std::convert::From<Builder> for crate::input::QueryPrecedenceInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-600
+        }
-601
+    }
     /// A builder for [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput).

↧ Expand context

     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {
         pub(crate) foo: ::std::option::Option<::std::string::String>,
         pub(crate) baz: ::std::option::Option<
             ::std::collections::HashMap<::std::string::String, ::std::string::String>,
         >,
-609
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_foo(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.foo = input.map(|v| v.into());
             self
-618
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_baz(
             mut self,
             input: Option<

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

Server Test Python

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/__init__.pyi

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/input/__init__.pyi

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/output/__init__.pyi

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

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

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/init.pyi

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/input/init.pyi

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/output/init.pyi