Update app.py

app.py

@@ -6,223 +6,425 @@ import google.generativeai as genai
 import time
 import tempfile
 from PIL import Image
+import logging
 
 class PDFTranscriberGradio:
     def __init__(self):
         self.temp_files = []
+        # Configurar logging para debug
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
         
     def get_selected_model(self, model_choice):
         """Retorna o ID do modelo selecionado"""
         return model_choice.split(" - ")[0].strip()
     
+    def validate_pdf_file(self, file_path):
+        """Valida se o arquivo é um PDF usando múltiplos métodos"""
+        try:
+            self.logger.info(f"Validando arquivo: {file_path}")
+            
+            # Método 1: Verificar se o arquivo existe
+            if not os.path.exists(file_path):
+                return False, "Arquivo não encontrado"
+            
+            # Método 2: Verificar tamanho do arquivo
+            file_size = os.path.getsize(file_path)
+            if file_size == 0:
+                return False, "Arquivo está vazio"
+            
+            # Método 3: Tentar abrir com PyMuPDF
+            try:
+                doc = fitz.open(file_path)
+                if doc.page_count > 0:
+                    doc.close()
+                    return True, f"PDF válido com {doc.page_count} página(s)"
+                else:
+                    return False, "PDF não contém páginas"
+            except Exception as e:
+                self.logger.warning(f"PyMuPDF falhou: {e}")
+            
+            # Método 4: Verificar header do arquivo
+            try:
+                with open(file_path, 'rb') as f:
+                    header = f.read(8)
+                    if header.startswith(b'%PDF-'):
+                        return True, "PDF detectado por header (pode ter problemas estruturais)"
+            except Exception as e:
+                self.logger.warning(f"Verificação de header falhou: {e}")
+            
+            return False, "Arquivo não é um PDF válido ou está corrompido"
+            
+        except Exception as e:
+            return False, f"Erro na validação: {str(e)}"
+    
     def convert_pdf_page_to_image(self, pdf_document, page_number):
         """Converte uma página do PDF em imagem e salva temporariamente"""
-        page = pdf_document[page_number]
-        pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))
-        img_data = pix.tobytes("png")
-        
-        # Criar arquivo temporário com nome único baseado no timestamp
-        temp_filename = f'page_{page_number}_{int(time.time()*1000)}.png'
-        temp_path = os.path.join(tempfile.gettempdir(), temp_filename)
-        
-        with open(temp_path, 'wb') as temp_file:
-            temp_file.write(img_data)
-        
-        # Adicionar à lista de arquivos temporários
-        self.temp_files.append(temp_path)
-        return temp_path
+        try:
+            page = pdf_document[page_number]
+            # Usar matriz de alta resolução para melhor qualidade
+            pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))
+            img_data = pix.tobytes("png")
+            
+            # Criar arquivo temporário com nome único
+            temp_filename = f'page_{page_number}_{int(time.time()*1000)}_{os.getpid()}.png'
+            temp_path = os.path.join(tempfile.gettempdir(), temp_filename)
+            
+            with open(temp_path, 'wb') as temp_file:
+                temp_file.write(img_data)
+            
+            # Adicionar à lista de arquivos temporários para limpeza posterior
+            self.temp_files.append(temp_path)
+            self.logger.info(f"Página {page_number} convertida para: {temp_path}")
+            return temp_path
+            
+        except Exception as e:
+            self.logger.error(f"Erro ao converter página {page_number}: {e}")
+            raise Exception(f"Erro ao converter página {page_number}: {str(e)}")
     
     def analyze_page_with_gemini(self, image_path, page_num, model_name, temperature, top_p, top_k):
         """Analisa uma página usando o modelo Gemini selecionado"""
         try:
-            # Carregar a imagem
+            # Carregar e verificar a imagem
             img = Image.open(image_path)
+            self.logger.info(f"Analisando página {page_num} com modelo {model_name}")
             
             # Configurar o modelo Gemini
             model = genai.GenerativeModel(model_name)
             
