sud-cli 0.1.1__py3-none-any.whl

sud_cli/__init__.py

@@ -0,0 +1,3 @@
+"""sud-cli — native offline court timeline and NPA tooling."""
+
+__version__ = "0.1.1"

sud_cli/__main__.py

@@ -0,0 +1,4 @@
+from sud_cli.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

sud_cli/_wm.py

@@ -0,0 +1,118 @@
+"""Варианты представления вывода (render styles).
+
+Выбор функционально эквивалентных формулировок; seed — из env; чисто локально, без сети; вывод семантически идентичен."""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import os
+
+_ENV_SEED = "SUD_BUILD_SEED"
+_ENV_SECRET = "SUD_BUILD_SECRET"
+
+# вариантные столбцы: кортежи эквивалентных формулировок (смысл/числа неизменны)
+STYLE_VARIANTS: dict[str, tuple[str, ...]] = {
+    "status_hint": (
+        "sud не утверждает жизненный статус нормы/акта без источника: проверьте "
+        "актуальность через Camofox/egress прогон или manual_review; verdict=unknown "
+        "означает отсутствие локальной записи, а не подтверждённое действие",
+        "без источника sud не выдаёт суждение о жизненном статусе нормы/акта: сверьте "
+        "актуальность Camofox/egress прогоном или manual_review; verdict=unknown — это "
+        "отсутствие локальной записи, а не подтверждение действия",
+        "sud не присваивает норме/акту жизненный статус без источника: актуальность "
+        "проверяется Camofox/egress прогоном либо manual_review; verdict=unknown значит "
+        "нет локальной записи, а не то, что действие подтверждено",
+    ),
+    "egrul_basis": (
+        "справочная карточка из открытых данных ФНС (ст. 6 129-ФЗ)",
+        "карточка справок сформирована из открытых сведений ФНС (ст. 6 129-ФЗ)",
+        "основа карточки — открытые данные ФНС согласно ст. 6 129-ФЗ",
+    ),
+    "fssp_captcha": (
+        "капчу всегда решает человек; авто-решение капчи запрещено политикой",
+        "капча — только человек; автоматическое решение капчи политикой запрещено",
+        "политика запрещает авто-решение капчи: капчу проходит человек",
+    ),
+    "fees_basis": (
+        "расчёт по действующему тарифу; итоговую сумму проверяет человек",
+        "сумма посчитана по текущему тарифу; окончательную сумму подтверждает человек",
+        "база расчёта — актуальный тариф; финальную цифру утверждает человек",
+    ),
+    "deadline_basis": (
+        "сроки исчисляются по процессуальному кодексу; календарные проверки — на человеке",
+        "расчёт срока идёт по нормам кодекса; финальную календарную сверку делает человек",
+        "процессуальный срок считается по кодексу; календарь итогово проверяет человек",
+    ),
+    "npa_source": (
+        "тексты норм — из официальных публикаций; перепроверка остаётся за юристом",
+        "нормы взяты из официальных источников публикации; финальную сверку делает юрист",
+        "основа текстов норм — официальные публикации; за перепроверкой остаётся юрист",
+    ),
+}
+
+
+def _seed(version: str) -> bytes:
+    s = (os.environ.get(_ENV_SEED) or "").strip()
+    return (s or f"public|{version}").encode("utf-8")
+
+
+def variant(key: str, version: str, *, default_idx: int | None = None) -> int:
+    """Индекс варианта для (key, seed, version). Детерминированно, без сети."""
+    table = STYLE_VARIANTS.get(key)
+    if not table:
+        return 0
+    if default_idx is not None and 0 <= default_idx < len(table):
+        return default_idx
+    h = hmac.new(_seed(version), key.encode("utf-8"), hashlib.sha256).digest()
+    return h[0] % len(table)
+
+
+def render_line(key: str, version: str, mapping: dict | None = None) -> str:
+    tpl = STYLE_VARIANTS[key][variant(key, version)]
+    if mapping:
+        for k, v in mapping.items():
+            tpl = tpl.replace("{" + k + "}", str(v))
+    return tpl
+
+
+def variant_seed() -> str:
+    """Режим сборки (не раскрывает значение seed)."""
+    s = (os.environ.get(_ENV_SEED) or "").strip()
+    if not s:
+        return "public"
+    return "client:" + hashlib.sha256(s.encode()).hexdigest()[:8]
+
+
+def build_flags(version: str) -> list[str]:
+    """HMAC-канарейки сборки; без секрета — пустой список (не выдумываем значения)."""
+    secret = (os.environ.get(_ENV_SECRET) or "").strip()
+    if not secret:
+        return []
+    out = []
+    for i in range(3):
+        d = hmac.new(secret.encode(), f"{version}|{i}".encode(), hashlib.sha256).hexdigest()
+        out.append(d[:16])
+    return out
+
+
+# ---- §13 интерфейс ---------------------------------------------------------
+LICENSE = "AGPL-3.0-only"
+
+
+def source_url() -> str | None:
+    return (os.environ.get("SUD_SOURCE_URL") or "").strip() or None
+
+
+def source_info(version: str) -> dict:
+    url = source_url()
+    return {
+        "license": LICENSE,
+        "source_url": url,
+        "how_to_obtain": (f"git clone {url}" if url else
+                          "источник этой сборки: репозиторий, указанный установщиком; "
+                          "локально — pip download sud-cli --no-deps --no-binary :all:"),
+        "agpl_section_13": "каждый пользователь сетевого сервиса на этой программе имеет право "
+                           "получить её полный исходный код этой версии",
+        "build_mode": variant_seed(),
+        "version": version,
+    }

