nedviga-cli 0.1.0__py3-none-any.whl

nedviga/risk.py

@@ -0,0 +1,127 @@
+"""v0.4.9 (the task brief) F-07b/F-19: risk scoring."""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+from .bargain import _load_cards, _ppm2, _percentile
+from .models import ListingCard
+
+
+URGENT_WORDS = ["срочно", "торопимся", "переоценка", "обмен", "срочная"]
+DISCOUNT_WORDS = ["без торга", "реально всё", "реально все", "без посредников"]
+
+
+def _listing(card: Any) -> ListingCard:
+    if isinstance(card, ListingCard):
+        return card
+    if isinstance(card, dict):
+        return ListingCard(**card)
+    if isinstance(card, str):
+        return _load_cards(card)[0]
+    raise TypeError("unsupported card")
+
+
+def _title_caps_ratio(title: str) -> float:
+    letters = [ch for ch in title if ch.isalpha()]
+    if not letters:
+        return 0.0
+    caps = [ch for ch in letters if ch.isupper()]
+    return len(caps) / len(letters)
+
+
+def _exclamations(title: str) -> int:
+    return title.count("!")
+
+
+def score_card(card: Any, corpus: Optional[Any] = None, district: Optional[str] = None,
+               rooms: Optional[int] = None) -> dict[str, Any]:
+    c = _listing(card)
+    title = c.title or ""
+    low = title.lower()
+    reasons: list[str] = []
+    score = 0.0
+
+    for w in URGENT_WORDS:
+        if w in low:
+            reasons.append(f"urgent:{w}")
+            score += 0.15
+
+    if _title_caps_ratio(title) > 0.6:
+        reasons.append("caps_ratio>0.6")
+        score += 0.2
+
+    if _exclamations(title) >= 3:
+        reasons.append("exclamations>=3")
+        score += 0.15
+
+    # minus signal: discount phrases
+    for w in DISCOUNT_WORDS:
+        if w in low:
+            reasons.append(f"discount_phrase:{w}")
+            score -= 0.1
+
+    # price vs group
+    bait_reasons: list[str] = []
+    bait_suspect = False
+    if corpus is not None:
+        try:
+            corpus_cards = corpus if isinstance(corpus, list) else _load_cards(corpus) if isinstance(corpus, str) else corpus
+        except Exception:
+            corpus_cards = []
+        # normalize
+        if not isinstance(corpus_cards, list):
+            corpus_cards = []
+        # filter district/rooms
+        t_district = district or (c.geo.district if c.geo else None)
+        t_rooms = rooms if rooms is not None else c.parameters.rooms
+        group_prices = []
+        for cc in corpus_cards:
+            try:
+                lc = cc if isinstance(cc, ListingCard) else ListingCard(**cc) if isinstance(cc, dict) else None
+            except Exception:
+                lc = None
+            if lc is None:
+                continue
+            cd = lc.geo.district if lc.geo else None
+            cr = lc.parameters.rooms
+            if t_district is not None and cd != t_district:
+                continue
+            if t_rooms is not None and cr is not None and abs(cr - t_rooms) > 1:
+                continue
+            p = _ppm2(lc)
+            if p is not None:
+                group_prices.append(p)
+        if len(group_prices) >= 20:
+            s = sorted(group_prices)
+            p10 = _percentile(s, 0.10)
+            median = _percentile(s, 0.5)
+            target_price = _ppm2(c)
+            if target_price is not None and target_price < p10:
+                reasons.append("price_below_p10")
+                score += 0.4
+            if target_price is not None and median and target_price < 0.6 * median:
+                bait_suspect = True
+                bait_reasons.append("price_below_0.6_median")
+        else:
+            # not enough sample, no strong signal
+            pass
+
+    score = max(0.0, min(1.0, score))
+    if bait_suspect:
+        bait_reasons.append("похоже на недостоверное объявление — проверьте звонком")
+
+    return {
+        "risk_score": round(score, 3),
+        "reasons": reasons,
+        "bait_suspect": bait_suspect,
+        "bait_reasons": bait_reasons,
+    }
+
+
+def bait_text(result: dict[str, Any]) -> str:
+    if not result.get("bait_suspect"):
+        return ""
+    return "похоже на недостоверное объявление — проверьте звонком: " + "; ".join(result.get("bait_reasons", []))

nedviga/roles.py

