Server Test Python

rev. d838bf488731ae5e751cce0fe13f339a5b9be858 (ignoring whitespace)

Files changed:

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[::pyo3::pymodule]
 #[pyo3(name = "json_rpc11")]
 pub fn python_library(py: ::pyo3::Python<'_>, m: &::pyo3::types::PyModule) -> ::pyo3::PyResult<()> {
     let input = ::pyo3::types::PyModule::new(py, "input")?;
     let output = ::pyo3::types::PyModule::new(py, "output")?;
     let error = ::pyo3::types::PyModule::new(py, "error")?;
     input.add_class::<crate::input::EmptyOperationInput>()?;
     output.add_class::<crate::output::EmptyOperationOutput>()?;
     error.add_class::<crate::error::InternalServerError>()?;
     output.add_class::<crate::output::ContentTypeParametersOutput>()?;
     input.add_class::<crate::input::ContentTypeParametersInput>()?;
     output.add_class::<crate::output::PutWithContentEncodingOutput>()?;
     input.add_class::<crate::input::PutWithContentEncodingInput>()?;
     output.add_class::<crate::output::FractionalSecondsOutput>()?;
     input.add_class::<crate::input::FractionalSecondsInput>()?;
     output.add_class::<crate::output::DatetimeOffsetsOutput>()?;
     input.add_class::<crate::input::DatetimeOffsetsInput>()?;
     output.add_class::<crate::output::HostWithPathOperationOutput>()?;
     input.add_class::<crate::input::HostWithPathOperationInput>()?;
     input.add_class::<crate::input::KitchenSinkOperationInput>()?;
     output.add_class::<crate::output::KitchenSinkOperationOutput>()?;
     error.add_class::<crate::error::ErrorWithMembers>()?;
     error.add_class::<crate::error::ErrorWithoutMembers>()?;
     input.add_class::<crate::input::SimpleScalarPropertiesInput>()?;
     output.add_class::<crate::output::SimpleScalarPropertiesOutput>()?;
     input.add_class::<crate::input::OperationWithOptionalInputOutputInput>()?;
     output.add_class::<crate::output::OperationWithOptionalInputOutputOutput>()?;
     input.add_class::<crate::input::PutAndGetInlineDocumentsInput>()?;
     output.add_class::<crate::output::PutAndGetInlineDocumentsOutput>()?;
     input.add_class::<crate::input::JsonEnumsInput>()?;
     output.add_class::<crate::output::JsonEnumsOutput>()?;
     error.add_class::<crate::error::ValidationException>()?;
     let model = ::pyo3::types::PyModule::new(py, "model")?;
     model.add_class::<crate::model::ValidationExceptionField>()?;
     output.add_class::<crate::output::EndpointWithHostLabelOperationOutput>()?;
     input.add_class::<crate::input::EndpointWithHostLabelOperationInput>()?;
     output.add_class::<crate::output::EndpointOperationOutput>()?;
     input.add_class::<crate::input::EndpointOperationInput>()?;
     output.add_class::<crate::output::JsonUnionsOutput>()?;
     model.add_class::<crate::model::PyUnionMarkerMyUnion>()?;
     model.add_class::<crate::model::GreetingStruct>()?;
     model.add_class::<crate::model::FooEnum>()?;
     input.add_class::<crate::input::JsonUnionsInput>()?;
     error.add_class::<crate::error::FooError>()?;
     error.add_class::<crate::error::ComplexError>()?;
     model.add_class::<crate::model::ComplexNestedErrorData>()?;
     error.add_class::<crate::error::InvalidGreeting>()?;
     output.add_class::<crate::output::GreetingWithErrorsOutput>()?;
     input.add_class::<crate::input::GreetingWithErrorsInput>()?;
     output.add_class::<crate::output::SparseNullsOperationOutput>()?;
     input.add_class::<crate::input::SparseNullsOperationInput>()?;
     output.add_class::<crate::output::NullOperationOutput>()?;
     input.add_class::<crate::input::NullOperationInput>()?;
     output.add_class::<crate::output::JsonIntEnumsOutput>()?;
     input.add_class::<crate::input::JsonIntEnumsInput>()?;
     output.add_class::<crate::output::JsonEnumsOutput>()?;
     input.add_class::<crate::input::JsonEnumsInput>()?;
     output.add_class::<crate::output::PutAndGetInlineDocumentsOutput>()?;
     input.add_class::<crate::input::PutAndGetInlineDocumentsInput>()?;
     output.add_class::<crate::output::OperationWithOptionalInputOutputOutput>()?;
     input.add_class::<crate::input::OperationWithOptionalInputOutputInput>()?;
     output.add_class::<crate::output::SimpleScalarPropertiesOutput>()?;
     input.add_class::<crate::input::SimpleScalarPropertiesInput>()?;
     error.add_class::<crate::error::ErrorWithoutMembers>()?;
     error.add_class::<crate::error::ErrorWithMembers>()?;
     output.add_class::<crate::output::JsonIntEnumsOutput>()?;
     input.add_class::<crate::input::NullOperationInput>()?;
     output.add_class::<crate::output::NullOperationOutput>()?;
     input.add_class::<crate::input::SparseNullsOperationInput>()?;
     output.add_class::<crate::output::SparseNullsOperationOutput>()?;
     input.add_class::<crate::input::GreetingWithErrorsInput>()?;
     output.add_class::<crate::output::GreetingWithErrorsOutput>()?;
     error.add_class::<crate::error::InvalidGreeting>()?;
     error.add_class::<crate::error::ComplexError>()?;
     error.add_class::<crate::error::FooError>()?;
     input.add_class::<crate::input::JsonUnionsInput>()?;
     output.add_class::<crate::output::JsonUnionsOutput>()?;
     input.add_class::<crate::input::EndpointOperationInput>()?;
     output.add_class::<crate::output::EndpointOperationOutput>()?;
     input.add_class::<crate::input::EndpointWithHostLabelOperationInput>()?;
     output.add_class::<crate::output::EndpointWithHostLabelOperationOutput>()?;
     input.add_class::<crate::input::HostWithPathOperationInput>()?;
     output.add_class::<crate::output::HostWithPathOperationOutput>()?;
     input.add_class::<crate::input::DatetimeOffsetsInput>()?;
     output.add_class::<crate::output::DatetimeOffsetsOutput>()?;
     input.add_class::<crate::input::FractionalSecondsInput>()?;
     output.add_class::<crate::output::FractionalSecondsOutput>()?;
     input.add_class::<crate::input::PutWithContentEncodingInput>()?;
     output.add_class::<crate::output::PutWithContentEncodingOutput>()?;
     input.add_class::<crate::input::ContentTypeParametersInput>()?;
     output.add_class::<crate::output::ContentTypeParametersOutput>()?;
     let model = ::pyo3::types::PyModule::new(py, "model")?;
     model.add_class::<crate::model::EmptyStruct>()?;
     model.add_class::<crate::model::KitchenSink>()?;
     model.add_class::<crate::model::StructWithJsonName>()?;
     model.add_class::<crate::model::SimpleStruct>()?;
     model.add_class::<crate::model::EmptyStruct>()?;
     output.add_class::<crate::output::KitchenSinkOperationOutput>()?;
     input.add_class::<crate::input::KitchenSinkOperationInput>()?;
     output.add_class::<crate::output::EmptyOperationOutput>()?;
     input.add_class::<crate::input::EmptyOperationInput>()?;
     model.add_class::<crate::model::StructWithJsonName>()?;
     model.add_class::<crate::model::FooEnum>()?;
     model.add_class::<crate::model::ComplexNestedErrorData>()?;
     model.add_class::<crate::model::PyUnionMarkerMyUnion>()?;
     model.add_class::<crate::model::ValidationExceptionField>()?;
     model.add_class::<crate::model::GreetingStruct>()?;
     ::pyo3::py_run!(
         py,
         input,
         "import sys; sys.modules['json_rpc11.input'] = input"
     );
     m.add_submodule(input)?;
     ::pyo3::py_run!(
         py,
         output,
         "import sys; sys.modules['json_rpc11.output'] = output"

↧ Expand context

     );
     m.add_submodule(output)?;
     ::pyo3::py_run!(
         py,
         error,
         "import sys; sys.modules['json_rpc11.error'] = error"
     );
     m.add_submodule(error)?;
     ::pyo3::py_run!(
         py,
         model,
         "import sys; sys.modules['json_rpc11.model'] = model"
     );
     m.add_submodule(model)?;
     let types = ::pyo3::types::PyModule::new(py, "types")?;
     types.add_class::<::aws_smithy_http_server_python::types::Blob>()?;
     types.add_class::<::aws_smithy_http_server_python::types::DateTime>()?;
     types.add_class::<::aws_smithy_http_server_python::types::Format>()?;
     types.add_class::<::aws_smithy_http_server_python::types::ByteStream>()?;
     ::pyo3::py_run!(

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

@@ -1,1 +968,968 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Python handler for operation `ContentTypeParameters`.
 pub(crate) async fn content_type_parameters(
     input: crate::input::ContentTypeParametersInput,
 /// Python handler for operation `EmptyOperation`.
 pub(crate) async fn empty_operation(
     input: crate::input::EmptyOperationInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::ContentTypeParametersOutput,
     crate::error::ContentTypeParametersError,
 > {
 ) -> std::result::Result<crate::output::EmptyOperationOutput, crate::error::EmptyOperationError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "content_type_parameters",
             name = "empty_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::ContentTypeParametersOutput>(py)
             })
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EmptyOperationOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "content_type_parameters",
             name = "empty_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::ContentTypeParametersOutput>()
             output.extract::<crate::output::EmptyOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-52
+}
-53
 /// Python handler for operation `PutWithContentEncoding`.
 pub(crate) async fn put_with_content_encoding(
     input: crate::input::PutWithContentEncodingInput,
 /// Python handler for operation `KitchenSinkOperation`.
 pub(crate) async fn kitchen_sink_operation(
     input: crate::input::KitchenSinkOperationInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::PutWithContentEncodingOutput,
     crate::error::PutWithContentEncodingError,
     crate::output::KitchenSinkOperationOutput,
     crate::error::KitchenSinkOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "put_with_content_encoding",
             name = "kitchen_sink_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::PutWithContentEncodingOutput>(py)
                 r.extract::<crate::output::KitchenSinkOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "put_with_content_encoding",
             name = "kitchen_sink_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::PutWithContentEncodingOutput>()
             output.extract::<crate::output::KitchenSinkOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-109
+}
-110
 /// Python handler for operation `FractionalSeconds`.
 pub(crate) async fn fractional_seconds(
     input: crate::input::FractionalSecondsInput,
 /// Python handler for operation `SimpleScalarProperties`.
 pub(crate) async fn simple_scalar_properties(
     input: crate::input::SimpleScalarPropertiesInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::FractionalSecondsOutput, crate::error::FractionalSecondsError>
--
+{
 ) -> std::result::Result<
     crate::output::SimpleScalarPropertiesOutput,
     crate::error::SimpleScalarPropertiesError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "fractional_seconds",
             name = "simple_scalar_properties",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::FractionalSecondsOutput>(py))
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::SimpleScalarPropertiesOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "fractional_seconds",
             name = "simple_scalar_properties",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::FractionalSecondsOutput>()
             output.extract::<crate::output::SimpleScalarPropertiesOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-166
+}
-167
 /// Python handler for operation `DatetimeOffsets`.
 pub(crate) async fn datetime_offsets(
     input: crate::input::DatetimeOffsetsInput,
 /// Python handler for operation `OperationWithOptionalInputOutput`.
 pub(crate) async fn operation_with_optional_input_output(
     input: crate::input::OperationWithOptionalInputOutputInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::DatetimeOffsetsOutput, crate::error::DatetimeOffsetsError> {
 ) -> std::result::Result<
     crate::output::OperationWithOptionalInputOutputOutput,
     crate::error::OperationWithOptionalInputOutputError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "datetime_offsets",
             name = "operation_with_optional_input_output",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::DatetimeOffsetsOutput>(py))
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::OperationWithOptionalInputOutputOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "datetime_offsets",
             name = "operation_with_optional_input_output",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::DatetimeOffsetsOutput>()
             output.extract::<crate::output::OperationWithOptionalInputOutputOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-223
+}
-224
 /// Python handler for operation `HostWithPathOperation`.
 pub(crate) async fn host_with_path_operation(
     input: crate::input::HostWithPathOperationInput,
 /// Python handler for operation `PutAndGetInlineDocuments`.
 pub(crate) async fn put_and_get_inline_documents(
     input: crate::input::PutAndGetInlineDocumentsInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::HostWithPathOperationOutput,
     crate::error::HostWithPathOperationError,
     crate::output::PutAndGetInlineDocumentsOutput,
     crate::error::PutAndGetInlineDocumentsError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "host_with_path_operation",
             name = "put_and_get_inline_documents",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::HostWithPathOperationOutput>(py)
                 r.extract::<crate::output::PutAndGetInlineDocumentsOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "host_with_path_operation",
             name = "put_and_get_inline_documents",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::HostWithPathOperationOutput>()
             output.extract::<crate::output::PutAndGetInlineDocumentsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-280
+}
-281
 /// Python handler for operation `EndpointWithHostLabelOperation`.
 pub(crate) async fn endpoint_with_host_label_operation(
     input: crate::input::EndpointWithHostLabelOperationInput,
 /// Python handler for operation `JsonEnums`.
 pub(crate) async fn json_enums(
     input: crate::input::JsonEnumsInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::EndpointWithHostLabelOperationOutput,
     crate::error::EndpointWithHostLabelOperationError,
 > {
 ) -> std::result::Result<crate::output::JsonEnumsOutput, crate::error::JsonEnumsError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "endpoint_with_host_label_operation",
             "executing python handler coroutine"
         );
         ::tracing::trace!(name = "json_enums", "executing python handler coroutine");
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::EndpointWithHostLabelOperationOutput>(py)
             })
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::JsonEnumsOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "endpoint_with_host_label_operation",
             "executing python handler function"
         );
         ::tracing::trace!(name = "json_enums", "executing python handler function");
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::EndpointWithHostLabelOperationOutput>()
             output.extract::<crate::output::JsonEnumsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-326
+}
-327
 /// Python handler for operation `EndpointOperation`.
 pub(crate) async fn endpoint_operation(
     input: crate::input::EndpointOperationInput,
 /// Python handler for operation `JsonIntEnums`.
 pub(crate) async fn json_int_enums(
     input: crate::input::JsonIntEnumsInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::EndpointOperationOutput, crate::error::EndpointOperationError>
--
+{
 ) -> std::result::Result<crate::output::JsonIntEnumsOutput, crate::error::JsonIntEnumsError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "endpoint_operation",
             name = "json_int_enums",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EndpointOperationOutput>(py))
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::JsonIntEnumsOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "endpoint_operation",
             "executing python handler function"
         );
         ::tracing::trace!(name = "json_int_enums", "executing python handler function");
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::EndpointOperationOutput>()
             output.extract::<crate::output::JsonIntEnumsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-375
