async-amazon-ads-api-v1 0.3.0__py3-none-any.whl

async_amazon_ads_api_v1/__init__.py

@@ -0,0 +1,30 @@
+"""Pure async Amazon Ads API v1 client — Sponsored Products, Sponsored Brands, Sponsored Display."""
+
+from async_amazon_ads_api_v1.client.sb import SBClient
+from async_amazon_ads_api_v1.client.sd import SDClient
+from async_amazon_ads_api_v1.client.sp import SPClient
+from async_amazon_ads_api_v1.config.region import Region
+from async_amazon_ads_api_v1.config.settings import AmazonAdsConfig, CacheBackend
+from async_amazon_ads_api_v1.config.token_cache import (
+    BaseTokenCache,
+    FileTokenCache,
+    RedisTokenCache,
+    close_all_redis,
+)
+from async_amazon_ads_api_v1.config.token_manager import TokenCredentials, TokenManager
+
+__all__ = [
+    "AmazonAdsConfig",
+    "BaseTokenCache",
+    "CacheBackend",
+    "FileTokenCache",
+    "RedisTokenCache",
+    "Region",
+    "SBClient",
+    "SDClient",
+    "SPClient",
+    "TokenCredentials",
+    "TokenManager",
+    "close_all_redis",
+]
+__version__ = "0.3.0"

async_amazon_ads_api_v1/_base.py

