ozonapi-async 0.1.0__py3-none-any.whl

ozonapi/seller/core/method_rate_limiter.py

@@ -0,0 +1,199 @@
+import asyncio
+import hashlib
+import time
+from functools import wraps
+from typing import Optional, Any
+
+from aiolimiter import AsyncLimiter
+from loguru import logger
+from pydantic import BaseModel, Field
+
+
+class MethodRateLimitConfig(BaseModel):
+    """Конфигурация ограничений для конкретного метода API."""
+    limit_requests: int = Field(..., ge=1, description="Максимальное количество запросов в интервал времени")
+    interval_seconds: float = Field(..., gt=0, description="Интервал ограничения количества запросов в секундах")
+    method_identifier: str = Field(..., description="Уникальный идентификатор вызываемого метода")
+
+
+class MethodRateLimiterManager:
+    """
+    Менеджер для управления ограничителями запросов по методам API.
+    Обеспечивает раздельные лимиты для каждого метода и client_id.
+    """
+
+    def __init__(self, cleanup_interval: float = 300.0, min_instance_ttl: float = 300.0) -> None:
+        self._rate_limiters: dict[str, AsyncLimiter] = {}
+        self._limiter_configs: dict[str, MethodRateLimitConfig] = {}
+        self._last_used: dict[str, float] = {}
+        self._last_instance_creation: dict[str, float] = {}
+        self._lock = asyncio.Lock()
+        self._cleanup_task: Optional[asyncio.Task] = None
+        self._shutdown = False
+        self._cleanup_interval = cleanup_interval
+        self._min_instance_ttl = min_instance_ttl
+
+    async def start(self) -> None:
+        """Запуск фоновых задач менеджера."""
+        if self._cleanup_task is None:
+            self._cleanup_task = asyncio.create_task(self._cleanup_loop())
+            logger.debug("Менеджер ограничителей методов запущен")
+
+    async def shutdown(self) -> None:
+        """Корректное завершение работы менеджера."""
+        self._shutdown = True
+        if self._cleanup_task:
+            self._cleanup_task.cancel()
+            try:
+                await self._cleanup_task
+            except asyncio.CancelledError:
+                logger.debug("Задача очистки ограничителей методов отменена")
+            self._cleanup_task = None
+        logger.debug("Менеджер ограничителей методов остановлен")
+
+    @staticmethod
+    def _generate_limiter_key(client_id: str, method_identifier: str) -> str:
+        """Генерирует уникальный ключ для ограничителя метода."""
+        key_data = f"{client_id}:{method_identifier}"
+        return hashlib.md5(key_data.encode()).hexdigest()
+
+    async def get_limiter(self, client_id: str, config: MethodRateLimitConfig) -> AsyncLimiter:
+        """
+        Получает ограничитель для указанного метода и client_id.
+
+        Args:
+            client_id: Идентификатор клиента
+            config: Конфигурация ограничителя метода
+
+        Returns:
+            AsyncLimiter: Ограничитель для метода
+        """
+        limiter_key = self._generate_limiter_key(client_id, config.method_identifier)
+        current_time = time.monotonic()
+
+        async with self._lock:
+            if limiter_key not in self._rate_limiters:
+                limiter = AsyncLimiter(config.limit_requests, config.interval_seconds)
+                self._rate_limiters[limiter_key] = limiter
+                self._limiter_configs[limiter_key] = config
+                self._last_instance_creation[limiter_key] = current_time
+                logger.debug(
+                    f"Инициализирован ограничитель запросов для метода {config.method_identifier} "
+                    f"ClientID {client_id}: {config.limit_requests} запросов в {config.interval_seconds} сек"
+                )
+
+            self._last_used[limiter_key] = current_time
+            return self._rate_limiters[limiter_key]
+
+    async def _cleanup_unused_limiters(self) -> None:
+        """Очистка неиспользуемых ограничителей методов с учетом минимального времени жизни."""
+        async with self._lock:
+            current_time = time.monotonic()
+            limiters_to_remove = []
+
+            for limiter_key in list(self._last_used.keys()):
+                last_used = self._last_used[limiter_key]
+                last_creation = self._last_instance_creation.get(limiter_key, last_used)
+                time_since_creation = current_time - last_creation
+                time_since_usage = current_time - last_used
+
+                if (time_since_usage > self._cleanup_interval and
+                        time_since_creation > self._min_instance_ttl):
+                    limiters_to_remove.append(limiter_key)
+
+            for limiter_key in limiters_to_remove:
+                config = self._limiter_configs.pop(limiter_key, None)
+                self._rate_limiters.pop(limiter_key, None)
+                self._last_used.pop(limiter_key, None)
+                self._last_instance_creation.pop(limiter_key, None)
+                if config:
+                    logger.debug(f"Очищен ограничитель для метода {config.method_identifier}")
+
+    async def _cleanup_loop(self) -> None:
+        """Фоновая задача для очистки неиспользуемых ограничителей."""
+        while not self._shutdown:
+            try:
+                await asyncio.sleep(self._cleanup_interval)
+                await self._cleanup_unused_limiters()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Ошибка в cleanup loop методов: {e}")
+                await asyncio.sleep(60)
+
+    async def get_limiter_stats(self) -> dict[str, dict[str, Any]]:
+        """Формирует статистику по ограничителям методов."""
+        current_time = time.monotonic()
+        async with self._lock:
+            stats = {}
+            for limiter_key in self._rate_limiters:
+                config = self._limiter_configs.get(limiter_key)
+                last_used = self._last_used.get(limiter_key, current_time)
+                last_creation = self._last_instance_creation.get(limiter_key, current_time)
+
+                if config:
+                    stats[limiter_key] = {
+                        "config": config,
+                        "last_used": last_used,
+                        "last_instance_creation": last_creation,
+                        "time_since_creation": current_time - last_creation,
+                        "time_since_usage": current_time - last_used,
+                    }
+            return stats
+
+def method_rate_limit(limit_requests: int, interval_seconds: float):
+    """
+    Декоратор для применения дополнительных ограничений частоты запросов к методам API.
+
+    Args:
+        limit_requests: Максимальное количество запросов в указанный интервал
+        interval_seconds: Временной интервал в секундах
+
+    Returns:
+        Декоратор метода
+    """
+
+    def decorator(method):
+        # Генерируем уникальный идентификатор метода
+        method_identifier = f"{method.__module__}.{method.__qualname__}"
+        config = MethodRateLimitConfig(
+            limit_requests=limit_requests,
+            interval_seconds=interval_seconds,
+            method_identifier=method_identifier
+        )
+
+        @wraps(method)
+        async def wrapper(self, *args, **kwargs):
+            # Проверяем, что экземпляр имеет необходимые атрибуты
+            if not hasattr(self, '_client_id') or not hasattr(self, '_method_rate_limiter_manager'):
+                logger.warning(
+                    f"Метод {method_identifier} вызван без инициализации ограничителей. "
+                    "Ограничения не применяются."
+                )
+                return await method(self, *args, **kwargs)
+
+            # Дополнительная проверка, что менеджер не None
+            if self._method_rate_limiter_manager is None:
+                logger.warning(
+                    f"Менеджер ограничителей методов не инициализирован для {method_identifier}. "
+                    "Ограничения не применяются."
+                )
+                return await method(self, *args, **kwargs)
+
+            # Получаем ограничитель запросов для этого метода
+            method_limiter = await self._method_rate_limiter_manager.get_limiter(
+                self._client_id, config
+            )
+
+            # Применяем ограничитель запросов
+            async with method_limiter:
+                logger.debug(
+                    f"Применен ограничитель метода {method_identifier} для ClientID {self._client_id}: "
+                    f"{limit_requests} запросов в {interval_seconds} сек"
+                )
+                return await method(self, *args, **kwargs)
+        # Добавляем метаданные
+        wrapper._rate_limit_config = config
+        return wrapper
+
+    return decorator

