Aller au contenu
English

Préparer le dépôt

  • Leçon 2
  • 45 min
  • Module 1 : Mettre en place un environnement de travail sûr

Où nous en sommes

Dans la dernière leçon, nous avons vu qu'un agent peut modifier de nombreux fichiers et exécuter des commandes. Après une séance, nous devons savoir exactement ce qu'il a changé, et si un nouvel échec vient de lui. Sans point de départ propre, personne ne peut le dire. Dans cette leçon, nous préparons d'abord le projet : une branche propre, un environnement reproductible et des vérifications qui réussissent aujourd'hui, comme le dessin des égratignures avant de conduire une voiture de location.

Ce que vous saurez faire

Préparez le projet avant de demander quoi que ce soit à un assistant. Il vous faut une branche propre, un environnement reproductible et des vérifications qui réussissent aujourd’hui. Ainsi, chaque modification de l’assistant apparaît dans les différences, et chaque nouvel échec vient de cette modification.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 45 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Python 3.12 ou une version ultérieure, et Git. L’équipe du cours a testé les étapes avec Python 3.14.6 et Git 2.54 sur macOS. La leçon donne aussi les commandes Windows, mais personne ne les a encore testées.
  • Un terminal dans votre dossier de projets, ~/projects, et environ 40 Mo d’espace disque libre.
  • Aucun compte, aucune clé et rien à payer.

Quand vous prenez une voiture de location, un employé en fait le tour avec vous. Ensemble, vous marquez chaque égratignure et chaque bosse sur un dessin de la voiture, puis vous le signez tous les deux. Vous notez aussi le niveau de carburant et le kilométrage.

Pourquoi faire tout cela? Parce que l’entreprise vérifie la voiture à nouveau quand vous la rapportez. Une égratignure sur le dessin était là avant vous. Une égratignure absente du dessin est la vôtre. Sans le dessin, personne ne peut faire la différence. Vous risquez de payer pour des dommages que vous n’avez pas causés.

Avant qu’un assistant modifie votre projet, il vous faut le même dessin.

Le problème : les tests réussissent, mais le rapport a changé

Section intitulée « Le problème : les tests réussissent, mais le rapport a changé »

Voici un cas réel tiré de ce cours. L’équipe du cours a demandé à un assistant : « Ajoutez un moyen de filtrer le rapport par catégorie. » Il a modifié 4 fichiers. Ses nouveaux tests et les anciens ont réussi : 29 passed (29 tests réussis). Aucun échec, donc la modification semblait sûre.

Mais la modification a aussi ajouté une nouvelle clé, "category": null, à chaque rapport, même sans demande de catégorie. L’équipe de Grace importe ce rapport dans une feuille de calcul. La clé supplémentaire peut briser sa feuille, et aucun test n’a signalé le problème. Les anciens tests du projet vérifient des parties du rapport. Mais aucun n’exigeait que « le rapport entier reste exactement comme il est aujourd’hui ».

Il y a un deuxième problème. Supposons qu’un test ait échoué après la modification. Était-il déjà défectueux avant l’intervention de l’assistant, ou la modification l’a-t-elle brisé? Sans exécuter les tests avant, vous ne pouvez pas le savoir. Et si le dossier contenait vos propres modifications non enregistrées, vous ne pourriez même pas reconnaître les lignes de l’assistant.

Un point de départ propre comporte trois parties. Chacune répond à une question que vous poserez après la modification de l’assistant.

  1. Un environnement reproductible. Le projet fonctionne dans un nouvel environnement virtuel, avec les versions exactes de requirements-lock.txt. Il répond à cette question : « L’échec vient-il du code ou de mon ordinateur? »
  2. Une branche propre basée sur un commit. Vous enregistrez chaque fichier dans un commit (un enregistrement des modifications), puis travaillez sur une nouvelle branche. Cela répond à cette question : « Quelles lignes l’assistant a-t-il modifiées? » La réponse vient de git diff. Pour annuler la modification, git restore . remet chaque fichier suivi dans son état du commit. Un nouveau fichier ajouté par la modification reste présent jusqu’à ce que vous le supprimiez.
  3. Des vérifications de référence. Les tests, ruff et une première exécution du programme réussissent, et vous notez ce qu’ils affichent. Elles répondent à cette question : « Cet échec est-il nouveau? »

