DEV Community: BotCity

Trilha de estudos para ser uma pessoa desenvolvedora Python RPA

Morganna — Fri, 29 Mar 2024 21:23:00 +0000

Python tem ganhado cada vez mais força no mundo da automação RPA e é importante, como profissionais, estudarmos também essa tecnologia para atender as demandas da melhor maneira possível.

Mas quais são os passos para aprender Python RPA?

Que tal seguir essas dicas de uma trilha para o seu desenvolvimento e ainda ter certificados para compartilhar suas novas skills técnicas?

🤖 Comece pela linguagem de programação Python

Este curso totalmente prático vai te guiar de forma clara e objetiva através das principais funcionalidades do Python.

Link: Python Basics - Introdução e Mão na Massa.

Para mais conteúdos para você aprender Python, siga as dicas do artigo "Como iniciar meus estudos em Python".

🤖 Desenvolva sua primeira automação Python

Este curso ministrado durante a Python Brasil de 2022 vai te ensinar a criar automações com visão computacional para qualquer sistema.

Link: Criando automações com visão computacional.

🤖 Segurança com Python RPA

Este curso vai te guiar de forma clara e objetiva através dos principais conceitos de segurança da informação e como aplicar esses conceitos em projetos Python com um foco especial em projetos de RPA.

Link: Segurança com Python RPA.

🤖 Aprenda como fazer orquestração da sua automação Python

Aprenda na prática de forma clara e objetiva as principais funcionalidades do orquestrador. Veja os benefícios e vantagens de usar cada recurso nos seus processos de automação.

Link: Orquestração de Python RPA.

🤖 Desenvolva uma automação com um importante sistema do mercado

Explore a automação SAP com Python e BotCity neste curso prático. Aprenda técnicas essenciais para agilizar os processos SAP de forma eficiente e eficaz.

Link: Automação de SAP com Python.

🤖 Pratique bastante e compartilhe sua evolução e seus aprendizados com a comunidade

Conheça o repositório de bots da comunidade, para aprender com o desenvolvimento de outras pessoas e compartilhar os seus projetos open source.

Link: Repositório de bots da comunidade.

O que achou dessas dicas? Bora começar esses estudos e sermos profissionais cada vez melhores!

E se tiver mais dicas, deixe nos comentários para complementar o conteúdo!

O papel da pessoa desenvolvedora muito além do código

Morganna — Fri, 29 Mar 2024 18:25:59 +0000

Estava acompanhando uma postagem no LinkedIn sobre como os times e as empresas precisam entender a importância do gerenciamento de projetos de automação. Você pode acompanhar a postagem neste link.

Entendo que é crucial que essa discussão ocorra entre as pessoas dos times de negócio e gestão. Mas essa preocupação deveria ser também considerada para pessoas desenvolvedoras e também outros papéis de pessoas tecnologistas.

Quando nos tornamos pessoas desenvolvedoras (independente do tipo de projeto que vamos desenvolver), colocamos na cabeça que somos pessoas que fazemos apenas código.

Mas na verdade, somos pessoas resolvedoras de problemas. Precisamos lembrar de exercitar esse papel, levando para os times que trabalhamos soluções que fazem mais sentido de acordo com os requisitos e projetos que temos que atender.

Além disso, resolver problemas não significa que vamos apenas desenvolver um código e acabou. Devemos encontrar soluções no mercado que nos ajudem, afinal de contas, nosso objetivo também é levar valor aos projetos que atuamos. Por isso é tão importante quando fazemos POCs (Proof of Concept, ou Prova de Conceito em português) das ferramentas que pesquisamos.

É nesse momento que testamos, avaliamos as funcionalidades e tentamos considerar quais serão os ganhos com aquela ferramenta. E isso vai muito além do que queremos. Por isso temos que entender o que as demais áreas precisam e o que de fato terá valor em nossa automação.

Um projeto de automação também é um projeto de software. E tal como um projeto de software, precisa de gerenciamento. Não basta entregar um executável para as pessoas usuárias. O que elas querem, no final do dia, é ter uma forma de orquestrar o que será executado.

Repare nas perguntas que as pessoas usuárias fazem:

Como eu sei se deu certo?
Como faço para agendar a execução?
E se der erro?
E se não executar?
Como eu levo uma comunicação eficaz para o time sobre o que está acontecendo com as automações?
Mas eu tenho uma planilha enorme de dados para consumir, e se falhar no meio do caminho?
Quem pode acessar as informações?
Onde eu coloco as senhas para autenticação nos sistemas?
Eu posso executar mais de uma automação por vez?

Entre tantas outras. E unir código com uma solução que te permita proporcionar todo esse gerenciamento é de extrema importância, principalmente porque a operação de automações pode ser facilmente escalada. E como vamos gerenciar isso?

Aproveitando a discussão, quero compartilhar com vocês uma trilha de estudos que pode te ajudar a entender melhor como seguir essas práticas e o nosso papel: trilha de estudos para Python RPA.

E o que você acha isso? Compartilhe suas experiências com a comunidade nos comentários e vamos trocar uma ideia.

Dicas sobre desenvolvimento de automação com visão computacional

Morganna — Sun, 17 Mar 2024 19:50:16 +0000

Existem diversos casos de uso em que o desenvolvimento das automações RPA podem ter um melhor resultado utilizando o apoio da linguagem de programação Python e a tecnologia visão computacional.

O que é visão computacional

A visão computacional é uma tecnologia que utiliza-se da Inteligência Artificial, Aprendizado de Máquina (ou Machine Learning) e reconhecimento óptico de caracteres (também conhecido como OCR) para desenvolver sistemas que possam interpretar e classificar imagens.

Por trás dessa tecnologia, existem algoritmos capazes de entender padrões apenas visualizando imagens e vídeos. E isso pode ser um grande poder para nos ajudar a automatizar tarefas e processos que precisam acessar sistemas que nem sempre nos permitem acessar o backend da aplicação desktop ou ainda a DOM (Document Object Model de uma página HTML) de uma página Web e temos que partir para a visão computacional.

Como usar a visão computacional para desenvolver automações

Vou deixar aqui como sugestão, um conteúdo bem interessante em formato de curso rápido com o passo a passo de como desenvolver a sua automação com visão computacional: Criando automações com visão computacional.

E como dica extra, vou deixar aqui também disponível acesso para a documentação de maneira gratuita de uma extensão que está em pré-release que você pode utilizar no Visual Studio Code para desenvolver suas automações com o apoio dessa tecnologia, visão computacional.

Dicas sobre como resolver problemas ao desenvolver com visão computacional

Elemento não encontrado

Algo que pode ajudar na investigação de elementos não encontrados pela visão computacional, é utilizar o seguinte comando logo após chamar a função find() e antes de executar operações como o click():

bot.save_screenshot("debug_find.png")

Isso pode te ajudar a analisar como estava a tela e talvez te dar um direcionamento de qual é o motivo do elemento não estar sendo encontrado.

Resolução da tela

Outra questão muito importante dentro do desenvolvimento com visão computacional é a resolução da tela. Caso esteja desenvolvendo uma automação que utiliza máquina virtual acessando via RDP, você pode seguir algumas dicas do artigo linkado.

Sugestões para avaliar problemas

Você pode analisar os pontos a seguir para descobrir o que pode estar acontecendo nas falhas do seu robô:

Talvez o período configurado no parâmetro waiting_time da função find() esteja muito curto e isso pode acontecer caso ainda não tenha dado tempo de carregar a tela, então você poderia ajustar esse item;
Talvez o sistema sendo automatizado possua algum bloqueio contra captura de telas (esse tipo de problema pode ser bastante comum em telas que envolvam Bancos, por exemplo);
Talvez algum outro elemento esteja na frente do elemento buscado, então a sugestão de tirar um print da tela citada acima, pode ajudar a entender se isso está acontecendo;
Pode ser que o recorte foi feito com outra resolução que não a do sistema atual. Lembre-se de tentar desenvolver num ambiente igual ou ao menos o mais parecido possível, principalmente ao que se refere às configurações de resolução;
Verifique se você está fazendo os recortes necessários em um ambiente com tema dark, por exemplo, porque isso pode fazer diferença se em outro momento, o ambiente estiver com o tema light;
E outra dica seria verificar a acurácia do algoritmo de visão computacional. Na função find(), ajuste, se necessário, o parâmetro matching. Ele costuma estar com o valor máximo 0.97. Esse valor poderia ser ajustado a, no mínimo, 0.90. Isso pode ajudar nas questões levantadas neste tópico. Mas cuidado para não diminuir muito mais que isso, a ponto do algoritmo perder a sua eficiência para encontrar o elemento que precisa ser identificado.

Já fez alguma automação com visão computacional?

Compartilhe suas experiências com essa forma de desenvolvimento e, caso tenha passado por algum problema ou erro, compartilhe também como solucionou ocorrido. Sempre bom aprender com experiências diferentes.

E não deixe de participar da comunidade para mais trocas e conteúdos.

Como identificar problemas de ambiente ao tentar instalar BotCity Studio SDK

Morganna — Tue, 12 Mar 2024 17:14:57 +0000

Para utilizar qualquer tecnologia e/ou linguagem de programação, você deve preparar o ambiente para que seu código funcione adequadamente conforme você o desenvolve. E as orientações sobre como fazer isso, normalmente constam nas primeiras etapas da documentação dessa tecnologia.

