Server Test Python

Server Test Python

rev. c67de0508e9d33923e47fd7281531eeca95f7996

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/python/rest_json/socket/__init__.pyi

@@ -1,0 +27,0 @@
    1         -
import typing
    2         -
    3         -
class PySocket:
    4         -
    """
    5         -
    Socket implementation that can be shared between multiple Python processes.
    6         -
    7         -
    Python cannot handle true multi-threaded applications due to the [GIL],
    8         -
    often resulting in reduced performance and only one core used by the application.
    9         -
    To work around this, Python web applications usually create a socket with
   10         -
    SO_REUSEADDR and SO_REUSEPORT enabled that can be shared between multiple
   11         -
    Python processes, allowing you to maximize performance and use all available
   12         -
    computing capacity of the host.
   13         -
   14         -
    [GIL]: https://wiki.python.org/moin/GlobalInterpreterLock
   15         -
    """
   16         -
   17         -
    def try_clone(self) -> PySocket:
   18         -
        """
   19         -
        Clone the inner socket allowing it to be shared between multiple
   20         -
        Python processes.
   21         -
        """
   22         -
        ...
   23         -
   24         -
   25         -
    def __init__(self, address: str, port: int, backlog: typing.Optional[int] = ...) -> None:
   26         -
        ...
   27         -

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/python/rest_json/tls/__init__.pyi

@@ -1,0 +10,0 @@
    1         -
import pathlib
    2         -
    3         -
class TlsConfig:
    4         -
    """
    5         -
    PyTlsConfig represents TLS configuration created from Python.
    6         -
    """
    7         -
    8         -
    def __init__(self, key_path: pathlib.Path, cert_path: pathlib.Path, reload_secs: int = ...) -> None:
    9         -
        ...
   10         -

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/python/rest_json/types/__init__.pyi

@@ -1,0 +209,0 @@
    1         -
import typing
    2         -
    3         -
class Blob:
    4         -
    """
    5         -
    Python Wrapper for [aws_smithy_types::Blob].
    6         -
    """
    7         -
    8         -
    data: bytes
    9         -
    """
   10         -
    Python getter for the `Blob` byte array.
   11         -
    """
   12         -
   13         -
    def __init__(self, input: bytes) -> None:
   14         -
        ...
   15         -
   16         -
   17         -
class ByteStream:
   18         -
    """
   19         -
    Python Wrapper for [aws_smithy_types::byte_stream::ByteStream].
   20         -
   21         -
    ByteStream provides misuse-resistant primitives to make it easier to handle common patterns with streaming data.
   22         -
   23         -
    On the Rust side, The Python implementation wraps the original [ByteStream](aws_smithy_types::byte_stream::ByteStream)
   24         -
    in a clonable structure and implements the [Stream](futures::stream::Stream) trait for it to
   25         -
    allow Rust to handle the type transparently.
   26         -
   27         -
    On the Python side both sync and async iterators are exposed by implementing `__iter__()` and `__aiter__()` magic methods,
   28         -
    which allows to just loop over the stream chunks.
   29         -
   30         -
    ### Example of async streaming:
   31         -
   32         -
    ```python
   33         -
        stream = await ByteStream.from_path("/tmp/music.mp3")
   34         -
        async for chunk in stream:
   35         -
            print(chunk)
   36         -
    ```
   37         -
   38         -
    ### Example of sync streaming:
   39         -
   40         -
    ```python
   41         -
        stream = ByteStream.from_stream_blocking("/tmp/music.mp3")
   42         -
        for chunk in stream:
   43         -
            print(chunk)
   44         -
    ```
   45         -
   46         -
    The main difference between the two implementations is that the async one is scheduling the Python coroutines as Rust futures,
   47         -
    effectively maintaining the asyncronous behavior that Rust exposes, while the sync one is blocking the Tokio runtime to be able
   48         -
    to await one chunk at a time.
   49         -
   50         -
    The original Rust [ByteStream](aws_smithy_types::byte_stream::ByteStream) is wrapped inside a `Arc<Mutex>` to allow the type to be
   51         -
    [Clone] (required by PyO3) and to allow internal mutability, required to fetch the next chunk of data.
   52         -
    """
   53         -
   54         -
    @staticmethod
   55         -
    def from_path(path: str) -> typing.Awaitable[ByteStream]:
   56         -
        """
   57         -
        Create a new [ByteStream](aws_smithy_types::byte_stream::ByteStream) from a path, forcing
   58         -
        Python to await this coroutine.
   59         -
        """
   60         -
        ...
   61         -
   62         -
   63         -
    @staticmethod
   64         -
    def from_path_blocking(path: str) -> ByteStream:
   65         -
        """
   66         -
        Create a new [ByteStream](aws_smithy_types::byte_stream::ByteStream) from a path, without
   67         -
        requiring Python to await this method.
   68         -
   69         -
        **NOTE:** This method will block the Rust event loop when it is running.
   70         -
        """
   71         -
        ...
   72         -
   73         -
   74         -
    def __init__(self, input: bytes) -> None:
   75         -
        ...
   76         -
   77         -
   78         -
class DateTime:
   79         -
    """
   80         -
    Python Wrapper for [aws_smithy_types::date_time::DateTime].
   81         -
    """
   82         -
   83         -
    def as_nanos(self) -> int:
   84         -
        """
   85         -
        Returns the number of nanoseconds since the Unix epoch that this `DateTime` represents.
   86         -
        """
   87         -
        ...
   88         -
   89         -
   90         -
    def as_secs_f64(self) -> float:
   91         -
        """
   92         -
        Returns the `DateTime` value as an `f64` representing the seconds since the Unix epoch.
   93         -
        """
   94         -
        ...
   95         -
   96         -
   97         -
    @staticmethod
   98         -
    def from_fractional_secs(epoch_seconds: int, fraction: float) -> DateTime:
   99         -
        """
  100         -
        Creates a `DateTime` from a number of seconds and a fractional second since the Unix epoch.
  101         -
        """
  102         -
        ...
  103         -
  104         -
  105         -
    @staticmethod
  106         -
    def from_millis(epoch_millis: int) -> DateTime:
  107         -
        """
  108         -
        Creates a `DateTime` from a number of milliseconds since the Unix epoch.
  109         -
        """
  110         -
        ...
  111         -
  112         -
  113         -
    @staticmethod
  114         -
    def from_nanos(epoch_nanos: int) -> DateTime:
  115         -
        """
  116         -
        Creates a `DateTime` from a number of nanoseconds since the Unix epoch.
  117         -
        """
  118         -
        ...
  119         -
  120         -
  121         -
    @staticmethod
  122         -
    def from_secs(epoch_seconds: int) -> DateTime:
  123         -
        """
  124         -
        Creates a `DateTime` from a number of seconds since the Unix epoch.
  125         -
        """
  126         -
        ...
  127         -
  128         -
  129         -
    @staticmethod
  130         -
    def from_secs_and_nanos(seconds: int, subsecond_nanos: int) -> DateTime:
  131         -
        """
  132         -
        Creates a `DateTime` from a number of seconds and sub-second nanos since the Unix epoch.
  133         -
        """
  134         -
        ...
  135         -
  136         -
  137         -
    @staticmethod
  138         -
    def from_secs_f64(epoch_seconds: float) -> DateTime:
  139         -
        """
  140         -
        Creates a `DateTime` from an `f64` representing the number of seconds since the Unix epoch.
  141         -
        """
  142         -
        ...
  143         -
  144         -
  145         -
    @staticmethod
  146         -
    def from_str(s: str, format: Format) -> DateTime:
  147         -
        """
  148         -
        Parses a `DateTime` from a string using the given `format`.
  149         -
        """
  150         -
        ...
  151         -
  152         -
  153         -
    def has_subsec_nanos(self) -> bool:
  154         -
        """
  155         -
        Returns true if sub-second nanos is greater than zero.
  156         -
        """
  157         -
        ...
  158         -
  159         -
  160         -
    @staticmethod
  161         -
    def read(format: Format, delim: str) -> typing.Tuple[DateTime, str]:
  162         -
        """
  163         -
        Read 1 date of `format` from `s`, expecting either `delim` or EOF.
  164         -
  165         -
        TODO(PythonTyping): How do we represent `char` in Python?
  166         -
        """
  167         -
        ...
  168         -
  169         -
  170         -
    def secs(self) -> int:
  171         -
        """
  172         -
        Returns the epoch seconds component of the `DateTime`.
  173         -
        """
  174         -
        ...
  175         -
  176         -
  177         -
    def subsec_nanos(self) -> int:
  178         -
        """
  179         -
        Returns the sub-second nanos component of the `DateTime`.
  180         -
        """
  181         -
        ...
  182         -
  183         -
  184         -
    def to_millis(self) -> int:
  185         -
        """
  186         -
        Converts the `DateTime` to the number of milliseconds since the Unix epoch.
  187         -
        """
  188         -
        ...
  189         -
  190         -
  191         -
class Format:
  192         -
    """
  193         -
    Formats for representing a `DateTime` in the Smithy protocols.
  194         -
    """
  195         -
  196         -
    DateTime: Format
  197         -
    """
  198         -
    Formats for representing a `DateTime` in the Smithy protocols.
  199         -
    """
  200         -
  201         -
    EpochSeconds: Format
  202         -
    """
  203         -
    Formats for representing a `DateTime` in the Smithy protocols.
  204         -
    """
  205         -
  206         -
    HttpDate: Format
  207         -
    """
  208         -
    Formats for representing a `DateTime` in the Smithy protocols.
  209         -
    """

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

@@ -121,121 +215,215 @@
  141    141   
        );
  142    142   
    }
  143    143   
    Ok(variant)
  144    144   
}
  145    145   
  146    146   
