*
 * h3. plugins should be able to have specific metadata for a plugin model and that be translated -
 * dependencies - resources - configuration - extension points of plugins
 *
 * For a particular application plugin there will be a declarative descriptor for that plugin type.
 *
 * - nexus - the plugin class - UI to contribute - what JS to hook into the UI - what resources to

import org.slf4j.LoggerFactory;

/**
 * Use an SLF4J {@link org.slf4j.ILoggerFactory} as a backing for a Plexus
 * {@link org.codehaus.plexus.logging.LoggerManager},
 * ignoring Plexus logger API parts that are not classical and probably not really used.
 *
 * @since 3.1
 */
public class Slf4jLoggerManager implements LoggerManager {

    private ILoggerFactory loggerFactory;

    public Slf4jLoggerManager() {

///

It will:

* Return that status code in the response.
* Document it as such in the OpenAPI schema (and so, in the user interfaces):

<img src="/img/tutorial/response-status-code/image01.png">

/// note

Some response codes (see the next section) indicate that the response does not have a body.

FastAPI knows this, and will produce OpenAPI docs that state there is no response body.

///

Let's imagine that we want to have a dependency that checks if the query parameter `q` contains some fixed content.

But we want to be able to parameterize that fixed content.

## A "callable" instance

In Python there's a way to make an instance of a class a "callable".

Not the class itself (which is already a callable), but an instance of that class.

To do that, we declare a method `__call__`:

    // can be passed back so that the default configuration information can be populated.
    //
    // We need to know the specific version so that we can look up the right version of the plugin descriptor
    // which tells us what the default configuration is.
    //

    /**

This can be very useful for setting up **resources** that you need to use for the whole app, and that are **shared** among requests, and/or that you need to **clean up** afterwards. For example, a database connection pool, or loading a shared machine learning model.

## Use Case

Let's start with an example **use case** and then see how to solve it with this.

Let's imagine that you have some **machine learning models** that you want to use to handle requests. 🤖

If there's no `gzip` in the header, it will not try to decompress the body.

That way, the same route class can handle gzip compressed or uncompressed requests.

{* ../../docs_src/custom_request_and_route/tutorial001.py hl[8:15] *}

### Create a custom `GzipRoute` class

Next, we create a custom subclass of `fastapi.routing.APIRoute` that will make use of the `GzipRequest`.

     * extra state from AbstractFuture), our options are limited: A call to setException() would be
     * a no-op. We could log, but if that's what we really want, we should modify
     * AbstractFuture.executeListener to do so, since that method would have the ability to continue
     * to execute other listeners.
     *

          <required>true</required>
        </field>
        <field>
          <version>1.0.0</version>
          <name>description</name>
          <description>The description of what this expression references, and what it's generally used for.</description>
          <type>String</type>
          <required>true</required>
        </field>
        <field>
          <version>1.0.0</version>

## What is "Dependency Injection"

**"Dependency Injection"** means, in programming, that there is a way for your code (in this case, your *path operation functions*) to declare things that it requires to work and use: "dependencies".