Update app.py

app.py

@@ -4,75 +4,91 @@ from huggingface_hub import InferenceClient
 from datetime import datetime
 import logging
 from typing import Dict, List, Optional
+from pathlib import Path
+import json
+import dotenv
+
+# Carrega variáveis de ambiente do arquivo .env se existir
+dotenv.load_dotenv()
 
 # Configuração do logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
-# Substitua com sua chave de API
-HF_API_KEY = "hf_seu_token_aqui"
-
-class DocumentManager:
-    """Gerencia templates e contextos dos documentos"""
-
-    @staticmethod
-    def create_prompt_messages(doc_type: str, context: Dict[str, str]) -> List[Dict[str, str]]:
-        """Cria a sequência de mensagens para o modelo"""
-        
-        system_message = {
-            "role": "system",
-            "content": """Você é um advogado criminalista brasileiro altamente experiente, especializado em redigir peças processuais.
-            Gere documentos jurídicos formais, tecnicamente precisos e no formato do direito brasileiro."""
-        }
+def load_token() -> str:
+    """Carrega o token HF de várias fontes possíveis"""
+    # Prioridade: 1. Variável de ambiente, 2. Arquivo .env, 3. arquivo config.json
+    
+    # Verifica variável de ambiente
+    token = os.getenv('HF_TOKEN')
+    if token:
+        return token
         
-        user_message = {
-            "role": "user",
-            "content": f"""Por favor, gere um {doc_type} completo e tecnicamente preciso com os seguintes dados:
-
-QUALIFICAÇÃO:
-Cliente: {context.get('client_name')}
-Processo: {context.get('process_number')}
-Tribunal: {context.get('court')}
-Comarca: {context.get('jurisdiction')}
-
-FATOS:
-{context.get('facts')}
-
-FUNDAMENTOS JURÍDICOS:
-{context.get('legal_basis')}
+    # Verifica arquivo config.json
+    config_file = Path('config.json')
+    if config_file.exists():
+        try:
+            with open(config_file, 'r') as f:
+                config = json.load(f)
+                return config.get('hf_token', '')
+        except Exception as e:
+            logger.error(f"Erro ao ler config.json: {e}")
+    
+    return ''
 
-O documento deve seguir a formatação jurídica padrão, incluindo:
-1. Cabeçalho com endereçamento correto
-2. Qualificação completa das partes
-3. Exposição clara dos fatos
-4. Fundamentação jurídica sólida
-5. Pedidos específicos
-6. Fechamento formal com local, data e espaço para assinatura"""
-        }
-        
-        return [system_message, user_message]
+# Carrega o token
+HF_API_TOKEN = load_token()
 
 class DocumentGenerator:
-    """Gerencia a geração de documentos usando HuggingFace Inference API"""
+    """Gerencia a geração de documentos usando HF Inference API"""
     
     def __init__(self, api_key: str):
+        if not api_key:
+            raise ValueError("API Key não encontrada. Configure HF_TOKEN nas variáveis de ambiente ou no arquivo config.json")
+        
         self.client = InferenceClient(api_key=api_key)
         self.model = "mistralai/Mistral-7B-Instruct-v0.2"
-        self.doc_manager = DocumentManager()
     
     def generate(self, doc_type: str, context: Dict[str, str]) -> str:
         """Gera o documento usando o modelo"""
         try:
-            # Prepara as mensagens
-            messages = self.doc_manager.create_prompt_messages(doc_type, context)
+            # Prepara as mensagens para o chat
+            messages = [
+                {
+                    "role": "system",
+                    "content": """Você é um advogado criminalista brasileiro experiente.
+                    Gere documentos jurídicos formais no formato do direito brasileiro."""
+                },
+                {
+                    "role": "user",
+                    "content": f"""Gere um {doc_type} completo com os seguintes dados:
+                    
+                    QUALIFICAÇÃO:
+                    Cliente: {context.get('client_name')}
+                    Processo: {context.get('process_number')}
+                    Tribunal: {context.get('court')}
+                    Comarca: {context.get('jurisdiction')}
+                    
+                    FATOS:
+                    {context.get('facts')}
+                    
+                    FUNDAMENTOS JURÍDICOS:
+                    {context.get('legal_basis')}
+                    
+                    Use formato jurídico adequado, com todas as partes necessárias."""
+                }
+            ]
             
             # Faz a chamada à API
             completion = self.client.chat.completions.create(
                 model=self.model,
                 messages=messages,
-                temperature=0.3,    # Mais conservador para documentos formais
-                top_p=0.85,         # Mantém coerência
-                max_tokens=2048,    # Documento completo
+                temperature=0.3,
+                top_p=0.85,
+                max_tokens=2048,
             )
             
             return self._format_output(completion.choices[0].message.content)