pub fn ser_my_union(
  147    147   
    object_2: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
  148    148   
    input: &crate::model::MyUnion,
  149    149   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
  150    150   
    match input {
  151         -
        crate::model::MyUnion::StringValue(inner) => {
         151  +
        crate::model::MyUnion::StringValue(_inner) => {
  152    152   
            object_2.key("stringValue").string(inner.as_str());
  153    153   
        }
  154         -
        crate::model::MyUnion::BooleanValue(inner) => {
         154  +
        crate::model::MyUnion::BooleanValue(_inner) => {
  155    155   
            object_2.key("booleanValue").boolean(*inner);
  156    156   
        }
  157         -
        crate::model::MyUnion::NumberValue(inner) => {
         157  +
        crate::model::MyUnion::NumberValue(_inner) => {
  158    158   
            object_2.key("numberValue").number(
  159    159   
                #[allow(clippy::useless_conversion)]
  160    160   
                ::aws_smithy_types::Number::NegInt((*inner).into()),
  161    161   
            );
  162    162   
        }
  163         -
        crate::model::MyUnion::BlobValue(inner) => {
         163  +
        crate::model::MyUnion::BlobValue(_inner) => {
  164    164   
            object_2
  165    165   
                .key("blobValue")
  166    166   
                .string_unchecked(&::aws_smithy_types::base64::encode(inner));
  167    167   
        }
  168         -
        crate::model::MyUnion::TimestampValue(inner) => {
         168  +
        crate::model::MyUnion::TimestampValue(_inner) => {
  169    169   
            object_2
  170    170   
                .key("timestampValue")
  171    171   
                .date_time(inner, ::aws_smithy_types::date_time::Format::EpochSeconds)?;
  172    172   
        }
  173         -
        crate::model::MyUnion::EnumValue(inner) => {
         173  +
        crate::model::MyUnion::EnumValue(_inner) => {
  174    174   
            object_2.key("enumValue").string(inner.as_str());
  175    175   
        }
  176         -
        crate::model::MyUnion::ListValue(inner) => {
         176  +
        crate::model::MyUnion::ListValue(_inner) => {
  177    177   
            let mut array_1 = object_2.key("listValue").start_array();
  178    178   
            for item_2 in inner {
  179    179   
                {
  180    180   
                    array_1.value().string(item_2.as_str());
  181    181   
                }
  182    182   
            }
  183    183   
            array_1.finish();
  184    184   
        }
  185         -
        crate::model::MyUnion::MapValue(inner) => {
         185  +
        crate::model::MyUnion::MapValue(_inner) => {
  186    186   
            #[allow(unused_mut)]
  187    187   
            let mut object_3 = object_2.key("mapValue").start_object();
  188    188   
            for (key_4, value_5) in inner {
  189    189   
                {
  190    190   
                    object_3.key(key_4.as_str()).string(value_5.as_str());
  191    191   
                }
  192    192   
            }
  193    193   
            object_3.finish();
  194    194   
        }
  195         -
        crate::model::MyUnion::StructureValue(inner) => {
         195  +
        crate::model::MyUnion::StructureValue(_inner) => {
  196    196   
            #[allow(unused_mut)]
  197    197   
            let mut object_6 = object_2.key("structureValue").start_object();
  198    198   
            crate::protocol_serde::shape_greeting_struct::ser_greeting_struct(
  199    199   
                &mut object_6,
  200    200   
                inner,
  201    201   
            )?;
  202    202   
            object_6.finish();
  203    203   
        }
  204         -
        crate::model::MyUnion::RenamedStructureValue(inner) => {
         204  +
        crate::model::MyUnion::RenamedStructureValue(_inner) => {
  205    205   
            #[allow(unused_mut)]
  206    206   
            let mut object_7 = object_2.key("renamedStructureValue").start_object();
  207    207   
            crate::protocol_serde::shape_renamed_greeting::ser_renamed_greeting(
  208    208   
                &mut object_7,
  209    209   
                inner,
  210    210   
            )?;
  211    211   
            object_7.finish();
  212    212   
        }
  213    213   
    }
  214    214   
    Ok(())

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

@@ -3,3 +63,63 @@
   23     23   
        );
   24     24   
    }
   25     25   
    result
   26     26   
}
   27     27   
   28     28   
pub fn ser_union_payload(
   29     29   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
   30     30   
    input: &crate::model::UnionPayload,
   31     31   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
   32     32   
    match input {
   33         -
        crate::model::UnionPayload::Greeting(inner) => {
          33  +
        crate::model::UnionPayload::Greeting(_inner) => {
   34     34   
            object.key("greeting").string(inner.as_str());
   35     35   
        }
   36     36   
    }
   37     37   
    Ok(())
   38     38   
}
   39     39   
   40     40   
pub(crate) fn de_union_payload<'a, I>(
   41     41   
    tokens: &mut ::std::iter::Peekable<I>,
   42     42   
) -> ::std::result::Result<
   43     43   
    Option<crate::model::UnionPayload>,

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

@@ -91,91 +132,132 @@
  111    111   
        );
  112    112   
    }
  113    113   
    Ok(variant)
  114    114   
}
  115    115   
  116    116   
pub fn ser_union_with_json_name(
  117    117   
    object_1: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
  118    118   
    input: &crate::model::UnionWithJsonName,
  119    119   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
  120    120   
    match input {
  121         -
        crate::model::UnionWithJsonName::Foo(inner) => {
         121  +
        crate::model::UnionWithJsonName::Foo(_inner) => {
  122    122   
            object_1.key("FOO").string(inner.as_str());
  123    123   
        }
  124         -
        crate::model::UnionWithJsonName::Bar(inner) => {
         124  +
        crate::model::UnionWithJsonName::Bar(_inner) => {
  125    125   
            object_1.key("bar").string(inner.as_str());
  126    126   
        }
  127         -
        crate::model::UnionWithJsonName::Baz(inner) => {
         127  +
        crate::model::UnionWithJsonName::Baz(_inner) => {
  128    128   
            object_1.key("_baz").string(inner.as_str());
  129    129   
        }
  130    130   
    }
  131    131   
    Ok(())
  132    132   
}

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/__init__.pyi

@@ -1,0 +215,0 @@
    1         -
import rest_json_extras.input
    2         -
import rest_json_extras.middleware
    3         -
import rest_json_extras.output
    4         -
import rest_json_extras.tls
    5         -
import typing
    6         -
    7         -
Ctx = typing.TypeVar('Ctx')
    8         -
    9         -
class App(typing.Generic[Ctx]):
   10         -
    """
   11         -
    Main Python application, used to register operations and context and start multiple
   12         -
    workers on the same shared socket.
   13         -
   14         -
    Operations can be registered using the application object as a decorator (`@app.operation_name`).
   15         -
   16         -
    Here's a full example to get you started:
   17         -
   18         -
    ```python
   19         -
    from rest_json_extras import input
   20         -
    from rest_json_extras import output
   21         -
    from rest_json_extras import error
   22         -
    from rest_json_extras import middleware
   23         -
    from rest_json_extras import App
   24         -
   25         -
    @dataclass
   26         -
    class Context:
   27         -
        counter: int = 0
   28         -
   29         -
    app = App()
   30         -
    app.context(Context())
   31         -
   32         -
    @app.request_middleware
   33         -
    def request_middleware(request: middleware::Request):
   34         -
        if request.get_header("x-amzn-id") != "secret":
   35         -
            raise middleware.MiddlewareException("Unsupported `x-amz-id` header", 401)
   36         -
   37         -
    @app.case_insensitive_error_operation
   38         -
    def case_insensitive_error_operation(input: input::CaseInsensitiveErrorOperationInput, ctx: Context) -> output::CaseInsensitiveErrorOperationOutput:
   39         -
        raise NotImplementedError
   40         -
   41         -
    @app.empty_struct_with_content_on_wire_op
   42         -
    def empty_struct_with_content_on_wire_op(input: input::EmptyStructWithContentOnWireOpInput, ctx: Context) -> output::EmptyStructWithContentOnWireOpOutput:
   43         -
        raise NotImplementedError
   44         -
   45         -
    @app.enum_query
   46         -
    def enum_query(input: input::EnumQueryInput, ctx: Context) -> output::EnumQueryOutput:
   47         -
        raise NotImplementedError
   48         -
   49         -
    @app.escaped_string_values
   50         -
    def escaped_string_values(input: input::EscapedStringValuesInput, ctx: Context) -> output::EscapedStringValuesOutput:
   51         -
        raise NotImplementedError
   52         -
   53         -
    @app.map_with_enum_key_op
   54         -
    def map_with_enum_key_op(input: input::MapWithEnumKeyOpInput, ctx: Context) -> output::MapWithEnumKeyOpOutput:
   55         -
        raise NotImplementedError
   56         -
   57         -
    @app.null_in_non_sparse
   58         -
    def null_in_non_sparse(input: input::NullInNonSparseInput, ctx: Context) -> output::NullInNonSparseOutput:
   59         -
        raise NotImplementedError
   60         -
   61         -
    @app.primitive_int_header
   62         -
    def primitive_int_header(input: input::PrimitiveIntHeaderInput, ctx: Context) -> output::PrimitiveIntHeaderOutput:
   63         -
        raise NotImplementedError
   64         -
   65         -
    @app.primitive_int_op
   66         -
    def primitive_int_op(input: input::PrimitiveIntOpInput, ctx: Context) -> output::PrimitiveIntOpOutput:
   67         -
        raise NotImplementedError
   68         -
   69         -
    @app.query_precedence
   70         -
    def query_precedence(input: input::QueryPrecedenceInput, ctx: Context) -> output::QueryPrecedenceOutput:
   71         -
        raise NotImplementedError
   72         -
   73         -
    @app.status_response
   74         -
    def status_response(input: input::StatusResponseInput, ctx: Context) -> output::StatusResponseOutput:
   75         -
        raise NotImplementedError
   76         -
   77         -
    @app.string_payload
   78         -
    def string_payload(input: input::StringPayloadInput, ctx: Context) -> output::StringPayloadOutput:
   79         -
        raise NotImplementedError
   80         -
   81         -
    app.run()
   82         -
    ```
   83         -
   84         -
    Any of operations above can be written as well prepending the `async` keyword and
   85         -
    the Python application will automatically handle it and schedule it on the event loop for you.
   86         -
    """
   87         -
   88         -
    def case_insensitive_error_operation(self, func: typing.Union[typing.Callable[[rest_json_extras.input.CaseInsensitiveErrorOperationInput, Ctx], typing.Union[rest_json_extras.output.CaseInsensitiveErrorOperationOutput, typing.Awaitable[rest_json_extras.output.CaseInsensitiveErrorOperationOutput]]], typing.Callable[[rest_json_extras.input.CaseInsensitiveErrorOperationInput], typing.Union[rest_json_extras.output.CaseInsensitiveErrorOperationOutput, typing.Awaitable[rest_json_extras.output.CaseInsensitiveErrorOperationOutput]]]]) -> None:
   89         -
        """
   90         -
        Method to register `case_insensitive_error_operation` Python implementation inside the handlers map.
   91         -
        It can be used as a function decorator in Python.
   92         -
        """
   93         -
        ...
   94         -
   95         -
   96         -
    def context(self, context: Ctx) -> None:
   97         -
        """
   98         -
        Register a context object that will be shared between handlers.
   99         -
        """
  100         -
        ...
  101         -
  102         -
  103         -
    def empty_struct_with_content_on_wire_op(self, func: typing.Union[typing.Callable[[rest_json_extras.input.EmptyStructWithContentOnWireOpInput, Ctx], typing.Union[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput, typing.Awaitable[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput]]], typing.Callable[[rest_json_extras.input.EmptyStructWithContentOnWireOpInput], typing.Union[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput, typing.Awaitable[rest_json_extras.output.EmptyStructWithContentOnWireOpOutput]]]]) -> None:
  104         -
        """
  105         -
        Method to register `empty_struct_with_content_on_wire_op` Python implementation inside the handlers map.
  106         -
        It can be used as a function decorator in Python.
  107         -
        """
  108         -
        ...
  109         -
  110         -
  111         -
    def enum_query(self, func: typing.Union[typing.Callable[[rest_json_extras.input.EnumQueryInput, Ctx], typing.Union[rest_json_extras.output.EnumQueryOutput, typing.Awaitable[rest_json_extras.output.EnumQueryOutput]]], typing.Callable[[rest_json_extras.input.EnumQueryInput], typing.Union[rest_json_extras.output.EnumQueryOutput, typing.Awaitable[rest_json_extras.output.EnumQueryOutput]]]]) -> None:
  112         -
        """
  113         -
        Method to register `enum_query` Python implementation inside the handlers map.
  114         -
        It can be used as a function decorator in Python.
  115         -
        """
  116         -
        ...
  117         -
  118         -
  119         -
    def escaped_string_values(self, func: typing.Union[typing.Callable[[rest_json_extras.input.EscapedStringValuesInput, Ctx], typing.Union[rest_json_extras.output.EscapedStringValuesOutput, typing.Awaitable[rest_json_extras.output.EscapedStringValuesOutput]]], typing.Callable[[rest_json_extras.input.EscapedStringValuesInput], typing.Union[rest_json_extras.output.EscapedStringValuesOutput, typing.Awaitable[rest_json_extras.output.EscapedStringValuesOutput]]]]) -> None:
  120         -
        """
  121         -
        Method to register `escaped_string_values` Python implementation inside the handlers map.
  122         -
        It can be used as a function decorator in Python.
  123         -
        """
  124         -
        ...
  125         -
  126         -
  127         -
    def map_with_enum_key_op(self, func: typing.Union[typing.Callable[[rest_json_extras.input.MapWithEnumKeyOpInput, Ctx], typing.Union[rest_json_extras.output.MapWithEnumKeyOpOutput, typing.Awaitable[rest_json_extras.output.MapWithEnumKeyOpOutput]]], typing.Callable[[rest_json_extras.input.MapWithEnumKeyOpInput], typing.Union[rest_json_extras.output.MapWithEnumKeyOpOutput, typing.Awaitable[rest_json_extras.output.MapWithEnumKeyOpOutput]]]]) -> None:
  128         -
        """
  129         -
        Method to register `map_with_enum_key_op` Python implementation inside the handlers map.
  130         -
        It can be used as a function decorator in Python.
  131         -
        """
  132         -
        ...
  133         -
  134         -
  135         -
    def middleware(self, func: typing.Callable[[rest_json_extras.middleware.Request, typing.Callable[[rest_json_extras.middleware.Request], typing.Awaitable[rest_json_extras.middleware.Response]]], typing.Awaitable[rest_json_extras.middleware.Response]]) -> None:
  136         -
        """
  137         -
        Register a Python function to be executed inside a Tower middleware layer.
  138         -
        """
  139         -
        ...
  140         -
  141         -
  142         -
    def null_in_non_sparse(self, func: typing.Union[typing.Callable[[rest_json_extras.input.NullInNonSparseInput, Ctx], typing.Union[rest_json_extras.output.NullInNonSparseOutput, typing.Awaitable[rest_json_extras.output.NullInNonSparseOutput]]], typing.Callable[[rest_json_extras.input.NullInNonSparseInput], typing.Union[rest_json_extras.output.NullInNonSparseOutput, typing.Awaitable[rest_json_extras.output.NullInNonSparseOutput]]]]) -> None:
  143         -
        """
  144         -
        Method to register `null_in_non_sparse` Python implementation inside the handlers map.
  145         -
        It can be used as a function decorator in Python.
  146         -
        """
  147         -
        ...
  148         -
  149         -
  150         -
    def primitive_int_header(self, func: typing.Union[typing.Callable[[rest_json_extras.input.PrimitiveIntHeaderInput, Ctx], typing.Union[rest_json_extras.output.PrimitiveIntHeaderOutput, typing.Awaitable[rest_json_extras.output.PrimitiveIntHeaderOutput]]], typing.Callable[[rest_json_extras.input.PrimitiveIntHeaderInput], typing.Union[rest_json_extras.output.PrimitiveIntHeaderOutput, typing.Awaitable[rest_json_extras.output.PrimitiveIntHeaderOutput]]]]) -> None:
  151         -
        """
  152         -
        Method to register `primitive_int_header` Python implementation inside the handlers map.
  153         -
        It can be used as a function decorator in Python.
  154         -
        """
  155         -
        ...
  156         -
  157         -
  158         -
    def primitive_int_op(self, func: typing.Union[typing.Callable[[rest_json_extras.input.PrimitiveIntOpInput, Ctx], typing.Union[rest_json_extras.output.PrimitiveIntOpOutput, typing.Awaitable[rest_json_extras.output.PrimitiveIntOpOutput]]], typing.Callable[[rest_json_extras.input.PrimitiveIntOpInput], typing.Union[rest_json_extras.output.PrimitiveIntOpOutput, typing.Awaitable[rest_json_extras.output.PrimitiveIntOpOutput]]]]) -> None:
  159         -
        """
  160         -
        Method to register `primitive_int_op` Python implementation inside the handlers map.
  161         -
        It can be used as a function decorator in Python.
  162         -
        """
  163         -
        ...
  164         -
  165         -
  166         -
    def query_precedence(self, func: typing.Union[typing.Callable[[rest_json_extras.input.QueryPrecedenceInput, Ctx], typing.Union[rest_json_extras.output.QueryPrecedenceOutput, typing.Awaitable[rest_json_extras.output.QueryPrecedenceOutput]]], typing.Callable[[rest_json_extras.input.QueryPrecedenceInput], typing.Union[rest_json_extras.output.QueryPrecedenceOutput, typing.Awaitable[rest_json_extras.output.QueryPrecedenceOutput]]]]) -> None:
  167         -
        """
  168         -
        Method to register `query_precedence` Python implementation inside the handlers map.
  169         -
        It can be used as a function decorator in Python.
  170         -
        """
  171         -
        ...
  172         -
  173         -
  174         -
    def run(self, address: typing.Optional[str] = ..., port: typing.Optional[int] = ..., backlog: typing.Optional[int] = ..., workers: typing.Optional[int] = ..., tls: typing.Optional[rest_json_extras.tls.TlsConfig] = ...) -> None:
  175         -
        """
  176         -
        Main entrypoint: start the server on multiple workers.
  177         -
        """
  178         -
        ...
  179         -
  180         -
  181         -
    def run_lambda(self) -> None:
  182         -
        """
  183         -
        Lambda entrypoint: start the server on Lambda.
  184         -
        """
  185         -
        ...
  186         -
  187         -
  188         -
    def start_worker(self) -> None:
  189         -
        """
  190         -
        Build the service and start a single worker.
  191         -
        """
  192         -
        ...
  193         -
  194         -
  195         -
    def status_response(self, func: typing.Union[typing.Callable[[rest_json_extras.input.StatusResponseInput, Ctx], typing.Union[rest_json_extras.output.StatusResponseOutput, typing.Awaitable[rest_json_extras.output.StatusResponseOutput]]], typing.Callable[[rest_json_extras.input.StatusResponseInput], typing.Union[rest_json_extras.output.StatusResponseOutput, typing.Awaitable[rest_json_extras.output.StatusResponseOutput]]]]) -> None:
  196         -
        """
  197         -
        Method to register `status_response` Python implementation inside the handlers map.
  198         -
        It can be used as a function decorator in Python.
  199         -
        """
  200         -
        ...
  201         -
  202         -
  203         -
    def string_payload(self, func: typing.Union[typing.Callable[[rest_json_extras.input.StringPayloadInput, Ctx], typing.Union[rest_json_extras.output.StringPayloadOutput, typing.Awaitable[rest_json_extras.output.StringPayloadOutput]]], typing.Callable[[rest_json_extras.input.StringPayloadInput], typing.Union[rest_json_extras.output.StringPayloadOutput, typing.Awaitable[rest_json_extras.output.StringPayloadOutput]]]]) -> None:
  204         -
        """
  205         -
        Method to register `string_payload` Python implementation inside the handlers map.
  206         -
        It can be used as a function decorator in Python.
  207         -
        """
  208         -
        ...
  209         -
  210         -
  211         -
    def __init__(self) -> None:
  212         -
        ...
  213         -
  214         -
  215         -
CODEGEN_VERSION: str = ...

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/aws_lambda/__init__.pyi

@@ -1,0 +143,0 @@
    1         -
import typing
    2         -
    3         -
class ClientApplication:
    4         -
    """
    5         -
    AWS Mobile SDK client fields.
    6         -
    """
    7         -
    8         -
    app_package_name: str
    9         -
    """
   10         -
    The package name for the mobile application invoking the function
   11         -
    """
   12         -
   13         -
    app_title: str
   14         -
    """
   15         -
    The app title for the mobile app as registered with AWS' mobile services.
   16         -
    """
   17         -
   18         -
    app_version_code: str
   19         -
    """
   20         -
    The app version code.
   21         -
    """
   22         -
   23         -
    app_version_name: str
   24         -
    """
   25         -
    The version name of the application as registered with AWS' mobile services.
   26         -
    """
   27         -
   28         -
    installation_id: str
   29         -
    """
   30         -
    The mobile app installation id
   31         -
    """
   32         -
   33         -
class ClientContext:
   34         -
    """
   35         -
    Client context sent by the AWS Mobile SDK.
   36         -
    """
   37         -
   38         -
    client: ClientApplication
   39         -
    """
   40         -
    Information about the mobile application invoking the function.
   41         -
    """
   42         -
   43         -
    custom: typing.Dict[str, str]
   44         -
    """
   45         -
    Custom properties attached to the mobile event context.
   46         -
    """
   47         -
   48         -
    environment: typing.Dict[str, str]
   49         -
    """
   50         -
    Environment settings from the mobile client.
   51         -
    """
   52         -
   53         -
class CognitoIdentity:
   54         -
    """
   55         -
    Cognito identity information sent with the event
   56         -
    """
   57         -
   58         -
    identity_id: str
   59         -
    """
   60         -
    The unique identity id for the Cognito credentials invoking the function.
   61         -
    """
   62         -
   63         -
    identity_pool_id: str
   64         -
    """
   65         -
    The identity pool id the caller is "registered" with.
   66         -
    """
   67         -
   68         -
class Config:
   69         -
    """
   70         -
    Configuration derived from environment variables.
   71         -
    """
   72         -
   73         -
    function_name: str
   74         -
    """
   75         -
    The name of the function.
   76         -
    """
   77         -
   78         -
    log_group: str
   79         -
    """
   80         -
    The name of the Amazon CloudWatch Logs group for the function.
   81         -
    """
   82         -
   83         -
    log_stream: str
   84         -
    """
   85         -
    The name of the Amazon CloudWatch Logs stream for the function.
   86         -
    """
   87         -
   88         -
    memory: int
   89         -
    """
   90         -
    The amount of memory available to the function in MB.
   91         -
    """
   92         -
   93         -
    version: str
   94         -
    """
   95         -
    The version of the function being executed.
   96         -
    """
   97         -
   98         -
class LambdaContext:
   99         -
    """
  100         -
    The Lambda function execution context. The values in this struct
  101         -
    are populated using the [Lambda environment variables](https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html)
  102         -
    and the headers returned by the poll request to the Runtime APIs.
  103         -
    """
  104         -
  105         -
    client_context: typing.Optional[ClientContext]
  106         -
    """
  107         -
    The client context object sent by the AWS mobile SDK. This field is
  108         -
    empty unless the function is invoked using an AWS mobile SDK.
  109         -
    """
  110         -
  111         -
    deadline: int
  112         -
    """
  113         -
    The execution deadline for the current invocation in milliseconds.
  114         -
    """
  115         -
  116         -
    env_config: Config
  117         -
    """
  118         -
    Lambda function configuration from the local environment variables.
  119         -
    Includes information such as the function name, memory allocation,
  120         -
    version, and log streams.
  121         -
    """
  122         -
  123         -
    identity: typing.Optional[CognitoIdentity]
  124         -
    """
  125         -
    The Cognito identity that invoked the function. This field is empty
  126         -
    unless the invocation request to the Lambda APIs was made using AWS
  127         -
    credentials issues by Amazon Cognito Identity Pools.
  128         -
    """
  129         -
  130         -
    invoked_function_arn: str
  131         -
    """
  132         -
    The ARN of the Lambda function being invoked.
  133         -
    """
  134         -
  135         -
    request_id: str
  136         -
    """
  137         -
    The AWS request ID generated by the Lambda service.
  138         -
    """
  139         -
  140         -
    xray_trace_id: typing.Optional[str]
  141         -
    """
  142         -
    The X-Ray trace ID for the current invocation.
  143         -
    """

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/error/__init__.pyi

@@ -1,0 +40,0 @@
    1         -
import rest_json_extras.model
    2         -
import typing
    3         -
    4         -
class CaseInsensitiveError(Exception):
    5         -
    message: typing.Optional[str]
    6         -
    7         -
    def __init__(self, message: typing.Optional[str] = ...) -> None:
    8         -
        ...
    9         -
   10         -
   11         -
class ExtraError(Exception):
   12         -
    def __init__(self) -> None:
   13         -
        ...
   14         -
   15         -
   16         -
class InternalServerError(Exception):
   17         -
    message: str
   18         -
   19         -
    def __init__(self, message: str) -> None:
   20         -
        ...
   21         -
   22         -
   23         -
class ValidationException(Exception):
   24         -
    """
   25         -
    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.
   26         -
    """
   27         -
   28         -
    field_list: typing.Optional[typing.List[rest_json_extras.model.ValidationExceptionField]]
   29         -
    """
   30         -
    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.
   31         -
    """
   32         -
   33         -
    message: str
   34         -
    """
   35         -
    A summary of the validation failure.
   36         -
    """
   37         -
   38         -
    def __init__(self, message: str, field_list: typing.Optional[typing.List[rest_json_extras.model.ValidationExceptionField]] = ...) -> None:
   39         -
        ...
   40         -

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/input/__init__.pyi

@@ -1,0 +73,0 @@
    1         -
import rest_json_extras.model
    2         -
import typing
    3         -
    4         -
class CaseInsensitiveErrorOperationInput:
    5         -
    def __init__(self) -> None:
    6         -
        ...
    7         -
    8         -
    9         -
class EmptyStructWithContentOnWireOpInput:
   10         -
    def __init__(self) -> None:
   11         -
        ...
   12         -
   13         -
   14         -
class EnumQueryInput:
   15         -
    enum: rest_json_extras.model.StringEnum
   16         -
   17         -
    def __init__(self, r#enum: rest_json_extras.model.StringEnum) -> None:
   18         -
        ...
   19         -
   20         -
   21         -
class EscapedStringValuesInput:
   22         -
    enum: typing.Optional[rest_json_extras.model.EnumWithEscapedChars]
   23         -
   24         -
    some_string: typing.Optional[str]
   25         -
   26         -
    def __init__(self, r#enum: typing.Optional[rest_json_extras.model.EnumWithEscapedChars] = ..., some_string: typing.Optional[str] = ...) -> None:
   27         -
        ...
   28         -
   29         -
   30         -
class MapWithEnumKeyOpInput:
   31         -
    map: typing.Optional[typing.Dict[rest_json_extras.model.StringEnum, str]]
   32         -
   33         -
    def __init__(self, map: typing.Optional[typing.Dict[rest_json_extras.model.StringEnum, str]] = ...) -> None:
   34         -
        ...
   35         -
   36         -
   37         -
class NullInNonSparseInput:
   38         -
    def __init__(self) -> None:
   39         -
        ...
   40         -
   41         -
   42         -
class PrimitiveIntHeaderInput:
   43         -
    def __init__(self) -> None:
   44         -
        ...
   45         -
   46         -
   47         -
class PrimitiveIntOpInput:
   48         -
    value: int
   49         -
   50         -
    def __init__(self, value: int) -> None:
   51         -
        ...
   52         -
   53         -
   54         -
class QueryPrecedenceInput:
   55         -
    baz: typing.Optional[typing.Dict[str, str]]
   56         -
   57         -
    foo: typing.Optional[str]
   58         -
   59         -
    def __init__(self, foo: typing.Optional[str] = ..., baz: typing.Optional[typing.Dict[str, str]] = ...) -> None:
   60         -
        ...
   61         -
   62         -
   63         -
class StatusResponseInput:
   64         -
    def __init__(self) -> None:
   65         -
        ...
   66         -
   67         -
   68         -
class StringPayloadInput:
   69         -
    payload: typing.Optional[str]
   70         -
   71         -
    def __init__(self, payload: typing.Optional[str] = ...) -> None:
   72         -
        ...
   73         -

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/logging/__init__.pyi

@@ -1,0 +26,0 @@
    1         -
import pathlib
    2         -
import typing
    3         -
    4         -
class TracingHandler:
    5         -
    """
    6         -
    Modifies the Python `logging` module to deliver its log messages using [tracing::Subscriber] events.
    7         -
    8         -
    To achieve this goal, the following changes are made to the module:
    9         -
    - A new builtin function `logging.py_tracing_event` transcodes `logging.LogRecord`s to `tracing::Event`s. This function
   10         -
      is not exported in `logging.__all__`, as it is not intended to be called directly.
   11         -
    - A new class `logging.TracingHandler` provides a `logging.Handler` that delivers all records to `python_tracing`.
   12         -
    """
   13         -
   14         -
    def handler(self) -> typing.Any:
   15         -
        ...
   16         -
   17         -
   18         -
    def __init__(self, level: typing.Optional[int] = ..., logfile: typing.Optional[pathlib.Path] = ..., format: typing.Optional[typing.Literal['compact', 'pretty', 'json']] = ...) -> None:
   19         -
        ...
   20         -
   21         -
   22         -
def py_tracing_event() -> None:
   23         -
    """
   24         -
    Consumes a Python `logging.LogRecord` and emits a Rust [tracing::Event] instead.
   25         -
    """
   26         -
    ...

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/middleware/__init__.pyi

@@ -1,0 +78,0 @@
    1         -
import typing
    2         -
    3         -
class MiddlewareException(Exception):
    4         -
    """
    5         -
    Exception that can be thrown from a Python middleware.
    6         -
    7         -
    It allows to specify a message and HTTP status code and implementing protocol specific capabilities
    8         -
    to build a [aws_smithy_http_server::response::Response] from it.
    9         -
    """
   10         -
   11         -
    message: str
   12         -
   13         -
    status_code: int
   14         -
   15         -
    def __init__(self, message: str, status_code: typing.Optional[int] = ...) -> None:
   16         -
        ...
   17         -
   18         -
   19         -
class Request:
   20         -
    """
   21         -
    Python-compatible [Request] object.
   22         -
    """
   23         -
   24         -
    body: typing.Awaitable[bytes]
   25         -
    """
   26         -
    Return the HTTP body of this request.
   27         -
    Note that this is a costly operation because the whole request body is cloned.
   28         -
    """
   29         -
   30         -
    headers: typing.MutableMapping[str, str]
   31         -
    """
   32         -
    Return the HTTP headers of this request.
   33         -
    """
   34         -
   35         -
    method: str
   36         -
    """
   37         -
    Return the HTTP method of this request.
   38         -
    """
   39         -
   40         -
    uri: str
   41         -
    """
   42         -
    Return the URI of this request.
   43         -
    """
   44         -
   45         -
    version: str
   46         -
    """
   47         -
    Return the HTTP version of this request.
   48         -
    """
   49         -
   50         -
class Response:
   51         -
    """
   52         -
    Python-compatible [Response] object.
   53         -
    """
   54         -
   55         -
    body: typing.Awaitable[bytes]
   56         -
    """
   57         -
    Return the HTTP body of this response.
   58         -
    Note that this is a costly operation because the whole response body is cloned.
   59         -
    """
   60         -
   61         -
    headers: typing.MutableMapping[str, str]
   62         -
    """
   63         -
    Return the HTTP headers of this response.
   64         -
    """
   65         -
   66         -
    status: int
   67         -
    """
   68         -
    Return the HTTP status of this response.
   69         -
    """
   70         -
   71         -
    version: str
   72         -
    """
   73         -
    Return the HTTP version of this response.
   74         -
    """
   75         -
   76         -
    def __init__(self, status: int, headers: typing.Optional[typing.Dict[str, str]] = ..., body: typing.Optional[bytes] = ...) -> None:
   77         -
        ...
   78         -

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/model/__init__.pyi

@@ -1,0 +64,0 @@
    1         -
import typing
    2         -
    3         -
class EmptyStruct:
    4         -
    def __init__(self) -> None:
    5         -
        ...
    6         -
    7         -
    8         -
class EnumWithEscapedChars:
    9         -
    HasQuotes: EnumWithEscapedChars
   10         -
   11         -
    Normal: EnumWithEscapedChars
   12         -
   13         -
    name: typing.Any
   14         -
   15         -
    value: typing.Any
   16         -
   17         -
class SingleElementUnion:
   18         -
    @staticmethod
   19         -
    def a(data: str) -> SingleElementUnion:
   20         -
        """
   21         -
        Creates a new union instance of [`A`](crate::model::SingleElementUnion::A)
   22         -
        """
   23         -
        ...
   24         -
   25         -
   26         -
    def as_a(self) -> str:
   27         -
        """
   28         -
        Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
   29         -
        """
   30         -
        ...
   31         -
   32         -
   33         -
    def is_a(self) -> bool:
   34         -
        """
   35         -
        Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
   36         -
        """
   37         -
        ...
   38         -
   39         -
   40         -
class StringEnum:
   41         -
    V: StringEnum
   42         -
   43         -
    name: typing.Any
   44         -
   45         -
    value: typing.Any
   46         -
   47         -
class ValidationExceptionField:
   48         -
    """
   49         -
    Describes one specific validation failure for an input member.
   50         -
    """
   51         -
   52         -
    message: str
   53         -
    """
   54         -
    A detailed description of the validation failure.
   55         -
    """
   56         -
   57         -
    path: str
   58         -
    """
   59         -
    A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
   60         -
    """
   61         -
   62         -
    def __init__(self, path: str, message: str) -> None:
   63         -
        ...
   64         -

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/output/__init__.pyi

@@ -1,0 +79,0 @@
    1         -
import rest_json_extras.model
    2         -
import typing
    3         -
    4         -
class CaseInsensitiveErrorOperationOutput:
    5         -
    def __init__(self) -> None:
    6         -
        ...
    7         -
    8         -
    9         -
class EmptyStructWithContentOnWireOpOutput:
   10         -
    empty: typing.Optional[rest_json_extras.model.EmptyStruct]
   11         -
   12         -
    def __init__(self, empty: typing.Optional[rest_json_extras.model.EmptyStruct] = ...) -> None:
   13         -
        ...
   14         -
   15         -
   16         -
class EnumQueryOutput:
   17         -
    def __init__(self) -> None:
   18         -
        ...
   19         -
   20         -
   21         -
class EscapedStringValuesOutput:
   22         -
    enum: typing.Optional[rest_json_extras.model.EnumWithEscapedChars]
   23         -
   24         -
    some_string: typing.Optional[str]
   25         -
   26         -
    def __init__(self, r#enum: typing.Optional[rest_json_extras.model.EnumWithEscapedChars] = ..., some_string: typing.Optional[str] = ...) -> None:
   27         -
        ...
   28         -
   29         -
   30         -
class MapWithEnumKeyOpOutput:
   31         -
    map: typing.Optional[typing.Dict[rest_json_extras.model.StringEnum, str]]
   32         -
   33         -
    def __init__(self, map: typing.Optional[typing.Dict[rest_json_extras.model.StringEnum, str]] = ...) -> None:
   34         -
        ...
   35         -
   36         -
   37         -
class NullInNonSparseOutput:
   38         -
    list: typing.Optional[typing.List[str]]
   39         -
   40         -
    map: typing.Optional[typing.Dict[str, str]]
   41         -
   42         -
    union: typing.Optional[rest_json_extras.model.SingleElementUnion]
   43         -
   44         -
    def __init__(self, list: typing.Optional[typing.List[str]] = ..., map: typing.Optional[typing.Dict[str, str]] = ..., union: typing.Optional[rest_json_extras.model.SingleElementUnion] = ...) -> None:
   45         -
        ...
   46         -
   47         -
   48         -
class PrimitiveIntHeaderOutput:
   49         -
    field: int
   50         -
   51         -
    def __init__(self, field: int) -> None:
   52         -
        ...
   53         -
   54         -
   55         -
class PrimitiveIntOpOutput:
   56         -
    value: int
   57         -
   58         -
    def __init__(self, value: int) -> None:
   59         -
        ...
   60         -
   61         -
   62         -
class QueryPrecedenceOutput:
   63         -
    def __init__(self) -> None:
   64         -
        ...
   65         -
   66         -
   67         -
class StatusResponseOutput:
   68         -
    field: int
   69         -
   70         -
    def __init__(self, field: int) -> None:
   71         -
        ...
   72         -
   73         -
   74         -
class StringPayloadOutput:
   75         -
    payload: typing.Optional[str]
   76         -
   77         -
    def __init__(self, payload: typing.Optional[str] = ...) -> None:
   78         -
        ...
   79         -

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/python/rest_json_extras/socket/__init__.pyi

@@ -1,0 +27,0 @@
    1         -
import typing
    2         -
    3         -
class PySocket:
    4         -
    """
    5         -
    Socket implementation that can be shared between multiple Python processes.
    6         -
    7         -
    Python cannot handle true multi-threaded applications due to the [GIL],
    8         -
    often resulting in reduced performance and only one core used by the application.
    9         -
    To work around this, Python web applications usually create a socket with
   10         -
    SO_REUSEADDR and SO_REUSEPORT enabled that can be shared between multiple
   11         -
    Python processes, allowing you to maximize performance and use all available
   12         -
    computing capacity of the host.
   13         -
   14         -
    [GIL]: https://wiki.python.org/moin/GlobalInterpreterLock
   15         -
    """
   16         -
   17         -
    def try_clone(self) -> PySocket:
   18         -
        """
   19         -
        Clone the inner socket allowing it to be shared between multiple
   20         -
        Python processes.
   21         -
        """
   22         -
        ...
   23         -
   24         -
   25         -
    def __init__(self, address: str, port: int, backlog: typing.Optional[int] = ...) -> None:
   26         -
        ...
   27         -