Update app.py

app.py

@@ -6,14 +6,10 @@ 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"""
@@ -22,13 +18,11 @@ class PDFTranscriberGradio:
     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
+            # Método 2: Verificar tamanho
             file_size = os.path.getsize(file_path)
             if file_size == 0:
                 return False, "Arquivo está vazio"
@@ -36,24 +30,25 @@ class PDFTranscriberGradio:
             # 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)"
+                page_count = len(doc)
+                doc.close()
+                if page_count > 0:
+                    return True, f"PDF válido com {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}")
+                pass
             
             # 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)"
+                        return True, "PDF detectado por header"
             except Exception as e:
-                self.logger.warning(f"Verificação de header falhou: {e}")
+                pass
             
-            return False, "Arquivo não é um PDF válido ou está corrompido"
+            return False, "Arquivo não é um PDF válido"
             
         except Exception as e:
             return False, f"Erro na validação: {str(e)}"
@@ -62,80 +57,66 @@ class PDFTranscriberGradio:
         """Converte uma página do PDF em imagem e salva temporariamente"""
         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
+            # Criar arquivo temporário com nome único baseado no timestamp
             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
+            # Adicionar à lista de arquivos temporários
             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 e verificar a imagem
+            # Carregar 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)
             
-            # 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:
+            # Prompt otimizado para transcrição
+            prompt = """Analise esta página do documento PDF em detalhes e forneça uma transcrição completa. Inclua:
 
-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.
+1. **TEXTO COMPLETO**: Transcreva todo o texto visível, mantendo a formatação original
+2. **ESTRUTURA**: Descreva títulos, subtítulos, parágrafos, listas
+3. **ELEMENTOS VISUAIS**: Descreva tabelas, gráficos, imagens, logotipos
+4. **FORMATAÇÃO**: Mencione textos em negrito, itálico, cores especiais
+5. **LAYOUT**: Como o conteúdo está organizado na página
+6. **INFORMAÇÕES IMPORTANTES**: Destaque dados relevantes, números, datas, certificações
 
-Seja preciso e detalhado na transcrição do texto."""
+Seja preciso e detalhado na transcrição."""
             
-            # Configuração de geração otimizada
-            generation_config = {
+            # Gerar resposta
+            response = model.generate_content([prompt, img], generation_config={
                 'temperature': temperature,
-                'max_output_tokens': 8192,  # Aumentado para respostas mais completas
+                'max_output_tokens': 8192,
                 'top_p': top_p,
                 'top_k': int(top_k),
-            }
+            })
             
-            # Gerar resposta
-            response = model.generate_content(
-                [prompt, img], 
-                generation_config=generation_config
-            )
-            
-            # Fechar a imagem explicitamente para liberar memória
+            # Fechar a imagem explicitamente
             img.close()
             
-            self.logger.info(f"Análise da página {page_num} concluída")
             return response.text
             
         except Exception as e:
-            error_msg = f"Erro ao analisar página {page_num}: {str(e)}"
-            self.logger.error(error_msg)
-            return error_msg
+            return f"Erro ao analisar página {page_num}: {str(e)}"
     
     def cleanup_temp_files(self):
-        """Limpa todos os arquivos temporários criados durante o processamento"""
+        """Limpa todos os arquivos temporários"""
         cleaned_count = 0
         for temp_file in self.temp_files:
             try:
                 if os.path.exists(temp_file):
-                    # Tentar remover o arquivo com retry em caso de uso
+                    # Tentar várias vezes em caso de arquivo em uso
                     for attempt in range(3):
                         try:
                             os.unlink(temp_file)
@@ -144,17 +125,17 @@ Seja preciso e detalhado na transcrição do texto."""
                         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
+                                print(f"Aviso: Não foi possível remover {temp_file}: {e}")
                                 break
             except Exception as e:
-                self.logger.warning(f"Erro ao remover arquivo temporário {temp_file}: {e}")
+                print(f"Erro ao limpar arquivo temporário {temp_file}: {e}")
         
         self.temp_files = []
-        self.logger.info(f"Limpeza concluída: {cleaned_count} arquivos removidos")
+        print(f"Limpeza concluída: {cleaned_count} arquivos removidos")
     
     def extract_text_from_pdf(self, pdf_path):
-        """Extrai texto diretamente do PDF usando PyMuPDF"""
+        """Extrai texto diretamente do PDF"""
         try:
             doc = fitz.open(pdf_path)
             text_content = ""
@@ -162,7 +143,7 @@ Seja preciso e detalhado na transcrição do texto."""
             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
+                if page_text.strip():
                     text_content += f"\n=== PÁGINA {page_num + 1} - TEXTO EXTRAÍDO ===\n"
                     text_content += page_text
                     text_content += "\n" + "="*50 + "\n"
