Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| import re | |
| import os | |
| import matplotlib.pyplot as plt | |
| from datetime import timedelta | |
| from fpdf import FPDF | |
| from weasyprint import HTML | |
| import seaborn as sns | |
| from typing import Tuple, Dict, List | |
| import logging | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| logging.basicConfig( | |
| level=logging.INFO, | |
| format='%(asctime)s - %(levelname)s - %(message)s' | |
| ) | |
| class DataProcessor: | |
| def parse_duration(duration_str: str) -> timedelta: | |
| try: | |
| h, m, s = map(int, duration_str.split(':')) | |
| return timedelta(hours=h, minutes=m, seconds=s) | |
| except: | |
| return timedelta(0) | |
| def format_timedelta(td: timedelta) -> str: | |
| total_seconds = int(td.total_seconds()) | |
| hours, remainder = divmod(total_seconds, 3600) | |
| minutes, seconds = divmod(remainder, 60) | |
| return f"{hours:02}:{minutes:02}:{seconds:02}" | |
| def normalize_html_to_csv(input_html_path: str, output_csv_path: str) -> None: | |
| try: | |
| html_data = pd.read_html(input_html_path) | |
| data = html_data[0] | |
| data.to_csv(output_csv_path, index=False, encoding='utf-8-sig') | |
| logging.info(f"HTML normalizado com sucesso: {output_csv_path}") | |
| except Exception as e: | |
| logging.error(f"Erro ao normalizar HTML: {str(e)}") | |
| raise | |
| def normalize_excel_to_csv(input_excel_path: str, output_csv_path: str) -> None: | |
| try: | |
| excel_data = pd.read_excel(input_excel_path) | |
| unnecessary_columns = [col for col in excel_data.columns if 'Unnamed' in str(col)] | |
| if unnecessary_columns: | |
| excel_data = excel_data.drop(columns=unnecessary_columns) | |
| excel_data.to_csv(output_csv_path, index=False, encoding='utf-8-sig') | |
| logging.info(f"Excel normalizado com sucesso: {output_csv_path}") | |
| except Exception as e: | |
| logging.error(f"Erro ao normalizar Excel: {str(e)}") | |
| raise | |
| class StudentAnalyzer: | |
| def __init__(self, tarefas_df: pd.DataFrame, alunos_df: pd.DataFrame): | |
| self.tarefas_df = tarefas_df | |
| self.alunos_df = alunos_df | |
| self.processor = DataProcessor() | |
| def prepare_data(self) -> pd.DataFrame: | |
| self.tarefas_df.columns = self.tarefas_df.columns.str.strip() | |
| self.alunos_df.columns = self.alunos_df.columns.str.strip() | |
| 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") | |
| 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: | |
| 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() | |
| self.alunos_df['Aluno_Pattern'] = self.alunos_df.apply( | |
| lambda row: generate_aluno_pattern(row['RA'], row['Dig. RA']), axis=1 | |
| ) | |
| def extract_pattern(nome): | |
| if isinstance(nome, str): | |
| match = re.search(r'\d+.*', nome.lower()) | |
| return match.group(0) if match else None | |
| return None | |
| self.tarefas_df['Aluno_Pattern'] = self.tarefas_df['Aluno'].apply(extract_pattern) | |
| return self.calculate_metrics() | |
| def calculate_metrics(self) -> pd.DataFrame: | |
| metrics_df = pd.DataFrame() | |
| for _, aluno in self.alunos_df.iterrows(): | |
| aluno_pattern = aluno['Aluno_Pattern'] | |
| 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() | |
| # Calcula eficiência como float diretamente | |
| eficiencia = (acertos_total / duracao_total.total_seconds() * 3600) | |
| metrics = { | |
| 'Nome do Aluno': aluno['Nome do Aluno'], | |
| 'Tarefas Completadas': len(aluno_tarefas), | |
| 'Acertos Absolutos': acertos_total, | |
| 'Total Tempo': str(duracao_total), | |
| 'Tempo Médio por Tarefa': str(duracao_total / len(aluno_tarefas)), | |
| 'Eficiência': eficiencia # Armazena como float, não como string | |
| } | |
| metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True) | |
| # Converte explicitamente a coluna Eficiência para float | |
| metrics_df['Eficiência'] = metrics_df['Eficiência'].astype(float) | |
| return metrics_df | |
| class ReportGenerator: | |
| 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) | |
| self.data = self.data.sort_values('Acertos Absolutos', ascending=False) | |
| def classify_performance(self, acertos): | |
| if acertos >= 10: | |
| return 'Avançado' | |
| elif acertos >= 5: | |
| return 'Intermediário' | |
| else: | |
| 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') | |
| basic_stats['top_performers'] = top_students[['Nome do Aluno', 'Acertos Absolutos']].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]: | |
| graphs = [] | |
| plt.style.use('seaborn') | |
| # 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'} | |
| bars = plt.bar(nivel_counts.index, nivel_counts.values) | |
| 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') | |
| plt.ylabel('Número de Alunos') | |
| graphs.append(plt.gcf()) | |
| plt.close() | |
| # 2. Top 10 alunos | |
| plt.figure(figsize=(12, 6)) | |
| top_10 = self.data.head(10) | |
| 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 acertos | |
| plt.figure(figsize=(10, 6)) | |
| for nivel in colors: | |
| 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) | |
| plt.title('Relação Tempo x Acertos por Nível') | |
| plt.xlabel('Tempo Total (minutos)') | |
| 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: | |
| class PDF(FPDF): | |
| def header(self): | |
| self.set_font('Arial', 'B', 15) | |
| self.cell(0, 10, 'Relatório de Desempenho - Análise Detalhada', 0, 1, 'C') | |
| self.ln(10) | |
| pdf = PDF('L', 'mm', 'A4') | |
| # Sumário executivo | |
| pdf.add_page() | |
| pdf.set_font('Arial', 'B', 12) | |
| pdf.cell(0, 10, 'Sumário Executivo', 0, 1) | |
| pdf.set_font('Arial', '', 10) | |
| 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} | |
| - Total de Alunos: {self.stats['total_alunos']} | |
| - 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) | |
| 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, acertos in self.stats['most_efficient']: | |
| # Formata a eficiência com 2 casas decimais ao exibir | |
| pdf.cell(0, 10, f"- {aluno}: Eficiência {eficiencia:.2f} (Acertos: {acertos:.0f})", 0, 1) | |
| for i, graph in enumerate(graphs): | |
| pdf.add_page() | |
| graph_path = f'temp_graph_{i}.png' | |
| graph.savefig(graph_path) | |
| pdf.image(graph_path, x=10, y=30, w=270) | |
| os.remove(graph_path) | |
| 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', 12) | |
| pdf.cell(0, 10, f'Alunos - Nível {nivel}', 0, 1) | |
| 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() | |
| 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['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) | |
| pdf.ln() | |
| pdf.output(output_path) | |
| def process_files(html_file, excel_files) -> Tuple[str, str, str]: | |
| try: | |
| temp_dir = "temp_files" | |
| os.makedirs(temp_dir, exist_ok=True) | |
| for file in os.listdir(temp_dir): | |
| os.remove(os.path.join(temp_dir, file)) | |
| html_path = os.path.join(temp_dir, "alunos.htm") | |
| with open(html_path, "wb") as f: | |
| f.write(html_file) | |
| excel_paths = [] | |
| for i, excel_file in enumerate(excel_files): | |
| excel_path = os.path.join(temp_dir, f"tarefa_{i}.xlsx") | |
| with open(excel_path, "wb") as f: | |
| f.write(excel_file) | |
| excel_paths.append(excel_path) | |
| processor = DataProcessor() | |
| alunos_csv_path = os.path.join(temp_dir, "alunos.csv") | |
| processor.normalize_html_to_csv(html_path, alunos_csv_path) | |
| tarefas_df = pd.DataFrame() | |
| for excel_path in excel_paths: | |
| csv_path = excel_path.replace('.xlsx', '.csv') | |
| processor.normalize_excel_to_csv(excel_path, csv_path) | |
| df = pd.read_csv(csv_path) | |
| tarefas_df = pd.concat([tarefas_df, df], ignore_index=True) | |
| 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() | |
| 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) | |
| 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 | |
| # 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") | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Markdown("## Lista de Alunos (arquivo .htm)") | |
| html_file = gr.File(label="Upload do arquivo HTML", type="binary") | |
| with gr.Column(): | |
| gr.Markdown("## Relatórios de Tarefas (arquivos .xlsx)") | |
| excel_files = gr.Files(label="Upload dos arquivos Excel", type="binary", file_count="multiple") | |
| generate_btn = gr.Button("Gerar Relatório", variant="primary") | |
| output_html = gr.HTML() | |
| download_html_btn = gr.File(label="Download HTML Report") | |
| download_pdf_btn = gr.File(label="Download PDF Report") | |
| generate_btn.click( | |
| fn=process_files, | |
| inputs=[html_file, excel_files], | |
| outputs=[output_html, download_html_btn, download_pdf_btn] | |
| ) | |
| # Iniciar a aplicação | |
| if __name__ == "__main__": | |
| interface.launch() |