Aperçu de l'apprentissage FastAPI

FastAPI est un framework Web moderne et rapide (haute performance) basé sur des types Python standard pour la création d'API. Il est basé sur des astuces de type Python standard et ses principaux avantages sont la vitesse, la sécurité du type et la génération automatique de documentation API.

Si vous envisagez d'utiliser FastAPI, voici quelques points clés et commandes associées que vous devez connaître :

Mise en place :
```
pip install fastapi[all]
pip install uvicorn
```
- fastapi[all]: Installez FastAPI et toutes ses dépendances.
- uvicorn: serveur ASGI, utilisé pour exécuter les applications FastAPI.
Créez une API de base :
```
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {
      
      "Hello": "World"}
```
Analyse : dans cet exemple simple, nous initialisons une application FastAPI et définissons un point de terminaison. Lorsque l'utilisateur fait une requête GET pour le chemin racine ( /), il sera renvoyé {"Hello": "World"}.
Exécutez l'application :
```
uvicorn your_filename:app --reload
```
Analyse : utilisez-la uvicornpour exécuter votre application FastAPI. your_filename:appFait référence au nom de votre fichier Python et au nom de l'instance d'application FastAPI. --reloadPermet le redémarrage automatique après des modifications de code dans l'environnement de développement.
Paramètres de chemin et paramètres de requête :
```
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {
      
      "item_id": item_id, "q": q}
```
Analyse : item_idIl s'agit d'un paramètre de chemin et qd'un paramètre de requête. FastAPI vérifiera automatiquement le type et l'affichera dans la documentation.
Corps de la requête :
importez une structure de données à partir d'un modèle Pydantic et utilisez-la pour valider le corps de la requête.
```
from pydantic import BaseModel

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

@app.post("/items/")
def create_item(item: Item):
    return item
```
Analyse : à l'aide du modèle Pydantic, les données de demande, la sérialisation et la désérialisation peuvent être automatiquement vérifiées, et FastAPI générera automatiquement les documents API pertinents.
Documentation automatique de l'API :
visitez /docspour afficher l'interface Swagger générée automatiquement, ou visitez /redocpour afficher l'interface Redoc.

[Rappel] Ce qui précède ne représente que quelques contenus de base de FastAPI. Le framework fournit également de nombreuses fonctionnalités avancées telles que l'injection de dépendances, la sécurité et OAuth2, les hooks d'événements, etc. Afin de profiter pleinement de FastAPI, il est recommandé de lire en profondeur sa documentation officielle.

Injection de dépendances :

FastAPI utilise un système d'injection de dépendances très puissant. Il vous permet de gérer et de contrôler facilement les connexions aux bases de données, les configurations, etc.

Exemple:
```
def get_db():
    db = "Some DB connection"
    try:
        yield db
    finally:
        db.close()

@app.get("/items/")
def read_items(db=Depends(get_db)):
    return {
      
      "items": "Items from " + db}
```
Analyse : get_dbC'est une fonction dépendante qui sera appelée à chaque fois qu'elle sera demandée. read_itemsCela dépend de get_dbla fonction, il get_dbsera donc exécuté en premier.

Sécurité :

FastAPI offre une variété d'options de sécurité et d'authentification, notamment l'authentification par mot de passe, OAuth2, les jetons Bearer, etc.

Exemple (en utilisant l'authentification HTTP Basic) :

from fastapi import Depends, HTTPException
from fastapi.security import HTTPBasic, HTTPBasicCredentials

security = HTTPBasic()

def get_current_user(credentials: HTTPBasicCredentials = Depends(security)):
    if credentials.username != "alice" or credentials.password != "password":
        raise HTTPException(status_code=400, detail="Incorrect email or password")
    return credentials.username

@app.get("/users/me")
def read_current_user(username: str = Depends(get_current_user)):
    return {
      
      "username": username}

Analyse : l'authentification HTTP Basic est utilisée dans cet exemple. Si le nom d'utilisateur et le mot de passe ne correspondent pas, une erreur HTTP 400 sera renvoyée.

OAuth2 :

OAuth2 est un cadre d'autorisation et FastAPI le prend en charge.

Exemple (en utilisant le mode Mot de passe) :

from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.post("/token")
def login(form_data: OAuth2PasswordRequestForm = Depends()):
    if form_data.username != "alice" or form_data.password != "password":
        raise HTTPException(status_code=400, detail="Incorrect username or password")
    return {
      
      "access_token": form_data.username, "token_type": "bearer"}

@app.get("/users/me")
def read_current_user(token: str = Depends(oauth2_scheme)):
    return {
      
      "token": token}

Résolution : L'utilisateur doit d'abord /tokenobtenir un jeton à l'aide de son nom d'utilisateur et de son mot de passe via le point de terminaison, puis le jeton pourra être utilisé pour les demandes ultérieures.

Crochet d'événement :

FastAPI fournit des « hooks » d'événements ou des rappels qui permettent d'exécuter du code lorsque l'application démarre et s'arrête.

Exemple:
```
@app.on_event("startup")
async def startup_event():
    app.state.database = "Some database connection"

@app.on_event("shutdown")
async def shutdown_event():
    app.state.database.close()
```
Analyse : lorsque l'application démarre, startup_eventla fonction sera appelée et pourra définir l'état de l'application, comme la connexion à la base de données. De même, lorsque l'application est fermée, shutdown_eventla fonction sera appelée et pourra être utilisée pour fermer des ressources, telles que les connexions à la base de données.

Ce ne sont là qu'un bref aperçu des fonctionnalités de FastAPI. Pour bien les comprendre et les utiliser, il est recommandé de consulter la documentation officielle de FastAPI, qui fournit des explications détaillées et des exemples pour chaque fonctionnalité.

Aperçu de l'apprentissage FastAPI

Je suppose que tu aimes