Update app.py

app.py

@@ -6,13 +6,13 @@ import os
 import matplotlib.pyplot as plt
 from datetime import timedelta
 from fpdf import FPDF
-from weasyprint import HTML
 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'
@@ -32,7 +32,11 @@ class DataProcessor:
         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}"
+        if hours > 0:
+            return f"{hours}h {minutes}min {seconds}s"
+        elif minutes > 0:
+            return f"{minutes}min {seconds}s"
+        return f"{seconds}s"
 
     @staticmethod
     def normalize_html_to_csv(input_html_path: str, output_csv_path: str) -> None:
@@ -95,38 +99,32 @@ class StudentAnalyzer:
 
     def calculate_metrics(self) -> pd.DataFrame:
         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:
                 duracao_total = aluno_tarefas['Duração'].sum()
                 acertos_total = aluno_tarefas['Nota'].sum()
-            
-                # Calcula eficiência como float diretamente
-                eficiencia = (acertos_total / duracao_total.total_seconds() * 3600)
-            
+                
                 metrics = {
                     'Nome do Aluno': aluno['Nome do Aluno'],
                     'Tarefas Completadas': len(aluno_tarefas),
                     'Acertos Absolutos': acertos_total,
                     'Total Tempo': str(duracao_total),
                     'Tempo Médio por Tarefa': str(duracao_total / len(aluno_tarefas)),
-                    'Eficiência': eficiencia  # Armazena como float, não como string
+                    'Eficiência': (acertos_total / duracao_total.total_seconds() * 3600)
                 }
                 metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True)
-            
-        # Converte explicitamente a coluna Eficiência para float
-        metrics_df['Eficiência'] = metrics_df['Eficiência'].astype(float)
-        return metrics_df
+
+        return metrics_df.sort_values('Acertos Absolutos', ascending=False)
 
 class ReportGenerator:
     def __init__(self, data: pd.DataFrame):
         self.data = data
         self.stats = self.calculate_statistics()
         self.data['Nível'] = self.data['Acertos Absolutos'].apply(self.classify_performance)
-        self.data = self.data.sort_values('Acertos Absolutos', ascending=False)
 
     def classify_performance(self, acertos):
         if acertos >= 10:
@@ -146,8 +144,10 @@ class ReportGenerator:
             'media_tempo': str(pd.to_timedelta(self.data['Total Tempo']).mean())
         }
 
