Server Test Python

rev. 0b749be6d000fdc7ef59d1bc26f1dce00358d95c

Files changed:

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

@@ -7,7 +66,72 @@

 Ctx = typing.TypeVar('Ctx')
-8
 class App(typing.Generic[Ctx]):
     """
     Main Python application, used to register operations and context and start multiple
     workers on the same shared socket.
-13
     Operations can be registered using the application object as a decorator (`@app.operation_name`).
-15
     Here's a full example to get you started:
-17
     ```python
     from json_rpc10 import input
     from json_rpc10 import output
     from json_rpc10 import error
     from json_rpc10 import middleware
     from json_rpc10 import App
-24
     @dataclass
     class Context:

         counter: int = 0
-28
     app = App()
     app.context(Context())
-31
     @app.request_middleware
     def request_middleware(request: middleware::Request):
         if request.get_header("x-amzn-id") != "secret":
             raise middleware.MiddlewareException("Unsupported `x-amz-id` header", 401)
-36
     # The example tests how servers must support requests
     # containing a `Content-Type` header with parameters.
     @app.content_type_parameters
     def content_type_parameters(input: input::ContentTypeParametersInput, ctx: Context) -> output::ContentTypeParametersOutput:
         raise NotImplementedError
-+
     # The example tests how requests and responses are serialized when there's
     # no request or response payload because the operation has an empty input
     # and empty output structure that reuses the same shape. While this should
     # be rare, code generators must support this.
     @app.empty_input_and_empty_output
     def empty_input_and_empty_output(input: input::EmptyInputAndEmptyOutputInput, ctx: Context) -> output::EmptyInputAndEmptyOutputOutput:
         raise NotImplementedError
-50
     @app.endpoint_operation
     def endpoint_operation(input: input::EndpointOperationInput, ctx: Context) -> output::EndpointOperationOutput:

↧ Expand context

         raise NotImplementedError
-54
     @app.endpoint_with_host_label_operation
     def endpoint_with_host_label_operation(input: input::EndpointWithHostLabelOperationInput, ctx: Context) -> output::EndpointWithHostLabelOperationOutput:
         raise NotImplementedError
-58
     # This operation has three possible return values:
-60
+    #
     # 1. A successful response in the form of GreetingWithErrorsOutput
     # 2. An InvalidGreeting error.
     # 3. A ComplexError error.
-64
+    #
     # Implementations must be able to successfully take a response and
     # properly deserialize successful and error responses.
     @app.greeting_with_errors
     def greeting_with_errors(input: input::GreetingWithErrorsInput, ctx: Context) -> output::GreetingWithErrorsOutput:
         raise NotImplementedError
-70
     @app.host_with_path_operation
     def host_with_path_operation(input: input::HostWithPathOperationInput, ctx: Context) -> output::HostWithPathOperationOutput:

@@ -86,92 +145,159 @@

↥ Expand context

     def no_input_and_output(input: input::NoInputAndOutputInput, ctx: Context) -> output::NoInputAndOutputOutput:
         raise NotImplementedError
-94
     @app.operation_with_defaults
     def operation_with_defaults(input: input::OperationWithDefaultsInput, ctx: Context) -> output::OperationWithDefaultsOutput:
         raise NotImplementedError
-98
     @app.operation_with_nested_structure
     def operation_with_nested_structure(input: input::OperationWithNestedStructureInput, ctx: Context) -> output::OperationWithNestedStructureOutput:
         raise NotImplementedError
-102
     @app.operation_with_required_members
     def operation_with_required_members(input: input::OperationWithRequiredMembersInput, ctx: Context) -> output::OperationWithRequiredMembersOutput:
         raise NotImplementedError
-106
     @app.put_with_content_encoding
     def put_with_content_encoding(input: input::PutWithContentEncodingInput, ctx: Context) -> output::PutWithContentEncodingOutput:
         raise NotImplementedError
-110
     @app.simple_scalar_properties

     def simple_scalar_properties(input: input::SimpleScalarPropertiesInput, ctx: Context) -> output::SimpleScalarPropertiesOutput:
         raise NotImplementedError
-114
     app.run()
     ```
-117
     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.
     """
-121
     def content_type_parameters(self, func: typing.Union[typing.Callable[[json_rpc10.input.ContentTypeParametersInput, Ctx], typing.Union[json_rpc10.output.ContentTypeParametersOutput, typing.Awaitable[json_rpc10.output.ContentTypeParametersOutput]]], typing.Callable[[json_rpc10.input.ContentTypeParametersInput], typing.Union[json_rpc10.output.ContentTypeParametersOutput, typing.Awaitable[json_rpc10.output.ContentTypeParametersOutput]]]]) -> None:
         """
         Method to register `content_type_parameters` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
-+
-+
     def context(self, context: Ctx) -> None:
         """
         Register a context object that will be shared between handlers.
         """
         ...
-135
-136
     def empty_input_and_empty_output(self, func: typing.Union[typing.Callable[[json_rpc10.input.EmptyInputAndEmptyOutputInput, Ctx], typing.Union[json_rpc10.output.EmptyInputAndEmptyOutputOutput, typing.Awaitable[json_rpc10.output.EmptyInputAndEmptyOutputOutput]]], typing.Callable[[json_rpc10.input.EmptyInputAndEmptyOutputInput], typing.Union[json_rpc10.output.EmptyInputAndEmptyOutputOutput, typing.Awaitable[json_rpc10.output.EmptyInputAndEmptyOutputOutput]]]]) -> None:
         """
         Method to register `empty_input_and_empty_output` Python implementation inside the handlers map.

