In this case, this `__call__` is what **FastAPI** will use to check for additional parameters and sub-dependencies, and this is what will be called to pass a value to the parameter in your *path operation function* later.

## Parameterize the instance

And now, we can use `__init__` to declare the parameters of the instance that we can use to "parameterize" the dependency:

			echo "...waiting... for 5secs" && sleep 5
		done
	done

	echo "Sleeping for nginx"
	sleep 20
}

__init__() {
	sudo apt install curl -y
	export GOPATH=/tmp/gopath
	export PATH=${PATH}:${GOPATH}/bin

	go install github.com/minio/mc@latest

	## this is needed because github actions don't have
	## docker-compose on all runners
	go install github.com/docker/compose/v2/cmd@latest

        # By default, queries listed here will override any specified in a config file. 
        # Prefix the list here with "+" to use these queries and those in the config file.
        # queries: ./path/to/local/query, your-org/your-repo/queries@main

    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)

 */
package mockwebserver3

import okhttp3.ExperimentalOkHttpApi
import okhttp3.Headers

/** An HTTP request initiated by the server. */
@ExperimentalOkHttpApi
class PushPromise(
  val method: String,
  val path: String,
  val headers: Headers,
  val response: MockResponse,

    page.get_by_role("button", name="Item-Output").click()
    page.set_viewport_size({"width": 960, "height": 820})
    # Manually add the screenshot
    page.screenshot(
        path="docs/en/docs/img/tutorial/separate-openapi-schemas/image04.png"
    )
    # ---------------------
    context.close()
    browser.close()


process = subprocess.Popen(

    archiveBaseName = "incubating-apis"
    from(allIncubationReports.get().htmlReportFile)
    from(resolver("html"))
}

fun resolver(reportType: String) = configurations.create("incubatingReport${reportType.capitalize()}Path") {
    isVisible = false
    isCanBeResolved = true
    isCanBeConsumed = false
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))

    public static final String CURRENT_ACCESSORS_OF_UPGRADED_PROPERTIES = "currentAccessorsOfUpgradedProperties";

    public static List<UpgradedProperty> parse(String path) {
        File file = new File(path);
        if (!file.exists()) {
            return Collections.emptyList();
        }
        try (FileReader reader = new FileReader(file)) {

					return nil
				}
				var envoyDump []byte
				if configDumpFile != "" {
					envoyDump, err = readConfigFile(configDumpFile)
				} else {
					path := "config_dump"
					envoyDump, err = kubeClient.EnvoyDo(context.TODO(), podName, ns, "GET", path)
				}
				if err != nil {
					return fmt.Errorf("could not contact sidecar: %w", err)
				}

				xdsRequest := discovery.DiscoveryRequest{

## The normal process

The normal (default) process, is as follows.

A `FastAPI` application (instance) has an `.openapi()` method that is expected to return the OpenAPI schema.

As part of the application object creation, a *path operation* for `/openapi.json` (or for whatever you set your `openapi_url`) is registered.

It just returns a JSON response with the result of the application's `.openapi()` method.

The <abbr title="specification">spec</abbr> requires the fields to be exactly named `username` and `password`, and to be sent as form fields, not JSON.

With `Form` you can declare the same configurations as with `Body` (and `Query`, `Path`, `Cookie`), including validation, examples, an alias (e.g. `user-name` instead of `username`), etc.

/// info

`Form` is a class that inherits directly from `Body`.

///

/// tip