@@ -0,0 +1,171 @@
+"""Shared HTTP session and base resource class for all API resource classes."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import random
+from dataclasses import dataclass
+from typing import Any, TypeVar, cast
+
+import httpx
+from pydantic import BaseModel, ValidationError
+
+from .config.settings import AmazonAdsConfig
+
+logger = logging.getLogger(__name__)
+
+_T = TypeVar("_T", bound=BaseModel)
+
+
+class ClientContext:
+    """Shared HTTP state for all resource instances.
+
+    Lazily creates and caches the ``httpx.AsyncClient`` on first use.
+    """
+
+    __slots__ = ("config", "_client")
+
+    def __init__(self, config: AmazonAdsConfig) -> None:
+        self.config: AmazonAdsConfig = config
+        self._client: httpx.AsyncClient | None = None
+
+    async def get_client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                base_url=self.config.base_url,
+                timeout=httpx.Timeout(self.config.timeout),
+            )
+        return self._client
+
+    def _response(self, model_cls: type[_T], resp: httpx.Response) -> _T | dict[str, Any]:
+        if self.config.raw_response:
+            return cast(dict[str, Any], resp.json())
+        try:
+            return model_cls.model_validate_json(resp.content, extra="ignore")
+        except ValidationError:
+            logger.warning(
+                "Failed to validate response for %s (status=%s): %s",
+                model_cls.__name__,
+                resp.status_code,
+                resp.text,
+            )
+            raise
+
+
+@dataclass
+class _ResourceSpec:
+    """Metadata for a REST resource (campaigns, adGroups, etc)."""
+
+    name: str
+    create_model: type[BaseModel]
+    update_model: type[BaseModel] | None = None
+    delete_key: str | None = None
+    path_suffix: str = ""
+
+
+class _ResourceBase:
+    """Base class providing shared HTTP operations for resource classes."""
+
+    __slots__ = ("_ctx",)
+
+    def __init__(self, ctx: ClientContext) -> None:
+        self._ctx: ClientContext = ctx
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        accept_async: bool = False,
+    ) -> httpx.Response:
+        client = await self._ctx.get_client()
+        accept = "application/vnd.createasyncrequestresults.v3+json" if accept_async else "application/json"
+        if self._ctx.config.access_token is None and self._ctx.config.refresh_token:
+            await self._ctx.config.refresh_access_token()
+        headers = {
+            "Authorization": f"Bearer {self._ctx.config.access_token}",
+            "Accept": accept,
+            "Amazon-Ads-ClientId": self._ctx.config.client_id,
+        }
+        if self._ctx.config.profile_id is not None:
+            headers["Amazon-Advertising-API-Scope"] = self._ctx.config.profile_id
+        for attempt in range(self._ctx.config.max_retries):
+            try:
+                resp = await client.request(
+                    method=method,
+                    url=path,
+                    params=params,
+                    json=json,
+                    headers=headers,
+                )
+                resp.raise_for_status()
+                return resp
+            except httpx.HTTPStatusError as exc:
+                if exc.response.status_code == 401 and self._ctx.config.refresh_token and attempt == 0:
+                    await self._ctx.config.refresh_access_token()
+                    headers["Authorization"] = f"Bearer {self._ctx.config.access_token}"
+                    continue
+                if exc.response.status_code in (429, 503, 504):
+                    if attempt < self._ctx.config.max_retries - 1:
+                        wait_time = 2**attempt + random.uniform(0, 1)
+                        logger.warning(f"Rate limit exceeded, retrying in %.2f seconds {exc}", wait_time)
+                        await asyncio.sleep(wait_time)
+                        continue
+                logger.error(f"{exc.response.status_code} {exc.response.text}")
+                raise
+            except httpx.ConnectError:
+                if attempt < self._ctx.config.max_retries - 1:
+                    await asyncio.sleep(2**attempt + random.uniform(0, 1))
+                    continue
+                raise
+        raise RuntimeError("Retry loop exited unexpectedly")
+
+    def _response(self, model_cls: type[_T], resp: httpx.Response) -> _T | dict[str, Any]:
+        return self._ctx._response(model_cls, resp)
+
+    def _validate(self, items: list[Any], model_cls: type[_T]) -> list[dict[str, Any]]:
+        result: list[dict[str, Any]] = []
+        for item in items:
+            if isinstance(item, model_cls):
+                result.append(item.model_dump(mode="json", exclude_none=True))
+            else:
+                result.append(model_cls(**item).model_dump(mode="json", exclude_none=True))
+        return result
+
+    async def _create(self, items: list[Any], spec: _ResourceSpec, response_cls: type[_T]) -> _T | dict[str, Any]:
+        validated = self._validate(items, spec.create_model)
+        resp = await self._request(
+            "POST",
+            f"/adsApi/v1/create/{spec.name}{spec.path_suffix}",
+            json={spec.name: validated},
+            accept_async=True,
+        )
+        return self._response(response_cls, resp)
+
+    async def _update(self, items: list[Any], spec: _ResourceSpec, response_cls: type[_T]) -> _T | dict[str, Any]:
+        assert spec.update_model is not None, f"{spec.name} has no update model"
+        validated = self._validate(items, spec.update_model)
+        resp = await self._request(
+            "POST",
+            f"/adsApi/v1/update/{spec.name}{spec.path_suffix}",
+            json={spec.name: validated},
+            accept_async=True,
+        )
+        return self._response(response_cls, resp)
+
+    async def _delete(self, ids: list[str], spec: _ResourceSpec, response_cls: type[_T]) -> _T | dict[str, Any]:
+        assert spec.delete_key is not None, f"{spec.name} has no delete operation"
+        resp = await self._request(
+            "POST",
+            f"/adsApi/v1/delete/{spec.name}{spec.path_suffix}",
+            json={spec.delete_key: ids},
+            accept_async=True,
+        )
+        return self._response(response_cls, resp)
+
+    async def _query(self, body: BaseModel, path: str, response_cls: type[_T]) -> _T | dict[str, Any]:
+        resp = await self._request("POST", path, json=body.model_dump(exclude_none=True))
+        return self._response(response_cls, resp)

async_amazon_ads_api_v1/client/sb/__init__.py

@@ -0,0 +1,121 @@
+"""Sponsored Brands async HTTP client."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import ClientContext
+from async_amazon_ads_api_v1.config.settings import AmazonAdsConfig
+
+from .ad_extensions import AdExtensions
+from .ad_groups import AdGroups
+from .ads import Ads
+from .advertising_deal_targets import AdvertisingDealTargets
+from .advertising_deals import AdvertisingDeals
+from .branded_keywords_pricings import BrandedKeywordsPricings
+from .campaigns import Campaigns
+from .keyword_reservation_validations import KeywordReservationValidations
+from .recommendation_types import RecommendationTypes
+from .recommendations import Recommendations
+from .targets import Targets
+
+
+class SBClient:
+    """Async HTTP client for Amazon Ads Sponsored Brands API.
+
+    Parameters
+    ----------
+    config : AmazonAdsConfig
+        Client configuration (auth, region, timeouts, retries).
+    """
+
+    def __init__(self, config: AmazonAdsConfig) -> None:
+        self._ctx = ClientContext(config)
+        self.__campaign: Campaigns | None = None
+        self.__ad_group: AdGroups | None = None
+        self.__ad: Ads | None = None
+        self.__target: Targets | None = None
+        self.__ad_extension: AdExtensions | None = None
+        self.__advertising_deal_target: AdvertisingDealTargets | None = None
+        self.__advertising_deal: AdvertisingDeals | None = None
+        self.__branded_keywords_pricing: BrandedKeywordsPricings | None = None
+        self.__keyword_reservation_validation: KeywordReservationValidations | None = None
+        self.__recommendation_type: RecommendationTypes | None = None
+        self.__recommendation: Recommendations | None = None
+
+    async def __aenter__(self) -> SBClient:
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        if self._ctx._client is not None:
+            await self._ctx._client.aclose()
+            self._ctx._client = None
+
+    @property
+    def campaigns(self) -> Campaigns:
+        if self.__campaign is None:
+            self.__campaign = Campaigns(self._ctx)
+        return self.__campaign
+
+    @property
+    def ad_groups(self) -> AdGroups:
+        if self.__ad_group is None:
+            self.__ad_group = AdGroups(self._ctx)
+        return self.__ad_group
+
+    @property
+    def ads(self) -> Ads:
+        if self.__ad is None:
+            self.__ad = Ads(self._ctx)
+        return self.__ad
+
+    @property
+    def targets(self) -> Targets:
+        if self.__target is None:
+            self.__target = Targets(self._ctx)
+        return self.__target
+
+    @property
+    def ad_extensions(self) -> AdExtensions:
+        if self.__ad_extension is None:
+            self.__ad_extension = AdExtensions(self._ctx)
+        return self.__ad_extension
+
+    @property
+    def advertising_deal_targets(self) -> AdvertisingDealTargets:
+        if self.__advertising_deal_target is None:
+            self.__advertising_deal_target = AdvertisingDealTargets(self._ctx)
+        return self.__advertising_deal_target
+
+    @property
+    def advertising_deals(self) -> AdvertisingDeals:
+        if self.__advertising_deal is None:
+            self.__advertising_deal = AdvertisingDeals(self._ctx)
+        return self.__advertising_deal
+
+    @property
+    def branded_keywords_pricings(self) -> BrandedKeywordsPricings:
+        if self.__branded_keywords_pricing is None:
+            self.__branded_keywords_pricing = BrandedKeywordsPricings(self._ctx)
+        return self.__branded_keywords_pricing
+
+    @property
+    def keyword_reservation_validations(self) -> KeywordReservationValidations:
+        if self.__keyword_reservation_validation is None:
+            self.__keyword_reservation_validation = KeywordReservationValidations(self._ctx)
+        return self.__keyword_reservation_validation
+
+    @property
+    def recommendation_types(self) -> RecommendationTypes:
+        if self.__recommendation_type is None:
+            self.__recommendation_type = RecommendationTypes(self._ctx)
+        return self.__recommendation_type
+
+    @property
+    def recommendations(self) -> Recommendations:
+        if self.__recommendation is None:
+            self.__recommendation = Recommendations(self._ctx)
+        return self.__recommendation