@@ -175,21 +156,21 @@ Seja preciso e detalhado na transcrição do texto."""
     
     def process_pdf(self, pdf_file, api_key, model_choice, temperature, top_p, top_k):
         """Função principal para processar o PDF"""
-        status_updates = ["🔄 Iniciando processamento do PDF..."]
+        status_updates = ["🔄 Iniciando processamento..."]
         yield "\n".join(status_updates), None, None
         
         try:
             # Verificar se o arquivo foi fornecido
             if pdf_file is None:
-                raise Exception("❌ Nenhum arquivo foi enviado")
+                raise Exception("❌ Nenhum arquivo enviado")
             
-            # Obter o caminho do arquivo
+            # Obter 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)}")
+            status_updates.append(f"📁 Arquivo: {os.path.basename(file_path)}")
             yield "\n".join(status_updates), None, None
             
-            # Validar o arquivo PDF
+            # Validar arquivo PDF
             is_valid, validation_msg = self.validate_pdf_file(file_path)
             if not is_valid:
                 raise Exception(f"❌ {validation_msg}")
@@ -204,39 +185,36 @@ Seja preciso e detalhado na transcrição do texto."""
             # Configurar API Gemini
             genai.configure(api_key=api_key.strip())
             
-            # Obter o modelo selecionado
+            # Obter modelo selecionado
             model_name = self.get_selected_model(model_choice)
-            status_updates.append(f"🤖 Modelo selecionado: {model_name}")
+            status_updates.append(f"🤖 Modelo: {model_name}")
             yield "\n".join(status_updates), None, None
             
-            # Abrir o PDF
+            # Abrir PDF
             doc = fitz.open(file_path)
             total_pages = len(doc)
             
-            status_updates.append(f"📄 PDF aberto: {total_pages} página(s) encontrada(s)")
+            status_updates.append(f"📄 PDF: {total_pages} página(s)")
             yield "\n".join(status_updates), None, None
             
-            # Extrair texto tradicional primeiro
-            status_updates.append("📝 Extraindo texto diretamente do PDF...")
+            # Extrair texto tradicional
+            status_updates.append("📝 Extraindo texto...")
             yield "\n".join(status_updates), None, None
             
             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...")
+            # Analisar páginas com IA
+            status_updates.append("🔍 Analisando com IA...")
             yield "\n".join(status_updates), None, None
             
             page_analyses = []
             
             for page_num in range(total_pages):
-                status_updates.append(f"🖼️ Processando página {page_num + 1} de {total_pages}...")
+                status_updates.append(f"🖼️ Página {page_num + 1}/{total_pages}...")
                 yield "\n".join(status_updates), None, None
                 
                 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, 
@@ -245,18 +223,17 @@ Seja preciso e detalhado na transcrição do texto."""
                         top_p, 
                         top_k
                     )
-                    
-                    page_analyses.append(f"\n{'='*60}\n📄 ANÁLISE DETALHADA DA PÁGINA {page_num + 1}\n{'='*60}\n{analysis}")
+                    page_analyses.append(f"\n{'='*60}\n📄 ANÁLISE 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}")
+                    error_msg = f"❌ Erro na página {page_num + 1}: {str(e)}"
+                    page_analyses.append(f"\n{'='*60}\n📄 PÁGINA {page_num + 1} - ERRO\n{'='*60}\n{error_msg}")
             
-            # Fechar o documento
+            # Fechar documento
             doc.close()
             
-            # Combinar todos os resultados
-            status_updates.append("📋 Compilando resultado final...")
+            # Compilar resultado final
+            status_updates.append("📋 Compilando resultado...")
             yield "\n".join(status_updates), None, None
             
             final_output = f"""{'='*80}
@@ -264,9 +241,9 @@ Seja preciso e detalhado na transcrição do texto."""
 {'='*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')}
+🤖 MODELO: {model_name}
+📊 PÁGINAS: {total_pages}
+⏰ PROCESSADO: {time.strftime('%Y-%m-%d %H:%M:%S')}
 
 {'='*80}
 📝 TEXTO EXTRAÍDO DIRETAMENTE
@@ -274,7 +251,7 @@ Seja preciso e detalhado na transcrição do texto."""
 {extracted_text}
 
 {'='*80}
-🔍 ANÁLISE VISUAL DETALHADA POR IA
+🔍 ANÁLISE VISUAL DETALHADA
 {'='*80}
 {chr(10).join(page_analyses)}
 
@@ -283,56 +260,44 @@ Seja preciso e detalhado na transcrição do texto."""
 {'='*80}
 """
             
-            # Salvar resultado em arquivo
+            # Salvar resultado
             output_filename = f"transcricao_pdf_{int(time.time())}.txt"
             output_path = os.path.join(tempfile.gettempdir(), output_filename)
             
             with open(output_path, 'w', encoding='utf-8') as f:
                 f.write(final_output)
             
