Server Test Python

[package]

name = "rest_json_extras"

version = "0.0.1"

authors = ["protocoltest@example.com"]

description = "test"

edition = "2021"

[package.metadata.smithy]

codegen-version = "ci"

protocol = "aws.protocols#restJson1"

[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.form_urlencoded]

version = "1"

[dependencies.futures-util]

version = "0.3"

[dependencies.http]

version = "0.2.9"

[dependencies.hyper]

version = "0.14.26"

[dependencies.mime]

version = "0.3"

[dependencies.nom]

version = "7"

[dependencies.parking_lot]

version = "0.12"

[dependencies.percent-encoding]

version = "2.0.0"

[dependencies.pin-project-lite]

version = "0.2"

[dependencies.pyo3]

version = "0.20"

[dependencies.pyo3-asyncio]

version = "0.20"

features = ["attributes", "tokio-runtime"]

[dependencies.tower]

version = "0.4"

[dependencies.tracing]

version = "0.1"

[dev-dependencies.tokio]

version = "1.23.1"

[features]

rt-tokio = ["aws-smithy-types/rt-tokio"]

extension-module = ["pyo3/extension-module"]

default = ["rt-tokio", "request-id", "extension-module"]

[lib]

name = "rest_json_extras"

crate-type = ["cdylib"]

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

    """

    message: str

    status_code: int

    def __init__(self, message: str, status_code: typing.Optional[int] = ...) -> None:

        ...

            path: ::std::string::String,

        ) -> crate::model::ValidationExceptionField {

            match self {

                ConstraintViolation::Enum(inner) => {

                    inner.as_validation_exception_field(path + "/enum")

                }

            }

        }

    }

    impl ::std::convert::From<ConstraintViolation>

    {

        fn from(constraint_violation: ConstraintViolation) -> Self {

            let first_validation_exception_field =

                constraint_violation.as_validation_exception_field("".to_owned());

            let validation_exception = crate::error::ValidationException {

                message: format!(

                    "1 validation error detected. {}",

                    &first_validation_exception_field.message

                ),

                field_list: Some(vec![first_validation_exception_field]),

            path: ::std::string::String,

        ) -> crate::model::ValidationExceptionField {

            match self {

                ConstraintViolation::Map(inner) => {

                    inner.as_validation_exception_field(path + "/map")

                }

            }

        }

    }

    impl ::std::convert::From<ConstraintViolation>

    {

        fn from(constraint_violation: ConstraintViolation) -> Self {

            let first_validation_exception_field =

                constraint_violation.as_validation_exception_field("".to_owned());

            let validation_exception = crate::error::ValidationException {

                message: format!(

                    "1 validation error detected. {}",

                    &first_validation_exception_field.message

                ),

                field_list: Some(vec![first_validation_exception_field]),

                    ),

                    path: path + "/enum",

                },

                ConstraintViolation::Enum(inner) => {

                    inner.as_validation_exception_field(path + "/enum")

                }

            }

        }

    }

    impl ::std::convert::From<ConstraintViolation>

    {

        fn from(constraint_violation: ConstraintViolation) -> Self {

            let first_validation_exception_field =

                constraint_violation.as_validation_exception_field("".to_owned());

            let validation_exception = crate::error::ValidationException {

                message: format!(

                    "1 validation error detected. {}",

                    &first_validation_exception_field.message

                ),

                field_list: Some(vec![first_validation_exception_field]),

//!

//! # let app = RestJsonExtras::builder(

//! #     RestJsonExtrasConfig::builder()

//! #         .build()

//! # ).build_unchecked();

//! let server = app.into_make_service();

//! let bind: SocketAddr = "127.0.0.1:6969".parse()

//!     .expect("unable to parse the server bind address and port");

//! ::hyper::Server::bind(&bind).serve(server).await.unwrap();

//! # }

//! ```

//!

//! ### Running on Lambda

//!

//! ```rust,ignore

//! use rest_json_extras::server::routing::LambdaHandler;

//! use rest_json_extras::RestJsonExtras;

//!

//! # async fn dummy() {

//! # let app = RestJsonExtras::builder(

//! #     RestJsonExtrasConfig::builder()

//! #         .build()

//! # ).build_unchecked();

//! let handler = LambdaHandler::new(app);

//! lambda_http::run(handler).await.unwrap();

//! # }

//! ```

//!

//! # Building the RestJsonExtras

//!

//! To construct [`RestJsonExtras`] we use [`RestJsonExtrasBuilder`] returned by [`RestJsonExtras::builder`].

//!

//! ## Plugins

//!

//! The [`RestJsonExtras::builder`] method, returning [`RestJsonExtrasBuilder`],

//! accepts a config object on which plugins can be registered.

//! Plugins allow you to build middleware which is aware of the operation it is being applied to.

//!

//! ```rust,no_run

//! # use rest_json_extras::server::plugin::IdentityPlugin as LoggingPlugin;

//! # use rest_json_extras::server::plugin::IdentityPlugin as MetricsPlugin;

//! # use ::hyper::Body;

//! use rest_json_extras::server::plugin::HttpPlugins;

//! use rest_json_extras::{RestJsonExtras, RestJsonExtrasConfig, RestJsonExtrasBuilder};

//!

//! let http_plugins = HttpPlugins::new()

//!         .push(LoggingPlugin)

//!         .push(MetricsPlugin);

//! let config = RestJsonExtrasConfig::builder().build();

//! ```

//!

//! Check out [`crate::server::plugin`] to learn more about plugins.

//!

//! ## Handlers

//!

//! [`RestJsonExtrasBuilder`] provides a setter method for each operation in your Smithy model. The setter methods expect an async function as input, matching the signature for the corresponding operation in your Smithy model.

//! We call these async functions **handlers**. This is where your application business logic lives.

//!

//! Every handler must take an `Input`, and optional [`extractor arguments`](crate::server::request), while returning:

//!     todo!()

//! }

//!

//! async fn string_payload(input: input::StringPayloadInput) -> Result<output::StringPayloadOutput, error::StringPayloadError> {

//!     todo!()

//! }

//!

//! ```

//!

//! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve

//! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html

//! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html

//! [operations]: https://smithy.io/2.0/spec/service-types.html#operation

//! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html

pub use crate::service::{

    MissingOperationsError, RestJsonExtras, RestJsonExtrasBuilder, RestJsonExtrasConfig,

    RestJsonExtrasConfigBuilder,

};

/// Contains the types that are re-exported from the `aws-smithy-http-server` crate.

pub mod server {

    // Re-export all types from the `aws-smithy-http-server` crate.

}

/// Crate version number.

pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");

/// Constrained types for constrained shapes.

mod constrained;

/// All error types that operations can return. Documentation on these types is copied from the model.

pub mod error;

/// Input structures for operations. Documentation on these types is copied from the model.

pub mod input;

/// Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.

pub mod model;

/// All operations that this crate can perform.

pub mod operation;

/// A collection of types representing each operation defined in the service closure.

///

/// [zero-sized types](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) (ZSTs) to

/// operation specific information to the [`Layer`](::tower::Layer) being applied.

pub mod operation_shape;

/// Output structures for operations. Documentation on these types is copied from the model.

pub mod output;

/// Export PyO3 symbols in the shared library

pub mod python_module_export;

/// Operation adapters that delegate to Python handlers.

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`HttpQueryParamsOnlyOperationInput`](crate::input::HttpQueryParamsOnlyOperationInput) using modelled bindings.

    pub struct HttpQueryParamsOnlyOperationInputFuture {

    }

}

impl std::future::Future for HttpQueryParamsOnlyOperationInputFuture {

    type Output = Result<

        crate::input::HttpQueryParamsOnlyOperationInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::HttpQueryParamsOnlyOperationInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = HttpQueryParamsOnlyOperationInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_http_query_params_only_operation::de_http_query_params_only_operation_http_request(request)

                            .await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        HttpQueryParamsOnlyOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::HttpQueryParamsOnlyOperationOutput

{

        match crate::protocol_serde::shape_http_query_params_only_operation::ser_http_query_params_only_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                        }

                    }

    }

}

impl

    > for crate::error::HttpQueryParamsOnlyOperationError

{

        match crate::protocol_serde::shape_http_query_params_only_operation::ser_http_query_params_only_operation_http_error(&self) {

            Ok(mut response) => {

                response

            },

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput) using modelled bindings.

    pub struct QueryPrecedenceInputFuture {

    }

}

impl std::future::Future for QueryPrecedenceInputFuture {

    type Output = Result<

        crate::input::QueryPrecedenceInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::QueryPrecedenceInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = QueryPrecedenceInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)

                .await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        QueryPrecedenceInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::QueryPrecedenceOutput

{

        match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(

            self,

        ) {

            Ok(response) => response,

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

impl

    > for crate::error::QueryPrecedenceError

{

        match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_error(&self)

        {

            Ok(mut response) => {

                response.extensions_mut().insert(

                );

                response

            }

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`EmptyStructWithContentOnWireOpInput`](crate::input::EmptyStructWithContentOnWireOpInput) using modelled bindings.

    pub struct EmptyStructWithContentOnWireOpInputFuture {

    }

}

impl std::future::Future for EmptyStructWithContentOnWireOpInputFuture {

    type Output = Result<

        crate::input::EmptyStructWithContentOnWireOpInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::EmptyStructWithContentOnWireOpInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = EmptyStructWithContentOnWireOpInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_http_request(request)

                            .await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        EmptyStructWithContentOnWireOpInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::EmptyStructWithContentOnWireOpOutput

{

        match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                        }

                    }

    }

}

impl

    > for crate::error::EmptyStructWithContentOnWireOpError

{

        match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_error(&self) {

            Ok(mut response) => {

                response

            },

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`CaseInsensitiveErrorOperationInput`](crate::input::CaseInsensitiveErrorOperationInput) using modelled bindings.

    pub struct CaseInsensitiveErrorOperationInputFuture {

    }

}

impl std::future::Future for CaseInsensitiveErrorOperationInputFuture {

    type Output = Result<

        crate::input::CaseInsensitiveErrorOperationInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::CaseInsensitiveErrorOperationInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = CaseInsensitiveErrorOperationInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_http_request(request)

                            .await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        CaseInsensitiveErrorOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::CaseInsensitiveErrorOperationOutput

{

        match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                        }

                    }

    }

}

impl

    > for crate::error::CaseInsensitiveErrorOperationError

{

        match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_error(&self) {

            Ok(mut response) => {

                response

            },

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`NullInNonSparseInput`](crate::input::NullInNonSparseInput) using modelled bindings.

    pub struct NullInNonSparseInputFuture {

    }

}

impl std::future::Future for NullInNonSparseInputFuture {

    type Output = Result<

        crate::input::NullInNonSparseInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::NullInNonSparseInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = NullInNonSparseInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_null_in_non_sparse::de_null_in_non_sparse_http_request(

                request,

            )

            .await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        NullInNonSparseInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::NullInNonSparseOutput

{

        match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_response(

            self,

        ) {

            Ok(response) => response,

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

impl

    > for crate::error::NullInNonSparseError

{

        match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_error(

            &self,

        ) {

            Ok(mut response) => {

                response.extensions_mut().insert(

                );

                response

            }

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`EscapedStringValuesInput`](crate::input::EscapedStringValuesInput) using modelled bindings.

    pub struct EscapedStringValuesInputFuture {

    }

}

impl std::future::Future for EscapedStringValuesInputFuture {

    type Output = Result<

        crate::input::EscapedStringValuesInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::EscapedStringValuesInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = EscapedStringValuesInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {