Server Test Python

rev. c67de0508e9d33923e47fd7281531eeca95f7996

Files changed:

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

@@ -1,0 +26,0 @@

 import pathlib
 import typing
--
 class TracingHandler:
     """
     Modifies the Python `logging` module to deliver its log messages using [tracing::Subscriber] events.
--
     To achieve this goal, the following changes are made to the module:
     - A new builtin function `logging.py_tracing_event` transcodes `logging.LogRecord`s to `tracing::Event`s. This function
       is not exported in `logging.__all__`, as it is not intended to be called directly.
     - A new class `logging.TracingHandler` provides a `logging.Handler` that delivers all records to `python_tracing`.
     """
--
     def handler(self) -> typing.Any:
         ...
--
--
     def __init__(self, level: typing.Optional[int] = ..., logfile: typing.Optional[pathlib.Path] = ..., format: typing.Optional[typing.Literal['compact', 'pretty', 'json']] = ...) -> None:
         ...
--
--
 def py_tracing_event() -> None:
     """
     Consumes a Python `logging.LogRecord` and emits a Rust [tracing::Event] instead.
     """
     ...

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

@@ -1,0 +78,0 @@

 import typing
--
 class MiddlewareException(Exception):
     """
     Exception that can be thrown from a Python middleware.
--
     It allows to specify a message and HTTP status code and implementing protocol specific capabilities
     to build a [aws_smithy_http_server::response::Response] from it.
     """
--
     message: str
--
     status_code: int
--
     def __init__(self, message: str, status_code: typing.Optional[int] = ...) -> None:
         ...
--
--
 class Request:
     """
     Python-compatible [Request] object.
     """
--
     body: typing.Awaitable[bytes]
     """
     Return the HTTP body of this request.
     Note that this is a costly operation because the whole request body is cloned.
     """
--
     headers: typing.MutableMapping[str, str]
     """
     Return the HTTP headers of this request.
     """
--
     method: str
     """
     Return the HTTP method of this request.
     """
--
     uri: str
     """
     Return the URI of this request.
     """
--
     version: str
     """
     Return the HTTP version of this request.
     """
--
 class Response:
     """
     Python-compatible [Response] object.
     """
--
     body: typing.Awaitable[bytes]
     """
     Return the HTTP body of this response.
     Note that this is a costly operation because the whole response body is cloned.
     """
--
     headers: typing.MutableMapping[str, str]
     """
     Return the HTTP headers of this response.
     """
--
     status: int
     """
     Return the HTTP status of this response.
     """
--
     version: str
     """
     Return the HTTP version of this response.
     """
--
     def __init__(self, status: int, headers: typing.Optional[typing.Dict[str, str]] = ..., body: typing.Optional[bytes] = ...) -> None:
         ...
--

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

@@ -1,0 +326,0 @@

 import json_rpc11.model
 import json_rpc11.types
 import typing
--
 class ComplexNestedErrorData:
     foo: typing.Optional[str]
--
     def __init__(self, foo: typing.Optional[str] = ...) -> None:
         ...
--
--
 class EmptyStruct:
     def __init__(self) -> None:
         ...
--
--
 class FooEnum:
     Bar: FooEnum
--
     Baz: FooEnum
--
     Foo: FooEnum
--
     One: FooEnum
--
     Zero: FooEnum
--
     name: typing.Any
--
     value: typing.Any
--
 class GreetingStruct:
     hi: typing.Optional[str]
--
     def __init__(self, hi: typing.Optional[str] = ...) -> None:
         ...
--
--
 class KitchenSink:
     blob: typing.Optional[json_rpc11.types.Blob]
--
     boolean: typing.Optional[bool]
--
     double: typing.Optional[float]
--
     empty_struct: typing.Optional[json_rpc11.model.EmptyStruct]
--
     float: typing.Optional[float]
--
     httpdate_timestamp: typing.Optional[json_rpc11.types.DateTime]
--
     integer: typing.Optional[int]
--
     iso8601_timestamp: typing.Optional[json_rpc11.types.DateTime]
--
     json_value: typing.Optional[str]
