walla-cli 0.1.0__py3-none-any.whl

walla/hunter/verdict.py

@@ -0,0 +1,42 @@
+"""GRAB / LOOK / PASS scoring (pure)."""
+
+from __future__ import annotations
+
+import math
+
+from walla.models.listing import Listing
+from walla.models.profile import Profile
+
+__all__ = (
+    "haversine_km",
+    "score_listing",
+)
+
+
+def haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    r = 6371.0
+    p1, p2 = math.radians(lat1), math.radians(lat2)
+    dphi = math.radians(lat2 - lat1)
+    dlmb = math.radians(lon2 - lon1)
+    a = math.sin(dphi / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dlmb / 2) ** 2
+    return 2 * r * math.asin(math.sqrt(a))
+
+
+def score_listing(listing: Listing, profile: Profile) -> str:
+    """Return GRAB / LOOK / PASS."""
+    if listing.reserved:
+        return "PASS"
+    budget = profile.budget or profile.max_price
+    if budget is not None and listing.price.amount > budget:
+        return "PASS"
+    if profile.lat is not None and profile.lon is not None and listing.location:
+        la, lo = listing.location.latitude, listing.location.longitude
+        if la is not None and lo is not None:
+            dist = haversine_km(profile.lat, profile.lon, la, lo)
+            if dist > profile.km and not listing.user_allows_shipping:
+                return "PASS"
+            if budget is not None and listing.price.amount <= budget * 0.85 and dist <= profile.km:
+                return "GRAB"
+    if budget is not None and listing.price.amount <= budget * 0.9:
+        return "GRAB"
+    return "LOOK"

walla/hunter/watches.py

