Server Test Python

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

@@ -1,1 +542,553 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `QueryPrecedence`.
 pub(crate) async fn query_precedence(
     input: crate::input::QueryPrecedenceInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::QueryPrecedenceOutput, crate::error::QueryPrecedenceError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "query_precedence",
             "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::QueryPrecedenceOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "query_precedence",
             "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::QueryPrecedenceOutput>()
         })
     };
     // 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()
     })
-51
+}
-52
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `EmptyStructWithContentOnWireOp`.
 pub(crate) async fn empty_struct_with_content_on_wire_op(
     input: crate::input::EmptyStructWithContentOnWireOpInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::EmptyStructWithContentOnWireOpOutput,
     crate::error::EmptyStructWithContentOnWireOpError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "empty_struct_with_content_on_wire_op",
             "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::EmptyStructWithContentOnWireOpOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "empty_struct_with_content_on_wire_op",
             "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::EmptyStructWithContentOnWireOpOutput>()
         })
     };
     // 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()
     })
-107
+}
-108
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `CaseInsensitiveErrorOperation`.
 pub(crate) async fn case_insensitive_error_operation(
     input: crate::input::CaseInsensitiveErrorOperationInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::CaseInsensitiveErrorOperationOutput,
     crate::error::CaseInsensitiveErrorOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "case_insensitive_error_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::CaseInsensitiveErrorOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "case_insensitive_error_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::CaseInsensitiveErrorOperationOutput>()
         })
     };
     // 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()
     })
-163
+}
-164
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `NullInNonSparse`.
 pub(crate) async fn null_in_non_sparse(
     input: crate::input::NullInNonSparseInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::NullInNonSparseOutput, crate::error::NullInNonSparseError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "null_in_non_sparse",
             "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::NullInNonSparseOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "null_in_non_sparse",
             "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::NullInNonSparseOutput>()
         })
     };
     // 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()
     })
-214
+}
-215
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `EscapedStringValues`.
 pub(crate) async fn escaped_string_values(
     input: crate::input::EscapedStringValuesInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::EscapedStringValuesOutput,
     crate::error::EscapedStringValuesError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "escaped_string_values",
             "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::EscapedStringValuesOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "escaped_string_values",
             "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::EscapedStringValuesOutput>()
         })
     };
     // 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()
     })
-268
+}
-269
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `PrimitiveIntOp`.
 pub(crate) async fn primitive_int_op(
     input: crate::input::PrimitiveIntOpInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::PrimitiveIntOpOutput, crate::error::PrimitiveIntOpError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "primitive_int_op",
             "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::PrimitiveIntOpOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "primitive_int_op",
             "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::PrimitiveIntOpOutput>()
         })
     };
     // 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()
     })
-319
+}
-320
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `MapWithEnumKeyOp`.
 pub(crate) async fn map_with_enum_key_op(
     input: crate::input::MapWithEnumKeyOpInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::MapWithEnumKeyOpOutput, crate::error::MapWithEnumKeyOpError>
-328
+{
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "map_with_enum_key_op",
             "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::MapWithEnumKeyOpOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "map_with_enum_key_op",
             "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::MapWithEnumKeyOpOutput>()
         })
     };
     // 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()
     })
-371
+}
-372
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `StatusResponse`.
 pub(crate) async fn status_response(
     input: crate::input::StatusResponseInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::StatusResponseOutput, crate::error::StatusResponseError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "status_response",
             "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::StatusResponseOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "status_response",
             "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::StatusResponseOutput>()
         })
     };
     // 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()
     })
-422
+}
-423
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `EnumQuery`.
 pub(crate) async fn enum_query(
     input: crate::input::EnumQueryInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::EnumQueryOutput, crate::error::EnumQueryError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(name = "enum_query", "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::EnumQueryOutput>(py))
         })
     } else {
         ::tracing::trace!(name = "enum_query", "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::EnumQueryOutput>()
         })
     };
     // 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()
     })
-467
+}
-468
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `PrimitiveIntHeader`.
 pub(crate) async fn primitive_int_header(
     input: crate::input::PrimitiveIntHeaderInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::PrimitiveIntHeaderOutput,
     crate::error::PrimitiveIntHeaderError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "primitive_int_header",
             "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::PrimitiveIntHeaderOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "primitive_int_header",
             "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::PrimitiveIntHeaderOutput>()
         })
     };
     // 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()
     })
