Update app.py

app.py

@@ -11,22 +11,8 @@ 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
@@ -34,10 +20,6 @@ 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': {
@@ -58,7 +40,7 @@ FORMACAO_BASICA = {
         'BIOLOGIA',
         'FISICA',
         'QUIMICA',
-        'INGLES',
+        'INGLÊS',
         'FILOSOFIA',
         'SOCIOLOGIA',
         'ARTE',
@@ -66,42 +48,33 @@ FORMACAO_BASICA = {
     }
 }
 
-# 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)
-
-@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)
+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'
 
-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ão 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 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
+    }
 
-def converter_nota(valor) -> Optional[float]:
+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
@@ -122,12 +95,14 @@ def converter_nota(valor) -> Optional[float]:
     
     return None
 
-def calcular_media_bimestres(notas: List[float]) -> float:
+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]
-    return sum(notas_validas) / len(notas_validas) if notas_validas else 0
+    if not notas_validas:
+        return 0
+    return sum(notas_validas) / len(notas_validas)
 
-def calcular_frequencia_media(frequencias: List[str]) -> float:
+def calcular_frequencia_media(frequencias):
     """Calcula média de frequência considerando apenas bimestres cursados."""
     freq_validas = []
     for freq in frequencias:
@@ -141,10 +116,12 @@ def calcular_frequencia_media(frequencias: List[str]) -> float:
         except:
             continue
     
-    return sum(freq_validas) / len(freq_validas) if freq_validas else 0
+    if not freq_validas:
+        return 0
+    return sum(freq_validas) / len(freq_validas)
 
-def extrair_tabelas_pdf(pdf_path: str) -> pd.DataFrame:
-    """Extrai tabelas do PDF usando stream para o nome e lattice para notas."""
+def extrair_tabelas_pdf(pdf_path):
+    """Extrai tabelas do PDF usando stream apenas para o nome e lattice para notas."""
     try:
         # Extrair nome do aluno usando stream
         tables_header = camelot.read_pdf(
@@ -156,7 +133,7 @@ def extrair_tabelas_pdf(pdf_path: str) -> pd.DataFrame:
         
         info_aluno = {}
         
-        # Procurar nome do aluno
+        # Procurar apenas o nome do aluno
         for table in tables_header:
             df = table.df
             for i in range(len(df)):
@@ -181,7 +158,7 @@ def extrair_tabelas_pdf(pdf_path: str) -> pd.DataFrame:
             flavor='lattice'
         )
         
-        # Encontrar tabela de notas
+        # Encontrar tabela de notas (procurar a maior tabela com 'Disciplina')
         df_notas = None
         max_rows = 0
         
@@ -202,22 +179,16 @@ def extrair_tabelas_pdf(pdf_path: str) -> pd.DataFrame:
         if df_notas is None:
             raise ValueError("Tabela de notas não encontrada")
         
-        # Adicionar informações do aluno ao DataFrame
+        # Adicionar apenas o nome 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)}")
+        print(f"Erro na extração das tabelas: {str(e)}")
         raise
