tradera-cli 0.1.1__tar.gz → 0.1.3__tar.gz

{tradera_cli-0.1.1 → tradera_cli-0.1.3}/PKG-INFO

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

{tradera_cli-0.1.1 → tradera_cli-0.1.3}/pyproject.toml

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

{tradera_cli-0.1.1 → tradera_cli-0.1.3}/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,117 @@ 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 = {
+        "props": {
+            "pageProps": {
+                "initialState": {
+                    "views": {
+                        "viewItem": {
+                            "itemDetails": {
+                                "paymentCalculations": {
+                                    "paymentAmountForBid": 4927,
+                                    "buyerProtectionCostForFixedPrice": 242,
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    client._request = lambda *_args, **_kwargs: (  # type: ignore[method-assign]
+        '<script id="__NEXT_DATA__" type="application/json">'
+        f"{json.dumps(next_data)}"
+        "</script>"
+    )
+
+    result = client.item_payment_calculations(123)
+    assert result["paymentAmountForBid"] == 4927
+    assert result["buyerProtectionCostForFixedPrice"] == 242
+
+
+def test_item_payment_calculations_raises_on_missing_next_data() -> None:
+    client = TraderaClient()
+    client._request = lambda *_args, **_kwargs: "<html></html>"  # type: ignore[method-assign]
+
+    with pytest.raises(TraderaApiError, match="Could not parse item page response"):
+        client.item_payment_calculations(123)
+
+
 def test_categories_calls_expected_path() -> None:
     client = TraderaClient()
     captured: dict[str, str] = {}
@@ -440,5 +589,11 @@ def test_categories_calls_expected_path() -> None:
 def test_parse_item_id_from_digits_and_url_and_invalid() -> None:
     assert parse_item_id("123456") == 123456
     assert parse_item_id("https://www.tradera.com/item/123456789/test") == 123456789
+    assert (
+        parse_item_id(
+            "https://www.tradera.com/item/1000006/707858418/playstation-5-disc-edition-the-last-of-us-dualsense"
+        )
+        == 707858418
+    )
     with pytest.raises(ValueError, match="Could not parse item id"):
         parse_item_id("https://www.tradera.com/item/no-id")

{tradera_cli-0.1.1 → tradera_cli-0.1.3}/tests/test_cli.py

@@ -23,6 +23,11 @@ class DummyClient:
             raise self.error
         return self.payload or {}
 
+    def item_payment_calculations(self, _item_id: int) -> dict:
+        if self.error:
+            raise self.error
+        return {}
+
     def categories(self, **_kwargs: object) -> list:
         if self.error:
             raise self.error
@@ -92,7 +97,7 @@ def test_cmd_search_and_no_translate(monkeypatch: pytest.MonkeyPatch, capsys: py
     assert "itemId" in out
 
 
-def test_cmd_item_table_and_json(monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
+def test_cmd_item_table_json_and_jsonl(monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
     class ItemClient(DummyClient):
         def item(self, _item_id: int) -> dict:
             return {
@@ -100,9 +105,13 @@ def test_cmd_item_table_and_json(monkeypatch: pytest.MonkeyPatch, capsys: pytest
                 "shortDescription": "Demo",
                 "buyNowPrice": 99,
                 "currency": "SEK",
+                "buyerProtectionInfo": {"totalPrice": 109, "fee": 10},
                 "seller": {"alias": "john"},
             }
 
+        def item_payment_calculations(self, _item_id: int) -> dict:
+            return {}
+
     monkeypatch.setattr(cli, "TraderaClient", ItemClient)
 
     table_args = argparse.Namespace(item="12", format="table")
@@ -110,11 +119,24 @@ def test_cmd_item_table_and_json(monkeypatch: pytest.MonkeyPatch, capsys: pytest
     table_out = capsys.readouterr().out
     assert "seller" in table_out
     assert "john" in table_out
+    assert "buyerProtectionTotal" in table_out
+    assert "109" in table_out
+    assert "10" in table_out
 
     json_args = argparse.Namespace(item="12", format="json")
     assert cli.cmd_item(json_args) == 0
     json_out = capsys.readouterr().out
     assert '"itemId": 12' in json_out
+    assert '"buyerProtectionTotal": 109' in json_out
+    assert '"buyerProtectionFee": 10' in json_out
+
+    jsonl_args = argparse.Namespace(item="12", format="jsonl")
+    assert cli.cmd_item(jsonl_args) == 0
+    jsonl_out = capsys.readouterr().out.strip()
+    assert '"itemId": 12' in jsonl_out
+    assert '"buyerProtectionTotal": 109' in jsonl_out
+    assert '"buyerProtectionFee": 10' in jsonl_out
+    assert "\n" not in jsonl_out
 
 
 def test_cmd_item_table_handles_non_dict_seller(monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
@@ -122,6 +144,9 @@ def test_cmd_item_table_handles_non_dict_seller(monkeypatch: pytest.MonkeyPatch,
         def item(self, _item_id: int) -> dict:
             return {"id": 33, "title": "No seller dict", "seller": "none"}
 
+        def item_payment_calculations(self, _item_id: int) -> dict:
+            return {}
+
     monkeypatch.setattr(cli, "TraderaClient", ItemClient)
 
     args = argparse.Namespace(item="33", format="table")
@@ -130,6 +155,84 @@ def test_cmd_item_table_handles_non_dict_seller(monkeypatch: pytest.MonkeyPatch,
     assert "No seller dict" in out
 
 
+def test_cmd_item_table_supports_hyphenated_buyer_protection_key(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    class ItemClient(DummyClient):
+        def item(self, _item_id: int) -> dict:
+            return {
+                "id": 44,
+                "title": "With fee",
+                "buyer-protection-info": {"priceTotal": 220, "serviceFee": 20},
+            }
+
+        def item_payment_calculations(self, _item_id: int) -> dict:
+            return {}
+
+    monkeypatch.setattr(cli, "TraderaClient", ItemClient)
+
+    args = argparse.Namespace(item="44", format="table")
+    assert cli.cmd_item(args) == 0
+    out = capsys.readouterr().out
+    assert "buyerProtectionTotal" in out
+    assert "220" in out
+    assert "20" in out
+
+
+def test_cmd_item_table_uses_payment_calculations_for_bid_total(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    class ItemClient(DummyClient):
+        def item(self, _item_id: int) -> dict:
+            return {
+                "itemId": 55,
+                "shortDescription": "Auction item",
+                "leadingBid": 4690,
+                "bidCount": 1,
+                "currency": "SEK",
+                "seller": {"alias": "john"},
+            }
+
+        def item_payment_calculations(self, _item_id: int) -> dict:
+            return {"paymentAmountForBid": 4927}
+
+    monkeypatch.setattr(cli, "TraderaClient", ItemClient)
+
+    args = argparse.Namespace(item="55", format="table")
+    assert cli.cmd_item(args) == 0
+    out = capsys.readouterr().out
+    assert "buyerProtectionTotal" in out
+    assert "4927" in out
+    assert "237" in out
+    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.1 → tradera_cli-0.1.3}/tradera_cli/api.py

@@ -4,7 +4,7 @@ import json
 import re
 from dataclasses import dataclass
 from typing import Any
-from urllib.parse import urlencode
+from urllib.parse import urlencode, urlparse
 
 import requests
 from requests import RequestException
@@ -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,11 +171,65 @@ 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_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}")
+
+        data = self._next_data_from_html(html, f"item page response for item {item_id}")
+
+        view_item = (
+            data.get("props", {})
+            .get("pageProps", {})
+            .get("initialState", {})
+            .get("views", {})
+            .get("viewItem", {})
+        )
+        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
+
     def categories(self, level: int = 1, lang: str = "sv") -> Any:
         return self._request("GET", f"/api/categories/{level}?languageCodeIso2={lang}&next=1")
 
@@ -207,7 +237,19 @@ class TraderaClient:
 def parse_item_id(value: str) -> int:
     if value.isdigit():
         return int(value)
-    match = re.search(r"/(\d{6,})", value)
-    if not match:
+    parsed = urlparse(value)
+    path = parsed.path or value
+    segments = [segment for segment in path.split("/") if segment]
+
+    if "item" in segments:
+        item_index = segments.index("item")
+        numeric_after_item = [segment for segment in segments[item_index + 1 :] if segment.isdigit()]
+        if len(numeric_after_item) >= 2:
+            return int(numeric_after_item[1])
+        if numeric_after_item:
+            return int(numeric_after_item[0])
+
+    matches = re.findall(r"(\d{6,})", value)
+    if not matches:
         raise ValueError(f"Could not parse item id from: {value}")
-    return int(match.group(1))
+    return int(matches[-1])

{tradera_cli-0.1.1 → tradera_cli-0.1.3}/tradera_cli/cli.py

@@ -14,6 +14,32 @@ from .formatters import (
 )
 
 
+def _extract_buyer_protection(data: dict[str, Any], payment_calculations: dict[str, Any] | None = None) -> tuple[Any, Any]:
+    info = data.get("buyerProtectionInfo")
+    if not isinstance(info, dict):
+        info = data.get("buyer-protection-info")
+    if not isinstance(info, dict):
+        info = {}
+
+    total = info.get("total") or info.get("totalPrice") or info.get("totalAmount") or info.get("priceTotal") or ""
+    fee = info.get("fee") or info.get("buyerProtectionFee") or info.get("serviceFee") or ""
+
+    if isinstance(payment_calculations, dict):
+        if data.get("bidCount") and payment_calculations.get("paymentAmountForBid") is not None:
+            total = payment_calculations.get("paymentAmountForBid")
+            leading_bid = data.get("leadingBid")
+            if isinstance(leading_bid, (int, float)) and isinstance(total, (int, float)):
+                fee = total - leading_bid
+        elif payment_calculations.get("paymentAmountForFixedPrice") is not None:
+            total = payment_calculations.get("paymentAmountForFixedPrice")
+            fixed_price = data.get("fixedPrice")
+            if payment_calculations.get("buyerProtectionCostForFixedPrice") is not None:
+                fee = payment_calculations.get("buyerProtectionCostForFixedPrice")
+            elif isinstance(fixed_price, (int, float)) and isinstance(total, (int, float)):
+                fee = total - fixed_price
+    return total, fee
+
+
 def _print_output(raw: Any, rows: list[dict[str, Any]], fmt: str, columns: list[str]) -> None:
     if fmt == "json":
         print(to_json(raw))
@@ -57,17 +83,54 @@ def cmd_item(args: argparse.Namespace) -> int:
     client = TraderaClient()
     item_id = parse_item_id(args.item)
     data = client.item(item_id)
+    payment_calculations: dict[str, Any] = {}
+    try:
+        payment_calculations = client.item_payment_calculations(item_id)
+    except TraderaApiError:
+        payment_calculations = {}
+
+    buyer_protection_total, buyer_protection_fee = _extract_buyer_protection(data, payment_calculations)
+
     if args.format == "table":
         row = {
             "itemId": data.get("itemId") or data.get("id") or item_id,
             "title": data.get("shortDescription") or data.get("title") or "",
-            "price": data.get("buyNowPrice") or data.get("nextBid") or data.get("price") or "",
+            "price": (
+                data.get("buyNowPrice")
+                or data.get("price")
+                or data.get("leadingBid")
+                or data.get("nextBid")
+                or data.get("fixedPrice")
+                or data.get("openingBid")
+                or ""
+            ),
             "currency": data.get("currency") or "SEK",
+            "buyerProtectionTotal": buyer_protection_total,
+            "buyerProtectionFee": buyer_protection_fee,
             "seller": (data.get("seller") or {}).get("alias") if isinstance(data.get("seller"), dict) else "",
         }
-        print(to_table([row], ["itemId", "title", "price", "currency", "seller"]))
+        print(
+            to_table(
+                [row],
+                ["itemId", "title", "price", "currency", "buyerProtectionTotal", "buyerProtectionFee", "seller"],
+            )
+        )
     else:
-        print(to_json(data))
+        enriched: dict[str, Any] = {}
+        inserted = False
+        for key, value in data.items():
+            enriched[key] = value
+            if key == "leadingBid":
+                enriched["buyerProtectionTotal"] = buyer_protection_total
+                enriched["buyerProtectionFee"] = buyer_protection_fee
+                inserted = True
+        if not inserted:
+            enriched["buyerProtectionTotal"] = buyer_protection_total
+            enriched["buyerProtectionFee"] = buyer_protection_fee
+        if args.format == "jsonl":
+            print(to_jsonl([enriched]))
+        else:
+            print(to_json(enriched))
     return 0
 
 
@@ -104,7 +167,7 @@ def build_parser() -> argparse.ArgumentParser:
 
     item = subparsers.add_parser("item", help="Get item details")
     item.add_argument("item", help="Item id or item URL")
-    item.add_argument("--format", choices=["table", "json"], default="json")
+    item.add_argument("--format", choices=["table", "json", "jsonl"], default="json")
     item.set_defaults(func=cmd_item)
 
     categories = subparsers.add_parser("categories", help="List categories by level")

{tradera_cli-0.1.1 → tradera_cli-0.1.3}/tradera_cli.egg-info/PKG-INFO

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