nedviga-cli 0.1.0__py3-none-any.whl

nedviga/feedback.py

@@ -0,0 +1,79 @@
+"""v0.5.4 (the task brief) feedback tracker."""
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+from . import pipeline
+
+
+def _connect(db=None):
+    conn = pipeline._connect(db)
+    conn.execute("""CREATE TABLE IF NOT EXISTS show_feedback (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        card_id TEXT NOT NULL,
+        verdict TEXT NOT NULL,
+        reason TEXT,
+        note TEXT,
+        created_at TEXT NOT NULL,
+        snapshot TEXT)""")
+    conn.commit()
+    return conn
+
+
+def add_feedback(card_id: str, verdict: str, reason: Optional[str] = None, note: Optional[str] = None, dry: bool = False, db=None) -> dict:
+    if dry:
+        return {"ok": True, "dry": True, "card_id": card_id, "verdict": verdict}
+    conn = _connect(db)
+    try:
+        conn.execute("INSERT INTO show_feedback (card_id, verdict, reason, note, created_at, snapshot) VALUES (?,?,?,?,?,?)",
+                     (card_id, verdict, reason, note, datetime.now(timezone.utc).isoformat(), None))
+        conn.commit()
+        return {"ok": True, "card_id": card_id, "verdict": verdict}
+    finally:
+        conn.close()
+
+
+def list_feedback(card_id: Optional[str] = None, db=None) -> list[dict]:
+    conn = _connect(db)
+    try:
+        if card_id:
+            rows = conn.execute("SELECT * FROM show_feedback WHERE card_id=? ORDER BY id", (card_id,)).fetchall()
+        else:
+            rows = conn.execute("SELECT * FROM show_feedback ORDER BY id").fetchall()
+        return [dict(r) for r in rows]
+    finally:
+        conn.close()
+
+
+def profile_aggregate(db=None) -> dict[str, Any]:
+    items = list_feedback(db=db)
+    n = len(items)
+    suggested = []
+    if n >= 5:
+        # naive: one aggregate weight
+        liked = sum(1 for x in items if x.get("verdict") == "liked")
+        rejected = sum(1 for x in items if x.get("verdict") == "rejected")
+        suggested.append({"feature": "overall", "delta": (liked - rejected) / n, "n_backing": n})
+    # features with n<5 omitted
+    return {"n_feedback": n, "suggested_weights": suggested}
+
+
+def _overrides_path() -> Path:
+    base = Path(os.environ.get("NEDVIGA_STATE_DIR", str(Path.home() / ".local" / "share" / "nedviga")))
+    return base / "profile_overrides.json"
+
+
+def apply_overrides(dry: bool = False, yes: bool = False, db=None) -> dict:
+    prof = profile_aggregate(db=db)
+    if dry:
+        return {"ok": True, "dry": True, "proposed": prof["suggested_weights"]}
+    if not yes:
+        return {"ok": False, "reason": "requires_yes"}
+    path = _overrides_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(prof["suggested_weights"], ensure_ascii=False, indent=2), encoding="utf-8")
+    return {"ok": True, "written": str(path), "overrides": prof["suggested_weights"]}

nedviga/geo_routing.py