-            # Criar prompt
-            prompt = """Analise esta página do documento em detalhes. Por favor, inclua:
-1. Conteúdo textual e sua organização
-2. Layout e estrutura visual
-3. Elementos gráficos, tabelas ou imagens
-4. Informações importantes ou destaques
-5. Formatação e estilo do documento"""
+            # Prompt otimizado para transcrição detalhada
+            prompt = """Analise esta página do documento PDF em detalhes. Forneça uma transcrição completa e organizada incluindo:
+
+1. **TEXTO COMPLETO**: Transcreva todo o texto visível, mantendo a formatação e organização original
+2. **ESTRUTURA DO DOCUMENTO**: Descreva títulos, subtítulos, parágrafos, listas, etc.
+3. **ELEMENTOS VISUAIS**: Descreva tabelas, gráficos, imagens, logotipos ou elementos gráficos
+4. **FORMATAÇÃO**: Mencione textos em negrito, itálico, cores especiais, tamanhos de fonte diferentes
+5. **LAYOUT**: Descreva como o conteúdo está organizado na página (colunas, seções, etc.)
+6. **INFORMAÇÕES IMPORTANTES**: Destaque dados relevantes, números, datas, nomes, certificações, etc.
+
+Seja preciso e detalhado na transcrição do texto."""
             
-            # Gerar resposta
-            response = model.generate_content([prompt, img], generation_config={
+            # Configuração de geração otimizada
+            generation_config = {
                 'temperature': temperature,
-                'max_output_tokens': 4096,
+                'max_output_tokens': 8192,  # Aumentado para respostas mais completas
                 'top_p': top_p,
                 'top_k': int(top_k),
-            })
+            }
             
-            # Fechar a imagem explicitamente
+            # Gerar resposta
+            response = model.generate_content(
+                [prompt, img], 
+                generation_config=generation_config
+            )
+            
+            # Fechar a imagem explicitamente para liberar memória
             img.close()
             
+            self.logger.info(f"Análise da página {page_num} concluída")
             return response.text
             
         except Exception as e:
-            return f"Erro ao analisar página {page_num}: {str(e)}"
+            error_msg = f"Erro ao analisar página {page_num}: {str(e)}"
+            self.logger.error(error_msg)
+            return error_msg
     
     def cleanup_temp_files(self):
-        """Limpa todos os arquivos temporários"""
+        """Limpa todos os arquivos temporários criados durante o processamento"""
+        cleaned_count = 0
         for temp_file in self.temp_files:
             try:
                 if os.path.exists(temp_file):
-                    # Tentar várias vezes em caso de arquivo em uso
-                    for _ in range(3):
+                    # Tentar remover o arquivo com retry em caso de uso
+                    for attempt in range(3):
                         try:
                             os.unlink(temp_file)
+                            cleaned_count += 1
                             break
                         except PermissionError:
                             time.sleep(0.5)
+                        except Exception as e:
+                            self.logger.warning(f"Tentativa {attempt + 1} falhou para {temp_file}: {e}")
+                            if attempt == 2:  # Última tentativa
+                                break
             except Exception as e:
-                print(f"Aviso: Não foi possível remover arquivo temporário {temp_file}: {e}")
+                self.logger.warning(f"Erro ao remover arquivo temporário {temp_file}: {e}")
+        
         self.temp_files = []
+        self.logger.info(f"Limpeza concluída: {cleaned_count} arquivos removidos")
     
     def extract_text_from_pdf(self, pdf_path):
+        """Extrai texto diretamente do PDF usando PyMuPDF"""
         try:
             doc = fitz.open(pdf_path)
-            text = ""
-            for page in doc:
-                text += page.get_text()
-            return text
+            text_content = ""
+            
+            for page_num in range(len(doc)):
+                page = doc[page_num]
+                page_text = page.get_text()
+                if page_text.strip():  # Só adiciona se a página tiver texto
+                    text_content += f"\n=== PÁGINA {page_num + 1} - TEXTO EXTRAÍDO ===\n"
+                    text_content += page_text
+                    text_content += "\n" + "="*50 + "\n"
+            
+            doc.close()
+            return text_content if text_content.strip() else "Nenhum texto extraível encontrado no PDF"
+            
         except Exception as e:
             raise Exception(f"Erro ao extrair texto do PDF: {str(e)}")
     
     def process_pdf(self, pdf_file, api_key, model_choice, temperature, top_p, top_k):
-        status_updates = ["Iniciando processamento..."]
+        """Função principal para processar o PDF"""
+        status_updates = ["🔄 Iniciando processamento do PDF..."]
         yield "\n".join(status_updates), None, None
         
         try:
             # Verificar se o arquivo foi fornecido
             if pdf_file is None:
