ozonapi-async 0.7.3__tar.gz → 0.7.4__tar.gz

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ozonapi-async
-Version: 0.7.3
+Version: 0.7.4
 Summary: Асинхронный клиент для работы с API маркетплейса Ozon
 Author: Alexander Ulianov
 License: MIT
@@ -113,6 +113,7 @@ async def main():
     config = SellerAPIConfig(
         client_id="your_client_id",
         api_key="your_api_key",
+        log_level="DEBUG"
     )
     
     async with SellerAPI(config=config) as api:

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ozonapi-async"
-version = "0.7.3"
+version = "0.7.4"
 description = "Асинхронный клиент для работы с API маркетплейса Ozon"
 readme = "readme.md"
 keywords = ["ozon", "api", "async", "ecommerce", "seller", "client"]

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/readme.md

@@ -71,6 +71,7 @@ async def main():
     config = SellerAPIConfig(
         client_id="your_client_id",
         api_key="your_api_key",
+        log_level="DEBUG"
     )
     
     async with SellerAPI(config=config) as api:

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/src/ozonapi/__init__.py

@@ -2,7 +2,7 @@
 Асинхронный интерфейс для взаимодействия с API маркетплейса Ozon.
 """
 
-__version__ = "0.7.3"
+__version__ = "0.7.4"
 __author__ = "Alexander Ulianov"
 __repository__ = "https://github.com/a-ulianov/OzonAPI"
 __docs__ = "https://github.com/a-ulianov/OzonAPI#readme"

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/src/ozonapi/seller/core/config.py

@@ -36,7 +36,7 @@ class APIConfig(BaseSettings):
         description="Авторизационный ключ Ozon Seller API",
     )
     log_level: Optional[str] = Field(
-        default="DEBUG",
+        default="ERROR",
         description="Уровень логирования."
     )
     base_url: str = Field(

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/src/ozonapi/seller/core/core.py

@@ -1,4 +1,5 @@
 import asyncio
+import logging
 import sys
 from types import TracebackType
 from typing import Any, Literal, Optional, ClassVar
@@ -27,13 +28,6 @@ from .exceptions import (
     APIServerError, APITooManyRequestsError,
 )
 
-logger.remove()
-logger.add(
-    sys.stderr,
-    level=APIConfig().log_level,
-    enqueue=True,
-)
-
 
 class APIManager:
     """
@@ -50,6 +44,15 @@ class APIManager:
     _initialized: ClassVar[bool] = False
     _instance_count: ClassVar[int] = 0
 
+    _class_logger: ClassVar = logger
+    _class_logger.remove()
+    _class_logger.add(
+        sys.stderr,
+        level=APIConfig().log_level,
+        enqueue=True,
+    )
+
+
     def __init__(
             self,
             client_id: Optional[str] = None,
@@ -70,6 +73,7 @@ class APIManager:
         self._instance_id = id(self)
         self._registered = False
         self._closed = False
+        self._instance_logger = self._get_instance_logger()
 
         if self._client_id is None or self._api_key is None:
             raise ValueError(
@@ -78,21 +82,24 @@ class APIManager:
 
         if APIManager._rate_limiter_manager is None:
             APIManager._rate_limiter_manager = RateLimiterManager(
-                cleanup_interval=self._config.cleanup_interval
+                cleanup_interval=self._config.cleanup_interval,
+                instance_logger=self.logger
             )
         if APIManager._session_manager is None:
             APIManager._session_manager = SessionManager(
                 timeout=self._config.request_timeout,
-                connector_limit=self._config.connector_limit
+                connector_limit=self._config.connector_limit,
+                instance_logger=self.logger
             )
         if APIManager._method_rate_limiter_manager is None:
             APIManager._method_rate_limiter_manager = MethodRateLimiterManager(
-                cleanup_interval=self._config.cleanup_interval
+                cleanup_interval=self._config.cleanup_interval,
+                instance_logger=self.logger
             )
 
         APIManager._instance_count += 1
         self._validate_credentials()
-        logger.debug(f"API-клиент инициализирован для ClientID {self._client_id}")
+        self.logger.debug(f"API-клиент инициализирован для ClientID {self._client_id}")
 
     @classmethod
     def load_config(cls, user_config: APIConfig | None = None) -> APIConfig:
@@ -110,6 +117,19 @@ class APIManager:
                 )
             )
 
