wbapi-async 0.7.7__tar.gz → 0.7.9__tar.gz

wbapi_async-0.7.9/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: wbapi-async
+Version: 0.7.9
+Summary: Fast, lightweight async client for the Wildberries Seller API
+Project-URL: Documentation, https://serdukow.github.io/wbapi-async/
+Project-URL: Repository, https://github.com/serdukow/wbapi-async
+Project-URL: Changelog, https://github.com/serdukow/wbapi-async/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/serdukow/wbapi-async/issues
+Author-email: Andrei Serdiukov <asyncdf@gmail.com>
+Maintainer-email: Andrei Serdiukov <asyncdf@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: api,async,client,wb,wildberries
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.11
+Requires-Dist: aiolimiter<2.0.0,>=1.2.1
+Requires-Dist: httpx<0.29.0,>=0.28.1
+Provides-Extra: dev
+Requires-Dist: pre-commit<5.0.0,>=4.3.0; extra == 'dev'
+Requires-Dist: ruff<0.15.0,>=0.14.1; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.6.0; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.29.0; extra == 'docs'
+Provides-Extra: lint
+Requires-Dist: pre-commit<5.0.0,>=4.3.0; extra == 'lint'
+Requires-Dist: ruff<0.15.0,>=0.14.1; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio<2.0.0,>=1.2.0; extra == 'test'
+Requires-Dist: pytest-httpx<0.37.0,>=0.35.0; extra == 'test'
+Requires-Dist: pytest<9.0.0,>=8.4.2; extra == 'test'
+Requires-Dist: python-dotenv<2.0.0,>=1.2.1; extra == 'test'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://dev.wildberries.ru"><img src="https://i.ibb.co/dwsMVbNC/logo.png" alt="wbapi"></a>
+</p>
+
+<p align="center">
+<a href="https://img.shields.io/pypi/v/wbapi-async.svg">
+<img src="https://img.shields.io/pypi/v/wbapi-async.svg" alt="Version">
+</a>
+<a href="https://pypi.python.org/pypi/wbapi-async">
+<img src="https://img.shields.io/pypi/dm/wbapi-async.svg" alt="Downloads">
+</a>
+<a href="https://pypi.python.org/pypi/wbapi-async">
+<img src="https://img.shields.io/badge/status-stable-green.svg?logo=git&logoColor=green" alt="Status">
+</a>
+<a href="https://pypi.org/project/wbapi-async">
+<img src="https://img.shields.io/pypi/pyversions/wbapi-async.svg" alt="Python">
+</a>
+</p>
+
+---
+
+**Documentation**: [https://dev.wildberries.ru](https://dev.wildberries.ru)
+
+**Source Code**: [https://github.com/serdukow/wbapi-async](https://github.com/serdukow/wbapi-async)
+
+---
+
+**wbapi** is a lightweight async client for the Wildberries Seller API, built on top of [httpx](https://www.python-httpx.org/).
+
+It handles pagination, rate limiting, and base URL resolution automatically — so you can focus on your business logic instead of HTTP boilerplate.
+
+## Requirements
+
+Python 3.10+
+
+wbapi stands on the shoulders of giants:
+
+- [httpx](https://www.python-httpx.org/) for async HTTP.
+- [aiolimiter](https://github.com/mjpieters/aiolimiter) for rate limiting.
+
+## Installation
+
+```bash
+pip install wbapi-async
+```
+
+## How to use
+
+1. Register in the Wildberries seller [personal account](https://seller.wildberries.ru/) if you haven't already.
+2. Go to store settings and [create an API token](https://dev.wildberries.ru/en/docs/openapi/api-information#tag/Authorization/How-to-create-a-personal-access-base-or-test-token).
+
+## Quick start
+
+```python
+import asyncio
+from wbapi import WbAPI
+
+async def main():
+    async with WbAPI(token="your_api_token") as api:
+        # Simple request
+        warehouses = await api.get("/api/v3/warehouses")
+
+        # Auto-paginated — fetches all pages automatically
+        all_cards = await api.post(
+            "/content/v2/get/cards/list",
+            body={
+                "settings": {
+                    "sort": {"ascending": True},
+                    "cursor": {"limit": 100},
+                    "filter": {"withPhoto": -1},
+                }
+            },
+            paginate=True,
+        )
+        print(all_cards)
+
+asyncio.run(main())
+```
+
+Pass `paginate=True` to any `get` or `post` call and the library fetches all pages automatically. Pagination strategy (cursor, token, or offset) is detected from the first response.
+
+Base URL resolution and per-endpoint rate limiting are handled transparently.
+
+## License
+
+This project is licensed under the terms of the [MIT license](https://github.com/serdukow/wbapi-async/blob/main/LICENSE).

wbapi_async-0.7.9/README.md

@@ -0,0 +1,86 @@
+<p align="center">
+  <a href="https://dev.wildberries.ru"><img src="https://i.ibb.co/dwsMVbNC/logo.png" alt="wbapi"></a>
+</p>
+
+<p align="center">
+<a href="https://img.shields.io/pypi/v/wbapi-async.svg">
+<img src="https://img.shields.io/pypi/v/wbapi-async.svg" alt="Version">
+</a>
+<a href="https://pypi.python.org/pypi/wbapi-async">
+<img src="https://img.shields.io/pypi/dm/wbapi-async.svg" alt="Downloads">
+</a>
+<a href="https://pypi.python.org/pypi/wbapi-async">
+<img src="https://img.shields.io/badge/status-stable-green.svg?logo=git&logoColor=green" alt="Status">
+</a>
+<a href="https://pypi.org/project/wbapi-async">
+<img src="https://img.shields.io/pypi/pyversions/wbapi-async.svg" alt="Python">
+</a>
+</p>
+
+---
+
+**Documentation**: [https://dev.wildberries.ru](https://dev.wildberries.ru)
+
+**Source Code**: [https://github.com/serdukow/wbapi-async](https://github.com/serdukow/wbapi-async)
+
+---
+
+**wbapi** is a lightweight async client for the Wildberries Seller API, built on top of [httpx](https://www.python-httpx.org/).
+
+It handles pagination, rate limiting, and base URL resolution automatically — so you can focus on your business logic instead of HTTP boilerplate.
+
+## Requirements
+
+Python 3.10+
+
+wbapi stands on the shoulders of giants:
+
+- [httpx](https://www.python-httpx.org/) for async HTTP.
+- [aiolimiter](https://github.com/mjpieters/aiolimiter) for rate limiting.
+
+## Installation
+
+```bash
+pip install wbapi-async
+```
+
+## How to use
+
+1. Register in the Wildberries seller [personal account](https://seller.wildberries.ru/) if you haven't already.
+2. Go to store settings and [create an API token](https://dev.wildberries.ru/en/docs/openapi/api-information#tag/Authorization/How-to-create-a-personal-access-base-or-test-token).
+
+## Quick start
+
+```python
+import asyncio
+from wbapi import WbAPI
+
+async def main():
+    async with WbAPI(token="your_api_token") as api:
+        # Simple request
+        warehouses = await api.get("/api/v3/warehouses")
+
+        # Auto-paginated — fetches all pages automatically
+        all_cards = await api.post(
+            "/content/v2/get/cards/list",
+            body={
+                "settings": {
+                    "sort": {"ascending": True},
+                    "cursor": {"limit": 100},
+                    "filter": {"withPhoto": -1},
+                }
+            },
+            paginate=True,
+        )
+        print(all_cards)
+
+asyncio.run(main())
+```
+
+Pass `paginate=True` to any `get` or `post` call and the library fetches all pages automatically. Pagination strategy (cursor, token, or offset) is detected from the first response.
+
+Base URL resolution and per-endpoint rate limiting are handled transparently.
+
+## License
+
+This project is licensed under the terms of the [MIT license](https://github.com/serdukow/wbapi-async/blob/main/LICENSE).

{wbapi_async-0.7.7 → wbapi_async-0.7.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wbapi-async"
-version = "0.7.7"
+version = "0.7.9"
 description = "Fast, lightweight async client for the Wildberries Seller API"
 
 authors = [

{wbapi_async-0.7.7 → wbapi_async-0.7.9}/src/wbapi/__init__.py

@@ -1,8 +1,8 @@
 from importlib.metadata import version
 
-from .api import WbAPI
-from .exceptions import PaginationNotSupported, TokenValidationError, WBAPIError
-from .type import ApiResponse
+from ._core.type import ApiResponse
+from ._main import WbAPI
+from .exceptions import TokenValidationError, WBAPIError
 
 
 __version__ = version("wbapi-async")
@@ -11,7 +11,6 @@ __all__ = (
     "WbAPI",
     "WBAPIError",
     "TokenValidationError",
-    "PaginationNotSupported",
     "ApiResponse",
     "__version__",
 )

wbapi_async-0.7.9/src/wbapi/_core/__init__.py

@@ -0,0 +1,5 @@
+from ._method import MethodDispatcher
+from ._session import BaseSession
+
+
+__all__ = ("MethodDispatcher", "BaseSession")

wbapi_async-0.7.9/src/wbapi/_core/_method.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ._registry import _PAGE_SIZES, _PUBLIC
+from ._session import BaseSession
+from .limiter import _get_limiter
+from .paginate import fetch_all
+from .parse_url import parse_url
+from .type import ApiResponse, _wrap
+
+
+class MethodDispatcher:
+    def __init__(self, session: BaseSession, token: str) -> None:
+        self._session = session
+        self._token = token
+
+    async def dispatch(
+        self,
+        http_method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any | None = None,
+        paginate: bool = False,
+        no_auth: bool = False,
+    ) -> Any:
+        import re
+        from urllib.parse import urlparse
+
+        placeholders = re.findall(r"\{(\w+)\}", path)
+        if placeholders and params:
+            params = dict(params)
+            for key in placeholders:
+                if key in params:
+                    path = path.replace(f"{{{key}}}", str(params.pop(key)))
+            params = params or None
+
+        if not no_auth and path.startswith(("https://", "http://")):
+            no_auth = urlparse(path).netloc in _PUBLIC
+
+        if no_auth:
+            self._session.headers.authorization = None
+        else:
+            self._session.headers.set_token(self._token)
+
+        if paginate:
+            page_size = _PAGE_SIZES.get(path, 1000)
+
+            async def _request(
+                params: dict[str, Any] | None = None,
+                body: dict[str, Any] | None = None,
+            ) -> Any:
+                url = parse_url(path)
+                limiter = _get_limiter(path)
+                return await self._session._request(http_method, url, params=params, json=body, limit=limiter)
+
+            return [ApiResponse(item) for item in await fetch_all(_request, path, page_size, params, json)]
+
+        url = parse_url(path)
+        limiter = _get_limiter(path)
+        return _wrap(await self._session._request(http_method, url, params=params, json=json, limit=limiter))

wbapi_async-0.7.9/src/wbapi/_core/_paginators.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+_Requester = Callable[..., Any]
+
+
+def _extract_list(raw: Any) -> list[Any] | None:
+    if isinstance(raw, list):
+        return raw
+    if isinstance(raw, dict):
+        for v in raw.values():
+            if isinstance(v, list):
+                return v
+        for v in raw.values():
+            if isinstance(v, dict):
+                found = _extract_list(v)
+                if found is not None:
+                    return found
+    return None
+
+
+async def next_token(
+    raw: Any,
+    page: list[Any],
+    request: _Requester,
+    params: dict[str, Any],
+    page_size: int,
+) -> list[Any]:
+    """
+    Token continuation pagination: API returns ``next`` in the response root,
+    which is passed as ``?next=<value>`` in subsequent requests.
+
+    Used by: Marketplace (FBS/DBS/DBW orders), Supplies FBW, Q&A, Reviews.
+    Stop condition: ``next`` is falsy or the page is empty.
+    """
+    result: list[Any] = list(page)
+    while True:
+        cursor = raw.get("next") if isinstance(raw, dict) else None
+        if not cursor or not page:
+            break
+        raw = await request(params={**params, "limit": page_size, "next": cursor})
+        page = _extract_list(raw) or []
+        result.extend(page)
+    return result
+
+
+async def rrdid_token(
+    raw: Any,
+    page: list[Any],
+    request: _Requester,
+    params: dict[str, Any],
+    page_size: int,
+) -> list[Any]:
+    """
+    Finance report token pagination: last item in the page has ``rrd_id``,
+    which is passed as ``?rrdid=<value>`` in subsequent requests.
+
+    Used by: Finance (reportDetailByPeriod).
+    Stop condition: page is empty (API returns 204 No Content → empty list).
+    """
+    result: list[Any] = list(page)
+    while page:
+        rrd_id = page[-1].get("rrd_id") if isinstance(page[-1], dict) else None
+        if not rrd_id:
+            break
+        raw = await request(params={**params, "rrdid": rrd_id})
+        page = _extract_list(raw) or []
+        result.extend(page)
+    return result
+
+
+async def offset(
+    raw: Any,
+    page: list[Any],
+    request: _Requester,
+    params: dict[str, Any],
+    page_size: int,
+) -> list[Any]:
+    """
+    Offset pagination: increments ``offset`` by ``limit`` each request.
+
+    Used by: Analytics, Promotions, Reports.
+    Stop condition: returned page is smaller than ``limit``.
+    """
+    result: list[Any] = list(page)
+    current_offset = page_size
+    while len(page) >= page_size:
+        raw = await request(params={**params, "limit": page_size, "offset": current_offset})
+        page = _extract_list(raw) or []
+        result.extend(page)
+        current_offset += page_size
+    return result
+
+
+async def cursor(
+    raw: Any,
+    page: list[Any],
+    request: _Requester,
+    body: dict[str, Any],
+    page_size: int,
+) -> list[Any]:
+    """
+    Cursor pagination (POST body): API returns ``cursor`` object with
+    ``updatedAt``, ``nmID``, and ``total``. Next request merges cursor
+    fields into ``settings.cursor`` in the request body.
+
+    Used by: Content v2 (cards list).
+    Stop condition: ``cursor.total`` < ``limit``.
+    """
+    result: list[Any] = list(page)
+    while True:
+        cursor_obj = raw.get("cursor", {}) if isinstance(raw, dict) else {}
+        total = cursor_obj.get("total", 0) if isinstance(cursor_obj, dict) else 0
+        if total < page_size:
+            break
+        next_body = {
+            **body,
+            "settings": {
+                **body.get("settings", {}),
+                "cursor": {
+                    "limit": page_size,
+                    "updatedAt": cursor_obj["updatedAt"],
+                    "nmID": cursor_obj["nmID"],
+                },
+            },
+        }
+        raw = await request(body=next_body)
+        page = _extract_list(raw) or []
+        result.extend(page)
+    return result
+
+
+def detect_and_paginate(
+    raw: Any,
+    page: list[Any],
+    request: _Requester,
+    params: dict[str, Any],
+    body: dict[str, Any] | None,
+    page_size: int,
+) -> Any:
+    """
+    Auto-detect pagination type from first-page response and dispatch
+    to the appropriate paginator coroutine.
+
+    Detection order (first match wins):
+    1. CursorPaginator  — POST body with ``cursor.updatedAt`` in response
+    2. NextTokenPaginator — ``next`` key in response root
+    3. RrdIdTokenPaginator — last item in page has ``rrd_id``
+    4. OffsetPaginator  — page length == page_size (fallback)
+    """
+    if body is not None and isinstance(raw, dict):
+        cursor_obj = raw.get("cursor", {})
+        if isinstance(cursor_obj, dict) and "updatedAt" in cursor_obj:
+            return cursor(raw, page, request, body, page_size)
+
+    if isinstance(raw, dict) and "next" in raw:
+        return next_token(raw, page, request, params, page_size)
+
+    if page and isinstance(page[-1], dict) and "rrd_id" in page[-1]:
+        return rrdid_token(raw, page, request, params, page_size)
+
+    return offset(raw, page, request, params, page_size)

wbapi_async-0.7.7/src/wbapi/client/session/base.py → wbapi_async-0.7.9/src/wbapi/_core/_session.py

@@ -7,8 +7,7 @@ from aiolimiter import AsyncLimiter
 import httpx
 from httpx import RequestError
 
-from ...exceptions import WBAPIError
-from .headers import Headers
+from ..exceptions import WBAPIError
 
 
 log = logging.getLogger("wbapi.session")
@@ -16,6 +15,31 @@ logging.getLogger("httpx").setLevel(logging.WARNING)
 logging.getLogger("httpcore").setLevel(logging.WARNING)
 
 
+class Headers:
+    def __init__(self) -> None:
+        self.accept = "application/json;charset=utf-8"
+        self.content_type = "application/json"
+        self.authorization: str | None = None
+        self.user_agent = (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/124.0.0.0 Safari/537.36"
+        )
+
+    def set_token(self, token: str) -> None:
+        self.authorization = f"Bearer {token}"
+
+    def as_dict(self) -> dict[str, str]:
+        headers: dict[str, str] = {
+            "Accept": self.accept,
+            "Content-Type": self.content_type,
+            "User-Agent": self.user_agent,
+        }
+        if self.authorization is not None:
+            headers["Authorization"] = self.authorization
+        return headers
+
+
 class BaseSession:
     base_url: str
     timeout: int

wbapi_async-0.7.9/src/wbapi/_core/limiter.py

@@ -0,0 +1,16 @@
+from aiolimiter import AsyncLimiter
+
+from ._registry import _LIMITS
+
+
+_DEFAULT_LIMIT: tuple[int, int, int, int] = (60000, 60, 1000, 5)
+
+_limiters: dict[tuple[int, int], AsyncLimiter] = {}
+
+
+def _get_limiter(path: str) -> AsyncLimiter:
+    period, limit, interval, burst = _LIMITS.get(path, _DEFAULT_LIMIT)
+    key = (interval, burst)
+    if key not in _limiters:
+        _limiters[key] = AsyncLimiter(max_rate=burst, time_period=interval / 1000)
+    return _limiters[key]

wbapi_async-0.7.9/src/wbapi/_core/paginate.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from ._paginators import _extract_list, detect_and_paginate
+
+
+_Requester = Callable[..., Any]
+
+
+async def fetch_all(
+    request: _Requester,
+    path: str,
+    page_size: int,
+    params: dict[str, Any] | None,
+    body: dict[str, Any] | None,
+) -> list[Any]:
+    init_params = {**(params or {}), "limit": page_size}
+    if body is not None:
+        init_body = {**body}
+        raw = await request(params=init_params or None, body=init_body)
+    else:
+        raw = await request(params=init_params)
+
+    page = _extract_list(raw) or []
+    return await detect_and_paginate(raw, page, request, init_params, body, page_size)

wbapi_async-0.7.9/src/wbapi/_core/parse_url.py

@@ -0,0 +1,31 @@
+from ._registry import _BASES, _PUBLIC
+
+
+def parse_url(path: str) -> str:
+    """Resolve full URL for a spec path like /api/v3/supplies.
+
+    If a full URL is passed, it is returned as-is provided its host is a known
+    wildberries.ru domain or is listed in ``_PUBLIC``.
+    """
+    from urllib.parse import urlparse
+
+    from ..exceptions import WBAPIError
+
+    if path.startswith("https://") or path.startswith("http://"):
+        host = urlparse(path).netloc
+        known_hosts = {urlparse(v).netloc for v in _BASES.values()} | _PUBLIC
+        if host not in known_hosts:
+            raise WBAPIError(detail=f"Unknown host {host!r}.")
+        return path
+
+    base = _BASES.get(path)
+    if base:
+        return base + path
+    parts = path.rstrip("/").split("/")
+    for i in range(len(parts) - 1, 0, -1):
+        candidate = "/".join(parts[:i])
+        if candidate in _BASES:
+            return _BASES[candidate] + path
+    raise WBAPIError(
+        detail=f"{path!r} may be deprecated or removed. See https://dev.wildberries.ru/release-notes"
+    )

wbapi_async-0.7.7/src/wbapi/api.py → wbapi_async-0.7.9/src/wbapi/_main.py

@@ -2,9 +2,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from ._method import MethodDispatcher
-from .client.session.base import BaseSession
-from .type import ApiResponse, _wrap
+from ._core import BaseSession, MethodDispatcher
 
 
 class WbAPI:
@@ -25,59 +23,60 @@ class WbAPI:
         self.session = session or BaseSession(base="https://wildberries.ru", timeout=timeout)
         self._dispatcher = MethodDispatcher(self.session, token)
 
-    async def get(self, path: str, **kwargs: Any) -> Any:
+    async def get(self, path: str, *, paginate: bool = False, **kwargs: Any) -> Any:
         """
         Send a GET request. kwargs become query parameters.
 
+        Pass ``paginate=True`` to fetch all pages automatically.
+        Pagination type is detected from the first response:
+        - ``next`` in response → token continuation (Marketplace, Supplies, Q&A)
+        - ``rrd_id`` in last item → rrdid token (Finance reports)
+        - fallback → offset (Analytics, Promotions, Reports)
+
         Example::
+
             warehouses = await api.get("/api/v3/warehouses")
             orders = await api.get(
                 "/api/v3/orders/new", limit=10, next=0
             )
-            meta = await api.get(
-                "/api/v3/orders/{orderId}/meta", orderId=123
-            )
-        """
-        return _wrap(await self._dispatcher.dispatch("GET", path, params=kwargs or None))
 
-    async def get_all(self, path: str, **kwargs: Any) -> list[ApiResponse]:
-        """
-        Fetch all pages from a paginated endpoint. Pass ``body=`` to use POST.
-
-        Example::
-            supplies = await api.get_all("/api/v3/supplies")
-            cards = await api.get_all(
-                "/content/v2/get/cards/list",
-                body={"settings": {"sort": {"ascending": False}}},
+            all_orders = await api.get(
+                "/api/v3/orders", paginate=True, dateFrom=1698045576
+            )
+            all_sales = await api.get(
+                "/api/finance/v1/sales-reports/detailed",
+                paginate=True,
+                dateFrom="2024-01-01",
+                dateTo="2024-01-31",
             )
         """
-        return [ApiResponse(item) for item in await self._dispatcher.fetch_all(path, **kwargs)]
+        return await self._dispatcher.dispatch("GET", path, params=kwargs or None, paginate=paginate)
 
-    async def post(self, path: str, *, body: Any = None, **kwargs: Any) -> Any:
+    async def post(self, path: str, *, body: Any = None, paginate: bool = False, **kwargs: Any) -> Any:
         """
         Send a POST request. ``body`` is serialized as JSON. kwargs become query parameters.
 
+        Pass ``paginate=True`` to fetch all pages automatically.
+        Pagination type is detected from the first response:
+        - ``cursor.updatedAt`` in response → cursor pagination (Content, cards list)
+        - fallback → offset
+
         Example::
 
             await api.post(
                 "/content/v2/get/cards/list",
-                body={
-                    "settings": {
-                        "sort": {"ascending": False},
-                        "filter": {"textSearch": "12345"},
-                    }
-                },
-            )
-            await api.post(
-                "/content/v2/tag/nomenclature/link",
-                body={"nmID": 179891389, "tagsIDs": [123456]},
+                body={"settings": {"sort": {"ascending": False}}},
             )
-            await api.post(
-                "/adv/v0/rename",
-                body={"advertId": 2233344, "name": "newname"},
+
+            all_cards = await api.post(
+                "/content/v2/get/cards/list",
+                body={"settings": {"filter": {"withPhoto": -1}}},
+                paginate=True,
             )
         """
-        return _wrap(await self._dispatcher.dispatch("POST", path, json=body, params=kwargs or None))
+        return await self._dispatcher.dispatch(
+            "POST", path, json=body, params=kwargs or None, paginate=paginate
+        )
 
     async def put(self, path: str, *, body: Any = None, **kwargs: Any) -> Any:
         """
@@ -90,7 +89,7 @@ class WbAPI:
                 body={"stocks": [{"sku": "WB007", "amount": 10}]},
             )
         """
-        return _wrap(await self._dispatcher.dispatch("PUT", path, json=body, params=kwargs or None))
+        return await self._dispatcher.dispatch("PUT", path, json=body, params=kwargs or None)
 
     async def patch(self, path: str, *, body: Any = None, **kwargs: Any) -> Any:
         """
@@ -101,7 +100,7 @@ class WbAPI:
             await api.patch("/api/v3/orders/13833711/cancel")
             await api.patch("/content/v2/tag/99", body={"name": "sale"})
         """
-        return _wrap(await self._dispatcher.dispatch("PATCH", path, json=body, params=kwargs or None))
+        return await self._dispatcher.dispatch("PATCH", path, json=body, params=kwargs or None)
 
     async def delete(self, path: str, **kwargs: Any) -> Any:
         """
@@ -112,7 +111,7 @@ class WbAPI:
             await api.delete("/content/v2/tag/99")
             await api.delete("/api/v1/user", deletedUserID="abc-123")
         """
-        return _wrap(await self._dispatcher.dispatch("DELETE", path, params=kwargs or None))
+        return await self._dispatcher.dispatch("DELETE", path, params=kwargs or None)
 
     async def __aenter__(self) -> WbAPI:
         return self

{wbapi_async-0.7.7 → wbapi_async-0.7.9}/src/wbapi/exceptions.py

@@ -15,7 +15,3 @@ class WBAPIError(BaseWBAPIError):
 
 class TokenValidationError(BaseWBAPIError):
     pass
-
-
-class PaginationNotSupported(BaseWBAPIError):
-    pass

wbapi_async-0.7.7/PKG-INFO

@@ -1,94 +0,0 @@
-Metadata-Version: 2.4
-Name: wbapi-async
-Version: 0.7.7
-Summary: Fast, lightweight async client for the Wildberries Seller API
-Project-URL: Documentation, https://serdukow.github.io/wbapi-async/
-Project-URL: Repository, https://github.com/serdukow/wbapi-async
-Project-URL: Changelog, https://github.com/serdukow/wbapi-async/blob/main/CHANGELOG.md
-Project-URL: Issues, https://github.com/serdukow/wbapi-async/issues
-Author-email: Andrei Serdiukov <asyncdf@gmail.com>
-Maintainer-email: Andrei Serdiukov <asyncdf@gmail.com>
-License: MIT
-License-File: LICENSE
-Keywords: api,async,client,wb,wildberries
-Classifier: Development Status :: 4 - Beta
-Classifier: Framework :: AsyncIO
-Classifier: Framework :: Pydantic :: 2
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
-Requires-Python: <3.14,>=3.11
-Requires-Dist: aiolimiter<2.0.0,>=1.2.1
-Requires-Dist: httpx<0.29.0,>=0.28.1
-Provides-Extra: dev
-Requires-Dist: pre-commit<5.0.0,>=4.3.0; extra == 'dev'
-Requires-Dist: ruff<0.15.0,>=0.14.1; extra == 'dev'
-Provides-Extra: docs
-Requires-Dist: mkdocs-material>=9.6.0; extra == 'docs'
-Requires-Dist: mkdocstrings[python]>=0.29.0; extra == 'docs'
-Provides-Extra: lint
-Requires-Dist: pre-commit<5.0.0,>=4.3.0; extra == 'lint'
-Requires-Dist: ruff<0.15.0,>=0.14.1; extra == 'lint'
-Provides-Extra: test
-Requires-Dist: pytest-asyncio<2.0.0,>=1.2.0; extra == 'test'
-Requires-Dist: pytest-httpx<0.37.0,>=0.35.0; extra == 'test'
-Requires-Dist: pytest<9.0.0,>=8.4.2; extra == 'test'
-Requires-Dist: python-dotenv<2.0.0,>=1.2.1; extra == 'test'
-Description-Content-Type: text/markdown
-
-![Logo](https://dev.wildberries.ru/images/open-graph.png)
-
-<div align="center">
-
-#### Fast, lightweight async client for the 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/wbapi-async.svg)](https://pypi.org/project/wild-api/)
-[![Downloads](https://img.shields.io/pypi/dm/wbapi-async.svg)](https://pypi.python.org/pypi/wild-api)
-[![Docs](https://img.shields.io/badge/docs-serdukow.github.io-blue.svg)](https://serdukow.github.io/wbapi-async/)
-[![Python](https://img.shields.io/pypi/pyversions/wbapi-async.svg)](https://pypi.org/project/wbapi-async/)
-
-</div>
-
-## Features
-
-- **Zero boilerplate** — responses are plain attribute-accessible dicts
-- **Auto-pagination** — `get_all()` fetches all pages. Auto-detects all known strategies; you can easily add your own via a custom paginator — [see docs](https://github.com/serdukow/wbapi-async/blob/dev/docs/advanced/pagination.md)
-- **Rate limiting** — per-endpoint limits powered by `aiolimiter`
-- **Auto-retry** — automatic retry
-- **Always up to date** — path registry is updated every monday
-- **Fully async** — built on `httpx` + `asyncio`
-
-## Install
-
-```bash
-pip install wbapi-async
-```
-
-## Quick start
-
-```python
-import asyncio
-from wbapi import WbAPI
-
-async def main():
-    async with WbAPI(token="YOUR_TOKEN") as api:
-        body = {
-            "settings": {
-                "sort": {"ascending": True},
-                "cursor": {"limit": 100},
-                "filter": {"withPhoto": -1},
-            }
-        }
-
-        cards = await api.get_all("/content/v2/get/cards/list", body=body)
-        print(f"cards: {cards!r}")
-
-asyncio.run(main())
-```

wbapi_async-0.7.7/README.md

@@ -1,50 +0,0 @@
-![Logo](https://dev.wildberries.ru/images/open-graph.png)
-
-<div align="center">
-
-#### Fast, lightweight async client for the 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/wbapi-async.svg)](https://pypi.org/project/wild-api/)
-[![Downloads](https://img.shields.io/pypi/dm/wbapi-async.svg)](https://pypi.python.org/pypi/wild-api)
-[![Docs](https://img.shields.io/badge/docs-serdukow.github.io-blue.svg)](https://serdukow.github.io/wbapi-async/)
-[![Python](https://img.shields.io/pypi/pyversions/wbapi-async.svg)](https://pypi.org/project/wbapi-async/)
-
-</div>
-
-## Features
-
-- **Zero boilerplate** — responses are plain attribute-accessible dicts
-- **Auto-pagination** — `get_all()` fetches all pages. Auto-detects all known strategies; you can easily add your own via a custom paginator — [see docs](https://github.com/serdukow/wbapi-async/blob/dev/docs/advanced/pagination.md)
-- **Rate limiting** — per-endpoint limits powered by `aiolimiter`
-- **Auto-retry** — automatic retry
-- **Always up to date** — path registry is updated every monday
-- **Fully async** — built on `httpx` + `asyncio`
-
-## Install
-
-```bash
-pip install wbapi-async
-```
-
-## Quick start
-
-```python
-import asyncio
-from wbapi import WbAPI
-
-async def main():
-    async with WbAPI(token="YOUR_TOKEN") as api:
-        body = {
-            "settings": {
-                "sort": {"ascending": True},
-                "cursor": {"limit": 100},
-                "filter": {"withPhoto": -1},
-            }
-        }
-
-        cards = await api.get_all("/content/v2/get/cards/list", body=body)
-        print(f"cards: {cards!r}")
-
-asyncio.run(main())
-```

wbapi_async-0.7.7/src/wbapi/_method.py

@@ -1,180 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from aiolimiter import AsyncLimiter
-
-from ._registry import _BASES, _LIMITS, _PAGE_SIZES, _PUBLIC
-
-
-if TYPE_CHECKING:
-    from .client.session.base import BaseSession
-
-_DEFAULT_LIMIT: tuple[int, int, int, int] = (60000, 60, 1000, 5)
-
-_limiters: dict[tuple[int, int], AsyncLimiter] = {}
-
-
-def _get_limiter(path: str) -> AsyncLimiter:
-    period, limit, interval, burst = _LIMITS.get(path, _DEFAULT_LIMIT)
-    key = (interval, burst)
-    if key not in _limiters:
-        _limiters[key] = AsyncLimiter(max_rate=burst, time_period=interval / 1000)
-    return _limiters[key]
-
-
-def resolve_url(path: str) -> str:
-    """Resolve full URL for a spec path like /api/v3/supplies.
-
-    If a full URL is passed, it is returned as-is provided its host is a known
-    wildberries.ru domain or is listed in ``_PUBLIC``.
-    """
-    from urllib.parse import urlparse
-
-    from .exceptions import WBAPIError
-
-    if path.startswith("https://") or path.startswith("http://"):
-        host = urlparse(path).netloc
-        known_hosts = {urlparse(v).netloc for v in _BASES.values()} | _PUBLIC
-        if host not in known_hosts:
-            raise WBAPIError(detail=f"Unknown host {host!r}.")
-        return path
-
-    base = _BASES.get(path)
-    if base:
-        return base + path
-    # Path may contain dynamic segments (e.g. /api/v3/supplies/WB-123/orders).
-    # Walk up the path until we find a match.
-    parts = path.rstrip("/").split("/")
-    for i in range(len(parts) - 1, 0, -1):
-        candidate = "/".join(parts[:i])
-        if candidate in _BASES:
-            return _BASES[candidate] + path
-    raise WBAPIError(
-        detail=f"{path!r} may be deprecated or removed. See https://dev.wildberries.ru/release-notes"
-    )
-
-
-def _extract_list(raw: Any) -> list[Any] | None:
-    if isinstance(raw, list):
-        return raw
-    if isinstance(raw, dict):
-        for v in raw.values():
-            if isinstance(v, list):
-                return v
-        for v in raw.values():
-            if isinstance(v, dict):
-                found = _extract_list(v)
-                if found is not None:
-                    return found
-    return None
-
-
-class MethodDispatcher:
-    def __init__(self, session: BaseSession, token: str) -> None:
-        self._session = session
-        self._token = token
-
-    async def dispatch(
-        self,
-        http_method: str,
-        path: str,
-        *,
-        params: dict[str, Any] | None = None,
-        json: Any | None = None,
-        no_auth: bool = False,
-    ) -> Any:
-        import re
-        from urllib.parse import urlparse
-
-        placeholders = re.findall(r"\{(\w+)\}", path)
-        if placeholders and params:
-            params = dict(params)
-            for key in placeholders:
-                if key in params:
-                    path = path.replace(f"{{{key}}}", str(params.pop(key)))
-            params = params or None
-
-        if not no_auth and path.startswith(("https://", "http://")):
-            no_auth = urlparse(path).netloc in _PUBLIC
-
-        if no_auth:
-            self._session.headers.authorization = None
-        else:
-            self._session.headers.set_token(self._token)
-        url = resolve_url(path)
-        limiter = _get_limiter(path)
-        return await self._session._request(http_method, url, params=params, json=json, limit=limiter)
-
-    async def fetch_all(self, path: str, **kwargs: Any) -> list[Any]:
-        """Fetch all pages. Accepts an optional ``paginator`` kwarg —
-        a callable ``(response) -> (items, next_params | None)`` for custom pagination logic.
-
-        Example::
-
-            def my_paginator(raw):
-                items = raw.get("result", [])
-                cursor = raw.get("cursor") or None
-                next_params = {"cursor": cursor} if cursor else None
-                return items, next_params
-
-
-            all_items = await api.get_all(
-                "/api/v3/custom", paginator=my_paginator
-            )
-        """
-        from .exceptions import PaginationNotSupported
-
-        paginator = kwargs.pop("paginator", None)
-        body = kwargs.pop("body", None)
-        http_method = "POST" if body is not None else "GET"
-
-        def _do_request(
-            extra: dict[str, Any] | None = None,
-            extra_body: dict[str, Any] | None = None,
-            full_body: dict[str, Any] | None = None,
-        ) -> Any:
-            if full_body is not None:
-                return self.dispatch(http_method, path, params=kwargs or None, json=full_body)
-            if body is not None:
-                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)
-
-        if paginator is not None:
-            result: list[Any] = []
-            next_extra: dict[str, Any] = {}
-            while True:
-                if body is not None:
-                    json = next_extra if next_extra else body
-                    raw = await self.dispatch(http_method, path, params=kwargs or None, json=json)
-                else:
-                    raw = await _do_request(next_extra or None)
-                items, next_extra = paginator(raw)
-                result.extend(items)
-                if not next_extra:
-                    break
-            return result
-
-        from .utils.paginate import PAGINATION_STRATEGIES
-
-        page_size = _PAGE_SIZES.get(path, 1000)
-        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:
-            raise PaginationNotSupported(f"No list data found in response for {path!r}")
-
-        result: list[Any] = list(page)
-
-        for strategy in PAGINATION_STRATEGIES:
-            if strategy.detect(raw, page, body, page_size, path):
-                return await strategy.paginate(result, page, raw, _do_request, page_size, body)
-
-        if not result:
-            raise PaginationNotSupported(f"{path!r} returned empty first page — pagination not supported")
-        return result

wbapi_async-0.7.7/src/wbapi/client/session/__init__.py

@@ -1,4 +0,0 @@
-from .base import BaseSession
-
-
-__all__ = ("BaseSession",)

wbapi_async-0.7.7/src/wbapi/client/session/headers.py

@@ -1,23 +0,0 @@
-class Headers:
-    def __init__(self) -> None:
-        self.accept = "application/json;charset=utf-8"
-        self.content_type = "application/json"
-        self.authorization: str | None = None
-        self.user_agent = (
-            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-            "AppleWebKit/537.36 (KHTML, like Gecko) "
-            "Chrome/124.0.0.0 Safari/537.36"
-        )
-
-    def set_token(self, token: str) -> None:
-        self.authorization = f"Bearer {token}"
-
-    def as_dict(self) -> dict[str, str]:
-        headers: dict[str, str] = {
-            "Accept": self.accept,
-            "Content-Type": self.content_type,
-            "User-Agent": self.user_agent,
-        }
-        if self.authorization is not None:
-            headers["Authorization"] = self.authorization
-        return headers

wbapi_async-0.7.7/src/wbapi/utils/paginate.py

@@ -1,155 +0,0 @@
-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, page_size: int, path: str) -> bool:
-        raise NotImplementedError
-
-    async def paginate(
-        self, result: list[Any], page: list[Any], raw: Any, request: _Requester, page_size: int, body: Any
-    ) -> list[Any]:
-        raise NotImplementedError
-
-
-class RrdIdCursorStrategy(PaginationStrategy):
-    def detect(self, raw: Any, page: list[Any], body: Any, page_size: int, path: str) -> 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, page_size: int, body: Any
-    ) -> 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, page_size: int, path: str) -> 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, page_size: int, body: Any
-    ) -> 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, page_size: int, path: str) -> 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, page_size: int, body: Any
-    ) -> 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, page_size: int, path: str) -> bool:
-        return isinstance(raw, dict) and "next" in raw
-
-    async def paginate(
-        self, result: list[Any], page: list[Any], raw: Any, request: _Requester, page_size: int, body: Any
-    ) -> list[Any]:
-        from .._method import _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, page_size: int, path: str) -> bool:
-        return len(page) >= page_size
-
-    async def paginate(
-        self, result: list[Any], page: list[Any], raw: Any, request: _Requester, page_size: int, body: Any
-    ) -> list[Any]:
-        from .._method import _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
-
-
-class CardsListStrategy(PaginationStrategy):
-    path = "/content/v2/get/cards/list"
-
-    def detect(self, raw: Any, page: list[Any], body: Any, page_size: int, path: str) -> bool:
-        if path != self.path:
-            return False
-        cursor = raw.get("cursor", {}) if isinstance(raw, dict) else {}
-        return isinstance(cursor, dict) and "updatedAt" in cursor
-
-    async def paginate(
-        self, result: list[Any], page: list[Any], raw: Any, request: _Requester, page_size: int, body: Any
-    ) -> list[Any]:
-        cursor = raw.get("cursor", {}) if isinstance(raw, dict) else {}
-        while cursor.get("total", 0) >= page_size:
-            next_body = {
-                **body,
-                "settings": {
-                    **body.get("settings", {}),
-                    "cursor": {
-                        "limit": page_size,
-                        "updatedAt": cursor["updatedAt"],
-                        "nmID": cursor["nmID"],
-                    },
-                },
-            }
-            raw = await request(full_body=next_body)
-            page = raw.get("cards", []) if isinstance(raw, dict) else []
-            result.extend(page)
-            cursor = raw.get("cursor", {}) if isinstance(raw, dict) else {}
-        return result
-
-
-PAGINATION_STRATEGIES: list[PaginationStrategy] = [
-    CardsListStrategy(),
-    RrdIdCursorStrategy(),
-    LastChangeDateStrategy(),
-    BodyCursorStrategy(),
-    NextCursorStrategy(),
-    OffsetStrategy(),
-]