Une référence de base est l’état connu du projet avant une modification, comme le dessin de la voiture de location. Un test peut en faire partie. Un test de régression échoue quand un comportement qui fonctionnait auparavant change. Une régression logicielle est un recul : quelque chose qui fonctionnait ne fonctionne plus.

Un petit exemple : figer le rapport d’aujourd’hui

Section intitulée « Un petit exemple : figer le rapport d’aujourd’hui »

La première exécution du programme est facile à figer, car sa sortie est un petit fichier JSON. Aujourd’hui, python -m ticket_cleaner data/tickets.csv écrit ce rapport. Ici, une ligne représente les six lignes rejetées :

{
"status": "open",
"valid_records": 9,
"selected": 4,
"by_category": {"billing": 2, "login": 1, "shipping": 1},
"average_priority": 2.0,
"rejected": ["… 6 rows, each with its problem …"]
}

Neuf des 15 lignes sont valides. Quatre sont ouvertes : deux de facturation, une de connexion et une de livraison, avec une priorité moyenne de 2,0. Imaginez un test qui compare le rapport entier à ces valeurs exactes. Il échoue si une clé, un nombre ou un problème change, ou si une nouvelle clé apparaît. C’est le dessin de la voiture.

Vous travaillez dans un nouveau dossier, ticket-cleaner-assist, qui est une copie de l’instantané start (départ) du cours. C’est le projet à la fin du cours de Python, avec une modification faite par un collègue. Le rapport compte maintenant les catégories du nouveau formulaire Web, comme Sign-in (connexion), sous ses propres noms. Cette modification contient un bogue que Grace a trouvé. Le cours le dit ouvertement : vous trouvez le bogue au module 2 et le corrigez au module 4. Votre propre ticket-cleaner du cours de Python ne l’a pas, alors gardez ce dossier tel quel.

  1. Récupérez les fichiers du cours. Si vous avez cloné le dépôt des laboratoires pour un cours précédent, mettez-le à jour dans ~/projects :

    Fenêtre de terminal
    cd ~/projects
    git -C nextia-learning-labs pull

    Si vous ne l’avez pas encore, clonez-le dans ~/projects avec git clone https://github.com/Nextia-Intelligence/nextia-learning-labs.git. Sans Git, téléchargez le fichier ZIP et décompressez-le dans ~/projects. Son dossier s’appelle alors nextia-learning-labs-main : utilisez ce nom à l’étape suivante.

  2. Copiez l’instantané start dans un nouveau dossier, puis ouvrez ce dossier :

    Fenêtre de terminal
    cp -R nextia-learning-labs/C15/snapshots/start ticket-cleaner-assist
    cd ticket-cleaner-assist
  3. Créez l’environnement virtuel, activez-le et installez les versions exactes :

    Fenêtre de terminal
    python3 -m venv .venv
    source .venv/bin/activate
    python -m pip install -r requirements-lock.txt

    L’invite commence maintenant par (.venv), et pip affiche une ligne qui commence par Successfully installed (installation réussie).

  4. Créez un dépôt Git pour que Git puisse montrer chaque modification :

    Fenêtre de terminal
    git init
    git status
    Sortie
    Initialized empty Git repository in /Users/amira/projects/ticket-cleaner-assist/.git/
    On branch main
    No commits yet
    Untracked files:
    (use "git add <file>..." to include in what will be committed)
    .env.example
    .gitignore
    LICENSE
    README.md
    data/
    pyproject.toml
    requirements-lock.txt
    requirements.txt
    tests/
    ticket_cleaner/
    nothing added to commit but untracked files present (use "git add" to track)

    .venv n’est pas dans la liste, car le fichier .gitignore de l’instantané l’exclut. Il exclut aussi reports/ et .env.

  5. Enregistrez chaque fichier dans un commit sur main :

    Fenêtre de terminal
    git add -A
    git commit -m "Start"
    Output (the start)
    [main (root-commit) 2498e15] Start
    25 files changed, 748 insertions(+)
    create mode 100644 .env.example
    create mode 100644 .gitignore

    Ensuite viennent 23 autres lignes create mode (mode de création). L’empreinte de votre commit diffère de 2498e15 : elle dépend de votre nom et de l’heure.

  6. Créez la branche pour la fonctionnalité de Grace, puis passez à cette branche :

    Fenêtre de terminal
    git switch -c feature/category-option
    git status
    Sortie
    Switched to a new branch 'feature/category-option'
    On branch feature/category-option
    nothing to commit, working tree clean

