python-wb 0.1.0__py3-none-any.whl

python_wb-0.1.0.dist-info/METADATA

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: python-wb
+Version: 0.1.0
+Summary: Библиотека для работы с API Wildberries на Python.
+Author-email: MistakeTZ <mistaketz@gmail.com>
+Project-URL: Homepage, https://github.com/mistaketz/pywb
+Project-URL: Bug Tracker, https://github.com/mistaketz/pywb/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.13.5
+Requires-Dist: build>=1.4.2
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: setuptools>=82.0.1
+Dynamic: license-file
+
+## pywb
+
+Asynchronous Python client for working with the Wildberries Seller API.
+
+The library provides:
+
+- async HTTP client based on `aiohttp`
+- typed request/response models via `pydantic`
+- centralized API error mapping to Python exceptions
+- support for multiple Wildberries API domains
+
+## Features
+
+- Easy entry point through `WBClient`
+- Domain routing (`common`, `content`, `statistics`, etc.)
+- Built-in methods:
+  - ping (`client.ping()`)
+  - content ping (`client.ping_content()`)
+  - statistics orders report (`client.get_orders(...)`)
+  - etc.
+- Generic low-level method execution:
+  - `await client(SomeWBMethod(...))`
+- Context manager support:
+  - `async with WBClient(...) as client:`
+
+## Requirements
+
+- Python 3.12+
+
+## Installation
+
+Using `uv`:
+
+```bash
+uv add python-wb
+```
+
+With `pip`:
+
+```bash
+pip install python-wb
+```
+
+## Quick Start
+
+```python
+import asyncio
+from pywb import WBClient
+
+
+async def main() -> None:
+    token = "YOUR_WB_API_TOKEN"
+
+    async with WBClient(token) as client:
+        result = await client.ping()
+        print(result.ts, result.status)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Usage
+
+### 1) Health check
+
+```python
+result = await client.ping()
+print(result.status)
+```
+
+### 2) Content API health check
+
+```python
+result = await client.ping_content()
+print(result.status)
+```
+
+### 3) Get orders from Statistics API
+
+```python
+from datetime import datetime
+
+orders = await client.get_orders(
+    date_from=datetime(2026, 1, 1, 0, 0, 0),
+    flag=0,
+)
+
+if orders:
+    print(orders[0].srid, orders[0].brand)
+```
+
+`date_from` accepts either:
+
+- ISO 8601 string (example: `"2022-03-04T18:08:31"`)
+- `datetime` object
+
+## Low-Level Method Call
+
+You can call method objects directly through the client:
+
+```python
+from pywb.methods import Ping
+
+response = await client(Ping())
+```
+
+This is useful when adding new method classes while keeping one transport layer.
+
+## Error Handling
+
+HTTP errors are mapped to dedicated exceptions:
+
+- `BadRequestError` (400)
+- `UnauthorizedError` (401)
+- `PaymentRequiredError` (402)
+- `AccessDeniedError` (403)
+- `NotFoundError` (404)
+- `ConflictError` (409)
+- `PayloadTooLargeError` (413)
+- `UnprocessableEntityError` (422)
+- `TooManyRequestsError` (429)
+- `InternalServerError` (5xx)
+
+Base type: `WBApiError`
+
+Example:
+
+```python
+from pywb.exceptions import BadRequestError
+
+try:
+    await client.get_orders(date_from="2022-03-04T18:08:31")
+except BadRequestError as e:
+    print(e)
+    print(e.payload)
+```
+
+Network/transport failures in the `aiohttp` session are raised as `WBNetworkError`.
+
+## Sandbox and Domains
+
+The client supports domain-based URL routing through `WBDomain` and `WB_ROUTER`.
+
+To enable sandbox mode (only where available for a domain):
+
+```python
+client = WBClient(token="YOUR_TOKEN", is_sandbox=True)
+```
+
+If sandbox is unavailable for a domain, a `ValueError` is raised by the session router.
+
+## Development
+
+Run the example script:
+
+```bash
+python examples/ping.py
+```
+
+## Notes
+
+- Keep your API token secret and do not commit it to git.
+- Respect Wildberries API rate limits for each endpoint.
+- For the statistics orders endpoint, use pagination strategy based on the last record timestamp when handling large datasets.

python_wb-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+test.py,sha256=Swoh8k3MnJNbc9uWPPKNHmnawy6bJU6yelmWdPeOwJw,845
+python_wb-0.1.0.dist-info/licenses/LICENSE,sha256=ZVCm8rowdh_H4PlGUkYZ3KUvwsgdfWcmBTgpsuwT-3I,1072
+pywb/__init__.py,sha256=Zbw-zByB-HJO3LCx8f0dqaUXTSu2LYjFntXlOTgecIk,200
+pywb/__meta__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+pywb/exceptions.py,sha256=SvWSGh6GO4Qszf3pBmj4VppV-syltkzayhr8WDJeZhI,1961
+pywb/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywb/client/wb_client.py,sha256=RfoANIt8Y0nSd_VTNrvujNGu9EJhZQsG11juK5gXLvY,5378
+pywb/client/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywb/client/session/aiohttp.py,sha256=tAMIx3NCkKVmYawUiwLq2JAJpZXSBINS915cCQSjGb4,4595
+pywb/client/session/base.py,sha256=7R8KtmemOtvb8uxaBUMmwfhSAyp_w3FI3zDXwS14vXU,6371
+pywb/enums/__init__.py,sha256=Fc9c2c9HoGz-yVf1r1x6_pZSFbLxBgsaBcNGv2aSMuM,116
+pywb/enums/urls.py,sha256=FKwmJFno_viYE0LGJLpzP-9dJ_1Ymp7aP1m_5F4gOGI,2079
+pywb/methods/__init__.py,sha256=pJcfhaujOVlKVK_YvWEi4HyGI_3AdmlL3RV5TSdVhpk,234
+pywb/methods/base.py,sha256=77ZkL3Yl0PlBbDTGkJD5ggl1nWhDm3IdfZJE4RREIz4,416
+pywb/methods/ping.py,sha256=Uce67ZgZ4ZPc9O9dw5txTP04WJJSHpAjEeBeipRdlyw,586
+pywb/methods/statistics.py,sha256=UTMXKmGrcoCcB0IasHUlKwPKB4zPKU4CmTufHq6TIoI,530
+pywb/methods/update_product_card.py,sha256=fsIHhTzlT12t-hmjWrZVDR9Gj-r4-0_py9A-9vxuzP4,372
+pywb/types/__init__.py,sha256=TEubPAI_bqgqC2Ron_62YHZoxt0TiDDigd_B-fOrG0g,131
+pywb/types/order.py,sha256=hJSBLPVoXouy4seo3fh3-L_hqqo_KTVXqt2qAXxpoPg,1316
+pywb/types/ping_response.py,sha256=SIpcGZBWx0GNbNt23XqPBzH-4AIUxXmbK4PQGyC4wt0,143
+pywb/utils/errors.py,sha256=6fPTI7XvAyI8f53xl329aDemUaHBnmdRNEUSVrt1CgU,1131
+python_wb-0.1.0.dist-info/METADATA,sha256=7Fghwm6MxRNeIKtv4iC_nRpYQ7_5rHJqb-WCI_1EMm4,3967
+python_wb-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_wb-0.1.0.dist-info/top_level.txt,sha256=ga0M4jXex5QccfVXqDbGMV3mmIaKvNg1HLOGclNqytE,10
+python_wb-0.1.0.dist-info/RECORD,,

python_wb-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_wb-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Browser Use Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_wb-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+pywb
+test

pywb/__init__.py

@@ -0,0 +1,12 @@
+from . import enums, methods, types
+from .__meta__ import __version__
+from .client.wb_client import WBClient
+
+
+__all__ = (
+    "WBClient",
+    "enums",
+    "methods",
+    "types",
+    "__version__",
+)

pywb/__meta__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

pywb/client/session/aiohttp.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import asyncio
+import ssl
+from typing import TYPE_CHECKING, Any, cast
+
+import certifi
+from aiohttp import ClientError, ClientSession, TCPConnector
+from typing_extensions import Self
+
+from .base import BaseSession, WBType
+from ...enums import WB_ROUTER, WBDomain
+from ...exceptions import WBApiError
+
+if TYPE_CHECKING:
+    from ...methods.base import WBMethod
+
+
+class WBNetworkError(WBApiError):
+    """Ошибка сети (таймаут, обрыв соединения, DNS и т.д.)"""
+
+    def __init__(self, message: str, original_exception: Exception | None = None):
+        super().__init__(
+            status_code=0, payload={"title": "Network Error", "detail": message}
+        )
+        self.original_exception = original_exception
+
+
+class AiohttpWBSession(BaseSession):
+    """
+    HTTP-сессия на базе aiohttp для работы с Wildberries API.
+    """
+
+    def __init__(self, is_sandbox: bool = False, limit: int = 100, **kwargs):
+        """
+        :param limit: Максимальное количество одновременных соединений (Connection Pooling).
+        :param kwargs: Аргументы для BaseSession (base_url, timeout и т.д.).
+        """
+        super().__init__(**kwargs)
+
+        self.is_sandbox = is_sandbox
+        self._session: ClientSession | None = None
+        self._connector_type: type[TCPConnector] = TCPConnector
+        self._connector_init: dict[str, Any] = {
+            "ssl": ssl.create_default_context(cafile=certifi.where()),
+            "limit": limit,
+            "ttl_dns_cache": 3600,
+        }
+
+    async def create_session(self) -> ClientSession:
+        """Ленивая инициализация aiohttp сессии."""
+        if self._session is None or self._session.closed:
+            self._session = ClientSession(
+                connector=self._connector_type(**self._connector_init),
+                headers={"Content-Type": "application/json"},
+            )
+        return self._session
+
+    async def close(self) -> None:
+        """Аккуратное закрытие сессии и всех TCP соединений."""
+        if self._session is not None and not self._session.closed:
+            await self._session.close()
+
+            await asyncio.sleep(0.25)
+
+    def _get_url(self, domain: WBDomain, path: str) -> str:
+        """Определяет базовый URL на основе домена и флага Sandbox"""
+        domain_urls = WB_ROUTER[domain]
+
+        if self.is_sandbox:
+            if domain_urls["sandbox"] is None:
+                raise ValueError(
+                    f"Sandbox environment is not available for domain: {domain}"
+                )
+            base_url = domain_urls["sandbox"]
+        else:
+            base_url = domain_urls["prod"]
+
+        return f"{base_url.rstrip('/')}/{path.lstrip('/')}"
+
+    async def make_request(
+        self,
+        token: str,
+        method: WBMethod[WBType],
+        timeout: int | None = None,
+    ) -> WBType:
+        """
+        Подготавливает данные, выполняет запрос и передает результат валидатору.
+        """
+        session = await self.create_session()
+
+        url = self._get_url(method.__domain__, method.__api_path__)
+
+        http_method = method.__http_method__.upper()
+
+        raw_payload = method.model_dump(exclude_none=True)
+
+        prepared_payload = self.prepare_value(raw_payload)
+
+        request_kwargs: dict[str, Any] = {}
+        if http_method in ("GET", "DELETE"):
+            request_kwargs["params"] = prepared_payload
+        else:
+            request_kwargs["json"] = prepared_payload
+
+        try:
+            async with session.request(
+                method=http_method,
+                url=url,
+                headers={"Authorization": token},
+                timeout=self.timeout if timeout is None else timeout,
+                **request_kwargs,
+            ) as resp:
+                raw_result = await resp.text()
+
+        except asyncio.TimeoutError as e:
+            raise WBNetworkError("Request timeout error", e) from e
+        except ClientError as e:
+            raise WBNetworkError(f"Network error: {type(e).__name__} - {e}", e) from e
+
+        response_data = self.check_response(
+            method=method,
+            status_code=resp.status,
+            content=raw_result,
+        )
+
+        return cast(WBType, response_data)
+
+    async def __aenter__(self) -> Self:
+        await self.create_session()
+        return self

pywb/client/session/base.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import abc
+import datetime
+import json
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, cast
+
+from pydantic import BaseModel, TypeAdapter, ValidationError
+from typing_extensions import Self
+
+from ...exceptions import (
+    AccessDeniedError,
+    BadRequestError,
+    ConflictError,
+    InternalServerError,
+    NotFoundError,
+    PaymentRequiredError,
+    PayloadTooLargeError,
+    TooManyRequestsError,
+    UnauthorizedError,
+    UnprocessableEntityError,
+    WBApiError,
+)
+
+if TYPE_CHECKING:
+    from types import TracebackType
+    from ...methods import WBMethod
+
+WBType = TypeVar("WBType")
+
+_JsonLoads = Callable[..., Any]
+_JsonDumps = Callable[..., str]
+
+DEFAULT_TIMEOUT: float = 60.0
+WB_PRODUCTION_API: str = "https://common-api.wildberries.ru"
+
+
+class ClientDecodeError(Exception):
+    """Ошибка при парсинге или валидации ответа от серверов WB"""
+
+    def __init__(self, message: str, original: Exception, data: Any):
+        super().__init__(message)
+        self.original = original
+        self.data = data
+
+
+class BaseSession(abc.ABC):
+    """
+    Базовый класс для всех HTTP сессий клиента Wildberries.
+    Наследуйтесь от него, чтобы реализовать конкретную сессию (например, HttpxSession).
+    """
+
+    def __init__(
+        self,
+        base_url: str = WB_PRODUCTION_API,
+        json_loads: _JsonLoads = json.loads,
+        json_dumps: _JsonDumps = json.dumps,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self.base_url = base_url
+        self.json_loads = json_loads
+        self.json_dumps = json_dumps
+        self.timeout = timeout
+
+    def check_response(
+        self,
+        method: WBMethod[WBType],
+        status_code: int,
+        content: str,
+    ) -> WBType:
+        """
+        Проверяет статус ответа и десериализует его в нужный тип Pydantic.
+        """
+        if status_code == 204:
+            return cast(WBType, None)
+
+        try:
+            json_data = self.json_loads(content) if content else {}
+        except Exception as e:
+            raise ClientDecodeError("Failed to decode JSON response", e, content) from e
+
+        if status_code >= 400:
+            self._raise_for_status(status_code, json_data)
+
+        return_type = method.__returning__
+        
+        if return_type in (bool, dict, list, Any):
+            return cast(WBType, json_data)
+
+        try:
+            adapter = TypeAdapter(return_type)
+            validated_data = adapter.validate_python(json_data)
+            return cast(WBType, validated_data)
+        except ValidationError as e:
+            raise ClientDecodeError("Failed to deserialize response into Pydantic model", e, json_data) from e
+        
+    def _raise_for_status(self, status_code: int, payload: dict[str, Any]) -> None:
+        """Внутренний маппинг ошибок HTTP на исключения Python"""
+        if status_code == 400:
+            raise BadRequestError(status_code, payload)
+        if status_code == 401:
+            raise UnauthorizedError(status_code, payload)
+        if status_code == 402:
+            raise PaymentRequiredError(status_code, payload)
+        if status_code == 403:
+            raise AccessDeniedError(status_code, payload)
+        if status_code == 404:
+            raise NotFoundError(status_code, payload)
+        if status_code == 409:
+            raise ConflictError(status_code, payload)
+        if status_code == 413:
+            raise PayloadTooLargeError(status_code, payload)
+        if status_code == 422:
+            raise UnprocessableEntityError(status_code, payload)
+        if status_code == 429:
+            raise TooManyRequestsError(status_code, payload)
+        if status_code >= 500:
+            raise InternalServerError(status_code, payload)
+
+        raise WBApiError(status_code, payload)
+
+    def prepare_value(self, value: Any) -> Any:
+        """
+        Подготавливает значения перед отправкой в WB API.
+        В отличие от Telegram, WB требует строгий JSON, поэтому
+        в основном мы форматируем даты и Enums.
+        """
+        if value is None:
+            return None
+        if isinstance(value, str):
+            return value
+        if isinstance(value, datetime.datetime):
+            # WB обычно ожидает ISO 8601 (например "2024-09-30T06:52:38Z")
+            return value.isoformat() + "Z"
+        if isinstance(value, Enum):
+            return value.value
+        if isinstance(value, BaseModel):
+            return self.prepare_value(value.model_dump(exclude_none=True))
+        if isinstance(value, dict):
+            return {k: self.prepare_value(v) for k, v in value.items() if v is not None}
+        if isinstance(value, list):
+            return [self.prepare_value(v) for v in value if v is not None]
+
+        return value
+
+    @abc.abstractmethod
+    async def close(self) -> None:
+        """Закрытие HTTP сессии (aiohttp/httpx)"""
+
+    @abc.abstractmethod
+    async def make_request(
+        self,
+        token: str,
+        method: WBMethod[WBType],
+        timeout: int | None = None,
+    ) -> WBType:
+        """
+        Фактическое выполнение HTTP запроса.
+        Должно быть реализовано в наследнике (HttpxSession или AiohttpSession).
+        """
+
+    async def __call__(
+        self,
+        token: str,
+        method: WBMethod[WBType],
+        timeout: int | None = None,
+    ) -> WBType:
+        """
+        Точка входа для выполнения запроса.
+        """
+        # TODO: Здесь можно добавить мидлвари (логирование, ретраи, метрики) перед вызовом make_request
+
+        return await self.make_request(token, method, timeout=timeout)
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.close()

pywb/client/wb_client.py

@@ -0,0 +1,122 @@
+# client.py
+from __future__ import annotations
+from datetime import datetime
+from typing import TYPE_CHECKING, Optional
+
+from pywb.methods.ping import PingContent
+from pywb.methods.statistics import GetOrders
+from pywb.types.order import StatisticOrder
+
+from .session.base import BaseSession
+from .session.aiohttp import AiohttpWBSession
+
+from ..methods import Ping, WT
+from ..types import PingResponse
+
+if TYPE_CHECKING:
+    from ..methods.base import WBMethod
+
+
+class WBClient:
+    """
+    Асинхронный клиент для работы с API Wildberries.
+    """
+
+    def __init__(
+        self,
+        token: str,
+        is_sandbox: bool = False,
+        session: BaseSession | None = None,
+    ) -> None:
+        self.token = token
+
+        if session is None:
+            session = AiohttpWBSession(is_sandbox=is_sandbox)
+
+        self.session = session
+
+    async def __call__(
+        self, method: WBMethod[WT], request_timeout: int | None = None
+    ) -> WT:
+        """
+        Единая точка входа.
+        Вызывает метод API и возвращает результат нужного типа.
+        """
+        return await self.session(
+            token=self.token, method=method, timeout=request_timeout
+        )
+
+    async def aclose(self) -> None:
+        """Делегируем закрытие соединений сессии"""
+        await self.session.close()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.aclose()
+
+    async def ping(self, request_timeout: int | None = None) -> PingResponse:
+        """
+        Проверяет доступность серверов Wildberries и валидность токена.
+        """
+        call = Ping()
+
+        return await self(call, request_timeout=request_timeout)
+    
+    async def ping_content(self, request_timeout: int | None = None) -> PingResponse:
+        """
+        Специальный метод для проверки доступности Content API (для карточек, цен и т.д.).
+        Полезно, если у вас есть методы, которые работают только с этим доменом.
+        """
+        call = PingContent()
+
+        return await self(call, request_timeout=request_timeout)
+
+    async def get_orders(
+        self,
+        date_from: datetime | str,
+        flag: int = 0,
+        request_timeout: Optional[int] = None
+    ) -> list[StatisticOrder]:
+        """
+        Возвращает информацию о заказах.
+        Данные в этом отчете предварительные и используются для оперативного контроля.
+
+        ⚠️ ЛИМИТЫ И ПРАВИЛА ИСПОЛЬЗОВАНИЯ API:
+        ---------------------------------------
+        - Обновление данных: Каждые 30 минут.
+        - Хранение данных: Гарантируется не более 90 дней со дня продажи.
+        - Rate Limit: 1 запрос в 1 минуту на один аккаунт продавца (Burst: 1 запрос).
+        
+        ОСОБЕННОСТИ ПАГИНАЦИИ (Лимит строк):
+        ---------------------------------------
+        При запросе с flag=0 или без него установлен условный лимит в 80 000 строк.
+        Для получения всех заказов:
+        1. В первом запросе передайте начальную дату в `date_from`.
+        2. Если вернулось 80 000 строк, возьмите значение `last_change_date`
+           из ПОСЛЕДНЕЙ строки ответа и передайте его как `date_from` в следующий запрос.
+        3. Если ответ вернул пустой массив `[]` — все заказы получены.
+
+        ПРИМЕЧАНИЯ:
+        ---------------------------------------
+        - 1 строка = 1 заказ = 1 единица товара.
+        - `srid` — уникальный идентификатор заказа.
+        - В отчет НЕ попадают заказы без подтвержденной оплаты (например, рассрочка).
+          Такие продажи можно найти в детализации отчета о реализации.
+
+        :param date_from: Дата в формате ISO 8601 (например, "2022-03-04T18:08:31") 
+                          или объект datetime.
+        :param flag: 0 (по умолчанию) - получить данные, у которых lastChangeDate >= dateFrom.
+                     1 - получить данные, у которых date >= dateFrom.
+        :param request_timeout: Таймаут запроса в секундах.
+        :return: Список объектов StatisticOrder.
+        """
+
+        if isinstance(date_from, datetime):
+            date_from_str = date_from.replace(microsecond=0).isoformat()
+        else:
+            date_from_str = date_from
+
+        call = GetOrders(dateFrom=date_from_str, flag=flag)
+        return await self(call, request_timeout=request_timeout)

pywb/enums/__init__.py

@@ -0,0 +1,7 @@
+from .urls import WBDomain, DomainUrls, WB_ROUTER
+
+__all__ = [
+    "WBDomain",
+    "DomainUrls",
+    "WB_ROUTER",
+]

pywb/enums/urls.py

@@ -0,0 +1,39 @@
+from enum import Enum
+from typing import Dict, TypedDict
+
+class WBDomain(str, Enum):
+    CONTENT = "content"
+    ANALYTICS = "analytics"
+    PRICES = "prices"
+    MARKETPLACE = "marketplace"
+    STATISTICS = "statistics"
+    PROMOTION = "promotion"
+    FEEDBACKS = "feedbacks"
+    BUYER_CHAT = "buyer_chat"
+    SUPPLIES = "supplies"
+    RETURNS = "returns"
+    DOCUMENTS = "documents"
+    FINANCE = "finance"
+    COMMON = "common"
+    USER_MANAGEMENT = "user_management"
+
+class DomainUrls(TypedDict):
+    prod: str
+    sandbox: str | None
+
+WB_ROUTER: Dict[WBDomain, DomainUrls] = {
+    WBDomain.CONTENT: {"prod": "https://content-api.wildberries.ru", "sandbox": "https://content-api-sandbox.wildberries.ru"},
+    WBDomain.ANALYTICS: {"prod": "https://seller-analytics-api.wildberries.ru", "sandbox": None},
+    WBDomain.PRICES: {"prod": "https://discounts-prices-api.wildberries.ru", "sandbox": "https://discounts-prices-api-sandbox.wildberries.ru"},
+    WBDomain.MARKETPLACE: {"prod": "https://marketplace-api.wildberries.ru", "sandbox": None},
+    WBDomain.STATISTICS: {"prod": "https://statistics-api.wildberries.ru", "sandbox": "https://statistics-api-sandbox.wildberries.ru"},
+    WBDomain.PROMOTION: {"prod": "https://advert-api.wildberries.ru", "sandbox": "https://advert-api-sandbox.wildberries.ru"},
+    WBDomain.FEEDBACKS: {"prod": "https://feedbacks-api.wildberries.ru", "sandbox": "https://feedbacks-api-sandbox.wildberries.ru"},
+    WBDomain.BUYER_CHAT: {"prod": "https://buyer-chat-api.wildberries.ru", "sandbox": None},
+    WBDomain.SUPPLIES: {"prod": "https://supplies-api.wildberries.ru", "sandbox": None},
+    WBDomain.RETURNS: {"prod": "https://returns-api.wildberries.ru", "sandbox": None},
+    WBDomain.DOCUMENTS: {"prod": "https://documents-api.wildberries.ru", "sandbox": None},
+    WBDomain.FINANCE: {"prod": "https://finance-api.wildberries.ru", "sandbox": None},
+    WBDomain.COMMON: {"prod": "https://common-api.wildberries.ru", "sandbox": None},
+    WBDomain.USER_MANAGEMENT: {"prod": "https://user-management-api.wildberries.ru", "sandbox": None},
+}

pywb/exceptions.py

@@ -0,0 +1,83 @@
+from typing import Optional, Dict, Any
+
+
+class WBApiError(Exception):
+    """
+    Base exception for all Wildberries API errors.
+    Automatically parses the WB error JSON schema to provide clear error messages.
+    """
+
+    def __init__(self, status_code: int, payload: Optional[Dict[str, Any]] = None):
+        self.status_code = status_code
+        self.payload = payload or {}
+
+        self.title = self.payload.get("title", "Unknown API Error")
+        self.detail = self.payload.get("detail", "")
+        self.timestamp = self.payload.get("timestamp", "")
+        self.status_text = self.payload.get("statusText", "")
+
+        message = f"[{self.status_code}] {self.title}"
+        if self.detail:
+            message += f" | Detail: {self.detail}"
+
+        super().__init__(message)
+
+
+class BadRequestError(WBApiError):
+    """400: Bad request. Check the request syntax."""
+
+    pass
+
+
+class UnauthorizedError(WBApiError):
+    """401: Unauthorized. Token is missing, expired, or incorrect."""
+
+    pass
+
+
+class PaymentRequiredError(WBApiError):
+    """402: Payment required. Insufficient funds on the Catalog balance."""
+
+    pass
+
+
+class AccessDeniedError(WBApiError):
+    """403: Access denied. Deleted user, blocked access, or missing Jam subscription."""
+
+    pass
+
+
+class NotFoundError(WBApiError):
+    """404: Not found. Check the request URL."""
+
+    pass
+
+
+class ConflictError(WBApiError):
+    """409: Status update error / Error adding label. Data contradicts limits."""
+
+    pass
+
+
+class PayloadTooLargeError(WBApiError):
+    """413: The request body size exceeds the given limit."""
+
+    pass
+
+
+class UnprocessableEntityError(WBApiError):
+    """422: Error processing request parameters or unexpected result."""
+
+    pass
+
+
+class TooManyRequestsError(WBApiError):
+    """429: Too many requests. Rate limit exceeded."""
+
+    pass
+
+
+class InternalServerError(WBApiError):
+    """5XX: Internal service error. Service is unavailable."""
+
+    pass

pywb/methods/__init__.py

@@ -0,0 +1,12 @@
+from .base import WBMethod, WT
+from .ping import Ping
+from .statistics import GetOrders
+from .update_product_card import UpdateProductCard
+
+__all__ = [
+    "Ping",
+    "UpdateProductCard",
+    "WBMethod",
+    "WT",
+    "GetOrders",
+]

pywb/methods/base.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import TypeVar, Generic, ClassVar
+from ..enums import WBDomain
+
+WT = TypeVar("WT")
+
+
+class WBMethod(BaseModel, Generic[WT]):
+    """Базовый класс для всех методов API"""
+
+    __http_method__: ClassVar[str]
+    __api_path__: ClassVar[str]
+    __domain__: ClassVar[WBDomain]
+    __returning__: ClassVar[type]
+
+    model_config = {"extra": "forbid"}

pywb/methods/ping.py

@@ -0,0 +1,24 @@
+from .base import WBMethod
+from ..enums import WBDomain
+from ..types import PingResponse
+
+
+class Ping(WBMethod[PingResponse]):
+    __http_method__ = "GET"
+    __api_path__ = "/ping"
+    __domain__ = WBDomain.COMMON
+    __returning__ = PingResponse
+
+
+class PingContent(WBMethod[PingResponse]):
+    __http_method__ = "GET"
+    __api_path__ = "/ping"
+    __domain__ = WBDomain.CONTENT
+    __returning__ = PingResponse
+
+
+class PingAnalytics(WBMethod[PingResponse]):
+    __http_method__ = "GET"
+    __api_path__ = "/ping"
+    __domain__ = WBDomain.ANALYTICS
+    __returning__ = PingResponse

pywb/methods/statistics.py

@@ -0,0 +1,19 @@
+from typing import ClassVar
+
+from pywb.types.order import StatisticOrder
+from .base import WBMethod
+from ..enums import WBDomain
+
+
+class GetOrders(WBMethod[list[StatisticOrder]]):
+    """
+    Команда для получения отчета по заказам.
+    """
+
+    __http_method__: ClassVar[str] = "GET"
+    __api_path__: ClassVar[str] = "/api/v1/supplier/orders"
+    __domain__: ClassVar[WBDomain] = WBDomain.STATISTICS
+    __returning__: ClassVar[type] = list[StatisticOrder]
+
+    dateFrom: str
+    flag: int = 0

pywb/methods/update_product_card.py

@@ -0,0 +1,16 @@
+from typing import Optional
+from .base import WBMethod
+
+
+class UpdateProductCard(WBMethod[bool]):
+    """
+    Класс-команда для обновления карточки товара.
+    """
+
+    __http_method__ = "POST"
+    __api_path__ = "/content/v1/cards/update"
+    __returning__ = bool
+
+    card_id: str
+    price: int
+    discount: Optional[int] = None

pywb/types/__init__.py

@@ -0,0 +1,7 @@
+from .ping_response import PingResponse
+from .order import StatisticOrder
+
+__all__ = [
+    "PingResponse",
+    "StatisticOrder",
+]

pywb/types/order.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class StatisticOrder(BaseModel):
+    """Модель информации о заказе из API Статистики."""
+
+    date: datetime
+    last_change_date: datetime = Field(alias="lastChangeDate")
+    warehouse_name: str = Field(alias="warehouseName")
+    warehouse_type: str = Field(alias="warehouseType")
+    country_name: str = Field(alias="countryName")
+    oblast_okrug_name: str = Field(alias="oblastOkrugName")
+    region_name: str = Field(alias="regionName")
+    supplier_article: str = Field(alias="supplierArticle")
+    nm_id: int = Field(alias="nmId")
+    barcode: str
+    category: str
+    subject: str
+    brand: str
+    tech_size: str = Field(alias="techSize")
+    income_id: int = Field(alias="incomeID")
+    is_supply: bool = Field(alias="isSupply")
+    is_realization: bool = Field(alias="isRealization")
+    total_price: float = Field(alias="totalPrice")
+    discount_percent: int = Field(alias="discountPercent")
+    spp: float
+    finished_price: float = Field(alias="finishedPrice")
+    price_with_disc: float = Field(alias="priceWithDisc")
+    is_cancel: bool = Field(alias="isCancel")
+    cancel_date: datetime = Field(alias="cancelDate")
+    sticker: str
+    g_number: str = Field(alias="gNumber")
+    srid: str

pywb/types/ping_response.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+
+
+class PingResponse(BaseModel):
+    ts: str = Field(alias="TS")
+    status: str = Field(alias="Status")

pywb/utils/errors.py

@@ -0,0 +1,46 @@
+from typing import Any, Dict, Optional
+
+from ..exceptions import (
+    BadRequestError,
+    ConflictError,
+    InternalServerError,
+    NotFoundError,
+    PayloadTooLargeError,
+    PaymentRequiredError,
+    TooManyRequestsError,
+    UnauthorizedError,
+    UnprocessableEntityError,
+    AccessDeniedError,
+    WBApiError,
+)
+
+
+_EXCEPTION_MAPPING = {
+    400: BadRequestError,
+    401: UnauthorizedError,
+    402: PaymentRequiredError,
+    403: AccessDeniedError,
+    404: NotFoundError,
+    409: ConflictError,
+    413: PayloadTooLargeError,
+    422: UnprocessableEntityError,
+    429: TooManyRequestsError,
+}
+
+
+def raise_for_status(
+    status_code: int,
+    response_json: Optional[Dict[str, Any]] = None,
+):
+    """
+    Helper function to raise the appropriate exception based on the status code.
+    If the status code is 200 or 204, it does nothing.
+    """
+    if status_code in (200, 204):
+        return
+
+    if 500 <= status_code < 600:
+        raise InternalServerError(status_code, response_json)
+
+    exception_class = _EXCEPTION_MAPPING.get(status_code, WBApiError)
+    raise exception_class(status_code, response_json)

test.py

@@ -0,0 +1,18 @@
+import asyncio
+from pywb import WBClient
+from pywb.exceptions import BadRequestError
+
+
+async def main():
+    token = "eyJhbGciOiJFUzI1NiIsImtpZCI6IjIwMjYwMzAydjEiLCJ0eXAiOiJKV1QifQ.eyJhY2MiOjEsImVudCI6MSwiZXhwIjoxNzkwMzk3MTQxLCJpZCI6IjAxOWQzMDIzLWJkMGMtNzYyNy1hZmQ4LTVmOGIwMWVmOGEwYyIsImlpZCI6MTI4NDg1NDE5LCJvaWQiOjI1MDEyNDEwOCwicyI6MTYxMjYsInNpZCI6ImJjMDRiNDUyLTlkMWMtNDM3MC1hZDUwLTc1NDQzYmJiZWQzMCIsInQiOmZhbHNlLCJ1aWQiOjEyODQ4NTQxOX0.r2N1FXLRM8PZM43PzkKa4HgrdFSYf5Nz3s2JXUPrcUOZ0RicfvWqa4JowK6FVDps8pHoqsnHDukuRLvNKqvCbQ"
+
+    async with WBClient(token, is_sandbox=False) as client:
+        try:
+            result = await client.get_orders(date_from="2022-03-04T18:08:31")
+            print(result[0].brand)
+        except BadRequestError as e:
+            print(f"Error: {e}", e.payload)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())