Tutoriel Git Reset et Revert pour les débutants

Qu'est-ce que Git ?

Git est un outil de contrôle de version open-source créé en 2005 par Linus Torvalds. Il est principalement utilisé pour assurer un cursus efficace des modifications apportées aux fichiers d'un projet, de sorte que les membres du projet puissent disposer d'un enregistrement de toutes les modifications et les fusionner sans perdre d'informations précieuses. Notre cours d'introduction à Git vous permettra de mieux comprendre comment et pourquoi utiliser Git tout en couvrant les étapes les plus courantes du flux de travail Git.

De plus, le cours Github Concepts vous donnera les clés pour utiliser les différentes fonctionnalités de Github, naviguer dans l'interface et réussir les tâches collaboratives quotidiennes.

Vue d'ensemble de Git Revert et Reset 

Git revert et Git reset sont deux commandes utilisées dans Git pour annuler les modifications apportées au code et à l'historique d'un projet, mais de manière différente. Dans cette section, nous vous présentons une vue d'ensemble de l'utilisation des fonctions de rétablissement et de réinitialisation. Avant de plonger dans le processus, créons un projet Git.

Créer un projet Git

Vous trouverez ci-dessous les instructions pour créer un projet git et l'initialiser avec quelques fichiers :

mkdir git_revert_reset
cd git_revert_reset
git init .

• mkdir git_revert_reset crée un dossier appelé git_revert_reset. 

• cd git_revert_reset se déplace vers le dossier. 

• git init . initialise le dossier en tant que dépôt git.

S'agissant d'un projet de science des données, nous pouvons créer les fichiers suivants pour l'acquisition des données, le prétraitement des données et l'entraînement des modèles à l'aide de la commande touch:

touch data_acquisition.py data_preprocessing.py model_training.py

Il s'agit du contenu final du dossier de projet.

git_revert_reset
      |---------- data_acquisition.py
      |---------- data_preprocessing.py
      |---------- model_training.py

Réinitialisation de Git 

Diagramme Git Reset(Source)

La commande git reset est utilisée pour annuler les modifications dans votre répertoire de travail et revenir à un commit spécifique tout en abandonnant tous les commits effectués après celui-ci. 

Imaginez, par exemple, que vous ayez effectué dix livraisons. L'utilisation de git reset sur le premier commit supprimera les neuf commits, ce qui vous ramènera à l'étape du premier commit.

Avant d'utiliser git reset, il est important de réfléchir au type de changements que vous envisagez d'apporter, sinon vous risquez de créer plus de désordre que de bien. 

Vous pouvez utiliser plusieurs options avec git reset, mais voici les principales. Chacun d'entre eux est utilisé en fonction d'une situation spécifique : git reset --soft, git reset --mixed, et git reset --hard

git reset --soft

Le --soft vise à modifier la référence HEAD (où se trouve le dernier commit dans votre machine locale) à un commit spécifique. Par exemple, si nous nous rendons compte que nous avons oublié d'ajouter un fichier à la livraison, nous pouvons revenir en arrière en utilisant le site --soft en respectant le format suivant :

• git reset --soft HEAD~n pour revenir au commit avec une référence spécifique (n). git reset --soft HEAD~1 revient au dernier commit.

• git reset --soft revient à la tête avec le .

Prenons quelques exemples.

git add data_acquisition.py data_preprocessing.py

git add data

git commit -m "added data acquisition and preprocessing scripts"

C'est le résultat de la commande précédente. 

[master (root-commit) faf864e] added python scripts and data folder
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_acquisition.py
create mode 100644 data_preprocessing.py

Nous pouvons vérifier l'état de la livraison de la manière suivante :

git status

On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
model_training.py

nothing added to commit but untracked files present (use "git add" to track)

Mais nous avons oublié d'ajouter le script model_training.py au commit.

Puisque le dernier commit se trouve à l'adresse HEAD, nous pouvons résoudre ce problème en exécutant les trois instructions suivantes. 

• Revenez à la phase de pré-commission en utilisant git reset --soft HEAD pour autoriser le fichier git reset.

• Ajoutez le fichier oublié avec git add. 

• Effectuez les modifications avec un commit final git commit.

