sud-cli 0.1.1__py3-none-any.whl

sud_cli/pretrial.py

@@ -0,0 +1,151 @@
+"""Pretrial (claim) helper for sud-cli (v2.6.0).
+
+Pure read of sud_cli/jurisdiction_rules.json. Calendar arithmetic via
+production_calendar/holidays_rf.
+"""
+import json
+from datetime import date, timedelta
+from pathlib import Path
+
+RULES_PATH = Path(__file__).with_name("jurisdiction_rules.json")
+
+CODE_TO_KEY = {"apk": "APK_30d", "zozpp": "ZOZPP_10d", "osago": "OSAGO_30d"}
+CHARTER_CODES = {
+    "railway": "railway_ujt", "ujt": "railway_ujt",
+    "road": "road_uat", "uat": "road_uat",
+    "maritime": "maritime_ktm", "ktm": "maritime_ktm",
+    "inland": "inland_water_kvvt", "kvvt": "inland_water_kvvt",
+    "air": "air_code_vk", "vk": "air_code_vk",
+    "freight": "freight_forwarding", "expedition": "freight_forwarding",
+    "postal": "postal",
+}
+
+
+def load_rules(path=None):
+    return json.loads(Path(path or RULES_PATH).read_text(encoding="utf-8"))
+
+
+def _shift_to_working(day):
+    from .production_calendar import is_working_day
+    cur = day
+    while not is_working_day(cur):
+        cur = cur + timedelta(days=1)
+    return cur
+
+
+def calc_pretrial(code, sent, rules=None):
+    rules = rules or load_rules()
+    key = CODE_TO_KEY.get(str(code).lower())
+    mode = str(code).lower()
+    if mode in CHARTER_CODES:
+        key = CHARTER_CODES[mode]
+        rule = rules["pretrial"].get("charters_transport", {}).get(key, {})
+        if not rule:
+            return {"code": mode, "error": "charter_rule_absent",
+                    "warnings": ["нет записи в VERIFIED rules — manual_review"]}
+    else:
+        rule = rules["pretrial"].get(CODE_TO_KEY.get(mode, ""), {})
+    days = int(rule.get("days", 0))
+    sent_d = date.fromisoformat(sent) if isinstance(sent, str) else sent
+    base_due = sent_d + timedelta(days=days)
+    exclude = bool(rule.get("exclude_nonworking_holidays"))
+    if exclude:
+        due = _shift_to_working(base_due)
+    else:
+        due = base_due
+    right_to_sue = due
+    # VERIFIED charter-нормы (юридическая проверка 2026.10.24): postal — manual_review (30/5), остальные hard
+    mr = []
+    if rule.get("confidence") == "manual_review" or rule.get("status") == "NOT_SERIALIZED_NEEDS_TEXT":
+        mr.append({"reason": rule.get("confidence", "manual_review"),
+                   "norm": rule.get("norms") or rule.get("norm", ""),
+                   "scope": rule.get("scope", "")})
+    warnings = ["disclaimer: " + rules.get("disclaimer", "")]
+    payload = {
+        "code": str(code).lower(),
+        "rule": key,
+        "norm": rule.get("norm") or rule.get("norms", ""),
+        "sent": sent_d.isoformat(),
+        "sent_date": sent_d.isoformat(),
+        "days": days,
+        "calendar": bool(rule.get("calendar", True)),
+        "exclude_nonworking_holidays": exclude,
+        "response_deadline": due.isoformat(),
+        "response_deadline_date": due.isoformat(),
+        "answer_deadline": due.isoformat(),
+        "deadline": due.isoformat(),
+        "deadline_date": due.isoformat(),
+        "due_date": due.isoformat(),
+        "due": due.isoformat(),
+        "right_to_sue_date": right_to_sue.isoformat(),
+        "right_to_sue": right_to_sue.isoformat(),
+        "right_to_claim_date": right_to_sue.isoformat(),
+        "right_to_claim": right_to_sue.isoformat(),
+        "sue_date": right_to_sue.isoformat(),
+        "claim_date": right_to_sue.isoformat(),
+        "warnings": warnings,
+        "manual_review": mr,
+        "disclaimer": rules.get("disclaimer", ""),
+    }
+    return payload
+
+
+def consequences(code, stage, rules=None):
+    rules = rules or load_rules()
+    code_u = str(code).upper()
+    cons = rules["consequences_noncompliance"]
+    stage_map = {
+        "filing": "return_at_filing",
+        "trial": "left_without_consideration",
+        "movement": "left_without_movement",
+    }
+    cons_key = stage_map.get(str(stage).lower(), str(stage).lower())
+
+    norms = {}
+    for k, v in cons.items():
+        if k == "confidence":
+            continue
+        if isinstance(v, dict) and code_u in v:
+            norms[k] = v[code_u]
+
+    selected = cons.get(cons_key, {})
+    selected_norm = None
+    basis = None
+    confidence = "hard"
+    if isinstance(selected, dict) and code_u in selected:
+        selected_val = selected[code_u]
+        if isinstance(selected_val, dict):
+            selected_norm = selected_val.get("norm", selected_val)
+            basis = selected_val.get("basis")
+        else:
+            selected_norm = selected_val
+        confidence = selected.get("confidence", confidence)
+    elif isinstance(selected, dict):
+        selected_norm = None
+        basis = None
+        confidence = selected.get("confidence", confidence)
+    else:
+        selected_norm = selected
+
+    lwm_full = cons.get("left_without_movement", {}).get(code_u)
+    if isinstance(lwm_full, dict):
+        norms["left_without_movement"] = lwm_full
+
+    out = {
+        "code": str(code).lower(),
+        "stage": str(stage).lower(),
+        "consequence": cons_key,
+        "norm": selected_norm,
+        "norms": norms,
+        "return_at_filing": norms.get("return_at_filing"),
+        "left_without_consideration": norms.get("left_without_consideration"),
+        "left_without_movement": lwm_full if isinstance(lwm_full, dict) else norms.get("left_without_movement"),
+        "confidence": confidence,
+        "disclaimer": rules.get("disclaimer", ""),
+        "warnings": [rules.get("disclaimer", "")],
+    }
+    if basis:
+        out["basis"] = basis
+    if isinstance(lwm_full, dict) and "basis" in lwm_full and "basis" not in out and cons_key == "left_without_movement":
+        out["basis"] = lwm_full["basis"]
+    return out

