}
)

client = TestClient(app)


def raise_value_error():
    raise ValueError()


def dependency_with_yield():
    yield raise_value_error()


@app.get("/dependency-with-yield", dependencies=[Depends(dependency_with_yield)])
def with_yield(): ...


@app.get("/http-exception")
def route_with_http_exception():
    raise HTTPException(status_code=400)

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

///

## 生命周期函数

首先要注意的是，我们定义了一个带有 `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!}
```

    dep_a = generate_dep_a()
    try:
        yield dep_a
    finally:
        dep_a.close()


async def dependency_b(dep_a=Depends(dependency_a)):
    dep_b = generate_dep_b()
    try:
        yield dep_b
    finally:
        dep_b.close(dep_a)


async def dependency_c(dep_b=Depends(dependency_b)):
    dep_c = generate_dep_c()
    try:
        yield dep_c
    finally:

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:

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

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

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

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

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

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

    pass


async def asyncgen_state(state: dict[str, str] = Depends(get_state)):
    state["/async"] = "asyncgen started"
    yield state["/async"]
    state["/async"] = "asyncgen completed"


def generator_state(state: dict[str, str] = Depends(get_state)):
    state["/sync"] = "generator started"
    yield state["/sync"]
    state["/sync"] = "generator completed"

class Session:
    def __init__(self) -> None:
        self.open = True


async def dep_session() -> Any:
    s = Session()
    yield s
    s.open = False
    global_state = global_context.get()
    global_state["session_closed"] = True


SessionFuncDep = Annotated[Session, Depends(dep_session, scope="function")]

                    yield webConfigService.getWebConfig(id).get();
                }
                case FILE -> {
                    final FileConfigService fileConfigService = ComponentUtil.getComponent(FileConfigService.class);
                    yield fileConfigService.getFileConfig(id).get();
                }
                case DATA -> {

    def __enter__(self):
        return self.db

    def __exit__(self, exc_type, exc_value, traceback):
        self.db.close()


async def get_db():
    with MySuperContextManager() as db:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()


async def fake_video_streamer():
    for i in range(10):
        yield b"some fake video bytes"


@app.get("/")
async def main():