Server Test Python

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

/// Python handler for operation `MalformedUniqueItems`.

pub(crate) async fn malformed_unique_items(

    input: crate::input::MalformedUniqueItemsInput,

    handler: ::aws_smithy_http_server_python::PyHandler,

) -> std::result::Result<

    crate::output::MalformedUniqueItemsOutput,

    crate::error::MalformedUniqueItemsError,

> {

    // Async block used to run the handler and catch any Python error.

    let result = if handler.is_coroutine {

        ::tracing::trace!(

            name = "malformed_unique_items",

            "executing python handler coroutine"

    fn handlers(

        &mut self,

    ) -> &mut ::std::collections::HashMap<String, ::aws_smithy_http_server_python::PyHandler> {

        &mut self.handlers

    }

    fn build_service(

        &mut self,

        event_loop: &::pyo3::PyAny,

    ) -> ::pyo3::PyResult<

        ::tower::util::BoxCloneService<

            std::convert::Infallible,

        >,

    > {

        let builder = crate::service::UniqueItemsService::builder_without_plugins();

        let malformed_unique_items_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);

        let handler = self

            .handlers

            .get("malformed_unique_items")

            .expect("Python handler for operation `malformed_unique_items` not found")

            .clone();

        let builder = builder.malformed_unique_items(move |input, state| {

            ::pyo3_asyncio::tokio::scope(

                malformed_unique_items_locals.clone(),

                crate::python_operation_adaptor::malformed_unique_items(

                    input,

                    state,

                    handler.clone(),

                ),

            )

        });

        let mut service = ::tower::util::BoxCloneService::new(builder.build().expect("one or more operations do not have a registered handler; this is a bug in the Python code generator, please file a bug report under https://github.com/smithy-lang/smithy-rs/issues"));

        {

            use ::tower::Layer;

            ::tracing::trace!("adding middlewares to rust python router");

            let mut middlewares = self.middlewares.clone();

            // Reverse the middlewares, so they run with same order as they defined

            middlewares.reverse();

            for handler in middlewares {

                ::tracing::trace!(name = &handler.name, "adding python middleware");

                let locals = ::pyo3_asyncio::TaskLocals::new(event_loop);

                let layer = ::aws_smithy_http_server_python::PyMiddlewareLayer::<

                >::new(handler, locals);

                service = ::tower::util::BoxCloneService::new(layer.layer(service));

            }

        }

        Ok(service)

    }

}

#[::pyo3::pymethods]

impl App {

    /// Create a new [App].

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

/// The service builder for [`UniqueItemsService`].

///

/// Constructed via [`UniqueItemsService::builder`].

pub struct UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {

    layer: L,

    http_plugin: HttpPl,

    model_plugin: ModelPl,

}

impl<Body, L, HttpPl, ModelPl> UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {

    /// Sets the [`MalformedUniqueItems`](crate::operation_shape::MalformedUniqueItems) operation.

    ///

    ///

    /// # Example

    ///

    /// ```no_run

    /// use unique_items::{UniqueItemsService, UniqueItemsServiceConfig};

    ///

    /// use unique_items::{input, output, error};

    ///

    /// async fn handler(input: input::MalformedUniqueItemsInput) -> Result<output::MalformedUniqueItemsOutput, error::MalformedUniqueItemsError> {

    ///     todo!()

    /// }

    ///

    /// let config = UniqueItemsServiceConfig::builder().build();

    /// let app = UniqueItemsService::builder(config)

    ///     .malformed_unique_items(handler)

    ///     /* Set other handlers */

    ///     .build()

    ///     .unwrap();

    /// ```

    ///

                    pub fn malformed_unique_items<HandlerType, HandlerExtractors, UpgradeExtractors>(self, handler: HandlerType) -> Self

                    where

                            UniqueItemsService<L>,

                            crate::operation_shape::MalformedUniqueItems,

                        >,

                            UniqueItemsService<L>,

                            crate::operation_shape::MalformedUniqueItems,

                            ModelPl::Output

                        >,

                            UniqueItemsService<L>,

                            crate::operation_shape::MalformedUniqueItems,

                            <

                                    UniqueItemsService<L>,

                                    crate::operation_shape::MalformedUniqueItems,

                                    ModelPl::Output

                                >

                            >::Output

                        >,

                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,

                    {

        let svc = crate::operation_shape::MalformedUniqueItems::from_handler(handler);

        let svc = self.model_plugin.apply(svc);

                .apply(svc);

        let svc = self.http_plugin.apply(svc);

        self.malformed_unique_items_custom(svc)

    }

    /// Sets the [`MalformedUniqueItems`](crate::operation_shape::MalformedUniqueItems) operation.

    ///

    ///

    /// # Example

    ///

    /// ```no_run

    /// use unique_items::{UniqueItemsService, UniqueItemsServiceConfig};

    ///

    /// use unique_items::{input, output, error};

    ///

    /// async fn handler(input: input::MalformedUniqueItemsInput) -> Result<output::MalformedUniqueItemsOutput, error::MalformedUniqueItemsError> {

    ///     todo!()

    /// }

    ///

    /// let config = UniqueItemsServiceConfig::builder().build();

    /// let svc = ::tower::util::service_fn(handler);

    /// let app = UniqueItemsService::builder(config)

    ///     .malformed_unique_items_service(svc)

    ///     /* Set other handlers */

    ///     .build()

    ///     .unwrap();

    /// ```

    ///

                    pub fn malformed_unique_items_service<S, ServiceExtractors, UpgradeExtractors>(self, service: S) -> Self

                    where

                            UniqueItemsService<L>,

                            crate::operation_shape::MalformedUniqueItems,

                        >,

                            UniqueItemsService<L>,

                            crate::operation_shape::MalformedUniqueItems,

                            ModelPl::Output

                        >,

                            UniqueItemsService<L>,

                            crate::operation_shape::MalformedUniqueItems,

                            <

                                    UniqueItemsService<L>,

                                    crate::operation_shape::MalformedUniqueItems,

                                    ModelPl::Output

                                >

                            >::Output

                        >,

                        <HttpPl::Output as ::tower::Service<::http::Request<Body>>>::Future: Send + 'static,

                    {

        let svc = crate::operation_shape::MalformedUniqueItems::from_service(service);

        let svc = self.model_plugin.apply(svc);

                .apply(svc);

        let svc = self.http_plugin.apply(svc);

        self.malformed_unique_items_custom(svc)

    }

    /// Sets the [`MalformedUniqueItems`](crate::operation_shape::MalformedUniqueItems) to a custom [`Service`](tower::Service).

    /// not constrained by the Smithy contract.

    fn malformed_unique_items_custom<S>(mut self, svc: S) -> Self

    where

        S: ::tower::Service<

                ::http::Request<Body>,

                Error = ::std::convert::Infallible,

            > + Clone

            + Send

            + 'static,

        S::Future: Send + 'static,

    {

        self

    }

}

impl<Body, L, HttpPl, ModelPl> UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {

    /// Constructs a [`UniqueItemsService`] from the arguments provided to the builder.

    ///

    /// Forgetting to register a handler for one or more operations will result in an error.

    ///

    /// Check out [`UniqueItemsServiceBuilder::build_unchecked`] if you'd prefer the service to return status code 500 when an

    /// unspecified route is requested.

    pub fn build(

        self,

    ) -> ::std::result::Result<

        UniqueItemsService<

            >,

        >,

        MissingOperationsError,

    >

    where

    {

        let router = {

            let mut missing_operation_names = std::collections::HashMap::new();

            if self.malformed_unique_items.is_none() {

                missing_operation_names.insert(

                    crate::operation_shape::MalformedUniqueItems::ID,

                    ".malformed_unique_items()",

                );

            }

            if !missing_operation_names.is_empty() {

                return Err(MissingOperationsError {

                    operation_names2setter_methods: missing_operation_names,

                });

            }

            let unexpected_error_msg = "this should never panic since we are supposed to check beforehand that a handler has been registered for this operation; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues";

                request_specs::malformed_unique_items(),

                self.malformed_unique_items.expect(unexpected_error_msg),

            )])

        };

        let svc = svc.map(|s| s.layer(self.layer));

        Ok(UniqueItemsService { svc })

    }

    /// Constructs a [`UniqueItemsService`] from the arguments provided to the builder.

    /// Operations without a handler default to returning 500 Internal Server Error to the caller.

    ///

    /// Check out [`UniqueItemsServiceBuilder::build`] if you'd prefer the builder to fail if one or more operations do

    /// not have a registered handler.

    pub fn build_unchecked(self) -> UniqueItemsService<L::Service>

    where

        Body: Send + 'static,

        L: ::tower::Layer<

                >,

            >,

        >,

    {

                request_specs::malformed_unique_items(),

                self.malformed_unique_items.unwrap_or_else(|| {

                    >::default();

                }),

            )]);

        let svc = self

            .layer

        UniqueItemsService { svc }

    }

}