-521
+}
-522
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `StringPayload`.
 pub(crate) async fn string_payload(
     input: crate::input::StringPayloadInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::StringPayloadOutput, crate::error::StringPayloadError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "string_payload",

↧ Expand context

             "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::StringPayloadOutput>(py))
         })
     } else {
         ::tracing::trace!(name = "string_payload", "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,))?

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

@@ -1,1 +336,365 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* PythonApplicationGenerator.kt:386 */
 #[allow(clippy::tabs_in_doc_comments)]
 /// Main Python application, used to register operations and context and start multiple
 /// workers on the same shared socket.
 ///
 /// Operations can be registered using the application object as a decorator (`@app.operation_name`).
 ///
 /// Here's a full example to get you started:
 ///
 /// ```python
 /* PythonApplicationGenerator.kt:399 */
 /// from rest_json_extras import input
 /// from rest_json_extras import output
 /* PythonApplicationGenerator.kt:406 */
 /// from rest_json_extras import error
 /* PythonApplicationGenerator.kt:408 */
 /// from rest_json_extras import middleware
 /// from rest_json_extras import App
 ///
 /// @dataclass
 /// class Context:
 ///     counter: int = 0
 ///
 /// app = App()
 /// app.context(Context())
 ///
 /// @app.request_middleware
 /// def request_middleware(request: middleware::Request):
 ///     if request.get_header("x-amzn-id") != "secret":
 ///         raise middleware.MiddlewareException("Unsupported `x-amz-id` header", 401)
 ///
 /* PythonApplicationGenerator.kt:441 */
 /// @app.case_insensitive_error_operation
 /// def case_insensitive_error_operation(input: input::CaseInsensitiveErrorOperationInput, ctx: Context) -> output::CaseInsensitiveErrorOperationOutput:
 ///     raise NotImplementedError
 ///
 /// @app.empty_struct_with_content_on_wire_op
 /// def empty_struct_with_content_on_wire_op(input: input::EmptyStructWithContentOnWireOpInput, ctx: Context) -> output::EmptyStructWithContentOnWireOpOutput:
 ///     raise NotImplementedError
 ///
 /// @app.enum_query
 /// def enum_query(input: input::EnumQueryInput, ctx: Context) -> output::EnumQueryOutput:
 ///     raise NotImplementedError
 ///
 /// @app.escaped_string_values
 /// def escaped_string_values(input: input::EscapedStringValuesInput, ctx: Context) -> output::EscapedStringValuesOutput:
 ///     raise NotImplementedError
 ///
 /// @app.map_with_enum_key_op
 /// def map_with_enum_key_op(input: input::MapWithEnumKeyOpInput, ctx: Context) -> output::MapWithEnumKeyOpOutput:
 ///     raise NotImplementedError
 ///
 /// @app.null_in_non_sparse
 /// def null_in_non_sparse(input: input::NullInNonSparseInput, ctx: Context) -> output::NullInNonSparseOutput:
 ///     raise NotImplementedError
 ///
 /// @app.primitive_int_header
 /// def primitive_int_header(input: input::PrimitiveIntHeaderInput, ctx: Context) -> output::PrimitiveIntHeaderOutput:
 ///     raise NotImplementedError
 ///
 /// @app.primitive_int_op
 /// def primitive_int_op(input: input::PrimitiveIntOpInput, ctx: Context) -> output::PrimitiveIntOpOutput:
 ///     raise NotImplementedError
 ///
 /// @app.query_precedence
 /// def query_precedence(input: input::QueryPrecedenceInput, ctx: Context) -> output::QueryPrecedenceOutput:
 ///     raise NotImplementedError
 ///
 /// @app.status_response
 /// def status_response(input: input::StatusResponseInput, ctx: Context) -> output::StatusResponseOutput:
 ///     raise NotImplementedError
 ///
 /// @app.string_payload
 /// def string_payload(input: input::StringPayloadInput, ctx: Context) -> output::StringPayloadOutput:
 ///     raise NotImplementedError
 /* PythonApplicationGenerator.kt:428 */
 ///
 /// app.run()
 /// ```
 ///
 /// Any of operations above can be written as well prepending the `async` keyword and
 /// the Python application will automatically handle it and schedule it on the event loop for you.
 /* PythonApplicationGenerator.kt:112 */
 #[::pyo3::pyclass]
 #[derive(Debug)]
 /// :generic Ctx:
 /// :extends typing.Generic\[Ctx\]:
 /// :rtype None:
 pub struct App {
     handlers: ::std::collections::HashMap<String, ::aws_smithy_http_server_python::PyHandler>,
     middlewares: Vec<::aws_smithy_http_server_python::PyMiddlewareHandler>,
     context: Option<::pyo3::PyObject>,
     workers: ::parking_lot::Mutex<Vec<::pyo3::PyObject>>,
-95
+}
 /* PythonApplicationGenerator.kt:149 */
 impl Default for App {
     fn default() -> Self {
         Self {
             handlers: Default::default(),
             middlewares: vec![],
             context: None,
             workers: ::parking_lot::Mutex::new(vec![]),
-104
+        }
-105
+    }
-106
+}
 /* PythonApplicationGenerator.kt:131 */
 impl Clone for App {
     fn clone(&self) -> Self {
         Self {
             handlers: self.handlers.clone(),
             middlewares: self.middlewares.clone(),
             context: self.context.clone(),
             workers: ::parking_lot::Mutex::new(vec![]),
-115
+        }
-116
+    }
-117
+}
 /* PythonApplicationGenerator.kt:168 */
 impl ::aws_smithy_http_server_python::PyApp for App {
     /* PythonApplicationGenerator.kt:174 */
     fn workers(&self) -> &::parking_lot::Mutex<Vec<::pyo3::PyObject>> {
         &self.workers
-123
+    }
     fn context(&self) -> &Option<::pyo3::PyObject> {
         &self.context
-126
+    }
     fn handlers(
         &mut self,
     ) -> &mut ::std::collections::HashMap<String, ::aws_smithy_http_server_python::PyHandler> {
         &mut self.handlers
-131
+    }
     /* PythonApplicationGenerator.kt:189 */
     fn build_service(
         &mut self,
         event_loop: &::pyo3::PyAny,
     ) -> ::pyo3::PyResult<
         ::tower::util::BoxCloneService<
             ::http::Request<::aws_smithy_http_server::body::Body>,
             ::http::Response<::aws_smithy_http_server::body::BoxBody>,
             std::convert::Infallible,
         >,
     > {
         /* PythonApplicationGenerator.kt:201 */
         let builder = crate::service::RestJsonExtras::builder_without_plugins();
         /* PythonApplicationGenerator.kt:209 */
         let case_insensitive_error_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("case_insensitive_error_operation")
             .expect("Python handler for operation `case_insensitive_error_operation` not found")
             .clone();
         let builder = builder.case_insensitive_error_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 case_insensitive_error_operation_locals.clone(),
                 crate::python_operation_adaptor::case_insensitive_error_operation(
                     input,
                     state,
                     handler.clone(),
                 ),
-160
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let empty_struct_with_content_on_wire_op_locals =
             ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("empty_struct_with_content_on_wire_op")
             .expect("Python handler for operation `empty_struct_with_content_on_wire_op` not found")
             .clone();
         let builder = builder.empty_struct_with_content_on_wire_op(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 empty_struct_with_content_on_wire_op_locals.clone(),
                 crate::python_operation_adaptor::empty_struct_with_content_on_wire_op(
                     input,
                     state,
                     handler.clone(),
                 ),
-178
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let enum_query_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("enum_query")
             .expect("Python handler for operation `enum_query` not found")
             .clone();
         let builder = builder.enum_query(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 enum_query_locals.clone(),
                 crate::python_operation_adaptor::enum_query(input, state, handler.clone()),
-191
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let escaped_string_values_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("escaped_string_values")
             .expect("Python handler for operation `escaped_string_values` not found")
             .clone();
         let builder = builder.escaped_string_values(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 escaped_string_values_locals.clone(),
                 crate::python_operation_adaptor::escaped_string_values(
                     input,
                     state,
                     handler.clone(),
                 ),
-208
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let map_with_enum_key_op_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("map_with_enum_key_op")
             .expect("Python handler for operation `map_with_enum_key_op` not found")
             .clone();
         let builder = builder.map_with_enum_key_op(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 map_with_enum_key_op_locals.clone(),
                 crate::python_operation_adaptor::map_with_enum_key_op(
                     input,
                     state,
                     handler.clone(),
                 ),
-225
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let null_in_non_sparse_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("null_in_non_sparse")
             .expect("Python handler for operation `null_in_non_sparse` not found")
             .clone();
         let builder = builder.null_in_non_sparse(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 null_in_non_sparse_locals.clone(),
                 crate::python_operation_adaptor::null_in_non_sparse(input, state, handler.clone()),
-238
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let primitive_int_header_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("primitive_int_header")
             .expect("Python handler for operation `primitive_int_header` not found")
             .clone();
         let builder = builder.primitive_int_header(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 primitive_int_header_locals.clone(),
                 crate::python_operation_adaptor::primitive_int_header(
                     input,
                     state,
                     handler.clone(),
                 ),
-255
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let primitive_int_op_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("primitive_int_op")
             .expect("Python handler for operation `primitive_int_op` not found")
             .clone();
         let builder = builder.primitive_int_op(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 primitive_int_op_locals.clone(),
                 crate::python_operation_adaptor::primitive_int_op(input, state, handler.clone()),
-268
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let query_precedence_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("query_precedence")
             .expect("Python handler for operation `query_precedence` not found")
             .clone();
         let builder = builder.query_precedence(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 query_precedence_locals.clone(),
                 crate::python_operation_adaptor::query_precedence(input, state, handler.clone()),
-281
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let status_response_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("status_response")
             .expect("Python handler for operation `status_response` not found")
             .clone();
         let builder = builder.status_response(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 status_response_locals.clone(),
                 crate::python_operation_adaptor::status_response(input, state, handler.clone()),
-294
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let string_payload_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("string_payload")
             .expect("Python handler for operation `string_payload` not found")
             .clone();
         let builder = builder.string_payload(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 string_payload_locals.clone(),
                 crate::python_operation_adaptor::string_payload(input, state, handler.clone()),
-307
+            )
         });
         /* PythonApplicationGenerator.kt:220 */
         let mut service = ::tower::util::BoxCloneService::new(builder.build().expect("one or more operations do not have a registered handler; this is a bug in the Python code generator, please file a bug report under https://github.com/smithy-lang/smithy-rs/issues"));
-311
-312
+        {
             use ::tower::Layer;
             ::tracing::trace!("adding middlewares to rust python router");
             let mut middlewares = self.middlewares.clone();
             // Reverse the middlewares, so they run with same order as they defined
             middlewares.reverse();
             for handler in middlewares {
                 ::tracing::trace!(name = &handler.name, "adding python middleware");
                 let locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
                 let layer = ::aws_smithy_http_server_python::PyMiddlewareLayer::<
                     ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
                 >::new(handler, locals);
                 service = ::tower::util::BoxCloneService::new(layer.layer(service));
-325
+            }
-326
+        }
         Ok(service)
         /* PythonApplicationGenerator.kt:189 */
-329
+    }
     /* PythonApplicationGenerator.kt:168 */
-331
+}
 /* PythonApplicationGenerator.kt:247 */
 #[::pyo3::pymethods]
 impl App {
     /* PythonApplicationGenerator.kt:260 */
     /// Create a new [App].
     #[new]
     pub fn new() -> Self {
         Self::default()
-340
+    }
-341
     /// Register a context object that will be shared between handlers.
     ///
     /// :param context Ctx:
     /// :rtype None:

↧ Expand context

     #[pyo3(text_signature = "($self, context)")]
     pub fn context(&mut self, context: ::pyo3::PyObject) {
         self.context = Some(context);
-349
+    }
-350
     /// Register a Python function to be executed inside a Tower middleware layer.
     ///
     /// :param func typing.Callable\[\[rest_json_extras.middleware.Request, typing.Callable\[\[rest_json_extras.middleware.Request\], typing.Awaitable\[rest_json_extras.middleware.Response\]\]\], typing.Awaitable\[rest_json_extras.middleware.Response\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn middleware(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         let handler = ::aws_smithy_http_server_python::PyMiddlewareHandler::new(py, func)?;
         ::tracing::trace!(
             name = &handler.name,
             is_coroutine = handler.is_coroutine,
             "registering middleware function",

@@ -359,388 +543,584 @@

↥ Expand context

         workers: Option<usize>,
         tls: Option<::aws_smithy_http_server_python::tls::PyTlsConfig>,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.run_server(py, address, port, backlog, workers, tls)
-393
+    }
-394
     /// Lambda entrypoint: start the server on Lambda.
     ///
     /// :rtype None:
     #[pyo3(text_signature = "($self)")]
     pub fn run_lambda(&mut self, py: ::pyo3::Python) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.run_lambda_handler(py)
-402
+    }
-403
     /// Build the service and start a single worker.
     #[pyo3(text_signature = "($self, socket, worker_number, tls=None)")]
     pub fn start_worker(
         &mut self,

         py: pyo3::Python,
         socket: &pyo3::PyCell<::aws_smithy_http_server_python::PySocket>,
         worker_number: isize,
         tls: Option<::aws_smithy_http_server_python::tls::PyTlsConfig>,
     ) -> pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         let event_loop = self.configure_python_event_loop(py)?;
         let service = self.build_and_configure_service(py, event_loop)?;
         self.start_hyper_worker(py, socket, event_loop, service, worker_number, tls)
-417
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `case_insensitive_error_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.CaseInsensitiveErrorOperationInput, Ctx\], typing.Union\[rest_json_extras.output.CaseInsensitiveErrorOperationOutput, typing.Awaitable\[rest_json_extras.output.CaseInsensitiveErrorOperationOutput\]\]\], typing.Callable\[\[rest_json_extras.input.CaseInsensitiveErrorOperationInput\], typing.Union\[rest_json_extras.output.CaseInsensitiveErrorOperationOutput, typing.Awaitable\[rest_json_extras.output.CaseInsensitiveErrorOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn case_insensitive_error_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "case_insensitive_error_operation", func)
-432
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `empty_struct_with_content_on_wire_op` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.EmptyStructWithContentOnWireOpInput, Ctx\], typing.Union\[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput, typing.Awaitable\[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput\]\]\], typing.Callable\[\[rest_json_extras.input.EmptyStructWithContentOnWireOpInput\], typing.Union\[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput, typing.Awaitable\[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn empty_struct_with_content_on_wire_op(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "empty_struct_with_content_on_wire_op", func)
-447
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `enum_query` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.EnumQueryInput, Ctx\], typing.Union\[rest_json_extras.output.EnumQueryOutput, typing.Awaitable\[rest_json_extras.output.EnumQueryOutput\]\]\], typing.Callable\[\[rest_json_extras.input.EnumQueryInput\], typing.Union\[rest_json_extras.output.EnumQueryOutput, typing.Awaitable\[rest_json_extras.output.EnumQueryOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn enum_query(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "enum_query", func)
-462
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `escaped_string_values` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.EscapedStringValuesInput, Ctx\], typing.Union\[rest_json_extras.output.EscapedStringValuesOutput, typing.Awaitable\[rest_json_extras.output.EscapedStringValuesOutput\]\]\], typing.Callable\[\[rest_json_extras.input.EscapedStringValuesInput\], typing.Union\[rest_json_extras.output.EscapedStringValuesOutput, typing.Awaitable\[rest_json_extras.output.EscapedStringValuesOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn escaped_string_values(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "escaped_string_values", func)
-477
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `map_with_enum_key_op` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.MapWithEnumKeyOpInput, Ctx\], typing.Union\[rest_json_extras.output.MapWithEnumKeyOpOutput, typing.Awaitable\[rest_json_extras.output.MapWithEnumKeyOpOutput\]\]\], typing.Callable\[\[rest_json_extras.input.MapWithEnumKeyOpInput\], typing.Union\[rest_json_extras.output.MapWithEnumKeyOpOutput, typing.Awaitable\[rest_json_extras.output.MapWithEnumKeyOpOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn map_with_enum_key_op(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "map_with_enum_key_op", func)
-492
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `null_in_non_sparse` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.NullInNonSparseInput, Ctx\], typing.Union\[rest_json_extras.output.NullInNonSparseOutput, typing.Awaitable\[rest_json_extras.output.NullInNonSparseOutput\]\]\], typing.Callable\[\[rest_json_extras.input.NullInNonSparseInput\], typing.Union\[rest_json_extras.output.NullInNonSparseOutput, typing.Awaitable\[rest_json_extras.output.NullInNonSparseOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn null_in_non_sparse(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "null_in_non_sparse", func)
-507
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `primitive_int_header` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.PrimitiveIntHeaderInput, Ctx\], typing.Union\[rest_json_extras.output.PrimitiveIntHeaderOutput, typing.Awaitable\[rest_json_extras.output.PrimitiveIntHeaderOutput\]\]\], typing.Callable\[\[rest_json_extras.input.PrimitiveIntHeaderInput\], typing.Union\[rest_json_extras.output.PrimitiveIntHeaderOutput, typing.Awaitable\[rest_json_extras.output.PrimitiveIntHeaderOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn primitive_int_header(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "primitive_int_header", func)
-522
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `primitive_int_op` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.PrimitiveIntOpInput, Ctx\], typing.Union\[rest_json_extras.output.PrimitiveIntOpOutput, typing.Awaitable\[rest_json_extras.output.PrimitiveIntOpOutput\]\]\], typing.Callable\[\[rest_json_extras.input.PrimitiveIntOpInput\], typing.Union\[rest_json_extras.output.PrimitiveIntOpOutput, typing.Awaitable\[rest_json_extras.output.PrimitiveIntOpOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn primitive_int_op(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "primitive_int_op", func)
-537
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `query_precedence` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.QueryPrecedenceInput, Ctx\], typing.Union\[rest_json_extras.output.QueryPrecedenceOutput, typing.Awaitable\[rest_json_extras.output.QueryPrecedenceOutput\]\]\], typing.Callable\[\[rest_json_extras.input.QueryPrecedenceInput\], typing.Union\[rest_json_extras.output.QueryPrecedenceOutput, typing.Awaitable\[rest_json_extras.output.QueryPrecedenceOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn query_precedence(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "query_precedence", func)
-552
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `status_response` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.StatusResponseInput, Ctx\], typing.Union\[rest_json_extras.output.StatusResponseOutput, typing.Awaitable\[rest_json_extras.output.StatusResponseOutput\]\]\], typing.Callable\[\[rest_json_extras.input.StatusResponseInput\], typing.Union\[rest_json_extras.output.StatusResponseOutput, typing.Awaitable\[rest_json_extras.output.StatusResponseOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn status_response(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "status_response", func)
-567
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `string_payload` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[rest_json_extras.input.StringPayloadInput, Ctx\], typing.Union\[rest_json_extras.output.StringPayloadOutput, typing.Awaitable\[rest_json_extras.output.StringPayloadOutput\]\]\], typing.Callable\[\[rest_json_extras.input.StringPayloadInput\], typing.Union\[rest_json_extras.output.StringPayloadOutput, typing.Awaitable\[rest_json_extras.output.StringPayloadOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn string_payload(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "string_payload", func)
-582
+    }
     /* PythonApplicationGenerator.kt:247 */
-584
+}

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

@@ -1,1 +31,32 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServerServiceGenerator.kt:795 */
 /// The service builder for [`RestJsonExtras`].
 ///
 /// Constructed via [`RestJsonExtras::builder`].
 pub struct RestJsonExtrasBuilder<Body, L, HttpPl, ModelPl> {
     case_insensitive_error_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     empty_struct_with_content_on_wire_op: Option<::aws_smithy_http_server::routing::Route<Body>>,
     enum_query: Option<::aws_smithy_http_server::routing::Route<Body>>,
     escaped_string_values: Option<::aws_smithy_http_server::routing::Route<Body>>,
     map_with_enum_key_op: Option<::aws_smithy_http_server::routing::Route<Body>>,
     null_in_non_sparse: Option<::aws_smithy_http_server::routing::Route<Body>>,

↧ Expand context

     primitive_int_header: Option<::aws_smithy_http_server::routing::Route<Body>>,
     primitive_int_op: Option<::aws_smithy_http_server::routing::Route<Body>>,
     query_precedence: Option<::aws_smithy_http_server::routing::Route<Body>>,
     status_response: Option<::aws_smithy_http_server::routing::Route<Body>>,
     string_payload: Option<::aws_smithy_http_server::routing::Route<Body>>,
     layer: L,
     http_plugin: HttpPl,
     model_plugin: ModelPl,
-21
+}
-22
 impl<Body, L, HttpPl, ModelPl> RestJsonExtrasBuilder<Body, L, HttpPl, ModelPl> {
     /// Sets the [`CaseInsensitiveErrorOperation`](crate::operation_shape::CaseInsensitiveErrorOperation) operation.
     ///
     /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.
     /// See the [operation module documentation](::aws_smithy_http_server::operation) for more information.
     ///
     /// # Example
     ///
     /// ```no_run
     /// use rest_json_extras::{RestJsonExtras, RestJsonExtrasConfig};

@@ -2477,2478 +2536,2538 @@

↥ Expand context

     ::aws_smithy_http_server::service::ContainsOperation<crate::operation_shape::QueryPrecedence>
     for RestJsonExtras<L>
-2480
+{
     const VALUE: Operation = Operation::QueryPrecedence;
-2482
+}
 impl<L> ::aws_smithy_http_server::service::ContainsOperation<crate::operation_shape::StatusResponse>
     for RestJsonExtras<L>
-2485
+{
     const VALUE: Operation = Operation::StatusResponse;
-2487
+}
 impl<L> ::aws_smithy_http_server::service::ContainsOperation<crate::operation_shape::StringPayload>
     for RestJsonExtras<L>
-2490
+{
     const VALUE: Operation = Operation::StringPayload;
-2492
+}
-2493
 impl<S> ::aws_smithy_http_server::service::ServiceShape for RestJsonExtras<S> {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.restjson#RestJsonExtras",

             "aws.protocoltests.restjson",
             "RestJsonExtras",
         );
-2501
     const VERSION: Option<&'static str> = Some("2019-12-16");
-2503
     type Protocol = ::aws_smithy_http_server::protocol::rest_json_1::RestJson1;
-2505
     type Operations = Operation;
-2507
+}
 /* ServiceConfigGenerator.kt:178 */
 /// Configuration for the [`RestJsonExtras`]. This is the central place where to register and
 /// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.
 ///
 /// ```rust,no_run
 /// # use rest_json_extras::RestJsonExtrasConfig;
 /// # use ::aws_smithy_http_server::plugin::IdentityPlugin;
 /// # use ::tower::layer::util::Identity;
 /// # let authentication_plugin = IdentityPlugin;
 /// # let authorization_plugin = IdentityPlugin;
 /// # let server_request_id_provider_layer = Identity::new();

↧ Expand context

 /// let config = RestJsonExtrasConfig::builder()
 ///     // Layers get executed first...
 ///     .layer(server_request_id_provider_layer)
 ///     // ...then HTTP plugins...
 ///     .http_plugin(authentication_plugin)
 ///     // ...and right after deserialization, model plugins.
 ///     .model_plugin(authorization_plugin)
 ///     .build();
 /// ```
 ///
 /// See the [`plugin`] system for details.
 ///
 /// [`plugin`]: ::aws_smithy_http_server::plugin
 #[derive(::std::fmt::Debug)]
 pub struct RestJsonExtrasConfig<L, H, M> {
     layers: L,
     http_plugins: H,
     model_plugins: M,
-2537
+}
-2538

@@ -2598,2600 +2657,2660 @@

↥ Expand context

     /// [plugin]: ::aws_smithy_http_server::plugin
     // We eagerly require `NewPlugin: ModelMarker`, despite not really needing it, because compiler
     // errors get _substantially_ better if the user makes a mistake.
     pub fn model_plugin<NewPlugin: ::aws_smithy_http_server::plugin::ModelMarker>(
         self,
         model_plugin: NewPlugin,
     ) -> RestJsonExtrasConfigBuilder<
         L,
         H,
         ::aws_smithy_http_server::plugin::PluginStack<NewPlugin, M>,
     > {
         RestJsonExtrasConfigBuilder {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: ::aws_smithy_http_server::plugin::PluginStack::new(
                 model_plugin,
                 self.model_plugins,
             ),
-2618
+        }
-2619
+    }

-2620
     /// Build the configuration.
     pub fn build(self) -> super::RestJsonExtrasConfig<L, H, M> {
         super::RestJsonExtrasConfig {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: self.model_plugins,
-2627
+        }
-2628
+    }
-2629
+}
 /* ScopeMacroGenerator.kt:81 */
 /// A macro to help with scoping [plugins](crate::server::plugin) to a subset of all operations.
 ///
 /// In contrast to [`crate::server::scope`](crate::server::scope), this macro has knowledge
 /// of the service and any operations _not_ specified will be placed in the opposing group.
 ///
 /// # Example
 ///
 /// ```rust
 /// scope! {
 ///     /// Includes [`CaseInsensitiveErrorOperation`], excluding all other operations.

↧ Expand context

 ///     struct ScopeA {
 ///         includes: [CaseInsensitiveErrorOperation]
 ///     }
 /// }
 ///
 /// scope! {
 ///     /// Excludes [`CaseInsensitiveErrorOperation`], excluding all other operations.
 ///     struct ScopeB {
 ///         excludes: [CaseInsensitiveErrorOperation]
 ///     }
 /// }
 ///
 /// # use rest_json_extras::server::plugin::{Plugin, Scoped};
 /// # use rest_json_extras::scope;
 /// # struct MockPlugin;
 /// # impl<S, Op, T> Plugin<S, Op, T> for MockPlugin { type Output = u32; fn apply(&self, input: T) -> u32 { 3 } }
 /// # let scoped_a = Scoped::new::<ScopeA>(MockPlugin);
 /// # let scoped_b = Scoped::new::<ScopeB>(MockPlugin);
 /// # let a = Plugin::<(), rest_json_extras::operation_shape::CaseInsensitiveErrorOperation, u64>::apply(&scoped_a, 6);
 /// # let b = Plugin::<(), rest_json_extras::operation_shape::CaseInsensitiveErrorOperation, u64>::apply(&scoped_b, 6);

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

@@ -1,1 +0,7 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* SmithyTypesPubUseExtra.kt:66 */
 pub use ::aws_smithy_types::date_time::Format as DateTimeFormat;
 /* ServerRequiredCustomizations.kt:69 */
 pub use ::aws_smithy_types::error::display::DisplayErrorContext;
 pub use ::aws_smithy_types::Blob;
 pub use ::aws_smithy_types::DateTime;
 /* SmithyTypesPubUseExtra.kt:69 */ pub use ::aws_smithy_types::DateTime;

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

@@ -1,1 +40,50 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 pub(crate) mod map_with_enum_key_unconstrained {
-4
     /* UnconstrainedMapGenerator.kt:79 */
     #[derive(Debug, Clone)]
     pub(crate) struct MapWithEnumKeyUnconstrained(
         pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
     );
-10
     impl From<MapWithEnumKeyUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::map_with_enum_key_constrained::MapWithEnumKeyConstrained,
-14
+        >
-15
+    {
         fn from(value: MapWithEnumKeyUnconstrained) -> Self {
             Self::Unconstrained(value)
-18
+        }
-19
+    }
     /* UnconstrainedMapGenerator.kt:101 */
     impl std::convert::TryFrom<MapWithEnumKeyUnconstrained>
         for crate::constrained::map_with_enum_key_constrained::MapWithEnumKeyConstrained
-23
+    {
         /* UnconstrainedMapGenerator.kt:102 */
         type Error = crate::model::map_with_enum_key_internal::ConstraintViolation;
         /* UnconstrainedMapGenerator.kt:104 */
         fn try_from(value: MapWithEnumKeyUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedMapGenerator.kt:186 */
             let res: ::std::result::Result<
                 ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(|(k, v)| {
                     let k: crate::model::StringEnum = k.try_into().map_err(Self::Error::Key)?;
-37
                     Ok((k, v))
                 })
                 .collect();
             let hm = res?;
             /* UnconstrainedMapGenerator.kt:247 */
             Ok(Self(hm))
             /* UnconstrainedMapGenerator.kt:104 */
-45
+        }
         /* UnconstrainedMapGenerator.kt:101 */
-47
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-50
+}

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/Cargo.toml

@@ -6,6 +58,58 @@

↥ Expand context

 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-http-server]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"
 [dependencies.aws-smithy-http-server-python]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server-python"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dependencies.futures-util]
 version = "0.3"
 [dependencies.http]

 version = "0.2.9"
 [dependencies.hyper]
 version = "0.14.26"
 [dependencies.mime]
 version = "0.3"
 [dependencies.parking_lot]
 version = "0.12"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.pyo3]
 version = "0.18"
 version = "0.20"
 [dependencies.pyo3-asyncio]
 version = "0.18"
 version = "0.20"
 features = ["attributes", "tokio-runtime"]
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.hyper]
 version = "0.14.12"
 [dev-dependencies.tokio]
 version = "1.23.1"
 [features]

↧ Expand context

 rt-tokio = ["aws-smithy-types/rt-tokio"]
 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 request-id = ["aws-smithy-http-server/request-id"]
 extension-module = ["pyo3/extension-module"]
 default = ["rt-tokio", "request-id", "extension-module"]
 [lib]
 name = "simple"
 crate-type = ["cdylib"]
-57
-58

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

@@ -1,1 +161,280 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServerOperationErrorGenerator.kt:63 */
 /// Error type for the `Operation` operation.
 /* ServerOperationErrorGenerator.kt:64 */
 /// Each variant represents an error that can occur for the `Operation` operation.
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum OperationError {
 pub /* ServerOperationErrorGenerator.kt:66 */ enum OperationError {
     /* ServerOperationErrorGenerator.kt:68 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServerOperationErrorGenerator.kt:71 */
     InternalServerError(crate::error::InternalServerError),
     /* ServerOperationErrorGenerator.kt:66 */
-14
+}
 /* ServerOperationErrorGenerator.kt:75 */
 impl ::std::fmt::Display for OperationError {
     /* ServerOperationErrorGenerator.kt:76 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             OperationError::InternalServerError(_inner) => _inner.fmt(f),
             /* ServerOperationErrorGenerator.kt:142 */
             OperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-28
+        }
         /* ServerOperationErrorGenerator.kt:76 */
-30
+    }
     /* ServerOperationErrorGenerator.kt:75 */
-32
+}
 /* ServerOperationErrorGenerator.kt:83 */
 impl OperationError {
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `OperationError::InternalServerError`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_internal_server_error(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(&self, OperationError::InternalServerError(_))
         /* ServerOperationErrorGenerator.kt:88 */
-42
+    }
     /* ServerOperationErrorGenerator.kt:92 */
     /// Returns the error name string by matching the correct variant.
     /* ServerOperationErrorGenerator.kt:93 */
     pub fn name(&self) -> &'static str {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             OperationError::InternalServerError(_inner) => _inner.name(),
             /* ServerOperationErrorGenerator.kt:142 */
             OperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-56
+        }
         /* ServerOperationErrorGenerator.kt:93 */
-58
+    }
     /* ServerOperationErrorGenerator.kt:83 */
-60
+}
 /* ServerOperationErrorGenerator.kt:100 */
 impl ::std::error::Error for OperationError {
     /* ServerOperationErrorGenerator.kt:101 */
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             OperationError::InternalServerError(_inner) => Some(_inner),
             /* ServerOperationErrorGenerator.kt:142 */
             OperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-74
+        }
         /* ServerOperationErrorGenerator.kt:101 */
-76
+    }
     /* ServerOperationErrorGenerator.kt:100 */
-78
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::InternalServerError> for crate::error::OperationError {
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(variant: crate::error::InternalServerError) -> crate::error::OperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::InternalServerError(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-86
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-88
+}
-89
 /* PythonServerOperationErrorGenerator.kt:38 */
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::OperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::OperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-95
             crate::error::InternalServerError {
                 message: error.to_string(),
-98
+            }
             .into()
         })
