Update app.py

app.py

@@ -9,26 +9,40 @@ from fpdf import FPDF
 from typing import Tuple, Dict, List
 import logging
 import warnings
+import seaborn as sns
+from matplotlib.colors import LinearSegmentedColormap
+from matplotlib.ticker import MaxNLocator
+from math import ceil
 
+# Configura o estilo seaborn e suprime warnings
 warnings.filterwarnings('ignore')
+sns.set_style("whitegrid")
 
 # Configuração de logging
 logging.basicConfig(
     level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("app.log"),
+        logging.StreamHandler()
+    ]
 )
 
 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)
+            if isinstance(duration_str, str) and ':' in duration_str:
+                h, m, s = map(int, duration_str.split(':'))
+                return timedelta(hours=h, minutes=m, seconds=s)
+        except Exception as e:
+            logging.warning(f"Erro ao processar duração '{duration_str}': {str(e)}")
+        return timedelta(0)
 
     @staticmethod
     def format_timedelta(td: timedelta) -> str:
+        """Formata timedelta em string legível."""
         total_seconds = int(td.total_seconds())
         hours, remainder = divmod(total_seconds, 3600)
         minutes, seconds = divmod(remainder, 60)
@@ -40,6 +54,7 @@ class DataProcessor:
 
     @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]
@@ -51,6 +66,7 @@ class DataProcessor:
 
     @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)]
@@ -64,11 +80,13 @@ class DataProcessor:
 
 class StudentAnalyzer:
     def __init__(self, tarefas_df: pd.DataFrame, alunos_df: pd.DataFrame):
+        """Inicializa o analisador com DataFrames de tarefas e alunos."""
         self.tarefas_df = tarefas_df
         self.alunos_df = alunos_df
         self.processor = DataProcessor()
 
     def prepare_data(self) -> pd.DataFrame:
+        """Prepara os dados para análise."""
         self.tarefas_df.columns = self.tarefas_df.columns.str.strip()
         self.alunos_df.columns = self.alunos_df.columns.str.strip()
 
@@ -80,7 +98,8 @@ class StudentAnalyzer:
         return self.match_students()
 
     def match_students(self) -> pd.DataFrame:
-        def generate_aluno_pattern(ra, dig_ra):
+        """Realiza o match entre alunos e tarefas."""
+        def generate_aluno_pattern(ra: str, dig_ra: str) -> str:
             ra_str = str(ra).zfill(9)
             return f"{ra_str[1]}{ra_str[2:]}{dig_ra}-sp".lower()
 
@@ -88,7 +107,7 @@ class StudentAnalyzer:
             lambda row: generate_aluno_pattern(row['RA'], row['Dig. RA']), axis=1
         )
 
-        def extract_pattern(nome):
+        def extract_pattern(nome: str) -> str:
             if isinstance(nome, str):
                 match = re.search(r'\d+.*', nome.lower())
                 return match.group(0) if match else None
@@ -98,6 +117,7 @@ class StudentAnalyzer:
         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():
@@ -120,12 +140,32 @@ class StudentAnalyzer:
         return metrics_df.sort_values('Acertos Absolutos', ascending=False)
 
 class ReportGenerator:
+    """Classe responsável pela geração de relatórios e visualizações."""
+    
     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)
-
-    def classify_performance(self, acertos):
+        self.colors = {
+            'Avançado': '#2ecc71',
+            'Intermediário': '#f1c40f',
+            'Necessita Atenção': '#e74c3c'
+        }
+        self.setup_plot_style()
+
+    def setup_plot_style(self):
+        """Configura o estilo padrão dos gráficos."""
+        plt.style.use('seaborn')
+        plt.rcParams['figure.figsize'] = [15, 10]
+        plt.rcParams['font.size'] = 11
+        plt.rcParams['axes.titlesize'] = 14
+        plt.rcParams['axes.labelsize'] = 12
+        plt.rcParams['axes.grid'] = True
+        plt.rcParams['grid.alpha'] = 0.3
+        plt.rcParams['grid.linestyle'] = '--'
+
+    def classify_performance(self, acertos: float) -> str:
+        """Classifica o desempenho do aluno baseado no número de acertos."""
         if acertos >= 10:
             return 'Avançado'
         elif acertos >= 5:
@@ -134,136 +174,269 @@ class ReportGenerator:
             return 'Necessita Atenção'
 
     def calculate_statistics(self) -> Dict:
-        basic_stats = {
-            'media_acertos': float(self.data['Acertos Absolutos'].mean()),
-            'desvio_padrao': float(self.data['Acertos Absolutos'].std()),
-            'mediana_acertos': float(self.data['Acertos Absolutos'].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())
-        }
-
-        top_students = self.data.nlargest(3, 'Acertos Absolutos')[
-            ['Nome do Aluno', 'Acertos Absolutos']
-        ].values.tolist()
-        basic_stats['top_performers'] = top_students
-
-        return basic_stats
+        """Calcula estatísticas básicas do desempenho dos alunos."""
+        try:
+            basic_stats = {
+                'media_acertos': float(self.data['Acertos Absolutos'].mean()),
+                'desvio_padrao': float(self.data['Acertos Absolutos'].std()),
+                'mediana_acertos': float(self.data['Acertos Absolutos'].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())
+            }
+
+            top_students = self.data.nlargest(3, 'Acertos Absolutos')[
+                ['Nome do Aluno', 'Acertos Absolutos']
+            ].values.tolist()
+            basic_stats['top_performers'] = top_students
+
+            return basic_stats
+        except Exception as e:
+            logging.error(f"Erro ao calcular estatísticas: {str(e)}")
+            raise
 
-    def generate_graphs(self) -> List[plt.Figure]:
-        graphs = []
-    
-        # Configurações globais
-        plt.rcParams['figure.figsize'] = [15, 10]  # Aumentado para acomodar rótulos
-        plt.rcParams['font.size'] = 10
-        plt.rcParams['axes.titlesize'] = 12
-    
-        # 1. Distribuição por nível
-        plt.figure()
+    def create_distribution_plot(self) -> plt.Figure:
+        """Cria o gráfico de distribuição por nível."""
+        plt.figure(figsize=(15, 8))
         nivel_counts = self.data['Nível'].value_counts()
-        colors = {'Avançado': '#2ecc71', 'Intermediário': '#f1c40f', 'Necessita Atenção': '#e74c3c'}
-    
-        bars = plt.bar(nivel_counts.index, nivel_counts.values)
+        total_alunos = len(self.data)
+
+        bars = plt.bar(nivel_counts.index, nivel_counts.values, width=0.6)
+        
         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')
+            bar.set_color(self.colors[nivel_counts.index[i]])
+            percentage = (nivel_counts.values[i] / total_alunos) * 100
+            plt.text(bar.get_x() + bar.get_width()/2, bar.get_height(),
+                    f'{nivel_counts.values[i]}\n({percentage:.1f}%)',
+                    ha='center', va='bottom', fontsize=12, fontweight='bold')
+
+        plt.title('Distribuição dos Alunos por Nível de Desempenho', pad=20)
         plt.ylabel('Número de Alunos')
-        graphs.append(plt.gcf())
-        plt.close()
+        plt.grid(True, axis='y', alpha=0.3)
+        
+        return plt.gcf()
 
-        # 2. Todos os alunos por acertos
-        plt.figure(figsize=(15, 12))
+    def create_ranking_plot(self) -> plt.Figure:
+        """Cria o gráfico de ranking completo dos alunos."""
+        plt.figure(figsize=(15, max(10, len(self.data) * 0.4)))
         students_data = self.data.sort_values('Acertos Absolutos', ascending=True)
