Server Test Python

rev. 1d902e1fdfff69f8aafe42b2306fa317ef96d562 (ignoring whitespace)

Files changed:

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

@@ -1,0 +170,0 @@

 import json_rpc10.model
 import json_rpc10.types
 import typing
--
 class ContentTypeParametersOutput:
     def __init__(self) -> None:
         ...
--
--
 class EmptyInputAndEmptyOutputOutput:
     def __init__(self) -> None:
         ...
--
--
 class EndpointOperationOutput:
     def __init__(self) -> None:
         ...
--
--
 class EndpointWithHostLabelOperationOutput:
     def __init__(self) -> None:
         ...
--
--
 class GreetingWithErrorsOutput:
     greeting: typing.Optional[str]
--
     def __init__(self, greeting: typing.Optional[str] = ...) -> None:
         ...
--
--
 class HostWithPathOperationOutput:
     def __init__(self) -> None:
         ...
--
--
 class JsonUnionsOutput:
     contents: typing.Optional[json_rpc10.model.MyUnion]
     """
     A union with a representative set of types for members.
     """
--
     def __init__(self, contents: typing.Optional[json_rpc10.model.MyUnion] = ...) -> None:
         ...
--
--
 class NoInputAndNoOutputOutput:
     def __init__(self) -> None:
         ...
--
--
 class NoInputAndOutputOutput:
     def __init__(self) -> None:
         ...
--
--
 class OperationWithDefaultsOutput:
     default_blob: json_rpc10.types.Blob
--
     default_boolean: bool
--
     default_byte: int
--
     default_document_boolean: json_rpc10.types.Document
--
     default_document_list: json_rpc10.types.Document
--
     default_document_map: json_rpc10.types.Document
--
     default_document_string: json_rpc10.types.Document
--
     default_double: float
--
     default_enum: json_rpc10.model.TestEnum
--
     default_float: float
--
     default_int_enum: int
--
     default_integer: int
--
     default_list: typing.List[str]
--
     default_long: int
--
     default_map: typing.Dict[str, str]
--
     default_null_document: typing.Optional[json_rpc10.types.Document]
--
     default_short: int
--
     default_string: str
--
     default_timestamp: json_rpc10.types.DateTime
--
     empty_blob: json_rpc10.types.Blob
--
     empty_string: str
--
     false_boolean: bool
--
     zero_byte: int
--
     zero_double: float
--
     zero_float: float
--
     zero_integer: int
--
     zero_long: int
--
     zero_short: int
--
     def __init__(self, default_string: str, default_boolean: bool, default_list: typing.List[str], default_document_map: json_rpc10.types.Document, default_document_string: json_rpc10.types.Document, default_document_boolean: json_rpc10.types.Document, default_document_list: json_rpc10.types.Document, default_null_document: typing.Optional[json_rpc10.types.Document] = ..., default_timestamp: json_rpc10.types.DateTime, default_blob: json_rpc10.types.Blob, default_byte: int, default_short: int, default_integer: int, default_long: int, default_float: float, default_double: float, default_map: typing.Dict[str, str], default_enum: json_rpc10.model.TestEnum, default_int_enum: int, empty_string: str, false_boolean: bool, empty_blob: json_rpc10.types.Blob, zero_byte: int, zero_short: int, zero_integer: int, zero_long: int, zero_float: float, zero_double: float) -> None:
         ...
--
--
 class OperationWithNestedStructureOutput:
     dialog: json_rpc10.model.Dialog
--
     dialog_list: typing.List[json_rpc10.model.Dialog]
--
     dialog_map: typing.Dict[str, json_rpc10.model.Dialog]
--
     def __init__(self, dialog: json_rpc10.model.Dialog, dialog_list: typing.List[json_rpc10.model.Dialog], dialog_map: typing.Dict[str, json_rpc10.model.Dialog]) -> None:
         ...
--
--
 class OperationWithRequiredMembersOutput:
     required_blob: json_rpc10.types.Blob
--
     required_boolean: bool
--
     required_byte: int
--
     required_double: float
--
     required_float: float
--
     required_integer: int
--
     required_list: typing.List[str]
--
     required_long: int
--
     required_map: typing.Dict[str, str]
--
     required_short: int
--
     required_string: str
--
     required_timestamp: json_rpc10.types.DateTime
--
     def __init__(self, required_string: str, required_boolean: bool, required_list: typing.List[str], required_timestamp: json_rpc10.types.DateTime, required_blob: json_rpc10.types.Blob, required_byte: int, required_short: int, required_integer: int, required_long: int, required_float: float, required_double: float, required_map: typing.Dict[str, str]) -> None:
         ...
--
--
 class PutWithContentEncodingOutput:
     def __init__(self) -> None:
         ...
--
--
 class SimpleScalarPropertiesOutput:
     double_value: typing.Optional[float]
--
     float_value: typing.Optional[float]
--
     def __init__(self, float_value: typing.Optional[float] = ..., double_value: typing.Optional[float] = ...) -> None:
         ...
--

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

@@ -1,0 +27,0 @@

 import typing
--
 class PySocket:
     """
     Socket implementation that can be shared between multiple Python processes.
--
     Python cannot handle true multi-threaded applications due to the [GIL],
     often resulting in reduced performance and only one core used by the application.
     To work around this, Python web applications usually create a socket with
     SO_REUSEADDR and SO_REUSEPORT enabled that can be shared between multiple
     Python processes, allowing you to maximize performance and use all available
     computing capacity of the host.
--
     [GIL]: https://wiki.python.org/moin/GlobalInterpreterLock
     """
