Update app.py

app.py

@@ -1,3 +1,4 @@
+
 import gradio as gr
 import camelot
 import pandas as pd
@@ -11,8 +12,22 @@ 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
@@ -20,7 +35,11 @@ LIMITE_APROVACAO_FREQ = 75
 BIMESTRES = ['1º Bimestre', '2º Bimestre', '3º Bimestre', '4º Bimestre']
 CONCEITOS_VALIDOS = ['ES', 'EP', 'ET']
 
-# Definição das disciplinas de formação básica
+# 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',
@@ -40,7 +59,7 @@ FORMACAO_BASICA = {
         'BIOLOGIA',
         'FISICA',
         'QUIMICA',
-        'INGLÊS',
+        'INGLES',
         'FILOSOFIA',
         'SOCIOLOGIA',
         'ARTE',
@@ -48,33 +67,42 @@ FORMACAO_BASICA = {
     }
 }
 
-def detectar_nivel_ensino(disciplinas):
-    """Detecta se é ensino fundamental ou médio baseado nas disciplinas presentes."""
-    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'
+# Context managers
+@contextmanager
+def temp_directory():
+    temp_dir = tempfile.mkdtemp()
+    try:
+        yield temp_dir
+    finally:
+        if os.path.exists(temp_dir):
+            shutil.rmtree(temp_dir)
 
-def separar_disciplinas_por_categoria(disciplinas_dados):
-    """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
-    }
+@contextmanager
+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):
+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
@@ -95,14 +123,12 @@ def converter_nota(valor):
     
     return None
 
-def calcular_media_bimestres(notas):
+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]
-    if not notas_validas:
-        return 0
-    return sum(notas_validas) / len(notas_validas)
+    return sum(notas_validas) / len(notas_validas) if notas_validas else 0
 
-def calcular_frequencia_media(frequencias):
+def calcular_frequencia_media(frequencias: List[str]) -> float:
     """Calcula média de frequência considerando apenas bimestres cursados."""
     freq_validas = []
     for freq in frequencias:
@@ -116,12 +142,10 @@ def calcular_frequencia_media(frequencias):
         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 usando stream apenas para o nome e lattice para notas."""
+    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(
@@ -133,7 +157,7 @@ def extrair_tabelas_pdf(pdf_path):
         
         info_aluno = {}
         
-        # Procurar apenas o nome do aluno
+        # Procurar nome do aluno
         for table in tables_header:
             df = table.df
             for i in range(len(df)):
@@ -158,7 +182,7 @@ def extrair_tabelas_pdf(pdf_path):
             flavor='lattice'
         )
         
-        # Encontrar tabela de notas (procurar a maior tabela com 'Disciplina')
+        # Encontrar tabela de notas
         df_notas = None
         max_rows = 0
         
@@ -179,16 +203,22 @@ def extrair_tabelas_pdf(pdf_path):
         if df_notas is None:
             raise ValueError("Tabela de notas não encontrada")
         
-        # Adicionar apenas o nome ao DataFrame
-        df_notas.attrs['nome'] = info_aluno.get('nome', 'Nome não encontrado')
+        # 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:
-        print(f"Erro na extração das tabelas: {str(e)}")
+        logger.error(f"Erro na extração das tabelas: {str(e)}")
         raise
-        
-def obter_disciplinas_validas(df):
+
+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']
@@ -231,62 +261,72 @@ def obter_disciplinas_validas(df):
     
     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'
+    
+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_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
+    if n_cores <= len(cores_formacao_basica):
+        return cores_formacao_basica[:n_cores]
     
-    return cores_base[: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, temp_dir, titulo=None, nome_arquivo=None):
-    """Plota gráfico de evolução das notas por bimestre com visualização refinada."""
+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.")
+        raise ValueError("Nenhuma disciplina válida encontrada para plotar.")
     
-    plt.figure(figsize=(11.69, 8.27))
+    # Configuração do estilo
+    plt.style.use('seaborn-v0_8-darkgrid')
+    fig, ax = plt.subplots(figsize=(11.69, 8.27))
     
-    cores = gerar_paleta_cores(n_disciplinas)
-    marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p', 'h', '*']
-    estilos_linha = ['-', '--', '-.', ':', '-', '--', '-.', ':', '-', '--']
-    
-    plt.grid(True, linestyle='--', alpha=0.3, zorder=0)
+    # Configurar grid mais suave
+    ax.grid(True, linestyle='--', alpha=0.2, color='gray')
+    ax.set_axisbelow(True)
     
