Create app.py

app.py

@@ -0,0 +1,676 @@
+# app.py
+import gradio as gr
+import requests
+import os
+import json
+import tempfile
+import PyPDF2
+import docx
+import io
+import time
+from dotenv import load_dotenv
+from pdfplumber import open as pdfplumber_open
+from PIL import Image
+import pytesseract
+import cv2
+import numpy as np
+from datetime import datetime
+
+# Carrega variáveis de ambiente de um arquivo .env (opcional para dev local)
+load_dotenv()
+
+# Obtém a chave da API do ambiente (no Hugging Face, configure como Secret)
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+if not GEMINI_API_KEY:
+    raise ValueError("❌ A chave GEMINI_API_KEY não foi encontrada. Configure-a como Secret no Hugging Face Spaces.")
+
+# URL da API Gemini
+GEMINI_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={GEMINI_API_KEY}"
+
+# Configurações da aplicação
+CONFIG = {
+    "max_retry_attempts": 3,
+    "retry_delay": 2,
+    "timeout": 60,
+    "temperatura": 0.2,
+    "max_tokens": 4096
+}
+
+# Banco de dicas contextuais
+DICAS_OAB = {
+    "Endereçamento": "Em relações de consumo, prefira o foro do domicílio do autor (art. 101, I, CDC).",
+    "Qualificação": "Mencione nome, estado civil (se informado), endereço (use 'Rua XXX' se não fornecido).",
+    "Fatos": "Descreva os fatos cronologicamente, sem inventar informações.",
+    "Pedidos": "Seja específico nos pedidos (ex.: 'condenação ao pagamento de R$ X').",
+    "Custas": "Inclua 'Requer a juntada da guia de custas devidamente recolhida'."
+}
+
+# Histórico de correções
+HISTORICO = []
+
+def preprocess_image_for_ocr(img):
+    try:
+        gray = img.convert('L')
+        np_img = np.array(gray)
+        _, thresh = cv2.threshold(np_img, 150, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        return Image.fromarray(thresh)
+    except Exception as e:
+        return f"❌ Erro no pré-processamento: {str(e)}"
+
+def extract_text_from_pdf(file_path_or_obj):
+    try:
+        if isinstance(file_path_or_obj, str):
+            with open(file_path_or_obj, 'rb') as f:
+                text = ""
+                with pdfplumber_open(f) as pdf:
+                    for page in pdf.pages:
+                        text += (page.extract_text() or "") + "\n"
+                if not text.strip():
+                    images = pdfplumber_open(f).pages
+                    for i, image in enumerate(images):
+                        try:
+                            img = image.to_image()
+                            preprocessed_img = preprocess_image_for_ocr(img)
+                            text += pytesseract.image_to_string(preprocessed_img) + "\n"
+                        except Exception as e:
+                            text += f"[Erro na página {i+1}: {str(e)}]\n"
+        else:
+            text = ""
+            with pdfplumber_open(file_path_or_obj) as pdf:
+                for page in pdf.pages:
+                    text += (page.extract_text() or "") + "\n"
+                if not text.strip():
+                    images = pdfplumber_open(file_path_or_obj).pages
+                    for i, image in enumerate(images):
+                        try:
+                            img = image.to_image()
+                            preprocessed_img = preprocess_image_for_ocr(img)
+                            text += pytesseract.image_to_string(preprocessed_img) + "\n"
+                        except Exception as e:
+                            text += f"[Erro na página {i+1}: {str(e)}]\n"
+        return text if text.strip() else "⚠️ Não foi possível extrair texto do PDF."
+    except Exception as e:
+        return f"❌ Erro ao processar o PDF: {str(e)}"
+
+def extract_text_from_docx(file_path_or_obj):
+    try:
+        if isinstance(file_path_or_obj, str):
+            with open(file_path_or_obj, 'rb') as f:
+                doc = docx.Document(f)
+                text = ""
+                for para in doc.paragraphs:
+                    text += para.text + "\n"
+                for table in doc.tables:
+                    for row in table.rows:
+                        for cell in row.cells:
+                            text += cell.text + " "
+                        text += "\n"
+        else:
+            doc = docx.Document(file_path_or_obj)
+            text = ""
+            for para in doc.paragraphs:
+                text += para.text + "\n"
+            for table in doc.tables:
+                for row in table.rows:
+                    for cell in row.cells:
+                        text += cell.text + " "
+                    text += "\n"
+        return text if text.strip() else "⚠️ Não foi possível extrair texto do DOCX."
+    except Exception as e:
+        return f"❌ Erro ao processar o DOCX: {str(e)}"
+
+def extract_text_from_txt(file_path_or_obj):
+    try:
+        if isinstance(file_path_or_obj, str):
+            with open(file_path_or_obj, 'rb') as f:
+                content = f.read()
+                encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+                for encoding in encodings:
+                    try:
+                        return content.decode(encoding)
+                    except UnicodeDecodeError:
+                        continue
+                return "❌ Não foi possível decodificar o arquivo TXT."
+        else:
+            content = file_path_or_obj.read()
+            encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+            for encoding in encodings:
+                try:
+                    return content.decode(encoding)
+                except UnicodeDecodeError:
+                    continue
+            return "❌ Não foi possível decodificar o arquivo TXT."
+    except Exception as e:
+        return f"❌ Erro ao processar o TXT: {str(e)}"
+
+def process_file(file_obj):
+    if file_obj is None:
+        return "Nenhum arquivo enviado."
+    try:
+        if hasattr(file_obj, 'name'):
+            file_path = file_obj.name
+            filename = os.path.basename(file_path).lower()
+            file_size = os.path.getsize(file_path)
+            if file_size > 10 * 1024 * 1024:
+                return "⚠️ O arquivo é muito grande. Máx. 10 MB."
+            if filename.endswith('.pdf'):
+                return extract_text_from_pdf(file_path)
+            elif filename.endswith('.docx'):
+                return extract_text_from_docx(file_path)
+            elif filename.endswith('.txt'):
+                return extract_text_from_txt(file_path)
+            else:
+                return "⚠️ Formato de arquivo não suportado. Use PDF, DOCX ou TXT."
+        else:
+            return "❌ Erro: Objeto de arquivo inválido."
+    except Exception as e:
+        return f"❌ Erro ao processar o arquivo: {str(e)}"
+
+def calcular_pontuacao(enderecamento, fundamentos, pedidos, fechamento):
+    tabela = [
+        ("**Endereçamento**", ""),
+        ("1. Correto endereçamento ao juízo competente", f"{enderecamento[0]:.2f} / 0,10"),
+        ("2. Qualificação das partes conforme Art. 319, II, CPC", f"{enderecamento[1]:.2f} / 0,20"),
+        ("**Fundamentos**", ""),
+        ("3. Exposição clara dos fatos", f"{fundamentos[0]:.2f} / 0,20"),
+        ("4. Fundamentação jurídica adequada", f"{fundamentos[1]:.2f} / 0,25"),
+        ("5. Demonstração de ilícito e dano", f"{fundamentos[2]:.2f} / 0,25"),
+        ("**Pedidos**", ""),
+        ("6. Pedidos claros e específicos", f"{pedidos[0]:.2f} / 0,30"),
+        ("7. Valor da causa indicado", f"{pedidos[1]:.2f} / 0,10"),
+        ("8. Provas pretendidas especificadas", f"{pedidos[2]:.2f} / 0,10"),
+        ("9. Opção sobre audiência de conciliação", f"{pedidos[3]:.2f} / 0,10"),
+        ("10. Pedido de citação do réu", f"{pedidos[4]:.2f} / 0,10"),
+        ("11. Juntada da guia de custas", f"{pedidos[5]:.2f} / 0,10"),
+        ("**Fechamento**", ""),
+        ("12. Fechamento formal adequado", f"{fechamento[0]:.2f} / 0,10"),
+    ]
+    nota_final = sum(enderecamento) + sum(fundamentos) + sum(pedidos) + sum(fechamento)
+    tabela_formatada = "\n".join([f"| {linha[0].ljust(60)} | {linha[1].rjust(10)} |" for linha in tabela])
+    return f"{tabela_formatada}\n\n**Nota Final:** {nota_final:.2f} / 10,00"
+
+def estruturar_prompt_correcao(caso, peticao, modo_treinamento=False):
+    base_prompt = f"""
+    ## Correção Rigorosa de Petição Inicial Cível (Critérios Realistas da OAB)
+    **Caso Fornecido:**
+    {caso}
+    **Petição do Aluno:**
+    {peticao}
+    **Estrutura da Avaliação:**
+    ### Análise da Petição
+    1. Análise Geral (Breve visão geral sobre a petição - máximo 3 linhas)
+    2. Nota Final (0 a 10 com uma casa decimal)
+    3. Pontos Positivos (Liste pelo menos 3 aspectos bem executados)
+    4. Pontos a Melhorar (Liste os problemas encontrados em ordem de gravidade)
+    5. Análise Específica dos Requisitos:
+       - Endereçamento e qualificação do juízo
+       - Qualificação das partes (Art. 319, II, CPC)
+       - Fatos e fundamentos jurídicos (Art. 319, III, CPC)
+       - Pedidos com especificações (Art. 319, IV, CPC)
+       - Valor da causa (Art. 319, V, CPC)
+       - Provas com que o autor pretende demonstrar a verdade dos fatos (Art. 319, VI, CPC)
+       - Opção pela realização ou não de audiência de conciliação (Art. 319, VII, CPC)
+       - Pedido de citação do réu
+       - Juntada da guia de custas
+       - Fechamento formal da petição
+    **Critérios Fundamentais:**
+    1. Identificação do candidato resulta em nota máxima de 3,0
+    2. Invenção de fatos não constantes no caso resulta em penalização grave (-5,0 pontos)
+    3. Falta de pedido de juntada de custas resulta em perda de 1,0 ponto
+    4. Use marcadores para dados não fornecidos (ex: "Rua XXX", "CPF XXX")
+    5. Não penalize por informações ausentes no caso original
+    **Instruções Especiais para Endereçamento:**
+    - CPC (art. 46): foro competente é o domicílio do réu; CDC (art. 101, I): em relação de consumo, foro do autor é correto.
+    - Avalie o contexto: priorize o foro do autor em casos consumeristas.
+    **Pontuação Detalhada:**
+    Inclua uma tabela com:
+    | ITEM                                      | PONTUAÇÃO |
+    |-------------------------------------------|-----------|
+    **Endereçamento**                          |           |
+    1. Correto endereçamento ao juízo competente (0,10) | / 0,10 |
+    2. Qualificação das partes conforme Art. 319, II, CPC (0,20) | / 0,20 |
+    **Fundamentos**                            |           |
+    3. Exposição clara dos fatos (0,20)       | / 0,20 |
+    4. Fundamentação jurídica adequada (0,25)  | / 0,25 |
+    5. Demonstração de ilícito e dano (0,25)  | / 0,25 |
+    **Pedidos**                                |           |
+    6. Pedidos claros e específicos (0,30)    | / 0,30 |
+    7. Valor da causa indicado (0,10)         | / 0,10 |
+    8. Provas pretendidas especificadas (0,10) | / 0,10 |
+    9. Opção sobre audiência de conciliação (0,10) | / 0,10 |
+    10. Pedido de citação do réu (0,10)       | / 0,10 |
+    11. Juntada da guia de custas (0,10)     | / 0,10 |
+    **Fechamento**                             |           |
+    12. Fechamento formal adequado (0,10)     | / 0,10 |
+    **Nota Final:**
+    Calcule a nota final somando os pontos.
+    ---
+
+    ### Petição Corrigida
+    Forneça a petição do aluno reescrita com todas as correções aplicadas, incluindo partes omitidas (como pedidos ou custas) e ajustando erros identificados nos "Pontos a Melhorar" e "Análise Específica". Use apenas informações do caso e fundamente com leis brasileiras relevantes (ex.: CPC, CDC). Estruture a petição corrigida com:
+    1. Endereçamento correto
+    2. Qualificação completa (Art. 319, II, CPC)
+    3. Fatos claros (Art. 319, III, CPC)
+    4. Fundamentação jurídica (ex.: CPC, CDC)
+    5. Pedidos específicos (Art. 319, IV, CPC)
+    6. Valor da causa (Art. 319, V, CPC)
+    7. Provas (Art. 319, VI, CPC)
+    8. Opção por audiência (Art. 319, VII, CPC)
+    9. Pedido de citação
+    10. Juntada da guia de custas
+    11. Fechamento formal
+    """
+    if modo_treinamento:
+        base_prompt += f"""
+        **Modo de Treinamento Interativo Ativado:**
+        - Para cada item com pontuação abaixo do máximo, forneça:
+          a) Uma explicação detalhada do erro.
+          b) Uma sugestão de redação corrigida baseada no caso.
+          c) Uma dica prática para evitar o erro no futuro (use este banco de dicas: {json.dumps(DICAS_OAB)}).
+        """
+    return base_prompt
+
+def estruturar_prompt_geracao_caso():
+    return """
+    Crie um caso fictício detalhado para uma petição inicial cível, similar ao exemplo:
+    "Ana, modelo profissional, residente em Manaus, viajou para São Paulo, para o casamento de sua filha. Para lavar, pintar seus cabelos e realizar um penteado para o casamento, Ana procurou os serviços de João Macedo, cabeleireiro e dono do salão de beleza 'Hair', sediado na cidade de São Paulo, que lhe cobrou R$500,00 (quinhentos reais) pela prestação do serviço. Após lavar os cabelos de Ana, João aplicou-lhe uma tintura da marca francesa ABC, importada pela empresa Brasil Connection Ltda, sediada na cidade de Curitiba (PR). Meia hora após a aplicação da tintura, Ana sofreu uma reação alérgica, que demandou atendimento médico-hospitalar, no valor de R$1.000,00 (um mil reais), bem como dois dias de absoluto repouso que impossibilitou sua presença no casamento de sua filha. Além disso, perdeu grande parte de seu cabelo, tendo permanecido com manchas em seu rosto por dois meses, perdendo um ensaio fotográfico, para o qual já havia sido contratada, pelo valor de R$50.000,00 (cinquenta mil reais). Posteriormente constatou-se que a tintura utilizada continha substâncias químicas extremamente perigosas à vida e à saúde das pessoas e a fabricante ABC já havia sido condenada pela justiça francesa a encerrar a fabricação e comercialização do produto. Indignada com os danos sofridos, Ana procura um advogado para pleitear o devido ressarcimento."
+    O caso deve:
+    1. Conter uma situação clara de violação de direitos que justifique uma ação cível
+    2. Incluir valores específicos de danos materiais e/ou morais
+    3. Mencionar nomes completos, cidades e informações suficientes para identificar as partes
+    4. Estabelecer relação entre as partes (contratual, extracontratual, consumo, etc.)
+    5. Ter complexidade adequada para uma petição inicial de nível OAB
+    6. Ter entre 15-25 linhas de texto
+    7. Focar em um dos seguintes temas (escolha APENAS UM aleatoriamente):
+       - Responsabilidade civil por acidente de consumo
+       - Inadimplemento contratual com danos
+       - Responsabilidade civil por dano ambiental
+       - Violação de direitos da personalidade
+       - Relação de consumo com vício de produto/serviço
+       - Reparação por danos patrimoniais
+    Termine com: "Situação problema: Como advogado(a) de [NOME DO CLIENTE], promova a demanda cabível."
+    """
+
+def gerar_caso_ficticio():
+    prompt = estruturar_prompt_geracao_caso()
+    payload = {
+        "contents": [{"parts": [{"text": prompt}]}],
+        "generationConfig": {"temperature": 0.7, "maxOutputTokens": CONFIG["max_tokens"], "topP": 0.95}
+    }
+    headers = {"Content-Type": "application/json"}
+    for tentativa in range(CONFIG["max_retry_attempts"]):
+        try:
+            response = requests.post(GEMINI_API_URL, headers=headers, data=json.dumps(payload), timeout=CONFIG["timeout"])
+            if response.status_code != 200:
+                response_data = response.json()
+                error_msg = response_data.get("error", {}).get("message", "Erro desconhecido")
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return f"❌ Erro da API (Tentativa {tentativa+1}/{CONFIG['max_retry_attempts']}): {error_msg}"
+            response_data = response.json()
+            if "candidates" not in response_data or not response_data["candidates"]:
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return "❌ A API retornou uma resposta vazia. Tente novamente."
+            caso_gerado = response_data["candidates"][0]["content"]["parts"][0]["text"].strip()
+            return f"## 📝 Caso Fictício Gerado\n\n{caso_gerado}"
+        except requests.Timeout:
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                continue
+            return "⏱️ A resposta demorou muito. Tente novamente mais tarde."
+        except requests.RequestException as e:
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                continue
+            return f"❌ Erro ao chamar a API: {e}"
+        except Exception as e:
+            return f"❌ Erro inesperado: {str(e)}"
+
+def corrigir_peticao(caso, peticao_texto=None, peticao_arquivo=None, modo_treinamento=False):
+    if not caso.strip():
+        return "⚠️ Forneça o caso da banca."
+    if peticao_arquivo is not None:
+        peticao_conteudo = process_file(peticao_arquivo)
+        if peticao_conteudo.startswith("❌") or peticao_conteudo.startswith("⚠️"):
+            return peticao_conteudo
+    else:
+        peticao_conteudo = peticao_texto or ""
+    if not peticao_conteudo.strip():
+        return "⚠️ Forneça uma petição."
+    prompt = estruturar_prompt_correcao(caso, peticao_conteudo, modo_treinamento)
+    payload = {
+        "contents": [{"parts": [{"text": prompt}]}],
+        "generationConfig": {"temperature": CONFIG["temperatura"], "maxOutputTokens": CONFIG["max_tokens"], "topP": 0.95}
+    }
+    headers = {"Content-Type": "application/json"}
+    for tentativa in range(CONFIG["max_retry_attempts"]):
+        try:
+            response = requests.post(GEMINI_API_URL, headers=headers, data=json.dumps(payload), timeout=CONFIG["timeout"])
+            if response.status_code != 200:
+                response_data = response.json()
+                error_msg = response_data.get("error", {}).get("message", "Erro desconhecido")
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return f"❌ Erro da API (Tentativa {tentativa+1}/{CONFIG['max_retry_attempts']}): {error_msg}"
+            response_data = response.json()
+            if "candidates" not in response_data or not response_data["candidates"]:
+                if tentativa < CONFIG["max_retry_attempts"] - 1:
+                    time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                    continue
+                return "❌ A API retornou uma resposta vazia. Tente novamente."
+            correção_completa = response_data["candidates"][0]["content"]["parts"][0]["text"]
+            if "### Petição Corrigida" in correção_completa:
+                analise_fim = correção_completa.index("### Petição Corrigida")
+                analise = correção_completa[:analise_fim].strip()
+            else:
+                analise = correção_completa.strip()
+            correção_formatada = formatar_correção(analise)
+            HISTORICO.append({
+                "data": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "caso": caso,
+                "peticao": peticao_conteudo,
+                "correcao_completa": correção_completa
+            })
+            return correção_formatada
+        except requests.Timeout:
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                continue
+            return "⏱️ A resposta demorou muito. Tente novamente mais tarde."
+        except requests.RequestException as e:
+            if tentativa < CONFIG["max_retry_attempts"] - 1:
+                time.sleep(CONFIG["retry_delay"] * (tentativa + 1))
+                continue
+            return f"❌ Erro ao chamar a API: {e}"
+        except Exception as e:
+            return f"❌ Erro inesperado: {str(e)}"
+
+def formatar_correção(texto):
+    linhas = texto.split('\n')
+    texto_formatado = ""
+    for linha in linhas:
+        if "Análise Geral" in linha or "Nota Final" in linha or "Pontos Positivos" in linha or "Pontos a Melhorar" in linha:
+            texto_formatado += f"### {linha.strip()}\n\n"
+        elif linha.strip().startswith('-') and len(linha) > 2 and any(termo in linha for termo in ["Endereçamento", "Qualificação", "Fatos", "Pedidos", "Valor", "Provas"]):
+            texto_formatado += f"**{linha.strip()}**\n"
+        elif "Explicação" in linha or "Sugestão" in linha or "Dica" in linha:
+            texto_formatado += f"*{linha.strip()}*\n"
+        else:
+            texto_formatado += f"{linha}\n"
+    if "Nota Final" in texto_formatado:
+        import re
+        nota_pattern = r"### Nota Final.*?(\d+[.,]\d+|\d+)"
+        match = re.search(nota_pattern, texto_formatado, re.DOTALL)
+        if match:
+            nota = match.group(1)
+            texto_formatado = texto_formatado.replace(f"### Nota Final\n\n{nota}", f"### Nota Final: {nota}/10\n\n")
+    return texto_formatado
+
+def extrair_peticao_corrigida(correcao_completa):
+    try:
+        if "### Petição Corrigida" in correcao_completa:
+            inicio = correcao_completa.index("### Petição Corrigida") + len("### Petição Corrigida")
+            peticao_texto = ""
+            for line in correcao_completa[inicio:].split('\n'):
+                if line.strip() and not line.strip().startswith('#') and not line.strip().startswith('*') and not any(prefix in line for prefix in ["Análise", "Nota Final", "Pontos Positivos", "Pontos a Melhorar"]):
+                    peticao_texto += line + '\n'
+            return peticao_texto.strip()
+        return "⚠️ Petição corrigida não encontrada na resposta da API."
+    except Exception as e:
+        return f"❌ Erro ao extrair petição corrigida: {str(e)}"
+
+def fornecer_dica_contextual(texto):
+    dicas = [f"💡 {chave}: {dica}" for chave, dica in DICAS_OAB.items() if chave.lower() in texto.lower()]
+    return "\n".join(dicas) if dicas else "💡 Escreva mais para receber dicas."
+
+def calcular_progresso():
+    if not HISTORICO:
+        return "📊 Nenhum progresso registrado."
+    notas = []
+    for entry in HISTORICO:
+        for line in entry["correcao_completa"].split("\n"):
+            if "Nota Final" in line:
+                try:
+                    nota = float(line.split()[-1].split("/")[0].replace(",", "."))
+                    notas.append(nota)
+                except:
+                    continue
+    media = sum(notas) / len(notas) if notas else 0
+    tendencia = "⬆️ Melhorando" if len(notas) > 1 and notas[-1] > notas[-2] else "⬇️ Estável ou piorando"
+    return f"📊 Progresso: Média {media:.1f}/10 | Tentativas: {len(notas)} | Tendência: {tendencia}"
+
+def comparar_peticao_melhorada(caso, peticao_texto, correcao):
+    import difflib
+    from html import escape
+
+    if not caso:
+        return "⚠️ Forneça um caso antes de comparar.", "", ""
+    peticao = peticao_texto if peticao_texto else (HISTORICO[-1]["peticao"] if HISTORICO else "")
+    if not peticao:
+        return "⚠️ Forneça uma petição para comparar ou corrija uma antes.", "", ""
+    if not correcao:
+        return "⚠️ Corrija a petição antes de comparar.", "", ""
+    ultima_correcao = HISTORICO[-1]["correcao_completa"] if HISTORICO else ""
+    if not ultima_correcao:
+        return "⚠️ Nenhuma correção disponível no histórico.", "", ""
+    peticao_corrigida = extrair_peticao_corrigida(ultima_correcao)
+
+    orig_lines = peticao.split('\n')
+    corr_lines = peticao_corrigida.split('\n')
+    start_orig = next((i for i, line in enumerate(orig_lines) if "AÇÃO" in line.upper() or "EXCELENTÍSSIMO" in line.upper()), 0)
+    start_corr = next((i for i, line in enumerate(corr_lines) if "AÇÃO" in line.upper() or "EXCELENTÍSSIMO" in line.upper()), 0)
+
+    orig_body = "\n".join(orig_lines[start_orig:]).strip()
+    corr_body = "\n".join(corr_lines[start_corr:]).strip()
+
+    diff = difflib.ndiff(orig_body.splitlines(), corr_body.splitlines())
+    secoes = {
+        "ENDEREÇAMENTO": [], "QUALIFICAÇÃO": [], "FATOS": [], "FUNDAMENTOS": [], "PEDIDOS": [], "FECHAMENTO": [], "OUTROS": []
+    }
+
+    def identificar_secao(linha):
+        linha_upper = linha.upper()
+        if "EXCELENTÍSSIMO" in linha_upper or "JUIZ" in linha_upper or "VARA" in linha_upper:
+            return "ENDEREÇAMENTO"
+        elif "QUALIFICAÇÃO" in linha_upper or "AUTOR" in linha_upper or "RÉU" in linha_upper:
+            return "QUALIFICAÇÃO"
+        elif "DOS FATOS" in linha_upper:
+            return "FATOS"
+        elif "DIREITO" in linha_upper or "FUNDAMENTO" in linha_upper:
+            return "FUNDAMENTOS"
+        elif "PEDIDO" in linha_upper or "REQUER" in linha_upper:
+            return "PEDIDOS"
+        elif "TERMOS" in linha_upper and "DEFERIMENTO" in linha_upper:
+            return "FECHAMENTO"
+        else:
+            return "OUTROS"
+
+    secao_atual = "OUTROS"
+    resultado_diff = []
+    for linha in diff:
+        if linha.startswith('  '):
+            texto = linha[2:]
+            nova_secao = identificar_secao(texto)
+            if nova_secao != "OUTROS":
+                secao_atual = nova_secao
+            resultado_diff.append(f"<div class='linha-igual'>{escape(texto)}</div>")
+        elif linha.startswith('- '):
+            texto = linha[2:]
+            resultado_diff.append(f"<div class='linha-removida'><del>{escape(texto)}</del></div>")
+            secoes[secao_atual].append(f"- REMOVIDO: {texto}")
+        elif linha.startswith('+ '):
+            texto = linha[2:]
+            nova_secao = identificar_secao(texto)
+            if nova_secao != "OUTROS":
+                secao_atual = nova_secao
+            resultado_diff.append(f"<div class='linha-adicionada'><ins>{escape(texto)}</ins></div>")
+            secoes[secao_atual].append(f"+ ADICIONADO: {texto}")
+        elif linha.startswith('? '):
+            continue
+
+    resumo_alteracoes = []
+    for secao, alteracoes in secoes.items():
+        if alteracoes:
+            resumo_alteracoes.append(f"### {secao}:")
+            for alt in alteracoes[:5]:
+                resumo_alteracoes.append(f"- {alt}")
+            if len(alteracoes) > 5:
+                resumo_alteracoes.append(f"- ... e mais {len(alteracoes) - 5} alterações")
+
+    total_removidas = len([linha for linha in resultado_diff if "linha-removida" in linha])
+    total_adicionadas = len([linha for linha in resultado_diff if "linha-adicionada" in linha])
+
+    resumo_estatistico = f"""
+    ## 📊 Resumo das Alterações
+    - Total de linhas removidas: {total_removidas}
+    - Total de linhas adicionadas: {total_adicionadas}
+    - Diferença líquida: {total_adicionadas - total_removidas} linhas
+
+    ## 🔍 Alterações por Seção
+    {chr(10).join(resumo_alteracoes)}
+
+    ## 📝 Visualização Detalhada
+    <style>
+    .linha-igual {{ color: #000000; }}
+    .linha-removida {{ color: #ffffff; background-color: #b30000; }}
+    .linha-adicionada {{ color: #ffffff; background-color: #006600; }}
+    </style>
+    {"".join(resultado_diff)}
+    """
+    return peticao, peticao_corrigida, resumo_estatistico
+
+def interface_gradio():
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 📝 Corretor Avançado de Petições Iniciais (Critérios OAB)")
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                ### 🔍 Critérios de Avaliação
+                - ✅ Endereçamento correto
+                - ✅ Qualificação das partes
+                - ✅ Fatos e fundamentos
+                - ✅ Pedidos claros e específicos
+                - ✅ Valor da causa
+                - ✅ Provas pretendidas
+                - ✅ Opção sobre conciliação
+                - ✅ Pedido de citação adequado
+                - ✅ Juntada da guia de custas
+                - ✅ Fechamento formal
+                ### ⚖️ Penalizações
+                - ❌ Identificação do candidato: nota máxima 3,0
+                - ❌ Invenção de fatos: -5,0 pontos
+                - ❌ Sem pedido de custas: -1,0 ponto
+                """)
+                modo_treinamento = gr.Checkbox(label="Modo de Treinamento Interativo", value=False)
+                with gr.Accordion("⚙️ Configurações", open=False):
+                    temperatura_slider = gr.Slider(minimum=0.0, maximum=1.0, value=CONFIG["temperatura"], step=0.1, label="Temperatura")
+                    timeout_slider = gr.Slider(minimum=30, maximum=120, value=CONFIG["timeout"], step=5, label="Timeout (segundos)")
+                    def atualizar_config(temp, timeout):
+                        CONFIG["temperatura"] = temp
+                        CONFIG["timeout"] = timeout
+                        return f"✅ Configurações atualizadas!"
+                    config_update_btn = gr.Button("📝 Atualizar Configurações")
+                    config_status = gr.Textbox(label="Status", visible=True)
+                    config_update_btn.click(atualizar_config, inputs=[temperatura_slider, timeout_slider], outputs=config_status)
+                with gr.Accordion("📊 Dashboard de Progresso", open=False):
+                    progresso_output = gr.Markdown()
+                    progresso_btn = gr.Button("🔄 Atualizar Progresso")
+                    progresso_btn.click(fn=calcular_progresso, outputs=progresso_output)
+
+            with gr.Column(scale=2):
+                with gr.Row():
+                    gr.Markdown("### 🧩 Gerar Caso Fictício")
+                    caso_btn = gr.Button("🔄 Gerar Novo Caso Fictício", variant="secondary")
+                caso_input = gr.Textbox(label="📋 Caso Fornecido pela Banca", lines=8, placeholder="Insira o texto COMPLETO do caso...")
+                with gr.Tabs():
+                    with gr.TabItem("✏️ Inserir Texto"):
+                        peticao_texto = gr.Textbox(label="Texto da Petição do Aluno", lines=15, placeholder="Insira a petição completa...")
+                        dica_contextual = gr.Textbox(label="Dicas Contextuais", interactive=False)
+                        peticao_texto.change(fn=fornecer_dica_contextual, inputs=peticao_texto, outputs=dica_contextual)
+                        btn_texto = gr.Button("🔍 Corrigir Petição (Texto)", variant="primary")
+                    with gr.TabItem("📎 Enviar Arquivo"):
+                        gr.Markdown("**Envie um arquivo PDF, DOCX ou TXT contendo a petição do aluno.**")
+                        peticao_arquivo = gr.File(label="Arquivo da Petição", file_types=[".pdf", ".docx", ".txt"])
+                        arquivo_preview = gr.Textbox(label="Prévia do Conteúdo do Arquivo", lines=5, interactive=False)
+                        btn_arquivo = gr.Button("🔍 Corrigir Petição (Arquivo)", variant="primary")
+                        peticao_arquivo.change(fn=process_file, inputs=[peticao_arquivo], outputs=[arquivo_preview])
+
+        with gr.Row():
+            clear_btn = gr.Button("🗑️ Limpar Todos os Campos")
+            comparar_btn = gr.Button("⚖️ Comparar com Correção")
+
+        resultado_output = gr.Markdown(label="📊 Correção Oficial e Nota", show_copy_button=True)
+
+        with gr.Row():
+            peticao_aluno_output = gr.Textbox(label="Petição do Aluno", lines=15, interactive=False)
+            peticao_corrigida_output = gr.Textbox(label="Petição Corrigida", lines=15, interactive=False)
+
+        with gr.Row():
+            comparacao_diferencas = gr.HTML(label="Diferenças Destacadas")
+
+        with gr.Accordion("📜 Histórico de Correções", open=False):
+            historico_output = gr.Markdown()
+            historico_btn = gr.Button("🔄 Ver Histórico")
+            historico_btn.click(
+                fn=lambda: "\n\n".join([f"**{h['data']}**\nCaso: {h['caso'][:100]}...\nCorreção: {h['correcao_completa'][:100]}..." for h in HISTORICO]),
+                outputs=historico_output
+            )
+
+        caso_btn.click(fn=gerar_caso_ficticio, inputs=[], outputs=[caso_input])
+        btn_texto.click(
+            fn=lambda caso, texto, treinamento: corrigir_peticao(caso, texto, None, treinamento),
+            inputs=[caso_input, peticao_texto, modo_treinamento],
+            outputs=[resultado_output]
+        )
+        btn_arquivo.click(
+            fn=lambda caso, arquivo, treinamento: corrigir_peticao(caso, None, arquivo, treinamento),
+            inputs=[caso_input, peticao_arquivo, modo_treinamento],
+            outputs=[resultado_output]
+        )
+        clear_btn.click(
+            fn=lambda: [None, None, None, None, "", "", "", ""],
+            inputs=None,
+            outputs=[caso_input, peticao_texto, peticao_arquivo, arquivo_preview, resultado_output, dica_contextual, peticao_aluno_output, peticao_corrigida_output]
+        )
+        comparar_btn.click(
+            fn=comparar_peticao_melhorada,
+            inputs=[caso_input, peticao_texto, resultado_output],
+            outputs=[peticao_aluno_output, peticao_corrigida_output, comparacao_diferencas]
+        )
+
+        with gr.Accordion("📘 Critérios Detalhados", open=False):
+            gr.Markdown("""
+            ### 📋 Critérios Realistas para Correção
+            #### 1. Qualificação das Partes (Art. 319, II, CPC)
+            - ✅ CORRETO: Usar "Rua XXXX" se endereço não for fornecido
+            - ❌ INCORRETO: Inventar dados
+            #### 2. Citação
+            - ✅ CORRETO: Pedir citação conforme dados do caso
+            #### 3. Pedidos Obrigatórios
+            - ✅ OBRIGATÓRIO: Incluir "a juntada da guia de custas"
+            #### 4. Penalização Grave
+            - ❌ INCORRETO: Identificação do candidato
+            - ❌ INCORRETO: Invenção de fatos
+            """)
+        gr.Markdown("""
+        ### ℹ️ Modo de Treinamento Interativo
+        Ative para explicações detalhadas.
+        ### 📋 Como usar
+        1. Gere ou cole o caso
+        2. Insira a petição
+        3. Corrija e compare
+        ### 📄 Formatos suportados
+        - PDF (texto e escaneados com OCR)
+        - DOCX
+        - TXT
+        """)
+
+    return demo
+
+# No Hugging Face, não usamos if __name__ == "__main__":
+app = interface_gradio()
+app.launch()