Comment valider et structurer les données avec Pydantic en Python

La validation des données joue un rôle crucial dans les applications modernes, en particulier dans les systèmes où la sécurité et l'intégrité des données sont essentielles. L'outil Pydantic, basé sur Python, permet de valider, sérialiser et désérialiser des structures de données de manière flexible et robuste. Cependant, un aspect souvent sous-estimé de la validation est la manière dont les modèles peuvent être utilisés pour s'assurer que les données respectent des contraintes spécifiques, qu'elles soient liées à des conditions internes ou à des normes externes.

Prenons, par exemple, un cas simple de validation où nous devons garantir que certains champs d'un modèle respectent des règles préétablies, comme l'égalité de deux mots de passe. Pour cela, on utilise un model_validator qui est un décorateur permettant de réaliser des vérifications avant ou après la création du modèle. Imaginons que nous ayons un modèle utilisateur avec deux champs de mot de passe, password1 et password2, et nous voulons nous assurer que ces deux mots de passe sont identiques. Le code suivant permet de réaliser cette validation :

python
Copy code
@model_validator(mode='after')

def check_passwords_match(self) -> Self:
    pw1 = self.password1
    pw2 = self.password2
    if pw1 is not None and pw2 is not None and pw1 != pw2:
        raise ValueError('Les mots de passe ne correspondent pas')
    return self

Dans cet exemple, après la création de l'instance, la méthode vérifie si les deux mots de passe sont différents et lève une exception si nécessaire.

Un autre cas fréquent est la validation de données privées, comme les numéros de sécurité sociale ou les informations bancaires. Lorsqu'une telle donnée est incluse dans un modèle, il est essentiel de la vérifier et de s'assurer qu'elle ne soit pas présente dans les données désérialisées, comme le montre le code suivant :

python
Copy code
@model_validator(mode='before')

@classmethod
def check_private_data(cls, data: Any) -> Any:
    if isinstance(data, dict):

        assert ('private_data' not in data), 'Les données privées ne doivent pas être incluses'

    return data

Ici, l'on vérifie que le champ private_data n'est pas présent dans le dictionnaire des données. Si ce champ existe, une erreur est levée avant même que le modèle ne soit instancié.

En pratique, lorsque l'on désérialise les données (par exemple, des informations d'un formulaire ou d'une API), il est important de tester la validité des données avant leur traitement. Prenons un exemple concret où des données utilisateurs sont envoyées à un modèle pour validation :

python
Copy code
usr_data = {

    "id": 1,
    "username": "freethrow",
    "email": "[email protected]",
    "password1": "password123",
    "password2": "password456",
    "private_data": "some private data",
}
try:
    user = UserModelV.model_validate(usr_data)
    print(user)
except ValidationError as e:
    print(e)

Dans ce cas, Pydantic lèvera une erreur avant même de valider les mots de passe, car il détectera que le champ private_data est présent, ce qui est interdit. Cela démontre l'importance de définir des règles strictes sur les données que l'on accepte.

Une autre caractéristique puissante de Pydantic est sa capacité à gérer des modèles imbriqués, ce qui permet de structurer des données complexes de manière claire et maintenable. Prenons l'exemple d'une structure de données représentant des marques de voitures et leurs modèles. Cela peut être facilement validé avec Pydantic en créant des modèles imbriqués.

Pour commencer, on définit d'abord un modèle pour un véhicule :

python
Copy code
class CarModel(BaseModel):

    model: str
    year: int

Puis, on crée un modèle pour la marque de la voiture, qui inclut une liste de modèles :

python
Copy code
class CarBrand(BaseModel):
    brand: str
    models: List[CarModel]
    country: str

Avec cette approche, chaque marque de voiture contient une liste de modèles, chacun ayant des informations spécifiques sur le modèle et l'année. Ce type de structure permet d'exprimer des hiérarchies de données complexes de manière naturelle et intuitive.

Cependant, lorsque l'on parle de gestion de la configuration des applications, un autre aspect important à considérer est la gestion des variables d'environnement. Pydantic offre un moyen simple et structuré de charger les configurations depuis des fichiers .env ou des variables d'environnement, ce qui est essentiel pour les applications modernes, notamment pour gérer des secrets comme les clés API ou les URLs de bases de données.

Voici un exemple simple de la manière dont Pydantic gère ces configurations avec sa classe BaseSettings :

python
Copy code
from pydantic import BaseSettings, Field
class Settings(BaseSettings):
    api_url: str = Field(default="")
    secret_key: str = Field(default="")
    class Config:
        env_file = ".env"
print(Settings().model_dump())

Il est essentiel de noter que Pydantic ne se contente pas de valider des données statiques. Il offre également la possibilité de transformer les données lors de la désérialisation ou de la validation, permettant ainsi une flexibilité accrue dans la gestion des entrées et des sorties.

En résumé, Pydantic est un outil puissant pour la validation des données en Python, permettant une validation flexible et robuste des données d'entrée, tout en garantissant l'intégrité des données tout au long du processus. En combinant des fonctionnalités comme la validation de données imbriquées, la gestion des secrets via des fichiers d'environnement et la validation conditionnelle des modèles, Pydantic s'affirme comme un choix de choix pour les applications Python modernes.

Comment intégrer et utiliser les valeurs de contexte dans une application React pour l'authentification