-    # Deslocamento ainda menor e mais refinado
-    deslocamentos = np.linspace(-0.03, 0.03, n_disciplinas)
+    cores = gerar_paleta_cores(n_disciplinas)
+    marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p']
+    estilos_linha = ['-', '--', '-.', ':']
     
-    # Estrutura para armazenar as posições das anotações já utilizadas
-    anotacoes_usadas = {}  # formato: {bimestre: [(y, texto)]}
+    deslocamentos = np.linspace(-0.02, 0.02, n_disciplinas)
+    anotacoes_usadas = {}
     
-    # Primeira passagem: coletar todos os valores e determinar grupos
-    grupos_notas = {}  # {bimestre: {nota: [índices]}}
-    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]
-            
-            for bim, nota in zip(bimestres, notas_validas):
-                if nota is not None:
-                    if bim not in grupos_notas:
-                        grupos_notas[bim] = {}
-                    if nota not in grupos_notas[bim]:
-                        grupos_notas[bim][nota] = []
-                    grupos_notas[bim][nota].append(idx)
-
-    # Segunda passagem: plotar e anotar
     for idx, disc_data in enumerate(disciplinas_dados):
         notas = pd.Series(disc_data['notas'])
         bimestres_cursados = disc_data['bimestres_cursados']
@@ -298,375 +338,78 @@ def plotar_evolucao_bimestres(disciplinas_dados, temp_dir, titulo=None, nome_arq
             bimestres_deslocados = [bim + desloc for bim in bimestres]
             
             if notas_validas:
-                # Plotar linha e pontos
-                plt.plot(bimestres_deslocados, notas_validas,
+                ax.plot(bimestres_deslocados, notas_validas,
                         color=cores[idx % len(cores)],
                         marker=marcadores[idx % len(marcadores)],
-                        markersize=7,
-                        linewidth=1.5,
+                        markersize=8,
+                        linewidth=2.5,
                         label=disc_data['disciplina'],
                         linestyle=estilos_linha[idx % len(estilos_linha)],
-                        alpha=0.8)
+                        alpha=0.8,
+                        zorder=3)
                 
-                # Adicionar anotações com posicionamento otimizado
-                for bim_orig, bim_desloc, nota in zip(bimestres, bimestres_deslocados, notas_validas):
+                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:
-                        # Verificar se é o primeiro índice para esta nota neste bimestre
-                        if grupos_notas[bim_orig][nota][0] == idx:
-                            # Determinar posição vertical da anotação
-                            if bim_orig not in anotacoes_usadas:
-                                anotacoes_usadas[bim_orig] = []
-                            
-                            # Encontrar posição vertical disponível
-                            y_base = nota
-                            y_offset = 10
-                            texto = f"{nota:.1f}"
-                            
-                            # Verificar sobreposição com anotações existentes
-                            while any(abs(y - (y_base + y_offset/20)) < 0.4 for y, _ in anotacoes_usadas.get(bim_orig, [])):
-                                y_offset += 5
-                            
-                            # Adicionar anotação
-                            plt.annotate(texto,
-                                       (bim_orig, nota),
-                                       textcoords="offset points",
-                                       xytext=(0, y_offset),
-                                       ha='center',
-                                       va='bottom',
-                                       fontsize=8,
-                                       bbox=dict(facecolor='white',
-                                               edgecolor='none',
-                                               alpha=0.8,
-                                               pad=0.5))
-                            
-                            anotacoes_usadas[bim_orig].append((nota + y_offset/20, texto))
-    
-    # Usar título personalizado se fornecido
-    titulo_grafico = titulo or 'Evolução das Médias por Disciplina ao Longo dos Bimestres'
-    plt.title(titulo_grafico, 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)
+                        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)
     
-    # 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
     if n_disciplinas > 8:
-        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=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:
-        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', ncol=1)
+        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()
     
-    # Usar nome de arquivo personalizado se fornecido
+    # Salvar com alta qualidade
     nome_arquivo = nome_arquivo or 'evolucao_notas.png'
     plot_path = os.path.join(temp_dir, nome_arquivo)
