Server Test Python

rev. 399187927edd9a1e762efeae060e3a56d671920a

Files changed:

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

@@ -8,8 +60,60 @@

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

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

↧ Expand context

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

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

@@ -1,0 +273,0 @@

 import json_rpc10.input
 import json_rpc10.middleware
 import json_rpc10.output
 import json_rpc10.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_rpc10 import input
     from json_rpc10 import output
     from json_rpc10 import error
     from json_rpc10 import middleware
     from json_rpc10 import App
--
     @dataclass
     class Context:
         counter: int = 0
--
     app = App()
     app.context(Context())
--
     @app.request_middleware
     def request_middleware(request: middleware::Request):
         if request.get_header("x-amzn-id") != "secret":
             raise middleware.MiddlewareException("Unsupported `x-amz-id` header", 401)
--
     # The example tests how servers must support requests
     # containing a `Content-Type` header with parameters.
     @app.content_type_parameters
     def content_type_parameters(input: input::ContentTypeParametersInput, ctx: Context) -> output::ContentTypeParametersOutput:
         raise NotImplementedError
--
     # The example tests how requests and responses are serialized when there's
     # no request or response payload because the operation has an empty input
     # and empty output structure that reuses the same shape. While this should
     # be rare, code generators must support this.
     @app.empty_input_and_empty_output
     def empty_input_and_empty_output(input: input::EmptyInputAndEmptyOutputInput, ctx: Context) -> output::EmptyInputAndEmptyOutputOutput:
         raise NotImplementedError
--
     @app.endpoint_operation
     def endpoint_operation(input: input::EndpointOperationInput, ctx: Context) -> output::EndpointOperationOutput:
         raise NotImplementedError
--
     @app.endpoint_with_host_label_operation
     def endpoint_with_host_label_operation(input: input::EndpointWithHostLabelOperationInput, ctx: Context) -> output::EndpointWithHostLabelOperationOutput:
         raise NotImplementedError
--
     # This operation has three possible return values:
--
+    #
     # 1. A successful response in the form of GreetingWithErrorsOutput
     # 2. An InvalidGreeting error.
     # 3. A ComplexError error.
--
+    #
     # Implementations must be able to successfully take a response and
     # properly deserialize successful and error responses.
     @app.greeting_with_errors
     def greeting_with_errors(input: input::GreetingWithErrorsInput, ctx: Context) -> output::GreetingWithErrorsOutput:
         raise NotImplementedError
--
     @app.host_with_path_operation
     def host_with_path_operation(input: input::HostWithPathOperationInput, ctx: Context) -> output::HostWithPathOperationOutput:
         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
--
     # The example tests how requests and responses are serialized when there's
     # no request or response payload because the operation has no input or output.
     # While this should be rare, code generators must support this.
     @app.no_input_and_no_output
     def no_input_and_no_output(input: input::NoInputAndNoOutputInput, ctx: Context) -> output::NoInputAndNoOutputOutput:
         raise NotImplementedError
--
     # The example tests how requests and responses are serialized when there's
     # no request or response payload because the operation has no input and the
     # output is empty. While this should be rare, code generators must support
     # this.
     @app.no_input_and_output
     def no_input_and_output(input: input::NoInputAndOutputInput, ctx: Context) -> output::NoInputAndOutputOutput:
         raise NotImplementedError
--
     @app.operation_with_defaults
     def operation_with_defaults(input: input::OperationWithDefaultsInput, ctx: Context) -> output::OperationWithDefaultsOutput:
         raise NotImplementedError
--
     @app.operation_with_nested_structure
     def operation_with_nested_structure(input: input::OperationWithNestedStructureInput, ctx: Context) -> output::OperationWithNestedStructureOutput:
         raise NotImplementedError
