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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbapi-async
-Version: 0.7.4
+Version: 0.7.5
 Summary: Asynchronous client for Wildberries API
 Project-URL: Documentation, https://serdukow.github.io/wbapi-async/
 Project-URL: Repository, https://github.com/serdukow/wbapi-async

{wbapi_async-0.7.4 → wbapi_async-0.7.5}/pyproject.toml

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

wbapi_async-0.7.5/src/wbapi_async/_method.py

@@ -0,0 +1,178 @@
+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"Unknown path {path!r}. Check available paths at https://dev.wildberries.ru")
+
+
+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.5/src/wbapi_async/_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",
@@ -242,7 +232,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),
@@ -462,160 +452,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 → wbapi_async-0.7.5}/src/wbapi_async/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 → wbapi_async-0.7.5}/src/wbapi_async/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.5/src/wbapi_async/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/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(),
-]