-    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.")
-    
-    # Criar figura
-    plt.figure(figsize=(12, 10))
-    
-    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]
-    
-    # Criar subplot com mais espaço entre os gráficos
-    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10), height_ratios=[1, 1])
-    plt.subplots_adjust(hspace=0.5)  # Aumentar espaço entre os gráficos
-    
-    # Definir cores baseadas nos limites de aprovação
-    cores_notas = ['red' if media < LIMITE_APROVACAO_NOTA else '#2ecc71' for media in medias_notas]
-    cores_freq = ['red' if media < LIMITE_APROVACAO_FREQ else '#2ecc71' for media in medias_freq]
-    
-    # Calcular médias globais
-    media_global = np.mean(medias_notas)
-    freq_global = np.mean(medias_freq)
-    
-    # Gráfico de notas
-    barras_notas = ax1.bar(disciplinas, medias_notas, color=cores_notas)
-    ax1.set_title('Média de Notas por Disciplina', pad=20, fontsize=12, fontweight='bold')
-    ax1.set_ylim(0, ESCALA_MAXIMA_NOTAS)
-    ax1.grid(True, axis='y', alpha=0.3, linestyle='--')
-    
-    # Melhorar a apresentação dos rótulos
-    ax1.set_xticklabels(disciplinas, rotation=45, ha='right', va='top')
-    ax1.set_ylabel('Notas', fontsize=10, labelpad=10)
-    
-    # Adicionar linha de média mínima
-    ax1.axhline(y=LIMITE_APROVACAO_NOTA, color='r', linestyle='--', alpha=0.3)
-    ax1.text(0.02, LIMITE_APROVACAO_NOTA + 0.1, 'Média mínima (5,0)',
-             transform=ax1.get_yaxis_transform(), color='r', alpha=0.7)
-    
-    # Valores nas barras de notas
-    for barra in barras_notas:
-        altura = barra.get_height()
-        ax1.text(barra.get_x() + barra.get_width()/2., altura,
-                f'{altura:.1f}',
-                ha='center', va='bottom', fontsize=8)
-    
-    # Gráfico de frequências
-    barras_freq = ax2.bar(disciplinas, medias_freq, color=cores_freq)
-    ax2.set_title('Frequência Média por Disciplina', pad=20, fontsize=12, fontweight='bold')
-    ax2.set_ylim(0, 110)
-    ax2.grid(True, axis='y', alpha=0.3, linestyle='--')
-    
-    # Melhorar a apresentação dos rótulos
-    ax2.set_xticklabels(disciplinas, rotation=45, ha='right', va='top')
-    ax2.set_ylabel('Frequência (%)', fontsize=10, labelpad=10)
-    
-    # Adicionar linha de frequência mínima
-    ax2.axhline(y=LIMITE_APROVACAO_FREQ, color='r', linestyle='--', alpha=0.3)
-    ax2.text(0.02, LIMITE_APROVACAO_FREQ + 1, 'Frequência mínima (75%)',
-             transform=ax2.get_yaxis_transform(), color='r', alpha=0.7)
-    
-    # Valores nas barras de frequência
-    for barra in barras_freq:
-        altura = barra.get_height()
-        ax2.text(barra.get_x() + barra.get_width()/2., altura,
-                f'{altura:.1f}%',
-                ha='center', va='bottom', fontsize=8)
-    
-    # Título global com informações de média
-    plt.suptitle(
-        f'Desempenho Geral\nMédia Global: {media_global:.1f} | Frequência Global: {freq_global:.1f}%',
-        y=0.98, fontsize=14, fontweight='bold'
-    )
-    
-    # Aviso de risco de reprovação se necessário
-    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=11, color="red", weight='bold')
-    
-    plt.tight_layout()
-    
-    # Salvar o gráfico
-    plot_path = os.path.join(temp_dir, 'medias_frequencias.png')
-    plt.savefig(plot_path, bbox_inches='tight', dpi=300)
-    plt.close()
+    fig.savefig(plot_path, bbox_inches='tight', dpi=300, facecolor='white', edgecolor='none')
+    plt.close(fig)
     
     return plot_path
 