No caso do desenvolvimento de automações RPA com as ferramentas da BotCity também funciona dessa maneira. As orientações estão na documentação com os pré-requisitos. Mas dependendo do computador que estamos utilizando, pode ser que tenhamos algumas dificuldades para instalar algo.

Isso pode acontecer por alguns motivos:

algumas tecnologias podem ter pré-requisitos para funcionar;
alguns computadores podem ter bloqueios para instalar algo, caso você não seja a pessoa administradora da máquina.

Essas questões ressaltam quando estamos lidando com computadores que são da empresa na qual trabalhamos que, por segurança, adiciona bloqueios nesses equipamentos.

Caso você esteja tentando preparar o ambiente para desenvolvimento de suas automações utilizando as ferramentas da BotCity e enfrente alguma dificuldade, é importante que você conheça também a ferramenta Diagnostic.

Essa ferramenta acompanha o mesmo pacote que você realiza o download do Wizard para instalação do BotCity Studio SDK. Seu objetivo é validar se o ambiente atende os pré-requisitos para que você utilize esse SDK sem problemas e se é possível a instalação das ferramentas em seu computador, além de confirmar se será possível estabelecer uma conexão de sucesso com o BotCity Orquestrador.

Como executar o diagnóstico

Ao fazer o dowload do BotCity Studio SDK, você terá uma pasta compactada chamada Wizard. Ao descompactá-la, um dos arquivos disponíveis será o diagnostic.jar.

⚠️ Para executar o Diagnostic no Linux ou no MacOS, é necessário ter o Java instalado. Se você for executar no ambiente Windows, pode executar sem essa preocupação.

A janela do Diagnostic se abrirá e você deverá adicionar o seu login da conta criada para utilizar o SDK e o Orquestrador. No campo "Email" preencha o seu e-mail cadastrado e no campo "Password" adicione a sua senha. Após isso clique no botão localizado do lado direito da janela, chamado “Run”.

Caso você não preencha e-mail e senha, o Diagnostic não fará os testes de login com o Orquestrador, deixando essa informação como resultado do teste: "E-mail ou senha não informados. Essa etapa foi pulada".

Após clicar em "Run", o Diagnostic começará os testes do ambiente. Se terminar com tudo funcionando corretamente, uma janela de confirmação aparecerá em cima informando que o diagnóstico finalizou e que o sistema está pronto para o desenvolvimento.

Status dos resultados do diagnóstico

Pode ser que você perceba três diferentes status após a execução. São eles:

PASS: significa que o teste passou;
FAIL: significa que o teste falhou e será necessário averiguar o problema;
SKIP: significa que o teste anterior com o SSL (certificado) habilitado, funcionou, então o Diagnostic não precisou executar um novo teste com o SSL desabilitado.

Caso receba o resultado FAIL em algum teste de conexão, possivelmente há algum bloqueio no ambiente que você está utilizando. E, neste caso, é necessário solicitar ao time responsável da empresa onde você trabalha, as liberações descritas na documentação de problemas com bloqueios de ambiente.

Como exportar o resultado dos testes

Se for necessário, você pode exportar o resultado dos testes em formato .csv. Para fazer isso, clique no botão "Export" localizado na parte debaixo da janela, do lado direito. Feito isso, uma nova janela se abrirá para você ter acesso ao arquivo.

Ficou alguma dúvida?

Você pode acessar o nosso FAQ para dúvidas frequentes, ou ainda entrar em contato com a comunidade global no Slack. Caso prefira, também temos o fórum disponível para dúvidas.

Como identificar se a automação está executando localmente ou no BotCity Orquestrador?

Morganna — Wed, 06 Mar 2024 20:31:41 +0000

A dúvida surgiu

Enquanto estávamos em nossa live coding desenvolvendo uma automação com Python e fazendo integração com e-mail e Google Sheets, surgiu uma dúvida:

Como identificar se a automação está executando localmente ou no BotCity Orquestrador?

Essa dúvida surgiu por causa da seguinte situação: quando estamos executando nossa automação localmente, ou seja, em nosso computador ou máquina virtual, e queremos conectá-la com o BotCity Orquestrador, precisamos utilizar o BotCity Maestro SDK para fazer login na plataforma. Mas quando fazemos deploy no Orquestrador, esse trecho de código para o login não precisa existir.

Exemplo prático

Criei um robô seguindo a documentação do framework web para exemplo. Abaixo temos o código principal:

# Import for the Web Bot
from botcity.web import WebBot, Browser, By

# Import for integration with BotCity Maestro SDK
from botcity.maestro import *

# Disable errors if we are not connected to Maestro
BotMaestroSDK.RAISE_NOT_CONNECTED = False


def main():
    # Runner passes the server url, the id of the task being executed,
    # the access token and the parameters that this task receives (when applicable).
    maestro = BotMaestroSDK.from_sys_args()
    ## Fetch the BotExecution with details from the task, including parameters
    execution = maestro.get_execution()

    print(f"Task ID is: {execution.task_id}")
    print(f"Task Parameters are: {execution.parameters}")

    bot = WebBot()

    # Configure whether or not to run on headless mode
    bot.headless = False

    # Uncomment to change the default Browser to Firefox
    # bot.browser = Browser.FIREFOX

    # Uncomment to set the WebDriver path
    # bot.driver_path = "<path to your WebDriver binary>"

    # Opens the BotCity website.
    bot.browse("https://www.botcity.dev")

    # Implement here your logic...
    ...

    # Wait 3 seconds before closing
    bot.wait(3000)

    # Finish and clean up the Web Browser
    # You MUST invoke the stop_browser to avoid
    # leaving instances of the webdriver open
    bot.stop_browser()

    # Uncomment to mark this task as finished on BotMaestro
    # maestro.finish_task(
    #     task_id=execution.task_id,
    #     status=AutomationTaskFinishStatus.SUCCESS,
    #     message="Task Finished OK."
    # )


def not_found(label):
    print(f"Element not found: {label}")


if __name__ == '__main__':
    main()

E assim fica o código do requirements.txt:

botcity-framework-web>=0.8.0,<1.0
botcity-maestro-sdk>=0.3.3,<1.0

O que eu fiz para poder executar esse código, foi descomentar a linha:

bot.browser = Browser.FIREFOX

E adicionar o geckodriver na configuração do WebDriver, deixando-o na pasta resources:

bot.driver_path = r"resources\geckodriver.exe"

Esse bot é apenas um exemplo e o que ele faz ao ser executado é abrir o navegador Firefox (poderia ter sido o Chrome, Edge, entre outros) com o site da BotCity e, depois de três segundos, fecha o navegador.

Conexão com BotCity Orquestrador

Se você precisar se conectar com a plataforma para orquestração, você precisará adicionar o seguinte código para fazer login no BotCity Orquestrador:

maestro.login(
    server='MAESTRO_SERVER', 
    login='MAESTRO_LOGIN', 
    key='MAESTRO_KEY'
)

Por serem dados sensíveis, uma saída para ocultar os dados é utilizando dotenv do Python e o OS. Para isso, basta importar da seguinte forma:

from dotenv import load_dotenv
import os

...

def main():
    load_dotenv()
    ...

E no arquivo requirements.txt precisa adicionar a biblioteca dotenv:

botcity-framework-web>=0.8.0,<1.0
botcity-maestro-sdk>=0.3.3,<1.0

python-dotenv

Além disso também é necessário termos um arquivo chamado .env, pois é de lá que o código buscará as informações. E esse arquivo ficará da seguinte forma:

MAESTRO_SERVER = "coloque o server aqui"
MAESTRO_LOGIN = "coloque o login aqui"
MAESTRO_KEY = "coloque a key aqui"

Essas informações ficam disponíveis em Dev. Environment, no BotCity Orquestrador.

OBS: É importante lembrar de não disponibilizar o .env ao versionar em plataformas como o GitHub, Gitlab, entre outras. Para facilitar, adicione .env ao arquivo .gitignore.

Qual a diferença entre o ambiente local e o orquestrador

Quando executamos nossa automação dentro do Orquestrador, uma tarefa é criada, atrelada a automação que fizemos o deploy, então por ele nós temos o ID da tarefa (ou task_id). Já no ambiente local, não temos essa informação.

Como validar em qual ambiente está sendo executado

Então podemos, por exemplo, fazer a seguinte validação: se task_id for igual a 0, estamos executando localmente e precisamos fazer o processo de login com o Orquestrador. Caso contrário, o task_id existe e, então, não precisamos fazer o login.

...
    maestro = BotMaestroSDK.from_sys_args()

    ## Fetch the BotExecution with details from the task, including parameters
    execution = maestro.get_execution()

    if(execution.task_id == 0):
        print("Running locally so we need to login to BotCity Orchestrator.")
        maestro.login(
            server=os.getenv('MAESTRO_SERVER'), 
            login=os.getenv('MAESTRO_LOGIN'), 
            key=os.getenv('MAESTRO_KEY')
        )
    else:
        print("Running with BotCity Orchestrator.")
...

Execução local

Ao testar a execução do robô localmente, percebemos que retorna a mensagem correta no terminal:

Execução no Orquestrador

Ao testar a execução do robô no Orquestrador, percebemos que retorna a mensagem correta no terminal:

Código completo

Caso queira validar como ficou o código principal completo, segue abaixo:

# Import for the Web Bot
from botcity.web import WebBot, Browser, By

# Import for integration with BotCity Maestro SDK
from botcity.maestro import *

from dotenv import load_dotenv
import os

# Disable errors if we are not connected to Maestro
BotMaestroSDK.RAISE_NOT_CONNECTED = False


def main():
    load_dotenv()

    # Runner passes the server url, the id of the task being executed,
    # the access token and the parameters that this task receives (when applicable).
    maestro = BotMaestroSDK.from_sys_args()

    ## Fetch the BotExecution with details from the task, including parameters
    execution = maestro.get_execution()

    if(execution.task_id == 0):
        print("Running locally so we need to login to BotCity Orchestrator.")
        maestro.login(
            server=os.getenv('MAESTRO_SERVER'), 
            login=os.getenv('MAESTRO_LOGIN'), 
            key=os.getenv('MAESTRO_KEY')
        )
    else:
        print("Running with BotCity Orchestrator.")

    bot = WebBot()

    # Configure whether or not to run on headless mode
    bot.headless = False

    # Uncomment to change the default Browser to Firefox
    bot.browser = Browser.FIREFOX

    # Uncomment to set the WebDriver path
    bot.driver_path = r"resources\geckodriver.exe"

    # Opens the BotCity website.
    bot.browse("https://www.botcity.dev")

    # Implement here your logic...
    ...

    # Wait 3 seconds before closing
    bot.wait(3000)

    # Finish and clean up the Web Browser
    # You MUST invoke the stop_browser to avoid
    # leaving instances of the webdriver open
    bot.stop_browser()

    # Uncomment to mark this task as finished on BotMaestro
    maestro.finish_task(
        task_id=execution.task_id,
        status=AutomationTaskFinishStatus.SUCCESS,
        message="Task Finished OK."
    )


def not_found(label):
    print(f"Element not found: {label}")


if __name__ == '__main__':
    main()

O que achou?

Espero que tenha curtido a dica e possa adaptá-la de acordo com a necessidade da sua execução. Qualquer dúvida, basta entrar em contato pela nossa comunidade.

Sites para praticar RPA

Bruna Ferreira — Wed, 08 Nov 2023 01:45:12 +0000

Para esse artigo você precisa ter:

Conhecimento básico de programação

Conhecimento básico da biblioteca Selenium

Qualquer dúvida, comente!

Robotic Process Automation (RPA) visa implementar soluções com automação robótica de processos para livrar pessoas de trabalhos repetitivos, trazendo mais agilidade e segurança para os negócios. Esses processos podem acontecer interagindo com aplicativos de computador como sistemas Customer Relationship Management (CRM), Enterprise Resource Planning (ERP) ou mesmo navegadores web, acessando portais comumente utilizados pelas organizações.

Quando entramos no contexto de RPA, temos diversas ferramentas diferentes para atender nossas demandas, sendo elas plataformas “no-code” ou “low-code” e ainda existe a possibilidade de utilizar código em alguma linguagem de programação para criar sua automação. Nesse artigo eu apresento um site para praticar suas automações do tipo Web, utilizando código Python e interagindo com navegadores diretamente com o Document Object Model (DOM) das páginas.

Uma das formas de melhorar a habilidade de programar é praticando. Dentro da área de RPA não é diferente, precisamos aprender sobre como os processos funcionam e assim conseguir desenvolver um programa capaz de executar todos os passos necessários para realizar a tarefa proposta com sucesso.

Practice Test Automation

Nesse site temos opções de fazer testes com nossa automação em contextos como:

Test Login Page: preenchendo o login da página utilizando as credenciais disponíveis, podendo testar casos de login válido ou inválido
Test Exceptions: tratamento de exceções mais comuns com base na ferramenta Selenium.

Abordando o primeiro caso, temos a possibilidade de preencher dois campos de texto, referentes a username e password e clicar um botão submit. Dependendo de como os campos foram preenchidos, teremos como respostas diferentes ao clicar no botão. A partir dessas respostas poderemos avaliar se a automação está passando pelas etapas corretas.

Como fica em código?

É importante verificar se todas as dependências necessárias estão instaladas na máquina para executar o código.

Para esse projeto utilizaremos as seguintes bibliotecas, nas versões fixadas:

selenium==4.10.0
webdriver-manager==3.8.5

O comando de instalação no terminal fica dessa forma:

python -m pip install selenium==4.10.0 webdriver-manager==3.8.5

Criaremos um arquivo python com o nome de bot.py, nele descreveremos os passos para preencher o formulário em forma de instruções.

from time import sleep

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.firefox.service import Service


def main():
    try:
        # Define o caminho do WebDriver executável do Firefox
        service = Service(executable_path=r"geckodriver.exe")

        # Cria uma instância do Navegador
        bot = webdriver.Firefox(service=service)

        # Define a URL da página Practice Test Automation na área de login
        url = "https://practicetestautomation.com/practice-test-login/"
        # Acessa página definida
        bot.get(url)

        # Busca pelo elemento input de nome de usuário
        elemento_campo_usuario = bot.find_element(
            by=By.ID,
            value="username"
            )
        # Ação de digitar no elemento
        elemento_campo_usuario.send_keys("student")

        # Busca pelo elemento input de senha
        elemento_campo_senha = bot.find_element(
            by=By.ID,
            value="password"
            )
        # Ação de digitar no elemento
        elemento_campo_senha.send_keys("Password123")

        # Busca pelo elemento botão submit
        elemento_botao = bot.find_element(
            by=By.ID,
            value="submit"
            )
        # Ação de clicar
        elemento_botao.click()

        # Aguarda 3 segundos para garantir
        # que carregou a página com resultado
        sleep(3)

        # Busca pela confirmação de login
        elemento_logado = bot.find_element(
            by=By.CSS_SELECTOR,
            value=".post-title"
            )
        # Imprime o texto da confirmação
        print(elemento_logado.text)

        # Busca pelo elemento botão log out
        elemento_deslogado = bot.find_element(
            by=By.CSS_SELECTOR,
            value=".wp-block-button__link"
            )
        # Ação de clicar no elemento
        elemento_deslogado.click()

    except Exception as ex:
        # Busca pelo elemento de mensagem de erro
        error_alert = bot.find_element(
            by=By.ID,
            value="error"
            )

        # Imprime a mensagem de erro
        print(error_alert.text)

    finally:
        # Finaliza fechando o navegador
        bot.quit()

        # Imprime mensagem de finalização
        print("Finally")


if __name__ == "__main__":
    main()

Ao executar esse código, o resultado deve ser a seguinte:

PS C:\practice_test_automation> python .\bot.py
Logged In Successfully
Finally

Nesse caso, ocorreu tudo como esperado, a automação preencheu os campos com os valores corretos e clicou no botão de login, acessando a página de confirmação e depois clicou em logout para sair da página.

Para testar outras validações, vamos alterar inicialmente o preenchimento do campo de nome de usuário, colocando um valor inválido.

        # Ação de digitar no elemento
        # elemento_campo_usuario.send_keys("student")
        # Valor incorreto para teste de erro
        elemento_campo_usuario.send_keys("estudante")

Esse será o resultado ao executar:

PS C:\practice_test_automation> python .\bot.py
Your username is invalid!
Finally

Conclusão

Podemos notar que o site oferece algumas formas de busca e interação com os elementos da DOM. Como sugestão, tente fazer outras alterações como mudar a senha que retorna outra mensagem de validação, além da possibilidade de procurar por outros elementos e interagir com eles.

Enjoy!

Why is it important to orchestrate your automation built in Python or other programming languages?

Morganna — Mon, 09 Oct 2023 14:03:16 +0000

RPA automation projects have several stages. We must care for each of them to ensure maximum assertiveness and successful delivery, from defining and mapping processes through development to orchestration and management, monitoring executions, taking care of the support part, and monitoring what is happening. We will start a series of weekly articles explaining and focusing on orchestration and how you can do it step by step for every need.

Is it possible to orchestrate automation built by code?

Yes. The BotCity Maestro Orchestrator is a tool that helps you orchestrate your automation, regardless of the language or technology used, either using the interface or interacting with the API.

Through BotCity Maestro Orchestrator, you can define which technologies you are using in your bot at the time of deployment or use our Command technology, through which you can enter a command that will activate your robot even if someone built it in a programming language.

Follow our documentation and the next articles in this series to understand how to do each orchestration step according to your project’s needs.

Why is it important to orchestrate RPA automation?

Keeping track of how your automations are working, especially when there are several executions, can help you monitor them. Not just by guaranteeing whether or not they have been carried out. But also making it possible to understand possible errors, when each robot should execute, in what sequence, etc.

Orchestrating makes day-to-day life easier, allows you to act on potential problems, and can help your team improve automated processes.

As well as running our robots, you need to:

Deploy your automation in execution environments;
Schedule the execution of your automation;
Manage tasks in queues according to their priority;
Monitor the status of tasks;
Monitor executions in real-time, following execution logs;
Trigger alerts and notifications when necessary;
Handle errors as quickly as possible;
Having a credentials vault that facilitates the execution of specific process steps that require authentication in different systems;
Audit and ensure the governance of the processes.