@@ -0,0 +1,214 @@
+"""Honest walking-distance router to the nearest Moscow metro vestibule.
+
+Public OSRM demo server is used when available; otherwise the module
+falls back to a haversine estimate with an urban winding factor.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import requests
+
+from .metro_vestibules import get_vestibules
+
+OSRM_BASE_URL = "https://router.project-osrm.org/route/v1"
+OSRM_TIMEOUT_SECONDS = 15
+
+WALK_SPEED_M_PER_MIN = 80.0  # 4.8 km/h
+URBAN_HAVERSINE_FACTOR = 1.35
+
+
+def _normalize_station_name(name: str) -> str:
+    return name.strip().casefold().replace("ё", "е")
+
+
+def _haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Great-circle distance between two WGS-84 points in meters."""
+    earth_radius_m = 6_371_000.0
+    phi1 = math.radians(lat1)
+    phi2 = math.radians(lat2)
+    dphi = math.radians(lat2 - lat1)
+    dlambda = math.radians(lon2 - lon1)
+
+    a = (
+        math.sin(dphi / 2) ** 2
+        + math.cos(phi1) * math.cos(phi2) * math.sin(dlambda / 2) ** 2
+    )
+    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+    return earth_radius_m * c
+
+
+def _duration_minutes(distance_meters: float) -> int:
+    """Walking duration at 4.8 km/h (80 m/min), rounded up."""
+    return math.ceil(distance_meters / WALK_SPEED_M_PER_MIN)
+
+
+def _osrm_distance(
+    lat1: float, lon1: float, lat2: float, lon2: float, profile: str
+) -> float:
+    """Ask OSRM for a route distance in meters.
+
+    Raises ``requests.RequestException`` or ``RuntimeError`` on any failure.
+    """
+    url = (
+        f"{OSRM_BASE_URL}/{profile}/{lon1},{lat1};{lon2},{lat2}"
+        f"?overview=false&alternatives=false&steps=false"
+    )
+    # v0.3.5: netguard (egress-guard + breaker) на внешние маршрутизаторы
+    from .net_guard import guarded_get
+
+    response = guarded_get(url, timeout=OSRM_TIMEOUT_SECONDS)
+    response.raise_for_status()
+    payload = response.json()
+
+    if payload.get("code") != "Ok":
+        message = payload.get("message", "unknown OSRM error")
+        raise RuntimeError(f"OSRM {profile} error: {message}")
+
+    return float(payload["routes"][0]["distance"])
+
+
+def _route_distance(
+    lat1: float, lon1: float, lat2: float, lon2: float
+) -> tuple[float, str, bool]:
+    """Return (distance_meters, provider, route_verified).
+
+    Provider ladder (v0.2.0, self-contained):
+      1. graph_local — встроенный пешеходный граф Москвы (route_verified=True)
+      2. cache — ранее посчитанный маршрут (route_verified=True, cached=True)
+      3. osrm_foot / osrm_driving_fallback — legacy, только если граф недоступен
+         (публичный OSRM не является зависимостью)
+      4. haversine_fallback — прикидка
+    """
+    # 1. Локальный граф
+    try:
+        from . import graph as _graph_mod
+
+        res = _graph_mod.route(lat1, lon1, lat2, lon2)
+        if res is not None:
+            meters, provider = res
+            return meters, "graph_local", True
+    except Exception:
+        pass  # граф не установлен/не загрузился — идём дальше по лестнице
+
+    # 2. OSRM (legacy path; не является обязательной инфрой)
+    try:
+        distance = _osrm_distance(lat1, lon1, lat2, lon2, "foot")
+        return distance, "osrm_foot", True
+    except Exception:
+        try:
+            distance = _osrm_distance(lat1, lon1, lat2, lon2, "driving")
+            return distance, "osrm_driving_fallback", False
+        except Exception:
+            pass
+
+    # 3. Haversine
+    distance = _haversine(lat1, lon1, lat2, lon2) * URBAN_HAVERSINE_FACTOR
+    return distance, "haversine_fallback", False
+
+
+def walk_route(lat: float, lon: float, target_station: str) -> dict[str, Any]:
+    """Route from (lat, lon) to the nearest vestibule of ``target_station``.
+
+    Returns a dict that follows the ``HonestWalkRoute`` schema with a few
+    extra operational keys:
+
+    * ``target_station`` – requested station name
+    * ``target_vestibule`` – name of the nearest vestibule
+    * ``walk_distance_meters`` – integer meters
+    * ``walk_duration_minutes`` – integer minutes at 4.8 km/h
+    * ``routing_provider`` – e.g. ``osrm_foot``, ``osrm_driving``,
+      ``haversine_fallback``
+    * ``route_verified`` – ``True`` when OSRM returned a real route
+    * ``status`` – ``ok`` or ``degraded``
+    * ``reason`` – ``None`` normally, ``STATION_NOT_IN_DIRECTORY`` for unknown
+      stations
+    """
+    vestibules = get_vestibules(target_station)
+    if vestibules is None:
+        return {
+            "target_station": target_station,
+            "target_vestibule": None,
+            "walk_distance_meters": None,
+            "walk_duration_minutes": None,
+            "routing_provider": "station_directory",
+            "route_verified": False,
+            "status": "degraded",
+            "reason": "STATION_NOT_IN_DIRECTORY",
+        }
+
+    # 0. Кеш: ранее посчитанный маршрут (station-level, до перебора вестибюлей)
+    try:
+        from . import routing_cache
+
+        cached = routing_cache.get(lat, lon, target_station)
+        if cached is not None:
+            return {
+                "target_station": target_station,
+                "target_vestibule": None,
+                "walk_distance_meters": int(round(cached)),
+                "walk_duration_minutes": _duration_minutes(cached),
+                "routing_provider": "cache",
+                "route_verified": True,
+                "status": "ok",
+                "reason": None,
+                "cached": True,
+            }
+    except Exception:
+        pass  # кеш не критичен
+
+    best: dict[str, Any] | None = None
+
+    for vestibule_name, vlat, vlon in vestibules:
+        distance, provider, verified = _route_distance(lat, lon, vlat, vlon)
+        if best is None or distance < best["distance"]:
+            best = {
+                "distance": distance,
+                "provider": provider,
+                "verified": verified,
+                "vestibule": vestibule_name,
+            }
+
+    assert best is not None
+
+    distance_m = int(round(best["distance"]))
+    duration_min = _duration_minutes(best["distance"])
+
+    result: dict[str, Any] = {
+        "target_station": target_station,
+        "target_vestibule": best["vestibule"],
+        "walk_distance_meters": distance_m,
+        "walk_duration_minutes": duration_min,
+        "routing_provider": best["provider"],
+        "route_verified": best["verified"],
+        "status": "ok",
+        "reason": None,
+    }
+    if not best["verified"]:
+        result["fallback_reason"] = "osrm_unavailable"
+    # Кешируем успешный маршрут (graph_local / osrm_foot) для будущих запросов
+    if best["provider"] in ("graph_local", "osrm_foot"):
+        try:
+            from . import routing_cache
+
+            routing_cache.put(lat, lon, target_station, float(distance_m),
+                              provider=best["provider"])
+        except Exception:
+            pass
+    return result
+
+
+def honest_overclaim(honest_minutes: int, claimed_minutes: int) -> dict[str, Any]:
+    """Compare honest walking time with a platform claim.
+
+    Returns ``{"overclaim_minutes": N, "flag": bool}`` where ``flag`` is
+    ``True`` when the honest time exceeds the claimed time by more than
+    three minutes.
+    """
+    overclaim = max(0, honest_minutes - claimed_minutes)
+    return {
+        "overclaim_minutes": overclaim,
+        "flag": honest_minutes > claimed_minutes + 3,
+    }

