Excel sem Limites: A Revolução da Integração com Python

Excel sem Limites: A Revolução da Integração com Python
├── 📝 Introdução
├── 🐍 Integração com Python
├── 🛠️ Automação de Processos e Tarefas Repetitivas
├── 📈 Análises Avançadas e Modelagem de Dados
├── 🤖 Machine Learning e Inteligência Artificial
├── 🌐 Integração com APIs e Banco de Dados
├── 🔍 Análise de Textos e Processamento de Linguagem Natural (NLP)
├── 🔐 Segurança e Automação de Relatórios
├── 🎯 Conclusão
├── 📚 Bibliotecas Python mencionadas no artigo
├── 🔗 Fontes
└── 🙏 Agradecimento

from openpyxl import Workbook
import pandas as pd
import xlsxwriter

# Criando planilha vazia com openpyxl
wb = Workbook()
wb.save("openpyxl.xlsx")

# Criando planilha vazia com pandas
df = pd.DataFrame()
df.to_excel("pandas.xlsx", index=False)

# Criando planilha vazia com XlsxWriter
wb_xlsxwriter = xlsxwriter.Workbook("xlsxwriter.xlsx")
wb_xlsxwriter.close()

import os
from googleapiclient.discovery import build
from google.oauth2.service_account import Credentials

def initialize_google_drive_service():
  SCOPES = ['https://www.googleapis.com/auth/drive']
  SERVICE_ACCOUNT_FILE = get_service_account_file()
  creds = Credentials.from_service_account_file(SERVICE_ACCOUNT_FILE, scopes=SCOPES)
  return build('drive', 'v3', credentials=creds)

def initialize_google_sheets_service():
  SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
  SERVICE_ACCOUNT_FILE = get_service_account_file()
  creds = Credentials.from_service_account_file(SERVICE_ACCOUNT_FILE, scopes=SCOPES)
  return build('sheets', 'v4', credentials=creds)

def get_service_account_file():
  if os.path.exists("service-account-example.json"):
      return "service-account-example.json"
  credentials_json = os.getenv("GOOGLE_CREDENTIALS_JSON")
  if credentials_json:
      with open("/tmp/service_account.json", "w") as f:
          f.write(credentials_json)
      return "/tmp/service_account.json"
  raise ValueError("Credenciais do Google não encontradas!")

from models.google_models import initialize_google_sheets_service, initialize_google_drive_service
from scripts.INVENTORY_REPORT_SCRIPT.universal_inventory_report_script import generate_data_frame

# Inicializa os serviços do Google Sheets e Google Drive
def initialize_services():
  sheets_service = initialize_google_sheets_service()
  drive_service = initialize_google_drive_service()
  return sheets_service, drive_service

# Verifica se uma planilha com o nome especificado já existe na pasta do Google Drive
def check_if_sheet_exists(drive_service, id_pasta, nome_planilha):
  query = f"'{id_pasta}' in parents and name='{nome_planilha}' and mimeType='application/vnd.google-apps.spreadsheet'"
  response = drive_service.files().list(q=query).execute()
  arquivos = response.get('files', [])
  return arquivos[0]['id'] if arquivos else None  # Retorna o ID da planilha se existir, caso contrário, retorna None

# Cria uma nova planilha no Google Drive dentro da pasta especificada
def create_new_sheet(drive_service, id_pasta, nome_planilha):
  nova_planilha = {
      'name': nome_planilha,
      'mimeType': 'application/vnd.google-apps.spreadsheet',
      'parents': [id_pasta]
  }
  arquivo_criado = drive_service.files().create(body=nova_planilha, fields='id').execute()
  return arquivo_criado.get('id')  # Retorna o ID da nova planilha criada

# Limpa os dados existentes na planilha, garantindo que ela esteja vazia antes da atualização
def clear_sheet_data(sheets_service, planilha_id):
  sheets_service.spreadsheets().values().clear(
      spreadsheetId=planilha_id,
      range="Sheet1"  # Limpa os dados da primeira aba da planilha
  ).execute()
  print("Existing data cleared from the sheet.")

# Atualiza a planilha com os novos dados fornecidos no DataFrame
def update_sheet_data(sheets_service, planilha_id, df):
  valores = [df.columns.tolist()] + df.values.tolist()  # Converte DataFrame para formato aceito pelo Google Sheets
  sheets_service.spreadsheets().values().update(
      spreadsheetId=planilha_id,
      range="Sheet1",
      valueInputOption="RAW",
      body={"values": valores}
  ).execute()

