PyAutoGUI

Automatize o uso do teclado e do mouse e crie robôs de comandos utilizando o PyAutoGUI em seu sistema Linux!

---

| Se você apoia nosso site, desative o AdBlock quando visitá-lo, inclusive em Mobile! Os anúncios são poucos e não invasivos. Se quiser contribuir com nosso trabalho, clique em qualquer banner de sua preferência, exceto dos Parceiros. Mais detalhes clicando aqui.

---

1. Introdução

Estava pensando com meus botões: o Python é uma linguagem de programação tão completa e complexa…. Eu já mostrei como automatizar comandos no Terminal com o Cron neste post… então, será que existe alguma coisa que automatiza tarefas de usuário na interface gráfica? – E a resposta é um grande Sim!

O PyAutoGUI é uma biblioteca para Python 2.7 e 3 – usaremos 3 nos exemplos abaixo – que permite automatizar movimentos e cliques do mouse, assim como comandos e ações do teclado. Ele permite que você controle aonde o mouse vai, quando clicar, clique + arraste, detectar a cor do pixel de determinada área da tela, dar comandos do teclado e digitar frases inteiras, entre outros.

Sabendo as sintaxes padrões desta postagem, você conseguirá, dentre outras coisas:

• Criar scripts de automação que jogam jogos simples como os típicos do ClickJogos.
• Criar scripts de automação para preencher formulários.
• Criar scripts de automação de resposta para mensageiros de redes sociais.
• Criar scripts de automação para desenhar automaticamente formas complexas.
• Criar scripts de automação para configurar programas que usam interface de usuário.

Enfim, a liberdade é grande. Principalmente considerando que esse script funciona em qualquer sistema, seja ele Windows, macOS, Linux, BSD, Solaris, enfim, onde o Python estiver presente e for suportado!

Observação:
Os scripts aqui ensinados funcionarão no X.Org!
Wayland não oferece pleno suporte às ferramentas que usaremos.

2. Instalação

Primeiro você deve saciar as dependências a seguir:

$ sudo apt install python3-tk scrot python3-dev python3-pip xdotool

Se seu sistema utilizar outro gerenciador de pacotes, mesma lógica, basta trocar apt por dnf ou zipper.
Com estas dependências satisfeitas, execute estes 2 comandos em sequência:

$ sudo pip3 install python3-xlib
$ sudo pip3 install pyautogui
$ sudo pip3 install --upgrade setuptools

Se você for usuário do macOS, deverá instalar estas dependências em sequência:

$ sudo pip3 install pyobjc-framework-Quartz
$ sudo pip3 install pyobjc-core
$ sudo pip3 install pyobjc
$ sudo pip3 install pyautogui

Com tudo instalado e configurado, vamos ás explicações!

Observação:
Peço encarecidamente que quem seguir este tutorial tenha o mínimo de conhecimento de programação em linguagem Python. Apesar dos comandos serem simples, existem variáveis de desenvolvimento que vão implicar no resultado de seu projeto de automação de interface.

Além disso, o que aqui for ensinado só será válido para o servidor gráfico X.Org!
O Wayland eliminou uma série de suportes às ferramentas do PyAutoGUI por motivos de segurança.
Portanto se você usar o Ubuntu 22.04, mude para o XOrg na tela de login para evitar dores de cabeça.

3. Resolução de Tela

Para programar aonde o mouse vai, você deve ter noção de coordenadas cartesianas. Num monitor comum, de resolução por exemplo 1920 x 1080, temos a distribuição de pixels sob os eixos X e Y conforme vemos abaixo:

Resolução 1920 x 1080

Com isso em mente, abra o terminal para capturar as coordenadas de tela de onde o mouse está, usando o seguinte comando:

$ xdotool getmouselocation

Você verá algo assim:

x:678 y:580 screen:0 window:46137345

Coordenadas X, Y, monitor 0 e o código da janela que o mouse estava sobre.
Não apenas o processo possui um PID próprio mas as janelas criadas no sistema possuem um código de identificação próprio. Pelo XDoTool você pode fechar uma janela específica sabendo seu código!
Mas no nosso caso isso não será detalhado por não ter a relevância para este tutorial e por haver meios melhores e mais práticos para tal ato.

