Update app.py

app.py

@@ -1,320 +1,264 @@
 import gradio as gr
 from gradio_client import Client
 import json
-import sqlite3
 from datetime import datetime
 import os
 from typing import Dict, List, Optional
-import asyncio
-from pathlib import Path
 import logging
 
-logging.basicConfig(level=logging.INFO)
+# Configuração do logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
-class DatabaseManager:
-    def __init__(self, db_path: str = "legal_docs.db"):
-        self.db_path = db_path
-        self.init_database()
+class PromptManager:
+    """Gerencia a criação e otimização de prompts"""
     
-    def init_database(self):
-        with sqlite3.connect(self.db_path) as conn:
-            conn.execute("""
-                CREATE TABLE IF NOT EXISTS documents (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    title TEXT,
-                    doc_type TEXT,
-                    content TEXT,
-                    created_at TIMESTAMP,
-                    client_name TEXT,
-                    process_number TEXT,
-                    template_used TEXT
-                )
-            """)
-            conn.execute("""
-                CREATE TABLE IF NOT EXISTS templates (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    name TEXT,
-                    doc_type TEXT,
-                    content TEXT,
-                    created_at TIMESTAMP
-                )
-            """)
-            conn.execute("""
-                CREATE TABLE IF NOT EXISTS jurisprudence (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    topic TEXT,
-                    content TEXT,
-                    source TEXT,
-                    relevance INTEGER
-                )
-            """)
-
-class PromptOptimizer:
-    def __init__(self):
-        self.base_prompts = self._load_base_prompts()
+    @staticmethod
+    def get_base_prompt(doc_type: str, context: Dict[str, str]) -> str:
+        """Retorna o prompt base para cada tipo de documento"""
         