ozonapi/seller/core/rate_limiter.py

@@ -0,0 +1,174 @@
+import asyncio
+import time
+from typing import Optional, Any
+
+from aiolimiter import AsyncLimiter
+from loguru import logger
+
+
+class RateLimiterConfig:
+    """Конфигурация ограничителя кол-ва запросов."""
+
+    def __init__(
+            self,
+            max_requests: int = 50,
+            time_window: float = 1.0,
+    ) -> None:
+        self.max_requests = max_requests
+        self.time_window = time_window
+
+    def __repr__(self) -> str:
+        return f"RateLimiterConfig(max_requests={self.max_requests}, time_window={self.time_window})"
+
+
+class RateLimiterManager:
+    """
+    Менеджер для управления ограничителями запросов по client_id.
+    Обеспечивает общий лимит запросов для всех экземпляров с одинаковым client_id.
+    """
+
+    def __init__(self, cleanup_interval: float = 300.0, min_instance_ttl: float = 300.0) -> None:
+        self._rate_limiters: dict[str, AsyncLimiter] = {}
+        self._instance_refs: dict[str, set[int]] = {}
+        self._configs: dict[str, RateLimiterConfig] = {}
+        self._last_instance_creation: dict[str, float] = {}
+        self._lock = asyncio.Lock()
+        self._cleanup_task: Optional[asyncio.Task] = None
+        self._shutdown = False
+        self._cleanup_interval = cleanup_interval
+        self._min_instance_ttl = min_instance_ttl
+
+    async def start(self) -> None:
+        """Запуск фоновых задач менеджера."""
+        if self._cleanup_task is None:
+            self._cleanup_task = asyncio.create_task(self._cleanup_loop())
+            logger.debug(f"Менеджер ограничителей общих клиентских запросов запущен")
+
+    async def shutdown(self) -> None:
+        """Корректное завершение работы менеджера."""
+        self._shutdown = True
+        if self._cleanup_task:
+            self._cleanup_task.cancel()
+            try:
+                await self._cleanup_task
+            except asyncio.CancelledError:
+                logger.debug("Задача очистки общих ограничителей клиентских запросов отменена")
+            self._cleanup_task = None
+
+        logger.debug("Менеджер общих ограничителей клиентских запросов остановлен")
+
+    async def get_limiter(self, client_id: str, config: RateLimiterConfig) -> AsyncLimiter:
+        """
+        Получает ограничитель кол-ва запросов для указанного client_id.
+
+        Args:
+            client_id: Идентификатор клиента
+            config: Конфигурация ограничителя
+
+        Returns:
+            AsyncLimiter: Общий ограничитель для client_id
+        """
+        async with self._lock:
+            if client_id not in self._rate_limiters:
+                limiter = AsyncLimiter(config.max_requests, config.time_window)
+                self._rate_limiters[client_id] = limiter
+                self._configs[client_id] = config
+                if client_id not in self._instance_refs:
+                    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}")
+
+            return self._rate_limiters[client_id]
+
+    async def register_instance(self, client_id: str, instance_id: int) -> None:
+        """
+        Регистрирует экземпляр класса.
+
+        Args:
+            client_id: Идентификатор клиента
+            instance_id: Уникальный идентификатор экземпляра
+        """
+        current_time = time.monotonic()
+        async with self._lock:
+            if client_id not in self._instance_refs:
+                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}")
+
+    async def unregister_instance(self, client_id: str, instance_id: int) -> None:
+        """
+        Удаляет регистрацию экземпляра.
+
+        Args:
+            client_id: Идентификатор клиента
+            instance_id: Уникальный идентификатор экземпляра
+        """
+        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}")
+
+    async def _cleanup_unused_limiters(self) -> None:
+        """Очистка неиспользуемых ограничителей кол-ва запросов с учетом минимального времени жизни."""
+        async with self._lock:
+            current_time = time.monotonic()
+            clients_to_remove = []
+
+            for client_id, instances in self._instance_refs.items():
+                if not instances:
+                    last_creation = self._last_instance_creation.get(client_id, 0)
+                    time_since_creation = current_time - last_creation
+
+                    # Планируем очистку, если прошло достаточно времени с создания последнего экземпляра
+                    if time_since_creation > self._min_instance_ttl:
+                        clients_to_remove.append(client_id)
+
+            for client_id in clients_to_remove:
+                self._rate_limiters.pop(client_id, None)
+                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}")
+
+    async def _cleanup_loop(self) -> None:
+        """Фоновая задача для очистки неиспользуемых ограничителей кол-ва запросов."""
+        while not self._shutdown:
+            try:
+                await asyncio.sleep(self._cleanup_interval)
+                await self._cleanup_unused_limiters()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Ошибка в cleanup loop: {e}")
+                await asyncio.sleep(60)  # Пауза при ошибках
+
+    async def get_active_client_ids(self) -> list[str]:
+        """Формирует список активных client_id."""
+        async with self._lock:
+            return [cid for cid, instances in self._instance_refs.items() if instances]
+
+    async def get_instance_stats(self) -> dict[str, int]:
+        """Формирует статистику по экземплярам."""
+        async with self._lock:
+            return {
+                client_id: len(instances)
+                for client_id, instances in self._instance_refs.items()
+                if instances
+            }
+
+    async def get_limiter_stats(self) -> dict[str, dict[str, Any]]:
+        """Формирует детальную статистику по ограничителям."""
+        current_time = time.monotonic()
+        async with self._lock:
+            return {
+                client_id: {
+                    "config": self._configs[client_id],
+                    "instances": len(self._instance_refs[client_id]),
+                    "limiter": str(self._rate_limiters[client_id]),
+                    "last_instance_creation": self._last_instance_creation.get(client_id),
+                    "time_since_creation": current_time - self._last_instance_creation.get(client_id, current_time),
+                }
+                for client_id in self._rate_limiters
+            }

