Update app.py

app.py

@@ -116,39 +116,40 @@ class StudentAnalyzer:
         return self.calculate_metrics()
 
     def calculate_metrics(self) -> pd.DataFrame:
-        """Calcula métricas de desempenho dos alunos, eliminando duplicatas e normalizando valores."""
+        """Calcula métricas de desempenho dos alunos, com formatação de tempo melhorada."""
         try:
             metrics_df = pd.DataFrame()
         
             # Agrupar por Aluno_Pattern para eliminar duplicatas
             grouped_tasks = self.tarefas_df.groupby('Aluno_Pattern').agg({
-                'Aluno': 'first',     # Nome original do aluno na tarefa
-                'Duração': 'sum',     # Soma total do tempo
-                'Nota': 'sum',        # Soma total dos acertos
+                'Aluno': 'first',     
+                'Duração': 'sum',     
+                'Nota': 'sum',        
             }).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')
         
-            # 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
+            processed_patterns = set()
         
             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': 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))
+                            'Total Tempo': DataProcessor.format_timedelta(total_tempo),
+                            'Tempo Médio por Tarefa': DataProcessor.format_timedelta(tempo_medio)
                         }
                         metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True)
                         processed_patterns.add(aluno_pattern)
@@ -160,6 +161,28 @@ 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."""
     
@@ -832,21 +855,19 @@ 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()
-
-        report_generator = ReportGenerator(results_df)
-        graphs = report_generator.generate_graphs()
-        
-        # Salvar outputs
+    
+        # Salvar outputs com formatação melhorada
         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)
+    
+        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)
         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
+    
+        return html_content, output_html, output_pdf
 
 def create_interface():
     """Cria a interface Gradio."""