O objetivo deste documento é apresentar uma arquitetura de referência para a criação de aplicações RPA usando a linguagem de programação Python. A arquitetura proposta baseia-se na divisão de responsabilidades em diferentes componentes, cada um com uma função específica dentro do fluxo de trabalho da automação.
Python é uma linguagem de programação popular e amplamente utilizada em diversas áreas, incluindo ciência de dados e automação. Ela tem uma sintaxe simples e fácil de aprender, o que torna mais fácil para os desenvolvedores iniciantes aprenderem e começarem a criar automações em Python.
Python possui uma grande variedade de bibliotecas, incluindo bibliotecas específicas para automação de tarefas repetitivas, como a biblioteca Selenium. Com essas bibliotecas, é possível automatizar uma ampla variedade de tarefas, desde a interação com interfaces de usuário até a manipulação de arquivos e dados.
Python é uma linguagem multiplataforma, o que significa que pode ser executada em diferentes sistemas operacionais, incluindo Windows, macOS e Linux. Isso torna mais fácil criar automações que possam ser executadas em diferentes ambientes, sem precisar se preocupar com a compatibilidade do sistema operacional.
Python é uma linguagem flexível e modular, o que significa que é possível criar automações personalizadas e adaptáveis às necessidades específicas do negócio. É possível combinar diferentes bibliotecas e componentes para criar soluções de automação escaláveis e modulares.
Python tem uma comunidade ativa de desenvolvedores, o que significa que há muitos recursos, tutoriais e fóruns disponíveis para ajudar os desenvolvedores a criar soluções de automação em Python. Isso torna mais fácil para os desenvolvedores obter ajuda e suporte, além de aprender com os outros membros da comunidade.
Esta é uma arquitetura de referência para criar soluções de RPA (Robotic Process Automation) usando a linguagem de programação Python. A arquitetura é composta por vários componentes que trabalham juntos para automatizar processos repetitivos.
Crie um ambiente virtual para isolamento das dependências do projeto. Isso pode ser feito com o comando python -m venv <nome_do_ambiente>. Instalar as dependências dentro desse ambiente.
A arquitetura de referência para aplicações Python RPA é composta pelos seguintes componentes:
Este componente é responsável por receber a entrada do usuário, por meio de uma interface de usuário (UI), e encaminhá-la para os componentes de automação. A interface de usuário pode ser implementada em várias tecnologias, como uma aplicação desktop, uma página web, ou uma planilha eletrônica. O objetivo é criar uma interface intuitiva para que o usuário possa iniciar e gerenciar as automações.
OBS: O componente de interação com o usuário não é obrigatório. Se a automação for executada em um ambiente controlado, sem a necessidade de interação com o usuário, este componente pode ser omitido.
O componente de automação é o coração da aplicação RPA. Ele é responsável por executar as ações automatizadas, como clicar em botões, preencher formulários, acessar sistemas externos, entre outras. O componente de automação é composto por uma ou mais bibliotecas Python que contêm as funcionalidades específicas de automação.
Este componente é responsável por gerenciar o fluxo de trabalho da automação, decidindo quais ações devem ser executadas em cada etapa do processo. O componente de gerenciamento de fluxo de trabalho também é responsável por tratar exceções e erros, a fim de garantir que a automação seja executada com sucesso.
Este componente é responsável por armazenar os dados da automação, como resultados de ações automatizadas, logs de atividades, e outros. O componente de armazenamento de dados pode ser implementado usando uma variedade de tecnologias, como um banco de dados relacional, um banco de dados NoSQL, ou um serviço de armazenamento em nuvem.
Este componente é responsável por gerenciar as configurações da aplicação, como credenciais de acesso, URLs de sistemas externos, e outras. O componente de configuração pode ser implementado como um arquivo de configuração ou um serviço de configuração em nuvem.
my-rpa-project/
│
├── app/
│ ├── __init__.py
│ ├── files/
│ │ ├── __init__.py
│ │ ├── logs/ (Diretório de logs de atividade e de erros)
│ │ ├── export/ (Diretório de arquivos gerado pela automação. Ex. .xlsx, pdf. doc. csv...)
│ │ └── ...
│ ├── automation/
│ │ ├── __init__.py
│ │ ├── click.py
│ │ ├── fill_form.py
│ │ ├── access_external_system.py
│ │ └── ...
│ ├── workflow/
│ │ ├── __init__.py
│ │ ├── step_1.py
│ │ ├── step_2.py
│ │ ├── step_3.py
│ │ └── ...
│ ├── ui/
│ │ ├── __init__.py
│ │ ├── main_window.py
│ │ ├── login_dialog.py
│ │ ├── settings_dialog.py
│ │ └── ...
│ ├── storage/
│ │ ├── __init__.py
│ │ ├── results.py
│ │ ├── logs.py
│ │ └── ...
│ ├── venv (Diretório do ambiente virtual)
│ ├── configuration/
│ │ ├── __init__.py
│ │ ├── config.json (Arquivo com parâmetros de configuração da automação)
│ │ ├── console_api.py (Arquivo com endpoint de integração do monitoramento)
│ │ └── ...
│ └── main.py (Arquivo principal da automação)
│
├── tests/
│ ├── __init__.py
│ ├── test_automation.py
│ ├── test_workflow.py
│ ├── test_user_interface.py
│ ├── test_storage.py
│ ├── test_configuration.py
│ └── ...
│
├── README.md
└── requirements.txt
Na estrutura de pastas acima, as pastas estão organizadas da seguinte forma:
A pasta app contém o código-fonte da aplicação, organizado em subpastas de acordo com os componentes da arquitetura. O arquivo main.py é o ponto de entrada da aplicação.
A pasta tests contém os testes automatizados da aplicação, organizados em subpastas de acordo com os componentes da arquitetura.
O arquivo requirements.txt contém as dependências do projeto, que podem ser instaladas usando o comando pip install -r requirements.txt.
Cada subpasta de componente contém um arquivo init.py para indicar que é um pacote Python. Os arquivos de cada componente são organizados de acordo com as suas responsabilidades, seguindo a arquitetura de referência. Por exemplo, a subpasta automation contém os arquivos que implementam as ações de automação, como clicar em botões e preencher formulários. A subpasta workflow contém os arquivos que implementam o fluxo de trabalho da automação, decidindo quais ações devem ser executadas em cada etapa do processo. E assim por diante.
O Python Enhancement Proposals (PEPs) são documentos que descrevem melhorias propostas para a linguagem Python. Seguir as PEPs ajuda a manter a consistência e a legibilidade do código em todo o projeto. As PEPs mais relevantes para um projeto RPA incluem a PEP 8, que descreve as convenções de codificação em Python, e a PEP 257, que descreve as convenções de documentação em Python.
Escolha nomes descritivos para variáveis e funções, que indiquem o que elas fazem. Isso torna mais fácil entender o código quando você volta a ele depois de um tempo e facilita a manutenção.
# Variáveis
first_name = "João"
last_name = "Silva"
age = 30
is_active = True
# Funções
def click_button(button_id):
"""
Clica em um botão com o ID especificado.
"""
# implementação aqui
def fill_form(form_data):
"""
Preenche um formulário com os dados especificados.
"""
# implementação aqui
def access_external_system(url, username, password):
"""
Acessa um sistema externo com as credenciais fornecidas.
"""
# implementação aqui
Neste exemplo, as variáveis são nomeadas de forma descritiva, para indicar o que elas representam. Por exemplo, first_name e last_name são usados para armazenar os nomes de uma pessoa, enquanto age é usado para armazenar a idade. Além disso, a variável booleana is_active é usada para indicar se uma conta está ativa ou não.
As funções também são nomeadas de forma descritiva, para indicar o que elas fazem. Por exemplo, a função click_button é usada para clicar em um botão, a função fill_form é usada para preencher um formulário, e a função access_external_system é usada para acessar um sistema externo.
Seguir essas convenções ajuda a tornar o código mais legível e fácil de entender, o que é especialmente importante em projetos RPA, onde a automação deve ser clara e fácil de acompanhar.
As docstrings são strings de documentação que aparecem no início de uma função, classe ou módulo. Elas descrevem a finalidade e o comportamento da função, e fornecem exemplos de uso. O uso de docstrings ajuda a tornar o código mais legível e ajuda outros desenvolvedores a entender o que cada função faz.
def click_button(button_id):
"""
Clica em um botão com o ID especificado.
Parâmetros:
button_id (str): O ID do botão a ser clicado.
Retorna:
bool: True se o botão foi clicado com sucesso, False caso contrário.
"""
# implementação aqui
Neste exemplo, a docstring descreve o objetivo da função click_button e como ela deve ser usada. A docstring começa com uma breve descrição do que a função faz, seguida por uma seção "Parâmetros", que descreve os argumentos da função e o tipo de cada um. A seção "Retorna" descreve o valor de retorno da função e o tipo do valor. Todas as seções da docstring são separadas por uma linha em branco para melhor legibilidade.
O uso de docstrings ajuda a tornar o código mais legível e fácil de entender, especialmente em projetos RPA, onde a automação precisa ser clara e bem documentada. A docstring permite que outros desenvolvedores entendam rapidamente o propósito de uma função e como usá-la, sem precisar olhar o código-fonte ou pedir ajuda.
Use espaços entre operadores e parênteses para tornar o código mais legível. Por exemplo, em vez de escrever "x=y+2", escreva "x = y + 2".
Organize o código em módulos e pacotes, com um módulo para cada componente da aplicação. Isso torna mais fácil encontrar o código relevante e ajuda a evitar arquivos grandes e difíceis de entender.
Escreva testes automatizados para cada componente da aplicação, para garantir que o código esteja funcionando corretamente e para ajudar a detectar bugs e erros. Mantenha os testes atualizados à medida que o código é alterado ou evoluído.
first_name = "João"
last_name = "Silva"
is_active = True
def click_button(button_id):
"""
Clica em um botão com o ID especificado.
Parâmetros:
button_id (str): O ID do botão a ser clicado.
Retorna:
bool: True se o botão foi clicado com sucesso, False caso contrário.
"""
# implementação aqui
def fill_form(form_data):
"""
Preenche um formulário com os dados especificados.
Parâmetros:
form_data (dict): Um dicionário com os dados a serem preenchidos no formulário.
Retorna:
bool: True se o formulário foi preenchido com sucesso, False caso contrário.
"""
# implementação aqui
def access_external_system(url, username, password):
"""
Acessa um sistema externo com as credenciais fornecidas.
Parâmetros:
url (str): O URL do sistema externo.
username (str): O nome de usuário para acessar o sistema externo.
password (str): A senha para acessar o sistema externo.
Retorna:
bool: True se o sistema externo foi acessado com sucesso, False caso contrário.
"""
# implementação aqui
Seguindo essas convenções, o código Python RPA é mais legível e fácil de entender, o que é especialmente importante em projetos RPA, onde a automação deve ser clara e fácil de acompanhar.
Deverão ser escolhidas apenas versões estáveis de bibliotecas ou módulos de terceiros. Pode ser deliberada, mediante consentimento da equipe de Arquitetura da Zello, a utilização de versões instáveis desde que exista registro (tag) de alguma versão. Na inexistência de versões para bibliotecas de terceiros instáveis, e acordado sua utilização com a equipe de Arquitetura da Zello, deverá ser feito um esforço de criar um fork e um versionamento para a biblioteca de terceiro ou deverá ser realizado um contato com os desenvolvedores da biblioteca no intuito de requisitar a geração de uma versão.
Em caso de bibliotecas privadas, que devem ser incluídas em um repositório sob responsabilidade do órgão ou empresa contratante.
Na raiz do projeto deverá existir um arquivo requirements.txt que contém todas as dependências externas do projeto. A figura abaixo mostra um exemplo do arquivo.
async-generator==1.10
attrs==22.1.0
certifi==2022.9.24
cffi==1.15.1
charset-normalizer==2.1.1
chromedriver-autoinstaller==0.4.0
DateTime==4.7
exceptiongroup==1.0.4
h11==0.14.0
idna==3.4
outcome==1.2.0
pycparser==2.21
PySocks==1.7.1
pytz==2022.6
requests==2.28.1
schedule==1.1.0
selenium==4.6.0
sniffio==1.3.0
sortedcontainers==2.4.0
trio==0.22.0
trio-websocket==0.9.2
urllib3==1.26.12
wsproto==1.2.0
zope.interface==5.5.2
Para manipulação de imagens.
É uma biblioteca Python que usa o Python Script para escrever gráficos e plotagens bidimensionais.
É um pacote popular de processamento de array do Python. Ele fornece um bom suporte para diferentes objetos de matriz multidimensional. O Numpy não se limita apenas a fornecer matrizes, mas também fornece uma variedade de ferramentas para gerenciar essas matrizes. É rápido, eficiente e muito bom para gerenciar arrays e matrizes.
Conhecido como Open Source Computer Vision, é um pacote para processamento de imagens. Ele monitora funções gerais focadas na visão instantânea do computador. Computer Vision permite reconstruir, interromper e compreender um ambiente 3D a partir do respectivo ambiente 2D. Este pacote permite diagnosticar objetos especiais em qualquer vídeo ou imagem. Objetos como rostos, olhos, árvores, etc.
É uma rica biblioteca HTTP sob a licença Apache 2.0, o Requests está focado em tornar as solicitações HTTP mais responsivas e fáceis de usar. Você pode facilmente personalizar, inspecionar, autorizar e configurar solicitações HTTP usando esta biblioteca.
É uma biblioteca para Machine Learning de código aberto e gratuita. É muito fácil de aprender e possui uma coleção de ferramentas úteis. No entanto, não se limita apenas ao aprendizado de máquina; você também pode usá-lo para fluxo de dados e programas diferenciáveis.
É outra biblioteca Python que oferece pesquisa e substituição fáceis de palavras dos documentos. Todas as necessidades do FlashText são um conjunto de palavras e sequências. Em seguida, identifica algumas palavras como palavras-chave e as substitui dos Dados de texto. É uma biblioteca muito eficaz.
É uma Biblioteca de Abstração de Banco de Dados (ORM) para Python. O SQLAlchemy vem com suporte impressionante para uma ampla variedade de bancos de dados e layouts possível.
É uma ótima biblioteca de python. É usado para análise. Ele também pode analisar diferentes documentos HTML e XML quebrados. Ele oferece uma maneira fácil de fazer scraping na Web, extraindo dados diretos do HTML.
É um pacote de software Python. É necessário aprender sobre ciência de dados e escrito exclusivamente para a linguagem Python. É uma plataforma rápida, demonstrativa e ajustável que oferece estruturas de dados intuitivas. Você pode manipular facilmente qualquer tipo de dado, como dados estruturados ou de séries temporais com este pacote incrível.
É um webdriver, ou seja, uma ferramenta que permite simular um usuário real utilizando um navegador. Desde a sua criação, ele é usado como uma ferramenta de testes automatizados. Ou seja, pode-se acionar uma ferramenta para rodar, capaz de simular a entrada de um usuário no site e verificar o seu funcionamento corretamente. No entanto, hoje, ele se tornou uma ferramenta geral de manipulação de sites e também é utilizado para web scraping.
Os pacotes e bibliotecas Python desempenham um papel vital na carreira de um desenvolvedor. Seja para ciência de dados, aprendizado de máquina ou qualquer outro aspecto do mundo da programação, esses pacotes e bibliotecas estão aqui para ajudar você. No entanto, além da nossa lista combinada de pacotes e bibliotecas Python, também existem muitas outras bibliotecas e pacotes. Você pode encontrar muitos deles no PyPI.