walla-cli 0.1.10__tar.gz → 0.1.12__tar.gz

{walla_cli-0.1.10 → walla_cli-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: walla-cli
-Version: 0.1.10
+Version: 0.1.12
 Summary: Wallapop.es CLI - look · offer · talk · sell for humans and agents
 Project-URL: Homepage, https://github.com/berendgort/wallapop-cli
 Project-URL: Repository, https://github.com/berendgort/wallapop-cli

{walla_cli-0.1.10 → walla_cli-0.1.12}/docs/WIRE.md

@@ -34,6 +34,12 @@ Public URL: `https://es.wallapop.com/item/<web_slug>`.
 `leaf_id` + `root_id`. Sell accepts `--category <leaf-or-name>`; `--root` is
 optional.
 
+After `current_step=photo`, the steps `draft` may include `category_leaf_id`
+(title+photo hint). `GET /api/v3/suggested-item-data/{upload_id}` often returns
+empty HTTP 200; still poll before `loading`. CLI: `walla sell … --title …
+--suggest` (explicit only; draft without `--suggest` does not upload).
+`walla desk --watch` polls the inbox until `stack.best` converges.
+
 ## Auth
 
 `POST https://api.wallapop.com/api/v3/access/login` with

walla_cli-0.1.12/fixtures/sell_suggest_draft.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "note": "After photo step, Wallapop may inject category_leaf_id from title+photos. suggested-item-data often returns empty HTTP 200.",
+  "after_photo": {
+    "step": {"id": "category", "components": []},
+    "draft": {
+      "title": "Escritorio madera oscura patas cromadas",
+      "category_leaf_id": "24208"
+    }
+  },
+  "after_loading": {
+    "step": {"id": "listing", "components": []},
+    "draft": {
+      "title": "Escritorio madera oscura patas cromadas",
+      "category_leaf_id": "24208",
+      "root_category_id": "12467"
+    }
+  },
+  "suggested_item_data": {
+    "http_status": 200,
+    "body": null
+  }
+}