+        
+        colors = [self.colors[nivel] for nivel in students_data['Nível']]
         bars = plt.barh(range(len(students_data)), students_data['Acertos Absolutos'])
-    
-        plt.yticks(range(len(students_data)), students_data['Nome do Aluno'], fontsize=8)
-        plt.title('Ranking Completo - Acertos Absolutos')
-        plt.xlabel('Número de Acertos')
-    
+        
+        for bar, color in zip(bars, colors):
+            bar.set_color(color)
+            bar.set_alpha(0.8)
+
+        plt.yticks(range(len(students_data)), students_data['Nome do Aluno'], 
+                  fontsize=10)
+        
         for i, bar in enumerate(bars):
-            plt.text(bar.get_width(), i, f' {bar.get_width():.0f}', 
-                    va='center')
-    
-        plt.tight_layout()
-        graphs.append(plt.gcf())
-        plt.close()
+            plt.text(bar.get_width(), i, f' {bar.get_width():.0f}',
+                    va='center', fontsize=10, fontweight='bold')
+            
+        plt.title('Ranking Completo - Acertos Absolutos', pad=20)
+        plt.xlabel('Número de Acertos')
+        plt.grid(True, axis='x', alpha=0.3)
+        
+        return plt.gcf()
 
-        # 3. Relação tempo x acertos com rótulos
+    def create_time_performance_plot(self) -> plt.Figure:
+        """Cria o gráfico de relação entre tempo e acertos."""
         plt.figure(figsize=(15, 10))
-        for nivel in colors:
+        
+        # Scatter plot com cores por nível
+        for nivel, color in self.colors.items():
             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, s=100)
-        
-            # Adicionar rótulos para cada ponto
+                       c=color, label=nivel, alpha=0.7, s=150)
+            
+            # Adiciona rótulos otimizados
             for i, (x, y, nome) in enumerate(zip(tempo, 
                                                self.data[mask]['Acertos Absolutos'],
                                                self.data[mask]['Nome do Aluno'])):
-                plt.annotate(nome, (x, y), xytext=(0, -10),
-                            textcoords='offset points', ha='center',
-                            va='top', rotation=45, fontsize=8)
-    
-        plt.title('Relação entre Tempo e Acertos por Nível')
+                if x > np.median(tempo.values):
+                    ha = 'right'
+                    offset = (-5, 0)
+                else:
+                    ha = 'left'
+                    offset = (5, 0)
+                
+                plt.annotate(nome, (x, y),
+                            xytext=offset, textcoords='offset points',
+                            ha=ha, va='center', rotation=30, fontsize=8,
+                            bbox=dict(facecolor='white', edgecolor='none', 
+                                    alpha=0.7))
+
+        plt.title('Relação entre Tempo e Acertos por Nível', pad=20)
         plt.xlabel('Tempo Total (minutos)')
         plt.ylabel('Número de Acertos')
-        plt.legend()
-        plt.tight_layout()
-        graphs.append(plt.gcf())
-        plt.close()
+        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+        plt.grid(True, alpha=0.3)
+        
+        return plt.gcf()
 
-        # 4. Relação Tarefas x Acertos com rótulos e linha de tendência
+    def create_tasks_performance_plot(self) -> plt.Figure:
+        """Cria o gráfico de relação entre tarefas e acertos."""
         plt.figure(figsize=(15, 10))
-        plt.scatter(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'],
-                    color='#3498db', alpha=0.6, s=100)
-    
-        # Adicionar rótulos para cada ponto
+        
+        # Scatter plot com cores por nível
+        for nivel, color in self.colors.items():
+            mask = self.data['Nível'] == nivel
+            plt.scatter(self.data[mask]['Tarefas Completadas'],
+                       self.data[mask]['Acertos Absolutos'],
+                       c=color, alpha=0.7, s=150, label=nivel)
+
+        # Adiciona rótulos otimizados
         for i, row in self.data.iterrows():
