Update app.py

app.py

@@ -1,367 +1,310 @@
 import gradio as gr
 import pandas as pd
+import numpy as np
 import re
 import os
 import matplotlib.pyplot as plt
 from datetime import timedelta
 from fpdf import FPDF
 from weasyprint import HTML
-from PyPDF2 import PdfMerger
-import numpy as np
-
-def parse_duration(duration_str):
-    try:
-        h, m, s = map(int, duration_str.split(':'))
-        return timedelta(hours=h, minutes=m, seconds=s)
-    except:
-        return timedelta(0)
-
-def format_timedelta(td):
-    total_seconds = int(td.total_seconds())
-    hours, remainder = divmod(total_seconds, 3600)
-    minutes, seconds = divmod(remainder, 60)
-    return f"{hours:02}:{minutes:02}:{seconds:02}"
-
-def normalize_html_to_csv(input_html_path, output_csv_path):
-    html_data = pd.read_html(input_html_path)
-    data = html_data[0]
-    data.to_csv(output_csv_path, index=False, encoding='utf-8-sig')
-
-def normalize_multiple_excel_to_csv(input_directory, output_directory):
-    input_excel_paths = [os.path.join(input_directory, f) for f in os.listdir(input_directory) if f.endswith('.xlsx')]
-    output_csv_paths = [os.path.join(output_directory, os.path.splitext(f)[0] + '.csv') for f in os.listdir(input_directory) if f.endswith('.xlsx')]
-    for input_excel_path, output_csv_path in zip(input_excel_paths, output_csv_paths):
-        excel_data = pd.read_excel(input_excel_path)
-        unnecessary_columns = [col for col in excel_data.columns if 'Unnamed' in col]
-        if unnecessary_columns:
-            excel_data = excel_data.drop(columns=unnecessary_columns)
-        excel_data.to_csv(output_csv_path, index=False, encoding='utf-8-sig')
-
-def extract_aluno_pattern(nome):
-    if isinstance(nome, str):
-        match = re.search(r"(\d{8,9}-\w{2})", nome.lower())
-        return match.group(1) if match else None
-    return None
-
-def match_alunos(tarefas_csv_path, alunos_csv_path, contador_csv_path):
-    try:
-        tarefas_df = pd.read_csv(tarefas_csv_path, encoding='utf-8-sig')
-        alunos_df = pd.read_csv(alunos_csv_path, encoding='utf-8-sig')
-    except pd.errors.EmptyDataError:
-        print(f"Arquivo {tarefas_csv_path} ou {alunos_csv_path} está vazio. Pulando...")
-        return
-
-    tarefas_df.columns = tarefas_df.columns.str.strip()
-    alunos_df.columns = alunos_df.columns.str.strip()
-
-    if 'Aluno' not in tarefas_df.columns or 'Nota' not in tarefas_df.columns or 'Duração' not in tarefas_df.columns:
-        print(f"Colunas 'Aluno', 'Nota' ou 'Duração' não encontradas no arquivo {tarefas_csv_path}. Pulando este arquivo.")
-        return
+import seaborn as sns
+from typing import Tuple, Dict, List
+import logging
+import warnings
+warnings.filterwarnings('ignore')
+
+# Configuração de logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 
+class DataProcessor:
+    @staticmethod
+    def parse_duration(duration_str: str) -> timedelta:
+        """Converte string de duração em objeto timedelta."""
+        try:
+            h, m, s = map(int, duration_str.split(':'))
+            return timedelta(hours=h, minutes=m, seconds=s)
+        except:
+            return timedelta(0)
+
+    @staticmethod
+    def format_timedelta(td: timedelta) -> str:
+        """Formata timedelta para string no formato HH:MM:SS."""
+        total_seconds = int(td.total_seconds())
+        hours, remainder = divmod(total_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+        return f"{hours:02}:{minutes:02}:{seconds:02}"
+
+    @staticmethod
+    def normalize_html_to_csv(input_html_path: str, output_csv_path: str) -> None:
+        """Converte arquivo HTML para CSV."""
+        try:
+            html_data = pd.read_html(input_html_path)
+            data = html_data[0]
+            data.to_csv(output_csv_path, index=False, encoding='utf-8-sig')
+            logging.info(f"HTML normalizado com sucesso: {output_csv_path}")
+        except Exception as e:
+            logging.error(f"Erro ao normalizar HTML: {str(e)}")
+            raise
+
+    @staticmethod
+    def normalize_excel_to_csv(input_excel_path: str, output_csv_path: str) -> None:
+        """Converte arquivo Excel para CSV."""
+        try:
+            excel_data = pd.read_excel(input_excel_path)
+            unnecessary_columns = [col for col in excel_data.columns if 'Unnamed' in str(col)]
+            if unnecessary_columns:
+                excel_data = excel_data.drop(columns=unnecessary_columns)
+            excel_data.to_csv(output_csv_path, index=False, encoding='utf-8-sig')
+            logging.info(f"Excel normalizado com sucesso: {output_csv_path}")
+        except Exception as e:
+            logging.error(f"Erro ao normalizar Excel: {str(e)}")
+            raise
+
+class StudentAnalyzer:
+    def __init__(self, tarefas_df: pd.DataFrame, alunos_df: pd.DataFrame):
+        self.tarefas_df = tarefas_df
+        self.alunos_df = alunos_df
+        self.processor = DataProcessor()
+
+    def prepare_data(self) -> pd.DataFrame:
+        """Prepara e limpa os dados para análise."""
+        # Limpeza de colunas
+        self.tarefas_df.columns = self.tarefas_df.columns.str.strip()
+        self.alunos_df.columns = self.alunos_df.columns.str.strip()
+
+        # Verifica colunas necessárias
+        required_columns = ['Aluno', 'Nota', 'Duração']
+        if not all(col in self.tarefas_df.columns for col in required_columns):
+            raise ValueError("Colunas obrigatórias não encontradas no arquivo de tarefas")
+
+        # Processamento de duração
+        self.tarefas_df['Duração'] = self.tarefas_df['Duração'].apply(self.processor.parse_duration)
+
+        return self.match_students()
+
+    def match_students(self) -> pd.DataFrame:
+        """Relaciona dados de alunos com suas tarefas."""
+        def generate_aluno_pattern(ra, dig_ra):
+            ra_str = str(ra).zfill(9)
+            return f"{ra_str[1]}{ra_str[2:]}{dig_ra}-sp".lower()
+
+        self.alunos_df['Aluno_Pattern'] = self.alunos_df.apply(
+            lambda row: generate_aluno_pattern(row['RA'], row['Dig. RA']), axis=1
+        )
+
+        def extract_pattern(nome):
+            if isinstance(nome, str):
+                match = re.search(r'\d+.*', nome.lower())
+                return match.group(0) if match else None
+            return None
+
+        self.tarefas_df['Aluno_Pattern'] = self.tarefas_df['Aluno'].apply(extract_pattern)
+
+        return self.calculate_metrics()
+
+    def calculate_metrics(self) -> pd.DataFrame:
+        """Calcula métricas de desempenho dos alunos."""
+        metrics_df = pd.DataFrame()
+        
+        for _, aluno in self.alunos_df.iterrows():
+            aluno_pattern = aluno['Aluno_Pattern']
+            aluno_tarefas = self.tarefas_df[self.tarefas_df['Aluno_Pattern'] == aluno_pattern]
+            
+            if not aluno_tarefas.empty:
+                metrics = {
+                    'Nome do Aluno': aluno['Nome do Aluno'],
+                    'Tarefas Completadas': len(aluno_tarefas),
+                    'Acertos Absolutos': aluno_tarefas['Nota'].sum(),
+                    'Total Tempo': str(aluno_tarefas['Duração'].sum()),
+                    'Média de Acertos': f"{(aluno_tarefas['Nota'].sum() / (len(aluno_tarefas) * 2) * 100):.2f}%",
+                    'Tempo Médio por Tarefa': str(aluno_tarefas['Duração'].mean()),
+                    'Eficiência': f"{(aluno_tarefas['Nota'].sum() / aluno_tarefas['Duração'].sum().total_seconds() * 3600):.2f}"
+                }
+                metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True)
+
+        return metrics_df
+
+class ReportGenerator:
+    def __init__(self, data: pd.DataFrame):
+        self.data = data
+        self.stats = self.calculate_statistics()
+
+    def calculate_statistics(self) -> Dict:
+        """Calcula estatísticas gerais da turma."""
+        return {
+            'media_acertos': float(self.data['Média de Acertos'].str.rstrip('%').astype(float).mean()),
+            'desvio_padrao': float(self.data['Média de Acertos'].str.rstrip('%').astype(float).std()),
+            'mediana_acertos': float(self.data['Média de Acertos'].str.rstrip('%').astype(float).median()),
+            'total_alunos': len(self.data),
+            'media_tarefas': float(self.data['Tarefas Completadas'].mean()),
+            'media_tempo': str(pd.to_timedelta(self.data['Total Tempo']).mean())
+        }
+
+    def generate_graphs(self) -> List[plt.Figure]:
+        """Gera gráficos para o relatório."""
+        graphs = []
+        
+        # Distribuição de notas
+        plt.figure(figsize=(10, 6))
+        sns.histplot(data=self.data, x='Média de Acertos'.str.rstrip('%').astype(float), bins=10)
+        plt.axvline(self.stats['media_acertos'], color='r', linestyle='--', label=f'Média ({self.stats["media_acertos"]:.1f}%)')
+        plt.title('Distribuição das Notas')
+        plt.xlabel('Percentual de Acertos')
+        plt.ylabel('Número de Alunos')
+        plt.legend()
+        graphs.append(plt.gcf())
+        plt.close()
+
+        # Relação tempo x desempenho
+        plt.figure(figsize=(10, 6))
+        tempo_segundos = pd.to_timedelta(self.data['Total Tempo']).dt.total_seconds()
+        acertos = self.data['Média de Acertos'].str.rstrip('%').astype(float)
+        plt.scatter(tempo_segundos / 60, acertos)
+        plt.title('Tempo x Desempenho')
+        plt.xlabel('Tempo Total (minutos)')
+        plt.ylabel('Percentual de Acertos')
+        graphs.append(plt.gcf())
+        plt.close()
+
+        return graphs
+
+    def generate_pdf(self, output_path: str, graphs: List[plt.Figure]) -> None:
+        """Gera relatório em PDF."""
+        class PDF(FPDF):
+            def header(self):
+                self.set_font('Arial', 'B', 15)
+                self.cell(0, 10, 'Relatório de Desempenho - Análise Detalhada', 0, 1, 'C')
+                self.ln(10)
+
+        pdf = PDF('L', 'mm', 'A4')
+        
+        # Sumário executivo
+        pdf.add_page()
+        pdf.set_font('Arial', 'B', 12)
+        pdf.cell(0, 10, 'Sumário Executivo', 0, 1)
+        pdf.set_font('Arial', '', 10)
+        
+        summary_text = f"""
+        Análise da Turma:
+        • Média de Acertos: {self.stats['media_acertos']:.1f}%
+        • Desvio Padrão: {self.stats['desvio_padrao']:.1f}%
+        • Mediana: {self.stats['mediana_acertos']:.1f}%
+        • Número de Alunos: {self.stats['total_alunos']}
+        • Média de Tarefas por Aluno: {self.stats['media_tarefas']:.1f}
+        • Tempo Médio Total: {self.stats['media_tempo']}
+        """
+        pdf.multi_cell(0, 10, summary_text)
+
+        # Gráficos
+        for i, graph in enumerate(graphs):
+            pdf.add_page()
+            graph_path = f'temp_graph_{i}.png'
+            graph.savefig(graph_path)
+            pdf.image(graph_path, x=10, y=30, w=270)
+            os.remove(graph_path)
+
+        # Tabela de alunos
+        pdf.add_page()
+        pdf.set_font('Arial', 'B', 12)
+        pdf.cell(0, 10, 'Desempenho Individual', 0, 1)
+        
+        # Cabeçalhos
+        columns = ['Nome do Aluno', 'Média de Acertos', 'Tarefas', 'Tempo Total', 'Eficiência']
+        widths = [80, 30, 30, 30, 30]
+        pdf.set_font('Arial', 'B', 8)
+        for i, col in enumerate(columns):
+            pdf.cell(widths[i], 7, col, 1)
+        pdf.ln()
+
+        # Dados
+        pdf.set_font('Arial', '', 8)
+        for _, row in self.data.iterrows():
+            pdf.cell(widths[0], 6, str(row['Nome do Aluno'])[:40], 1)
+            pdf.cell(widths[1], 6, str(row['Média de Acertos']), 1)
+            pdf.cell(widths[2], 6, str(row['Tarefas Completadas']), 1)
+            pdf.cell(widths[3], 6, str(row['Total Tempo']), 1)
+            pdf.cell(widths[4], 6, str(row['Eficiência']), 1)
+            pdf.ln()
+
+        pdf.output(output_path)
+
+def process_files(html_file, excel_files) -> Tuple[str, str, str]:
+    """Processa arquivos e gera relatório."""
     try:
