"""Decisão do JUIZ de contexto pelo código (doc/clipador/EQUIPE-IA.md). O juiz (IA, só texto) responde perguntas sim/não sobre o corte; quem decide é esta função, com regras fixas e calibráveis no painel (papel `judge` em `judge.roles`): - checagem **crítica** que falhou (padrão: começo, desfecho, funciona sozinho) + ajuste de trecho dentro dos limites → **ajusta** (o trecho é recalculado com `fit_window`) e o juiz confere UMA vez de novo; falhou de novo → descarta; - crítica que falhou sem ajuste possível → **descarta** com o motivo em português; - "funciona sozinho" (e "quem/o quê") falho + frase de contexto → a frase resolve: vai na tela no começo do corte; - checagem não crítica que falhou só **baixa a nota** (`penalty` por checagem); abaixo da nota mínima → descarta; - corte manual ("cortar agora"): o juiz só **avisa**, nunca descarta nem mexe no trecho. """ from __future__ import annotations from dataclasses import dataclass, field from .roles import CHECK_NAMES, CHECKS, DEFAULT_CRITICAL, DEFAULT_PENALTY from .scoring import fit_window MIN_SHIFT_S = 1.0 # ajuste menor que isso não muda nada: conta como "sem ajuste" CONTEXT_LINE_MAX_WORDS = 10 CONTEXT_LINE_MAX_CHARS = 60 OUT_BEFORE_S = 20.0 # o juiz vê 20 s antes do corte, marcados out=1 (o espectador não vê)… OUT_AFTER_S = 15.0 # …e 15 s depois (para notar o desfecho que ficou de fora) # O que a frase de contexto resolve (ela dá ao espectador frio quem/o quê e o pano de fundo). SOLVED_BY_LINE = ("standalone", "who_what") @dataclass class Decision: action: str # approve | adjust | discard | warn failed: list[str] = field(default_factory=list) # todas as checagens que falharam failed_critical: list[str] = field(default_factory=list) # críticas que falharam e a frase não resolveu solved_by_line: list[str] = field(default_factory=list) window: tuple[float, float] | None = None # trecho novo (só em adjust) context_line: str = "" score_after: float | None = None reason_pt: str = "" def usable_line(text: str) -> str: """Frase de contexto que cabe na tela no começo do corte (curta); senão vazia.""" text = " ".join((text or "").split()) if not text or len(text) > CONTEXT_LINE_MAX_CHARS or len(text.split()) > CONTEXT_LINE_MAX_WORDS: return "" return text def _names(checks: list[str]) -> str: names = [CHECK_NAMES.get(c, c) for c in checks] return names[0] if len(names) == 1 else ", ".join(names[:-1]) + " e " + names[-1] def decide(result: dict, *, start_s: float, end_s: float, lo: float, hi: float, min_s: float, max_s: float, conf: dict | None = None, score: float | None = None, min_score: float | None = None, manual: bool = False, allow_fix: bool | None = None) -> Decision: """Ação pelo resultado do juiz (`judge.clean_context`). `conf` = papel `judge` da Equipe de IA. `allow_fix=False` força a 2ª rodada (sem novo ajuste).""" conf = conf or {} critical = [c for c in conf.get("critical", DEFAULT_CRITICAL) if c in CHECKS] penalty = float(conf.get("penalty", DEFAULT_PENALTY)) can_fix = conf.get("allowFix", True) if allow_fix is None else (allow_fix and conf.get("allowFix", True)) checks = result.get("checks") or {} failed = [c for c in CHECKS if not (checks.get(c) or {}).get("ok", True)] fix = result.get("fix") or {} line = usable_line(fix.get("context_line", "")) if conf.get("allowContextLine", True) else "" solved = [c for c in failed if c in SOLVED_BY_LINE] if line else [] failed_critical = [c for c in failed if c in critical and c not in solved] others = [c for c in failed if c not in critical and c not in solved] score_after = None if score is None else round(max(0.0, score - penalty * len(others)), 2) why_pt = (result.get("pt") or {}).get("reason") or result.get("reason") or "" d = Decision("approve", failed, failed_critical, solved, None, line, score_after) if manual: d.action = "warn" if failed else "approve" d.reason_pt = (f"Aviso do juiz: falhou em {_names(failed)}. {why_pt}".strip() if failed else "") return d if failed_critical: new = None if can_fix and (fix.get("start_s") is not None or fix.get("end_s") is not None): ns = fix["start_s"] if fix.get("start_s") is not None else start_s ne = fix["end_s"] if fix.get("end_s") is not None else end_s # Recuar o início (faltou o começo) mantém o início; estender o fim (faltou o desfecho) mantém o fim. keep = "start" if "setup" in failed_critical or ns < start_s - MIN_SHIFT_S else "end" ns, ne = fit_window(ns, ne, lo, hi, min_s, max_s, keep=keep) if ne - ns >= min(min_s, 10.0) and (abs(ns - start_s) >= MIN_SHIFT_S or abs(ne - end_s) >= MIN_SHIFT_S): new = (ns, ne) if new: d.action, d.window = "adjust", new d.reason_pt = (f"Juiz ajustou o trecho para {new[0]:.0f}–{new[1]:.0f}s: faltava {_names(failed_critical)}. " f"{why_pt}").strip() else: d.action = "discard" d.reason_pt = f"Descartado pelo juiz: sem {_names(failed_critical)}. {why_pt}".strip() return d if score_after is not None and min_score is not None and others and score_after < min_score: d.action = "discard" d.reason_pt = (f"Descartado pelo juiz: a nota caiu para {score_after:.1f} (falhou em {_names(others)}). " f"{why_pt}").strip() return d d.reason_pt = (f"Juiz aprovou{' com frase de contexto' if line and solved else ''}" + (f" (falhou em {_names(others)}, nota {score_after:.1f})" if others and score_after is not None else "") + (f". {why_pt}" if why_pt else ".")) return d def view(result: dict, decision: Decision, model: str) -> dict: """O que vai em `judge_json.context` (o painel mostra em português).""" return {"model": model, "viewerSummary": result.get("viewer_summary", ""), "checks": result.get("checks", {}), "fix": result.get("fix", {}), "confidence": result.get("confidence"), "reason": result.get("reason", ""), "pt": result.get("pt") or {}, "decision": decision.action, "failed": decision.failed, "failedCritical": decision.failed_critical, "solvedByLine": decision.solved_by_line, "contextLine": decision.context_line if decision.action in ("approve", "adjust", "warn") else "", "scoreAfter": decision.score_after, "reasonPt": decision.reason_pt, **({"window": [round(decision.window[0], 2), round(decision.window[1], 2)]} if decision.window else {})}