↧ Expand context

         It can be used as a function decorator in Python.
         """
         ...
-143
-144
     def endpoint_operation(self, func: typing.Union[typing.Callable[[json_rpc10.input.EndpointOperationInput, Ctx], typing.Union[json_rpc10.output.EndpointOperationOutput, typing.Awaitable[json_rpc10.output.EndpointOperationOutput]]], typing.Callable[[json_rpc10.input.EndpointOperationInput], typing.Union[json_rpc10.output.EndpointOperationOutput, typing.Awaitable[json_rpc10.output.EndpointOperationOutput]]]]) -> None:
         """
         Method to register `endpoint_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
-151
-152
     def endpoint_with_host_label_operation(self, func: typing.Union[typing.Callable[[json_rpc10.input.EndpointWithHostLabelOperationInput, Ctx], typing.Union[json_rpc10.output.EndpointWithHostLabelOperationOutput, typing.Awaitable[json_rpc10.output.EndpointWithHostLabelOperationOutput]]], typing.Callable[[json_rpc10.input.EndpointWithHostLabelOperationInput], typing.Union[json_rpc10.output.EndpointWithHostLabelOperationOutput, typing.Awaitable[json_rpc10.output.EndpointWithHostLabelOperationOutput]]]]) -> None:
         """
         Method to register `endpoint_with_host_label_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
-159

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

@@ -1,1 +33,40 @@

 import json_rpc10.model
 import typing
-3
 class ContentTypeParametersInput:
     value: typing.Optional[int]
-+
     def __init__(self, value: typing.Optional[int] = ...) -> None:
         ...
-+
-+
 class EmptyInputAndEmptyOutputInput:
     def __init__(self) -> None:
         ...
-14
-15
 class EndpointOperationInput:
     def __init__(self) -> None:
         ...
-19
-20

↧ Expand context

 class EndpointWithHostLabelOperationInput:
     label: str
-23
     def __init__(self, label: str) -> None:
         ...
-26
-27
 class GreetingWithErrorsInput:
     greeting: typing.Optional[str]
-30
     def __init__(self, greeting: typing.Optional[str] = ...) -> None:
         ...
-33
-34
 class HostWithPathOperationInput:
     def __init__(self) -> None:
         ...
-38
-39
 class JsonUnionsInput:

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

@@ -1,1 +34,39 @@

 import json_rpc10.model
 import json_rpc10.types
 import typing
-4
 class ContentTypeParametersOutput:
     def __init__(self) -> None:
         ...
-+
-+
 class EmptyInputAndEmptyOutputOutput:
     def __init__(self) -> None:
         ...
-13
-14
 class EndpointOperationOutput:
     def __init__(self) -> None:
         ...
-18
-19

↧ Expand context

 class EndpointWithHostLabelOperationOutput:
     def __init__(self) -> None:
         ...
-23
-24
 class GreetingWithErrorsOutput:
     greeting: typing.Optional[str]
-27
     def __init__(self, greeting: typing.Optional[str] = ...) -> None:
         ...
-30
-31
 class HostWithPathOperationOutput:
     def __init__(self) -> None:
         ...