+}
-376
 /// Python handler for operation `JsonUnions`.
 pub(crate) async fn json_unions(
     input: crate::input::JsonUnionsInput,
 /// Python handler for operation `NullOperation`.
 pub(crate) async fn null_operation(
     input: crate::input::NullOperationInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::JsonUnionsOutput, crate::error::JsonUnionsError> {
 ) -> std::result::Result<crate::output::NullOperationOutput, crate::error::NullOperationError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(name = "json_unions", "executing python handler coroutine");
         ::tracing::trace!(
             name = "null_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::JsonUnionsOutput>(py))
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::NullOperationOutput>(py))
         })
     } else {
         ::tracing::trace!(name = "json_unions", "executing python handler function");
         ::tracing::trace!(name = "null_operation", "executing python handler function");
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::JsonUnionsOutput>()
             output.extract::<crate::output::NullOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-424
+}
-425
 /// Python handler for operation `GreetingWithErrors`.
 pub(crate) async fn greeting_with_errors(
     input: crate::input::GreetingWithErrorsInput,
 /// Python handler for operation `SparseNullsOperation`.
 pub(crate) async fn sparse_nulls_operation(
     input: crate::input::SparseNullsOperationInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::GreetingWithErrorsOutput,
     crate::error::GreetingWithErrorsError,
     crate::output::SparseNullsOperationOutput,
     crate::error::SparseNullsOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "greeting_with_errors",
             name = "sparse_nulls_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::GreetingWithErrorsOutput>(py))
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::SparseNullsOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "greeting_with_errors",
             name = "sparse_nulls_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::GreetingWithErrorsOutput>()
             output.extract::<crate::output::SparseNullsOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-481
+}
-482
 /// Python handler for operation `SparseNullsOperation`.
 pub(crate) async fn sparse_nulls_operation(
     input: crate::input::SparseNullsOperationInput,
 /// Python handler for operation `GreetingWithErrors`.
 pub(crate) async fn greeting_with_errors(
     input: crate::input::GreetingWithErrorsInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::SparseNullsOperationOutput,
     crate::error::SparseNullsOperationError,
     crate::output::GreetingWithErrorsOutput,
     crate::error::GreetingWithErrorsError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "sparse_nulls_operation",
             name = "greeting_with_errors",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::SparseNullsOperationOutput>(py)
             })
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::GreetingWithErrorsOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "sparse_nulls_operation",
             name = "greeting_with_errors",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::SparseNullsOperationOutput>()
             output.extract::<crate::output::GreetingWithErrorsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-536
+}
-537
 /// Python handler for operation `NullOperation`.
 pub(crate) async fn null_operation(
     input: crate::input::NullOperationInput,
 /// Python handler for operation `JsonUnions`.
 pub(crate) async fn json_unions(
     input: crate::input::JsonUnionsInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::NullOperationOutput, crate::error::NullOperationError> {
 ) -> std::result::Result<crate::output::JsonUnionsOutput, crate::error::JsonUnionsError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "null_operation",
             "executing python handler coroutine"
         );
         ::tracing::trace!(name = "json_unions", "executing python handler coroutine");
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::NullOperationOutput>(py))
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::JsonUnionsOutput>(py))
         })
     } else {
         ::tracing::trace!(name = "null_operation", "executing python handler function");
         ::tracing::trace!(name = "json_unions", "executing python handler function");
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::NullOperationOutput>()
             output.extract::<crate::output::JsonUnionsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-582
+}
-583
 /// Python handler for operation `JsonIntEnums`.
 pub(crate) async fn json_int_enums(
     input: crate::input::JsonIntEnumsInput,
 /// Python handler for operation `EndpointOperation`.
 pub(crate) async fn endpoint_operation(
     input: crate::input::EndpointOperationInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::JsonIntEnumsOutput, crate::error::JsonIntEnumsError> {
 ) -> std::result::Result<crate::output::EndpointOperationOutput, crate::error::EndpointOperationError>
-+
+{
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "json_int_enums",
             name = "endpoint_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::JsonIntEnumsOutput>(py))
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EndpointOperationOutput>(py))
         })
     } else {
         ::tracing::trace!(name = "json_int_enums", "executing python handler function");
         ::tracing::trace!(
             name = "endpoint_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::JsonIntEnumsOutput>()
             output.extract::<crate::output::EndpointOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-635
+}
-636
 /// Python handler for operation `JsonEnums`.
 pub(crate) async fn json_enums(
     input: crate::input::JsonEnumsInput,
 /// Python handler for operation `EndpointWithHostLabelOperation`.
 pub(crate) async fn endpoint_with_host_label_operation(
     input: crate::input::EndpointWithHostLabelOperationInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::JsonEnumsOutput, crate::error::JsonEnumsError> {
 ) -> std::result::Result<
     crate::output::EndpointWithHostLabelOperationOutput,
     crate::error::EndpointWithHostLabelOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(name = "json_enums", "executing python handler coroutine");
         ::tracing::trace!(
             name = "endpoint_with_host_label_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::JsonEnumsOutput>(py))
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::EndpointWithHostLabelOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(name = "json_enums", "executing python handler function");
         ::tracing::trace!(
             name = "endpoint_with_host_label_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::JsonEnumsOutput>()
             output.extract::<crate::output::EndpointWithHostLabelOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-692
+}
-693
 /// Python handler for operation `PutAndGetInlineDocuments`.
 pub(crate) async fn put_and_get_inline_documents(
     input: crate::input::PutAndGetInlineDocumentsInput,
 /// Python handler for operation `HostWithPathOperation`.
 pub(crate) async fn host_with_path_operation(
     input: crate::input::HostWithPathOperationInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::PutAndGetInlineDocumentsOutput,
     crate::error::PutAndGetInlineDocumentsError,
     crate::output::HostWithPathOperationOutput,
     crate::error::HostWithPathOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "put_and_get_inline_documents",
             name = "host_with_path_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::PutAndGetInlineDocumentsOutput>(py)
                 r.extract::<crate::output::HostWithPathOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "put_and_get_inline_documents",
             name = "host_with_path_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::PutAndGetInlineDocumentsOutput>()
             output.extract::<crate::output::HostWithPathOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-749
+}
-750
 /// Python handler for operation `OperationWithOptionalInputOutput`.
 pub(crate) async fn operation_with_optional_input_output(
     input: crate::input::OperationWithOptionalInputOutputInput,
 /// Python handler for operation `DatetimeOffsets`.
 pub(crate) async fn datetime_offsets(
     input: crate::input::DatetimeOffsetsInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::OperationWithOptionalInputOutputOutput,
     crate::error::OperationWithOptionalInputOutputError,
 > {
 ) -> std::result::Result<crate::output::DatetimeOffsetsOutput, crate::error::DatetimeOffsetsError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "operation_with_optional_input_output",
             name = "datetime_offsets",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::OperationWithOptionalInputOutputOutput>(py)
             })
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::DatetimeOffsetsOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "operation_with_optional_input_output",
             name = "datetime_offsets",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::OperationWithOptionalInputOutputOutput>()
             output.extract::<crate::output::DatetimeOffsetsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-801
+}
-802
 /// Python handler for operation `SimpleScalarProperties`.
 pub(crate) async fn simple_scalar_properties(
     input: crate::input::SimpleScalarPropertiesInput,
 /// Python handler for operation `FractionalSeconds`.
 pub(crate) async fn fractional_seconds(
     input: crate::input::FractionalSecondsInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::SimpleScalarPropertiesOutput,
     crate::error::SimpleScalarPropertiesError,
 > {
 ) -> std::result::Result<crate::output::FractionalSecondsOutput, crate::error::FractionalSecondsError>
-+
+{
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "simple_scalar_properties",
             name = "fractional_seconds",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::SimpleScalarPropertiesOutput>(py)
             })
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::FractionalSecondsOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "simple_scalar_properties",
             name = "fractional_seconds",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::SimpleScalarPropertiesOutput>()
             output.extract::<crate::output::FractionalSecondsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-854
+}
-855
 /// Python handler for operation `KitchenSinkOperation`.
 pub(crate) async fn kitchen_sink_operation(
     input: crate::input::KitchenSinkOperationInput,
 /// Python handler for operation `PutWithContentEncoding`.
 pub(crate) async fn put_with_content_encoding(
     input: crate::input::PutWithContentEncodingInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::KitchenSinkOperationOutput,
     crate::error::KitchenSinkOperationError,
     crate::output::PutWithContentEncodingOutput,
     crate::error::PutWithContentEncodingError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "kitchen_sink_operation",
             name = "put_with_content_encoding",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::KitchenSinkOperationOutput>(py)
                 r.extract::<crate::output::PutWithContentEncodingOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "kitchen_sink_operation",
             name = "put_with_content_encoding",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::KitchenSinkOperationOutput>()
             output.extract::<crate::output::PutWithContentEncodingOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-911
+}
-912
 /// Python handler for operation `EmptyOperation`.
 pub(crate) async fn empty_operation(
     input: crate::input::EmptyOperationInput,
 /// Python handler for operation `ContentTypeParameters`.
 pub(crate) async fn content_type_parameters(
     input: crate::input::ContentTypeParametersInput,
     state: ::aws_smithy_legacy_http_server::Extension<
         ::aws_smithy_http_server_python::context::PyContext,
     >,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::EmptyOperationOutput, crate::error::EmptyOperationError> {
 ) -> std::result::Result<
     crate::output::ContentTypeParametersOutput,
     crate::error::ContentTypeParametersError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "empty_operation",
             name = "content_type_parameters",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EmptyOperationOutput>(py))
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::ContentTypeParametersOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "empty_operation",
             name = "content_type_parameters",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::EmptyOperationOutput>()
             output.extract::<crate::output::ContentTypeParametersOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()

↧ Expand context

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

@@ -1,1 +202,201 @@

↥ Expand context

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2
3 3	`impl crate::constrained::Constrained for crate::model::MyUnion {`

     type Unconstrained = crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained;
-5
+}
-6
 impl From<crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained>
     for crate::constrained::MaybeConstrained<crate::model::MyUnion>
-9
+{
     fn from(value: crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained) -> Self {
         Self::Unconstrained(value)
-12
+    }
-13
+}
 pub(crate) mod foo_enum_list_unconstrained {
-15
 pub(crate) mod my_union_unconstrained {
--
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) enum MyUnionUnconstrained {
         BlobValue(::aws_smithy_http_server_python::types::Blob),
         BooleanValue(bool),
         EnumValue(::std::string::String),
         ListValue(::std::vec::Vec<::std::string::String>),
         MapValue(::std::collections::HashMap<::std::string::String, ::std::string::String>),
         NumberValue(i32),
         StringValue(::std::string::String),
         StructureValue(crate::model::GreetingStruct),
         TimestampValue(::aws_smithy_http_server_python::types::DateTime),
--
+    }
     impl ::std::convert::TryFrom<MyUnionUnconstrained> for crate::model::MyUnion {
         type Error = crate::model::my_union_internal::ConstraintViolation;
--
         fn try_from(value: MyUnionUnconstrained) -> ::std::result::Result<Self, Self::Error> {
             Ok(
         match value {
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::BlobValue(unconstrained) => Self::BlobValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::BooleanValue(unconstrained) => Self::BooleanValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::EnumValue(unconstrained) => Self::EnumValue(
                 unconstrained
                                         .try_into()
--
     pub(crate) struct FooEnumListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-18
                                         .map_err(Self::Error::EnumValue)?
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::ListValue(unconstrained) => Self::ListValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::MapValue(unconstrained) => Self::MapValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::NumberValue(unconstrained) => Self::NumberValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::StringValue(unconstrained) => Self::StringValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::StructureValue(unconstrained) => Self::StructureValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::TimestampValue(unconstrained) => Self::TimestampValue(
                 unconstrained
             ),
     impl From<FooEnumListUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,
-+
+        >
-+
+    {
         fn from(value: FooEnumListUnconstrained) -> Self {
             Self::Unconstrained(value)
-26
+        }
--
+    )
-+
+    }
     impl std::convert::TryFrom<FooEnumListUnconstrained>
         for crate::constrained::foo_enum_list_constrained::FooEnumListConstrained
-+
+    {
         type Error = crate::model::foo_enum_list_internal::ConstraintViolation;
         fn try_from(value: FooEnumListUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::FooEnum>,
                 (usize, crate::model::foo_enum_internal::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             Ok(Self(inner))
-49
+        }
-50
+    }
-51
+}
 pub(crate) mod integer_enum_set_unconstrained {
 pub(crate) mod foo_enum_set_unconstrained {
-53
     #[derive(Debug, Clone)]
     pub(crate) struct IntegerEnumSetUnconstrained(pub(crate) std::vec::Vec<i32>);
     pub(crate) struct FooEnumSetUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-56
     impl From<IntegerEnumSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::IntegerEnumSet>
     impl From<FooEnumSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::FooEnumSet>
-59
+    {
         fn from(value: IntegerEnumSetUnconstrained) -> Self {
         fn from(value: FooEnumSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-62
+        }
-63
+    }
     impl std::convert::TryFrom<IntegerEnumSetUnconstrained> for crate::model::IntegerEnumSet {
         type Error = crate::model::integer_enum_set_internal::ConstraintViolation;
         fn try_from(value: IntegerEnumSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             let inner = value.0;
     impl std::convert::TryFrom<FooEnumSetUnconstrained> for crate::model::FooEnumSet {
         type Error = crate::model::foo_enum_set_internal::ConstraintViolation;
         fn try_from(value: FooEnumSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::FooEnum>,
                 (usize, crate::model::foo_enum_internal::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             Self::try_from(inner)
-83
+        }
-84
+    }
-85
+}
 pub(crate) mod foo_enum_map_unconstrained {
-87
     #[derive(Debug, Clone)]
     pub(crate) struct FooEnumMapUnconstrained(
         pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
     );
-92
     impl From<FooEnumMapUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::foo_enum_map_constrained::FooEnumMapConstrained,
-96
+        >
-97
+    {
         fn from(value: FooEnumMapUnconstrained) -> Self {
             Self::Unconstrained(value)
-100
+        }
-101
+    }
     impl std::convert::TryFrom<FooEnumMapUnconstrained>
         for crate::constrained::foo_enum_map_constrained::FooEnumMapConstrained
-104
+    {
         type Error = crate::model::foo_enum_map_internal::ConstraintViolation;
         fn try_from(value: FooEnumMapUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::collections::HashMap<::std::string::String, crate::model::FooEnum>,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(|(k, v)| match crate::model::FooEnum::try_from(v) {
                     Ok(v) => Ok((k, v)),
                     Err(inner_constraint_violation) => {
                         Err(Self::Error::Value(k, inner_constraint_violation))
-117
+                    }
                 })
                 .collect();
             let hm = res?;
             Ok(Self(hm))
-122
+        }
-123
+    }
-124
+}
 pub(crate) mod foo_enum_set_unconstrained {
 pub(crate) mod integer_enum_set_unconstrained {
-126
     #[derive(Debug, Clone)]
     pub(crate) struct FooEnumSetUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
     pub(crate) struct IntegerEnumSetUnconstrained(pub(crate) std::vec::Vec<i32>);
-129
     impl From<FooEnumSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::FooEnumSet>
     impl From<IntegerEnumSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::IntegerEnumSet>
-132
+    {
         fn from(value: FooEnumSetUnconstrained) -> Self {
         fn from(value: IntegerEnumSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-135
+        }
-136
+    }
     impl std::convert::TryFrom<FooEnumSetUnconstrained> for crate::model::FooEnumSet {
         type Error = crate::model::foo_enum_set_internal::ConstraintViolation;
         fn try_from(value: FooEnumSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::FooEnum>,
                 (usize, crate::model::foo_enum_internal::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
     impl std::convert::TryFrom<IntegerEnumSetUnconstrained> for crate::model::IntegerEnumSet {
         type Error = crate::model::integer_enum_set_internal::ConstraintViolation;
         fn try_from(value: IntegerEnumSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             let inner = value.0;
             Self::try_from(inner)
-142
+        }
-143
+    }
-144
+}
 pub(crate) mod foo_enum_list_unconstrained {
 pub(crate) mod my_union_unconstrained {
-146
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) struct FooEnumListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
--
     impl From<FooEnumListUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,
--
+        >
--
+    {
         fn from(value: FooEnumListUnconstrained) -> Self {
             Self::Unconstrained(value)
--
+        }
     pub(crate) enum MyUnionUnconstrained {
         BlobValue(::aws_smithy_http_server_python::types::Blob),
         BooleanValue(bool),
         EnumValue(::std::string::String),
         ListValue(::std::vec::Vec<::std::string::String>),
         MapValue(::std::collections::HashMap<::std::string::String, ::std::string::String>),
         NumberValue(i32),
         StringValue(::std::string::String),
         StructureValue(crate::model::GreetingStruct),
         TimestampValue(::aws_smithy_http_server_python::types::DateTime),
-159
+    }
     impl std::convert::TryFrom<FooEnumListUnconstrained>
         for crate::constrained::foo_enum_list_constrained::FooEnumListConstrained
--
+    {
         type Error = crate::model::foo_enum_list_internal::ConstraintViolation;
         fn try_from(value: FooEnumListUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::FooEnum>,
                 (usize, crate::model::foo_enum_internal::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
     impl ::std::convert::TryFrom<MyUnionUnconstrained> for crate::model::MyUnion {
         type Error = crate::model::my_union_internal::ConstraintViolation;
-+
         fn try_from(value: MyUnionUnconstrained) -> ::std::result::Result<Self, Self::Error> {
             Ok(
         match value {
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::BlobValue(unconstrained) => Self::BlobValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::BooleanValue(unconstrained) => Self::BooleanValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::EnumValue(unconstrained) => Self::EnumValue(
                 unconstrained
                                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             Ok(Self(inner))
-+
-+
                                         .map_err(Self::Error::EnumValue)?
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::ListValue(unconstrained) => Self::ListValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::MapValue(unconstrained) => Self::MapValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::NumberValue(unconstrained) => Self::NumberValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::StringValue(unconstrained) => Self::StringValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::StructureValue(unconstrained) => Self::StructureValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::TimestampValue(unconstrained) => Self::TimestampValue(
                 unconstrained
             ),
-+
+        }
-+
+    )
-199
+        }
-200
+    }
-201
+}

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

@@ -1,1 +197,243 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Error type for the `ResponseCodeDefaultOperation` operation.
 /// Each variant represents an error that can occur for the `ResponseCodeDefaultOperation` operation.
 /// Error type for the `TypeComplexityOperation` operation.
 /// Each variant represents an error that can occur for the `TypeComplexityOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum ResponseCodeDefaultOperationError {
 pub enum TypeComplexityOperationError {
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-8
+}
 impl ::std::fmt::Display for ResponseCodeDefaultOperationError {
 impl ::std::fmt::Display for TypeComplexityOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => _inner.fmt(f),
             TypeComplexityOperationError::InternalServerError(_inner) => _inner.fmt(f),
-13
+        }
-14
+    }
-15
+}
 impl ResponseCodeDefaultOperationError {
     /// Returns `true` if the error kind is `ResponseCodeDefaultOperationError::InternalServerError`.
 impl TypeComplexityOperationError {
     /// Returns `true` if the error kind is `TypeComplexityOperationError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             ResponseCodeDefaultOperationError::InternalServerError(_)
--
+        )
         matches!(&self, TypeComplexityOperationError::InternalServerError(_))
-20
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => _inner.name(),
             TypeComplexityOperationError::InternalServerError(_inner) => _inner.name(),
-25
+        }
-26
+    }
-27
+}
 impl ::std::error::Error for ResponseCodeDefaultOperationError {
 impl ::std::error::Error for TypeComplexityOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => Some(_inner),
             TypeComplexityOperationError::InternalServerError(_inner) => Some(_inner),
-32
+        }
-33
+    }
-34
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::ResponseCodeDefaultOperationError
     for crate::error::TypeComplexityOperationError
-37
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::ResponseCodeDefaultOperationError {
     ) -> crate::error::TypeComplexityOperationError {
         Self::InternalServerError(variant)
-42
+    }
-43
+}
-44
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeDefaultOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeDefaultOperationError {
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::TypeComplexityOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::TypeComplexityOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-49
             crate::error::InternalServerError {
                 message: error.to_string(),
-52
+            }
             .into()
         })
-55
+    }
-56
+}
-57
 #[::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:
 /// Error type for the `RequiredInnerShapeOperation` operation.
 /// Each variant represents an error that can occur for the `RequiredInnerShapeOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum RequiredInnerShapeOperationError {
     /// 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
     pub message: ::std::string::String,
     InternalServerError(crate::error::InternalServerError),
-66
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl InternalServerError {
     #[new]
     pub fn new(message: ::std::string::String) -> Self {
         Self { message }
--
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
 impl ::std::fmt::Display for RequiredInnerShapeOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => _inner.fmt(f),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => _inner.fmt(f),
-72
+        }
     fn __str__(&self) -> String {
         format!("{self:?}")
-73
+    }
-74
+}
 impl InternalServerError {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
 impl RequiredInnerShapeOperationError {
     /// Returns `true` if the error kind is `RequiredInnerShapeOperationError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(
             &self,
             RequiredInnerShapeOperationError::ValidationException(_)
-+
+        )
-82
+    }
     #[doc(hidden)]
     /// Returns the error name.
     /// Returns `true` if the error kind is `RequiredInnerShapeOperationError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             RequiredInnerShapeOperationError::InternalServerError(_)
-+
+        )
-+
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         "InternalServerError"
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => _inner.name(),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => _inner.name(),
-+
+        }
-96
+    }
-97
+}
 impl ::std::fmt::Display for InternalServerError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "InternalServerError")?;
--
+        {
             ::std::write!(f, ": {}", &self.message)?;
 impl ::std::error::Error for RequiredInnerShapeOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => Some(_inner),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => Some(_inner),
-103
+        }
         Ok(())
-104
+    }
-105
+}
 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()
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::RequiredInnerShapeOperationError
-+
+{
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::RequiredInnerShapeOperationError {
         Self::ValidationException(variant)
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::RequiredInnerShapeOperationError
-+
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::RequiredInnerShapeOperationError {
         Self::InternalServerError(variant)
-122
+    }
-123
+}
-124
 /// Error type for the `ResponseCodeHttpFallbackOperation` operation.
 /// Each variant represents an error that can occur for the `ResponseCodeHttpFallbackOperation` operation.
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::RequiredInnerShapeOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::RequiredInnerShapeOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {
                 return error.into();
-+
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
-+
+            }
             .into()
         })
-+
+    }
-+
+}
-+
 /// Error type for the `RequiredHeaderCollectionOperation` operation.
 /// Each variant represents an error that can occur for the `RequiredHeaderCollectionOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum ResponseCodeHttpFallbackOperationError {
 pub enum RequiredHeaderCollectionOperationError {
     /// 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
     InternalServerError(crate::error::InternalServerError),
-148
+}
 impl ::std::fmt::Display for ResponseCodeHttpFallbackOperationError {
 impl ::std::fmt::Display for RequiredHeaderCollectionOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => _inner.fmt(f),
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => _inner.fmt(f),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => _inner.fmt(f),
-154
+        }
-155
+    }
-156
+}
 impl ResponseCodeHttpFallbackOperationError {
     /// Returns `true` if the error kind is `ResponseCodeHttpFallbackOperationError::InternalServerError`.
 impl RequiredHeaderCollectionOperationError {
     /// Returns `true` if the error kind is `RequiredHeaderCollectionOperationError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(
             &self,
             RequiredHeaderCollectionOperationError::ValidationException(_)
-+
+        )
-+
+    }
     /// Returns `true` if the error kind is `RequiredHeaderCollectionOperationError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             ResponseCodeHttpFallbackOperationError::InternalServerError(_)
             RequiredHeaderCollectionOperationError::InternalServerError(_)
-170
+        )
-171
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => _inner.name(),
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => _inner.name(),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => _inner.name(),
-177
+        }
-178
+    }
-179
+}
 impl ::std::error::Error for ResponseCodeHttpFallbackOperationError {
 impl ::std::error::Error for RequiredHeaderCollectionOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => Some(_inner),
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => Some(_inner),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => Some(_inner),
-185
+        }
-186
+    }
-187
+}
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::RequiredHeaderCollectionOperationError
-+
+{
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::RequiredHeaderCollectionOperationError {
         Self::ValidationException(variant)
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::ResponseCodeHttpFallbackOperationError
     for crate::error::RequiredHeaderCollectionOperationError
-199
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::ResponseCodeHttpFallbackOperationError {
     ) -> crate::error::RequiredHeaderCollectionOperationError {
         Self::InternalServerError(variant)
-204
+    }
-205
+}
-206
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeHttpFallbackOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeHttpFallbackOperationError {
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::RequiredHeaderCollectionOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::RequiredHeaderCollectionOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
--
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {
                 return error.into();
-+
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
-216
+            }
             .into()
         })