/// The error encountered when calling the [`UniqueItemsServiceBuilder::build`] method if one or more operation handlers are not

/// specified.

#[derive(Debug)]

pub struct MissingOperationsError {

    operation_names2setter_methods:

}

impl std::fmt::Display for MissingOperationsError {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        write!(

            f,

            "You must specify a handler for all operations attached to `UniqueItemsService`.\n\

                            We are missing handlers for the following operations:\n",

        )?;

        for operation_name in self.operation_names2setter_methods.keys() {

            writeln!(f, "- {}", operation_name.absolute())?;

        }

        writeln!(f, "\nUse the dedicated methods on `UniqueItemsServiceBuilder` to register the missing handlers:")?;

        for setter_name in self.operation_names2setter_methods.values() {

            writeln!(f, "- {}", setter_name)?;

        }

        Ok(())

    }

}

impl std::error::Error for MissingOperationsError {}

mod request_specs {

    pub(super) fn malformed_unique_items(

                    ::http::Method::POST,

]),

])

                        )

                    ),

                )

    }

}

#[allow(missing_docs)] // documentation missing in model

///

/// See the [root](crate) documentation for more information.

#[derive(Clone)]

pub struct UniqueItemsService<

            >,

    >,

> {

    // This is the router wrapped by layers.

    svc: S,

}

