Gestion d’environnements Python

Cet article détaille un programme Python complet qui permet de gérer des environnements virtuels Python sur un Raspberry via une interface graphique créée avec Tkinter. Le programme permet de créer, démarrer, supprimer des environnements virtuels, ainsi que de générer une liste des modules installés. Voici une vue d’ensemble du fonctionnement du code et des fonctionnalités implémentées.

Présentation du Code

1. Imports et Dépendances

Le programme utilise plusieurs modules essentiels :

os : Pour les opérations de système de fichiers.
subprocess : Pour exécuter des commandes système.
tkinter : Pour créer l’interface graphique.
threading : Pour exécuter des tâches en parallèle sans bloquer l’interface utilisateur.
time : Pour les animations et les délais.

2. Classe `ToolTip`

La classe ToolTip est utilisée pour afficher des info-bulles contextuelles. Chaque instance de ToolTip est attachée à un widget spécifique et affiche un texte lorsqu’on survole le widget.

Méthodes :
- __init__ : Initialise l’info-bulle avec le widget et le texte.
- show_tooltip : Affiche l’info-bulle à la position de la souris.
- hide_tooltip : Cache l’info-bulle lorsque la souris quitte le widget.

3. Fonctions Principales

Les fonctions suivantes gèrent les opérations sur les environnements Python.

show_status_message : Affiche ou masque un message de statut dans l’interface graphique pour informer l’utilisateur de l’état des opérations en cours.
run_command_with_status : Exécute une commande système et met à jour l’interface avec une animation pour indiquer que le processus est en cours. Elle gère également les succès et les échecs des commandes.
create_env : Crée un nouvel environnement virtuel Python. Elle demande le nom de l’environnement via une boîte de dialogue et exécute la commande pour créer l’environnement dans un nouveau thread pour éviter de bloquer l’interface graphique.
start_env : Démarre un environnement virtuel dans un terminal. La commande source bin/activate est utilisée pour activer l’environnement, et exec bash pour ouvrir un nouveau shell. La commande est exécutée dans un terminal LXDE (lxterminal).
generate_and_open_module_list : Génère un fichier texte avec la liste des modules installés dans l’environnement virtuel sélectionné et ouvre ce fichier. La méthode d’ouverture du fichier dépend du système d’exploitation.
delete_env : Supprime un environnement virtuel sélectionné après confirmation de l’utilisateur. La commande rm -rf est utilisée pour supprimer le répertoire de l’environnement.
update_env_list : Met à jour la liste des environnements virtuels affichée dans l’interface graphique.

4. Interface Graphique

Le code crée une interface graphique en utilisant Tkinter avec les éléments suivants :

Barre d’outils : Contient quatre boutons pour créer, démarrer, lister, et supprimer des environnements. Chaque bouton est équipé d’une info-bulle pour décrire sa fonction.
Liste des environnements : Une Listbox affichant les environnements Python disponibles. Les utilisateurs peuvent sélectionner un environnement pour effectuer des actions dessus.
Label de statut : Affiche les messages d’état pour informer l’utilisateur des opérations en cours.

5. Boucle Principale

La boucle principale de Tkinter est lancée avec root.mainloop(), ce qui permet à l’interface graphique de rester interactive et de répondre aux actions des utilisateurs.

Conclusion

Ce programme offre une interface graphique complète pour gérer des environnements Python virtuels, facilitant ainsi les tâches courantes telles que la création, la gestion et la suppression d’environnements. Grâce à l’utilisation de Tkinter et de threading, il permet une interaction fluide et réactive avec l’utilisateur tout en exécutant des tâches potentiellement longues en arrière-plan. Le design modulaire du code permet également de facilement étendre ou modifier les fonctionnalités selon les besoins.

Code

Python

import os
import subprocess
import tkinter as tk
from tkinter import messagebox, simpledialog, Listbox, Scrollbar, RIGHT, Y, END
from threading import Thread
import time

