client = TestClient(app)


def test_dependency_contextvars():
    """
    Check that custom middlewares don't affect the contextvar context for dependencies.

    The code before yield and the code after yield should be run in the same contextvar
    context, so that request_state_context_var.reset(contextvar_token).

    If they are run in a different context, that raises an error.
    """

The files and form fields will be uploaded as form data and you will receive the files and form fields.

And you can declare some of the files as `bytes` and some as `UploadFile`.

/// warning

Lo primero que hay que notar es que estamos definiendo una función asíncrona con `yield`. Esto es muy similar a las Dependencias con `yield`.

{* ../../docs_src/events/tutorial003_py39.py hl[14:19] *}

La primera parte de la función, antes del `yield`, será ejecutada **antes** de que la aplicación comience.

Y la parte después del `yield` será ejecutada **después** de que la aplicación haya terminado.

Das Erste, was auffällt, ist, dass wir eine asynchrone Funktion mit `yield` definieren. Das ist sehr ähnlich zu Abhängigkeiten mit `yield`.

{* ../../docs_src/events/tutorial003_py39.py hl[14:19] *}

Der erste Teil der Funktion, vor dem `yield`, wird ausgeführt **bevor** die Anwendung startet.

Und der Teil nach `yield` wird ausgeführt, **nachdem** die Anwendung beendet ist.

### Функция lifespan { #lifespan-function }

Первое, на что стоит обратить внимание, — мы определяем асинхронную функцию с `yield`. Это очень похоже на Зависимости с `yield`.

{* ../../docs_src/events/tutorial003_py39.py hl[14:19] *}

Первая часть функции, до `yield`, будет выполнена до запуска приложения.

А часть после `yield` будет выполнена после завершения работы приложения.

### Асинхронный менеджер контекста { #async-context-manager }

可能你需要启动一个新版本，或者你只是你厌倦了运行它。 🤷

///

## 生命周期函数

首先要注意的是，我们定义了一个带有 `yield` 的异步函数。这与带有 `yield` 的依赖项非常相似。

```Python hl_lines="14-19"
{!../../docs_src/events/tutorial003.py!}
```

这个函数在 `yield`之前的部分，会在应用启动前执行。

剩下的部分在 `yield` 之后，会在应用完成后执行。

## 异步上下文管理器

如你所见，这个函数有一个装饰器 `@asynccontextmanager` 。

它将函数转化为所谓的“**异步上下文管理器**”。

```Python hl_lines="1  13"
{!../../docs_src/events/tutorial003.py!}
```

 * forked lifecycle.
 * </p>
 * <p>
 * The {@link Parameter} annotation can be added on fields to inject data
 * from the plugin configuration or from other components.
 * </p>
 * <p>
 * Fields can also be annotated with the {@link Resolution} annotation to be injected
 * with the dependency collection or resolution result for the project.
 * </p>
 *

class CallableGenDependency:
    def __call__(self, value: str) -> Generator[str, None, None]:
        yield value


class AsyncCallableDependency:
    async def __call__(self, value: str) -> str:
        return value


class AsyncCallableGenDependency:
    async def __call__(self, value: str) -> AsyncGenerator[str, None]:
        yield value


class MethodsDependency:
    def synchronous(self, value: str) -> str:

The first thing to notice, is that we are defining an async function with `yield`. This is very similar to Dependencies with `yield`.

{* ../../docs_src/events/tutorial003_py39.py hl[14:19] *}

The first part of the function, before the `yield`, will be executed **before** the application starts.

And the part after the `yield` will be executed **after** the application has finished.

### Async Context Manager { #async-context-manager }

A primeira coisa a notar é que estamos definindo uma função assíncrona com `yield`. Isso é muito semelhante a Dependências com `yield`.

{* ../../docs_src/events/tutorial003_py39.py hl[14:19] *}

A primeira parte da função, antes do `yield`, será executada **antes** de a aplicação iniciar.

E a parte posterior ao `yield` será executada **depois** de a aplicação ter terminado.