{walla_cli-0.1.10 → walla_cli-0.1.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walla-cli"
-version = "0.1.10"
+version = "0.1.12"
 description = "Wallapop.es CLI - look · offer · talk · sell for humans and agents"
 authors = [{ name = "Dr. Berend Gort", email = "berend.gort@gmail.com" }]
 readme = "README.md"

{walla_cli-0.1.10 → walla_cli-0.1.12}/skills/walla-sell/SKILL.md

@@ -14,10 +14,12 @@ Do not ask the human to type buyer replies. Desk sends those.
 
 ```bash
 walla categories --find escritorio --json
-walla sell ./shot1.jpg ./shot2.jpg --json
+walla sell ./shot1.jpg ./shot2.jpg --title "Escritorio madera" --suggest --json
 ```
 
-Ask every question in `data.questions`, then publish once:
+`--suggest` uploads photos and asks Wallapop to prefill `category_leaf_id`.
+Draft without `--suggest` stays local (no upload). Ask remaining
+`data.questions`, then:
 
 ```bash
 walla sell ./shot1.jpg ./shot2.jpg \
@@ -26,17 +28,17 @@ walla sell ./shot1.jpg ./shot2.jpg \
   --floor 35 --yes --json
 ```
 
-`--category` accepts a leaf id **or** name tokens (`escritorio`, `hogar/muebles`).
-`--root` is optional (derived from the leaf). `--floor` is the lowest EUR desk may
-accept. Omit it to hold the asking price.
+`--category` accepts a leaf id **or** name tokens. `--root` is optional.
+`--floor` is the lowest EUR desk may accept.
+
 Then:
 
 ```bash
-walla desk --json
+walla desk --watch --seconds 45 --rounds 12 --json
 ```
 
-Desk reads the inbox once and answers buyers. Repeat desk until `stack.best`
-is a sell row. Show the title, agreed EUR, `stack.why`, and the item link.
+Desk answers buyers until `stack.best` converges or rounds end. Show the title,
+agreed EUR, `stack.why`, and the item link.
 
 The human accepts the sale in the Wallapop app. `walla unsell <id> --yes` deletes
 a listing. Never mark the item sold from walla.

{walla_cli-0.1.10 → walla_cli-0.1.12}/tests/test_live.py

@@ -11,7 +11,8 @@ import pytest
 from walla.account.chat import open_conversation
 from walla.account.inbox import list_conversations_raw
 from walla.account.login import ensure_access_token, whoami
-from walla.account.sell import _step, delete_listing, publish_listing, upload_pictures
+from walla.account.sell import delete_listing, publish_listing, upload_pictures
+from walla.account.sell_steps import post_step as _step
 from walla.account.session_store import load_session
 from walla.http.client import HttpClient
 from walla.http.polite import reset_polite

{walla_cli-0.1.10 → walla_cli-0.1.12}/tests/test_sell.py

@@ -70,6 +70,63 @@ def test_missing_sell_fields() -> None:
     assert CONDITIONS[0] == "as_good_as_new"
 
 
+def test_sell_draft_with_title_does_not_suggest(tmp_path: Path) -> None:
+    from typer.testing import CliRunner
+
+    from walla.cli.main import app
+
+    photo = tmp_path / "a.jpg"
+    photo.write_bytes(b"\xff\xd8\xff\xd9")
+    runner = CliRunner()
+    with (
+        patch("walla.cli.cmd_sell.load_profile") as lp,
+        patch("walla.cli.cmd_sell.suggest_from_photos") as sug,
+    ):
+        profile = MagicMock()
+        profile.lat = 41.39
+        profile.lon = 2.17
+        profile.label = "BCN"
+        lp.return_value = profile
+        result = runner.invoke(
+            app, ["sell", str(photo), "--title", "Escritorio", "--json"]
+        )
+    assert result.exit_code == 0, result.output
+    sug.assert_not_called()
+    payload = json.loads(result.output)
+    assert payload["data"]["status"] == "draft"
+    assert "suggested" not in payload["data"]
+
+
+def test_publish_prepared_reuses_upload(tmp_path: Path) -> None:
+    from walla.account.sell import publish_prepared
+
+    photo = tmp_path / "a.jpg"
+    photo.write_bytes(b"\xff\xd8\xff\xd9")
+    listing = MagicMock()
+    listing.url = "https://es.wallapop.com/item/x"
+    listing.web_slug = "x"
+    with (
+        patch(
+            "walla.account.sell.create_listing",
+            return_value={"id": "abc", "flags": {}},
+        ) as create,
+        patch("walla.account.sell.get_item", return_value=listing),
+    ):
+        out = publish_prepared(
+            [photo],
+            upload_id="upload-1",
+            title="T",
+            description="D",
+            price_eur=10,
+            category_leaf_id="24208",
+            lat=41.0,
+            lon=2.0,
+        )
+    assert out["reused_suggest"] is True
+    assert out["upload_id"] == "upload-1"
+    create.assert_called_once()
+
+
 def test_sell_cmd_draft_without_yes(tmp_path: Path) -> None:
     from typer.testing import CliRunner
 
@@ -119,23 +176,23 @@ def test_publish_listing_mocked(tmp_path: Path) -> None:
     photo.write_bytes(b"\xff\xd8\xff\xd9")
     fake_http = MagicMock()
     fake_http.post.side_effect = [
-        {"step": {"id": "title"}},
-        {"step": {"id": "photo", "picture_upload": {"path": "/api/v3/upload/x/pictures"}}},
-        {"step": {"id": "category"}},
+        {"step": {"id": "title"}, "draft": {}},
+        {"step": {"id": "photo"}, "draft": {"title": "Test item"}},
         {
-            "step": {
-                "id": "loading",
-                "poll_before_next_step": {"path": "/api/v3/suggested-item-data/x"},
-            }
+            "step": {"id": "category"},
+            "draft": {"title": "Test item", "category_leaf_id": "10105"},
         },
-        {"step": {"id": "listing"}},
+        {"step": {"id": "loading"}, "draft": {"title": "Test item"}},
+        {"step": {"id": "listing"}, "draft": {"title": "Test item"}},
     ]
     fake_http.get.return_value = {}
     listing = MagicMock()
     listing.url = "https://es.wallapop.com/item/test-item-99"
     listing.web_slug = "test-item-99"
     with (
-        patch("walla.account.sell._auth_client", return_value=fake_http),
+        patch("walla.account.sell.auth_client", return_value=fake_http),
+        patch("walla.account.sell.post_step", side_effect=fake_http.post.side_effect),
+        patch("walla.account.sell.poll_suggested", return_value=None),
         patch("walla.account.sell.upload_pictures", return_value=1),
         patch(
             "walla.account.sell.create_listing",
@@ -156,7 +213,6 @@ def test_publish_listing_mocked(tmp_path: Path) -> None:
     assert out["id"] == "abc123"
     assert out["photos"] == 1
     assert out["url"] == "https://es.wallapop.com/item/test-item-99"
-    assert fake_http.post.call_count == 5
 
 
 def test_create_listing_multipart(tmp_path: Path) -> None:
@@ -179,7 +235,7 @@ def test_create_listing_multipart(tmp_path: Path) -> None:
     fake_session = MagicMock()
     fake_session.request.return_value = fake_resp
     with (
-        patch("walla.account.sell._auth_headers", return_value={"Authorization": "Bearer x"}),
+        patch("walla.account.sell.auth_headers", return_value={"Authorization": "Bearer x"}),
         patch("walla.account.sell.requests.Session", return_value=fake_session),
         patch("walla.account.sell.CurlMime") as mime_cls,
         patch("walla.account.sell.wait_turn"),
@@ -227,14 +283,16 @@ def test_publish_listing_two_photos(tmp_path: Path) -> None:
     listing.url = "https://es.wallapop.com/item/test-item-99"
     listing.web_slug = "test-item-99"
     with (
-        patch("walla.account.sell._auth_client", return_value=fake_http),
+        patch("walla.account.sell.auth_client", return_value=fake_http),
+        patch("walla.account.sell.post_step", side_effect=fake_http.post.side_effect),
+        patch("walla.account.sell.poll_suggested", return_value=None),
         patch("walla.account.sell.upload_pictures", return_value=2),
         patch(
             "walla.account.sell.create_listing",
             return_value={"id": "abc123", "flags": {}},
         ),
         patch("walla.account.sell.get_item", return_value=listing),
-        patch("walla.account.sell._auth_headers", return_value={}),
+        patch("walla.account.sell.auth_headers", return_value={}),
         patch("walla.account.sell.requests.Session", return_value=fake_session),
         patch("walla.account.sell.CurlMime") as mime_cls,
         patch("walla.account.sell.wait_turn"),

walla_cli-0.1.12/tests/test_suggest_watch.py

@@ -0,0 +1,101 @@
+"""Suggest draft parse + desk watch stop conditions."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+from walla.account.desk_watch import run_desk_watch
+from walla.account.sell_steps import parse_steps_draft
+
+FIX = Path(__file__).resolve().parents[1] / "fixtures"
+
+
+def test_parse_steps_draft_fixture() -> None:
+    raw = json.loads((FIX / "sell_suggest_draft.json").read_text(encoding="utf-8"))
+    after = parse_steps_draft(raw["after_photo"])
+    assert after["category_leaf_id"] == "24208"
+    assert after["title"].startswith("Escritorio")
+    loaded = parse_steps_draft(raw["after_loading"])
+    assert loaded["root_category_id"] == "12467"
+
+
+def test_desk_watch_stops_on_converged() -> None:
+    converged = {
+        "replies": [],
+        "stack": {"best": {"status": "converged", "title": "X", "agreed_eur": 40}},
+        "close_in_app": True,
+    }
+    with patch("walla.account.desk_watch.run_desk", return_value=converged) as desk:
+        with patch("walla.account.desk_watch.time.sleep") as slept:
+            out = run_desk_watch(seconds=5, rounds=5)
+    assert out["watch_stopped"] == "converged"
+    assert out["watch_round"] == 1
+    desk.assert_called_once()
+    slept.assert_not_called()
+
+
+def test_desk_watch_max_rounds() -> None:
+    waiting = {
+        "replies": [],
+        "stack": {"best": None},
+        "close_in_app": True,
+    }
+    with patch("walla.account.desk_watch.run_desk", return_value=waiting) as desk:
+        with patch("walla.account.desk_watch.time.sleep") as slept:
+            out = run_desk_watch(seconds=5, rounds=3)
+    assert out["watch_stopped"] == "max_rounds"
+    assert out["watch_round"] == 3
+    assert desk.call_count == 3
+    assert slept.call_count == 2
+
+
+def test_suggest_from_photos_mocked(tmp_path: Path) -> None:
+    from walla.account.sell_suggest import suggest_from_photos
+
+    photo = tmp_path / "a.jpg"
+    photo.write_bytes(b"\xff\xd8\xff\xd9")
+    steps = [
+        {"step": {"id": "title"}, "draft": {}},
+        {"step": {"id": "photo"}, "draft": {"title": "Escritorio madera"}},
+        {
+            "step": {"id": "category"},
+            "draft": {"title": "Escritorio madera", "category_leaf_id": "24208"},
+        },
+        {
+            "step": {"id": "loading"},
+            "draft": {
+                "title": "Escritorio madera",
+                "category_leaf_id": "24208",
+                "root_category_id": "12467",
+            },
+        },
+        {
+            "step": {"id": "listing"},
+            "draft": {
+                "title": "Escritorio madera",
+                "category_leaf_id": "24208",
+                "root_category_id": "12467",
+            },
+        },
+    ]
+    fake = MagicMock()
+    with (
+        patch("walla.account.sell_suggest.auth_client", return_value=fake),
+        patch("walla.account.sell_suggest.post_step", side_effect=steps),
+        patch("walla.account.sell_suggest.upload_pictures", return_value=1),
+        patch("walla.account.sell_suggest.poll_suggested", return_value=None),
+        patch(
+            "walla.account.sell_suggest.get_categories",
+            return_value=__import__(
+                "walla.search.parse", fromlist=["parse_categories"]
+            ).parse_categories(
+                json.loads((FIX / "categories.json").read_text(encoding="utf-8"))
+            ),
+        ),
+    ):
+        out = suggest_from_photos([photo], title="Escritorio madera")
+    assert out["category_leaf_id"] == "24208"
+    assert out["root_category_id"] == "12467"
+    assert "Escritorios" in (out.get("path") or "")

{walla_cli-0.1.10 → walla_cli-0.1.12}/tests/test_wire_contracts.py

@@ -250,8 +250,9 @@ def test_every_contract_is_sent(
         expires_at=9_999_999_999,
     )
     monkeypatch.setattr("walla.account.login.ensure_access_token", lambda: sess)
-    monkeypatch.setattr("walla.account.sell.ensure_access_token", lambda: sess)
-    monkeypatch.setattr("walla.account.sell._auth_client", lambda: rec)
+    monkeypatch.setattr("walla.account.sell_steps.ensure_access_token", lambda: sess)
+    monkeypatch.setattr("walla.account.sell.auth_client", lambda: rec)
+    monkeypatch.setattr("walla.account.sell_steps.auth_client", lambda: rec)
     monkeypatch.setattr("walla.account.chat.ensure_access_token", _must_not_mint)
     monkeypatch.setattr(
         "walla.account.actions.load_profile",

{walla_cli-0.1.10 → walla_cli-0.1.12}/walla/__init__.py

@@ -4,4 +4,4 @@ from __future__ import annotations
 
 __all__ = ("__version__",)
 
-__version__ = "0.1.10"
+__version__ = "0.1.12"

walla_cli-0.1.12/walla/account/desk_watch.py

@@ -0,0 +1,36 @@
+"""Poll the inbox until a deal converges or rounds run out."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from walla.account.desk import run_desk
+from walla.http.client import HttpClient
+
+__all__ = ("run_desk_watch",)
+
+
+def run_desk_watch(
+    *,
+    seconds: float = 45.0,
+    rounds: int = 12,
+    client: HttpClient | None = None,
+) -> dict[str, Any]:
+    """Repeat run_desk until stack.best is converged or max rounds."""
+    if seconds < 5:
+        raise ValueError("--seconds must be >= 5")
+    if rounds < 1 or rounds > 60:
+        raise ValueError("--rounds must be 1..60")
+    last: dict[str, Any] = {}
+    for i in range(rounds):
+        last = run_desk(client=client)
+        last["watch_round"] = i + 1
+        best = (last.get("stack") or {}).get("best")
+        if isinstance(best, dict) and best.get("status") == "converged":
+            last["watch_stopped"] = "converged"
+            return last
+        if i + 1 < rounds:
+            time.sleep(float(seconds))
+    last["watch_stopped"] = "max_rounds"
+    return last

{walla_cli-0.1.10 → walla_cli-0.1.12}/walla/account/sell.py

@@ -9,7 +9,14 @@ from typing import Any
 
 from curl_cffi import CurlMime, requests
 
-from walla.account.login import ensure_access_token
+from walla.account.sell_steps import (
+    auth_client,
+    auth_headers,
+    parse_steps_draft,
+    poll_suggested,
+    post_step,
+)
+from walla.account.sell_upload import IMAGE_TYPES, upload_pictures
 from walla.account.sell_wire import build_item_body
 from walla.core.exceptions import (
     WallaHTTPError,
@@ -18,7 +25,7 @@ from walla.core.exceptions import (
     WallaUnsupportedError,
 )
 from walla.http.client import HttpClient
-from walla.http.headers import API_BASE, WEB_BASE, default_headers
+from walla.http.headers import API_BASE, WEB_BASE
 from walla.http.polite import wait_turn
 from walla.search.api import get_item
 from walla.search.parse import item_url
@@ -27,84 +34,19 @@ __all__ = (
     "create_listing",
     "delete_listing",
     "publish_listing",
+    "publish_prepared",
     "upload_pictures",
 )
 
 _UPLOAD_ACCEPT = "application/vnd.upload-v2+json"
-_IMAGE_TYPES = {
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".webp": "image/webp",
-}
-
-
-def _auth_client() -> HttpClient:
-    sess = ensure_access_token()
-    return HttpClient(access_token=sess.access_token, device_id=sess.device_id)
-
-
-def _auth_headers() -> dict[str, str]:
-    sess = ensure_access_token()
-    headers = default_headers(device_id=sess.device_id)
-    headers["Authorization"] = f"Bearer {sess.access_token}"
-    return headers
-
-
-def _step(
-    http: HttpClient,
-    upload_id: str,
-    *,
-    current: str | None,
-    draft: dict[str, Any],
-) -> dict[str, Any]:
-    body: dict[str, Any] = {
-        "mode": {"action": "upload", "id": upload_id},
-        "draft": draft,
-    }
-    if current:
-        body["current_step"] = current
-    raw = http.post("/api/v3/steps", json_body=body, auth=True)
-    if not isinstance(raw, dict):
-        raise WallaUnsupportedError("steps returned non-object")
-    return raw
-
-
-def upload_pictures(upload_id: str, photos: list[Path]) -> int:
-    """POST each photo to /api/v3/upload/{id}/pictures (HTTP 204)."""
-    if not photos:
-        raise ValueError("at least one photo required")
-    headers = {k: v for k, v in _auth_headers().items() if k.lower() != "content-type"}
-    session: Any = requests.Session()
-    for path in photos:
-        data = path.read_bytes()
-        ctype = _IMAGE_TYPES.get(path.suffix.lower(), "image/jpeg")
-        wait_turn()
-        mp = CurlMime()
-        mp.addpart(name="file", content_type=ctype, filename=path.name, data=data)
-        resp: Any = session.request(
-            "POST",
-            f"{API_BASE}/api/v3/upload/{upload_id}/pictures",
-            headers=headers,
-            multipart=mp,
-            impersonate="chrome",
-            timeout=60,
-        )
-        mp.close()
-        if resp.status_code not in (200, 201, 204):
-            raise WallaHTTPError(
-                f"picture upload HTTP {resp.status_code}: {(resp.text or '')[:200]}",
-                status_code=resp.status_code,
-            )
-    return len(photos)
 
 
 def create_listing(item: dict[str, Any], first_photo: Path) -> dict[str, Any]:
     """Multipart POST /api/v3/items with Accept upload-v2."""
-    headers = {k: v for k, v in _auth_headers().items() if k.lower() != "content-type"}
+    headers = {k: v for k, v in auth_headers().items() if k.lower() != "content-type"}
     headers["Accept"] = _UPLOAD_ACCEPT
     data = first_photo.read_bytes()
-    ctype = _IMAGE_TYPES.get(first_photo.suffix.lower(), "image/jpeg")
+    ctype = IMAGE_TYPES.get(first_photo.suffix.lower(), "image/jpeg")
     wait_turn()
     mp = CurlMime()
     mp.addpart(name="image", content_type=ctype, filename=first_photo.name, data=data)
@@ -130,52 +72,33 @@ def create_listing(item: dict[str, Any], first_photo: Path) -> dict[str, Any]:
 
 
 def delete_listing(item_id: str, *, client: HttpClient | None = None) -> dict[str, Any]:
-    http = client or _auth_client()
+    http = client or auth_client()
     http.delete(f"/api/v3/items/{item_id}", auth=True)
     return {"id": item_id, "deleted": True}
 
 
-def publish_listing(
+def publish_prepared(
     photos: list[Path],
     *,
+    upload_id: str,
     title: str,
     description: str,
     price_eur: float,
     category_leaf_id: str,
-    root_category_id: str,
     lat: float,
     lon: float,
     condition: str = "good",
     shipping: bool = False,
     weight_kg: float | None = None,
+    wire_draft: dict[str, str] | None = None,
 ) -> dict[str, Any]:
-    """Full Vender path. Caller must already require --yes."""
+    """Create item from an upload_id already walked through loading."""
     paths = [Path(p) for p in photos]
     for p in paths:
         if not p.is_file():
             raise ValueError(f"photo not found: {p}")
-    http = _auth_client()
-    upload_id = str(uuid.uuid4())
-    draft: dict[str, Any] = {"title": title.strip()[:50]}
-    _step(http, upload_id, current=None, draft={})
-    _step(http, upload_id, current="title", draft=draft)
-    upload_pictures(upload_id, paths)
-    _step(http, upload_id, current="photo", draft=draft)
-    draft = {
-        **draft,
-        "category_leaf_id": str(category_leaf_id),
-        "root_category_id": str(root_category_id),
-    }
-    _step(http, upload_id, current="category", draft=draft)
-    for _ in range(8):
-        wait_turn()
-        try:
-            http.get(f"/api/v3/suggested-item-data/{upload_id}", auth=True)
-            break
-        except WallaHTTPError as exc:
-            if exc.status_code != 404:
-                raise
-    _step(http, upload_id, current="loading", draft=draft)
+    if not upload_id.strip():
+        raise ValueError("upload_id required")
     item = build_item_body(
         upload_id=upload_id,
         title=title,
@@ -197,11 +120,63 @@ def publish_listing(
         "title": title.strip()[:50],
         "url": _public_item_url(str(created["id"])),
         "photos": len(paths),
+        "wire_draft": wire_draft or {},
+        "reused_suggest": True,
     }
 
 
+def publish_listing(
+    photos: list[Path],
+    *,
+    title: str,
+    description: str,
+    price_eur: float,
+    category_leaf_id: str,
+    root_category_id: str,
+    lat: float,
+    lon: float,
+    condition: str = "good",
+    shipping: bool = False,
+    weight_kg: float | None = None,
+) -> dict[str, Any]:
+    """Full Vender path. Caller must already require --yes."""
+    paths = [Path(p) for p in photos]
+    for p in paths:
+        if not p.is_file():
+            raise ValueError(f"photo not found: {p}")
+    http = auth_client()
+    upload_id = str(uuid.uuid4())
+    draft: dict[str, Any] = {"title": title.strip()[:50]}
+    post_step(http, upload_id, current=None, draft={})
+    post_step(http, upload_id, current="title", draft=draft)
+    upload_pictures(upload_id, paths)
+    after_photo = post_step(http, upload_id, current="photo", draft=draft)
+    wire = parse_steps_draft(after_photo)
+    leaf = str(category_leaf_id)
+    root = str(root_category_id)
+    draft = {**draft, "category_leaf_id": leaf, "root_category_id": root}
+    post_step(http, upload_id, current="category", draft=draft)
+    poll_suggested(http, upload_id)
+    post_step(http, upload_id, current="loading", draft=draft)
+    out = publish_prepared(
+        paths,
+        upload_id=upload_id,
+        title=title,
+        description=description,
+        price_eur=price_eur,
+        category_leaf_id=leaf,
+        lat=lat,
+        lon=lon,
+        condition=condition,
+        shipping=shipping,
+        weight_kg=weight_kg,
+        wire_draft=wire,
+    )
+    out["reused_suggest"] = False
+    return out
+
+
 def _public_item_url(item_id: str) -> str:
-    """Wallapop web needs the slug path, not the opaque item hash."""
     try:
         listing = get_item(item_id)
     except (
@@ -222,12 +197,12 @@ def _public_item_url(item_id: str) -> str:
 
 
 def _upload_extra_pictures(item_id: str, photos: list[Path]) -> None:
-    headers = {k: v for k, v in _auth_headers().items() if k.lower() != "content-type"}
+    headers = {k: v for k, v in auth_headers().items() if k.lower() != "content-type"}
     headers["Accept"] = _UPLOAD_ACCEPT
     session: Any = requests.Session()
     for idx, path in enumerate(photos, start=1):
         data = path.read_bytes()
-        ctype = _IMAGE_TYPES.get(path.suffix.lower(), "image/jpeg")
+        ctype = IMAGE_TYPES.get(path.suffix.lower(), "image/jpeg")
         wait_turn()
         mp = CurlMime()
         mp.addpart(name="image", content_type=ctype, filename=path.name, data=data)