Incrível Visualização de Dados com Power BI Python – techsyncer

A sua administração quer saber tudo sobre as finanças e produtividade da sua empresa, mas não quer gastar dinheiro em ferramentas avançadas de gestão de TI? Não acabe por recorrer a diferentes ferramentas para inventário, faturação e sistemas de bilheteira. Só precisa de um sistema central. Porque não considerar o Power BI Python?

O Power BI pode transformar tarefas aborrecidas e demoradas num processo automatizado. E neste tutorial, irá aprender a fatiar e combinar os seus dados de formas que nem imagina.

Força, e poupe-se ao stress de analisar relatórios complexos!

Pré-requisitos

Neste tutorial, haverá uma demonstração prática. Se quiser seguir, certifique-se de que tem o seguinte:

Subscrição do Power BI – O período experimental gratuito é suficiente.

A Windows Server – This tutorial uses a Windows Server 2022.

Power BI Desktop instalado no seu servidor Windows – Este tutorial utiliza a versão 2.105.664.0 do Power BI Desktop.

Servidor MySQL instalado – Este tutorial utiliza a versão 8.0.29 do MySQL Server.

Uma gateway de dados local instalada em dispositivos externos que planeiam utilizar uma versão Desktop.

Visual Studio Code (VS Code) – Este tutorial utiliza o VS Code v17.2

Python v3.6 ou posterior instalado – Este tutorial utiliza o Python v3.10.5.

DBeaver instalado – Este tutorial utiliza o DBeaver v22.0.2.

Construindo um Banco de Dados MySQL

O Power BI pode visualizar dados de maneira incrível, mas você precisa buscar e armazenar os dados antes de chegar à visualização. Uma das melhores maneiras de armazenar dados é em um banco de dados. O MySQL é uma ferramenta de banco de dados gratuita e poderosa.

1. Abra o prompt de comando como administrador, execute o comando mysql abaixo e insira o nome de usuário root (-u) e a senha (-p) quando solicitado.

Por padrão, apenas o usuário root tem permissão para fazer alterações no banco de dados.

mysql -u root -p

2. Em seguida, execute a consulta abaixo para criar um novo usuário de banco de dados (CREATE USER) com uma senha (IDENTIFIED BY). Você pode dar um nome diferente ao usuário, mas a escolha deste tutorial é ata_levi.

CREATE USER 'ata_levi'@'localhost' IDENTIFIED BY 'Password';

3. Após criar um usuário, execute a consulta abaixo para CONCEDER permissões ao novo usuário (ALL PRIVILEGES), como criar um banco de dados no servidor.

GRANT ALL PRIVILEGES ON . TO 'ata_levi'@'localhost' WITH GRANT OPTION;

Granting privileges to the newly-created user

4. Agora, execute o comando \q abaixo para sair do MySQL.

5. Execute o comando mysql abaixo para fazer login como o usuário de banco de dados recém-criado (ata_levi).

mysql -u ata_levi -p

6. Por último, execute a seguinte consulta para CRIAR um novo BANCO DE DADOS chamado ata_database. Claro, você pode dar um nome diferente ao banco de dados.

CREATE DATABASE ata_database;

Gerenciando Bancos de Dados MySQL com o DBeaver

Ao gerenciar bancos de dados, geralmente é necessário ter conhecimento em SQL. Mas com o DBeaver, você tem uma interface gráfica para gerenciar seus bancos de dados em alguns cliques, e o DBeaver cuidará das instruções SQL para você.

1. Abra o DBeaver a partir da sua área de trabalho ou do menu Iniciar.

2. Quando o DBeaver abrir, clique na lista suspensa Nova Conexão de Banco de Dados e selecione MySQL para iniciar a conexão com seu servidor MySQL.

3. Faça login no seu servidor MySQL local com o seguinte:

Mantenha o Host do Servidor como localhost e a Porta em 3306 já que você está se conectando a um servidor local.