-219
+    }
-220
+}
-221
 /// Error type for the `ResponseCodeRequiredOperation` operation.
 /// Each variant represents an error that can occur for the `ResponseCodeRequiredOperation` operation.

↧ Expand context

 #[derive(::std::fmt::Debug)]
 pub enum ResponseCodeRequiredOperationError {
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-228
+}
 impl ::std::fmt::Display for ResponseCodeRequiredOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             ResponseCodeRequiredOperationError::InternalServerError(_inner) => _inner.fmt(f),
-233
+        }
-234
+    }
-235
+}
 impl ResponseCodeRequiredOperationError {
     /// Returns `true` if the error kind is `ResponseCodeRequiredOperationError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             ResponseCodeRequiredOperationError::InternalServerError(_)
-242
+        )
-243
+    }

@@ -205,251 +346,484 @@

↥ Expand context

 impl ::std::error::Error for ResponseCodeRequiredOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             ResponseCodeRequiredOperationError::InternalServerError(_inner) => Some(_inner),
-255
+        }
-256
+    }
-257
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::ResponseCodeRequiredOperationError
-260
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::ResponseCodeRequiredOperationError {
         Self::InternalServerError(variant)
-265
+    }
-266
+}
-267
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeRequiredOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeRequiredOperationError {
         ::pyo3::Python::with_gil(|py| {

             let error = variant.value(py);
-272
             crate::error::InternalServerError {
                 message: error.to_string(),
-275
+            }
             .into()
         })
-278
+    }
-279
+}
-280
 /// Error type for the `RequiredHeaderCollectionOperation` operation.
 /// Each variant represents an error that can occur for the `RequiredHeaderCollectionOperation` operation.
 /// Error type for the `ResponseCodeHttpFallbackOperation` operation.
 /// Each variant represents an error that can occur for the `ResponseCodeHttpFallbackOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum RequiredHeaderCollectionOperationError {
     /// 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),
 pub enum ResponseCodeHttpFallbackOperationError {
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-287
+}
 impl ::std::fmt::Display for RequiredHeaderCollectionOperationError {
 impl ::std::fmt::Display for ResponseCodeHttpFallbackOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => _inner.fmt(f),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => _inner.fmt(f),
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => _inner.fmt(f),
-292
+        }
-293
+    }
-294
+}
 impl RequiredHeaderCollectionOperationError {
     /// Returns `true` if the error kind is `RequiredHeaderCollectionOperationError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(
             &self,
             RequiredHeaderCollectionOperationError::ValidationException(_)
--
+        )
--
+    }
     /// Returns `true` if the error kind is `RequiredHeaderCollectionOperationError::InternalServerError`.
 impl ResponseCodeHttpFallbackOperationError {
     /// Returns `true` if the error kind is `ResponseCodeHttpFallbackOperationError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             RequiredHeaderCollectionOperationError::InternalServerError(_)
             ResponseCodeHttpFallbackOperationError::InternalServerError(_)
-301
+        )
-302
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => _inner.name(),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => _inner.name(),
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => _inner.name(),
-307
+        }
-308
+    }
-309
+}
 impl ::std::error::Error for RequiredHeaderCollectionOperationError {
 impl ::std::error::Error for ResponseCodeHttpFallbackOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => Some(_inner),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => Some(_inner),
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => Some(_inner),
-314
+        }
-315
+    }
-316
+}
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::RequiredHeaderCollectionOperationError
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::ResponseCodeHttpFallbackOperationError
-319
+{
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::RequiredHeaderCollectionOperationError {
         Self::ValidationException(variant)
         variant: crate::error::InternalServerError,
     ) -> crate::error::ResponseCodeHttpFallbackOperationError {
         Self::InternalServerError(variant)
-+
+    }
-+
+}
-+
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeHttpFallbackOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeHttpFallbackOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-+
             crate::error::InternalServerError {
                 message: error.to_string(),
-+
+            }
             .into()
         })
