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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradera-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: CLI for Tradera web endpoints
 Author: Johnny W
 License-Expression: MIT
@@ -69,6 +69,11 @@ tradera search "iphone"
 tradera search "pokemon" --page 2 --page-size 20
 tradera search "kamera" --sort AddedOn --format json
 tradera search "klocka" --country SE --lang sv --format jsonl
+tradera search "lego" --item-status Sold --format json
+tradera search "lego" --condition "Oanvänt" --format json
+tradera search "lego" --item-type FixedPrice --from-price 100 --to-price 500
+tradera search "lego" --allowed-buyer-regions eu --counties Stockholm Uppsala
+tradera search "lego city" --search-type ExactSearch
 ```
 
 ### Get item details
@@ -105,6 +110,14 @@ Search command (`tradera search`) supports:
 | `--sort` | Sort mode (default: `Relevance`) |
 | `--lang` | Language code (default: `sv`) |
 | `--country` | Shipping country code (default: `SE`) |
+| `--item-status` | Filter by item status: `Active`, `Sold`, `Unsold` |
+| `--condition` | Filter by condition: `Oanvänt`, `Mycket gott skick`, `Gott skick`, `Okej skick`, `Defekt` |
+| `--item-type` | Filter by listing type: `All`, `Auction`, `FixedPrice`, `ContactOnly` |
+| `--from-price` | Minimum price |
+| `--to-price` | Maximum price |
+| `--allowed-buyer-regions` | Buyer region filter: `sweden`, `eu`, `international` |
+| `--counties` | Pickup counties, passed as one or more values, for example `Stockholm Uppsala` |
+| `--search-type` | Search mode. Current supported value: `ExactSearch` |
 | `--no-translate` | Disable automatic translation preference |
 | `--format` | Output format: `table`, `json`, `jsonl` |
 

{tradera_cli-0.1.0 → tradera_cli-0.1.2}/README.md

@@ -39,6 +39,11 @@ tradera search "iphone"
 tradera search "pokemon" --page 2 --page-size 20
 tradera search "kamera" --sort AddedOn --format json
 tradera search "klocka" --country SE --lang sv --format jsonl
+tradera search "lego" --item-status Sold --format json
+tradera search "lego" --condition "Oanvänt" --format json
+tradera search "lego" --item-type FixedPrice --from-price 100 --to-price 500
+tradera search "lego" --allowed-buyer-regions eu --counties Stockholm Uppsala
+tradera search "lego city" --search-type ExactSearch
 ```
 
 ### Get item details
@@ -75,6 +80,14 @@ Search command (`tradera search`) supports:
 | `--sort` | Sort mode (default: `Relevance`) |
 | `--lang` | Language code (default: `sv`) |
 | `--country` | Shipping country code (default: `SE`) |
+| `--item-status` | Filter by item status: `Active`, `Sold`, `Unsold` |
+| `--condition` | Filter by condition: `Oanvänt`, `Mycket gott skick`, `Gott skick`, `Okej skick`, `Defekt` |
+| `--item-type` | Filter by listing type: `All`, `Auction`, `FixedPrice`, `ContactOnly` |
+| `--from-price` | Minimum price |
+| `--to-price` | Maximum price |
+| `--allowed-buyer-regions` | Buyer region filter: `sweden`, `eu`, `international` |
+| `--counties` | Pickup counties, passed as one or more values, for example `Stockholm Uppsala` |
+| `--search-type` | Search mode. Current supported value: `ExactSearch` |
 | `--no-translate` | Disable automatic translation preference |
 | `--format` | Output format: `table`, `json`, `jsonl` |
 

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

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

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

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import json
+from urllib.parse import parse_qs, urlparse
+
 import requests
 import pytest
 
@@ -212,6 +215,201 @@ def test_search_builds_payload() -> None:
     assert payload["sortBy"] == "EndDate"
 
 