Exécutez maintenant les trois vérifications et la première exécution, puis conservez leurs sorties. Ce sont les égratignures sur le dessin.

  1. Exécutez les tests :

    Fenêtre de terminal
    python -m pytest
    Output (the end)
    tests/test_cli.py .. [ 8%]
    tests/test_files.py .. [ 16%]
    tests/test_parsing.py .............. [ 75%]
    tests/test_remote.py .. [ 83%]
    tests/test_report.py .... [100%]
    ============================== 24 passed in 0.05s ==============================

    Le temps peut varier. Si vous voyez No module named pytest (aucun module nommé pytest), lisez l’erreur courante à la fin de cette leçon.

  2. Exécutez l’analyseur de code et la vérification du formatage :

    Fenêtre de terminal
    ruff check .
    ruff format --check .
    Sortie
    All checks passed!
    15 files already formatted
  3. Exécutez le programme sur le fichier d’exemple du cours de Python :

    Fenêtre de terminal
    python -m ticket_cleaner data/tickets.csv
    Sortie
    WARNING ticket_cleaner: row 7 rejected: unknown status 'opne'
    WARNING ticket_cleaner: row 8 rejected: missing id
    WARNING ticket_cleaner: row 9 rejected: priority must be 1, 2 or 3, not 'high'
    WARNING ticket_cleaner: row 11 rejected: priority must be 1, 2 or 3, not '5'
    WARNING ticket_cleaner: row 13 rejected: duplicate id T-1003
    WARNING ticket_cleaner: row 14 rejected: missing category
    15 rows: 9 valid, 6 rejected.
    Report: reports/summary.json
  4. Vérifiez que l’exécution n’a pas modifié le dépôt :

    Fenêtre de terminal
    git status --short

    La commande n’affiche rien. Le programme a écrit reports/summary.json, mais .gitignore exclut reports/.

Notez les quatre résultats : 24 passed (24 tests réussis), All checks passed! (toutes les vérifications ont réussi), 15 files already formatted (15 fichiers déjà formatés) et 15 rows: 9 valid, 6 rejected. (15 lignes : 9 valides, 6 rejetées). Après chaque modification, exécutez les mêmes quatre commandes et comparez les résultats.

Trois cases de gauche à droite. Sur main, le commit Start : 24 tests réussis, toutes les vérifications ruff réussies, 15 lignes : 9 valides, 6 rejetées. Une flèche, git switch -c, mène à la branche feature/category-option et à son commit Figer le rapport actuel du fichier d'exemple : 25 tests réussis. Une flèche mène à une case en pointillé : la modification de l'assistant, pas encore enregistrée dans un commit; git diff montre seulement cette modification. Une flèche rouge en pointillé revient de cette case vers le commit et indique : git restore . revient ici.
Un point de départ propre. Chaque fichier est enregistré dans un commit, le travail se fait sur une branche et les vérifications réussissent. La modification de l'assistant est alors la seule différence que git diff montre, et git restore . la supprime.
Description textuelle du diagramme

