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

{wbapi_async-0.7.4 → wbapi_async-0.7.7}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: wbapi-async
-Version: 0.7.4
-Summary: Asynchronous client for Wildberries API
+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
@@ -17,6 +17,7 @@ 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
@@ -41,31 +42,27 @@ 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://dev.wildberries.ru/images/open-graph.png" alt="WbAPI" width="600"></a>
-</p>
+![Logo](https://dev.wildberries.ru/images/open-graph.png)
 
 <div align="center">
 
-#### Lightweight async client for Wildberries Seller API
+#### 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/wild-api.svg)](https://pypi.org/project/wild-api/)
-[![Downloads](https://img.shields.io/pypi/dm/wild-api.svg)](https://pypi.python.org/pypi/wild-api)
+[![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>
 
-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 pages. Auto-detects all known strategies; you can easily add your own via a custom paginator — [see docs](https://serdukow.github.io/wbapi-async/advanced/pagination/)
-- **Rate limiting** — per-endpoint limits from the spec, powered by `aiolimiter`
-- **Auto-retry** — automatic retry on HTTP 429
-- **Always up to date** — path registry is [auto-generated](https://github.com/serdukow/wbapi-codegen) from WB OpenAPI specs daily
+- **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
@@ -77,12 +74,21 @@ pip install wbapi-async
 ## Quick start
 
 ```python
-from wbapi_async import WbAPI
+import asyncio
+from wbapi import WbAPI
 
-async with WbAPI(token="...") as api:
+async def main():
+    async with WbAPI(token="YOUR_TOKEN") as api:
+        body = {
+            "settings": {
+                "sort": {"ascending": True},
+                "cursor": {"limit": 100},
+                "filter": {"withPhoto": -1},
+            }
+        }
 
-    supplies = await api.get_all("/api/v3/supplies")
-    print(f"supplies: {supplies!r}")
-```
+        cards = await api.get_all("/content/v2/get/cards/list", body=body)
+        print(f"cards: {cards!r}")
 
-Just copy the path straight from the [WB API](https://dev.wildberries.ru) — the correct base URL and subdomain are resolved automatically.
+asyncio.run(main())
+```

wbapi_async-0.7.7/README.md

@@ -0,0 +1,50 @@
+![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.4 → wbapi_async-0.7.7}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wbapi-async"
-version = "0.7.4"
-description = "Asynchronous client for Wildberries API"
+version = "0.7.7"
+description = "Fast, lightweight async client for the Wildberries Seller API"
+
 authors = [
     { name = "Andrei Serdiukov", email = "asyncdf@gmail.com" },
 ]
@@ -21,6 +22,7 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -65,13 +67,13 @@ Issues = "https://github.com/serdukow/wbapi-async/issues"
 
 [tool.hatch.build.targets.sdist]
 only-include = [
-    "src/wbapi_async",
+    "src/wbapi",
     "README.md",
     "pyproject.toml"
 ]
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/wbapi_async"]
+packages = ["src/wbapi"]
 
 [tool.ruff]
 exclude = [
@@ -94,7 +96,7 @@ select = ["E", "F", "I", "UP", "C4", "B", "RUF100"]
 fixable = ["ALL"]
 
 [tool.ruff.lint.isort]
-known-first-party = ["wbapi_async"]
+known-first-party = ["wbapi"]
 force-sort-within-sections = true
 order-by-type = true
 combine-as-imports = true

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

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

wbapi_async-0.7.7/src/wbapi/_method.py

@@ -0,0 +1,180 @@
+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.4/src/wbapi_async/method.py → wbapi_async-0.7.7/src/wbapi/_registry.py

@@ -1,17 +1,7 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from aiolimiter import AsyncLimiter
-
-
-if TYPE_CHECKING:
-    from .client.session.base import BaseSession
-
 # fmt: off
 # AUTO-GENERATED — DO NOT EDIT MANUALLY!!!
 
-_PATH_TO_BASE: dict[str, str] = {
+_BASES: dict[str, str] = {
     "/adv/v0/auction/nms": "https://advert-api.wildberries.ru",
     "/adv/v0/auction/placements": "https://advert-api.wildberries.ru",
     "/adv/v0/delete": "https://advert-api.wildberries.ru",
@@ -71,6 +61,7 @@ _PATH_TO_BASE: dict[str, str] = {
     "/api/marketplace/v3/supplies/{supplyId}/order-ids": "https://marketplace-api.wildberries.ru",
     "/api/marketplace/v3/supplies/{supplyId}/orders": "https://marketplace-api.wildberries.ru",
     "/api/tariffs/v1/acceptance/coefficients": "https://common-api.wildberries.ru",
+    "/api/finance/v1/sales-reports/detailed": "https://finance-api.wildberries.ru",
     "/api/v1/acceptance/options": "https://supplies-api.wildberries.ru",
     "/api/v1/acceptance_report": "https://seller-analytics-api.wildberries.ru",
     "/api/v1/acceptance_report/tasks/{task_id}/download": "https://seller-analytics-api.wildberries.ru",
@@ -242,7 +233,7 @@ _PATH_TO_BASE: dict[str, str] = {
     "/ping": "https://common-api.wildberries.ru",
 }
 
-_PATH_TO_LIMIT: dict[str, tuple[int, int, int, int]] = {
+_LIMITS: dict[str, tuple[int, int, int, int]] = {
     "/adv/v0/auction/nms": (1000, 1, 1000, 1),
     "/adv/v0/auction/placements": (1000, 1, 1000, 1),
     "/adv/v0/delete": (1000, 5, 200, 5),
@@ -302,6 +293,7 @@ _PATH_TO_LIMIT: dict[str, tuple[int, int, int, int]] = {
     "/api/marketplace/v3/supplies/{supplyId}/order-ids": (60000, 300, 200, 20),
     "/api/marketplace/v3/supplies/{supplyId}/orders": (60000, 300, 200, 20),
     "/api/tariffs/v1/acceptance/coefficients": (60000, 6, 10000, 6),
+    "/api/finance/v1/sales-reports/detailed": (60000, 1, 60000, 1),
     "/api/v1/acceptance/options": (60000, 6, 10000, 6),
     "/api/v1/acceptance_report": (60000, 1, 60000, 1),
     "/api/v1/acceptance_report/tasks/{task_id}/download": (60000, 1, 60000, 1),
@@ -462,160 +454,9 @@ _PATH_TO_LIMIT: dict[str, tuple[int, int, int, int]] = {
 }
 # fmt: on
 
-_DEFAULT_LIMIT: tuple[int, int, int, int] = (60000, 60, 1000, 5)
-
-# Shared AsyncLimiter instances keyed by (interval_ms, burst).
-_limiters: dict[tuple[int, int], AsyncLimiter] = {}
-
-
-def _get_limiter(path: str) -> AsyncLimiter:
-    period_ms, limit, interval_ms, burst = _PATH_TO_LIMIT.get(path, _DEFAULT_LIMIT)
-    key = (interval_ms, burst)
-    if key not in _limiters:
-        _limiters[key] = AsyncLimiter(max_rate=burst, time_period=interval_ms / 1000)
-    return _limiters[key]
-
-
-_EXTRA_ALLOWED_HOSTS: frozenset[str] = frozenset(
-    {
-        "card.wb.ru",
-    }
-)
-
-
-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 ``_EXTRA_ALLOWED_HOSTS``.
-    """
-    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 _PATH_TO_BASE.values()} | _EXTRA_ALLOWED_HOSTS
-        if host not in known_hosts:
-            raise WbAPIError(detail=f"Unknown host {host!r}.")
-        return path
-
-    base = _PATH_TO_BASE.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 _PATH_TO_BASE:
-            return _PATH_TO_BASE[candidate] + path
-    raise WbAPIError(detail=f"Unknown path {path!r}. Check available paths at https://dev.wildberries.ru")
-
-
-_PAGE_SIZE = 1000
-
-
-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
+_PUBLIC: frozenset[str] = frozenset({"card.wb.ru"})
 
-
-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:
-        from urllib.parse import urlparse
-
-        if not no_auth and path.startswith(("https://", "http://")):
-            no_auth = urlparse(path).netloc in _EXTRA_ALLOWED_HOSTS
-
-        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) -> Any:
-            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_params: dict[str, Any] = {}
-            while True:
-                raw = await _do_request(next_params)
-                items, next_params = paginator(raw)
-                result.extend(items)
-                if not next_params:
-                    break
-            return result
-
-        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:
-            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):
-                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
+_PAGE_SIZES: dict[str, int] = {
+    "/content/v2/get/cards/list": 100,
+    "/api/v1/documents/list": 50,
+}

{wbapi_async-0.7.4/src/wbapi_async → wbapi_async-0.7.7/src/wbapi}/api.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from typing import Any
 
+from ._method import MethodDispatcher
 from .client.session.base import BaseSession
-from .method import MethodDispatcher
 from .type import ApiResponse, _wrap
 
 
@@ -11,23 +11,7 @@ class WbAPI:
     """
     Async client for the Wildberries Seller API.
 
-    Full API reference and available paths: https://dev.wildberries.ru/openapi/
-    Swagger specs (YAML): https://dev.wildberries.ru/api/swagger/yaml/en/
-
-    Swagger specs (YAML) — use these to look up paths, parameters, and response schemas:
-    - https://dev.wildberries.ru/api/swagger/yaml/en/01-general.yaml       — warehouses, ping
-    - https://dev.wildberries.ru/api/swagger/yaml/en/02-products.yaml      — cards, stocks, prices, tags
-    - https://dev.wildberries.ru/api/swagger/yaml/en/03-orders-fbs.yaml    — orders, supplies, shipments (FBS)
-    - https://dev.wildberries.ru/api/swagger/yaml/en/04-orders-dbw.yaml    — orders DBW
-    - https://dev.wildberries.ru/api/swagger/yaml/en/05-orders-dbs.yaml    — orders DBS
-    - https://dev.wildberries.ru/api/swagger/yaml/en/06-in-store-pickup.yaml — in-store pickup
-    - https://dev.wildberries.ru/api/swagger/yaml/en/07-orders-fbw.yaml    — orders FBW
-    - https://dev.wildberries.ru/api/swagger/yaml/en/08-promotion.yaml     — ad campaigns, budgets, bids
-    - https://dev.wildberries.ru/api/swagger/yaml/en/09-communications.yaml — questions, reviews, news
-    - https://dev.wildberries.ru/api/swagger/yaml/en/10-tariffs.yaml       — tariffs
-    - https://dev.wildberries.ru/api/swagger/yaml/en/11-analytics.yaml     — sales funnel, turnover, stocks
-    - https://dev.wildberries.ru/api/swagger/yaml/en/12-reports.yaml       — detailed sales report
-    - https://dev.wildberries.ru/api/swagger/yaml/en/13-finances.yaml      — payments, penalties
+    Source: https://dev.wildberries.ru/en/docs/openapi/api-information
     """
 
     def __init__(
@@ -50,8 +34,8 @@ class WbAPI:
             orders = await api.get(
                 "/api/v3/orders/new", limit=10, next=0
             )
-            news = await api.get(
-                "/api/communications/v2/news", fromID=0
+            meta = await api.get(
+                "/api/v3/orders/{orderId}/meta", orderId=123
             )
         """
         return _wrap(await self._dispatcher.dispatch("GET", path, params=kwargs or None))

{wbapi_async-0.7.4/src/wbapi_async → wbapi_async-0.7.7/src/wbapi}/client/session/base.py

@@ -7,7 +7,7 @@ from aiolimiter import AsyncLimiter
 import httpx
 from httpx import RequestError
 
-from ...exceptions import WbAPIError
+from ...exceptions import WBAPIError
 from .headers import Headers
 
 
@@ -74,7 +74,7 @@ class BaseSession:
                 detail = response.json() if response.content else {}
             except Exception:
                 detail = {"detail": response.text.strip() or None}
-            raise WbAPIError(http_status=response.status_code, **detail)
+            raise WBAPIError(http_status=response.status_code, **detail)
 
         if not response.content:
             return None
@@ -82,7 +82,7 @@ class BaseSession:
         try:
             return response.json()
         except Exception as e:
-            raise WbAPIError(
+            raise WBAPIError(
                 http_status=response.status_code,
                 detail=f"Failed to decode JSON response: {response.text[:200]!r}",
             ) from e

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

@@ -1,11 +1,11 @@
 from typing import Any
 
 
-class BaseWbAPIError(Exception):
+class BaseWBAPIError(Exception):
     pass
 
 
-class WbAPIError(BaseWbAPIError):
+class WBAPIError(BaseWBAPIError):
     def __init__(self, http_status: int = 0, **kwargs: Any) -> None:
         self.http_status = http_status
         self.detail: dict[str, Any] = kwargs
@@ -13,9 +13,9 @@ class WbAPIError(BaseWbAPIError):
         super().__init__(msg)
 
 
-class TokenValidationError(BaseWbAPIError):
+class TokenValidationError(BaseWBAPIError):
     pass
 
 
-class PaginationNotSupported(BaseWbAPIError):
+class PaginationNotSupported(BaseWBAPIError):
     pass

{wbapi_async-0.7.4/src/wbapi_async → wbapi_async-0.7.7/src/wbapi}/type.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from typing import Any
 
 
@@ -17,7 +18,8 @@ class ApiResponse:
         try:
             val = self._data[name]
         except (KeyError, TypeError):
-            raise AttributeError(name) from None
+            available = list(self._data) if isinstance(self._data, dict) else type(self._data).__name__
+            raise AttributeError(f"{name!r} not found. Got: {available}") from None
         return _wrap(val)
 
     def __getitem__(self, key: str | int) -> Any:
@@ -39,3 +41,11 @@ class ApiResponse:
 
     def unwrap(self) -> Any:
         return self._data
+
+    def to_snake(self) -> dict[str, Any]:
+        def convert(key: str) -> str:
+            return re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "_", key).lower()
+
+        if isinstance(self._data, dict):
+            return {convert(k): v for k, v in self._data.items()}
+        return self._data

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

@@ -0,0 +1,155 @@
+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(),
+]

wbapi_async-0.7.4/README.md

@@ -1,45 +0,0 @@
-<p align="center">
-  <a href="https://dev.wildberries.ru/"><img src="https://dev.wildberries.ru/images/open-graph.png" alt="WbAPI" width="600"></a>
-</p>
-
-<div align="center">
-
-#### 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/)
-[![Downloads](https://img.shields.io/pypi/dm/wild-api.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/)
-
-</div>
-
-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 pages. Auto-detects all known strategies; you can easily add your own via a custom paginator — [see docs](https://serdukow.github.io/wbapi-async/advanced/pagination/)
-- **Rate limiting** — per-endpoint limits from the spec, powered by `aiolimiter`
-- **Auto-retry** — automatic retry on HTTP 429
-- **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
-```
-
-## Quick start
-
-```python
-from wbapi_async import WbAPI
-
-async with WbAPI(token="...") as api:
-
-    supplies = await api.get_all("/api/v3/supplies")
-    print(f"supplies: {supplies!r}")
-```
-
-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.4/src/wbapi_async/utils/paginate.py

@@ -1,114 +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) -> 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(),
-]