nedviga/graph.py

@@ -0,0 +1,149 @@
+"""Локальный пешеходный граф Москвы: загрузка, снап, A*.
+
+Граф поставляется артефактом (pickle, см. tools/build_graph.py) и кладётся
+в nedviga/graph_moscow.pkg или по пути из NEDVIGA_GRAPH_PATH.
+"""
+from __future__ import annotations
+
+import heapq
+import math
+import pickle
+from pathlib import Path
+
+# Приоритет путей поиска граф-файла
+DEFAULT_GRAPH_PATHS = [
+    Path(__file__).parent / "graph_moscow.pkg",
+    Path(__file__).parent.parent / "graph_moscow.pkg",
+]
+
+_walking_speed_m_per_min = 80.0  # 4.8 km/h, согласовано с SPEC
+
+
+class GraphNotAvailable(Exception):
+    """Граф не найден/не загружен."""
+
+
+class _Graph:
+    __slots__ = ("nodes", "edges", "adj", "version", "built_at", "_grid_cache")
+
+    def __init__(self, nodes: dict, edges: dict, version: int, built_at: str):
+        self.nodes = nodes              # {id: (lat, lon)}
+        self.edges = edges              # {id: [(id, meters), ...]}
+        self.version = version
+        self.built_at = built_at
+        self.adj = edges                # alias
+        self._grid_cache = None
+
+    def nearest_node(self, lat: float, lon: float, max_m: float = 400.0) -> int | None:
+        """Ближайший узел графа. Линейный поиск приемлем: узлов ~200-400k,
+        но для скорости — сетка-индекс."""
+        # Простой грид-индекс
+        cell = 0.005  # ~500 м
+        best, best_d = None, max_m
+        la0, la1 = math.floor((lat - max_m/111000) / cell), math.ceil((lat + max_m/111000) / cell)
+        lo0, lo1 = math.floor((lon - max_m/111000) / (cell * 0.6)), math.ceil((lon + max_m/111000) / (cell * 0.6))
+        grid = self._grid()
+        for ga in range(la0, la1 + 1):
+            for go in range(lo0, lo1 + 1):
+                for nid in grid.get((ga, go), ()):  # noqa
+                    nla, nlo = self.nodes[nid]
+                    d = _haversine(lat, lon, nla, nlo)
+                    if d < best_d:
+                        best, best_d = nid, d
+        return best
+
+    def _grid(self) -> dict:
+        if self._grid_cache is None:
+            g: dict[tuple[int, int], list[int]] = {}
+            cell = 0.005
+            for nid, (la, lo) in self.nodes.items():
+                g.setdefault((math.floor(la / cell), math.floor(lo / (cell * 0.6))), []).append(nid)
+            self._grid_cache = g
+        return self._grid_cache
+
+
+_graph: _Graph | None = None
+
+
+def _haversine(lat1, lon1, lat2, lon2):
+    r = 6_371_000.0
+    p1, p2 = math.radians(lat1), math.radians(lat2)
+    dp = math.radians(lat2 - lat1)
+    dl = math.radians(lon2 - lon1)
+    a = math.sin(dp / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dl / 2) ** 2
+    return 2 * r * math.asin(math.sqrt(a))
+
+
+def load_graph(explicit: Path | None = None) -> _Graph:
+    """Загрузить граф (однократно). Path: explicit > NEDVIGA_GRAPH_PATH > дефолты."""
+    global _graph
+    if _graph is not None:
+        return _graph
+    import os
+
+    candidates = []
+    if explicit:
+        candidates.append(explicit)
+    env = os.environ.get("NEDVIGA_GRAPH_PATH")
+    if env:
+        candidates.append(Path(env))
+    candidates.extend(DEFAULT_GRAPH_PATHS)
+    import hashlib
+    for c in candidates:
+        if c.exists():
+            # v0.4.5 (review R14/R9): pickle = RCE при подмене файла.
+            # Грузим только с валидным sidecar .sha256; осознанный обход — явным env.
+            sidecar = Path(str(c) + ".sha256")
+            allow_unsigned = os.environ.get("NEDVIGA_GRAPH_ALLOW_UNSIGNED") == "1"
+            if sidecar.exists():
+                want = sidecar.read_text(encoding="ascii").split()[0].lower()
+                got = hashlib.sha256(c.read_bytes()).hexdigest()
+                if want != got:
+                    raise GraphNotAvailable(f"graph-артефакт повреждён: sha256 {got[:12]} != {want[:12]} (подмена?)")
+            elif not allow_unsigned:
+                raise GraphNotAvailable(
+                    f"{c} без sidecar .sha256 — pickle без верификации запрещён "
+                    f"(сгенерируй: sha256sum pkg > pkg.sha256, или осознанно NEDVIGA_GRAPH_ALLOW_UNSIGNED=1)")
+            with open(c, "rb") as f:
+                data = pickle.load(f)
+            _graph = _Graph(data["nodes"], data["edges"], data.get("version", 1), data.get("built_at", ""))
+            return _graph
+    raise GraphNotAvailable("graph_moscow.pkg не найден (NEDVIGA_GRAPH_PATH или рядом с пакетом)")
+
+
+def route(lat: float, lon: float, mlat: float, mlon: float) -> tuple[float, str] | None:
+    """Пешее расстояние между двумя координатами по графу. (meters, provider) или None."""
+    g = load_graph()
+    s = g.nearest_node(lat, lon)
+    t = g.nearest_node(mlat, mlon)
+    if s is None or t is None:
+        return None
+    if s == t:
+        return 0.0, "graph_local"
+    # A* по haversine-эвристике
+    dist: dict[int, float] = {s: 0.0}
+    pq = [(0.0, s)]
+    seen: set[int] = set()
+    while pq:
+        _, u = heapq.heappop(pq)
+        if u in seen:
+            continue
+        seen.add(u)
+        if u == t:
+            meters = dist[t]
+            # + снап-хвосты до реальных точек
+            nla, nlo = g.nodes[s]
+            mla, mlo = g.nodes[t]
+            meters += _haversine(lat, lon, nla, nlo) + _haversine(mla, mlo, mlat, mlo)
+            return round(meters, 1), "graph_local"
+        for v, m in g.adj.get(u, ()):
+            if v in seen:
+                continue
+            nd = dist[u] + m
+            if v not in dist or nd < dist[v]:
+                dist[v] = nd
+                # эвристика: прямая до цели
+                hla, hlo = g.nodes[v]
+                h = _haversine(hla, hlo, mlat, mlon)
+                heapq.heappush(pq, (nd + h, v))
+    return None

