Update app.py

app.py

@@ -42,16 +42,14 @@ class DataProcessor:
         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)
-        if hours > 0:
-            return f"{hours}h {minutes}min {seconds}s"
-        elif minutes > 0:
-            return f"{minutes}min {seconds}s"
-        return f"{seconds}s"
+    def format_time(seconds: float) -> str:
+        """Formata o tempo de forma mais limpa e consistente."""
+        minutes = int(seconds // 60)
+        remaining_seconds = int(seconds % 60)
+        
+        if minutes == 0:
+            return f"{remaining_seconds}s"
+        return f"{minutes}min {remaining_seconds}s"
 
     @staticmethod
     def normalize_html_to_csv(input_html_path: str, output_csv_path: str) -> None:
@@ -269,71 +267,81 @@ class ReportGenerator:
         return plt.gcf()
 
     def create_time_performance_plot(self) -> plt.Figure:
-        """Cria o gráfico de relação entre tempo e acertos com melhor legibilidade."""
+        """Cria o gráfico de relação entre tempo e acertos com melhor agrupamento."""
         plt.figure(figsize=(15, 10))
-    
-        # Configurar fundo e grade
+        
+        # Configuração inicial
         plt.grid(True, alpha=0.2, linestyle='--')
         plt.gca().set_facecolor('#f8f9fa')
-    
-        # Criar dicionário para armazenar pontos próximos
-        proximity_groups = {}
-    
-        # Primeiro, plotar os pontos
+        
+        # Função para determinar proximidade de pontos
+        def are_points_close(p1, p2, threshold=0.1):
+            x1, y1 = p1
+            x2, y2 = p2
+            return abs(x1 - x2) < threshold and abs(y1 - y2) < threshold
+        
+        # Agrupar pontos próximos
+        point_groups = []
+        processed_points = set()
+        
         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
+            tempo_mins = pd.to_timedelta(self.data[mask]['Total Tempo']).dt.total_seconds() / 60
             acertos = self.data[mask]['Acertos Absolutos']
-        
-            scatter = plt.scatter(tempo, acertos, c=color, label=nivel, alpha=0.7, s=150)
-        
+            
+            # Plotar pontos
+            plt.scatter(tempo_mins, acertos, c=color, label=nivel, alpha=0.7, s=100)
+            
             # Agrupar pontos próximos
-            for x, y, nome in zip(tempo, acertos, self.data[mask]['Nome do Aluno']):
-                key = (round(x, 1), round(y, 1))  # Arredondar para agrupar pontos próximos
-                if key not in proximity_groups:
-                    proximity_groups[key] = []
-                proximity_groups[key].append((x, y, nome))
-    
-        # Adicionar anotações com tratamento especial para pontos próximos
-        for group in proximity_groups.values():
+            points = list(zip(tempo_mins, acertos, self.data[mask]['Nome do Aluno']))
+            
+            for i, (x, y, nome) in enumerate(points):
+                if (x, y) in processed_points:
+                    continue
+                    
+                # Encontrar pontos próximos
+                current_group = [(x, y, nome)]
+                processed_points.add((x, y))
+                
+                for j, (x2, y2, nome2) in enumerate(points[i+1:]):
+                    if are_points_close((x, y), (x2, y2)):
+                        current_group.append((x2, y2, nome2))
+                        processed_points.add((x2, y2))
+                
+                if current_group:
+                    point_groups.append(current_group)
+        
+        # Adicionar anotações para grupos
+        for group in point_groups:
             if len(group) == 1:
-                # Ponto único - anotação normal
                 x, y, nome = group[0]
                 plt.annotate(
-                    nome.split()[0],  # Usar apenas primeiro nome
+                    nome.split()[0],
                     (x, y),
                     xytext=(5, 5),
                     textcoords='offset points',
+                    fontsize=8,
                     bbox=dict(
                         facecolor='white',
                         edgecolor='none',
                         alpha=0.8,
                         pad=0.5
-                    ),
-                    fontsize=8,
-                    arrowprops=dict(
-                        arrowstyle='-',
-                        color='gray',
-                        alpha=0.3,
-                        connectionstyle='arc3,rad=0.3'
                     )
                 )
             else:
-                # Múltiplos pontos próximos - criar lista vertical
-                x_base = sum(p[0] for p in group) / len(group)
-                y_base = sum(p[1] for p in group) / len(group)
-                nomes = [p[2].split()[0] for p in group]
-            
-                # Calcular posição do texto para evitar sobreposição
-                x_text = x_base + 10
-                y_text = y_base
-            
-                # Criar caixa com lista de nomes
-                nome_text = '\n'.join(nomes)
+                # Centro do grupo
+                x_mean = sum(p[0] for p in group) / len(group)
+                y_mean = sum(p[1] for p in group) / len(group)
+                
+                # Lista de nomes ordenada
+                nomes = sorted([p[2].split()[0] for p in group])
+                
+                # Posicionar caixa de texto
                 plt.annotate(
-                    nome_text,
-                    (x_base, y_base),
-                    xytext=(x_text, y_text),
+                    '\n'.join(nomes),
+                    (x_mean, y_mean),
+                    xytext=(15, 15),
+                    textcoords='offset points',
                     bbox=dict(
                         facecolor='white',
                         edgecolor='lightgray',
@@ -341,30 +349,22 @@ class ReportGenerator:
                         pad=0.5,
                         boxstyle='round,pad=0.5'
                     ),
-                    fontsize=8,
                     arrowprops=dict(
                         arrowstyle='->',
+                        connectionstyle='arc3,rad=0.2',
                         color='gray',
-                        alpha=0.5,
-                        connectionstyle='arc3,rad=0.2'
-                    )
+                        alpha=0.6
+                    ),
+                    fontsize=8,
+                    zorder=5
                 )
-    
+        
         plt.title('Relação entre Tempo e Acertos por Nível', pad=20)
         plt.xlabel('Tempo Total (minutos)')
         plt.ylabel('Número de Acertos')
-    
-        # Melhorar posição e aparência da legenda
-        plt.legend(
-            bbox_to_anchor=(1.05, 1),
-            loc='upper left',
-            borderaxespad=0,
-            frameon=True,
-            facecolor='white',
-            edgecolor='none'
-        )
-    
+        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
         plt.tight_layout()
+        
         return plt.gcf()
 
     def create_tasks_performance_plot(self) -> plt.Figure:
@@ -538,7 +538,7 @@ class ReportGenerator:
                 ('Acertos', 20),
                 ('Tarefas', 20),
                 ('Taxa', 20),
-                ('Tempo Total', 35)
+                ('Tempo Total', 20)
             ]
         
             # Cabeçalho da tabela