sud-cli 0.1.1__py3-none-any.whl

sud_cli/completeness.py

@@ -0,0 +1,105 @@
+"""the wave §3 (S-71): структурный чек-лист комплектности — справка, не валиация.
+
+Границы:
+- правила живут в data/completeness_rules.json как СПИСОК СТРУКТУРНЫХ маркеров
+  по kinds (isk_apk/claim_apk/appeal_apk/hodat); файл помечен format-checklist
+  и несёт disclaimer: это НЕ юридическая проверка достаточности;
+- ни в данных, ни в выводе не бывает нормативных цитат («ст.» с номером) —
+  тесты гейтят это регуляркой по файлу и по выводу;
+- вывод всегда exit 0: чек-лист справочный; бинарный файл без извлечённого
+  текста = need-text hint, а не провал.
+"""
+import json
+from pathlib import Path
+
+RULES_PATH = Path(__file__).resolve().parent / "data" / "completeness_rules.json"
+
+#: kinds правил; синхронизированы с forms.CHECKLIST_KIND_FOR_FORM (§4).
+DEFAULT_KIND = "isk_apk"
+
+VERDICT_FULL = "структурно полный"
+VERDICT_INCOMPLETE = "структурно неполный"
+
+
+def load_rules():
+    rules = json.loads(RULES_PATH.read_text(encoding="utf-8"))
+    if rules.get("meta", {}).get("format") != "format-checklist":
+        raise ValueError("completeness_rules.json: meta.format must be format-checklist")
+    if not rules.get("meta", {}).get("disclaimer"):
+        raise ValueError("completeness_rules.json: meta.disclaimer is required")
+    return rules
+
+
+def resolve_kind(kind_arg, title, rules):
+    """kind документа: явный > совпадение в заголовке > DEFAULT_KIND.
+
+    Никакой магии угадывания: если kind не передан и не читается из title,
+    источник в выводе честно помечен 'default'.
+    """
+    kinds = rules.get("kinds", {})
+    if kind_arg:
+        if kind_arg not in kinds:
+            raise ValueError(f"unknown checklist kind: {kind_arg}")
+        return kind_arg, "explicit"
+    text = (title or "").lower()
+    for kind in kinds:
+        if kind.lower() in text:
+            return kind, "title"
+    if "апелл" in text:
+        return "appeal_apk", "title"
+    return DEFAULT_KIND, "default"
+
+
+def extract_text(path):
+    """(text|None, hint). Plain-read utf-8; бинарь/нет файла -> None + hint."""
+    p = Path(path)
+    if not p.is_file():
+        return None, "need-text: файл документа исчез с пути — список не извлечь"
+    try:
+        return p.read_text(encoding="utf-8"), None
+    except (UnicodeDecodeError, ValueError):
+        return None, ("need-text: файл не является plain-text (docx/pdf/скан) — "
+                      "сначала извлеките текст (extract-text) и добавьте его как документ")
+
+
+def evaluate(text, kind, rules):
+    """Чек-лист {маркер: found|missing}: регистронезависимый подстрочный поиск."""
+    hay = (text or "").casefold()
+    markers = rules["kinds"][kind]
+    checklist = {m: ("found" if m.casefold() in hay else "missing") for m in markers}
+    missing = [m for m, state in checklist.items() if state == "missing"]
+    return {
+        "kind": kind,
+        "checklist": checklist,
+        "missing": missing,
+        "verdict": VERDICT_INCOMPLETE if missing else VERDICT_FULL,
+    }
+
+
+def checklist_payload(doc, kind_arg, rules=None):
+    """Полный конверт команды: данные + disclaimer; found/need_text — честные флаги."""
+    rules = rules or load_rules()
+    base = {
+        "doc_id": doc.get("id") if doc else None,
+        "case_id": doc.get("case_id") if doc else None,
+        "path": doc.get("path") if doc else None,
+        "title": doc.get("title") if doc else None,
+        "disclaimer": rules["meta"]["disclaimer"],
+        "format": rules["meta"]["format"],
+    }
+    if doc is None:
+        base.update({"found": False, "need_text": False, "kind": None,
+                     "kind_source": None, "checklist": {}, "missing": [],
+                     "verdict": "документ не найден"})
+        return base
+    kind, kind_source = resolve_kind(kind_arg, doc.get("title"), rules)
+    base.update({"found": True, "kind": kind, "kind_source": kind_source})
+    text, hint = extract_text(doc.get("path"))
+    if text is None:
+        base.update({"need_text": True, "hint": hint, "checklist": {}, "missing": [],
+                     "verdict": "текст не извлечён"})
+        return base
+    base["need_text"] = False
+    base.update(evaluate(text, kind, rules))
+    base["kind"] = kind
+    return base

