Update app.py

app.py

@@ -116,40 +116,39 @@ class StudentAnalyzer:
         return self.calculate_metrics()
 
     def calculate_metrics(self) -> pd.DataFrame:
-        """Calcula métricas de desempenho dos alunos, com formatação de tempo melhorada."""
+        """Calcula métricas de desempenho dos alunos, eliminando duplicatas e normalizando valores."""
         try:
             metrics_df = pd.DataFrame()
         
             # Agrupar por Aluno_Pattern para eliminar duplicatas
             grouped_tasks = self.tarefas_df.groupby('Aluno_Pattern').agg({
-                'Aluno': 'first',     
-                'Duração': 'sum',     
-                'Nota': 'sum',        
+                'Aluno': 'first',     # Nome original do aluno na tarefa
+                'Duração': 'sum',     # Soma total do tempo
+                'Nota': 'sum',        # Soma total dos acertos
             }).reset_index()
         
+            # Contar número de tarefas únicas por aluno
             task_counts = self.tarefas_df.groupby('Aluno_Pattern').size().reset_index(name='total_tarefas')
             grouped_tasks = grouped_tasks.merge(task_counts, on='Aluno_Pattern', how='left')
         
-            processed_patterns = set()
+            # Processar cada aluno uma única vez usando o DataFrame de alunos para informações corretas
+            processed_patterns = set()  # Conjunto para controlar padrões já processados
         
             for _, aluno in self.alunos_df.iterrows():
                 aluno_pattern = aluno['Aluno_Pattern']
             
+                # Evitar duplicatas do mesmo padrão
                 if aluno_pattern not in processed_patterns:
                     aluno_data = grouped_tasks[grouped_tasks['Aluno_Pattern'] == aluno_pattern]
                 
                     if not aluno_data.empty:
-                        total_tempo = aluno_data['Duração'].iloc[0]
-                        tempo_medio = (total_tempo / aluno_data['total_tarefas'].iloc[0] 
-                                     if aluno_data['total_tarefas'].iloc[0] > 0 
-                                     else timedelta(0))
-                        
                         metrics = {
                             'Nome do Aluno': aluno['Nome do Aluno'],
                             'Tarefas Completadas': aluno_data['total_tarefas'].iloc[0],
                             'Acertos Absolutos': aluno_data['Nota'].iloc[0],
-                            'Total Tempo': DataProcessor.format_timedelta(total_tempo),
-                            'Tempo Médio por Tarefa': DataProcessor.format_timedelta(tempo_medio)
+                            'Total Tempo': str(aluno_data['Duração'].iloc[0]),
+                            'Tempo Médio por Tarefa': str(aluno_data['Duração'].iloc[0] / aluno_data['total_tarefas'].iloc[0] 
+                                                    if aluno_data['total_tarefas'].iloc[0] > 0 else timedelta(0))
                         }
                         metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True)
                         processed_patterns.add(aluno_pattern)
@@ -161,28 +160,6 @@ class StudentAnalyzer:
             logging.error(f"Erro ao calcular métricas: {str(e)}")
             raise
 
-    def generate_html(self, df: pd.DataFrame) -> str:
-        """Gera HTML com formatação personalizada."""
-        # Fazer uma cópia para não modificar o DataFrame original
-        df_display = df.copy()
-        
-        # Definir formatação personalizada
-        formatters = {
-            'Tarefas Completadas': lambda x: f"{x:d}",
-            'Acertos Absolutos': lambda x: f"{x:.0f}",
-        }
-        
-        # Gerar HTML com formatação personalizada
-        html = df_display.to_html(
-            index=False,
-            formatters=formatters,
-            escape=False,
-            classes='dataframe',
-            border=1
-        )
-        
-        return html
-
 class ReportGenerator:
     """Classe responsável pela geração de relatórios e visualizações."""
     
@@ -855,19 +832,21 @@ def process_files(html_file, excel_files) -> Tuple[str, str, str]:
         alunos_df = pd.read_csv(alunos_csv_path)
         analyzer = StudentAnalyzer(tarefas_df, alunos_df)
         results_df = analyzer.prepare_data()
-    
-        # Salvar outputs com formatação melhorada
+
+        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")
-    
-        html_content = analyzer.generate_html(results_df)
-        with open(output_html, 'w', encoding='utf-8') as f:
-            f.write(html_content)
-    
-        report_generator = ReportGenerator(results_df)
+        results_df.to_html(output_html, index=False)
         report_generator.generate_pdf(output_pdf, graphs)
-    
-        return html_content, 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
 
 def create_interface():
     """Cria a interface Gradio."""