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 typing import Tuple, Dict, List | |
| import logging | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| # Configuração de logging | |
| 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) | |
| 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 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() | |
| 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': (acertos_total / duracao_total.total_seconds() * 3600) | |
| } | |
| metrics_df = pd.concat([metrics_df, pd.DataFrame([metrics])], ignore_index=True) | |
| return metrics_df.sort_values('Acertos Absolutos', ascending=False) | |
| 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) | |
| 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')[ | |
| ['Nome do Aluno', 'Acertos Absolutos'] | |
| ].values.tolist() | |
| basic_stats['top_performers'] = top_students | |
| 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]: | |
| plt.style.use('seaborn') | |
| graphs = [] | |
| # 1. Distribuição por nível | |
| plt.figure(figsize=(12, 6)) | |
| nivel_counts = self.data['Nível'].value_counts() | |
| colors = {'Avançado': '#2ecc71', 'Intermediário': '#f1c40f', 'Necessita Atenção': '#e74c3c'} | |
| 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', pad=20, fontsize=12) | |
| plt.ylabel('Número de Alunos', labelpad=10) | |
| plt.grid(True, alpha=0.3) | |
| graphs.append(plt.gcf()) | |
| plt.close() | |
| # 2. Top 10 alunos | |
| plt.figure(figsize=(12, 6)) | |
| top_10 = self.data.head(10) | |
| bars = plt.barh(top_10['Nome do Aluno'], top_10['Acertos Absolutos'], | |
| color='#3498db') | |
| plt.title('Top 10 Alunos - Acertos Absolutos', pad=20, fontsize=12) | |
| plt.xlabel('Número de Acertos', labelpad=10) | |
| for i, bar in enumerate(bars): | |
| plt.text(bar.get_width(), bar.get_y() + bar.get_height()/2, | |
| f' {bar.get_width():.0f}', | |
| va='center') | |
| plt.grid(True, alpha=0.3) | |
| plt.tight_layout() | |
| graphs.append(plt.gcf()) | |
| plt.close() | |
| # 3. Relação tempo x acertos | |
| plt.figure(figsize=(12, 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, s=100) | |
| plt.title('Relação entre Tempo e Acertos por Nível', pad=20, fontsize=12) | |
| plt.xlabel('Tempo Total (minutos)', labelpad=10) | |
| plt.ylabel('Número de Acertos', labelpad=10) | |
| plt.legend() | |
| plt.grid(True, alpha=0.3) | |
| graphs.append(plt.gcf()) | |
| plt.close() | |
| # 4. Relação Tarefas x Acertos com linha de tendência | |
| plt.figure(figsize=(12, 6)) | |
| plt.scatter(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'], | |
| color='#3498db', alpha=0.6, s=100) | |
| z = np.polyfit(self.data['Tarefas Completadas'], self.data['Acertos Absolutos'], 1) | |
| p = np.poly1d(z) | |
| x_range = np.linspace(self.data['Tarefas Completadas'].min(), | |
| self.data['Tarefas Completadas'].max(), 100) | |
| plt.plot(x_range, p(x_range), "r--", alpha=0.8, label='Tendência') | |
| plt.title('Relação entre Tarefas Completadas e Acertos', pad=20, fontsize=12) | |
| plt.xlabel('Número de Tarefas Completadas', labelpad=10) | |
| plt.ylabel('Número de Acertos', labelpad=10) | |
| plt.legend() | |
| plt.grid(True, alpha=0.3) | |
| 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) | |
| self.set_fill_color(240, 240, 240) | |
| self.cell(0, 15, 'Relatório de Desempenho - Análise Detalhada', 0, 1, 'C', True) | |
| self.ln(10) | |
| pdf = PDF('L', 'mm', 'A4') | |
| # Introdução | |
| pdf.add_page() | |
| pdf.set_font('Arial', 'B', 14) | |
| pdf.set_fill_color(240, 240, 240) | |
| pdf.cell(0, 10, 'Introdução', 0, 1, 'L', True) | |
| pdf.ln(5) | |
| pdf.set_font('Arial', '', 11) | |
| intro_text = """ | |
| Este relatório apresenta uma análise abrangente do desempenho dos alunos nas atividades realizadas. | |
| Os dados são analisados considerando três aspectos principais: | |
| • Acertos: Total de questões respondidas corretamente | |
| • Engajamento: Número de tarefas completadas | |
| • Dedicação: Tempo investido nas atividades | |
| Os alunos são classificados em três níveis de acordo com seu desempenho: | |
| • Avançado: 10 ou mais acertos - Excelente domínio do conteúdo | |
| • Intermediário: 5 a 9 acertos - Bom entendimento, com espaço para melhorias | |
| • Necessita Atenção: Menos de 5 acertos - Requer suporte adicional | |
| A eficiência é medida em acertos por hora, permitindo identificar alunos que | |
| conseguem bons resultados com uso eficiente do tempo. | |
| """ | |
| pdf.multi_cell(0, 7, intro_text) | |
| # Visão Geral | |
| pdf.add_page() | |
| pdf.set_font('Arial', 'B', 14) | |
| pdf.cell(0, 10, 'Visão Geral da Turma', 0, 1, 'L', True) | |
| pdf.ln(5) | |
| tempo_medio = pd.to_timedelta(self.stats['media_tempo']) | |
| minutos = int(tempo_medio.total_seconds() // 60) | |
| segundos = int(tempo_medio.total_seconds() % 60) | |
| pdf.set_font('Arial', '', 11) | |
| stats_text = f""" | |
| Participação e Resultados: | |
| • Total de Alunos Participantes: {self.stats['total_alunos']} | |
| • Média de Tarefas por Aluno: {self.stats['media_tarefas']:.1f} | |
| • Média de Acertos: {self.stats['media_acertos']:.1f} | |
| • Tempo Médio de Dedicação: {minutos} minutos e {segundos} segundos | |
| Distribuição de Desempenho: | |
| • Desvio Padrão: {self.stats['desvio_padrao']:.1f} acertos | |
| • Mediana: {self.stats['mediana_acertos']:.1f} acertos | |
| """ | |
| pdf.multi_cell(0, 7, stats_text) | |
| # Destaques | |
| pdf.ln(5) | |
| pdf.set_font('Arial', 'B', 12) | |
| pdf.cell(0, 10, 'Destaques de Desempenho', 0, 1) | |
| pdf.set_font('Arial', '', 11) | |
| pdf.ln(3) | |
| pdf.cell(0, 7, "🏆 Melhores Desempenhos:", 0, 1) | |
| for aluno, acertos in self.stats['top_performers']: | |
| pdf.cell(0, 7, f"• {aluno}: {acertos:.0f} acertos", 0, 1) | |
| pdf.ln(3) | |
| pdf.cell(0, 7, "⚡ Maior Eficiência:", 0, 1) | |
| for aluno, eficiencia, acertos in self.stats['most_efficient']: | |
| pdf.cell(0, 7, f"• {aluno}: {eficiencia:.1f} acertos/hora ({acertos:.0f} acertos totais)", 0, 1) | |
| # Gráficos e Análises | |
| for i, graph in enumerate(graphs): | |
| pdf.add_page() | |
| graph_path = f'temp_graph_{i}.png' | |
| graph.savefig(graph_path, dpi=300, bbox_inches='tight') | |
| pdf.image(graph_path, x=10, y=30, w=270) | |
| os.remove(graph_path) | |
| # Título e explicação para cada gráfico | |
| pdf.ln(150) # Espaço após o gráfico | |
| pdf.set_font('Arial', 'B', 12) | |
| if i == 0: | |
| pdf.cell(0, 10, 'Análise da Distribuição por Nível', 0, 1, 'L', True) | |
| pdf.set_font('Arial', '', 11) | |
| pdf.multi_cell(0, 6, """ | |
| Este gráfico ilustra como os alunos estão distribuídos entre os três níveis de desempenho. | |
| • Verde: Alunos no nível Avançado - demonstram excelente compreensão | |
| • Amarelo: Alunos no nível Intermediário - bom progresso com espaço para melhorias | |
| • Vermelho: Alunos que Necessitam Atenção - requerem suporte adicional | |
| """) | |
| elif i == 1: | |
| pdf.cell(0, 10, 'Top 10 Alunos por Acertos', 0, 1, 'L', True) | |
| pdf.set_font('Arial', '', 11) | |
| pdf.multi_cell(0, 6, """ | |
| Destaca os dez alunos com maior número de acertos absolutos. | |
| Este ranking permite: | |
| • Identificar exemplos de sucesso na turma | |
| • Reconhecer diferentes níveis de excelência | |
| • Estabelecer metas realistas para os demais alunos | |
| """) | |
| elif i == 2: | |
| pdf.cell(0, 10, 'Relação Tempo x Desempenho', 0, 1, 'L', True) | |
| pdf.set_font('Arial', '', 11) | |
| pdf.multi_cell(0, 6, """ | |
| Mostra a relação entre tempo dedicado e número de acertos. | |
| Pontos importantes: | |
| • Cores indicam o nível de cada aluno | |
| • Posição vertical mostra o número de acertos | |
| • Posição horizontal indica o tempo total dedicado | |
| • Dispersão dos pontos revela diferentes padrões de estudo | |
| """) | |
| elif i == 3: | |
| pdf.cell(0, 10, 'Progresso por Número de Tarefas', 0, 1, 'L', True) | |
| pdf.set_font('Arial', '', 11) | |
| pdf.multi_cell(0, 6, """ | |
| Analisa se mais tarefas realizadas resultam em melhor desempenho. | |
| A linha de tendência (tracejada) indica: | |
| • Correlação entre quantidade de tarefas e acertos | |
| • Expectativa média de progresso | |
| • Alunos acima da linha superam a expectativa da turma | |
| """) | |
| # Detalhamento 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: | |
| pdf.add_page() | |
| pdf.set_font('Arial', 'B', 14) | |
| pdf.cell(0, 10, f'Detalhamento - Nível {nivel}', 0, 1, 'L', True) | |
| pdf.ln(5) | |
| # Tabela | |
| colunas = [ | |
| ('Nome do Aluno', 80), | |
| ('Acertos', 25), | |
| ('Tarefas', 25), | |
| ('Tempo Total', 35), | |
| ('Eficiência', 25) | |
| ] | |
| # Cabeçalho da tabela | |
| pdf.set_font('Arial', 'B', 10) | |
| pdf.set_fill_color(230, 230, 230) | |
| for titulo, largura in colunas: | |
| pdf.cell(largura, 8, titulo, 1, 0, 'C', True) | |
| pdf.ln() | |
| # Dados | |
| pdf.set_font('Arial', '', 10) | |
| for _, row in alunos_nivel.iterrows(): | |
| tempo = pd.to_timedelta(row['Total Tempo']) | |
| tempo_str = f"{int(tempo.total_seconds() // 60)}min {int(tempo.total_seconds() % 60)}s" | |
| pdf.cell(80, 7, str(row['Nome do Aluno'])[:40], 1) | |
| pdf.cell(25, 7, f"{row['Acertos Absolutos']:.0f}", 1, 0, 'C') | |
| pdf.cell(25, 7, str(row['Tarefas Completadas']), 1, 0, 'C') | |
| pdf.cell(35, 7, tempo_str, 1, 0, 'C') | |
| pdf.cell(25, 7, f"{float(row['Eficiência']):.1f}", 1, 0, 'C') | |
| pdf.ln() | |
| # Recomendações Finais | |
| pdf.add_page() | |
| pdf.set_font('Arial', 'B', 14) | |
| pdf.cell(0, 10, 'Recomendações e Próximos Passos', 0, 1, 'L', True) | |
| pdf.ln(5) | |
| pdf.set_font('Arial', '', 11) | |
| percent_necessita_atencao = len(self.data[self.data['Nível'] == 'Necessita Atenção']) / len(self.data) * 100 | |
| recom_text = f""" | |
| Com base na análise dos dados, recomenda-se: | |
| 1. Ações Imediatas: | |
| • Implementar monitoria com alunos do nível Avançado | |
| • Realizar reforço focado nos {percent_necessita_atencao:.1f}% que necessitam atenção | |
| • Desenvolver planos de estudo personalizados | |
| 2. Melhorias no Processo: | |
| • Acompanhamento individualizado dos alunos com baixo desempenho | |
| • Feedback regular sobre o progresso | |
| • Atividades extras para alunos com alta eficiência | |
| 3. Próximos Passos: | |
| • Compartilhar resultados individuais | |
| • Agendar sessões de reforço | |
| • Reconhecer publicamente bons desempenhos | |
| • Estabelecer metas claras de melhoria | |
| """ | |
| pdf.multi_cell(0, 7, recom_text) | |
| pdf.output(output_path) | |
| def process_files(html_file, excel_files) -> Tuple[str, str, str]: | |
| """Processa arquivos e gera relatório.""" | |
| try: | |
| 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) | |
| 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) | |
| # Processar arquivos | |
| 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) | |
| # 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) | |
| 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 | |
| Este sistema analisa o desempenho dos alunos e gera um relatório detalhado com: | |
| - Análise estatística completa | |
| - Visualizações gráficas | |
| - Recomendações personalizadas | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Markdown("## Lista de Alunos") | |
| html_file = gr.File( | |
| label="Arquivo HTML com lista de alunos (.htm)", | |
| type="binary", | |
| file_types=[".htm", ".html"] | |
| ) | |
| with gr.Column(): | |
| gr.Markdown("## Relatórios de Tarefas") | |
| excel_files = gr.Files( | |
| label="Arquivos Excel com dados das tarefas (.xlsx)", | |
| type="binary", | |
| file_count="multiple", | |
| file_types=[".xlsx"] | |
| ) | |
| with gr.Row(): | |
| generate_btn = gr.Button("Gerar Relatório", variant="primary", size="lg") | |
| with gr.Row(): | |
| output_html = gr.HTML() | |
| with gr.Row(): | |
| with gr.Column(): | |
| download_html_btn = gr.File( | |
| label="Download Relatório HTML", | |
| type="filepath", | |
| interactive=False | |
| ) | |
| with gr.Column(): | |
| download_pdf_btn = gr.File( | |
| label="Download Relatório PDF", | |
| type="filepath", | |
| interactive=False | |
| ) | |
| generate_btn.click( | |
| fn=process_files, | |
| inputs=[html_file, excel_files], | |
| outputs=[output_html, download_html_btn, download_pdf_btn] | |
| ) | |
| if __name__ == "__main__": | |
| interface.launch( | |
| share=False, | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| show_error=True | |
| ) |