--
     def try_clone(self) -> PySocket:
         """
         Clone the inner socket allowing it to be shared between multiple
         Python processes.
         """
         ...
--
--
     def __init__(self, address: str, port: int, backlog: typing.Optional[int] = ...) -> None:
         ...
--

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

@@ -1,0 +10,0 @@

 import pathlib
--
 class TlsConfig:
     """
     PyTlsConfig represents TLS configuration created from Python.
     """
--
     def __init__(self, key_path: pathlib.Path, cert_path: pathlib.Path, reload_secs: int = ...) -> None:
         ...
--

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

@@ -1,0 +209,0 @@

 import typing
--
 class Blob:
     """
     Python Wrapper for [aws_smithy_types::Blob].
     """
--
     data: bytes
     """
     Python getter for the `Blob` byte array.
     """
--
     def __init__(self, input: bytes) -> None:
         ...
--
--
 class ByteStream:
     """
     Python Wrapper for [aws_smithy_types::byte_stream::ByteStream].
--
     ByteStream provides misuse-resistant primitives to make it easier to handle common patterns with streaming data.
--
     On the Rust side, The Python implementation wraps the original [ByteStream](aws_smithy_types::byte_stream::ByteStream)
     in a clonable structure and implements the [Stream](futures::stream::Stream) trait for it to
     allow Rust to handle the type transparently.
--
     On the Python side both sync and async iterators are exposed by implementing `__iter__()` and `__aiter__()` magic methods,
     which allows to just loop over the stream chunks.
--
     ### Example of async streaming:
--
     ```python
         stream = await ByteStream.from_path("/tmp/music.mp3")
         async for chunk in stream:
             print(chunk)
     ```
--
     ### Example of sync streaming:
--
     ```python
         stream = ByteStream.from_stream_blocking("/tmp/music.mp3")
         for chunk in stream:
             print(chunk)
     ```
--
     The main difference between the two implementations is that the async one is scheduling the Python coroutines as Rust futures,
     effectively maintaining the asyncronous behavior that Rust exposes, while the sync one is blocking the Tokio runtime to be able
     to await one chunk at a time.
--
     The original Rust [ByteStream](aws_smithy_types::byte_stream::ByteStream) is wrapped inside a `Arc<Mutex>` to allow the type to be
     [Clone] (required by PyO3) and to allow internal mutability, required to fetch the next chunk of data.
     """
--
     @staticmethod
     def from_path(path: str) -> typing.Awaitable[ByteStream]:
         """
         Create a new [ByteStream](aws_smithy_types::byte_stream::ByteStream) from a path, forcing
         Python to await this coroutine.
         """
         ...
--
--
     @staticmethod
     def from_path_blocking(path: str) -> ByteStream:
         """
         Create a new [ByteStream](aws_smithy_types::byte_stream::ByteStream) from a path, without
         requiring Python to await this method.
--
         **NOTE:** This method will block the Rust event loop when it is running.
         """
         ...
--
--
     def __init__(self, input: bytes) -> None:
         ...
--
--
 class DateTime:
     """
     Python Wrapper for [aws_smithy_types::date_time::DateTime].
     """
--
     def as_nanos(self) -> int:
         """
         Returns the number of nanoseconds since the Unix epoch that this `DateTime` represents.
         """
         ...
--
--
     def as_secs_f64(self) -> float:
         """
         Returns the `DateTime` value as an `f64` representing the seconds since the Unix epoch.
         """
         ...
--
--
     @staticmethod
     def from_fractional_secs(epoch_seconds: int, fraction: float) -> DateTime:
         """
         Creates a `DateTime` from a number of seconds and a fractional second since the Unix epoch.
         """
         ...
--
--
     @staticmethod
     def from_millis(epoch_millis: int) -> DateTime:
         """
         Creates a `DateTime` from a number of milliseconds since the Unix epoch.
         """
         ...
--
--
     @staticmethod
     def from_nanos(epoch_nanos: int) -> DateTime:
         """
         Creates a `DateTime` from a number of nanoseconds since the Unix epoch.
         """
         ...
--
--
     @staticmethod
     def from_secs(epoch_seconds: int) -> DateTime:
         """
         Creates a `DateTime` from a number of seconds since the Unix epoch.
         """
         ...
--
--
     @staticmethod
     def from_secs_and_nanos(seconds: int, subsecond_nanos: int) -> DateTime:
         """
         Creates a `DateTime` from a number of seconds and sub-second nanos since the Unix epoch.
         """
         ...
--
--
     @staticmethod
     def from_secs_f64(epoch_seconds: float) -> DateTime:
         """
         Creates a `DateTime` from an `f64` representing the number of seconds since the Unix epoch.
         """
         ...
--
--
     @staticmethod
     def from_str(s: str, format: Format) -> DateTime:
         """
         Parses a `DateTime` from a string using the given `format`.
         """
         ...
--
--
     def has_subsec_nanos(self) -> bool:
         """
         Returns true if sub-second nanos is greater than zero.
         """
         ...
--
--
     @staticmethod
     def read(format: Format, delim: str) -> typing.Tuple[DateTime, str]:
         """
         Read 1 date of `format` from `s`, expecting either `delim` or EOF.
--
         TODO(PythonTyping): How do we represent `char` in Python?
         """
         ...
--
--
     def secs(self) -> int:
         """
         Returns the epoch seconds component of the `DateTime`.
         """
         ...