-101
+    }
-102
+}
-103
 /* RustType.kt:516 */
 #[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 /* PythonServerStructureGenerator.kt:63 */
 /// :param message str:
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct InternalServerError {
 pub /* StructureGenerator.kt:201 */ struct InternalServerError {
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type str:
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::string::String,
     /* StructureGenerator.kt:201 */
-124
+}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl InternalServerError {
     #[new]
     pub fn new(message: ::std::string::String) -> Self {
         Self { message }
-136
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-139
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-142
+    }
-143
+}
 /* ErrorImplGenerator.kt:99 */
 impl InternalServerError {
     /* ErrorImplGenerator.kt:128 */
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-150
+    }
     /* ErrorImplGenerator.kt:141 */
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "InternalServerError"
-156
+    }
     /* ErrorImplGenerator.kt:99 */
-158
+}
 /* ErrorImplGenerator.kt:153 */
 impl ::std::fmt::Display for InternalServerError {
     /* ErrorImplGenerator.kt:154 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ErrorImplGenerator.kt:161 */
         ::std::write!(f, "InternalServerError")?;
         /* ErrorImplGenerator.kt:166 */
-166
+        {
             /* ErrorImplGenerator.kt:167 */
             ::std::write!(f, ": {}", &self.message)?;
             /* ErrorImplGenerator.kt:166 */
-170
+        }
         /* ErrorImplGenerator.kt:171 */
         Ok(())
         /* ErrorImplGenerator.kt:154 */
-174
+    }
     /* ErrorImplGenerator.kt:153 */