@@ -0,0 +1,60 @@
+"""Local saved searches with new-id diff."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from walla.core.path import watches_path
+
+__all__ = (
+    "Watch",
+    "WatchStore",
+    "diff_new_ids",
+    "load_watches",
+    "save_watches",
+)
+
+
+class Watch(BaseModel):
+    id: str
+    keywords: str
+    max_price: float | None = None
+    category_id: int | None = None
+    seen_ids: list[str] = Field(default_factory=list)
+
+
+class WatchStore(BaseModel):
+    schema_version: int = 1
+    watches: list[Watch] = Field(default_factory=list)
+
+
+def load_watches(path: Path | None = None) -> WatchStore:
+    p = path or watches_path()
+    if not p.is_file():
+        return WatchStore()
+    return WatchStore.model_validate(json.loads(p.read_text(encoding="utf-8")))
+
+
+def save_watches(store: WatchStore, path: Path | None = None) -> Path:
+    p = path or watches_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(store.model_dump_json(indent=2), encoding="utf-8")
+    return p
+
+
+def diff_new_ids(seen: list[str], found: list[str]) -> list[str]:
+    known = set(seen)
+    return [i for i in found if i not in known]
+
+
+def merge_seen(watch: Watch, found_ids: list[str]) -> Watch:
+    merged = list(dict.fromkeys([*watch.seen_ids, *found_ids]))
+    return watch.model_copy(update={"seen_ids": merged})
+
+
+def watch_to_dict(watch: Watch) -> dict[str, Any]:
+    return watch.model_dump(mode="json")

walla/mcp/__init__.py

@@ -0,0 +1,7 @@
+"""MCP package."""
+
+from __future__ import annotations
+
+from walla.mcp._entry import run, run_http
+
+__all__ = ("run", "run_http")

walla/mcp/_entry.py

@@ -0,0 +1,17 @@
+"""MCP entrypoints."""
+
+from __future__ import annotations
+
+__all__ = ("run", "run_http")
+
+
+def run() -> None:
+    from walla.mcp.server import build_server
+
+    build_server().run()
+
+
+def run_http() -> None:
+    from walla.mcp.server import build_server
+
+    build_server().run(transport="streamable-http", host="127.0.0.1", port=8000)

walla/mcp/server.py

@@ -0,0 +1,135 @@
+"""FastMCP server over walla core (no CLI imports)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from walla.account.actions import make_offer, quote_offer
+from walla.account.inbox import list_conversations, list_messages, send_message
+from walla.account.login import login_cookie_text, whoami
+from walla.core.envelope import error_payload, success_payload
+from walla.core.instruct import instruct_recipe
+from walla.hunter.profile_store import load_profile
+from walla.hunter.verdict import score_listing
+from walla.search.api import get_categories, get_item, search_listings
+
+__all__ = ("build_server",)
+
+
+def _wrap(fn: Any) -> dict[str, Any]:
+    try:
+        return success_payload(fn())
+    except Exception as exc:  # noqa: BLE001
+        return error_payload(exc)
+
+
+def build_server() -> Any:
+    from fastmcp import FastMCP
+
+    mcp = FastMCP("walla")
+
+    @mcp.tool()
+    def instruct() -> dict[str, Any]:
+        return _wrap(instruct_recipe)
+
+    @mcp.tool()
+    def search(
+        keywords: str,
+        max_results: int = 40,
+        min_price: float | None = None,
+        max_price: float | None = None,
+    ) -> dict[str, Any]:
+        def _run() -> dict[str, Any]:
+            profile = load_profile()
+            if not profile.ready or profile.lat is None or profile.lon is None:
+                return {
+                    "ready": False,
+                    "intake": {"prompt_to_user": profile.intake_prompt()},
+                }
+            result = search_listings(
+                keywords,
+                latitude=profile.lat,
+                longitude=profile.lon,
+                max_results=max_results,
+                min_price=min_price,
+                max_price=max_price or profile.budget,
+            )
+            rows = []
+            for listing in result.listings:
+                listing.verdict = score_listing(listing, profile)
+                rows.append(listing.model_dump(mode="json"))
+            return {"count": len(rows), "listings": rows}
+
+        return _wrap(_run)
+
+    @mcp.tool()
+    def item(item_id: str) -> dict[str, Any]:
+        def _run() -> dict[str, Any]:
+            listing = get_item(item_id)
+            listing.verdict = score_listing(listing, load_profile())
+            return listing.model_dump(mode="json")
+
+        return _wrap(_run)
+
+    @mcp.tool()
+    def categories() -> dict[str, Any]:
+        return _wrap(
+            lambda: {"categories": [c.model_dump(mode="json") for c in get_categories()]}
+        )
+
+    @mcp.tool()
+    def login(cookie: str) -> dict[str, Any]:
+        """Log in with a pasted __Secure-next-auth.session-token value."""
+
+        def _run() -> dict[str, Any]:
+            sess = login_cookie_text(cookie)
+            return {
+                "authenticated": True,
+                "has_access_token": bool(sess.access_token),
+                "has_cookie": bool(sess.session_cookie),
+            }
+
+        return _wrap(_run)
+
+    @mcp.tool()
+    def inbox() -> dict[str, Any]:
+        return _wrap(
+            lambda: {
+                "conversations": [c.model_dump(mode="json") for c in list_conversations()]
+            }
+        )
+
+    @mcp.tool()
+    def thread(conversation_id: str) -> dict[str, Any]:
+        return _wrap(
+            lambda: {
+                "messages": [
+                    m.model_dump(mode="json") for m in list_messages(conversation_id)
+                ]
+            }
+        )
+
+    @mcp.tool()
+    def say(conversation_id: str, text: str, confirm: bool = False) -> dict[str, Any]:
+        return _wrap(lambda: send_message(conversation_id, text, confirm=confirm))
+
+    @mcp.tool()
+    def offer(item_id: str, eur: float, confirm: bool = False) -> dict[str, Any]:
+        def _run() -> dict[str, Any]:
+            if not confirm:
+                listing = get_item(item_id)
+                q = quote_offer(listing, eur)
+                return {
+                    "needs_confirm": True,
+                    "quote": q.model_dump(mode="json"),
+                    "title": listing.title,
+                }
+            return make_offer(item_id, eur, confirm=True)
+
+        return _wrap(_run)
+
+    @mcp.tool()
+    def me() -> dict[str, Any]:
+        return _wrap(whoami)
+
+    return mcp