+    def _get_instance_logger(self) -> logging.Logger:
+        """Инициализирует и возвращает настроенный логер для экземпляра."""
+        instance_logger = logger.bind(client_id=self._client_id)
+
+        instance_logger.remove()
+        instance_logger.add(
+            sys.stderr,
+            level=self._config.log_level,
+            enqueue=True,
+        )
+
+        return instance_logger
+
     @classmethod
     async def initialize(cls) -> None:
         """Инициализация ресурсов."""
@@ -119,7 +139,7 @@ class APIManager:
             if cls._method_rate_limiter_manager:
                 await cls._method_rate_limiter_manager.start()
             cls._initialized = True
-            logger.debug("Выполнена инициализация ресурсов API-менеджера")
+            cls._class_logger.debug("Выполнена инициализация ресурсов API-менеджера")
 
     @classmethod
     async def shutdown(cls) -> None:
@@ -132,7 +152,7 @@ class APIManager:
             if cls._session_manager:
                 await cls._session_manager.close_all()
             cls._initialized = False
-            logger.debug("Выполнена деинициализация ресурсов API-менеджера")
+            cls._class_logger.debug("Выполнена деинициализация ресурсов API-менеджера")
 
     def _validate_credentials(self) -> None:
         """Валидация учетных данных."""
@@ -142,7 +162,7 @@ class APIManager:
             raise ValueError("api_key не должен быть пустой строкой")
 
         if self._config.max_requests_per_second > 50:
-            logger.warning(
+            self.logger.warning(
                 f"Максимальное кол-во запросов в секунду согласно документации Ozon - 50. "
                 f"Установлено: {self._config.max_requests_per_second}"
             )
@@ -194,7 +214,7 @@ class APIManager:
             if APIManager._session_manager:
                 await APIManager._session_manager.close_all()
 
-        logger.debug(f"Работа API-клиента для ClientID {self._client_id} завершена")
+        self.logger.debug(f"Работа API-клиента для ClientID {self._client_id} завершена")
 
     @property
     def client_id(self) -> str:
@@ -211,6 +231,11 @@ class APIManager:
         """Проверяет закрыт ли клиент."""
         return self._closed
 
+    @property
+    def logger(self):
+        """Возвращает логер экземпляра."""
+        return self._instance_logger
+
     @classmethod
     def get_instance_count(cls) -> int:
         """Получает количество активных экземпляров."""
@@ -220,7 +245,7 @@ class APIManager:
         """Создает декоратор повторов на основе конфигурации."""
 
         def log_retry(retry_state):
-            logger.debug(
+            self.logger.debug(
                 f"Попытка {retry_state.attempt_number} совершения запроса для ClientID {self._client_id}"
                 f" завершилась исключением: {retry_state.outcome.exception()}"
             )
@@ -240,7 +265,7 @@ class APIManager:
                 min=self._config.retry_min_wait,
                 max=self._config.retry_max_wait
             ),
-            before_sleep=before_sleep_log(logger, 30),
+            before_sleep=before_sleep_log(self.logger, 30),
             after=log_retry,
             reraise=True,
         )
@@ -268,7 +293,7 @@ class APIManager:
             "error_details": details,
         })
 
-        logger.error(f"Ошибка API: {message}", extra=log_context)
+        APIManager._class_logger.error(f"Ошибка API: {message}", extra=log_context)
 
         error_map = {
             400: APIClientError,
@@ -332,7 +357,7 @@ class APIManager:
             "has_payload": json is not None,
         }
 
-        logger.debug("Отправка запроса к API", extra=log_context)
+        self.logger.debug("Отправка запроса к API", extra=log_context)
 
         await self._ensure_registered()
 
@@ -367,21 +392,21 @@ class APIManager:
                                 if error:
                                     raise error
 
-                            logger.debug("Успешный ответ от API", extra=log_context)
+                            self.logger.debug("Успешный ответ от API", extra=log_context)
                             return data
 
                     except asyncio.TimeoutError:
-                        logger.error("Таймаут запроса к API", extra=log_context)
+                        self.logger.error("Таймаут запроса к API", extra=log_context)
                         raise APIError(408, "Request timeout")
                     except asyncio.CancelledError:
-                        logger.warning("Запрос к API отменен", extra=log_context)
+                        self.logger.warning("Запрос к API отменен", extra=log_context)
                         raise
                     except (aiohttp.ClientError, ConnectionError, OSError) as e:
                         log_context.update({
                             "error_type": type(e).__name__,
                             "error_message": str(e)
                         })
-                        logger.error(
+                        self.logger.error(
                             f"Сетевая ошибка при выполнении запроса к API: {str(e)}",
                             extra=log_context
                         )

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/src/ozonapi/seller/core/method_rate_limiter.py

@@ -22,7 +22,12 @@ class MethodRateLimiterManager:
     Обеспечивает раздельные лимиты для каждого метода и client_id.
     """
 
-    def __init__(self, cleanup_interval: float = 300.0, min_instance_ttl: float = 300.0) -> None:
+    def __init__(
+            self,
+            cleanup_interval: float = 300.0,
+            min_instance_ttl: float = 300.0,
+            instance_logger = logger
+    ) -> None:
         self._rate_limiters: dict[str, AsyncLimiter] = {}
         self._limiter_configs: dict[str, MethodRateLimitConfig] = {}
         self._last_used: dict[str, float] = {}
@@ -32,12 +37,13 @@ class MethodRateLimiterManager:
         self._shutdown = False
         self._cleanup_interval = cleanup_interval
         self._min_instance_ttl = min_instance_ttl
+        self._logger = instance_logger
 
     async def start(self) -> None:
         """Запуск фоновых задач менеджера."""
         if self._cleanup_task is None:
             self._cleanup_task = asyncio.create_task(self._cleanup_loop())
-            logger.debug("Менеджер ограничителей методов запущен")
+            self._logger.debug("Менеджер ограничителей методов запущен")
 
     async def shutdown(self) -> None:
         """Корректное завершение работы менеджера."""
@@ -47,9 +53,9 @@ class MethodRateLimiterManager:
             try:
                 await self._cleanup_task
             except asyncio.CancelledError:
-                logger.debug("Задача очистки ограничителей методов отменена")
+                self._logger.debug("Задача очистки ограничителей методов отменена")
             self._cleanup_task = None
-        logger.debug("Менеджер ограничителей методов остановлен")
+        self._logger.debug("Менеджер ограничителей методов остановлен")
 
     @staticmethod
     def _generate_limiter_key(client_id: str, method_identifier: str) -> str:
@@ -77,7 +83,7 @@ class MethodRateLimiterManager:
                 self._rate_limiters[limiter_key] = limiter
                 self._limiter_configs[limiter_key] = config
                 self._last_instance_creation[limiter_key] = current_time
-                logger.debug(
+                self._logger.debug(
                     f"Инициализирован ограничитель запросов для метода {config.method_identifier} "
                     f"ClientID {client_id}: {config.limit_requests} запросов в {config.interval_seconds} сек"
                 )
@@ -107,7 +113,7 @@ class MethodRateLimiterManager:
                 self._last_used.pop(limiter_key, None)
                 self._last_instance_creation.pop(limiter_key, None)
                 if config:
-                    logger.debug(f"Очищен ограничитель для метода {config.method_identifier}")
+                    self._logger.debug(f"Очищен ограничитель для метода {config.method_identifier}")
 
     async def _cleanup_loop(self) -> None:
         """Фоновая задача для очистки неиспользуемых ограничителей."""
@@ -118,7 +124,7 @@ class MethodRateLimiterManager:
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                logger.error(f"Ошибка в cleanup loop методов: {e}")
+                self._logger.error(f"Ошибка в cleanup loop методов: {e}")
                 await asyncio.sleep(60)
 
     async def get_limiter_stats(self) -> dict[str, dict[str, Any]]:
@@ -164,9 +170,10 @@ def method_rate_limit(limit_requests: int, interval_seconds: float):
 
         @wraps(method)
         async def wrapper(self, *args, **kwargs):
+            _logger = self._logger if hasattr(self, '_logger') else logger
             # Проверяем, что экземпляр имеет необходимые атрибуты
             if not hasattr(self, '_client_id') or not hasattr(self, '_method_rate_limiter_manager'):
-                logger.warning(
+                _logger.warning(
                     f"Метод {method_identifier} вызван без инициализации ограничителей. "
                     "Ограничения не применяются."
                 )
@@ -174,7 +181,7 @@ def method_rate_limit(limit_requests: int, interval_seconds: float):
 
             # Дополнительная проверка, что менеджер не None
             if self._method_rate_limiter_manager is None:
-                logger.warning(
+                _logger.warning(
                     f"Менеджер ограничителей методов не инициализирован для {method_identifier}. "
                     "Ограничения не применяются."
                 )
@@ -187,7 +194,7 @@ def method_rate_limit(limit_requests: int, interval_seconds: float):
 
             # Применяем ограничитель запросов
             async with method_limiter:
-                logger.debug(
+                _logger.debug(
                     f"Применен ограничитель метода {method_identifier} для ClientID {self._client_id}: "
                     f"{limit_requests} запросов в {interval_seconds} сек"
                 )

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/src/ozonapi/seller/core/rate_limiter.py

@@ -27,7 +27,12 @@ class RateLimiterManager:
     Обеспечивает общий лимит запросов для всех экземпляров с одинаковым client_id.
     """
 
-    def __init__(self, cleanup_interval: float = 300.0, min_instance_ttl: float = 300.0) -> None:
+    def __init__(
+            self,
+            cleanup_interval: float = 300.0,
+            min_instance_ttl: float = 300.0,
+            instance_logger = logger,
+    ) -> None:
         self._rate_limiters: dict[str, AsyncLimiter] = {}
         self._instance_refs: dict[str, set[int]] = {}
         self._configs: dict[str, RateLimiterConfig] = {}
@@ -37,12 +42,13 @@ class RateLimiterManager:
         self._shutdown = False
         self._cleanup_interval = cleanup_interval
         self._min_instance_ttl = min_instance_ttl
+        self._logger = instance_logger
 
     async def start(self) -> None:
         """Запуск фоновых задач менеджера."""
         if self._cleanup_task is None:
             self._cleanup_task = asyncio.create_task(self._cleanup_loop())
-            logger.debug(f"Менеджер ограничителей общих клиентских запросов запущен")
+            self._logger.debug(f"Менеджер ограничителей общих клиентских запросов запущен")
 
     async def shutdown(self) -> None:
         """Корректное завершение работы менеджера."""
@@ -52,10 +58,10 @@ class RateLimiterManager:
             try:
                 await self._cleanup_task
             except asyncio.CancelledError:
-                logger.debug("Задача очистки общих ограничителей клиентских запросов отменена")
+                self._logger.debug("Задача очистки общих ограничителей клиентских запросов отменена")
             self._cleanup_task = None
 
-        logger.debug("Менеджер общих ограничителей клиентских запросов остановлен")
+        self._logger.debug("Менеджер общих ограничителей клиентских запросов остановлен")
 
     async def get_limiter(self, client_id: str, config: RateLimiterConfig) -> AsyncLimiter:
         """
@@ -77,7 +83,7 @@ class RateLimiterManager:
                     self._instance_refs[client_id] = set()
                 if client_id not in self._last_instance_creation:
                     self._last_instance_creation[client_id] = time.monotonic()
-                logger.debug(f"Инициализирован новый общий ограничитель запросов для ClientID {client_id}: {config}")
+                self._logger.debug(f"Инициализирован новый общий ограничитель запросов для ClientID {client_id}: {config}")
 
             return self._rate_limiters[client_id]
 
@@ -95,7 +101,7 @@ class RateLimiterManager:
                 self._instance_refs[client_id] = set()
                 self._last_instance_creation[client_id] = current_time
             self._instance_refs[client_id].add(instance_id)
-            logger.debug(f"Зарегистрировано подключение к API {instance_id} для ClientID {client_id}")
+            self._logger.debug(f"Зарегистрировано подключение к API {instance_id} для ClientID {client_id}")
 
     async def unregister_instance(self, client_id: str, instance_id: int) -> None:
         """
@@ -108,7 +114,7 @@ class RateLimiterManager:
         async with self._lock:
             if client_id in self._instance_refs:
                 self._instance_refs[client_id].discard(instance_id)
-                logger.debug(f"Отменена регистрация подключения к API {instance_id} для ClientID {client_id}")
+                self._logger.debug(f"Отменена регистрация подключения к API {instance_id} для ClientID {client_id}")
 
     async def _cleanup_unused_limiters(self) -> None:
         """Очистка неиспользуемых ограничителей кол-ва запросов с учетом минимального времени жизни."""
@@ -130,7 +136,7 @@ class RateLimiterManager:
                 self._configs.pop(client_id, None)
                 self._instance_refs.pop(client_id, None)
                 self._last_instance_creation.pop(client_id, None)
-                logger.debug(f"Очищены ресурсы общего ограничителя запросов для ClientID {client_id}")
+                self._logger.debug(f"Очищены ресурсы общего ограничителя запросов для ClientID {client_id}")
 
     async def _cleanup_loop(self) -> None:
         """Фоновая задача для очистки неиспользуемых ограничителей кол-ва запросов."""
@@ -141,7 +147,7 @@ class RateLimiterManager:
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                logger.error(f"Ошибка в cleanup loop: {e}")
+                self._logger.error(f"Ошибка в cleanup loop: {e}")
                 await asyncio.sleep(60)  # Пауза при ошибках
 
     async def get_active_client_ids(self) -> list[str]:

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/src/ozonapi/seller/core/sessions.py

@@ -9,12 +9,18 @@ from loguru import logger
 class SessionManager:
     """Менеджер для управления HTTP-сессиями."""
 
-    def __init__(self, timeout: float = 30.0, connector_limit: int = 100) -> None:
+    def __init__(
+            self,
+            timeout: float = 30.0,
+            connector_limit: int = 100,
+            instance_logger = logger
+    ) -> None:
         self._sessions: dict[str, ClientSession] = {}
         self._session_refs: dict[str, set[int]] = {}
         self._lock = asyncio.Lock()
         self._timeout = ClientTimeout(total=timeout)
         self._connector_limit = connector_limit
+        self._logger = instance_logger
 
     @asynccontextmanager
     async def get_session(self, client_id: str, api_key: str, instance_id: int) -> AsyncIterator[ClientSession]:
@@ -40,7 +46,7 @@ class SessionManager:
                     connector=TCPConnector(limit=self._connector_limit)
                 )
                 self._session_refs[client_id] = set()