@@ -85,18 +101,13 @@ class DocumentGenerator:
         """Formata o texto gerado"""
         if not text:
             return "Erro: Nenhum texto gerado"
-        
-        # Remove espaços extras e formata parágrafos
-        lines = [line.strip() for line in text.split('\n') if line.strip()]
-        formatted_text = '\n\n'.join(lines)
-        
-        return formatted_text.strip()
+        return text.strip()
 
 class WebInterface:
     """Interface Gradio para o gerador de documentos"""
     
     def __init__(self):
-        self.generator = DocumentGenerator(api_key=HF_API_KEY)
+        self.generator = DocumentGenerator(api_key=HF_API_TOKEN)
         self.create_interface()
     
     def create_interface(self):
@@ -104,13 +115,12 @@ class WebInterface:
         
         with gr.Blocks(theme=gr.themes.Soft()) as self.app:
             gr.Markdown("""
-            # Criminal.ai - Gerador de Peças Processuais
-            ### Sistema Inteligente de Geração de Documentos Jurídicos
+            # Criminal.ai - Gerador de Documentos Jurídicos
+            Sistema de geração de peças processuais criminais
             """)
             
             with gr.Row():
                 with gr.Column():
-                    # Tipo de documento
                     doc_type = gr.Dropdown(
                         choices=[
                             "Habeas Corpus",
@@ -121,108 +131,48 @@ class WebInterface:
                             "Apelação Criminal"
                         ],
                         label="Tipo de Documento",
-                        value="Habeas Corpus",
-                        info="Selecione o tipo de peça processual"
+                        value="Habeas Corpus"
                     )
                     
-                    # Informações do processo
                     with gr.Group():
                         gr.Markdown("### Informações do Processo")
-                        
                         client_name = gr.Textbox(
                             label="Nome do Cliente",
-                            placeholder="Nome completo do cliente/paciente",
-                            info="Digite o nome completo"
+                            placeholder="Nome completo"
                         )
-                        
                         process_number = gr.Textbox(
                             label="Número do Processo",
-                            placeholder="NNNNNNN-NN.NNNN.N.NN.NNNN",
-                            info="Número CNJ do processo"
+                            placeholder="NNNNNNN-NN.NNNN.N.NN.NNNN"
                         )
-                        
                         court = gr.Textbox(
                             label="Tribunal",
-                            value="TRIBUNAL DE JUSTIÇA DO ESTADO",
-                            info="Nome completo do tribunal"
+                            value="TRIBUNAL DE JUSTIÇA DO ESTADO"
                         )
-                        
                         jurisdiction = gr.Textbox(
-                            label="Comarca",
-                            placeholder="Nome da comarca",
-                            info="Comarca onde tramita o processo"
+                            label="Comarca"
                         )
                     
-                    # Detalhes do caso
                     with gr.Group():
                         gr.Markdown("### Detalhes do Caso")
-                        
                         facts = gr.Textbox(
                             label="Fatos",
                             lines=5,
-                            placeholder="Descreva os fatos relevantes do caso...",
-                            info="Descreva os fatos de forma clara e objetiva"
+                            placeholder="Descreva os fatos..."
                         )
-                        
                         legal_basis = gr.Textbox(
                             label="Fundamentos Jurídicos",
-                            lines=3,
-                            placeholder="Indique os fundamentos legais...",
-                            info="Artigos, jurisprudência e doutrina aplicáveis"
-                        )
-                    
-                    # Status e botões
-                    with gr.Row():
-                        generate_btn = gr.Button(
-                            "📝 Gerar Documento",
-                            variant="primary",
-                            scale=2
-                        )
-                        
-                        clear_btn = gr.Button(
-                            "🗑️ Limpar",
-                            variant="secondary",
-                            scale=1
+                            lines=3
                         )
                     
-                    status = gr.Textbox(
-                        label="Status",
-                        interactive=False,
-                        show_label=False
-                    )
+                    generate_btn = gr.Button("Gerar Documento", variant="primary")
                 
-                # Coluna de saída
                 with gr.Column():
                     output = gr.Textbox(
                         label="Documento Gerado",
                         lines=30,
-                        show_copy_button=True,
-                        show_label=True,
-                        container=True
+                        show_copy_button=True
                     )