async_amazon_ads_api_v1/client/sb/ad_extensions.py

@@ -0,0 +1,39 @@
+"""SB AdExtension resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBAdExtensionCreate,
+    SBAdExtensionMultiStatusResponse,
+    SBAdExtensionSuccessResponse,
+    SBAdExtensionUpdate,
+    SBQueryAdExtensionRequest,
+)
+
+
+class AdExtensions(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="adExtensions",
+        create_model=SBAdExtensionCreate,
+        update_model=SBAdExtensionUpdate,
+    )
+
+    async def create(
+        self, ad_extensions: list[dict[str, Any] | SBAdExtensionCreate]
+    ) -> SBAdExtensionSuccessResponse | dict[str, Any]:
+        return await self._create(ad_extensions, self._spec, SBAdExtensionSuccessResponse)
+
+    async def query(
+        self, body: dict[str, Any] | SBQueryAdExtensionRequest
+    ) -> SBAdExtensionSuccessResponse | dict[str, Any]:
+        if isinstance(body, dict):
+            body = SBQueryAdExtensionRequest(**body)
+        return await self._query(body, "/adsApi/v1/query/adExtensions", SBAdExtensionSuccessResponse)
+
+    async def update(
+        self, ad_extensions: list[dict[str, Any] | SBAdExtensionUpdate]
+    ) -> SBAdExtensionMultiStatusResponse | dict[str, Any]:
+        return await self._update(ad_extensions, self._spec, SBAdExtensionMultiStatusResponse)

async_amazon_ads_api_v1/client/sb/ad_groups.py

@@ -0,0 +1,41 @@
+"""SB AdGroup resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBAdGroupCreate,
+    SBAdGroupMultiStatusResponse,
+    SBAdGroupSuccessResponse,
+    SBAdGroupUpdate,
+    SBQueryAdGroupRequest,
+)
+
+
+class AdGroups(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="adGroups",
+        create_model=SBAdGroupCreate,
+        update_model=SBAdGroupUpdate,
+        delete_key="adGroupIds",
+    )
+
+    async def create(
+        self, ad_groups: list[dict[str, Any] | SBAdGroupCreate]
+    ) -> SBAdGroupMultiStatusResponse | dict[str, Any]:
+        return await self._create(ad_groups, self._spec, SBAdGroupMultiStatusResponse)
+
+    async def query(self, body: dict[str, Any] | SBQueryAdGroupRequest) -> SBAdGroupSuccessResponse | dict[str, Any]:
+        if isinstance(body, dict):
+            body = SBQueryAdGroupRequest(**body)
+        return await self._query(body, "/adsApi/v1/query/adGroups", SBAdGroupSuccessResponse)
+
+    async def update(
+        self, ad_groups: list[dict[str, Any] | SBAdGroupUpdate]
+    ) -> SBAdGroupMultiStatusResponse | dict[str, Any]:
+        return await self._update(ad_groups, self._spec, SBAdGroupMultiStatusResponse)
+
+    async def delete(self, ad_group_ids: list[str]) -> SBAdGroupMultiStatusResponse | dict[str, Any]:
+        return await self._delete(ad_group_ids, self._spec, SBAdGroupMultiStatusResponse)