Le diagramme comporte trois cases. La première est le commit Start sur la branche main. Ses vérifications ont réussi : 24 tests, ruff et la première exécution avec 15 lignes, dont 9 valides et 6 rejetées. Une flèche portant l’étiquette git switch -c mène à la deuxième case, sur la branche feature/category-option. C’est le commit « Figer le rapport actuel du fichier d’exemple », avec 25 tests réussis. Vous créez ce commit dans la prochaine section. Une flèche mène à une case en pointillé : la modification de l’assistant, pas encore enregistrée dans un commit. git diff montre cette modification et rien d’autre. Une flèche rouge en pointillé revient de cette case vers le deuxième commit, avec l’étiquette « git restore . revient ici ».

La note est votre dessin. Un test est le dessin pour tout le monde, et il se vérifie chaque fois que quelqu’un exécute pytest. L’instantané end-of-m01 contient le test. Copiez-le dans votre projet :

Fenêtre de terminal
cp ../nextia-learning-labs/C15/snapshots/end-of-m01/tests/test_baseline.py tests/

Ouvrez tests/test_baseline.py et lisez-le :

tests/test_baseline.py
"""Today's report for the sample file, kept as it is.
This test pins the report of data/tickets.csv before any change. If a change
makes it fail, that change altered the report: check that this was intended.
"""
import json
from ticket_cleaner.cli import main
def test_report_of_the_sample_file_is_unchanged(tmp_path):
output = tmp_path / "summary.json"
assert main(["data/tickets.csv", "--output", str(output)]) == 0
assert json.loads(output.read_text(encoding="utf-8")) == {
"status": "open",
"valid_records": 9,
"selected": 4,
"by_category": {"billing": 2, "login": 1, "shipping": 1},
"average_priority": 2.0,
"rejected": [
{"row": 7, "problems": ["unknown status 'opne'"]},
{"row": 8, "problems": ["missing id"]},
{"row": 9, "problems": ["priority must be 1, 2 or 3, not 'high'"]},
{"row": 11, "problems": ["priority must be 1, 2 or 3, not '5'"]},
{"row": 13, "problems": ["duplicate id T-1003"]},
{"row": 14, "problems": ["missing category"]},
],
}

Le test exécute le programme comme la ligne de commande, avec main(). Il écrit le rapport dans tmp_path, un dossier temporaire que pytest crée pour chaque test. Votre propre dossier reports/ ne change donc pas. Ensuite, il compare le rapport entier aux valeurs d’aujourd’hui, avec ==. Une clé supplémentaire, un nombre modifié ou un texte de problème modifié le fait échouer.

Exécutez les vérifications, puis enregistrez le test dans un commit :

Fenêtre de terminal
python -m pytest
ruff check .
ruff format --check .
git add tests/test_baseline.py
git commit -m "Pin today's report of the sample file"
Output (the end of each command)
============================== 25 passed in 0.04s ==============================
All checks passed!
16 files already formatted
[feature/category-option 245d23e] Pin today's report of the sample file
1 file changed, 29 insertions(+)
create mode 100644 tests/test_baseline.py

Votre projet correspond maintenant à l’instantané end-of-m01, sauf pour ASSISTANT-SCOPE.md, que vous rédigerez dans la prochaine leçon.

Voir la référence de base détecter une modification

Section intitulée « Voir la référence de base détecter une modification »

Essayez maintenant la modification réelle présentée dans la section sur le problème. Elle se trouve dans le dossier des laboratoires sous le nom A-vague-request.patch. L’assistant l’a écrite pendant une séance enregistrée, et le cours ne l’a pas modifiée. git apply l’applique à vos fichiers, comme le ferait un agent :

Fenêtre de terminal
git apply ../nextia-learning-labs/C15/candidates/A-vague-request.patch
git diff --stat
Sortie
tests/test_cli.py | 34 ++++++++++++++++++++++++++++++++++
tests/test_report.py | 23 +++++++++++++++++++++++
ticket_cleaner/cli.py | 6 +++++-
ticket_cleaner/report.py | 17 +++++++++++++++--
4 files changed, 77 insertions(+), 3 deletions(-)