+def test_search_uses_search_page_for_sold_items() -> None:
+    client = TraderaClient()
+    captured: dict[str, object] = {}
+    next_data = {
+        "props": {
+            "pageProps": {
+                "initialState": {
+                    "discover": {
+                        "items": [{"itemId": 42, "isActive": False}],
+                        "filters": {"itemStatus": {"selectedValue": "Sold"}},
+                    }
+                }
+            }
+        }
+    }
+
+    def fake_request(method: str, path: str, **_kwargs: object) -> str:
+        captured["method"] = method
+        captured["path"] = 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.search("kamera", page=3, sort_by="EndDate", item_status="Sold")
+
+    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": ["3"],
+        "sortBy": ["EndDate"],
+        "languageCodeIso2": ["sv"],
+        "itemStatus": ["Sold"],
+    }
+
+
+def test_search_uses_search_page_for_condition_filter() -> None:
+    client = TraderaClient()
+    captured: dict[str, object] = {}
+    next_data = {
+        "props": {
+            "pageProps": {
+                "initialState": {
+                    "discover": {
+                        "items": [{"itemId": 99}],
+                        "attributeFilters": [{"parameter": "af-condition", "selectedValues": ["Oanvänt"]}],
+                    }
+                }
+            }
+        }
+    }
+
+    def fake_request(method: str, path: str, **_kwargs: object) -> str:
+        captured["method"] = method
+        captured["path"] = path
+        return (
+            '<script id="__NEXT_DATA__" type="application/json">'
+            f"{json.dumps(next_data, ensure_ascii=False)}"
+            "</script>"
+        )
+
+    client._request = fake_request  # type: ignore[method-assign]
+
+    result = client.search("kamera", condition="Oanvänt")
+
+    assert result["items"][0]["itemId"] == 99
+    assert captured["method"] == "GET"
+    parsed = urlparse(str(captured["path"]))
+    assert parsed.path == "/search"
+    assert parse_qs(parsed.query) == {
+        "q": ["kamera"],
+        "paging": ["1"],
+        "sortBy": ["Relevance"],
+        "languageCodeIso2": ["sv"],
+        "af-condition": ["Oanvänt"],
+    }
+
+
+def test_search_uses_search_page_for_additional_page_filters() -> None:
+    client = TraderaClient()
+    captured: dict[str, object] = {}
+    next_data = {
+        "props": {
+            "pageProps": {
+                "initialState": {
+                    "discover": {
+                        "items": [{"itemId": 77}],
+                        "filters": {
+                            "itemType": {"selectedValue": "FixedPrice"},
+                            "allowedBuyerRegions": {"selectedValue": "eu;international"},
+                        },
+                        "filterPrice": {
+                            "fromPrice": {"parameter": "fromPrice", "value": 100},
+                            "toPrice": {"parameter": "toPrice", "value": 500},
+                        },
+                        "filterCounties": {"selectedValues": ["Stockholm", "Uppsala"]},
+                    }
+                }
+            }
+        }
+    }
+
+    def fake_request(method: str, path: str, **_kwargs: object) -> str:
+        captured["method"] = method
+        captured["path"] = path
+        return (
+            '<script id="__NEXT_DATA__" type="application/json">'
+            f"{json.dumps(next_data, ensure_ascii=False)}"
+            "</script>"
+        )
+
+    client._request = fake_request  # type: ignore[method-assign]
+
+    result = client.search(
+        "kamera",
+        item_type="FixedPrice",
+        from_price=100,
+        to_price=500,
+        allowed_buyer_regions="eu",
+        counties=["Stockholm", "Uppsala"],
+    )
+
+    assert result["items"][0]["itemId"] == 77
+    assert captured["method"] == "GET"
+    parsed = urlparse(str(captured["path"]))
+    assert parsed.path == "/search"
+    assert parse_qs(parsed.query) == {
+        "q": ["kamera"],
+        "paging": ["1"],
+        "sortBy": ["Relevance"],
+        "languageCodeIso2": ["sv"],
+        "itemType": ["FixedPrice"],
+        "fromPrice": ["100"],
+        "toPrice": ["500"],
+        "allowedBuyerRegions": ["eu;international"],
+        "counties": ["Stockholm;Uppsala"],
+    }
+
+
+def test_search_uses_search_page_for_search_type() -> None:
+    client = TraderaClient()
+    captured: dict[str, object] = {}
+    next_data = {
+        "props": {
+            "pageProps": {
+                "initialState": {
+                    "discover": {
+                        "items": [{"itemId": 88}],
+                        "queryParams": {"q": "kamera", "searchType": "ExactSearch"},
+                    }
+                }
+            }
+        }
+    }
+
+    def fake_request(method: str, path: str, **_kwargs: object) -> str:
+        captured["method"] = method
+        captured["path"] = 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.search("kamera", search_type="ExactSearch")
+
+    assert result["items"][0]["itemId"] == 88
+    assert captured["method"] == "GET"
+    parsed = urlparse(str(captured["path"]))
+    assert parsed.path == "/search"
+    assert parse_qs(parsed.query) == {
+        "q": ["kamera"],
+        "paging": ["1"],
+        "sortBy": ["Relevance"],
+        "languageCodeIso2": ["sv"],
+        "searchType": ["ExactSearch"],
+    }
+
+
+def test_search_page_raises_when_next_data_is_missing() -> None:
+    client = TraderaClient()
+    client._request = lambda *_args, **_kwargs: "<html></html>"  # type: ignore[method-assign]
+
+    with pytest.raises(TraderaApiError, match="Could not parse search page response"):
+        client.search("kamera", item_status="Unsold")
+
+
 def test_item_returns_dict_or_raises() -> None:
     client = TraderaClient()
     client._request = lambda *_args, **_kwargs: {"itemId": 123}  # type: ignore[method-assign]