-+
+    }
-+
+}
-+
 /// Error type for the `ResponseCodeDefaultOperation` operation.
 /// Each variant represents an error that can occur for the `ResponseCodeDefaultOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum ResponseCodeDefaultOperationError {
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-+
+}
 impl ::std::fmt::Display for ResponseCodeDefaultOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => _inner.fmt(f),
-+
+        }
-+
+    }
-+
+}
 impl ResponseCodeDefaultOperationError {
     /// Returns `true` if the error kind is `ResponseCodeDefaultOperationError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             ResponseCodeDefaultOperationError::InternalServerError(_)
-+
+        )
-+
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => _inner.name(),
-+
+        }
-+
+    }
-+
+}
 impl ::std::error::Error for ResponseCodeDefaultOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => Some(_inner),
-+
+        }
-374
+    }
-375
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::RequiredHeaderCollectionOperationError
     for crate::error::ResponseCodeDefaultOperationError
-378
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::RequiredHeaderCollectionOperationError {
     ) -> crate::error::ResponseCodeDefaultOperationError {
         Self::InternalServerError(variant)
-383
+    }
-384
+}
-385
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::RequiredHeaderCollectionOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::RequiredHeaderCollectionOperationError {
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeDefaultOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeDefaultOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {
                 return error.into();
--
+            }
-+
             crate::error::InternalServerError {
                 message: error.to_string(),
-393
+            }
             .into()
         })