-176
+}
 /* ErrorImplGenerator.kt:175 */
 impl ::std::error::Error for InternalServerError {}
 /* ServerCodegenVisitor.kt:370 */
 impl InternalServerError {
     /// Creates a new builder-style object to manufacture [`InternalServerError`](crate::error::InternalServerError).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`InternalServerError`](crate::error::InternalServerError).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::error::internal_server_error::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::error::internal_server_error::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-187
+    }
     /* ServerCodegenVisitor.kt:370 */
-189
+}
 /// See [`InternalServerError`](crate::error::InternalServerError).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`InternalServerError`](crate::error::InternalServerError).
 pub mod internal_server_error {
-192
     /* RustType.kt:516 */
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     /// /* ServerBuilderConstraintViolations.kt:72 */Holds one variant for each of the ways the builder can fail.
     /* ServerBuilderConstraintViolations.kt:75 */
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `InternalServerError`.
         /// /* ServerBuilderConstraintViolations.kt:138 */`message` was not provided but it is required when building `InternalServerError`.
         /* ServerBuilderConstraintViolations.kt:143 */
         MissingMessage,
         /* ServerBuilderConstraintViolations.kt:75 */
-203
+    }
     /* ServerBuilderConstraintViolations.kt:117 */
     impl ::std::fmt::Display for ConstraintViolation {
         /* ServerBuilderConstraintViolations.kt:118 */
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             /* ServerBuilderConstraintViolations.kt:119 */
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
--
+            }
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
             /* ServerBuilderConstraintViolations.kt:119 */}
             /* ServerBuilderConstraintViolations.kt:118 */