walla/models/__init__.py

@@ -0,0 +1,18 @@
+"""Models facade."""
+
+from __future__ import annotations
+
+from walla.models.account import Conversation, Message, OfferQuote, SessionData
+from walla.models.listing import Listing, SearchResult
+from walla.models.profile import Category, Profile
+
+__all__ = (
+    "Category",
+    "Conversation",
+    "Listing",
+    "Message",
+    "OfferQuote",
+    "Profile",
+    "SearchResult",
+    "SessionData",
+)

walla/models/account.py

@@ -0,0 +1,48 @@
+"""Session and messaging models."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+__all__ = (
+    "Conversation",
+    "Message",
+    "OfferQuote",
+    "SessionData",
+)
+
+
+class SessionData(BaseModel):
+    schema_version: int = 1
+    access_token: str | None = None
+    refresh_token: str | None = None
+    session_cookie: str | None = None
+    device_id: str | None = None
+    user_id: str | None = None
+    micro_name: str | None = None
+    expires_at: float | None = None
+
+
+class Conversation(BaseModel):
+    id: str
+    item_id: str | None = None
+    item_title: str | None = None
+    other_user: str | None = None
+    unread: int = 0
+    last_message: str | None = None
+
+
+class Message(BaseModel):
+    id: str | None = None
+    text: str
+    from_self: bool = False
+    created_at: int | None = None
+
+
+class OfferQuote(BaseModel):
+    item_id: str
+    offer_eur: float
+    protection_eur: float
+    shipping_eur: float
+    total_eur: float
+    within_pickup: bool = True

walla/models/listing.py

@@ -0,0 +1,51 @@
+"""Pydantic listing models (no I/O)."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+__all__ = (
+    "Listing",
+    "ListingLocation",
+    "Money",
+    "SearchResult",
+)
+
+
+class Money(BaseModel):
+    amount: float
+    currency: str = "EUR"
+
+
+class ListingLocation(BaseModel):
+    latitude: float | None = None
+    longitude: float | None = None
+    city: str | None = None
+    postal_code: str | None = None
+    region: str | None = None
+    country_code: str | None = None
+
+
+class Listing(BaseModel):
+    id: str
+    title: str
+    description: str | None = None
+    price: Money
+    web_slug: str
+    url: str
+    category_id: int | None = None
+    reserved: bool = False
+    shippable: bool = False
+    user_allows_shipping: bool = False
+    location: ListingLocation | None = None
+    image_url: str | None = None
+    created_at: int | None = None
+    modified_at: int | None = None
+    user_id: str | None = None
+    verdict: str | None = None
+
+
+class SearchResult(BaseModel):
+    listings: list[Listing] = Field(default_factory=list)
+    next_page: str | None = None
+    count: int = 0

walla/models/profile.py