git diff --stat montre la modification de l’assistant et rien d’autre, car vous avez tout enregistré dans un commit avant. Avant d’exécuter les tests, faites une prédiction : sur start, cette modification donnait 29 passed. Que se passe-t-il maintenant?

Fenêtre de terminal
python -m pytest
Output (the end)
E AssertionError: assert {'status': 'o...cted': 4, ...} == {'status': 'o...ing': 1}, ...}
E
E Omitting 6 identical items, use -vv to show
E Left contains 1 more item:
E {'category': None}
E Use -v to get more diff
tests/test_baseline.py:15: AssertionError
…
FAILED tests/test_baseline.py::test_report_of_the_sample_file_is_unchanged - ...
========================= 1 failed, 29 passed in 0.05s =========================

Le test de référence a échoué, et pytest indique la différence : le nouveau rapport contient un élément supplémentaire, {'category': None}. En JSON, la valeur Python None devient null. Le changement de contrat est maintenant visible. Grace le veut peut-être, mais quelqu’un doit prendre cette décision et mettre le test à jour volontairement. Le module 3 examine cette modification ligne par ligne.

Annulez la modification. git restore . remet chaque fichier suivi dans son état du dernier commit :

Fenêtre de terminal
git restore .
git status
Sortie
On branch feature/category-option
nothing to commit, working tree clean
Deux rangées de quatre cases. Rangée du haut, sans test de référence : start, 24 tests réussis; appliquer la modification proposée à partir d'une demande vague, 4 fichiers, plus 77 moins 3; python -m pytest, 29 tests réussis, en vert; chaque rapport contient maintenant category null et aucun échec, en rouge. Rangée du bas, avec le test de référence : start plus test_baseline.py, 25 tests réussis; appliquer la même proposition; python -m pytest, 1 échec, 29 tests réussis, en rouge; test_baseline.py : le côté gauche contient 1 élément supplémentaire, category None; la modification est détectée, en vert.
La même modification réelle, appliquée deux fois. Sans le test de référence, tous les tests réussissent et le rapport change sans avertissement. Avec ce test, un test échoue et indique la nouvelle clé.
Description textuelle du diagramme

Le diagramme comporte deux rangées de quatre étapes. La rangée du haut n’a pas de test de référence. Elle commence à start, où 24 tests réussissent. Vient ensuite la modification proposée à partir d’une demande vague : 4 fichiers, 77 lignes ajoutées et 3 supprimées. python -m pytest affiche 29 tests réussis, en vert. La dernière case, en rouge, indique que chaque rapport contient maintenant « category » : null, et qu’aucun test n’a échoué. La rangée du bas contient le test de référence : start plus test_baseline.py, où 25 tests réussissent. Vient ensuite la même proposition. python -m pytest affiche 1 échec et 29 tests réussis, en rouge. La dernière case, en vert, cite l’échec : le côté gauche contient 1 élément supplémentaire : {'category': None}. La modification est détectée.

Préparez le projet ainsi avant chaque séance avec un assistant qui peut modifier des fichiers. Cela inclut un agent ou une conversation dont vous collez la réponse. La branche et le commit prennent une minute. Le test de référence a demandé un fichier de 29 lignes.

Il y a des coûts. Un test qui fige le rapport entier échoue pour chaque modification du rapport, même une modification voulue. Quand la fonctionnalité de Grace ajoute la clé categories, celle-ci doit apparaître seulement avec --category, donc ce test continue de réussir. Une modification qui doit réellement changer le rapport par défaut doit aussi mettre le test à jour dans le même commit. Ainsi, un réviseur voit la décision. Et une référence de base fige le comportement d’aujourd’hui, y compris ses bogues. Ne figez pas une sortie que vous savez incorrecte, comme le montre la prochaine tâche.