-35
-36
 class JsonUnionsOutput:
     contents: typing.Optional[json_rpc10.model.MyUnion]
     """

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

@@ -318,318 +377,433 @@

↥ Expand context

         variant: crate::error::ValidationException,
     ) -> crate::error::OperationWithDefaultsError {
         Self::ValidationException(variant)
-321
+    }
-322
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::OperationWithDefaultsError
-325
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::OperationWithDefaultsError {
         Self::InternalServerError(variant)
-330
+    }
-331
+}
-332
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::OperationWithDefaultsError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::OperationWithDefaultsError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {

                 return error.into();
-339
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
-342
+            }
             .into()
         })
-345
+    }
-346
+}
-347
 /// Error type for the `ContentTypeParameters` operation.
 /// Each variant represents an error that can occur for the `ContentTypeParameters` operation.
 #[derive(::std::fmt::Debug)]
 pub enum ContentTypeParametersError {
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-+
+}
 impl ::std::fmt::Display for ContentTypeParametersError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {
             ContentTypeParametersError::InternalServerError(_inner) => _inner.fmt(f),
-+
+        }
-+
+    }
-+
+}
 impl ContentTypeParametersError {
     /// Returns `true` if the error kind is `ContentTypeParametersError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(&self, ContentTypeParametersError::InternalServerError(_))
-+
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             ContentTypeParametersError::InternalServerError(_inner) => _inner.name(),
-+
+        }
-+
+    }
-+
+}
 impl ::std::error::Error for ContentTypeParametersError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             ContentTypeParametersError::InternalServerError(_inner) => Some(_inner),
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::ContentTypeParametersError
-+
+{
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::ContentTypeParametersError {
         Self::InternalServerError(variant)
-+
+    }
-+
+}
-+
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ContentTypeParametersError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ContentTypeParametersError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-+
             crate::error::InternalServerError {
                 message: error.to_string(),
-+
+            }
             .into()
         })
-+
+    }
-+
+}
-+
 /// Error type for the `PutWithContentEncoding` operation.
 /// Each variant represents an error that can occur for the `PutWithContentEncoding` operation.
 #[derive(::std::fmt::Debug)]
 pub enum PutWithContentEncodingError {
     #[allow(missing_docs)] // documentation missing in model
     InternalServerError(crate::error::InternalServerError),
-410
+}
 impl ::std::fmt::Display for PutWithContentEncodingError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match &self {

↧ Expand context

             PutWithContentEncodingError::InternalServerError(_inner) => _inner.fmt(f),
-415
+        }
-416
+    }
-417
+}
 impl PutWithContentEncodingError {
     /// Returns `true` if the error kind is `PutWithContentEncodingError::InternalServerError`.
     pub fn is_internal_server_error(&self) -> bool {
         matches!(&self, PutWithContentEncodingError::InternalServerError(_))
-422
+    }
     /// Returns the error name string by matching the correct variant.
     pub fn name(&self) -> &'static str {
         match &self {
             PutWithContentEncodingError::InternalServerError(_inner) => _inner.name(),
-427
+        }
-428
+    }
-429
+}
 impl ::std::error::Error for PutWithContentEncodingError {
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match &self {
             PutWithContentEncodingError::InternalServerError(_inner) => Some(_inner),

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

@@ -163,163 +222,277 @@

↥ Expand context

-163
+        }
-164
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-167
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-170
+    }
-171
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<OperationWithDefaultsInput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<OperationWithDefaultsInput>().map(Box::new)
-175
+    }
-176
+}
-177
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<OperationWithDefaultsInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-181
+    }
-182
+}

 impl crate::constrained::Constrained for crate::input::OperationWithDefaultsInput {
     type Unconstrained = crate::input::operation_with_defaults_input_internal::Builder;
-185
+}
 impl OperationWithDefaultsInput {
     /// Creates a new builder-style object to manufacture [`OperationWithDefaultsInput`](crate::input::OperationWithDefaultsInput).
     pub fn builder() -> crate::input::operation_with_defaults_input::Builder {
         crate::input::operation_with_defaults_input::Builder::default()
-190
+    }
-191
+}
-192
 #[::pyo3::pyclass]
 /// :param value typing.Optional\[int\]:
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ContentTypeParametersInput {
     #[pyo3(get, set)]
     /// :type typing.Optional\[int\]:
     #[allow(missing_docs)] // documentation missing in model
     pub value: ::std::option::Option<i32>,
-+
+}
 impl ContentTypeParametersInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn value(&self) -> ::std::option::Option<i32> {
         self.value
-+
+    }
-+
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl ContentTypeParametersInput {
     #[new]
     pub fn new(value: ::std::option::Option<i32>) -> Self {
         Self { value }
-+
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-+
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-+
+    }
-+
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ContentTypeParametersInput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ContentTypeParametersInput>().map(Box::new)
-+
+    }
-+
+}
-+
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ContentTypeParametersInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-+
+    }
-+
+}
 impl crate::constrained::Constrained for crate::input::ContentTypeParametersInput {
     type Unconstrained = crate::input::content_type_parameters_input_internal::Builder;
-+
+}
 impl ContentTypeParametersInput {
     /// Creates a new builder-style object to manufacture [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).
     pub fn builder() -> crate::input::content_type_parameters_input::Builder {
         crate::input::content_type_parameters_input::Builder::default()
-+
+    }
-+
+}
-+
 #[::pyo3::pyclass]
 /// :param encoding typing.Optional\[str\]:
 /// :param data typing.Optional\[str\]:
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct PutWithContentEncodingInput {
     #[pyo3(get, set)]

↧ Expand context

     /// :type typing.Optional\[str\]:
     #[allow(missing_docs)] // documentation missing in model
     pub encoding: ::std::option::Option<::std::string::String>,
     #[pyo3(get, set)]
     /// :type typing.Optional\[str\]:
     #[allow(missing_docs)] // documentation missing in model
     pub data: ::std::option::Option<::std::string::String>,
-265
+}
 impl PutWithContentEncodingInput {
     #[allow(missing_docs)] // documentation missing in model
     pub fn encoding(&self) -> ::std::option::Option<&str> {
         self.encoding.as_deref()
-270
+    }
     #[allow(missing_docs)] // documentation missing in model
     pub fn data(&self) -> ::std::option::Option<&str> {
         self.data.as_deref()
-274
+    }
-275
+}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]

@@ -1101,1156 +1160,1275 @@

↥ Expand context

-1156
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn top_level_default(mut self, input: ::std::string::String) -> Self {
             self.top_level_default = Some(input);
             self
-1161
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn other_top_level_default(mut self, input: i32) -> Self {
             self.other_top_level_default = Some(input);
             self
-1166
+        }
         /// Consumes the builder and constructs a [`OperationWithDefaultsInput`](crate::input::OperationWithDefaultsInput).
         pub fn build(self) -> crate::input::OperationWithDefaultsInput {
             self.build_enforcing_required_and_enum_traits()
-1170
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::input::OperationWithDefaultsInput {
             crate::input::OperationWithDefaultsInput {
                 defaults: self.defaults,

                 client_optional_defaults: self.client_optional_defaults,
                 top_level_default: self.top_level_default.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from("hi"),
                 ),
                 other_top_level_default: self.other_top_level_default.unwrap_or(0i32),
-1182
+            }
-1183
+        }
-1184
+    }
-1185
+}
 /// See [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).
 ///
 pub(crate) mod content_type_parameters_input_internal {
-+
     impl ::std::convert::From<Builder> for crate::input::ContentTypeParametersInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {
         pub(crate) value: ::std::option::Option<i32>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_value(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {
             self.value = input.map(|v| v.into());
             self
-+
+        }
         /// Consumes the builder and constructs a [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).
         pub fn build(self) -> crate::input::ContentTypeParametersInput {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::input::ContentTypeParametersInput {
             crate::input::ContentTypeParametersInput { value: self.value }
-+
+        }
-+
+    }
-+
+}
 /// See [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).
 ///
 pub mod content_type_parameters_input {
-+
     impl ::std::convert::From<Builder> for crate::input::ContentTypeParametersInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) value: ::std::option::Option<i32>,
-+
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub fn value(mut self, input: ::std::option::Option<i32>) -> Self {
             self.value = input;
             self
-+
+        }
         /// Consumes the builder and constructs a [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput).
         pub fn build(self) -> crate::input::ContentTypeParametersInput {
             self.build_enforcing_required_and_enum_traits()
-+
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::input::ContentTypeParametersInput {
             crate::input::ContentTypeParametersInput { value: self.value }
-+
+        }
-+
+    }
-+
+}
 /// See [`PutWithContentEncodingInput`](crate::input::PutWithContentEncodingInput).
 ///
 pub(crate) mod put_with_content_encoding_input_internal {
-1249
     impl ::std::convert::From<Builder> for crate::input::PutWithContentEncodingInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-1253
+        }
-1254
+    }
     /// A builder for [`PutWithContentEncodingInput`](crate::input::PutWithContentEncodingInput).

↧ Expand context

     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {
         pub(crate) encoding: ::std::option::Option<::std::string::String>,
         pub(crate) data: ::std::option::Option<::std::string::String>,
-1260
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_encoding(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.encoding = input.map(|v| v.into());
             self
-1269
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_data(
             mut self,
             input: Option<impl ::std::convert::Into<::std::string::String>>,
         ) -> Self {
             self.data = input.map(|v| v.into());

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

@@ -130,130 +218,223 @@

↥ Expand context

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

 //! # Example
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! use json_rpc10::{JsonRpc10, JsonRpc10Config};
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = JsonRpc10Config::builder().build();
 //!    let app = JsonRpc10::builder(config)
 //!        .content_type_parameters(content_type_parameters)
 //!        .empty_input_and_empty_output(empty_input_and_empty_output)
 //!        .endpoint_operation(endpoint_operation)
 //!        .endpoint_with_host_label_operation(endpoint_with_host_label_operation)
 //!        .greeting_with_errors(greeting_with_errors)
 //!        .host_with_path_operation(host_with_path_operation)
 //!        .json_unions(json_unions)
 //!        .no_input_and_no_output(no_input_and_no_output)
 //!        .no_input_and_output(no_input_and_output)
 //!        .operation_with_defaults(operation_with_defaults)
 //!        .operation_with_nested_structure(operation_with_nested_structure)
 //!        .operation_with_required_members(operation_with_required_members)
 //!        .put_with_content_encoding(put_with_content_encoding)
 //!        .simple_scalar_properties(simple_scalar_properties)
 //!        .build()
 //!        .expect("failed to build an instance of JsonRpc10");
 //!
 //!    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 json_rpc10::{input, output, error};
 //!
 //! async fn content_type_parameters(input: input::ContentTypeParametersInput) -> Result<output::ContentTypeParametersOutput, error::ContentTypeParametersError> {
 //!     todo!()
 //! }
 //!
 //! async fn empty_input_and_empty_output(input: input::EmptyInputAndEmptyOutputInput) -> Result<output::EmptyInputAndEmptyOutputOutput, error::EmptyInputAndEmptyOutputError> {
 //!     todo!()
 //! }
 //!
 //! async fn endpoint_operation(input: input::EndpointOperationInput) -> Result<output::EndpointOperationOutput, error::EndpointOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn endpoint_with_host_label_operation(input: input::EndpointWithHostLabelOperationInput) -> Result<output::EndpointWithHostLabelOperationOutput, error::EndpointWithHostLabelOperationError> {
 //!     todo!()

↧ Expand context

 //! }
 //!
 //! async fn greeting_with_errors(input: input::GreetingWithErrorsInput) -> Result<output::GreetingWithErrorsOutput, error::GreetingWithErrorsError> {
 //!     todo!()
 //! }
 //!
 //! async fn host_with_path_operation(input: input::HostWithPathOperationInput) -> Result<output::HostWithPathOperationOutput, error::HostWithPathOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn json_unions(input: input::JsonUnionsInput) -> Result<output::JsonUnionsOutput, error::JsonUnionsError> {
 //!     todo!()
 //! }
 //!
 //! async fn no_input_and_no_output(input: input::NoInputAndNoOutputInput) -> Result<output::NoInputAndNoOutputOutput, error::NoInputAndNoOutputError> {
 //!     todo!()
 //! }
 //!
 //! async fn no_input_and_output(input: input::NoInputAndOutputInput) -> Result<output::NoInputAndOutputOutput, error::NoInputAndOutputError> {
 //!     todo!()

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

@@ -281,281 +340,443 @@

↥ Expand context

-281
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-288
+                        }
-289
+                    }
-290
+    }
-291
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::error::OperationWithDefaultsError
-296
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));

                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-306
+            }
-307
+        }
-308
+    }
-309
+}
-310
 static CONTENT_TYPE_CONTENTTYPEPARAMETERS: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "application/x-amz-json-1.0"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput) using modelled bindings.
     pub struct ContentTypeParametersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ContentTypeParametersInput, ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for ContentTypeParametersInputFuture {
     type Output = Result<
         crate::input::ContentTypeParametersInput,
         ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::ContentTypeParametersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = ContentTypeParametersInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONTENTTYPEPARAMETERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         ContentTypeParametersInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::ContentTypeParametersOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::error::ContentTypeParametersError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 static CONTENT_TYPE_PUTWITHCONTENTENCODING: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "application/x-amz-json-1.0"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PutWithContentEncodingInput`](crate::input::PutWithContentEncodingInput) using modelled bindings.
     pub struct PutWithContentEncodingInputFuture {

↧ Expand context

         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PutWithContentEncodingInput, ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError>> + Send>>
-425
+    }
-426
+}
-427
 impl std::future::Future for PutWithContentEncodingInputFuture {
     type Output = Result<
         crate::input::PutWithContentEncodingInput,
         ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError,
     >;
-433
     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)
-440
+    }
-441
+}
-442
 impl<B>

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

@@ -63,63 +122,151 @@

↥ Expand context

-63
 #[allow(missing_docs)] // documentation missing in model
 pub struct OperationWithDefaults;
-66
 impl ::aws_smithy_http_server::operation::OperationShape for OperationWithDefaults {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.json10#OperationWithDefaults",
             "aws.protocoltests.json10",
             "OperationWithDefaults",
         );
-74
     type Input = crate::input::OperationWithDefaultsInput;
     type Output = crate::output::OperationWithDefaultsOutput;
     type Error = crate::error::OperationWithDefaultsError;
-78
+}
-79
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for OperationWithDefaults {
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::DefaultRequestFmt;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::DefaultResponseFmt;

-83
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
-86
+    }
-87
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-90
+    }
-91
+}
-92
 /// The example tests how servers must support requests containing a `Content-Type` header with parameters.
 pub struct ContentTypeParameters;
-+
 impl ::aws_smithy_http_server::operation::OperationShape for ContentTypeParameters {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.json10#ContentTypeParameters",
             "aws.protocoltests.json10",
             "ContentTypeParameters",
         );
-+
     type Input = crate::input::ContentTypeParametersInput;
     type Output = crate::output::ContentTypeParametersOutput;
     type Error = crate::error::ContentTypeParametersError;
-+
+}
-+
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for ContentTypeParameters {
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::DefaultRequestFmt;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::DefaultResponseFmt;
-+
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
-+
+    }
-+
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 pub struct PutWithContentEncoding;
-124
 impl ::aws_smithy_http_server::operation::OperationShape for PutWithContentEncoding {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.json10#PutWithContentEncoding",
             "aws.protocoltests.json10",
             "PutWithContentEncoding",
         );

↧ Expand context

-132
     type Input = crate::input::PutWithContentEncodingInput;
     type Output = crate::output::PutWithContentEncodingOutput;
     type Error = crate::error::PutWithContentEncodingError;
-136
+}
-137
 impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity
     for PutWithContentEncoding
-140
+{
     type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::DefaultRequestFmt;
     type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::DefaultResponseFmt;
-143
     fn request_fmt() -> Self::RequestFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
-146
+    }
-147
     fn response_fmt() -> Self::ResponseFmt {
         ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
-150
+    }
-151
+}

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

@@ -597,597 +656,696 @@

↥ Expand context

             zero_long,
             zero_float,
             zero_double,
-600
+        }
-601
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-604
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-607
+    }
-608
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<OperationWithDefaultsOutput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<OperationWithDefaultsOutput>().map(Box::new)
-612
+    }
-613
+}
-614
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<OperationWithDefaultsOutput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {

         (*self).into_py(py)
-618
+    }
-619
+}
 impl OperationWithDefaultsOutput {
     /// Creates a new builder-style object to manufacture [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).
     pub fn builder() -> crate::output::operation_with_defaults_output::Builder {
         crate::output::operation_with_defaults_output::Builder::default()
-624
+    }
-625
+}
-626
 #[::pyo3::pyclass]
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ContentTypeParametersOutput {}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]
 impl ContentTypeParametersOutput {
     #[new]
     pub fn new() -> Self {
         Self {}
-+
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-+
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-+
+    }
-+
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ContentTypeParametersOutput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ContentTypeParametersOutput>().map(Box::new)
-+
+    }
-+
+}
-+
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ContentTypeParametersOutput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-+
+    }
-+
+}
 impl ContentTypeParametersOutput {
     /// Creates a new builder-style object to manufacture [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
     pub fn builder() -> crate::output::content_type_parameters_output::Builder {
         crate::output::content_type_parameters_output::Builder::default()
-+
+    }
-+
+}
-+
 #[::pyo3::pyclass]
 /// :rtype None:
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct PutWithContentEncodingOutput {}
 #[allow(clippy::new_without_default)]
 #[allow(clippy::too_many_arguments)]
 #[::pyo3::pymethods]

↧ Expand context

 impl PutWithContentEncodingOutput {
     #[new]
     pub fn new() -> Self {
         Self {}
-681
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-684
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-687
+    }
-688
+}
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<PutWithContentEncodingOutput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<PutWithContentEncodingOutput>().map(Box::new)
-692
+    }
-693
+}
-694
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<PutWithContentEncodingOutput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {

@@ -1628,1668 +1687,1751 @@

↥ Expand context

                 default_double: self.default_double.unwrap_or(1.0f64),
                 default_map: self.default_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 default_enum: self.default_enum.unwrap_or(
                     "FOO"
                         .parse::<crate::model::TestEnum>()
                         .expect("static value validated to member"),
                 ),
                 default_int_enum: self.default_int_enum.unwrap_or(1i32),
                 empty_string: self.empty_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from(""),
                 ),
                 false_boolean: self.false_boolean.unwrap_or(false),
                 empty_blob: self.empty_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new("").into(),
                 ),

                 zero_byte: self.zero_byte.unwrap_or(0i8),
                 zero_short: self.zero_short.unwrap_or(0i16),
                 zero_integer: self.zero_integer.unwrap_or(0i32),
                 zero_long: self.zero_long.unwrap_or(0i64),
                 zero_float: self.zero_float.unwrap_or(0.0f32),
                 zero_double: self.zero_double.unwrap_or(0.0f64),
-1694
+            }
-1695
+        }
-1696
+    }
-1697
+}
 /// See [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
 ///
 pub mod content_type_parameters_output {
-+
     impl ::std::convert::From<Builder> for crate::output::ContentTypeParametersOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
         pub fn build(self) -> crate::output::ContentTypeParametersOutput {
             self.build_enforcing_required_and_enum_traits()
-+
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::output::ContentTypeParametersOutput {
             crate::output::ContentTypeParametersOutput {}
-+
+        }
-+
+    }
-+
+}
 /// See [`PutWithContentEncodingOutput`](crate::output::PutWithContentEncodingOutput).
 ///
 pub mod put_with_content_encoding_output {
-1725
     impl ::std::convert::From<Builder> for crate::output::PutWithContentEncodingOutput {
         fn from(builder: Builder) -> Self {
             builder.build()
-1729
+        }
-1730
+    }
     /// A builder for [`PutWithContentEncodingOutput`](crate::output::PutWithContentEncodingOutput).

↧ Expand context

     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`PutWithContentEncodingOutput`](crate::output::PutWithContentEncodingOutput).
         pub fn build(self) -> crate::output::PutWithContentEncodingOutput {
             self.build_enforcing_required_and_enum_traits()
-1738
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::output::PutWithContentEncodingOutput {
             crate::output::PutWithContentEncodingOutput {}
-1743
+        }
-1744
+    }
-1745
+}
 /// See [`HostWithPathOperationOutput`](crate::output::HostWithPathOperationOutput).
 ///
 pub mod host_with_path_operation_output {
-1749
     impl ::std::convert::From<Builder> for crate::output::HostWithPathOperationOutput {
         fn from(builder: Builder) -> Self {

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

@@ -1,1 +69,73 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) mod shape_content_type_parameters;
-+
 pub(crate) mod shape_empty_input_and_empty_output;
-5
 pub(crate) mod shape_endpoint_operation;
-7
 pub(crate) mod shape_endpoint_with_host_label_operation;
-9
 pub(crate) mod shape_greeting_with_errors;
-11
 pub(crate) mod shape_host_with_path_operation;
-13
 pub(crate) mod shape_json_unions;
-15
 pub(crate) mod shape_no_input_and_no_output;
-17
 pub(crate) mod shape_no_input_and_output;
-19
 pub(crate) mod shape_operation_with_defaults;
-21
 pub(crate) mod shape_operation_with_nested_structure;
-23
 pub(crate) mod shape_operation_with_required_members;
-25
 pub(crate) mod shape_put_with_content_encoding;
-27
 pub(crate) mod shape_simple_scalar_properties;
-29
 pub(crate) mod shape_complex_error;
-31
 pub(crate) mod shape_empty_input_and_empty_output_output;
--
 pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
     if data.is_empty() {
         b"{}"
     } else {
         data
-37
+    }
-38
+}
-39
 pub(crate) mod shape_content_type_parameters_output;
-+
 pub(crate) mod shape_empty_input_and_empty_output_output;
-+
 pub(crate) mod shape_foo_error;
-45
 pub(crate) mod shape_greeting_with_errors_output;
-47
 pub(crate) mod shape_internal_server_error;
-49
 pub(crate) mod shape_invalid_greeting;
-51
 pub(crate) mod shape_json_unions_output;
-53

↧ Expand context

 pub(crate) mod shape_no_input_and_output_output;
-55
 pub(crate) mod shape_operation_with_defaults_output;
-57
 pub(crate) mod shape_operation_with_nested_structure_output;
-59
 pub(crate) mod shape_operation_with_required_members_output;
-61
 pub(crate) mod shape_simple_scalar_properties_output;
-63
 pub(crate) mod shape_validation_exception;
-65
 pub(crate) mod shape_client_optional_defaults;
-67
 pub(crate) mod shape_defaults;
-69
 pub(crate) mod shape_my_union;
-71
 pub(crate) mod shape_top_level;
-73

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

@@ -0,1 +0,148 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_content_type_parameters_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
 ) -> std::result::Result<
     crate::input::ContentTypeParametersInput,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection,
-+
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::content_type_parameters_input_internal::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/x-amz-json-1.0"),
             )?;
             input =
                 crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters(
                     bytes.as_ref(),
                     input,
                 )?;
-+
+        }
         input.build()
     })
-+
+}
-+
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_content_type_parameters_http_response(
     #[allow(unused_variables)] output: crate::output::ContentTypeParametersOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::aws_json::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             "application/x-amz-json-1.0",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_content_type_parameters_output::ser_content_type_parameters_output_output_output(&output)?
-+
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-+
+}
-+
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_content_type_parameters_http_error(
     error: &crate::error::ContentTypeParametersError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::aws_json::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::ContentTypeParametersError::InternalServerError(output) => {
                 let payload = crate::protocol_serde::shape_internal_server_error::ser_internal_server_error_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     "application/x-amz-json-1.0",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(500)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-+
+            }
-+
+        }
     })
-+
+}
-+
 pub(crate) fn de_content_type_parameters(
     value: &[u8],
     mut builder: crate::input::content_type_parameters_input_internal::Builder,
 ) -> Result<
     crate::input::content_type_parameters_input_internal::Builder,
     ::aws_smithy_json::deserialize::error::DeserializeError,
 > {
     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())?;
     loop {
         match tokens.next().transpose()? {
             Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
             Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                 match key.to_unescaped()?.as_ref() {
                     "value" => {
                         builder = builder.set_value(
                             ::aws_smithy_json::deserialize::token::expect_number_or_null(
                                 tokens.next(),
                             )?
                             .map(i32::try_from)
                             .transpose()?,
                         );
-+
+                    }
                     _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
-+
+                }
-+
+            }
             other => {
                 return Err(
                     ::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                         "expected object key or end object, found: {:?}",
                         other
                     )),
-+
+                )
-+
+            }
-+
+        }
-+
+    }
     if tokens.next().is_some() {
         return Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "found more JSON tokens after completing parsing",
             ),
         );
-+
+    }
     Ok(builder)
-+
+}

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

@@ -0,1 +0,17 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub fn ser_content_type_parameters_output_output_output(
     value: &crate::output::ContentTypeParametersOutput,
 ) -> Result<String, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_content_type_parameters_output::ser_content_type_parameters_output_output(&mut object, value)?;
     object.finish();
     Ok(out)
-+
+}
-+
 pub fn ser_content_type_parameters_output_output(
     #[allow(unused_variables)] object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     #[allow(unused_variables)] input: &crate::output::ContentTypeParametersOutput,
 ) -> Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     Ok(())
-+
+}

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

@@ -1,1 +53,55 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[::pyo3::pymodule]
 #[::pyo3(name = "json_rpc10")]
 pub fn python_library(py: ::pyo3::Python<'_>, m: &::pyo3::types::PyModule) -> ::pyo3::PyResult<()> {
     let input = ::pyo3::types::PyModule::new(py, "input")?;
     let output = ::pyo3::types::PyModule::new(py, "output")?;
     let error = ::pyo3::types::PyModule::new(py, "error")?;
     error.add_class::<crate::error::InternalServerError>()?;
     error.add_class::<crate::error::ValidationException>()?;
     let model = ::pyo3::types::PyModule::new(py, "model")?;
     model.add_class::<crate::model::ValidationExceptionField>()?;
     output.add_class::<crate::output::OperationWithNestedStructureOutput>()?;
     model.add_class::<crate::model::Dialog>()?;

     model.add_class::<crate::model::Farewell>()?;
     input.add_class::<crate::input::OperationWithNestedStructureInput>()?;
     model.add_class::<crate::model::TopLevel>()?;
     output.add_class::<crate::output::OperationWithRequiredMembersOutput>()?;
     input.add_class::<crate::input::OperationWithRequiredMembersInput>()?;
     output.add_class::<crate::output::OperationWithDefaultsOutput>()?;
     model.add_class::<crate::model::TestEnum>()?;
     input.add_class::<crate::input::OperationWithDefaultsInput>()?;
     model.add_class::<crate::model::ClientOptionalDefaults>()?;
     model.add_class::<crate::model::Defaults>()?;
     output.add_class::<crate::output::ContentTypeParametersOutput>()?;
     input.add_class::<crate::input::ContentTypeParametersInput>()?;
     output.add_class::<crate::output::PutWithContentEncodingOutput>()?;
     input.add_class::<crate::input::PutWithContentEncodingInput>()?;
     output.add_class::<crate::output::HostWithPathOperationOutput>()?;
     input.add_class::<crate::input::HostWithPathOperationInput>()?;
     output.add_class::<crate::output::EndpointWithHostLabelOperationOutput>()?;
     input.add_class::<crate::input::EndpointWithHostLabelOperationInput>()?;
     output.add_class::<crate::output::EndpointOperationOutput>()?;
     input.add_class::<crate::input::EndpointOperationInput>()?;
     output.add_class::<crate::output::JsonUnionsOutput>()?;
     model.add_class::<crate::model::PyUnionMarkerMyUnion>()?;

↧ Expand context

     model.add_class::<crate::model::GreetingStruct>()?;
     model.add_class::<crate::model::FooEnum>()?;
     input.add_class::<crate::input::JsonUnionsInput>()?;
     error.add_class::<crate::error::FooError>()?;
     error.add_class::<crate::error::ComplexError>()?;
     model.add_class::<crate::model::ComplexNestedErrorData>()?;
     error.add_class::<crate::error::InvalidGreeting>()?;
     output.add_class::<crate::output::GreetingWithErrorsOutput>()?;
     input.add_class::<crate::input::GreetingWithErrorsInput>()?;
     output.add_class::<crate::output::SimpleScalarPropertiesOutput>()?;
     input.add_class::<crate::input::SimpleScalarPropertiesInput>()?;
     output.add_class::<crate::output::EmptyInputAndEmptyOutputOutput>()?;
     input.add_class::<crate::input::EmptyInputAndEmptyOutputInput>()?;
     output.add_class::<crate::output::NoInputAndOutputOutput>()?;
     input.add_class::<crate::input::NoInputAndOutputInput>()?;
     output.add_class::<crate::output::NoInputAndNoOutputOutput>()?;
     input.add_class::<crate::input::NoInputAndNoOutputInput>()?;
     ::pyo3::py_run!(
         py,
         input,

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

@@ -137,137 +196,251 @@

↥ Expand context

             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::OperationWithDefaultsOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "operation_with_defaults",
             "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::OperationWithDefaultsOutput>()
         })
     };
     // 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()
     })
-165
+}
-166
 /// Python handler for operation `ContentTypeParameters`.
 pub(crate) async fn content_type_parameters(
     input: crate::input::ContentTypeParametersInput,
     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::ContentTypeParametersOutput,
     crate::error::ContentTypeParametersError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "content_type_parameters",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::ContentTypeParametersOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "content_type_parameters",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::ContentTypeParametersOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-+
+}
-+
 /// Python handler for operation `PutWithContentEncoding`.
 pub(crate) async fn put_with_content_encoding(
     input: crate::input::PutWithContentEncodingInput,
     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::PutWithContentEncodingOutput,
     crate::error::PutWithContentEncodingError,
 > {
     // Async block used to run the handler and catch any Python error.

↧ Expand context

     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "put_with_content_encoding",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::PutWithContentEncodingOutput>(py)
             })
         })
     } else {

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

@@ -1,1 +58,64 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[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
 /// from json_rpc10 import input
 /// from json_rpc10 import output
 /// from json_rpc10 import error
 /// from json_rpc10 import middleware
 /// from json_rpc10 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)
 ///
 /// # The example tests how servers must support requests
 /// # containing a `Content-Type` header with parameters.
 /// @app.content_type_parameters
 /// def content_type_parameters(input: input::ContentTypeParametersInput, ctx: Context) -> output::ContentTypeParametersOutput:
 ///     raise NotImplementedError
 ///
 /// # The example tests how requests and responses are serialized when there's
 /// # no request or response payload because the operation has an empty input
 /// # and empty output structure that reuses the same shape. While this should
 /// # be rare, code generators must support this.
 /// @app.empty_input_and_empty_output
 /// def empty_input_and_empty_output(input: input::EmptyInputAndEmptyOutputInput, ctx: Context) -> output::EmptyInputAndEmptyOutputOutput:
 ///     raise NotImplementedError
 ///
 /// @app.endpoint_operation
 /// def endpoint_operation(input: input::EndpointOperationInput, ctx: Context) -> output::EndpointOperationOutput:

↧ Expand context

 ///     raise NotImplementedError
 ///
 /// @app.endpoint_with_host_label_operation
 /// def endpoint_with_host_label_operation(input: input::EndpointWithHostLabelOperationInput, ctx: Context) -> output::EndpointWithHostLabelOperationOutput:
 ///     raise NotImplementedError
 ///
 /// # This operation has three possible return values:
 /// #
 /// # 1. A successful response in the form of GreetingWithErrorsOutput
 /// # 2. An InvalidGreeting error.
 /// # 3. A ComplexError error.
 /// #
 /// # Implementations must be able to successfully take a response and
 /// # properly deserialize successful and error responses.
 /// @app.greeting_with_errors
 /// def greeting_with_errors(input: input::GreetingWithErrorsInput, ctx: Context) -> output::GreetingWithErrorsOutput:
 ///     raise NotImplementedError
 ///
 /// @app.host_with_path_operation
 /// def host_with_path_operation(input: input::HostWithPathOperationInput, ctx: Context) -> output::HostWithPathOperationOutput:

@@ -130,136 +189,211 @@

↥ Expand context

             handlers: self.handlers.clone(),
             middlewares: self.middlewares.clone(),
             context: self.context.clone(),
             workers: ::parking_lot::Mutex::new(vec![]),
-140
+        }
-141
+    }
-142
+}
 impl ::aws_smithy_http_server_python::PyApp for App {
     fn workers(&self) -> &::parking_lot::Mutex<Vec<::pyo3::PyObject>> {
         &self.workers
-146
+    }
     fn context(&self) -> &Option<::pyo3::PyObject> {
         &self.context
-149
+    }
     fn handlers(
         &mut self,
     ) -> &mut ::std::collections::HashMap<String, ::aws_smithy_http_server_python::PyHandler> {
         &mut self.handlers
-154
+    }
     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,
         >,
     > {
         let builder = crate::service::JsonRpc10::builder_without_plugins();
         let content_type_parameters_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("content_type_parameters")
             .expect("Python handler for operation `content_type_parameters` not found")
             .clone();
         let builder = builder.content_type_parameters(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 content_type_parameters_locals.clone(),
                 crate::python_operation_adaptor::content_type_parameters(
                     input,
                     state,
                     handler.clone(),
                 ),
-+
+            )
         });
         let empty_input_and_empty_output_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("empty_input_and_empty_output")
             .expect("Python handler for operation `empty_input_and_empty_output` not found")
             .clone();
         let builder = builder.empty_input_and_empty_output(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 empty_input_and_empty_output_locals.clone(),
                 crate::python_operation_adaptor::empty_input_and_empty_output(

↧ Expand context

                     input,
                     state,
                     handler.clone(),
                 ),
-196
+            )
         });
         let endpoint_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("endpoint_operation")
             .expect("Python handler for operation `endpoint_operation` not found")
             .clone();
         let builder = builder.endpoint_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 endpoint_operation_locals.clone(),
                 crate::python_operation_adaptor::endpoint_operation(input, state, handler.clone()),
-208
+            )
         });
         let endpoint_with_host_label_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self

@@ -430,452 +489,525 @@

↥ 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)
-457
+    }
-458
     /// 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)
-466
+    }
-467
     /// 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)
-481
+    }
     /// Method to register `content_type_parameters` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc10.input.ContentTypeParametersInput, Ctx\], typing.Union\[json_rpc10.output.ContentTypeParametersOutput, typing.Awaitable\[json_rpc10.output.ContentTypeParametersOutput\]\]\], typing.Callable\[\[json_rpc10.input.ContentTypeParametersInput\], typing.Union\[json_rpc10.output.ContentTypeParametersOutput, typing.Awaitable\[json_rpc10.output.ContentTypeParametersOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn content_type_parameters(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "content_type_parameters", func)
-+
+    }
     /// Method to register `empty_input_and_empty_output` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc10.input.EmptyInputAndEmptyOutputInput, Ctx\], typing.Union\[json_rpc10.output.EmptyInputAndEmptyOutputOutput, typing.Awaitable\[json_rpc10.output.EmptyInputAndEmptyOutputOutput\]\]\], typing.Callable\[\[json_rpc10.input.EmptyInputAndEmptyOutputInput\], typing.Union\[json_rpc10.output.EmptyInputAndEmptyOutputOutput, typing.Awaitable\[json_rpc10.output.EmptyInputAndEmptyOutputOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn empty_input_and_empty_output(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,

↧ Expand context

     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "empty_input_and_empty_output", func)
-509
+    }
     /// Method to register `endpoint_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc10.input.EndpointOperationInput, Ctx\], typing.Union\[json_rpc10.output.EndpointOperationOutput, typing.Awaitable\[json_rpc10.output.EndpointOperationOutput\]\]\], typing.Callable\[\[json_rpc10.input.EndpointOperationInput\], typing.Union\[json_rpc10.output.EndpointOperationOutput, typing.Awaitable\[json_rpc10.output.EndpointOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn endpoint_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "endpoint_operation", func)
-523
+    }
     /// Method to register `endpoint_with_host_label_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.

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