And then mount that under a path.

{* ../../docs_src/wsgi/tutorial001.py hl[2:3,3] *}

## Check it { #check-it }

Now, every request under the path `/v1/` will be handled by the Flask application.

And the rest will be handled by **FastAPI**.

If you run it and go to <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a> you will see the response from Flask:

```txt

		if assignBack.Index > 0 {
			reflect.Indirect(assignBack.Dest).Set(fieldValue.Index(assignBack.Index - 1))
		} else {
			reflect.Indirect(assignBack.Dest).Set(fieldValue)
		}
	}
}

func (association *Association) buildCondition() *DB {
	var (

		</antcall>

		<antcall target="remove.jars" />
	</target>

	<target name="install.module">
		<get dest="${target.dir}">
			<url url="${repo.url}/${module.groupId}/${module.name.prefix}${module.name}/${module.version}/${module.name.prefix}${module.name}-${module.zip.version}.zip" />
		</get>
		<unzip dest="${modules.dir}/${module.name}" src="${target.dir}/${module.name.prefix}${module.name}-${module.zip.version}.zip">
			<patternset>

{* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}

/// note

Notez que, dans ce cas, le paramètre `item` provenant du `Body` est optionnel (sa valeur par défaut est `None`).

///

## Paramètres multiples du body

Dans l'exemple précédent, les opérations de routage attendaient un body JSON avec les attributs d'un `Item`, par exemple :

```JSON
{

Le mot "**serveur**" est couramment utilisé pour désigner à la fois l'ordinateur distant/cloud (la machine physique ou virtuelle) et également le programme qui s'exécute sur cette machine (par exemple, Uvicorn).

Gardez cela à l'esprit lorsque vous lisez "serveur" en général, cela pourrait faire référence à l'une de ces deux choses.

/**
 * Determine the number of buckets for the first element in the list
 * when it needs to be split into several smaller pieces.
 *
 * The basic idea is:
 * 1. Make sure the rest elements has at least one bucket.
 * 2. Make sure the "roughSizeOfEachBucket" for the rest elements is smaller than the current "roughSizeOfEachBucket".
 */
private fun <T> determineBucketNumberForLargeElment(
    largestElementSize: Int,

    public void assembleBuildInheritance(Build childBuild, Build parentBuild, boolean handleAsInheritance) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void copyModel(Model dest, Model source) {
        throw new UnsupportedOperationException();
    }

func statUnix(fi fs.FileInfo, h *Header, doNameLookups bool) error {
	sys, ok := fi.Sys().(*syscall.Stat_t)
	if !ok {
		return nil
	}
	h.Uid = int(sys.Uid)
	h.Gid = int(sys.Gid)
	if doNameLookups {
		// Best effort at populating Uname and Gname.
		// The os/user functions may fail for any number of reasons
		// (not implemented on that platform, cgo not enabled, etc).
		if u, ok := userMap.Load(h.Uid); ok {
			h.Uname = u.(string)

 * and initializing on first use.
 *
 * We use this because eager classpath checks cause confusion and excessive logging in Android,
 * and we can't rely on classnames after proguard, so are probably best served by falling through
 * to a situation of trying our least likely noisiest options.
 */
class DeferredSocketAdapter(
  private val socketAdapterFactory: Factory,
) : SocketAdapter {

 *   <li>{@link MoreObjects}
 *   <li>{@link Preconditions}
 *   <li>{@link StandardSystemProperty}
 *   <li>{@link Stopwatch}
 *   <li>{@link Throwables}
 *   <li>{@link Verify}
 * </ul>
 *
 * <h3>The rest</h3>
 *
 * This package also contains some classes with niche use cases (e.g., {@link Utf8} and {@link
 * Defaults}), as well as a number of classes that have been superseded by additions to the JDK.
 */
@CheckReturnValue