--
--
     def subsec_nanos(self) -> int:
         """
         Returns the sub-second nanos component of the `DateTime`.
         """
         ...
--
--
     def to_millis(self) -> int:
         """
         Converts the `DateTime` to the number of milliseconds since the Unix epoch.
         """
         ...
--
--
 class Format:
     """
     Formats for representing a `DateTime` in the Smithy protocols.
     """
--
     DateTime: Format
     """
     Formats for representing a `DateTime` in the Smithy protocols.
     """
--
     EpochSeconds: Format
     """
     Formats for representing a `DateTime` in the Smithy protocols.
     """
--
     HttpDate: Format
     """
     Formats for representing a `DateTime` in the Smithy protocols.
     """

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

@@ -1796,1796 +1863,1857 @@

↥ Expand context

         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_dialog_list(
             mut self,
             input: impl ::std::convert::Into<::std::vec::Vec<crate::model::Dialog>>,
         ) -> Self {
             self.dialog_list = Some(input.into());
             self
-1803
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_dialog_map(
             mut self,
             input: impl ::std::convert::Into<
                 ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
             >,
         ) -> Self {
             self.dialog_map = Some(input.into());
             self
-1813
+        }
         /// Consumes the builder and constructs a [`TopLevel`](crate::model::TopLevel).
         ///

         /// The builder fails to construct a [`TopLevel`](crate::model::TopLevel) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::model::TopLevel, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-1820
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::TopLevel, ConstraintViolation> {
             Ok(crate::model::TopLevel {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 dialog_list: self.dialog_list.unwrap_or_default(),
                 dialog_map: self.dialog_map.unwrap_or_default(),
             })
-1829
+        }
-1830
+    }
-1831
+}
 /// See [`TopLevel`](crate::model::TopLevel).
 pub mod top_level {
-1834
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
-1837

↧ Expand context

     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `dialog` was not provided but it is required when building `TopLevel`.
         MissingDialog,
-1842
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingDialog => write!(
                     f,
                     "`dialog` was not provided but it is required when building `TopLevel`"
                 ),
-1850
+            }
-1851
+        }
-1852
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::TopLevel {
         type Error = ConstraintViolation;
-1856
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

@@ -1877,1871 +1944,1932 @@

↥ Expand context

         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog(mut self, input: crate::model::Dialog) -> Self {
             self.dialog = Some(input);
             self
-1875
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_list(mut self, input: ::std::vec::Vec<crate::model::Dialog>) -> Self {
             self.dialog_list = Some(input);
             self
-1880
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_map(
             mut self,
             input: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
         ) -> Self {
             self.dialog_map = Some(input);
             self
-1888
+        }
         /// Consumes the builder and constructs a [`TopLevel`](crate::model::TopLevel).
         ///

         /// The builder fails to construct a [`TopLevel`](crate::model::TopLevel) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(self) -> Result<crate::model::TopLevel, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-1895
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::model::TopLevel, ConstraintViolation> {
             Ok(crate::model::TopLevel {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 dialog_list: self.dialog_list.unwrap_or_default(),
                 dialog_map: self.dialog_map.unwrap_or_default(),
             })
-1904
+        }
-1905
+    }
-1906
+}
 /// See [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
 pub(crate) mod client_optional_defaults_internal {
-1909
     impl ::std::convert::From<Builder> for crate::model::ClientOptionalDefaults {
         fn from(builder: Builder) -> Self {
             builder.build()

↧ Expand context

-1913
+        }
-1914
+    }
     /// A builder for [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {
         pub(crate) member: ::std::option::Option<i32>,
-1919
+    }
     impl Builder {
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_member(mut self, input: impl ::std::convert::Into<i32>) -> Self {
             self.member = Some(input.into());
             self
-1925
+        }
         /// Consumes the builder and constructs a [`ClientOptionalDefaults`](crate::model::ClientOptionalDefaults).
         pub fn build(self) -> crate::model::ClientOptionalDefaults {
             self.build_enforcing_all_constraints()
-1929
+        }
         fn build_enforcing_all_constraints(self) -> crate::model::ClientOptionalDefaults {
             crate::model::ClientOptionalDefaults {
                 member: self.member.unwrap_or(0i32),

@@ -2245,2233 +2348,2330 @@

↥ Expand context

         pub(crate) fn set_zero_long(mut self, input: impl ::std::convert::Into<i64>) -> Self {
             self.zero_long = Some(input.into());
             self
-2236
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_zero_float(mut self, input: impl ::std::convert::Into<f32>) -> Self {
             self.zero_float = Some(input.into());
             self
-2241
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub(crate) fn set_zero_double(mut self, input: impl ::std::convert::Into<f64>) -> Self {
             self.zero_double = Some(input.into());
             self
-2246
+        }
         /// Consumes the builder and constructs a [`Defaults`](crate::model::Defaults).
         ///
         /// The builder fails to construct a [`Defaults`](crate::model::Defaults) if a [`ConstraintViolation`] occurs.
         ///
         pub fn build(self) -> Result<crate::model::Defaults, ConstraintViolation> {
             self.build_enforcing_all_constraints()

-2253
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::Defaults, ConstraintViolation> {
             Ok(crate::model::Defaults {
                 default_string: self.default_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from("hi"),
                 ),
                 default_boolean: self.default_boolean.unwrap_or(true),
                 default_list: self.default_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 default_list: self.default_list.unwrap_or_default(),
                 default_document_map: self.default_document_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || {
                         ::aws_smithy_types::Document::Object(::std::collections::HashMap::new())
                             .into()
                     },
                 ),
                 default_document_string: self.default_document_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || {
                         ::aws_smithy_types::Document::String(::std::string::String::from("hi"))
                             .into()
                     },
                 ),
                 default_document_boolean: self
                     .default_document_boolean
                     .unwrap_or(::aws_smithy_types::Document::Bool(true).into()),
                 default_document_list: self.default_document_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Array(::std::vec::Vec::new()).into(),
                 ),
                 default_null_document: self.default_null_document,
                 default_timestamp: self.default_timestamp.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64).into(),
                 ),
                 default_blob: self.default_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new("abc").into(),
                 ),
                 default_byte: self.default_byte.unwrap_or(1i8),
                 default_short: self.default_short.unwrap_or(1i16),
                 default_integer: self.default_integer.unwrap_or(10i32),
                 default_long: self.default_long.unwrap_or(100i64),
                 default_float: self.default_float.unwrap_or(1.0f32),
                 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_map: self.default_map.unwrap_or_default(),
                 default_enum: self
                     .default_enum
                     .map(|v| match v {
                         crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                         crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                     })
                     .map(|res| res.map_err(ConstraintViolation::DefaultEnum))
                     .transpose()?
                     .unwrap_or(
                         "FOO"

↧ Expand context

                             .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),
             })

@@ -2544,2526 +2647,2623 @@

↥ Expand context

         pub fn zero_integer(mut self, input: i32) -> Self {
             self.zero_integer = Some(input);
             self
-2529
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_long(mut self, input: i64) -> Self {
             self.zero_long = Some(input);
             self
-2534
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_float(mut self, input: f32) -> Self {
             self.zero_float = Some(input);
             self
-2539
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_double(mut self, input: f64) -> Self {
             self.zero_double = Some(input);
             self
-2544
+        }
         /// Consumes the builder and constructs a [`Defaults`](crate::model::Defaults).

         pub fn build(self) -> crate::model::Defaults {
             self.build_enforcing_required_and_enum_traits()
-2548
+        }
         fn build_enforcing_required_and_enum_traits(self) -> crate::model::Defaults {
             crate::model::Defaults {
                 default_string: self.default_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from("hi"),
                 ),
                 default_boolean: self.default_boolean.unwrap_or(true),
                 default_list: self.default_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 default_list: self.default_list.unwrap_or_default(),
                 default_document_map: self.default_document_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || {
                         ::aws_smithy_types::Document::Object(::std::collections::HashMap::new())
                             .into()
                     },
                 ),
                 default_document_string: self.default_document_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || {
                         ::aws_smithy_types::Document::String(::std::string::String::from("hi"))
                             .into()
                     },
                 ),
                 default_document_boolean: self
                     .default_document_boolean
                     .unwrap_or(::aws_smithy_types::Document::Bool(true).into()),
                 default_document_list: self.default_document_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Array(::std::vec::Vec::new()).into(),
                 ),
                 default_null_document: self.default_null_document,
                 default_timestamp: self.default_timestamp.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64).into(),
                 ),
                 default_blob: self.default_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new("abc").into(),
                 ),
                 default_byte: self.default_byte.unwrap_or(1i8),
                 default_short: self.default_short.unwrap_or(1i16),
                 default_integer: self.default_integer.unwrap_or(10i32),
                 default_long: self.default_long.unwrap_or(100i64),
                 default_float: self.default_float.unwrap_or(1.0f32),
                 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_map: self.default_map.unwrap_or_default(),
                 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(""),
                 ),