nedviga/legal_triage.py

@@ -0,0 +1,105 @@
+"""v0.5.0 (the task brief) legal red-flag triage (data-driven)."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+from .models import ListingCard
+
+
+def _data_path() -> Path:
+    return Path(__file__).resolve().parent / "data" / "legal_flags.json"
+
+
+def load_legal_data() -> dict[str, Any]:
+    return json.loads(_data_path().read_text(encoding="utf-8"))
+
+
+def _listing(card: Any) -> ListingCard:
+    if isinstance(card, ListingCard):
+        return card
+    if isinstance(card, dict):
+        return ListingCard(**card)
+    if isinstance(card, str):
+        import json as _j
+        raw = _j.loads(Path(card).read_text(encoding="utf-8"))
+        if isinstance(raw, list):
+            raw = raw[0]
+        if isinstance(raw, dict) and "cards" in raw:
+            raw = raw["cards"][0]
+        return ListingCard(**raw)
+    raise TypeError("unsupported card")
+
+
+def _card_text(card: ListingCard) -> str:
+    parts = [card.title or "", card.description_text or "", card.building.building_type or "",
+             card.building.address_raw or "", card.category or ""]
+    # include seller type etc
+    if card.seller and card.seller.seller_type:
+        parts.append(card.seller.seller_type)
+    return " ".join(p for p in parts if p)
+
+
+def _quote(text: str, marker: str) -> str:
+    low = text.lower()
+    idx = low.find(marker.lower())
+    if idx < 0:
+        return marker
+    start = max(0, idx - 60)
+    end = min(len(text), idx + len(marker) + 60)
+    snippet = text[start:end].strip()
+    # trim to word boundaries roughly
+    return snippet if snippet else marker
+
+
+def _severity(flag: dict, text: str) -> str:
+    sev = flag.get("severity", "amber")
+    rule = flag.get("severity_rule")
+    if not rule:
+        return sev
+    # conditional
+    low = text.lower()
+    if rule.get("if_text") in low:
+        # find number before 'лет'
+        import re
+        m = re.search(r"(\d+)\s*лет", low)
+        if m:
+            years = int(m.group(1))
+            threshold = rule.get("threshold_years", 3)
+            if years < threshold and rule.get("red_if_under"):
+                return "red"
+            return rule.get("else", "amber")
+    return rule.get("else", sev)
+
+
+def triage(card: Any) -> dict[str, Any]:
+    data = load_legal_data()
+    c = _listing(card)
+    text = _card_text(c)
+    low = text.lower()
+    flags = []
+    for flag in data.get("flags", []):
+        markers = flag.get("markers", [])
+        found_marker = None
+        for m in markers:
+            if m.lower() in low:
+                found_marker = m
+                break
+        if not found_marker:
+            continue
+        text_basis = _quote(text, found_marker)
+        sev = _severity(flag, text)
+        flags.append({
+            "code": flag["code"],
+            "label": flag.get("title"),
+            "severity": sev,
+            "text_basis": text_basis,
+            "check": flag.get("check"),
+        })
+    return {
+        "flags": flags,
+        "disclaimer": data.get("disclaimer"),
+        "legal_data_version": data.get("version"),
+        "approved_by": data.get("approved_by"),
+    }

nedviga/litprecheck.py

@@ -0,0 +1,116 @@
+"""v0.5.6 (the task brief) litigation pre-check via sud-cli."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+from . import pipeline
+
+
+def _sud_bin() -> str:
+    return os.environ.get("SUD_BIN", "sud-cli")
+
+
+def _cache_dir() -> Path:
+    base = Path(os.environ.get("NEDVIGA_STATE_DIR", str(Path.home() / ".local" / "share" / "nedviga")))
+    d = base / "litcheck_cache"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _cache_key(query: str) -> str:
+    return hashlib.sha256(query.encode()).hexdigest()
+
+
+def _cache_get(key: str) -> Optional[dict]:
+    p = _cache_dir() / f"{key}.json"
+    if not p.exists():
+        return None
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+    ts = data.get("_ts")
+    if ts:
+        dt = datetime.fromisoformat(ts)
+        if datetime.now(timezone.utc) - dt > timedelta(hours=24):
+            return None
+    return data.get("payload")
+
+
+def _cache_set(key: str, payload: dict) -> None:
+    p = _cache_dir() / f"{key}.json"
+    p.write_text(json.dumps({"_ts": datetime.now(timezone.utc).isoformat(), "payload": payload},
+                            ensure_ascii=False), encoding="utf-8")
+
+
+def litcheck(card_id: Optional[str] = None, address: Optional[str] = None,
+             developer: Optional[str] = None, since: int = 2020, file: Optional[str] = None,
+             db=None) -> dict:
+    # build query from card if file provided
+    query = address or developer or ""
+    if file and not query:
+        try:
+            import json as _j
+            raw = _j.loads(Path(file).read_text(encoding="utf-8"))
+            if isinstance(raw, list):
+                raw = raw[0]
+            if isinstance(raw, dict) and "cards" in raw:
+                raw = raw["cards"][0]
+            addr = (raw.get("building", {}) or {}).get("address_raw")
+            if addr:
+                query = addr
+        except Exception:
+            pass
+    if not query:
+        query = card_id or ""
+
+    key = _cache_key(query)
+    cached = _cache_get(key)
+    if cached is not None:
+        cached["cache_hit"] = True
+        return cached
+
+    bin_path = _sud_bin()
+    # try subprocess
+    try:
+        proc = subprocess.run(
+            [bin_path, "--json", "kad", "--name", query],
+            capture_output=True, text=True, timeout=30,
+        )
+    except FileNotFoundError:
+        result = {"status": "unavailable", "reason": "sud_bin_not_found", "count": None, "links": []}
+        _cache_set(key, result)
+        return result
+    except Exception as exc:
+        result = {"status": "error", "reason": str(exc), "count": None, "links": []}
+        _cache_set(key, result)
+        return result
+
+    if proc.returncode != 0:
+        result = {"status": "unavailable", "reason": proc.stderr.strip() or "sud_error", "count": None, "links": []}
+        _cache_set(key, result)
+        return result
+    # parse
+    try:
+        data = json.loads(proc.stdout)
+    except Exception:
+        result = {"status": "error", "reason": "invalid_json", "count": None, "links": []}
+        _cache_set(key, result)
+        return result
+    count = data.get("count")
+    links = data.get("links", [])
+    result = {"status": "ok", "count": count, "links": links, "query": query, "cache_hit": False}
+    _cache_set(key, result)
+    return result
+
+
+def render_text(result: dict) -> str:
+    if result.get("status") != "ok":
+        return f"litcheck: {result.get('status')} — {result.get('reason')}"
+    return f"выявлены записи {result.get('count')} по запросу {result.get('query')}, проверь детали; " + ", ".join(result.get("links", []))