![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

## Build a Docker Image with a Single-File FastAPI { #build-a-docker-image-with-a-single-file-fastapi }

If your FastAPI is a single file, for example, `main.py` without an `./app` directory, your file structure could look like this:

```
.
├── Dockerfile
├── main.py
└── requirements.txt

            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_CONC_MPX), "DCERPC_CONC_MPX should be a single bit");
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_DID_NOT_EXECUTE), "DCERPC_DID_NOT_EXECUTE should be a single bit");
            assertEquals(1, Integer.bitCount(DcerpcConstants.DCERPC_MAYBE), "DCERPC_MAYBE should be a single bit");

Until a connection is established, all outgoing requests will return `ErrDisconnected`.

# Usage

## Single Payload Requests

Single payload requests are requests and responses that are sent in a single message.
In essence, they are `[]byte` -> `[]byte, error` functions.

It is not possible to return *both* an error and a response.

/**
 * NTLMSSP AV pair representing single host information in NTLM authentication.
 * Contains host-specific data used during the NTLM challenge-response process.
 *
 * @author mbechler
 */
public class AvSingleHost extends AvPair {

    /**
     * Constructs an AvSingleHost from raw byte data
     *
     * @param raw the raw byte data for the single host AV pair
     */

   * limits, this call may be executed well before processing the request is able to begin.
   *
   * This will be invoked only once for a single [Call]. Retries of different routes or redirects
   * will be handled within the boundaries of a single [callStart] and [callEnd]/[callFailed] pair.
   */
  open fun callStart(call: Call) {
  }

  /**

<div class="termy">

```console
$ pip install sqlmodel
---> 100%
```

</div>

## Create the App with a Single Model { #create-the-app-with-a-single-model }

We'll create the simplest first version of the app with a single **SQLModel** model first.

Later we'll improve it increasing security and versatility with **multiple models** below. 🤓

### Create Models { #create-models }

        ],
        scope: Annotated[
            str,
            Form(),
            Doc(
                """
                A single string with actually several scopes separated by spaces. Each
                scope is also a string.

                For example, a single string with:

                ```python
                "items:read items:write users:read profile openid"
                ````

/// info

`Body` also has all the same extra validation and metadata parameters as `Query`, `Path` and others you will see later.

///

## Embed a single body parameter { #embed-a-single-body-parameter }

Let's say you only have a single `item` body parameter from a Pydantic model `Item`.

By default, **FastAPI** will then expect its body directly.

            'Whitelist' validation step. The parameter field will be the single one
            allowed by the alias or set of aliases defined.
            """
        ),
    ] = None,
    serialization_alias: Annotated[
        Union[str, None],
        Doc(
            """
            'Blacklist' validation step. The vanilla parameter field will be the
            single one of the alias' or set of aliases' fields and all the other

        <artifactId>maven-assembly-plugin</artifactId>
        <executions>
          <execution>
            <id>create-distro-packages</id>
            <goals>
              <goal>single</goal>
            </goals>
            <phase>package</phase>
            <configuration>
              <descriptors>
                <descriptor>src/assembly/bin.xml</descriptor>
              </descriptors>