@@ -222,6 +420,45 @@ def test_item_returns_dict_or_raises() -> None:
         client.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] = {}
@@ -242,5 +479,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.0 → tradera_cli-0.1.2}/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
@@ -64,6 +69,14 @@ def test_cmd_search_and_no_translate(monkeypatch: pytest.MonkeyPatch, capsys: py
         sort="Relevance",
         lang="sv",
         country="SE",
+        item_status="Sold",
+        condition="Oanvänt",
+        item_type="FixedPrice",
+        from_price=100,
+        to_price=500,
+        allowed_buyer_regions="eu",
+        counties=["Stockholm", "Uppsala"],
+        search_type="ExactSearch",
         no_translate=True,
         format="table",
     )
@@ -72,11 +85,19 @@ def test_cmd_search_and_no_translate(monkeypatch: pytest.MonkeyPatch, capsys: py
 
     assert code == 0
     assert calls["automatic_translation_preferred"] is False
+    assert calls["item_status"] == "Sold"
+    assert calls["condition"] == "Oanvänt"
+    assert calls["item_type"] == "FixedPrice"
+    assert calls["from_price"] == 100
+    assert calls["to_price"] == 500
+    assert calls["allowed_buyer_regions"] == "eu"
+    assert calls["counties"] == ["Stockholm", "Uppsala"]
+    assert calls["search_type"] == "ExactSearch"
     out = capsys.readouterr().out
     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 {
@@ -84,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")
@@ -94,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:
@@ -106,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")
@@ -114,6 +155,58 @@ 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_categories_jsonl(monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
     class CategoriesClient(DummyClient):
         def categories(self, **_kwargs: object) -> list:

{tradera_cli-0.1.0 → tradera_cli-0.1.2}/tradera_cli/__init__.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "0.1.0"
+__version__ = "0.1.1"

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

@@ -1,14 +1,21 @@
 from __future__ import annotations
 
+import json
 import re
 from dataclasses import dataclass
 from typing import Any
+from urllib.parse import urlencode, urlparse
 
 import requests
 from requests import RequestException
 
 
 BASE_URL = "https://www.tradera.com"
+ALLOWED_BUYER_REGIONS = {
+    "sweden": "sweden;eu;international",
+    "eu": "eu;international",
+    "international": "international",
+}
 
 
 class TraderaApiError(RuntimeError):
@@ -25,7 +32,7 @@ class TraderaClient:
         self.session.headers.update(
             {
                 "accept": "application/json, text/plain, */*",
-                "user-agent": "tradera-cli/0.1.0",
+                "user-agent": "tradera-cli/0.1.1",
             }
         )
 
@@ -84,7 +91,43 @@ class TraderaClient:
         language_code_iso2: str = "sv",
         shipping_country_code_iso2: str = "SE",
         automatic_translation_preferred: bool = True,
+        item_status: str | None = None,
+        condition: str | None = None,
+        item_type: str | None = None,
+        from_price: int | None = None,
+        to_price: int | None = None,
+        allowed_buyer_regions: str | None = None,
+        counties: list[str] | None = None,
+        search_type: str | None = None,
     ) -> dict[str, Any]:
+        normalized_item_status = item_status or "Active"
+        page_filters: dict[str, str] = {}
+        if search_type:
+            page_filters["searchType"] = search_type
+        if normalized_item_status in {"Sold", "Unsold"}:
+            page_filters["itemStatus"] = normalized_item_status
+        if condition:
+            page_filters["af-condition"] = condition
+        if item_type and item_type != "All":
+            page_filters["itemType"] = item_type
+        if from_price is not None:
+            page_filters["fromPrice"] = str(from_price)
+        if to_price is not None:
+            page_filters["toPrice"] = str(to_price)
+        if allowed_buyer_regions:
+            page_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,
@@ -118,12 +161,72 @@ class TraderaClient:
         }
         return self._request("POST", "/api/webapi/discover/web/independent-search", json=payload)
 
+    def _search_page(
+        self,
+        query: str,
+        page: int,
+        sort_by: str,
+        language_code_iso2: str,
+        filters: dict[str, str],
+    ) -> dict[str, Any]:
+        params = {
+            "q": query,
+            "paging": page,
+            "sortBy": sort_by,
+            "languageCodeIso2": language_code_iso2.lower(),
+        }
+        params.update(filters)
+        html = self._request("GET", f"/search?{urlencode(params)}")
+        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
+
+        discover = data.get("props", {}).get("pageProps", {}).get("initialState", {}).get("discover")
+        if not isinstance(discover, dict):
+            raise TraderaApiError("Unexpected search page data")
+        return discover
+
     def item(self, item_id: int) -> dict[str, Any]:
         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]:
+        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}")
+
+        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 = (
+            data.get("props", {})
+            .get("pageProps", {})
+            .get("initialState", {})
+            .get("views", {})
+            .get("viewItem", {})
+            .get("itemDetails", {})
+            .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")
 
@@ -131,7 +234,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.2/tradera_cli/cli.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Any
+
+from .api import TraderaApiError, TraderaClient, parse_item_id
+from .formatters import (
+    normalize_categories_rows,
+    normalize_search_rows,
+    to_json,
+    to_jsonl,
+    to_table,
+)
+
+
+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))
+        return
+    if fmt == "jsonl":
+        print(to_jsonl(rows))
+        return
+    print(to_table(rows, columns))
+
+
+def cmd_search(args: argparse.Namespace) -> int:
+    client = TraderaClient()
+    data = client.search(
+        query=args.query,
+        page=args.page,
+        page_size=args.page_size,
+        sort_by=args.sort,
+        language_code_iso2=args.lang,
+        shipping_country_code_iso2=args.country,
+        automatic_translation_preferred=not args.no_translate,
+        item_status=args.item_status,
+        condition=args.condition,
+        item_type=args.item_type,
+        from_price=args.from_price,
+        to_price=args.to_price,
+        allowed_buyer_regions=args.allowed_buyer_regions,
+        counties=args.counties,
+        search_type=args.search_type,
+    )
+    rows = normalize_search_rows(data)
+    _print_output(
+        raw=data,
+        rows=rows,
+        fmt=args.format,
+        columns=["itemId", "title", "price", "currency", "endDate", "url"],
+    )
+    return 0
+
+
+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 data.get("leadingBid")
+                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", "buyerProtectionTotal", "buyerProtectionFee", "seller"],
+            )
+        )
+    else:
+        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
+
+
+def cmd_categories(args: argparse.Namespace) -> int:
+    client = TraderaClient()
+    data = client.categories(level=args.level, lang=args.lang)
+    rows = normalize_categories_rows(data)
+    _print_output(raw=data, rows=rows, fmt=args.format, columns=["id", "name", "level"])
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="tradera", description="Tradera CLI")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    search = subparsers.add_parser("search", help="Search listings")
+    search.add_argument("query", help="Search query")
+    search.add_argument("--page", type=int, default=1)
+    search.add_argument("--page-size", type=int, default=50)
+    search.add_argument("--sort", default="Relevance")
+    search.add_argument("--lang", default="sv")
+    search.add_argument("--country", default="SE")
+    search.add_argument("--item-status", choices=["Active", "Sold", "Unsold"])
+    search.add_argument("--condition", choices=["Oanvänt", "Mycket gott skick", "Gott skick", "Okej skick", "Defekt"])
+    search.add_argument("--item-type", choices=["All", "Auction", "FixedPrice", "ContactOnly"])
+    search.add_argument("--from-price", type=int)
+    search.add_argument("--to-price", type=int)
+    search.add_argument("--allowed-buyer-regions", choices=["sweden", "eu", "international"])
+    search.add_argument("--counties", nargs="+")
+    search.add_argument("--search-type", choices=["ExactSearch"])
+    search.add_argument("--no-translate", action="store_true")
+    search.add_argument("--format", choices=["table", "json", "jsonl"], default="table")
+    search.set_defaults(func=cmd_search)
+
+    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", "jsonl"], default="json")
+    item.set_defaults(func=cmd_item)
+
+    categories = subparsers.add_parser("categories", help="List categories by level")
+    categories.add_argument("--level", type=int, default=1)
+    categories.add_argument("--lang", default="sv")
+    categories.add_argument("--format", choices=["table", "json", "jsonl"], default="table")
+    categories.set_defaults(func=cmd_categories)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        code = args.func(args)
+    except (TraderaApiError, ValueError) as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        raise SystemExit(2) from exc
+    raise SystemExit(code)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tradera-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: CLI for Tradera web endpoints
 Author: Johnny W
 License-Expression: MIT