ozonapi/seller/core/sessions.py

@@ -0,0 +1,75 @@
+import asyncio
+from contextlib import asynccontextmanager
+from typing import AsyncIterator
+
+from aiohttp import ClientSession, ClientTimeout, TCPConnector
+from loguru import logger
+
+
+class SessionManager:
+    """Менеджер для управления HTTP-сессиями."""
+
+    def __init__(self, timeout: float = 30.0, connector_limit: int = 100) -> 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
+
+    @asynccontextmanager
+    async def get_session(self, client_id: str, api_key: str, instance_id: int) -> AsyncIterator[ClientSession]:
+        """
+        Получает сессию для client_id.
+
+        Args:
+            client_id: Идентификатор клиента
+            api_key: Ключ API
+            instance_id: ID экземпляра
+
+        Yields:
+            ClientSession: HTTP-сессия
+        """
+        async with self._lock:
+            if client_id not in self._sessions:
+                self._sessions[client_id] = ClientSession(
+                    headers={
+                        "Client-Id": client_id,
+                        "Api-Key": api_key,
+                    },
+                    timeout=self._timeout,
+                    connector=TCPConnector(limit=self._connector_limit)
+                )
+                self._session_refs[client_id] = set()
+                logger.debug(f"Создана новая сессия для ClientID {client_id}")
+
+            self._session_refs[client_id].add(instance_id)
+
+        try:
+            yield self._sessions[client_id]
+        finally:
+            async with self._lock:
+                if client_id in self._session_refs:
+                    self._session_refs[client_id].discard(instance_id)
+
+    async def close_session(self, client_id: str) -> None:
+        """Закрывает сессию для client_id."""
+        async with self._lock:
+            if client_id in self._sessions:
+                if client_id in self._session_refs and self._session_refs[client_id]:
+                    return
+                session = self._sessions.pop(client_id)
+                self._session_refs.pop(client_id, None)
+                if not session.closed:
+                    await session.close()
+                    logger.debug(f"Сессия для ClientID {client_id} закрыта")
+
+    async def close_all(self) -> None:
+        """Закрывает все сессии."""
+        async with self._lock:
+            for client_id, session in list(self._sessions.items()):
+                if not session.closed:
+                    await session.close()
+                    logger.debug(f"Сессия для ClientID {client_id} закрыта")
+            self._sessions.clear()
+            self._session_refs.clear()
+        logger.debug("Все сессии закрыты")