# Classe ToolTip pour afficher une info-bulle
class ToolTip:
    def __init__(self, widget, text):
        self.widget = widget
        self.text = text
        self.tooltip = None
        self.widget.bind("<Enter>", self.show_tooltip)
        self.widget.bind("<Leave>", self.hide_tooltip)

    def show_tooltip(self, event):
        x = event.x_root + 20
        y = event.y_root + 10
        self.tooltip = tk.Toplevel(self.widget)
        self.tooltip.overrideredirect(True)
        self.tooltip.geometry(f"+{x}+{y}")
        label = tk.Label(self.tooltip, text=self.text, background="yellow", relief=tk.SOLID, borderwidth=1)
        label.pack()

    def hide_tooltip(self, event):
        if self.tooltip:
            self.tooltip.destroy()
            self.tooltip = None

# Fonction pour afficher/masquer le texte d'état
def show_status_message(message, show=True):
    status_label.config(text=message if show else "")
    if show:
        status_label.pack(padx=10, pady=5)
    else:
        status_label.pack_forget()

# Fonction pour exécuter une commande avec une animation de texte
def run_command_with_status(command, on_success, on_failure):
    try:
        show_status_message("En cours de traitement…", show=True)
        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

        while process.poll() is None:
            # Animation des trois petits points
            for dots in ['.', '..', '…']:
                show_status_message(f"En cours de traitement{dots}", show=True)
                time.sleep(0.5)

        process.wait()  # Assurez-vous que le processus est terminé
        show_status_message("", show=False)
        on_success()
    except subprocess.CalledProcessError:
        show_status_message("", show=False)
        on_failure()
    finally:
        # Masquer le texte d'état après l'exécution
        show_status_message("", show=False)

# Fonction pour créer un nouvel environnement
def create_env():
    env_name = simpledialog.askstring("Nouvel environnement", "Nom de l'environnement :")
    if env_name:
        env_path = os.path.join("env", env_name)
        if not os.path.exists(env_path):
            os.makedirs("env", exist_ok=True)

            def success():
                messagebox.showinfo("Succès", f"L'environnement '{env_name}' a été créé.")
                update_env_list()
            
            def failure():
                messagebox.showerror("Erreur", "Échec de la création de l'environnement.")
            
            command = ["python3", "-m", "venv", env_path]
            thread = Thread(target=run_command_with_status, args=(command, success, failure))
            thread.start()
        else:
            messagebox.showerror("Erreur", "Cet environnement existe déjà.")

# Fonction pour démarrer un environnement dans un nouveau terminal
def start_env():
    selected_env = env_listbox.get(tk.ACTIVE)
    if selected_env:
        env_path = os.path.join("env", selected_env)
        terminal_command = f"cd {env_path} && source bin/activate && exec bash"
        
        def success():
            pass  # Pas de message pour la réussite
        
        def failure():
            messagebox.showerror("Erreur", "Échec du démarrage de l'environnement.")
        
        command = ['lxterminal', '–command', terminal_command]
        thread = Thread(target=lambda: run_command_with_status(command, success, failure))
        thread.start()
    else:
        messagebox.showerror("Erreur", "Veuillez sélectionner un environnement.")

# Fonction pour générer un fichier texte avec la liste des modules installés et l'ouvrir
def generate_and_open_module_list():
    selected_env = env_listbox.get(tk.ACTIVE)
    if selected_env:
        env_path = os.path.join("env", selected_env)
        pip_path = os.path.join(env_path, "bin", "pip")
        list_file_path = os.path.join(env_path, "listeModules.txt")
        
        def success():
            if os.name == 'posix':  # Unix-like OS (Linux, macOS)
                subprocess.Popen(['xdg-open', list_file_path])
            elif os.name == 'nt':  # Windows
                os.startfile(list_file_path)
            messagebox.showinfo("Succès", "Liste des modules générée.")
        
        def failure():
            messagebox.showerror("Erreur", "Échec de la génération de la liste des modules.")
        
        command = [pip_path, "list"]
        thread = Thread(target=lambda: run_command_with_status(command, success, failure))
        thread.start()
    else:
        messagebox.showerror("Erreur", "Veuillez sélectionner un environnement.")