git reset --soft HEAD

git add model_training.py

git commit -m "added all the python scripts"

Le résultat suivant a rendu git reset maître après toutes les étapes précédentes : 

[master (root-commit) faf864e] added all the python scripts
3 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_acquisition.py
create mode 100644 data_preprocessing.py
create mode 100644 model_training.py

git reset --mixed

C'est l'argument par défaut de git reset. L'exécution de cette commande a deux conséquences : (1) désengager tous les changements et (2) les déstocker. Imaginez que nous ayons accidentellement ajouté le fichier model_training.py et que nous souhaitions le supprimer parce que l'apprentissage du modèle n'est pas encore terminé. Voici comment procéder : 

• Supprimez les fichiers qui étaient dans le commit avec git reset HEAD
• N'ajoutez que les fichiers dont nous avons besoin pour la livraison

git reset HEAD

git status

On branch master
Untracked files:
(use "git add <file>..." to include in what will be committed)
model_training.py
data_acquisition.py
data_preprocessing.py

nothing added to commit but untracked files present (use "git add" to track)

Nous pouvons maintenant ajouter uniquement les deux derniers fichiers à livrer et effectuer la livraison.

git add data_acquisition.py data_preprocessing.py

git commit -m "Removed the model_training.py from the commit"

git reset --hard

Cette option peut s'avérer dangereuse. Soyez donc prudent lorsque vous l'utilisez ! 

En fait, lorsque vous utilisez la réinitialisation sur un commit spécifique, cela force le HEAD à revenir à ce commit et supprime tout ce qui suit.

Avant de procéder à la réinitialisation, examinons le contenu du dossier.

ls
data_acquisition.py data_preprocessing.py model_training.py

git reset --hard
HEAD is now at 97159bc added data acquisition and preprocessing scripts

Vérifions maintenant le contenu du dossier :

ls
data_acquisition.py data_preprocessing.py

Nous constatons que le fichier non suivi model_training.py est supprimé. Encore une fois, assurez-vous de bien comprendre ce que vous faites avec la déclaration de réinitialisation, car les conséquences peuvent être dramatiques !

Git Revert

Avant et après la réversion(Source)

Git revert est similaire à git reset, mais l'approche est légèrement différente. Au lieu de supprimer toutes les livraisons qui se trouvent sur son chemin, la commande Revert n'annule qu'une seule livraison en vous ramenant aux fichiers mis à disposition avant la livraison.

Ainsi, au lieu de supprimer un commit, git revert inverse les changements introduits par le commit original en créant un nouveau commit avec le contenu inverse sous-jacent. Il s'agit d'un moyen sûr de révoquer un commit, car il vous évite de perdre votre historique. 

Il est important de savoir que le retour en arrière n'aura aucun effet si le hachage ou la référence du commit n'est pas spécifié. 

Explorons quelques options courantes de git revert.

git revert --no-edit <commit ID>

L'option --no-edit permet à l'utilisateur de ne pas changer le message utilisé pour le commit que vous souhaitez inverser, ce qui fera que git inversera le fichier vers la branche master.

Pour illustrer ce scénario, créons deux nouveaux fichiers à ajouter. 

touch model_monitoring.py data_monitoring.py

Après avoir créé ces fichiers, nous devons les ajouter à la zone de transit de la version modifiée.

git add model_monitoring.py

Avant de poursuivre, jetons un coup d'œil à l'état de la situation en exécutant la commande suivante.

git status
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file:   data_monitoring.py
new file:   model_monitoring.py

Nous pouvons observer que les deux fichiers ont été ajoutés, nous pouvons maintenant valider les modifications.

git commit -m "Added the monitoring script files"
[master (root-commit) eae84e7] Added the monitoring script files
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 data_monitoring.py
create mode 100644 model_monitoring.py

Ensuite, le hash de validation peut être généré à l'aide de la commande suivante. Cela est utile lorsque vous essayez d'effectuer une action sur cette livraison spécifique. 

git reflog
eae84e7 (HEAD -> master) HEAD@{0}: commit (initial): Added the monitoring script files

Imaginons maintenant que le commit précédent n'était pas intentionnel et que nous voulons nous en débarrasser.

