Zaczniemy od poznania kluczowych funkcji FastAPI i głównych przypadków użycia. Następnie uruchomimy pierwszą aplikację i ją przetestujemy! Na koniec poznamy szczegóły obsługi operacji GET i POST – z parametrami żądania – oraz zbudujemy i przetestujemy odpowiednie endpointy.

Dlaczego FastAPI?

Pierwsza aplikacja

FastAPI vs. Django

Operacje GET

Hello world

Hej, kto tam?

Operacje POST

Model Pydantic

Operacja POST w praktyce

Podstawy FastAPI

Zaczniemy od obsługi operacji PUT i DELETE w FastAPI. Następnie nauczymy się, jak radzić sobie z różnymi błędami i zawsze zwracać odpowiedni kod statusu w odpowiedzi. Na koniec poznamy zastosowanie async do obsługi współbieżnych żądań, co pozwala na pracę przy większym obciążeniu.

Operacje PUT i DELETE

Operacja PUT w praktyce

Operacja DELETE w praktyce

Obsługa błędów

Klasyfikacja kodów stanu

Obsługa błędu klienta

Użycie async do współbieżnego przetwarzania

Kiedy używać async?

Asynchroniczna operacja DELETE

FastAPI – tematy zaawansowane

Zaczniemy od pisania testów systemowych sprawdzających poszczególne endpointy FastAPI. Następnie zbudujemy pełne API CRUD w formacie JSON do zarządzania cyklem życia obiektów przez HTTP. Na koniec nauczymy się testować współpracę różnych endpointów aplikacji za pomocą ręcznych testów funkcjonalnych.

Automatyczne testowanie w FastAPI

Opcje

Testy jednostkowe

Testy systemowe

Testy jednostkowe a testy systemowe

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 systemowy

Budowanie JSON CRUD API

Create

Read

Update

Operacje HTTP a kroki CRUD

Odpowiedź operacji 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}."}

Kompletne JSON CRUD API

Pisanie manualnego testu funkcjonalnego

Testy funkcjonalne

Testy systemowe a testy funkcjonalne

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 funkcjonalny

Podsumowanie

Budowanie i testowanie API CRUD w formacie JSON

Ten kurs uczy, jak budować produkcyjne aplikacje webowe przy użyciu FastAPI – popularnego frameworka Pythona do tworzenia API. Nauczysz się obsługiwać wszystkie cztery operacje HTTP, definiować schematy żądań i odpowiedzi, walidować żądania API oraz zwracać odpowiednie kody statusu HTTP. Poznasz też asynchroniczne wykonywanie kodu w celu poprawy wydajności, a na koniec zbudujesz API CRUD i przetestujesz przepływy pracy przy użyciu modułu requests. Kurs jest przeznaczony dla doświadczonych programistów Pythona i wyposaża cię w umiejętności zarządzania danymi za pomocą FastAPI – przygotowując do budowania solidnych potoków zarządzania danymi i serwowania modeli uczenia maszynowego.

<h2>Wprowadzenie do FastAPI i jego zastosowań</h2> API są powszechnie używane do zarządzania danymi w sieci, a FastAPI to popularny nowy framework webowy do tworzenia API w Pythonie. Inżynierowie danych i uczenia maszynowego wykorzystują FastAPI do tworzenia aplikacji, które w sieci obsługują transakcje danych i potoki uwzględniające kontekst.<br><br> <h2>Tworzenie aplikacji internetowych klasy produkcyjnej z FastAPI</h2> W tym kursie nauczysz się tworzyć aplikacje internetowe klasy produkcyjnej, wykorzystując swoje umiejętności Pythona z frameworkiem FastAPI. Na koniec zrozumiesz kluczowe zastosowania FastAPI w odniesieniu do innych frameworków webowych Pythona. Nauczysz się tworzyć API, korzystając ze wszystkich czterech typów operacji HTTP, oraz definiować schematy żądań i odpowiedzi. Dodatkowo będziesz walidować żądania API, odpowiadać odpowiednimi kodami statusu HTTP i komunikatami oraz wykonywać kod asynchronicznie, aby poprawić wydajność aplikacji. Praktyczny projekt poprowadzi Cię przez tworzenie klasycznego API CRUD (Create, Read, Update, Delete) oraz testowanie przepływów pracy za pomocą modułu requests w Pythonie.<br><br> <h2>Cele kursu i grupa docelowa</h2> Ten kurs jest przeznaczony dla doświadczonych programistów Pythona, którzy chcą tworzyć aplikacje webowe do zarządzania danymi z użyciem FastAPI. Po ukończeniu tego kursu zdobędziesz podstawy niezbędne do tworzenia projektów FastAPI odpowiednich do zarządzania danymi o dużej przepustowości oraz potoków do udostępniania modeli ML.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Twórz solidne API z FastAPI, opanuj operacje HTTP, walidację i asynchroniczność dla efektywnych danych.

Wprowadzenie do FastAPI

Twórz solidne, produkcyjne API z FastAPI, opanuj operacje HTTP, walidację i asynchroniczne wykonanie, by budować wydajne potoki danych i ML.


Kompletne JSON CRUD API

Wprowadzenie do FastAPI

Interaktywne ćwiczenie praktyczne