+            if row['Tarefas Completadas'] > np.median(self.data['Tarefas Completadas']):
+                ha = 'right'
+                offset = (-5, 0)
+            else:
+                ha = 'left'
+                offset = (5, 0)
+            
             plt.annotate(row['Nome do Aluno'],
                         (row['Tarefas Completadas'], row['Acertos Absolutos']),
-                        xytext=(0, -10), textcoords='offset points',
-                        ha='center', va='top', rotation=45, fontsize=8)
-    
+                        xytext=offset, textcoords='offset points',
+                        ha=ha, va='center', rotation=30, fontsize=8,
+                        bbox=dict(facecolor='white', edgecolor='none', alpha=0.7))
+
         # Linha de tendência
-        z = np.polyfit(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'], 1)
+        z = np.polyfit(self.data['Tarefas Completadas'],
+                      self.data['Acertos Absolutos'], 1)
         p = np.poly1d(z)
-        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')
+        x_range = np.linspace(self.data['Tarefas Completadas'].min(),
+                           self.data['Tarefas Completadas'].max(), 100)
+        
+        plt.plot(x_range, p(x_range), "--", color='#e74c3c', alpha=0.8,
+                label='Tendência', linewidth=2)
+
+        plt.title('Relação entre Tarefas Completadas e Acertos', pad=20)
         plt.xlabel('Número de Tarefas Completadas')
         plt.ylabel('Número de Acertos')
-        plt.legend()
-        plt.tight_layout()
-        graphs.append(plt.gcf())
-        plt.close()
+        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+        plt.grid(True, alpha=0.3)
+        
+        return plt.gcf()
+
+    def generate_graphs(self) -> List[plt.Figure]:
+        """Gera todos os gráficos para o relatório."""
+        try:
+            graphs = []
+            
+            # 1. Distribuição por nível
+            graphs.append(self.create_distribution_plot())
+            plt.close()
+
+            # 2. Ranking completo
+            graphs.append(self.create_ranking_plot())
+            plt.close()
 
-        return graphs
+            # 3. Relação tempo x acertos
+            graphs.append(self.create_time_performance_plot())
+            plt.close()
+
+            # 4. Relação tarefas x acertos
+            graphs.append(self.create_tasks_performance_plot())
+            plt.close()
+
+            return graphs
+        except Exception as e:
+            logging.error(f"Erro ao gerar gráficos: {str(e)}")
+            raise
+
+    def generate_table_section(self, pdf: FPDF, nivel: str, alunos_nivel: pd.DataFrame):
+        """Gera uma seção de tabela com formatação melhorada."""
+        try:
+            pdf.set_font('Arial', 'B', 14)
+            pdf.set_fill_color(240, 240, 240)
+            pdf.cell(0, 10, f'Detalhamento - Nível {nivel}', 0, 1, 'L', True)
+            pdf.ln(5)
+
+            # Configuração da tabela
+            colunas = [
+                ('Nome do Aluno', 80),
+                ('Acertos', 25),
+                ('Tarefas', 25),
+                ('Tempo Total', 35)
+            ]
+            
+            # Cabeçalho
+            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()
+
+            # Dados com cores alternadas
+            pdf.set_font('Arial', '', 10)
+            for i, (_, row) in enumerate(alunos_nivel.iterrows()):
+                # Cor de fundo alternada
+                fill_color = (245, 245, 245) if i % 2 == 0 else (255, 255, 255)
+                pdf.set_fill_color(*fill_color)
+
+                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, 0, 'L', True)
+                pdf.cell(25, 7, f"{row['Acertos Absolutos']:.0f}", 1, 0, 'R', True)
+                pdf.cell(25, 7, str(row['Tarefas Completadas']), 1, 0, 'R', True)
+                pdf.cell(35, 7, tempo_str, 1, 0, 'R', True)
+                pdf.ln()
+        except Exception as e:
+            logging.error(f"Erro ao gerar seção de tabela: {str(e)}")
+            raise
 
     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.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')