@@ -0,0 +1,124 @@
+"""v0.5.5 (the task brief) roles."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+WRITE_COMMANDS = {
+    "pipeline": {"set"},
+    "watch": {"add", "rm"},
+    "feedback": {"add", "apply"},
+    "project": {"new", "add", "refresh"},
+    "chain": {"new", "link"},
+    "checklist": {"handoff"},
+    "purge": {"card", "profile"},
+}
+
+READ_COMMANDS = {
+    "search", "get-card", "export", "import", "walk-distance", "doctor",
+    "pipeline", "watch", "digest", "compare", "bargain", "risk", "triage",
+    "checklist", "callsheet", "project", "poi", "tour", "market", "stale",
+    "catalog-pdf", "sources", "dedup", "scorefit", "chain", "text", "audit",
+    "pii-log", "feedback",
+}
+
+
+def roles_file() -> Path:
+    p = os.environ.get("NEDVIGA_ROLES_FILE")
+    if p:
+        return Path(p)
+    base = Path(os.environ.get("NEDVIGA_STATE_DIR", str(Path.home() / ".local" / "share" / "nedviga")))
+    return base / "roles.json"
+
+
+def load_roles() -> list[dict]:
+    p = roles_file()
+    if not p.exists():
+        return []
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return []
+    if isinstance(data, list):
+        return data
+    return []
+
+
+def current_role() -> str:
+    return os.environ.get("NEDVIGA_ROLE", "agent")
+
+
+def validate_role() -> tuple[bool, Optional[str]]:
+    role = current_role()
+    roles = load_roles()
+    # default agent allowed even without manifest? Task: family/auditor must be declared explicitly.
+    if role == "agent":
+        return True, None
+    for r in roles:
+        if r.get("name") == role or r.get("role") == role:
+            # manifest contains role
+            if r.get("role") == role:
+                return True, None
+    # also allow if manifest lists role as a role value
+    for r in roles:
+        if r.get("role") == role:
+            return True, None
+    return False, "unknown_role"
+
+
+def _subcommand(args) -> Optional[str]:
+    # determine subcommand for grouped commands
+    for attr in ("pipeline_action", "watch_action", "feedback_action", "project_action",
+                 "chain_action", "checklist_action", "text_action", "sources_action"):
+        v = getattr(args, attr, None)
+        if v:
+            return v
+    return None
+
+
+def is_write(args) -> bool:
+    cmd = getattr(args, "command", None)
+    sub = _subcommand(args)
+    if cmd in ("purge",):
+        return True
+    if cmd in WRITE_COMMANDS:
+        if sub is None:
+            return True
+        return sub in WRITE_COMMANDS[cmd]
+    return False
+
+
+def check_permission(args) -> tuple[bool, Optional[str]]:
+    role = current_role()
+    ok, reason = validate_role()
+    if not ok:
+        return False, reason
+    cmd = getattr(args, "command", None)
+    sub = _subcommand(args)
+    if role == "agent":
+        return True, None
+    if role == "auditor":
+        # read-only: no writes, no contacts
+        if is_write(args):
+            return False, "role_forbidden"
+        return True, None
+    if role == "family":
+        if is_write(args):
+            # allow feedback add
+            if cmd == "feedback" and sub == "add":
+                return True, None
+            # pipeline set only show->feedback: allow if status == feedback
+            if cmd == "pipeline" and sub == "set":
+                if getattr(args, "status", None) == "feedback":
+                    return True, None
+                return False, "role_forbidden"
+            return False, "role_forbidden"
+        return True, None
+    return False, "unknown_role"
+
+
+def role_allows_contacts(role: Optional[str] = None) -> bool:
+    r = role or current_role()
+    return r == "agent"

nedviga/routing_cache.py

@@ -0,0 +1,72 @@
+"""SQLite-кеш маршрутов (routing_cache.sqlite)."""
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import threading
+from pathlib import Path
+
+# v0.4.5 (панель): кеш внутри пакета ломал read-only установки и параллельные запуски.
+_USER_DIR = Path(os.environ.get("NEDVIGA_CACHE_DIR", str(Path.home() / ".local" / "share" / "nedviga")))
+_USER_DIR.mkdir(parents=True, exist_ok=True)
+_DEFAULT = _USER_DIR / "routing_cache.sqlite"
+_lock = threading.Lock()
+
+
+def _connect(db_path: Path | None = None) -> sqlite3.Connection:
+    p = db_path or _DEFAULT
+    p.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(p, timeout=30.0)
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA busy_timeout=5000")
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS routes ("
+        " key TEXT PRIMARY KEY,"
+        " meters REAL NOT NULL,"
+        " provider TEXT NOT NULL,"
+        " created_at TEXT NOT NULL DEFAULT (datetime('now')))"
+    )
+    return conn
+
+
+def cache_key(lat: float, lon: float, station: str, grid_m: float = 50.0) -> str:
+    """Ключ = округлённые координаты (грид ~50м) + станция."""
+    lat_r = round(lat / (grid_m / 111_000.0))
+    lon_r = round(lon / (grid_m / 76_000.0))
+    return f"{lat_r}:{lon_r}:{station.casefold()}"
+
+
+def get(lat: float, lon: float, station: str, db_path: Path | None = None) -> float | None:
+    k = cache_key(lat, lon, station)
+    with _lock:
+        conn = _connect(db_path)
+        try:
+            row = conn.execute("SELECT meters FROM routes WHERE key=?", (k,)).fetchone()
+            return row[0] if row else None
+        finally:
+            conn.close()
+
+
+def put(lat: float, lon: float, station: str, meters: float,
+        provider: str = "unknown", db_path: Path | None = None) -> None:
+    k = cache_key(lat, lon, station)
+    with _lock:
+        conn = _connect(db_path)
+        try:
+            conn.execute(
+                "INSERT OR REPLACE INTO routes (key, meters, provider) VALUES (?, ?, ?)",
+                (k, meters, provider),
+            )
+            conn.commit()
+        finally:
+            conn.close()
+
+
+def stats(db_path: Path | None = None) -> dict:
+    conn = _connect(db_path)
+    try:
+        n = conn.execute("SELECT COUNT(*) FROM routes").fetchone()[0]
+        return {"entries": n, "path": str(db_path or _DEFAULT)}
+    finally:
+        conn.close()

nedviga/rush.py

@@ -0,0 +1,139 @@
+"""v0.5.13 F-15t: транспортная доступность — пешая до метро + ТЕКУЩИЕ пробки.
+
+Честная рамка: прогноза «час-пик» нет — Яндекс отдаёт только
+текущий балл, прогноз требует платного API-ключа. Балл замеряется ТОЛЬКО
+через RU-egress браузерным каналом; без egress — честный unavailable
+(не 0, не среднее, не выдумка).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def _egress() -> str | None:
+    v = (os.environ.get("NEDVIGA_EGRESS_PROXY") or "").strip()
+    return v or None
+
+
+def _fetch_traffic() -> str:
+    """Текущий балл пробок Москвы. Только RU-egress; без — RuntimeError.
+    (тесты мокают эту функцию — сеть в тестах запрещена)"""
+    proxy = _egress()
+    if not proxy:
+        raise RuntimeError("egress_required")
+    from camoufox.sync_api import Camoufox
+    with Camoufox(headless=True, humanize=True, geoip=False,
+                  proxy={"server": proxy}) as browser:
+        pg = browser.new_page()
+        pg.goto("https://yandex.ru/maps/213/moscow/probki/",
+                wait_until="domcontentloaded", timeout=45000)
+        pg.wait_for_timeout(9000)
+        return (pg.evaluate("document.body.innerText") or "")
+
+
+def parse_balls(text: str) -> int | None:
+    m = re.search(r"(\d+)\s*балл", text)
+    return int(m.group(1)) if m else None
+
+
+def _pairs_from_run(nums: list[int]) -> list[dict] | None:
+    """Пары «балл@час» из ряда чисел; чередование сломалось -> None."""
+    pairs: list[dict] = []
+    for i in range(0, len(nums) - 1, 2):
+        val, hour = nums[i], nums[i + 1]
+        if not (0 <= val <= 10 and 0 <= hour <= 23):
+            return None
+        if pairs and hour <= pairs[-1]["hour"]:
+            break  # прогноз остатка дня: часы идут по возрастанию
+        pairs.append({"hour": hour, "balls": val})
+    return pairs if len(pairs) >= 2 else None
+
+
+def parse_forecast_hours(text: str) -> list[dict]:
+    """v0.5.14 (the task brief §2): почасовой web-прогноз загруженности со
+    страницы Яндекс Карт (innerText), НЕ платный API.
+
+    Живая форма: «Дорожная ситуация сейчас Пробки N баллов» + пары
+    «балл@час», идущие подряд: «6 18 5 19 4 20 2 21 1 22 1 23»
+    (остаток дня; балл, затем час).
+
+    Честная рамка: только целые баллы 0-10 и целые часы 0-23,
+    часы строго по возрастанию, минимум 2 полные пары. Структура не
+    распарсилась -> пустой список. Никогда не угадываем.
+    """
+    if not text:
+        return []
+    m = re.search(r"\b(\d{1,2})\s*балл", text)
+    if not m:
+        return []
+    runs: list[list[int]] = []
+    cur: list[int] = []
+    for tok in re.split(r"[\s\u00a0]+", text[m.end():]):
+        if re.fullmatch(r"\d{1,2}", tok):
+            cur.append(int(tok))
+        elif cur:
+            runs.append(cur)
+            cur = []
+    if cur:
+        runs.append(cur)
+    for run in runs:
+        if len(run) < 4:
+            continue
+        # смещение 1 — если первым в ряд попал мусор-число (напр. «41 км/ч»)
+        for off in (0, 1):
+            pairs = _pairs_from_run(run[off:])
+            if pairs:
+                return pairs
+    return []
+
+
+def walk_to_metro(lat: float, lon: float) -> dict:
+    """Ближайшее метро по внутреннему графу (офлайн, пешая дистанция).
+    Без графа — честная unavailable."""
+    try:
+        from .graph import load_graph, _haversine
+        g = load_graph()
+        node = g.nearest_node(lat, lon, max_m=4000.0)
+        if node is None:
+            return {"status": "no_metro_in_4km", "walk_minutes": None}
+        nla, nlo = g.nodes[node]
+        dist = _haversine(lat, lon, nla, nlo)
+        minutes = round(dist / 80.0)  # 80 м/мин пешком
+        return {"status": "ok", "metro_node": node,
+                "distance_m": round(dist), "walk_minutes": minutes}
+    except Exception as exc:
+        return {"status": "graph_unavailable", "reason": type(exc).__name__,
+                "walk_minutes": None}
+
+
+def rush_report(card_data: dict) -> dict:
+    geo = (card_data or {}).get("geo") or {}
+    lat, lon = geo.get("lat"), geo.get("lon")
+    out: dict = {"walk": None, "traffic": {}, "honest_note":
+                 "загруженность текущего момента; прогноз час-пика недоступен без платного API-ключа"}
+    if lat is not None and lon is not None:
+        out["walk"] = walk_to_metro(lat, lon)
+    else:
+        out["walk"] = {"status": "no_coordinates", "walk_minutes": None}
+    if _egress():
+        try:
+            text = _fetch_traffic()
+            balls = parse_balls(text)
+            out["traffic"] = {"score": balls,
+                              "measured_at_utc": datetime.now(timezone.utc).isoformat(timespec="seconds")}
+            if balls is None:
+                out["traffic"]["status"] = "unavailable"
+            # v0.5.14: почасовой web-прогноз с той же страницы (офлайн-разбор,
+            # без угадывания: пустой список, если структура не распарсилась)
+            out["traffic"]["forecast_hours"] = parse_forecast_hours(text)
+        except Exception:
+            out["traffic"] = {"status": "unavailable", "score": None,
+                              "forecast_hours": []}
+    else:
+        out["traffic"] = {"status": "unavailable (нет RU-egress: не замерено)",
+                          "score": None, "forecast_hours": []}
+    return out