-        contador_df = pd.read_csv(contador_csv_path, encoding='utf-8-sig')
-    except FileNotFoundError:
-        contador_df = pd.DataFrame(columns=['Nome do Aluno', 'Tarefas Completadas', 'Acertos Absolutos', 'Total Tempo'])
-
-    if 'Tarefas Completadas' not in contador_df.columns:
-        contador_df['Tarefas Completadas'] = 0
-    if 'Acertos Absolutos' not in contador_df.columns:
-        contador_df['Acertos Absolutos'] = 0
-    if 'Total Tempo' not in contador_df.columns:
-        contador_df['Total Tempo'] = '00:00:00'
-
-    def generate_aluno_pattern(ra, dig_ra):
-        ra_str = str(ra).zfill(9)
-        ra_without_first_two_digits = ra_str[2:]
-        return f"{ra_str[1]}{ra_without_first_two_digits}{dig_ra}-sp".lower()
-
-    alunos_df['Aluno_Pattern'] = alunos_df.apply(lambda row: generate_aluno_pattern(row['RA'], row['Dig. RA']), axis=1)
-
-    def extract_aluno_pattern(nome):
-        if isinstance(nome, str):
-            match = re.search(r'\d+.*', nome.lower())
-            return match.group(0) if match else None
-        return None
-
-    tarefas_df['Aluno_Pattern'] = tarefas_df['Aluno'].apply(extract_aluno_pattern)
-    tarefas_df['Duração'] = tarefas_df['Duração'].apply(parse_duration)
-
-    matched_alunos = alunos_df[alunos_df['Aluno_Pattern'].isin(tarefas_df['Aluno_Pattern'])]
-
-    result_df = matched_alunos[['Nome do Aluno']].drop_duplicates()
-
-    for aluno in result_df['Nome do Aluno']:
-        aluno_pattern = alunos_df.loc[alunos_df['Nome do Aluno'] == aluno, 'Aluno_Pattern'].values[0]
-        aluno_tarefas = tarefas_df[tarefas_df['Aluno_Pattern'] == aluno_pattern]
-        nota_total = aluno_tarefas['Nota'].sum()
-        tempo_total = aluno_tarefas['Duração'].sum()
-
-        if aluno in contador_df['Nome do Aluno'].values:
-            contador_df.loc[contador_df['Nome do Aluno'] == aluno, 'Tarefas Completadas'] += 1
-            contador_df.loc[contador_df['Nome do Aluno'] == aluno, 'Acertos Absolutos'] += nota_total
-            current_total_tempo = pd.to_timedelta(contador_df.loc[contador_df['Nome do Aluno'] == aluno, 'Total Tempo'].values[0])
-            contador_df.loc[contador_df['Nome do Aluno'] == aluno, 'Total Tempo'] = str(current_total_tempo + tempo_total)
-        else:
-            contador_df = pd.concat([contador_df, pd.DataFrame({'Nome do Aluno': [aluno], 'Tarefas Completadas': [1], 'Acertos Absolutos': [nota_total], 'Total Tempo': [str(tempo_total)]})], ignore_index=True)
-
-    contador_df.to_csv(contador_csv_path, index=False, encoding='utf-8-sig')
-
-    return result_df
-
-def remove_outliers(data, column, threshold=3):
-    mean = data[column].mean()
-    std = data[column].std()
-    return data[(data[column] > mean - threshold * std) & (data[column] < mean + threshold * std)]
-
-def process_all_tarefas_in_directory(directory, alunos_csv_path, contador_csv_path, relatorio_csv_path):
-    tarefas_files = [os.path.join(directory, f) for f in os.listdir(directory) if f.endswith('.csv') and f not in ['alunos_fim.csv', 'contador_tarefas.csv']]
-
-    for i, tarefas_file in enumerate(tarefas_files):
-        match_alunos(tarefas_file, alunos_csv_path, contador_csv_path)
-
-    process_relatorios(contador_csv_path, relatorio_csv_path)
-
-def process_relatorios(contador_csv_path, relatorio_csv_path):
-    contador_df = pd.read_csv(contador_csv_path, encoding='utf-8-sig')
-    contador_df['Média de Acertos'] = ((contador_df['Acertos Absolutos'] / (contador_df['Tarefas Completadas'] * 2)) * 100).round(2).astype(str) + '%'
-    contador_df['Total Tempo'] = pd.to_timedelta(contador_df['Total Tempo'])
-    contador_df['Tempo Médio por Tarefa'] = contador_df['Total Tempo'] / contador_df['Tarefas Completadas']
-    contador_df['Total Tempo'] = contador_df['Total Tempo'].apply(format_timedelta)
-    contador_df['Tempo Médio por Tarefa'] = contador_df['Tempo Médio por Tarefa'].apply(format_timedelta)
-    contador_df = contador_df.sort_values(by='Nome do Aluno', ascending=True)
-
-    # Remove outliers e calcula o tempo médio por tarefa da turma
-    tempo_medio_por_tarefa = pd.to_timedelta(contador_df['Tempo Médio por Tarefa'])
-    tempo_medio_por_tarefa = remove_outliers(pd.DataFrame({'Tempo Médio por Tarefa': tempo_medio_por_tarefa}), 'Tempo Médio por Tarefa')
-    media_tempo_medio_turma = tempo_medio_por_tarefa['Tempo Médio por Tarefa'].mean()
-    media_tempo_medio_turma = format_timedelta(media_tempo_medio_turma)
-
-    # Calcula médias gerais da turma
-    media_acertos_turma = (contador_df['Acertos Absolutos'] / (contador_df['Tarefas Completadas'] * 2)).mean() * 100
-    media_tarefas_turma = contador_df['Tarefas Completadas'].mean()
-
-    contador_df.to_csv(relatorio_csv_path, index=False, encoding='utf-8-sig')
-    return contador_df, media_tempo_medio_turma, media_acertos_turma, media_tarefas_turma
-
-def generate_pdf_report(dataframe, media_tempo_medio_turma, media_acertos_turma, media_tarefas_turma, html_path, output_pdf_path):
-    class PDF(FPDF):
-        def header(self):
-            self.set_font('Arial', 'B', 12)
-            self.cell(0, 10, 'Relatório de Tarefas', 0, 1, 'C')
-
-        def footer(self):
-            self.set_y(-15)
-            self.set_font('Arial', 'I', 8)
-            self.cell(0, 10, f'Page {self.page_no()}', 0, 0, 'C')
-
-        def add_image(self, image_path):
-            self.add_page()
-            self.image(image_path, x=10, y=10, w=270)
-
-    pdf = PDF(orientation='L', unit='mm', format='A4')
-
-    # Gerar gráficos e adicionar ao PDF
-    def add_bar_labels(bars, labels):
-        for bar, label in zip(bars, labels):
-            height = bar.get_height()
-            plt.annotate(f'{label}', 
-                         xy=(bar.get_x() + bar.get_width() / 2, height), 
-                         xytext=(0, 3),  # 3 points vertical offset
-                         textcoords="offset points",
-                         ha='center', va='bottom')
-
-    top_students = dataframe.nlargest(5, 'Acertos Absolutos')
-    
-    plt.figure(figsize=(10, 6))
-    bars = plt.bar(top_students['Nome do Aluno'], top_students['Acertos Absolutos'], color='blue')
-    plt.xlabel('Nome do Aluno')
-    plt.ylabel('Acertos Absolutos')
-    plt.title('Top 5 Alunos - Acertos Absolutos')
-    plt.xticks(rotation=45, ha='right')
-    add_bar_labels(bars, top_students['Acertos Absolutos'])
-    plt.tight_layout()
-    graph_path = 'top_5_acertos_absolutos.png'
-    plt.savefig(graph_path)
-    pdf.add_image(graph_path)
-
-    plt.figure(figsize=(10, 6))
-    bars = plt.bar(top_students['Nome do Aluno'], top_students['Média de Acertos'].str.rstrip('%').astype('float'), color='green')
-    plt.xlabel('Nome do Aluno')
-    plt.ylabel('Percentual de Acertos (%)')
-    plt.title('Top 5 Alunos - Percentual de Acertos')
-    plt.xticks(rotation=45, ha='right')
-    add_bar_labels(bars, top_students['Média de Acertos'].str.rstrip('%').astype('float'))
-    plt.tight_layout()
-    graph_path = 'top_5_percentual_acertos.png'
-    plt.savefig(graph_path)
-    pdf.add_image(graph_path)
-
-    plt.figure(figsize=(10, 6))
-    bars = plt.bar(top_students['Nome do Aluno'], top_students['Tarefas Completadas'], color='red')
-    plt.xlabel('Nome do Aluno')
-    plt.ylabel('Tarefas Completadas')
-    plt.title('Top 5 Alunos - Tarefas Completadas')
-    plt.xticks(rotation=45, ha='right')
-    add_bar_labels(bars, top_students['Tarefas Completadas'])
-    plt.tight_layout()
-    graph_path = 'top_5_tarefas_completadas.png'
-    plt.savefig(graph_path)
-    pdf.add_image(graph_path)
-
-    # Adiciona gráfico de alunos que passam mais tempo fazendo as tarefas
-    dataframe['Total Tempo'] = pd.to_timedelta(dataframe['Total Tempo'])
-    top_time_students = dataframe.nlargest(5, 'Total Tempo')
-    plt.figure(figsize=(10, 6))
-    bars = plt.bar(top_time_students['Nome do Aluno'], top_time_students['Total Tempo'].dt.total_seconds(), color='purple')
-    plt.xlabel('Nome do Aluno')
-    plt.ylabel('Tempo Total (hh:mm:ss)')
-    plt.title('Top 5 Alunos - Tempo Total')
-    plt.xticks(rotation=45, ha='right')
-    add_bar_labels(bars, top_time_students['Total Tempo'].apply(format_timedelta))
-    plt.tight_layout()
-    graph_path = 'top_5_tempo_total.png'
-    plt.savefig(graph_path)
-    pdf.add_image(graph_path)
-
-    # Adiciona gráfico de resumo da turma
-    metrics = ['Tempo Médio (hh:mm:ss)', 'Média de Acertos (%)', 'Média de Tarefas']
-    values = [media_tempo_medio_turma, media_acertos_turma, media_tarefas_turma]
-
-    # Convertendo os valores para strings apropriadas
-    values_str = [media_tempo_medio_turma, f"{media_acertos_turma:.2f}", f"{media_tarefas_turma:.2f}"]
-
-    plt.figure(figsize=(10, 6))
-    bars = plt.bar(metrics, values_str, color=['blue', 'green', 'red'])
-    plt.xlabel('Métricas')
-    plt.ylabel('Valores')
-    plt.title('Resumo da Turma')
-    plt.xticks(rotation=45, ha='right')
-    for bar, value in zip(bars, values_str):
-        plt.annotate(f'{value}', 
-                     xy=(bar.get_x() + bar.get_width() / 2, bar.get_height()), 
-                     xytext=(0, 3),  # 3 points vertical offset
-                     textcoords="offset points",
-                     ha='center', va='bottom')
-    plt.tight_layout()
-    graph_path = 'resumo_turma.png'
-    plt.savefig(graph_path)
-    pdf.add_image(graph_path)
-
-    # Salvar o PDF com os gráficos
-    temp_graphics_pdf = 'temp_graphics.pdf'
-    pdf.output(temp_graphics_pdf)
-
-    # Estilo personalizado para bordas da tabela
-    html_style = """
-    <style>
-    .dataframe {
-        border-collapse: collapse;
-        width: 100%;
-    }
-    .dataframe th, .dataframe td {
-        border: 1px solid black;
-        padding: 8px;
-        text-align: left;
-    }
-    </style>
-    """
-
-    # Ler o conteúdo HTML e adicionar o estilo personalizado
-    with open(html_path, 'r', encoding='utf-8-sig') as f:
-        html_content = f.read()
-    
-    html_content = html_style + html_content
-
-    temp_html_path = 'temp_html_with_borders.html'
-    with open(temp_html_path, 'w', encoding='utf-8-sig') as f:
-        f.write(html_content)
-
-    temp_html_pdf = 'temp_html.pdf'
-    HTML(temp_html_path).write_pdf(temp_html_pdf)
-
-    # Combinar os PDFs
-    merger = PdfMerger()
-    merger.append(temp_html_pdf)
-    merger.append(temp_graphics_pdf)
-    merger.write(output_pdf_path)
-    merger.close()
-
-    # Remover arquivos temporários
-    os.remove(temp_graphics_pdf)
-    os.remove(temp_html_pdf)
-    os.remove(temp_html_path)
-
-def processar_relatorio(html_file, tarefa_files):
-    input_directory = "temp_files"  # Diretório temporário para os arquivos
-    output_directory = "temp_files"
-
-    os.makedirs(input_directory, exist_ok=True)
-    os.makedirs(output_directory, exist_ok=True)
-
-    # Limpa o diretório temporário antes de cada execução (opcional, mas recomendado)
-    for filename in os.listdir(input_directory):
-        file_path = os.path.join(input_directory, filename)
-        if os.path.isfile(file_path):
-            os.remove(file_path)
-
-    # Salva os arquivos enviados
-    html_path = os.path.join(input_directory, "alunos.htm")
-    with open(html_path, "wb") as f:
-        f.write(html_file)
-
-    for idx, tarefa_file in enumerate(tarefa_files):
-        tarefa_path = os.path.join(input_directory, f"tarefa_{idx}.xlsx")
-        with open(tarefa_path, "wb") as f:
-            f.write(tarefa_file)
-
-    # Normaliza os arquivos
-    alunos_csv_path = os.path.join(output_directory, "alunos_fim.csv")
-    normalize_html_to_csv(html_path, alunos_csv_path)
-    normalize_multiple_excel_to_csv(input_directory, output_directory)
-
-    # Processa os dados e gera o relatório
-    contador_csv_path = os.path.join(output_directory, "contador_tarefas.csv")
-    relatorio_csv_path = os.path.join(output_directory, "relatorio_final.csv")
-    process_all_tarefas_in_directory(output_directory, alunos_csv_path, contador_csv_path, relatorio_csv_path)
-    df, media_tempo_medio_turma, media_acertos_turma, media_tarefas_turma = process_relatorios(contador_csv_path, relatorio_csv_path)
-
-    # Salva o relatório em HTML e PDF
-    html_output_path = os.path.join(output_directory, "relatorio_final.html")
-    df.to_html(html_output_path, index=False, encoding='utf-8-sig')
-    
-    pdf_output_path = os.path.join(output_directory, "relatorio_final.pdf")
-    generate_pdf_report(df, media_tempo_medio_turma, media_acertos_turma, media_tarefas_turma, html_output_path, pdf_output_path)
-
-    return df.to_html(index=False), html_output_path, pdf_output_path
-
-# Tema personalizado
+        # Criar diretório temporário
+        temp_dir = "temp_files"
+        os.makedirs(temp_dir, exist_ok=True)
+
+        # Limpar diretório temporário
+        for file in os.listdir(temp_dir):
+            os.remove(os.path.join(temp_dir, file))
+
+        # Salvar arquivos
+        html_path = os.path.join(temp_dir, "alunos.htm")
+        with open(html_path, "wb") as f:
+            f.write(html_file)
+
+        excel_paths = []
+        for i, excel_file in enumerate(excel_files):
+            excel_path = os.path.join(temp_dir, f"tarefa_{i}.xlsx")
+            with open(excel_path, "wb") as f:
+                f.write(excel_file)
+            excel_paths.append(excel_path)
+
+        # Processar arquivos
+        processor = DataProcessor()
+        alunos_csv_path = os.path.join(temp_dir, "alunos.csv")
+        processor.normalize_html_to_csv(html_path, alunos_csv_path)
+
+        tarefas_df = pd.DataFrame()
+        for excel_path in excel_paths:
+            csv_path = excel_path.replace('.xlsx', '.csv')
+            processor.normalize_excel_to_csv(excel_path, csv_path)
+            df = pd.read_csv(csv_path)
+            tarefas_df = pd.concat([tarefas_df, df], ignore_index=True)
+
+        # Análise
+        alunos_df = pd.read_csv(alunos_csv_path)
+        analyzer = StudentAnalyzer(tarefas_df, alunos_df)
+        results_df = analyzer.prepare_data()
+
+        # Gerar relatório
+        report_generator = ReportGenerator(results_df)
+        graphs = report_generator.generate_graphs()
+        
+        # Salvar outputs
+        output_html = os.path.join(temp_dir, "relatorio.html")
+        output_pdf = os.path.join(temp_dir, "relatorio.pdf")
+        results_df.to_html(output_html, index=False)
+        report_generator.generate_pdf(output_pdf, graphs)
+
+        return results_df.to_html(index=False), output_html, output_pdf
+
+    except Exception as e:
+        logging.error(f"Erro no processamento: {str(e)}")
+        raise
+
+# Interface Gradio
 theme = gr.themes.Default(
-    primary_hue="blue",  # Cor principal (tons de azul)
-    secondary_hue="gray",  # Cor secundária (tons de cinza)
-    font=["Arial", "sans-serif"],  # Família de fontes
-    font_mono=["Courier New", "monospace"],  # Fonte para código
+    primary_hue="blue",
+    secondary_hue="gray",
+    font=["Arial", "sans-serif"],
+    font_mono=["Courier New", "monospace"],
 )
 