↧ Expand context

                 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),
-2615
+            }
-2616
+        }
-2617
+    }
-2618
+}
 pub(crate) mod my_union_internal {
-2620
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {

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

@@ -1156,1156 +1223,1217 @@

↥ Expand context

-1156
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_list(mut self, input: ::std::vec::Vec<crate::model::Dialog>) -> Self {
             self.dialog_list = Some(input);
             self
-1161
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn dialog_map(
             mut self,
             input: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
         ) -> Self {
             self.dialog_map = Some(input);
             self
-1169
+        }
         /// Consumes the builder and constructs a [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
         ///
         /// The builder fails to construct a [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput) if you do not provide a value for all non-`Option`al members.
         ///
         pub fn build(
             self,

         ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
-1177
+        {
             self.build_enforcing_required_and_enum_traits()
-1179
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
-1183
+        {
             Ok(crate::output::OperationWithNestedStructureOutput {
                 dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
                 dialog_list: self.dialog_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 dialog_map: self.dialog_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::collections::HashMap::new(),
                 ),
                 dialog_list: self.dialog_list.unwrap_or_default(),
                 dialog_map: self.dialog_map.unwrap_or_default(),
             })
-1189
+        }
-1190
+    }
-1191
+}
 /// See [`OperationWithRequiredMembersOutput`](crate::output::OperationWithRequiredMembersOutput).
 pub mod operation_with_required_members_output {
-1194
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
-1197

↧ Expand context

     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `required_string` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredString,
         /// `required_boolean` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredBoolean,
         /// `required_list` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredList,
         /// `required_timestamp` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredTimestamp,
         /// `required_blob` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredBlob,
         /// `required_byte` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredByte,
         /// `required_short` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredShort,
         /// `required_integer` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredInteger,
         /// `required_long` was not provided but it is required when building `OperationWithRequiredMembersOutput`.
         MissingRequiredLong,

@@ -1596,1590 +1699,1687 @@

↥ Expand context

             self
-1591
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_long(mut self, input: i64) -> Self {
             self.zero_long = Some(input);
             self
-1596
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_float(mut self, input: f32) -> Self {
             self.zero_float = Some(input);
             self
-1601
+        }
         #[allow(missing_docs)] // documentation missing in model
         pub fn zero_double(mut self, input: f64) -> Self {
             self.zero_double = Some(input);
             self
-1606
+        }
         /// Consumes the builder and constructs a [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).
         pub fn build(self) -> crate::output::OperationWithDefaultsOutput {
             self.build_enforcing_required_and_enum_traits()

-1610
+        }
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::output::OperationWithDefaultsOutput {
             crate::output::OperationWithDefaultsOutput {
                 default_string: self.default_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || String::from("hi"),
                 ),
                 default_boolean: self.default_boolean.unwrap_or(true),
                 default_list: self.default_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::std::vec::Vec::new(),
                 ),
                 default_list: self.default_list.unwrap_or_default(),
                 default_document_map: self.default_document_map.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || {
                         ::aws_smithy_types::Document::Object(::std::collections::HashMap::new())
                             .into()
                     },
                 ),
                 default_document_string: self.default_document_string.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || {
                         ::aws_smithy_types::Document::String(::std::string::String::from("hi"))
                             .into()
                     },
                 ),
                 default_document_boolean: self
                     .default_document_boolean
                     .unwrap_or(::aws_smithy_types::Document::Bool(true).into()),
                 default_document_list: self.default_document_list.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Document::Array(::std::vec::Vec::new()).into(),
                 ),
                 default_null_document: self.default_null_document,
                 default_timestamp: self.default_timestamp.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64).into(),
                 ),
                 default_blob: self.default_blob.unwrap_or_else(
                     #[allow(clippy::redundant_closure)]
                     || ::aws_smithy_types::Blob::new("abc").into(),
                 ),
                 default_byte: self.default_byte.unwrap_or(1i8),
                 default_short: self.default_short.unwrap_or(1i16),
                 default_integer: self.default_integer.unwrap_or(10i32),
                 default_long: self.default_long.unwrap_or(100i64),
                 default_float: self.default_float.unwrap_or(1.0f32),
                 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_map: self.default_map.unwrap_or_default(),
                 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(""),
                 ),