We must go far beyond “it worked” or “it went wrong, now what do I do?”. Management can help ensure a scalable and centralized operation, coordinating workflow more efficiently and safely.

Who is the automation orchestration process important for?

Orchestration can involve the business or product area and the IT team (specifically the RPA center of excellence), whether they operate, consume, analyze processes, or develop automation. Managing executions is essential for several areas in the company, not least because all the information we discussed in the previous question needs to be attainable and easy to find.

How to orchestrate using BotCity Maestro Orchestrator?

You can follow the next articles here on our blog. Every week, we’ll show you how to use each one of the features. Create a free account and test the orchestrator. But you can also check out our documentation, look for support in our community, or ask questions in the forum.

Por que é importante orquestrar suas automações feitas em Python ou outras linguagens de programação?

Morganna — Mon, 09 Oct 2023 13:58:55 +0000

Projetos de automações RPA possuem diversas etapas. Precisamos nos preocupar com cada uma delas para garantir o máximo de assertividade e sucesso na entrega. Desde o processo de definição e mapeamento de processos, passando pelo desenvolvimento, até a orquestração e gerenciamento, para acompanhar as execuções, cuidar da parte de sustentação e também para acompanhar o que está acontecendo. Vamos começar uma série de artigos semanais explicando e focando na orquestração de robôs e como você pode fazer o passo a passo para cada necessidade.

É possível fazer orquestração de automações feitas em código?

Sim. Você pode conhecer, por exemplo, nossa ferramenta chamada BotCity Maestro Orchestrator. Trata-se de uma ferramenta que te ajuda a orquestrar suas automações, independente da linguagem ou da tecnologia utilizada, seja via interface ou interagindo pela API.

Pelo BotCity Maestro Orchestrator você pode definir qual tecnologia está sendo utilizada no seu bot no momento do deploy, ou utilizar a nossa tecnologia Command, pela qual você pode informar um comando que ativará o seu robô mesmo que construído em alguma linguagem de programação.

Acompanhe a nossa documentação e os próximos artigos dessa série para entender como fazer cada etapa de orquestração de acordo com a necessidade do seu projeto.

Por que é importante orquestrar as automações RPA?

Fazer o acompanhamento de como suas automações estão funcionando, principalmente quando são diversas execuções, pode te ajudar a monitorá-las. Não apenas trazendo uma garantia de saber se foram ou não foram executadas. Mas também possibilitando o entendimento de possíveis erros, em que momento cada robô deve ser executado, em qual sequência etc.

Isso facilita o dia-a-dia, permite atuar onde possíveis problemas possam ocorrer e pode, inclusive, melhorar ainda mais processos que já foram automatizados.

Além de executar os nossos robôs, precisamos:

Realizar deploy de suas automações em ambientes de execução;
Agendar a execução de suas automações;
Gerenciar tarefas em filas de acordo com a prioridade de cada uma delas;
Acompanhar os estados das tarefas;
Monitorar execuções em tempo real, acompanhando logs de execução;
Disparar alertas e notificações quando necessário;
Tratar erros da forma mais rápida possível, com um local onde você possa identificá-los e saber onde atuar para corrigi-los;
Ter um cofre de credenciais que facilite a execução de determinadas etapas de processo que precisam autenticar em sistemas diferentes;
Fazer auditoria e garantir governança dos processos executados de acordo com as necessidades da área atendida.

Precisamos ir muito além do “deu certo” ou “deu erro, e agora?”. A gestão pode ajudar a garantir uma operação escalável e centralizada, coordenando o fluxo de trabalho de maneira mais eficiente e segura.

Para quem é importante o processo de orquestração de automações?

A orquestração pode envolver tanto a área de negócios ou de produto, como o time de TI (ou especificamente o centro de excelência de RPA), seja quem opera, quem consome, quem analisa os processos ou quem desenvolve as automações. Gerenciar as execuções é importante para diversas áreas na empresa, até porque todas as informações que discutimos na questão anterior precisam ser atingidas e fáceis de serem buscadas.

Como orquestrar utilizando o BotCity Maestro Orchestrator?

Você pode acompanhar os próximos artigos aqui em nosso blog. Semanalmente vamos demonstrar como utilizar cada uma das funcionalidades dentro da ferramenta. Mas você também pode verificar a nossa documentação, buscar apoio em nossa comunidade, tirar suas dúvidas no fórum ou ainda acompanhar esse workshop que realizamos online. Crie uma conta gratuita e faça os testes para a sua necessidade.

Construindo um bot com Python RPA para interagir com sistemas desktop

Morganna — Wed, 20 Sep 2023 23:14:50 +0000

Você já deve conhecer ferramentas e frameworks que podem te ajudar a construir automações para interagir com sistemas Web. Mas e quando se trata de sistemas desktop, como você faz? Vim te mostrar como utilizar o framework Open Source da BotCity com diversas funcionalidades para você construir a sua automação com Python RPA.

Preparando o ambiente de desenvolvimento

Crie a sua conta gratuita na plataforma da BotCity;
Acompanhe o passo a passo da instalação nas orientações da documentação de pré-requisitos e da instalação do SDK BotCity Studio;
Instale o Sicalc (caso queira seguir o tutorial com o mesmo programa de exemplo utilizado).
- o Sicalc desktop é utilizado de maneira offline, então não será gerada uma Nota Fiscal válida;
- o Sicalc funciona para sistema operacional Windows, contudo todo o processo e uso do framework pode ser aplicado também para distribuições Linux e MacOS sem problemas;
- ao abrir o Sicalc pela primeira vez, será solicitado um código de município. Para o nosso exemplo, vamos colocar o 7107 que representa São Paulo, mas poderia ser qualquer outro.

Primeiros passos do desenvolvimento do nosso robô

Criando o projeto a partir do template da BotCity

No terminal do seu computador, dentro da pasta em que você deseja criar o projeto, execute o seguinte comando para instalarmos o pacote cookiecutter (porque os templates oferecidos foram criados a partir dele).

Para instalarmos o pacote do cookiecutter, vamos executar o seguinte comando:

python -m pip install --upgrade cookiecutter

Para criarmos um projeto usando o modelo, vamos invocar o cookiecutter e fornecer como argumento a URL do repositório onde os templates da BotCity estão localizados:

python -m cookiecutter https://github.com/botcity-dev/bot-python-template/archive/v2.zip

Durante a execução deste comando, você precisará informar duas coisas:

project_type: refere-se ao tipo de projeto que deseja criar. O template fornecerá algumas opções, mas neste caso, vamos escolher o número 1, pois vamos construir um bot Desktop;
bot_id: refere-se a uma identificação que você deseja dar para o seu projeto. Neste exemplo, chamaremos de bot-sicalc.

Após o término do processo acima, uma nova pasta chamada bot-sicalc estará disponível. Você pode entender um pouco mais sobre a estrutura e como ele funciona com as orientações na documentação.

Instalando as dependências do seu projeto

Normalmente, projetos de desenvolvimento podem ter dependências como os frameworks utilizados, pacotes importantes, entre outros. O nosso também tem dependências e você poderá identificá-las no arquivo requirements.txt. Você notará que há pelo menos essas duas:

botcity-framework-core # framework de desenvolvimento da automação
botcity-maestro-sdk # API do BotCity Maestro para orquestração da automação

Antes de rodar o seu projeto, é importante fazermos a instalação dessas dependências. E para isso, devemos executar o seguinte comando:

pip install --upgrade -r requirements.txt

Primeira execução do nosso robô

Se você entrar no arquivo bot.py, perceberá que já temos um código pré-pronto e alguns comentários com orientações importantes sobre como fazer alguns dos próximos passos.

Entenda o que o código está fazendo

Identifique as linhas com os comandos abaixo. Elas estão importando as bibliotecas que mencionamos do arquivo requirements.txt para que consiga utilizá-las no seu código.

from botcity.core import DesktopBot
from botcity.maestro import *

E nas linhas abaixo, estamos criando um objeto para o bot com o framework Desktop e pedindo para ele abrir um navegador no site da BotCity.

bot = DesktopBot()
bot.browse("<http://www.botcity.dev>")

Execute o robô

Para ver o robô sendo executado, você pode fazer isso pela IDE que estiver utilizando ou na linha de comando com o seguinte:

python bot.py

Deu certo? Abriu o navegador do seu computador com o site da BotCity? Aqui está um exemplo de qual seria o resultado esperado após essa execução:

💡 Uma dica interessante é você testar se o que está acontecendo é o esperado. Tente fazer essa prática de testar aos poucos para você entender o que está acontecendo. Isso também facilitará no entendimento caso algum erro ocorra.

Como lidar com os erros

Caso não tenha funcionado de primeira, não se preocupe. É normal você passar por alguns erros quando está desenvolvendo algo pela primeira vez ou aprendendo algo do zero. Te convido a acompanhar este post sobre alguns erros que podem acontecer e te encorajar a compartilhar os erros que você teve e como os resolveu.

Caso esteja com alguma outra dificuldade no desenvolvimento, fique à vontade para entrar em nosso fórum ou em nossa comunidade no slack para pedir ajuda e tirar suas dúvidas.

Desenvolvendo o robô desktop

Para esse desenvolvimento, vamos utilizar o BotCity Studio, que através de visão computacional, nos ajudará com o mapeamento dos itens na tela do sistema utilizado para que nosso robô possa interagir com ele.

