Exceptions

Starlette vous permet d'installer des gestionnaires d'exceptions personnalisés pour gérer la façon dont les réponses sont renvoyées en cas d'erreur ou d'exception gérée.

de starlette.applications import Starlette
de starlette.exceptions import HTTPException
de starlette.requests Demande d'importation
from starlette.responses import HTMLResponse


HTML_404_PAGE = ...
HTML_500_PAGE = ...


async def not_found(request: Request, exc: HTTPException):
    return HTMLResponse(content=HTML_404_PAGE, status_code=exc.status_code)

async def server_Error(request: Request, exc: HTTPException):
    return HTMLResponse(content=HTML_500_PAGE, status_code=exc.status_code)


exception_handlers = {
    404: not_found,
    500: serveur_erreur
}

app = Starlette(routes=routes, exception_handlers=exception_handlers)

Si debug est activé et qu 'une erreur se produit, Starlette utilisera une réponse rétroactive au lieu d'utiliser le gestionnaire 500 installé.

app = Starlette(defg =True, routes=routes, exception_handlers=exception_handlers)

En plus d'enregistrer des gestionnaires pour des codes d'état spécifiques, vous pouvez également enregistrer des gestionnaires pour des classes d'exception.

En particulier, vous voudrez peut-être remplacer le traitement de la classe HTTPException intégrée, par exemple, en utilisant une réponse de style JSON:

async def http_exception(request: Request, exc: HTTPException):
    return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)

exception_handlers = {
    HTTPException: http_exception
}

HTTPException est également équipé du paramètre headers. cela permet la propagation des en-têtes aux classes de réponse:

async def http_exception(request: Request, exc: HTTPException):
    return JSONResponse(
        {"detail": exc.detail},
        status_code=exc.status_code,
        headers=exc.headers
    )

Vous voudrez peut-être également remplacer la façon dont WebSocketException traite:

async def websocket_exception(websocket: WebSocket, exc: WebSocketException):
    await websock.close(code=1008)

exception_handlers = {
    WebSocketException: websocket_exception
}

Erreurs et exceptions traitées

Il est important de distinguer les exceptions traitées des erreurs.

Les exceptions traitées ne représentent pas une situation d'erreur. elles sont converties de force en réponses HTTP appropriées, puis envoyées via la pile middleware standard. par défaut, la classe HTTPException est utilisée pour gérer toutes les exceptions traitées.

Les erreurs sont toutes les autres exceptions qui se produisent dans l'application. ces situations devraient bouillonner comme des exceptions dans toute la pile middleware. tout middleware de journalisation des erreurs devrait s'assurer que les exceptions sont relancées tout au long du chemin vers le serveur.

En fait, le traitement des erreurs utilisé est exception_handler[500] ou exception_handler[Exception]. les deux touches 500 et Exception sont disponibles. voir ci-dessous:

async def handle_Error(request: Request, exc: HTTPException):
    # Perform some logique
    return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)

exception_handlers = {
    Exception: handle_Error #ou "500: handle_Error"
}

Il est important de noter que si BackgroundTask Déclencher une exception qui sera déterminée par handle_error La fonction effectue le traitement, mais la réponse a déjà été envoyée à ce moment-là. handle_error Si l'erreur se produit avant que la réponse ne soit envoyée, alors l'objet de réponse sera utilisé-dans l'exemple ci-dessus, pour le renvoi de JSONResponse 。

Pour gérer correctement ce comportement, la pile middleware de l'application Starlette est configurée de cette façon:

• ServerErrorMiddleware - 500 réponses sont renvoyées lorsque le serveur a une erreur
• Middleware installé
• ExceptionMiddleware - Les exceptions gérées sont traitées et une réponse est renvoyée.
• Le routeur
• Endpoint à

Exceptions HTTP

La classe HTTPException fournit une classe de base que vous pouvez utiliser pour toute exception gérée. les implémentations de ExceptionMiddleware renvoient par défaut une réponse HTTP en texte brut pour tout HTTPException.

• HTTPException(status_code, detail=None, headers=None)

Vous ne devriez lever HTTPException qu'à l'intérieur d'une route ou d'un point final. la classe middleware devrait plutôt retourner directement la réponse appropriée.

Exceptions WebSocket

Vous pouvez utiliser la classe WebSocketException pour générer une erreur à l'intérieur du point de terminaison WebSocket.

• WebSocketException(code=1008, reason=None)

Vous pouvez définir tout code valide défini dans la spécification.