# Gera e salva o relatório de inventário no Google Sheets
def save_inventory_report(id_conta="EXEMPLO_ID_CONTA", id_pasta="EXEMPLO_ID_PASTA", data="YYYY-MM-DD"):
  df = generate_data_frame(id_conta, data, data)  # Gera o DataFrame com os dados do inventário
  sheets_service, drive_service = initialize_services()  # Inicializa os serviços da API do Google

  nome_planilha = f"Relatorio_Inventarios_{data.replace('-', '')}"  # Define o nome da planilha com a data

  # Verifica se a planilha já existe, caso contrário, cria uma nova
  planilha_id = check_if_sheet_exists(drive_service, id_pasta, nome_planilha)
  if not planilha_id:
      planilha_id = create_new_sheet(drive_service, id_pasta, nome_planilha)
      print(f"New sheet created: {nome_planilha}")
  else:
      print(f"Existing sheet found: {nome_planilha}, clearing data...")
      clear_sheet_data(sheets_service, planilha_id)  # Limpa os dados caso a planilha já exista

  update_sheet_data(sheets_service, planilha_id, df)  # Atualiza a planilha com os novos dados
  print(f"Data successfully inserted into the sheet: {nome_planilha}")

  return planilha_id  # Retorna o ID da planilha criada ou atualizada

import pandas as pd
from datetime import datetime

def processar_categorias(original_file):
  # Obter a data atual no formato ddmmaaaa
  data_atual = datetime.today().strftime("%d%m%Y")

  # Carregar a planilha original
  df_original = pd.read_excel(original_file, sheet_name='Sheet1')

  # Ordenar os dados
  df_sorted = df_original.sort_values(by=df_original.columns.tolist(), ascending=False)

  # Identificar e separar os duplicados
  df_duplicates = df_sorted[df_sorted.duplicated(subset=['ean', 'descricao'], keep='first')]
  df_filtered = df_sorted.drop_duplicates(subset=['ean', 'descricao'], keep='first')

  # Definir os nomes dos arquivos com a data atual
  file_filtered = f"Categorias_Filtradas_{data_atual}.xlsx"
  file_duplicates = f"Categorias_Removidas_{data_atual}.xlsx"

  # Salvar as planilhas
  df_filtered.to_excel(file_filtered, index=False)
  df_duplicates.to_excel(file_duplicates, index=False)

  print(f"Planilhas '{file_filtered}' e '{file_duplicates}' foram geradas com sucesso.")

processar_categorias("Categorias_DB_18022025.xlsx")

import os
import pandas as pd
from pymongo import MongoClient
from tqdm import tqdm

def verificar_ids_no_mongo(excel_path, sheet_name, column_name, collection_name, id_cliente, output_path_encontrados, output_path_nao_encontrados):

  # Obtém a URI de conexão ao MongoDB a partir das variáveis de ambiente
  mongo_uri = os.getenv('MONGO_DB_CONNECTION')
  client = MongoClient(mongo_uri)
  db = client['meuBanco']
  collection = db[collection_name]

  # Verifica se o arquivo Excel existe e não está vazio
  if not os.path.exists(excel_path) or os.path.getsize(excel_path) == 0:
      print(f"Erro: O arquivo {excel_path} não existe ou está vazio.")
      return

  try:
      # Carrega os dados do Excel para um DataFrame do pandas
      df = pd.read_excel(excel_path, sheet_name=sheet_name, dtype=str)
  except Exception as e:
      print(f"Erro ao ler o arquivo Excel: {e}")
      return

  # Verifica se a coluna especificada existe no DataFrame
  if column_name not in df.columns:
      print(f"Erro: A coluna '{column_name}' não foi encontrada no arquivo Excel.")
      return

  # Obtém os IDs da coluna, removendo valores nulos e duplicados
  ids = df[column_name].dropna().astype(str).unique().tolist()

  if not ids:
      print("Erro: O arquivo Excel não contém nenhum `_id` válido.")
      return

  encontrados = []  # Lista para armazenar os IDs encontrados no MongoDB
  nao_encontrados = []  # Lista para armazenar os IDs não encontrados

  print(f"\nVerificando {len(ids)} IDs na coleção '{collection_name}' para id_cliente: {id_cliente}...\n")

  # Itera sobre os IDs e verifica se estão na coleção do MongoDB
  for item_id in tqdm(ids, desc="Processando", unit="item"):
      result = collection.find_one({"_id": item_id, "id_cliente": id_cliente})

      if result:
          encontrados.append({"_id": item_id, "id_cliente": id_cliente})
      else:
          nao_encontrados.append({"_id": item_id, "id_cliente": id_cliente})

  # Se houver IDs encontrados, salva em um arquivo Excel
  if encontrados:
      df_encontrados = pd.DataFrame(encontrados)
      df_encontrados.to_excel(output_path_encontrados, index=False)
      print(f"\nArquivo gerado: {output_path_encontrados}")

  # Se houver IDs não encontrados, salva em outro arquivo Excel
  if nao_encontrados:
      df_nao_encontrados = pd.DataFrame(nao_encontrados)
      df_nao_encontrados.to_excel(output_path_nao_encontrados, index=False)
      print(f"\nArquivo gerado: {output_path_nao_encontrados}")