Carregando o projeto BotSicalc no BotCity Studio

Mantenha a sua IDE aberta com o seu projeto. Abra também o BotCity Studio e, no menu superior, escolha a opção "File" e, em seguida, "Load Project".

Uma nova janela se abrirá e, nela, você deverá clicar em "browse" e identificar onde está a pasta do seu projeto.

Em seguida, identifique o arquivo com extensão .botproj. Selecione este arquivo para o BotCity Studio carregar o seu projeto. No caso deste exemplo, o arquivo será “bot-sicalc.botproj”. Após isso, clique em "Open" e, em seguida, "Launch". Pronto, você já tem seu projeto carregado no BotCity Studio.

Prosseguindo no desenvolvimento

Para os próximos passos, vamos manter as duas ferramentas abertas, a sua IDE e o BotCity Studio, para que os códigos sejam sincronizados em ambas as plataformas.

Até este momento, mantivemos apenas o seguinte código no meu arquivo "bot.py". Perceba que deletamos a linha bot.browse("http://www.botcity.dev"), pois ela não será mais necessária.

# Import for the Desktop Bot
from botcity.core import DesktopBot

# Import for integration with BotCity Maestro SDK
from botcity.maestro import *

# Disable errors if we are not connected to Maestro
BotMaestroSDK.RAISE_NOT_CONNECTED = False

def main():

    bot = DesktopBot()


def not_found(label):
    print(f"Element not found: {label}")

if __name__ == '__main__':
    main()

Ao salvar esse código na minha IDE, ao clicar novamente no BotCity Studio, você perceberá que também foi atualizado.

Abaixo da linha bot = DesktopBot(), vamos adicionar o comando execute para o robô abrir o Sicalc, conforme código abaixo:

bot.execute(r"C:\Program Files (x86)\Programas RFB\Sicalc Auto Atendimento\SicalcAA.exe")

Uma dica interessante é você testar se o que está acontecendo é o esperado. Neste momento, por exemplo, podemos salvar o código e executar o robô pela IDE para verificarmos se, de fato, o comando funcionará. Tente fazer essa prática de testar aos poucos para você entender o que está acontecendo. Isso também facilitará no entendimento caso algum erro ocorra.

Se essa etapa funcionar, o robô executará e o Sicalc ficará nessa tela:

💡 Antes de seguir em frente, lembre-se de deixar o cursor logo abaixo da linha de código que o bot abre o Sicalc no BotCity Studio. Isso é porque ele vai começar a gerar código para você utilizar em seu projeto. E o código será adicionado exatamente onde o cursor estiver posicionado.

Identificando pop-up da tela inicial

Ao executarmos o aplicativo Sicalc pela primeira vez, será exibido um pop-up contendo um aviso. A tarefa será identificarmos essa janela e fechá-la logo em seguida.

A estratégia que vamos utilizar é procurar por uma âncora e realizar um clique relativo no botão Continuar.

Voltando ao BotCity Studio, no arquivo bot.py posicionamos o cursor na linha onde o código deve ser gerado.

Na aba UI, clicamos próximo ao elemento que queremos identificar e a ferramenta dará um zoom para selecionarmos o elemento. A seleção do nosso recorte é feita com o mouse, clicando e arrastando até selecionar dessa maneira:

💡 Se o zoom não estiver adequado para você fazer a seleção necessária, basta pressionar a tecla esc no seu teclado e refazer o clique próximo ao elemento.

Após selecionado, vamos preencher os campos Name com o valor "popup-esclarecimento" e Action com o valor "Click_relative". O campo "mode" deve ser mantido com a opção "Image" selecionada. Em seguida, clicamos no botão Submit.

Após clicar em Submit, ao arrastar o mouse, você perceberá que uma linha vermelha acompanhará o movimento. Nós devemos dizer para o BotCity Studio onde deverá ser o clique relativo. Neste caso, será o botão "Continuar". Então arrastamos o cursor do mouse até esse botão e clicamos nele.

Com essa etapa concluída, o seguinte trecho de código será gerado pelo BotCity Studio:

# Abre o aplicativo do SiCalc
bot.execute(path_sicalc)

if not bot.find( "popup-esclarecimento", matching=0.97, waiting_time=10000):
    not_found("popup-esclarecimento")
bot.click_relative(195, 211)

Lembre-se de salvar o código no BotCity Studio, que pode ser pelo atalho "ctrl + s". Isso fará com que a sua IDE também seja atualizada com o novo código gerado.

Ao rodarmos novamente esse código pela IDE, depois de abrir o aplicativo Sicalc, o bot realizará o clique relativo no elemento que foi selecionado acima. A partir disso, conseguimos continuar o processo de preenchimento da DARF.

Selecionando opções do menu

No aplicativo do Sicalc, precisaremos acessar a opção Funções do menu e, em seguida, a opção Preenchimento de DARF. Então devemos tirar um novo print da tela do Sicalc e, no BotCity Studio, podemos fazer o recorte desses elementos.

Vamos começar pelo item "Funções". E para essa opção, vamos dar o nome funcoes e a action será click. A opção mode deve continuar como image.

Com o sub-menu de opções de Funções aberto, vamos tirar um novo print para fazermos a seleção e ação Click na opção Preenchimento de DARF, chamando-a de preenchimento-darf.

O código gerado pelo BotCity Studio será parecido com o código abaixo:

if not bot.find( "funcoes", matching=0.97, waiting_time=10000):
    not_found("funcoes")
bot.click()

if not bot.find( "preenchimento-darf", matching=0.97, waiting_time=10000):
    not_found("preenchimento-darf")
bot.click()

Preenchendo do formulário inicial

Após a etapa anterior, será aberto um formulário inicial onde precisaremos preencher somente o código da receita.

Novamente, vamos tirar um novo print da tela atualizada para fazermos a seleção do elemento correto no BotCity Studio.

Nesse caso, vamos encontrar a âncora do input Cód. Receita e fazer um clique relativo dentro do campo, que fica logo na frente para ser preenchido:

Após encontrar e clicar no campo referente a esse elemento, utilizamos o comando paste() para inserir nosso dado. Em seguida vamos utilizar o comando tab() para avançarmos para o próximo formulário.

Você pode adicionar o código com o comando paste() e com o comando tab() diretamente no BotCity Studio e salvar para atualizar na sua IDE, ou adicionar diretamente pela IDE. Apenas lembre-se de salvar o código para ambas as ferramentas seguirem atualizadas.

Abaixo, o exemplo de como poderá ficar esse trecho do código:

if not bot.find( "codigo-receita", matching=0.97, waiting_time=10000):
    not_found("codigo-receita")
bot.click_relative(128, 10)

# Inserindo no campo um código fictício
bot.paste("5629")

# Tecla "tab" avança para o próximo formulário
bot.tab()

Preenchendo os dados da DARF

Ao executarmos o código acima, será aberto um segundo formulário. E nele, devemos inserir os demais dados da DARF. Neste momento, a tela será parecida com essa:

Atualizando o print da tela no BotCity Studio, vamos precisar encontrar os elementos referentes ao período de apuração (campo PA) e ao valor do documento (campo Valor em Reais) e fazer um clique relativo nos seus respectivos campos:

E da mesma forma que fizemos anteriormente, vamos utilizar o comando paste() do framework para nos ajudar a digitar o valor dentro dos campos que estamos preenchendo neste momento. Perceba como o código ficará nessa etapa:

if not bot.find( "periodo-apuracao", matching=0.97, waiting_time=10000):
    not_found("periodo-apuracao")
bot.click_relative(15, 25)
# Inserindo PA
bot.paste("310120")

if not bot.find( "valor", matching=0.97, waiting_time=10000):
    not_found("valor")
bot.click_relative(17, 27)
# Inserindo valor
bot.paste("10000")

O próximo passo é clicarmos no botão Calcular, para conseguirmos acessar o formulário final. Temos duas formas de resolver essa etapa. A primeira delas seria adicionar o comando enter(), pois essa ação no teclado de apertar a tecla enter, após o preenchimento dos campos, aciona o botão Calcular.

bot.enter()

Outra forma é seguir pela visão computacional e apoio do BotCity Studio. Então tiramos um novo print, selecionamos o botão Calcular e informamos que a ação deverá ser a de click.

if not bot.find( "calcular", matching=0.97, waiting_time=10000):
    not_found("calcular")
bot.click()

Preenchendo formulário final

Após o processo de cálculo ser finalizado, precisamos acessar o formulário final. Para isso, vamos clicar no botão DARF:

if not bot.find( "botao-darf", matching=0.97, waiting_time=10000):
    not_found("botao-darf")
bot.click()

Com o formulário final aberto, vamos atualizar o print da tela no BotCity Studio para fazermos a seleção dos últimos elementos:

Para essa etapa, vamos seguir utilizando a mesma estratégia das etapas anteriores, procurando pela âncora e fazendo um clique relativo no campo que precisamos preencher.

Os dados que precisamos preencher nesse último formulário serão:

Nome: Petrobras
Telefone: 1199991234
CNPJ: 33000167000101
Referência: 0

Com todas as âncoras mapeadas, o código gerado será semelhante a esse:

if not bot.find( "nome", matching=0.97, waiting_time=10000):
    not_found("nome")
bot.click_relative(0, 24)