--
     list_of_lists: typing.Optional[typing.List[typing.List[str]]]
--
     list_of_maps_of_strings: typing.Optional[typing.List[typing.Dict[str, str]]]
--
     list_of_strings: typing.Optional[typing.List[str]]
--
     list_of_structs: typing.Optional[typing.List[json_rpc11.model.SimpleStruct]]
--
     long: typing.Optional[int]
--
     map_of_lists_of_strings: typing.Optional[typing.Dict[str, typing.List[str]]]
--
     map_of_maps: typing.Optional[typing.Dict[str, typing.Dict[str, str]]]
--
     map_of_strings: typing.Optional[typing.Dict[str, str]]
--
     map_of_structs: typing.Optional[typing.Dict[str, json_rpc11.model.SimpleStruct]]
--
     recursive_list: typing.Optional[typing.List[json_rpc11.model.KitchenSink]]
--
     recursive_map: typing.Optional[typing.Dict[str, json_rpc11.model.KitchenSink]]
--
     recursive_struct: typing.Optional[json_rpc11.model.KitchenSink]
--
     simple_struct: typing.Optional[json_rpc11.model.SimpleStruct]
--
     string: typing.Optional[str]
--
     struct_with_json_name: typing.Optional[json_rpc11.model.StructWithJsonName]
--
     timestamp: typing.Optional[json_rpc11.types.DateTime]
--
     unix_timestamp: typing.Optional[json_rpc11.types.DateTime]
--
     def __init__(self, blob: typing.Optional[json_rpc11.types.Blob] = ..., boolean: typing.Optional[bool] = ..., double: typing.Optional[float] = ..., empty_struct: typing.Optional[json_rpc11.model.EmptyStruct] = ..., float: typing.Optional[float] = ..., httpdate_timestamp: typing.Optional[json_rpc11.types.DateTime] = ..., integer: typing.Optional[int] = ..., iso8601_timestamp: typing.Optional[json_rpc11.types.DateTime] = ..., json_value: typing.Optional[str] = ..., list_of_lists: typing.Optional[typing.List[typing.List[str]]] = ..., list_of_maps_of_strings: typing.Optional[typing.List[typing.Dict[str, str]]] = ..., list_of_strings: typing.Optional[typing.List[str]] = ..., list_of_structs: typing.Optional[typing.List[json_rpc11.model.SimpleStruct]] = ..., long: typing.Optional[int] = ..., map_of_lists_of_strings: typing.Optional[typing.Dict[str, typing.List[str]]] = ..., map_of_maps: typing.Optional[typing.Dict[str, typing.Dict[str, str]]] = ..., map_of_strings: typing.Optional[typing.Dict[str, str]] = ..., map_of_structs: typing.Optional[typing.Dict[str, json_rpc11.model.SimpleStruct]] = ..., recursive_list: typing.Optional[typing.List[json_rpc11.model.KitchenSink]] = ..., recursive_map: typing.Optional[typing.Dict[str, json_rpc11.model.KitchenSink]] = ..., recursive_struct: typing.Optional[json_rpc11.model.KitchenSink] = ..., simple_struct: typing.Optional[json_rpc11.model.SimpleStruct] = ..., string: typing.Optional[str] = ..., struct_with_json_name: typing.Optional[json_rpc11.model.StructWithJsonName] = ..., timestamp: typing.Optional[json_rpc11.types.DateTime] = ..., unix_timestamp: typing.Optional[json_rpc11.types.DateTime] = ...) -> None:
         ...
--
--
 class MyUnion:
     def as_blob_value(self) -> json_rpc11.types.Blob:
         """
         Tries to convert the enum instance into [`BlobValue`](crate::model::MyUnion::BlobValue), extracting the inner [`Blob`](::aws_smithy_http_server_python::types::Blob).
         """
         ...
--
--
     def as_boolean_value(self) -> bool:
         """
         Tries to convert the enum instance into [`BooleanValue`](crate::model::MyUnion::BooleanValue), extracting the inner [`bool`](bool).
         """
         ...