@@ -0,0 +1,37 @@
+"""Category and profile models."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+__all__ = (
+    "Category",
+    "Profile",
+)
+
+
+class Category(BaseModel):
+    id: int
+    name: str
+    icon: str | None = None
+    vertical_id: str | None = None
+
+
+class Profile(BaseModel):
+    schema_version: int = 1
+    lat: float | None = None
+    lon: float | None = None
+    km: float = 30.0
+    pickup_km: float = 30.0
+    label: str | None = None
+    max_price: float | None = None
+    budget: float | None = None
+
+    @property
+    def ready(self) -> bool:
+        return self.lat is not None and self.lon is not None
+
+    def intake_prompt(self) -> str:
+        return (
+            "lat=41.39 lon=2.17 km=30 pickup_km=30 label=Barcelona budget=250"
+        )

walla/search/__init__.py

@@ -0,0 +1,15 @@
+"""Search package facade."""
+
+from __future__ import annotations
+
+from walla.search.api import get_categories, get_item, search_listings
+from walla.search.parse import parse_categories, parse_item, parse_search
+
+__all__ = (
+    "get_categories",
+    "get_item",
+    "parse_categories",
+    "parse_item",
+    "parse_search",
+    "search_listings",
+)

walla/search/api.py

@@ -0,0 +1,78 @@
+"""Public Wallapop search / item / categories."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from walla.http.client import HttpClient
+from walla.models.listing import Listing, SearchResult
+from walla.models.profile import Category
+from walla.search.parse import parse_categories, parse_item, parse_search
+
+__all__ = (
+    "get_categories",
+    "get_item",
+    "search_listings",
+)
+
+
+def search_listings(
+    keywords: str,
+    *,
+    latitude: float,
+    longitude: float,
+    max_results: int = 40,
+    min_price: float | None = None,
+    max_price: float | None = None,
+    category_id: int | None = None,
+    order_by: str = "most_relevance",
+    next_page: str | None = None,
+    client: HttpClient | None = None,
+) -> SearchResult:
+    http = client or HttpClient()
+    collected: list[Listing] = []
+    cursor = next_page
+    last: SearchResult | None = None
+    while len(collected) < max_results:
+        params: dict[str, Any] = {
+            "source": "search_box",
+            "keywords": keywords,
+            "latitude": latitude,
+            "longitude": longitude,
+            "order_by": order_by,
+        }
+        if min_price is not None:
+            params["min_sale_price"] = min_price
+        if max_price is not None:
+            params["max_sale_price"] = max_price
+        if category_id is not None:
+            params["category_id"] = category_id
+        if cursor:
+            params["next_page"] = cursor
+        raw = http.get("/api/v3/search", params=params, use_cache=True)
+        page = parse_search(raw)
+        last = page
+        if not page.listings:
+            break
+        collected.extend(page.listings)
+        if not page.next_page:
+            break
+        cursor = page.next_page
+    listings = collected[:max_results]
+    return SearchResult(
+        listings=listings,
+        next_page=last.next_page if last else None,
+        count=len(listings),
+    )
+
+
+def get_item(item_id: str, *, client: HttpClient | None = None) -> Listing:
+    http = client or HttpClient()
+    raw = http.get(f"/api/v3/items/{item_id}", use_cache=True)
+    return parse_item(raw)
+
+
+def get_categories(*, client: HttpClient | None = None) -> list[Category]:
+    http = client or HttpClient()
+    raw = http.get("/api/v3/categories", use_cache=True)
+    return parse_categories(raw)

walla/search/parse.py