# Inserindo nome no campo
bot.paste("Petrobras")

if not bot.find( "telefone", matching=0.97, waiting_time=10000):
    not_found("telefone")
bot.click_relative(1, 27)

# Inserindo telefone no campo
bot.paste("1199991234")

if not bot.find( "cnpj", matching=0.97, waiting_time=10000):
    not_found("cnpj")
bot.click_relative(123, 9)

# Inserindo CNPJ no campo
bot.paste("33000167000101")

if not bot.find( "referencia", matching=0.97, waiting_time=10000):
    not_found("referencia")
bot.click_relative(121, 8)

# Inserindo referência no campo
bot.paste("0")

Salvando o arquivo

O último passo é salvarmos o arquivo da DARF que será gerado. Ainda na tela do último formulário exibido, após preencher os dados vamos clicar no botão Imprimir:

if not bot.find( "imprimir", matching=0.97, waiting_time=10000):
    not_found("imprimir")
bot.click()

Clicando no botão, será aberto a janela do gerenciador de arquivos do Windows, caso não tenha diretamente uma impressora configurada:

Neste caso, vamos encontrar a referência dessa janela e clicar para que ela fique em foco:

Após isso, podemos utilizar o paste() para informar qual será o caminho do arquivo e o enter() para salvar. Abaixo temos o exemplo de como poderá ficar o código:

if not bot.find( "janela-salvar", matching=0.97, waiting_time=10000):
    not_found("janela-salvar")
bot.click()

# Inserindo o caminho do arquivo
bot.paste(r"C:\Users\username\Documents\DARF.pdf")
bot.enter()

Finalizando o processo

Após salvar o arquivo, nosso processo está finalizado!

Podemos agora utilizar o comando wait() para aguardar 2 segundos e garantir que tudo foi salvo e depois o comando alt_f4() para fecharmos o formulário e a janela do Sicalc.

# Aguarda 2 segundos
bot.wait(2000)

# Fechando janela do formulário
bot.alt_f4()

# Fechando app do SiCalc
bot.alt_f4()

💡 Essa estratégia do comando wait() pode ser útil em algumas ocasiões, quando algum processo ou comando pode levar um tempo para acontecer ou atualizar antes de ir para a próxima etapa do processo. Então analise se no seu projeto isso pode te ajudar e utilize da maneira que for melhor para você.

Código final

Caso queira validar como o código final deste tutorial poderá ficar, segue abaixo o conteúdo do arquivo bot.py do projeto:

def main():
    bot = DesktopBot()

    # Implement here your logic...
    # Caminho onde está o executável SiCalc
    path_sicalc = r"C:\Program Files (x86)\Programas RFB\Sicalc Auto Atendimento\SicalcAA.exe"

    # Abre o aplicativo do SiCalc
    bot.execute(path_sicalc)

    if not bot.find( "popup-esclarecimento", matching=0.97, waiting_time=10000):
        not_found("popup-esclarecimento")
    bot.click_relative(195, 211)

    if not bot.find( "funcoes", matching=0.97, waiting_time=10000):
        not_found("funcoes")
    bot.click()

    if not bot.find( "preenchimento-darf", matching=0.97, waiting_time=10000):
        not_found("preenchimento-darf")
    bot.click()

    if not bot.find( "codigo-receita", matching=0.97, waiting_time=10000):
        not_found("codigo-receita")
    bot.click_relative(128, 10)

    # Inserindo no campo um código fictício
    bot.paste("5629")

    # Tecla "tab" avança para o próximo formulário
    bot.tab()

    if not bot.find( "periodo-apuracao", matching=0.97, waiting_time=10000):
        not_found("periodo-apuracao")
    bot.click_relative(15, 25)
    # Inserindo PA
    bot.paste("310120")

    if not bot.find( "valor", matching=0.97, waiting_time=10000):
        not_found("valor")
    bot.click_relative(17, 27)
    # Inserindo valor
    bot.paste("10000")

    if not bot.find( "calcular", matching=0.97, waiting_time=10000):
        not_found("calcular")
    bot.click()

    if not bot.find( "botao-darf", matching=0.97, waiting_time=10000):
        not_found("botao-darf")
    bot.click()

    if not bot.find( "nome", matching=0.97, waiting_time=10000):
        not_found("nome")
    bot.click_relative(0, 24)
    # Inserindo nome
    bot.paste("Petrobras")

    if not bot.find( "telefone", matching=0.97, waiting_time=10000):
        not_found("telefone")
    bot.click_relative(1, 27)
    # Inserindo telefone
    bot.paste("1199991234")

    if not bot.find( "cnpj", matching=0.97, waiting_time=10000):
        not_found("cnpj")
    bot.click_relative(123, 9)
    # Inserindo CNPJ
    bot.paste("33000167000101")

    if not bot.find( "referencia", matching=0.97, waiting_time=10000):
        not_found("referencia")
    bot.click_relative(121, 8)
    # Inserindo referência
    bot.paste("0")

    if not bot.find( "imprimir", matching=0.97, waiting_time=10000):
        not_found("imprimir")
    bot.click()

    if not bot.find( "janela-salvar", matching=0.97, waiting_time=10000):
        not_found("janela-salvar")
    bot.click()

    # Inserindo path do arquivo
    bot.paste(r"C:\Users\username\Documents\DARF.pdf")
    bot.enter()

    # Aguarda 2 segundos
    bot.wait(2000)

    # Fechando janela do formulário
    bot.alt_f4()

    # Fechando app do SiCalc
    bot.alt_f4()

def not_found(label):
    print(f"Element not found: {label}")

if __name__ == '__main__':
    main()

Para explorar mais comandos do framework desktop

Tem vários outros comandos que você pode explorar e utilizar para construir suas automações desktop. Acompanhe pelo link da documentação.

Compartilhe com a comunidade o seu projeto

Após construir a sua automação, que tal compartilhar com a comunidade o que aprendeu e o robô que você construiu? Basta compartilhar com o repositório de robôs da comunidade.

Hello World challenges: creating my first bot with Python RPA using BotCity

Morganna — Tue, 20 Jun 2023 20:04:48 +0000

pt-br: link

We should value our "Hello World" tries more when learning new technologies. It is from there that we begin a journey of exploration and learning. And even because it's a learning process, we can go through some mistakes, and that's ok. It's part of the process too.

Here are some tips on errors you may face in your first steps when building a bot with Python RPA. And if you have experienced an error that is not here in this article, please, feel free to contribute in the comments, especially commenting on the solution you applied to solve the problem.

First of all... Hello World

Hello World is a joke we play in the technology area, mainly in the software development part, which would be the first thing to do when learning something new to avoid bad luck while using that technology. For example, if you are learning Python, you should show the message "Hello World" on the screen using Python commands.

How to build my first Hello World with Python RPA using BotCity

You can take your first steps into this world with BotCity's Open Source frameworks. Also, explore the documentation, start coding, and the forum to clear your doubts with the community.

Common Mistakes

'`ModuleNotFoundError`' error when trying to run my project

This error also happens with the message: No module named 'botcity'.

It means you skipped the bot installation step or did that step in a different IDE than the one you are using now.

To resolve the problem, run the following command in the terminal: pip install --upgrade -r requirements.txt. We need to do this because the requirements.txt file has all external dependencies for your robot.

You must run the command above for both BotCity Framework Desktop and BotCity Framework Web. You can have more details in the documentation.

Important: if you use virtual environments to run your project, such as venv, review that you are using the same version of Python to install the dependencies mentioned and run the code. Checking these versions and ensuring they are the same will also avoid some errors.

Error '`OSError: [WinError 216]`'

In this error, the complete message can be:

OSError: [WinError 216] This version of %1 is not compatible with the version of Windows you're running. Check your computer's system information and then contact the software publisher

And the scenario is usually this: you are trying to perform the configuration part of a web driver in your code for your web bot, and, in this case, you have chosen the Firefox browser.

# Changing the default Browser to Firefox
bot.browser = Browser.FIREFOX

# Setting the path of the Firefox WebDriver
bot.driver_path = "<path to your WebDriver binary>"

To configure this web driver, we usually download it from this link, where the geckodriver releases are. And then, we identify the correct web driver for our operating system, choosing one of the items in the download assets part:

It is essential to choose carefully because confusion is common when using, for example, the Windows 64-bit operating system and trying to configure geckodriver-vX.YY.Z-win-aarch64.zip. The correct one would be geckodriver-vX.YY.Z-win64.zip.

By making this correction of using the geckodriver with the correct version, we corrected the error, and you can open the browser through your code automatically.

Driver incompatibility with browser error

It is also important to confirm the browser version you will use and validate that the web driver is compatible with that version. Using Firefox again as an example, you can check the version by looking at Menu > Help > About Firefox.

When validating the version of your browser or the browser that you will use in your automation, check the release information of the selected web driver to verify if it is compatible with the version you will use.

In the example we use, we observe that the Firefox version that I will use in the automation is 114.0.2, and the release contains information that the minimum required version is 113.0:

In this case, I can use that geckodriver version in my automation since it is compatible with my browser.

About the mistakes when we started

It is essential to understand that some mistakes can happen. And this is necessary for your learning. Understanding the error, reading the message calmly, researching, clarifying doubts with the community, and solving this problem will bring you knowledge.