--
--
     def as_enum_value(self) -> json_rpc11.model.FooEnum:
         """
         Tries to convert the enum instance into [`EnumValue`](crate::model::MyUnion::EnumValue), extracting the inner [`FooEnum`](crate::model::FooEnum).
         """
         ...
--
--
     def as_list_value(self) -> typing.List[str]:
         """
         Tries to convert the enum instance into [`ListValue`](crate::model::MyUnion::ListValue), extracting the inner [`Vec`](::std::vec::Vec).
         """
         ...
--
--
     def as_map_value(self) -> typing.Dict[str, str]:
         """
         Tries to convert the enum instance into [`MapValue`](crate::model::MyUnion::MapValue), extracting the inner [`HashMap`](::std::collections::HashMap).
         """
         ...
--
--
     def as_number_value(self) -> int:
         """
         Tries to convert the enum instance into [`NumberValue`](crate::model::MyUnion::NumberValue), extracting the inner [`i32`](i32).
         """
         ...
--
--
     def as_string_value(self) -> str:
         """
         Tries to convert the enum instance into [`StringValue`](crate::model::MyUnion::StringValue), extracting the inner [`String`](::std::string::String).
         """
         ...
--
--
     def as_structure_value(self) -> json_rpc11.model.GreetingStruct:
         """
         Tries to convert the enum instance into [`StructureValue`](crate::model::MyUnion::StructureValue), extracting the inner [`GreetingStruct`](crate::model::GreetingStruct).
         """
         ...
--
--
     def as_timestamp_value(self) -> json_rpc11.types.DateTime:
         """
         Tries to convert the enum instance into [`TimestampValue`](crate::model::MyUnion::TimestampValue), extracting the inner [`DateTime`](::aws_smithy_http_server_python::types::DateTime).
         """
         ...
--
--
     @staticmethod
     def blob_value(data: json_rpc11.types.Blob) -> MyUnion:
         """
         Creates a new union instance of [`BlobValue`](crate::model::MyUnion::BlobValue)
         """
         ...
--
--
     @staticmethod
     def boolean_value(data: bool) -> MyUnion:
         """
         Creates a new union instance of [`BooleanValue`](crate::model::MyUnion::BooleanValue)
         """
         ...
--
--
     @staticmethod
     def enum_value(data: json_rpc11.model.FooEnum) -> MyUnion:
         """
         Creates a new union instance of [`EnumValue`](crate::model::MyUnion::EnumValue)
         """
         ...
--
--
     def is_blob_value(self) -> bool:
         """
         Returns true if this is a [`BlobValue`](crate::model::MyUnion::BlobValue).
         """
         ...
--
--
     def is_boolean_value(self) -> bool:
         """
         Returns true if this is a [`BooleanValue`](crate::model::MyUnion::BooleanValue).
         """
         ...
--
--
     def is_enum_value(self) -> bool:
         """
         Returns true if this is a [`EnumValue`](crate::model::MyUnion::EnumValue).
         """
         ...
--
--
     def is_list_value(self) -> bool:
         """
         Returns true if this is a [`ListValue`](crate::model::MyUnion::ListValue).
         """
         ...
--
--
     def is_map_value(self) -> bool:
         """
         Returns true if this is a [`MapValue`](crate::model::MyUnion::MapValue).
         """
         ...
--
--
     def is_number_value(self) -> bool:
         """
         Returns true if this is a [`NumberValue`](crate::model::MyUnion::NumberValue).
         """
         ...
--
--
     def is_string_value(self) -> bool:
         """
         Returns true if this is a [`StringValue`](crate::model::MyUnion::StringValue).
         """
         ...
--
--
     def is_structure_value(self) -> bool:
         """
         Returns true if this is a [`StructureValue`](crate::model::MyUnion::StructureValue).
         """
         ...
--
--
     def is_timestamp_value(self) -> bool:
         """
         Returns true if this is a [`TimestampValue`](crate::model::MyUnion::TimestampValue).
         """
         ...
--
--
     @staticmethod
     def list_value(data: typing.List[str]) -> MyUnion:
         """
         Creates a new union instance of [`ListValue`](crate::model::MyUnion::ListValue)
         """
         ...