4. Explicação

Os scripts que automatizam trajetos do mouse na tela são relativamente simples.
Você só precisa importar o módulo pyautogui:

import pyautogui

E imediatamente trazer o comando que deseja realizar.
As sintaxes de comando são as seguintes:

• pyautogui.size()
  Coleta a resolução de tela atual adicionando ela a variáveis que podem ser chamadas com:
  width, height = pyautogui.size()
  Assim você terá os valores de resolução de tela armazenados nas variáveis “width” e “height”
• pyautogui.moveTo(100, 100, duration=0.25)
  Move o mouse para as coordenadas 100 x 100 com duração de 0.25 segundo.
  Ajustando o valor da duração você muda a velocidade de deslocamento do mouse. Quanto maior o tempo, mais lento ele vai se mover. Um movimento lento dará tempo por exemplo até um programa concluir seu carregamento.
• pyautogui.dragTo()
  O mesmo do moveTo,inclusive com as variáveis, porém como clique e segurando!
• pyautogui.moveRel(100, -100, duration=0.25)
  Move o mouse a uma distância relativa: Do ponto em que o mouse estiver, ele irá se deslocar 100 pixels á direita e 100 pixels para baixo, por exemplo.
• pyautogui.dragRel()
  O mesmo do moveRel, inclusive com as variáveis, porém como clique e segurando!
• pyautogui.position()
  Exibe as coordenadas atuais da localização do mouse. Podem ser armazenadas numa variável para serem posteriormente utilizadas.
• pyautogui.click(100, 150, button=’left’)
  Vai clicar com o mouse nas coordenadas 100 x 150, com o botão esquerdo.
  Pode ser definido como middle (botão do meio / roda) ou right (direito)
  Se essa linha não tiver variáveis – pyautogui.click() – o mouse vai clicar por padrão direito, aonde estiver naquele momento.
• pyautogui.doubleClick()
  Fará um clique duplo aonde o mouse estiver – ou na coordenada definida.
• pyautogui.scroll(200)
  Vai descer a barra de rolagem vertical presente na tela 200 “unidades”.
  Essas unidades variam de sistema para sistema e você deve fazer alguns testes para ter certeza do quanto será “rolado”. Valor positivo rola para cima, valor negativo rola para baixo.
• im = pyautogui.screenshot()
  Esse comando tira um printscreen da tela e armazena ele na variável im.
  Com o comando:
  im.getpixel((100, 50))
  Você terá as cores RGB do pixel que estiver na coordenada 100 x 50.
  Assim seu programa terá uma maneira segura de ler as informações da tela, tirando um print e lendo o que foi visto. Mas existe um método mais direto para fazer isso.
• pyautogui.pixelMatchesColor(50, 200, (130, 135, 144))
  Vai analisar se o pixel da coordenada 50 x 200 possui a cor RGB 130,135,144.
  Com isso você pode criar uma função condicional, onde True ou Falso validam o que deve ser feito.
  Isso é particularmente útil por exemplo, o script vai preencher um formulário cuja janela possui uma logomarca. O mouse vai até a logo e analisa, se a logo possui uma cor única em um tom azul por exemplo, ele ativará o deslocamento do mouse e o posterior preenchimento dos campos; se o tom for diferente, o programa saberá que aquela janela não é a esperada e fará outra coisa a respeito – claro, você programando todas essas variáveis!
• pyautogui.locateOnScreen(‘submit.png’)
  Tire um pequeno print screen de uma área da tela e salve como submit.png.
  Assim, o programa vai pegar esse print e analisar aonde ele está na tela aberta naquele momento.
  O resultado poderá ser: (643, 745, 70, 29)
  O primeiro e o segundo valores são as coordenadas X e Y;
  O terceiro e quarto valores serão a altura e largura em pixels.
• pyautogui.typewrite(‘Hello World!’)
  Sintaxe: Palavra ou caractere entre ‘ ‘
  Por exemplo, após mover o mouse até as coordenadas X e Y, e dá 1 clique, o teclado vai escrever “Hello World!” no local designado.