# Fonction pour supprimer un environnement
def delete_env():
    selected_env = env_listbox.get(tk.ACTIVE)
    if selected_env:
        confirm = messagebox.askyesno("Confirmation", f"Voulez-vous vraiment supprimer l'environnement '{selected_env}' ?")
        if confirm:
            env_path = os.path.join("env", selected_env)
            if os.path.exists(env_path):
                
                def success():
                    messagebox.showinfo("Succès", f"L'environnement '{selected_env}' a été supprimé.")
                    update_env_list()
                
                def failure():
                    messagebox.showerror("Erreur", "Échec de la suppression de l'environnement.")
                
                command = ['rm', '-rf', env_path]
                thread = Thread(target=lambda: run_command_with_status(command, success, failure))
                thread.start()
            else:
                messagebox.showerror("Erreur", "L'environnement sélectionné n'existe pas.")
    else:
        messagebox.showerror("Erreur", "Veuillez sélectionner un environnement.")

# Fonction pour mettre à jour la liste des environnements
def update_env_list():
    env_listbox.delete(0, END)
    if os.path.exists("env"):
        for env_name in os.listdir("env"):
            env_listbox.insert(END, env_name)

# Interface graphique
root = tk.Tk()
root.title("Gestionnaire d'Environnements Python")

# Barre d'outils
toolbar = tk.Frame(root, bd=1, relief=tk.RAISED)
toolbar.pack(side=tk.TOP, fill=tk.X, padx=5, pady=5)

# Bouton pour créer un nouvel environnement
create_button = tk.Button(toolbar, text="Créer", command=create_env)
create_button.pack(side=tk.LEFT, padx=2, pady=2)
ToolTip(create_button, "Créer un nouvel environnement")

# Bouton pour démarrer un environnement
start_button = tk.Button(toolbar, text="Démarrer", command=start_env)
start_button.pack(side=tk.LEFT, padx=2, pady=2)
ToolTip(start_button, "Démarrer l'environnement sélectionné")

# Bouton pour afficher les modules installés
list_packages_button = tk.Button(toolbar, text="Liste", command=generate_and_open_module_list)
list_packages_button.pack(side=tk.LEFT, padx=2, pady=2)
ToolTip(list_packages_button, "Générer et ouvrir la liste des modules installés")

# Bouton pour supprimer un environnement
delete_button = tk.Button(toolbar, text="Suppr", command=delete_env)
delete_button.pack(side=tk.LEFT, padx=2, pady=2)
ToolTip(delete_button, "Supprimer l'environnement sélectionné")

# Liste des environnements
frame = tk.Frame(root)
frame.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)

env_listbox = Listbox(frame)
env_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

scrollbar = Scrollbar(frame, orient="vertical")
scrollbar.config(command=env_listbox.yview)
scrollbar.pack(side=RIGHT, fill=Y)
env_listbox.config(yscrollcommand=scrollbar.set)

# Label de statut
status_label = tk.Label(root, text="", font=('Helvetica', 12, 'italic'))

update_env_list()

root.mainloop()

Grimeco

Gestion d’environnements Python

Présentation du Code

1. Imports et Dépendances

2. Classe `ToolTip`

3. Fonctions Principales

4. Interface Graphique

5. Boucle Principale

Conclusion

Code

A DECOUVRIR EGALEMENT

Redimensionnement de vidéos en Python

Gestion d’un ruban de leds

Raspberry PI5 Leds WS2812b

Laisser un commentaire Annuler la réponse

Gestion d’environnements Python

Présentation du Code

1. Imports et Dépendances

2. Classe ToolTip

3. Fonctions Principales

4. Interface Graphique

5. Boucle Principale

Conclusion

Code

A DECOUVRIR EGALEMENT

Redimensionnement de vidéos en Python

Gestion d’un ruban de leds

Raspberry PI5 Leds WS2812b

Laisser un commentaire Annuler la réponse

2. Classe `ToolTip`