--
--
     @staticmethod
     def map_value(data: typing.Dict[str, str]) -> MyUnion:
         """
         Creates a new union instance of [`MapValue`](crate::model::MyUnion::MapValue)
         """
         ...
--
--
     @staticmethod
     def number_value(data: int) -> MyUnion:
         """
         Creates a new union instance of [`NumberValue`](crate::model::MyUnion::NumberValue)
         """
         ...
--
--
     @staticmethod
     def string_value(data: str) -> MyUnion:
         """
         Creates a new union instance of [`StringValue`](crate::model::MyUnion::StringValue)
         """
         ...
--
--
     @staticmethod
     def structure_value(data: json_rpc11.model.GreetingStruct) -> MyUnion:
         """
         Creates a new union instance of [`StructureValue`](crate::model::MyUnion::StructureValue)
         """
         ...
--
--
     @staticmethod
     def timestamp_value(data: json_rpc11.types.DateTime) -> MyUnion:
         """
         Creates a new union instance of [`TimestampValue`](crate::model::MyUnion::TimestampValue)
         """
         ...
--
--
 class SimpleStruct:
     value: typing.Optional[str]
--
     def __init__(self, value: typing.Optional[str] = ...) -> None:
         ...
--
--
 class StructWithJsonName:
     value: typing.Optional[str]
--
     def __init__(self, value: typing.Optional[str] = ...) -> None:
         ...
--
--
 class ValidationExceptionField:
     """
     Describes one specific validation failure for an input member.
     """
--
     message: str
     """
     A detailed description of the validation failure.
     """
--
     path: str
     """
     A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     """
--
     def __init__(self, path: str, message: str) -> None:
         ...
--

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

@@ -1,0 +198,0 @@

 import json_rpc11.model
 import json_rpc11.types
 import typing
--
 class ContentTypeParametersOutput:
     def __init__(self) -> None:
         ...
--
--
 class DatetimeOffsetsOutput:
     datetime: typing.Optional[json_rpc11.types.DateTime]
--
     def __init__(self, datetime: typing.Optional[json_rpc11.types.DateTime] = ...) -> None:
         ...
--
--
 class EmptyOperationOutput:
     def __init__(self) -> None:
         ...
--
--
 class EndpointOperationOutput:
     def __init__(self) -> None:
         ...
--
--
 class EndpointWithHostLabelOperationOutput:
     def __init__(self) -> None:
         ...
--
--
 class FractionalSecondsOutput:
     datetime: typing.Optional[json_rpc11.types.DateTime]
--
     def __init__(self, datetime: typing.Optional[json_rpc11.types.DateTime] = ...) -> None:
         ...
--
--
 class GreetingWithErrorsOutput:
     greeting: typing.Optional[str]
--
     def __init__(self, greeting: typing.Optional[str] = ...) -> None:
         ...
--
--
 class HostWithPathOperationOutput:
     def __init__(self) -> None:
         ...
--
--
 class JsonEnumsOutput:
     foo_enum1: typing.Optional[json_rpc11.model.FooEnum]
--
     foo_enum2: typing.Optional[json_rpc11.model.FooEnum]
--
     foo_enum3: typing.Optional[json_rpc11.model.FooEnum]
--
     foo_enum_list: typing.Optional[typing.List[json_rpc11.model.FooEnum]]
--
     foo_enum_map: typing.Optional[typing.Dict[str, json_rpc11.model.FooEnum]]
--
     foo_enum_set: typing.Optional[typing.List[json_rpc11.model.FooEnum]]
--
     def __init__(self, foo_enum1: typing.Optional[json_rpc11.model.FooEnum] = ..., foo_enum2: typing.Optional[json_rpc11.model.FooEnum] = ..., foo_enum3: typing.Optional[json_rpc11.model.FooEnum] = ..., foo_enum_list: typing.Optional[typing.List[json_rpc11.model.FooEnum]] = ..., foo_enum_set: typing.Optional[typing.List[json_rpc11.model.FooEnum]] = ..., foo_enum_map: typing.Optional[typing.Dict[str, json_rpc11.model.FooEnum]] = ...) -> None:
         ...