-                raise Exception("Nenhum arquivo enviado")
-                
-            # Configurar API Gemini
+                raise Exception("❌ Nenhum arquivo foi enviado")
+            
+            # Obter o caminho do arquivo
+            file_path = pdf_file.name if hasattr(pdf_file, 'name') else pdf_file
+            
+            status_updates.append(f"📁 Arquivo recebido: {os.path.basename(file_path)}")
+            yield "\n".join(status_updates), None, None
+            
+            # Validar o arquivo PDF
+            is_valid, validation_msg = self.validate_pdf_file(file_path)
+            if not is_valid:
+                raise Exception(f"❌ {validation_msg}")
+            
+            status_updates.append(f"✅ {validation_msg}")
+            yield "\n".join(status_updates), None, None
+            
+            # Verificar API Key
             if not api_key or api_key.strip() == "":
-                raise Exception("API Key não fornecida")
-            genai.configure(api_key=api_key)
+                raise Exception("❌ API Key do Gemini não fornecida")
+            
+            # Configurar API Gemini
+            genai.configure(api_key=api_key.strip())
             
             # Obter o modelo selecionado
             model_name = self.get_selected_model(model_choice)
+            status_updates.append(f"🤖 Modelo selecionado: {model_name}")
+            yield "\n".join(status_updates), None, None
             
             # Abrir o PDF
-            # Gradio retorna um objeto NamedString, precisamos usar o caminho do arquivo
-            doc = fitz.open(pdf_file.name)
+            doc = fitz.open(file_path)
+            total_pages = len(doc)
             
-            # Extrair texto tradicional
-            status_updates.append("Extraindo texto do PDF...")
+            status_updates.append(f"📄 PDF aberto: {total_pages} página(s) encontrada(s)")
             yield "\n".join(status_updates), None, None
             
-            text_content = ""
-            for page in doc:
-                text_content += page.get_text()
+            # Extrair texto tradicional primeiro
+            status_updates.append("📝 Extraindo texto diretamente do PDF...")
+            yield "\n".join(status_updates), None, None
             
-            # Analisar cada página como imagem
-            status_updates.append("Analisando páginas como imagens...")
+            extracted_text = self.extract_text_from_pdf(file_path)
+            
+            # Analisar cada página como imagem com IA
+            status_updates.append("🔍 Iniciando análise visual com IA...")
             yield "\n".join(status_updates), None, None
             
             page_analyses = []
             
-            for page_num in range(len(doc)):
-                status_updates.append(f"Processando página {page_num + 1} de {len(doc)}...")
+            for page_num in range(total_pages):
+                status_updates.append(f"🖼️ Processando página {page_num + 1} de {total_pages}...")
                 yield "\n".join(status_updates), None, None
                 
-                image_path = self.convert_pdf_page_to_image(doc, page_num)
-                analysis = self.analyze_page_with_gemini(
-                    image_path, 
-                    page_num + 1, 
-                    model_name, 
-                    temperature, 
-                    top_p, 
-                    top_k
-                )
-                page_analyses.append(f"\n=== Análise da Página {page_num + 1} ===\n{analysis}")
-            
-            # Combinar resultados
-            final_output = "=== CONTEÚDO TEXTUAL ===\n\n"
-            final_output += text_content
-            final_output += "\n\n=== ANÁLISE VISUAL DAS PÁGINAS ===\n"
-            final_output += "\n".join(page_analyses)
-            
-            # Gerar nome para arquivo de saída
-            output_filename = f"analise_pdf_{int(time.time())}.txt"
+                try:
+                    # Converter página para imagem
+                    image_path = self.convert_pdf_page_to_image(doc, page_num)
+                    
+                    # Analisar com Gemini
+                    analysis = self.analyze_page_with_gemini(
+                        image_path, 
+                        page_num + 1, 
+                        model_name, 
+                        temperature, 
+                        top_p, 
+                        top_k
+                    )
+                    
+                    page_analyses.append(f"\n{'='*60}\n📄 ANÁLISE DETALHADA DA PÁGINA {page_num + 1}\n{'='*60}\n{analysis}")
+                    
+                except Exception as e:
+                    error_analysis = f"❌ Erro ao processar página {page_num + 1}: {str(e)}"
+                    page_analyses.append(f"\n{'='*60}\n📄 PÁGINA {page_num + 1} - ERRO\n{'='*60}\n{error_analysis}")
+            
+            # Fechar o documento
+            doc.close()
+            
+            # Combinar todos os resultados
+            status_updates.append("📋 Compilando resultado final...")
+            yield "\n".join(status_updates), None, None
+            
+            final_output = f"""{'='*80}
+🔍 TRANSCRIÇÃO COMPLETA DO PDF
+{'='*80}
+
+📄 ARQUIVO: {os.path.basename(file_path)}
+🤖 MODELO USADO: {model_name}
+📊 TOTAL DE PÁGINAS: {total_pages}
+⏰ PROCESSADO EM: {time.strftime('%Y-%m-%d %H:%M:%S')}
+
+{'='*80}
+📝 TEXTO EXTRAÍDO DIRETAMENTE
+{'='*80}
+{extracted_text}
+
+{'='*80}
+🔍 ANÁLISE VISUAL DETALHADA POR IA
+{'='*80}
+{chr(10).join(page_analyses)}
+
+{'='*80}
+✅ PROCESSAMENTO CONCLUÍDO
+{'='*80}
+"""
+            
+            # Salvar resultado em arquivo
+            output_filename = f"transcricao_pdf_{int(time.time())}.txt"
             output_path = os.path.join(tempfile.gettempdir(), output_filename)
             
