Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import camelot | |
| import pandas as pd | |
| import matplotlib.pyplot as plt | |
| import numpy as np | |
| from fpdf import FPDF | |
| from fpdf.enums import XPos, YPos | |
| import tempfile | |
| import os | |
| import matplotlib | |
| import shutil | |
| import colorsys | |
| from datetime import datetime | |
| matplotlib.use('Agg') | |
| # Configurações globais | |
| ESCALA_MAXIMA_NOTAS = 12 # Aumentado para melhor visualização | |
| LIMITE_APROVACAO_NOTA = 5 | |
| LIMITE_APROVACAO_FREQ = 75 | |
| BIMESTRES = ['1º Bimestre', '2º Bimestre', '3º Bimestre', '4º Bimestre'] | |
| CONCEITOS_VALIDOS = ['ES', 'EP', 'ET'] # Conceitos não numéricos válidos | |
| def converter_nota(valor): | |
| """Converte valor de nota para float, tratando casos especiais e conceitos.""" | |
| if pd.isna(valor) or valor == '-' or valor == 'N' or valor == '' or valor == 'None': | |
| return None | |
| # Se for string, limpar e verificar se é conceito | |
| if isinstance(valor, str): | |
| valor_limpo = valor.strip().upper() | |
| if valor_limpo in CONCEITOS_VALIDOS: | |
| # Converter conceitos para valores numéricos | |
| conceitos_map = {'ET': 10, 'ES': 8, 'EP': 6} | |
| return conceitos_map.get(valor_limpo) | |
| # Tentar converter para número | |
| try: | |
| return float(valor_limpo.replace(',', '.')) | |
| except: | |
| return None | |
| # Se for número, retornar diretamente | |
| if isinstance(valor, (int, float)): | |
| return float(valor) | |
| return None | |
| def calcular_media_bimestres(notas): | |
| """Calcula média considerando apenas bimestres com notas válidas.""" | |
| notas_validas = [nota for nota in notas if nota is not None] | |
| if not notas_validas: | |
| return 0 | |
| return sum(notas_validas) / len(notas_validas) | |
| def calcular_frequencia_media(frequencias): | |
| """Calcula média de frequência considerando apenas bimestres cursados.""" | |
| freq_validas = [] | |
| for freq in frequencias: | |
| try: | |
| # Limpar string e converter para número | |
| if isinstance(freq, str): | |
| freq = freq.strip().replace('%', '').replace(',', '.') | |
| if freq and freq != '-': | |
| valor = float(freq) | |
| if valor > 0: # Considerar apenas frequências positivas | |
| freq_validas.append(valor) | |
| except: | |
| continue | |
| if not freq_validas: | |
| return 0 | |
| return sum(freq_validas) / len(freq_validas) | |
| def extrair_tabelas_pdf(pdf_path): | |
| """Extrai tabelas do PDF e retorna um DataFrame processado.""" | |
| try: | |
| tables = camelot.read_pdf(pdf_path, pages='all', flavor='lattice') | |
| print(f"Tabelas extraídas: {len(tables)}") | |
| if len(tables) == 0: | |
| raise ValueError("Nenhuma tabela foi extraída do PDF.") | |
| # Processar a primeira tabela | |
| df = tables[0].df | |
| # Extrair nome do aluno e outras informações se disponível | |
| info_aluno = {} | |
| for i, row in df.iterrows(): | |
| if 'Nome do Aluno' in str(row[0]): | |
| info_aluno['nome'] = row[1].strip() if len(row) > 1 else '' | |
| elif 'RA' in str(row[0]): | |
| info_aluno['ra'] = row[1].strip() if len(row) > 1 else '' | |
| elif 'Escola' in str(row[0]): | |
| info_aluno['escola'] = row[1].strip() if len(row) > 1 else '' | |
| elif 'Turma' in str(row[0]): | |
| info_aluno['turma'] = row[1].strip() if len(row) > 1 else '' | |
| # Encontrar a tabela de notas | |
| for i, table in enumerate(tables): | |
| df_temp = table.df | |
| # Verificar se é a tabela de notas | |
| if any('Disciplina' in str(col) for col in df_temp.iloc[0]) or \ | |
| any('Bimestre' in str(col) for col in df_temp.iloc[0]): | |
| df = df_temp | |
| # Renomear as colunas corretamente | |
| df = df.rename(columns={ | |
| 0: 'Disciplina', | |
| 1: 'Nota B1', 2: 'Freq B1', 3: '%Freq B1', 4: 'AC B1', | |
| 5: 'Nota B2', 6: 'Freq B2', 7: '%Freq B2', 8: 'AC B2', | |
| 9: 'Nota B3', 10: 'Freq B3', 11: '%Freq B3', 12: 'AC B3', | |
| 13: 'Nota B4', 14: 'Freq B4', 15: '%Freq B4', 16: 'AC B4', | |
| 17: 'CF', 18: 'Nota Final', 19: 'Freq Final', 20: 'AC Final' | |
| }) | |
| break | |
| if df.empty: | |
| raise ValueError("A tabela extraída está vazia.") | |
| # Adicionar informações do aluno ao DataFrame | |
| for key, value in info_aluno.items(): | |
| df.attrs[key] = value | |
| return df | |
| except Exception as e: | |
| print(f"Erro na extração das tabelas: {str(e)}") | |
| raise | |
| # Adicionar informações do aluno ao DataFrame | |
| for key, value in info_aluno.items(): | |
| df.attrs[key] = value | |
| return df | |
| except Exception as e: | |
| print(f"Erro na extração das tabelas: {str(e)}") | |
| raise | |
| def obter_disciplinas_validas(df): | |
| """Identifica disciplinas válidas no boletim com seus dados.""" | |
| colunas_notas = ['Nota B1', 'Nota B2', 'Nota B3', 'Nota B4'] | |
| colunas_freq = ['%Freq B1', '%Freq B2', '%Freq B3', '%Freq B4'] | |
| disciplinas_dados = [] | |
| for _, row in df.iterrows(): | |
| disciplina = row['Disciplina'] | |
| if pd.isna(disciplina) or disciplina == '': | |
| continue | |
| # Coletar notas e frequências | |
| notas = [] | |
| freqs = [] | |
| bimestres_cursados = [] | |
| for i, (col_nota, col_freq) in enumerate(zip(colunas_notas, colunas_freq), 1): | |
| nota = converter_nota(row[col_nota]) | |
| freq = row[col_freq] if col_freq in row else None | |
| if nota is not None or (freq and freq != '-'): | |
| bimestres_cursados.append(i) | |
| notas.append(nota if nota is not None else 0) | |
| freqs.append(freq) | |
| else: | |
| notas.append(None) | |
| freqs.append(None) | |
| # Calcular médias apenas se houver dados válidos | |
| if bimestres_cursados: | |
| media_notas = calcular_media_bimestres(notas) | |
| media_freq = calcular_frequencia_media(freqs) | |
| disciplinas_dados.append({ | |
| 'disciplina': disciplina, | |
| 'notas': notas, | |
| 'frequencias': freqs, | |
| 'media_notas': media_notas, | |
| 'media_freq': media_freq, | |
| 'bimestres_cursados': bimestres_cursados | |
| }) | |
| return disciplinas_dados | |
| def gerar_paleta_cores(n_cores): | |
| """Gera uma paleta de cores distintas para o número de disciplinas.""" | |
| cores_base = [ | |
| '#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', | |
| '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf', | |
| '#393b79', '#637939', '#8c6d31', '#843c39', '#7b4173' | |
| ] | |
| if n_cores > len(cores_base): | |
| HSV_tuples = [(x/n_cores, 0.7, 0.85) for x in range(n_cores)] | |
| cores_extras = ['#%02x%02x%02x' % tuple(int(x*255) for x in colorsys.hsv_to_rgb(*hsv)) | |
| for hsv in HSV_tuples] | |
| return cores_extras | |
| return cores_base[:n_cores] | |
| def plotar_evolucao_bimestres(disciplinas_dados, temp_dir): | |
| """Plota gráfico de evolução das notas por bimestre.""" | |
| n_disciplinas = len(disciplinas_dados) | |
| if n_disciplinas == 0: | |
| raise ValueError("Nenhuma disciplina válida encontrada para plotar.") | |
| # Calcular tamanho da figura para A4 (proporção 1:√2) | |
| plt.figure(figsize=(11.69, 8.27)) # Tamanho A4 em polegadas | |
| cores = gerar_paleta_cores(n_disciplinas) | |
| marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p', 'h', '*'] | |
| estilos_linha = ['-', '--', '-.', ':', '-', '--', '-.', ':', '-', '--'] | |
| plt.grid(True, linestyle='--', alpha=0.3, zorder=0) | |
| for idx, disc_data in enumerate(disciplinas_dados): | |
| notas = pd.Series(disc_data['notas']) | |
| bimestres_cursados = disc_data['bimestres_cursados'] | |
| if bimestres_cursados: | |
| notas_validas = [nota for i, nota in enumerate(notas, 1) if i in bimestres_cursados and nota is not None] | |
| bimestres = [bim for bim in bimestres_cursados if notas[bim-1] is not None] | |
| if notas_validas: | |
| plt.plot(bimestres, notas_validas, | |
| color=cores[idx % len(cores)], | |
| marker=marcadores[idx % len(marcadores)], | |
| markersize=8, | |
| linewidth=2, | |
| label=disc_data['disciplina'], | |
| linestyle=estilos_linha[idx % len(estilos_linha)], | |
| alpha=0.8) | |
| for x, y in zip(bimestres, notas_validas): | |
| if y is not None: | |
| plt.annotate(f"{y:.1f}", (x, y), | |
| textcoords="offset points", | |
| xytext=(0, 5), | |
| ha='center', | |
| fontsize=8) | |
| plt.title('Evolução das Médias por Disciplina ao Longo dos Bimestres', | |
| pad=20, fontsize=12, fontweight='bold') | |
| plt.xlabel('Bimestres', fontsize=10) | |
| plt.ylabel('Notas', fontsize=10) | |
| plt.xticks([1, 2, 3, 4], ['1º Bim', '2º Bim', '3º Bim', '4º Bim']) | |
| plt.ylim(0, ESCALA_MAXIMA_NOTAS) | |
| # Adicionar linha de aprovação | |
| plt.axhline(y=LIMITE_APROVACAO_NOTA, color='r', linestyle='--', alpha=0.3) | |
| plt.text(0.02, LIMITE_APROVACAO_NOTA + 0.1, 'Média mínima para aprovação', | |
| transform=plt.gca().get_yaxis_transform(), color='r', alpha=0.5) | |
| # Ajustar legenda baseado no número de disciplinas | |
| if n_disciplinas > 8: | |
| plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=8, | |
| ncol=max(1, n_disciplinas // 12)) | |
| else: | |
| plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', ncol=1) | |
| plt.tight_layout() | |
| plot_path = os.path.join(temp_dir, 'evolucao_notas.png') | |
| plt.savefig(plot_path, bbox_inches='tight', dpi=300) | |
| plt.close() | |
| return plot_path | |
| def plotar_graficos_destacados(disciplinas_dados, temp_dir): | |
| """Plota gráficos de médias e frequências com destaques.""" | |
| n_disciplinas = len(disciplinas_dados) | |
| if not n_disciplinas: | |
| raise ValueError("Nenhuma disciplina válida encontrada no boletim.") | |
| # Calcular tamanho da figura para A4 (proporção 1:√2) | |
| plt.figure(figsize=(11.69, 8.27)) # Tamanho A4 em polegadas | |
| disciplinas = [d['disciplina'] for d in disciplinas_dados] | |
| medias_notas = [d['media_notas'] for d in disciplinas_dados] | |
| medias_freq = [d['media_freq'] for d in disciplinas_dados] | |
| cores_notas = ['red' if media < LIMITE_APROVACAO_NOTA else 'green' | |
| for media in medias_notas] | |
| cores_freq = ['red' if media < LIMITE_APROVACAO_FREQ else 'green' | |
| for media in medias_freq] | |
| media_global = np.mean(medias_notas) | |
| freq_global = np.mean(medias_freq) | |
| # Gráfico de notas | |
| plt.subplot(2, 1, 1) | |
| barras_notas = plt.bar(disciplinas, medias_notas, color=cores_notas) | |
| plt.title('Média de Notas por Disciplina', pad=20, fontsize=12, fontweight='bold') | |
| plt.xticks(rotation=45, ha='right', fontsize=8) | |
| plt.ylim(0, ESCALA_MAXIMA_NOTAS) | |
| # Adicionar linha de média mínima | |
| plt.axhline(y=LIMITE_APROVACAO_NOTA, color='r', linestyle='--', alpha=0.3) | |
| plt.text(0.02, LIMITE_APROVACAO_NOTA + 0.1, 'Média mínima', | |
| transform=plt.gca().get_yaxis_transform(), color='r', alpha=0.5) | |
| # Valores nas barras | |
| for barra in barras_notas: | |
| altura = barra.get_height() | |
| plt.text(barra.get_x() + barra.get_width()/2., altura, | |
| f'{altura:.1f}', | |
| ha='center', va='bottom', fontsize=8) | |
| # Gráfico de frequências | |
| plt.subplot(2, 1, 2) | |
| barras_freq = plt.bar(disciplinas, medias_freq, color=cores_freq) | |
| plt.title('Frequência Média por Disciplina', pad=20, fontsize=12, fontweight='bold') | |
| plt.xticks(rotation=45, ha='right', fontsize=8) | |
| plt.ylim(0, 110) # Deixar espaço para os valores acima das barras | |
| # Adicionar linha de frequência mínima | |
| plt.axhline(y=LIMITE_APROVACAO_FREQ, color='r', linestyle='--', alpha=0.3) | |
| plt.text(0.02, LIMITE_APROVACAO_FREQ + 1, 'Frequência mínima', | |
| transform=plt.gca().get_yaxis_transform(), color='r', alpha=0.5) | |
| # Valores nas barras | |
| for barra in barras_freq: | |
| altura = barra.get_height() | |
| plt.text(barra.get_x() + barra.get_width()/2., altura, | |
| f'{altura:.1f}%', | |
| ha='center', va='bottom', fontsize=8) | |
| plt.suptitle( | |
| f'Média Global: {media_global:.1f} | Frequência Global: {freq_global:.1f}%', | |
| y=0.95, fontsize=12, fontweight='bold' | |
| ) | |
| if freq_global < LIMITE_APROVACAO_FREQ: | |
| plt.figtext(0.5, 0.02, | |
| "Atenção: Risco de Reprovação por Baixa Frequência", | |
| ha="center", fontsize=10, color="red") | |
| plt.tight_layout() | |
| plot_path = os.path.join(temp_dir, 'medias_frequencias.png') | |
| plt.savefig(plot_path, bbox_inches='tight', dpi=300) | |
| plt.close() | |
| return plot_path | |
| def gerar_relatorio_pdf(df, disciplinas_dados, grafico1_path, grafico2_path): | |
| """Gera relatório PDF com os gráficos e análises.""" | |
| pdf = FPDF() | |
| pdf.set_auto_page_break(auto=True, margin=15) | |
| pdf.add_page() | |
| # Cabeçalho | |
| pdf.set_font('Helvetica', 'B', 16) | |
| pdf.cell(0, 10, 'Relatório de Desempenho Escolar', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C') | |
| pdf.ln(5) | |
| # Informações do aluno | |
| pdf.set_font('Helvetica', '', 11) | |
| if hasattr(df, 'attrs'): | |
| if 'nome' in df.attrs: | |
| pdf.cell(0, 7, f'Aluno: {df.attrs["nome"]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| if 'ra' in df.attrs: | |
| pdf.cell(0, 7, f'RA: {df.attrs["ra"]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| if 'escola' in df.attrs: | |
| pdf.cell(0, 7, f'Escola: {df.attrs["escola"]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| if 'turma' in df.attrs: | |
| pdf.cell(0, 7, f'Turma: {df.attrs["turma"]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| pdf.ln(5) | |
| # Data do relatório | |
| data_atual = datetime.now().strftime('%d/%m/%Y') | |
| pdf.set_font('Helvetica', 'I', 10) | |
| pdf.cell(0, 5, f'Relatório gerado em: {data_atual}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R') | |
| pdf.ln(10) | |
| # Gráficos | |
| pdf.image(grafico1_path, x=10, w=190) | |
| pdf.ln(10) | |
| pdf.image(grafico2_path, x=10, w=190) | |
| pdf.ln(10) | |
| # Seção de Análise | |
| pdf.set_font('Helvetica', 'B', 14) | |
| pdf.cell(0, 10, 'Análise de Desempenho', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| pdf.ln(5) | |
| # Calcular médias globais | |
| medias_notas = [d['media_notas'] for d in disciplinas_dados] | |
| medias_freq = [d['media_freq'] for d in disciplinas_dados] | |
| media_global = np.mean(medias_notas) | |
| freq_global = np.mean(medias_freq) | |
| # Resumo geral | |
| pdf.set_font('Helvetica', '', 11) | |
| pdf.cell(0, 7, f'Média Global: {media_global:.1f}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| pdf.cell(0, 7, f'Frequência Global: {freq_global:.1f}%', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| pdf.ln(5) | |
| # Avisos Importantes | |
| pdf.set_font('Helvetica', 'B', 12) | |
| pdf.cell(0, 10, 'Avisos Importantes:', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| pdf.ln(2) | |
| pdf.set_font('Helvetica', '', 10) | |
| # Disciplinas com baixo desempenho | |
| disciplinas_risco = [] | |
| for disc_data in disciplinas_dados: | |
| avisos = [] | |
| if disc_data['media_notas'] < LIMITE_APROVACAO_NOTA: | |
| avisos.append(f"Média de notas abaixo de {LIMITE_APROVACAO_NOTA} ({disc_data['media_notas']:.1f})") | |
| if disc_data['media_freq'] < LIMITE_APROVACAO_FREQ: | |
| avisos.append(f"Frequência abaixo de {LIMITE_APROVACAO_FREQ}% ({disc_data['media_freq']:.1f}%)") | |
| if avisos: | |
| disciplinas_risco.append((disc_data['disciplina'], avisos)) | |
| if disciplinas_risco: | |
| for disc, avisos in disciplinas_risco: | |
| for aviso in avisos: | |
| pdf.cell(0, 7, f'- {disc}: {aviso}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| else: | |
| pdf.cell(0, 7, 'Nenhum problema identificado.', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L') | |
| pdf.ln(5) | |
| # Rodapé | |
| pdf.set_y(-30) | |
| pdf.set_font('Helvetica', 'I', 8) | |
| pdf.cell(0, 10, 'Este relatório é uma análise automática e deve ser validado junto à secretaria da escola.', | |
| 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C') | |
| # Salvar PDF | |
| temp_pdf = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') | |
| pdf_path = temp_pdf.name | |
| pdf.output(pdf_path) | |
| return pdf_path | |
| def processar_boletim(file): | |
| """Função principal que processa o boletim e gera o relatório.""" | |
| temp_dir = None | |
| try: | |
| if file is None: | |
| return None, "Nenhum arquivo foi fornecido." | |
| temp_dir = tempfile.mkdtemp() | |
| print(f"Diretório temporário criado: {temp_dir}") | |
| if not hasattr(file, 'name') or not os.path.exists(file.name): | |
| return None, "Arquivo inválido ou corrompido." | |
| if os.path.getsize(file.name) == 0: | |
| return None, "O arquivo está vazio." | |
| temp_pdf = os.path.join(temp_dir, 'boletim.pdf') | |
| shutil.copy2(file.name, temp_pdf) | |
| print(f"PDF copiado para: {temp_pdf}") | |
| if not os.path.exists(temp_pdf) or os.path.getsize(temp_pdf) == 0: | |
| return None, "Erro ao copiar o arquivo." | |
| print("Iniciando extração das tabelas...") | |
| df = extrair_tabelas_pdf(temp_pdf) | |
| print("Tabelas extraídas com sucesso") | |
| if df is None or df.empty: | |
| return None, "Não foi possível extrair dados do PDF." | |
| try: | |
| # Processar disciplinas | |
| disciplinas_dados = obter_disciplinas_validas(df) | |
| if not disciplinas_dados: | |
| return None, "Nenhuma disciplina válida encontrada no boletim." | |
| # Gerar gráficos | |
| print("Gerando gráficos...") | |
| grafico1_path = plotar_evolucao_bimestres(disciplinas_dados, temp_dir) | |
| grafico2_path = plotar_graficos_destacados(disciplinas_dados, temp_dir) | |
| print("Gráficos gerados") | |
| # Gerar PDF | |
| print("Gerando relatório PDF...") | |
| pdf_path = gerar_relatorio_pdf(df, disciplinas_dados, grafico1_path, grafico2_path) | |
| print("Relatório PDF gerado") | |
| # Criar arquivo de retorno | |
| output_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') | |
| output_path = output_file.name | |
| shutil.copy2(pdf_path, output_path) | |
| return output_path, "Relatório gerado com sucesso!" | |
| except Exception as e: | |
| return None, f"Erro ao processar os dados: {str(e)}" | |
| except Exception as e: | |
| print(f"Erro durante o processamento: {str(e)}") | |
| return None, f"Erro ao processar o boletim: {str(e)}" | |
| finally: | |
| if temp_dir and os.path.exists(temp_dir): | |
| try: | |
| shutil.rmtree(temp_dir) | |
| print("Arquivos temporários limpos") | |
| except Exception as e: | |
| print(f"Erro ao limpar arquivos temporários: {str(e)}") | |
| # Interface Gradio | |
| iface = gr.Interface( | |
| fn=processar_boletim, | |
| inputs=gr.File(label="Upload do Boletim (PDF)"), | |
| outputs=[ | |
| gr.File(label="Relatório (PDF)"), | |
| gr.Textbox(label="Status") | |
| ], | |
| title="Análise de Boletim Escolar", | |
| description="Faça upload do boletim em PDF para gerar um relatório com análises e visualizações.", | |
| allow_flagging="never" | |
| ) | |
| if __name__ == "__main__": | |
| iface.launch(server_name="0.0.0.0") |