Une référence de base ne remplace pas la révision. Elle détecte les modifications de ce qu’elle fige, et rien d’autre. Une modification peut réussir les 25 tests et rester incorrecte sur un point qu’aucun test ne vérifie.

À vous de jouer : faut-il figer l’export de Grace?

Section intitulée « À vous de jouer : faut-il figer l’export de Grace? »

Exécutez le programme sur l’export de Grace, le fichier du nouveau formulaire Web :

Fenêtre de terminal
python -m ticket_cleaner data/web-form-export.csv

Ouvrez reports/summary.json et regardez by_category. Tomás propose un deuxième test de référence pour ce rapport : « Comme ça, rien ne pourra le modifier par erreur. » Avant d’écrire quoi que ce soit, décidez : ce rapport est-il une bonne référence de base? Que ferait le test au module 4, quand vous corrigerez le bogue? N’enregistrez pas de nouveau test dans un commit : les prochaines leçons s’attendent à 25 tests.

Afficher la réponse

Le programme affiche 12 rows: 12 valid, 0 rejected. (12 lignes : 12 valides, 0 rejetée). Le rapport contient :

"by_category": {
"Billing": 1,
"LOGIN": 1,
"Login": 1,
"account": 1,
"billing": 2,
"login": 2,
"shipping": 2
}

C’est le bogue de Grace : le rapport compte Billing, LOGIN et Login séparément de billing et login. Elle attend les nombres suivants : account 1, billing 3, login 4 et shipping 2. Un test qui fige ce rapport protégerait le bogue. Au module 4, la correction le ferait échouer, et l’échec ressemblerait à une régression. Ne le figez donc pas. Notez « résultat connu comme incorrect : bogue de Grace », avec les valeurs qu’elle attend. Une référence de base fige seulement les comportements que vous voulez conserver.

Erreur courante

Aucun module nommé pytest

Symptôme : python -m pytest s’arrête immédiatement avec une ligne comme celle-ci. Le chemin au début diffère sur chaque ordinateur :

/Library/Frameworks/Python.framework/Versions/3.14/bin/python3: No module named pytest

Cause : l’environnement virtuel n’est pas actif. Le terminal utilise donc le Python de votre ordinateur, qui n’a pas les paquets du projet. L’environnement n’est jamais actif dans une nouvelle fenêtre de terminal. Pire encore, un outil peut exister hors de l’environnement dans une autre version. Sur l’ordinateur de l’auteur, ruff --version affichait ruff 0.16.0 hors de l’environnement, et ruff 0.16.10 dans l’environnement, la version de requirements-lock.txt.

Solution : activez à nouveau l’environnement : source .venv/bin/activate sur macOS et Linux, .venv\Scripts\Activate.ps1 sur Windows. L’invite commence par (.venv). Ensuite, relancez les vérifications. Exécutez chaque vérification de ce cours avec l’environnement actif pour que votre référence de base utilise les versions verrouillées.

Erreur courante

Vos propres modifications se mélangent à celles de l'assistant

Symptôme : vous aviez ajouté une note à README.md sans l’enregistrer dans un commit. Ensuite, la modification proposée a été appliquée. git diff --stat montre maintenant 5 fichiers et 79 lignes ajoutées, au lieu de 4 fichiers et 77 lignes :

README.md | 2 ++
tests/test_cli.py | 34 ++++++++++++++++++++++++++++++++++
tests/test_report.py | 23 +++++++++++++++++++++++
ticket_cleaner/cli.py | 6 +++++-
ticket_cleaner/report.py | 17 +++++++++++++++--
5 files changed, 79 insertions(+), 3 deletions(-)

Cause : l’arbre de travail n’était pas propre avant la modification. Git ne peut pas distinguer vos lignes de celles de l’assistant : les deux sont des « modifications depuis le dernier commit ». Et git restore . supprime les deux, donc votre note est aussi perdue.