-            # Salvar resultado
             with open(output_path, 'w', encoding='utf-8') as f:
                 f.write(final_output)
             
-            status_updates.append(f"Análise completa! Arquivo salvo temporariamente.")
+            status_updates.append("✅ Processamento concluído com sucesso!")
+            status_updates.append(f"💾 Arquivo salvo: {output_filename}")
             
-            # Retornar o conteúdo e o caminho do arquivo para download
+            # Retornar resultado final
             yield "\n".join(status_updates), final_output, output_path
             
         except Exception as e:
-            error_msg = f"Erro: {str(e)}"
+            error_msg = f"❌ ERRO: {str(e)}"
             status_updates.append(error_msg)
+            self.logger.error(error_msg)
             yield "\n".join(status_updates), None, None
             
         finally:
-            # Limpar arquivos temporários
+            # Sempre limpar arquivos temporários
             self.cleanup_temp_files()
     
     def create_interface(self):
-        with gr.Blocks(title="Transcritor de PDF com Gemini API") as interface:
-            gr.Markdown("# Transcritor de PDF com Gemini API")
+        """Cria a interface Gradio"""
+        with gr.Blocks(
+            title="Transcritor de PDF com Gemini AI",
+            theme=gr.themes.Soft(),
+            css="""
+            .gradio-container {
+                max-width: 1200px !important;
+                margin: auto;
+            }
+            """
+        ) as interface:
+            
+            gr.Markdown("""
+            # 🔍 Transcritor de PDF com Gemini AI
+            
+            **Ferramenta avançada para transcrição e análise de documentos PDF**
+            
+            ✨ **Recursos:**
+            - 📝 Extração de texto nativo do PDF
+            - 🖼️ Análise visual inteligente com IA
+            - 📊 Descrição de tabelas, gráficos e elementos visuais
+            - 💾 Download do resultado completo
+            
+            ⚠️ **Requisitos:**
+            - API Key válida do Google Gemini AI
+            - Arquivo PDF (máximo recomendado: 20 páginas)
+            """)
             
             with gr.Row():
-                with gr.Column():
-                    api_key = gr.Textbox(label="API Key Gemini", type="password")
-                    pdf_file = gr.File(label="Arquivo PDF", file_types=[".pdf"])
+                with gr.Column(scale=1):
+                    gr.Markdown("### ⚙️ Configurações")
                     
