🌱 Miniprojeto 10: Catalogador de Arquivos & Backups

import os
import shutil
from datetime import datetime

def catalogar_pasta(pasta_origem):
    if not os.path.exists(pasta_origem):
        return []
    arquivos = []
    for item in os.listdir(pasta_origem):
        caminho_completo = os.path.join(pasta_origem, item)
        if os.path.isfile(caminho_completo):
            tamanho = os.path.getsize(caminho_completo)
            arquivos.append({"nome": item, "caminho": caminho_completo, "tamanho_bytes": tamanho})
    return arquivos

def executar_backup(pasta_origem, pasta_destino, caminho_log="backup_log.txt"):
    arquivos = catalogar_pasta(pasta_origem)
    os.makedirs(pasta_destino, exist_ok=True)
    total_bytes = 0
    with open(caminho_log, "a", encoding="utf-8") as f_log:
        f_log.write(f"=== BACKUP: {datetime.now()} ===\n")
        for arq in arquivos:
            shutil.copy2(arq["caminho"], os.path.join(pasta_destino, arq["nome"]))
            total_bytes += arq["tamanho_bytes"]
            f_log.write(f" - {arq['nome']} ({arq['tamanho_bytes']} bytes)\n")
    return len(arquivos), total_bytes

"""
Testes Unitários para o Degrau 1 do Projeto 10 (Imperativo & OS/Shutil)
"""

import os
import shutil
import unittest
from main import (
    catalogar_pasta,
    executar_backup,
    formatar_tamanho
)

PASTA_ORIGEM_TESTE = "teste_origem_temp"
PASTA_DESTINO_TESTE = "teste_destino_temp"
ARQUIVO_LOG_TESTE = "teste_backup_log.txt"


class TestDegrau1Backup(unittest.TestCase):

    def setUp(self):
        os.makedirs(PASTA_ORIGEM_TESTE, exist_ok=True)
        if os.path.exists(PASTA_DESTINO_TESTE):
            shutil.rmtree(PASTA_DESTINO_TESTE)
        if os.path.exists(ARQUIVO_LOG_TESTE):
            os.remove(ARQUIVO_LOG_TESTE)

        # Cria arquivos fictícios para backup
        with open(os.path.join(PASTA_ORIGEM_TESTE, "contrato_01.pdf"), "w") as f:
            f.write("Conteudo do contrato 01")
        with open(os.path.join(PASTA_ORIGEM_TESTE, "nfe_1020.xml"), "w") as f:
            f.write("Conteudo do xml da nota fiscal")

    def tearDown(self):
        if os.path.exists(PASTA_ORIGEM_TESTE):
            shutil.rmtree(PASTA_ORIGEM_TESTE)
        if os.path.exists(PASTA_DESTINO_TESTE):
            shutil.rmtree(PASTA_DESTINO_TESTE)
        if os.path.exists(ARQUIVO_LOG_TESTE):
            os.remove(ARQUIVO_LOG_TESTE)

    def test_catalogacao_e_backup(self):
        arquivos = catalogar_pasta(PASTA_ORIGEM_TESTE)
        self.assertEqual(len(arquivos), 2)

        total_copiados, total_bytes = executar_backup(PASTA_ORIGEM_TESTE, PASTA_DESTINO_TESTE, caminho_log=ARQUIVO_LOG_TESTE)
        self.assertEqual(total_copiados, 2)
        self.assertGreater(total_bytes, 0)

        # Verifica se os arquivos foram realmente copiados para o destino
        self.assertTrue(os.path.exists(os.path.join(PASTA_DESTINO_TESTE, "contrato_01.pdf")))
        self.assertTrue(os.path.exists(os.path.join(PASTA_DESTINO_TESTE, "nfe_1020.xml")))

        # Verifica criação do log
        self.assertTrue(os.path.exists(ARQUIVO_LOG_TESTE))


if __name__ == "__main__":
    unittest.main()

class ArquivoInfo:
    def __init__(self, caminho, nome, tamanho_bytes):
        self.caminho = caminho
        self.nome = nome
        self.tamanho_bytes = int(tamanho_bytes)

    def tamanho_formatado(self):
        if self.tamanho_bytes < 1024:
            return f"{self.tamanho_bytes} B"
        elif self.tamanho_bytes < 1024 * 1024:
            return f"{self.tamanho_bytes / 1024:.2f} KB"
        return f"{self.tamanho_bytes / (1024 * 1024):.2f} MB"

class GerenciadorBackup:
    def __init__(self, pasta_origem, pasta_destino):
        self.pasta_origem = pasta_origem
        self.pasta_destino = pasta_destino
        self.arquivos = []

    def escanear(self):
        self.arquivos.clear()
        for item in os.listdir(self.pasta_origem):
            p = os.path.join(self.pasta_origem, item)
            if os.path.isfile(p):
                self.arquivos.append(ArquivoInfo(p, item, os.path.getsize(p)))
        return self.arquivos