-396
+    }
-397
+}
-398
 #[::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,
-+
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl InternalServerError {
     #[new]
     pub fn new(message: ::std::string::String) -> Self {
         Self { message }
-+
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-+
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-+
+    }
-+
+}
 impl InternalServerError {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-+
+    }
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "InternalServerError"
-+
+    }
-+
+}
 impl ::std::fmt::Display for InternalServerError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "InternalServerError")?;
-+
+        {
             ::std::write!(f, ": {}", &self.message)?;
-+
+        }
         Ok(())
-+
+    }
-+
+}
 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()
-+
+    }
-+
+}
-+
 #[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 /// :param message str:
 /// :param field_list typing.Optional\[typing.List\[misc.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)]

↧ Expand context

     /// :type str:
     /// A summary of the validation failure.
     pub message: ::std::string::String,
     #[pyo3(get, set)]
     /// :type typing.Optional\[typing.List\[misc.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>>,
-472
+}
 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()
-477
+    }
-478
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl ValidationException {
     #[new]
     pub fn new(

@@ -359,497 +556,556 @@

↥ Expand context

         format!("{self:?}")
-498
+    }
-499
+}
 impl ValidationException {
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-504
+    }
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "ValidationException"
-509
+    }
-510
+}
 impl ::std::fmt::Display for ValidationException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         ::std::write!(f, "ValidationException")?;
