Pydantic en FastAPI

Pydantic

¿Qué es Pydantic?

Pydantic es una librería de Python que permite definir esquemas de datos y validarlos. Pydantic se utiliza en FastAPI para definir los modelos de datos que se utilizan en la API y validar los datos que se reciben en las solicitudes.

En FastAPI se utiliza Pydantic para definir los modelos de datos que se utilizan en la API. Pydantic es una librería que permite definir esquemas de datos y validarlos.

La estructura del proyecto de esta unidad es la siguiente:

proyecto/
│
├── app/
│   ├── __init__.py
│   ├── main.py
│
├── .gitignore
├── README.md
├── requirements.txt

A continuación se muestra un ejemplo de cómo definir un modelo de datos con Pydantic:

Es necesario instalar Pydantic para poder utilizarlo en FastAPI. Para instalar Pydantic se utiliza el siguiente comando:

pip install pydantic

Sin olvidar nuestro framework FastAPI:

pip install fastapi uvicorn

Ahora se puede definir un modelo de datos con Pydantic. A continuación se muestra un ejemplo de cómo definir un modelo de datos con Pydantic:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

En el ejemplo anterior se define un modelo de datos Item que contiene tres campos: name, price e is_offer. El campo name es de tipo str, el campo price es de tipo float y el campo is_offer es de tipo bool con un valor por defecto de None.

Para utilizar el modelo de datos Item en una operación de la API se importa la clase Item y se utiliza como tipo de parámetro en la operación. A continuación se muestra un ejemplo de cómo utilizar el modelo de datos Item en una operación de la API:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

@app.post("/items/")
async def create_item(item: Item):
    return {"name": item.name, "price": item.price}

En el ejemplo anterior se importa la clase Item y se define una operación create_item() que recibe un parámetro item de tipo Item. En la operación se retorna un diccionario con los campos name y price del objeto item.

Es necesario probar nuestro código, para ello se ejecuta el servidor web con el siguiente comando:

uvicorn app.main:app --reload

Para probar la operación create_item() se puede utilizar una herramienta como Tunder Client o Postman. A continuación se muestra un ejemplo de cómo probar la operación create_item() con Tunder Client:

Para realizar una solicitud POST a la ruta /items/ con un objeto item se utiliza la siguiente solicitud:

POST /items/
Content-Type: application/json

{
    "name": "item1",
    "price": 10.5
}

En la solicitud anterior se envía un objeto item con los campos name y price. La operación create_item() recibe el objeto item y retorna un diccionario con los campos name y price del objeto item.

En este ejemplo se ha utilizado Pydantic para definir un modelo de datos Item y validar los datos que se reciben en la solicitud. Pydantic permite definir esquemas de datos y validarlos, lo que facilita la creación de APIs con FastAPI.

Para comprobar que todo funciona correctamente, se puede probar la operación create_item() con Tunder Client o Postman y verificar que se retorna un diccionario con los campos name y price del objeto item.

Otro Ejemplo

En este nuevo ejemplo se va a definir un modelo de datos User con Pydantic y se va a utilizar un CRUD para la generación de la API. A continuación se muestra el código del ejemplo:

La estructura del proyecto de esta unidad es la siguiente:

proyecto/
│
├── app/
│   ├── __init__.py
│   ├── main.py
│
├── .gitignore
├── README.md
├── requirements.txt

El código de la API (main.py) es el siguiente:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    id: int
    name: str
    email: str

users = []

@app.post("/users/")
async def create_user(user: User):
    users.append(user)
    return user

@app.get("/users/")
async def read_users():
    return users

@app.get("/users/{user_id}")
async def read_user(user_id: int):
    for user in users:
        if user.id == user_id:
            return user
    return {"message": "User not found"}

@app.put("/users/{user_id}")
async def update_user(user_id: int, user: User):
    for i, u in enumerate(users):
        if u.id == user_id:
            users[i] = user
            return user
    return {"message": "User not found"}

@app.delete("/users/{user_id}")
async def delete_user(user_id: int):
    for i, user in enumerate(users):
        if user.id == user_id:
            del users[i]
            return {"message": "User deleted"}
    return {"message": "User not found"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="localhost", port=8000)

En el ejemplo anterior se define un modelo de datos User con tres campos: id, name y email. Se define una lista users para almacenar los usuarios y se definen las operaciones create_user(), read_users(), read_user(), update_user() y delete_user() para realizar las operaciones CRUD sobre los usuarios.

Para probar el ejemplo se ejecuta el servidor web con el siguiente comando:

uvicorn app.main:app --reload

Para probar las operaciones CRUD sobre los usuarios se puede utilizar una herramienta como Tunder Client o Postman. A continuación se muestra un ejemplo de cómo probar las operaciones CRUD sobre los usuarios con Tunder Client:

Para crear un usuario se realiza una solicitud POST a la ruta /users/ con un objeto user:

POST /users/
Content-Type: application/json

{
    "id": 1,
    "name": "user1",
    "email": "dmsaavedra@espe.edu.ec"
}

Para obtener todos los usuarios se realiza una solicitud GET a la ruta /users/:

GET /users/

Para obtener un usuario se realiza una solicitud GET a la ruta /users/{user_id} con el id del usuario:

GET /users/1

Para actualizar un usuario se realiza una solicitud PUT a la ruta /users/{user_id} con el id del usuario y un objeto user:

PUT /users/1
Content-Type: application/json

{
    "id": 1,
    "name": "user2",
    "email": "dmsaavedra@espe.edu.ec"
}

Para eliminar un usuario se realiza una solicitud DELETE a la ruta /users/{user_id} con el id del usuario:

DELETE /users/1

En este ejemplo se ha utilizado Pydantic para definir un modelo de datos User y validar los datos que se reciben en las solicitudes. Pydantic permite definir esquemas de datos y validarlos, lo que facilita la creación de APIs con FastAPI.

En este capítulo se ha mostrado cómo utilizar Pydantic en FastAPI para definir modelos de datos y validar los datos que se reciben en las solicitudes. Pydantic es una librería de Python que permite definir esquemas de datos y validarlos, lo que facilita la creación de APIs con FastAPI.