freoa-verifica 1.3.0__py3-none-any.whl

freoa_verifica/__init__.py

@@ -0,0 +1,5 @@
+"""FREOA Verifica — verificação de citações jurídicas contra fontes oficiais."""
+
+__version__ = "1.3.0"
+
+from freoa_verifica.contrato import CONTRATO_VERSAO  # noqa: E402,F401

freoa_verifica/acervo.py

@@ -0,0 +1,161 @@
+"""Acervo efetivo (contrato C7): manifesto do snapshot x conteúdo do home."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+MANIFESTO_LOCAL = "acervo-manifesto.json"
+# Mínimo embutido na versão, usado quando nenhum snapshot foi instalado.
+# shortcut: valor-guarda (home vazio alerta); fixar com os totais do snapshot
+# publicado a cada release.
+MINIMO_EMBUTIDO = {"obras": 1, "decisoes": 0}
+
+_OBRAS_SQL = "SELECT authority||':'||kind||':'||number||'/'||year FROM work"
+_DECISOES_SQL = (
+    "SELECT court||'|'||COALESCE(class,'')||'|'||COALESCE(number,'')||'|'||"
+    "COALESCE(judgment_date,'')||'|'||kind FROM decision"
+)
+
+
+def _ids(conn: sqlite3.Connection, sql: str) -> list[str]:
+    return sorted(r[0] for r in conn.execute(sql).fetchall())
+
+
+def _digest(ids: list[str]) -> str:
+    return hashlib.sha256("\n".join(ids).encode("utf-8")).hexdigest()
+
+
+def derived_version(conn: sqlite3.Connection) -> str | None:
+    try:
+        row = conn.execute("SELECT value FROM meta WHERE key='derived_version'").fetchone()
+    except sqlite3.Error:
+        return None
+    return str(row[0]) if row else None
+
+
+def manifest_fields(conn: sqlite3.Connection, db_sha256: str | None = None) -> dict[str, Any]:
+    """Campos do manifesto publicados pelo snapshot (obras, decisões, derivados, hashes)."""
+    obras, decisoes = _ids(conn, _OBRAS_SQL), _ids(conn, _DECISOES_SQL)
+    return {
+        "obras": len(obras),
+        "decisoes": len(decisoes),
+        "derived_version": derived_version(conn),
+        "obras_ids": obras,
+        "obras_ids_sha256": _digest(obras),
+        "decisoes_ids_sha256": _digest(decisoes),
+        "db_sha256": db_sha256,
+    }
+
+
+def save_installed(home: Path, manifest: dict[str, Any]) -> None:
+    keys = ("obras", "decisoes", "derived_version", "obras_ids", "obras_ids_sha256",
+            "decisoes_ids_sha256", "db_sha256", "vinculado", "snapshot_sha256", "snapshot_derived_version",
+            "vinculo_motivo")
+    (Path(home) / MANIFESTO_LOCAL).write_text(
+        json.dumps({k: manifest.get(k) for k in keys}, ensure_ascii=False, sort_keys=True),
+        encoding="utf-8",
+    )
+
+
+def status(conn: sqlite3.Connection, home: Path) -> dict[str, Any] | None:
+    """None se o acervo atende ao manifesto instalado (ou ao mínimo); senão o aviso."""
+    path = Path(home) / MANIFESTO_LOCAL
+    try:
+        ref = json.loads(path.read_text(encoding="utf-8")) if path.is_file() else None
+    except (OSError, ValueError):
+        ref = None
+    origem = "snapshot_instalado" if ref else "minimo_embutido"
+    ref = ref or MINIMO_EMBUTIDO
+    obras, decisoes = _ids(conn, _OBRAS_SQL), _ids(conn, _DECISOES_SQL)
+    motivos: list[str] = []
+    if len(obras) < int(ref.get("obras") or 0):
+        motivos.append("obras_abaixo_do_manifesto")
+    if len(decisoes) < int(ref.get("decisoes") or 0):
+        motivos.append("decisoes_abaixo_do_manifesto")
+    if ref.get("obras_ids") is not None:
+        if set(ref["obras_ids"]) - set(obras):
+            motivos.append("obras_ausentes_do_manifesto")
+    elif ref.get("obras_ids_sha256") and len(obras) == ref.get("obras") and _digest(obras) != ref["obras_ids_sha256"]:
+        motivos.append("obras_ids_divergentes")
+    if (ref.get("decisoes_ids_sha256") and len(decisoes) == ref.get("decisoes")
+            and _digest(decisoes) != ref["decisoes_ids_sha256"]):
+        motivos.append("decisoes_ids_divergentes")
+    dv = ref.get("derived_version")
+    if dv is not None and derived_version(conn) != str(dv):
+        motivos.append("derived_version_divergente")
+    from freoa_verifica.derivados import compativel
+
+    if not compativel(conn):
+        motivos.append("derivados_desatualizados")
+    from freoa_verifica.derivados import REASON_NAO_PUBLICADA, origem_nao_publicada
+
+    if origem_nao_publicada(conn):
+        motivos.append(REASON_NAO_PUBLICADA)
+    if not motivos:
+        return None
+    return {
+        "codigo": "acervo_incompleto",
+        "referencia": origem,
+        "motivos": motivos,
+        "obras": len(obras),
+        "decisoes": len(decisoes),
+    }
+
+
+def verificar_digest_instalado(provenance: dict[str, Any]) -> dict[str, Any]:
+    """Compara o digest do snapshot instalado com o da lista embutida para esta versão do pacote."""
+    from freoa_verifica import __version__
+    from freoa_verifica.snapshot import _da_versao_instalada, _snapshots_oficiais
+
+    digest = provenance.get("snapshot_sha256")
+    esperados = [e["sha256"] for e in _snapshots_oficiais() if _da_versao_instalada(e)]
+    detalhe = {"versao": __version__, "instalado": digest, "esperados": esperados}
+    if not digest:
+        return {"nome": "snapshot_digest", "status": "alerta", "detalhe": {**detalhe, "motivo": "sem snapshot instalado"}}
+    ok = digest in esperados
+    return {"nome": "snapshot_digest", "status": "ok" if ok else "alerta",
+            "detalhe": {**detalhe, "confere": ok}}
+
+
+def attestation_instalacao(provenance: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Registro do instalador (instalacao.json) confrontado com esta instalação.
+
+    `ok` exige instalação concluída, versão igual à do pacote, attestation verificada e, havendo snapshot
+    instalado, o mesmo digest gravado pelo instalador. Ausente ou divergente é `alerta`.
+    """
+    from freoa_verifica import __version__
+
+    base = os.environ.get("LOCALAPPDATA") or str(Path.home() / ".local" / "share")
+    try:
+        data = json.loads((Path(base) / "freoa-verifica" / "instalacao.json").read_text(encoding="utf-8-sig"))
+        if not isinstance(data, dict):
+            raise ValueError
+    except (OSError, ValueError):
+        return {"nome": "attestation", "status": "alerta",
+                "detalhe": {"attestation_verificada": None, "motivos": ["sem_registro_do_instalador"]}}
+    motivos = []
+    if data.get("concluida") is not True:
+        motivos.append("instalacao_nao_concluida")
+    if data.get("versao") != __version__:
+        motivos.append("versao_divergente")
+    if data.get("attestation_verificada") is not True:
+        motivos.append("attestation_nao_verificada")
+    instalado = (provenance or {}).get("snapshot_sha256")
+    if provenance is not None and instalado and data.get("digest_snapshot") != instalado:
+        motivos.append("digest_snapshot_divergente")
+    detalhe = {k: data.get(k) for k in ("attestation_verificada", "versao", "concluida", "sha256_wheel", "digest_snapshot")}
+    return {"nome": "attestation", "status": "alerta" if motivos else "ok",
+            "detalhe": {**detalhe, "versao_instalada": __version__, "motivos": motivos}}
+
+
+def installed_provenance(home: Path) -> dict[str, Any]:
+    try:
+        data = json.loads((Path(home) / MANIFESTO_LOCAL).read_text(encoding="utf-8"))
+        return {k: data.get(k) for k in ("vinculado", "snapshot_sha256", "snapshot_derived_version", "vinculo_motivo")}
+    except (OSError, ValueError, AttributeError):
+        return {"vinculado": False}