Fornecer as credenciais do usuário ata_levi (Nome de Usuário e Senha) do passo dois da seção “Construindo um Banco de Dados MySQL” e clique em Concluir para fazer login no MySQL.

4. Agora, expanda seu banco de dados (ata_database) no Navegador de Banco de Dados (painel esquerdo) → clique com o botão direito em Tabelas e selecione Criar Nova Tabela para iniciar a criação de uma nova tabela.

Creating a new database table with DBeaver GUI.

5. Nomeie sua nova tabela, mas a escolha deste tutorial é ata_Table, como mostrado abaixo.

Certifique-se de que o nome da tabela corresponda ao nome da tabela que você especificará no método to_sql (“Nome da Tabela”) no passo sete da seção “Obtenção e Consumo de Dados da API”.

6. Em seguida, expanda a nova tabela (ata_table) → clique com o botão direito em Colunas → Criar Nova Coluna para criar uma nova coluna.

7. Forneça um Nome de coluna, como mostrado abaixo, marque a caixa Not Null e clique em OK para criar a nova coluna.

Idealmente, você gostaria de adicionar uma coluna chamada “id”. Por quê? A maioria das APIs terá um id, e o data frame do pandas do Python preencherá automaticamente as outras colunas.

8. Clique em Salvar (canto inferior direito) ou pressione Ctrl+S para salvar as alterações assim que você tiver verificado sua coluna recém-criada (id), como mostrado abaixo.

9. Por fim, clique em Persistir para persistir as alterações que você fez no banco de dados.

Obtenção e Consumo de Dados da API

Agora que você criou o banco de dados para armazenar dados, você precisa buscar os dados de seu respectivo provedor de API e enviá-los para seu banco de dados usando Python. Você vai fornecer seus dados para serem visualizados no Power BI.

Para se conectar ao seu provedor de API, você precisará de três informações-chave; o método de autorização, URL base da API e endpoint da API. Se tiver dúvidas sobre como obter estas informações, visite o site de documentação do seu provedor de API.

Abaixo está uma página de documentação da Syncro.

1. Abra o VS Code, crie um arquivo Python e nomeie o arquivo de acordo com os dados esperados da API. Este arquivo será responsável por buscar e enviar os dados da API para o seu banco de dados (conexão com o banco de dados).

Múltiplas bibliotecas Python estão disponíveis para ajudar na conexão com o banco de dados, mas você usará SQLAlchemy neste tutorial.

Execute o comando pip abaixo no terminal do VS Code para instalar o SQLAlchemy em seu ambiente.

pip install SQLAlchemy

2. Em seguida, crie um arquivo chamado connection.py, preencha o código abaixo, substitua os valores conforme necessário e salve o arquivo.

Ao começar a escrever scripts para se comunicar com o seu banco de dados, uma conexão com o banco de dados deve ser estabelecida antes que o banco de dados aceite qualquer comando.

Mas, em vez de reescrever a string de conexão do banco de dados para cada script que você escreve, o código abaixo é dedicado a fazer com que essa conexão seja chamada/referenciada por outros scripts.

# Importando módulos
# Motor de conexão do SQLAlchemy
from sqlalchemy import create_engine
import sqlalchemy as db
from sqlalchemy.exc import SQLAlchemyError

# Usando lógica try/except para criar uma conexão de banco de dados MySQL
# Forneça as credenciais do servidor MySQL abaixo:
# db: nome do banco de dados
# usuário: nome de usuário
# senha: senha
try:
    engine = create_engine("mysql+pymysql://{user}:{pw}@localhost/{db}"
    .format(
        db="ata_database",
        user="ata_levi",
        pw="password"
    ))
    print("Connected")
except SQLAlchemyError as e:
    error = str(e.dict['orig'])
print(error)

