Vom începe prin a învăța funcționalitățile cheie și principalele cazuri de utilizare ale FastAPI. Apoi vom rula prima aplicație și o vom testa! În final, vom aprofunda detaliile operațiunilor GET și POST, inclusiv parametrii de cerere, și vom construi și testa acele endpoint-uri.

De ce FastAPI?

Prima aplicație

FastAPI vs. Django

Operațiuni GET

Hello world

Salut, cine ești?

Operațiuni POST

Model Pydantic

Operațiunea POST în acțiune

Noțiuni de bază FastAPI

Vom începe prin a învăța cum să suportăm operațiunile PUT și DELETE în FastAPI. Vom continua cu gestionarea diferitelor tipuri de erori și returnarea întotdeauna a unui cod de stare corespunzător în răspuns. La final, vom vedea cum să folosim `async` pentru a permite cereri concurente capabile să gestioneze volume de lucru mai mari.

Operațiuni PUT și DELETE

Operațiunea PUT în practică

Operațiunea DELETE în acțiune

Gestionarea erorilor

Clasificarea codurilor de stare

Gestionarea unei erori de client

Utilizarea async pentru lucrul concurent

Când ar trebui să folosim async?

Operațiune DELETE asincronă

Subiecte avansate FastAPI

Vom începe prin a învăța cum să scriem teste de sistem pentru a valida endpoint-uri FastAPI individuale. Vom construi apoi un API CRUD JSON complet pentru a gestiona ciclul de viață al obiectelor prin HTTP. În final, vom învăța cum să testăm diferite endpoint-uri ale aplicației lucrând împreună, prin teste funcționale manuale.

Testare automată cu FastAPI

Opțiuni

Teste unitare

Teste de sistem

Teste unitare vs. teste de sistem

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 de sistem

Construirea unui API JSON CRUD

Creare

Citire

Actualizare

Operații HTTP și pașii CRUD

Răspunsul operației 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 CRUD JSON complet

Scrierea unui test funcțional manual

Teste funcționale

Teste de sistem vs. teste funcționale

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 funcțional

Concluzie

Construirea și testarea unui API CRUD JSON

Acest curs te învață să construiești aplicații web de nivel producție folosind FastAPI, un framework Python popular pentru crearea de API-uri. Vei învăța să gestionezi toate cele patru operațiuni HTTP, să definești scheme de cereri și răspunsuri, să validezi cererile API și să returnezi codurile de stare HTTP corespunzătoare. Vei aborda, de asemenea, execuția asincronă a codului pentru a îmbunătăți performanța, iar la final vei dezvolta un API CRUD și vei testa fluxuri de lucru cu modulul `requests` din Python. Destinat programatorilor Python cu experiență, acest curs îți oferă abilitățile necesare pentru a gestiona date cu FastAPI, pregătindu-te să construiești pipeline-uri robuste de gestionare a datelor și de servire a modelelor ML.

<h2>Introducere în FastAPI și aplicațiile sale</h2> API-urile sunt folosite frecvent pentru a gestiona date pe web, iar FastAPI este un framework web nou și popular pentru construirea de API-uri cu Python. Inginerii de date și machine learning folosesc FastAPI pentru a construi aplicații care servesc drept tranzacții și pipeline-uri de date context-aware pe web.<br><br> <h2>Construirea de aplicații web de nivel de producție cu FastAPI</h2> În acest curs, vei învăța cum să construiești aplicații web de nivel de producție valorificându-ți abilitățile de Python cu framework-ul FastAPI. Până la final, vei înțelege principalele cazuri de utilizare pentru FastAPI în raport cu alte framework-uri web Python. Vei învăța să construiești API-uri folosind toate cele patru tipuri de operațiuni HTTP și să definești schemele de request și response. În plus, vei valida cererile API, vei răspunde cu coduri de stare HTTP și mesaje adecvate și vei executa codul asincron pentru a îmbunătăți performanța aplicației. Un proiect practic te va ghida prin construirea unui API CRUD clasic (Create, Read, Update, Delete), testând fluxurile de lucru folosind modulul requests din Python.<br><br> <h2>Obiectivele cursului și publicul țintă</h2> Acest curs este conceput pentru programatori Python cu experiență care vor să construiască aplicații web care gestionează date folosind FastAPI. După finalizarea acestui curs, vei avea baza necesară pentru a crea proiecte FastAPI potrivite pentru gestionarea datelor cu volum mare și pentru pipeline-uri de servire a modelelor ML.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Construiește API-uri robuste cu FastAPI, stăpânind operațiunile HTTP, validarea și execuția asincronă.

Introducere în FastAPI

Creează API-uri robuste, de nivel producție, cu FastAPI, stăpânind operațiunile HTTP, validarea și execuția async pentru pipeline-uri eficiente de date și ML.


Test funcțional

Introducere în FastAPI

Exercițiu interactiv practic