-514
+        {
             ::std::write!(f, ": {}", &self.message)?;
-516
+        }

         Ok(())
-518
+    }
-519
+}
 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()
-525
+    }
-526
+}
--
 /// Error type for the `RequiredInnerShapeOperation` operation.
 /// Each variant represents an error that can occur for the `RequiredInnerShapeOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum RequiredInnerShapeOperationError {
     /// 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
     InternalServerError(crate::error::InternalServerError),
--
+}
 impl ::std::fmt::Display for RequiredInnerShapeOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => _inner.fmt(f),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => _inner.fmt(f),
--
+        }
--
+    }
--
+}
 impl RequiredInnerShapeOperationError {
     /// Returns `true` if the error kind is `RequiredInnerShapeOperationError::ValidationException`.
     pub fn is_validation_exception(&self) -> bool {
         matches!(
             &self,
             RequiredInnerShapeOperationError::ValidationException(_)
--
+        )
--
+    }
     /// Returns `true` if the error kind is `RequiredInnerShapeOperationError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(
             &self,
             RequiredInnerShapeOperationError::InternalServerError(_)
--
+        )
--
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => _inner.name(),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => _inner.name(),
--
+        }
--
+    }
--
+}
 impl ::std::error::Error for RequiredInnerShapeOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => Some(_inner),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => Some(_inner),