async_amazon_ads_api_v1/client/sb/ads.py

@@ -0,0 +1,37 @@
+"""SB Ad resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBAdCreate,
+    SBAdMultiStatusResponse,
+    SBAdSuccessResponse,
+    SBAdUpdate,
+    SBQueryAdRequest,
+)
+
+
+class Ads(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="ads",
+        create_model=SBAdCreate,
+        update_model=SBAdUpdate,
+        delete_key="adIds",
+    )
+
+    async def create(self, ads: list[dict[str, Any] | SBAdCreate]) -> SBAdMultiStatusResponse | dict[str, Any]:
+        return await self._create(ads, self._spec, SBAdMultiStatusResponse)
+
+    async def query(self, body: dict[str, Any] | SBQueryAdRequest) -> SBAdSuccessResponse | dict[str, Any]:
+        if isinstance(body, dict):
+            body = SBQueryAdRequest(**body)
+        return await self._query(body, "/adsApi/v1/query/ads", SBAdSuccessResponse)
+
+    async def update(self, ads: list[dict[str, Any] | SBAdUpdate]) -> SBAdMultiStatusResponse | dict[str, Any]:
+        return await self._update(ads, self._spec, SBAdMultiStatusResponse)
+
+    async def delete(self, ad_ids: list[str]) -> SBAdMultiStatusResponse | dict[str, Any]:
+        return await self._delete(ad_ids, self._spec, SBAdMultiStatusResponse)

async_amazon_ads_api_v1/client/sb/advertising_deal_targets.py

@@ -0,0 +1,41 @@
+"""SB AdvertisingDealTarget resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBAdvertisingDealTargetCreate,
+    SBAdvertisingDealTargetMultiStatusResponse,
+    SBAdvertisingDealTargetSuccessResponse,
+    SBQueryAdvertisingDealTargetRequest,
+)
+
+
+class AdvertisingDealTargets(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="advertisingDealTargets",
+        create_model=SBAdvertisingDealTargetCreate,
+        delete_key="advertisingDealTargetIds",
+        path_suffix="/sb",
+    )
+
+    async def create(
+        self, items: list[dict[str, Any] | SBAdvertisingDealTargetCreate]
+    ) -> SBAdvertisingDealTargetSuccessResponse | dict[str, Any]:
+        return await self._create(items, self._spec, SBAdvertisingDealTargetSuccessResponse)
+
+    async def query(
+        self, body: dict[str, Any] | SBQueryAdvertisingDealTargetRequest
+    ) -> SBAdvertisingDealTargetSuccessResponse | dict[str, Any]:
+        if isinstance(body, dict):
+            body = SBQueryAdvertisingDealTargetRequest(**body)
+        return await self._query(
+            body,
+            "/adsApi/v1/query/advertisingDealTargets/sb",
+            SBAdvertisingDealTargetSuccessResponse,
+        )
+
+    async def delete(self, ids: list[str]) -> SBAdvertisingDealTargetMultiStatusResponse | dict[str, Any]:
+        return await self._delete(ids, self._spec, SBAdvertisingDealTargetMultiStatusResponse)