--
--
 class JsonIntEnumsOutput:
     int_enum1: typing.Optional[int]
--
     int_enum2: typing.Optional[int]
--
     int_enum3: typing.Optional[int]
--
     int_enum_list: typing.Optional[typing.List[int]]
--
     int_enum_map: typing.Optional[typing.Dict[str, int]]
--
     int_enum_set: typing.Optional[typing.List[int]]
--
     def __init__(self, int_enum1: typing.Optional[int] = ..., int_enum2: typing.Optional[int] = ..., int_enum3: typing.Optional[int] = ..., int_enum_list: typing.Optional[typing.List[int]] = ..., int_enum_set: typing.Optional[typing.List[int]] = ..., int_enum_map: typing.Optional[typing.Dict[str, int]] = ...) -> None:
         ...
--
--
 class JsonUnionsOutput:
     """
     A shared structure that contains a single union member.
     """
--
     contents: typing.Optional[json_rpc11.model.MyUnion]
     """
     A union with a representative set of types for members.
     """
--
     def __init__(self, contents: typing.Optional[json_rpc11.model.MyUnion] = ...) -> None:
         ...
--
--
 class KitchenSinkOperationOutput:
     blob: typing.Optional[json_rpc11.types.Blob]
--
     boolean: typing.Optional[bool]
--
     double: typing.Optional[float]
--
     empty_struct: typing.Optional[json_rpc11.model.EmptyStruct]
--
     float: typing.Optional[float]
--
     httpdate_timestamp: typing.Optional[json_rpc11.types.DateTime]
--
     integer: typing.Optional[int]
--
     iso8601_timestamp: typing.Optional[json_rpc11.types.DateTime]
--
     json_value: typing.Optional[str]
--
     list_of_lists: typing.Optional[typing.List[typing.List[str]]]
--
     list_of_maps_of_strings: typing.Optional[typing.List[typing.Dict[str, str]]]
--
     list_of_strings: typing.Optional[typing.List[str]]
--
     list_of_structs: typing.Optional[typing.List[json_rpc11.model.SimpleStruct]]
--
     long: typing.Optional[int]
--
     map_of_lists_of_strings: typing.Optional[typing.Dict[str, typing.List[str]]]
--
     map_of_maps: typing.Optional[typing.Dict[str, typing.Dict[str, str]]]
--
     map_of_strings: typing.Optional[typing.Dict[str, str]]
--
     map_of_structs: typing.Optional[typing.Dict[str, json_rpc11.model.SimpleStruct]]
--
     recursive_list: typing.Optional[typing.List[json_rpc11.model.KitchenSink]]
--
     recursive_map: typing.Optional[typing.Dict[str, json_rpc11.model.KitchenSink]]
--
     recursive_struct: typing.Optional[json_rpc11.model.KitchenSink]
--
     simple_struct: typing.Optional[json_rpc11.model.SimpleStruct]
--
     string: typing.Optional[str]
--
     struct_with_json_name: typing.Optional[json_rpc11.model.StructWithJsonName]
--
     timestamp: typing.Optional[json_rpc11.types.DateTime]
--
     unix_timestamp: typing.Optional[json_rpc11.types.DateTime]
