Update app.py

app.py

@@ -121,35 +121,25 @@ def calcular_frequencia_media(frequencias):
     return sum(freq_validas) / len(freq_validas)
 
 def extrair_tabelas_pdf(pdf_path):
-    """Extrai tabelas do PDF usando múltiplas abordagens."""
+    """Extrai tabelas do PDF usando stream apenas para o nome e lattice para notas."""
     try:
-        info_aluno = {}
-        print("Iniciando extração de informações...")
-        
-        # Primeira tentativa: Extrair toda a primeira página com stream
+        # Extrair nome do aluno usando stream
         tables_header = camelot.read_pdf(
             pdf_path,
             pages='1',
             flavor='stream',
-            edge_tol=500  # Aumentar tolerância para detectar bordas
+            edge_tol=500
         )
         
-        print(f"Tabelas encontradas na primeira tentativa: {len(tables_header)}")
+        info_aluno = {}
         
-        # Processar todas as tabelas encontradas
+        # Procurar apenas o nome do aluno
         for table in tables_header:
             df = table.df
-            print("\nAnalisando tabela:")
-            print(df)
-            
-            # Procurar em cada célula da tabela
             for i in range(len(df)):
                 for j in range(len(df.columns)):
                     texto = str(df.iloc[i,j]).strip()
-                    
-                    # Nome do Aluno
                     if 'Nome do Aluno' in texto:
-                        # Tentar diferentes posições para o valor
                         try:
                             if j + 1 < len(df.columns):
                                 nome = str(df.iloc[i,j+1]).strip()
@@ -157,58 +147,17 @@ def extrair_tabelas_pdf(pdf_path):
                                 nome = str(df.iloc[i+1,j]).strip()
                             if nome and nome != 'Nome do Aluno:':
                                 info_aluno['nome'] = nome
-                                print(f"Nome encontrado: {nome}")
-                        except:
-                            continue
-                    
-                    # RA
-                    elif 'RA' in texto and len(texto) < 5:  # Para evitar falsos positivos
-                        try:
-                            if j + 1 < len(df.columns):
-                                ra = str(df.iloc[i,j+1]).strip()
-                            elif i + 1 < len(df):
-                                ra = str(df.iloc[i+1,j]).strip()
-                            if ra and ra != 'RA:':
-                                info_aluno['ra'] = ra
-                                print(f"RA encontrado: {ra}")
-                        except:
-                            continue
-                    
-                    # Escola
-                    elif 'Escola' in texto:
-                        try:
-                            if j + 1 < len(df.columns):
-                                escola = str(df.iloc[i,j+1]).strip()
-                            elif i + 1 < len(df):
-                                escola = str(df.iloc[i+1,j]).strip()
-                            if escola and escola != 'Escola:':
-                                info_aluno['escola'] = escola
-                                print(f"Escola encontrada: {escola}")
-                        except:
-                            continue
-                    
-                    # Turma
-                    elif 'Turma' in texto:
-                        try:
-                            if j + 1 < len(df.columns):
-                                turma = str(df.iloc[i,j+1]).strip()
-                            elif i + 1 < len(df):
-                                turma = str(df.iloc[i+1,j]).strip()
-                            if turma and turma != 'Turma:':
-                                info_aluno['turma'] = turma
-                                print(f"Turma encontrada: {turma}")
+                                break
                         except:
                             continue
         
-        # Segunda parte: Extrair tabela de notas usando lattice
+        # Extrair tabela de notas usando lattice
         tables_notas = camelot.read_pdf(
             pdf_path,
             pages='all',
             flavor='lattice'
         )
         
-        print(f"\nTabelas de notas encontradas: {len(tables_notas)}")
-        
         # Encontrar tabela de notas (procurar a maior tabela com 'Disciplina')
         df_notas = None
         max_rows = 0
@@ -230,47 +179,14 @@ def extrair_tabelas_pdf(pdf_path):
         if df_notas is None:
             raise ValueError("Tabela de notas não encontrada")
         
-        # Adicionar informações do aluno ao DataFrame
-        df_notas.attrs.update(info_aluno)
-        
-        print("\nInformações finais encontradas:")
-        for campo, valor in info_aluno.items():
-            print(f"{campo}: {valor}")
+        # 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:
-        print(f"Erro detalhado na extração: {str(e)}")
-        print("Tentando abordagem alternativa...")
-        
-        try:
-            # Tentativa alternativa usando apenas lattice
-            tables = camelot.read_pdf(pdf_path, pages='all', flavor='lattice')
-            if len(tables) > 0:
-                df = tables[0].df
-                df_notas = None
-                
-                for table in tables:
-                    if 'Disciplina' in str(table.df.iloc[0,0]):
-                        df_notas = table.df
-                        df_notas = df_notas.rename(columns={
-                            0: 'Disciplina',
-                            1: 'Nota B1', 2: 'Freq B1', 3: '%Freq B1', 4: 'AC B1',
-                            5: 'Nota B2', 6: 'Freq B2', 7: '%Freq B2', 8: 'AC B2',
-                            9: 'Nota B3', 10: 'Freq B3', 11: '%Freq B3', 12: 'AC B3',
-                            13: 'Nota B4', 14: 'Freq B4', 15: '%Freq B4', 16: 'AC B4',
-                            17: 'CF', 18: 'Nota Final', 19: 'Freq Final', 20: 'AC Final'
-                        })
-                        break
-                
-                if df_notas is not None:
-                    return df_notas
-                
-            raise ValueError("Não foi possível extrair as tabelas em nenhuma tentativa")
-            
-        except Exception as e2:
-            print(f"Erro na tentativa alternativa: {str(e2)}")
-            raise
+        print(f"Erro na extração das tabelas: {str(e)}")
+        raise
         
 def obter_disciplinas_validas(df):
     """Identifica disciplinas válidas no boletim com seus dados."""
@@ -563,33 +479,12 @@ def gerar_relatorio_pdf(df, disciplinas_dados, grafico_basica, grafico_diversifi
     pdf.line(10, pdf.get_y(), 200, pdf.get_y())
     pdf.ln(5)
     
-    pdf.set_font('Helvetica', '', 11)
-    if hasattr(df, 'attrs'):
-        nome = df.attrs.get('nome', 'Nome não encontrado')
-        ra = df.attrs.get('ra', 'RA não encontrado')
-        escola = df.attrs.get('escola', 'Escola não encontrada')
-        turma = df.attrs.get('turma', 'Turma não encontrada')
-        
-        # Adicionar rótulos em negrito
+    # 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, nome, 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
-        
-        pdf.set_font('Helvetica', 'B', 11)
-        pdf.cell(30, 7, 'RA:', 0, 0)
-        pdf.set_font('Helvetica', '', 11)
-        pdf.cell(0, 7, ra, 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
-        
-        pdf.set_font('Helvetica', 'B', 11)
-        pdf.cell(30, 7, 'Escola:', 0, 0)
-        pdf.set_font('Helvetica', '', 11)
-        pdf.cell(0, 7, escola, 0, new_x=XPos.LMARGIN, new_y=YPos.NEXT)
-        
-        pdf.set_font('Helvetica', 'B', 11)
-        pdf.cell(30, 7, 'Turma:', 0, 0)
-        pdf.set_font('Helvetica', '', 11)
-        pdf.cell(0, 7, turma, 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)