async_amazon_ads_api_v1/client/sb/advertising_deals.py

@@ -0,0 +1,44 @@
+"""SB AdvertisingDeal resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBAdvertisingDealCreate,
+    SBAdvertisingDealMultiStatusResponse,
+    SBAdvertisingDealSuccessResponse,
+    SBAdvertisingDealUpdate,
+    SBQueryAdvertisingDealRequest,
+)
+
+
+class AdvertisingDeals(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="advertisingDeals",
+        create_model=SBAdvertisingDealCreate,
+        update_model=SBAdvertisingDealUpdate,
+        delete_key="advertisingDealIds",
+        path_suffix="/sb",
+    )
+
+    async def create(
+        self, items: list[dict[str, Any] | SBAdvertisingDealCreate]
+    ) -> SBAdvertisingDealSuccessResponse | dict[str, Any]:
+        return await self._create(items, self._spec, SBAdvertisingDealSuccessResponse)
+
+    async def query(
+        self, body: dict[str, Any] | SBQueryAdvertisingDealRequest
+    ) -> SBAdvertisingDealSuccessResponse | dict[str, Any]:
+        if isinstance(body, dict):
+            body = SBQueryAdvertisingDealRequest(**body)
+        return await self._query(body, "/adsApi/v1/query/advertisingDeals/sb", SBAdvertisingDealSuccessResponse)
+
+    async def update(
+        self, items: list[dict[str, Any] | SBAdvertisingDealUpdate]
+    ) -> SBAdvertisingDealMultiStatusResponse | dict[str, Any]:
+        return await self._update(items, self._spec, SBAdvertisingDealMultiStatusResponse)
+
+    async def delete(self, ids: list[str]) -> SBAdvertisingDealMultiStatusResponse | dict[str, Any]:
+        return await self._delete(ids, self._spec, SBAdvertisingDealMultiStatusResponse)

async_amazon_ads_api_v1/client/sb/branded_keywords_pricings.py

@@ -0,0 +1,24 @@
+"""SB BrandedKeywordsPricing resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBBrandedKeywordsPricingCreate,
+    SBBrandedKeywordsPricingMultiStatusResponse,
+)
+
+
+class BrandedKeywordsPricings(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="brandedKeywordsPricings",
+        create_model=SBBrandedKeywordsPricingCreate,
+        path_suffix="/sb",
+    )
+
+    async def create(
+        self, items: list[dict[str, Any] | SBBrandedKeywordsPricingCreate]
+    ) -> SBBrandedKeywordsPricingMultiStatusResponse | dict[str, Any]:
+        return await self._create(items, self._spec, SBBrandedKeywordsPricingMultiStatusResponse)

