walla-cli 0.1.0__py3-none-any.whl

walla/__init__.py

@@ -0,0 +1,7 @@
+"""walla - Wallapop.es look · offer · talk."""
+
+from __future__ import annotations
+
+__all__ = ("__version__",)
+
+__version__ = "0.1.0"

walla/account/__init__.py

@@ -0,0 +1,23 @@
+"""Account package facade."""
+
+from __future__ import annotations
+
+from walla.account.actions import list_favorites, make_offer, quote_offer
+from walla.account.inbox import list_conversations, list_messages, send_message
+from walla.account.login import login_cookie_text, login_cookies, login_password, whoami
+from walla.account.session_store import clear_session, load_session
+
+__all__ = (
+    "clear_session",
+    "list_conversations",
+    "list_favorites",
+    "list_messages",
+    "load_session",
+    "login_cookie_text",
+    "login_cookies",
+    "login_password",
+    "make_offer",
+    "quote_offer",
+    "send_message",
+    "whoami",
+)

walla/account/actions.py

@@ -0,0 +1,135 @@
+"""Favorites and offers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from walla.account.login import ensure_access_token
+from walla.core.exceptions import WallaUnsupportedError
+from walla.http.client import HttpClient
+from walla.hunter.profile_store import load_profile
+from walla.hunter.verdict import haversine_km
+from walla.models.account import OfferQuote
+from walla.models.listing import Listing
+from walla.search.api import get_item
+
+__all__ = (
+    "add_favorite",
+    "list_favorites",
+    "make_offer",
+    "quote_offer",
+    "remove_favorite",
+)
+
+PROTECTION_PCT = 0.09
+SHIPPING_EUR = 4.0
+
+
+def _auth_client() -> HttpClient:
+    sess = ensure_access_token()
+    return HttpClient(access_token=sess.access_token, device_id=sess.device_id)
+
+
+def list_favorites(*, client: HttpClient | None = None) -> list[dict[str, Any]]:
+    http = client or _auth_client()
+    for path in ("/api/v3/users/me/favorites", "/api/v3/favorites"):
+        try:
+            raw = http.get(path, auth=True)
+            if isinstance(raw, dict):
+                items = raw.get("data") or raw.get("items") or raw.get("favorites") or []
+                if isinstance(items, list):
+                    return [i for i in items if isinstance(i, dict)]
+            if isinstance(raw, list):
+                return [i for i in raw if isinstance(i, dict)]
+        except Exception:  # noqa: BLE001
+            continue
+    raise WallaUnsupportedError("Favorites list wire not confirmed. Update docs/WIRE.md.")
+
+
+def add_favorite(item_id: str, *, client: HttpClient | None = None) -> dict[str, Any]:
+    http = client or _auth_client()
+    try:
+        raw = http.post(f"/api/v3/items/{item_id}/favorite", auth=True)
+        return {"favorited": True, "item_id": item_id, "response": raw}
+    except Exception as exc:
+        raise WallaUnsupportedError(f"Favorite add failed: {exc}") from exc
+
+
+def remove_favorite(item_id: str, *, client: HttpClient | None = None) -> dict[str, Any]:
+    http = client or _auth_client()
+    try:
+        raw = http.delete(f"/api/v3/items/{item_id}/favorite", auth=True)
+        return {"favorited": False, "item_id": item_id, "response": raw}
+    except Exception as exc:
+        raise WallaUnsupportedError(f"Favorite remove failed: {exc}") from exc
+
+
+def quote_offer(item: Listing, offer_eur: float) -> OfferQuote:
+    protection = round(offer_eur * PROTECTION_PCT, 2)
+    shipping = SHIPPING_EUR if item.shippable else 0.0
+    profile = load_profile()
+    within = True
+    if (
+        not item.user_allows_shipping
+        and profile.lat is not None
+        and profile.lon is not None
+        and item.location
+        and item.location.latitude is not None
+        and item.location.longitude is not None
+    ):
+        dist = haversine_km(
+            profile.lat,
+            profile.lon,
+            item.location.latitude,
+            item.location.longitude,
+        )
+        within = dist <= profile.pickup_km
+    return OfferQuote(
+        item_id=item.id,
+        offer_eur=offer_eur,
+        protection_eur=protection,
+        shipping_eur=shipping,
+        total_eur=round(offer_eur + protection + shipping, 2),
+        within_pickup=within,
+    )
+
+
+def make_offer(
+    item_id: str,
+    offer_eur: float,
+    *,
+    confirm: bool = False,
+    client: HttpClient | None = None,
+) -> dict[str, Any]:
+    if not confirm:
+        raise ValueError("offer requires confirm=True / --yes")
+    item = get_item(item_id, client=client)
+    quote = quote_offer(item, offer_eur)
+    if not quote.within_pickup:
+        raise ValueError(
+            f"In-person listing outside pickup radius ({item.title}). Refuse offer."
+        )
+    http = client or _auth_client()
+    try:
+        raw = http.post(
+            "/api/v3/delivery/buyer/offers",
+            json_body={
+                "item_id": item_id,
+                "amount": offer_eur,
+                "currency": "EUR",
+            },
+            auth=True,
+        )
+        return {
+            "sent": True,
+            "quote": quote.model_dump(mode="json"),
+            "title": item.title,
+            "response": raw,
+        }
+    except Exception as exc:
+        msg = str(exc)
+        if "409" in msg:
+            raise WallaUnsupportedError("Seller disabled offers (409).") from exc
+        raise WallaUnsupportedError(
+            f"Offer wire failed ({exc}). Capture POST buyer/offers and update WIRE.md."
+        ) from exc

walla/account/cookies.py

@@ -0,0 +1,88 @@
+"""Parse browser cookie exports for NextAuth session."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from walla.core.exceptions import WallaAuthError
+
+__all__ = (
+    "SESSION_COOKIE",
+    "parse_cookie_export",
+    "parse_cookie_text",
+)
+
+SESSION_COOKIE = "__Secure-next-auth.session-token"
+
+
+def parse_cookie_export(path: Path) -> tuple[str, str | None]:
+    """Return (session_cookie, device_id) from a cookies file."""
+    return parse_cookie_text(path.read_text(encoding="utf-8"))
+
+
+def parse_cookie_text(text: str) -> tuple[str, str | None]:
+    """Return (session_cookie, device_id) from pasted text or export body."""
+    stripped = text.strip()
+    if not stripped:
+        raise WallaAuthError(f"empty cookie paste; need {SESSION_COOKIE}")
+    if stripped.startswith("[") or stripped.startswith("{"):
+        return _from_json(stripped)
+    return _from_text(stripped)
+
+
+def _from_json(text: str) -> tuple[str, str | None]:
+    data = json.loads(text)
+    session: str | None = None
+    device: str | None = None
+    rows = data if isinstance(data, list) else [data]
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        name = row.get("name") or row.get("Name")
+        value = row.get("value") or row.get("Value")
+        if name == SESSION_COOKIE and value:
+            session = str(value)
+        if name == "device_id" and value:
+            device = str(value)
+    if not session:
+        raise WallaAuthError(f"no {SESSION_COOKIE} in JSON cookie export")
+    return session, device
+
+
+def _from_text(text: str) -> tuple[str, str | None]:
+    session: str | None = None
+    device: str | None = None
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line or (line.startswith("#") and "HttpOnly" not in line):
+            continue
+        if line.startswith("#HttpOnly_"):
+            line = line[len("#HttpOnly_") :]
+        if "\t" in line:
+            fields = line.split("\t")
+            if len(fields) >= 7:
+                name, value = fields[5], fields[6]
+                if name == SESSION_COOKIE:
+                    session = value
+                elif name == "device_id":
+                    device = value
+            continue
+        line = line.removeprefix("Cookie:").strip()
+        for pair in line.split(";"):
+            pair = pair.strip()
+            if "=" not in pair:
+                if pair.count(".") >= 2 and len(pair) > 100:
+                    session = pair
+                continue
+            name, _, value = pair.partition("=")
+            name, value = name.strip(), value.strip()
+            if name == SESSION_COOKIE:
+                session = value
+            elif name == "device_id":
+                device = value
+    if not session and text.count(".") >= 2 and len(text.strip()) > 100:
+        session = text.strip()
+    if not session:
+        raise WallaAuthError(f"no {SESSION_COOKIE} in cookie paste")
+    return session, device

