wbapi-async 0.7.0__tar.gz → 0.7.2__tar.gz

{wbapi_async-0.7.0 → wbapi_async-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbapi-async
-Version: 0.7.0
+Version: 0.7.2
 Summary: Asynchronous client for Wildberries API
 Project-URL: Documentation, https://serdukow.github.io/wbapi-async/
 Project-URL: Repository, https://github.com/serdukow/wbapi-async
@@ -47,7 +47,7 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-### Lightweight async client for Wildberries Seller API
+#### Lightweight async client for Wildberries Seller API
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![PyPI version](https://img.shields.io/pypi/v/wild-api.svg)](https://pypi.org/project/wild-api/)
@@ -59,20 +59,27 @@ Description-Content-Type: text/markdown
 Lightweight async Python client for the [Wildberries Seller API](https://dev.wildberries.ru).
 Just pass the path from the docs and get data back.
 
+## Features
+
+- **Zero boilerplate** — WB API changes constantly; typed models break on every schema update. Instead, responses are plain attribute-accessible dicts — `result.fieldName` just works, no models to maintain
+- **Auto-pagination** — `get_all()` fetches all page. Auto-detect for all known strategies
+- **Rate limiting** — per-endpoint limits from the spec, powered by `aiolimiter`
+- **Auto-retry** — automatic retry on HTTP 429 with `X-Ratelimit-Retry` backoff
+- **Always up to date** — path registry is [auto-generated](https://github.com/serdukow/wbapi-codegen) from WB OpenAPI specs daily
+- **Fully async** — built on `httpx` + `asyncio`
+
 ## Install
 
 ```bash
 pip install wbapi-async
 ```
 
-## Usage
+## Quick start
 
 ```python
 from wbapi_async import WbAPI
 
 async with WbAPI(token="...") as api:
-    orders = await api.get("/api/v3/orders/new", limit=10, next=0)
-    print(f"orders: {orders.orders!r}")
 
     supplies = await api.get_all("/api/v3/supplies")
     print(f"supplies: {supplies!r}")
@@ -84,28 +91,4 @@ async with WbAPI(token="...") as api:
     await api.delete("/content/v2/tag/99")
 ```
 
-Paths are used exactly as they appear in the [wb api](https://dev.wildberries.ru) —
-no need to know which subdomain serves which endpoint, it's resolved automatically.
-
-## Features
-
-- **Zero boilerplate** — no type models, no method classes, just `api.get(path, **params)`
-- **Auto-pagination** — `get_all()` fetches all page. Currently auto-detects cursor or offset style
-- **Rate limiting** — per-endpoint limits from the spec, powered by `aiolimiter`
-- **Auto-retry** — automatic retry on HTTP 429 with `X-Ratelimit-Retry` backoff
-- **Always up to date** — path registry is [auto-generated](https://github.com/serdukow/wbapi-codegen) from WB OpenAPI specs daily
-- **Fully async** — built on `httpx` + `asyncio`
-
-## Custom pagination
-
-For endpoints with non-standard pagination, pass a `paginator=` callable.
-If you've figured out a pattern that works well — feel free to open a [PR](https://github.com/serdukow/wbapi-async/pulls):
-
-```python
-def my_paginator(response):
-    items = response.get("result", [])
-    cursor = response.get("cursor") or None
-    return items, {"cursor": cursor} if cursor else None
-
-all_items = await api.get_all("/api/v3/custom", paginator=my_paginator)
-```
+Just copy the path straight from the [WB API](https://dev.wildberries.ru) — the correct base URL and subdomain are resolved automatically.

{wbapi_async-0.7.0 → wbapi_async-0.7.2}/README.md

@@ -4,7 +4,7 @@
 
 <div align="center">
 
-### Lightweight async client for Wildberries Seller API
+#### Lightweight async client for Wildberries Seller API
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![PyPI version](https://img.shields.io/pypi/v/wild-api.svg)](https://pypi.org/project/wild-api/)
@@ -16,20 +16,27 @@
 Lightweight async Python client for the [Wildberries Seller API](https://dev.wildberries.ru).
 Just pass the path from the docs and get data back.
 
+## Features
+
+- **Zero boilerplate** — WB API changes constantly; typed models break on every schema update. Instead, responses are plain attribute-accessible dicts — `result.fieldName` just works, no models to maintain
+- **Auto-pagination** — `get_all()` fetches all page. Auto-detect for all known strategies
+- **Rate limiting** — per-endpoint limits from the spec, powered by `aiolimiter`
+- **Auto-retry** — automatic retry on HTTP 429 with `X-Ratelimit-Retry` backoff
+- **Always up to date** — path registry is [auto-generated](https://github.com/serdukow/wbapi-codegen) from WB OpenAPI specs daily
+- **Fully async** — built on `httpx` + `asyncio`
+
 ## Install
 
 ```bash
 pip install wbapi-async
 ```
 
-## Usage
+## Quick start
 
 ```python
 from wbapi_async import WbAPI
 
 async with WbAPI(token="...") as api:
-    orders = await api.get("/api/v3/orders/new", limit=10, next=0)
-    print(f"orders: {orders.orders!r}")
 
     supplies = await api.get_all("/api/v3/supplies")
     print(f"supplies: {supplies!r}")
@@ -41,28 +48,4 @@ async with WbAPI(token="...") as api:
     await api.delete("/content/v2/tag/99")
 ```
 
-Paths are used exactly as they appear in the [wb api](https://dev.wildberries.ru) —
-no need to know which subdomain serves which endpoint, it's resolved automatically.
-
-## Features
-
-- **Zero boilerplate** — no type models, no method classes, just `api.get(path, **params)`
-- **Auto-pagination** — `get_all()` fetches all page. Currently auto-detects cursor or offset style
-- **Rate limiting** — per-endpoint limits from the spec, powered by `aiolimiter`
-- **Auto-retry** — automatic retry on HTTP 429 with `X-Ratelimit-Retry` backoff
-- **Always up to date** — path registry is [auto-generated](https://github.com/serdukow/wbapi-codegen) from WB OpenAPI specs daily
-- **Fully async** — built on `httpx` + `asyncio`
-
-## Custom pagination
-
-For endpoints with non-standard pagination, pass a `paginator=` callable.
-If you've figured out a pattern that works well — feel free to open a [PR](https://github.com/serdukow/wbapi-async/pulls):
-
-```python
-def my_paginator(response):
-    items = response.get("result", [])
-    cursor = response.get("cursor") or None
-    return items, {"cursor": cursor} if cursor else None
-
-all_items = await api.get_all("/api/v3/custom", paginator=my_paginator)
-```
+Just copy the path straight from the [WB API](https://dev.wildberries.ru) — the correct base URL and subdomain are resolved automatically.

{wbapi_async-0.7.0 → wbapi_async-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wbapi-async"
-version = "0.7.0"
+version = "0.7.2"
 description = "Asynchronous client for Wildberries API"
 authors = [
     { name = "Andrei Serdiukov", email = "asyncdf@gmail.com" },

{wbapi_async-0.7.0 → wbapi_async-0.7.2}/src/wbapi_async/api.py

@@ -5,7 +5,6 @@ from typing import Any
 from .client.session.base import BaseSession
 from .method import MethodDispatcher
 from .type import ApiResponse, _wrap
-from .utils.token import validate_token
 
 
 class WbAPI:
@@ -38,7 +37,6 @@ class WbAPI:
         *,
         timeout: int = 60,
     ) -> None:
-        validate_token(token)
         self._token = token
         self.session = session or BaseSession(base="https://wildberries.ru", timeout=timeout)
         self._dispatcher = MethodDispatcher(self.session, token)

{wbapi_async-0.7.0 → wbapi_async-0.7.2}/src/wbapi_async/client/session/base.py

@@ -56,7 +56,10 @@ class BaseSession:
             raise
 
         if response.status_code == 429:
-            retry_after = int(response.headers.get("X-Ratelimit-Retry", 1))
+            retry_after = int(response.headers.get("X-Ratelimit-Retry", "1"))
+            log = logging.getLogger("wbapi.session")
+            if retry_after > 60:
+                log.warning("Rate limit exceeded. Retrying in %s seconds", retry_after)
             await asyncio.sleep(retry_after)
             return await self._request(method, url, params=params, json=json, limit=limit)
 
@@ -69,10 +72,14 @@ class BaseSession:
 
         if not response.content:
             return None
+
         try:
             return response.json()
-        except Exception:
-            return None
+        except Exception as e:
+            raise WbAPIError(
+                http_status=response.status_code,
+                detail=f"Failed to decode JSON response: {response.text[:200]!r}",
+            ) from e
 
     async def get(
         self,

{wbapi_async-0.7.0 → wbapi_async-0.7.2}/src/wbapi_async/method.py

@@ -242,7 +242,6 @@ _PATH_TO_BASE: dict[str, str] = {
     "/ping": "https://common-api.wildberries.ru",
 }
 
-# (period_ms, limit, interval_ms, burst)
 _PATH_TO_LIMIT: dict[str, tuple[int, int, int, int]] = {
     "/adv/v0/auction/nms": (1000, 1, 1000, 1),
     "/adv/v0/auction/placements": (1000, 1, 1000, 1),
@@ -575,9 +574,9 @@ class MethodDispatcher:
         body = kwargs.pop("body", None)
         http_method = "POST" if body is not None else "GET"
 
-        def _do_request(extra: dict[str, Any] | None = None) -> Any:
+        def _do_request(extra: dict[str, Any] | None = None, extra_body: dict[str, Any] | None = None) -> Any:
             if body is not None:
-                json = {**body, **(extra or {})}
+                json = {**body, **(extra or {}), **(extra_body or {})}
                 return self.dispatch(http_method, path, params=kwargs or None, json=json)
             params = {**kwargs, **(extra or {})} or None
             return self.dispatch(http_method, path, params=params)
@@ -593,7 +592,12 @@ class MethodDispatcher:
                     break
             return result
 
-        raw = await _do_request({"limit": _PAGE_SIZE})
+        from .utils.paginate import PAGINATION_STRATEGIES
+
+        first_extra: dict[str, Any] = {"limit": _PAGE_SIZE}
+        if body is not None:
+            first_extra["offset"] = 0
+        raw = await _do_request(first_extra)
         page = _extract_list(raw)
 
         if page is None:
@@ -601,49 +605,10 @@ class MethodDispatcher:
 
         result: list[Any] = list(page)
 
-        # rrd_id cursor — detected by presence of rrd_id in last item
-        if page and isinstance(page[-1], dict) and "rrd_id" in page[-1]:
-            while page:
-                rrd_id = page[-1]["rrd_id"]
-                page = _extract_list(await _do_request({"rrdid": rrd_id})) or []
-                result.extend(page)
-            return result
-
-        # lastChangeDate cursor — detected by presence of lastChangeDate in last item
-        if page and isinstance(page[-1], dict) and "lastChangeDate" in page[-1]:
-            while page:
-                date_from = page[-1]["lastChangeDate"]
-                page = _extract_list(await _do_request({"dateFrom": date_from})) or []
-                result.extend(page)
-            return result
-
-        # Cursor pagination
-        if isinstance(raw, dict) and "next" in raw:
-            cursor = raw["next"]
-            while cursor:
-                raw = await _do_request({"limit": _PAGE_SIZE, "next": cursor})
-                page = _extract_list(raw)
-                if not page:
-                    break
-                result.extend(page)
-                cursor = raw.get("next") if isinstance(raw, dict) else None
-            return result
-
-        # Offset pagination — first page was full
-        if len(page) < _PAGE_SIZE:
-            if not result:
-                raise PaginationNotSupported(f"{path!r} returned empty first page — pagination not supported")
-            return result
-
-        offset = _PAGE_SIZE
-        while True:
-            raw = await _do_request({"limit": _PAGE_SIZE, "offset": offset})
-            page = _extract_list(raw)
-            if not page:
-                break
-            result.extend(page)
-            if len(page) < _PAGE_SIZE:
-                break
-            offset += _PAGE_SIZE
+        for strategy in PAGINATION_STRATEGIES:
+            if strategy.detect(raw, page, body):
+                return await strategy.paginate(result, page, raw, _do_request)
 
+        if not result:
+            raise PaginationNotSupported(f"{path!r} returned empty first page — pagination not supported")
         return result

wbapi_async-0.7.2/src/wbapi_async/utils/paginate.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+_Requester = Callable[..., Any]
+
+
+class PaginationStrategy:
+    """Base class for pagination strategies used by fetch_all."""
+
+    def detect(self, raw: Any, page: list[Any], body: Any) -> bool:
+        """Return True if this strategy applies to the given response."""
+        raise NotImplementedError
+
+    async def paginate(self, result: list[Any], page: list[Any], raw: Any, request: _Requester) -> list[Any]:
+        """Continue fetching pages and append to result. Return final list."""
+        raise NotImplementedError
+
+
+class RrdIdCursorStrategy(PaginationStrategy):
+    def detect(self, raw: Any, page: list[Any], body: Any) -> bool:
+        return bool(page and isinstance(page[-1], dict) and "rrd_id" in page[-1])
+
+    async def paginate(self, result: list[Any], page: list[Any], raw: Any, request: _Requester) -> list[Any]:
+        from ..method import _extract_list
+
+        while page:
+            rrd_id = page[-1]["rrd_id"]
+            page = _extract_list(await request({"rrdid": rrd_id})) or []
+            result.extend(page)
+        return result
+
+
+class LastChangeDateStrategy(PaginationStrategy):
+    def detect(self, raw: Any, page: list[Any], body: Any) -> bool:
+        return bool(page and isinstance(page[-1], dict) and "lastChangeDate" in page[-1])
+
+    async def paginate(self, result: list[Any], page: list[Any], raw: Any, request: _Requester) -> list[Any]:
+        from ..method import _extract_list
+
+        while page:
+            date_from = page[-1]["lastChangeDate"]
+            page = _extract_list(await request({"dateFrom": date_from})) or []
+            result.extend(page)
+        return result
+
+
+class BodyCursorStrategy(PaginationStrategy):
+    def detect(self, raw: Any, page: list[Any], body: Any) -> bool:
+        return body is not None and isinstance(raw, dict) and bool(raw.get("cursor"))
+
+    async def paginate(self, result: list[Any], page: list[Any], raw: Any, request: _Requester) -> list[Any]:
+        from ..method import _extract_list
+
+        cursor_val = raw.get("cursor")
+        while cursor_val:
+            raw = await request(extra_body={"cursor": cursor_val})
+            page = _extract_list(raw)
+            if not page:
+                break
+            result.extend(page)
+            cursor_val = raw.get("cursor") if isinstance(raw, dict) else None
+        return result
+
+
+class NextCursorStrategy(PaginationStrategy):
+    def detect(self, raw: Any, page: list[Any], body: Any) -> bool:
+        return isinstance(raw, dict) and "next" in raw
+
+    async def paginate(self, result: list[Any], page: list[Any], raw: Any, request: _Requester) -> list[Any]:
+        from ..method import _PAGE_SIZE, _extract_list
+
+        cursor = raw["next"]
+        while cursor:
+            raw = await request({"limit": _PAGE_SIZE, "next": cursor})
+            page = _extract_list(raw)
+            if not page:
+                break
+            result.extend(page)
+            cursor = raw.get("next") if isinstance(raw, dict) else None
+        return result
+
+
+class OffsetStrategy(PaginationStrategy):
+    def detect(self, raw: Any, page: list[Any], body: Any) -> bool:
+        from ..method import _PAGE_SIZE
+
+        return len(page) >= _PAGE_SIZE
+
+    async def paginate(self, result: list[Any], page: list[Any], raw: Any, request: _Requester) -> list[Any]:
+        from ..method import _PAGE_SIZE, _extract_list
+
+        offset = _PAGE_SIZE
+        while True:
+            raw = await request({"limit": _PAGE_SIZE, "offset": offset})
+            page = _extract_list(raw)
+            if not page:
+                break
+            result.extend(page)
+            if len(page) < _PAGE_SIZE:
+                break
+            offset += _PAGE_SIZE
+        return result
+
+
+PAGINATION_STRATEGIES: list[PaginationStrategy] = [
+    RrdIdCursorStrategy(),
+    LastChangeDateStrategy(),
+    BodyCursorStrategy(),
+    NextCursorStrategy(),
+    OffsetStrategy(),
+]

wbapi_async-0.7.0/src/wbapi_async/utils/paginate.py

@@ -1,86 +0,0 @@
-"""paginate() — fetch all pages from a paginated API method.
-
-Example::
-
-    from wbapi_async import WbAPI, paginate
-
-    async with WbAPI(token="...") as api:
-        products = await paginate(
-            api.get_products_with_prices, nm_id=123
-        )
-        orders = await paginate(
-            api.get_assembly_orders, date_from=1700000000
-        )
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from pydantic import TypeAdapter
-
-
-if TYPE_CHECKING:
-    from ..client.api import WbAPI
-
-
-async def paginate(method: Any, **kwargs: Any) -> list[Any]:
-    """Fetch all pages from a paginated API method and return a combined list.
-
-    Args:
-        method: A bound method from WbAPI (e.g. ``api.get_products_with_prices``).
-        **kwargs: Parameters to pass to the method (excluding pagination params).
-
-    Returns:
-        Combined list of all items from all pages.
-
-    Raises:
-        TypeError: If the method does not support pagination.
-
-    Example::
-
-        products = await paginate(
-            api.get_products_with_prices, nm_id=123
-        )
-    """
-    from ..methods.pagination import PAGINATION_STRATEGIES  # lazy — avoids circular import
-
-    # Resolve WbAPI instance and WbMethod class from the bound method
-    wb_api: WbAPI = method.__self__
-    method_cls = getattr(method, "__wrapped_cls__", None)
-    if method_cls is None:
-        raise TypeError(
-            f"{method.__name__!r} does not expose __wrapped_cls__. "
-            "Only auto-generated WbAPI methods support paginate()."
-        )
-
-    pagination_key: str | None = method_cls.__dict__.get("__pagination__")
-    if not isinstance(pagination_key, str):
-        raise TypeError(f"{method_cls.__name__} does not support pagination (__pagination__ is not set)")
-
-    strategy = PAGINATION_STRATEGIES[pagination_key]
-    pagination_params = strategy.first_params()
-
-    # Use model_construct to skip validation — pagination params are injected separately
-    instance = method_cls.model_construct(**kwargs)
-    return_type = method_cls.__return__
-    adapter: TypeAdapter[Any] = TypeAdapter(list[return_type])  # type: ignore[valid-type]
-
-    wb_api.session.headers.set_token(wb_api._token)
-    url = instance._get_url(wb_api)
-    request_limit = getattr(instance, "request_limit", None)
-    http_method = getattr(instance, "__http_method__", "GET").upper()
-    base_params = instance.model_dump(by_alias=True, exclude_none=True, exclude={"request_limit"})
-    result: list[Any] = []
-
-    while True:
-        raw = await instance._dispatch(
-            wb_api, http_method, url, {**base_params, **pagination_params}, request_limit
-        )
-        page_raw = instance._extract(raw)
-        if not page_raw:
-            return result
-        result.extend(adapter.validate_python(page_raw))
-        pagination_params = strategy.next_params(pagination_params, raw, page_raw)
-        if pagination_params is None:
-            return result

wbapi_async-0.7.0/src/wbapi_async/utils/token.py

@@ -1,63 +0,0 @@
-import base64
-from functools import lru_cache
-import json
-import time
-
-from ..exceptions import TokenValidationError
-
-
-def _decode_part(part: str) -> dict:
-    padded = part + "=" * (-len(part) % 4)
-    try:
-        return json.loads(base64.urlsafe_b64decode(padded))
-    except Exception as exc:
-        raise TokenValidationError("Token is invalid! Failed to decode JWT part.") from exc
-
-
-@lru_cache
-def validate_token(token: str) -> bool:
-    """
-    Validate WB API JWT token (RFC 7519).
-
-    Checks header typ=JWT, required payload fields (id, sid, acc, t, s, exp),
-    valid acc value (1-4), and token expiry.
-
-    Source: https://dev.wildberries.ru/en/docs/openapi/api-information#tag/Authorization/About-the-token
-
-    :param token: Access token
-    :return: True if token is valid
-    :raises TokenValidationError: If token is malformed or expired
-    """
-    # "test" is a special token that bypasses validation.
-    # It exists to allow using unofficial (undocumented) API methods
-    # that don't require authorization. Not intended for public use.
-    if token == "test":
-        return True
-
-    if not isinstance(token, str) or not token:
-        raise TokenValidationError("Token is invalid! Must be a non-empty string.")
-
-    if any(c.isspace() for c in token):
-        raise TokenValidationError("Token is invalid! Must not contain whitespace.")
-
-    parts = token.split(".")
-    if len(parts) != 3:
-        raise TokenValidationError(f"Token is invalid! JWT must have 3 parts, got {len(parts)}.")
-
-    header = _decode_part(parts[0])
-    if header.get("typ", "").upper() != "JWT":
-        raise TokenValidationError(f"Token is invalid! Header typ must be 'JWT', got {header.get('typ')!r}.")
-
-    payload = _decode_part(parts[1])
-
-    for field in ("id", "sid", "acc", "t", "s", "exp"):
-        if field not in payload:
-            raise TokenValidationError(f"Token is invalid! Payload missing '{field}' field.")
-
-    if payload["acc"] not in (1, 2, 3, 4):
-        raise TokenValidationError(f"Token is invalid! Unknown token type acc={payload['acc']!r}.")
-
-    if time.time() > payload["exp"]:
-        raise TokenValidationError("Token is invalid! Token has expired.")
-
-    return True

wbapi_async-0.7.0/src/wbapi_async/utils/unofficial.py

@@ -1,20 +0,0 @@
-from collections.abc import Callable
-from functools import wraps
-from typing import Any
-import warnings
-
-
-def unofficial(func: Callable[..., Any]) -> Callable[..., Any]:
-    """Mark a method as unofficial (not documented in WB API docs)."""
-
-    @wraps(func)
-    async def wrapper(*args: Any, **kwargs: Any) -> Any:
-        warnings.warn(
-            f"{func.__name__} is an unofficial method and may stop working at any time.",
-            stacklevel=2,
-        )
-        return await func(*args, **kwargs)
-
-    wrapper.__unofficial__ = True  # type: ignore[attr-defined]
-    wrapper.__doc__ = f".. warning:: Unofficial method — not documented in WB API.\n\n{func.__doc__ or ''}"
-    return wrapper