--
+        }
--
+    }
--
+}
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::RequiredInnerShapeOperationError
--
+{
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::RequiredInnerShapeOperationError {
         Self::ValidationException(variant)
--
+    }
--
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::RequiredInnerShapeOperationError
--
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::RequiredInnerShapeOperationError {
         Self::InternalServerError(variant)
--
+    }
--
+}
--
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::RequiredInnerShapeOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::RequiredInnerShapeOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {
                 return error.into();
--
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
--
+            }
             .into()
         })
--
+    }
--
+}
--
 /// Error type for the `TypeComplexityOperation` operation.
 /// Each variant represents an error that can occur for the `TypeComplexityOperation` operation.
 #[derive(::std::fmt::Debug)]
 pub enum TypeComplexityOperationError {
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
--
+}
 impl ::std::fmt::Display for TypeComplexityOperationError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             TypeComplexityOperationError::InternalServerError(_inner) => _inner.fmt(f),
--
+        }
--
+    }
--
+}
 impl TypeComplexityOperationError {
     /// Returns `true` if the error kind is `TypeComplexityOperationError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(&self, TypeComplexityOperationError::InternalServerError(_))
--
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             TypeComplexityOperationError::InternalServerError(_inner) => _inner.name(),
--
+        }
--
+    }
--
+}
 impl ::std::error::Error for TypeComplexityOperationError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             TypeComplexityOperationError::InternalServerError(_inner) => Some(_inner),
--
+        }
--
+    }
--
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::TypeComplexityOperationError
--
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::TypeComplexityOperationError {
         Self::InternalServerError(variant)
--
+    }
--
+}
--
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::TypeComplexityOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::TypeComplexityOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
--
             crate::error::InternalServerError {
                 message: error.to_string(),
--
+            }
             .into()
         })
--
+    }
--
+}
 /// See [`InternalServerError`](crate::error::InternalServerError).
 pub mod internal_server_error {
-529
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `InternalServerError`.
         MissingMessage,
-536
+    }

↧ Expand context

     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
-541
+            }
-542
+        }
-543
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::error::InternalServerError {
         type Error = ConstraintViolation;
-547
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-550
+        }
-551
+    }
     /// A builder for [`InternalServerError`](crate::error::InternalServerError).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) message: ::std::option::Option<::std::string::String>,
-556
+    }

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

967 967	`})`
968 968	`}`