walla/account/inbox.py

@@ -0,0 +1,147 @@
+"""Authenticated inbox / thread / send."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from walla.account.login import ensure_access_token
+from walla.core.exceptions import WallaUnsupportedError
+from walla.http.client import HttpClient
+from walla.models.account import Conversation, Message
+
+__all__ = (
+    "list_conversations",
+    "list_messages",
+    "send_message",
+)
+
+
+def _auth_client() -> HttpClient:
+    sess = ensure_access_token()
+    return HttpClient(access_token=sess.access_token, device_id=sess.device_id)
+
+
+def list_conversations(*, client: HttpClient | None = None) -> list[Conversation]:
+    http = client or _auth_client()
+    raw = http.get("/api/v3/conversations", params={"max_messages": 1}, auth=True)
+    rows = _extract_list(raw)
+    out: list[Conversation] = []
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        cid = str(row.get("id") or row.get("conversation_id") or "")
+        if not cid:
+            continue
+        item = row.get("item") or row.get("product") or {}
+        user = row.get("user") or row.get("other_user") or {}
+        last = row.get("last_message") or row.get("messages") or {}
+        last_text = None
+        if isinstance(last, dict):
+            last_text = last.get("text") or last.get("message")
+        elif isinstance(last, list) and last:
+            last_text = last[0].get("text") if isinstance(last[0], dict) else None
+        out.append(
+            Conversation(
+                id=cid,
+                item_id=str(item.get("id")) if isinstance(item, dict) and item.get("id") else None,
+                item_title=item.get("title") if isinstance(item, dict) else None,
+                other_user=(
+                    user.get("micro_name") or user.get("name")
+                    if isinstance(user, dict)
+                    else None
+                ),
+                unread=int(row.get("unread_count") or row.get("unread") or 0),
+                last_message=str(last_text) if last_text else None,
+            )
+        )
+    return out
+
+
+def list_messages(conversation_id: str, *, client: HttpClient | None = None) -> list[Message]:
+    http = client or _auth_client()
+    # Try common shapes; first success wins.
+    for path in (
+        f"/api/v3/conversations/{conversation_id}/messages",
+        f"/api/v3/conversations/{conversation_id}",
+    ):
+        try:
+            raw = http.get(path, auth=True)
+        except Exception:  # noqa: BLE001
+            continue
+        rows = _extract_messages(raw)
+        if rows is not None:
+            return rows
+    raise WallaUnsupportedError(
+        "Message thread wire not confirmed for this account. "
+        "Capture GET conversation messages and update docs/WIRE.md."
+    )
+
+
+def send_message(
+    conversation_id: str,
+    text: str,
+    *,
+    confirm: bool = False,
+    client: HttpClient | None = None,
+) -> dict[str, Any]:
+    if not confirm:
+        raise ValueError("send requires confirm=True / --yes")
+    http = client or _auth_client()
+    try:
+        raw = http.post(
+            f"/api/v3/conversations/{conversation_id}/messages",
+            json_body={"text": text, "message": text},
+            auth=True,
+        )
+        return {"sent": True, "conversation_id": conversation_id, "response": raw}
+    except Exception as exc:
+        raise WallaUnsupportedError(
+            f"Send wire failed ({exc}). Capture POST messages and update docs/WIRE.md."
+        ) from exc
+
+
+def _extract_list(raw: Any) -> list[Any]:
+    if isinstance(raw, list):
+        return raw
+    if not isinstance(raw, dict):
+        return []
+    for key in ("conversations", "data", "items"):
+        val = raw.get(key)
+        if isinstance(val, list):
+            return val
+        if isinstance(val, dict):
+            for k2 in ("conversations", "items", "list"):
+                if isinstance(val.get(k2), list):
+                    return cast(list[Any], val[k2])
+    return []
+
+
+def _extract_messages(raw: Any) -> list[Message] | None:
+    rows: list[Any] | None = None
+    if isinstance(raw, list):
+        rows = raw
+    elif isinstance(raw, dict):
+        for key in ("messages", "data", "items"):
+            val = raw.get(key)
+            if isinstance(val, list):
+                rows = val
+                break
+            if isinstance(val, dict) and isinstance(val.get("messages"), list):
+                rows = val["messages"]
+                break
+    if rows is None:
+        return None
+    out: list[Message] = []
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        text = row.get("text") or row.get("message") or ""
+        out.append(
+            Message(
+                id=str(row["id"]) if row.get("id") else None,
+                text=str(text),
+                from_self=bool(row.get("from_self") or row.get("mine")),
+                created_at=row.get("created_at") or row.get("timestamp"),
+            )
+        )
+    return out

walla/account/login.py

@@ -0,0 +1,205 @@
+"""Login: cookie paste (primary) + optional password."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Any, cast
+
+from curl_cffi import requests
+
+from walla.account.cookies import SESSION_COOKIE, parse_cookie_export, parse_cookie_text
+from walla.account.session_store import load_session, save_session
+from walla.core.exceptions import WallaAuthError, WallaHTTPError
+from walla.http.headers import WEB_BASE, default_headers, new_device_id
+from walla.http.polite import wait_turn
+from walla.models.account import SessionData
+
+__all__ = (
+    "ensure_access_token",
+    "login_cookie_text",
+    "login_cookies",
+    "login_password",
+    "mint_access_token",
+    "refresh_session",
+    "whoami",
+)
+
+
+def login_cookie_text(text: str) -> SessionData:
+    """Primary path: pasted cookie value, Cookie header, or export body."""
+    path_candidate = Path(text.strip()).expanduser()
+    if path_candidate.is_file():
+        return login_cookies(path_candidate)
+    cookie, device = parse_cookie_text(text)
+    return _session_from_cookie(cookie, device)
+
+
+def login_cookies(path: Path) -> SessionData:
+    cookie, device = parse_cookie_export(path)
+    return _session_from_cookie(cookie, device)
+
+
+def _session_from_cookie(cookie: str, device: str | None) -> SessionData:
+    session = SessionData(session_cookie=cookie, device_id=device or new_device_id())
+    token, exp = mint_access_token(session)
+    session.access_token = token
+    session.expires_at = exp
+    save_session(session)
+    return session
+
+
+def login_password(*, username: str, password: str) -> SessionData:
+    """Optional fallback. Often fails on MFA; prefer cookie paste."""
+    if not username or not password:
+        raise WallaAuthError("email and password required")
+    device = new_device_id()
+    wait_turn()
+    headers = default_headers(device_id=device)
+    headers["Content-Type"] = "application/json"
+    resp = requests.post(
+        "https://api.wallapop.com/api/v3/access/login",
+        json={"username": username, "password": password},
+        headers=headers,
+        impersonate="chrome",
+        timeout=30,
+    )
+    if resp.status_code != 200 or not resp.content:
+        raise WallaAuthError(
+            f"Password login failed (HTTP {resp.status_code}). "
+            "Paste the session cookie instead: walla login"
+        )
+    body = cast(Any, resp.json())  # type: ignore[no-untyped-call]
+    data = body.get("data") if isinstance(body, dict) else body
+    token_block = data.get("token", data) if isinstance(data, dict) else {}
+    access = (
+        token_block.get("access_token")
+        or token_block.get("accessToken")
+        or (data or {}).get("access_token")
+    )
+    refresh = token_block.get("refresh_token") or token_block.get("refreshToken")
+    if not access:
+        raise WallaAuthError("Password login returned no access token. Use walla login.")
+    session = SessionData(
+        access_token=str(access),
+        refresh_token=str(refresh) if refresh else None,
+        device_id=device,
+        expires_at=time.time() + 300,
+    )
+    save_session(session)
+    return session
+
+
+def mint_access_token(session: SessionData) -> tuple[str, float]:
+    """Mint a short-lived Bearer from the NextAuth session cookie."""
+    if not session.session_cookie:
+        if session.access_token:
+            return session.access_token, session.expires_at or (time.time() + 240)
+        raise WallaAuthError("No session cookie or access token")
+    wait_turn()
+    headers = default_headers(device_id=session.device_id)
+    headers["Cookie"] = f"{SESSION_COOKIE}={session.session_cookie}"
+    resp = requests.get(
+        f"{WEB_BASE}/api/auth/session",
+        headers=headers,
+        impersonate="chrome",
+        timeout=30,
+    )
+    if resp.status_code != 200:
+        raise WallaAuthError(f"Session mint failed (HTTP {resp.status_code})")
+    data = cast(Any, resp.json()) if resp.content else {}  # type: ignore[no-untyped-call]
+    token = data.get("token") if isinstance(data, dict) else None
+    if not token:
+        raise WallaAuthError("Stored session is no longer valid. Run walla login again.")
+    for ck in resp.cookies.jar if hasattr(resp.cookies, "jar") else []:
+        if getattr(ck, "name", None) == SESSION_COOKIE and ck.value:
+            session.session_cookie = ck.value
+    exp = time.time() + 240
+    return str(token), exp
+
+
+def refresh_session(session: SessionData | None = None) -> SessionData:
+    sess = session or load_session()
+    if sess is None:
+        raise WallaAuthError("No session. Run walla login.")
+    if sess.session_cookie:
+        token, exp = mint_access_token(sess)
+        sess.access_token = token
+        sess.expires_at = exp
+        save_session(sess)
+        return sess
+    if sess.refresh_token:
+        wait_turn()
+        headers = default_headers(device_id=sess.device_id)
+        headers["Content-Type"] = "application/json"
+        resp = requests.post(
+            "https://api.wallapop.com/api/v3/access/refresh",
+            json={"refresh_token": sess.refresh_token},
+            headers=headers,
+            impersonate="chrome",
+            timeout=30,
+        )
+        if resp.status_code != 200:
+            raise WallaAuthError(f"Refresh failed (HTTP {resp.status_code})")
+        body = cast(Any, resp.json())  # type: ignore[no-untyped-call]
+        data = body.get("data") if isinstance(body, dict) else body
+        token_block = data.get("token", data) if isinstance(data, dict) else {}
+        access = token_block.get("access_token") or token_block.get("accessToken")
+        if not access:
+            raise WallaAuthError("Refresh returned no access token")
+        sess.access_token = str(access)
+        new_refresh = token_block.get("refresh_token") or token_block.get("refreshToken")
+        if new_refresh:
+            sess.refresh_token = str(new_refresh)
+        sess.expires_at = time.time() + 300
+        save_session(sess)
+        return sess
+    raise WallaAuthError("Session has neither cookie nor refresh token")
+
+
+def ensure_access_token() -> SessionData:
+    sess = load_session()
+    if sess is None:
+        raise WallaAuthError("No session. Run: walla login")
+    if sess.expires_at and sess.expires_at > time.time() + 30 and sess.access_token:
+        return sess
+    return refresh_session(sess)
+
+
+def whoami(*, client_data: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Return account label without secrets."""
+    sess = ensure_access_token()
+    if client_data:
+        return client_data
+    wait_turn()
+    headers = default_headers(device_id=sess.device_id)
+    headers["Authorization"] = f"Bearer {sess.access_token}"
+    resp = requests.get(
+        "https://api.wallapop.com/api/v3/users/me",
+        headers=headers,
+        impersonate="chrome",
+        timeout=30,
+    )
+    if resp.status_code == 404:
+        return {
+            "user_id": sess.user_id,
+            "micro_name": sess.micro_name,
+            "authenticated": True,
+        }
+    if resp.status_code != 200:
+        raise WallaHTTPError(
+            f"whoami failed (HTTP {resp.status_code})",
+            status_code=resp.status_code,
+        )
+    data = cast(Any, resp.json())  # type: ignore[no-untyped-call]
+    user = data.get("data") if isinstance(data.get("data"), dict) else data
+    micro = user.get("micro_name") or user.get("microName")
+    uid = user.get("id") or user.get("user_id")
+    sess.micro_name = str(micro) if micro else sess.micro_name
+    sess.user_id = str(uid) if uid else sess.user_id
+    save_session(sess)
+    return {
+        "user_id": sess.user_id,
+        "micro_name": sess.micro_name,
+        "authenticated": True,
+    }

walla/account/prompt.py

@@ -0,0 +1,56 @@
+"""Interactive login helpers (cookie paste primary)."""
+
+from __future__ import annotations
+
+import getpass
+from typing import Any
+
+import typer
+
+from walla.account.cookies import SESSION_COOKIE
+from walla.account.login import login_cookie_text, login_password
+from walla.core.exceptions import WallaAuthError
+from walla.models.account import SessionData
+
+__all__ = ("interactive_login",)
+
+
+def interactive_login(*, password: bool = False) -> SessionData:
+    """Prompt for cookie paste, or email/password when ``password`` is True."""
+    if password:
+        return _prompt_password()
+    return _prompt_cookie()
+
+
+def _prompt_cookie() -> SessionData:
+    typer.echo(
+        f"Paste {SESSION_COOKIE} (or a cookies.txt path), then Enter:\n"
+        "  Tip: log in at es.wallapop.com → Cookie-Editor → copy that cookie."
+    )
+    raw = typer.prompt("cookie").strip()
+    if not raw:
+        raise WallaAuthError("empty paste")
+    return login_cookie_text(raw)
+
+
+def _prompt_password() -> SessionData:
+    typer.echo(
+        "Password login often fails (MFA). Prefer: walla login  (paste cookie)."
+    )
+    email = typer.prompt("email").strip()
+    pw = getpass.getpass("password: ")
+    try:
+        return login_password(username=email, password=pw)
+    except WallaAuthError:
+        typer.echo("Password rejected. Paste the session cookie instead.")
+        return _prompt_cookie()
+
+
+def session_summary(sess: SessionData) -> dict[str, Any]:
+    return {
+        "authenticated": True,
+        "has_access_token": bool(sess.access_token),
+        "has_cookie": bool(sess.session_cookie),
+        "user_id": sess.user_id,
+        "micro_name": sess.micro_name,
+    }