--
     def __init__(self, blob: typing.Optional[json_rpc11.types.Blob] = ..., boolean: typing.Optional[bool] = ..., double: typing.Optional[float] = ..., empty_struct: typing.Optional[json_rpc11.model.EmptyStruct] = ..., float: typing.Optional[float] = ..., httpdate_timestamp: typing.Optional[json_rpc11.types.DateTime] = ..., integer: typing.Optional[int] = ..., iso8601_timestamp: typing.Optional[json_rpc11.types.DateTime] = ..., json_value: typing.Optional[str] = ..., list_of_lists: typing.Optional[typing.List[typing.List[str]]] = ..., list_of_maps_of_strings: typing.Optional[typing.List[typing.Dict[str, str]]] = ..., list_of_strings: typing.Optional[typing.List[str]] = ..., list_of_structs: typing.Optional[typing.List[json_rpc11.model.SimpleStruct]] = ..., long: typing.Optional[int] = ..., map_of_lists_of_strings: typing.Optional[typing.Dict[str, typing.List[str]]] = ..., map_of_maps: typing.Optional[typing.Dict[str, typing.Dict[str, str]]] = ..., map_of_strings: typing.Optional[typing.Dict[str, str]] = ..., map_of_structs: typing.Optional[typing.Dict[str, json_rpc11.model.SimpleStruct]] = ..., recursive_list: typing.Optional[typing.List[json_rpc11.model.KitchenSink]] = ..., recursive_map: typing.Optional[typing.Dict[str, json_rpc11.model.KitchenSink]] = ..., recursive_struct: typing.Optional[json_rpc11.model.KitchenSink] = ..., simple_struct: typing.Optional[json_rpc11.model.SimpleStruct] = ..., string: typing.Optional[str] = ..., struct_with_json_name: typing.Optional[json_rpc11.model.StructWithJsonName] = ..., timestamp: typing.Optional[json_rpc11.types.DateTime] = ..., unix_timestamp: typing.Optional[json_rpc11.types.DateTime] = ...) -> None:
         ...
--
--
 class NullOperationOutput:
     string: typing.Optional[str]
--
     def __init__(self, string: typing.Optional[str] = ...) -> None:
         ...
--
--
 class OperationWithOptionalInputOutputOutput:
     value: typing.Optional[str]
--
     def __init__(self, value: typing.Optional[str] = ...) -> None:
         ...
--
--
 class PutAndGetInlineDocumentsOutput:
     inline_document: typing.Optional[json_rpc11.types.Document]
--
     def __init__(self, inline_document: typing.Optional[json_rpc11.types.Document] = ...) -> 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:
         ...
--
--
 class SparseNullsOperationOutput:
     sparse_string_list: typing.Optional[typing.List[typing.Optional[str]]]
--
     sparse_string_map: typing.Optional[typing.Dict[str, typing.Optional[str]]]
--
     def __init__(self, sparse_string_list: typing.Optional[typing.List[typing.Optional[str]]] = ..., sparse_string_map: typing.Optional[typing.Dict[str, typing.Optional[str]]] = ...) -> None:
         ...
--

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/python/json_rpc11/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_rpc11/rust-server-codegen-python/python/json_rpc11/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_rpc11/rust-server-codegen-python/python/json_rpc11/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_rpc11/rust-server-codegen-python/src/protocol_serde/shape_my_union.rs

@@ -115,115 +200,200 @@

↥ Expand context

                             "expected object key or end object, found: {:?}",
                             other
                         )),
-118
+                    )
-119
+                }
-120
+            }
         },
         _ => {
             return Err(
                 ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                     "expected start object or null",
                 ),
-127
+            )
-128
+        }
-129
+    }
     if variant.is_none() {
         return Err(
             ::aws_smithy_json::deserialize::error::DeserializeError::custom(
                 "Union did not contain a valid variant.",
             ),

         );
-136
+    }
     Ok(variant)