# Definição dos parâmetros do programa
excel_path = "ids_para_verificacao.xlsx"  # Caminho do arquivo Excel contendo os IDs
sheet_name = "Planilha1"  # Nome da aba no Excel
column_name = "id_verificacao"  # Nome da coluna onde os IDs estão armazenados
collection_name = "colecao_dados"  # Nome da coleção do MongoDB
id_cliente = os.getenv("ID_CLIENTE")  # Obtém o ID do cliente das variáveis de ambiente
output_path_encontrados = "ids_encontrados.xlsx"  # Arquivo de saída para IDs encontrados
output_path_nao_encontrados = "ids_nao_encontrados.xlsx"  # Arquivo de saída para IDs não encontrados

# Chamada da função principal
verificar_ids_no_mongo(excel_path, sheet_name, column_name, collection_name, id_cliente, output_path_encontrados, output_path_nao_encontrados)

import hashlib


def exibir_hash_arquivo(arquivo):
  # Inicializa o objeto de hash SHA-256
  sha256 = hashlib.sha256()
  
  try:
      # Abre o arquivo em modo binário para leitura
      with open(arquivo, "rb") as f:
          # Lê o arquivo em blocos para eficiência e atualiza o hash
          while chunk := f.read(4096):
              sha256.update(chunk)
      # Retorna o hash calculado em formato hexadecimal
      return sha256.hexdigest()
  except FileNotFoundError:
      # Retorna erro caso o arquivo não seja encontrado
      print(f"Erro: O arquivo '{arquivo}' não foi encontrado.")
      return None

def comparar_hash_arquivos(arquivo1, arquivo2):
  # Gera o hash para o primeiro arquivo
  hash1 = exibir_hash_arquivo(arquivo1)
  # Gera o hash para o segundo arquivo
  hash2 = exibir_hash_arquivo(arquivo2)

  # Se algum dos hashes for None, a comparação não pode ser feita
  if hash1 is None or hash2 is None:
      return False

  # Retorna True se os hashes forem iguais, indicando que os arquivos são idênticos
  return hash1 == hash2

# Exemplo de uso
arquivo_a = "arquivo1.xlsx"
arquivo_b = "arquivo2.xlsx"

# Exibir o hash do primeiro arquivo
hash_a = exibir_hash_arquivo(arquivo_a)
print(f"Hash de {arquivo_a}: {hash_a}")

# Exibir o hash do segundo arquivo
hash_b = exibir_hash_arquivo(arquivo_b)
print(f"Hash de {arquivo_b}: {hash_b}")

# Comparar os arquivos e mostrar o resultado
if comparar_hash_arquivos(arquivo_a, arquivo_b):
  print("Os arquivos são idênticos.")
else:
  print("Os arquivos são diferentes.")

