Relatório Acadêmico Tecnológico:
Otimização de Dados e Automação em Ambientes Dinâmicos

Delean Mafra - Profile Picture

CDADOS - Projeto de Extensão I - Delean Mafra

Descrição do Projeto

Este projeto tem como objetivo automatizar a conferência de recibos de pagamentos de eventos beneficentes da Igreja Renascer em Cristo. Com a implementação deste sistema, busca-se:

Descrição da 1° parte do Projeto: Base de Dados e Automação Core

Criei um plano de ação com os seguintes objetivos:

Com esses objetivos, o projeto visa não apenas a eficiência operacional, mas também um suporte adequado às atividades da Igreja Renascer em Cristo.

Descrição da 2ª parte do Projeto: Arquitetura de Dados Flexível

A atualização no código permite ler automaticamente o caminho da pasta a partir de um arquivo de configuração (pex.lic), trazendo uma melhoria significativa em termos de usabilidade e eficiência. O sistema não exige que o usuário insira manualmente o caminho da pasta a cada execução, minimizando o tempo necessário para configurar e executar o script. Esse aprimoramento torna o processo mais ágil, reduz a chance de erros de digitação ao informar o caminho e permite que a equipe execute a verificação de duplicados com um clique. Além disso, essa modificação facilita a integração do sistema com outros processos automatizados e garante uma experiência mais prática e acessível para a equipe da igreja.

Observação: Desafios na Integração de Tecnologias

Inicialmente, optei por utilizar a biblioteca "kivy" para criar uma interface mais agradável, combinada com a biblioteca "cryptography" para criar um registro de licença criptografado, evitando que o programa fosse compartilhado com outras pessoas além do pastor Julian e do Bispo Gabriel. Infelizmente, tive diversos problemas com as duas bibliotecas, pois o código funcionava perfeitamente no meu ambiente de teste, porém, quando era compilado para um executável, ele não conseguia ler corretamente o registro de licença criado. Outro problema foi que a compilação do programa utilizando a biblioteca "kivy" era muito longa, levando aproximadamente 30 minutos para concluir cada compilação. Foram compiladas 47 versões (1.0.0.47) desse projeto inicial, totalizando aproximadamente 23 horas de programação e compilação do programa.

3ª Parte do Projeto: Redesenho da Interface do Usuário com Tkinter

Removi do código a biblioteca “kivy” e "cryptography” e adicionei a biblioteca “Tkinter” no lugar da “kivy”.

A implementação da biblioteca “Tkinter” no projeto permitiu criar uma interface gráfica amigável e visualmente agradável, oferecendo várias vantagens:

4ª Parte do Projeto: Versionamento de Código (Database Snapshots)

A implementação de um sistema de controle de versão utilizando o arquivo “version.txt” permite acompanhar e documentar as diferentes versões do software, garantindo um histórico claro das alterações e evoluções do projeto.

5ª Parte do Projeto: Compilador de Software (Automated Build System)

Na quinta parte do projeto, foi desenvolvido um compilador em Python com o objetivo de transformar o código em um executável (.exe), utilizando as bibliotecas “pyinstaller” e “subprocess”. Esta etapa é fundamental para a distribuição do software, permitindo que ele seja executado no ambiente dos usuários sem a necessidade de um interpretador Python instalado.

Linha do Tempo para Conclusão do Projeto: Framework Evolutivo

1° parte do projeto: Identificação de Necessidade e Solução em Python (Data Processing Core)

import os
import hashlib

def calcular_hash(arquivo):
    """Calcula o hash SHA-256 de um arquivo para identificar duplicados."""
    hash_sha256 = hashlib.sha256()
    with open(arquivo, 'rb') as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_sha256.update(chunk)
    return hash_sha256.hexdigest()

def verificar_duplicados(caminho_pasta):
    """Verifica e exclui arquivos duplicados na pasta especificada."""
    arquivos_verificados = {}
    log_exclusao = []

    for root, _, arquivos in os.walk(caminho_pasta):
        for nome_arquivo in arquivos:
            if nome_arquivo.lower().endswith(('.pdf', '.png', '.jpeg', '.jpg')):
                caminho_completo = os.path.join(root, nome_arquivo)
                hash_arquivo = calcular_hash(caminho_completo)

                if hash_arquivo in arquivos_verificados:
                    # Excluir o arquivo duplicado
                    os.remove(caminho_completo)
                    log_exclusao.append(caminho_completo)
                else:
                    # Armazenar o hash para comparação futura
                    arquivos_verificados[hash_arquivo] = caminho_completo

    # Salvar log dos arquivos excluídos
    with open('log_exclusao.txt', 'w') as log:
        for item in log_exclusao:
            log.write(f"{item}\n")
    print("Processo concluído. Log salvo em 'log_exclusao.txt'.")