git revert --no-edit eae84e7

[master c61ef6b] Revert "Added the monitoring script files"
Date: Sat Nov 12 20:14:17 2022 -0600
2 files changed, 0 insertions(+), 0 deletions(-)
delete mode 100644 data_monitoring.py
delete mode 100644 model_monitoring.py

Jetons un coup d'œil au journal des commits :

git log

commit c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 (HEAD -> master)
Author: Zoumana Keita <keitnekozou@gmail.com>
Date:   Sat Nov 12 20:14:17 2022 -0600

  Revert "Added the monitoring script files"
 
  This reverts commit eae84e7669af733ee6c1b854f2fcd9acfea9d4a3.

commit eae84e7669af733ee6c1b854f2fcd9acfea9d4a3
Author: Zoumana Keita <keitnekozou@gmail.com>
Date:   Sat Nov 12 20:05:57 2022 -0600

  Added the monitoring script files

Le journal montre qu'un nouveau commit a été créé avec l'ID c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 pour annuler le commit original avec l'ID eae84e7669af733ee6c1b854f2fcd9acfea9d4a3. 

Dans cet exemple, puisque nous avons un seul commit, nous pourrions simplement utiliser git revert HEAD, qui aurait le même effet en annulant le dernier commit.

git revert <hachage de validation>

Cette opération ne supprimera que les modifications associées à ce hachage de validation et n'aura aucun impact sur les autres validations.

Selon vous, quel git revert aura un effet, compte tenu de l'ID généré précédemment ? 

Si vous avez répondu c61ef6b4e86f41f47c8c77de3b5fca3945a7c075, vous avez raison. Considérer eae84e7669af733ee6c1b854f2fcd9acfea9d4a3 n'aura aucun effet, puisqu'il est remplacé par un nouveau. 

Voyons ce qui se passe lorsque vous essayez d'effectuer le retour en arrière.

git revert c61ef6b4e86f41f47c8c77de3b5fca3945a7c075

[master aaead40] Revert "Revert "Added the monitoring script files""

 2 files changed, 0 insertions(+), 0 deletions(-)

 create mode 100644 data_monitoring.py

 create mode 100644 model_monitoring.py

Comme vous pouvez le constater, les deux fichiers initialement créés et engagés ont été ramenés !

git revert --no-commit <identification du commit>

Le but de l'utilisation de l'option --no-commit ou -n est d'empêcher git de livrer automatiquement la correction. Cela peut s'avérer utile si vous souhaitez revoir les modifications apportées par l'instruction revert avant de les valider.

Prenons l'exemple suivant : 

git revert --no-commit c61ef6b4e86f41f47c8c77de3b5fca3945a7c075

Cela annulera les modifications apportées par le commit avec l'ID c61ef6b4e86f41f47c8c77de3b5fca3945a7c075 mais ne créera pas automatiquement un nouveau commit pour enregistrer l'annulation. Au lieu de cela, il laissera les modifications non paginées afin que vous puissiez les examiner et décider de les valider ou de les annuler manuellement.

Git Revert vs. Remise à zéro

Git Revert 

• En utilisant git revert, vous avez la possibilité de revenir à des états antérieurs tout en créant un nouveau commit.

• Choisissez cette option si vous souhaitez annuler des modifications sur une branche publique pour des raisons de sécurité.

Réinitialisation de Git

• Avec git reset, vous pouvez revenir sur les commits précédents mais vous ne pouvez pas créer un nouveau commit. 

• Cette option est préférable pour annuler des modifications sur une branche privée.

Conclusion

Dans ce tutoriel, nous avons vu comment effectuer les changements git reset et git revert dans votre dépôt git. N'oubliez pas qu'une réinitialisation peut être très dangereuse car elle vous fera perdre vos fichiers non suivis dans le projet. 

Quelle est la prochaine étape ? DataCano propose de nombreux tutoriels qui pourraient être une bonne étape pour améliorer vos compétences Git, comme par exemple :

• Comment résoudre les conflits de fusion dans Git Tutorial
• GitHub, et tutoriel Git pour les débutants
• Tutoriel Git Push et Pull