-        top_students = self.data.nlargest(3, 'Acertos Absolutos')
-        basic_stats['top_performers'] = top_students[['Nome do Aluno', 'Acertos Absolutos']].values.tolist()
+        top_students = self.data.nlargest(3, 'Acertos Absolutos')[
+            ['Nome do Aluno', 'Acertos Absolutos']
+        ].values.tolist()
+        basic_stats['top_performers'] = top_students
 
         efficient_students = self.data.nlargest(3, 'Eficiência')[
             ['Nome do Aluno', 'Eficiência', 'Acertos Absolutos']
@@ -157,185 +157,339 @@ class ReportGenerator:
         return basic_stats
 
     def generate_graphs(self) -> List[plt.Figure]:
+        plt.style.use('seaborn')
         graphs = []
-    
+        
         # 1. Distribuição por nível
         plt.figure(figsize=(12, 6))
         nivel_counts = self.data['Nível'].value_counts()
-        colors = {'Avançado': 'green', 'Intermediário': 'yellow', 'Necessita Atenção': 'red'}
+        colors = {'Avançado': '#2ecc71', 'Intermediário': '#f1c40f', 'Necessita Atenção': '#e74c3c'}
+        
         bars = plt.bar(nivel_counts.index, nivel_counts.values)
         for i, bar in enumerate(bars):
             bar.set_color(colors[nivel_counts.index[i]])
             plt.text(bar.get_x() + bar.get_width()/2, bar.get_height(), 
                     str(nivel_counts.values[i]), 
                     ha='center', va='bottom')
-        plt.title('Distribuição dos Alunos por Nível de Desempenho')
-        plt.ylabel('Número de Alunos')
+        
+        plt.title('Distribuição dos Alunos por Nível de Desempenho', pad=20, fontsize=12)
+        plt.ylabel('Número de Alunos', labelpad=10)
+        plt.grid(True, alpha=0.3)
         graphs.append(plt.gcf())
         plt.close()
 
         # 2. Top 10 alunos
         plt.figure(figsize=(12, 6))
         top_10 = self.data.head(10)
-        plt.barh(top_10['Nome do Aluno'], top_10['Acertos Absolutos'])
-        plt.title('Top 10 Alunos - Acertos Absolutos')
-        plt.xlabel('Número de Acertos')
-        for i, v in enumerate(top_10['Acertos Absolutos']):
-            plt.text(v, i, f'{v:.0f}', va='center')
+        bars = plt.barh(top_10['Nome do Aluno'], top_10['Acertos Absolutos'], 
+                       color='#3498db')
+        
+        plt.title('Top 10 Alunos - Acertos Absolutos', pad=20, fontsize=12)
+        plt.xlabel('Número de Acertos', labelpad=10)
+        
+        for i, bar in enumerate(bars):
+            plt.text(bar.get_width(), bar.get_y() + bar.get_height()/2,
+                    f' {bar.get_width():.0f}', 
+                    va='center')
+        
+        plt.grid(True, alpha=0.3)
         plt.tight_layout()
         graphs.append(plt.gcf())
         plt.close()
 
         # 3. Relação tempo x acertos
-        plt.figure(figsize=(10, 6))
+        plt.figure(figsize=(12, 6))
         for nivel in colors:
             mask = self.data['Nível'] == nivel
             tempo = pd.to_timedelta(self.data[mask]['Total Tempo']).dt.total_seconds() / 60
-            plt.scatter(tempo, self.data[mask]['Acertos Absolutos'], 
-                       c=colors[nivel], label=nivel, alpha=0.6)
-        plt.title('Relação Tempo x Acertos por Nível')
-        plt.xlabel('Tempo Total (minutos)')
-        plt.ylabel('Número de Acertos')
+            plt.scatter(tempo, self.data[mask]['Acertos Absolutos'],
+                       c=colors[nivel], label=nivel, alpha=0.6, s=100)
+        
+        plt.title('Relação entre Tempo e Acertos por Nível', pad=20, fontsize=12)
+        plt.xlabel('Tempo Total (minutos)', labelpad=10)
+        plt.ylabel('Número de Acertos', labelpad=10)
         plt.legend()
         plt.grid(True, alpha=0.3)
         graphs.append(plt.gcf())
         plt.close()
 
-        # 4. Relação Tarefas x Acertos
-        plt.figure(figsize=(10, 6))
-        plt.scatter(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'])
-        plt.title('Relação entre Tarefas Completadas e Acertos')
-        plt.xlabel('Número de Tarefas Completadas')
-        plt.ylabel('Número de Acertos')
-        plt.grid(True, alpha=0.3)
-    
-        # Linha de tendência
+        # 4. Relação Tarefas x Acertos com linha de tendência
+        plt.figure(figsize=(12, 6))
+        plt.scatter(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'],
+                   color='#3498db', alpha=0.6, s=100)
+        
         z = np.polyfit(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'], 1)
         p = np.poly1d(z)
-        plt.plot(self.data['Tarefas Completadas'], p(self.data['Tarefas Completadas']), 
-                "r--", alpha=0.8, label='Tendência')
+        x_range = np.linspace(self.data['Tarefas Completadas'].min(), 
+                            self.data['Tarefas Completadas'].max(), 100)
+        plt.plot(x_range, p(x_range), "r--", alpha=0.8, label='Tendência')
+        
+        plt.title('Relação entre Tarefas Completadas e Acertos', pad=20, fontsize=12)
+        plt.xlabel('Número de Tarefas Completadas', labelpad=10)
+        plt.ylabel('Número de Acertos', labelpad=10)
         plt.legend()
+        plt.grid(True, alpha=0.3)
         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 com análise detalhada."""
         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.set_fill_color(240, 240, 240)
+                self.cell(0, 15, 'Relatório de Desempenho - Análise Detalhada', 0, 1, 'C', True)
                 self.ln(10)
 
         pdf = PDF('L', 'mm', 'A4')
+
+        # Introdução
+        pdf.add_page()
+        pdf.set_font('Arial', 'B', 14)
+        pdf.set_fill_color(240, 240, 240)
+        pdf.cell(0, 10, 'Introdução', 0, 1, 'L', True)
+        pdf.ln(5)
+        pdf.set_font('Arial', '', 11)
+        intro_text = """
+        Este relatório apresenta uma análise abrangente do desempenho dos alunos nas atividades realizadas.
+        Os dados são analisados considerando três aspectos principais:
+
+        • Acertos: Total de questões respondidas corretamente
+        • Engajamento: Número de tarefas completadas
+        • Dedicação: Tempo investido nas atividades
+
+        Os alunos são classificados em três níveis de acordo com seu desempenho:
+        • Avançado: 10 ou mais acertos - Excelente domínio do conteúdo
+        • Intermediário: 5 a 9 acertos - Bom entendimento, com espaço para melhorias
+        • Necessita Atenção: Menos de 5 acertos - Requer suporte adicional
+
+        A eficiência é medida em acertos por hora, permitindo identificar alunos que
+        conseguem bons resultados com uso eficiente do tempo.
+        """
+        pdf.multi_cell(0, 7, intro_text)
         
-        # Sumário executivo
+        # Visão Geral
         pdf.add_page()
-        pdf.set_font('Arial', 'B', 12)
-        pdf.cell(0, 10, 'Sumário Executivo', 0, 1)
-        pdf.set_font('Arial', '', 10)
+        pdf.set_font('Arial', 'B', 14)
+        pdf.cell(0, 10, 'Visão Geral da Turma', 0, 1, 'L', True)
+        pdf.ln(5)
+
+        tempo_medio = pd.to_timedelta(self.stats['media_tempo'])
+        minutos = int(tempo_medio.total_seconds() // 60)
+        segundos = int(tempo_medio.total_seconds() % 60)
         
-        summary_text = f"""
-        Visão Geral 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}
-        - Total 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.set_font('Arial', '', 11)
+        stats_text = f"""
+        Participação e Resultados:
+        • Total de Alunos Participantes: {self.stats['total_alunos']}
+        • Média de Tarefas por Aluno: {self.stats['media_tarefas']:.1f}
+        • Média de Acertos: {self.stats['media_acertos']:.1f}
+        • Tempo Médio de Dedicação: {minutos} minutos e {segundos} segundos
+
+        Distribuição de Desempenho:
+        • Desvio Padrão: {self.stats['desvio_padrao']:.1f} acertos
+        • Mediana: {self.stats['mediana_acertos']:.1f} acertos
         """
-        pdf.multi_cell(0, 10, summary_text)
+        pdf.multi_cell(0, 7, stats_text)
 
-        pdf.ln()
-        pdf.cell(0, 10, "Top 3 - Maiores Números de Acertos:", 0, 1)
+        # Destaques
+        pdf.ln(5)
+        pdf.set_font('Arial', 'B', 12)
+        pdf.cell(0, 10, 'Destaques de Desempenho', 0, 1)
+        pdf.set_font('Arial', '', 11)
+        
+        pdf.ln(3)
+        pdf.cell(0, 7, "🏆 Melhores Desempenhos:", 0, 1)
         for aluno, acertos in self.stats['top_performers']:
-            pdf.cell(0, 10, f"- {aluno}: {acertos:.0f} acertos", 0, 1)
+            pdf.cell(0, 7, f"• {aluno}: {acertos:.0f} acertos", 0, 1)
 
-        pdf.ln()
-        pdf.cell(0, 10, "Alunos Mais Eficientes:", 0, 1)
+        pdf.ln(3)
+        pdf.cell(0, 7, "⚡ Maior Eficiência:", 0, 1)
         for aluno, eficiencia, acertos in self.stats['most_efficient']:
-            # Formata a eficiência com 2 casas decimais ao exibir
-            pdf.cell(0, 10, f"- {aluno}: Eficiência {eficiencia:.2f} (Acertos: {acertos:.0f})", 0, 1)
+            pdf.cell(0, 7, f"• {aluno}: {eficiencia:.1f} acertos/hora ({acertos:.0f} acertos totais)", 0, 1)
 
+        # Gráficos e Análises
         for i, graph in enumerate(graphs):
             pdf.add_page()
             graph_path = f'temp_graph_{i}.png'
-            graph.savefig(graph_path)
+            graph.savefig(graph_path, dpi=300, bbox_inches='tight')
             pdf.image(graph_path, x=10, y=30, w=270)
             os.remove(graph_path)
-
+            
+            # Título e explicação para cada gráfico
+            pdf.ln(150)  # Espaço após o gráfico
+            pdf.set_font('Arial', 'B', 12)
+            
+            if i == 0:
+                pdf.cell(0, 10, 'Análise da Distribuição por Nível', 0, 1, 'L', True)
+                pdf.set_font('Arial', '', 11)
+                pdf.multi_cell(0, 6, """
+                Este gráfico ilustra como os alunos estão distribuídos entre os três níveis de desempenho.
+                • Verde: Alunos no nível Avançado - demonstram excelente compreensão
+                • Amarelo: Alunos no nível Intermediário - bom progresso com espaço para melhorias
+                • Vermelho: Alunos que Necessitam Atenção - requerem suporte adicional
+                """)
+                
+            elif i == 1:
+                pdf.cell(0, 10, 'Top 10 Alunos por Acertos', 0, 1, 'L', True)
+                pdf.set_font('Arial', '', 11)
+                pdf.multi_cell(0, 6, """
+                Destaca os dez alunos com maior número de acertos absolutos.
+                Este ranking permite:
+                • Identificar exemplos de sucesso na turma
+                • Reconhecer diferentes níveis de excelência
+                • Estabelecer metas realistas para os demais alunos
+                """)
+                
+            elif i == 2:
+                pdf.cell(0, 10, 'Relação Tempo x Desempenho', 0, 1, 'L', True)
+                pdf.set_font('Arial', '', 11)
+                pdf.multi_cell(0, 6, """
+                Mostra a relação entre tempo dedicado e número de acertos.
+                Pontos importantes:
+                • Cores indicam o nível de cada aluno
+                • Posição vertical mostra o número de acertos
+                • Posição horizontal indica o tempo total dedicado
+                • Dispersão dos pontos revela diferentes padrões de estudo
+                """)
+                
+            elif i == 3:
+                pdf.cell(0, 10, 'Progresso por Número de Tarefas', 0, 1, 'L', True)
+                pdf.set_font('Arial', '', 11)
+                pdf.multi_cell(0, 6, """
+                Analisa se mais tarefas realizadas resultam em melhor desempenho.
+                A linha de tendência (tracejada) indica:
+                • Correlação entre quantidade de tarefas e acertos
+                • Expectativa média de progresso
+                • Alunos acima da linha superam a expectativa da turma
+                """)
+
+        # Detalhamento por Nível
         for nivel in ['Avançado', 'Intermediário', 'Necessita Atenção']:
             alunos_nivel = self.data[self.data['Nível'] == nivel]
             if not alunos_nivel.empty:
                 pdf.add_page()
-                pdf.set_font('Arial', 'B', 12)
-                pdf.cell(0, 10, f'Alunos - Nível {nivel}', 0, 1)
+                pdf.set_font('Arial', 'B', 14)
+                pdf.cell(0, 10, f'Detalhamento - Nível {nivel}', 0, 1, 'L', True)
+                pdf.ln(5)
+
+                # Tabela
+                colunas = [
+                    ('Nome do Aluno', 80),
+                    ('Acertos', 25),
+                    ('Tarefas', 25),
+                    ('Tempo Total', 35),
+                    ('Eficiência', 25)
+                ]
                 
-                columns = ['Nome do Aluno', 'Acertos Absolutos', '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)
+                # Cabeçalho da tabela
+                pdf.set_font('Arial', 'B', 10)
+                pdf.set_fill_color(230, 230, 230)
+                for titulo, largura in colunas:
+                    pdf.cell(largura, 8, titulo, 1, 0, 'C', True)
                 pdf.ln()
 
-                pdf.set_font('Arial', '', 8)
+                # Dados
+                pdf.set_font('Arial', '', 10)
                 for _, row in alunos_nivel.iterrows():
-                    pdf.cell(widths[0], 6, str(row['Nome do Aluno'])[:40], 1)
-                    pdf.cell(widths[1], 6, str(row['Acertos Absolutos']), 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)
+                    tempo = pd.to_timedelta(row['Total Tempo'])
+                    tempo_str = f"{int(tempo.total_seconds() // 60)}min {int(tempo.total_seconds() % 60)}s"
+                    
+                    pdf.cell(80, 7, str(row['Nome do Aluno'])[:40], 1)
+                    pdf.cell(25, 7, f"{row['Acertos Absolutos']:.0f}", 1, 0, 'C')
+                    pdf.cell(25, 7, str(row['Tarefas Completadas']), 1, 0, 'C')
+                    pdf.cell(35, 7, tempo_str, 1, 0, 'C')
+                    pdf.cell(25, 7, f"{float(row['Eficiência']):.1f}", 1, 0, 'C')
                     pdf.ln()
 
+        # Recomendações Finais
+        pdf.add_page()
+        pdf.set_font('Arial', 'B', 14)
+        pdf.cell(0, 10, 'Recomendações e Próximos Passos', 0, 1, 'L', True)
+        pdf.ln(5)
+        
+        pdf.set_font('Arial', '', 11)
+        percent_necessita_atencao = len(self.data[self.data['Nível'] == 'Necessita Atenção']) / len(self.data) * 100
+        
+        recom_text = f"""
+        Com base na análise dos dados, recomenda-se:
+
+        1. Ações Imediatas:
+           • Implementar monitoria com alunos do nível Avançado
+           • Realizar reforço focado nos {percent_necessita_atencao:.1f}% que necessitam atenção
+           • Desenvolver planos de estudo personalizados
+
+        2. Melhorias no Processo:
+           • Acompanhamento individualizado dos alunos com baixo desempenho
+           • Feedback regular sobre o progresso
+           • Atividades extras para alunos com alta eficiência
+
+        3. Próximos Passos:
+           • Compartilhar resultados individuais
+           • Agendar sessões de reforço
+           • Reconhecer publicamente bons desempenhos
+           • Estabelecer metas claras de melhoria
+        """
+        pdf.multi_cell(0, 7, recom_text)
+
         pdf.output(output_path)
 
-def process_files(html_file, excel_files) -> Tuple[str, str, str]:
-    try:
-        temp_dir = "temp_files"
-        os.makedirs(temp_dir, exist_ok=True)
-
-        for file in os.listdir(temp_dir):
-            os.remove(os.path.join(temp_dir, file))
-
-        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)
-
-        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)
-
-        alunos_df = pd.read_csv(alunos_csv_path)
-        analyzer = StudentAnalyzer(tarefas_df, alunos_df)
-        results_df = analyzer.prepare_data()
-
-        report_generator = ReportGenerator(results_df)
-        graphs = report_generator.generate_graphs()
+    def process_files(html_file, excel_files) -> Tuple[str, str, str]:
+        """Processa arquivos e gera relatório."""
+        try:
+            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()
         
-        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)
+            # 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
+            return results_df.to_html(index=False), output_html, output_pdf
 