-                    with gr.Row():
-                        model_choice = gr.Dropdown(
-                            label="Modelo", 
-                            choices=[
-                                "gemini-2.0-flash-exp - Última geração (Experimental)",
-                                "gemini-1.5-flash - Rápido e versátil",
-                                "gemini-1.5-flash-8b - Alto volume",
-                                "gemini-1.5-pro - Raciocínio complexo"
-                            ],
-                            value="gemini-1.5-pro - Raciocínio complexo"
-                        )
+                    api_key = gr.Textbox(
+                        label="🔑 API Key Gemini", 
+                        type="password",
+                        placeholder="Insira sua API key do Google Gemini AI",
+                        info="Obtenha em: https://ai.google.dev/"
+                    )
+                    
+                    pdf_file = gr.File(
+                        label="📄 Arquivo PDF", 
+                        file_types=[".pdf"],
+                        info="Selecione o arquivo PDF para transcrever"
+                    )
+                    
+                    model_choice = gr.Dropdown(
+                        label="🤖 Modelo Gemini", 
+                        choices=[
+                            "gemini-2.0-flash-exp - Última geração (Experimental)",
+                            "gemini-1.5-flash - Rápido e versátil",
+                            "gemini-1.5-flash-8b - Alto volume",
+                            "gemini-1.5-pro - Raciocínio complexo"
+                        ],
+                        value="gemini-1.5-pro - Raciocínio complexo",
+                        info="Escolha o modelo mais adequado para sua necessidade"
+                    )
+                    
+                    gr.Markdown("#### 🎛️ Parâmetros Avançados")
                     
                     with gr.Row():
                         temperature = gr.Slider(
-                            label="Temperatura", 
+                            label="🌡️ Temperatura", 
                             minimum=0.0, 
                             maximum=1.0, 
                             step=0.1, 
-                            value=0.4
+                            value=0.1,
+                            info="Controla a criatividade (0.0 = mais preciso)"
                         )
                     
                     with gr.Row():
                         top_p = gr.Slider(
-                            label="Top P", 
+                            label="🎯 Top P", 
                             minimum=0.0, 
                             maximum=1.0, 
                             step=0.1, 
-                            value=0.8
+                            value=0.9,
+                            info="Controla a diversidade das respostas"
                         )
                         
                         top_k = gr.Slider(
-                            label="Top K", 
+                            label="🔢 Top K", 
                             minimum=1, 
                             maximum=40, 
                             step=1, 
-                            value=32
+                            value=40,
+                            info="Número de tokens considerados"
                         )
                     
-                    process_button = gr.Button("Transcrever e Analisar")
+                    process_button = gr.Button(
+                        "🚀 Transcrever e Analisar", 
+                        variant="primary",
+                        size="lg"
+                    )
                 
-                with gr.Column():
-                    status_output = gr.Textbox(label="Status", lines=10)
-                    result_output = gr.Textbox(label="Resultado", lines=20)
-                    file_output = gr.File(label="Download do Resultado")
+                with gr.Column(scale=2):
+                    gr.Markdown("### 📊 Resultados")
+                    
+                    status_output = gr.Textbox(
+                        label="📋 Status do Processamento", 
+                        lines=8,
+                        max_lines=15,
+                        info="Acompanhe o progresso em tempo real"
+                    )
+                    
+                    result_output = gr.Textbox(
+                        label="📄 Transcrição Completa", 
+                        lines=20,
+                        max_lines=30,
+                        show_copy_button=True,
+                        info="Resultado completo da transcrição"
+                    )
+                    
+                    file_output = gr.File(
+                        label="💾 Download do Resultado",
+                        info="Baixe o arquivo completo da transcrição"
+                    )
             
+            # Conectar o botão à função
             process_button.click(
                 fn=self.process_pdf,
                 inputs=[pdf_file, api_key, model_choice, temperature, top_p, top_k],
@@ -230,12 +432,31 @@ class PDFTranscriberGradio:
                 show_progress=True
             )
             
+            gr.Markdown("""
+            ### 💡 Dicas de Uso
+            
+            1. **API Key**: Obtenha gratuitamente em [Google AI Studio](https://ai.google.dev/)
+            2. **Qualidade**: PDFs com texto nativo produzem melhores resultados
+            3. **Tamanho**: Para PDFs grandes (>20 páginas), considere dividir em partes
+            4. **Modelos**: 
+               - **Gemini 1.5 Pro**: Melhor para análise complexa
+               - **Gemini 1.5 Flash**: Mais rápido para documentos simples
+            5. **Parâmetros**: Use temperatura baixa (0.1-0.3) para maior precisão
+            """)
+            
         return interface
     
     def run(self):
+        """Inicia a aplicação"""
         interface = self.create_interface()
-        interface.launch()
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True
+        )
 
+# Ponto de entrada da aplicação
 if __name__ == "__main__":
     app = PDFTranscriberGradio()
     app.run()