nedviga/scorefit.py

@@ -0,0 +1,127 @@
+"""v0.5.4 (the task brief) scorefit."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+from .models import ListingCard
+
+
+def _listing(card: Any) -> ListingCard:
+    if isinstance(card, ListingCard):
+        return card
+    if isinstance(card, dict):
+        return ListingCard(**card)
+    raise TypeError("unsupported card")
+
+
+def _load_profile(profile) -> dict:
+    if isinstance(profile, dict):
+        return profile
+    if isinstance(profile, str):
+        # could be path or profile name
+        p = Path(profile)
+        if p.exists():
+            return json.loads(p.read_text(encoding="utf-8"))
+        # builtin profiles
+        from .profiles import get_profile
+        try:
+            return get_profile(profile)
+        except Exception:
+            return {}
+    return {}
+
+
+def score_card(card: Any, profile: Any = None) -> dict[str, Any]:
+    c = _listing(card)
+    prof = _load_profile(profile)
+    breakdown = []
+    total_weight = 0.0
+    total_score = 0.0
+
+    # district
+    w = 20.0
+    total_weight += w
+    expected = prof.get("districts") or prof.get("geo_districts")
+    actual = c.geo.district if c.geo else None
+    ok = (expected is None) or (actual in (expected if isinstance(expected, list) else [expected]))
+    contrib = w if ok else 0.0
+    total_score += contrib
+    breakdown.append({"criterion": "district", "value": actual, "expected": expected, "weight": w, "contribution": contrib})
+
+    # budget (price <= price_max)
+    w = 20.0
+    total_weight += w
+    price_max = prof.get("price_max")
+    price = c.pricing.price_total_rub
+    if price_max is None or price is None or price <= price_max:
+        ok = True
+    else:
+        ok = False
+    contrib = w if ok else 0.0
+    total_score += contrib
+    breakdown.append({"criterion": "budget", "value": price, "expected": f"<= {price_max}", "weight": w, "contribution": contrib})
+
+    # rooms
+    w = 15.0
+    total_weight += w
+    exp_rooms = prof.get("rooms")
+    actual_rooms = c.parameters.rooms
+    ok = (exp_rooms is None) or (actual_rooms == exp_rooms)
+    contrib = w if ok else 0.0
+    total_score += contrib
+    breakdown.append({"criterion": "rooms", "value": actual_rooms, "expected": exp_rooms, "weight": w, "contribution": contrib})
+
+    # metro walk
+    w = 15.0
+    total_weight += w
+    max_walk = prof.get("metro_walk_max")
+    walk = None
+    if c.geo and c.geo.honest_walk_route:
+        walk = c.geo.honest_walk_route.walk_duration_minutes
+    elif c.geo and c.geo.cian_claimed_metro:
+        walk = c.geo.cian_claimed_metro.claimed_time_minutes
+    ok = (max_walk is None) or (walk is None) or (walk <= max_walk)
+    contrib = w if ok else 0.0
+    total_score += contrib
+    breakdown.append({"criterion": "metro_walk", "value": walk, "expected": f"<= {max_walk}", "weight": w, "contribution": contrib})
+
+    # kitchen
+    w = 10.0
+    total_weight += w
+    kitchen_min = prof.get("kitchen_min")
+    kitchen = c.parameters.area_kitchen_m2
+    ok = (kitchen_min is None) or (kitchen is None) or (kitchen >= kitchen_min)
+    contrib = w if ok else 0.0
+    total_score += contrib
+    breakdown.append({"criterion": "kitchen", "value": kitchen, "expected": f">= {kitchen_min}", "weight": w, "contribution": contrib})
+
+    # floor not first
+    w = 10.0
+    total_weight += w
+    floor = c.parameters.floor
+    ok = (floor is None) or (floor != 1)
+    contrib = w if ok else 0.0
+    total_score += contrib
+    breakdown.append({"criterion": "floor_not_first", "value": floor, "expected": "!=1", "weight": w, "contribution": contrib})
+
+    # area total
+    w = 10.0
+    total_weight += w
+    # no explicit expected; give full if present
+    ok = c.parameters.area_total_m2 is not None
+    contrib = w if ok else 0.0
+    total_score += contrib
+    breakdown.append({"criterion": "area_total", "value": c.parameters.area_total_m2, "expected": "present", "weight": w, "contribution": contrib})
+
+    score = (total_score / total_weight * 100.0) if total_weight else 0.0
+    return {"score": round(score, 2), "breakdown": breakdown}
+
+
+def score_cards(cards, profile=None) -> list[dict]:
+    out = []
+    for c in cards:
+        r = score_card(c, profile=profile)
+        out.append({"id": getattr(c, "id", None), "score": r["score"], "breakdown": r["breakdown"]})
+    return out

nedviga/sources.py

@@ -0,0 +1,55 @@
+"""v0.5.2 (the task brief) pluggable source adapters."""
+from __future__ import annotations
+
+from typing import Any, Callable, Optional, Protocol, runtime_checkable
+
+_REGISTRY: list[Any] = []
+
+
+@runtime_checkable
+class SourceAdapter(Protocol):
+    id: str
+    site_patterns: list[str]
+    status: str
+
+    def parse_listing(self, payload: Any) -> Any: ...
+    def search_url(self, params: dict) -> str: ...
+    def fetch(self, params: dict) -> list: ...
+
+
+def register_source(adapter: Any) -> None:
+    _REGISTRY.append(adapter)
+
+
+def list_sources() -> list[dict[str, Any]]:
+    out = []
+    for a in _REGISTRY:
+        out.append({
+            "id": getattr(a, "id", None),
+            "site_patterns": getattr(a, "site_patterns", []),
+            "status": getattr(a, "status", "experimental"),
+        })
+    return out
+
+
+class CianAdapter:
+    id = "cian"
+    site_patterns = ["cian.ru"]
+    status = "ready"
+
+    def parse_listing(self, payload):
+        from .models import ListingCard
+        if isinstance(payload, dict):
+            return ListingCard(**payload)
+        return payload
+
+    def search_url(self, params):
+        return "https://www.cian.ru/cat.php"
+
+    def fetch(self, params):
+        from .cian_live import search
+        return search(**params) if params else []
+
+
+# register default
+register_source(CianAdapter())