/**
   * This is mutable and order matters. By default, it contains [IPv4, IPv6]. Tests may manipulate
   * it to prefer IPv6.
   */
  private var dnsResults = listOf<InetAddress>()

  @BeforeEach
  internal fun setUp() {
    val inetAddresses = InetAddress.getAllByName("localhost")
    localhostIpv4 = inetAddresses.firstOrNull { it is Inet4Address }
      ?: throw TestAbortedException()

 of this license document, but changing it is not allowed.

(This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.)

                            Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public

The **server** program (for example **Uvicorn** via **FastAPI CLI**) is capable of interpreting these headers, and then passing that information to your application.

But for security, as the server doesn't know it is behind a trusted proxy, it won't interpret those headers.

/// note | Technical Details

* `https://www.googleapis.com/auth/drive` is used by Google.

/// info

In OAuth2 a "scope" is just a string that declares a specific permission required.

It doesn't matter if it has other characters like `:` or if it is a URL.

Those details are implementation specific.

For OAuth2 they are just strings.

///

## Global view { #global-view }

# HTTP Basic Auth { #http-basic-auth }

For the simplest cases, you can use HTTP Basic Auth.

In HTTP Basic Auth, the application expects a header that contains a username and a password.

If it doesn't receive it, it returns an HTTP 401 "Unauthorized" error.

And returns a header `WWW-Authenticate` with a value of `Basic`, and an optional `realm` parameter.

That tells the browser to show the integrated prompt for a username and password.

But all this functionality of using asynchronous code with `async` and `await` is many times summarized as using "coroutines". It is comparable to the main key feature of Go, the "Goroutines".

If you declare it as is, because it is a singular value, **FastAPI** will assume that it is a query parameter.

But you can instruct **FastAPI** to treat it as another body key using `Body`:

{* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}

When using **Pydantic v2**, the generated OpenAPI is a bit more exact and **correct** than before. 😎

In fact, in some cases, it will even have **two JSON Schemas** in OpenAPI for the same Pydantic model, for input and output, depending on if they have **default values**.

Let's see how that works and how to change it if you need to do that.

## Pydantic Models for Input and Output { #pydantic-models-for-input-and-output }

        final Iterator<String> it = new MultiIterator<String>(list1.iterator(), list2.iterator());

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("Foo"));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("Bar"));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("Baz"));

        assertThat(it.hasNext(), is(not(true)));
    }

Then pass the parameter `deprecated=True` to `Query`:

{* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}

The docs will show it like this:

<img src="/img/tutorial/query-params-str-validations/image01.png">

## Exclude parameters from OpenAPI { #exclude-parameters-from-openapi }