import gradio as gr import requests import json import os import copy # --- Configuration from Script 1 & 2 (merged) --- GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") if not GEMINI_API_KEY: print("ALERTA: GEMINI_API_KEY não encontrada como Secret no Hugging Face Space. O app não funcionará.") # Para teste local, descomente e cole sua chave, mas NÃO FAÇA COMMIT DISSO COM A CHAVE. # GEMINI_API_KEY = "SUA_CHAVE_AQUI_PARA_TESTE_LOCAL_APENAS" MODEL_NAME = "gemini-1.5-flash-latest" # Consistent model name API_URL_BASE = f"https://generativelanguage.googleapis.com/v1beta/models/{MODEL_NAME}:generateContent" # --- Fases da AIJ (from Script 1) --- FASE_INICIAL_CONFIG = "CONFIGURACAO" FASE_ABERTURA_CONCILIACAO = "ABERTURA_E_CONCILIACAO" FASE_TESTEMUNHAS_AUTOR_INICIO = "TESTEMUNHAS_AUTOR_INICIO" FASE_TESTEMUNHAS_AUTOR_PERGUNTAS_AUTOR = "TESTEMUNHAS_AUTOR_PERGUNTAS_AUTOR" FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU = "TESTEMUNHAS_AUTOR_CONTRADITA_REU" FASE_TESTEMUNHAS_REU_INICIO = "TESTEMUNHAS_REU_INICIO" FASE_TESTEMUNHAS_REU_PERGUNTAS_REU = "TESTEMUNHAS_REU_PERGUNTAS_REU" FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR = "TESTEMUNHAS_REU_INQUIRICAO_AUTOR" FASE_ALEGACOES_FINAIS_AUTOR = "ALEGACOES_FINAIS_AUTOR" FASE_ALEGACOES_FINAIS_REU = "ALEGACOES_FINAIS_REU" FASE_ANALISE_FINAL_PROFESSOR = "ANALISE_FINAL_PROFESSOR" FASE_CONCLUIDA = "AIJ_CONCLUIDA" # --- Predefined Case Data (from Script 2, adapted for Script 1 structure) --- CASO_TITULO_PREDEFINIDO = "O Caso da Reportagem Revisitada" CASO_PARTES_PREDEFINIDO = "Autor: Carlos Alberto Mendes\nRéu: Jornal 'A Verdade Diária'" CASO_DESCRICAO_PREDEFINIDO = """ Uma pessoa (Carlos Alberto Mendes) processou um jornal (A Verdade Diária) alegando violação do direito ao esquecimento. O jornal publicou uma matéria relembrando um crime ocorrido há 15 anos, no qual o autor foi acusado de fraude, mas posteriormente absolvido por falta de provas. A matéria original foi publicada na época dos fatos e a nova matéria, parte de uma série "Crimes que Marcaram a Cidade", revisitou o caso, mencionando a absolvição. O autor alega que a republicação da história, mesmo com a menção da absolvição, causou-lhe constrangimentos sociais, dificuldades em obter novo emprego e reacendeu traumas passados, afetando sua vida familiar. Ele requer a remoção da matéria do site do jornal e uma indenização por danos morais. O jornal (réu) defende a liberdade de imprensa e o direito à informação, argumentando que a matéria tem interesse público histórico, é factualmente correta (inclusive quanto à absolvição) e faz parte do acervo jornalístico que documenta a história da comunidade. """ CASO_FATOS_COMPLETO_PREDEFINIDO = f"Título: {CASO_TITULO_PREDEFINIDO}\nPartes:\n{CASO_PARTES_PREDEFINIDO}\n\n---INÍCIO DOS FATOS---\n{CASO_DESCRICAO_PREDEFINIDO.strip()}" ARGUMENTOS_AUTOR_PREDEFINIDOS = [ "Argumento: A matéria publicada reabriu feridas do passado e causou danos psicológicos e sociais ao autor. Prova: Laudo psicológico atestando abalo emocional e depoimentos sobre constrangimento social.", "Argumento: O autor já foi absolvido judicialmente e tem direito a reconstruir sua vida sem o estigma do passado. Prova: Cópia da sentença absolutória.", "Argumento: O tempo transcorrido (15 anos) torna o caso desatualizado e sem relevância pública atual que justifique a exposição. Prova: Irrelevância pública atual, foco no dano individual.", "Argumento: A publicação violou o direito à privacidade e à honra do autor. Prova: Doutrina e jurisprudência sobre direitos da personalidade." ] PROVAS_AUTOR_SUPPOSTAS_TEXTO_PREDEFINIDO = "\n".join(ARGUMENTOS_AUTOR_PREDEFINIDOS) CONTRA_ARGUMENTOS_REU_PREDEFINIDOS = [ "Argumento: A liberdade de imprensa é um direito fundamental e a matéria é de interesse público histórico. Prova: Art. 5º, IX e XIV da CF/88; Doutrina sobre liberdade de imprensa.", "Argumento: A matéria baseia-se inteiramente em informações verídicas e de acesso público (processo judicial). Prova: Cópia da matéria original e da recente, certidão do processo.", "Argumento: O STF (RE 1.010.606) não reconheceu o direito ao esquecimento de forma absoluta, ponderando-o com a liberdade de informação. Prova: Inteiro teor do acórdão do RE 1.010.606.", "Argumento: A matéria destacou a absolvição do autor, não havendo intenção de difamar. Prova: Conteúdo da própria matéria." ] PROVAS_REU_TEXTO_PREDEFINIDO = "\n".join(CONTRA_ARGUMENTOS_REU_PREDEFINIDOS) TESTEMUNHAS_REU_PREDEFINIDAS = [ {"nome": "João Silva", "pontos_chave": "Editor-chefe do jornal. Confirmará o processo editorial, o interesse público da série de reportagens e a ausência de intenção de prejudicar o autor."}, {"nome": "Dra. Maria Santos", "pontos_chave": "Historiadora local. Atestará a relevância histórica do caso para a comunidade e a importância de preservar a memória de tais eventos."}, {"nome": "Roberto Almeida", "pontos_chave": "Jornalista responsável pela matéria. Detalhará a pesquisa, a verificação dos fatos e a menção explícita à absolvição do autor."} ] TESTEMUNHAS_REU_TEXTO_PREDEFINIDO = "\n".join([f"{t['nome']}: {t['pontos_chave']}" for t in TESTEMUNHAS_REU_PREDEFINIDAS]) # Para o caso padrão, precisamos de testemunhas do autor também. TESTEMUNHAS_AUTOR_SUPPOSTAS_PREDEFINIDAS_TEXTO = """ Dr. Felipe Antunes: Psicólogo do autor. Relatará o impacto emocional da nova reportagem na vida do autor. Sra. Clara Dias: Vizinha do autor. Comentará sobre as mudanças no tratamento social que o autor recebeu após a reportagem. """ LEGISLACAO_PRECEDENTES_PREDEFINIDO = { "favoraveis_ao_reu": [ "Art. 5º, IV, IX e XIV da Constituição Federal - garantia da liberdade de expressão e acesso à informação", "ADPF 130 (STF) - declarou a Lei de Imprensa incompatível com a ordem constitucional atual", "RE 1.010.606 (STF) - não reconheceu o direito ao esquecimento na esfera civil de forma irrestrita", "Pacto de San José da Costa Rica - proteção à liberdade de expressão", ], "favoraveis_ao_autor": [ "Art. 5º, X da Constituição Federal - inviolabilidade da intimidade, vida privada e honra", "Art. 21 do Código Civil - proteção à vida privada", "Enunciado 531 da VI Jornada de Direito Civil - reconhece o direito ao esquecimento", "LGPD (Lei Geral de Proteção de Dados) - embora não diretamente, reforça a proteção a dados pessoais." ] } # --- Funções de Estado e API (from Script 1) --- def estado_inicial_simulacao(): return { "fase_aij": FASE_INICIAL_CONFIG, "caso_fatos": "", "provas_reu_texto": "", "provas_autor_supostas_texto": "", "testemunhas_reu_defs": [], "testemunhas_autor_supostas_defs": [], "testemunha_autor_atual_idx": -1, "testemunha_reu_atual_idx": -1, "testemunha_em_depoimento": None, "transcricao_chat": [], "transcricao_logica": [], "feedback_para_usuario": "Aguardando início da simulação.", "instrucao_para_usuario": "Configure os detalhes do caso na aba 'Configuração' ou carregue o caso padrão." } def chamar_gemini_api(prompt_text, temperature=0.7, max_output_tokens=800): if not GEMINI_API_KEY: return "ERRO_FATAL: API Key do Gemini não configurada (verifique os Secrets do Space)." api_url_com_chave = f"{API_URL_BASE}?key={GEMINI_API_KEY}" headers = {'Content-Type': 'application/json'} data = { "contents": [{"parts": [{"text": prompt_text}]}], "generationConfig": {"temperature": temperature, "maxOutputTokens": max_output_tokens}, "safetySettings": [ {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"}, {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"}, {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"}, {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"} ] } try: response = requests.post(api_url_com_chave, headers=headers, data=json.dumps(data), timeout=180) # Increased timeout response.raise_for_status() response_json = response.json() if response_json.get("candidates") and response_json["candidates"][0].get("content"): return response_json["candidates"][0]["content"]["parts"][0]["text"].strip() elif response_json.get("promptFeedback") and response_json["promptFeedback"].get("blockReason"): return f"ERRO_API: Conteúdo bloqueado. Razão: {response_json['promptFeedback']['blockReason']}" return "ERRO_API: Resposta inesperada da API." except requests.exceptions.Timeout: return "ERRO_CONEXAO: Timeout ao chamar a API Gemini. Tente novamente." except requests.exceptions.RequestException as e: error_msg = f"ERRO_CONEXAO: {e}" if e.response is not None: try: error_msg += f" - Detalhes: {e.response.json().get('error', {}).get('message', e.response.text)}" except json.JSONDecodeError: error_msg += f" - Resposta não JSON: {e.response.text}" print(error_msg) return error_msg except Exception as e: print(f"Erro desconhecido na API: {e}") return f"ERRO_DESCONHECIDO: {e}" def formatar_historico_para_prompt(transcricao_logica, max_turns=15): historico_formatado = "\nContexto da Audiência (últimas interações):\n" for ator, fala in transcricao_logica[-max_turns:]: historico_formatado += f"- {ator}: {fala}\n" return historico_formatado # --- Funções de Geração de Conteúdo IA (from Script 1, some new) --- def gerar_caso_ficticio_com_ia(): # (Função mantida como no Script 1 original) prompt_geracao_caso = """ **Instrução de Persona:** Você é um roteirista jurídico criativo e experiente, especializado em criar casos simulados realistas para treinamento de advogados. **Tarefa:** Crie um caso fictício detalhado para uma simulação de Audiência de Instrução e Julgamento (AIJ) sobre o tema "Direito ao Esquecimento vs. Liberdade de Imprensa". **Elementos Obrigatórios a Serem Gerados:** 1. **Título do Caso Fictício:** (Ex: "O Caso da Notícia Ressurgida") 2. **Partes:** (Autor: Nome; Réu: Nome do veículo) 3. **Resumo Detalhado dos Fatos (Mínimo 250 palavras):** (Detalhes da publicação, lapso temporal, motivos do autor) 4. **Argumentos e "Provas" Hipotéticas da Parte AUTORA (mínimo 3):** (Formato: `Argumento: [Descrição]. Prova: [Descrição].`) 5. **Argumentos e "Provas" Hipotéticas da Parte RÉ (Jornal - mínimo 3):** (Formato: `Argumento: [Descrição]. Prova: [Descrição].`) 6. **Testemunhas Hipotéticas da Parte AUTORA (Pelo menos 1, idealmente 2):** (Formato: `[Nome]: [Pontos Chave]`) 7. **Testemunhas Hipotéticas da Parte RÉ (Pelo menos 1, idealmente 2):** (Formato: `[Nome]: [Pontos Chave]`) **Formato da Saída:** Use os seguintes marcadores exatos para cada seção (iniciando em nova linha): `## Título do Caso Fictício` `## Partes` `## Resumo Detalhado dos Fatos` `## Argumentos e "Provas" Hipotéticas da Parte AUTORA` `## Argumentos e "Provas" Hipotéticas da Parte RÉ (Jornal)` `## Testemunhas Hipotéticas da Parte AUTORA` `## Testemunhas Hipotéticas da Parte RÉ` O conteúdo de cada seção deve vir após o marcador. Para Argumentos/Provas e Testemunhas, liste cada item em uma nova linha. """ texto_caso_completo = chamar_gemini_api(prompt_geracao_caso, temperature=0.75, max_output_tokens=2500) # Increased tokens if "ERRO_" in texto_caso_completo: return {"fatos": f"Falha ao gerar caso com IA: {texto_caso_completo}", "provas_autor": "", "provas_reu": "", "testemunhas_autor": "", "testemunhas_reu": ""} return parse_caso_gerado(texto_caso_completo) def parse_caso_gerado(texto_completo_caso): # (Função mantida como no Script 1 original) dados_caso = {"fatos": "Falha parsing: Fatos", "provas_autor": "Falha parsing: Provas Autor", "provas_reu": "Falha parsing: Provas Réu", "testemunhas_autor": "Falha parsing: Testemunhas Autor", "testemunhas_reu": "Falha parsing: Testemunhas Réu"} secoes = {"fatos": "## Resumo Detalhado dos Fatos", "provas_autor": "## Argumentos e \"Provas\" Hipotéticas da Parte AUTORA", "provas_reu": "## Argumentos e \"Provas\" Hipotéticas da Parte RÉ (Jornal)", "testemunhas_autor": "## Testemunhas Hipotéticas da Parte AUTORA", "testemunhas_reu": "## Testemunhas Hipotéticas da Parte RÉ"} fatos_prefix = "" try: titulo_match = texto_completo_caso.split("## Título do Caso Fictício")[1].split("## Partes")[0].strip() partes_match_text = texto_completo_caso.split("## Partes")[1].split(secoes["fatos"])[0].strip() fatos_prefix = f"Título: {titulo_match}\nPartes:\n{partes_match_text}\n\n---INÍCIO DOS FATOS---\n" except IndexError: pass texto_lower = texto_completo_caso.lower() chaves_ordenadas = ["fatos", "provas_autor", "provas_reu", "testemunhas_autor", "testemunhas_reu"] marcadores_lower = {k: secoes[k].lower() for k in secoes} current_pos = 0 for i, chave_atual in enumerate(chaves_ordenadas): marcador_atual_lower = marcadores_lower[chave_atual] inicio_secao = texto_lower.find(marcador_atual_lower, current_pos) if inicio_secao == -1: continue inicio_conteudo = texto_completo_caso.find("\n", inicio_secao) + 1 if texto_completo_caso.find("\n", inicio_secao) != -1 else inicio_secao + len(secoes[chave_atual]) fim_conteudo = len(texto_completo_caso) if i + 1 < len(chaves_ordenadas): marcador_proximo_lower = marcadores_lower[chaves_ordenadas[i+1]] fim_conteudo_temp = texto_lower.find(marcador_proximo_lower, inicio_conteudo) if fim_conteudo_temp != -1: fim_conteudo = fim_conteudo_temp conteudo_secao = texto_completo_caso[inicio_conteudo:fim_conteudo].strip() dados_caso[chave_atual] = fatos_prefix + conteudo_secao if chave_atual == "fatos" and fatos_prefix else conteudo_secao current_pos = fim_conteudo for key_testemunha in ["testemunhas_autor", "testemunhas_reu"]: if "Falha no parsing" not in dados_caso[key_testemunha] and dados_caso[key_testemunha]: # Check if not empty linhas = dados_caso[key_testemunha].split('\n') linhas_formatadas = [] for linha in linhas: if linha.strip(): partes = linha.split(':', 1) if len(partes) == 2: linhas_formatadas.append(f"{partes[0].strip()}: {partes[1].strip()}") else: linhas_formatadas.append(partes[0].strip()) # Handle lines without colon if necessary dados_caso[key_testemunha] = "\n".join(linhas_formatadas) return dados_caso def acao_gerar_caso_ficticio_ui(): gr.Info("Gerando caso fictício com IA... Isso pode levar um momento.") dados_gerados = gerar_caso_ficticio_com_ia() return [dados_gerados["fatos"], dados_gerados["provas_reu"], dados_gerados["provas_autor"], dados_gerados["testemunhas_reu"], dados_gerados["testemunhas_autor"], "Caso fictício gerado. Revise e salve."] def acao_carregar_caso_padrao_ui(): gr.Info("Carregando caso padrão...") return [ CASO_FATOS_COMPLETO_PREDEFINIDO, PROVAS_REU_TEXTO_PREDEFINIDO, PROVAS_AUTOR_SUPPOSTAS_TEXTO_PREDEFINIDO, TESTEMUNHAS_REU_TEXTO_PREDEFINIDO, TESTEMUNHAS_AUTOR_SUPPOSTAS_PREDEFINIDAS_TEXTO, "Caso padrão carregado. Revise e salve." ] def gerar_resposta_juiz_ia(estado_simulacao, acao_especifica=""): # (Função mantida como no Script 1 original) fase = estado_simulacao["fase_aij"] historico = formatar_historico_para_prompt(estado_simulacao["transcricao_logica"]) prompt = f"**Persona:** Juiz(a) experiente em AIJ (Direito Esquecimento vs Liberdade Imprensa).\n**Fatos:** {estado_simulacao['caso_fatos'] or 'Não detalhado.'}\n{historico}**Fase Atual:** {fase}\n" if fase == FASE_ABERTURA_CONCILIACAO: prompt += "**Tarefa:** Declare audiência aberta, pergunte sobre conciliação. Se já houve manifestação e sem acordo, anuncie prosseguimento para testemunhas do autor." elif fase == FASE_TESTEMUNHAS_AUTOR_INICIO: prompt += f"**Tarefa:** Anuncie oitiva testemunhas do Autor. Peça ao Adv. Autor (IA) para qualificar e inquirir a primeira. (Supostas test. Autor: {', '.join([t['nome'] for t in estado_simulacao['testemunhas_autor_supostas_defs']]) or 'Nenhuma'})" elif fase == FASE_TESTEMUNHAS_REU_INICIO: prompt += f"**Tarefa:** Anuncie oitiva testemunhas do Réu. Peça ao Adv. Réu (Usuário) para indicar a primeira. (Test. Réu: {', '.join([t['nome'] for t in estado_simulacao['testemunhas_reu_defs']]) or 'Nenhuma'})" elif fase == FASE_ALEGACOES_FINAIS_AUTOR: prompt += "**Tarefa:** Anuncie encerramento instrução. Conceda palavra ao Adv. Autor (IA) para alegações finais." elif fase == FASE_ALEGACOES_FINAIS_REU: prompt += "**Tarefa:** Após alegações do Autor, conceda palavra ao Adv. Réu (Usuário) para suas alegações." elif fase == FASE_ANALISE_FINAL_PROFESSOR: prompt += "**Tarefa:** Declare audiência encerrada para julgamento (simulado)." else: prompt += f"**Tarefa:** Conduza a audiência. Ação específica: {acao_especifica or 'Nenhuma'}. Mantenha ordem e fluxo." prompt += "\n**Sua Fala (Juiz):**" return chamar_gemini_api(prompt, temperature=0.6, max_output_tokens=300) def gerar_resposta_advogado_autor_ia(estado_simulacao, fala_adv_reu=""): # (Função mantida como no Script 1 original) fase = estado_simulacao["fase_aij"] historico = formatar_historico_para_prompt(estado_simulacao["transcricao_logica"]) prompt = f"**Persona:** Advogado(a) do AUTOR em AIJ (Direito Esquecimento vs Liberdade Imprensa). Cliente busca esquecimento/reparação.\n**Réu:** Jornal.\n**Fatos:** {estado_simulacao['caso_fatos'] or 'Não detalhado.'}\n**Provas/Argumentos Autor:** {estado_simulacao['provas_autor_supostas_texto'] or 'Passagem tempo, desinteresse público, dano vida privada.'}\n{historico}**Fase Atual:** {fase}\n" if fase == FASE_ABERTURA_CONCILIACAO: prompt += f"**Tarefa:** Juiz perguntou sobre conciliação. Apresente proposta ou declare desinteresse. Se Réu já falou (\"{fala_adv_reu}\"), responda." elif fase == FASE_TESTEMUNHAS_AUTOR_INICIO: if estado_simulacao["testemunhas_autor_supostas_defs"]: proxima_testemunha_idx = estado_simulacao["testemunha_autor_atual_idx"] + 1 if proxima_testemunha_idx < len(estado_simulacao["testemunhas_autor_supostas_defs"]): testemunha_nome = estado_simulacao["testemunhas_autor_supostas_defs"][proxima_testemunha_idx]["nome"] prompt += f"**Tarefa:** Juiz pediu para chamar testemunha. Chame {testemunha_nome}. Faça 1-2 perguntas iniciais (Ex: 'Sra. {testemunha_nome}, confirme conhecimento sobre X?')." else: return "Advogado do Autor (IA): Não tenho mais testemunhas a apresentar, Excelência." else: return "Advogado do Autor (IA): Não arrolei testemunhas, Excelência." elif fase == FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR: testemunha_reu_obj = estado_simulacao.get("testemunha_em_depoimento") if testemunha_reu_obj and testemunha_reu_obj["parte"] == "REU": prompt += f"**Tarefa:** Testemunha do Réu ({testemunha_reu_obj['nome']}) depôs. Formule 1-2 perguntas incisivas. (Pontos chave dela: {testemunha_reu_obj.get('pontos_chave', 'Não informado')})" else: return "Advogado do Autor (IA): (Erro interno - sem testemunha do réu para inquirir)" elif fase == FASE_ALEGACOES_FINAIS_AUTOR: prompt += "**Tarefa:** Juiz concedeu palavra para alegações finais. Apresente resumo persuasivo e reitere pedidos." else: prompt += f"**Contexto:** Adv. Réu (Usuário) disse: \"{fala_adv_reu}\"\n**Tarefa:** Responda estrategicamente." prompt += "\n**Sua Resposta (Advogado Autor):**" return chamar_gemini_api(prompt, temperature=0.75, max_output_tokens=450) def gerar_resposta_testemunha_autor_ia(estado_simulacao, pergunta_feita): # (Função mantida como no Script 1 original) testemunha_obj = estado_simulacao.get("testemunha_em_depoimento") if not testemunha_obj or testemunha_obj["parte"] != "AUTOR": return "Testemunha do Autor (IA): (Erro interno - Nenhuma testemunha do autor em depoimento)" historico = formatar_historico_para_prompt(estado_simulacao["transcricao_logica"]) prompt = f"**Persona:** Testemunha {testemunha_obj['nome']} (AUTOR).\n**Caso:** Direito Esquecimento vs Liberdade Imprensa.\n**Fatos:** {estado_simulacao['caso_fatos'] or 'Não detalhado.'}\n**Seus Pontos Chave:** {testemunha_obj['pontos_chave'] or 'Conhecimento geral sobre autor e impactos.'}\n{historico}**Pergunta Feita:** \"{pergunta_feita}\"\n**Tarefa:** Responda claro, conciso, baseado nos seus pontos. Se Adv. Réu, seja cauteloso(a).\n**Sua Resposta (Testemunha {testemunha_obj['nome']}):**" return chamar_gemini_api(prompt, temperature=0.6, max_output_tokens=250) def analisar_atuacao_defesa_ia(estado_simulacao, ultima_fala_reu=""): # (Função mantida como no Script 1 original) historico_completo_dialogo = formatar_historico_para_prompt(estado_simulacao["transcricao_logica"], max_turns=len(estado_simulacao["transcricao_logica"])) prompt_analise = f"**Persona:** Professor(a) de Prática Jurídica experiente.\n**Tarefa:** Feedback construtivo para aluno (Adv. RÉU - Jornal) em AIJ (Direito Esquecimento vs Liberdade Imprensa).\n**Fatos:** {estado_simulacao['caso_fatos'] or 'Não detalhado.'}\n**Provas/Argumentos Réu:** {estado_simulacao['provas_reu_texto'] or 'Não detalhado.'}\n**Transcrição AIJ:** {historico_completo_dialogo}\n**Última Intervenção Réu:** \"{ultima_fala_reu}\"\n**Feedback Detalhado (Pontos Fortes, Melhorias, Sugestões, Fundamentação, Estratégia):**" return chamar_gemini_api(prompt_analise, temperature=0.65, max_output_tokens=1200) # --- Novas Funções de IA para Treinamento (inspiradas em Script 2) --- def avaliar_argumentos_defesa_ia(fatos_caso, provas_reu, tipo_argumento, argumento_usuario): if not argumento_usuario.strip(): return "Por favor, insira seus argumentos para avaliação." contexto_caso = f""" Você está avaliando argumentos no contexto de um caso jurídico no Brasil sobre direito ao esquecimento vs. liberdade de imprensa. O usuário representa a defesa (jornal). **Fatos do Caso:** {fatos_caso if fatos_caso else CASO_DESCRICAO_PREDEFINIDO} **Principais Argumentos/Provas da Defesa (Jornal):** {provas_reu if provas_reu else "\n".join(CONTRA_ARGUMENTOS_REU_PREDEFINIDOS)} """ prompt = f""" {contexto_caso} **Persona:** Você é um Juiz experiente em um tribunal brasileiro, com especialidade em casos de liberdade de imprensa e direitos da personalidade. **Tarefa:** Avalie o seguinte argumento apresentado pelo advogado de defesa (jornal) para a peça/momento processual: "{tipo_argumento}". Forneça feedback detalhado e construtivo em português brasileiro, incluindo: 1. **Pontos Fortes:** Destaque aspectos positivos (ex: fundamentação legal sólida, coerência lógica, clareza, persuasão, uso de fatos). 2. **Pontos a Melhorar:** Identifique fraquezas (ex: falta de aprofundamento, generalizações, omissão de contrapontos importantes, linguagem inadequada, falta de nexo com os fatos/provas do réu). 3. **Sugestões Específicas:** Ofereça conselhos práticos para aprimoramento (ex: citar precedentes específicos como o RE 1.010.606/STF, refutar explicitamente possíveis argumentos do autor, conectar melhor o argumento às provas do réu, sugerir redação alternativa). 4. **Nota Geral (0 a 5):** Atribua uma nota considerando: * Fundamentação Legal/Jurisprudencial (Peso 3) * Coerência e Lógica (Peso 2) * Persuasão e Clareza (Peso 2) * Adequação ao tipo de peça/momento (Peso 1) * Conexão com os fatos/provas do caso (Peso 2) Formato da Resposta: Utilize linguagem formal e jurídica. Estruture a resposta rigorosamente com os títulos: `### Pontos Fortes` `### Pontos a Melhorar` `### Sugestões Específicas` `### Nota Geral` **Argumento do Advogado de Defesa (Jornal):** "{argumento_usuario}" **Sua Avaliação:** """ return chamar_gemini_api(prompt, temperature=0.6, max_output_tokens=1000) def gerar_resposta_testemunha_defesa_para_treino_ia(fatos_caso, nome_testemunha, pontos_chave_testemunha, historico_perguntas_respostas, pergunta_atual_adv_defesa): contexto_caso = f""" Você está simulando o depoimento de uma testemunha de DEFESA (Jornal) em uma Audiência de Instrução e Julgamento (AIJ) no Brasil. O caso envolve Direito ao Esquecimento vs. Liberdade de Imprensa. O jornal (réu) é processado por relembrar um crime antigo (com absolvição) do autor. **Fatos do Caso:** {fatos_caso if fatos_caso else CASO_DESCRICAO_PREDEFINIDO} """ historico_formatado = "\nDepoimento até agora:\n" for p, r in historico_perguntas_respostas: historico_formatado += f"- Advogado Defesa: {p}\n- {nome_testemunha}: {r}\n" prompt = f""" {contexto_caso} **Persona:** Você é {nome_testemunha}, testemunha arrolada pela DEFESA (Jornal). **Seus Pontos Chave a Defender/Explicar:** {pontos_chave_testemunha} Você deve responder às perguntas do advogado de defesa de forma consistente com esses pontos e com a tese da defesa (liberdade de imprensa, interesse público, veracidade, ausência de dolo/culpa, destaque à absolvição do autor no caso original). Use linguagem formal, mas acessível para uma testemunha. Seja objetivo e direto. Evite admitir qualquer falha ou negligência por parte do jornal. {historico_formatado if historico_perguntas_respostas else "Este é o início do seu depoimento."} **Pergunta do Advogado de Defesa (Jornal):** "{pergunta_atual_adv_defesa}" **Sua Resposta ({nome_testemunha}):** """ return chamar_gemini_api(prompt, temperature=0.5, max_output_tokens=300) # --- Funções de Lógica da Simulação e UI (from Script 1, adaptadas e com novas) --- def adicionar_fala_transcricao(estado_simulacao, ator, fala): # (Função mantida como no Script 1 original) estado_simulacao["transcricao_logica"].append((ator, fala)) if ator == "Advogado do Réu (Você)": estado_simulacao["transcricao_chat"].append((fala, None)) else: if estado_simulacao["transcricao_chat"] and estado_simulacao["transcricao_chat"][-1][1] is None: estado_simulacao["transcricao_chat"][-1] = (estado_simulacao["transcricao_chat"][-1][0], fala) else: estado_simulacao["transcricao_chat"].append((None, fala)) return estado_simulacao def mostrar_botoes_corretos(fase_atual): # (Função mantida como no Script 1 original) vis = { "btn_responder_conciliacao": fase_atual == FASE_ABERTURA_CONCILIACAO, "btn_chamar_testemunha_reu": fase_atual == FASE_TESTEMUNHAS_REU_INICIO, "dropdown_testemunhas_reu": fase_atual == FASE_TESTEMUNHAS_REU_INICIO, "btn_perguntar_testemunha_autor": fase_atual == FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, "btn_adv_reu_pergunta_sua_testemunha": fase_atual == FASE_TESTEMUNHAS_REU_PERGUNTAS_REU, "btn_adv_reu_responde_pela_sua_testemunha": fase_atual == FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR, "btn_apresentar_alegacoes_finais_reu": fase_atual == FASE_ALEGACOES_FINAIS_REU, "btn_juiz_avancar_fase": fase_atual not in [FASE_INICIAL_CONFIG, FASE_CONCLUIDA] and fase_atual != FASE_ALEGACOES_FINAIS_REU } return [gr.update(visible=vis[k]) for k in sorted(vis.keys())] def configurar_e_iniciar_simulacao(estado_s, fatos, p_reu, p_autor, t_reu_str, t_autor_str): # (Função adaptada do Script 1) novo_estado = estado_inicial_simulacao() if not fatos or not p_reu or not p_autor: # Basic validation gr.Warning("Por favor, preencha todos os campos de configuração do caso ou carregue o caso padrão.") return [novo_estado, novo_estado["transcricao_chat"], "Erro: Configuração incompleta.", "Preencha a configuração.", gr.Dropdown(choices=[], value=None)] + mostrar_botoes_corretos(novo_estado["fase_aij"]) novo_estado["caso_fatos"], novo_estado["provas_reu_texto"], novo_estado["provas_autor_supostas_texto"] = fatos, p_reu, p_autor def parse_testemunhas(t_str): defs = [] if t_str and t_str.strip(): for linha in t_str.strip().split('\n'): if linha.strip(): partes = linha.split(':', 1) if len(partes) == 2: defs.append({"nome": partes[0].strip(), "pontos_chave": partes[1].strip()}) elif len(partes) == 1 and partes[0].strip(): # Testemunha sem pontos chave explícitos defs.append({"nome": partes[0].strip(), "pontos_chave": "Não especificado."}) return defs novo_estado["testemunhas_reu_defs"] = parse_testemunhas(t_reu_str) novo_estado["testemunhas_autor_supostas_defs"] = parse_testemunhas(t_autor_str) novo_estado["fase_aij"] = FASE_ABERTURA_CONCILIACAO novo_estado = adicionar_fala_transcricao(novo_estado, "Sistema", "Configuração salva. Iniciando simulação...") gr.Info("Iniciando simulação... Gerando falas iniciais da IA.") fala_juiz = gerar_resposta_juiz_ia(novo_estado) novo_estado = adicionar_fala_transcricao(novo_estado, "Juiz (IA)", fala_juiz) fala_adv_autor = gerar_resposta_advogado_autor_ia(novo_estado) novo_estado = adicionar_fala_transcricao(novo_estado, "Advogado do Autor (IA)", fala_adv_autor) novo_estado["instrucao_para_usuario"] = "Responda à proposta de conciliação do Autor ou declare sua posição." novo_estado["feedback_para_usuario"] = analisar_atuacao_defesa_ia(novo_estado) nomes_testemunhas_reu = [t["nome"] for t in novo_estado["testemunhas_reu_defs"]] if novo_estado["testemunhas_reu_defs"] else [] botoes_vis = mostrar_botoes_corretos(novo_estado["fase_aij"]) gr.Info("Simulação iniciada.") return [novo_estado, novo_estado["transcricao_chat"], novo_estado["feedback_para_usuario"], novo_estado["instrucao_para_usuario"], gr.Dropdown(choices=nomes_testemunhas_reu, value=None, interactive=True)] + botoes_vis def lidar_com_fala_usuario(estado_s, fala_usuario_txt): # (Função mantida como no Script 1 original, com pequenas adaptações) if not fala_usuario_txt and estado_s["fase_aij"] not in [FASE_TESTEMUNHAS_REU_INICIO]: estado_s["instrucao_para_usuario"] = "Por favor, digite sua fala ou selecione uma ação." return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"], gr.Textbox(value="")] + mostrar_botoes_corretos(estado_s["fase_aij"]) estado_s = copy.deepcopy(estado_s) ator_usuario = "Advogado do Réu (Você)" if estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_PERGUNTAS_REU and estado_s.get("testemunha_em_depoimento"): ator_usuario = f"Advogado do Réu (Você) perguntando a {estado_s['testemunha_em_depoimento']['nome']}" elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR and estado_s.get("testemunha_em_depoimento"): ator_usuario = f"Testemunha {estado_s['testemunha_em_depoimento']['nome']} (Réu) respondendo" if fala_usuario_txt: estado_s = adicionar_fala_transcricao(estado_s, ator_usuario, fala_usuario_txt) gr.Info(f"Sua fala registrada. Aguardando respostas da IA...") # Lógica de transição de fases e respostas da IA if estado_s["fase_aij"] == FASE_ABERTURA_CONCILIACAO: fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s, fala_adv_reu=fala_usuario_txt) estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor) fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Partes se manifestaram sobre conciliação. Decida o prosseguimento.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) if any(k in fala_juiz.lower() for k in ["testemunha", "instrução", "prossegu", "oitiva"]): if estado_s["testemunhas_autor_supostas_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_INICIO, "Aguarde Juiz/Adv.Autor chamarem testemunha." # Adicionar fala do Adv. Autor chamando a testemunha fala_adv_autor_chamando = gerar_resposta_advogado_autor_ia(estado_s) estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor_chamando) if not ("Não tenho mais testemunhas" in fala_adv_autor_chamando or "Não arrolei testemunhas" in fala_adv_autor_chamando): estado_s["testemunha_autor_atual_idx"] += 1 idx = estado_s["testemunha_autor_atual_idx"] if idx < len(estado_s["testemunhas_autor_supostas_defs"]): t_info = estado_s["testemunhas_autor_supostas_defs"][idx] estado_s["testemunha_em_depoimento"] = {"nome": t_info["nome"], "pontos_chave": t_info["pontos_chave"], "parte": "AUTOR"} fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor_chamando) estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {t_info['nome']} (Autor - IA)", fala_test_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite/pergunte à testemunha {t_info['nome']} (Autor)." elif estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha para chamar." else: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_AUTOR, "Aguarde Juiz iniciar Alegações Finais." # Se for para alegações do autor, o juiz deve dar a palavra e o adv. autor falar fala_juiz_aleg = gerar_resposta_juiz_ia(estado_s) estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_aleg) fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s) estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_aleg_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais." else: estado_s["instrucao_para_usuario"] = "Responda ao Juiz ou Adv. Autor sobre conciliação." elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU: fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_usuario_txt) estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {estado_s['testemunha_em_depoimento']['nome']} (Autor - IA)", fala_test_autor) estado_s["instrucao_para_usuario"] = f"Faça outra pergunta à testemunha {estado_s['testemunha_em_depoimento']['nome']} (Autor) ou clique 'Juiz Avançar'." elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_PERGUNTAS_REU: # Usuário (Adv Réu) perguntou à sua testemunha # Aqui, o usuário está *atuando* como sua testemunha para responder à sua própria pergunta. # A IA do Adv. Autor fará perguntas à testemunha do Réu. # O usuário deve então responder como se fosse sua testemunha. # Após a pergunta do usuário à sua testemunha, e a resposta simulada (pelo usuário mesmo, no chat), # o Adv. Autor (IA) deve ter a chance de inquirir. estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR fala_adv_autor_ia = gerar_resposta_advogado_autor_ia(estado_s) # Adv. Autor IA pergunta à testemunha do Réu estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor_ia) estado_s["instrucao_para_usuario"] = f"Como testemunha {estado_s['testemunha_em_depoimento']['nome']}, responda à pergunta do Adv. Autor." elif estado_s["fase_aij"] == FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR: # Usuário respondeu como sua testemunha à pergunta do Adv. Autor # Advogado do Autor (IA) pode fazer mais perguntas ou encerrar. fala_adv_autor_ia = gerar_resposta_advogado_autor_ia(estado_s, fala_adv_reu=fala_usuario_txt) # Passa a resposta da testemunha do réu estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor_ia) if "pergunta" in fala_adv_autor_ia.lower() or "?" in fala_adv_autor_ia and "não tenho mais perguntas" not in fala_adv_autor_ia.lower(): estado_s["instrucao_para_usuario"] = f"Como testemunha {estado_s['testemunha_em_depoimento']['nome']}, responda à nova pergunta do Adv. Autor." else: # Adv. Autor não tem mais perguntas fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=f"Adv. Autor encerrou inquirição da testemunha {estado_s['testemunha_em_depoimento']['nome']}. Adv. Réu pode fazer mais perguntas ou dispensar.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_PERGUNTAS_REU # Volta para Adv. Réu perguntar estado_s["instrucao_para_usuario"] = f"Faça mais perguntas à sua testemunha {estado_s['testemunha_em_depoimento']['nome']}, ou clique 'Juiz Avançar' para dispensá-la." elif estado_s["fase_aij"] == FASE_ALEGACOES_FINAIS_REU: estado_s["fase_aij"] = FASE_ANALISE_FINAL_PROFESSOR fala_juiz = gerar_resposta_juiz_ia(estado_s) estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) estado_s["instrucao_para_usuario"] = "Audiência encerrada para sentença (simulada). Veja o feedback final do Professor IA." # Analise final é chamada abaixo estado_s["feedback_para_usuario"] = analisar_atuacao_defesa_ia(estado_s, ultima_fala_reu=fala_usuario_txt if ator_usuario == "Advogado do Réu (Você)" else "") gr.Info("Respostas da IA geradas.") return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"], gr.Textbox(value="")] + mostrar_botoes_corretos(estado_s["fase_aij"]) def acao_botao_juiz_avancar(estado_s): # (Função mantida e adaptada do Script 1) estado_s = copy.deepcopy(estado_s) fase_atual = estado_s["fase_aij"] gr.Info(f"Avançando fase a partir de: {fase_atual}. Aguarde IA...") if fase_atual == FASE_ABERTURA_CONCILIACAO: # Se partes não chegaram a acordo, ou se o usuário pulou a conciliação. estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", "Considerando frustrada a tentativa de conciliação, passaremos à instrução.") if estado_s["testemunhas_autor_supostas_defs"]: estado_s["fase_aij"] = FASE_TESTEMUNHAS_AUTOR_INICIO fala_juiz = gerar_resposta_juiz_ia(estado_s) estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor chama/pergunta estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor) if not ("Não tenho mais testemunhas" in fala_adv_autor or "Não arrolei testemunhas" in fala_adv_autor): estado_s["testemunha_autor_atual_idx"] += 1 idx = estado_s["testemunha_autor_atual_idx"] if idx < len(estado_s["testemunhas_autor_supostas_defs"]): t_info = estado_s["testemunhas_autor_supostas_defs"][idx] estado_s["testemunha_em_depoimento"] = {"nome": t_info["nome"], "pontos_chave": t_info["pontos_chave"], "parte": "AUTOR"} fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor) # Testemunha responde à pergunta inicial estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {t_info['nome']} (Autor - IA)", fala_test_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite ou faça perguntas à testemunha {t_info['nome']} (Autor)." else: # Adv Autor não tem testemunhas, mesmo que tenha sido definido if estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha para chamar." else: estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR # Pula para alegações finais elif estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO fala_juiz = gerar_resposta_juiz_ia(estado_s) estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) estado_s["instrucao_para_usuario"] = "Selecione sua testemunha para chamar." else: # Sem testemunhas de nenhuma parte estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR fala_juiz = gerar_resposta_juiz_ia(estado_s) # Juiz anuncia alegações estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor faz alegações estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais." elif fase_atual == FASE_TESTEMUNHAS_AUTOR_INICIO or fase_atual == FASE_TESTEMUNHAS_AUTOR_PERGUNTAS_AUTOR: # Juiz pede ao Adv. Autor para chamar a *próxima* testemunha ou encerrar fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Verificar se há mais testemunhas do Autor ou encerrar esta fase.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv. Autor chama próxima ou diz que não tem mais estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor) if "Não tenho mais testemunhas" in fala_adv_autor or "Não arrolei testemunhas" in fala_adv_autor or estado_s["testemunha_autor_atual_idx"] +1 >= len(estado_s["testemunhas_autor_supostas_defs"]): estado_s["testemunha_em_depoimento"] = None if estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO fala_juiz_trans = gerar_resposta_juiz_ia(estado_s) # Juiz anuncia oitiva das testemunhas do Réu estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans) estado_s["instrucao_para_usuario"] = "Selecione sua testemunha para chamar." else: # Sem testemunhas do Réu, vai para alegações finais estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR fala_juiz_trans = gerar_resposta_juiz_ia(estado_s) # Juiz anuncia alegações estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans) fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor faz alegações estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_aleg_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais." else: # Adv Autor chamou próxima testemunha estado_s["testemunha_autor_atual_idx"] += 1 idx = estado_s["testemunha_autor_atual_idx"] # Garantir que o índice é válido if idx < len(estado_s["testemunhas_autor_supostas_defs"]): t_info = estado_s["testemunhas_autor_supostas_defs"][idx] estado_s["testemunha_em_depoimento"] = {"nome": t_info["nome"], "pontos_chave": t_info["pontos_chave"], "parte": "AUTOR"} fala_test_autor = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor) # Testemunha responde à pergunta inicial do Adv. Autor estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {t_info['nome']} (Autor - IA)", fala_test_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite ou faça perguntas à testemunha {t_info['nome']} (Autor)." else: # Caso raro de lógica inconsistente, trata como se não houvesse mais testemunhas estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO # Ou alegações finais, conforme lógica acima # ... (repetir lógica de transição para Réu ou Alegações) elif fase_atual == FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU: # Usuário (Adv. Réu) terminou de perguntar à testemunha do Autor. estado_s["testemunha_em_depoimento"] = None # Verificar se há mais testemunhas do Autor if estado_s["testemunha_autor_atual_idx"] + 1 < len(estado_s["testemunhas_autor_supostas_defs"]): estado_s["fase_aij"] = FASE_TESTEMUNHAS_AUTOR_INICIO # Volta para o juiz pedir ao Adv. Autor chamar a próxima fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Advogado do Réu encerrou perguntas à testemunha do Autor. Verificar próxima testemunha do Autor.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) # Adv Autor precisa ser chamado para agir fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor chama/pergunta estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor) if not ("Não tenho mais testemunhas" in fala_adv_autor or "Não arrolei testemunhas" in fala_adv_autor): estado_s["testemunha_autor_atual_idx"] += 1 idx_new = estado_s["testemunha_autor_atual_idx"] if idx_new < len(estado_s["testemunhas_autor_supostas_defs"]): t_info_new = estado_s["testemunhas_autor_supostas_defs"][idx_new] estado_s["testemunha_em_depoimento"] = {"nome": t_info_new["nome"], "pontos_chave": t_info_new["pontos_chave"], "parte": "AUTOR"} fala_test_autor_new = gerar_resposta_testemunha_autor_ia(estado_s, pergunta_feita=fala_adv_autor) estado_s = adicionar_fala_transcricao(estado_s, f"Testemunha {t_info_new['nome']} (Autor - IA)", fala_test_autor_new) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_AUTOR_CONTRADITA_REU, f"Contradite ou faça perguntas à testemunha {t_info_new['nome']} (Autor)." else: # Adv. Autor não tem mais, mesmo que houvesse na lista (raro) if estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_TESTEMUNHAS_REU_INICIO, "Selecione sua testemunha para chamar." else: estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR fala_juiz_trans = gerar_resposta_juiz_ia(estado_s) # Juiz comanda nova fase estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_trans) if estado_s["fase_aij"] == FASE_ALEGACOES_FINAIS_AUTOR: fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s) estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_aleg_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais." else: # Não há mais testemunhas do Autor if estado_s["testemunhas_reu_defs"]: estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Encerrada oitiva das testemunhas do Autor. Iniciar oitiva das testemunhas do Réu.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) estado_s["instrucao_para_usuario"] = "Selecione sua testemunha para chamar." else: # Sem testemunhas do Réu, vai para alegações finais estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Instrução encerrada. Passar para alegações finais do Autor.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) fala_aleg_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor faz alegações estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_aleg_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais." elif fase_atual in [FASE_TESTEMUNHAS_REU_PERGUNTAS_REU, FASE_TESTEMUNHAS_REU_INQUIRICAO_AUTOR]: # Usuário (Adv. Réu) dispensou sua testemunha atual. nome_test_dispensada = estado_s.get("testemunha_em_depoimento", {}).get("nome", "a testemunha do Réu") estado_s["testemunha_em_depoimento"] = None fala_juiz_dispensa = f"Juiz (IA): Dispensada {nome_test_dispensada}." if estado_s.get("testemunha_em_depoimento"): # Adiciona só se havia uma testemunha em depoimento fala_juiz_dispensa = gerar_resposta_juiz_ia(estado_s, acao_especifica=f"Dispensar {nome_test_dispensada}. Perguntar ao Adv. Réu se tem mais testemunhas.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz_dispensa) if estado_s["testemunha_reu_atual_idx"] + 1 < len(estado_s["testemunhas_reu_defs"]): estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_INICIO # Volta para o usuário selecionar a próxima estado_s["instrucao_para_usuario"] = "Selecione sua próxima testemunha para chamar ou clique 'Juiz Avançar' para encerrar oitiva das suas testemunhas." else: # Não há mais testemunhas do Réu estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_AUTOR fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Encerrada oitiva das testemunhas do Réu. Passar para alegações finais do Autor.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) fala_adv_autor = gerar_resposta_advogado_autor_ia(estado_s) # Adv Autor faz alegações estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Autor (IA)", fala_adv_autor) estado_s["fase_aij"], estado_s["instrucao_para_usuario"] = FASE_ALEGACOES_FINAIS_REU, "Apresente suas Alegações Finais." elif fase_atual == FASE_ALEGACOES_FINAIS_AUTOR: # Adv. Autor terminou alegações, Juiz passa palavra ao Réu estado_s["fase_aij"] = FASE_ALEGACOES_FINAIS_REU fala_juiz = gerar_resposta_juiz_ia(estado_s) # Juiz passa a palavra ao Réu estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) estado_s["instrucao_para_usuario"] = "Apresente suas Alegações Finais." else: # Fallback para fases não explicitamente tratadas acima fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica="Conduza para a próxima etapa lógica da audiência.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) estado_s["instrucao_para_usuario"] = "Siga as instruções do Juiz ou avance a fase." estado_s["feedback_para_usuario"] = analisar_atuacao_defesa_ia(estado_s) gr.Info("Fase avançada. Interações da IA geradas.") return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"]] + mostrar_botoes_corretos(estado_s["fase_aij"]) def chamar_testemunha_reu_selecionada(estado_s, nome_testemunha_selecionada): # (Função mantida como no Script 1 original) estado_s = copy.deepcopy(estado_s) if not nome_testemunha_selecionada: estado_s["instrucao_para_usuario"] = "Nenhuma testemunha selecionada. Por favor, selecione uma testemunha da lista." gr.Warning("Selecione uma testemunha da lista.") return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"]] + mostrar_botoes_corretos(estado_s["fase_aij"]) idx_testemunha = next((i for i, t in enumerate(estado_s["testemunhas_reu_defs"]) if t["nome"] == nome_testemunha_selecionada), -1) if idx_testemunha == -1: estado_s["instrucao_para_usuario"] = f"Testemunha '{nome_testemunha_selecionada}' não encontrada na configuração." gr.Error(f"Testemunha '{nome_testemunha_selecionada}' não encontrada.") return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"]] + mostrar_botoes_corretos(estado_s["fase_aij"]) estado_s["testemunha_reu_atual_idx"] = idx_testemunha testemunha_obj = estado_s["testemunhas_reu_defs"][idx_testemunha] estado_s["testemunha_em_depoimento"] = {"nome": testemunha_obj["nome"], "pontos_chave": testemunha_obj["pontos_chave"], "parte": "REU"} gr.Info(f"Chamando testemunha {testemunha_obj['nome']}. Aguarde IA...") estado_s = adicionar_fala_transcricao(estado_s, "Advogado do Réu (Você)", f"Chamo para depor minha testemunha, Sr(a). {testemunha_obj['nome']}.") fala_juiz = gerar_resposta_juiz_ia(estado_s, acao_especifica=f"Advogado do Réu chamou a testemunha {testemunha_obj['nome']}. Qualifique-a e passe a palavra ao Advogado do Réu para inquirição inicial.") estado_s = adicionar_fala_transcricao(estado_s, "Juiz (IA)", fala_juiz) estado_s["fase_aij"] = FASE_TESTEMUNHAS_REU_PERGUNTAS_REU estado_s["instrucao_para_usuario"] = f"Faça sua primeira pergunta à sua testemunha, {testemunha_obj['nome']}. Após sua pergunta e a resposta (que você digitará no chat como se fosse a testemunha), o Advogado do Autor (IA) poderá inquirir." estado_s["feedback_para_usuario"] = analisar_atuacao_defesa_ia(estado_s) gr.Info("Testemunha chamada. Interações da IA geradas.") return [estado_s, estado_s["transcricao_chat"], estado_s["feedback_para_usuario"], estado_s["instrucao_para_usuario"]] + mostrar_botoes_corretos(estado_s["fase_aij"]) # --- UI Callbacks para Novas Abas --- def avaliar_argumentos_defesa_ia_ui(fatos_caso_atual, provas_reu_atual, tipo_argumento_selecionado, argumento_digitado): if not GEMINI_API_KEY: return "ERRO: API Key não configurada." if not argumento_digitado or not tipo_argumento_selecionado: return "Por favor, selecione o tipo de argumento e digite seu texto." gr.Info(f"Avaliando seu argumento ({tipo_argumento_selecionado})... Aguarde.") feedback = avaliar_argumentos_defesa_ia(fatos_caso_atual, provas_reu_atual, tipo_argumento_selecionado, argumento_digitado) gr.Info("Avaliação concluída.") return feedback _historico_treino_testemunha_atual = [] # Simples cache para o diálogo de treino def gerar_dialogo_testemunha_defesa_para_treino_ui(fatos_caso_atual, testemunhas_reu_defs_atual_str, testemunha_selecionada_nome, pergunta_adv_defesa): global _historico_treino_testemunha_atual if not GEMINI_API_KEY: return _historico_treino_testemunha_atual + [ (None, "ERRO: API Key não configurada.") ] if not testemunha_selecionada_nome: return _historico_treino_testemunha_atual + [ (None, "Por favor, selecione uma testemunha da sua lista na aba 'Configuração'.") ] if not pergunta_adv_defesa: return _historico_treino_testemunha_atual + [ (None, "Por favor, digite sua pergunta para a testemunha.") ] # Recriar testemunhas_reu_defs a partir da string (se fornecida e mudou) ou usar a padrão testemunhas_reu_defs_usar = [] if testemunhas_reu_defs_atual_str: try: # Re-parse a string de testemunhas do réu da aba de configuração linhas = testemunhas_reu_defs_atual_str.strip().split('\n') for linha in linhas: if linha.strip(): partes = linha.split(':', 1) if len(partes) == 2: testemunhas_reu_defs_usar.append({"nome": partes[0].strip(), "pontos_chave": partes[1].strip()}) elif len(partes) == 1: # Nome sem pontos chave testemunhas_reu_defs_usar.append({"nome": partes[0].strip(), "pontos_chave": "Não especificado."}) except Exception as e: print(f"Erro ao parsear testemunhas_reu_defs_atual_str: {e}") testemunhas_reu_defs_usar = TESTEMUNHAS_REU_PREDEFINIDAS # Fallback else: testemunhas_reu_defs_usar = TESTEMUNHAS_REU_PREDEFINIDAS testemunha_obj = next((t for t in testemunhas_reu_defs_usar if t["nome"] == testemunha_selecionada_nome), None) if not testemunha_obj: # Se não achou na lista dinâmica, tenta na lista padrão testemunha_obj = next((t for t in TESTEMUNHAS_REU_PREDEFINIDAS if t["nome"] == testemunha_selecionada_nome), None) if not testemunha_obj: return _historico_treino_testemunha_atual + [ (None, f"Testemunha '{testemunha_selecionada_nome}' não encontrada. Verifique a aba 'Configuração'.") ] # Reinicia o histórico se a testemunha mudou (simplificado) if not _historico_treino_testemunha_atual or \ (_historico_treino_testemunha_atual and not _historico_treino_testemunha_atual[0][1].startswith(f"**{testemunha_obj['nome']}**:")): _historico_treino_testemunha_atual = [] _historico_treino_testemunha_atual.append( (None, f"Iniciando inquirição de **{testemunha_obj['nome']}**. Pontos chave: {testemunha_obj['pontos_chave']}") ) gr.Info(f"Gerando resposta da testemunha {testemunha_obj['nome']}... Aguarde.") resposta_testemunha = gerar_resposta_testemunha_defesa_para_treino_ia( fatos_caso_atual if fatos_caso_atual else CASO_FATOS_COMPLETO_PREDEFINIDO, testemunha_obj['nome'], testemunha_obj['pontos_chave'], [(q,r) for q,r in _historico_treino_testemunha_atual if q is not None], # Passa apenas Q/A anteriores pergunta_adv_defesa ) _historico_treino_testemunha_atual.append( (pergunta_adv_defesa, resposta_testemunha) ) gr.Info("Resposta da testemunha gerada.") return _historico_treino_testemunha_atual, "" # Retorna o histórico e limpa o campo de pergunta # --- Interface Gráfica (Gradio UI) --- with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="orange"), title="Simulador AIJ Interativo") as demo: gr.Markdown("# ⚖️ Simulador Interativo de Audiência de Instrução e Julgamento (AIJ)") gr.Markdown("Tema: **Direito ao Esquecimento vs. Liberdade de Imprensa**. Você assume o papel de **Advogado(a) do Réu (Jornal)**.") if not GEMINI_API_KEY: gr.Warning("API Key do Gemini (GEMINI_API_KEY) não encontrada! O aplicativo pode não funcionar corretamente. Configure-a como Secret neste Space ou localmente como variável de ambiente.") sim_state = gr.State(value=estado_inicial_simulacao()) with gr.Tabs() as abas_principais: with gr.TabItem("1. Configuração do Caso", id=0): gr.Markdown("## Detalhes do Caso para Simulação") gr.Markdown("Preencha os campos abaixo ou use os botões para gerar/carregar um caso.") with gr.Row(): btn_gerar_caso_ia = gr.Button("✨ Gerar Novo Caso com IA", icon="🧠", scale=1) btn_carregar_caso_padrao = gr.Button("📄 Carregar Caso Padrão (Esquecimento)", icon="📜", scale=1) with gr.Row(): with gr.Column(scale=2): fatos_input = gr.Textbox(lines=7, label="Resumo dos Fatos, Partes e Título:", placeholder="Descreva o caso ou gere/carregue.") provas_reu_input = gr.Textbox(lines=4, label="Argumentos e Provas do Réu (Seu Cliente - Jornal):", placeholder="Ex: Arg: Liberdade de imprensa. Prova: Art. 5 CF.") provas_autor_input = gr.Textbox(lines=4, label="Argumentos e Provas (Supostas) do Autor:", placeholder="Ex: Arg: Dano à imagem. Prova: Laudo X.") with gr.Column(scale=1): testemunhas_reu_input = gr.Textbox(lines=5, label="Suas Testemunhas (Réu) - Formato: Nome: Pontos Chave a Depor", placeholder="João Silva: Viu X e Y.\nMaria Costa: Sabe Z.") testemunhas_autor_supostas_input = gr.Textbox(lines=5, label="Supostas Testemunhas do Autor - Formato: Nome: Pontos Chave", placeholder="Carlos Lima: Sofreu Z.\nAna B.: Testemunhará sobre Q.") btn_config_iniciar = gr.Button("💾 Salvar Configurações e Iniciar Simulação Interativa", variant="primary") status_config_output = gr.Label(value="Aguardando configuração do caso...") outputs_gerar_caso = [fatos_input, provas_reu_input, provas_autor_input, testemunhas_reu_input, testemunhas_autor_supostas_input, status_config_output] btn_gerar_caso_ia.click(acao_gerar_caso_ficticio_ui, inputs=None, outputs=outputs_gerar_caso) btn_carregar_caso_padrao.click(acao_carregar_caso_padrao_ui, inputs=None, outputs=outputs_gerar_caso) with gr.TabItem("2. Audiência Interativa", id=1): gr.Markdown("## Andamento da Audiência Simulada") instrucao_usuario_output = gr.Markdown("Instrução: Configure o caso na aba 'Configuração' e clique em 'Salvar e Iniciar' para começar.") chat_aij_output = gr.Chatbot(label="Transcrição da Audiência", height=500, bubble_full_width=False, show_copy_button=True, avatar_images=(None, "https://img.icons8.com/fluency/96/robot-2.png")) fala_usuario_input = gr.Textbox(show_label=False, placeholder="Digite sua fala aqui ou use os botões de ação abaixo...", scale=4, lines=3) btn_enviar_fala_usuario = gr.Button("🎤 Enviar Fala / Ação", variant="stop") with gr.Accordion("Ações Contextuais do Advogado do Réu (Você)", open=True): with gr.Row(): btn_responder_conciliacao = gr.Button("Responder à Conciliação", visible=False) dropdown_testemunhas_reu_select = gr.Dropdown(label="Sua Testemunha a Chamar:", choices=[], visible=False, interactive=True) btn_chamar_testemunha_reu_action = gr.Button("Chamar Testemunha Selecionada", visible=False) with gr.Row(): btn_perguntar_testemunha_autor_action = gr.Button("Perguntar à Test. do Autor", visible=False) btn_adv_reu_pergunta_sua_testemunha_action = gr.Button("Perguntar à Minha Testemunha", visible=False) btn_adv_reu_responde_pela_sua_testemunha_action = gr.Button("Responder pela Minha Testemunha (à IA)", visible=False) btn_apresentar_alegacoes_finais_reu_action = gr.Button("Apresentar Alegações Finais", visible=False) btn_juiz_avancar_fase_action = gr.Button("⚖️ Juiz (IA): Concluir Etapa / Avançar Fase", visible=False, variant="secondary") lista_botoes_feedback = [btn_responder_conciliacao, btn_chamar_testemunha_reu_action, dropdown_testemunhas_reu_select, btn_perguntar_testemunha_autor_action, btn_adv_reu_pergunta_sua_testemunha_action, btn_adv_reu_responde_pela_sua_testemunha_action, btn_apresentar_alegacoes_finais_reu_action, btn_juiz_avancar_fase_action] with gr.TabItem("3. Feedback da Atuação (Professor IA)", id=2): gr.Markdown("## 💡 Análise da Sua Atuação na Audiência Interativa") gr.Markdown("Este feedback é gerado pela IA com base na sua participação na aba 'Audiência Interativa'.") feedback_output = gr.Textbox(lines=20, label="Feedback Detalhado:", interactive=False, show_copy_button=True) with gr.TabItem("4. Treinamento de Argumentação (Defesa)", id=3): gr.Markdown("## 🗣️ Pratique e Avalie Seus Argumentos (Advogado de Defesa)") gr.Markdown("Use esta seção para redigir e obter feedback sobre argumentos específicos para o caso configurado.") with gr.Row(): fatos_caso_treino_arg_display = gr.Textbox(label="Fatos do Caso (da Configuração):", value=CASO_FATOS_COMPLETO_PREDEFINIDO, lines=5, interactive=False) # Mostra fatos do caso padrão ou o configurado provas_reu_treino_arg_display = gr.Textbox(label="Provas do Réu (da Configuração):", value=PROVAS_REU_TEXTO_PREDEFINIDO, lines=5, interactive=False) tipo_argumento_treino = gr.Radio( ["Contestação (teses principais)", "Perguntas para Testemunha do Autor", "Perguntas para Testemunha do Réu", "Alegações Finais (memoriais)"], label="Selecione o Tipo de Argumento/Peça para Treinar:", value="Alegações Finais (memoriais)" ) argumento_input_treino = gr.Textbox(lines=10, label="Digite seu argumento aqui:", placeholder="Ex: 'Excelência, a matéria jornalística é um retrato fiel dos fatos públicos...'") btn_avaliar_argumento_treino = gr.Button("🤖 Avaliar Argumento com IA", variant="primary") avaliacao_output_treino = gr.Markdown(label="Feedback da IA sobre o Argumento:") # Atualizar displays quando a configuração mudar fatos_input.change(lambda x: x, inputs=fatos_input, outputs=fatos_caso_treino_arg_display) provas_reu_input.change(lambda x: x, inputs=provas_reu_input, outputs=provas_reu_treino_arg_display) btn_avaliar_argumento_treino.click( avaliar_argumentos_defesa_ia_ui, inputs=[fatos_caso_treino_arg_display, provas_reu_treino_arg_display, tipo_argumento_treino, argumento_input_treino], outputs=avaliacao_output_treino ) with gr.TabItem("5. Preparar Testemunhas (Defesa)", id=4): gr.Markdown("## 🎙️ Simule a Inquirição das Suas Testemunhas (Defesa)") gr.Markdown("Pratique como você (Advogado de Defesa) inquiriria suas próprias testemunhas. A IA responderá como a testemunha selecionada.") fatos_caso_treino_test_display = gr.Textbox(label="Fatos do Caso (da Configuração):", value=CASO_FATOS_COMPLETO_PREDEFINIDO, lines=5, interactive=False) testemunhas_reu_config_treino_display = gr.Textbox(label="Definição das Testemunhas do Réu (da Configuração):", value=TESTEMUNHAS_REU_TEXTO_PREDEFINIDO, lines=3, interactive=False) # Atualizar displays quando a configuração mudar fatos_input.change(lambda x: x, inputs=fatos_input, outputs=fatos_caso_treino_test_display) testemunhas_reu_input.change(lambda x: x, inputs=testemunhas_reu_input, outputs=testemunhas_reu_config_treino_display) # Dropdown para selecionar testemunha do réu para treino dropdown_testemunhas_reu_treino = gr.Dropdown(label="Selecione Sua Testemunha para Inquirir:", choices=[t['nome'] for t in TESTEMUNHAS_REU_PREDEFINIDAS], interactive=True) # Atualizar choices do dropdown quando testemunhas_reu_input mudar def update_dropdown_treino_choices(t_reu_str): nomes = [] if t_reu_str and t_reu_str.strip(): for linha in t_reu_str.strip().split('\n'): if linha.strip(): partes = linha.split(':', 1) nomes.append(partes[0].strip()) return gr.Dropdown(choices=nomes if nomes else [t['nome'] for t in TESTEMUNHAS_REU_PREDEFINIDAS], value=nomes[0] if nomes else None) testemunhas_reu_input.change(update_dropdown_treino_choices, inputs=testemunhas_reu_input, outputs=dropdown_testemunhas_reu_treino) chat_treino_testemunha = gr.Chatbot(label="Simulação de Depoimento (Treino)", height=300, show_copy_button=True, bubble_full_width=False, avatar_images=(None, "https://img.icons8.com/officel/80/person-male.png")) pergunta_testemunha_treino_input = gr.Textbox(label="Sua Pergunta para a Testemunha:", placeholder="Ex: 'Senhor Silva, poderia descrever o procedimento editorial?'") btn_perguntar_testemunha_treino = gr.Button("💬 Perguntar à Testemunha (IA)", variant="primary") btn_limpar_chat_treino_testemunha = gr.Button("🗑️ Limpar Chat de Treino") def limpar_chat_treino(): global _historico_treino_testemunha_atual _historico_treino_testemunha_atual = [] return [], "" btn_limpar_chat_treino_testemunha.click(limpar_chat_treino, outputs=[chat_treino_testemunha, pergunta_testemunha_treino_input]) btn_perguntar_testemunha_treino.click( gerar_dialogo_testemunha_defesa_para_treino_ui, inputs=[fatos_caso_treino_test_display, testemunhas_reu_config_treino_display, dropdown_testemunhas_reu_treino, pergunta_testemunha_treino_input], outputs=[chat_treino_testemunha, pergunta_testemunha_treino_input] # Limpa input após envio ) with gr.TabItem("ℹ️ Ajuda / Sobre o Caso Padrão", id=5): gr.Markdown("## Sobre o Caso Padrão: Direito ao Esquecimento vs. Liberdade de Imprensa") gr.Markdown(f"**Título:** {CASO_TITULO_PREDEFINIDO}") gr.Markdown(f"**Partes:**\n{CASO_PARTES_PREDEFINIDO.replace('\n', '\n\n')}") gr.Markdown(f"**Resumo do Caso:**\n{CASO_DESCRICAO_PREDEFINIDO}") with gr.Accordion("Argumentos Principais do Autor (Caso Padrão)", open=False): gr.Markdown("\n".join([f"- {arg}" for arg in ARGUMENTOS_AUTOR_PREDEFINIDOS])) with gr.Accordion("Argumentos Principais do Réu/Jornal (Caso Padrão)", open=False): gr.Markdown("\n".join([f"- {arg}" for arg in CONTRA_ARGUMENTOS_REU_PREDEFINIDOS])) with gr.Accordion("Testemunhas do Réu/Jornal (Caso Padrão)", open=False): gr.Markdown("\n".join([f"- **{t['nome']}**: {t['pontos_chave']}" for t in TESTEMUNHAS_REU_PREDEFINIDAS])) gr.Markdown("### Legislação e Precedentes Relevantes (Geral)") with gr.Row(): with gr.Column(): gr.Markdown("**Potencialmente Favoráveis ao Réu (Jornal):**") gr.Markdown("\n".join([f"- {lei}" for lei in LEGISLACAO_PRECEDENTES_PREDEFINIDO["favoraveis_ao_reu"]])) with gr.Column(): gr.Markdown("**Potencialmente Favoráveis ao Autor:**") gr.Markdown("\n".join([f"- {lei}" for lei in LEGISLACAO_PRECEDENTES_PREDEFINIDO["favoraveis_ao_autor"]])) gr.Markdown(""" ## Como utilizar este simulador: 1. **Configuração (Aba 1):** * **Gerar Novo Caso com IA:** Cria um caso fictício aleatório sobre o tema. * **Carregar Caso Padrão:** Preenche os campos com o "Caso da Reportagem Revisitada". * Ou preencha manualmente os detalhes do seu próprio caso. * **Salve e Inicie:** Fundamental para começar a simulação interativa. 2. **Audiência Interativa (Aba 2):** * O núcleo da simulação. Siga as instruções e interaja como Advogado(a) do Réu. * Use o campo de texto para suas falas ou os botões de ação contextual. * O "Juiz (IA): Avançar Fase" é usado para progredir quando você conclui sua parte em uma etapa ou quando a IA indica. 3. **Feedback da Atuação (Aba 3):** * Após interagir na Aba 2, verifique aqui a análise da IA sobre sua performance. 4. **Treinamento de Argumentação (Aba 4):** * Use para praticar a redação de argumentos específicos (ex: para contestação, alegações finais) e receber feedback da IA. Baseia-se nos fatos e provas configurados na Aba 1. 5. **Preparar Testemunhas (Aba 5):** * Treine a inquirição das suas testemunhas (do Réu). Você faz as perguntas, e a IA responde como se fosse a testemunha selecionada, baseando-se nos "pontos chave" definidos na Aba 1. ## Dicas para Atuação como Advogado(a) do Réu (Jornal): * **Liberdade de Imprensa:** Seu principal argumento. Fundamente com a Constituição. * **Interesse Público:** Demonstre a relevância da matéria. * **Veracidade dos Fatos:** Crucial. A matéria deve ser factualmente correta. * **Ausência de Dolo/Culpa:** Argumente que não houve intenção de prejudicar, apenas informar. * **Menção à Absolvição:** Se o autor foi absolvido e a matéria menciona isso, é um ponto forte para a defesa. * **Precedentes (STF):** Cite o RE 1.010.606, que ponderou o direito ao esquecimento com a liberdade de informação. * **Contraditório:** Explore as perguntas às testemunhas do Autor para enfraquecer a tese dele. * **Suas Testemunhas:** Prepare-as para reforçar a tese da defesa. """) # --- Conexões dos Componentes da UI (Event Handlers) --- outputs_config = [sim_state, chat_aij_output, feedback_output, instrucao_usuario_output, dropdown_testemunhas_reu_select] + lista_botoes_feedback btn_config_iniciar.click( configurar_e_iniciar_simulacao, inputs=[sim_state, fatos_input, provas_reu_input, provas_autor_input, testemunhas_reu_input, testemunhas_autor_supostas_input], outputs=outputs_config ).then(lambda: gr.Textbox(value=""), outputs=[fala_usuario_input] # Limpa o campo de fala ).then(lambda: gr.Tabs(selected=1), outputs=[abas_principais]) # Muda para aba Audiência outputs_fala_usuario = [sim_state, chat_aij_output, feedback_output, instrucao_usuario_output, fala_usuario_input] + lista_botoes_feedback btn_enviar_fala_usuario.click(lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario) fala_usuario_input.submit(lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario) outputs_acao_juiz = [sim_state, chat_aij_output, feedback_output, instrucao_usuario_output] + lista_botoes_feedback btn_juiz_avancar_fase_action.click(acao_botao_juiz_avancar, inputs=[sim_state], outputs=outputs_acao_juiz).then(lambda: gr.Textbox(value=""), outputs=[fala_usuario_input]) btn_chamar_testemunha_reu_action.click(chamar_testemunha_reu_selecionada, inputs=[sim_state, dropdown_testemunhas_reu_select], outputs=outputs_acao_juiz).then(lambda: gr.Textbox(value=""), outputs=[fala_usuario_input]) # Links dos botões de ação específicos para lidar_com_fala_usuario (eles apenas enviam o texto do botão como "fala") # Estes botões agora estão mais para indicar o contexto da fala do usuário no input principal. # A lógica de o que fazer com a fala do usuário está centralizada em `lidar_com_fala_usuario`. # Se o botão for para uma ação específica que não envolve fala direta, ele precisa de seu próprio handler. # Ex: Responder conciliação, apresentar alegações finais - podem usar o `lidar_com_fala_usuario` se o usuário digitar no campo. # Se forem "ações puras" sem texto, podem precisar de lógica adaptada ou de um `fala_usuario_txt` especial. # Para simplificar, vamos assumir que o usuário digita a resposta no campo de texto principal após clicar nesses botões (que agora servem mais como lembretes visuais). # A alternativa seria esses botões passarem um placeholder de texto para `lidar_com_fala_usuario`. # Por exemplo, btn_responder_conciliacao.click(lambda s: lidar_com_fala_usuario(s, "Réu se manifesta sobre conciliação (detalhes no campo de texto)."), ...) # Mas a implementação atual já faz o `lidar_com_fala_usuario` receber o texto do `fala_usuario_input`. # Botões que enviam a fala do input principal btn_responder_conciliacao.click(lambda: gr.Info("Digite sua resposta à conciliação no campo de fala e envie."), inputs=[], outputs=[]).then( lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario ) btn_perguntar_testemunha_autor_action.click(lambda: gr.Info("Digite sua pergunta à testemunha do Autor no campo de fala e envie."), inputs=[], outputs=[]).then( lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario ) btn_adv_reu_pergunta_sua_testemunha_action.click(lambda: gr.Info("Digite sua pergunta à sua testemunha no campo de fala e envie. Você também digitará a RESPOSTA dela em seguida."), inputs=[], outputs=[]).then( lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario ) btn_adv_reu_responde_pela_sua_testemunha_action.click(lambda: gr.Info("Digite a resposta da sua testemunha (à pergunta do Adv. Autor) no campo de fala e envie."), inputs=[], outputs=[]).then( lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario ) btn_apresentar_alegacoes_finais_reu_action.click(lambda: gr.Info("Digite suas alegações finais no campo de fala e envie."), inputs=[], outputs=[]).then( lidar_com_fala_usuario, inputs=[sim_state, fala_usuario_input], outputs=outputs_fala_usuario ) # Estado inicial da UI no carregamento def setup_initial_ui_state_load(s): initial_fase = s["fase_aij"] dropdown_choices = [t["nome"] for t in s.get("testemunhas_reu_defs", [])] if s.get("testemunhas_reu_defs") else [] return [gr.Dropdown(choices=dropdown_choices, value=None, interactive=True)] + mostrar_botoes_corretos(initial_fase) demo.load( lambda s: (s, s["transcricao_chat"], s["feedback_para_usuario"], s["instrucao_para_usuario"]) + tuple(setup_initial_ui_state_load(s)), inputs=[sim_state], outputs=[sim_state, chat_aij_output, feedback_output, instrucao_usuario_output, dropdown_testemunhas_reu_select] + lista_botoes_feedback ) if __name__ == "__main__": if not GEMINI_API_KEY: print("#####################################################################") print("ATENÇÃO: GEMINI_API_KEY não configurada como variável de ambiente.") print("Para rodar localmente, edite o script e insira sua chave ou defina a variável de ambiente.") print("Para Hugging Face Spaces, configure o Secret 'GEMINI_API_KEY'.") print("#####################################################################") demo.queue(max_size=20).launch(debug=False) # Adicionado max_size para melhor gerenciamento de fila.