-213
+        }
         /* ServerBuilderConstraintViolations.kt:117 */
-215
+    }
     /* ServerBuilderConstraintViolations.kt:84 */
     impl ::std::error::Error for ConstraintViolation {}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:254 */
     impl ::std::convert::TryFrom<Builder> for crate::error::InternalServerError {
         type Error = ConstraintViolation;
-221
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-224
+        }
-225
+    }
     /// A builder for [`InternalServerError`](crate::error::InternalServerError).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`InternalServerError`](crate::error::InternalServerError).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) message: ::std::option::Option<::std::string::String>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
-234
+    }
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.message =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */Some(
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */)
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-249
+        }
         /// Consumes the builder and constructs a [`InternalServerError`](crate::error::InternalServerError).
         ///
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`InternalServerError`](crate::error::InternalServerError).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:152 */
         /// The builder fails to construct a [`InternalServerError`](crate::error::InternalServerError) if you do not provide a value for all non-`Option`al members.
         ///
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-257
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             Ok(crate::error::InternalServerError {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:175 */
             Ok(
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
                 crate::error::InternalServerError {
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                     message: self
                         .message
                         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:202 */
                         .ok_or(ConstraintViolation::MissingMessage)?,
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
                 }, /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:175 */
-+
+            )
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-275
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-277
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-280
+}

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

@@ -1,1 +118,183 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* RustType.kt:516 */
 #[::pyo3::pyclass]
 /* PythonServerStructureGenerator.kt:63 */
 /// :param message typing.Optional\[str\]:
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct OperationInput {
 pub /* StructureGenerator.kt:201 */ struct OperationInput {
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type typing.Optional\[str\]:
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     /* StructureGenerator.kt:201 */
-22
+}
 /* StructureGenerator.kt:135 */
 impl OperationInput {
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
                            /* StructureGenerator.kt:166 */
     pub fn message(&self) -> ::std::option::Option<&str> {
         /* StructureGenerator.kt:169 */
         self.message.as_deref()
         /* StructureGenerator.kt:166 */
-32
+    }
     /* StructureGenerator.kt:135 */
-34
+}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl OperationInput {
     #[new]
     pub fn new(message: ::std::option::Option<::std::string::String>) -> Self {
         Self { message }
-46
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-49
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-52
+    }
-53
+}
 /* PythonServerStructureGenerator.kt:111 */
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<OperationInput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<OperationInput>().map(Box::new)
-58
+    }
-59
+}
-60
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<OperationInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-64
+    }
-65
+}
 /* ServerStructureConstrainedTraitImpl.kt:21 */
 impl crate::constrained::Constrained for crate::input::OperationInput {
     type Unconstrained = crate::input::operation_input_internal::Builder;
-69
+}
 /* ServerCodegenVisitor.kt:370 */
 impl OperationInput {
     /// Creates a new builder-style object to manufacture [`OperationInput`](crate::input::OperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`OperationInput`](crate::input::OperationInput).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::input::operation_input::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::input::operation_input::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-78
+    }
     /* ServerCodegenVisitor.kt:370 */
