Introduction aux fichiers YAML

YAML est un format de sérialisation des données couramment utilisé pour les fichiers de configuration.

1. Règles syntaxiques de YAML

• L'analyse est sensible à la casse
• La hiérarchie est définie par l'indentation
• L'indentation utilise exclusivement des espaces (pas de tabulations)
• Le nombre d'espaces d'indentation peut varier tant que les éléments de même niveau sont alignés
• Les chaînes simples n'ont pas besoin de guillemets, sauf si elles contiennent des caractères spéciaux
• Les commentaires débutent par le symbole #

2. Structures de données YAML

Mappages : Collections de paires clé-valeur (équivalent des dictionnaires Python). La clé et la valeur sont séparées par deux-points avec un espace.

Séquences : Listes ordonnées d'éléments. Chaque élément est précédé du tiret "-" avec un espace.

Scalars : Valeurs atomiques (chaînes, booléens, nombres entiers/flottants, dates, null). La valeur nulle s'écrit null ou ~.

Lecture de fichiers YAML avec Python

1. Configuration requise

Pour manipuler des fichiers YAML en Python, vous devez installer le paquet PyYAML et imporetr le module yaml :

• Installation : pip3 install pyyaml
• Importation : import yaml

2. Extraction des données YAML

Python ouvre le fichier avec open(), puis convertit le contenu texte en structures Python natives via yaml.safe_load() :

import yaml
import pathlib

def lire_fichier_yaml(chemin_fichier):
    """Charge et parse un fichier YAML"""
    print("--- Lecture du fichier ---")
    with open(chemin_fichier, 'r', encoding='utf-8') as fichier:
        contenu_brut = fichier.read()
    print(contenu_brut)
    
    print("--- Conversion en structure Python ---")
    donnees = yaml.safe_load(contenu_brut)
    print(type(donnees))
    return donnees

# Utilisation
chemin = pathlib.Path.cwd() / "config.yaml"
resultat = lire_fichier_yaml(chemin)

3. Exemples de structures YAML parsées

Mappages simples

# Contenu YAML (config_simple.yaml)
utilisateur: admin
motdepasse: secret123
description: "Paramètres\nprincipaux"

Résultat Python : {'utilisateur': 'admin', 'motdepasse': 'secret123', 'description': 'Paramètres\nprincipaux'}

Mappages imbriqués

# Contenu YAML (config_imbriquee.yaml)
compte1:
  nom: service_a
  cle_api: "ABC-123"
compte2:
  nom: service_b
  cle_api: "XYZ-789"

Résultat Python : {'compte1': {'nom': 'service_a', 'cle_api': 'ABC-123'}, 'compte2': {'nom': 'service_b', 'cle_api': 'XYZ-789'}}

Séquences dans des mappages

# Contenu YAML (config_listes.yaml)
serveurs:
  - web-01.example.com
  - web-02.example.com
  - db-01.example.com
ports:
  - 8080
  - 8443

Résultat Python : {'serveurs': ['web-01.example.com', 'web-02.example.com', 'db-01.example.com'], 'ports': [8080, 8443]}

Séquences contenant des mappages

# Contenu YAML (config_sequence_mappages.yaml)
- environnement: production
  actif: true
- environnement: developpement
  actif: false
  debug: true

Résultat Python : [{'environnement': 'production', 'actif': True}, {'environnement': 'developpement', 'actif': False, 'debug': True}]

4. Gestion des scalaires spéciaux

# Exemples de valeurs scalaires
texte_simple: bonjour
nombre_entier: 42
nombre_decimal: 3.14159
booleen_vrai: oui
booleen_faux: non
valeur_nulle: null
date_iso: 2023-12-31
heure_iso: 2023-12-31T23:59:59Z

Python interprétera ces valeurs avec les types appropriés : str, int, float, bool, None, datetime.date, datetime.datetime.

5. Références et ancres

# Contenu YAML avec ancres
defaults: &config_defaut
  timeout: 30
  retries: 3

service_principal:
  <<: *config_defaut
  endpoint: "https://api.principal.example"

Le résultat Python aura les valeurs de timeout et retries copiées dans la section service_principal.

Traitement de plusieurs documents YAML

1. Structure multi-doucments

Plusieurs documents YAML dans un même fichier sont séparés par --- :

---
type: configuration
version: 2
---
type: donnees
contenu: [a, b, c]

2. Chargement de tous les documents

Utilisez yaml.safe_load_all() pour parcourir chaque document :

def lire_tous_documents(chemin_fichier):
    with open(chemin_fichier, 'r', encoding='utf-8') as f:
        documents = yaml.safe_load_all(f.read())
        for index, doc in enumerate(documents):
            print(f"Document {index}: {doc}")

chemin = pathlib.Path.cwd() / "multi_doc.yaml"
lire_tous_documents(chemin)

Génération de fichiers YAML

1. Avec PyYAML

La fonction yaml.dump() sérialise les objets Python :

def creer_fichier_yaml(chemin_sortie, donnees):
    with open(chemin_sortie, 'w', encoding='utf-8') as f:
        yaml.dump(donnees, f, default_flow_style=False, allow_unicode=True)

config = {
    'base_donnees': {
        'host': 'localhost',
        'port': 5432,
        'utilisateurs': ['admin', 'app']
    }
}

creer_fichier_yaml('nouvelle_config.yaml', config)

2. Avec ruamel.yaml pour un formatage avancé

Le module ruamel.yaml permet un meilleur contrôle du formatage et préserve l'ordre des clés :

from ruamel.yaml import YAML

def generer_yaml_ruamel(chemin, donnees):
    yml = YAML()
    yml.default_flow_style = False
    with open(chemin, 'w', encoding='utf-8') as f:
        yml.dump(donnees, f)

donnees_complexes = [
    {'nom': 'alpha', 'tags': ['important', 'urgent']},
    {'nom': 'beta', 'tags': ['test']}
]

generer_yaml_ruamel('config_ruamel.yaml', donnees_complexes)

3. Lecture avec ruamel.yaml

def lire_yaml_ruamel(chemin):
    yml = YAML()
    with open(chemin, 'r', encoding='utf-8') as f:
        return yml.load(f)

contenu = lire_yaml_ruamel('config_ruamel.yaml')