3. Abra o terminal do Visual Studio (Ctrl+Shift+`), e execute os comandos abaixo para instalar o pandas e requests.

pip install pandas
pip install requests

4. Crie outro arquivo Python chamado invoices.py (ou dê outro nome), e adicione o código abaixo ao arquivo.

Você adicionará trechos de código ao arquivo invoices.py em cada etapa subsequente, mas pode visualizar o código completo em GitHub da ATA.

O script invoices.py será executado a partir do script principal descrito na próxima seção, que extrai seus primeiros dados da API.

O código abaixo realiza o seguinte:

Consome dados da sua API e os escreve no seu banco de dados.

Substitui o método de autorização, chave, URL base e pontos finais da API pelos credenciais do seu provedor de API.

# Importação de módulos essenciais
import pymysql
from pandas.core.frame import DataFrame
import requests
import pandas as pd
from requests.api import get
from sqlalchemy.dialects.mysql import LONGTEXT

import os
import schedule
import time
import asyncio

# Importação da string de conexão de connection.py
from connection import engine

5. Adicione o trecho de código abaixo ao arquivo invoices.py para definir os cabeçalhos, por exemplo:

O formato de dados que você espera receber da sua API.

A URL base e o ponto final devem acompanhar o método de autorização e a chave respectiva.

Certifique-se de alterar os valores abaixo com os seus próprios.

# Definindo parâmetros da requisição.
headers = {
'accept':'application/json',
'authorization':'Bearer *Your-bearer-code if the authentication is Bearer*'
}
baseurl = 'https://*your base url*'
endpoint  = 'your endpoint'

6. Em seguida, adicione a seguinte função assíncrona ao arquivo invoices.py.

O código abaixo utiliza o AsyncIO para gerenciar vários scripts a partir de um script principal, conforme abordado na seção seguinte. Quando seu projeto se expandir para incluir vários pontos finais de API, é uma boa prática ter scripts de consumo de API em arquivos separados.

# Envolver o código com uma função assíncrona para torná-lo assíncrono.
async def get_invoices():
	print("Going through the invoices")
	def main_request(baseurl,endpoint,x,headers):
	# Usando o método get do request para puxar dados usando parâmetros definidos.
	# Usando f string para iterar páginas quando a função é chamada.
	r = requests.get(baseurl + endpoint + f'?page={x}',headers=headers)
	return r.json()

7. Por fim, adicione o código abaixo ao arquivo invoices.py, onde uma função get_pages lida com a paginação da sua API.

Essa função retorna o número total de páginas na sua API e ajuda a função range a iterar por todas as páginas.

Entre em contato com os desenvolvedores da sua API sobre o método de paginação utilizado pelo provedor da sua API.

  def get_pages(response):
			return response['meta']['total_pages']

	def parse_json(response):
	    charlist =[]
	    for item in response['invoices']:
	        charlist.append(item)
	    return charlist
	# Chamar a função principal com parâmetros predefinidos.
	data = main_request(baseurl=baseurl,endpoint=endpoint,x=1,headers=headers)
	
	main_invoices = []
	# Iterar/paginar pelos dados da API.
  # Seu provedor de API pode estar usando um método diferente 
	# para paginação.
	for x in range(1,get_pages(data)+1):
	
	    print(x)
	    main_invoices.extend(parse_json(main_request(baseurl,endpoint,x,headers)))
	df_invoices = pd.DataFrame(main_invoices)
	
	# Escrever novos dados no banco de dados SQL.
	# Nota: Certifique-se de que o nome da tabela no banco de dados corresponda ao fornecido aqui.
	df_invoices.to_sql('invoices',con=engine,if_exists='replace',index=False)
	
  # Esta função aguarda a função get_invoices,
	# executa a função get_invoices() quando chamada,
	# e será chamada por um arquivo externo para invocar sua chamada de API.

async def call_invoices():
	await get_invoices()

Se preferir adicionar mais endpoints de API aos seus dados:

Repita os passos quatro a seis da seção “Gerenciando Bancos de Dados MySQL com DBeaver”.

Repita todos os passos na seção “Obtendo e Consumindo Dados da API”.

Altere o endpoint da API para outro que deseja consumir.

Sincronizando Endpoints da API

Agora você tem um banco de dados e conexão API, e está pronto para iniciar o consumo da API executando o código no arquivo invoices.py. Mas fazer isso limitaria você a consumir um endpoint da API simultaneamente.

Como ultrapassar o limite? Você criará outro arquivo Python como um arquivo central que chama funções da API de vários arquivos Python e executa as funções de forma assíncrona usando \texttt{AsyncIO}. Dessa forma, você mantém sua programação limpa e permite agrupar várias funções juntas.

1. Crie um novo arquivo Python chamado \texttt{central.py} e adicione o código abaixo.

Assim como no arquivo \texttt{invoices.py}, você adicionará trechos de código ao arquivo \texttt{central.py} em cada etapa, mas pode visualizar o código completo no GitHub da ATA.

O código abaixo importa módulos essenciais e scripts de outros arquivos usando a sintaxe \texttt{from import }.

from datetime import datetime
from numpy import product
# Importando a função da API de busca de faturas de invoices.py
from invoices import call_invoices
import asyncio
import time
import schedule
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from datetime import datetime
import os

2. Em seguida, adicione o seguinte código para controlar os scripts de invoices.py no arquivo central.py.

Você precisa fazer referência/chamar a função \texttt{call_invoices} de invoices.py para uma tarefa AsyncIO (\texttt{invoice_task}) em central.py.

# Criando a função principal
async def chain():
	def _handle_task_result(task: asyncio.Task) -> None:
		try:
				task.result()
		except asyncio.CancelledError:
				pass
		except Exception:
				logging.exception('Exception raised by task %r',task)
	start = time.perf_counter()
	# Criando tarefa para a função importada de invoices.py
	invoice_task = asyncio.create_task(call_invoices())

3. Após criar a tarefa AsyncIO, aguarde a tarefa para buscar e executar a função call_invoices de invoice.py assim que a função chain (no passo dois) começar a ser executada.

	# Aguardando a tarefa criada
	await invoice_task
	# Acompanhando os tempos da tarefa
	end = time.perf_counter()-start
	l_time =  time.localtime()
	human_time = time.asctime(l_time)
	print (f"chained result took {end:0.2f} seconds")
	print(f"Current time is {human_time}")

4. Crie um AsyncIOScheduler para agendar um trabalho para o script executar. O trabalho adicionado neste código executa a função chain em intervalos de um segundo.

Este trabalho é importante para garantir que seu programa continue executando seus scripts para manter seus dados atualizados.

if name == "main":
# O agendador permite que o código faça loop indefinidamente e faça pausas entre os loops.
    scheduler = AsyncIOScheduler()
scheduler.add_job(chain,'interval',seconds=1)
scheduler.start()
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))

try:
	asyncio.get_event_loop().run_forever()
except (KeyboardInterrupt,SystemExit):
    pass

5. Por fim, execute o script central.py no VS Code, conforme mostrado abaixo.

Depois de executar o script, você verá a saída no terminal como a abaixo.

Abaixo, a saída confirma que as faturas foram adicionadas ao banco de dados.

Verifying invoices are added to the database

Desenvolvendo Visualizações Power BI

Depois de codificar um programa que se conecta e consome dados da API e envia esses dados para um banco de dados, você está quase pronto para colher seus dados. Mas primeiro, você vai enviar os dados no banco de dados para o Power BI para visualização, o objetivo final.

Muitos dados são inúteis se você não puder visualizá-los e fazer conexões profundas. Felizmente, as visualizações do Power BI são como gráficos que podem tornar equações matemáticas complicadas simples e previsíveis.

1. Abra o Power BI a partir do seu Desktop ou menu Iniciar.

2. Clique no ícone da fonte de dados acima do menu suspenso Obter dados na janela principal do Power BI. Uma janela pop-up aparecerá onde você pode selecionar a fonte de dados a ser usada (passo três).

3. Procure por mysql, selecione o banco de dados MySQL e clique em Conectar para iniciar a conexão com o seu banco de dados MySQL.

Selecting MySQL as the data source to connect

4. Agora, conecte-se ao seu banco de dados MySQL com o seguinte:

Insira localhost:3306 pois você está se conectando ao seu servidor MySQL local na porta 3306.

Forneça o nome do seu banco de dados, neste caso, ata_db.

Clique em OK para se conectar ao seu banco de dados MySQL.

5. Agora, clique em Transformar dados (canto inferior direito) para ver a visão geral dos dados no Editor de Consultas do Power BI (passo cinco).

6. Após visualizar a fonte de dados, clique em Fechar e Aplicar para voltar à aplicação principal e confirmar se alguma alteração foi aplicada.

O editor de consultas mostra tabelas da sua fonte de dados à extrema esquerda. Ao mesmo tempo, você pode verificar o formato dos dados antes de prosseguir para a aplicação principal.

7. Clique na guia de ferramentas de tabela, selecione qualquer tabela no Painel de Campos e clique em Gerenciar relacionamentos para abrir o assistente de relacionamento.

Antes de criar visuais, você deve garantir que suas tabelas estejam relacionadas, então especifique qualquer relação entre suas tabelas explicitamente. Por quê? O Power BI ainda não detecta automaticamente correlação complexa de tabelas.

8. Marque as caixas das relações existentes para editar e clique em Editar. Uma janela pop-up aparecerá, onde você pode editar as relações selecionadas (passo nove).

Mas se preferir adicionar um novo relacionamento, clique em Novo em vez disso.

9. Edite os relacionamentos da seguinte forma:

Clique no campo suspenso de tabelas e selecione uma tabela.

Clique nos cabeçalhos para selecionar as colunas a serem usadas.

Marque a opção Tornar este relacionamento ativo para garantir que os relacionamentos sejam válidos.

Clique em OK para estabelecer o relacionamento e fechar a janela de edição de relacionamento.

10. Agora, clique no tipo de visualização de tabela na área de Visualizações (à direita) para criar sua primeira visualização, e uma visualização de tabela vazia aparecerá (passo 11).

11. Selecione a visualização de tabela e os campos de dados (no painel Campos) para adicionar à sua visualização de tabela, como mostrado abaixo.

12. Por fim, clique no tipo de visualização de filtro para adicionar outra visualização. Como o nome sugere, a visualização de filtro fatia dados filtrando outras visualizações.

Após adicionar o filtro, selecione dados no painel Campos para adicionar à visualização de filtro.

Adding a slicer visual and adding a data field

Alterando Visualizações

As aparências padrão das visualizações são bastante decentes. Mas não seria ótimo se você pudesse mudar a aparência das visualizações para algo menos monótono? Deixe o Power BI fazer a mágica.

Clique no ícone Formatar sua visualização sob a visualização para acessar o editor de visualização, como mostrado abaixo.

Passe algum tempo brincando com as configurações de visualização para obter a aparência desejada para suas visualizações. Suas visualizações estarão correlacionadas, desde que você estabeleça um relacionamento entre as tabelas envolvidas em suas visualizações.

Accessing the Power BI visualization editor

Depois de alterar as configurações de visualização, você pode gerar relatórios como os abaixo.

Agora, você pode visualizar e analisar seus dados sem complexidade ou cansar seus olhos.

Na visualização a seguir, ao observar o gráfico de tendências, você verá que algo deu errado em abril de 2020. Naquele momento, foram impostos os bloqueios devido à Covid-19 na África do Sul.

Esse resultado apenas comprova a habilidade do Power BI em fornecer visualizações de dados precisas.

Conclusão

Este tutorial tem como objetivo mostrar como estabelecer um pipeline de dados dinâmico ao vivo, obtendo seus dados de pontos de extremidade da API. Além disso, processando e enviando dados para seu banco de dados e Power BI usando Python. Com esse conhecimento recém-adquirido, agora você pode consumir dados da API e criar suas próprias visualizações de dados.

Cada vez mais empresas estão criando aplicativos web Restful API. E, neste ponto, você está confiante em consumir APIs usando Python e criar visualizações de dados com o Power BI, o que pode ajudar a influenciar as decisões comerciais.