-                logger.debug(f"Создана новая сессия для ClientID {client_id}")
+                self._logger.debug(f"Создана новая сессия для ClientID {client_id}")
 
             self._session_refs[client_id].add(instance_id)
 
@@ -61,7 +67,7 @@ class SessionManager:
                 self._session_refs.pop(client_id, None)
                 if not session.closed:
                     await session.close()
-                    logger.debug(f"Сессия для ClientID {client_id} закрыта")
+                    self._logger.debug(f"Сессия для ClientID {client_id} закрыта")
 
     async def close_all(self) -> None:
         """Закрывает все сессии."""
@@ -69,7 +75,7 @@ class SessionManager:
             for client_id, session in list(self._sessions.items()):
                 if not session.closed:
                     await session.close()
-                    logger.debug(f"Сессия для ClientID {client_id} закрыта")
+                    self._logger.debug(f"Сессия для ClientID {client_id} закрыта")
             self._sessions.clear()
             self._session_refs.clear()
-        logger.debug("Все сессии закрыты")
+        self._logger.debug("Все сессии закрыты")

{ozonapi_async-0.7.3 → ozonapi_async-0.7.4}/src/ozonapi_async.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ozonapi-async
-Version: 0.7.3
+Version: 0.7.4
 Summary: Асинхронный клиент для работы с API маркетплейса Ozon
 Author: Alexander Ulianov
 License: MIT
@@ -113,6 +113,7 @@ async def main():
     config = SellerAPIConfig(
         client_id="your_client_id",
         api_key="your_api_key",
+        log_level="DEBUG"
     )
     
     async with SellerAPI(config=config) as api: