`OAuth2PasswordRequestForm` is a class dependency that declares a form body with:

* The `username`.
* The `password`.
* An optional `scope` field as a big string, composed of strings separated by spaces.
* An optional `grant_type`.

/// tip

The OAuth2 spec actually *requires* a field `grant_type` with a fixed value of `password`, but `OAuth2PasswordRequestForm` doesn't enforce it.

 * <p>
 * The path matchers created by this service support Maven's traditional include/exclude
 * pattern syntax, which is compatible with the behavior of Maven 3 plugins like
 * maven-compiler-plugin and maven-clean-plugin.
 * <p>
 * Pattern syntax supports:
 * <ul>
 *   <li>Standard glob patterns with {@code *}, {@code ?}, and {@code **} wildcards</li>

## Server Machine and Server Program { #server-machine-and-server-program }

There's a small detail about names to keep in mind. 💡

The word "**server**" is commonly used to refer to both the remote/cloud computer (the physical or virtual machine) and also the program that is running on that machine (e.g. Uvicorn).

Just keep in mind that when you read "server" in general, it could refer to one of those two things.

#!/usr/bin/env bash

TESTS_RUN_STATUS=1

function cleanup() {
	echo "Cleaning up MinIO deployment"
	docker compose -f "${DOCKER_COMPOSE_FILE}" down --volumes
	for container in $(docker ps -q); do
		echo Removing docker $container
		docker rm -f $container >/dev/null 2>&1
		docker wait $container
	done
}

function cleanup_and_prune() {
	cleanup
	docker system prune --volumes --force
	docker image prune --all --force
}

    b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is

   *
   * <p><i>Notes:</i> This is an implementation of the algorithm for Lexicographical Permutations
   * Generation, described in Knuth's "The Art of Computer Programming", Volume 4, Chapter 7,
   * Section 7.2.1.2. The iteration order follows the lexicographical order. This means that the
   * first permutation will be in ascending order, and the last will be in descending order.
   *

        Map<String, PluginUpgradeInfo> upgrades = new HashMap<>();
        upgrades.put(
                DEFAULT_MAVEN_PLUGIN_GROUP_ID + ":maven-compiler-plugin",
                new PluginUpgradeInfo(DEFAULT_MAVEN_PLUGIN_GROUP_ID, "maven-compiler-plugin", "3.2"));
        upgrades.put(
                "org.codehaus.mojo:exec-maven-plugin",

### Type-checking, generics and casting

You should try to write code that does not require suppressing any warnings from
the compiler, e.g. suppressing type-checking, raw generics, and so on. However,
this isn't always possible or practical. In such cases, you should use the
`@SuppressWarnings` annotations to silence the compiler warning, trying to keep
the scope of the suppression as small as possible. Where a piece of code

Pour plus de détails, consultez la section [Déploiement](deployment/index.md).

///

## Benchmarks et vitesse { #benchmarks-and-speed }

		next, err := filepath.Glob(filepath.Join(testenv.GOROOT(t), "api/next/*.txt"))
		if err != nil {
			t.Fatal(err)
		}
		nextFiles = next
	}

	for _, c := range contexts {
		c.Compiler = build.Default.Compiler
	}

	walkers := make([]*Walker, len(contexts))
	var wg sync.WaitGroup
	for i, context := range contexts {
		wg.Add(1)
		go func() {
			defer wg.Done()