Le hot reloading est une technique extrêmement pratique pour les développeurs, permettant de voir immédiatement les modifications de code sans avoir à redémarrer l’application à chaque fois. En Python, cela peut être accompli en utilisant un outil appelé Jurigged. Dans ce tutoriel, nous allons vous montrer comment configurer le hot reloading avec Jurigged et Visual Studio Code (VSCode).

Qu’est-ce que Jurigged ?

Jurigged est un outil open-source permettant de recharger dynamiquement des fichiers Python dans une application en cours d’exécution. Cela signifie que lorsque vous modifiez un fichier, Jurigged détecte les changements et applique ces modifications sans avoir à relancer votre programme.

Le principal avantage est que vous pouvez tester les modifications de code immédiatement, ce qui peut accélérer considérablement votre flux de développement.

Installation de Jurigged

L’installation de Jurigged est très simple grâce à pip, le gestionnaire de paquets Python.

1. Ouvrez un terminal.
2. Exécutez la commande suivante pour installer Jurigged :

bash

Copier le code

pip install jurigged

Une fois installé, vous serez prêt à l’utiliser dans n’importe quel projet Python.

Configuration de Jurigged avec VSCode

Visual Studio Code est un IDE léger et populaire qui s’intègre parfaitement avec Jurigged. Voici comment configurer Jurigged pour fonctionner avec VSCode.

Étape 1 : Créer un script Python

Créez un fichier Python que vous souhaitez exécuter. Par exemple, créons un fichier main.py avec un simple script qui affiche un message à l’écran et boucle infiniment pour simuler une application en cours d’exécution :

import time

def afficher_message():
    print("Hello, world!")

while True:
    afficher_message()
    time.sleep(5)

Étape 2 : Ajouter un fichier de configuration pour VSCode

Dans VSCode, vous pouvez créer une configuration de débogage qui inclura Jurigged. Pour ce faire :

1. Dans la barre latérale, cliquez sur l’icône d’exécution (un triangle pointant vers la droite).
2. Cliquez ensuite sur « Ajouter une configuration » en haut de l’interface de débogage.
3. Sélectionnez « Python debugger » dans la liste des environnements disponibles.
4. Une configuration par défaut sera ajoutée à votre projet. Remplacez-la par la configuration suivante dans le fichier .vscode/launch.json :

{
    "version": "0.2.0",
    "configurations": [
        {
       {
            "name": "jurigged",
            "type": "debugpy",
            "request": "launch",
            "module": "jurigged",
            "console": "integratedTerminal",
            "args": [
                "main.py",
            ]
        }
    ]
}

Étape 3 : Lancer votre projet avec Jurigged

Maintenant que la configuration est en place, vous pouvez lancer votre projet avec Jurigged en procédant comme suit :

1. Assurez-vous que votre fichier main.py est sauvegardé.
2. Allez dans l’onglet de débogage et sélectionnez « jurigged » dans le menu déroulant.
3. Cliquez sur l’icône de lecture pour démarrer le débogage.

Votre programme Python sera exécuté avec Jurigged, ce qui signifie que toutes les modifications de code dans les fichiers seront automatiquement rechargées sans avoir à redémarrer l’application.

Exemple de projet avec Hot Reloading

Pour illustrer le fonctionnement, modifions notre fichier main.py pendant son exécution.

1. Démarrez l’application comme décrit ci-dessus.
2. Une fois l’application en cours d’exécution, modifiez la fonction afficher_message comme suit :

def afficher_message():
    print("Hello, Python avec Hot Reloading!")

3. Sauvegardez le fichier. Jurigged détectera automatiquement la modification et actualisera le code en conséquence sans avoir à redémarrer le script. Vous verrez maintenant le nouveau message "Hello, Python avec Hot Reloading!" dans la console.
4. Vous pouvez mettre les break points que vous souhaitez.

Cela montre la puissance du hot reloading avec Jurigged et combien cela peut rendre le développement plus fluide et rapide.

Exemple asynchrone

import asyncio

async def main():
    await ma_fonction_asynchrone()


if __name__ == "__main__":
    # jurigged.watch(str(Path.cwd() / "asynctgtest.py"))
    asyncio.run(main())

Loop avec une IDE console

Vous pouvez également exécuter Jurigged en mode IDE console pour écouter et exécuter une fonction en particulier avec :

    {
            "name": "juriggedMaFunc",
            "type": "debugpy",
            "request": "launch",
            "module": "jurigged",
            "console": "integratedTerminal",
            "args": [
                "--loop",
                "mafonction",
                "main.py",
            ]
        },

Conclusion

Jurigged est un outil efficace pour les développeurs Python, en particulier lorsqu’il est intégré à un IDE comme Visual Studio Code. Le hot reloading vous permet de voir les résultats des modifications en temps réel, ce qui améliore la productivité et réduit le temps de développement.

Avec cette configuration, vous pouvez maintenant expérimenter plus rapidement, tester des modifications instantanément, et maintenir une boucle de rétroaction rapide tout au long du processus de développement.

N’hésitez pas à explorer plus en profondeur les fonctionnalités de Jurigged sur Github, notamment le rechargement dynamique de classes, fonctions et modules. Bonne programmation !

Si vous avez des questions ou des commentaires sur ce tutoriel, laissez un message dans la section des commentaires ci-dessous !