-138
+}
-139
 pub fn ser_my_union(
     object_2: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
     input: &crate::model::MyUnion,
 ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
     match input {
         crate::model::MyUnion::StringValue(inner) => {
         crate::model::MyUnion::StringValue(_inner) => {
             object_2.key("stringValue").string(inner.as_str());
-147
+        }
         crate::model::MyUnion::BooleanValue(inner) => {
         crate::model::MyUnion::BooleanValue(_inner) => {
             object_2.key("booleanValue").boolean(*inner);
-150
+        }
         crate::model::MyUnion::NumberValue(inner) => {
         crate::model::MyUnion::NumberValue(_inner) => {
             object_2.key("numberValue").number(
                 #[allow(clippy::useless_conversion)]
                 ::aws_smithy_types::Number::NegInt((*inner).into()),
             );
-156
+        }
         crate::model::MyUnion::BlobValue(inner) => {
         crate::model::MyUnion::BlobValue(_inner) => {
             object_2
                 .key("blobValue")
                 .string_unchecked(&::aws_smithy_types::base64::encode(inner));
-161
+        }
         crate::model::MyUnion::TimestampValue(inner) => {
         crate::model::MyUnion::TimestampValue(_inner) => {
             object_2
                 .key("timestampValue")
                 .date_time(inner, ::aws_smithy_types::date_time::Format::EpochSeconds)?;
-166
+        }
         crate::model::MyUnion::EnumValue(inner) => {
         crate::model::MyUnion::EnumValue(_inner) => {
             object_2.key("enumValue").string(inner.as_str());
-169
+        }
         crate::model::MyUnion::ListValue(inner) => {
         crate::model::MyUnion::ListValue(_inner) => {
             let mut array_1 = object_2.key("listValue").start_array();
             for item_2 in inner {
-173
+                {
                     array_1.value().string(item_2.as_str());
-175
+                }
-176
+            }
             array_1.finish();
-178
+        }
         crate::model::MyUnion::MapValue(inner) => {
         crate::model::MyUnion::MapValue(_inner) => {
             #[allow(unused_mut)]
             let mut object_3 = object_2.key("mapValue").start_object();
             for (key_4, value_5) in inner {
-183
+                {
                     object_3.key(key_4.as_str()).string(value_5.as_str());
-185
+                }
-186
+            }
             object_3.finish();
-188
+        }
         crate::model::MyUnion::StructureValue(inner) => {
         crate::model::MyUnion::StructureValue(_inner) => {
             #[allow(unused_mut)]
             let mut object_6 = object_2.key("structureValue").start_object();
             crate::protocol_serde::shape_greeting_struct::ser_greeting_struct(
                 &mut object_6,
                 inner,
             )?;
             object_6.finish();
-197
+        }
-198
+    }
     Ok(())

↧ Expand context

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

@@ -1,0 +164,0 @@

 import misc.input
 import misc.middleware
 import misc.output
 import misc.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 misc import input
     from misc import output
     from misc import error
     from misc import middleware
     from misc 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)
--
     @app.required_header_collection_operation
     def required_header_collection_operation(input: input::RequiredHeaderCollectionOperationInput, ctx: Context) -> output::RequiredHeaderCollectionOperationOutput:
         raise NotImplementedError
--
     # This operation tests that (de)serializing required values from a nested
     # shape works correctly.
     @app.required_inner_shape_operation
     def required_inner_shape_operation(input: input::RequiredInnerShapeOperationInput, ctx: Context) -> output::RequiredInnerShapeOperationOutput:
         raise NotImplementedError
--
     # This operation tests that the response code defaults to 200 when no other
     # code is set.
     @app.response_code_default_operation
     def response_code_default_operation(input: input::ResponseCodeDefaultOperationInput, ctx: Context) -> output::ResponseCodeDefaultOperationOutput:
         raise NotImplementedError
--
     # This operation tests that the response code defaults to `@http`'s code.
     @app.response_code_http_fallback_operation
     def response_code_http_fallback_operation(input: input::ResponseCodeHttpFallbackOperationInput, ctx: Context) -> output::ResponseCodeHttpFallbackOperationOutput:
         raise NotImplementedError
--
     # This operation tests that `@httpResponseCode` is `@required`
     # and is used over `@http's` code.
     @app.response_code_required_operation
     def response_code_required_operation(input: input::ResponseCodeRequiredOperationInput, ctx: Context) -> output::ResponseCodeRequiredOperationOutput:
         raise NotImplementedError
--
     # An operation whose shapes generate complex Rust types.
     # See https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity.
     @app.type_complexity_operation
     def type_complexity_operation(input: input::TypeComplexityOperationInput, ctx: Context) -> output::TypeComplexityOperationOutput:
         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 context(self, context: Ctx) -> None:
         """
         Register a context object that will be shared between handlers.
         """
         ...
--
--
     def middleware(self, func: typing.Callable[[misc.middleware.Request, typing.Callable[[misc.middleware.Request], typing.Awaitable[misc.middleware.Response]]], typing.Awaitable[misc.middleware.Response]]) -> None:
         """
         Register a Python function to be executed inside a Tower middleware layer.
         """
         ...
--
--
     def required_header_collection_operation(self, func: typing.Union[typing.Callable[[misc.input.RequiredHeaderCollectionOperationInput, Ctx], typing.Union[misc.output.RequiredHeaderCollectionOperationOutput, typing.Awaitable[misc.output.RequiredHeaderCollectionOperationOutput]]], typing.Callable[[misc.input.RequiredHeaderCollectionOperationInput], typing.Union[misc.output.RequiredHeaderCollectionOperationOutput, typing.Awaitable[misc.output.RequiredHeaderCollectionOperationOutput]]]]) -> None:
         """
         Method to register `required_header_collection_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def required_inner_shape_operation(self, func: typing.Union[typing.Callable[[misc.input.RequiredInnerShapeOperationInput, Ctx], typing.Union[misc.output.RequiredInnerShapeOperationOutput, typing.Awaitable[misc.output.RequiredInnerShapeOperationOutput]]], typing.Callable[[misc.input.RequiredInnerShapeOperationInput], typing.Union[misc.output.RequiredInnerShapeOperationOutput, typing.Awaitable[misc.output.RequiredInnerShapeOperationOutput]]]]) -> None:
         """
         Method to register `required_inner_shape_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def response_code_default_operation(self, func: typing.Union[typing.Callable[[misc.input.ResponseCodeDefaultOperationInput, Ctx], typing.Union[misc.output.ResponseCodeDefaultOperationOutput, typing.Awaitable[misc.output.ResponseCodeDefaultOperationOutput]]], typing.Callable[[misc.input.ResponseCodeDefaultOperationInput], typing.Union[misc.output.ResponseCodeDefaultOperationOutput, typing.Awaitable[misc.output.ResponseCodeDefaultOperationOutput]]]]) -> None:
         """
         Method to register `response_code_default_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def response_code_http_fallback_operation(self, func: typing.Union[typing.Callable[[misc.input.ResponseCodeHttpFallbackOperationInput, Ctx], typing.Union[misc.output.ResponseCodeHttpFallbackOperationOutput, typing.Awaitable[misc.output.ResponseCodeHttpFallbackOperationOutput]]], typing.Callable[[misc.input.ResponseCodeHttpFallbackOperationInput], typing.Union[misc.output.ResponseCodeHttpFallbackOperationOutput, typing.Awaitable[misc.output.ResponseCodeHttpFallbackOperationOutput]]]]) -> None:
         """
         Method to register `response_code_http_fallback_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def response_code_required_operation(self, func: typing.Union[typing.Callable[[misc.input.ResponseCodeRequiredOperationInput, Ctx], typing.Union[misc.output.ResponseCodeRequiredOperationOutput, typing.Awaitable[misc.output.ResponseCodeRequiredOperationOutput]]], typing.Callable[[misc.input.ResponseCodeRequiredOperationInput], typing.Union[misc.output.ResponseCodeRequiredOperationOutput, typing.Awaitable[misc.output.ResponseCodeRequiredOperationOutput]]]]) -> None:
         """
         Method to register `response_code_required_operation` 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[misc.tls.TlsConfig] = ...) -> None:
         """
         Main entrypoint: start the server on multiple workers.
         """
         ...
--
--
     def run_lambda(self) -> None:
         """
         Lambda entrypoint: start the server on Lambda.
         """
         ...
--
--
     def start_worker(self) -> None:
         """
         Build the service and start a single worker.
         """
         ...
--
--
     def type_complexity_operation(self, func: typing.Union[typing.Callable[[misc.input.TypeComplexityOperationInput, Ctx], typing.Union[misc.output.TypeComplexityOperationOutput, typing.Awaitable[misc.output.TypeComplexityOperationOutput]]], typing.Callable[[misc.input.TypeComplexityOperationInput], typing.Union[misc.output.TypeComplexityOperationOutput, typing.Awaitable[misc.output.TypeComplexityOperationOutput]]]]) -> None:
         """
         Method to register `type_complexity_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def __init__(self) -> None:
         ...
--
--
 CODEGEN_VERSION: str = ...

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