We’ll start by learning FastAPI’s key features and core use cases. Then we will run our first application and test it out! Finally, we will learn the details of supporting GET and POST operations that include request parameters and build and test those endpoints.

Why FastAPI?

First application

FastAPI vs. Django

GET operations

Hello world

Hello who?

POST operations

Pydantic model

POST operation in action

FastAPI Basics

We’ll start by learning how to support PUT and DELETE operations using FastAPI. Then we will learn how to handle different kinds of errors and always return an appropriate status code in the response. Lastly we'll learn how to use async to enable concurrent requests that can handle higher workloads.

PUT and DELETE operations

PUT operation in action

DELETE operation in action

Handling errors

Status code classification

Handling a client error

Using async for concurrent work

When should we use async?

Asynchronous DELETE operation

FastAPI Advanced topics

We'll start by learning how to write system tests to validate individual FastAPI endpoints. Next we'll build a full JSON CRUD API to manage object lifecycles over HTTP. Finally, we'll learn how to test different application endpoints working together with manual functional tests.

Test automatizzati con FastAPI

Opzioni

Unit test

System test

Unit test vs. system test

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {"scissors": Item(name="scissors", quantity=100)}


@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]

# Import TestClient
from fastapi.testclient import ____
from main import app

# Create test client with application context
client = TestClient(____)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": ____}

# Import TestClient
from fastapi.testclient import TestClient
from main import app

# Create test client with application context
client = TestClient(app)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": 100}

Test di sistema

Creare una API CRUD JSON

Create

Read

Update

Operazioni HTTP e passaggi CRUD

Risposta dell'operazione DELETE

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.____("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.____("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    return items[name]  
  
@app.____("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.post("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]  
  
@app.put("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

API JSON CRUD completa

Scrivere un test funzionale manuale

Test funzionali

Test di sistema vs. test funzionali

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == ____
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?____=____")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == ____

# Delete item "rock"
r = requests.delete(ENDPOINT, json={____: ____})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == ____

print("Test complete.")

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 100

# Delete item "rock"
r = requests.delete(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 404

print("Test complete.")

Test funzionale

Riepilogo

Building and testing a JSON CRUD API

Questo corso ti insegna a creare applicazioni web pronte per la produzione con FastAPI, un popolare framework Python per sviluppare API. Imparerai a gestire le quattro operazioni HTTP, definire gli schemi di richiesta e risposta, convalidare le richieste alle API e restituire i codici di stato HTTP appropriati. Tratteremo anche l’esecuzione asincrona per aumentare le prestazioni e, alla fine, svilupperai una CRUD API e testerai i flussi di lavoro con il modulo requests di Python. Progettato per programmatori Python esperti, questo corso ti fornisce le competenze per gestire i dati con FastAPI, preparandoti a creare pipeline robuste per la gestione dei dati e la pubblicazione di modelli di ML.

<h2>Introduzione a FastAPI e alle sue applicazioni</h2> Le API sono spesso usate per gestire i dati sul web, e FastAPI è un nuovo framework web molto usato per creare API con Python. Gli ingegneri dei dati e dell'apprendimento automatico usano FastAPI per creare app che funzionano come transazioni e pipeline di dati sensibili al contesto sul web.<br><br> <h2>Creare app web pronte per l'uso con FastAPI</h2> In questo corso imparerai a creare app web di livello professionale usando le tue competenze Python con il framework FastAPI. Alla fine, capirai i casi d'uso principali di FastAPI rispetto ad altri framework web Python. Imparerai a creare API usando tutti e quattro i tipi di operazioni HTTP e a definire schemi di richiesta e risposta. In più, dovrai controllare le richieste API, rispondere con i codici di stato HTTP e i messaggi giusti ed eseguire il codice in modo asincrono per migliorare le prestazioni dell'applicazione. Un progetto pratico ti aiuterà a creare una classica API CRUD (Create, Read, Update, Delete) e a testare i flussi di lavoro usando il modulo requests di Python.<br><br> <h2>Obiettivi del corso e a chi è rivolto</h2> Questo corso è pensato per programmatori Python esperti che vogliono creare applicazioni web che gestiscono dati usando FastAPI. Finito questo corso, avrai le basi per creare progetti FastAPI adatti alla gestione di dati ad alta velocità e alle pipeline di ML model-serving.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Crea API robuste con FastAPI, padroneggiando operazioni HTTP, validazione ed esecuzione asincrona.

Operazioni HTTP e passaggi CRUD

Introduzione a FastAPI

Esercizio pratico interattivo