Assembler le parcours d’import

Un lecteur CSV et une fonction d’écriture JSON ne suffisent pas à réaliser un import : il faut aussi les appeler dans le bon ordre et transmettre des données cohérentes entre les modules. Dans cette leçon, vous assemblez un parcours complet : le programme reçoit le chemin du relevé, valide ses lignes, puis enregistre les dépenses acceptées dans un fichier JSON.

Les leçons précédentes ont défini la lecture et la validation CSV, l’écriture JSON et la gestion des erreurs de données. Vous allez maintenant faire circuler leurs résultats depuis main.py, sans déplacer dans le point d’entrée la logique qui appartient aux modules spécialisés.

Définir le contrat des données

Pour que les modules puissent coopérer, fixez une représentation commune d’une dépense. Le parcours ci-dessous utilise un dictionnaire avec les clés date, libelle et montant : la date reste une chaîne au format ISO, le libellé une chaîne et le montant un nombre. C’est le format produit par la validation CSV et transmis ensuite à l’écriture JSON.

date,libelle,montant
2025-01-15,Courses,42.80
2025-01-16,Transport,18.50

Les noms de colonnes correspondent au contrat attendu par le lecteur et le validateur. Placez ce fichier à la racine du projet pour les commandes de démonstration de cette leçon, ou transmettez un autre chemin lors de l’exécution. Le point d’entrée ne doit pas interpréter les colonnes lui-même : il délègue cette tâche à fichiers.py.

Orchestrer l’import dans le point d’entrée

Remplacez le contenu de depenses/main.py par le fichier complet ci-dessous. La fonction importer_releve coordonne trois étapes : demander à fichiers.py les dépenses validées, écrire leur état JSON, puis annoncer le nombre de lignes importées. Le bloc de lancement traite les erreurs attendues au niveau où un message peut être présenté à la personne qui lance la commande.

import argparse
import sys

from depenses.fichiers import lire_releve_csv, sauvegarder_json


def importer_releve(chemin_csv, chemin_json):
    depenses = lire_releve_csv(chemin_csv)
    sauvegarder_json(chemin_json, depenses)
    return len(depenses)


def main():
    parseur = argparse.ArgumentParser(
        description="Importe un relevé CSV et enregistre les dépenses en JSON."
    )
    parseur.add_argument("fichier_csv", help="Chemin du relevé CSV à importer")
    parseur.add_argument(
        "--sortie",
        default="depenses.json",
        help="Chemin du fichier JSON produit (par défaut : depenses.json)",
    )
    arguments = parseur.parse_args()

    try:
        nombre = importer_releve(arguments.fichier_csv, arguments.sortie)
    except (OSError, ValueError) as erreur:
        print(f"Import impossible : {erreur}", file=sys.stderr)
        return 1

    print(f"Import terminé : {nombre} dépense(s) enregistrée(s) dans {arguments.sortie}.")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Exécuter et vérifier le parcours

Depuis la racine du projet, lancez le module en lui donnant le relevé. Le fichier de sortie peut être précisé avec --sortie ; s’il n’est pas indiqué, le programme écrit dans depenses.json. La commande ci-dessous suppose que l’environnement et les dépendances du projet ont déjà été préparés conformément aux leçons précédentes.

python -m depenses.main depenses.csv --sortie depenses.json

Import terminé : 2 dépense(s) enregistrée(s) dans depenses.json.

Après une exécution réussie, depenses.json contient les deux dictionnaires validés par le lecteur CSV, sous forme de tableau JSON. Vous pouvez l’ouvrir pour contrôler les clés et les valeurs : le montant demeure numérique et le texte accentué, s’il y en a, doit être conservé par l’écriture UTF-8 déjà mise en place dans fichiers.py.

[
  {
    "date": "2025-01-15",
    "libelle": "Courses",
    "montant": 42.8
  },
  {
    "date": "2025-01-16",
    "libelle": "Transport",
    "montant": 18.5
  }
]

Essayez également un chemin CSV inexistant ou une ligne dont le montant ne peut pas être converti. Le programme doit afficher l’erreur utile renvoyée par le module de fichiers et s’arrêter avec un code d’échec ; il ne doit pas produire un état présenté comme valide. La validation détaillée ligne par ligne reste celle de la leçon précédente, et cet assemblage en réutilise le résultat plutôt que de la dupliquer.

À retenir

• Le point d’entrée orchestre les appels ; les modules CSV et JSON conservent leurs responsabilités propres.
• Un contrat commun — date, libellé et montant — permet de transmettre les dépenses d’un module à l’autre.
• Le programme n’écrit l’état JSON qu’après le retour réussi de la lecture et de la validation.
• Une erreur attendue est présentée clairement et entraîne un code de sortie d’échec, sans être avalée.

Dans la prochaine leçon, vous réutiliserez les dépenses importées et un taux de change pour convertir les montants et calculer un total dans une devise cible.