sud_cli/agenda.py

@@ -0,0 +1,90 @@
+"""W6a §1 (S-80): единый билдер «calendar agenda» для CLI и MCP.
+
+Логика cmd_calendar_agenda сюда вынесена без изменения формы
+конверта (пины v2.5.0 сверяют ключи payload), чтобы MCP-инструмент
+sud_cli_calendar_agenda не воспроизводил её второй копией — копия всегда
+расходится с оригиналом, поэтому оригинал вызывается напрямую.
+"""
+from __future__ import annotations
+
+from datetime import date as _date, timedelta
+from typing import Optional
+
+
+def agenda_payload(state_dir, days: int = 14, today: Optional[_date] = None) -> dict:
+    from sud_cli.db import get_connection, init_db, list_all_deadline_states, list_cases
+
+    init_db(state_dir)
+    conn = get_connection(state_dir)
+    try:
+        states = list_all_deadline_states(conn)
+        cases = {c["case_id"]: c for c in list_cases(conn)}
+        hearing_rows = conn.execute(
+            "SELECT * FROM events WHERE lower(event_type) LIKE '%hearing%' OR lower(event_type) LIKE '%слушани%'"
+        ).fetchall()
+        hearing_events = [dict(r) for r in hearing_rows]
+    finally:
+        conn.close()
+
+    today = today or _date.today()
+    horizon = today + timedelta(days=days)
+    items = []
+    for s in states:
+        if s.get("state") not in ("computed", "confirmed"):
+            continue
+        if not s.get("due_at"):
+            continue
+        case = cases.get(s.get("case_id"))
+        if case and case.get("status") == "closed":
+            continue
+        try:
+            due = _date.fromisoformat(str(s["due_at"])[:10])
+        except ValueError:
+            continue
+        items.append({
+            "kind": "deadline",
+            "case_id": s.get("case_id"),
+            "deadline_key": s.get("deadline_key"),
+            "due_at": s.get("due_at"),
+            "state": s.get("state"),
+            "confirmed_by": s.get("confirmed_by"),
+            "evidence_note": s.get("evidence_note"),
+        })
+    for e in hearing_events:
+        ed = e.get("event_date")
+        if not ed:
+            continue
+        try:
+            due = _date.fromisoformat(str(ed)[:10])
+        except ValueError:
+            continue
+        items.append({
+            "kind": "hearing",
+            "case_id": e.get("case_id"),
+            "event_id": e.get("event_id"),
+            "due_at": ed,
+            "state": "scheduled",
+            "title": e.get("doc_text"),
+            "confirmed_by": None,
+        })
+
+    def _due(x):
+        try:
+            return _date.fromisoformat(str(x["due_at"])[:10])
+        except Exception:
+            return today
+
+    overdue = sorted([i for i in items if _due(i) < today], key=_due)
+    upcoming = sorted([i for i in items if today <= _due(i) <= horizon], key=_due)
+    next_5 = upcoming[:5]
+    return {
+        "horizon_days": days,
+        "today": today.isoformat(),
+        "overdue": overdue,
+        "upcoming": upcoming,
+        "next_5": next_5,
+        "next": next_5,
+        "items": sorted(items, key=_due),
+        "hearings": [i for i in items if i.get("kind") == "hearing"],
+        "empty": len(items) == 0,
+    }

sud_cli/autofill.py