• pyautogui.typewrite([‘enter’])
  Sintaxe: Nome da tecla entre [‘ ‘]
  Dá Enter!

Dar Enter:
pyautogui.typewrite([‘Enter’])

Escrever “Enter”:
pyautogui.typewrite(‘Enter’)

Tabela de Comandos para o teclado:

Caractere	Significado
‘a’, ‘b’, ‘c’, ‘A’, ‘B’, ‘C’, ‘1’, ‘2’, ‘3’, ‘!’, ‘@’, ‘#’ e etc.	Digitar um caractere
‘enter’ (ou ‘return’ ou ainda ‘\n’)	Tecla Enter
‘esc’	Tecla Esc
‘shiftleft’, ‘shiftright’	Teclas Shift esquerda e direita
‘tab’ (ou ‘\t’)	Tecla Tab
‘backspace’, ‘delete’	Teclas Backspace e Delete

A sintaxe continua sob o padrão já mostrado:

• altleft, altright; (Teclas Alt)
• ctrlleft, ctrlright; (Teclas Ctrl)
• home, end;
• up, down, left, right (setas)
• pageup, pagedown;
• f1, f2, f3, f4… (Teclas F1 a F12)
• volumemute, volumedown, volumeup; (Controle de volume)
• capslock, numlock, scrolllock;
• winleft, winright;
• capslock, numlock, scrolllock

Comandos do macOS: option e command;

5. Teclas de Atalhos

Você pode controlar quando uma tecla é pressionada ou solta. Assim permite fazer comandos combinados.

• pyautogui.hotkey(‘ctrl’, ‘c’)
  Permite usar “hotkeys”, atalhos. Com essa sintaxe ele pressiona as teclas na ordem e depois libera elas inversamente. No exemplo, ele segura a tecla Ctrl e depois c, soltando c e depois Ctrl.
  Ou seja, o comando copiar.

Até aqui, o que foi mostrado é curiosamente útil para automatizar uma resposta em um chat de rede social: O programa procura por um pixel de cabeçalho da janela de chat que vai demonstrar que a janela está aberta e então clicar no campo de mensagem, digitar e dar Enter.

Usando de exemplo o chat do Vilson, com a coordenada X Y do “meio” do cabeçalho, entre “Olivei” e o sinal de “+”, você terá o tom azul; O mouse vai até ali e compara. Se for branco, o chat está fechado e o script poderá ir para outro bloco de código que faça mouse mover e clicar em um contato específico usando comparação de print para saber quem é quem. Com o chat aberto, confirmando o tom azul, o mouse pode seguramente descer até o campo de texto, digitar e dar Enter. Com o sistema de print screen, poderá comparar inclusive textos de dúvidas com possíveis soluções a serem digitadas!

6. Fail-Safe

Os scripts do PyAutoGUI possuem um módulo de fail-safe, em caso de algo dar errado e o mouse clicar onde não deveria, você pode tomar a ação de volta interrompendo sua execução apenas tentando mover o mouse para o extremo canto superior esquerdo. Isso pode ser desativado adicionando estas variáveis no começo do código:

import pyautogui
pyautogui.PAUSE = 1
pyautogui.FAILSAFE = True

7. Exemplos

Bom, depois de toda essa apresentação dos comandos, hora dos exemplos práticos!
Os comando abaixo são salvos em texto plano, marcados como executáveis.
Caso tenha alguma dúvida sobre como marca um script como executável, basta rodá-lo no terminal:

$ python3 mover.py

1) Movendo o mouse para uma posição:

#!/usr/bin/env python3
import pyautogui
import time
time.sleep(3)
pyautogui.moveTo(100, 100, duration=0.25)

Esse comando vai aguardar 3 segundos para você “se preparar” e então vai fazer o mouse se mover, de onde estiver, para a coordenada 100 x 100 rapidamente.

2) Clicando em algo:

#!/usr/bin/env python3
import pyautogui
import time
time.sleep(3)
pyautogui.click(134o, 42)