Le premier élément fondamental à inclure dans le contexte est le JWT (JSON Web Token), car cela constitue la base même du processus d'authentification. En plus du JWT, il est important de stocker l'utilisateur actuellement connecté et de gérer un message d'état qui permettra d'afficher des informations sur l'application. Ce message d'état pourrait, par exemple, indiquer si l'utilisateur est bien connecté ou si une erreur est survenue lors de la tentative d'authentification. Cependant, l'une des caractéristiques les plus puissantes du contexte est sa capacité à contenir et à transmettre des fonctions, ce qui permet de manipuler directement les données. C’est pourquoi, en plus des informations relatives à l'utilisateur, il est pertinent d’ajouter des fonctions de gestion d'authentification telles que register, login et logout.

Pour débuter, après avoir défini les variables d'état nécessaires (comme user, jwt, et message), il faut ajouter les fonctions d'enregistrement, de connexion et de déconnexion. Par exemple, la fonction register permet d’enregistrer un nouvel utilisateur en envoyant une requête POST au serveur. Si l'enregistrement est réussi, un message confirmant la réussite de l'opération est affiché, sinon un message d'erreur s'affiche.

javascript
Copy code
const register = async (username, password) => {

  try {
    const response = await fetch('http://127.0.0.1:8000/users/register', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ username, password }),
    });
    if (response.ok) {
      const data = await response.json();
      setMessage(`Enregistrement réussi : utilisateur ${data.username} créé`);
    } else {
      const data = await response.json();
      setMessage(`Échec de l'enregistrement : ${JSON.stringify(data)}`);
    }
  } catch (error) {
    setMessage(`Échec de l'enregistrement : ${JSON.stringify(error)}`);
  }
};

javascript
Copy code
const login = async (username, password) => {
  setJwt(null);

  const response = await fetch('http://127.0.0.1:8000/users/login', {

    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ username, password }),
  });
  if (response.ok) {
    const data = await response.json();
    setJwt(data.token);
    setUser({ username });
    setMessage(`Connexion réussie : token ${data.token.slice(0, 10)}..., utilisateur ${username}`);
  } else {
    const data = await response.json();
    setMessage(`Échec de la connexion : ${data.detail}`);
    setUser({ username: null });
  }
};

La fonction logout complète ce processus en permettant à l'utilisateur de se déconnecter. Elle efface simplement les données relatives à l'utilisateur et au JWT stockées dans le contexte, et affiche un message confirmant la déconnexion.

javascript
Copy code
const logout = () => {

  setUser(null);
  setJwt(null);
  setMessage('Déconnexion réussie');
};

Une fois ces fonctions définies, le contexte doit les fournir à l’ensemble des composants concernés. Cela se fait en modifiant le return du AuthContext.Provider pour inclure toutes les valeurs nécessaires : l'utilisateur, le JWT, les fonctions d'authentification, et le message d'état.

javascript
Copy code
return (

  <AuthContext.Provider value={{ user, jwt, register, login, logout, message, setMessage }}>
    {children}
  </AuthContext.Provider>
);

javascript
Copy code
export const useAuth = () => useContext(AuthContext);

Cette approche permet à chaque composant ayant besoin des données d'authentification (par exemple, Login, Register, Message, Users) d'accéder facilement au contexte en utilisant ce hook.

Il convient maintenant d'intégrer le contexte d'authentification dans l'application. Dans le fichier App.jsx, il suffit d'enrouler les composants avec le AuthProvider pour leur donner accès au contexte.

javascript
Copy code
import { AuthProvider } from './AuthContext';

const App = () => {
  return (
    <AuthProvider>
      {/* Composants de l'application */}
    </AuthProvider>
  );
};
export default App;

Ensuite, vous pouvez créer des composants spécifiques comme Register pour l’enregistrement des utilisateurs. Ce composant doit permettre à l'utilisateur de saisir un nom d'utilisateur et un mot de passe, puis appeler la fonction register depuis le contexte.

javascript
Copy code
import { useState } from 'react';

import { useAuth } from './AuthContext';
const Register = () => {
  const [username, setUsername] = useState('');
  const [password, setPassword] = useState('');
  const { register } = useAuth();
  const handleSubmit = (e) => {
    e.preventDefault();
    register(username, password);
    setUsername('');
    setPassword('');
  };
  return (
    <form onSubmit={handleSubmit}>
      <input
        type="text"
        value={username}
        onChange={(e) => setUsername(e.target.value)}
      />
      <input
        type="password"
        value={password}
        onChange={(e) => setPassword(e.target.value)}
      />
      <button type="submit">S'inscrire</button>
    </form>
  );
};
export default Register;

Les autres composants, comme Login et Users, suivront une approche similaire pour utiliser le contexte d'authentification et afficher les informations nécessaires selon l'état de l'utilisateur.

Il est important de noter que, bien que ce système soit parfaitement adapté pour des applications simples ou pour des démonstrations, dans un environnement de production, il est essentiel de considérer des aspects supplémentaires comme la gestion des erreurs de manière plus détaillée, la validation des champs de formulaire, et l'utilisation d'un mécanisme de stockage persistant (par exemple, localStorage ou cookies) pour le JWT. Cela permettrait d'améliorer la sécurité, la fiabilité et l'expérience utilisateur.