# Solicita o caminho da pasta ao usuário e executa a verificação de duplicados
if __name__ == "__main__":
    caminho = input("Informe o caminho da pasta com os arquivos: ")
    verificar_duplicados(caminho)

2ª parte do projeto: Otimização de Entrada de Dados (Automated Data Pathways)

Foi adicionada uma função no código para que não seja necessário ter que sempre informar manualmente o caminho da pasta.

def obter_caminho_da_pasta():
"""Lê o caminho da pasta a partir de um arquivo de texto."""
with open('pex.lic', 'r') as arquivo: caminho_pasta = arquivo.readline().strip() return caminho_pasta

3ª parte do projeto: Interface Gráfica Avançada (Gaming-Inspired GUI)

Foi criada uma interface para que o programa não precisasse ser executado pelo terminal, melhorando a intuição e experiência do usuário

import os
import hashlib
import tkinter as tk
from tkinter import messagebox

def calcular_hash(arquivo):
    # Calcula o hash SHA-256 de um arquivo para identificar duplicados
    hash_sha256 = hashlib.sha256()
    with open(arquivo, 'rb') as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_sha256.update(chunk)
    return hash_sha256.hexdigest()

def verificar_duplicados(caminho_pasta):
    # Verifica e exclui arquivos duplicados na pasta especificada
    arquivos_verificados = {}
    log_exclusao = []

    for root, _, arquivos in os.walk(caminho_pasta):
        for nome_arquivo in arquivos:
            if nome_arquivo.lower().endswith(('.pdf', '.png', '.jpeg', '.jpg')):
                caminho_completo = os.path.join(root, nome_arquivo)
                hash_arquivo = calcular_hash(caminho_completo)

                if hash_arquivo in arquivos_verificados:
                    os.remove(caminho_completo) # Excluir o arquivo duplicado
                    log_exclusao.append(caminho_completo)
                else:
                    arquivos_verificados[hash_arquivo] = caminho_completo

    # Salvar log dos arquivos excluídos
    with open('log_exclusao.txt', 'w') as log:
        for item in log_exclusao:
            log.write(f"{item}\n")
    return "Processo concluído. Log salvo em 'log_exclusao.txt'."

def obter_caminho_da_pasta():
    # Lê o caminho da pasta a partir de um arquivo de texto
    with open('pex.lic', 'r') as arquivo:
        caminho_pasta = arquivo.readline().strip()
    return caminho_pasta

def excluir_arquivos_duplicados():
    # Executa a função de exclusão de arquivos duplicados e exibe mensagem de conclusão
    caminho = obter_caminho_da_pasta()
    mensagem = verificar_duplicados(caminho)
    messagebox.showinfo("Resultado", f"{mensagem}\nTodos os arquivos duplicados foram excluídos.")

def main():
    root = tk.Tk()
    root.withdraw() # Oculta a janela principal inicialmente

    # Configuração da interface para executar a exclusão de arquivos duplicados
    root.deiconify() # Mostra a janela principal para o botão de execução
    root.title("Exclusão de Arquivos Duplicados")
    root.geometry("400x200")

    # Label de autoria
    label_copyright = tk.Label(root, text="©2024 Delean Mafra - Todos os direitos reservados")
    label_copyright.pack(pady=10)

    # Botão para iniciar o processo de exclusão
    btn_executar = tk.Button(
        root,
        text="Excluir Arquivos Duplicados",
        command=excluir_arquivos_duplicados
    )
    btn_executar.pack(pady=20)

    root.mainloop()

if __name__ == "__main__":
    main()

4ª Parte: Arquivo de Versão (Version Control Data Layer)

Foi criado arquivo de versão (version.txt)

# UTF-8
#
# Para mais detalhes sobre o 'ffi' veja:
# http://msdn.microsoft.com/en-us/library/ms646997.aspx

