from starlette.websockets import WebSocket

app = FastAPI()
app.state.value = 42


async def extract_value_from_http_connection(conn: HTTPConnection):
    return conn.app.state.value


@app.get("/http")
async def get_value_by_http(value: int = Depends(extract_value_from_http_connection)):
    return value


@app.websocket("/ws")
async def get_value_by_ws(
    websocket: WebSocket, value: int = Depends(extract_value_from_http_connection)

```Python hl_lines="1"
async def get_burgers(number: int):
    # Сделать что-то асинхронное, чтобы приготовить бургеры
    return burgers
```

...вместо `def`:

```Python hl_lines="2"
# Это не асинхронный код
def get_sequential_burgers(number: int):
    # Сделать что-то последовательное, чтобы приготовить бургеры

    model_config = {"extra": "allow"}


@app.get("/query")
async def query_model_with_extra(data: Model = Query()):
    return data


@app.get("/header")
async def header_model_with_extra(data: Model = Header()):
    return data


@app.get("/cookie")
async def cookies_model_with_extra(data: Model = Cookie()):
    return data


def test_query_pass_extra_list():
    client = TestClient(app)

)

app = FastAPI()


def verify_password(plain_password, hashed_password):
    return password_hash.verify(plain_password, hashed_password)


def get_password_hash(password):
    return password_hash.hash(password)


def get_user(db, username: str):
    if username in db:
        user_dict = db[username]
        return UserInDB(**user_dict)


def authenticate_user(fake_db, username: str, password: str):

state = initial_state.copy()

app = FastAPI()


async def get_database():
    temp_database = fake_database.copy()
    try:
        yield temp_database
        fake_database.update(temp_database)
    except HTTPException:
        state["except"] = True
        raise
    finally:
        state["finally"] = True


@app.put("/invalid-user/{user_id}")
def put_invalid_user(

oid = OpenIdConnect(openIdConnectUrl="/openid", auto_error=False)


class User(BaseModel):
    username: str


def get_current_user(oauth_header: str | None = Security(oid)):
    if oauth_header is None:
        return None
    user = User(username=oauth_header)
    return user


@app.get("/users/me")
def read_current_user(current_user: User | None = Depends(get_current_user)):
    if current_user is None:

    }

    /**
     * DFS volume flavor indicating standalone DFS
     */
    public static final int DFS_VOLUME_FLAVOR_STANDALONE = 0x100;
    /**
     * DFS volume flavor indicating Active Directory blob storage
     */
    public static final int DFS_VOLUME_FLAVOR_AD_BLOB = 0x200;
    /**
     * DFS storage state indicating offline status
     */

app = FastAPI()


@app.get("/query")
def read_query(q: str | None):
    return q


@app.get("/explicit-query")
def read_explicit_query(q: str | None = Query()):
    return q


@app.post("/body-embed")
def send_body_embed(b: str | None = Body(embed=True)):
    return b


client = TestClient(app)


def test_required_nonable_query_invalid():
    response = client.get("/query")

        ],
    )


def get_en_config() -> dict[str, Any]:
    return mkdocs.utils.yaml_load(en_config_path.read_text(encoding="utf-8"))


def get_lang_paths() -> list[Path]:
    return sorted(docs_path.iterdir())


def lang_callback(lang: str | None) -> str | None:
    if lang is None:
        return None
    lang = lang.lower()
    return lang


def complete_existing_lang(incomplete: str):

# Without aliases


@app.get("/optional-list-str")
async def read_optional_list_str(
    p: Annotated[list[str] | None, Header()] = None,
):
    return {"p": p}


class HeaderModelOptionalListStr(BaseModel):
    p: list[str] | None = None


@app.get("/model-optional-list-str")
async def read_model_optional_list_str(
    p: Annotated[HeaderModelOptionalListStr, Header()],
):