Create app.py

app.py

@@ -0,0 +1,320 @@
+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)
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    def __init__(self, db_path: str = "legal_docs.db"):
+        self.db_path = db_path
+        self.init_database()
+    
+    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()
+        
+    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:
+            
+            CONTEXTO DO CASO:
+            {caso_detalhes}
+            
+            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
+            
+            ESTRUTURA REQUERIDA:
+            - Cabeçalho completo com qualificação
+            - Fatos detalhados
+            - Fundamentos jurídicos
+            - Jurisprudência aplicável
+            - Pedidos liminar e final
+            """,
+            
+            "denuncia_crime": """
+            Atue como um advogado criminalista experiente e gere uma denúncia criminal detalhada:
+            
+            DETALHES DO CASO:
+            {caso_detalhes}
+            
+            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
+            
+            ESTRUTURA:
+            - Qualificação completa
+            - Narrativa dos fatos
+            - Tipificação penal
+            - Pedidos
+            - Provas a produzir
+            """,
+            
+            "recurso_especial": """
+            Atue como um advogado criminalista e gere um Recurso Especial Criminal:
+            
+            CASO E DECISÃO RECORRIDA:
+            {caso_detalhes}
+            
+            REQUISITOS:
+            1. Demonstre o prequestionamento
+            2. Indique violação à lei federal
+            3. Cite precedentes do STJ
+            4. Demonstre divergência jurisprudencial
+            
+            ESTRUTURA:
+            - Cabimento e tempestividade
+            - Prequestionamento
+            - Mérito recursal
+            - 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
+
+class LegalDocumentGenerator:
+    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:
+        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)
+            
+            # Salva o documento gerado
+            self._save_document(doc_type, result, context)
+            
+            return 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"
+        )
+    
+    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')
+            ))
+
+class AdvancedLegalInterface:
+    def __init__(self):
+        self.generator = LegalDocumentGenerator()
+        self.create_interface()
+    
+    def create_interface(self):
+        with gr.Blocks(theme=gr.themes.Glass()) as self.app:
+            gr.Markdown("""
+            # Sistema Avançado de Geração de Peças 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.Tab("Histórico"):
+                    self._create_history_viewer()
+            
+            # 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
+                ],
+                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
+        
+        except Exception as e:
+            logger.error(f"Erro na geração: {str(e)}")
+            return f"Erro na geração do documento: {str(e)}"
+    
+    def launch(self):
+        self.app.launch(share=True)
+
+if __name__ == "__main__":
+    interface = AdvancedLegalInterface()
+    interface.launch()