sud_cli/config.py

@@ -0,0 +1,20 @@
+"""Application state directory configuration."""
+
+import os
+from pathlib import Path
+
+
+ENV_VAR = "SUD_CLI_STATE_DIR"
+DEFAULT_DIR_NAME = "sud-cli"
+
+
+def get_state_dir() -> Path:
+    """Return the sud-cli state directory.
+
+    Resolution order:
+      1. SUD_CLI_STATE_DIR environment variable.
+      2. ~/.local/share/sud-cli
+    """
+    if ENV_VAR in os.environ:
+        return Path(os.environ[ENV_VAR]).expanduser().resolve()
+    return Path.home() / ".local" / "share" / DEFAULT_DIR_NAME

sud_cli/conflict.py

@@ -0,0 +1,210 @@
+"""Conflict-of-interest heuristic for sud-cli (v2.4.1).
+
+Pure local heuristic: name-exact intersection of party names across the local
+case registry. No external parties/affiliates are known, so absence of a hit
+does NOT mean absence of a conflict.
+"""
+
+from collections import defaultdict
+from typing import Any, Dict, List
+
+METHOD = "name_exact"
+COVERAGE = "local registry names only"
+DISCLAIMER = (
+    "Отсутствие совпадений не означает отсутствие конфликта: покрытие — "
+    "только имена локального реестра; внешние стороны и аффилированные лица "
+    "не охвачены. Решение остаётся за человеком (boundary IX-3)."
+)
+
+
+def normalize_name(value: Any) -> str:
+    if value is None:
+        return ""
+    text = str(value)
+    for q in ('"', "'", "«", "»", "„", "“", "”", "`"):
+        text = text.replace(q, "")
+    text = text.replace("ё", "е").replace("Ё", "Е")
+    text = " ".join(text.split())
+    return text.upper()
+
+
+# Aliases for callers that expect other names.
+normalize = normalize_name
+normalize_party = normalize_name
+
+
+def _case_id(case: Any, fallback: Any = None) -> Any:
+    if isinstance(case, dict):
+        for key in ("case_id", "id", "case_number", "number"):
+            v = case.get(key)
+            if v is not None and str(v).strip() != "":
+                return v
+    return fallback
+
+
+def _owner_key(case: Any) -> Any:
+    if not isinstance(case, dict):
+        return None
+    val = case.get("owner")
+    if val is None or str(val).strip() == "":
+        return None
+    return normalize_name(val)
+
+
+def _iter_roles(case: Any):
+    if not isinstance(case, dict):
+        return
+    for role in ("plaintiff", "defendant", "owner"):
+        val = case.get(role)
+        if val is not None and str(val).strip() != "":
+            yield normalize_name(val), role, val
+    parties = case.get("parties")
+    if isinstance(parties, dict):
+        for role, val in parties.items():
+            if val is not None and str(val).strip() != "":
+                yield normalize_name(val), str(role), val
+    elif isinstance(parties, (list, tuple)):
+        for val in parties:
+            if val is not None and str(val).strip() != "":
+                yield normalize_name(val), "party", val
+
+
+def _collect_candidate_parties(candidate: Any) -> List[str]:
+    parties: List[str] = []
+    if isinstance(candidate, dict):
+        raw = candidate.get("parties")
+        if isinstance(raw, (list, tuple)):
+            parties.extend(str(p) for p in raw)
+        elif isinstance(raw, dict):
+            parties.extend(str(v) for v in raw.values() if v is not None and str(v).strip() != "")
+        elif isinstance(raw, str):
+            parties.append(raw)
+        for key in ("plaintiff", "defendant", "party", "name", "owner"):
+            val = candidate.get(key)
+            if val is not None and str(val).strip() != "":
+                parties.append(str(val))
+    elif isinstance(candidate, (list, tuple)):
+        parties.extend(str(p) for p in candidate)
+    elif candidate is not None:
+        parties.append(str(candidate))
+    return parties
+
+
+def check(portfolio: Any, candidate: Any) -> List[Dict[str, Any]]:
+    cases = list(portfolio or [])
+    cand = candidate if isinstance(candidate, dict) else {"parties": candidate}
+    # Exclude the candidate's own case from the portfolio when identified.
+    cid = cand.get("case_id") if isinstance(cand, dict) else None
+    if cid is None and isinstance(cand, dict):
+        cid = cand.get("id")
+    if cid is not None:
+        cases = [c for c in cases if _case_id(c) != cid]
+
+    candidate_names = []
+    seen_names = set()
+    for p in _collect_candidate_parties(cand):
+        n = normalize_name(p)
+        if n and n not in seen_names:
+            seen_names.add(n)
+            candidate_names.append(n)
+
+    hits: List[Dict[str, Any]] = []
+
+    # (a) same party in cases owned by different owners
+    name_entries: Dict[str, List[Any]] = defaultdict(list)
+    for case in cases:
+        for norm, role, raw in _iter_roles(case):
+            name_entries[norm].append((case, role))
+    for name, entries in name_entries.items():
+        owners = {_owner_key(c) for c, _ in entries}
+        distinct = {o for o in owners if o is not None}
+        if len(distinct) >= 2:
+            case_ids = []
+            seen = set()
+            for case, _ in entries:
+                k = _case_id(case)
+                if k not in seen:
+                    seen.add(k)
+                    case_ids.append(k)
+            hits.append({
+                "type": "a",
+                "hit_type": "a",
+                "party": name,
+                "normalized": name,
+                "reason": "same party appears in cases owned by different owners",
+                "case_ids": case_ids,
+                "cases": case_ids,
+                "owners": sorted(distinct),
+                "method": METHOD,
+            })
+
+    # (b) adversary flip: plaintiff in one case, defendant in another, same owner
+    by_owner: Dict[Any, List[Any]] = defaultdict(list)
+    for case in cases:
+        by_owner[_owner_key(case)].append(case)
+    for owner_key, group in by_owner.items():
+        if owner_key is None:
+            continue
+        name_to_p: Dict[str, List[Any]] = defaultdict(list)
+        name_to_d: Dict[str, List[Any]] = defaultdict(list)
+        for case in group:
+            for norm, role, raw in _iter_roles(case):
+                if role == "plaintiff":
+                    name_to_p[norm].append(case)
+                elif role == "defendant":
+                    name_to_d[norm].append(case)
+        for name in name_to_p:
+            if name not in name_to_d:
+                continue
+            p_cases = name_to_p[name]
+            d_cases = name_to_d[name]
+            if not any(_case_id(pc) != _case_id(dc) for pc in p_cases for dc in d_cases):
+                continue
+            case_ids = []
+            seen = set()
+            for case in p_cases + d_cases:
+                k = _case_id(case)
+                if k not in seen:
+                    seen.add(k)
+                    case_ids.append(k)
+            hits.append({
+                "type": "b",
+                "hit_type": "b",
+                "party": name,
+                "normalized": name,
+                "reason": "party is plaintiff in one case and defendant in another within same owner portfolio",
+                "owner": owner_key,
+                "case_ids": case_ids,
+                "cases": case_ids,
+                "method": METHOD,
+            })
+
+    # (c) candidate party equals any party of any existing case
+    existing_names = set()
+    for case in cases:
+        for norm, role, raw in _iter_roles(case):
+            existing_names.add(norm)
+    for cand_name in candidate_names:
+        if cand_name not in existing_names:
+            continue
+        matched_ids = []
+        seen = set()
+        for case in cases:
+            if any(norm == cand_name for norm, role, raw in _iter_roles(case)):
+                k = _case_id(case)
+                if k not in seen:
+                    seen.add(k)
+                    matched_ids.append(k)
+        hits.append({
+            "type": "c",
+            "hit_type": "c",
+            "party": cand_name,
+            "name": cand_name,
+            "normalized": cand_name,
+            "reason": "candidate party equals a party of an existing case",
+            "case_ids": matched_ids,
+            "cases": matched_ids,
+            "method": METHOD,
+        })
+
+    return hits

