Pybites Platform

Back

Food logging crud

Pybites

Level: Intermediate (score: 3)

In this Bite you will use the Pydantic FoodEntry model (which contains the Food and User models as well).

You will create the CRUD (create-read-update-delete) for this model repeating what you've learned in FastAPI Bites 3, 4 and 5.

Here are the endpoints you need to implement with their inputs and responses:

- / [POST] -> receives a FoodEntry, adds it to food_log and returns it.

- /users/{user_id} [GET] -> receives a user_id, filters food_log and returns the foods logged for that user (List[FoodEntry]).

- /{entry_id} [PUT] -> receives an entry_id and new FoodEntry, updates the corresponding entry and returns the new FoodEntry, raises an HTTPException if the entry is not found.

- /{entry_id} [DELETE] -> receives an entry_id and deletes it from food_log, raises an HTTPException if the entry is not found.

We'll hide the previous Food CRUD in the template for now to force the deliberate practice!

Because the platform supports single modules only for exercises, we embedded all three Pydantic models so you might need to scroll down a bit.

Again, we use an in-memory dictionary (food_log: Dict[int, Food]) to focus on the FastAPI / Pydantic (typing) part.

In the SQLModel learning path we'll cover databases and ORMs.

At the end of this Bite you'll have a simple API to track foods. Super exciting!

But it's not very robust yet, so in the next Bite we'll add exception handling.

Then we take a detour to some web development, having you show a user's food log in an HTML template.

In the final Bite we'll lock down the API so only logged-in users can track their own foods.

Note that if you want to code this Bite offline you need to pip install the bcrypt library.

FastAPI

Code
Tests

from datetime import datetime
from typing import Any, Dict, List

from fastapi import FastAPI
from passlib.context import CryptContext
from pydantic import BaseModel

# https://fastapi.tiangolo.com/tutorial/security/oauth2-jwt/
# We'll export authentication further in a later Bite
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

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

class Food(BaseModel):
    id: int
    name: str
    serving_size: str
    kcal_per_serving: int
    protein_grams: float
    fibre_grams: float = 0

class User(BaseModel):
    id: int
    username: str
    password: str

def __init__(self, **data: Any):
        data["password"] = get_password_hash(data["password"])
        super().__init__(**data)

class FoodEntry(BaseModel):
    id: int
    user: User
    food: Food
    date_added: datetime = datetime.now()
    number_servings: float

@property
    def total_calories(self):
        return self.food.kcal_per_serving * self.number_servings

app = FastAPI()
food_log: Dict[int, FoodEntry] = {}

# We've hidden the previous Food CRUD to keep it compact and to force you to
# repeat the API building process (deliberate practice is key!)

# Create CRUD endpoints for FoodEntry below as per instructions in the Bite ...

import pytest
from fastapi.testclient import TestClient

from app import FoodEntry, app, pwd_context

LAME_PASSWORD = "1234"  # noqa S105

# also from https://fastapi.tiangolo.com/tutorial/security/oauth2-jwt/
def _verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

@pytest.fixture(scope="session")
def client():
    client = TestClient(app)
    return client

@pytest.fixture(scope="session")
def user1():
    user = dict(id=1, username="user1", password=LAME_PASSWORD)
    return user

@pytest.fixture(scope="session")
def user2():
    user = dict(id=2, username="user2", password=LAME_PASSWORD)
    return user

@pytest.fixture(scope="session")
def food1():
    food = dict(
        id=1,
        name="egg",
        serving_size="piece",
        kcal_per_serving=78,
        protein_grams=6.2,
        fibre_grams=0,
    )
    return food

@pytest.fixture(scope="session")
def food2():
    food = dict(
        id=2,
        name="oatmeal",
        serving_size="100 grams",
        kcal_per_serving=336,
        protein_grams=13.2,
        fibre_grams=10.1,
    )
    return food

@pytest.fixture(autouse=True, scope="session")
def create_food_entries(client, user1, user2, food1, food2):
    payload = dict(id=1, user=user1, food=food1, number_servings=1.5)
    client.post("/", json=payload)
    payload = dict(id=2, user=user2, food=food2, number_servings=2.2)
    client.post("/", json=payload)

def test_get_foods_user1(client):
    resp = client.get("/users/1")
    data = resp.json()
    assert len(data) == 1
    entry = data[0]
    assert entry["id"] == 1
    assert entry["user"]["username"] == "user1"
    assert entry["food"]["name"] == "egg"
    assert entry["number_servings"] == 1.5
    assert FoodEntry(**entry).total_calories == 117.0

def test_get_foods_user2(client, user2):
    new_food = dict(
        id=3,
        name="almendras",
        serving_size="20 grams",
        kcal_per_serving=104,
        protein_grams=2.3,
        fibre_grams=1.1,
    )
    payload = dict(id=3, user=user2, food=new_food, number_servings=2)
    client.post("/", json=payload)
    resp = client.get("/users/2")
    data = resp.json()
    assert len(data) == 2
    assert data[0]["food"]["name"] == "oatmeal"
    assert data[1]["food"]["name"] == "almendras"
    assert data[0]["user"]["id"] == 2
    assert data[1]["user"]["id"] == 2
    assert data[0]["number_servings"] == 2.2
    assert data[1]["number_servings"] == 2.0
    # need to create Pydantic model to test property
    assert FoodEntry(**data[0]).total_calories == 739.2
    assert FoodEntry(**data[1]).total_calories == 208.0
    # clean up for next tests (price of having global dict)
    client.delete("/3")

def test_update_food_entry(client):
    entry = client.get("/users/1").json()[0]
    assert entry["number_servings"] == 1.5
    new_entry = entry.copy()
    new_entry["number_servings"] = 3
    client.put(f"/{entry['id']}", json=new_entry)
    entry = client.get("/users/1").json()[0]
    assert entry["number_servings"] == 3.0

def test_update_nonexisting_food_entry_returns_404(client):
    entry = client.get("/users/2").json()[0]
    resp = client.put("/3", json=entry)
    assert resp.status_code == 404
    assert resp.json() == {"detail": "Food entry not found"}

def test_delete_food_entry(client):
    resp = client.delete("/2")
    assert resp.json() == {"ok": True}
    # user1's item still there
    assert len(client.get("/users/1").json()) == 1
    # user2's item deleted
    assert len(client.get("/users/2").json()) == 0

def test_delete_nonexisting_food_entry_returns_404(client):
    resp = client.delete("/3")
    assert resp.status_code == 404
    assert resp.json() == {"detail": "Food entry not found"}