freoa_verifica/aliases.py

@@ -0,0 +1,150 @@
+"""Apelidos estáveis de obras normativas brasileiras → WorkKey."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class WorkKey:
+    """Chave de obra normativa (autoridade + espécie + número + ano)."""
+
+    authority: str  # federal|cvm|cmn|bcb|stf|stj
+    kind: str
+    number: str
+    year: int
+
+
+# Apelidos canônicos (chave = fold_alias; valor = WorkKey).
+_LSA = WorkKey("federal", "lei", "6404", 1976)
+_CVM_LEI = WorkKey("federal", "lei", "6385", 1976)
+_CC = WorkKey("federal", "lei", "10406", 2002)
+_CPC = WorkKey("federal", "lei", "13105", 2015)
+_CDC = WorkKey("federal", "lei", "8078", 1990)
+_LRF_FALENCIAS = WorkKey("federal", "lei", "11101", 2005)
+_LRF_RESPONSABILIDADE = WorkKey("federal", "lei_complementar", "101", 2000)
+_CF = WorkKey("federal", "constituicao", "1988", 1988)
+
+# LRF é ambíguo: Lei 11.101/2005 (falências) vs LC 101/2000 (responsabilidade fiscal).
+LRF_CANDIDATES: tuple[WorkKey, WorkKey] = (_LRF_FALENCIAS, _LRF_RESPONSABILIDADE)
+
+# Apelidos curtos que exigem contexto normativo (art., §, inciso, do/da).
+CONTEXT_REQUIRED_ALIASES: frozenset[str] = frozenset({"cc", "cf"})
+
+ALIASES: dict[str, WorkKey] = {
+    "lei das s.a.": _LSA,
+    "lei das s.a": _LSA,
+    "lei das sa": _LSA,
+    "lsa": _LSA,
+    "lei das sociedades por acoes": _LSA,
+    "lei do mercado de capitais": _CVM_LEI,
+    "lei da cvm": _CVM_LEI,
+    "codigo civil": _CC,
+    "cc": _CC,
+    "cpc": _CPC,
+    "codigo de processo civil": _CPC,
+    "cdc": _CDC,
+    "codigo de defesa do consumidor": _CDC,
+    "lei de falencias": _LRF_FALENCIAS,
+    # "lrf" tratado à parte (ambíguo) — não entra em ALIASES unívoco
+    "lei anticorrupcao": WorkKey("federal", "lei", "12846", 2013),
+    "lgpd": WorkKey("federal", "lei", "13709", 2018),
+    "marco da securitizacao": WorkKey("federal", "lei", "14430", 2022),
+    "lei de arbitragem": WorkKey("federal", "lei", "9307", 1996),
+    "constituicao": _CF,
+    "cf": _CF,
+    "cf/88": _CF,
+    "adct": _CF,
+    "ato das disposicoes constitucionais transitorias": _CF,
+    "constituicao federal": _CF,
+}
+
+# Formas de superfície (com e sem acento) para regex de extração.
+ALIAS_SURFACES: list[tuple[str, WorkKey]] = [
+    ("Lei das Sociedades por Ações", _LSA),
+    ("Lei das Sociedades por Acoes", _LSA),
+    ("Lei das S.A.", _LSA),
+    ("Lei das S.A", _LSA),
+    ("LSA", _LSA),
+    ("Lei do Mercado de Capitais", _CVM_LEI),
+    ("Lei da CVM", _CVM_LEI),
+    ("Código Civil", _CC),
+    ("Codigo Civil", _CC),
+    ("CC", _CC),
+    ("Código de Processo Civil", _CPC),
+    ("Codigo de Processo Civil", _CPC),
+    ("CPC", _CPC),
+    ("Código de Defesa do Consumidor", _CDC),
+    ("Codigo de Defesa do Consumidor", _CDC),
+    ("CDC", _CDC),
+    ("Lei de Falências", _LRF_FALENCIAS),
+    ("Lei de Falencias", _LRF_FALENCIAS),
+    ("Lei de Recuperação e Falências", _LRF_FALENCIAS),
+    ("Lei de Recuperacao e Falencias", _LRF_FALENCIAS),
+    ("Lei de Recuperação Judicial e Falências", _LRF_FALENCIAS),
+    ("Lei de Recuperacao Judicial e Falencias", _LRF_FALENCIAS),
+    ("Lei de Recuperação de Empresas e Falências", _LRF_FALENCIAS),
+    ("LRF", _LRF_FALENCIAS),  # ambiguidade resolvida em citation.extract
+    ("Lei Anticorrupção", WorkKey("federal", "lei", "12846", 2013)),
+    ("Lei Anticorrupcao", WorkKey("federal", "lei", "12846", 2013)),
+    ("LGPD", WorkKey("federal", "lei", "13709", 2018)),
+    ("Marco da Securitização", WorkKey("federal", "lei", "14430", 2022)),
+    ("Marco da Securitizacao", WorkKey("federal", "lei", "14430", 2022)),
+    ("Lei de Arbitragem", WorkKey("federal", "lei", "9307", 1996)),
+    ("Constituição Federal", _CF),
+    ("Constituicao Federal", _CF),
+    ("Constituição", _CF),
+    ("Constituicao", _CF),
+    ("Ato das Disposições Constitucionais Transitórias", _CF),
+    ("Ato das Disposicoes Constitucionais Transitorias", _CF),
+    ("ADCT", _CF),
+    ("CF/88", _CF),
+    ("CF", _CF),
+]
+
+
+def fold_alias(text: str) -> str:
+    """Normaliza texto para busca em ALIASES (minúsculas, sem diacríticos)."""
+    import unicodedata
+
+    nfkd = unicodedata.normalize("NFKD", text)
+    bare = "".join(c for c in nfkd if not unicodedata.combining(c))
+    return " ".join(bare.lower().split())
+
+
+def lookup_alias(text: str) -> WorkKey | None:
+    key = fold_alias(text)
+    if key == "lrf":
+        return None  # ambíguo — ver lookup_lrf / citation
+    return ALIASES.get(key)
+
+
+def lookup_lrf(text: str, surrounding: str | None = None) -> list[WorkKey]:
+    """Resolve LRF: se o entorno explicita a lei, devolve só ela; senão ambas."""
+    ctx = surrounding or text
+    folded = fold_alias(ctx)
+    # LC 101 / Lei Complementar 101 / responsabilidade fiscal
+    if re_search_lc101(folded) or "responsabilidade fiscal" in folded:
+        return [_LRF_RESPONSABILIDADE]
+    # Lei 11.101 / falências
+    if (
+        "11.101" in ctx
+        or "11101" in folded.replace(".", "")
+        or "falenc" in folded
+        or "recuperacao judicial" in folded
+        or "recuperação judicial" in fold_alias(ctx)
+    ):
+        return [_LRF_FALENCIAS]
+    return list(LRF_CANDIDATES)
+
+
+def re_search_lc101(folded: str) -> bool:
+    import re
+
+    return bool(
+        re.search(
+            r"\b(?:lc|lei\s+complementar)\s*(?:n[º°o.]?\s*)?101\b",
+            folded,
+            re.I,
+        )
+    )

freoa_verifica/authority.py

@@ -0,0 +1,213 @@
+"""Atributos verificáveis de autoridade e rótulo A–E (regra pública)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+RULES_VERSION = "autoridade-1"
+
+# Espécies reconhecidas (forma canônica).
+SPECIES = frozenset(
+    {
+        "sumula_vinculante",
+        "controle_concentrado",
+        "repercussao_geral",
+        "repetitivo",
+        "irdr_iac",
+        "sumula",
+        "orgao_cupula",
+        "acordao",
+        "monocratica",
+        "administrativa",
+        "informativo",
+    }
+)
+
+# Órgãos de cúpula / colegiados superiores (rótulo C) — só judiciais.
+CUPULA_ORGANS = frozenset(
+    {
+        "pleno",
+        "plenario",
+        "tribunal pleno",
+        "corte especial",
+        "secao",
+        "primeira secao",
+        "segunda secao",
+        "terceira secao",
+        "orgao especial",
+    }
+)
+
+CONTROLE_CLASSES = frozenset({"adi", "adc", "adpf", "ado"})
+
+# Cortes administrativas: nunca promovidas por órgão de cúpula.
+_ADMIN_COURTS = frozenset({"CVM", "TCU", "BCB", "CMN"})
+
+_SPECIES_ALIASES: dict[str, str] = {
+    "acordao": "acordao",
+    "acordaos": "acordao",
+    "monocratica": "monocratica",
+    "decisao monocratica": "monocratica",
+    "decisoes monocraticas": "monocratica",
+    "administrativa": "administrativa",
+    "controle concentrado": "controle_concentrado",
+    "controle_concentrado": "controle_concentrado",
+    "repercussao geral": "repercussao_geral",
+    "repercussao_geral": "repercussao_geral",
+    "repetitivo": "repetitivo",
+    "tema repetitivo": "repetitivo",
+    "irdr": "irdr_iac",
+    "iac": "irdr_iac",
+    "irdr_iac": "irdr_iac",
+    "irdr/iac": "irdr_iac",
+    "sumula": "sumula",
+    "sumula vinculante": "sumula_vinculante",
+    "sumula_vinculante": "sumula_vinculante",
+    "orgao_cupula": "orgao_cupula",
+    "informativo": "informativo",
+}
+
+
+@dataclass(frozen=True)
+class AuthorityAttributes:
+    species: str
+    court: str
+    organ: str | None = None
+    class_name: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.species not in SPECIES:
+            raise ValueError(f"espécie desconhecida: {self.species}")
+
+
+@dataclass(frozen=True)
+class AuthorityLabel:
+    label: str  # A..E
+    rule: str
+    attributes: AuthorityAttributes
+    rules_version: str = RULES_VERSION
+
+
+def normalize_species(species: str) -> str:
+    """Normaliza espécie (acórdão/ACÓRDÃO/Acordao → acordao)."""
+    key = _norm(species)
+    if key in _SPECIES_ALIASES:
+        return _SPECIES_ALIASES[key]
+    # remove underscores duplicados / espaços já tratados por _norm
+    compact = key.replace(" ", "_")
+    if compact in SPECIES:
+        return compact
+    if compact in _SPECIES_ALIASES:
+        return _SPECIES_ALIASES[compact]
+    raise ValueError(f"espécie desconhecida: {species}")
+
+
+def classify_authority(
+    *,
+    species: str,
+    court: str,
+    organ: str | None = None,
+    class_name: str | None = None,
+) -> AuthorityLabel:
+    """Deriva rótulo A–E e devolve sempre atributos + regra aplicada."""
+    species_n = normalize_species(species)
+    # Preserva grafia comprovada do órgão (ex.: Plenário), só normaliza internamente.
+    attrs = AuthorityAttributes(
+        species=species_n,
+        court=(court or "").strip().upper(),
+        organ=organ,
+        class_name=class_name,
+    )
+    label, rule = _derive(attrs)
+    return AuthorityLabel(label=label, rule=rule, attributes=attrs)
+
+
+def _derive(attrs: AuthorityAttributes) -> tuple[str, str]:
+    species = attrs.species
+    court = attrs.court
+    organ_norm = _norm(attrs.organ)
+    class_norm = _norm(attrs.class_name)
+
+    # Exclusões antes de qualquer promoção (monocrática / administrativa).
+    if species == "monocratica":
+        return "E", "especie=monocratica"
+    if species == "administrativa" or court in _ADMIN_COURTS:
+        return "E", "administrativa_ou_corte_administrativa"
+
+    # A — súmula vinculante; ADI/ADC/ADPF colegiados; súmulas STF/STJ
+    if species == "sumula_vinculante":
+        return "A", "especie=sumula_vinculante"
+    if species == "controle_concentrado" or class_norm in CONTROLE_CLASSES:
+        return "A", "controle_concentrado_ou_classe_adi_adc_adpf"
+    if species == "sumula" and court in {"STF", "STJ"}:
+        return "A", f"sumula_{court.lower()}"
+
+    # B — tema RG, repetitivo, IRDR/IAC
+    if species == "repercussao_geral":
+        return "B", "especie=repercussao_geral"
+    if species == "repetitivo":
+        return "B", "especie=repetitivo"
+    if species == "irdr_iac":
+        return "B", "especie=irdr_iac"
+
+    # C — Pleno / Corte Especial / Seções / Órgão Especial (judiciais)
+    if species == "orgao_cupula" or _is_cupula(organ_norm):
+        return "C", "orgao_cupula_ou_colegiado_superior"
+
+    # D — acórdão de turma/câmara (padrão residual de julgamento colegiado)
+    if species in {"acordao", "informativo"}:
+        return "D", "acordao_turma_camara_ou_equivalente"
+
+    return "E", "residual_especie_" + species
+
+
+def _norm(value: str | None) -> str:
+    if not value:
+        return ""
+    return (
+        value.strip()
+        .lower()
+        .replace("á", "a")
+        .replace("ã", "a")
+        .replace("à", "a")
+        .replace("é", "e")
+        .replace("ê", "e")
+        .replace("í", "i")
+        .replace("ó", "o")
+        .replace("ô", "o")
+        .replace("õ", "o")
+        .replace("ú", "u")
+        .replace("ç", "c")
+    )
+
+
+def _is_cupula(organ_norm: str) -> bool:
+    if not organ_norm:
+        return False
+    if organ_norm in CUPULA_ORGANS:
+        return True
+    return any(
+        token in organ_norm
+        for token in (
+            "pleno",
+            "plenario",
+            "corte especial",
+            "orgao especial",
+            "secao",
+        )
+    )
+
+
+def as_dict(label: AuthorityLabel) -> dict[str, Any]:
+    return {
+        "label": label.label,
+        "rule": label.rule,
+        "rules_version": label.rules_version,
+        "attributes": {
+            "species": label.attributes.species,
+            "court": label.attributes.court,
+            "organ": label.attributes.organ,
+            "class_name": label.attributes.class_name,
+        },
+    }