@@ -0,0 +1,192 @@
+"""W6a §5 (S-23): автозаполнение точек срока из текстов актов (events.doc_text).
+
+Честная модель: маркеры детерминированы (словарь ``autofill_markers.json``),
+а юридическая сила у созданной точки — нулевая до подтверждения:
+``state=computed``, ``needs_confirm=true``, basis несёт след
+``autofill:event:<id>:marker:<name>``. Подтверждённой (confirmed) autofill не
+делает никогда — решение за оператором (anti-laches контракт the wave).
+
+Ловушка cure-срока: в утверждённой deadline_matrix строки cure-срока нет,
+поэтому маркер «оставлено без движения» НЕ рождает выдуманную точку — он
+отдаётся manual_review-hint'ом (словарь ссылается только на существующие
+ключи матрицы). Сеть не вызывается; новые keys матрицы не создаются.
+
+Идемпотентность повторного запуска: строки с тем же marker_id не удваиваются
+— состояние дела переписывается только когда маркер виден впервые.
+"""
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional
+
+MARKERS_PATH = Path(__file__).with_name("autofill_markers.json")
+
+_WS_RE = re.compile(r"\s+")
+
+
+def load_markers(path: Optional[Path] = None) -> dict:
+    data = json.loads(Path(path or MARKERS_PATH).read_text(encoding="utf-8"))
+    if not isinstance(data, dict) or not isinstance(data.get("markers"), list):
+        raise ValueError("autofill dictionary malformed")
+    return data
+
+
+def normalize(text: str) -> str:
+    return _WS_RE.sub(" ", str(text or "")).strip().casefold()
+
+
+def find_markers(doc_text: str, markers: List[dict]) -> List[dict]:
+    """Маркеры, чей pattern встретился в тексте (детерминированный порядок словаря)."""
+    hay = normalize(doc_text)
+    hits = []
+    for m in markers:
+        for pat in m.get("patterns", []):
+            if normalize(pat) in hay:
+                hits.append(m)
+                break
+    return hits
+
+
+def _marker_id(event_id, marker_name: str) -> str:
+    return f"autofill:event:{event_id}:marker:{marker_name}"
+
+
+def _existing_marker_ids(states) -> set:
+    ids = set()
+    for s in states:
+        basis = s.get("basis")
+        if isinstance(basis, dict) and basis.get("marker_id"):
+            ids.add(str(basis["marker_id"]))
+        elif isinstance(basis, str) and basis.startswith("autofill:"):
+            ids.add(basis)
+    return ids
+
+
+def _parse_date(raw) -> Optional[str]:
+    if not raw:
+        return None
+    try:
+        datetime.strptime(str(raw)[:10], "%Y-%m-%d")
+    except ValueError:
+        return None
+    return str(raw)[:10]
+
+
+def autofill_case(conn, state_dir, case_id: str, event_id: Optional[str] = None,
+                  markers: Optional[dict] = None, rules: Optional[dict] = None) -> dict:
+    """Просканровать события дела и создать computed-точки по маркерам.
+
+    Возвращает payload: created / skipped (честный skip-лог) /
+    manual_review_hints (cure-маркеры без строки матрицы — точка НЕ создаётся).
+    """
+    from .deadline_matrix import INSTANCE_TO_JURISDICTION
+    from .db import (
+        get_case,
+        get_case_events,
+        insert_deadline_state,
+        list_deadline_states,
+    )
+    from .legal_deadlines import calculate_deadline
+    from .legal_engine import STATUS_OK, load_rules
+
+    dictionary = markers or load_markers()
+    rules = rules or load_rules()
+    matrix = rules.get("deadline_matrix", {}) or {}
+    cure_hint = dictionary.get("cure_hint", {})
+
+    case = get_case(conn, case_id)
+    if case is None:
+        raise ValueError(f"case not found: {case_id}")
+    instance = str(case.get("instance") or "").strip().lower()
+    target_jurisdiction = INSTANCE_TO_JURISDICTION.get(instance)
+
+    events = get_case_events(conn, case_id)
+    if event_id is not None:
+        events = [e for e in events if e.get("event_id") == event_id]
+
+    created: List[dict] = []
+    skipped: List[dict] = []
+    hints: List[dict] = []
+
+    for event in events:
+        eid = event.get("event_id")
+        hits = find_markers(event.get("doc_text") or "", dictionary["markers"])
+        if not hits:
+            skipped.append({"event_id": eid, "reason": "no_markers"})
+            continue
+        event_date = _parse_date(event.get("event_date"))
+        if event_date is None:
+            skipped.append({"event_id": eid, "reason": "event_date_unparsable",
+                            "markers": [m["name"] for m in hits]})
+            continue
+        for marker in hits:
+            name = marker["name"]
+            marker_id = _marker_id(eid, name)
+            keys = list(marker.get("deadline_keys") or [])
+            # v1.4.0 правил (внешняя проверка 2026-10-24): cure-строка есть в матрице —
+            # marker создаёт точку (due=null: duration null в строке, дата
+            # устранения назначена судом → needs_confirm). Hint остаётся только
+            # если у маркера нет ни одного ключа, присутствующего в матрице.
+            if not keys or (marker.get("cure") and not any(k in matrix for k in keys)):
+                hints.append({
+                    "event_id": eid,
+                    "marker": name,
+                    "code": cure_hint.get("code", "cure_requires_verified_matrix_row"),
+                    "hint": cure_hint.get("hint", "cure-срок требует VERIFIED строки матрицы"),
+                })
+                continue
+            if target_jurisdiction:
+                keys = [k for k in keys
+                        if (matrix.get(k) or {}).get("jurisdiction") == target_jurisdiction]
+            for key in keys:
+                if key not in matrix:
+                    skipped.append({"event_id": eid, "marker": name, "deadline_key": key,
+                                    "reason": "key_not_in_matrix"})
+                    continue
+                states = list_deadline_states(conn, case_id, key)
+                if marker_id in _existing_marker_ids(states):
+                    skipped.append({"event_id": eid, "marker": name, "deadline_key": key,
+                                    "reason": "already_autofilled"})
+                    continue
+                due_at = None
+                try:
+                    res = calculate_deadline(deadline_key=key,
+                                             event_date=datetime.strptime(event_date, "%Y-%m-%d").date(),
+                                             rules=rules)
+                    if res.status == STATUS_OK and res.deadline is not None:
+                        due_at = res.deadline.isoformat()
+                except Exception:
+                    due_at = None
+                basis = {
+                    "source": "autofill",
+                    "marker_id": marker_id,
+                    "event_id": eid,
+                    "marker": name,
+                    "event_date": event_date,
+                    "method": "autofill",
+                    "needs_confirm": True,
+                    "actor": "autofill",
+                    "ts": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+                }
+                row = insert_deadline_state(
+                    conn, case_id, key, due_at=due_at, basis=basis, state="computed",
+                    state_dir=state_dir, actor="autofill", action="autofill",
+                    before=states[-1] if states else None,
+                )
+                out = dict(row)
+                out["needs_confirm"] = True
+                created.append(out)
+
+    return {
+        "case_id": case_id,
+        "instance": instance or "unknown",
+        "events_scanned": len(events),
+        "created": created,
+        "skipped": skipped,
+        "manual_review_hints": hints,
+        "never_confirmed_note": "autofill создаёт только computed/needs_confirm; confirmed — исключительно человек (the wave).",
+        "markers_version": dictionary.get("version"),
+    }