-def gerar_relatorio_pdf(df, disciplinas_dados, grafico_basica, grafico_diversificada, grafico_medias):
-    """Gera relatório PDF com os gráficos e análises."""
-    pdf = FPDF()
-    pdf.set_auto_page_break(auto=True, margin=15)
-    
-    # Primeira página - Informações e Formação Básica
-    pdf.add_page()
-    pdf.set_font('Helvetica', 'B', 18)
-    pdf.cell(0, 10, 'Relatório de Desempenho Escolar', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
-    pdf.ln(15)
-    
-    # Informações do aluno
-    pdf.set_font('Helvetica', 'B', 12)
-    pdf.cell(0, 10, 'Informações do Aluno', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
-    pdf.ln(5)
-    
-    # Mostrar apenas o nome
-    if hasattr(df, 'attrs') and 'nome' in df.attrs:
-        pdf.set_font('Helvetica', 'B', 11)
-        pdf.cell(30, 7, 'Nome:', 0, 0)
-        pdf.set_font('Helvetica', '', 11)
-        pdf.cell(0, 7, df.attrs['nome'], 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
-    
-    pdf.ln(10)
-    
-    # Data do relatório
-    data_atual = datetime.now().strftime('%d/%m/%Y')
-    pdf.set_font('Helvetica', 'I', 10)
-    pdf.cell(0, 5, f'Data de geração: {data_atual}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
-    pdf.ln(15)
-    
-    # Gráfico de evolução da formação básica
-    pdf.set_font('Helvetica', 'B', 14)
-    pdf.cell(0, 10, 'Evolução das Notas - Formação Geral Básica', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
-    pdf.ln(10)
-    pdf.image(grafico_basica, x=10, w=190)
-    
-    # Segunda página - Parte Diversificada
-    pdf.add_page()
-    pdf.set_font('Helvetica', 'B', 14)
-    pdf.cell(0, 10, 'Evolução das Notas - Parte Diversificada', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
-    pdf.ln(10)
-    pdf.image(grafico_diversificada, x=10, w=190)
     
-    # Terceira página - Médias e Frequências
-    pdf.add_page()
-    pdf.set_font('Helvetica', 'B', 14)
-    pdf.cell(0, 10, 'Análise de Médias e Frequências', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
-    pdf.ln(10)
-    pdf.image(grafico_medias, x=10, w=190)
-    
-    # Quarta página - Análise Detalhada
-    pdf.add_page()
-    pdf.set_font('Helvetica', 'B', 14)
-    pdf.cell(0, 10, 'Análise Detalhada', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
-    pdf.ln(10)
-    
-    # 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', 'B', 12)
-    pdf.cell(0, 7, 'Resumo Geral:', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-    pdf.ln(5)
-    
-    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(10)
-    
-    # Avisos Importantes
-    pdf.set_font('Helvetica', 'B', 12)
-    pdf.cell(0, 10, 'Pontos de Atenção:', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-    pdf.ln(5)
-    
-    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:
-            pdf.set_font('Helvetica', 'B', 10)
-            pdf.cell(0, 7, f'- {disc}:', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-            pdf.set_font('Helvetica', '', 10)
-            for aviso in avisos:
-                pdf.cell(10)  # Indentação
-                pdf.cell(0, 7, f'- {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')
-    
-    # Rodapé
-    pdf.set_y(-30)
-    pdf.line(10, pdf.get_y(), 200, pdf.get_y())
-    pdf.ln(5)
-    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}")
-        
-        # Salvar o arquivo binário como um arquivo PDF temporário
-        temp_pdf = os.path.join(temp_dir, 'boletim.pdf')
-        with open(temp_pdf, 'wb') as f:
-            f.write(file)  # Salva os bytes do arquivo no disco
-        print(f"PDF salvo temporariamente em: {temp_pdf}")
-        
-        if os.path.getsize(temp_pdf) == 0:
-            return None, "O arquivo está vazio."
-        
-        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."
-            
-            # Separar disciplinas por categoria
-            categorias = separar_disciplinas_por_categoria(disciplinas_dados)
-            nivel = categorias['nivel']
-            nivel_texto = "Ensino Médio" if nivel == "medio" else "Ensino Fundamental"
-            
-            # Gerar gráficos
-            print("Gerando gráficos...")
-            grafico_basica = plotar_evolucao_bimestres(
-                categorias['formacao_basica'],
-                temp_dir,
-                titulo=f"Evolução das Médias - Formação Geral Básica ({nivel_texto})",
-                nome_arquivo='evolucao_basica.png'
-            )
-            
-            grafico_diversificada = plotar_evolucao_bimestres(
-                categorias['diversificada'],
-                temp_dir,
-                titulo=f"Evolução das Médias - Parte Diversificada ({nivel_texto})",
-                nome_arquivo='evolucao_diversificada.png'
-            )
-            
-            grafico_medias = 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, grafico_basica, grafico_diversificada, grafico_medias)
-            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,
@@ -680,8 +423,9 @@ iface = gr.Interface(
         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"
+    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__":