Update app.py

app.py

@@ -10,12 +10,70 @@ 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:
-        # Extrair tabelas do PDF usando o método 'lattice'
         tables = camelot.read_pdf(pdf_path, pages='all', flavor='lattice')
         print(f"Tabelas extraídas: {len(tables)}")
         
@@ -25,146 +83,159 @@ def extrair_tabelas_pdf(pdf_path):
         # Processar a primeira tabela
         df = tables[0].df
         
-        # Verificar se a tabela tem conteúdo
+        # 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
+            if 'Disciplina' in str(df_temp.iloc[0,0]) or 'Bimestre' in str(df_temp.iloc[0,1]):
+                df = df_temp
+                break
+        
         if df.empty:
             raise ValueError("A tabela extraída está vazia.")
-            
-        # Salvar todas as tabelas extraídas em CSV (para debug)
-        temp_dir = os.path.dirname(pdf_path)
-        for i, table in enumerate(tables):
-            csv_path = os.path.join(temp_dir, f'boletim_extraido_{i+1}.csv')
-            table.to_csv(csv_path)
-            print(f"Tabela {i+1} salva como CSV em {csv_path}")
+        
+        # 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 converter_nota(valor):
-    """Converte valor de nota para float, tratando casos especiais."""
-    if pd.isna(valor) or valor == '-' or valor == 'N' or valor == '' or valor == 'None':
-        return 0
-    try:
-        if isinstance(valor, str):
-            # Remover possíveis espaços e substituir vírgula por ponto
-            valor_limpo = valor.strip().replace(',', '.')
-            # Se depois de limpar ainda estiver vazio, retorna 0
-            if not valor_limpo:
-                return 0
-            return float(valor_limpo)
-        elif isinstance(valor, (int, float)):
-            return float(valor)
-        return 0
-    except:
-        return 0
-
 def obter_disciplinas_validas(df):