So relax, enjoy this trip, and explore the RPA universe with a lot of Python and Open Source.

How about doing your own Hello World and telling us what challenges it brought to you? Let's share our experiences and knowledge with the community.

And if you want some inspiration on what to build to continue learning, look at our bot repository, where community members share their Open Source projects to exchange knowledge and experiences.

Os desafios do Hello World: criando meu primeiro bot com Python RPA utilizando BotCity

Morganna — Tue, 20 Jun 2023 18:03:59 +0000

en-us: link

Particularmente, eu acredito que deveríamos dar mais valor ao Hello World de qualquer tecnologia nova que estivermos aprendendo. É a partir dele que damos início a uma jornada de exploração e aprendizado. E até mesmo por ser um processo de aprendizado, podemos passar por alguns erros e está tudo bem, faz parte do processo também.

Quero deixar aqui algumas dicas sobre alguns erros que você pode enfrentar nos seus primeiros passos durante a construção de um bot com Python RPA. E caso você tenha passado por algum erro que não está aqui neste artigo, fique à vontade para contribuir nos comentários, principalmente comentando a solução que você aplicou para resolver o problema, combinado?

Antes de tudo... o Hello World

Hello World é uma brincadeira que fazemos na área de tecnologia, e talvez principalmente na parte de desenvolvimento, que seria a primeira coisa a se fazer ao aprender algo novo, para evitar o azar durante o uso dessa tal tecnologia. Por exemplo, se você estiver aprendendo Python, o "Hello World" seria mostrar essa mensagem mesmo na tela, utilizando comandos do Python. Você pode até dar uma olhada nesse meu outro artigo: Deixando seu 'Olá, mundo' com o Python.

Como fazer meu primeiro Hello World com Python RPA utilizando BotCity

Você pode dar seus primeiros passos nesse mundo com os frameworks Open Source da BotCity. Inclusive fique à vontade para explorar a documentação e começar a codar, além do fórum para tirar suas dúvidas com a comunidade.

Erros comuns

Erro '`ModuleNotFoundError`' ao tentar executar meu projeto

Esse erro costuma acontecer também com a mensagem: No module named 'botcity'.

Isso significa que você acabou pulando a etapa de instalação do bot ou então você fez essa etapa, mas possivelmente em ambiente diferente da que está utilizando agora.

Para solucionar, execute o seguinte comando no terminal: pip install --upgrade -r requirements.txt. Isso é necessário porque nesse arquivo estão todas dependências externas para seu robô.

Essa etapa deve ser feita tanto para o BotCity Framework Desktop quanto para o BotCity Framework Web. Você pode ter mais detalhes na documentação.

Importante: se você utiliza ambientes virtuais para executar o seu projeto, como o venv, por exemplo, verifique que está utilizando a mesma versão do Python tanto para instalar as dependências que citamos, quanto para rodar o código. Isso também evitará alguns erros.

Erro `No such file or directory: 'requirements.txt'`

Esse erro pode acontecer caso você esteja tentando corrigir o anterior. É possível que você tenha executado o comando pip install --upgrade -r requirements.txt dentro da pasta errada do projeto. Verifique em seu terminal a pasta em que você está.

Erro '`OSError: [WinError 216]`'

Neste erro, a mensagem completa pode ser:

OSError: [WinError 216] This version of %1 is not compatible with the version of Windows you're running. Check your computer's system information and then contact the software publisher

E o cenário, normalmente é o seguinte: você está tentando realizar a parte de configuração de um webdriver em seu código para o seu bot web e, no caso, escolheu o browser Firefox.

# Setando navegador padrão para o Firefox
bot.browser = Browser.FIREFOX

# Setando o caminho do Geckodriver
bot.driver_path = "<caminho para o WebDriver>"

Para fazer a configuração desse webdriver, costumamos fazer o download por este link, onde estão as releases do geckodriver. E então, identificamos o webdriver correto para o nosso sistema operacional, escolhendo um dos itens na parte de assets para download:

É importante escolher com atenção, porque é comum haver confusão quando usamos, por exemplo, o sistema operacional Windows 64 bits e acabamos tentando configurar o geckodriver-vX.YY.Z-win-aarch64.zip. O correto seria o geckodriver-vX.YY.Z-win64.zip.

Ao fazer essa correção de utilizar o geckodriver com a versão correta, corrigimos o erro e você consegue abrir o navegador através do seu código, automaticamente.

Erro de incompatibilidade do driver com o navegador

É importante também confirmar a versão do navegador que você vai utilizar e validar que o webdriver é compatível com essa versão. Utilizando novamente o Firefox como exemplo, você pode entender observando a versão ao clicar no Menu > Ajuda > Sobre o Firefox.

Ao validar a versão do seu navegador ou do navegador que será utilizado na sua automação, verifique nas informações de release do webdriver selecionado se ele é compatível com essa versão que você vai utilizar.

No exemplo que utilizamos, observamos que a versão do Firefox que eu vou utilizar na automação é 114.0.2 e na release consta a informação que a versão mínima requerida é a 113.0:

Ou seja, nesse caso, eu conseguiria utilizar normalmente esse mesmo geckodriver na minha automação, visto que é compatível.

Erros quando os sistemas barram a utilização por identificar um robô

Em casos assim, pode ser possível tentar humanizar o processo. O que isso significa? Você pode tentar fazer movimentações com o mouse na tela, como uma pessoa poderia fazer. Ou ainda ajustar a digitação para que não seja um conteúdo diretamente colado no campo a ser preenchido.

Esse tipo de problema costuma acontecer mais em projetos de automações Web. Mas para "humanizar" a execução, você pode recorrer a alguns recursos do framework desktop da BotCity, essa pode ser uma boa alternativa. Abaixo, seguem os exemplos dos comandos que você pode utilizar:

Sobre a digitação, você pode usar o seguinte comando do framework BotCity (veja mais exemplos em nossa documentação):

bot.kb_type("Coloque seu texto aqui.")

Sobre a movimentação do cursor do mouse, você pode usar os seguintes comandos do framework BotCity (veja mais exemplos em nossa documentação):

bot.mouse_move(x=100, y=200) # x e y são coordenadas

Erros quando a execução do robô é muito mais rápida que os sistemas que está acessando

Como estamos criando automações para serem executadas com código, esse tempo de execução pode ser muito mais rápido que o esperado ou que os sistemas que estamos interagindo conseguem lidar.

E por causa disso, erros de execução podem acontecer, porque determinada etapa na tela ainda não finalizou para que o próximo passo aconteça dentro do processo.

Em ocasiões assim, talvez faça sentido avaliar a possibilidade de colocar pausas entre algumas dessas etapas.

Uma forma de fazer isso com o nosso framework da BotCity seria (veja outros exemplos na documentação):

# Aguardar por cinco segundos.
bot.wait(5000)

Além disso, você também pode criar lógicas ou regras em seu código para garantir que o robô está na tela certa antes de executar determinado comando. Uma das formas de fazer isso, seria utilizar a visão computacional e buscar por alguma âncora na tela que deveria estar aberta e em uso.

Erro na precisão de encontrar elementos na tela

Esse problema pode acontecer por alguns motivos:

Você desenvolveu o robô em um ambiente diferente do que será executado em produção;
A resolução da tela alterou.

Para amenizar ou evitar que esse problema continue acontecendo:

Tente possibilitar que você faça o desenvolvimento da automação em ambiente e resolução o mais próximo possível de como será executado em produção;
Outra saída é fazer um ajuste em relação a acurácia do algoritmo de visão computacional no código gerado.

Veja no exemplo do código a seguir gerado pela visão computacional:

    if not bot.find("window", matching=0.97, waiting_time=10000):
        not_found("window")
    bot.click_relative(221, 206)

O parâmetro matching costuma estar com o valor máximo 0.97. Esse valor poderia ser ajustado a, no mínimo, 0.90. Isso pode ajudar nas questões levantadas neste tópico. Mas cuidado para não diminuir muito mais que isso, a ponto do algoritmo perder a sua eficiência para encontrar o elemento que precisa ser identificado.

Erro `unable to find valid certification path to requested target` ao tentar executar o BotCity Studio

Este erro pode acontecer em seu ambiente caso existam bloqueios configurados de certificados. Uma das saídas é fazer o seguinte passo-a-passo:

Abra a pasta do SDK. No wizard isso pode ser feito clicando em "Open SDK folder";
Acesse a pasta conf e abra o arquivo conf.bcf em modo de edição (você pode fazer isso, abrindo com o bloco de notas, por exemplo);
Adicione a linha ignoreSSL=true e não esqueça de salvar essa alteração no arquivo conf.bcf;
Reinicie o BotCity Studio e o problema deve estar resolvido.

Sobre os erros quando começamos

É importante entender que alguns erros podem, de fato, acontecer. E isso não é um impedimento para o seu aprendizado, pelo contrário. Entender o erro, ler a mensagem com calma, pesquisar, tirar dúvidas com a comunidade e resolver esse problema é o que vai te trazer ainda mais conhecimento.

Então relaxe, aproveite essa viagem e desbrave o universo RPA com muito Python e Open Source.

Que tal você fazer o seu Hello World e nos contar quais foram os desafios que isso lhe trouxe? Vamos compartilhar nossas experiências e conhecimento com a comunidade.