↧ Expand context

                 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),
-1679
+            }
-1680
+        }
-1681
+    }
-1682
+}
 /// See [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
 pub mod content_type_parameters_output {
-1685
     impl ::std::convert::From<Builder> for crate::output::ContentTypeParametersOutput {
         fn from(builder: Builder) -> Self {

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

@@ -1,0 +300,0 @@

 import json_rpc11.input
 import json_rpc11.middleware
 import json_rpc11.output
 import json_rpc11.tls
 import typing
--
 Ctx = typing.TypeVar('Ctx')
--
 class App(typing.Generic[Ctx]):
     """
     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_rpc11 import input
     from json_rpc11 import output
     from json_rpc11 import error
     from json_rpc11 import middleware
     from json_rpc11 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
--
     @app.datetime_offsets
     def datetime_offsets(input: input::DatetimeOffsetsInput, ctx: Context) -> output::DatetimeOffsetsOutput:
         raise NotImplementedError
--
     @app.empty_operation
     def empty_operation(input: input::EmptyOperationInput, ctx: Context) -> output::EmptyOperationOutput:
         raise NotImplementedError
--
     @app.endpoint_operation
     def endpoint_operation(input: input::EndpointOperationInput, ctx: Context) -> output::EndpointOperationOutput:
         raise NotImplementedError
--
     @app.endpoint_with_host_label_operation
     def endpoint_with_host_label_operation(input: input::EndpointWithHostLabelOperationInput, ctx: Context) -> output::EndpointWithHostLabelOperationOutput:
         raise NotImplementedError
--
     @app.fractional_seconds
     def fractional_seconds(input: input::FractionalSecondsInput, ctx: Context) -> output::FractionalSecondsOutput:
         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:
         raise NotImplementedError
--
     # This example serializes enums as top level properties, in lists, sets, and maps.
     @app.json_enums
     def json_enums(input: input::JsonEnumsInput, ctx: Context) -> output::JsonEnumsOutput:
         raise NotImplementedError
--
     # This operation uses unions for inputs and outputs.
     @app.json_unions
     def json_unions(input: input::JsonUnionsInput, ctx: Context) -> output::JsonUnionsOutput:
         raise NotImplementedError
--
     @app.kitchen_sink_operation
     def kitchen_sink_operation(input: input::KitchenSinkOperationInput, ctx: Context) -> output::KitchenSinkOperationOutput:
         raise NotImplementedError
--
     @app.null_operation
     def null_operation(input: input::NullOperationInput, ctx: Context) -> output::NullOperationOutput:
         raise NotImplementedError
--
     @app.operation_with_optional_input_output
     def operation_with_optional_input_output(input: input::OperationWithOptionalInputOutputInput, ctx: Context) -> output::OperationWithOptionalInputOutputOutput:
         raise NotImplementedError
--
     # This example serializes an inline document as part of the payload.
     @app.put_and_get_inline_documents
     def put_and_get_inline_documents(input: input::PutAndGetInlineDocumentsInput, ctx: Context) -> output::PutAndGetInlineDocumentsOutput:
         raise NotImplementedError
--
     @app.put_with_content_encoding
     def put_with_content_encoding(input: input::PutWithContentEncodingInput, ctx: Context) -> output::PutWithContentEncodingOutput:
         raise NotImplementedError
--
     @app.simple_scalar_properties
     def simple_scalar_properties(input: input::SimpleScalarPropertiesInput, ctx: Context) -> output::SimpleScalarPropertiesOutput:
         raise NotImplementedError
--
     @app.sparse_nulls_operation
     def sparse_nulls_operation(input: input::SparseNullsOperationInput, ctx: Context) -> output::SparseNullsOperationOutput:
         raise NotImplementedError
--
     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.
     """
--
     def content_type_parameters(self, func: typing.Union[typing.Callable[[json_rpc11.input.ContentTypeParametersInput, Ctx], typing.Union[json_rpc11.output.ContentTypeParametersOutput, typing.Awaitable[json_rpc11.output.ContentTypeParametersOutput]]], typing.Callable[[json_rpc11.input.ContentTypeParametersInput], typing.Union[json_rpc11.output.ContentTypeParametersOutput, typing.Awaitable[json_rpc11.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.
         """
         ...
--
--
     def datetime_offsets(self, func: typing.Union[typing.Callable[[json_rpc11.input.DatetimeOffsetsInput, Ctx], typing.Union[json_rpc11.output.DatetimeOffsetsOutput, typing.Awaitable[json_rpc11.output.DatetimeOffsetsOutput]]], typing.Callable[[json_rpc11.input.DatetimeOffsetsInput], typing.Union[json_rpc11.output.DatetimeOffsetsOutput, typing.Awaitable[json_rpc11.output.DatetimeOffsetsOutput]]]]) -> None:
         """
         Method to register `datetime_offsets` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def empty_operation(self, func: typing.Union[typing.Callable[[json_rpc11.input.EmptyOperationInput, Ctx], typing.Union[json_rpc11.output.EmptyOperationOutput, typing.Awaitable[json_rpc11.output.EmptyOperationOutput]]], typing.Callable[[json_rpc11.input.EmptyOperationInput], typing.Union[json_rpc11.output.EmptyOperationOutput, typing.Awaitable[json_rpc11.output.EmptyOperationOutput]]]]) -> None:
         """
         Method to register `empty_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def endpoint_operation(self, func: typing.Union[typing.Callable[[json_rpc11.input.EndpointOperationInput, Ctx], typing.Union[json_rpc11.output.EndpointOperationOutput, typing.Awaitable[json_rpc11.output.EndpointOperationOutput]]], typing.Callable[[json_rpc11.input.EndpointOperationInput], typing.Union[json_rpc11.output.EndpointOperationOutput, typing.Awaitable[json_rpc11.output.EndpointOperationOutput]]]]) -> None:
         """
         Method to register `endpoint_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def endpoint_with_host_label_operation(self, func: typing.Union[typing.Callable[[json_rpc11.input.EndpointWithHostLabelOperationInput, Ctx], typing.Union[json_rpc11.output.EndpointWithHostLabelOperationOutput, typing.Awaitable[json_rpc11.output.EndpointWithHostLabelOperationOutput]]], typing.Callable[[json_rpc11.input.EndpointWithHostLabelOperationInput], typing.Union[json_rpc11.output.EndpointWithHostLabelOperationOutput, typing.Awaitable[json_rpc11.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.
         """
         ...
--
--
     def fractional_seconds(self, func: typing.Union[typing.Callable[[json_rpc11.input.FractionalSecondsInput, Ctx], typing.Union[json_rpc11.output.FractionalSecondsOutput, typing.Awaitable[json_rpc11.output.FractionalSecondsOutput]]], typing.Callable[[json_rpc11.input.FractionalSecondsInput], typing.Union[json_rpc11.output.FractionalSecondsOutput, typing.Awaitable[json_rpc11.output.FractionalSecondsOutput]]]]) -> None:
         """
         Method to register `fractional_seconds` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def greeting_with_errors(self, func: typing.Union[typing.Callable[[json_rpc11.input.GreetingWithErrorsInput, Ctx], typing.Union[json_rpc11.output.GreetingWithErrorsOutput, typing.Awaitable[json_rpc11.output.GreetingWithErrorsOutput]]], typing.Callable[[json_rpc11.input.GreetingWithErrorsInput], typing.Union[json_rpc11.output.GreetingWithErrorsOutput, typing.Awaitable[json_rpc11.output.GreetingWithErrorsOutput]]]]) -> None:
         """
         Method to register `greeting_with_errors` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def host_with_path_operation(self, func: typing.Union[typing.Callable[[json_rpc11.input.HostWithPathOperationInput, Ctx], typing.Union[json_rpc11.output.HostWithPathOperationOutput, typing.Awaitable[json_rpc11.output.HostWithPathOperationOutput]]], typing.Callable[[json_rpc11.input.HostWithPathOperationInput], typing.Union[json_rpc11.output.HostWithPathOperationOutput, typing.Awaitable[json_rpc11.output.HostWithPathOperationOutput]]]]) -> None:
         """
         Method to register `host_with_path_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def json_enums(self, func: typing.Union[typing.Callable[[json_rpc11.input.JsonEnumsInput, Ctx], typing.Union[json_rpc11.output.JsonEnumsOutput, typing.Awaitable[json_rpc11.output.JsonEnumsOutput]]], typing.Callable[[json_rpc11.input.JsonEnumsInput], typing.Union[json_rpc11.output.JsonEnumsOutput, typing.Awaitable[json_rpc11.output.JsonEnumsOutput]]]]) -> None:
         """
         Method to register `json_enums` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def json_unions(self, func: typing.Union[typing.Callable[[json_rpc11.input.JsonUnionsInput, Ctx], typing.Union[json_rpc11.output.JsonUnionsOutput, typing.Awaitable[json_rpc11.output.JsonUnionsOutput]]], typing.Callable[[json_rpc11.input.JsonUnionsInput], typing.Union[json_rpc11.output.JsonUnionsOutput, typing.Awaitable[json_rpc11.output.JsonUnionsOutput]]]]) -> None:
         """
         Method to register `json_unions` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def kitchen_sink_operation(self, func: typing.Union[typing.Callable[[json_rpc11.input.KitchenSinkOperationInput, Ctx], typing.Union[json_rpc11.output.KitchenSinkOperationOutput, typing.Awaitable[json_rpc11.output.KitchenSinkOperationOutput]]], typing.Callable[[json_rpc11.input.KitchenSinkOperationInput], typing.Union[json_rpc11.output.KitchenSinkOperationOutput, typing.Awaitable[json_rpc11.output.KitchenSinkOperationOutput]]]]) -> None:
         """
         Method to register `kitchen_sink_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def middleware(self, func: typing.Callable[[json_rpc11.middleware.Request, typing.Callable[[json_rpc11.middleware.Request], typing.Awaitable[json_rpc11.middleware.Response]]], typing.Awaitable[json_rpc11.middleware.Response]]) -> None:
         """
         Register a Python function to be executed inside a Tower middleware layer.
         """
         ...
--
--
     def null_operation(self, func: typing.Union[typing.Callable[[json_rpc11.input.NullOperationInput, Ctx], typing.Union[json_rpc11.output.NullOperationOutput, typing.Awaitable[json_rpc11.output.NullOperationOutput]]], typing.Callable[[json_rpc11.input.NullOperationInput], typing.Union[json_rpc11.output.NullOperationOutput, typing.Awaitable[json_rpc11.output.NullOperationOutput]]]]) -> None:
         """
         Method to register `null_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def operation_with_optional_input_output(self, func: typing.Union[typing.Callable[[json_rpc11.input.OperationWithOptionalInputOutputInput, Ctx], typing.Union[json_rpc11.output.OperationWithOptionalInputOutputOutput, typing.Awaitable[json_rpc11.output.OperationWithOptionalInputOutputOutput]]], typing.Callable[[json_rpc11.input.OperationWithOptionalInputOutputInput], typing.Union[json_rpc11.output.OperationWithOptionalInputOutputOutput, typing.Awaitable[json_rpc11.output.OperationWithOptionalInputOutputOutput]]]]) -> None:
         """
         Method to register `operation_with_optional_input_output` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def put_and_get_inline_documents(self, func: typing.Union[typing.Callable[[json_rpc11.input.PutAndGetInlineDocumentsInput, Ctx], typing.Union[json_rpc11.output.PutAndGetInlineDocumentsOutput, typing.Awaitable[json_rpc11.output.PutAndGetInlineDocumentsOutput]]], typing.Callable[[json_rpc11.input.PutAndGetInlineDocumentsInput], typing.Union[json_rpc11.output.PutAndGetInlineDocumentsOutput, typing.Awaitable[json_rpc11.output.PutAndGetInlineDocumentsOutput]]]]) -> None:
         """
         Method to register `put_and_get_inline_documents` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def put_with_content_encoding(self, func: typing.Union[typing.Callable[[json_rpc11.input.PutWithContentEncodingInput, Ctx], typing.Union[json_rpc11.output.PutWithContentEncodingOutput, typing.Awaitable[json_rpc11.output.PutWithContentEncodingOutput]]], typing.Callable[[json_rpc11.input.PutWithContentEncodingInput], typing.Union[json_rpc11.output.PutWithContentEncodingOutput, typing.Awaitable[json_rpc11.output.PutWithContentEncodingOutput]]]]) -> None:
         """
         Method to register `put_with_content_encoding` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def run(self, address: typing.Optional[str] = ..., port: typing.Optional[int] = ..., backlog: typing.Optional[int] = ..., workers: typing.Optional[int] = ..., tls: typing.Optional[json_rpc11.tls.TlsConfig] = ...) -> None:
         """
         Main entrypoint: start the server on multiple workers.
         """
         ...
--
--
     def run_lambda(self) -> None:
         """
         Lambda entrypoint: start the server on Lambda.
         """
         ...
--
--
     def simple_scalar_properties(self, func: typing.Union[typing.Callable[[json_rpc11.input.SimpleScalarPropertiesInput, Ctx], typing.Union[json_rpc11.output.SimpleScalarPropertiesOutput, typing.Awaitable[json_rpc11.output.SimpleScalarPropertiesOutput]]], typing.Callable[[json_rpc11.input.SimpleScalarPropertiesInput], typing.Union[json_rpc11.output.SimpleScalarPropertiesOutput, typing.Awaitable[json_rpc11.output.SimpleScalarPropertiesOutput]]]]) -> None:
         """
         Method to register `simple_scalar_properties` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def sparse_nulls_operation(self, func: typing.Union[typing.Callable[[json_rpc11.input.SparseNullsOperationInput, Ctx], typing.Union[json_rpc11.output.SparseNullsOperationOutput, typing.Awaitable[json_rpc11.output.SparseNullsOperationOutput]]], typing.Callable[[json_rpc11.input.SparseNullsOperationInput], typing.Union[json_rpc11.output.SparseNullsOperationOutput, typing.Awaitable[json_rpc11.output.SparseNullsOperationOutput]]]]) -> None:
         """
         Method to register `sparse_nulls_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def start_worker(self) -> None:
         """
         Build the service and start a single worker.
         """
         ...
--
--
     def __init__(self) -> None:
         ...
--
--
 CODEGEN_VERSION: str = ...

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

@@ -1,0 +143,0 @@

 import typing
--
 class ClientApplication:
     """
     AWS Mobile SDK client fields.
     """
--
     app_package_name: str
     """
     The package name for the mobile application invoking the function
     """
--
     app_title: str
     """
     The app title for the mobile app as registered with AWS' mobile services.
     """
--
     app_version_code: str
     """
     The app version code.
     """
--
     app_version_name: str
     """
     The version name of the application as registered with AWS' mobile services.
     """
--
     installation_id: str
     """
     The mobile app installation id
     """
--
 class ClientContext:
     """
     Client context sent by the AWS Mobile SDK.
     """
--
     client: ClientApplication
     """
     Information about the mobile application invoking the function.
     """
--
     custom: typing.Dict[str, str]
     """
     Custom properties attached to the mobile event context.
     """
--
     environment: typing.Dict[str, str]
     """
     Environment settings from the mobile client.
     """
--
 class CognitoIdentity:
     """
     Cognito identity information sent with the event
     """
--
     identity_id: str
     """
     The unique identity id for the Cognito credentials invoking the function.
     """
--
     identity_pool_id: str
     """
     The identity pool id the caller is "registered" with.
     """
--
 class Config:
     """
     Configuration derived from environment variables.
     """
--
     function_name: str
     """
     The name of the function.
     """
--
     log_group: str
     """
     The name of the Amazon CloudWatch Logs group for the function.
     """
--
     log_stream: str
     """
     The name of the Amazon CloudWatch Logs stream for the function.
     """
--
     memory: int
     """
     The amount of memory available to the function in MB.
     """
--
     version: str
     """
     The version of the function being executed.
     """
--
 class LambdaContext:
     """
     The Lambda function execution context. The values in this struct
     are populated using the [Lambda environment variables](https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html)
     and the headers returned by the poll request to the Runtime APIs.
     """
--
     client_context: typing.Optional[ClientContext]
     """
     The client context object sent by the AWS mobile SDK. This field is
     empty unless the function is invoked using an AWS mobile SDK.
     """
--
     deadline: int
     """
     The execution deadline for the current invocation in milliseconds.
     """
--
     env_config: Config
     """
     Lambda function configuration from the local environment variables.
     Includes information such as the function name, memory allocation,
     version, and log streams.
     """
--
     identity: typing.Optional[CognitoIdentity]
     """
     The Cognito identity that invoked the function. This field is empty
     unless the invocation request to the Lambda APIs was made using AWS
     credentials issues by Amazon Cognito Identity Pools.
     """
--
     invoked_function_arn: str
     """
     The ARN of the Lambda function being invoked.
     """
--
     request_id: str
     """
     The AWS request ID generated by the Lambda service.
     """
--
     xray_trace_id: typing.Optional[str]
     """
     The X-Ray trace ID for the current invocation.
     """

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

@@ -1,0 +88,0 @@

 import json_rpc11.model
 import typing
--
 class ComplexError(Exception):
     """
     This error is thrown when a request is invalid.
     """
--
     nested: typing.Optional[json_rpc11.model.ComplexNestedErrorData]
--
     top_level: typing.Optional[str]
--
     def __init__(self, top_level: typing.Optional[str] = ..., nested: typing.Optional[json_rpc11.model.ComplexNestedErrorData] = ...) -> None:
         ...
--
--
 class ErrorWithMembers(Exception):
     code: typing.Optional[str]
--
     complex_data: typing.Optional[json_rpc11.model.KitchenSink]
--
     integer_field: typing.Optional[int]
--
     list_field: typing.Optional[typing.List[str]]
--
     map_field: typing.Optional[typing.Dict[str, str]]
--
     message: typing.Optional[str]
--
     string_field: typing.Optional[str]
     """
     abc
     """
--
     def __init__(self, code: typing.Optional[str] = ..., complex_data: typing.Optional[json_rpc11.model.KitchenSink] = ..., integer_field: typing.Optional[int] = ..., list_field: typing.Optional[typing.List[str]] = ..., map_field: typing.Optional[typing.Dict[str, str]] = ..., message: typing.Optional[str] = ..., string_field: typing.Optional[str] = ...) -> None:
         ...
--
--
 class ErrorWithoutMembers(Exception):
     def __init__(self) -> None:
         ...
--
--
 class FooError(Exception):
     """
     This error has test cases that test some of the dark corners of Amazon service framework history. It should only be implemented by clients.
     """
--
     def __init__(self) -> None:
         ...
--
--
 class InternalServerError(Exception):
     message: str
--
     def __init__(self, message: str) -> None:
         ...
--
--
 class InvalidGreeting(Exception):
     """
     This error is thrown when an invalid greeting value is provided.
     """
--
     message: typing.Optional[str]
--
     def __init__(self, message: typing.Optional[str] = ...) -> None:
         ...
--
--
 class ValidationException(Exception):
     """
     A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     """
--
     field_list: typing.Optional[typing.List[json_rpc11.model.ValidationExceptionField]]
     """
     A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     """
--
     message: str
     """
     A summary of the validation failure.
     """
--
     def __init__(self, message: str, field_list: typing.Optional[typing.List[json_rpc11.model.ValidationExceptionField]] = ...) -> None:
         ...
--

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17