"""
Testes Unitários para o Degrau 2 do Projeto 10 (Primeira Classe POO)
"""

import os
import shutil
import unittest
from main import ArquivoInfo, GerenciadorBackup

PASTA_ORIGEM_TESTE = "teste_poo_origem"
PASTA_DESTINO_TESTE = "teste_poo_destino"


class TestDegrau2Backup(unittest.TestCase):

    def setUp(self):
        os.makedirs(PASTA_ORIGEM_TESTE, exist_ok=True)
        if os.path.exists(PASTA_DESTINO_TESTE):
            shutil.rmtree(PASTA_DESTINO_TESTE)

        with open(os.path.join(PASTA_ORIGEM_TESTE, "doc1.txt"), "w") as f:
            f.write("A" * 2048)  # 2 KB
        with open(os.path.join(PASTA_ORIGEM_TESTE, "doc2.txt"), "w") as f:
            f.write("B" * 512)   # 512 Bytes

    def tearDown(self):
        if os.path.exists(PASTA_ORIGEM_TESTE):
            shutil.rmtree(PASTA_ORIGEM_TESTE)
        if os.path.exists(PASTA_DESTINO_TESTE):
            shutil.rmtree(PASTA_DESTINO_TESTE)

    def test_classe_arquivo_info(self):
        a1 = ArquivoInfo("/caminho/doc.txt", "doc.txt", 1024)
        self.assertEqual(a1.tamanho_formatado(), "1.00 KB")

        a2 = ArquivoInfo("/caminho/foto.jpg", "foto.jpg", 2 * 1024 * 1024)
        self.assertEqual(a2.tamanho_formatado(), "2.00 MB")

    def test_gerenciador_backup_execucao(self):
        ger = GerenciadorBackup(PASTA_ORIGEM_TESTE, PASTA_DESTINO_TESTE)
        arqs = ger.escanear()
        self.assertEqual(len(arqs), 2)
        self.assertEqual(ger.volume_total_bytes(), 2560)

        copiados, total_b = ger.executar_backup()
        self.assertEqual(copiados, 2)
        self.assertEqual(total_b, 2560)
        self.assertTrue(os.path.exists(os.path.join(PASTA_DESTINO_TESTE, "doc1.txt")))


if __name__ == "__main__":
    unittest.main()

import sqlite3

def inicializar_tabelas(caminho="backup.db"):
    conn = sqlite3.connect(caminho)
    conn.execute("PRAGMA foreign_keys = ON;")
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS execucoes_backup (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            pasta_origem TEXT NOT NULL,
            pasta_destino TEXT NOT NULL,
            total_arquivos INTEGER NOT NULL,
            total_bytes INTEGER NOT NULL,
            status TEXT DEFAULT 'SUCESSO',
            data_execucao TEXT DEFAULT (datetime('now', 'localtime'))
        )
    """)
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS arquivos_backup (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            backup_id INTEGER NOT NULL,
            nome_arquivo TEXT NOT NULL,
            tamanho_bytes INTEGER NOT NULL,
            FOREIGN KEY (backup_id) REFERENCES execucoes_backup(id) ON DELETE CASCADE
        )
    """)
    conn.commit()
    conn.close()

"""
Testes Unitários para o Degrau 3 do Projeto 10 (SQLite3 Relacional com Auditoria)
"""

import os
import shutil
import unittest
from main import (
    executar_backup_e_gravar,
    inicializar_tabelas,
    listar_historico_backups,
    obter_metricas_gerais
)

PASTA_ORIGEM_TESTE = "teste_sql_origem"
PASTA_DESTINO_TESTE = "teste_sql_destino"
BANCO_TESTE = "teste_backup_degrau3.db"


class TestDegrau3SQLite(unittest.TestCase):

    def setUp(self):
        os.makedirs(PASTA_ORIGEM_TESTE, exist_ok=True)
        if os.path.exists(PASTA_DESTINO_TESTE):
            shutil.rmtree(PASTA_DESTINO_TESTE)
        if os.path.exists(BANCO_TESTE):
            os.remove(BANCO_TESTE)

        inicializar_tabelas(caminho=BANCO_TESTE)

        # Arquivos de teste
        with open(os.path.join(PASTA_ORIGEM_TESTE, "balanco_2026.xlsx"), "w") as f:
            f.write("A" * 4096)
        with open(os.path.join(PASTA_ORIGEM_TESTE, "folha_pagamento.pdf"), "w") as f:
            f.write("B" * 2048)

    def tearDown(self):
        if os.path.exists(PASTA_ORIGEM_TESTE):
            shutil.rmtree(PASTA_ORIGEM_TESTE)
        if os.path.exists(PASTA_DESTINO_TESTE):
            shutil.rmtree(PASTA_DESTINO_TESTE)
        if os.path.exists(BANCO_TESTE):
            os.remove(BANCO_TESTE)

    def test_execucao_e_auditoria_sqlite(self):
        b_id = executar_backup_e_gravar(PASTA_ORIGEM_TESTE, PASTA_DESTINO_TESTE, caminho_db=BANCO_TESTE)
        self.assertIsNotNone(b_id)

        # Métricas
        m = obter_metricas_gerais(caminho_db=BANCO_TESTE)
        self.assertEqual(m["total_backups"], 1)
        self.assertEqual(m["total_arquivos"], 2)
        self.assertEqual(m["volume_geral_bytes"], 6144)

        # Histórico
        hist = listar_historico_backups(caminho_db=BANCO_TESTE)
        self.assertEqual(len(hist), 1)
        self.assertEqual(hist[0][3], 2)  # total_arquivos