+        try:
+            class PDF(FPDF):
+                def header(self):
+                    """Define o cabeçalho padrão do PDF."""
+                    self.set_font('Arial', 'B', 15)
+                    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()
+            self._add_introduction_section(pdf)
+            
+            # Visão Geral
+            pdf.add_page()
+            self._add_overview_section(pdf)
+            
+            # Destaques
+            self._add_highlights_section(pdf)
+            
+            # Gráficos e Análises
+            self._add_graphs_section(pdf, graphs)
+            
+            # Detalhamento por Nível
+            self._add_detailed_sections(pdf)
+            
+            # Recomendações Finais
+            self._add_recommendations_section(pdf)
+            
+            pdf.output(output_path)
+            
+        except Exception as e:
+            logging.error(f"Erro ao gerar PDF: {str(e)}")
+            raise
 
-        # Introdução
-        pdf.add_page()
+    def _add_introduction_section(self, pdf: FPDF) -> None:
+        """Adiciona a seção de introdução ao PDF."""
         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:
@@ -278,9 +451,9 @@ class ReportGenerator:
         - Necessita Atenção: Menos de 5 acertos - Requer suporte adicional
         """
         pdf.multi_cell(0, 7, intro_text)
-        
-        # Visão Geral
-        pdf.add_page()
+
+    def _add_overview_section(self, pdf: FPDF) -> None:
+        """Adiciona a seção de visão geral ao PDF."""
         pdf.set_font('Arial', 'B', 14)
         pdf.cell(0, 10, 'Visão Geral da Turma', 0, 1, 'L', True)
         pdf.ln(5)
@@ -303,7 +476,8 @@ class ReportGenerator:
         """
         pdf.multi_cell(0, 7, stats_text)
 
-        # Destaques
+    def _add_highlights_section(self, pdf: FPDF) -> None:
+        """Adiciona a seção de destaques ao PDF."""
         pdf.ln(5)
         pdf.set_font('Arial', 'B', 12)
         pdf.cell(0, 10, 'Destaques de Desempenho', 0, 1)
@@ -314,7 +488,8 @@ class ReportGenerator:
         for aluno, acertos in self.stats['top_performers']:
             pdf.cell(0, 7, f"- {aluno}: {acertos:.0f} acertos", 0, 1)
 
-        # Gráficos e Análises
+    def _add_graphs_section(self, pdf: FPDF, graphs: List[plt.Figure]) -> None:
+        """Adiciona a seção de gráficos ao PDF."""
         for i, graph in enumerate(graphs):
             pdf.add_page()
             graph_path = f'temp_graph_{i}.png'
@@ -322,8 +497,7 @@ class ReportGenerator:
             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.ln(150)
             pdf.set_font('Arial', 'B', 12)
             
             if i == 0:
@@ -370,43 +544,16 @@ class ReportGenerator:
                 - Alunos acima da linha superam a expectativa da turma
                 """)
 
-        # Detalhamento por Nível
+    def _add_detailed_sections(self, pdf: FPDF) -> None:
+        """Adiciona as seções detalhadas por nível ao PDF."""
         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', 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)
-                ]
-                
-                # 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()
+                self.generate_table_section(pdf, nivel, alunos_nivel)
 
-                # Dados
-                pdf.set_font('Arial', '', 10)
-                for _, row in alunos_nivel.iterrows():
-                    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.ln()
-
-        # Recomendações Finais
+    def _add_recommendations_section(self, pdf: FPDF) -> None:
+        """Adiciona a seção de recomendações ao PDF."""
         pdf.add_page()
         pdf.set_font('Arial', 'B', 14)
         pdf.cell(0, 10, 'Recomendações e Próximos Passos', 0, 1, 'L', True)
@@ -436,9 +583,7 @@ class ReportGenerator:
         """
         pdf.multi_cell(0, 7, recom_text)
 
