Saltar al contenido

Excepciones - HTTPException y WebSocketException

Estas son las excepciones que puedes lanzar para mostrar errores al cliente.

Cuando lanzas una excepción, como pasaría con Python normal, el resto de la ejecución se aborta. De esta manera puedes lanzar estas excepciones desde cualquier parte del código para abortar una petición y mostrar el error al cliente.

Puedes usar:

  • HTTPException
  • WebSocketException

Estas excepciones pueden ser importadas directamente desde fastapi:

from fastapi import HTTPException, WebSocketException

fastapi.HTTPException 

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

Hereda de: HTTPException

Una excepción HTTP que puedes lanzar en tu propio código para mostrar errores al cliente.

Esto es para errores del cliente, autenticación inválida, datos inválidos, etc. No para errores del servidor en tu código.

Lee más sobre esto en la documentación de FastAPI para Manejo de errores.

Ejemplo

from fastapi import FastAPI, HTTPException

app = FastAPI()

items = {"foo": "The Foo Wrestlers"}


@app.get("/items/{item_id}")
async def read_item(item_id: str):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return {"item": items[item_id]}
PARÁMETRO DESCRIPCIÓN
status_code

Código de estado HTTP para enviar al cliente.

Lee más sobre esto en la documentación de FastAPI para Manejo de errores

TIPO: int

detail

Cualquier dato para ser enviado al cliente en la clave detail de la respuesta JSON.

Lee más sobre esto en la documentación de FastAPI para Manejo de errores

TYPE: Any DEFAULT: None

headers

Cualquier cabecera para enviar al cliente en la respuesta.

Lee más sobre esto en la documentación de FastAPI para Manejo de errores

TIPO: Mapping[str, str] | None DEFAULT: None

Código fuente en fastapi/exceptions.py 
def __init__(
    self,
    status_code: Annotated[
        int,
        Doc(
            """
            HTTP status code to send to the client.

            Read more about it in the
            [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/#use-httpexception)
            """
        ),
    ],
    detail: Annotated[
        Any,
        Doc(
            """
            Any data to be sent to the client in the `detail` key of the JSON
            response.

            Read more about it in the
            [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/#use-httpexception)
            """
        ),
    ] = None,
    headers: Annotated[
        Mapping[str, str] | None,
        Doc(
            """
            Any headers to send to the client in the response.

            Read more about it in the
            [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/#add-custom-headers)

            """
        ),
    ] = None,
) -> None:
    super().__init__(status_code=status_code, detail=detail, headers=headers)

status_code instance-attribute 

status_code = status_code

detail instance-attribute 

detail = detail

headers instance-attribute 

headers = headers

fastapi.WebSocketException 

WebSocketException(code, reason=None)

Hereda de: WebSocketException

Una excepción de WebSocket que puedes lanzar en tu propio código para mostrar errores al cliente.

Esto es para errores del cliente, autenticación inválida, datos inválidos, etc. No para errores del servidor en tu código.

Lee más sobre esto en la documentación de FastAPI para WebSockets.

Ejemplo

from typing import Annotated

from fastapi import (
    Cookie,
    FastAPI,
    WebSocket,
    WebSocketException,
    status,
)

app = FastAPI()

@app.websocket("/items/{item_id}/ws")
async def websocket_endpoint(
    *,
    websocket: WebSocket,
    session: Annotated[str | None, Cookie()] = None,
    item_id: str,
):
    if session is None:
        raise WebSocketException(code=status.WS_1008_POLICY_VIOLATION)
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Session cookie is: {session}")
        await websocket.send_text(f"Message text was: {data}, for item ID: {item_id}")
PARÁMETRO DESCRIPCIÓN
code

Un código de cierre de los códigos válidos definidos en la especificación.

TIPO: int

reason

La razón para cerrar la conexión WebSocket.

Son datos codificados en UTF-8. La interpretación de la razón depende de la aplicación, no está especificada por la especificación de WebSocket.

Podría contener texto que sea legible por humanos o interpretable por el código del cliente, etc.

TYPE: str | None DEFAULT: None

Código fuente en fastapi/exceptions.py 
def __init__(
    self,
    code: Annotated[
        int,
        Doc(
            """
            A closing code from the
            [valid codes defined in the specification](https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1).
            """
        ),
    ],
    reason: Annotated[
        str | None,
        Doc(
            """
            The reason to close the WebSocket connection.

            It is UTF-8-encoded data. The interpretation of the reason is up to the
            application, it is not specified by the WebSocket specification.

            It could contain text that could be human-readable or interpretable
            by the client code, etc.
            """
        ),
    ] = None,
) -> None:
    super().__init__(code=code, reason=reason)

code instance-attribute 

code = code

reason instance-attribute 

reason = reason or ''