-    except Exception as e:
-        logging.error(f"Erro no processamento: {str(e)}")
-        raise
+        except Exception as e:
+            logging.error(f"Erro no processamento: {str(e)}")
+            raise
 
 # Interface Gradio
 theme = gr.themes.Default(
@@ -346,28 +500,39 @@ theme = gr.themes.Default(
 )
 
 with gr.Blocks(theme=theme) as interface:
-    gr.Markdown("# Sistema de Análise de Desempenho Acadêmico")
+    gr.Markdown("""
+    # Sistema de Análise de Desempenho Acadêmico
+    
+    Este sistema analisa o desempenho dos alunos e gera um relatório detalhado com:
+    - Análise estatística completa
+    - Visualizações gráficas
+    - Recomendações personalizadas
+    """)
     
     with gr.Row():
         with gr.Column():
-            gr.Markdown("## Lista de Alunos (arquivo .htm)")
-            html_file = gr.File(label="Upload do arquivo HTML", type="binary")
+            gr.Markdown("## Lista de Alunos")
+            html_file = gr.File(
+                label="Arquivo HTML com lista de alunos (.htm)",
+                type="binary",
+                file_types=[".htm", ".html"]
+            )
         
         with gr.Column():
-            gr.Markdown("## Relatórios de Tarefas (arquivos .xlsx)")
-            excel_files = gr.Files(label="Upload dos arquivos Excel", type="binary", file_count="multiple")
-
-    generate_btn = gr.Button("Gerar Relatório", variant="primary")
-    output_html = gr.HTML()
-    download_html_btn = gr.File(label="Download HTML Report")
-    download_pdf_btn = gr.File(label="Download PDF Report")
-
-    generate_btn.click(
-        fn=process_files,
-        inputs=[html_file, excel_files],
-        outputs=[output_html, download_html_btn, download_pdf_btn]
-    )
-
-# Iniciar a aplicação
-if __name__ == "__main__":
-    interface.launch()
+            gr.Markdown("## Relatórios de Tarefas")
+            excel_files = gr.Files(
+                label="Arquivos Excel com dados das tarefas (.xlsx)",
+                type="binary",
+                file_count="multiple",
+                file_types=[".xlsx"]
+            )
+
+    with gr.Row():
+        generate_btn = gr.Button("Gerar Relatório", variant="primary", size="lg")
+        
+    with gr.Row():
+        output_html = gr.HTML()
+        
+    with gr.Row():
+        with gr.Column():
+            download_html_btn =