buildReportTab("Performance", "performance-test-results.zip!report/index.html")
            }
        }

        specificBuildTypes =
            stage.specificBuilds.map {
                it.create(model, stage, FlakyTestStrategy.EXCLUDE)
            }

        val (smokeBuildTypes, nonSmokeBuildTypes) =
            stage.specificBuilds.zip(specificBuildTypes).partition { (spec, _) ->

---

## Install FastAPI { #install-fastapi }

The first step is to install FastAPI.

Make sure you create a [virtual environment](../virtual-environments.md), activate it, and then **install FastAPI**:

<div class="termy">

```console
$ pip install "fastapi[standard]"

---> 100%
```

</div>

/// note

{* ../../docs_src/background_tasks/tutorial001_py310.py hl[1,13] *}

**FastAPI** créera l'objet de type `BackgroundTasks` pour vous et le passera comme paramètre.

## Créer une fonction de tâche { #create-a-task-function }

Créez une fonction à exécuter comme tâche d'arrière-plan.

Une fonction à exécuter comme tâche d'arrière-plan est juste une fonction standard qui peut recevoir des paramètres.

Mas é a maneira mais simples de focar no lado do servidor de WebSockets e ter um exemplo funcional:

{* ../../docs_src/websockets_/tutorial001_py310.py hl[2,6:38,41:43] *}

## Crie um `websocket` { #create-a-websocket }

Em sua aplicação **FastAPI**, crie um `websocket`:

{* ../../docs_src/websockets_/tutorial001_py310.py hl[1,46:47] *}

/// note | Detalhes Técnicos

- 可以對該**回應**做一些處理或執行所需的程式碼。
- 然後回傳**回應**。

/// note | 技術細節

如果你有使用帶有 `yield` 的相依性，其釋放階段的程式碼會在中介軟體之後執行。

若有背景工作（在[背景工作](background-tasks.md)一節會介紹，你稍後會看到），它們會在所有中介軟體之後執行。

///

## 建立中介軟體 { #create-a-middleware }

要建立中介軟體，將裝飾器 `@app.middleware("http")` 加在函式上方。

中介軟體函式會接收：

- `request`。
- 一個函式 `call_next`，會以 `request` 作為參數。
    - 這個函式會把 `request` 傳給對應的*路徑操作*。
    - 然後回傳對應*路徑操作*所產生的 `response`。

	if err != nil {
		return path, err
	}

	fi, err := Lstat(path)
	if err != nil && !osIsNotExist(err) {
		return path, err
	}
	if osIsNotExist(err) {
		// Disk not found create it.
		if err = mkdirAll(path, 0o777, ""); err != nil {
			return path, err
		}
	}
	if fi != nil && !fi.IsDir() {
		return path, errDiskNotDir
	}

	return path, nil
}

     */
    public SynonymItem(final long id, final String[] inputs, final String[] outputs) {
        this.id = id;
        this.inputs = inputs;
        this.outputs = outputs;

        if (id == 0) {
            // create
            newInputs = inputs;
            newOutputs = outputs;
        }
    }

    /**
     * Gets the new input words.
     * Returns a defensive copy to prevent external modification.
     *

        this.id = id;
        this.token = token;
        this.segmentation = segmentation;
        this.reading = reading;
        this.pos = pos;

        if (id == 0) {
            // create
            newToken = token;
            newSegmentation = segmentation;
            newReading = reading;
            newPos = pos;
        }
    }

    /**
     * Returns the new token.
     *

    private val ignorePackages: Set<String>
) {

    fun analyze(jarFile: File, classesDir: File, manifestFile: File, buildReceipt: File): ClassGraph {
        val classGraph = classGraph()

        val jarUri = URI.create("jar:${jarFile.toPath().toUri()}")
        FileSystems.newFileSystem(jarUri, emptyMap<String, Any>()).use { jarFileSystem ->
            jarFileSystem.rootDirectories.forEach {

   *
   * <p>When {@code maxSize} is zero, elements will be evicted immediately after being added to the
   * queue.
   */
  public static <E> EvictingQueue<E> create(int maxSize) {
    return new EvictingQueue<>(maxSize);
  }

  /**
   * Returns the number of additional elements that this queue can accept without evicting; zero if
   * the queue is currently full.
   *