Solution : avant chaque séance, exécutez git status. Il doit indiquer nothing to commit, working tree clean (rien à enregistrer, arbre de travail propre). Sinon, enregistrez d’abord votre travail dans un commit, ou mettez-le de côté avec git stash. La leçon Récupérer son travail du cours de Git explique cette commande.

Vérifiez votre compréhension

Nommez les trois éléments d'un point de départ propre et la question à laquelle chacun répond après une modification de l'assistant.

Afficher la réponse
  • Un environnement que vous pouvez recréer (un nouvel environnement virtuel à partir de requirements-lock.txt) : l’échec vient-il du code ou de mon ordinateur?
  • Une branche propre sur un commit (instantané enregistré) (git status indique working tree clean (arbre de travail propre)) : quelles lignes l’assistant a-t-il modifiées? git diff les montre, et git restore . les supprime.
  • Des vérifications de référence (les tests, ruff et une première exécution, consignés ou fixés dans un test) : cet échec est-il nouveau?

Vérifiez votre compréhension

Prédisez le résultat : au démarrage, la solution candidate vague donne « 29 passed ». Avec test_baseline.py, elle donne « 1 failed, 29 passed ». Pourquoi les anciens tests n'ont-ils pas échoué, et qu'a détecté le nouveau test?

Afficher la réponse

Les anciens tests vérifient des parties du rapport, comme un nombre ou une clé. Les nouveaux tests de la solution candidate vérifient son propre nouveau comportement. Aucun test ne comparait le rapport entier. Le test de référence compare le rapport entier de data/tickets.csv aux valeurs d’aujourd’hui. La solution candidate ajoute "category": null à chaque rapport. Le test échoue donc, et pytest indique l’élément supplémentaire : {'category': None}.

Vérifiez votre compréhension

Vérification pratique : montrez que votre projet est prêt pour un assistant. Quelles commandes exécutez-vous, et que doivent-elles afficher?

Afficher la réponse

Dans ~/projects/ticket-cleaner-assist, avec l’environnement actif :

  • git status affiche On branch feature/category-option (sur la branche feature/category-option) et nothing to commit, working tree clean (rien à enregistrer, arbre de travail propre).
  • git log --oneline montre deux commits : Pin today's report of the sample file (fixer le rapport actuel du fichier d’exemple) et Start (début).
  • python -m pytest affiche 25 passed (25 tests réussis).
  • ruff check . affiche All checks passed! (toutes les vérifications ont réussi!), et ruff format --check . affiche 16 files already formatted (16 fichiers déjà formatés).
  • python -m ticket_cleaner data/tickets.csv affiche 15 rows: 9 valid, 6 rejected. (15 lignes : 9 valides, 6 rejetées).

Récapitulatif

  • Préparez-vous avant chaque séance qui peut modifier des fichiers, comme lorsqu’on dessine les égratignures d’une voiture de location.
  • Un point de départ propre comprend trois éléments : un environnement créé à partir du fichier de verrouillage, une branche propre sur un commit et des vérifications de référence réussies.
  • tests/test_baseline.py fixe le rapport entier du fichier d’exemple. Une modification réelle d’un assistant a réussi tous les anciens tests (29 passed (29 tests réussis)). Mais elle ajoutait "category": null à chaque rapport. Avec le test de référence, 1 failed, 29 passed (1 test échoué, 29 réussis) indiquait la clé supplémentaire.
  • git diff --stat montre uniquement la modification de l’assistant si l’arbre de travail était propre avant, et git restore . la supprime. Votre propre travail non enregistré s’y mélangerait, et git restore . le supprimerait aussi.
  • Une référence fixe le comportement actuel, y compris les bogues : ne fixez pas les catégories séparées de Grace.

Votre projet affiche maintenant 25 passed sur la branche feature/category-option. Ensuite, vous consignez ce qu’un assistant peut y lire, modifier et exécuter.

Leçon suivante : Contexte et limites