* adopt (meaning start to use): использовать (or `начать использовать`)
* headers (meaning HTTP-headers): HTTP-заголовки
* cookie sessions: сессии с использованием cookie
* tested (adjective): протестированный
* middleware: middleware (don't translate, but add `промежуточный слой` if clarification is needed)
* path operation: операция пути (optionally clarify as `обработчик пути`)
* path operation function: функция-обработчик пути (or `функция обработки пути`)

In einigen Fällen möchten Sie möglicherweise die von den Klassen `Request` und `APIRoute` verwendete Logik überschreiben.

Das kann insbesondere eine gute Alternative zur Logik in einer Middleware sein.

Wenn Sie beispielsweise den <abbr title="Anfragekörper">Requestbody</abbr> lesen oder manipulieren möchten, bevor er von Ihrer Anwendung verarbeitet wird.

/// danger | Gefahr

from fastapi import FastAPI
from fastapi.middleware.wsgi import WSGIMiddleware
from flask import Flask, request
from markupsafe import escape

flask_app = Flask(__name__)


@flask_app.route("/")
def flask_main():
    name = request.args.get("name", "World")
    return f"Hello, {escape(name)} from Flask!"


app = FastAPI()


@app.get("/v2")
def read_main():
    return {"message": "Hello World"}

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

origins = [
    "http://localhost.tiangolo.com",
    "https://localhost.tiangolo.com",
    "http://localhost",
    "http://localhost:8080",
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)


@app.get("/")

    request_state = {"user": "deadpond"}
    contextvar_token = legacy_request_state_context_var.set(request_state)
    yield request_state
    legacy_request_state_context_var.reset(contextvar_token)


@app.middleware("http")
async def custom_middleware(
    request: Request, call_next: Callable[[Request], Awaitable[Response]]
):
    response = await call_next(request)
    response.headers["custom"] = "foo"
    return response

import time

from fastapi import FastAPI, Request

app = FastAPI()


@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.perf_counter()
    response = await call_next(request)
    process_time = time.perf_counter() - start_time
    response.headers["X-Process-Time"] = str(process_time)

## Usando `WSGIMiddleware` { #using-wsgimiddleware }

Necesitas importar `WSGIMiddleware`.

Luego envuelve la aplicación WSGI (p. ej., Flask) con el middleware.

Y luego móntala bajo un path.

{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}

## Revisa { #check-it }

Ahora, cada request bajo el path `/v1/` será manejado por la aplicación Flask.

## `WSGIMiddleware` Kullanımı

`WSGIMiddleware`'ı projenize dahil edin.

Ardından WSGI (örneğin Flask) uygulamanızı middleware ile sarmalayın.

Son olarak da bir yol altında bağlama işlemini gerçekleştirin.

{* ../../docs_src/wsgi/tutorial001.py hl[2:3,23] *}

## Kontrol Edelim

## Using `WSGIMiddleware` { #using-wsgimiddleware }

You need to import `WSGIMiddleware`.

Then wrap the WSGI (e.g. Flask) app with the middleware.

And then mount that under a path.

{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}

## Check it { #check-it }

Now, every request under the path `/v1/` will be handled by the Flask application.

		w = &trackingResponseWriter{ResponseWriter: w}

		// Wrap the actual handler with the appropriate tracing middleware.
		var tracedHandler http.HandlerFunc
		if handlerFlags.has(traceHdrsS3HFlag) {
			tracedHandler = httpTraceHdrs(f)
		} else {
			tracedHandler = httpTraceAll(f)
		}

		// Skip wrapping with the gzip middleware if specified.
		gzippedHandler := tracedHandler
		if !handlerFlags.has(noGZS3HFlag) {