impl UniqueItemsService<()> {

    /// Constructs a builder for [`UniqueItemsService`].

    /// You must specify a configuration object holding any plugins and layers that should be applied

    /// to the operations in this service.

    pub fn builder<

        Body,

        L,

    >(

        config: UniqueItemsServiceConfig<L, HttpPl, ModelPl>,

    ) -> UniqueItemsServiceBuilder<Body, L, HttpPl, ModelPl> {

        UniqueItemsServiceBuilder {

            malformed_unique_items: None,

            layer: config.layers,

            http_plugin: config.http_plugins,

            model_plugin: config.model_plugins,

        }

    }

    /// Constructs a builder for [`UniqueItemsService`].

    /// You must specify what plugins should be applied to the operations in this service.

    ///

    /// Use [`UniqueItemsService::builder_without_plugins`] if you don't need to apply plugins.

    ///

    /// multiple plugins.

    #[deprecated(

        since = "0.57.0",

        note = "please use the `builder` constructor and register plugins on the `UniqueItemsServiceConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"

    )]

    pub fn builder_with_plugins<

        Body,

    >(

        http_plugin: HttpPl,

        model_plugin: ModelPl,

    ) -> UniqueItemsServiceBuilder<Body, ::tower::layer::util::Identity, HttpPl, ModelPl> {

        UniqueItemsServiceBuilder {

            malformed_unique_items: None,

            layer: ::tower::layer::util::Identity::new(),

            http_plugin,

            model_plugin,

        }

    }

    /// Constructs a builder for [`UniqueItemsService`].

    ///

    /// Use [`UniqueItemsService::builder_with_plugins`] if you need to specify plugins.

    #[deprecated(

        since = "0.57.0",

        note = "please use the `builder` constructor instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"

    )]

    pub fn builder_without_plugins<Body>() -> UniqueItemsServiceBuilder<

        Body,

        ::tower::layer::util::Identity,

    > {

        Self::builder_with_plugins(

        )

    }

}

impl<S> UniqueItemsService<S> {

    /// Converts [`UniqueItemsService`] into a [`MakeService`](tower::make::MakeService).

    }

    pub fn into_make_service_with_connect_info<C>(

        self,

    }

}

impl<S>

    UniqueItemsService<

        >,

    >

{

    /// Applies a [`Layer`](::tower::Layer) uniformly to all routes.

    #[deprecated(

        since = "0.57.0",

        note = "please add layers to the `UniqueItemsServiceConfig` object instead; see https://github.com/smithy-lang/smithy-rs/discussions/3096"

    )]

    pub fn layer<L>(

        self,

        layer: &L,

    ) -> UniqueItemsService<

        >,

    >

    where

        L: ::tower::Layer<S>,

    {

        UniqueItemsService {

            svc: self.svc.map(|s| s.layer(layer)),

        }

    }

    ///

    /// This has the effect of erasing all types accumulated via layers.

    pub fn boxed<B>(

        self,

    ) -> UniqueItemsService<

            >,

        >,

    >

    where

        S: ::tower::Service<

            ::http::Request<B>,

            Error = std::convert::Infallible,

        >,

        S: Clone + Send + 'static,

        S::Future: Send + 'static,

    {

        self.layer(&::tower::layer::layer_fn(

        ))

    }

}

impl<S, R> ::tower::Service<R> for UniqueItemsService<S>

where

    S: ::tower::Service<R>,