sud_cli/production_calendar.py

@@ -0,0 +1,233 @@
+"""Production calendar for federal deadlines (addendum 1.1.0, п. Б2).
+
+The calendar carries three layers, and each is recorded with its own legal
+source so a reader can tell how much of the answer is statute and how much is
+decree:
+
+* **ст. 112 ТК РФ** — the fixed federal non-working holidays. These repeat every
+  year, so a year with no calendar entry still gets them.
+* **ч. 2 ст. 112 ТК РФ** — automatic moves. A holiday landing on a weekend moves
+  to the next working day on its own, except for the holidays named in абз. 2
+  and 3 (1–8 января, 23 февраля), where only the Government may move the day off.
+* **Постановления Правительства РФ** — the yearly transfer decrees.
+
+The transfer decrees used to be absent here: they are published per-year and no
+verified copy was supplied, and transcribing a calendar from memory would be a
+silent legal guess inside a deadline calculator. The 2026 decree is now encoded
+because it was verified against the official portal scan (№ 1466 от 24.09.2025,
+publication N 0001202509240023). 2026 is the only verified year, so the
+``CALENDAR_WARNING`` is now **per-year** rather than global: a deadline landing in
+a year whose decree is encoded carries a note saying so, and every other year
+still carries the full warning. Failing a year loudly is the point — the tool
+says what it does not know instead of pretending.
+"""
+
+import json
+from datetime import date, timedelta
+from functools import lru_cache
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+from .regional_holidays import holidays_for_year as regional_holidays, normalize_region, region_name
+
+CALENDAR_PATH = Path(__file__).with_name("holidays_rf.json")
+TRANSFERS_PATH = Path(__file__).with_name("government_transfers.json")
+
+REGIONAL_NOTE = (
+    "Региональные нерабочие праздничные дни субъектов РФ не учитываются."
+)
+
+
+class CalendarError(Exception):
+    """The calendar file is missing or structurally invalid."""
+
+
+@lru_cache(maxsize=1)
+def load_calendar(path: Optional[str] = None) -> dict:
+    target = Path(path) if path else CALENDAR_PATH
+    try:
+        data = json.loads(target.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise CalendarError(f"cannot load production calendar: {exc}") from exc
+    if "federal_holidays" not in data:
+        raise CalendarError("production calendar missing federal_holidays")
+    return data
+
+
+def _parse(token: str, year: int) -> date:
+    month, day = (int(part) for part in token.split("-"))
+    return date(year, month, day)
+
+
+@lru_cache(maxsize=1)
+def _holiday_index(calendar_path: Optional[str] = None) -> Dict[int, Set[date]]:
+    data = load_calendar(calendar_path)
+    index: Dict[int, Set[date]] = {}
+    for year, days in data["federal_holidays"].items():
+        index[int(year)] = {_parse(token, int(year)) for token in days}
+    return index
+
+
+def _statutory_pattern(calendar_path: Optional[str] = None) -> List[str]:
+    """The ст. 112 ТК РФ day pattern, taken from any populated year.
+
+    The statutory dates repeat annually, so they are used as the fallback for a
+    year that has no calendar entry. Only the fixed holidays are used; the
+    automatic weekend moves are applied separately by ``holidays_for_year``.
+    """
+    data = load_calendar(calendar_path)
+    for days in data["federal_holidays"].values():
+        return list(days)
+    raise CalendarError("production calendar has no years to copy the pattern from")
+
+
+def holidays_for_year(year: int, calendar_path: Optional[str] = None, region=None) -> Set[date]:
+    """Every federal non-working day in ``year``.
+
+    This is the union of the ст. 112 ТК РФ holidays and any day the Government
+    declared a day off by decree. Days moved *out* of a holiday by a decree are
+    not representable in a set of non-working days; that is why
+    ``days_restored_to_working`` is applied by :func:`is_working_day` rather
+    than here.
+    """
+    index = _holiday_index(calendar_path)
+    base = index.get(year) or {_parse(token, year) for token in _statutory_pattern(calendar_path)}
+    transfer = load_calendar(calendar_path).get("transfers", {}).get(str(year), {})
+    # ч. 2 ст. 112 ТК РФ: a holiday landing on a weekend moves to the next working
+    # day on its own. These are derived from the statute, not from the decree, and
+    # are recorded per-year because the set depends on which weekdays that year
+    # happens to start on.
+    cases = load_calendar(calendar_path).get("auto_transfers_st112", {}).get(str(year), [])
+    for case in cases:
+        base.add(_parse(case["moved_to"], year))
+    # v2.3.2 (sa-1 F-12): ч.2 ст.112 переносы выводятся алгоритмически для ЛЮБОГО
+    # года, а не только записанных (23.02.2025 воскресенье -> 24.02.2025 отсутствовал).
+    # Явные записи выше имеют приоритет: праздник, уже перенесённый записью, не
+    # сдвигается повторно. Не переносим: январский блок (каникулы поглощают перенос,
+    # позиция Роструда) и даты вне фиксированного statutory-списка (декретные дни).
+    _ST112_FIXED = {"02-23", "03-08", "05-01", "05-09", "06-12", "11-04"}
+    _explicit_holidays = {case.get("holiday") for case in cases}
+    derived: Set[date] = set()
+    for token in _statutory_pattern(calendar_path):
+        if token not in _ST112_FIXED or token in _explicit_holidays:
+            continue
+        h = _parse(token, year)
+        if h.weekday() < 5:
+            continue
+        cand = h + timedelta(days=1)
+        while cand.weekday() >= 5 or cand in base or cand in derived:
+            cand += timedelta(days=1)
+        derived.add(cand)
+    base |= derived
+    return (base | {_parse(token, year) for token in transfer.get("extra_days_off", [])} |
+            regional_holidays(year, region))
+
+
+def days_restored_to_working(year: int, calendar_path: Optional[str] = None) -> Set[date]:
+    """Days a decree moved a day off back onto a working day."""
+    return {
+        _parse(token, year)
+        for token in (
+            load_calendar(calendar_path)
+            .get("transfers", {})
+            .get(str(year), {})
+            .get("days_restored_to_working", [])
+        )
+    }
+
+
+def is_working_day(day: date, calendar_path: Optional[str] = None, region=None) -> bool:
+    """True when ``day`` counts as a working day for АПК/ГПК deadlines."""
+    if day in days_restored_to_working(day.year, calendar_path):
+        return True
+    if day.weekday() >= 5:
+        return False
+    return day not in holidays_for_year(day.year, calendar_path, region)
+
+
+def auto_transfers_encoded(calendar_path: Optional[str] = None) -> bool:
+    """Whether ч. 2 ст. 112 ТК РФ automatic moves are encoded for ``year``."""
+    return bool(load_calendar(calendar_path).get("auto_transfers_st112"))
+
+
+def transfers_encoded_for(year: int, calendar_path: Optional[str] = None) -> bool:
+    """Whether the Government transfer decree for ``year`` is actually encoded.
+
+    Per-year on purpose: encoding 2026 must not silence the warning for 2027.
+    """
+    data = load_calendar(calendar_path)
+    verified = data.get("years_with_verified_transfers", [])
+    return year in verified or str(year) in verified
+
+
+def calendar_warnings(year: int, calendar_path: Optional[str] = None, region=None) -> List[str]:
+    """Warnings that must accompany any deadline computed for ``year``."""
+    data = load_calendar(calendar_path)
+    warnings: List[str] = []
+    if transfers_encoded_for(year, calendar_path):
+        decree = data.get("transfers", {}).get(str(year), {}).get("decree", "не указан")
+        warnings.append(
+            data["no_warning_template"].format(year=year, decree=decree)
+        )
+        if data.get("transfers", {}).get(str(year), {}).get("amendments_found") is False:
+            warnings.append(
+                "Проверено: изменяющих актов к постановлению о переносах не найдено "
+                "(скан официального портала)."
+            )
+    else:
+        warnings.append(data["warning_template"].format(year=year))
+    if region is None:
+        warnings.append(REGIONAL_NOTE + " (укажите --region <код> при необходимости)")
+    else:
+        code = normalize_region(region)
+        warnings.append(f"Учтены региональные нерабочие праздничные дни: {region_name(code)} (код {code}).")
+    return warnings
+
+
+def unknown_years(years, calendar_path: Optional[str] = None) -> Set[int]:
+    """Years in the span that have no declared holiday set at all."""
+    index = _holiday_index(calendar_path)
+    return {y for y in years if y not in index}
+
+
+def calendar_check() -> dict:
+    """Validate the isolated transfer manifest and report its coverage."""
+    try:
+        data = json.loads(TRANSFERS_PATH.read_text(encoding="utf-8"))
+        through = int(data["verified_through"])
+        years = sorted(int(year) for year in data["years"])
+        if years != list(range(min(years), through + 1)):
+            raise CalendarError("government transfer years are not contiguous")
+        return {"status": "ok", "valid": True, "verified_through": through, "years": years, "source": data["source"]}
+    except (OSError, json.JSONDecodeError, KeyError, TypeError, ValueError, CalendarError) as exc:
+        return {"status": "error", "valid": False, "detail": str(exc)}
+
+
+def add_working_days(start: date, count: int, calendar_path: Optional[str] = None, region=None) -> date:
+    """Advance ``count`` working days per Б1 (ч. 3 + ч. 4 ст. 113 АПК РФ).
+
+    ``start`` is Day 1 — the next calendar day after the event — and it counts
+    as day 1 when it is a working day. Non-working days are skipped without
+    incrementing the counter. So a Friday event (start = Saturday) skips
+    Saturday and Sunday and returns the following Friday for ``count=3``,
+    while a Thursday event (start = Friday) counts that Friday as day 1.
+
+    Getting this off by one silently shifts every АПК deadline by a day, so the
+    distinction is asserted in tests on both a mid-week and a weekend start.
+    """
+    if count <= 0:
+        return start
+    current = start
+    counted = 0
+    while counted < count:
+        if is_working_day(current, calendar_path, region):
+            counted += 1
+            if counted == count:
+                break
+        current += timedelta(days=1)
+    return current
+
+
+def add_calendar_days(start: date, count: int) -> date:
+    """Advance ``count`` calendar days (ГПК/КАС)."""
+    return start + timedelta(days=count - 1)

sud_cli/providers.py

@@ -0,0 +1,95 @@
+"""Source/provider registry for sud-cli."""
+
+from dataclasses import dataclass
+from typing import List
+
+
+@dataclass(frozen=True)
+class Provider:
+    name: str
+    kind: str  # 'offline' | 'live'
+    status: str  # 'available' | 'unavailable' | 'blocked'
+    description: str
+
+
+REGISTRY: List[Provider] = [
+    Provider(
+        name="local-json-court",
+        kind="offline",
+        status="available",
+        description="Synthetic local JSON import for legacy court records.",
+    ),
+    Provider(
+        name="local-json-court-case",
+        kind="offline",
+        status="available",
+        description="Synthetic local JSON import for native court case/event timelines.",
+    ),
+    Provider(
+        name="local-json-npa",
+        kind="offline",
+        status="available",
+        description="Synthetic local JSON import for NPA document fixtures.",
+    ),
+    Provider(
+        name="case-search-live",
+        kind="live",
+        status="unavailable",
+        description="Live court source adapter; not implemented (Phase 3 offline-only).",
+    ),
+    Provider(
+        name="case-search-bridge",
+        kind="bridge",
+        status="available",
+        description=(
+            "Transitional read-only bridge to the case-search CLI for allowlisted "
+            "offline import/extraction commands; not a live source or parity claim."
+        ),
+    ),
+    Provider(
+        name="kad-arbitr-ru",
+        kind="live",
+        status="unavailable",
+        description=(
+            "KAD/arbitr.ru live case search; response contract is unverified "
+            "(HTML response, CAPTCHA gate, HTTP 451 probe) and no live adapter is implemented."
+        ),
+    ),
+    Provider(
+        name="pravo-gov-ru",
+        kind="live",
+        status="available",
+        description=(
+            "Official publication.pravo.gov.ru metadata-only search; "
+            "one bounded GET per invocation, HTTPS only."
+        ),
+    ),
+    Provider(
+        name="garant",
+        kind="live",
+        status="unavailable",
+        description="Commercial legal source metadata-only access; not implemented in Phase 1.",
+    ),
+    Provider(
+        name="consultantplus",
+        kind="live",
+        status="unavailable",
+        description="Commercial legal source metadata-only access; not implemented in Phase 1.",
+    ),
+    Provider(
+        name="fees-calculator",
+        kind="calculator",
+        status="blocked",
+        description="Court fee calculation; blocked in Phase 1.",
+    ),
+    Provider(
+        name="deadlines-calculator",
+        kind="calculator",
+        status="blocked",
+        description="Procedural deadline calculation; blocked in Phase 1.",
+    ),
+]
+
+
+def list_providers() -> List[Provider]:
+    return list(REGISTRY)