-    """Identifica disciplinas válidas no boletim."""
-    # Colunas de notas e frequências
+    """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']
     
-    # Converter notas para numérico, tratando valores inválidos
-    for col in colunas_notas:
-        if col in df.columns:
-            df[col] = df[col].apply(lambda x: converter_nota(x))
-    
-    # Converter frequências, tratando valores inválidos
-    for col in colunas_freq:
-        if col in df.columns:
-            df[col] = df[col].replace('%', '', regex=True)
-            df[col] = df[col].apply(lambda x: converter_nota(x) if pd.notna(x) else 0)
+    disciplinas_dados = []
     
-    # Identificar disciplinas que têm pelo menos uma nota ou frequência
-    disciplinas_validas = []
     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
             
-        notas = row[colunas_notas].astype(float)
-        freq = row[colunas_freq].astype(float)
+            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 (notas > 0).any() or (freq > 0).any():
-            disciplinas_validas.append(disciplina)
+        # 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
     
-    return disciplinas_validas
-
 def gerar_paleta_cores(n_cores):
     """Gera uma paleta de cores distintas para o número de disciplinas."""
     cores_base = [
-        '#DC143C', '#4169E1', '#9370DB', '#32CD32', '#FF8C00', 
-        '#00CED1', '#FF69B4', '#8B4513', '#4B0082', '#556B2F',
-        '#B8860B', '#483D8B', '#008B8B', '#8B008B', '#8B0000'
+        '#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.8, 0.9) for x in range(n_cores)]
+        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(df_filtrado, temp_dir):
+def plotar_evolucao_bimestres(disciplinas_dados, temp_dir):
     """Plota gráfico de evolução das notas por bimestre."""
-    # Obter disciplinas válidas
-    disciplinas_validas = obter_disciplinas_validas(df_filtrado)
-    n_disciplinas = len(disciplinas_validas)
+    n_disciplinas = len(disciplinas_dados)
     
     if n_disciplinas == 0:
         raise ValueError("Nenhuma disciplina válida encontrada para plotar.")
     
-    # Calcular tamanho da figura baseado no número de disciplinas
-    altura_figura = max(6, n_disciplinas * 0.4)
-    plt.figure(figsize=(14, altura_figura))
+    # 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', '8', '*', 'H', '+', 'x', 'd']
-    estilos_linha = ['-', '--', '-.', ':', '-', '--', '-.', ':', '-', '--', '-.', ':', '-', '--', '-.']
+    marcadores = ['o', 's', '^', 'D', 'v', '<', '>', 'p', 'h', '*']
+    estilos_linha = ['-', '--', '-.', ':', '-', '--', '-.', ':', '-', '--']
     
     plt.grid(True, linestyle='--', alpha=0.3, zorder=0)
     
-    colunas_notas = ['Nota B1', 'Nota B2', 'Nota B3', 'Nota B4']
-    
-    for idx, disciplina in enumerate(disciplinas_validas):
-        dados_disciplina = df_filtrado[df_filtrado['Disciplina'] == disciplina]
-        if not dados_disciplina.empty:
-            # Converter notas para Series do pandas
-            notas = pd.Series(dados_disciplina[colunas_notas].values[0])
-            notas_validas = pd.to_numeric(notas, errors='coerce').replace([np.nan, 0], 0) > 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.any():
-                bimestres = np.arange(1, len(colunas_notas) + 1)[notas_validas]
-                notas_filtradas = pd.to_numeric(notas[notas_validas], errors='coerce').replace(np.nan, 0)
-                
-                plt.plot(bimestres, notas_filtradas,
+            if notas_validas:
+                plt.plot(bimestres, notas_validas,
                         color=cores[idx % len(cores)],
                         marker=marcadores[idx % len(marcadores)],
                         markersize=8,
                         linewidth=2,
-                        label=disciplina,
+                        label=disc_data['disciplina'],
                         linestyle=estilos_linha[idx % len(estilos_linha)],
                         alpha=0.8)
                 
-                for x, y in zip(bimestres, notas_filtradas):
-                    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')
-    plt.xlabel('Bimestres')
-    plt.ylabel('Média de Notas')
-    plt.xticks([1, 2, 3, 4], ['B1', 'B2', 'B3', 'B4'])
-    plt.ylim(0, 10)
-    
-    if n_disciplinas > 10:
-        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', fontsize=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')
+        plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left', ncol=1)
     
     plt.tight_layout()
     
@@ -173,67 +244,75 @@ def plotar_evolucao_bimestres(df_filtrado, temp_dir):
     plt.close()
     return plot_path
 
-def plotar_graficos_destacados(df_boletim_clean, temp_dir):
+def plotar_graficos_destacados(disciplinas_dados, temp_dir):
     """Plota gráficos de médias e frequências com destaques."""
-    # Obter disciplinas válidas
-    disciplinas_validas = obter_disciplinas_validas(df_boletim_clean)
+    n_disciplinas = len(disciplinas_dados)
     
-    if not disciplinas_validas:
+    if not n_disciplinas:
         raise ValueError("Nenhuma disciplina válida encontrada no boletim.")
     
-    n_disciplinas = len(disciplinas_validas)
-    
-    # Calcular tamanho da figura baseado no número de disciplinas
-    altura_figura = max(6, n_disciplinas * 0.4)
-    plt.figure(figsize=(14, altura_figura))
-    
-    df_filtrado = df_boletim_clean[df_boletim_clean['Disciplina'].isin(disciplinas_validas)]
-    disciplinas = df_filtrado['Disciplina'].astype(str)
+    # Calcular tamanho da figura para A4 (proporção 1:√2)
+    plt.figure(figsize=(11.69, 8.27))  # Tamanho A4 em polegadas
     
-    # Processar frequências
-    colunas_freq = ['%Freq B1', '%Freq B2', '%Freq B3', '%Freq B4']
-    freq_data = df_filtrado[colunas_freq].replace('%', '', regex=True).astype(float)
-    medias_frequencia = freq_data.replace([np.nan, 0], 0).mean(axis=1)
-    
-    # Processar notas
-    colunas_notas = ['Nota B1', 'Nota B2', 'Nota B3', 'Nota B4']
-    notas_data = df_filtrado[colunas_notas].astype(float)
-    medias_notas = notas_data.replace([np.nan, 0], 0).mean(axis=1)
+    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 < 5 else 'blue' for media in medias_notas]
-    cores_frequencias = ['red' if media < 75 else 'green' for media in medias_frequencia]
+    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]
     
-    frequencia_global_media = medias_frequencia.mean()
+    media_global = np.mean(medias_notas)
+    freq_global = np.mean(medias_freq)
     
-    plt.subplot(1, 2, 1)
+    # 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 (Vermelho: < 5)')
-    plt.xticks(rotation=45, ha='right')
-    plt.ylim(0, 10)
+    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')
+                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
     
-    plt.subplot(1, 2, 2)
-    barras_freq = plt.bar(disciplinas, medias_frequencia, color=cores_frequencias)
-    plt.title('Média de Frequência por Disciplina (Vermelho: < 75%)')
-    plt.xticks(rotation=45, ha='right')
-    plt.ylim(0, 100)
+    # 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')
+                ha='center', va='bottom', fontsize=8)
     
-    plt.suptitle(f"Frequência Global Média: {frequencia_global_media:.2f}%")
+    plt.suptitle(
+        f'Média Global: {media_global:.1f} | Frequência Global: {freq_global:.1f}%',
+        y=0.95, fontsize=12, fontweight='bold'
+    )
     
-    if frequencia_global_media < 75:
-        plt.figtext(0.5, 0.02, "Cuidado: Risco de Reprovação por Baixa Frequência", 
-                   ha="center", fontsize=12, color="red")
+    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()
     
@@ -242,57 +321,95 @@ def plotar_graficos_destacados(df_boletim_clean, temp_dir):
     plt.close()
     return plot_path
 
-def gerar_relatorio_pdf(df, grafico1_path, grafico2_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(10)
+    pdf.ln(5)
     
-    if 'Nome do Aluno' in df.columns:
-        pdf.set_font('Helvetica', '', 12)
-        pdf.cell(0, 10, f'Aluno: {df["Nome do Aluno"].iloc[0]}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+    # 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.set_font('Helvetica', '', 10)
+    pdf.ln(2)
     
-    disciplinas_validas = obter_disciplinas_validas(df)
-    df_filtrado = df[df['Disciplina'].isin(disciplinas_validas)]
-    
-    # Calcular médias
-    colunas_notas = ['Nota B1', 'Nota B2', 'Nota B3', 'Nota B4']
-    notas_data = df_filtrado[colunas_notas].astype(float)
-    medias_notas = notas_data.replace([np.nan, 0], 0).mean(axis=1)
+    pdf.set_font('Helvetica', '', 10)
     
-    # Processar frequências
-    colunas_freq = ['%Freq B1', '%Freq B2', '%Freq B3', '%Freq B4']
-    freq_data = df_filtrado[colunas_freq].replace('%', '', regex=True).astype(float)
-    medias_freq = freq_data.replace([np.nan, 0], 0).mean(axis=1)
+    # 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))
     
-    # Adicionar média global
-    media_global = medias_notas.mean()
-    freq_global = medias_freq.mean()
+    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.cell(0, 10, f'Média Global: {media_global:.1f}', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-    pdf.cell(0, 10, f'Frequência Global: {freq_global:.1f}%', 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
     pdf.ln(5)
     
-    for idx, (disciplina, media_nota, media_freq) in enumerate(zip(df_filtrado['Disciplina'], medias_notas, medias_freq)):
-        if media_nota < 5:
-            pdf.cell(0, 10, f'- {disciplina}: Média de notas abaixo de 5 ({media_nota:.1f})', 0, 
-                    new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
-        if media_freq < 75:
-            pdf.cell(0, 10, f'- {disciplina}: Frequência abaixo de 75% ({media_freq:.1f}%)', 0, 
-                    new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
+    # 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)
@@ -302,31 +419,25 @@ def processar_boletim(file):
     """Função principal que processa o boletim e gera o relatório."""
     temp_dir = None
     try:
-        # Verificar se o arquivo é válido
         if file is None:
             return None, "Nenhum arquivo foi fornecido."
         
-        # Criar diretório temporário
         temp_dir = tempfile.mkdtemp()
         print(f"Diretório temporário criado: {temp_dir}")
         
-        # Verificar se o arquivo tem conteúdo
         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."
         
-        # Copiar o arquivo para o diretório temporário
         temp_pdf = os.path.join(temp_dir, 'boletim.pdf')
         shutil.copy2(file.name, temp_pdf)
         print(f"PDF copiado para: {temp_pdf}")
         
-        # Verificar se a cópia foi bem sucedida
         if not os.path.exists(temp_pdf) or os.path.getsize(temp_pdf) == 0:
             return None, "Erro ao copiar o arquivo."
         
-        # Extrair tabelas do PDF
         print("Iniciando extração das tabelas...")
         df = extrair_tabelas_pdf(temp_pdf)
         print("Tabelas extraídas com sucesso")
@@ -334,47 +445,38 @@ def processar_boletim(file):
         if df is None or df.empty:
             return None, "Não foi possível extrair dados do PDF."
         
-        # Renomear colunas para o formato esperado
         try:
-            df.columns = ['Disciplina', 'Nota B1', 'Freq B1', '%Freq B1', 'AC B1',
-                         'Nota B2', 'Freq B2', '%Freq B2', 'AC B2',
-                         'Nota B3', 'Freq B3', '%Freq B3', 'AC B3',
-                         'Nota B4', 'Freq B4', '%Freq B4', 'AC B4',
-                         'CF', 'Nota Final', 'Freq Final', 'AC Final']
-        except:
-            return None, "O formato do PDF não corresponde ao esperado."
-        
-        # Processar notas
-        colunas_notas = ['Nota B1', 'Nota B2', 'Nota B3', 'Nota B4']
-        for col in colunas_notas:
-            if col in df.columns:
-                df[col] = df[col].apply(converter_nota)
-        print("Notas processadas")
-        
-        # Gerar gráficos
-        print("Gerando gráficos...")
-        grafico1_path = plotar_evolucao_bimestres(df, temp_dir)
-        grafico2_path = plotar_graficos_destacados(df, temp_dir)
-        print("Gráficos gerados")
-        
-        # Gerar PDF
-        print("Gerando relatório PDF...")
-        pdf_path = gerar_relatorio_pdf(df, grafico1_path, grafico2_path)
-        print("Relatório PDF gerado")
-        
-        # Criar arquivo temporário para retorno
-        output_file = tempfile.NamedTemporaryFile(delete=False, suffix='.pdf')
-        output_path = output_file.name
-        shutil.copy2(pdf_path, output_path)
+            # 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!"
             
-        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:
-        # Limpar arquivos temporários
         if temp_dir and os.path.exists(temp_dir):
             try:
                 shutil.rmtree(temp_dir)