Se seu monitor for 1340×768, vai fechar a janela que estiver aberta após 3 segundos, já que o botão fechar janela fica no canto superior direito aproximadamente na coordenada 1360×42.

3) Desenhando algo na tela:

Preparação:
Primeiro abra o GIMP, crie um Novo… com 500×500 pixels, selecione a ferramenta Pincel e deixe bem fino.
Minimize.

Crie o seguinte script:

#!/usr/bin/env python3
import pyautogui
import time
distance = 200
time.sleep(5)
while distance > 0:
###pyautogui.dragRel(distance, 0, duration=0.2) # Direita
###distance = distance -5
###pyautogui.dragRel(0, distance, duration=0.2) # Baixo
###pyautogui.dragRel(-distance, 0, duration=0.2) # Esquerda
###distance = distance -5
###pyautogui.dragRel(0, -distance, duration=0.2) # Cima

Observação:
Onde tem ### substitua por 1x TAB, assim ficará indentado corretamente!

Salve, marque como executável.
Execute-o e você terá 5 segundos de prazo pra minimizar o que estiver te atrapalhando e maximizar a janela do GIMP; além disso, deixe o mouse no canto superior direito da área de desenho!

O script, uma vez executado, deverá gerar algo assim após 5 segundos:

E aqui está o que foi produzido quando gravei este vídeo:

Caso queira cancelar o desenho, basta mover manualmente o mouse para o canto superior esquerdo da sua tela. Quando o mouse tocar o limite máximo (Coordenadas 0.0) ele vai parar o script.

4) Esse script vai pegar a atual coordenada x e y do mouse e mostrar a cor do pixel naquele ponto da tela.
A cada Enter, ele coleta a coordenada e exibe o pixel. Execute no BASH!

#!/usr/bin/env python3
import pyautogui
import time
x = 0
y = 0
try:
>while True:
>>time.sleep(1)
>>x, y = pyautogui.position()
>>print (x, y)
>>a = pyautogui.pixel(x, y)
>>print (a)
>>input("Press Enter to continue...")
except KeyboardInterrupt:
>quit()

Cada > é 1x Tab.
Se >>, 2x Tab para a correta indentação.

Com essa informação, você pode usar o comando de comparar se o pixel está True ou False, importante no processo de automação!

Exemplo, onde cada > é 1x Tab para indentação:

#!/usr/bin/env python3
import pyautogui
import time
if pyautogui.pixelMatchesColor(283, 542, (0, 128, 0)): # verifica se a cor em 283x542 é a RGB "0, 128, 0"
>pyautogui.moveTo(755, 158, duration=0.50) # Move o mouse
>time.sleep(1) # Aguarda 1 segundo
>pyautogui.click() # clique
>quit() # fim
else:
>pyautogui.moveTo(427, 591, duration=0.50) # Se o pixel não condizer com a cor, faça isso
>time.sleep(1) # aguarde 1 segundo

8. Conclusão

Utilizando as sintaxes apresentadas, somando a um pré conhecimento de Python, você poderá programar scripts complexos com facilidade! Uma verdadeira mão na roda para games de PC que exige movimentos rápidos e precisos, para preencher campos de pesquisa, enviar mensagens, enfim, toda sorte de comandos e movimentos que você faria se fosse você movendo o mouse e digitando manualmente.

Poderá por exemplo, abrir o terminal (CTRL + ALT + T em alguns sistemas), digitar um comando, dar Enter, confirmar com Y, etc.

Isso é simplesmente ideal para criar desenhos de formas complexas para edições de imagem.
Se o fundo da imagem for um canal alpha, você terá o desenho que demonstrei mas com fundo vazado para ser utilizado posteriormente.

Se você for paciente, poderá criar um script completo que funciona como uma “impressora” de tela – imagina as possibilidades de executar algo assim no AutoCAD nos scripts executando no Windows?
Com a combinação certa de ferramentas, poderá criar uma interface em GTK ou QT com campos, você preenche e depois o PyAutoGUI executa tudo de forma automática.

O limite será a disposição e imaginação de vocês!

Fonte:
Arte de chamada: WayNext
automatetheboringstuff: Capítulo 18