-    def _load_base_prompts(self) -> Dict[str, str]:
-        return {
-            "habeas_corpus": """
-            Atue como um advogado criminalista experiente e gere um Habeas Corpus detalhado e tecnicamente preciso:
+        prompts = {
+            "habeas_corpus": f"""
+            Atue como um advogado criminalista experiente e gere um Habeas Corpus detalhado:
+            
+            DADOS DO CASO:
+            Cliente: {context.get('client_name')}
+            Processo: {context.get('process_number')}
+            Tribunal: {context.get('court')}
+            Comarca: {context.get('jurisdiction')}
             
-            CONTEXTO DO CASO:
-            {caso_detalhes}
+            FATOS:
+            {context.get('facts')}
             
-            REQUISITOS ESPECÍFICOS:
-            1. Use linguagem jurídica formal
-            2. Cite jurisprudência relevante dos tribunais superiores
-            3. Estruture o documento com todas as partes necessárias
-            4. Inclua argumentos constitucionais pertinentes
-            5. Faça referências específicas ao CPP
+            FUNDAMENTOS JURÍDICOS:
+            {context.get('legal_basis')}
             
-            ESTRUTURA REQUERIDA:
-            - Cabeçalho completo com qualificação
-            - Fatos detalhados
-            - Fundamentos jurídicos
-            - Jurisprudência aplicável
-            - Pedidos liminar e final
+            Gere um Habeas Corpus completo e tecnicamente preciso, incluindo:
+            1. Cabeçalho com endereçamento correto
+            2. Qualificação das partes
+            3. Fatos relevantes
+            4. Fundamentos jurídicos
+            5. Jurisprudência relevante
+            6. Pedidos (liminar e mérito)
             """,
             
-            "denuncia_crime": """
-            Atue como um advogado criminalista experiente e gere uma denúncia criminal detalhada:
+            "denuncia": f"""
+            Atue como um promotor de justiça experiente e gere uma denúncia criminal:
             
-            DETALHES DO CASO:
-            {caso_detalhes}
+            DADOS DO CASO:
+            Processo: {context.get('process_number')}
+            Tribunal: {context.get('court')}
+            Comarca: {context.get('jurisdiction')}
             
-            REQUISITOS:
-            1. Descreva os fatos com precisão temporal
-            2. Tipifique corretamente a conduta
-            3. Indique as circunstâncias do crime
-            4. Qualifique todos os envolvidos
-            5. Indique as provas disponíveis
+            FATOS:
+            {context.get('facts')}
             
-            ESTRUTURA:
-            - Qualificação completa
-            - Narrativa dos fatos
-            - Tipificação penal
-            - Pedidos
-            - Provas a produzir
+            ENQUADRAMENTO LEGAL:
+            {context.get('legal_basis')}
+            
+            Gere uma denúncia criminal completa, incluindo:
+            1. Qualificação do(s) denunciado(s)
+            2. Narrativa clara dos fatos
+            3. Tipificação penal
+            4. Circunstâncias do crime
+            5. Rol de testemunhas
+            6. Pedidos
             """,
             
-            "recurso_especial": """
-            Atue como um advogado criminalista e gere um Recurso Especial Criminal:
+            "alegacoes_finais": f"""
+            Atue como um advogado criminalista e gere alegações finais:
+            
+            DADOS DO PROCESSO:
+            Cliente: {context.get('client_name')}
+            Processo: {context.get('process_number')}
+            Tribunal: {context.get('court')}
             
-            CASO E DECISÃO RECORRIDA:
-            {caso_detalhes}
+            FATOS E PROVAS:
+            {context.get('facts')}
             
-            REQUISITOS:
-            1. Demonstre o prequestionamento
-            2. Indique violação à lei federal
-            3. Cite precedentes do STJ
-            4. Demonstre divergência jurisprudencial
+            TESE DEFENSIVA:
+            {context.get('legal_basis')}
             
-            ESTRUTURA:
-            - Cabimento e tempestividade
-            - Prequestionamento
-            - Mérito recursal
-            - Pedidos
+            Elabore alegações finais completas, incluindo:
+            1. Relatório do processo
+            2. Preliminares (se houver)
+            3. Mérito
+            4. Análise das provas
+            5. Pedidos
             """
         }
-    
-    def optimize_prompt(self, doc_type: str, context: Dict[str, str]) -> str:
-        base_prompt = self.base_prompts.get(doc_type, "")
-        optimized = base_prompt.format(caso_detalhes=json.dumps(context, indent=2))
-        return optimized
+        
+        return prompts.get(doc_type, "Tipo de documento não suportado")
 
-class LegalDocumentGenerator:
+class DocumentGenerator:
+    """Gerencia a geração de documentos usando a API do LLama"""
+    
     def __init__(self):
         self.client = Client("ysharma/Chat_with_Meta_llama3_8b")
-        self.db = DatabaseManager()
-        self.prompt_optimizer = PromptOptimizer()
-        
-    async def generate_document(self, doc_type: str, context: Dict[str, str], 
-                              template_id: Optional[int] = None) -> str:
+        self.prompt_manager = PromptManager()
+    
+    def generate(self, doc_type: str, context: Dict[str, str]) -> str:
+        """Gera o documento baseado no tipo e contexto"""
         try:
-            # Otimiza o prompt baseado no tipo de documento
-            optimized_prompt = self.prompt_optimizer.optimize_prompt(doc_type, context)
-            
-            # Gera o documento usando a API do Llama
-            result = await self._generate_with_llama(optimized_prompt)
+            prompt = self.prompt_manager.get_base_prompt(doc_type, context)
             
-            # Salva o documento gerado
-            self._save_document(doc_type, result, context)
+            result = self.client.predict(
+                message=prompt,
+                request=0.85,  # temperatura mais baixa para maior consistência
+                param_3=3072,  # tokens aumentados para documentos longos
+                api_name="/chat"
+            )
             
-            return result
+            return self._format_output(result)
             
         except Exception as e:
             logger.error(f"Erro na geração do documento: {str(e)}")
-            raise
-
-    async def _generate_with_llama(self, prompt: str) -> str:
-        return self.client.predict(
-            message=prompt,
-            request=0.85,  # Temperatura reduzida para maior consistência
-            param_3=3072,  # Aumentado para documentos mais longos
-            api_name="/chat"
-        )
+            return f"Erro na geração do documento: {str(e)}"
     
-    def _save_document(self, doc_type: str, content: str, context: Dict[str, str]):
-        with sqlite3.connect(self.db.db_path) as conn:
-            conn.execute("""
-                INSERT INTO documents 
-                (title, doc_type, content, created_at, client_name, process_number)
-                VALUES (?, ?, ?, ?, ?, ?)
-            """, (
-                f"{doc_type}_{context.get('client_name')}",
-                doc_type,
-                content,
-                datetime.now(),
-                context.get('client_name'),
-                context.get('process_number')
-            ))
+    def _format_output(self, text: str) -> str:
+        """Formata o texto gerado para melhor apresentação"""
+        return text.strip()
 
-class AdvancedLegalInterface:
+class WebInterface:
+    """Interface Gradio para o gerador de documentos"""
+    
     def __init__(self):
-        self.generator = LegalDocumentGenerator()
+        self.generator = DocumentGenerator()
         self.create_interface()
     
     def create_interface(self):
-        with gr.Blocks(theme=gr.themes.Glass()) as self.app:
+        """Cria a interface web com Gradio"""
+        
+        with gr.Blocks(theme=gr.themes.Soft()) as self.app:
             gr.Markdown("""
-            # Sistema Avançado de Geração de Peças Criminais
+            # Gerador de Documentos Criminais
             ### Powered by LLM Technology
             """)
             
-            with gr.Tabs():
-                with gr.Tab("Gerar Documento"):
-                    with gr.Row():
-                        with gr.Column():
-                            doc_type = gr.Dropdown(
-                                choices=[
-                                    "Habeas Corpus",
-                                    "Denúncia Criminal",
-                                    "Recurso Especial",
-                                    "Alegações Finais",
-                                    "Resposta à Acusação",
-                                    "Revisão Criminal",
-                                    "Apelação Criminal"
-                                ],
-                                label="Tipo de Documento"
-                            )
-                            
-                            client_info = gr.Group()
-                            with client_info:
-                                client_name = gr.Textbox(label="Nome do Cliente")
-                                process_number = gr.Textbox(label="Número do Processo")
-                                court = gr.Textbox(label="Tribunal")
-                                jurisdiction = gr.Textbox(label="Comarca")
-                            
-                            case_details = gr.Group()
-                            with case_details:
-                                facts = gr.Textbox(
-                                    label="Fatos",
-                                    lines=5,
-                                    placeholder="Descreva os fatos relevantes..."
-                                )
-                                legal_basis = gr.Textbox(
-                                    label="Fundamentos Jurídicos",
-                                    lines=3,
-                                    placeholder="Indique os principais fundamentos legais..."
-                                )
-                            
-                            advanced_options = gr.Group()
-                            with advanced_options:
-                                use_template = gr.Checkbox(label="Usar Template Personalizado")
-                                template_select = gr.Dropdown(
-                                    choices=self._get_templates(),
-                                    label="Template",
-                                    visible=False
-                                )
-                                include_jurisprudence = gr.Checkbox(
-                                    label="Incluir Jurisprudência Relevante"
-                                )
-                            
-                            generate_btn = gr.Button("Gerar Documento", variant="primary")
-                            
-                        with gr.Column():
-                            output = gr.Textbox(
-                                label="Documento Gerado",
-                                lines=30,
-                                show_copy_button=True
-                            )
-                            
-                            with gr.Row():
-                                save_btn = gr.Button("Salvar Documento")
-                                export_btn = gr.Button("Exportar como PDF")
-                
-                with gr.Tab("Gerenciar Templates"):
-                    self._create_template_manager()
+            with gr.Row():
+                with gr.Column():
+                    # Seleção do tipo de documento
+                    doc_type = gr.Dropdown(
+                        choices=[
+                            "Habeas Corpus",
+                            "Denúncia",
+                            "Alegações Finais",
+                            "Resposta à Acusação",
+                            "Recurso em Sentido Estrito",
+                            "Apelação Criminal"
+                        ],
+                        label="Tipo de Documento",
+                        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"
+                        )
+                        process_number = gr.Textbox(
+                            label="Número do Processo",
+                            placeholder="NNNNNNN-NN.NNNN.N.NN.NNNN"
+                        )
+                        court = gr.Textbox(
+                            label="Tribunal",
+                            value="TRIBUNAL DE JUSTIÇA DO ESTADO"
+                        )
+                        jurisdiction = gr.Textbox(
+                            label="Comarca",
+                            placeholder="Comarca onde tramita o processo"
+                        )
+                    
+                    # 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..."
+                        )
+                        legal_basis = gr.Textbox(
+                            label="Fundamentos Jurídicos",
+                            lines=3,
+                            placeholder="Indique os fundamentos legais principais..."
+                        )
+                    
+                    generate_btn = gr.Button(
+                        "Gerar Documento",
+                        variant="primary"
+                    )
                 
-                with gr.Tab("Histórico"):
-                    self._create_history_viewer()
+                with gr.Column():
+                    output = gr.Textbox(
+                        label="Documento Gerado",
+                        lines=30,
+                        show_copy_button=True
+                    )
+            
+            # Exemplos de uso
+            gr.Examples(
+                examples=[
+                    [
+                        "Habeas Corpus",
+                        "João da Silva",
+                        "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...",
+                        "Art. 5º, LXVIII da CF/88; Art. 647 do CPP; Ausência dos requisitos do Art. 312 do CPP"
+                    ]
+                ],
+                inputs=[
+                    doc_type, client_name, process_number,
+                    court, jurisdiction, facts, legal_basis
+                ]
+            )
             
             # Eventos
             generate_btn.click(
                 fn=self._generate_document,
                 inputs=[
-                    doc_type, client_name, process_number, court,
-                    jurisdiction, facts, legal_basis, use_template,
-                    template_select, include_jurisprudence
+                    doc_type, client_name, process_number,
+                    court, jurisdiction, facts, legal_basis
                 ],
                 outputs=output
             )
-            
-            use_template.change(
-                fn=lambda x: gr.update(visible=x),
-                inputs=[use_template],
-                outputs=[template_select]
-            )
-    
-    def _get_templates(self) -> List[str]:
-        with sqlite3.connect(self.generator.db.db_path) as conn:
-            templates = conn.execute("SELECT name FROM templates").fetchall()
-            return [t[0] for t in templates]
-    
-    def _create_template_manager(self):
-        with gr.Group():
-            gr.Markdown("### Gerenciar Templates")
-            template_name = gr.Textbox(label="Nome do Template")
-            template_content = gr.Textbox(label="Conteúdo", lines=10)
-            save_template_btn = gr.Button("Salvar Template")
-    
-    def _create_history_viewer(self):
-        with gr.Group():
-            gr.Markdown("### Histórico de Documentos")
-            history_table = gr.Dataframe(
-                headers=["Data", "Tipo", "Cliente", "Processo"],
-                row_count=10
-            )
     
-    async def _generate_document(self, *args) -> str:
-        try:
-            context = {
-                "client_name": args[1],
-                "process_number": args[2],
-                "court": args[3],
-                "jurisdiction": args[4],
-                "facts": args[5],
-                "legal_basis": args[6],
-                "use_template": args[7],
-                "template": args[8] if args[7] else None,
-                "include_jurisprudence": args[9]
-            }
-            
-            result = await self.generator.generate_document(
-                doc_type=args[0].lower().replace(" ", "_"),
-                context=context
-            )
-            
-            return result
+    def _generate_document(
+        self, doc_type: str, client_name: str,
+        process_number: str, court: str,
+        jurisdiction: str, facts: str,
+        legal_basis: str
+    ) -> str:
+        """Gera o documento com os parâmetros fornecidos"""
         
-        except Exception as e:
-            logger.error(f"Erro na geração: {str(e)}")
-            return f"Erro na geração do documento: {str(e)}"
+        # Validação básica
+        if not all([client_name, process_number, facts, legal_basis]):
+            return "Erro: Todos os campos obrigatórios devem ser preenchidos"
+        
+        context = {
+            "client_name": client_name,
+            "process_number": process_number,
+            "court": court,
+            "jurisdiction": jurisdiction,
+            "facts": facts,
+            "legal_basis": legal_basis
+        }
+        
+        return self.generator.generate(
+            doc_type.lower().replace(" ", "_"),
+            context
+        )
     
     def launch(self):
+        """Inicia a interface web"""
         self.app.launch(share=True)
 
 if __name__ == "__main__":
-    interface = AdvancedLegalInterface()
+    interface = WebInterface()
     interface.launch()