@@ -69,6 +69,11 @@ tradera search "iphone"
 tradera search "pokemon" --page 2 --page-size 20
 tradera search "kamera" --sort AddedOn --format json
 tradera search "klocka" --country SE --lang sv --format jsonl
+tradera search "lego" --item-status Sold --format json
+tradera search "lego" --condition "Oanvänt" --format json
+tradera search "lego" --item-type FixedPrice --from-price 100 --to-price 500
+tradera search "lego" --allowed-buyer-regions eu --counties Stockholm Uppsala
+tradera search "lego city" --search-type ExactSearch
 ```
 
 ### Get item details
@@ -105,6 +110,14 @@ Search command (`tradera search`) supports:
 | `--sort` | Sort mode (default: `Relevance`) |
 | `--lang` | Language code (default: `sv`) |
 | `--country` | Shipping country code (default: `SE`) |
+| `--item-status` | Filter by item status: `Active`, `Sold`, `Unsold` |
+| `--condition` | Filter by condition: `Oanvänt`, `Mycket gott skick`, `Gott skick`, `Okej skick`, `Defekt` |
+| `--item-type` | Filter by listing type: `All`, `Auction`, `FixedPrice`, `ContactOnly` |
+| `--from-price` | Minimum price |
+| `--to-price` | Maximum price |
+| `--allowed-buyer-regions` | Buyer region filter: `sweden`, `eu`, `international` |
+| `--counties` | Pickup counties, passed as one or more values, for example `Stockholm Uppsala` |
+| `--search-type` | Search mode. Current supported value: `ExactSearch` |
 | `--no-translate` | Disable automatic translation preference |
 | `--format` | Output format: `table`, `json`, `jsonl` |
 

tradera_cli-0.1.0/tradera_cli/cli.py

@@ -1,111 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import sys
-from typing import Any
-
-from .api import TraderaApiError, TraderaClient, parse_item_id
-from .formatters import (
-    normalize_categories_rows,
-    normalize_search_rows,
-    to_json,
-    to_jsonl,
-    to_table,
-)
-
-
-def _print_output(raw: Any, rows: list[dict[str, Any]], fmt: str, columns: list[str]) -> None:
-    if fmt == "json":
-        print(to_json(raw))
-        return
-    if fmt == "jsonl":
-        print(to_jsonl(rows))
-        return
-    print(to_table(rows, columns))
-
-
-def cmd_search(args: argparse.Namespace) -> int:
-    client = TraderaClient()
-    data = client.search(
-        query=args.query,
-        page=args.page,
-        page_size=args.page_size,
-        sort_by=args.sort,
-        language_code_iso2=args.lang,
-        shipping_country_code_iso2=args.country,
-        automatic_translation_preferred=not args.no_translate,
-    )
-    rows = normalize_search_rows(data)
-    _print_output(
-        raw=data,
-        rows=rows,
-        fmt=args.format,
-        columns=["itemId", "title", "price", "currency", "endDate", "url"],
-    )
-    return 0
-
-
-def cmd_item(args: argparse.Namespace) -> int:
-    client = TraderaClient()
-    item_id = parse_item_id(args.item)
-    data = client.item(item_id)
-    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 "",
-            "currency": data.get("currency") or "SEK",
-            "seller": (data.get("seller") or {}).get("alias") if isinstance(data.get("seller"), dict) else "",
-        }
-        print(to_table([row], ["itemId", "title", "price", "currency", "seller"]))
-    else:
-        print(to_json(data))
-    return 0
-
-
-def cmd_categories(args: argparse.Namespace) -> int:
-    client = TraderaClient()
-    data = client.categories(level=args.level, lang=args.lang)
-    rows = normalize_categories_rows(data)
-    _print_output(raw=data, rows=rows, fmt=args.format, columns=["id", "name", "level"])
-    return 0
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="tradera", description="Tradera CLI")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    search = subparsers.add_parser("search", help="Search listings")
-    search.add_argument("query", help="Search query")
-    search.add_argument("--page", type=int, default=1)
-    search.add_argument("--page-size", type=int, default=50)
-    search.add_argument("--sort", default="Relevance")
-    search.add_argument("--lang", default="sv")
-    search.add_argument("--country", default="SE")
-    search.add_argument("--no-translate", action="store_true")
-    search.add_argument("--format", choices=["table", "json", "jsonl"], default="table")
-    search.set_defaults(func=cmd_search)
-
-    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.set_defaults(func=cmd_item)
-
-    categories = subparsers.add_parser("categories", help="List categories by level")
-    categories.add_argument("--level", type=int, default=1)
-    categories.add_argument("--lang", default="sv")
-    categories.add_argument("--format", choices=["table", "json", "jsonl"], default="table")
-    categories.set_defaults(func=cmd_categories)
-
-    return parser
-
-
-def main(argv: list[str] | None = None) -> None:
-    parser = build_parser()
-    args = parser.parse_args(argv)
-    try:
-        code = args.func(args)
-    except (TraderaApiError, ValueError) as exc:
-        print(f"Error: {exc}", file=sys.stderr)
-        raise SystemExit(2) from exc
-    raise SystemExit(code)