-            status_updates.append("✅ Processamento concluído com sucesso!")
-            status_updates.append(f"💾 Arquivo salvo: {output_filename}")
+            status_updates.append("✅ Processamento concluído!")
+            status_updates.append(f"💾 Arquivo: {output_filename}")
             
-            # Retornar resultado final
             yield "\n".join(status_updates), final_output, output_path
             
         except Exception as 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:
-            # Sempre limpar arquivos temporários
+            # Limpar arquivos temporários
             self.cleanup_temp_files()
     
     def create_interface(self):
-        """Cria a interface Gradio"""
+        """Cria 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;
-            }
-            """
+            theme=gr.themes.Soft()
         ) as interface:
             
             gr.Markdown("""
             # 🔍 Transcritor de PDF com Gemini AI
             
-            **Ferramenta avançada para transcrição e análise de documentos PDF**
+            **Ferramenta 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)
+            - 📝 Extração de texto nativo
+            - 🖼️ Análise visual com IA
+            - 📊 Descrição de elementos visuais
+            - 💾 Download do resultado
             """)
             
             with gr.Row():
@@ -342,38 +307,34 @@ Seja preciso e detalhado na transcrição do texto."""
                     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/"
+                        placeholder="Insira sua API key do Google Gemini"
                     )
                     
+                    # CORREÇÃO PRINCIPAL: Remover validação restritiva
                     pdf_file = gr.File(
-                        label="📄 Arquivo PDF", 
-                        file_types=[".pdf"],
-                        info="Selecione o arquivo PDF para transcrever"
+                        label="📄 Arquivo PDF",
+                        file_types=None,  # Aceita qualquer tipo
+                        file_count="single"
                     )
                     
                     model_choice = gr.Dropdown(
-                        label="🤖 Modelo Gemini", 
+                        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",
-                        info="Escolha o modelo mais adequado para sua necessidade"
+                        value="gemini-1.5-pro - Raciocínio complexo"
                     )
                     
-                    gr.Markdown("#### 🎛️ Parâmetros Avançados")
-                    
                     with gr.Row():
                         temperature = gr.Slider(
                             label="🌡️ Temperatura", 
                             minimum=0.0, 
                             maximum=1.0, 
                             step=0.1, 
-                            value=0.1,
-                            info="Controla a criatividade (0.0 = mais preciso)"
+                            value=0.1
                         )
                     
                     with gr.Row():
@@ -382,8 +343,7 @@ Seja preciso e detalhado na transcrição do texto."""
                             minimum=0.0, 
                             maximum=1.0, 
                             step=0.1, 
-                            value=0.9,
-                            info="Controla a diversidade das respostas"
+                            value=0.9
                         )
                         
                         top_k = gr.Slider(
@@ -391,40 +351,34 @@ Seja preciso e detalhado na transcrição do texto."""
                             minimum=1, 
                             maximum=40, 
                             step=1, 
-                            value=40,
-                            info="Número de tokens considerados"
+                            value=40
                         )
                     
                     process_button = gr.Button(
-                        "🚀 Transcrever e Analisar", 
-                        variant="primary",
-                        size="lg"
+                        "🚀 Transcrever PDF", 
+                        variant="primary"
                     )
                 
                 with gr.Column(scale=2):
                     gr.Markdown("### 📊 Resultados")
                     
                     status_output = gr.Textbox(
-                        label="📋 Status do Processamento", 
+                        label="📋 Status", 
                         lines=8,
-                        max_lines=15,
-                        info="Acompanhe o progresso em tempo real"
+                        interactive=False
                     )
                     
                     result_output = gr.Textbox(
-                        label="📄 Transcrição Completa", 
+                        label="📄 Transcrição", 
                         lines=20,
-                        max_lines=30,
-                        show_copy_button=True,
-                        info="Resultado completo da transcrição"
+                        show_copy_button=True
                     )
                     
                     file_output = gr.File(
-                        label="💾 Download do Resultado",
-                        info="Baixe o arquivo completo da transcrição"
+                        label="💾 Download"
                     )
             
-            # Conectar o botão à função
+            # Conectar função
             process_button.click(
                 fn=self.process_pdf,
                 inputs=[pdf_file, api_key, model_choice, temperature, top_p, top_k],
@@ -433,15 +387,10 @@ Seja preciso e detalhado na transcrição do texto."""
             )
             
             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
+            ### 💡 Dicas
+            - Obtenha API Key gratuita em: https://ai.google.dev/
+            - Use temperatura baixa (0.1-0.3) para maior precisão
+            - Gemini 1.5 Pro é melhor para análise complexa
             """)
             
         return interface
@@ -452,11 +401,9 @@ Seja preciso e detalhado na transcrição do texto."""
         interface.launch(
             server_name="0.0.0.0",
             server_port=7860,
-            share=False,
-            show_error=True
+            share=False
         )
 
-# Ponto de entrada da aplicação
 if __name__ == "__main__":
     app = PDFTranscriberGradio()
     app.run()