nedviga-cli 0.1.0__py3-none-any.whl

nedviga/browser_native.py

@@ -0,0 +1,242 @@
+"""Native embedded Camoufox browser for nedviga (no external HTTP service).
+
+Replaces any external browser service with an in-process browser launched via
+the ``camoufox`` Python library. Fail-closed: every failure surfaces as
+:class:`FetchError` with an actionable message — never a fabricated result.
+
+Design:
+- Lazy singleton: the browser process starts on the first ``fetch()`` call and
+  stays alive for the process lifetime (per CLI invocation, per API process).
+- Bounded crash recovery: if the browser dies mid-flight ("window is null",
+  protocol errors), the next ``fetch()`` relaunches it once.
+- GTK workaround: system ``libgtk-3.so.0`` may be absent; the bundled libs in
+  ``~/.local/camofox-libs`` are injected via LD_LIBRARY_PATH before Playwright
+  launches. Configurable through ``CW_NEDVIGA_LD_PATH``.
+- Thread-safety: guarded by locks; the sync Playwright API is used, one page at
+  a time.
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+from .errors import FetchError
+
+NativeFetcher = Callable[[str], str]
+
+_native_tls = threading.local()
+
+_LAUNCH_LOCK = threading.Lock()
+_FETCH_LOCK = threading.Lock()
+_BROWSER_HOLDER: dict[str, Any] = {"browser": None, "pw": None}
+_RELAUNCH_TS = 0.0
+_RELAUNCH_MIN_INTERVAL = 5.0
+
+# Locations of bundled GTK libs (same set the external camofox-browser service
+# uses), checked in order. Only the first existing path is injected.
+_CANDIDATE_LD_PATHS = (
+    "~/.local/camofox-libs/usr/lib/x86_64-linux-gnu",
+    "~/.local/camofox-libs/usr/lib/x86_64-linux-gnu:"
+    "~/.local/camofox-libs/lib/x86_64-linux-gnu",
+)
+
+
+def _library_path() -> str | None:
+    """Resolve LD_LIBRARY_PATH addition for the embedded browser."""
+    override = os.environ.get("CW_NEDVIGA_LD_PATH")
+    if override:
+        return override
+    for candidate in _CANDIDATE_LD_PATHS:
+        parts = [os.path.expanduser(p) for p in candidate.split(":")]
+        if all(os.path.exists(p) for p in parts):
+            return ":".join(parts)
+    return None
+
+
+def _install_cache_env() -> None:
+    """Isolate the python-camoufox browser cache from any other service cache.
+
+    The external camofox-browser service (node) and the python camoufox package
+    share ``~/.cache/camoufox`` by default but expect DIFFERENT layouts; a
+    python ``camoufox fetch`` wipes the node-side metadata. Point python at its
+    own XDG cache dir (its INSTALL_DIR = $XDG_CACHE_HOME/camoufox).
+    """
+    cache = os.environ.get(
+        "CW_NEDVIGA_CACHE", str(Path.home() / ".cache" / "nedviga-py")
+    )
+    os.environ.setdefault("XDG_CACHE_HOME", cache)
+
+
+def ensure_launch_env() -> None:
+    """Inject bundled GTK libs into LD_LIBRARY_PATH.
+
+    Must run BEFORE Playwright spawns the browser process: the driver
+    propagates the current process environment at spawn time, so setting it
+    later has no effect. Called at module import (idempotent).
+    """
+    ld = _library_path()
+    if not ld:
+        return
+    current = os.environ.get("LD_LIBRARY_PATH", "")
+    if ld in current:
+        return
+    os.environ["LD_LIBRARY_PATH"] = f"{ld}:{current}" if current else ld
+
+
+def native_available() -> bool:
+    """True when the camoufox python package can be imported."""
+    try:
+        import camoufox  # noqa: F401
+
+        return True
+    except Exception:
+        return False
+
+
+def _launch_browser() -> Any:
+    """Launch the embedded Camoufox browser; return (playwright, browser)."""
+    try:
+        from camoufox.sync_api import Camoufox
+    except Exception as exc:  # pragma: no cover - import-time
+        raise FetchError(
+            f"embedded camoufox not importable: {exc}. "
+            "Install it with: pip install 'camoufox[geoip]' && "
+            "python3 -m camoufox fetch"
+        ) from exc
+
+    try:
+        profile_dir = Path.home() / ".cache" / "nedviga-cli" / "native-profile"
+        profile_dir.mkdir(parents=True, exist_ok=True)
+        pw_browser = Camoufox(
+            headless=True,
+            humanize=True,
+            os="linux",
+            persistent_context=True,
+            user_data_dir=str(profile_dir),
+            enable_cache=True,
+        )
+        browser = pw_browser.__enter__()
+        return pw_browser, browser
+    except Exception as exc:
+        raise FetchError(
+            f"embedded camoufox launch failed: {exc}. "
+            "Check camoufox installation and GTK libs "
+            "(CW_NEDVIGA_LD_PATH may point at bundled libs)."
+        ) from exc
+
+
+def _get_browser() -> Any:
+    """Return the live browser, (re)launching if needed."""
+    global _RELAUNCH_TS
+    with _LAUNCH_LOCK:
+        browser = _BROWSER_HOLDER.get("browser")
+        if browser is not None:
+            try:
+                # Cheap liveness probe: an attached context object.
+                _ = browser.browser_type  # attribute touch
+                return browser
+            except Exception:
+                # Browser died; fall through to relaunch.
+                pass
+        now = time.monotonic()
+        if (
+            now - _RELAUNCH_TS < _RELAUNCH_MIN_INTERVAL
+            and _BROWSER_HOLDER.get("browser") is None
+        ):
+            raise FetchError(
+                "embedded camoufox relaunch cooldown active (recent crash). "
+                "Retry in a few seconds."
+            )
+        _RELAUNCH_TS = now
+        _install_cache_env()
+        ensure_launch_env()
+        pw, browser = _launch_browser()
+        _BROWSER_HOLDER["pw"] = pw
+        _BROWSER_HOLDER["browser"] = browser
+        return browser
+
+
+def _close_browser() -> None:
+    with _LAUNCH_LOCK:
+        browser = _BROWSER_HOLDER.get("browser")
+        pw = _BROWSER_HOLDER.get("pw")
+        try:
+            if pw is not None:
+                pw.__exit__(None, None, None)
+        except Exception:
+            pass
+        _BROWSER_HOLDER["browser"] = None
+        _BROWSER_HOLDER["pw"] = None
+
+
+def get_last_http_status() -> str | None:
+    """Return the HTTP status code (as string) from the most recent ``native_fetch``.
+
+    Returns ``None`` if no fetch has been performed or if the status is unavailable.
+    Thread-local: each thread sees only its own last status.
+    """
+    status = getattr(_native_tls, "http_status", None)
+    return str(status) if status is not None else None
+
+
+def native_fetch(
+    url: str, *, timeout: float = 60.0, settle_ms: int = 1500
+) -> str:
+    """Render ``url`` through the embedded Camoufox and return outerHTML.
+
+    Fail-closed: any launch/navigation/evaluate failure raises :class:`FetchError`
+    with an actionable message.
+
+    After each call (success or failure) the HTTP status code is available via
+    :func:`get_last_http_status` for challenge detection.
+    """
+    with _FETCH_LOCK:
+        _native_tls.http_status = None
+        browser = _get_browser()
+        page = None
+        try:
+            try:
+                page = browser.new_page()
+            except Exception as exc:
+                # Browser process died between calls: one relaunch attempt.
+                _close_browser()
+                browser = _get_browser()
+                page = browser.new_page()
+            response = page.goto(url, timeout=int(timeout * 1000))
+            if response is not None:
+                _native_tls.http_status = response.status
+            # Brief settle for JS-rendered content.
+            time.sleep(settle_ms / 1000.0)
+            html = page.evaluate("document.documentElement.outerHTML")
+            if not isinstance(html, str) or not html.strip():
+                raise FetchError(f"embedded camoufox: empty DOM for {url}")
+            return html
+        except FetchError:
+            raise
+        except Exception as exc:
+            # Mark the browser dead so the next call relaunches cleanly.
+            _close_browser()
+            raise FetchError(
+                f"embedded camoufox fetch failed for {url}: {exc}. "
+                "The browser will relaunch on the next call."
+            ) from exc
+        finally:
+            if page is not None:
+                try:
+                    page.close()
+                except Exception:
+                    pass
+
+
+def native_status() -> dict[str, Any]:
+    """Machine-readable status of the embedded browser (for doctor)."""
+    browser = _BROWSER_HOLDER.get("browser")
+    return {
+        "mode": "native",
+        "available": native_available(),
+        "running": browser is not None,
+    }

nedviga/callsheet.py

@@ -0,0 +1,63 @@
+"""v0.5.0 (the task brief) call-sheet."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+from .legal_triage import triage
+from .models import ListingCard
+from .pii import PHONE_MASK
+
+
+def _listing(card: Any) -> ListingCard:
+    if isinstance(card, ListingCard):
+        return card
+    if isinstance(card, dict):
+        return ListingCard(**card)
+    raise TypeError("unsupported card")
+
+
+def _load_cards(path: str) -> list[ListingCard]:
+    raw = json.loads(Path(path).read_text(encoding="utf-8"))
+    if isinstance(raw, dict):
+        if "cards" in raw and isinstance(raw["cards"], list):
+            raw = raw["cards"]
+        elif "data" in raw:
+            d = raw["data"]
+            raw = d if isinstance(d, list) else ([d] if isinstance(d, dict) else [])
+        else:
+            raw = [raw]
+    if not isinstance(raw, list):
+        raw = [raw]
+    return [_listing(x) for x in raw if isinstance(x, (dict, ListingCard))]
+
+
+def build_callsheet(cards: list[ListingCard], with_contacts: bool = False) -> str:
+    lines: list[str] = []
+    for c in cards:
+        t = triage(c)
+        phones = [str(p) for p in (c.seller.phones if c.seller else []) if str(p or "").strip()]
+        if with_contacts:
+            phone_str = " · ".join(phones) if phones else "нет"
+        else:
+            phone_str = " · ".join(PHONE_MASK for _ in phones) if phones else "нет"
+        lines.append(f"📞 {c.title or c.id}")
+        lines.append(f"Телефон: {phone_str}")
+        lines.append(f"Цена: {c.pricing.price_total_rub} ₽ ({c.pricing.price_per_m2_rub} ₽/м²)")
+        lines.append(f"Район: {c.geo.district or 'нет данных'}")
+        lines.append("Вопросы:")
+        lines.append("• Почему цена отличается от медианы группы? (если применимо)")
+        lines.append("• История цены объявления?")
+        lines.append("• Кто собственник, сколько владеет?")
+        lines.append("• Есть обременения/аресты?")
+        lines.append("• Альтернатива? Ключи/показы в будни?")
+        lines.append("• Торг возможен?")
+        if t["flags"]:
+            lines.append("⚠ Аккуратно: " + ", ".join(f["code"] for f in t["flags"]) + " — уточнить статус")
+        lines.append("")
+    return "\n".join(lines).strip()
+
+
+def render_telegram(text: str) -> str:
+    return text