@@ -0,0 +1,150 @@
+"""Parse Wallapop search / item JSON into Listing models."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from walla.core.exceptions import WallaParseError
+from walla.models.listing import Listing, ListingLocation, Money, SearchResult
+from walla.models.profile import Category
+
+__all__ = (
+    "item_url",
+    "parse_categories",
+    "parse_item",
+    "parse_search",
+)
+
+
+def item_url(web_slug: str) -> str:
+    return f"https://es.wallapop.com/item/{web_slug}"
+
+
+def _flag(obj: Any) -> bool:
+    if isinstance(obj, dict):
+        return bool(obj.get("flag"))
+    return bool(obj)
+
+
+def _money(obj: Any) -> Money:
+    if isinstance(obj, dict):
+        amount = obj.get("amount")
+        if isinstance(amount, dict):
+            amount = amount.get("value") or amount.get("amount")
+        currency = obj.get("currency") or "EUR"
+        if amount is None:
+            raise WallaParseError("missing price.amount")
+        return Money(amount=float(amount), currency=str(currency))
+    raise WallaParseError("invalid price")
+
+
+def _location(obj: Any) -> ListingLocation | None:
+    if not isinstance(obj, dict):
+        return None
+    return ListingLocation(
+        latitude=obj.get("latitude"),
+        longitude=obj.get("longitude"),
+        city=obj.get("city"),
+        postal_code=obj.get("postal_code"),
+        region=obj.get("region"),
+        country_code=obj.get("country_code"),
+    )
+
+
+def _image_url(images: Any) -> str | None:
+    if not isinstance(images, list) or not images:
+        return None
+    first = images[0]
+    if not isinstance(first, dict):
+        return None
+    urls = first.get("urls") or {}
+    if isinstance(urls, dict):
+        return urls.get("medium") or urls.get("small") or urls.get("big")
+    return None
+
+
+def parse_listing_row(raw: dict[str, Any]) -> Listing:
+    web_slug = raw.get("web_slug") or raw.get("slug") or ""
+    title = raw.get("title")
+    if isinstance(title, dict):
+        title = title.get("original") or title.get("text") or ""
+    description = raw.get("description")
+    if isinstance(description, dict):
+        description = description.get("original") or description.get("text")
+    shipping = raw.get("shipping") or {}
+    price_raw = raw.get("price")
+    if isinstance(price_raw, dict) and "amount" not in price_raw and "cash" in price_raw:
+        price_raw = price_raw.get("cash")
+    return Listing(
+        id=str(raw["id"]),
+        title=str(title or ""),
+        description=str(description) if description else None,
+        price=_money(price_raw),
+        web_slug=str(web_slug),
+        url=item_url(str(web_slug)) if web_slug else "",
+        category_id=int(raw["category_id"]) if raw.get("category_id") is not None else None,
+        reserved=_flag(raw.get("reserved")),
+        shippable=bool(
+            shipping.get("item_is_shippable")
+            if isinstance(shipping, dict)
+            else raw.get("supports_shipping")
+        ),
+        user_allows_shipping=bool(
+            shipping.get("user_allows_shipping") if isinstance(shipping, dict) else False
+        ),
+        location=_location(raw.get("location")),
+        image_url=_image_url(raw.get("images")),
+        created_at=raw.get("created_at") or raw.get("modified_date"),
+        modified_at=raw.get("modified_at") or raw.get("modified_date"),
+        user_id=(raw.get("user_id") or (raw.get("user") or {}).get("id")),
+    )
+
+
+def parse_search(payload: dict[str, Any]) -> SearchResult:
+    data = payload.get("data") or payload
+    section = data.get("section") if isinstance(data, dict) else None
+    items_raw: list[Any] = []
+    if isinstance(section, dict):
+        pl = section.get("payload") or {}
+        items_raw = pl.get("items") or []
+    elif isinstance(data, dict) and "search_objects" in data:
+        items_raw = data["search_objects"]
+    if not isinstance(items_raw, list):
+        raise WallaParseError("search items missing")
+    listings = [parse_listing_row(i) for i in items_raw if isinstance(i, dict)]
+    meta = payload.get("meta") or {}
+    next_page = meta.get("next_page") if isinstance(meta, dict) else None
+    return SearchResult(listings=listings, next_page=next_page, count=len(listings))
+
+
+def parse_item(payload: dict[str, Any]) -> Listing:
+    raw = payload.get("data") if isinstance(payload.get("data"), dict) else payload
+    if not isinstance(raw, dict) or "id" not in raw:
+        raise WallaParseError("item payload missing id")
+    # Detail endpoint uses title.original / slug
+    if "web_slug" not in raw and "slug" in raw:
+        raw = {**raw, "web_slug": raw["slug"]}
+    if "category_id" not in raw and isinstance(raw.get("taxonomy"), list) and raw["taxonomy"]:
+        tid = raw["taxonomy"][0].get("id")
+        if tid is not None:
+            raw = {**raw, "category_id": int(tid)}
+    return parse_listing_row(raw)
+
+
+def parse_categories(payload: dict[str, Any]) -> list[Category]:
+    cats = payload.get("categories") or payload.get("data") or []
+    if not isinstance(cats, list):
+        raise WallaParseError("categories missing")
+    out: list[Category] = []
+    for c in cats:
+        if not isinstance(c, dict):
+            continue
+        out.append(
+            Category(
+                id=int(c["id"]),
+                name=str(c.get("name") or ""),
+                icon=c.get("icon"),
+                vertical_id=c.get("vertical_id"),
+            )
+        )
+    return out