tradera-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{tradera_cli-0.1.2 → tradera_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradera-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: CLI for Tradera web endpoints
 Author: Johnny W
 License-Expression: MIT

{tradera_cli-0.1.2 → tradera_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tradera-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "CLI for Tradera web endpoints"
 readme = "README.md"
 requires-python = ">=3.10"

{tradera_cli-0.1.2 → tradera_cli-0.1.4}/tests/test_api.py

@@ -190,29 +190,46 @@ def test_ensure_client_token_raises_on_http_error() -> None:
         client._ensure_client_token()
 
 
-def test_search_builds_payload() -> None:
+def test_search_reads_current_search_page_state() -> None:
     client = TraderaClient()
     captured: dict[str, object] = {}
+    next_data = {
+        "props": {
+            "pageProps": {
+                "initialState": {
+                    "discover": {
+                        "items": [{"itemId": 42, "shortDescription": "Apple TV"}],
+                        "queryParams": {"q": "kamera"},
+                    }
+                }
+            }
+        }
+    }
 
-    def fake_request(method: str, path: str, **kwargs: object) -> dict[str, object]:
+    def fake_request(method: str, path: str, **_kwargs: object) -> str:
         captured["method"] = method
         captured["path"] = path
-        captured["json"] = kwargs["json"]
-        return {"items": []}
+        return (
+            '<script id="__NEXT_DATA__" type="application/json">'
+            f"{json.dumps(next_data)}"
+            "</script>"
+        )
 
     client._request = fake_request  # type: ignore[method-assign]
 
     result = client.search("kamera", page=2, page_size=10, sort_by="EndDate")
 
-    assert result == {"items": []}
-    assert captured["method"] == "POST"
-    assert captured["path"] == "/api/webapi/discover/web/independent-search"
-    payload = captured["json"]
-    assert isinstance(payload, dict)
-    assert payload["query"] == "kamera"
-    assert payload["page"] == 2
-    assert payload["pageSize"] == 10
-    assert payload["sortBy"] == "EndDate"
+    assert result["items"][0]["itemId"] == 42
+    assert captured["method"] == "GET"
+    parsed = urlparse(str(captured["path"]))
+    assert parsed.path == "/search"
+    assert parse_qs(parsed.query) == {
+        "q": ["kamera"],
+        "paging": ["2"],
+        "pageSize": ["10"],
+        "sortBy": ["EndDate"],
+        "languageCodeIso2": ["sv"],
+    }
 
 
 def test_search_uses_search_page_for_sold_items() -> None:
@@ -251,6 +268,7 @@ def test_search_uses_search_page_for_sold_items() -> None:
     assert parse_qs(parsed.query) == {
         "q": ["kamera"],
         "paging": ["3"],
+        "pageSize": ["50"],
         "sortBy": ["EndDate"],
         "languageCodeIso2": ["sv"],
         "itemStatus": ["Sold"],
@@ -293,6 +311,7 @@ def test_search_uses_search_page_for_condition_filter() -> None:
     assert parse_qs(parsed.query) == {
         "q": ["kamera"],
         "paging": ["1"],
+        "pageSize": ["50"],
         "sortBy": ["Relevance"],
         "languageCodeIso2": ["sv"],
         "af-condition": ["Oanvänt"],
@@ -350,6 +369,7 @@ def test_search_uses_search_page_for_additional_page_filters() -> None:
     assert parse_qs(parsed.query) == {
         "q": ["kamera"],
         "paging": ["1"],
+        "pageSize": ["50"],
         "sortBy": ["Relevance"],
         "languageCodeIso2": ["sv"],
         "itemType": ["FixedPrice"],
@@ -396,6 +416,7 @@ def test_search_uses_search_page_for_search_type() -> None:
     assert parse_qs(parsed.query) == {
         "q": ["kamera"],
         "paging": ["1"],
+        "pageSize": ["50"],
         "sortBy": ["Relevance"],
         "languageCodeIso2": ["sv"],
         "searchType": ["ExactSearch"],
@@ -412,7 +433,24 @@ def test_search_page_raises_when_next_data_is_missing() -> None:
 
 def test_item_returns_dict_or_raises() -> None:
     client = TraderaClient()
-    client._request = lambda *_args, **_kwargs: {"itemId": 123}  # type: ignore[method-assign]
+    next_data = {
+        "props": {
+            "pageProps": {
+                "initialState": {
+                    "views": {
+                        "viewItem": {
+                            "itemDetails": {"itemId": 123, "title": "Demo"},
+                        }
+                    }
+                }
+            }
+        }
+    }
+    client._request = lambda *_args, **_kwargs: (  # type: ignore[method-assign]
+        '<script id="__NEXT_DATA__" type="application/json">'
+        f"{json.dumps(next_data)}"
+        "</script>"
+    )
     assert client.item(123)["itemId"] == 123
 
     client._request = lambda *_args, **_kwargs: "not a dict"  # type: ignore[method-assign]
@@ -420,6 +458,78 @@ def test_item_returns_dict_or_raises() -> None:
         client.item(123)
 
 
+def test_item_reads_current_item_page_state() -> None:
+    client = TraderaClient()
+    calls: list[tuple[str, str]] = []
+    next_data = {
+        "props": {
+            "pageProps": {
+                "initialState": {
+                    "views": {
+                        "viewItem": {
+                            "bidInfo": {
+                                "leadingBidAmount": 926,
+                                "nextValidBidAmount": 951,
+                                "bidCount": 79,
+                            },
+                            "itemDetails": {
+                                "itemId": 731572375,
+                                "title": "Apple TV 32GB",
+                                "itemType": "Auction",
+                                "openingBid": 1,
+                                "leadingBid": 926,
+                                "seller": {"alias": "Lufox"},
+                                "paymentCalculations": {"paymentAmountForBid": 974},
+                            },
+                            "purchaseInfo": {"finalPrice": 926},
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    def fake_request(method: str, path: str, **_kwargs: object) -> object:
+        calls.append((method, path))
+        return (
+            '<script id="__NEXT_DATA__" type="application/json">'
+            f"{json.dumps(next_data)}"
+            "</script>"
+        )
+
+    client._request = fake_request  # type: ignore[method-assign]
+
+    result = client.item(731572375)
+
+    assert result["itemId"] == 731572375
+    assert result["title"] == "Apple TV 32GB"
+    assert result["leadingBid"] == 926
+    assert result["bidCount"] == 79
+    assert result["nextBid"] == 951
+    assert result["price"] == 926
+    assert result["finalPrice"] == 926
+    assert result["currency"] == "SEK"
+    assert calls == [("GET", "/item/731572375")]
+
+
+def test_item_falls_back_to_ajax_when_page_parse_fails() -> None:
+    client = TraderaClient()
+    calls: list[tuple[str, str]] = []
+
+    def fake_request(method: str, path: str, **_kwargs: object) -> object:
+        calls.append((method, path))
+        if path == "/item/123":
+            raise TraderaApiError("Could not parse item page response for item 123")
+        return {"itemId": 123, "title": "Legacy"}
+
+    client._request = fake_request  # type: ignore[method-assign]
+
+    result = client.item(123)
+
+    assert result == {"itemId": 123, "title": "Legacy"}
+    assert calls == [("GET", "/item/123"), ("GET", "/ajax/item/123")]
+
+
 def test_item_payment_calculations_returns_dict() -> None:
     client = TraderaClient()
     next_data = {

{tradera_cli-0.1.2 → tradera_cli-0.1.4}/tests/test_cli.py

@@ -207,6 +207,32 @@ def test_cmd_item_table_uses_payment_calculations_for_bid_total(
     assert "4690" in out
 
 
+def test_cmd_item_table_prefers_auction_price_over_next_bid(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    class ItemClient(DummyClient):
+        def item(self, _item_id: int) -> dict:
+            return {
+                "itemId": 66,
+                "title": "Ended auction",
+                "leadingBid": 926,
+                "nextBid": 951,
+                "bidCount": 79,
+                "currency": "SEK",
+            }
+
+        def item_payment_calculations(self, _item_id: int) -> dict:
+            return {"paymentAmountForBid": 974}
+
+    monkeypatch.setattr(cli, "TraderaClient", ItemClient)
+
+    args = argparse.Namespace(item="66", format="table")
+    assert cli.cmd_item(args) == 0
+    out = capsys.readouterr().out
+    assert "926" in out
+    assert "951" not in out
+
+
 def test_cmd_categories_jsonl(monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
     class CategoriesClient(DummyClient):
         def categories(self, **_kwargs: object) -> list:

{tradera_cli-0.1.2 → tradera_cli-0.1.4}/tradera_cli/api.py

@@ -32,7 +32,7 @@ class TraderaClient:
         self.session.headers.update(
             {
                 "accept": "application/json, text/plain, */*",
-                "user-agent": "tradera-cli/0.1.1",
+                "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
             }
         )
 
@@ -68,6 +68,20 @@ class TraderaClient:
                 raise TraderaApiError(f"Invalid JSON response from {path}") from exc
         return response.text
 
+    def _next_data_from_html(self, html: str, context: str) -> dict[str, Any]:
+        match = re.search(r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>', html)
+        if not match:
+            raise TraderaApiError(f"Could not parse {context}")
+
+        try:
+            data = json.loads(match.group(1))
+        except ValueError as exc:
+            raise TraderaApiError(f"Invalid {context}") from exc
+
+        if not isinstance(data, dict):
+            raise TraderaApiError(f"Unexpected {context}")
+        return data
+
     def _ensure_client_token(self, force: bool = False) -> None:
         if not force and self.session.cookies.get("trd_at"):
             return
@@ -101,70 +115,38 @@ class TraderaClient:
         search_type: str | None = None,
     ) -> dict[str, Any]:
         normalized_item_status = item_status or "Active"
-        page_filters: dict[str, str] = {}
+        filters: dict[str, str] = {}
         if search_type:
-            page_filters["searchType"] = search_type
+            filters["searchType"] = search_type
         if normalized_item_status in {"Sold", "Unsold"}:
-            page_filters["itemStatus"] = normalized_item_status
+            filters["itemStatus"] = normalized_item_status
         if condition:
-            page_filters["af-condition"] = condition
+            filters["af-condition"] = condition
         if item_type and item_type != "All":
-            page_filters["itemType"] = item_type
+            filters["itemType"] = item_type
         if from_price is not None:
-            page_filters["fromPrice"] = str(from_price)
+            filters["fromPrice"] = str(from_price)
         if to_price is not None:
-            page_filters["toPrice"] = str(to_price)
+            filters["toPrice"] = str(to_price)
         if allowed_buyer_regions:
-            page_filters["allowedBuyerRegions"] = ALLOWED_BUYER_REGIONS[allowed_buyer_regions]
+            filters["allowedBuyerRegions"] = ALLOWED_BUYER_REGIONS[allowed_buyer_regions]
         if counties:
-            page_filters["counties"] = ";".join(counties)
-
-        if page_filters:
-            return self._search_page(
-                query=query,
-                page=page,
-                sort_by=sort_by,
-                language_code_iso2=language_code_iso2,
-                filters=page_filters,
-            )
-
-        payload: dict[str, Any] = {
-            "isCsaSearchQuery": False,
-            "query": query,
-            "page": page,
-            "pageSize": page_size,
-            "sortBy": sort_by,
-            "languageCodeIso2": language_code_iso2.lower(),
-            "shippingCountryCodeIso2": shipping_country_code_iso2.upper(),
-            "automaticTranslationPreferred": automatic_translation_preferred,
-            "attributeFilters": [],
-            "categoryPath": [],
-            "currentCategoryId": 0,
-            "filterCounties": None,
-            "filterCategories": {},
-            "filterPrice": {},
-            "filters": {},
-            "headerText": None,
-            "internalSearch": {"showSearchBar": False},
-            "introText": None,
-            "isSavedSearchEmailEnabled": False,
-            "isShopOwnedByCurrentMember": False,
-            "items": [],
-            "relatedItems": [],
-            "itemsOnDisplay": [],
-            "mainText": None,
-            "pagination": None,
-            "totalItems": 0,
-            "searchLanguages": [],
-            "itemsMatchedViewModel": None,
-            "suggestion": None,
-        }
-        return self._request("POST", "/api/webapi/discover/web/independent-search", json=payload)
+            filters["counties"] = ";".join(counties)
+
+        return self._search_page(
+            query=query,
+            page=page,
+            page_size=page_size,
+            sort_by=sort_by,
+            language_code_iso2=language_code_iso2,
+            filters=filters,
+        )
 
     def _search_page(
         self,
         query: str,
         page: int,
+        page_size: int,
         sort_by: str,
         language_code_iso2: str,
         filters: dict[str, str],
@@ -172,6 +154,7 @@ class TraderaClient:
         params = {
             "q": query,
             "paging": page,
+            "pageSize": page_size,
             "sortBy": sort_by,
             "languageCodeIso2": language_code_iso2.lower(),
         }
@@ -180,14 +163,7 @@ class TraderaClient:
         if not isinstance(html, str):
             raise TraderaApiError("Unexpected search page response")
 
-        match = re.search(r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>', html)
-        if not match:
-            raise TraderaApiError("Could not parse search page response")
-
-        try:
-            data = json.loads(match.group(1))
-        except ValueError as exc:
-            raise TraderaApiError("Invalid search page data") from exc
+        data = self._next_data_from_html(html, "search page response")
 
         discover = data.get("props", {}).get("pageProps", {}).get("initialState", {}).get("discover")
         if not isinstance(discover, dict):
@@ -195,34 +171,61 @@ class TraderaClient:
         return discover
 
     def item(self, item_id: int) -> dict[str, Any]:
-        data = self._request("GET", f"/ajax/item/{item_id}")
+        try:
+            return self._item_from_page(item_id)
+        except TraderaApiError:
+            data = self._request("GET", f"/ajax/item/{item_id}")
         if not isinstance(data, dict):
             raise TraderaApiError(f"Unexpected item response for item {item_id}")
         return data
 
-    def item_payment_calculations(self, item_id: int) -> dict[str, Any]:
+    def _item_page_state(self, item_id: int) -> dict[str, Any]:
         html = self._request("GET", f"/item/{item_id}")
         if not isinstance(html, str):
             raise TraderaApiError(f"Unexpected item page response for item {item_id}")
 
-        match = re.search(r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>', html)
-        if not match:
-            raise TraderaApiError(f"Could not parse item page response for item {item_id}")
+        data = self._next_data_from_html(html, f"item page response for item {item_id}")
 
-        try:
-            data = json.loads(match.group(1))
-        except ValueError as exc:
-            raise TraderaApiError(f"Invalid item page data for item {item_id}") from exc
-
-        payment_calculations = (
+        view_item = (
             data.get("props", {})
             .get("pageProps", {})
             .get("initialState", {})
             .get("views", {})
             .get("viewItem", {})
-            .get("itemDetails", {})
-            .get("paymentCalculations", {})
         )
+        if not isinstance(view_item, dict):
+            raise TraderaApiError(f"Unexpected item page data for item {item_id}")
+        return view_item
+
+    def _item_from_page(self, item_id: int) -> dict[str, Any]:
+        view_item = self._item_page_state(item_id)
+        item_details = view_item.get("itemDetails")
+        if not isinstance(item_details, dict) or not item_details:
+            raise TraderaApiError(f"Unexpected item response for item {item_id}")
+
+        data = dict(item_details)
+        bid_info = view_item.get("bidInfo")
+        if isinstance(bid_info, dict):
+            if bid_info.get("bidCount") is not None:
+                data.setdefault("bidCount", bid_info.get("bidCount"))
+            if bid_info.get("leadingBidAmount") is not None:
+                data.setdefault("leadingBid", bid_info.get("leadingBidAmount"))
+            if bid_info.get("nextValidBidAmount") is not None:
+                data.setdefault("nextBid", bid_info.get("nextValidBidAmount"))
+
+        purchase_info = view_item.get("purchaseInfo")
+        if isinstance(purchase_info, dict) and purchase_info.get("finalPrice") is not None:
+            data.setdefault("price", purchase_info.get("finalPrice"))
+            data.setdefault("finalPrice", purchase_info.get("finalPrice"))
+
+        data.setdefault("currency", "SEK")
+        return data
+
+    def item_payment_calculations(self, item_id: int) -> dict[str, Any]:
+        item_details = self._item_page_state(item_id).get("itemDetails", {})
+        if not isinstance(item_details, dict):
+            raise TraderaApiError(f"Unexpected payment calculations for item {item_id}")
+        payment_calculations = item_details.get("paymentCalculations", {})
         if not isinstance(payment_calculations, dict):
             raise TraderaApiError(f"Unexpected payment calculations for item {item_id}")
         return payment_calculations

{tradera_cli-0.1.2 → tradera_cli-0.1.4}/tradera_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradera-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: CLI for Tradera web endpoints
 Author: Johnny W
 License-Expression: MIT

{tradera_cli-0.1.2 → tradera_cli-0.1.4}/tradera_cli/cli.py

@@ -97,9 +97,9 @@ def cmd_item(args: argparse.Namespace) -> int:
             "title": data.get("shortDescription") or data.get("title") or "",
             "price": (
                 data.get("buyNowPrice")
-                or data.get("nextBid")
                 or data.get("price")
                 or data.get("leadingBid")
+                or data.get("nextBid")
                 or data.get("fixedPrice")
                 or data.get("openingBid")
                 or ""