{

    type Response = S::Response;

    type Error = S::Error;

    type Future = S::Future;

    fn poll_ready(

        &mut self,

        cx: &mut std::task::Context,

    ) -> std::task::Poll<::std::result::Result<(), Self::Error>> {

        self.svc.poll_ready(cx)

    }

    fn call(&mut self, request: R) -> Self::Future {

        self.svc.call(request)

    }

}

/// An enumeration of all [operations](https://smithy.io/2.0/spec/service-types.html#operation) in UniqueItemsService.

#[allow(clippy::enum_variant_names)]

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

pub enum Operation {

    MalformedUniqueItems,

}

impl Operation {

        match self {

                    "com.amazonaws.constraints#MalformedUniqueItems",

                    "com.amazonaws.constraints",

                    "MalformedUniqueItems",

        }

    }

}

impl<L>

        crate::operation_shape::MalformedUniqueItems,

    > for UniqueItemsService<L>

{

    const VALUE: Operation = Operation::MalformedUniqueItems;

}

            "com.amazonaws.constraints#UniqueItemsService",

            "com.amazonaws.constraints",

            "UniqueItemsService",

        );

    const VERSION: Option<&'static str> = Some("");

    type Operations = Operation;

}

/// Configuration for the [`UniqueItemsService`]. This is the central place where to register and

/// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.

///

/// ```rust,no_run

/// # use unique_items::UniqueItemsServiceConfig;

/// # use ::tower::layer::util::Identity;

/// # let authentication_plugin = IdentityPlugin;

/// # let authorization_plugin = IdentityPlugin;

/// # let server_request_id_provider_layer = Identity::new();

/// let config = UniqueItemsServiceConfig::builder()

///     // Layers get executed first...

///     .layer(server_request_id_provider_layer)

///     // ...then HTTP plugins...

///     .http_plugin(authentication_plugin)

///     // ...and right after deserialization, model plugins.

///     .model_plugin(authorization_plugin)

///     .build();

/// ```

///

/// See the [`plugin`] system for details.

///

#[derive(::std::fmt::Debug)]

pub struct UniqueItemsServiceConfig<L, H, M> {

    layers: L,

    http_plugins: H,

    model_plugins: M,

}

impl UniqueItemsServiceConfig<(), (), ()> {

    /// Returns a builder to construct the configuration.

    pub fn builder() -> UniqueItemsServiceConfigBuilder<

        ::tower::layer::util::Identity,

    > {

        UniqueItemsServiceConfigBuilder {

            layers: ::tower::layer::util::Identity::new(),

        }

    }

}

/// Builder returned by [`UniqueItemsServiceConfig::builder()`].

#[derive(::std::fmt::Debug)]

pub struct UniqueItemsServiceConfigBuilder<L, H, M> {

    pub(crate) layers: L,

    pub(crate) http_plugins: H,

    pub(crate) model_plugins: M,

}

impl<L, H, M> UniqueItemsServiceConfigBuilder<L, H, M> {

    /// Add a [`::tower::Layer`] to the service.

    pub fn layer<NewLayer>(

        self,

        layer: NewLayer,

    ) -> UniqueItemsServiceConfigBuilder<::tower::layer::util::Stack<NewLayer, L>, H, M> {

        UniqueItemsServiceConfigBuilder {

            layers: ::tower::layer::util::Stack::new(layer, self.layers),

            http_plugins: self.http_plugins,

            model_plugins: self.model_plugins,

        }

    }

    /// Add a HTTP [plugin] to the service.

    ///

    // We eagerly require `NewPlugin: HttpMarker`, despite not really needing it, because compiler

    // errors get _substantially_ better if the user makes a mistake.

        self,

        http_plugin: NewPlugin,

    ) -> UniqueItemsServiceConfigBuilder<

        L,

        M,

    > {

        UniqueItemsServiceConfigBuilder {

            layers: self.layers,

                http_plugin,

                self.http_plugins,

            ),

            model_plugins: self.model_plugins,

        }

    }

    /// Add a model [plugin] to the service.

    ///

    // We eagerly require `NewPlugin: ModelMarker`, despite not really needing it, because compiler

    // errors get _substantially_ better if the user makes a mistake.

        self,

        model_plugin: NewPlugin,

    ) -> UniqueItemsServiceConfigBuilder<

        L,

        H,

    > {

        UniqueItemsServiceConfigBuilder {

            layers: self.layers,

            http_plugins: self.http_plugins,

                model_plugin,

                self.model_plugins,

            ),

        }

    }

    /// Build the configuration.

    pub fn build(self) -> super::UniqueItemsServiceConfig<L, H, M> {

        super::UniqueItemsServiceConfig {

            layers: self.layers,