-80
+}
 /// See [`OperationInput`](crate::input::OperationInput).
 /// /* ServerBuilderGenerator.kt:171 */See [`OperationInput`](crate::input::OperationInput).
 pub(crate) mod operation_input_internal {
-83
     /* ServerBuilderGenerator.kt:461 */
     impl ::std::convert::From<Builder> for crate::input::OperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-88
+        }
-89
+    }
     /// A builder for [`OperationInput`](crate::input::OperationInput).
     /// /* ServerBuilderGenerator.kt:201 */A builder for [`OperationInput`](crate::input::OperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGenerator.kt:211 */
     pub(crate) struct Builder {
         /* ServerBuilderGenerator.kt:308 */
         pub(crate) message: ::std::option::Option<::std::string::String>,
         /* ServerBuilderGenerator.kt:211 */
-98
+    }
     /* ServerBuilderGenerator.kt:215 */
     impl Builder {
         /* ServerBuilderGenerator.kt:426 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGenerator.kt:428 */
         pub(crate) fn set_message(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             /* ServerBuilderGenerator.kt:429 */
             self.message = input.map(|v| v.into());
             self
             /* ServerBuilderGenerator.kt:428 */
-112
+        }
         /// Consumes the builder and constructs a [`OperationInput`](crate::input::OperationInput).
         /// /* ServerBuilderGenerator.kt:258 */Consumes the builder and constructs a [`OperationInput`](crate::input::OperationInput).
         /* ServerBuilderGenerator.kt:271 */
         pub fn build(self) -> crate::input::OperationInput {
             self.build_enforcing_all_constraints()
-117
+        }
         /* ServerBuilderGenerator.kt:283 */
         fn build_enforcing_all_constraints(self) -> crate::input::OperationInput {
             /* ServerBuilderGenerator.kt:542 */
             crate::input::OperationInput {
                 /* ServerBuilderGenerator.kt:546 */
                 message: self.message,
                 /* ServerBuilderGenerator.kt:542 */
-125
+            }
             /* ServerBuilderGenerator.kt:283 */
-127
+        }
         /* ServerBuilderGenerator.kt:215 */
-129
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-132
+}
 /// See [`OperationInput`](crate::input::OperationInput).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`OperationInput`](crate::input::OperationInput).
 pub mod operation_input {
-135
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:269 */
     impl ::std::convert::From<Builder> for crate::input::OperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-140
+        }
-141
+    }
     /// A builder for [`OperationInput`](crate::input::OperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`OperationInput`](crate::input::OperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) message: ::std::option::Option<::std::string::String>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
-150
+    }
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.message = input;
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.message =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-163
+        }
         /// Consumes the builder and constructs a [`OperationInput`](crate::input::OperationInput).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`OperationInput`](crate::input::OperationInput).
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> crate::input::OperationInput {
             self.build_enforcing_required_and_enum_traits()
-168
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(self) -> crate::input::OperationInput {
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
             crate::input::OperationInput {
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                 message: self.message,
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
-176
+            }
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-178
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-180
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-183
+}

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

@@ -1,1 +52,53 @@

↥ Expand context

 #![allow(deprecated)]
 #![allow(unknown_lints)]
 #![allow(clippy::module_inception)]
 #![allow(clippy::upper_case_acronyms)]
 #![allow(clippy::large_enum_variant)]
 #![allow(clippy::wrong_self_convention)]
 #![allow(clippy::should_implement_trait)]
 #![allow(clippy::disallowed_names)]
 #![allow(clippy::vec_init_then_push)]
 #![allow(clippy::type_complexity)]
 #![allow(clippy::needless_return)]
 #![allow(clippy::derive_partial_eq_without_eq)]

 #![allow(clippy::result_large_err)]
 #![allow(clippy::unnecessary_map_on_constructor)]
 #![allow(rustdoc::bare_urls)]
 #![allow(rustdoc::redundant_explicit_links)]
 #![allow(rustdoc::invalid_html_tags)]
 #![forbid(unsafe_code)]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 //! simple
-21
 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServerRootGenerator.kt:65 */
 //! A fast and customizable Rust implementation of the SimpleService Smithy service.
 //!
 //! # Using SimpleService
 //!
 //! The primary entrypoint is [`SimpleService`]: it satisfies the [`Service<http::Request, Response = http::Response>`](::tower::Service)
 //! trait and therefore can be handed to a [`hyper` server](https://github.com/hyperium/hyper) via [`SimpleService::into_make_service`]
 //! or used in AWS Lambda
 #![cfg_attr(
     feature = "aws-lambda",
     doc = " via [`LambdaHandler`](crate::server::routing::LambdaHandler)."

↧ Expand context

 )]
 #![cfg_attr(
     not(feature = "aws-lambda"),
     doc = " by enabling the `aws-lambda` feature flag and utilizing the `LambdaHandler`."
 )]
 //! The [`crate::input`], [`crate::output`], and [`crate::error`]
 //! modules provide the types used in each operation.
 //!
 //! ### Running on Hyper
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! # async fn dummy() {
 //! use simple::{SimpleService, SimpleServiceConfig};
 //!
 //! # let app = SimpleService::builder(
 //! #     SimpleServiceConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let server = app.into_make_service();

@@ -167,168 +256,269 @@

↥ Expand context

 //!    let app = SimpleService::builder(config)
 //!        .operation(operation)
 //!        .build()
 //!        .expect("failed to build an instance of SimpleService");
 //!
 //!    let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!        .expect("unable to parse the server bind address and port");
 //!    let server = ::hyper::Server::bind(&bind).serve(app.into_make_service());
 //!    # let server = async { Ok::<_, ()>(()) };
 //!
 //!    // Run your service!
 //!    if let Err(err) = server.await {
 //!        eprintln!("server error: {:?}", err);
 //!    }
 //! }
 //!
 //! use simple::{input, output, error};
 //!
 //! async fn operation(input: input::OperationInput) -> Result<output::OperationOutput, error::OperationError> {
 //!     todo!()

 //! }
 //!
 //! ```
 //!
 //! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve
 //! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html
 //! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html
 //! [operations]: https://smithy.io/2.0/spec/service-types.html#operation
 //! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
 //! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html
 /* ServerRootGenerator.kt:261 */
 pub use crate::service::{
     MissingOperationsError, SimpleService, SimpleServiceBuilder, SimpleServiceConfig,
     SimpleServiceConfigBuilder,
 };
-203
 /// Contains the types that are re-exported from the `aws-smithy-http-server` crate.
 /// /* ServerRustModule.kt:55 */Contains the types that are re-exported from the `aws-smithy-http-server` crate.
 pub mod server {
     // Re-export all types from the `aws-smithy-http-server` crate.
     pub use ::aws_smithy_http_server::*;
-+
     /* CodegenDelegator.kt:200 */
-210
+}
-211
 /* CrateVersionCustomization.kt:23 */
 /// Crate version number.
 pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-215
 /// All error types that operations can return. Documentation on these types is copied from the model.
 /// /* ServerRustModule.kt:55 */All error types that operations can return. Documentation on these types is copied from the model.
 pub mod error;
-218
 /// Input structures for operations. Documentation on these types is copied from the model.
 /// /* ServerRustModule.kt:55 */Input structures for operations. Documentation on these types is copied from the model.
 pub mod input;
-221
 /// All operations that this crate can perform.
 /// /* ServerRustModule.kt:55 */All operations that this crate can perform.
 pub mod operation;
-224
 /* ServerRustModule.kt:79 */
 /// A collection of types representing each operation defined in the service closure.
 ///
 /// The [plugin system](::aws_smithy_http_server::plugin) makes use of these
 /// [zero-sized types](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) (ZSTs) to
 /// parameterize [`Plugin`](::aws_smithy_http_server::plugin::Plugin) implementations. Their traits, such as
 /// [`OperationShape`](::aws_smithy_http_server::operation::OperationShape), can be used to provide
 /// operation specific information to the [`Layer`](::tower::Layer) being applied.
 pub mod operation_shape;
-234
 /// Output structures for operations. Documentation on these types is copied from the model.
 /// /* ServerRustModule.kt:55 */Output structures for operations. Documentation on these types is copied from the model.
 pub mod output;
-237
 /// Export PyO3 symbols in the shared library
 /// /* PythonServerRustModule.kt:23 */Export PyO3 symbols in the shared library
 pub mod python_module_export;
-240
 /// Operation adapters that delegate to Python handlers.
 /// /* PythonServerRustModule.kt:23 */Operation adapters that delegate to Python handlers.
 pub mod python_operation_adaptor;
-243
 /// Python server and application implementation.
 /// /* PythonServerRustModule.kt:23 */Python server and application implementation.
 pub mod python_server_application;
-246
 /* RustModule.kt:172 */
 mod service;
-249
 /// Data primitives referenced by other data types.
 /// /* ServerRustModule.kt:55 */Data primitives referenced by other data types.
 pub mod types;
-252
 /// Constrained types for constrained shapes.
 /// /* ServerRustModule.kt:55 */Constrained types for constrained shapes.
 /* RustModule.kt:172 */
 mod constrained;
-256
 pub(crate) mod protocol_serde;
-258
 /// Re-exported Python types from supporting crates.
 /// /* PythonServerCodegenDecorator.kt:57 */Re-exported Python types from supporting crates.
 /* PythonServerCodegenDecorator.kt:58 */
 pub mod python_types {
     /* PythonServerCodegenDecorator.kt:59 */
     pub use ::aws_smithy_http_server_python::types::Blob;
     /* PythonServerCodegenDecorator.kt:60 */
     pub use ::aws_smithy_http_server_python::types::DateTime;
     /* PythonServerCodegenDecorator.kt:61 */
     pub use ::aws_smithy_http_server_python::types::Document;
     /* PythonServerCodegenDecorator.kt:58 */
-269
+}

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

@@ -1,1 +31,32 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServerHttpBoundProtocolGenerator.kt:266 */
 const CONTENT_TYPE_OPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`OperationInput`](crate::input::OperationInput) using modelled bindings.
     pub struct OperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9
+    }
-10
+}
-11
 impl std::future::Future for OperationInputFuture {

↧ Expand context

     type Output = Result<
         crate::input::OperationInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-17
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-24
+    }
-25
+}
-26
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OperationInput
 where

@@ -38,39 +102,105 @@

↥ Expand context

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

                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-61
+                )
             },
         );
         OperationInputFuture {
             inner: Box::pin(fut),
-66
+        }
-67
+    }
-68
+}
 /* ServerHttpBoundProtocolGenerator.kt:329 */
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OperationOutput
-74
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation::ser_operation_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-81
+            }
-82
+        }
-83
+    }
-84
+}
 /* ServerHttpBoundProtocolGenerator.kt:350 */
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::OperationError
-90
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation::ser_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),

↧ Expand context

                 );
                 response
-98
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-102
+            }
-103
+        }
-104
+    }
-105
+}

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

@@ -1,1 +0,41 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServerOperationGenerator.kt:48 */
 #[allow(missing_docs)] // documentation missing in model
                        /* ServerOperationGenerator.kt:55 */
 pub struct Operation;
-6
 impl ::aws_smithy_http_server::operation::OperationShape for Operation {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "com.amazonaws.simple#Operation",
             "com.amazonaws.simple",
             "Operation",
         );
-14
     type Input = crate::input::OperationInput;
     type Output = crate::output::OperationOutput;
     type Error = crate::error::OperationError;
-18
+}
-19
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for Operation {
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
             ::aws_smithy_http_server::instrumentation::MakeIdentity,
         >,
     >;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
         ::aws_smithy_http_server::instrumentation::MakeIdentity,
     >;
-32
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
-35
+    }
-36
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-39
+    }
-40
+}
 /* ServerOperationGenerator.kt:88 */

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

@@ -1,1 +82,127 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* RustType.kt:516 */
 #[::pyo3::pyclass]
 /* PythonServerStructureGenerator.kt:63 */
 /// :param message typing.Optional\[str\]:
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct OperationOutput {
 pub /* StructureGenerator.kt:201 */ struct OperationOutput {
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type typing.Optional\[str\]:
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::option::Option<::std::string::String>,
     /* StructureGenerator.kt:201 */
-22
+}
 /* StructureGenerator.kt:135 */
 impl OperationOutput {
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
                            /* StructureGenerator.kt:166 */
     pub fn message(&self) -> ::std::option::Option<&str> {
         /* StructureGenerator.kt:169 */
         self.message.as_deref()
         /* StructureGenerator.kt:166 */
-32
+    }
     /* StructureGenerator.kt:135 */
-34
+}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl OperationOutput {
     #[new]
     pub fn new(message: ::std::option::Option<::std::string::String>) -> Self {
         Self { message }
-46
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-49
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-52
+    }
-53
+}
 /* PythonServerStructureGenerator.kt:111 */
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<OperationOutput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<OperationOutput>().map(Box::new)
-58
+    }
-59
+}
-60
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<OperationOutput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-64
+    }
-65
+}
 /* ServerCodegenVisitor.kt:370 */
 impl OperationOutput {
     /// Creates a new builder-style object to manufacture [`OperationOutput`](crate::output::OperationOutput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`OperationOutput`](crate::output::OperationOutput).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::output::operation_output::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::output::operation_output::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-74
+    }
     /* ServerCodegenVisitor.kt:370 */
-76
+}
 /// See [`OperationOutput`](crate::output::OperationOutput).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`OperationOutput`](crate::output::OperationOutput).
 pub mod operation_output {
-79
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:269 */
     impl ::std::convert::From<Builder> for crate::output::OperationOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-84
+        }
-85
+    }
     /// A builder for [`OperationOutput`](crate::output::OperationOutput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`OperationOutput`](crate::output::OperationOutput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) message: ::std::option::Option<::std::string::String>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
-94
+    }
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn message(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
             self.message = input;
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.message =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-107
+        }
         /// Consumes the builder and constructs a [`OperationOutput`](crate::output::OperationOutput).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`OperationOutput`](crate::output::OperationOutput).
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> crate::output::OperationOutput {
             self.build_enforcing_required_and_enum_traits()
-112
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(self) -> crate::output::OperationOutput {
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
             crate::output::OperationOutput {
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                 message: self.message,
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
-120
+            }
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-122
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-124
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-127
+}

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/src/protocol_serde.rs

@@ -1,1 +14,15 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) mod shape_operation;
-3
 pub(crate) mod shape_internal_server_error;
-5
 /* JsonParserGenerator.kt:227 */
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
-12
+    }
-13
+}
-14
 pub(crate) mod shape_operation_output;

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/src/protocol_serde/shape_internal_server_error.rs