sud_cli/autofill_markers.json

@@ -0,0 +1,56 @@
+{
+  "version": "1.1.0",
+  "source_note": "Словарь детерминированных текстовых маркеров актов (W6a S-23). deadline_keys — только существующие ключи legal_rules.json:deadline_matrix. Тексты норм здесь не хранятся и не дописываются (правило «тексты только из реестра»). v1.1.0: cure-строка as_cure_left_without_movement сериализована из VERIFIED внешняя проверка 2026-10-24 (duration=null — точка без даты, needs_confirm).",
+  "markers": [
+    {
+      "name": "left_without_movement",
+      "patterns": [
+        "оставлено без движения",
+        "оставлена без движения"
+      ],
+      "deadline_keys": [
+        "as_cure_left_without_movement"
+      ],
+      "cure": true
+    },
+    {
+      "name": "cure_period_set",
+      "patterns": [
+        "срок для устранения"
+      ],
+      "deadline_keys": [
+        "as_cure_left_without_movement"
+      ],
+      "cure": true
+    },
+    {
+      "name": "final_form_date",
+      "patterns": [
+        "изготовлено в окончательной форме",
+        "в окончательной форме"
+      ],
+      "deadline_keys": [
+        "as_appeal_decision",
+        "soyu_appeal_decision",
+        "kas_appeal_decision"
+      ],
+      "cure": false
+    },
+    {
+      "name": "act_received",
+      "patterns": [
+        "получено",
+        "получена",
+        "получен",
+        "вручена",
+        "вручено"
+      ],
+      "deadline_keys": [
+        "as_court_order_cancel",
+        "soyu_court_order_cancel",
+        "kas_court_order_cancel"
+      ],
+      "cure": false
+    }
+  ]
+}