-# --- Interface Gradio ---
 with gr.Blocks(theme=theme) as interface:
-    gr.Markdown("# Processamento de Relatórios de Tarefas")
+    gr.Markdown("# Sistema de Análise de Desempenho Acadêmico")
+    
     with gr.Row():
         with gr.Column():
-            gr.Markdown("## Arquivo HTML (alunos.htm)")
-            html_file = gr.File(label="Arraste o arquivo .htm aqui", type="binary")
+            gr.Markdown("## Lista de Alunos (arquivo .htm)")
+            html_file = gr.File(label="Upload do arquivo HTML", type="binary")
+        
         with gr.Column():
-            gr.Markdown("## Arquivos Excel (Relatórios de Tarefas)")
-            excel_files = gr.Files(label="Arraste os arquivos .xlsx aqui", type="binary", file_count="multiple")
-
-    generate_btn = gr.Button("Gerar Relatório", variant="primary")  # Destaque no botão
-    output_html = gr.HTML()
-    download_html_btn = gr.File(label="Download HTML Report")
-    download_pdf_btn = gr.File(label="Download PDF Report")
-
-    def wrapper(html_file, excel_files):
-        html_content, html_path, pdf_path = processar_relatorio(html_file, excel_files)
-        return html_content, html_path, pdf_path
-
-    generate_btn.click(fn=wrapper, inputs=[html_file, excel_files], outputs=[output_html, download_html_btn, download_pdf_btn])
+            gr.Markdown("## Relatórios de Tarefas (arquivos .xlsx)")
+            excel_files = gr.Files(label="Upload dos arquivos Excel", type="binary", file_count="multiple")
 
-interface.launch()
+    generate_btn = gr.Button("