📚 Bibliotecas Python:
├── 🔐 cryptography
│   ├── Implementação de algoritmos de criptografia simétrica e assimétrica, incluindo AES e RSA.
│   └── 📄 https://cryptography.io/en/latest/
│
├── 📊 dash
│   ├── Framework para criação de dashboards interativos e aplicações web de análise de dados baseadas em Flask e Plotly.
│   └── 📄 https://dash.plotly.com/
│
├── ☁️ Google Drive API
│   ├── Upload, download e gerenciamento de arquivos no Google Drive via requisições HTTP.
│   └── 📄 https://developers.google.com/drive/api
│
├── 📑 Google Sheets API
│   ├── API REST para criar, ler, editar e formatar planilhas no Google Sheets.
│   └── 📄 https://developers.google.com/sheets/api
│
├── 📂 gspread
│   ├── Manipulação de planilhas do Google Sheets via API, permitindo leitura e escrita programática.
│   └── 📄 https://gspread.readthedocs.io/
│
├── 🔒 hashlib
│   ├── Implementação de algoritmos de hash (SHA-256, MD5, etc.), garantindo integridade e autenticação de dados.
│   └── 📄 https://docs.python.org/3/library/hashlib.html
│
├── 📊 matplotlib
│   ├── Biblioteca para criação de gráficos 2D e 3D em Python, com suporte a diversas personalizações.
│   └── 📄 https://matplotlib.org/stable/contents.html
│
├── 🗣️ nltk
│   ├── Conjunto de ferramentas para Processamento de Linguagem Natural (NLP), incluindo tokenização e análise semântica.
│   └── 📄 https://www.nltk.org/
│
├── 🔢 numpy
│   ├── Biblioteca para computação numérica eficiente, fornecendo suporte a arrays multidimensionais e operações vetorizadas.
│   └── 📄 https://numpy.org/doc/
│
├── 📊 openpyxl
│   ├── Leitura, escrita e modificação de arquivos Excel (.xlsx), incluindo manipulação de células e formatação.
│   └── 📄 https://openpyxl.readthedocs.io/
│
├── 📑 pandas
│   ├── Manipulação de dados tabulares com estrutura DataFrame para análise e transformação eficiente.
│   └── 📄 https://pandas.pydata.org/pandas-docs/stable/
│
├── 📈 plotly
│   ├── Biblioteca interativa para visualização de dados, suportando gráficos dinâmicos e integração com aplicações web.
│   └── 📄 https://plotly.com/python/
│
├── 🛢️ pymongo
│   ├── Driver para interação com MongoDB, permitindo leitura, escrita e manipulação de dados em bancos NoSQL.
│   └── 📄 https://pymongo.readthedocs.io/en/stable/
│
├── 📄 PyPDF2
│   ├── Manipulação de arquivos PDF, incluindo extração de texto, divisão e mesclagem de páginas.
│   └── 📄 https://pypdf2.readthedocs.io/en/latest/
│
├── 🏷️ re (expressões regulares)
│   ├── Manipulação de strings via padrões de expressões regulares para extração e validação de dados.
│   └── 📄 https://docs.python.org/3/library/re.html
│
├── 🌍 requests
│   ├── Biblioteca HTTP para integração com APIs REST via requisições GET, POST, PUT e DELETE.
│   └── 📄 https://docs.python-requests.org/en/latest/
│
├── 🤖 scikit-learn
│   ├── Biblioteca de aprendizado de máquina, com algoritmos de regressão, classificação e clusterização.
│   └── 📄 https://scikit-learn.org/stable/
│
├── 📊 seaborn
│   ├── Extensão do matplotlib para visualização estatística aprimorada, fornecendo gráficos elegantes e informativos.
│   └── 📄 https://seaborn.pydata.org/
│
├── 📧 smtplib
│   ├── Envio de e-mails via protocolo SMTP, permitindo automação de notificações e alertas.
│   └── 📄 https://docs.python.org/3/library/smtplib.html
│
├── 🗣️ spaCy
│   ├── Framework avançado para NLP, otimizado para extração de entidades e análise sintática de textos.
│   └── 📄 https://spacy.io/usage
│
├── 🗄️ sqlalchemy
│   ├── ORM para mapeamento objeto-relacional, permitindo manipulação de bancos de dados SQL via código Python.
│   └── 📄 https://docs.sqlalchemy.org/en/latest/
│
├── 🤖 tensorflow
│   ├── Framework para construção e treinamento de redes neurais profundas e modelos avançados de machine learning.
│   └── 📄 https://www.tensorflow.org/api_docs
│
├── 🔠 textblob
│   ├── Biblioteca para análise de sentimentos, classificação de texto e processamento gramatical simplificado.
│   └── 📄 https://textblob.readthedocs.io/en/dev/
│
└── 📊 xlwings
  ├── Integração entre Python e Excel VBA, permitindo automação de planilhas e manipulação de macros.
  └── 📄 https://docs.xlwings.org/