if __name__ == "__main__":
    unittest.main()

import tkinter as tk
from tkinter import filedialog, messagebox, ttk

class AppBackup:
    def __init__(self, root):
        self.root = root
        self.root.title("💾 Catalogador de Arquivos & Backups (Degrau 4)")
        self.root.geometry("760x650")
        self.criar_widgets()
        self.recarregar_dados()

"""
Hub Central / Launcher — Miniprojeto 10: Catalogador de Arquivos & Gerenciador de Backups
Permite executar de forma autoguiada qualquer um dos 4 degraus pedagógicos ou rodar a suíte de testes.
"""

import os
import subprocess
import sys

BASE_DIR = os.path.dirname(os.path.abspath(__file__))


def rodar_script(caminho_relativo):
    caminho_absoluto = os.path.join(BASE_DIR, caminho_relativo)
    diretorio = os.path.dirname(caminho_absoluto)
    print(f"\n🚀 Executando: {caminho_relativo}...\n")
    try:
        subprocess.run([sys.executable, caminho_absoluto], cwd=diretorio, check=True)
    except KeyboardInterrupt:
        print("\n\n⏹️ Execucao interrompida pelo usuario.")
    except Exception as e:
        print(f"\n❌ Erro durante a execucao: {e}")


def rodar_todos_os_testes():
    print("\n🧪 ========================================================")
    print("   RODANDO A SUÍTE DE TESTES DOS DEGRAUS 1, 2 E 3")
    print("========================================================\n")
    testes = [
        ("Degrau 1 (Imperativo & Arquivo TXT)", "degrau_1_imperativo_txt/test_degrau_1.py"),
        ("Degrau 2 (Primeira Classe POO)", "degrau_2_primeira_classe/test_degrau_2.py"),
        ("Degrau 3 (Banco SQLite3 Relacional)", "degrau_3_sqlite/test_degrau_3.py"),
    ]
    for nome, arq in testes:
        print(f"▶️ Testando {nome}...")
        caminho_abs = os.path.join(BASE_DIR, arq)
        diretorio = os.path.dirname(caminho_abs)
        res = subprocess.run([sys.executable, caminho_abs], cwd=diretorio)
        if res.returncode == 0:
            print(f"✅ {nome}: PASSOU!\n")
        else:
            print(f"❌ {nome}: FALHOU!\n")


def menu_hub():
    while True:
        print("\n========================================================")
        print("💾 MINIPROJETO 10: CATALOGADOR & BACKUP DE ARQUIVOS (HUB)")
        print("========================================================")
        print("1. 🪜 Executar Degrau 1 (Imperativo & Log .txt com os/shutil)")
        print("2. 🪜 Executar Degrau 2 (Primeira Classe POO: ArquivoInfo e GerenciadorBackup)")
        print("3. 🪜 Executar Degrau 3 (Banco de Dados SQLite3 com Auditoria)")
        print("4. 🪜 Executar Degrau 4 (Interface Desktop Visual com Progressbar)")
        print("5. 🧪 Rodar Todos os Testes Automatizados (Degraus 1, 2 e 3)")
        print("6. 🚪 Sair")
        print("========================================================")
        opcao = input("Escolha o degrau que deseja executar (1-6): ").strip()

        if opcao == "1":
            rodar_script("degrau_1_imperativo_txt/main.py")
        elif opcao == "2":
            rodar_script("degrau_2_primeira_classe/main.py")
        elif opcao == "3":
            rodar_script("degrau_3_sqlite/main.py")
        elif opcao == "4":
            rodar_script("degrau_4_interface_customtkinter/main.py")
        elif opcao == "5":
            rodar_todos_os_testes()
        elif opcao == "6":
            print("👋 Encerrando o launcher. Parabéns por concluir os 10 miniprojetos!")
            break
        else:
            print("❌ Opcao invalida. Digite de 1 a 6.")


if __name__ == "__main__":
    menu_hub()