VSVersionInfo(
    ffi=FixedFileInfo(
        filevers=(2, 0, 0, 0),
        prodvers=(2, 0, 0, 0),
        mask=0x3f,
        flags=0x0,
        OS=0x4,
        fileType=0x1,
        subtype=0x0,
        date=(0, 0)
    ),
    kids=[
        StringFileInfo(
            [
                StringTable(
                    '041604B0',
                    [
                        StringStruct('CompanyName', 'Delean Mafra'),
                        StringStruct('FileDescription', 'Exclui Arquivos Duplicados'),
                        StringStruct('FileVersion', StringStruct('Exclui Arquivos Duplicados'),
                        StringStruct('Copyright ©2024 | Delean Mafra, todos os direitos reservados.'),
                        StringStruct('Exclui Arquivos Duplicados.exe'),
                        StringStruct('Exclui Arquivos Duplicados'),
                        StringStruct('2.0.0.2'),
                    ]
                )
            ]
        ),
        VarFileInfo([VarStruct('Translation', [1046, 1200])])
    ]
)

5ª parte: Ferramenta de Compilação (Cybernetic Deployment Tool)

Foi criado compilador:

import os
import subprocess

# Função para incrementar a versão
def incrementar_versao(versao):
    partes = versao.split('.')
    partes[-1] = str(int(partes[-1]) + 1)
    return '.'.join(partes)

# Caminho do arquivo de versão
version_file_path = 'D:/Python/Python_projcts/pex/version.txt'

# Ler o arquivo de versão
with open(version_file_path, 'r', encoding='utf-8') as file:
    linhas = file.readlines()

# Atualizar as linhas com a nova versão, sem tocar no filevers
for i, linha in enumerate(linhas):
    if "StringStruct('ProductVersion'," in linha:
        partes = linha.split("'")
        nova_versao = incrementar_versao(partes[3])
        partes[3] = nova_versao
        linhas[i] = "'".join(partes)

# Escrever as novas linhas de volta no arquivo de versão
with open(version_file_path, 'w', encoding=as file:
    file.writelines(linhas)

# Mudar para o drive D:
os.chdir('D:/')

# Mudar para o diretório do projeto
os.chdir('D:/Python/Python_projcts/pex')

# Caminho do ícone
icon_path = 'D:/Python/Python_projcts/pex/ico_lupa.ico'

# Caminho correto do arquivo de versão
correct_version_file_path = # Executar o comando do PyInstaller
subprocess.run(['pyinstaller', '--onefile',
                    f'--version-file={correct_version_file_path}', f'--icon={icon_path}',
                    'pex.py'])

# Pausar a execução (equivalente ao 'pause' no .bat)
input("Pressione Enter para continuar...")

6ª Parte: Distribuição do Software (Network Deployment)

Foi realizada a compilação do software e disponibilizada aos computadores dos usuários via AnyDesk.

7ª Parte/parte final: Validação e Acompanhamento (Cyber-Audit & Feedback Loop)

Foi realizado acompanhamento e validação do funcionamento do programa. Foi coletada assinatura do responsável da organização.

Observação: Projeto disponível no github: https://github.com/Delean-Mafra/pex

EVOLUÇÃO PARA VERSÃO 3.0: Aprimoramento Solicitado pela Igreja Renascer

8ª Parte: Solicitação de Aprimoramento (Advanced Partnership Development)

Após a conclusão bem-sucedida do projeto inicial, a Igreja Renascer em Cristo entrou em contato solicitando aprimoramentos no sistema de exclusão de arquivos duplicados. O feedback positivo da versão 2.0 e a confiança estabelecida pela parceria anterior motivaram a organização a solicitar uma versão ainda mais avançada e funcional.

Análise das Necessidades para a Versão 3.0 (Requirements Engineering)

Durante as reuniões de levantamento de requisitos com a equipe da Igreja Renascer, foram identificadas as seguintes necessidades:

Desenvolvimento da Versão 3.0: Interface Web Avançada (Flask-Based Architecture)

A versão 3.0 representa uma completa reformulação arquitetural do sistema, mantendo a robustez da lógica de detecção de duplicados enquanto introduz uma interface web moderna e intuitiva:

# Principais mudanças arquiteturais na versão 3.0
from flask import Flask, render_template_string, request, jsonify
from PIL import Image
from PyPDF2 import PdfReader

app = Flask(__name__)

# Interface HTML embutida com Tailwind CSS
INDEX_HTML = """
<!DOCTYPE html>
<html lang="pt-BR">
<head>
    <title>Exclusão de Arquivos Duplicados v3.0</title>
    <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-gray-100">
    <div class="max-w-4xl mx-auto bg-white rounded-lg shadow-lg">
        <!-- Interface web responsiva -->
    </div>
</body>
</html>
"""

def calcular_hash(arquivo):
    """Detecção inteligente de duplicados baseada no conteúdo"""
    if arquivo.lower().endswith(('.png', '.jpeg', '.jpg')):
        # Para imagens: normalização e hash do conteúdo visual
        img = Image.open(arquivo)
        # Hash baseado no conteúdo visual, não metadados
    elif arquivo.lower().endswith('.pdf'):
        # Para PDFs: extração de texto e hash do conteúdo
        pdf = PdfReader(arquivo)
        # Hash baseado no texto extraído

Comparativo Detalhado: Versão 2.0 vs 3.0

Aspecto Versão 2.0 (Tkinter) Versão 3.0 (Flask/Web) Benefícios
Interface Desktop nativa (Tkinter) Web responsiva (HTML + CSS) Maior compatibilidade e usabilidade
Configuração Arquivo pex.lic obrigatório Seleção dinâmica de pasta Eliminação de dependências externas
Seleção de Arquivos Caminho fixo pré-configurado Botão "Selecionar Pasta" + entrada manual Flexibilidade total na escolha
Feedback Caixa de diálogo simples Interface dinâmica com loading Melhor experiência do usuário
Sistema de Logs Arquivo de texto básico Log detalhado com timestamp Rastreabilidade aprimorada
Detecção de Duplicados Hash SHA-256 básico Hash inteligente por tipo de arquivo Maior precisão na detecção
Compilação PyInstaller simples Script automatizado + assinatura digital Distribuição profissional e segura
Direitos Autorais Texto estático local Iframe para página oficial Informações sempre atualizadas

Principais Inovações da Versão 3.0 (Advanced Features)

Impacto Técnico e Operacional da Versão 3.0

A evolução para a versão 3.0 trouxe melhorias significativas para a operação da Igreja Renascer:

O QUE REALIZEI: Ciclo de Desenvolvimento Iterativo

COMPETÊNCIAS DESENVOLVIDAS: Hard Skills

SOFT SKILLS DESENVOLVIDAS: Habilidades Interpessoais Essenciais

Sobre as comunidades que a igreja atende e alcança: Impacto Social

CONCLUSÃO: Impacto e Evolução Contínua do Projeto

Impacto da Versão 2.0 (Projeto Original)

A igreja passou a ter um software desenvolvido por mim que automatiza suas tarefas, o que antes eles levavam de 6 a 8 horas para realizar agora realizam em alguns minutos com o novo software desenvolvido e distribuído de forma gratuita por mim.

Evolução para a Versão 3.0: Parceria Continuada

O sucesso da implementação inicial estabeleceu uma relação de confiança entre mim e a Igreja Renascer em Cristo. Após meses de uso eficiente da versão 2.0, a organização me contatou solicitando aprimoramentos no sistema. Este pedido demonstra:

Resultados Quantitativos e Qualitativos

Versão 2.0 (Tkinter - 2024)

  • Redução de tempo: de 6-8 horas para 5-10 minutos
  • Economia de tempo: ~95% de eficiência
  • Interface: Desktop nativa funcional
  • Dependências: Arquivo de configuração pex.lic

Versão 3.0 (Flask/Web - 2025)

  • Redução adicional de tempo: processo ainda mais otimizado
  • Economia de treinamento: interface intuitiva elimina curva de aprendizado
  • Interface: Web responsiva e moderna
  • Autonomia total: eliminação de dependências externas
  • Segurança aprimorada: assinatura digital e logs detalhados

Lições Aprendidas e Desenvolvimento Profissional

A evolução deste projeto proporcionou crescimento técnico e pessoal significativo:

Impacto Social Ampliado

Além dos benefícios operacionais diretos, o projeto teve impacto social ampliado:

Perspectivas Futuras

O projeto estabelece bases para futuras colaborações e desenvolvimentos:

Conclusão Final: O que iniciou como um projeto acadêmico evoluiu para uma parceria tecnológica contínua, demonstrando como soluções bem desenvolvidas podem gerar impacto duradouro e abrir caminhos para colaborações futuras. A versão 3.0 não apenas aprimora o software existente, mas consolida um relacionamento de confiança e inovação entre desenvolvedor e organização beneficiária.

Simulação de Processamento de Arquivos

Carregue múltiplos arquivos (PDF e PNG) abaixo para ver a simulação de remoção de duplicatas, similar à funcionalidade central do sistema de automação.

Arquivos Processados:

    LEI Nº 9.610/98
    Esta obra está protegida contra plágio e cópias indevidas pela Lei nº 9.610/98, a Lei de Direitos Autorais brasileira. Conforme o Art. 7º, inciso X, desta lei, estão protegidas as "obras de desenho, litografia ou arte aplicada", e por analogia, obras de desenvolvimento e propriedade intelectual, como projetos acadêmicos, teses, artigos e códigos-fonte, se enquadram na proteção conferida à criação do intelecto.