Update app.py

app.py

@@ -13,7 +13,6 @@ import logging
 import warnings
 warnings.filterwarnings('ignore')
 
-# Configuração de logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s'
@@ -22,7 +21,6 @@ logging.basicConfig(
 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)
@@ -31,7 +29,6 @@ class DataProcessor:
 
     @staticmethod
     def format_timedelta(td: timedelta) -> str:
-        """Formata timedelta para string no formato HH:MM:SS."""
         total_seconds = int(td.total_seconds())
         hours, remainder = divmod(total_seconds, 3600)
         minutes, seconds = divmod(remainder, 60)
@@ -39,7 +36,6 @@ 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,7 +47,6 @@ 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)]
@@ -70,23 +65,17 @@ class StudentAnalyzer:
         self.processor = DataProcessor()
 
     def prepare_data(self) -> pd.DataFrame:
-        """Prepara e limpa os dados para análise."""
-        # Limpeza de colunas
         self.tarefas_df.columns = self.tarefas_df.columns.str.strip()
         self.alunos_df.columns = self.alunos_df.columns.str.strip()
 
-        # Verifica colunas necessárias
         required_columns = ['Aluno', 'Nota', 'Duração']
         if not all(col in self.tarefas_df.columns for col in required_columns):
             raise ValueError("Colunas obrigatórias não encontradas no arquivo de tarefas")
 
-        # Processamento de duração
         self.tarefas_df['Duração'] = self.tarefas_df['Duração'].apply(self.processor.parse_duration)
-
         return self.match_students()
 
     def match_students(self) -> pd.DataFrame:
-        """Relaciona dados de alunos com suas tarefas."""
         def generate_aluno_pattern(ra, dig_ra):
             ra_str = str(ra).zfill(9)
             return f"{ra_str[1]}{ra_str[2:]}{dig_ra}-sp".lower()
@@ -102,11 +91,9 @@ class StudentAnalyzer:
             return None
 
         self.tarefas_df['Aluno_Pattern'] = self.tarefas_df['Aluno'].apply(extract_pattern)
-
         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():
@@ -114,14 +101,16 @@ class StudentAnalyzer:
             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()
+                
                 metrics = {
                     'Nome do Aluno': aluno['Nome do Aluno'],
                     'Tarefas Completadas': len(aluno_tarefas),
-                    'Acertos Absolutos': aluno_tarefas['Nota'].sum(),
-                    'Total Tempo': str(aluno_tarefas['Duração'].sum()),
-                    'Média de Acertos': f"{(aluno_tarefas['Nota'].sum() / (len(aluno_tarefas) * 2) * 100):.2f}%",
-                    'Tempo Médio por Tarefa': str(aluno_tarefas['Duração'].mean()),
-                    'Eficiência': f"{(aluno_tarefas['Nota'].sum() / aluno_tarefas['Duração'].sum().total_seconds() * 3600):.2f}"
+                    'Acertos Absolutos': acertos_total,
+                    'Total Tempo': str(duracao_total),
+                    'Tempo Médio por Tarefa': str(duracao_total / len(aluno_tarefas)),
+                    'Eficiência': f"{(acertos_total / duracao_total.total_seconds() * 3600):.2f}"
                 }
                 metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True)
 
@@ -131,44 +120,42 @@ class ReportGenerator:
     def __init__(self, data: pd.DataFrame):
         self.data = data
         self.stats = self.calculate_statistics()
-        # Classificar alunos por níveis
-        self.data['Nível'] = self.data['Média de Acertos'].str.rstrip('%').astype(float).apply(self.classify_performance)
-        self.data = self.data.sort_values('Média de Acertos'.str.rstrip('%').astype(float), ascending=False)
+        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, score):
-        if score >= 70:
+    def classify_performance(self, acertos):
+        if acertos >= 10:
             return 'Avançado'
-        elif score >= 40:
+        elif acertos >= 5:
             return 'Intermediário'
         else:
             return 'Necessita Atenção'
 
     def calculate_statistics(self) -> Dict:
-        """Calcula estatísticas gerais e por grupo."""
         basic_stats = {
-            'media_acertos': float(self.data['Média de Acertos'].str.rstrip('%').astype(float).mean()),
-            'desvio_padrao': float(self.data['Média de Acertos'].str.rstrip('%').astype(float).std()),
-            'mediana_acertos': float(self.data['Média de Acertos'].str.rstrip('%').astype(float).median()),
+            '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 performers
-        top_students = self.data.nlargest(3, 'Média de Acertos')
-        basic_stats['top_performers'] = top_students[['Nome do Aluno', 'Média de Acertos']].values.tolist()
+        top_students = self.data.nlargest(3, 'Acertos Absolutos')
+        basic_stats['top_performers'] = top_students[['Nome do Aluno', 'Acertos Absolutos']].values.tolist()
 
-        # Mais eficientes (melhor relação acerto/tempo)
-        efficient_students = self.data.nlargest(3, 'Eficiência')
-        basic_stats['most_efficient'] = efficient_students[['Nome do Aluno', 'Eficiência', 'Média de Acertos']].values.tolist()
+        efficient_students = self.data.nlargest(3, 'Eficiência')[
+            ['Nome do Aluno', 'Eficiência', 'Acertos Absolutos']
+        ].values.tolist()
+        basic_stats['most_efficient'] = efficient_students
 
         return basic_stats
 
     def generate_graphs(self) -> List[plt.Figure]:
-        """Gera gráficos para o relatório."""
         graphs = []
+        plt.style.use('seaborn')
         
-        # 1. Distribuição de notas por nível
+        # 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'}
@@ -186,36 +173,48 @@ class ReportGenerator:
         # 2. Top 10 alunos
         plt.figure(figsize=(12, 6))
         top_10 = self.data.head(10)
-        acertos = top_10['Média de Acertos'].str.rstrip('%').astype(float)
-        plt.barh(top_10['Nome do Aluno'], acertos)
-        plt.title('Top 10 Alunos por Desempenho')
-        plt.xlabel('Percentual de Acertos')
-        for i, v in enumerate(acertos):
-            plt.text(v, i, f'{v:.1f}%', va='center')
+        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')
         plt.tight_layout()
         graphs.append(plt.gcf())
         plt.close()
 
-        # 3. Relação tempo x desempenho com níveis
+        # 3. Relação tempo x acertos
         plt.figure(figsize=(10, 6))
-        colors = {'Avançado': 'green', 'Intermediário': 'yellow', 'Necessita Atenção': 'red'}
         for nivel in colors:
             mask = self.data['Nível'] == nivel
             tempo = pd.to_timedelta(self.data[mask]['Total Tempo']).dt.total_seconds() / 60
-            acertos = self.data[mask]['Média de Acertos'].str.rstrip('%').astype(float)
-            plt.scatter(tempo, acertos, c=colors[nivel], label=nivel, alpha=0.6)
-        plt.title('Relação Tempo x Desempenho por Nível')
+            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('Percentual de Acertos')
+        plt.ylabel('Número de Acertos')
         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)
+        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')
+        plt.legend()
+        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)
@@ -232,26 +231,25 @@ class ReportGenerator:
         
         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}%
+        - 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']}
-        
-        Destaques:
-        Top 3 Melhores Desempenhos:
+        - Média de Tarefas por Aluno: {self.stats['media_tarefas']:.1f}
+        - Tempo Médio Total: {self.stats['media_tempo']}
         """
         pdf.multi_cell(0, 10, summary_text)
 
-        # Adicionar top performers
-        for aluno, nota in self.stats['top_performers']:
-            pdf.cell(0, 10, f"- {aluno}: {nota}", 0, 1)
+        pdf.ln()
+        pdf.cell(0, 10, "Top 3 - Maiores Números de Acertos:", 0, 1)
+        for aluno, acertos in self.stats['top_performers']:
+            pdf.cell(0, 10, f"- {aluno}: {acertos:.0f} acertos", 0, 1)
 
         pdf.ln()
         pdf.cell(0, 10, "Alunos Mais Eficientes:", 0, 1)
-        for aluno, eficiencia, nota in self.stats['most_efficient']:
-            pdf.cell(0, 10, f"- {aluno}: Eficiência {eficiencia:.1f} (Acertos: {nota})", 0, 1)
+        for aluno, eficiencia, acertos in self.stats['most_efficient']:
+            pdf.cell(0, 10, f"- {aluno}: Eficiência {eficiencia} (Acertos: {acertos:.0f})", 0, 1)
 
-        # Gráficos e análises
         for i, graph in enumerate(graphs):
             pdf.add_page()
             graph_path = f'temp_graph_{i}.png'
@@ -259,7 +257,6 @@ class ReportGenerator:
             pdf.image(graph_path, x=10, y=30, w=270)
             os.remove(graph_path)
 
-        # Tabela detalhada 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:
@@ -267,19 +264,17 @@ class ReportGenerator:
                 pdf.set_font('Arial', 'B', 12)
                 pdf.cell(0, 10, f'Alunos - Nível {nivel}', 0, 1)
                 
-                # Cabeçalhos
-                columns = ['Nome do Aluno', 'Média de Acertos', 'Tarefas', 'Tempo Total', 'Eficiência']
+                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)
                 pdf.ln()
 
-                # Dados
                 pdf.set_font('Arial', '', 8)
                 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['Média de Acertos']), 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)
@@ -288,17 +283,13 @@ class ReportGenerator:
         pdf.output(output_path)
 
 def process_files(html_file, excel_files) -> Tuple[str, str, str]:
-    """Processa arquivos e gera relatório."""
     try:
-        # Criar diretório temporário
         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)
@@ -310,7 +301,6 @@ def process_files(html_file, excel_files) -> Tuple[str, str, str]:
                 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)
@@ -322,16 +312,13 @@ 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
         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()
         
-        # 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)
@@ -374,4 +361,6 @@ with gr.Blocks(theme=theme) as interface:
         outputs=[output_html, download_html_btn, download_pdf_btn]
     )
 
-interface.launch()
+# Iniciar a aplicação
+if __name__ == "__main__":
+    interface.launch()