-        pdf.output(output_path)
-
-def process_files(html_file, excel_files) -> Tuple[str, str, str]:
+    def process_files(html_file, excel_files) -> Tuple[str, str, str]:
     """Processa arquivos e gera relatório."""
     try:
         temp_dir = "temp_files"
@@ -453,6 +598,7 @@ def process_files(html_file, excel_files) -> Tuple[str, str, str]:
         with open(html_path, "wb") as f:
             f.write(html_file)
 
+        # Processar arquivos Excel
         excel_paths = []
         for i, excel_file in enumerate(excel_files):
             excel_path = os.path.join(temp_dir, f"tarefa_{i}.xlsx")
@@ -465,6 +611,7 @@ def process_files(html_file, excel_files) -> Tuple[str, str, str]:
         alunos_csv_path = os.path.join(temp_dir, "alunos.csv")
         processor.normalize_html_to_csv(html_path, alunos_csv_path)
 
+        # Concatenar dados das tarefas
         tarefas_df = pd.DataFrame()
         for excel_path in excel_paths:
             csv_path = excel_path.replace('.xlsx', '.csv')
@@ -472,12 +619,11 @@ def process_files(html_file, excel_files) -> Tuple[str, str, str]:
             df = pd.read_csv(csv_path)
             tarefas_df = pd.concat([tarefas_df, df], ignore_index=True)
 
-        # Análise
+        # Análise e geração de relatório
         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()
         
@@ -493,69 +639,77 @@ def process_files(html_file, excel_files) -> Tuple[str, str, str]:
         logging.error(f"Erro no processamento: {str(e)}")
         raise
 
-# Interface Gradio
-theme = gr.themes.Default(
-    primary_hue="blue",
-    secondary_hue="gray",
-    font=["Arial", "sans-serif"],
-    font_mono=["Courier New", "monospace"],
-)
-
-with gr.Blocks(theme=theme) as interface:
-    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")
-            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")
-            excel_files = gr.Files(
-                label="Arquivos Excel com dados das tarefas (.xlsx)",
-                type="binary",
-                file_count="multiple",
-                file_types=[".xlsx"]
-            )
+def create_interface():
+    """Cria a interface Gradio."""
+    theme = gr.themes.Default(
+        primary_hue="blue",
+        secondary_hue="gray",
+        font=["Arial", "sans-serif"],
+        font_mono=["Courier New", "monospace"],
+    )
 
-    with gr.Row():
-        generate_btn = gr.Button("Gerar Relatório", variant="primary", size="lg")
+    with gr.Blocks(theme=theme) as interface:
+        gr.Markdown("""
+        # Sistema de Análise de Desempenho Acadêmico
         
-    with gr.Row():
-        output_html = gr.HTML()
+        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():
-            download_html_btn = gr.File(
-                label="Download Relatório HTML",
-                type="filepath",
-                interactive=False
-            )
-        with gr.Column():
-            download_pdf_btn = gr.File(
-                label="Download Relatório PDF",
-                type="filepath",
-                interactive=False
+        with gr.Row():
+            with gr.Column():
+                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")
+                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 = gr.File(
+                    label="Download Relatório HTML",
+                    type="filepath",
+                    interactive=False
+                )
+            with gr.Column():
+                download_pdf_btn = gr.File(
+                    label="Download Relatório PDF",
+                    type="filepath",
+                    interactive=False
+                )
+
+        generate_btn.click(
+            fn=process_files,
+            inputs=[html_file, excel_files],
+            outputs=[output_html, download_html_btn, download_pdf_btn]
+        )
 
-    generate_btn.click(
-        fn=process_files,
-        inputs=[html_file, excel_files],
-        outputs=[output_html, download_html_btn, download_pdf_btn]
-    )
+    return interface
 
 if __name__ == "__main__":
+    interface = create_interface()
     interface.launch(
         share=False,
         server_name="0.0.0.0",