ozonapi/seller/methods/__init__.py

@@ -0,0 +1,15 @@
+__all__ = [
+    "SellerBarcodeAPI",
+    "SellerCategoryAPI",
+    "SellerFBSAPI",
+    "SellerPricesAndStocksAPI",
+    "SellerProductAPI",
+    "SellerWarehouseAPI",
+]
+
+from .attributes_and_characteristics import SellerCategoryAPI
+from .barcodes import SellerBarcodeAPI
+from .fbs import SellerFBSAPI
+from .prices_and_stocks import SellerPricesAndStocksAPI
+from .products import SellerProductAPI
+from .warehouses import SellerWarehouseAPI

ozonapi/seller/methods/attributes_and_characteristics.py

@@ -0,0 +1,177 @@
+from ..core import APIManager
+from ..schemas.attributes_and_characteristics import (
+    DescriptionCategoryAttributeResponse,
+    DescriptionCategoryTreeResponse,
+    DescriptionCategoryTreeRequest,
+    DescriptionCategoryAttributeRequest,
+    DescriptionCategoryAttributeValuesRequest,
+    DescriptionCategoryAttributeValuesResponse,
+    DescriptionCategoryAttributeValuesSearchRequest,
+    DescriptionCategoryAttributeValuesSearchResponse
+)
+
+
+class SellerCategoryAPI(APIManager):
+    """Реализует методы раздела Атрибуты и характеристики Ozon.
+
+    References:
+        https://docs.ozon.ru/api/seller/?__rr=1#tag/CategoryAPI
+    """
+
+    async def description_category_tree(
+        self: "SellerCategoryAPI",
+        request: DescriptionCategoryTreeRequest = DescriptionCategoryTreeRequest.model_construct(),
+    ) -> DescriptionCategoryTreeResponse:
+        """Возвращает категории и типы для товаров в виде дерева.
+        Создание товаров доступно только в категориях последнего уровня, сравните именно их с категориями на своей площадке.
+        Категории не создаются по запросу пользователя.
+
+        Notes:
+            Внимательно выбирайте категорию для товара: для разных категорий применяется разный размер комиссии.
+
+        References:
+            https://docs.ozon.ru/api/seller/#operation/DescriptionCategoryAPI_GetTree
+
+        Args:
+            request: Запрос к серверу по схеме `DescriptionCategoryTreeRequest`
+
+        Returns:
+            Категории и типы для товаров в виде дерева по схеме `DescriptionCategoryTreeResponse`
+
+        Example:
+            async with SellerAPI(client_id, api_key) as api:
+                description_category_tree = await api.description_category_tree()
+        """
+        response = await self._request(
+            method="post",
+            api_version="v1",
+            endpoint="description-category/tree",
+            json=request.model_dump()
+        )
+        return DescriptionCategoryTreeResponse(**response)
+
+    async def description_category_attribute(
+        self: "SellerCategoryAPI",
+        request: DescriptionCategoryAttributeRequest,
+    ) -> DescriptionCategoryAttributeResponse:
+        """Получение характеристик для указанных категории и типа товара.
+        Если у `dictionary_id` значение `0`, у атрибута нет вложенных справочников. Если значение другое, то справочники есть.
+        Запросите их методом `description_category_attribute_values()`.
+
+        Notes:
+            • `attribute_id` - Идентификатор характеристики, можно получить с помощью метода `description_category_attribute()`
+            • `description_category_id` - Идентификатор категории, можно получить с помощью метода `description_category_tree()`
+            • `type_id` - Идентификатор типа товара, можно получить с помощью метода `description_category_tree()`
+
+        References:
+            https://docs.ozon.ru/api/seller/#operation/DescriptionCategoryAPI_GetAttributes
+
+        Args:
+            request: Запрос к серверу gо схеме `DescriptionCategoryAttributeRequest`
+
+        Returns:
+            Характеристики для указанных категории и типа товара по схеме `DescriptionCategoryAttributeResponse`
+
+        Example:
+            async with SellerAPI(client_id, api_key) as api:
+                description_category_attribute = await api.description_category_attribute(
+                    DescriptionCategoryAttributeRequest(
+                        description_category_id=200000933,
+                        type_id=93080,
+                        language=Language.DEFAULT,
+                    )
+                )
+        """
+        response = await self._request(
+            method="post",
+            api_version="v1",
+            endpoint="description-category/attribute",
+            json=request.model_dump(),
+        )
+        return DescriptionCategoryAttributeResponse(**response)
+
+    async def description_category_attribute_values(
+        self: "SellerCategoryAPI",
+        request: DescriptionCategoryAttributeValuesRequest,
+    ) -> DescriptionCategoryAttributeValuesResponse:
+        """Возвращает справочник значений характеристики.
+        Узнать, есть ли вложенный справочник, можно через метод `description_category_attribute()`.
+
+        Notes:
+            • `attribute_id` - Идентификатор характеристики, можно получить с помощью метода `description_category_attribute()`
+            • `description_category_id` - Идентификатор категории, можно получить с помощью метода `description_category_tree()`
+            • `type_id` - Идентификатор типа товара, можно получить с помощью метода `description_category_tree()`
+            • Для пагинации используйте значение `last_value_id`
+
+        References:
+            https://docs.ozon.ru/api/seller/?__rr=2&abt_att=1#operation/DescriptionCategoryAPI_GetAttributeValues
+
+        Args:
+            request: Запрос к серверу по схеме `DescriptionCategoryAttributeValuesRequest`
+
+        Returns:
+            Cправочник значений характеристики по схеме `DescriptionCategoryAttributeValuesResponse`
+
+        Example:
+            async with SellerAPI(client_id, api_key) as api:
+                description_category_attribute_values = await api.description_category_attribute_values(
+                    DescriptionCategoryAttributeValuesRequest(
+                        attribute_id=85,
+                        description_category_id=17054869,
+                        language=Language.DEFAULT,
+                        last_value_id=0,
+                        limit=100,
+                        type_id=97311
+                    )
+                )
+        """
+        response = await self._request(
+            method="post",
+            api_version="v1",
+            endpoint="description-category/attribute/values",
+            json=request.model_dump(),
+        )
+        return DescriptionCategoryAttributeValuesResponse(**response)
+
+
+    async def description_category_attribute_values_search(
+        self: "SellerCategoryAPI",
+        request: DescriptionCategoryAttributeValuesSearchRequest,
+    ) -> DescriptionCategoryAttributeValuesSearchResponse:
+        """Возвращает справочные значения характеристики по заданному значению value в запросе.
+        Узнать, есть ли вложенный справочник, можно через метод `description_category_attribute()`.
+
+        Notes:
+            • `attribute_id` - Идентификатор характеристики, можно получить с помощью метода `description_category_attribute()`
+            • `description_category_id` - Идентификатор категории, можно получить с помощью метода `description_category_tree()`
+            • `type_id` - Идентификатор типа товара, можно получить с помощью метода `description_category_tree()`
+            • `value` - Поисковый запрос (минимум 2 символа)
+
+        References:
+            https://docs.ozon.ru/api/seller/?__rr=2&abt_att=1#operation/DescriptionCategoryAPI_SearchAttributeValues
+
+        Args:
+            request: Запрос к серверу по схеме `DescriptionCategoryAttributeValuesSearchRequest`
+
+        Returns:
+            Справочные значения характеристики по заданному значению value в запросе по схеме `DescriptionCategoryAttributeValuesSearchResponse`
+
+        Example:
+            async with SellerAPI(client_id, api_key) as api:
+                description_category_attribute_values = await api.description_category_attribute_values_search(
+                    DescriptionCategoryAttributeValuesSearchRequest(
+                        attribute_id=85,
+                        description_category_id=17054869,
+                        limit=100,
+                        type_id=97311,
+                        value="Красота"
+                    )
+                )
+        """
+        response = await self._request(
+            method="post",
+            api_version="v1",
+            endpoint="description-category/attribute/values/search",
+            json=request.model_dump(),
+        )
+        return DescriptionCategoryAttributeValuesSearchResponse(**response)