globalMavenDirectory = userHomeDir.createDir("m2_home")
            globalSettingsFile = globalMavenDirectory.file("conf/settings.xml")
            println "M2 home: " + userHomeDir

            initialized = true
        }
    }

    void assertNoLeftoverState() {
        assert System.getenv("M2_HOME") == null
        assert System.getProperty("maven.repo.local") == null

    You could also use `from starlette.staticfiles import StaticFiles`.

    **FastAPI** provides the same `starlette.staticfiles` as `fastapi.staticfiles` just as a convenience for you, the developer. But it actually comes directly from Starlette.

### What is "Mounting"

"Mounting" means adding a complete "independent" application in a specific path, that then takes care of handling all the sub-paths.

        assertTrue(instance.isFileSystemCheckIgnoredFor(File("foo/2/bar/3/4")))
    }

    @Test
    fun `recognizes user-home-based paths against the user home dir`() {
        val instance = createFromPaths(listOf("~/.gradle/foo.bar"))
        assertTrue(instance.isFileSystemCheckIgnoredFor(File(System.getProperty("user.home"), ".gradle/foo.bar")))
    }

    @Test
    fun `recognizes relative paths pointing outside the root directory`() {

    def "Gradle API is not generated if not declared by build"() {
        given:
        buildFile << applyJavaPlugin()

        when:
        succeeds 'build'

        then:
        file("user-home/caches/${distribution.version.version}/generated-gradle-jars").assertIsEmptyDir()
    }

    def "buildSrc project implicitly forces generation of Gradle API JAR"() {
        given:
        buildFile << applyJavaPlugin()

configurations { compile }
dependencies {
    compile 'org.name:projectB:1.0'
}

task retrieve(type: Sync) {
    into 'libs'
    from configurations.compile
}
"""
        and:
        def userHome = file('user-home')

        when:
        projectB.allowAll()

        and:
        version previous withGradleUserHomeDir userHome withTasks 'retrieve' withArguments '-i' run()

        then:

}

bootgo = 1.20.6
GOROOT = `{cd .. && pwd}
goroot_bootstrap_set = 'true'
if(! ~ $#GOROOT_BOOTSTRAP 1){
	goroot_bootstrap_set = 'false'
	GOROOT_BOOTSTRAP = $home/go1.4
	for(d in sdk/go$bootgo go$bootgo)
		if(test -d $home/$d)
			GOROOT_BOOTSTRAP = $home/$d
}
for(p in $path){
	if(! test -x $GOROOT_BOOTSTRAP/bin/go){
		if(go_exe = `{path=$p whatis go}){
			goroot_bootstrap = $GOROOT_BOOTSTRAP
			GOROOT_BOOTSTRAP = ()

			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         QueueDir,
			Description: `staging dir for undelivered logger messages e.g. '/home/logger-events'`,
			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         Proxy,
			Description: "proxy url endpoint e.g. http(s)://proxy",
			Optional:    true,

{!../../../docs_src/path_params/tutorial004.py!}
```

!!! tip "Tipp"
    Der Parameter könnte einen führenden Schrägstrich (`/`) haben, wie etwa in `/home/johndoe/myfile.txt`.

    In dem Fall wäre die URL: `/files//home/johndoe/myfile.txt`, mit einem doppelten Schrägstrich (`//`) zwischen `files` und `home`.

## Zusammenfassung

In **FastAPI** erhalten Sie mittels kurzer, intuitiver Typdeklarationen:

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.
* Then it passes the **request** to be processed by the rest of the application (by some *path operation*).

// 1. First we take the default config
// 2. Then we apply any settings from file (this comes from gateway mounting configmap)
// 3. Then we apply settings from environment variable (this comes from sidecar injection sticking meshconfig here)
// 4. Then we apply overrides from annotation (this comes from annotation on gateway, passed through downward API)
//