-
-def detectar_nivel_ensino(disciplinas: List[str]) -> str:
-    """Detecta se é 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]:
+        
+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']
@@ -260,71 +231,62 @@ def obter_disciplinas_validas(df: pd.DataFrame) -> List[Dict]:
     
     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
+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_formacao_basica):
-        return cores_formacao_basica[:n_cores]
+    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
     
-    # 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]
+    return cores_base[:n_cores]
 
-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."""
+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."""
     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)
+    plt.figure(figsize=(11.69, 8.27))
     
     cores = gerar_paleta_cores(n_disciplinas)
-    marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p']
-    estilos_linha = ['-', '--', '-.', ':']
+    marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p', 'h', '*']
+    estilos_linha = ['-', '--', '-.', ':', '-', '--', '-.', ':', '-', '--']
     
-    deslocamentos = np.linspace(-0.02, 0.02, n_disciplinas)
-    anotacoes_usadas = {}
+    plt.grid(True, linestyle='--', alpha=0.3, zorder=0)
     
+    # Deslocamento ainda menor e mais refinado
+    deslocamentos = np.linspace(-0.03, 0.03, n_disciplinas)
+    
+    # Estrutura para armazenar as posições das anotações já utilizadas
+    anotacoes_usadas = {}  # formato: {bimestre: [(y, texto)]}
+    
+    # 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']
@@ -336,341 +298,374 @@ def plotar_evolucao_bimestres(disciplinas_dados: List[Dict], temp_dir: str,
             bimestres_deslocados = [bim + desloc for bim in bimestres]
             
             if notas_validas:
-                ax.plot(bimestres_deslocados, notas_validas,
+                # Plotar linha e pontos
+                plt.plot(bimestres_deslocados, notas_validas,
                         color=cores[idx % len(cores)],
                         marker=marcadores[idx % len(marcadores)],
-                        markersize=8,
-                        linewidth=2.5,
+                        markersize=7,
+                        linewidth=1.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)
+                        alpha=0.8)
                 
-                for bim, nota in zip(bimestres_deslocados, notas_validas):
+                # Adicionar anotações com posicionamento otimizado
+                for bim_orig, bim_desloc, nota in zip(bimestres, 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)
-    
+                        # 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)
+    
+    # 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:
-        ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=9, framealpha=0.8, fancybox=True, shadow=True,
+        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=8,
                   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.legend(bbox_to_anchor=(1.05, 1), loc='upper left', ncol=1)
     
     plt.tight_layout()
-
-    # Força a renderização para evitar o erro de renderizador
-    fig.canvas.draw()
     
-    # Salvar com alta qualidade
+    # Usar nome de arquivo personalizado se fornecido
     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)
-    
+    plt.savefig(plot_path, bbox_inches='tight', dpi=300)
+    plt.close()
     return plot_path
-    
-def plotar_graficos_destacados(disciplinas_dados: List[Dict], temp_dir: str) -> str:
-    """Plota gráficos de médias e frequências com visual aprimorado."""
+
+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.")
     
-    # Configuração do estilo
-    plt.style.use('seaborn-v0_8-darkgrid')
-    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10),
-                                  height_ratios=[1, 1])
-    plt.subplots_adjust(hspace=0.4)
+    # 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]
     
-    # Definir cores baseadas nos limites
-    cores_notas = [COR_REPROVADO if media < LIMITE_APROVACAO_NOTA 
-                  else COR_APROVADO for media in medias_notas]
-    cores_freq = [COR_REPROVADO if media < LIMITE_APROVACAO_FREQ 
-                 else COR_APROVADO for media in medias_freq]
+    # 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)
     
-    # Configurações comuns para os eixos
-    for ax in [ax1, ax2]:
-        ax.grid(True, axis='y', alpha=0.2, linestyle='--')
-        ax.set_axisbelow(True)
-        ax.spines['top'].set_visible(False)
-        ax.spines['right'].set_visible(False)
-    
-    # Definir os ticks do eixo x para corresponder ao número de disciplinas
-    ax1.set_xticks(range(n_disciplinas))
-    ax2.set_xticks(range(n_disciplinas))
-    
     # 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=14, fontweight='bold')
+    ax1.set_title('Média de Notas por Disciplina', pad=20, fontsize=12, fontweight='bold')
     ax1.set_ylim(0, ESCALA_MAXIMA_NOTAS)
-    ax1.set_xticklabels(disciplinas, rotation=45, ha='right', va='top', fontsize=10)
-    ax1.set_ylabel('Notas', fontsize=12, labelpad=10)
+    ax1.grid(True, axis='y', alpha=0.3, linestyle='--')
     
-    # Linha de média mínima
-    ax1.axhline(y=LIMITE_APROVACAO_NOTA, color=COR_REPROVADO, linestyle='--', alpha=0.3, linewidth=2)
+    # 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=COR_REPROVADO, alpha=0.7, fontsize=10)
+             transform=ax1.get_yaxis_transform(), color='r', alpha=0.7)
     
     # Valores nas barras de notas
     for barra in barras_notas:
         altura = barra.get_height()
-        cor_texto = 'white' if altura >= LIMITE_APROVACAO_NOTA else 'black'
         ax1.text(barra.get_x() + barra.get_width()/2., altura,
-                 f'{altura:.1f}', ha='center', va='bottom', fontsize=10,
-                 bbox=dict(facecolor='white', edgecolor='none', alpha=0.7, pad=1),
-                 color=cor_texto if altura >= 8 else 'black')
+                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=14, fontweight='bold')
+    ax2.set_title('Frequência Média por Disciplina', pad=20, fontsize=12, fontweight='bold')
     ax2.set_ylim(0, 110)
-    ax2.set_xticklabels(disciplinas, rotation=45, ha='right', va='top', fontsize=10)
-    ax2.set_ylabel('Frequência (%)', fontsize=12, labelpad=10)
+    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)
     
-    # Linha de frequência mínima
-    ax2.axhline(y=LIMITE_APROVACAO_FREQ, color=COR_REPROVADO, linestyle='--', alpha=0.3, linewidth=2)
+    # 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=COR_REPROVADO, alpha=0.7, fontsize=10)
+             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()
-        cor_texto = 'white' if altura >= LIMITE_APROVACAO_FREQ else 'black'
         ax2.text(barra.get_x() + barra.get_width()/2., altura,
-                 f'{altura:.1f}%', ha='center', va='bottom', fontsize=10,
-                 bbox=dict(facecolor='white', edgecolor='none', alpha=0.7, pad=1),
-                 color=cor_texto if altura >= 90 else 'black')
+                f'{altura:.1f}%',
+                ha='center', va='bottom', fontsize=8)
     
-    # Título global com estilo
+    # 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=16, fontweight='bold',
-        bbox=dict(facecolor='white', edgecolor='none', alpha=0.8, pad=5, boxstyle='round,pad=0.5')
+        y=0.98, fontsize=14, fontweight='bold'
     )
     
-    # Aviso de reprovação estilizado
+    # 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=12, color=COR_REPROVADO, weight='bold',
-                    bbox=dict(facecolor='#FFEBEE', edgecolor=COR_REPROVADO, alpha=0.9, pad=5, boxstyle='round,pad=0.5'))
+        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 com alta qualidade
+    # Salvar o gráfico
     plot_path = os.path.join(temp_dir, 'medias_frequencias.png')
-    plt.savefig(plot_path, bbox_inches='tight', dpi=300, facecolor='white', edgecolor='none')
+    plt.savefig(plot_path, bbox_inches='tight', dpi=300)
     plt.close()
     
     return plot_path
 
-# Funções de processamento do PDF e geração de relatórios
-def gerar_relatorio_pdf(df: pd.DataFrame, disciplinas_dados: List[Dict],
-                       grafico_basica: str, grafico_diversificada: str,
-                       grafico_medias: str) -> str:
-    """Gera relatório PDF com análise completa."""
-    pdf = PDFReport()
+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.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.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)
     
-    # Nome do aluno
+    # Mostrar apenas o nome
     if hasattr(df, 'attrs') and 'nome' in df.attrs:
         pdf.set_font('Helvetica', 'B', 11)
-        pdf.cell(30, 7, 'Nome:', new_x=XPos.RIGHT, new_y=YPos.TOP)
+        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.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.cell(0, 5, f'Data de geração: {data_atual}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='R')
     pdf.ln(15)
     
-    # Inserir gráficos com verificação
-    if os.path.exists(grafico_basica):
-        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)
-    else:
-        logger.error("Gráfico de formação básica não encontrado.")
+    # 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()
-    if os.path.exists(grafico_diversificada):
-        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)
-    else:
-        logger.error("Gráfico de parte diversificada não encontrado.")
+    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()
-    if os.path.exists(grafico_medias):
-        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)
-    else:
-        logger.error("Gráfico de médias e frequências não encontrado.")
+    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)
     
-    # Salvar PDF em um arquivo temporário
-    with temp_file(suffix='.pdf') as temp_pdf:
-        pdf.output(temp_pdf)
+    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}%)")
         
-        # Verifique se o arquivo PDF foi realmente salvo
-        if os.path.exists(temp_pdf):
-            logger.info("Relatório PDF gerado com sucesso.")
-            return temp_pdf
-        else:
-            logger.error("Falha ao salvar o relatório PDF.")
-            return None
+        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) -> Tuple[Optional[str], str]:
+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."
         
-        with temp_directory() as temp_dir:
-            # Salvar arquivo temporário
-            temp_pdf = os.path.join(temp_dir, 'boletim.pdf')
-            with open(temp_pdf, 'wb') as f:
-                f.write(file)
-            
-            if os.path.getsize(temp_pdf) == 0:
-                return None, "O arquivo está vazio."
-            
-            # Extrair e processar dados
-            df = extrair_tabelas_pdf(temp_pdf)
-            if df is None or df.empty:
-                return None, "Não foi possível extrair dados do PDF."
-            
+        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 e determinar nível
+            # Separar disciplinas por categoria
             categorias = separar_disciplinas_por_categoria(disciplinas_dados)
-            nivel_texto = "Ensino Médio" if categorias['nivel'] == "medio" else "Ensino Fundamental"
+            nivel = categorias['nivel']
+            nivel_texto = "Ensino Médio" if nivel == "medio" else "Ensino Fundamental"
             
-            # Gerar gráficos em paralelo
-            with ThreadPoolExecutor() as executor:
-                futures = {
-                    'basica': executor.submit(
-                        plotar_evolucao_bimestres,
-                        categorias['formacao_basica'],
-                        temp_dir,
-                        f"Evolução das Médias - Formação Geral Básica ({nivel_texto})",
-                        'evolucao_basica.png'
-                    ),
-                    'diversificada': executor.submit(
-                        plotar_evolucao_bimestres,
-                        categorias['diversificada'],
-                        temp_dir,
-                        f"Evolução das Médias - Parte Diversificada ({nivel_texto})",
-                        'evolucao_diversificada.png'
-                    ),
-                    'medias': executor.submit(
-                        plotar_graficos_destacados,
-                        disciplinas_dados,
-                        temp_dir
-                    )
-                }
-                
-                grafico_basica = futures['basica'].result()
-                grafico_diversificada = futures['diversificada'].result()
-                grafico_medias = futures['medias'].result()
+            # 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'
+            )
             
-            # Gerar relatório final
-            pdf_path = gerar_relatorio_pdf(
-                df,
-                disciplinas_dados,
-                grafico_basica,
-                grafico_diversificada,
-                grafico_medias
+            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'
             )
             
-            # Verificar se o arquivo PDF foi criado corretamente
-            if pdf_path and os.path.exists(pdf_path):
-                output_path = os.path.join(temp_dir, 'relatorio_final.pdf')
-                shutil.copy2(pdf_path, output_path)
-                return output_path, "Relatório gerado com sucesso!"
-            else:
-                logger.error("Falha ao gerar o PDF do relatório.")
-                return None, "Erro ao gerar o relatório PDF final."
+            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:
-        logger.exception("Erro durante o processamento")
+        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(
@@ -686,8 +681,7 @@ iface = gr.Interface(
     ],
     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()
+    allow_flagging="never"
 )
 
 if __name__ == "__main__":