async_amazon_ads_api_v1/client/sb/campaigns.py

@@ -0,0 +1,41 @@
+"""SB Campaign resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBCampaignCreate,
+    SBCampaignMultiStatusResponse,
+    SBCampaignSuccessResponse,
+    SBCampaignUpdate,
+    SBQueryCampaignRequest,
+)
+
+
+class Campaigns(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="campaigns",
+        create_model=SBCampaignCreate,
+        update_model=SBCampaignUpdate,
+        delete_key="campaignIds",
+    )
+
+    async def create(
+        self, campaigns: list[dict[str, Any] | SBCampaignCreate]
+    ) -> SBCampaignMultiStatusResponse | dict[str, Any]:
+        return await self._create(campaigns, self._spec, SBCampaignMultiStatusResponse)
+
+    async def query(self, body: dict[str, Any] | SBQueryCampaignRequest) -> SBCampaignSuccessResponse | dict[str, Any]:
+        if isinstance(body, dict):
+            body = SBQueryCampaignRequest(**body)
+        return await self._query(body, "/adsApi/v1/query/campaigns", SBCampaignSuccessResponse)
+
+    async def update(
+        self, campaigns: list[dict[str, Any] | SBCampaignUpdate]
+    ) -> SBCampaignMultiStatusResponse | dict[str, Any]:
+        return await self._update(campaigns, self._spec, SBCampaignMultiStatusResponse)
+
+    async def delete(self, campaign_ids: list[str]) -> SBCampaignMultiStatusResponse | dict[str, Any]:
+        return await self._delete(campaign_ids, self._spec, SBCampaignMultiStatusResponse)

async_amazon_ads_api_v1/client/sb/keyword_reservation_validations.py

@@ -0,0 +1,24 @@
+"""SB KeywordReservationValidation resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBKeywordReservationValidationCreate,
+    SBKeywordReservationValidationMultiStatusResponse,
+)
+
+
+class KeywordReservationValidations(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="keywordReservationValidations",
+        create_model=SBKeywordReservationValidationCreate,
+        path_suffix="/sb",
+    )
+
+    async def create(
+        self, items: list[dict[str, Any] | SBKeywordReservationValidationCreate]
+    ) -> SBKeywordReservationValidationMultiStatusResponse | dict[str, Any]:
+        return await self._create(items, self._spec, SBKeywordReservationValidationMultiStatusResponse)

async_amazon_ads_api_v1/client/sb/recommendation_types.py

@@ -0,0 +1,26 @@
+"""SB RecommendationType resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBQueryRecommendationTypeRequest,
+    SBRecommendationTypeSuccessResponse,
+)
+
+
+class RecommendationTypes(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="recommendationTypes",
+        create_model=SBRecommendationTypeSuccessResponse,
+        path_suffix="/sb",
+    )
+
+    async def query(
+        self, body: dict[str, Any] | SBQueryRecommendationTypeRequest
+    ) -> SBRecommendationTypeSuccessResponse | dict[str, Any]:
+        if isinstance(body, dict):
+            body = SBQueryRecommendationTypeRequest(**body)
+        return await self._query(body, "/adsApi/v1/query/recommendationTypes/sb", SBRecommendationTypeSuccessResponse)

async_amazon_ads_api_v1/client/sb/recommendations.py

@@ -0,0 +1,24 @@
+"""SB Recommendation resource operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from async_amazon_ads_api_v1._base import _ResourceBase, _ResourceSpec
+from async_amazon_ads_api_v1.models.sb import (
+    SBRecommendationCreate,
+    SBRecommendationMultiStatusResponse,
+)
+
+
+class Recommendations(_ResourceBase):
+    _spec = _ResourceSpec(
+        name="recommendations",
+        create_model=SBRecommendationCreate,
+        path_suffix="/sb",
+    )
+
+    async def create(
+        self, items: list[dict[str, Any] | SBRecommendationCreate]
+    ) -> SBRecommendationMultiStatusResponse | dict[str, Any]:
+        return await self._create(items, self._spec, SBRecommendationMultiStatusResponse)