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 | |
| from concurrent.futures import ThreadPoolExecutor | |
| from typing import Dict, List, Tuple, Optional | |
| from io import BytesIO | |
| import logging | |
| from contextlib import contextmanager | |
| # Configurar matplotlib | |
| matplotlib.use('Agg') | |
| # Configurar logging | |
| logging.basicConfig( | |
| level=logging.INFO, | |
| format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' | |
| ) | |
| logger = logging.getLogger(__name__) | |
| # Configurações globais | |
| ESCALA_MAXIMA_NOTAS = 12 | |
| LIMITE_APROVACAO_NOTA = 5 | |
| LIMITE_APROVACAO_FREQ = 75 | |
| BIMESTRES = ['1º Bimestre', '2º Bimestre', '3º Bimestre', '4º Bimestre'] | |
| CONCEITOS_VALIDOS = ['ES', 'EP', 'ET'] | |
| # Cores para os gráficos | |
| COR_APROVADO = '#2ECC71' # Verde suave | |
| COR_REPROVADO = '#E74C3C' # Vermelho suave | |
| # Definição das disciplinas de formação básica | |
| FORMACAO_BASICA = { | |
| 'fundamental': { | |
| 'LINGUA PORTUGUESA', | |
| 'MATEMATICA', | |
| 'HISTORIA', | |
| 'GEOGRAFIA', | |
| 'CIENCIAS', | |
| 'LINGUA ESTRANGEIRA INGLES', | |
| 'ARTE', | |
| 'EDUCACAO FISICA' | |
| }, | |
| 'medio': { | |
| 'LINGUA PORTUGUESA', | |
| 'MATEMATICA', | |
| 'HISTORIA', | |
| 'GEOGRAFIA', | |
| 'BIOLOGIA', | |
| 'FISICA', | |
| 'QUIMICA', | |
| 'INGLES', | |
| 'FILOSOFIA', | |
| 'SOCIOLOGIA', | |
| 'ARTE', | |
| 'EDUCACAO FISICA' | |
| } | |
| } | |
| # Context managers | |
| def temp_directory(): | |
| temp_dir = tempfile.mkdtemp() | |
| try: | |
| yield temp_dir | |
| finally: | |
| if os.path.exists(temp_dir): | |
| shutil.rmtree(temp_dir) | |
| def temp_file(suffix=None): | |
| temp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix) | |
| try: | |
| yield temp.name | |
| finally: | |
| if os.path.exists(temp.name): | |
| os.unlink(temp.name) | |
| class PDFReport(FPDF): | |
| """Classe personalizada para geração do relatório PDF.""" | |
| def __init__(self): | |
| super().__init__() | |
| self.set_auto_page_break(auto=True, margin=15) | |
| def header_footer(self): | |
| """Adiciona header e footer padrãoo nas páginas.""" | |
| self.set_y(-30) | |
| self.line(10, self.get_y(), 200, self.get_y()) | |
| self.ln(5) | |
| self.set_font('Helvetica', 'I', 8) | |
| self.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') | |
| def converter_nota(valor) -> Optional[float]: | |
| """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 | |
| if isinstance(valor, str): | |
| valor_limpo = valor.strip().upper() | |
| if valor_limpo in CONCEITOS_VALIDOS: | |
| conceitos_map = {'ET': 10, 'ES': 8, 'EP': 6} | |
| return conceitos_map.get(valor_limpo) | |
| try: | |
| return float(valor_limpo.replace(',', '.')) | |
| except: | |
| return None | |
| if isinstance(valor, (int, float)): | |
| return float(valor) | |
| return None | |
| def calcular_media_bimestres(notas: List[float]) -> float: | |
| """Calcula média considerando apenas bimestres com notas válidas.""" | |
| notas_validas = [nota for nota in notas if nota is not None] | |
| return sum(notas_validas) / len(notas_validas) if notas_validas else 0 | |
| def calcular_frequencia_media(frequencias: List[str]) -> float: | |
| """Calcula média de frequência considerando apenas bimestres cursados.""" | |
| freq_validas = [] | |
| for freq in frequencias: | |
| try: | |
| if isinstance(freq, str): | |
| freq = freq.strip().replace('%', '').replace(',', '.') | |
| if freq and freq != '-': | |
| valor = float(freq) | |
| if valor > 0: | |
| freq_validas.append(valor) | |
| except: | |
| continue | |
| return sum(freq_validas) / len(freq_validas) if freq_validas else 0 | |
| def extrair_tabelas_pdf(pdf_path: str) -> pd.DataFrame: | |
| """Extrai tabelas do PDF usando stream para o nome e lattice para notas.""" | |
| try: | |
| # Extrair nome do aluno usando stream | |
| tables_header = camelot.read_pdf( | |
| pdf_path, | |
| pages='1', | |
| flavor='stream', | |
| edge_tol=500 | |
| ) | |
| info_aluno = {} | |
| # Procurar nome do aluno | |
| for table in tables_header: | |
| df = table.df | |
| for i in range(len(df)): | |
| for j in range(len(df.columns)): | |
| texto = str(df.iloc[i,j]).strip() | |
| if 'Nome do Aluno' in texto: | |
| try: | |
| if j + 1 < len(df.columns): | |
| nome = str(df.iloc[i,j+1]).strip() | |
| elif i + 1 < len(df): | |
| nome = str(df.iloc[i+1,j]).strip() | |
| if nome and nome != 'Nome do Aluno:': | |
| info_aluno['nome'] = nome | |
| break | |
| except: | |
| continue | |
| # Extrair tabela de notas usando lattice | |
| tables_notas = camelot.read_pdf( | |
| pdf_path, | |
| pages='all', | |
| flavor='lattice' | |
| ) | |
| # Encontrar tabela de notas | |
| df_notas = None | |
| max_rows = 0 | |
| for table in tables_notas: | |
| df_temp = table.df | |
| if len(df_temp) > max_rows and 'Disciplina' in str(df_temp.iloc[0,0]): | |
| max_rows = len(df_temp) | |
| df_notas = df_temp.copy() | |
| df_notas = df_notas.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' | |
| }) | |
| if df_notas is None: | |
| raise ValueError("Tabela de notas não encontrada") | |
| # Adicionar informações do aluno ao DataFrame | |
| df_notas.attrs['nome'] = info_aluno.get('nome', 'Nome não encontrado') | |
| return df_notas | |
| except Exception as e: | |
| logger.error(f"Erro na extração das tabelas: {str(e)}") | |
| raise | |
| def detectar_nivel_ensino(disciplinas: List[str]) -> str: | |
| """Detecta se são ensino fundamental ou médio baseado nas disciplinas.""" | |
| disciplinas_set = set(disciplinas) | |
| disciplinas_exclusivas_medio = {'BIOLOGIA', 'FISICA', 'QUIMICA', 'FILOSOFIA', 'SOCIOLOGIA'} | |
| return 'medio' if any(d in disciplinas_set for d in disciplinas_exclusivas_medio) else 'fundamental' | |
| def obter_disciplinas_validas(df: pd.DataFrame) -> List[Dict]: | |
| """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 | |
| 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) | |
| 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 separar_disciplinas_por_categoria(disciplinas_dados: List[Dict]) -> Dict: | |
| """Separa as disciplinas em formação básica e diversificada.""" | |
| disciplinas = [d['disciplina'] for d in disciplinas_dados] | |
| nivel = detectar_nivel_ensino(disciplinas) | |
| formacao_basica = [] | |
| diversificada = [] | |
| for disc_data in disciplinas_dados: | |
| if disc_data['disciplina'] in FORMACAO_BASICA[nivel]: | |
| formacao_basica.append(disc_data) | |
| else: | |
| diversificada.append(disc_data) | |
| return { | |
| 'nivel': nivel, | |
| 'formacao_basica': formacao_basica, | |
| 'diversificada': diversificada | |
| } | |
| # Funções de plotagem | |
| def gerar_paleta_cores(n_cores: int) -> List[str]: | |
| """Gera uma paleta de cores harmoniosa.""" | |
| cores_formacao_basica = [ | |
| '#2E86C1', # Azul royal | |
| '#2ECC71', # Verde esmeralda | |
| '#E74C3C', # Vermelho coral | |
| '#F1C40F', # Amarelo ouro | |
| '#8E44AD', # Roxo médio | |
| '#E67E22', # Laranja escuro | |
| '#16A085', # Verde-água | |
| '#D35400' # Laranja queimado | |
| ] | |
| if n_cores <= len(cores_formacao_basica): | |
| return cores_formacao_basica[:n_cores] | |
| # Gerar cores adicionais se necessário | |
| HSV_tuples = [(x/n_cores, 0.8, 0.9) for x in range(n_cores)] | |
| return ['#%02x%02x%02x' % tuple(int(x*255) for x in colorsys.hsv_to_rgb(*hsv)) | |
| for hsv in HSV_tuples] | |
| def plotar_evolucao_bimestres(disciplinas_dados: List[Dict], temp_dir: str, | |
| titulo: Optional[str] = None, | |
| nome_arquivo: Optional[str] = None) -> str: | |
| """Plota gráfico de evolução das notas com visual aprimorado.""" | |
| n_disciplinas = len(disciplinas_dados) | |
| if n_disciplinas == 0: | |
| raise ValueError("Nenhuma disciplina válida encontrada para plotar.") | |
| # Configuração do estilo | |
| plt.style.use('seaborn-v0_8-darkgrid') | |
| fig, ax = plt.subplots(figsize=(11.69, 8.27)) | |
| # Configurar grid mais suave | |
| ax.grid(True, linestyle='--', alpha=0.2, color='gray') | |
| ax.set_axisbelow(True) | |
| cores = gerar_paleta_cores(n_disciplinas) | |
| marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p'] | |
| estilos_linha = ['-', '--', '-.', ':'] | |
| deslocamentos = np.linspace(-0.02, 0.02, n_disciplinas) | |
| anotacoes_usadas = {} | |
| for idx, disc_data in enumerate(disciplinas_dados): | |
| notas = pd.Series(disc_data['notas']) | |
| bimestres_cursados = disc_data['bimestres_cursados'] | |
| desloc = deslocamentos[idx] | |
| 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] | |
| bimestres_deslocados = [bim + desloc for bim in bimestres] | |
| if notas_validas: | |
| ax.plot(bimestres_deslocados, notas_validas, | |
| color=cores[idx % len(cores)], | |
| marker=marcadores[idx % len(marcadores)], | |
| markersize=8, | |
| linewidth=2.5, | |
| label=disc_data['disciplina'], | |
| linestyle=estilos_linha[idx % len(estilos_linha)], | |
| alpha=0.8, | |
| zorder=3) | |
| ax.fill_between(bimestres_deslocados, 0, notas_validas, | |
| color=cores[idx % len(cores)], alpha=0.1) | |
| for bim, nota in zip(bimestres_deslocados, notas_validas): | |
| if nota is not None: | |
| y_offset = 10 | |
| while any(abs(y - (nota + y_offset/20)) < 0.4 for y, _ in anotacoes_usadas.get(bim, [])): | |
| y_offset += 5 | |
| ax.annotate(f"{nota:.1f}", | |
| (bim, nota), | |
| xytext=(0, y_offset), | |
| textcoords="offset points", | |
| ha='center', | |
| va='bottom', | |
| fontsize=9, | |
| bbox=dict(facecolor='white', | |
| edgecolor=cores[idx % len(cores)], | |
| alpha=0.8, | |
| pad=2, | |
| boxstyle='round,pad=0.5')) | |
| if bim not in anotacoes_usadas: | |
| anotacoes_usadas[bim] = [] | |
| anotacoes_usadas[bim].append((nota + y_offset/20, nota)) | |
| titulo_grafico = titulo or 'Evolução das Médias por Disciplina' | |
| ax.set_title(titulo_grafico, pad=20, fontsize=14, fontweight='bold') | |
| ax.set_xlabel('Bimestres', fontsize=12, labelpad=10) | |
| ax.set_ylabel('Notas', fontsize=12, labelpad=10) | |
| ax.spines['top'].set_visible(False) | |
| ax.spines['right'].set_visible(False) | |
| ax.set_xticks([1, 2, 3, 4]) | |
| ax.set_xticklabels(['1º Bim', '2º Bim', '3º Bim', '4º Bim'], fontsize=10) | |
| ax.set_ylim(0, ESCALA_MAXIMA_NOTAS) | |
| ax.axhline(y=LIMITE_APROVACAO_NOTA, color=COR_REPROVADO, linestyle='--', alpha=0.3, linewidth=2) | |
| ax.text(0.02, LIMITE_APROVACAO_NOTA + 0.1, 'Média mínima para aprovação', | |
| transform=ax.get_yaxis_transform(), color=COR_REPROVADO, alpha=0.7) | |
| if n_disciplinas > 8: | |
| ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=9, framealpha=0.8, fancybox=True, shadow=True, | |
| ncol=max(1, n_disciplinas // 12)) | |
| else: | |
| ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=10, framealpha=0.8, fancybox=True, shadow=True) | |
| plt.tight_layout() | |
| # Força a renderização para evitar o erro de renderizador | |
| fig.canvas.draw() | |
| # Salvar com alta qualidade | |
| nome_arquivo = nome_arquivo or 'evolucao_notas.png' | |
| plot_path = os.path.join(temp_dir, nome_arquivo) | |
| fig.savefig(plot_path, bbox_inches='tight', dpi=300, facecolor='white', edgecolor='none') | |
| plt.close(fig) | |
| return plot_path | |
| # Interface Gradio | |
| iface = gr.Interface( | |
| fn=processar_boletim, | |
| inputs=gr.File( | |
| label="Upload do Boletim (PDF)", | |
| type="binary", | |
| file_types=[".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", | |
| theme=gr.themes.Default() | |
| ) | |
| if __name__ == "__main__": | |
| iface.launch( | |
| server_name="0.0.0.0", | |
| share=True | |
| ) |