@@ -1,1 +23,34 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* JsonSerializerGenerator.kt:213 */
 pub fn ser_internal_server_error_error(
     value: &crate::error::InternalServerError,
 ) -> ::std::result::Result<String, ::aws_smithy_types::error::operation::SerializationError> {
     /* JsonSerializerGenerator.kt:218 */
     let mut out = ::std::string::String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     /* JsonSerializerGenerator.kt:375 */
     crate::protocol_serde::shape_internal_server_error::ser_internal_server_error(
         &mut object,
         value,
     )?;
     /* JsonSerializerGenerator.kt:227 */
     object.finish();
     Ok(out)
     /* JsonSerializerGenerator.kt:213 */
-18
+}
-19
 /* JsonSerializerGenerator.kt:358 */
 pub fn ser_internal_server_error(
     object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::error::InternalServerError,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     /* SerializerUtil.kt:42 */
-26
+    {
         /* JsonSerializerGenerator.kt:423 */
         object.key("message").string(input.message.as_str());
         /* SerializerUtil.kt:42 */
-30
+    }
     /* JsonSerializerGenerator.kt:372 */
     Ok(())
     /* JsonSerializerGenerator.kt:358 */
-34
+}

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/src/protocol_serde/shape_operation.rs

@@ -1,1 +150,213 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* RustType.kt:516 */
 #[allow(clippy::unnecessary_wraps)]
 /* ServerHttpBoundProtocolGenerator.kt:383 */
 pub async fn de_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
 ) -> std::result::Result<
     crate::input::OperationInput,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
-10
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-16
+{
     /* ServerHttpBoundProtocolGenerator.kt:399 */
     Ok({
         /* RustType.kt:516 */
         #[allow(unused_mut)]
         /* ServerHttpBoundProtocolGenerator.kt:723 */
         let mut input = crate::input::operation_input_internal::Builder::default();
         /* RustType.kt:516 */
         #[allow(unused_variables)]
         /* ServerHttpBoundProtocolGenerator.kt:728 */
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         /* ServerHttpBoundProtocolGenerator.kt:745 */
         let bytes = ::hyper::body::to_bytes(body).await?;
         /* ServerHttpBoundProtocolGenerator.kt:768 */
         if !bytes.is_empty() {
             /* ServerHttpBoundProtocolGenerator.kt:769 */
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/json"),
             )?;
             input = crate::protocol_serde::shape_operation::de_operation(bytes.as_ref(), input)?;
             /* ServerHttpBoundProtocolGenerator.kt:768 */
-40
+        }
         /* ServerHttpBoundProtocolGenerator.kt:834 */
         input.build()
         /* ServerHttpBoundProtocolGenerator.kt:399 */
     })
     /* ServerHttpBoundProtocolGenerator.kt:383 */
-46
+}
-47
 /* RustType.kt:516 */
 #[allow(clippy::unnecessary_wraps)]
 /* ServerHttpBoundProtocolGenerator.kt:421 */
 pub fn ser_operation_http_response(
     #[allow(unused_variables)] output: crate::output::OperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     /* ServerHttpBoundProtocolGenerator.kt:433 */
     Ok({
         /* RustType.kt:516 */
         #[allow(unused_mut)]
         /* ServerHttpBoundProtocolGenerator.kt:523 */
         let mut builder = ::http::Response::builder();
         /* ServerHttpBoundProtocolGenerator.kt:597 */
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             "application/json",
         );
         /* ServerHttpBoundProtocolGenerator.kt:682 */
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         /* ServerHttpBoundProtocolGenerator.kt:561 */
         let payload =
             crate::protocol_serde::shape_operation_output::ser_operation_output_output_output(
                 &output,
             )?;
             /* HttpBoundProtocolPayloadGenerator.kt:237 */crate::protocol_serde::shape_operation_output::ser_operation_output_output_output(&output)?
         /* ServerHttpBoundProtocolGenerator.kt:561 */;
         /* ServerHttpBoundProtocolGenerator.kt:663 */
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             content_length,
         );
         /* ServerHttpBoundProtocolGenerator.kt:567 */
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         /* ServerHttpBoundProtocolGenerator.kt:575 */
         builder.body(body)?
         /* ServerHttpBoundProtocolGenerator.kt:433 */
     })
     /* ServerHttpBoundProtocolGenerator.kt:421 */
-90
+}
-91
 /* RustType.kt:516 */
 #[allow(clippy::unnecessary_wraps)]
 /* ServerHttpBoundProtocolGenerator.kt:447 */
 pub fn ser_operation_http_error(
     error: &crate::error::OperationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
 > {
     /* ServerHttpBoundProtocolGenerator.kt:452 */
     Ok({
         /* ServerHttpBoundProtocolGenerator.kt:468 */
         match error {
             /* ServerHttpBoundProtocolGenerator.kt:476 */
             crate::error::OperationError::InternalServerError(output) => {
                 /* ServerHttpBoundProtocolGenerator.kt:477 */
                 let payload = crate::protocol_serde::shape_internal_server_error::ser_internal_server_error_error(output)?;
                 /* RustType.kt:516 */
                 #[allow(unused_mut)]
                 /* ServerHttpBoundProtocolGenerator.kt:487 */
                 let mut builder = ::http::Response::builder();
                 /* ServerHttpBoundProtocolGenerator.kt:597 */
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     "application/json",
                 );
                 /* ServerHttpBoundProtocolGenerator.kt:597 */
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("x-amzn-errortype"),
                     "InternalServerError",
                 );
                 /* ServerHttpBoundProtocolGenerator.kt:663 */
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     content_length,
                 );
                 /* ServerHttpBoundProtocolGenerator.kt:504 */
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
--
+            }
                 /* ServerHttpBoundProtocolGenerator.kt:476 */
             } /* ServerHttpBoundProtocolGenerator.kt:468 */
-138
+        }
         /* ServerHttpBoundProtocolGenerator.kt:452 */
     })
     /* ServerHttpBoundProtocolGenerator.kt:447 */
-142
+}
-143
 /* JsonParserGenerator.kt:148 */
 pub(crate) fn de_operation(
     value: &[u8],
     mut builder: crate::input::operation_input_internal::Builder,
 ) -> ::std::result::Result<
     crate::input::operation_input_internal::Builder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     /* JsonParserGenerator.kt:153 */
     let mut tokens_owned =
         ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value))
             .peekable();
     let tokens = &mut tokens_owned;
     ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
     /* JsonParserGenerator.kt:684 */
     loop {
         /* JsonParserGenerator.kt:685 */
         match tokens.next().transpose()? {
             /* JsonParserGenerator.kt:686 */
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                 /* JsonParserGenerator.kt:260 */
                 match key.to_unescaped()?.as_ref() {
                     /* JsonParserGenerator.kt:262 */
                     "message" => {
                         /* JsonParserGenerator.kt:272 */
                         builder = builder.set_message(
                             /* JsonParserGenerator.kt:354 */
                             ::aws_smithy_json::deserialize::token::expect_string_or_null(
                                 tokens.next(),
                             )?
                             .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                             .transpose()?,
                             .map(|s|
                                 /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
                                     /* JsonParserGenerator.kt:348 */u.into_owned()
                                 /* JsonParserGenerator.kt:339 */) /* JsonParserGenerator.kt:354 */)
                             .transpose()?, /* JsonParserGenerator.kt:272 */
                         );
                         /* JsonParserGenerator.kt:262 */
-182
+                    }
                     _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
                     /* JsonParserGenerator.kt:290 */
                     _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?, /* JsonParserGenerator.kt:260 */
-185
+                }
                 /* JsonParserGenerator.kt:686 */
-187
+            }
             /* JsonParserGenerator.kt:695 */
             other => {
                 return Err(
                     ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                         "expected object key or end object, found: {:?}",
                         other
                     )),
-195
+                )
--
+            }
             } /* JsonParserGenerator.kt:685 */
-197
+        }
         /* JsonParserGenerator.kt:684 */
-199
+    }
     /* JsonParserGenerator.kt:250 */
     if tokens.next().is_some() {
         /* JsonParserGenerator.kt:251 */
         return Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "found more JSON tokens after completing parsing",
             ),
         );
         /* JsonParserGenerator.kt:250 */
-209
+    }
     /* JsonParserGenerator.kt:163 */
     Ok(builder)
     /* JsonParserGenerator.kt:148 */
-213
+}

Server Test Python

Files changed:

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

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

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

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

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

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/Cargo.toml

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

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

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

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

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

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

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/src/protocol_serde.rs

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/src/protocol_serde/shape_internal_server_error.rs

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/src/protocol_serde/shape_operation.rs

tmp-codegen-diff/codegen-server-test-python/simple/rust-server-codegen-python/src/protocol_serde/shape_operation_output.rs