Un auto-cliqueur en Python est une application simple conçue pour simuler des clics de souris répétitifs selon une configuration définie par l'utilisateur. Il permet de contrôler des paramètres tels que la vitesse, la fréquence et la position des clics. Python, grâce à ses nombreuses bibliothèques, offre des moyens efficaces pour interagir avec le clavier et la souris, ce qui simplifie grandement la création de tels outils.

Ce guide explore différentes approches pour développer un programme de clic automatique en Python, en utilisant trois modules populaires.

1. Utilisation du Module pyautogui

Le module pyautogui est idéal pour les tâches d'automatisation d'interface graphique (GUI) car il permet de contrôler à la fois la souris et le clavier. Pour simuler un clic de souris, nous utilisons la fonction pyautogui.click(). La position du curseur peut être définie au préalable avec pyautogui.moveTo() en spécifiant les coordonnées X et Y.

Pour construire un auto-cliqueur avec pyautogui, nous allons déplacer le curseur à une position spécifique puis exécuter une boucle pour répéter l'appel à pyautogui.click(). Un bref délai sera introduit entre chaque clic via time.sleep() pour rendre l'action visible et éviter une exécution trop rapide.

Voici l'implémentation de base :

import pyautogui
import time

# Déplace le curseur à une position donnée (par exemple, 750x400)
pyautogui.moveTo(750, 400)

# Effectue 15 clics avec un court délai entre chaque
for _ in range(15):
    time.sleep(0.05) # Pause de 50 millisecondes
    pyautogui.click()

Dans cet exemple, le curseur est déplacé aux coordonnées (750, 400), puis la fonction click() est appelée 15 fois, avec un intervalle de 50 ms entre chaque clic.

2. Utilisation de win32api pour Windows

Le module win32api est spécifique aux systèmes d'exploitation Windows et permet une interaction directe avec les objets COM de Windows. Il peut être utilisé, en combinaison avec win32con, pour émuler des événements de souris. Pour simuler un clic gauche, la fonction win32api.mouse_event() doit être appelée deux fois : une fois avec win32con.MOUSEEVENTF_LEFTDOWN pour l'appui, et une autre fois avec win32con.MOUSEEVENTF_LEFTUP pour le relâchement.

La position du curseur peut être définie avec win32api.SetCursorPos(). Nous suivrons une logique similaire à la méthode précédente, en utilisant une boucle pour répéter les événements de clic.

Voici le code illustratif :

import win32api, win32con
import time

# Fonction utilitaire pour simuler un clic gauche
def simuler_clic_gauche(coord_x, coord_y):
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, coord_x, coord_y, 0, 0)
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, coord_x, coord_y, 0, 0)

# Définit la position du curseur (par exemple, 500x700)
win32api.SetCursorPos((500, 700))

# Effectue 10 clics avec un délai
for _ in range(10):
    simuler_clic_gauche(500, 700)
    time.sleep(0.2) # Pause de 200 millisecondes

3. Création d'un Auto-Cliqueur Avancé avec pynput et le Multithreading

Le module pynput offre un contrôle fin sur les périphériques d'entrée tels que la souris et le clavier en Python. Cette approche est plus sophistiquée, car elle implique la création d'une classe dédiée, héritant de threading.Thread, pour gérer l'auto-clic de manière asynchrone et réactive aux entrées clavier.

L'idée est de concevoir un auto-cliqueur qui peut être activé ou désactivé par la pression d'une touche spécifique, et arrêté complètement par une autre touche. Pour cela, nous importerons pynput.mouse et pynput.keyboard.

La classe GenerateurDeClic étendra threading.Thread pour permettre l'exécution du clic en arrière-plan. Dans son constructeur (méthode __init__), nous définirons le délai entre les clics et spécifierons le bouton de la souris (par exemple, Button.left pour le clic gauche).

Le thread principal gérera le cycle de vie de l'auto-cliuqeur, tandis qu'un écouteur de clavier (Listener) interceptera les touches définies pour démarrer, arrêter ou quitter le programme.

Voici la mise en œuvre détaillée :

import time
import threading
from pynput.mouse import Button, Controller
from pynput.keyboard import Listener, KeyCode

# Définition des touches de contrôle
cle_activation_desactivation = KeyCode(char='s') # 's' pour Start/Stop
cle_arret_programme = KeyCode(char='q')      # 'q' pour Quitter

class GenerateurDeClic(threading.Thread):
    def __init__(self):
        super().__init__()
        self.delai_entre_clics = 0.08  # Délai par défaut entre les clics (en secondes)
        self.bouton_clic = Button.left # Le bouton de souris à cliquer
        self.actif = False             # État actuel de l'auto-cliqueur (actif/inactif)
        self.doit_s_executer = True    # Contrôle l'exécution globale du thread

    def demarrer_clics(self):
        """Active l'auto-cliqueur."""
        self.actif = True

    def arreter_clics(self):
        """Désactive l'auto-cliqueur."""
        self.actif = False

    def terminer_application(self):
        """Arrête le thread et termine l'application."""
        self.arreter_clics()
        self.doit_s_executer = False

    def run(self):
        """Méthode exécutée par le thread."""
        while self.doit_s_executer:
            while self.actif:
                controleur_souris.click(self.bouton_clic)
                time.sleep(self.delai_entre_clics)
            time.sleep(0.05) # Petite pause lorsque l'auto-cliqueur est inactif

# Initialisation du contrôleur de souris et du thread de clic
controleur_souris = Controller()
gestionnaire_clic = GenerateurDeClic()
gestionnaire_clic.start() # Démarre le thread en arrière-plan

def gestionnaire_evenements_clavier(touche):
    """Fonction de rappel pour les événements de pression de touche."""
    if touche == cle_activation_desactivation:
        if gestionnaire_clic.actif:
            gestionnaire_clic.arreter_clics()
        else:
            gestionnaire_clic.demarrer_clics()
    elif touche == cle_arret_programme:
        gestionnaire_clic.terminer_application()
        ecouteur_clavier.stop() # Arrête l'écouteur de clavier

# Démarrage de l'écouteur de clavier
with Listener(on_press=gestionnaire_evenements_clavier) as ecouteur_clavier:
    ecouteur_clavier.join() # Maintient le programme en vie tant que l'écouteur est actif