Aller au contenu

Entrées humanisées

Avec humanize, le SDK exécute les déplacements de souris, les clics, le défilement et la frappe selon des trajectoires et un rythme proches de ceux d'une personne. showCursor dessine le pointeur pour que vous puissiez le suivre.

Entrées humanisées (humanize & showCursor)

Passez humanize et toutes les entrées — déplacements, clics, glisser-déposer, défilement et frappe — suivent un même standard humanisé, aussi bien au niveau de la page (page.click / hover / type / fill / mouse.* / keyboard.type) qu’au niveau des locators (locator.click / type / fill / pressSequentially / dragTo / …). Les déplacements suivent une courbe de Bézier cubique légèrement incurvée, construite à partir de la dernière position du curseur et parcourue comme une somme de sous-mouvements à jerk minimal (un mouvement balistique principal + un mouvement correctif — la vitesse à plusieurs pics d’un vrai geste de pointage, et non une seule cloche symétrique), et tout est envoyé sous forme d’événements réels et de confiance (isTrusted === true, et navigator.webdriver reste à false). Sur Pro, les clics par coordonnées (mouse.click(x, y)) suivent des mouvements enregistrés sur de vraies personnes ; tout le reste, ainsi que chaque clic sur le build ouvert et sur l’offre Gratuit avec GitHub, utilise des trajectoires générées. Ajoutez showCursor pour dessiner un point qui suit le mouvement et le voir à l’œuvre.

Comme les déplacements passent par des entrées natives, un bouton enfoncé avec mouse.down() reste maintenu pendant le déplacement — down → move → up donne donc un vrai glisser avec bouton maintenu (les contrôles qu’on positionne en glissant, comme les sliders, reçoivent un glisser réellement appuyé), et locator.dragTo est lui aussi humanisé. La frappe se fait touche par touche, avec un délai aléatoire entre les touches + des pauses entre les mots, de temps en temps une faute de frappe corrigée, et un chevauchement des touches : sur certaines paires rapides, la touche suivante s’enfonce avant que la précédente ne remonte, à un taux fixé par identité (SDK 0.41.1). fill clique dans le champ et tape la valeur (une valeur de plus de 200 caractères reçoit d’abord le clic puis est insérée d’un coup, pour que les gros remplissages ne traînent pas).

Le défilement avance par crans entiers de molette, par petits coups rapides avec, de temps en temps, une pause de lecture, et amène d’abord le pointeur au-dessus du contenu s’il n’y est pas déjà. Un navigateur rapporte chaque événement de molette comme un cran complet, et un vrai cran fait défiler de 100 px sous Windows, 120 sous Linux et 40 sous macOS. Le cran suit donc la plateforme qu’indique la page, et une distance demandée est arrondie au cran le plus proche, au moins un : mouse.wheel(0, 800) fait défiler de 800 px pour une identité Windows et de 840 pour une identité Linux (SDK 0.41.1).

Formulaires (SDK 0.48.0)

fill s’adapte au type de champ. Le texte est tapé, après un effacement avec des touches maintenues seulement si le champ contient une valeur, et le résultat est vérifié ; un curseur de plage est glissé jusqu’à la valeur exacte ; un champ date, heure, mois, semaine ou date-heure est tapé segment par segment dans l’ordre où le navigateur les affiche. Une valeur qu’un champ ne peut pas contenir lève l’erreur de Playwright lui-même, comme avant.

selectOption ouvre une liste déroulante d’un clic, tape le début du libellé de l’option (espaces compris) et valide avec Entrée, si bien que la page voit un seul changement de confiance, pas un par ligne ; les lignes qu’on ne peut pas atteindre en tapant sont atteintes avec une touche fléchée maintenue. Une zone de liste défile à la molette et se choisit par clics sur les lignes, Ctrl maintenu pour les lignes supplémentaires d’une sélection multiple. check / uncheck ne cliquent que lorsque l’état doit changer.

Aucune faute de frappe n’est faite dans les champs mot de passe, e-mail, nombre, téléphone, URL ou code à usage unique, ni dans un champ à l’intérieur d’un frame, et seul ce qui est réellement arrivé est corrigé. CLEARCOTE_HUMANIZE_TYPO_RATE fixe le taux par touche (par défaut 0.02 ; 0 désactive les fautes). Chaque option de clic est respectée (bouton, nombre de clics, maintien, modificateurs, position, force, trial), tous les locators Playwright fonctionnent, et la vérification qu’un point de clic n’est pas recouvert utilise le test d’atteinte du navigateur lui-même, de sorte que le pointeur ne bouge jamais avant sa trajectoire et que rien n’est pressé trop tôt.

Rythme et précision (SDK 0.49.0)