--
     @app.operation_with_required_members
     def operation_with_required_members(input: input::OperationWithRequiredMembersInput, ctx: Context) -> output::OperationWithRequiredMembersOutput:
         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.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_rpc10.input.ContentTypeParametersInput, Ctx], typing.Union[json_rpc10.output.ContentTypeParametersOutput, typing.Awaitable[json_rpc10.output.ContentTypeParametersOutput]]], typing.Callable[[json_rpc10.input.ContentTypeParametersInput], typing.Union[json_rpc10.output.ContentTypeParametersOutput, typing.Awaitable[json_rpc10.output.ContentTypeParametersOutput]]]]) -> None:
         """
         Method to register `content_type_parameters` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def context(self, context: Ctx) -> None:
         """
         Register a context object that will be shared between handlers.
         """
         ...
--
--
     def empty_input_and_empty_output(self, func: typing.Union[typing.Callable[[json_rpc10.input.EmptyInputAndEmptyOutputInput, Ctx], typing.Union[json_rpc10.output.EmptyInputAndEmptyOutputOutput, typing.Awaitable[json_rpc10.output.EmptyInputAndEmptyOutputOutput]]], typing.Callable[[json_rpc10.input.EmptyInputAndEmptyOutputInput], typing.Union[json_rpc10.output.EmptyInputAndEmptyOutputOutput, typing.Awaitable[json_rpc10.output.EmptyInputAndEmptyOutputOutput]]]]) -> None:
         """
         Method to register `empty_input_and_empty_output` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def endpoint_operation(self, func: typing.Union[typing.Callable[[json_rpc10.input.EndpointOperationInput, Ctx], typing.Union[json_rpc10.output.EndpointOperationOutput, typing.Awaitable[json_rpc10.output.EndpointOperationOutput]]], typing.Callable[[json_rpc10.input.EndpointOperationInput], typing.Union[json_rpc10.output.EndpointOperationOutput, typing.Awaitable[json_rpc10.output.EndpointOperationOutput]]]]) -> None:
         """
         Method to register `endpoint_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def endpoint_with_host_label_operation(self, func: typing.Union[typing.Callable[[json_rpc10.input.EndpointWithHostLabelOperationInput, Ctx], typing.Union[json_rpc10.output.EndpointWithHostLabelOperationOutput, typing.Awaitable[json_rpc10.output.EndpointWithHostLabelOperationOutput]]], typing.Callable[[json_rpc10.input.EndpointWithHostLabelOperationInput], typing.Union[json_rpc10.output.EndpointWithHostLabelOperationOutput, typing.Awaitable[json_rpc10.output.EndpointWithHostLabelOperationOutput]]]]) -> None:
         """
         Method to register `endpoint_with_host_label_operation` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def greeting_with_errors(self, func: typing.Union[typing.Callable[[json_rpc10.input.GreetingWithErrorsInput, Ctx], typing.Union[json_rpc10.output.GreetingWithErrorsOutput, typing.Awaitable[json_rpc10.output.GreetingWithErrorsOutput]]], typing.Callable[[json_rpc10.input.GreetingWithErrorsInput], typing.Union[json_rpc10.output.GreetingWithErrorsOutput, typing.Awaitable[json_rpc10.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_rpc10.input.HostWithPathOperationInput, Ctx], typing.Union[json_rpc10.output.HostWithPathOperationOutput, typing.Awaitable[json_rpc10.output.HostWithPathOperationOutput]]], typing.Callable[[json_rpc10.input.HostWithPathOperationInput], typing.Union[json_rpc10.output.HostWithPathOperationOutput, typing.Awaitable[json_rpc10.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_unions(self, func: typing.Union[typing.Callable[[json_rpc10.input.JsonUnionsInput, Ctx], typing.Union[json_rpc10.output.JsonUnionsOutput, typing.Awaitable[json_rpc10.output.JsonUnionsOutput]]], typing.Callable[[json_rpc10.input.JsonUnionsInput], typing.Union[json_rpc10.output.JsonUnionsOutput, typing.Awaitable[json_rpc10.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 middleware(self, func: typing.Callable[[json_rpc10.middleware.Request, typing.Callable[[json_rpc10.middleware.Request], typing.Awaitable[json_rpc10.middleware.Response]]], typing.Awaitable[json_rpc10.middleware.Response]]) -> None:
         """
         Register a Python function to be executed inside a Tower middleware layer.
         """
         ...
--
--
     def no_input_and_no_output(self, func: typing.Union[typing.Callable[[json_rpc10.input.NoInputAndNoOutputInput, Ctx], typing.Union[json_rpc10.output.NoInputAndNoOutputOutput, typing.Awaitable[json_rpc10.output.NoInputAndNoOutputOutput]]], typing.Callable[[json_rpc10.input.NoInputAndNoOutputInput], typing.Union[json_rpc10.output.NoInputAndNoOutputOutput, typing.Awaitable[json_rpc10.output.NoInputAndNoOutputOutput]]]]) -> None:
         """
         Method to register `no_input_and_no_output` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def no_input_and_output(self, func: typing.Union[typing.Callable[[json_rpc10.input.NoInputAndOutputInput, Ctx], typing.Union[json_rpc10.output.NoInputAndOutputOutput, typing.Awaitable[json_rpc10.output.NoInputAndOutputOutput]]], typing.Callable[[json_rpc10.input.NoInputAndOutputInput], typing.Union[json_rpc10.output.NoInputAndOutputOutput, typing.Awaitable[json_rpc10.output.NoInputAndOutputOutput]]]]) -> None:
         """
         Method to register `no_input_and_output` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def operation_with_defaults(self, func: typing.Union[typing.Callable[[json_rpc10.input.OperationWithDefaultsInput, Ctx], typing.Union[json_rpc10.output.OperationWithDefaultsOutput, typing.Awaitable[json_rpc10.output.OperationWithDefaultsOutput]]], typing.Callable[[json_rpc10.input.OperationWithDefaultsInput], typing.Union[json_rpc10.output.OperationWithDefaultsOutput, typing.Awaitable[json_rpc10.output.OperationWithDefaultsOutput]]]]) -> None:
         """
         Method to register `operation_with_defaults` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def operation_with_nested_structure(self, func: typing.Union[typing.Callable[[json_rpc10.input.OperationWithNestedStructureInput, Ctx], typing.Union[json_rpc10.output.OperationWithNestedStructureOutput, typing.Awaitable[json_rpc10.output.OperationWithNestedStructureOutput]]], typing.Callable[[json_rpc10.input.OperationWithNestedStructureInput], typing.Union[json_rpc10.output.OperationWithNestedStructureOutput, typing.Awaitable[json_rpc10.output.OperationWithNestedStructureOutput]]]]) -> None:
         """
         Method to register `operation_with_nested_structure` Python implementation inside the handlers map.
         It can be used as a function decorator in Python.
         """
         ...
--
--
     def operation_with_required_members(self, func: typing.Union[typing.Callable[[json_rpc10.input.OperationWithRequiredMembersInput, Ctx], typing.Union[json_rpc10.output.OperationWithRequiredMembersOutput, typing.Awaitable[json_rpc10.output.OperationWithRequiredMembersOutput]]], typing.Callable[[json_rpc10.input.OperationWithRequiredMembersInput], typing.Union[json_rpc10.output.OperationWithRequiredMembersOutput, typing.Awaitable[json_rpc10.output.OperationWithRequiredMembersOutput]]]]) -> None:
         """
         Method to register `operation_with_required_members` 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_rpc10.input.PutWithContentEncodingInput, Ctx], typing.Union[json_rpc10.output.PutWithContentEncodingOutput, typing.Awaitable[json_rpc10.output.PutWithContentEncodingOutput]]], typing.Callable[[json_rpc10.input.PutWithContentEncodingInput], typing.Union[json_rpc10.output.PutWithContentEncodingOutput, typing.Awaitable[json_rpc10.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_rpc10.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_rpc10.input.SimpleScalarPropertiesInput, Ctx], typing.Union[json_rpc10.output.SimpleScalarPropertiesOutput, typing.Awaitable[json_rpc10.output.SimpleScalarPropertiesOutput]]], typing.Callable[[json_rpc10.input.SimpleScalarPropertiesInput], typing.Union[json_rpc10.output.SimpleScalarPropertiesOutput, typing.Awaitable[json_rpc10.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 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_rpc10/rust-server-codegen-python/python/json_rpc10/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_rpc10/rust-server-codegen-python/python/json_rpc10/error/init.pyi

@@ -1,0 +61,0 @@

 import json_rpc10.model
 import typing
--
 class ComplexError(Exception):
     """
     This error is thrown when a request is invalid.
     """
--
     nested: typing.Optional[json_rpc10.model.ComplexNestedErrorData]
--
     top_level: typing.Optional[str]
--
     def __init__(self, top_level: typing.Optional[str] = ..., nested: typing.Optional[json_rpc10.model.ComplexNestedErrorData] = ...) -> 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_rpc10.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_rpc10.model.ValidationExceptionField]] = ...) -> None:
         ...
--

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

@@ -1,0 +101,0 @@

 import json_rpc10.model
 import typing
--
 class ContentTypeParametersInput:
     value: typing.Optional[int]
--
     def __init__(self, value: typing.Optional[int] = ...) -> None:
         ...
--
--
 class EmptyInputAndEmptyOutputInput:
     def __init__(self) -> None:
         ...
--
--
 class EndpointOperationInput:
     def __init__(self) -> None:
         ...
--
--
 class EndpointWithHostLabelOperationInput:
     label: str
--
     def __init__(self, label: str) -> None:
         ...
--
--
 class GreetingWithErrorsInput:
     greeting: typing.Optional[str]
--
     def __init__(self, greeting: typing.Optional[str] = ...) -> None:
         ...
--
--
 class HostWithPathOperationInput:
     def __init__(self) -> None:
         ...
--
--
 class JsonUnionsInput:
     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 NoInputAndNoOutputInput:
     def __init__(self) -> None:
         ...
--
--
 class NoInputAndOutputInput:
     def __init__(self) -> None:
         ...
--
--
 class OperationWithDefaultsInput:
     client_optional_defaults: typing.Optional[json_rpc10.model.ClientOptionalDefaults]
--
     defaults: typing.Optional[json_rpc10.model.Defaults]
--
     other_top_level_default: int
--
     top_level_default: str
--
     def __init__(self, defaults: typing.Optional[json_rpc10.model.Defaults] = ..., client_optional_defaults: typing.Optional[json_rpc10.model.ClientOptionalDefaults] = ..., top_level_default: str, other_top_level_default: int) -> None:
         ...
--
--
 class OperationWithNestedStructureInput:
     top_level: json_rpc10.model.TopLevel
--
     def __init__(self, top_level: json_rpc10.model.TopLevel) -> None:
         ...
--
--
 class OperationWithRequiredMembersInput:
     def __init__(self) -> None:
         ...
--
--
 class PutWithContentEncodingInput:
     data: typing.Optional[str]
--
     encoding: typing.Optional[str]
--
     def __init__(self, encoding: typing.Optional[str] = ..., data: typing.Optional[str] = ...) -> None:
         ...
--
--
 class SimpleScalarPropertiesInput:
     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/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_rpc10/rust-server-codegen-python/python/json_rpc10/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_rpc10/rust-server-codegen-python/python/json_rpc10/model/init.pyi

@@ -1,0 +380,0 @@

 import json_rpc10.model
 import json_rpc10.types
 import typing
--
 class ClientOptionalDefaults:
     member: int
--
     def __init__(self, member: int) -> None:
         ...
--
--
 class ComplexNestedErrorData:
     foo: typing.Optional[str]
--
     def __init__(self, foo: typing.Optional[str] = ...) -> None:
         ...
--
--
 class Defaults:
     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 Dialog:
     farewell: typing.Optional[json_rpc10.model.Farewell]
--
     greeting: str
--
     language: typing.Optional[str]
--
     def __init__(self, language: typing.Optional[str] = ..., greeting: str, farewell: typing.Optional[json_rpc10.model.Farewell] = ...) -> None:
         ...
--
--
 class Farewell:
     phrase: str
--
     def __init__(self, phrase: str) -> 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 MyUnion:
     def as_blob_value(self) -> json_rpc10.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_rpc10.model.FooEnum:
         """
         Tries to convert the enum instance into [`EnumValue`](crate::model::MyUnion::EnumValue), extracting the inner [`FooEnum`](crate::model::FooEnum).
         """
         ...
--
--
     def as_int_enum_value(self) -> int:
         """
         Tries to convert the enum instance into [`IntEnumValue`](crate::model::MyUnion::IntEnumValue), extracting the inner [`i32`](i32).
         """
         ...
--
--
     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_rpc10.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_rpc10.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_rpc10.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_rpc10.model.FooEnum) -> MyUnion:
         """
         Creates a new union instance of [`EnumValue`](crate::model::MyUnion::EnumValue)
         """
         ...
--
--
     @staticmethod
     def int_enum_value(data: int) -> MyUnion:
         """
         Creates a new union instance of [`IntEnumValue`](crate::model::MyUnion::IntEnumValue)
         """
         ...
--
--
     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_int_enum_value(self) -> bool:
         """
         Returns true if this is a [`IntEnumValue`](crate::model::MyUnion::IntEnumValue).
         """
         ...
--
--
     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_rpc10.model.GreetingStruct) -> MyUnion:
         """
         Creates a new union instance of [`StructureValue`](crate::model::MyUnion::StructureValue)
         """
         ...
--
--
     @staticmethod
     def timestamp_value(data: json_rpc10.types.DateTime) -> MyUnion:
         """
         Creates a new union instance of [`TimestampValue`](crate::model::MyUnion::TimestampValue)
         """
         ...
--
--
 class TestEnum:
     Bar: TestEnum
--
     Baz: TestEnum
--
     Foo: TestEnum
--
     name: typing.Any
--
     value: typing.Any
--
 class TopLevel:
     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 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:
         ...
--

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