E se quiser uma inspiração sobre o que construir para continuar seus aprendizados, dá uma olhada em nosso repositório de bots, onde a galera da comunidade compartilha seus projetos Open Source para troca de conhecimento e experiências.

How to use GitHub Actions to keep your Python RPA project updated

Morganna — Tue, 13 Jun 2023 18:56:48 +0000

pt-br: link

You’ve heard about GitHub Actions, right? If you haven’t, take advantage and explore the documentation about it at this link.

And to take advantage of the practicality of performing different actions in projects from this functionality, we created a GitHub Actions function to automate the bot’s update, called BotCity Actions, and you can find it available in this repository.

Why use BotCity Actions?

Whenever we can automate a process to make our day-to-day life easier, it makes sense to learn how to do it and understand if it makes sense in our context and need. So, suppose you have a continuous development process for your bots. Why not make your day-to-day life more manageable and automate beyond the business and product processes? Like the deployment and update of your releases as well.

How does BotCity Actions work?

Our function performs updates, deploys, and releases automatically to our orchestrator, BotCity Maestro, without manual implementations. Also, if you need to become familiar with the BotCity Maestro API for better use, please consult our documentation at this link.

Applying BotCity Actions in your project

Follow the step-by-step below. In the example, we are considering projects built with the Python language. However, feel free to use other languages. Our documentation contains examples for configuring projects in Java, JavaScript, and TypeScript.

[0] Configure your project

As a first step, you need to add a folder structure to your project. Create a folder with the exact name .github at the root of your project. Inside that folder, create another one with the specific name workflows.

This specification comes directly from GitHub, and this is how it will interpret where the functions are. For further clarification, remember to consult the documentation.

[1] Creating the first workflow

At this point, we’re assuming you already have bots developed. But if you want help, look at this link in our documentation. We have a very interesting tutorial on how to create a bot with our Open Source frameworks.

Still, we point out that you can use bots built with other technologies in our orchestrator, for example, Java, JavaScript, Selenium, and bash scripts, among many others.

One of the events that we can consider in our action would be the push on the main branch. It means that whenever there is a change in the main branch, you want a new deployment to BotCity Maestro to update the bot. It works like this if you are considering Git Flow rules and best practices, where the main branch is the production branch.

In this step, we will create the update_bot.yml file inside the workflows folder. And you should add the code below to take into account the changes explained above in the push event on the main branch:

name: Update the latest version bot on BotCity Maestro.

on:
    push:
      branches:
        - main

[2] Generating the bot by the BotCity Actions function

To know what you need to add to the function, it is also necessary to understand what is required to deploy your bot.

For example, considering that you developed your automation with our Open Source framework, we need to complete the following prerequisite: generate a zipped file with the bot’s code and dependencies, which we can create by executing the script: ./build.sh or ./build.bat, depending on the operating system. This script is at the project’s root, constructed from our desktop or web framework template.

So, we need to add the following actions to our function:

Run in an environment (which, in this case, we chose Ubuntu due to its ease and speed, however, you can analyze your specific circumstance and understand if there are essential dependencies to consider and, if necessary, run in a Windows or MacOS environment, for example);
Permit the execution of the build.sh file;
Run the ./build.sh command. With these new actions, our update_bot.yml file will look like this:

name: Update the latest version bot on BotCity Maestro.

on:
    push:
      branches:
        - main
jobs:
  update-latest:
    name: Update the latest version bot on BotCity Maestro.
    #  Running the latest version of Ubuntu.
    runs-on: ubuntu-latest
    steps:
      # Checking out the project.
      - uses: actions/checkout@v3
      # Implemented executable permission to `.sh`
      - name: Get permission to build.
        run: chmod +x build.sh
      # Execute to build.
      - name: Execute to build.
        run: ./build.sh

[3] Using the function

The sequence of steps we’ve added to the update_bot.yml file so far has been to define an environment to build in and create the zipped file we’ll upload in Maestro. However, now we need to configure the steps for the function to be used.

In this case, we add some important data for successful deployment. They are botId, technology (where you must inform the language used in your bot and, in our example, we consider Python), and botPath (location at the project’s root where the zipped file will be uploaded to our orchestrator’s platform).

name: Update the latest version bot on BotCity Maestro.

on:
  push:
    branches:
      - main
jobs:
  update-latest:
    name: Update the latest version bot on BotCity Maestro.
    #  Running the latest version of Ubuntu.
    runs-on: ubuntu-latest
    steps:
      # Checking out the project.
      - uses: actions/checkout@v3
      # Implemented executable permission to `.sh`
      - name: Get permission to build.
        run: chmod +x build.sh
      # Execute to build.
      - name: Execute to build.
        run: ./build.sh
      - name: Using a Botcity action.
        # Using the v1.0.0 version of botcity-action-bots
        uses: botcity-dev/botcity-action-bots@v1.0.0
        with:
          # Use the update function.
          update: true
          # Bot Id in Maestro.
          botId: 'example'
          # Technology utilized in bot
          technology: 'python'
          # Path from the root of the project where the generated .zip/.jar will be.
          botPath: './bot.zip'
        env:
          # These secrets must be configured in your repository.
          LOGIN: ${{ secrets.LOGIN }}
          SERVER: ${{ secrets.SERVER }}
          KEY: ${{ secrets.KEY }}

Notice that we added some environment variables like LOGIN, SERVER, and KEY. These are essential secrets for you to be able to use BotCity Maestro. So remember to set these keys securely in your repository.

Where can I find more tips?

You can access the guide we created in our documentation with many more tips and guidance on using BotCity Actions, including creating releases and much more.

Also, remember to join our community to share your Open Source projects and get your questions answered with others. It will be exciting to learn from your experience.

DEV Community: BotCity

Trilha de estudos para ser uma pessoa desenvolvedora Python RPA

🤖 Comece pela linguagem de programação Python

🤖 Desenvolva sua primeira automação Python

🤖 Segurança com Python RPA

🤖 Aprenda como fazer orquestração da sua automação Python

🤖 Desenvolva uma automação com um importante sistema do mercado

🤖 Pratique bastante e compartilhe sua evolução e seus aprendizados com a comunidade

O papel da pessoa desenvolvedora muito além do código

Dicas sobre desenvolvimento de automação com visão computacional

O que é visão computacional

Como usar a visão computacional para desenvolver automações

Dicas sobre como resolver problemas ao desenvolver com visão computacional

Elemento não encontrado

Resolução da tela

Sugestões para avaliar problemas

Já fez alguma automação com visão computacional?

Como identificar problemas de ambiente ao tentar instalar BotCity Studio SDK

Como executar o diagnóstico

Status dos resultados do diagnóstico

Como exportar o resultado dos testes

Ficou alguma dúvida?

Como identificar se a automação está executando localmente ou no BotCity Orquestrador?

A dúvida surgiu

Exemplo prático

Conexão com BotCity Orquestrador

Qual a diferença entre o ambiente local e o orquestrador

Como validar em qual ambiente está sendo executado

Execução local

Execução no Orquestrador

Código completo

O que achou?

Sites para praticar RPA

Practice Test Automation

Como fica em código?

Conclusão

Why is it important to orchestrate your automation built in Python or other programming languages?

Is it possible to orchestrate automation built by code?

Why is it important to orchestrate RPA automation?

Who is the automation orchestration process important for?

How to orchestrate using BotCity Maestro Orchestrator?

Por que é importante orquestrar suas automações feitas em Python ou outras linguagens de programação?

É possível fazer orquestração de automações feitas em código?

Por que é importante orquestrar as automações RPA?

Para quem é importante o processo de orquestração de automações?

Como orquestrar utilizando o BotCity Maestro Orchestrator?

Construindo um bot com Python RPA para interagir com sistemas desktop

Preparando o ambiente de desenvolvimento

Primeiros passos do desenvolvimento do nosso robô

Criando o projeto a partir do template da BotCity

Instalando as dependências do seu projeto

Primeira execução do nosso robô

Entenda o que o código está fazendo

Execute o robô

Como lidar com os erros

Desenvolvendo o robô desktop

Carregando o projeto BotSicalc no BotCity Studio

Prosseguindo no desenvolvimento

Identificando pop-up da tela inicial

Selecionando opções do menu

Preenchendo do formulário inicial

Preenchendo os dados da DARF

Preenchendo formulário final

Salvando o arquivo

Finalizando o processo

Código final

Para explorar mais comandos do framework desktop

Compartilhe com a comunidade o seu projeto

Hello World challenges: creating my first bot with Python RPA using BotCity

First of all... Hello World

How to build my first Hello World with Python RPA using BotCity

Common Mistakes

'ModuleNotFoundError' error when trying to run my project

Error 'OSError: [WinError 216]'

Driver incompatibility with browser error

About the mistakes when we started

Os desafios do Hello World: criando meu primeiro bot com Python RPA utilizando BotCity

Antes de tudo... o Hello World

Como fazer meu primeiro Hello World com Python RPA utilizando BotCity

Erros comuns

'`ModuleNotFoundError`' error when trying to run my project

Error '`OSError: [WinError 216]`'

Erro '`ModuleNotFoundError`' ao tentar executar meu projeto

Erro `No such file or directory: 'requirements.txt'`

Erro '`OSError: [WinError 216]`'

Erro `unable to find valid certification path to requested target` ao tentar executar o BotCity Studio