-                    
-                    with gr.Row():
-                        copy_btn = gr.Button("📋 Copiar")
-                        download_btn = gr.Button("💾 Salvar como .txt")
-            
-            # Exemplos
-            gr.Examples(
-                examples=[
-                    [
-                        "Habeas Corpus",
-                        "João da Silva Santos",
-                        "0000123-45.2024.8.26.0000",
-                        "TRIBUNAL DE JUSTIÇA DO ESTADO DE SÃO PAULO",
-                        "São Paulo",
-                        "Paciente preso em flagrante no dia 25/12/2024 por suposto furto simples (art. 155, caput, do CP). Não estão presentes os requisitos da prisão preventiva, sendo o paciente primário, com residência fixa e trabalho lícito.",
-                        "Art. 5º, LXVIII da CF/88; Art. 647 do CPP; Art. 312 do CPP; Súmula 308 do STJ."
-                    ]
-                ],
-                inputs=[
-                    doc_type, client_name, process_number,
-                    court, jurisdiction, facts, legal_basis
-                ]
-            )
+                    status = gr.Textbox(label="Status")
             
             # Eventos
             generate_btn.click(
@@ -233,42 +183,6 @@ class WebInterface:
                 ],
                 outputs=[output, status]
             )
-            
-            def clear_inputs():
-                return [
-                    gr.update(value="") for _ in range(6)
-                ] + [gr.update(value="Campos limpos")]
-            
-            clear_btn.click(
-                fn=clear_inputs,
-                inputs=[],
-                outputs=[
-                    client_name, process_number, court,
-                    jurisdiction, facts, legal_basis,
-                    status
-                ]
-            )
-            
-            copy_btn.click(
-                fn=lambda x: gr.update(value=x),
-                inputs=[output],
-                outputs=[output]
-            )
-            
-            def save_document(text):
-                if not text:
-                    return "Nenhum documento para salvar"
-                    
-                filename = f"documento_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
-                with open(filename, 'w', encoding='utf-8') as f:
-                    f.write(text)
-                return f"Documento salvo como {filename}"
-            
-            download_btn.click(
-                fn=save_document,
-                inputs=[output],
-                outputs=[status]
-            )
     
     def _generate_document(
         self, doc_type: str, client_name: str,
@@ -277,11 +191,9 @@ class WebInterface:
         legal_basis: str
     ) -> tuple:
         """Gera o documento com os parâmetros fornecidos"""
-        
         try:
-            # Validação básica
             if not all([client_name, process_number, facts, legal_basis]):
-                return "⚠️ Erro: Todos os campos obrigatórios devem ser preenchidos", "⚠️ Preencha todos os campos obrigatórios"
+                return "Erro: Preencha todos os campos obrigatórios", "⚠️ Campos incompletos"
             
             context = {
                 "client_name": client_name,
@@ -292,13 +204,8 @@ class WebInterface:
                 "legal_basis": legal_basis
             }
             
-            # Atualiza status
-            yield "", "⏳ Gerando documento..."
-            
-            # Gera documento
             result = self.generator.generate(doc_type, context)
-            
-            return result, "✅ Documento gerado com sucesso!"
+            return result, "✅ Documento gerado com sucesso"
             
         except Exception as e:
             logger.error(f"Erro: {str(e)}")
@@ -309,10 +216,18 @@ class WebInterface:
         self.app.launch(share=True)
 
 if __name__ == "__main__":
-    # Verificar token
-    if HF_API_KEY == "hf_seu_token_aqui":
-        print("⚠️ Atenção: Configure sua API key do Hugging Face antes de executar!")
-        print("Substitua 'hf_seu_token_aqui' pela sua chave real.")
-    else:
-        interface = WebInterface()
-        interface.launch()
+    # Verifica se o token está configurado
+    if not HF_API_TOKEN:
+        print("\n⚠️  Token HF não encontrado!")
+        print("\nPara configurar o token:")
+        print("1. Crie um arquivo .env com:")
+        print("   HF_TOKEN=seu_token_aqui")
+        print("\nOu")
+        print("2. Crie um arquivo config.json com:")
+        print('   {"hf_token": "seu_token_aqui"}')
+        print("\nOu")
+        print("3. Configure a variável de ambiente HF_TOKEN")
+        exit(1)
+    
+    interface = WebInterface()
+    interface.launch()