Les trajectoires de souris, les glisser-déposer et ambient_motion / ambientMotion gardent la durée prévue, même sur une machine chargée. Certaines trajectoires dépassent la cible puis reviennent, à un taux fixé par identité, et un glisser avec le bouton maintenu reste à quelques pixels de sa ligne, si bien que la poignée d’un curseur reste sur sa piste. Chaque appui que fait le SDK lui-même arrive après une courte pause une fois le pointeur arrivé (40 à 250 ms, durée typique fixée par identité).

Un contrôle sous une couche qui laisse passer les clics (un dégradé, une icône, un libellé flottant) est cliqué comme n’importe quel autre. trial exécute les vérifications de Playwright et n’effectue aucune entrée. Un champ avec une longueur maximale ou un masque de saisie (une date d’expiration, un numéro de téléphone) est tapé une seule fois, jamais effacé puis retapé, et les champs date et heure sont tapés avec le même rythme de frappe que le texte. Les erreurs sont celles de Playwright, formulées de la même façon.

En Python, en Node et en .NET (.NET depuis la 0.58.0), un clic par coordonnées (mouse.click(x, y)) peut être parcouru et pressé par le moteur du navigateur lui-même ; sur les moteurs jusqu’à 154 r39, cet appui arrive environ 10 ms après l’arrivée du pointeur, sans la pause. CLEARCOTE_HUMANIZE_ENGINE_CLICKS=off garde chaque clic sur le chemin du SDK, et =all (optionnel) envoie aussi au moteur les clics par sélecteur.

from clearcote import launch

browser = launch(fingerprint="seed-123", humanize=True, show_cursor=True)
page = browser.new_page()
page.goto("https://example.com")

page.click("text=Sign in")               # eased curve, then a trusted click
page.fill("#email", "you@example.com")   # focus + key-by-key human typing
page.locator("#password").type("s3cr3t") # locators are humanized too

# held-button drag (e.g. a slider): the press stays held across the move
x0, y0, x1 = 100, 300, 400               # the handle's start, and where to release it
page.mouse.move(x0, y0); page.mouse.down()
page.mouse.move(x1, y0); page.mouse.up()
browser.close()

Appui prolongé

Certains contrôles n’agissent que tant que le bouton reste enfoncé : un bouton à maintenir pour confirmer, un menu à appui long, un bouton d’appui prolongé qui se remplit avant d’accepter. press_and_hold / pressAndHold / PressAndHoldAsync effectue un seul appui long et humanisé sur un élément. Avec humanize, il est disponible sur la page (page.press_and_hold(selector)) et sur chaque locator (locator.press_and_hold()), frame locators compris ; la fonction du module press_and_hold(locator) fonctionne sur n’importe quelle page. L’API async (clearcote.async_api) porte les mêmes noms, avec await.

Il attend que l’élément soit visible et l’amène à l’écran (avec le défilement humanisé à la molette), fait glisser le pointeur vers un point proche du centre, propre à l’identité (ou vers position, relatif au coin supérieur gauche de l’élément comme dans Playwright), marque une courte pause et appuie. Le bouton reste enfoncé pendant duration millisecondes, par défaut une durée tirée à chaque fois entre 2,8 et 3,8 s, ou jusqu’à ce que until renvoie true : la condition est interrogée toutes les 100 ms, duration devient alors la durée maximale de l’appui (15 s si elle n’est pas donnée), et le bouton est relâché après un temps de réaction humain de 160 à 350 ms, pas au même instant que le changement de la condition.

Tant que le bouton est enfoncé, une main au repos bouge encore la souris de temps en temps : une dérive rare, au pixel entier, jamais à plus de 2 px du point d’appui, chaque mouvement étant un mouvement de confiance avec le bouton signalé comme enfoncé. tremor=False / tremor: false garde le pointeur immobile. button choisit gauche, droit ou milieu, et timeout fixe combien de temps attendre que l’élément devienne visible. L’appel renvoie true quand l’appui a duré tout son temps ou que until est devenu vrai, et false quand until ne l’est jamais devenu. Le bouton est toujours relâché, y compris quand until lève une erreur ; dans l’API async, until peut être une fonction async, et annuler l’appel relâche aussi le bouton.

from clearcote import launch, press_and_hold

browser = launch(fingerprint="seed-123", humanize=True)
page = browser.new_page()
page.goto("https://example.com")

# hold until the button reports it is done (at most 15 s), then let go
done = page.press_and_hold(
    "#hold", until=lambda: page.locator("#hold[data-state=done]").count() > 0
)
print(done)                              # False if the state never changed

# a fixed 4-second hold, pressed 20 px in from the left edge
page.locator("#confirm").press_and_hold(4000, position={"x": 20, "y": 10})

# a control inside an iframe
frame = page.frame_locator("iframe#widget")
frame.locator("#hold").press_and_hold(
    until=lambda: frame.locator("#hold[data-state=done]").count() > 0
)

# the module function works on any Playwright page
press_and_hold(page.locator("#menu-item"), 1200)
browser.close()