nedviga/chains.py

@@ -0,0 +1,83 @@
+"""v0.5.4 (the task brief) deal chains."""
+from __future__ import annotations
+
+import os
+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 deal_structures (
+        card_id TEXT PRIMARY KEY, kind TEXT NOT NULL, created TEXT NOT NULL)""")
+    conn.execute("""CREATE TABLE IF NOT EXISTS chain_links (
+        a TEXT NOT NULL, b TEXT NOT NULL, rel TEXT NOT NULL,
+        UNIQUE(a,b,rel))""")
+    conn.commit()
+    return conn
+
+
+def chain_new(card_id: str, kind: str, db=None) -> dict:
+    conn = _connect(db)
+    try:
+        conn.execute("INSERT OR REPLACE INTO deal_structures (card_id, kind, created) VALUES (?,?,?)",
+                     (card_id, kind, pipeline._now()))
+        conn.commit()
+        return {"ok": True, "card_id": card_id, "kind": kind}
+    finally:
+        conn.close()
+
+
+def _has_path(start: str, target: str, db=None) -> bool:
+    conn = _connect(db)
+    try:
+        # BFS over links a->b
+        seen = set()
+        stack = [start]
+        while stack:
+            cur = stack.pop()
+            if cur == target:
+                return True
+            if cur in seen:
+                continue
+            seen.add(cur)
+            rows = conn.execute("SELECT b FROM chain_links WHERE a=?", (cur,)).fetchall()
+            for r in rows:
+                if r["b"] not in seen:
+                    stack.append(r["b"])
+        return False
+    finally:
+        conn.close()
+
+
+def chain_link(a: str, b: str, rel: str, db=None) -> dict:
+    if _has_path(b, a, db=db):
+        return {"ok": False, "reason": "cycle_detected"}
+    conn = _connect(db)
+    try:
+        conn.execute("INSERT OR REPLACE INTO chain_links (a,b,rel) VALUES (?,?,?)", (a, b, rel))
+        conn.commit()
+        return {"ok": True, "a": a, "b": b, "rel": rel}
+    finally:
+        conn.close()
+
+
+def chain_show(card_id: str, db=None) -> dict:
+    conn = _connect(db)
+    try:
+        row = conn.execute("SELECT * FROM deal_structures WHERE card_id=?", (card_id,)).fetchone()
+        links = conn.execute("SELECT * FROM chain_links WHERE a=? OR b=?", (card_id, card_id)).fetchall()
+        # gather up to 10 nodes
+        nodes = {card_id}
+        for r in links:
+            nodes.add(r["a"]); nodes.add(r["b"])
+        nodes = list(nodes)[:10]
+        risk = None
+        if row and row["kind"] == "alt_unfound":
+            risk = "risk: развал вероятен — альтернатива не подобрана"
+        return {"card_id": card_id, "kind": row["kind"] if row else None,
+                "nodes": nodes, "links": [dict(r) for r in links], "risk": risk}
+    finally:
+        conn.close()

nedviga/checklist.py

@@ -0,0 +1,119 @@
+"""v0.5.0 (the task brief) checklist."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+import os
+import subprocess
+from pathlib import Path as _Path
+
+from .legal_triage import load_legal_data, triage
+from .models import ListingCard
+
+
+def _load_card(card_id: str, file: str) -> ListingCard:
+    raw = json.loads(Path(file).read_text(encoding="utf-8"))
+    if isinstance(raw, dict):
+        if "cards" in raw and isinstance(raw["cards"], list):
+            raw = raw["cards"]
+        elif "data" in raw:
+            d = raw["data"]
+            raw = d if isinstance(d, list) else ([d] if isinstance(d, dict) else [])
+        else:
+            raw = [raw]
+    if not isinstance(raw, list):
+        raw = [raw]
+    for item in raw:
+        if isinstance(item, dict) and item.get("id") == card_id:
+            return ListingCard(**item)
+    if raw and isinstance(raw[0], dict):
+        return ListingCard(**raw[0])
+    raise ValueError("card not found")
+
+
+def new_checklist(card_id: str, file: str) -> str:
+    card = _load_card(card_id, file)
+    data = load_legal_data()
+    t = triage(card)
+    lines = [f"# Чек-лист юридической проверки — {card_id}", ""]
+    lines.append(data.get("disclaimer", ""))
+    lines.append("")
+    lines.append("## Триаж (red flags)")
+    if t["flags"]:
+        for f in t["flags"]:
+            lines.append(f"- ⚠ {f['code']} ({f['severity']}): {f['text_basis']}")
+            lines.append(f"  Проверка: {f['check']}")
+    else:
+        lines.append("- Маркеры не выявлены (предварительно).")
+    lines.append("")
+    lines.append("## Пункты проверки")
+    for i, item in enumerate(data.get("checklist", []), 1):
+        lines.append(f"- [ ] {item}")
+    return "\n".join(lines)
+
+
+def _a2a_bin() -> str:
+    return os.environ.get("A2A_BIN", "a2a")
+
+
+def _drafts_dir() -> Path:
+    base = Path(os.environ.get("NEDVIGA_STATE_DIR", str(Path.home() / ".local" / "share" / "nedviga")))
+    d = base / "drafts"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def handoff(card_id: str, to: str, file: Optional[str] = None) -> dict:
+    from .models import ListingCard
+    import json as _json
+
+    card = None
+    if file:
+        try:
+            card = _load_card(card_id, file)
+        except Exception:
+            card = None
+    data = load_legal_data()
+    t = triage(card) if card is not None else {"flags": [], "disclaimer": data.get("disclaimer")}
+    # build obfuscated fact block
+    price = None
+    address = None
+    if card is not None:
+        price = card.pricing.price_total_rub
+        address = card.building.address_raw
+    fact_lines = [f"Карточка: {card_id}"]
+    if address:
+        fact_lines.append(f"Адрес: {address}")
+    if price is not None:
+        fact_lines.append(f"Цена: {price}")
+    fact_lines.append("Флаги triage:")
+    for f in t.get("flags", []):
+        fact_lines.append(f"- {f['code']} ({f['severity']}): {f['text_basis']}")
+    if not t.get("flags"):
+        fact_lines.append("- (нет выявленных маркеров)")
+    fact_lines.append("")
+    fact_lines.append("Чек-лист:")
+    for item in data.get("checklist", []):
+        fact_lines.append(f"- [ ] {item}")
+    fact_lines.append("")
+    fact_lines.append(data.get("disclaimer", ""))
+    body = "\n".join(fact_lines)
+    subject = f"Handoff: юридическая проверка {card_id}"
+
+    draft_path = _drafts_dir() / f"{card_id}.md"
+    draft_path.write_text(body, encoding="utf-8")
+
+    bin_path = _a2a_bin()
+    try:
+        proc = subprocess.run(
+            [bin_path, "mail", "send", "--to", to, "--subject", subject, "--body", body],
+            capture_output=True, text=True, timeout=30,
+        )
+    except Exception as exc:
+        return {"ok": False, "reason": f"a2a_unavailable: {exc}", "draft": str(draft_path)}
+    if proc.returncode != 0:
+        return {"ok": False, "reason": f"a2a_error: {proc.stderr.strip() or proc.stdout.strip()}",
+                "draft": str(draft_path), "returncode": proc.returncode}
+    return {"ok": True, "draft": str(draft_path), "stdout": proc.stdout.strip()}