sud_cli/conflicts.py

@@ -0,0 +1,207 @@
+"""the wave §3 (S-27): конфликты расписания — слушания × сроки по разным делам.
+
+Границы:
+- набор event_type фиксирован (HEARING_EVENT_TYPES) и сравнивается без
+  регистра: «угадывать» по подстроке, что событие является заседанием, движок
+  не имеет права — недописанный тип остаётся вне детекта, а не внутри;
+- conflict = пересечение НА ОДНУ ДАТУ событий/сроков по РАЗНЫМ делам;
+- то же дело, срок + слушание в один день = НЕ конфликт, а подсказка
+  (same_case_hints): физически это один и тот же участник, два события в
+  один день — напоминание, а не коллизия;
+- невалидные даты не валят команду: строка уходит в skipped с причиной;
+- списки пустые выводятся явно []; порядок детерминирован.
+"""
+from __future__ import annotations
+
+from datetime import date as _date, timedelta
+from typing import Any, Dict, List, Optional
+
+#: Фиксированный набор типов слушаний (ниже — только точное сравнение lower()).
+HEARING_EVENT_TYPES = frozenset({"слушание", "заседание", "предварительное"})
+
+#: Сроки, участвующие в детекте: только вычисленные и подтверждённые.
+DEADLINE_STATES = ("computed", "confirmed")
+
+CONFLICTS_DISCLAIMER = (
+    "Детект справочный: он видит только слушания с event_type из фиксированного "
+    "набора {слушание, заседание, предварительное} и сроки computed|confirmed "
+    "локального реестра. Отсутствие пересечений не означает, что их нет: "
+    "командировки, несколько процессов у одного лица и время на дорогу не "
+    "покрыты данными. Решение — за человеком."
+)
+
+
+def _parse_date(raw: Any) -> Optional[_date]:
+    if raw is None or str(raw) == "":
+        return None
+    try:
+        return _date.fromisoformat(str(raw)[:10])
+    except ValueError:
+        return None
+
+
+def _latest_per_key(states: List[dict]) -> List[dict]:
+    """Последнее состояние на пару (case_id, deadline_key).
+
+    Не вторая копия логики: тот же хелпер, что у reminders (the wave) — копия
+    окна/истории расходится с оригиналом при первой же правке.
+    """
+    from .reminders import _latest_per_key as latest
+
+    return latest(states)
+
+
+def collect_entries(conn, window_from: _date, window_to: _date):
+    """Записи расписания в окне: слушания (фикс. набор типов) + сроки.
+
+    Возвращает (entries, skipped). entry = {kind, case_id, ref, on_date, label}.
+    """
+    entries: List[dict] = []
+    skipped: List[dict] = []
+
+    for row in conn.execute("SELECT * FROM events ORDER BY event_id ASC").fetchall():
+        ev = dict(row)
+        etype = ("" if ev.get("event_type") is None else str(ev["event_type"]).strip().lower())
+        if etype not in HEARING_EVENT_TYPES:
+            continue
+        day = _parse_date(ev.get("event_date"))
+        if day is None:
+            skipped.append({
+                "kind": "hearing",
+                "case_id": ev.get("case_id"),
+                "ref": ev.get("event_id"),
+                "reason": f"нечитаемая дата события: {ev.get('event_date')!r}",
+            })
+            continue
+        if not (window_from <= day <= window_to):
+            continue
+        entries.append({
+            "kind": "hearing",
+            "case_id": ev.get("case_id"),
+            "ref": ev.get("event_id"),
+            "event_type": ev.get("event_type"),
+            "on_date": day.isoformat(),
+            "label": ev.get("doc_text"),
+        })
+
+    from .db import list_all_deadline_states
+
+    for s in _latest_per_key(list_all_deadline_states(conn)):
+        if s.get("state") not in DEADLINE_STATES:
+            continue
+        day = _parse_date(s.get("due_at"))
+        if day is None:
+            if s.get("due_at"):
+                skipped.append({
+                    "kind": "deadline",
+                    "case_id": s.get("case_id"),
+                    "ref": s.get("deadline_key"),
+                    "reason": f"нечитаемая due_at: {s.get('due_at')!r}",
+                })
+            continue
+        if not (window_from <= day <= window_to):
+            continue
+        entries.append({
+            "kind": "deadline",
+            "case_id": s.get("case_id"),
+            "ref": s.get("deadline_key"),
+            "state": s.get("state"),
+            "on_date": day.isoformat(),
+            "label": s.get("deadline_key"),
+        })
+
+    entries.sort(key=lambda e: (e["on_date"], str(e["case_id"]), e["kind"], str(e["ref"])))
+    skipped.sort(key=lambda e: (str(e["case_id"]), str(e["ref"])))
+    return entries, skipped
+
+
+def pair_conflicts(entries: List[dict]) -> List[dict]:
+    """Конфликты: одна дата, разные дела. Пары дел — без дублей и без повторов."""
+    by_day: Dict[str, List[dict]] = {}
+    for e in entries:
+        by_day.setdefault(e["on_date"], []).append(e)
+    conflicts: List[dict] = []
+    for day in sorted(by_day):
+        items = by_day[day]
+        pairs: Dict[tuple, dict] = {}
+        for i in range(len(items)):
+            for j in range(i + 1, len(items)):
+                a, b = items[i], items[j]
+                if a["case_id"] == b["case_id"]:
+                    continue
+                case_a, case_b = sorted([str(a["case_id"]), str(b["case_id"])])
+                pk = (day, case_a, case_b)
+                rec = pairs.setdefault(pk, {
+                    "date": day,
+                    "case_a": case_a,
+                    "case_b": case_b,
+                    "entries": [],
+                })
+                for e in (a, b):
+                    token = (e["kind"], str(e["case_id"]), str(e["ref"]))
+                    if token not in [tuple(x.get("_k", [])) for x in rec["entries"]]:
+                        rec["entries"].append({
+                            "_k": list(token),
+                            "case_id": e["case_id"],
+                            "kind": e["kind"],
+                            "ref": e["ref"],
+                            "detail": e.get("event_type") or e.get("state"),
+                        })
+        for rec in sorted(pairs.values(), key=lambda r: (r["date"], r["case_a"], r["case_b"])):
+            conflicts.append({
+                "date": rec["date"],
+                "case_a": rec["case_a"],
+                "case_b": rec["case_b"],
+                "kinds": sorted({e["kind"] for e in rec["entries"]}),
+                "entries": [
+                    {k: v for k, v in e.items() if k != "_k"} for e in rec["entries"]
+                ],
+            })
+    return conflicts
+
+
+def same_case_hints(entries: List[dict]) -> List[dict]:
+    """Подсказки: тот же день, то же дело, срок + слушание (не конфликт)."""
+    by_day_case: Dict[tuple, List[dict]] = {}
+    for e in entries:
+        by_day_case.setdefault((e["on_date"], str(e["case_id"])), []).append(e)
+    hints = []
+    for (day, case_id) in sorted(by_day_case):
+        items = by_day_case[(day, case_id)]
+        kinds = {i["kind"] for i in items}
+        if "hearing" in kinds and "deadline" in kinds:
+            hints.append({
+                "date": day,
+                "case_id": case_id,
+                "hearings": [i["ref"] for i in items if i["kind"] == "hearing"],
+                "deadlines": [i["ref"] for i in items if i["kind"] == "deadline"],
+                "note": "срок и слушание одного дела в один день — это "
+                        "подсказка, а не конфликт разных дел",
+            })
+    return hints
+
+
+def conflicts_payload(state_dir: Any, days: int = 30,
+                      today: Optional[_date] = None) -> Dict[str, Any]:
+    from .db import get_connection, init_db
+
+    init_db(state_dir)
+    conn = get_connection(state_dir)
+    try:
+        today = today or _date.today()
+        horizon = today + timedelta(days=days)
+        entries, skipped = collect_entries(conn, today, horizon)
+    finally:
+        conn.close()
+    return {
+        "days": days,
+        "today": today.isoformat(),
+        "window_to": horizon.isoformat(),
+        "hearing_event_types": sorted(HEARING_EVENT_TYPES),
+        "entries": entries,
+        "conflicts": pair_conflicts(entries),
+        "same_case_hints": same_case_hints(entries),
+        "skipped": skipped,
+        "empty": not entries,
+        "disclaimer": CONFLICTS_DISCLAIMER,
+    }