python-amazon-sp-api 1.9.18__py3-none-any.whl → 2.0.7__py3-none-any.whl

sp_api/asyncio/api/vendor_transaction_status/vendor_transaction_status.py

@@ -0,0 +1,41 @@
+import urllib.parse
+
+from sp_api.base import Client, sp_endpoint, fill_query_params, ApiResponse
+from sp_api.asyncio.base import AsyncBaseClient
+
+
+class VendorTransactionStatus(AsyncBaseClient):
+    """
+    VendorTransactionStatus SP-API Client
+    :link:
+
+    The Selling Partner API for Retail Procurement Transaction Status provides programmatic access to status information on specific asynchronous POST transactions for vendors.
+    """
+
+    @sp_endpoint("/vendor/transactions/v1/transactions/{}", method="GET")
+    async def get_transaction(self, transactionId, **kwargs) -> ApiResponse:
+        """
+        get_transaction(self, transactionId, **kwargs) -> ApiResponse
+
+        Returns the status of the transaction that you specify.
+
+        **Usage Plans:**
+
+        ======================================  ==============
+        Rate (requests per second)               Burst
+        ======================================  ==============
+        10                                      10
+        ======================================  ==============
+
+        The x-amzn-RateLimit-Limit response header returns the usage plan rate limits that were applied to the requested operation. Rate limits for some selling partners will vary from the default rate and burst shown in the table above. For more information, see "Usage Plans and Rate Limits" in the Selling Partner API documentation.
+
+        Args:
+            transactionId:string | * REQUIRED The GUID provided by Amazon in the 'transactionId' field in response to the post request of a specific transaction.
+
+        Returns:
+            ApiResponse:
+        """
+
+        return await self._request(
+            fill_query_params(kwargs.pop("path"), transactionId), params=kwargs
+        )

sp_api/asyncio/auth/__init__.py

@@ -0,0 +1,12 @@
+from sp_api.auth.access_token_response import AccessTokenResponse
+from sp_api.auth.credentials import Credentials
+from sp_api.auth.exceptions import AuthorizationError
+
+from .access_token_client import AccessTokenClient
+
+__all__ = [
+    "AccessTokenResponse",
+    "AccessTokenClient",
+    "AuthorizationError",
+    "Credentials",
+]

sp_api/asyncio/auth/access_token_client.py

@@ -0,0 +1,145 @@
+import asyncio
+import logging
+import os
+
+from cachetools import TTLCache
+
+from sp_api.auth.access_token_response import AccessTokenResponse
+from sp_api.auth.credentials import Credentials
+from sp_api.auth.exceptions import AuthorizationError
+from sp_api.auth._core import (
+    build_auth_code_request_body,
+    build_cache_key,
+    build_grantless_data,
+    build_headers,
+    build_refresh_token_data,
+)
+from sp_api.asyncio.base.base_client import BaseClient
+from sp_api.asyncio.base._transport_httpx import AsyncHttpxTransport
+
+cache = TTLCache(
+    maxsize=int(os.environ.get("SP_API_AUTH_CACHE_SIZE", 10)),
+    ttl=int(os.environ.get("SP_API_AUTH_CACHE_TTL", 3200)),
+)
+grantless_cache = TTLCache(
+    maxsize=int(os.environ.get("SP_API_AUTH_CACHE_SIZE", 10)),
+    ttl=int(os.environ.get("SP_API_AUTH_CACHE_TTL", 3200)),
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AccessTokenClient(BaseClient):
+    host = "api.amazon.com"
+    grant_type = "refresh_token"
+    path = "/auth/o2/token"
+
+    def __init__(self, refresh_token=None, credentials=None, proxies=None, verify=True):
+        self.cred = Credentials(refresh_token, credentials)
+        self.proxies = proxies
+        self.verify = verify
+        self._lock = asyncio.Lock()
+        self._transport = AsyncHttpxTransport(
+            proxies=proxies,
+            verify=verify,
+        )
+
+    async def _request(self, url, data, headers):
+        response = await self._transport.request(
+            "POST",
+            url,
+            data=data,
+            headers=headers,
+        )
+        response_data = response.json()
+        if response.status_code != 200:
+            error_message = response_data.get("error_description")
+            error_code = response_data.get("error")
+            raise AuthorizationError(error_code, error_message, response.status_code)
+        return response_data
+
+    async def get_auth(self) -> AccessTokenResponse:
+        """
+        Get's the access token
+        :return:AccessTokenResponse
+        """
+        cache_key = self._get_cache_key()
+        try:
+            access_token = cache[cache_key]
+        except KeyError:
+            async with self._lock:
+                try:
+                    access_token = cache[cache_key]
+                except KeyError:
+                    request_url = self.scheme + self.host + self.path
+                    access_token = await self._request(
+                        request_url,
+                        self.data,
+                        self.headers,
+                    )
+                    cache[cache_key] = access_token
+        return AccessTokenResponse(**access_token)
+
+    async def get_grantless_auth(self, scope="sellingpartnerapi::notifications"):
+        """
+        :param scope: One of allowed scope for grantless operations:
+            sellingpartnerapi::notifications or sellingpartnerapi::migration
+            See: https://github.com/amzn/selling-partner-api-docs/blob/main/guides/en-US/developer-guide/SellingPartnerApiDeveloperGuide.md#step-3-configure-your-lwa-credentials
+
+        POST /auth/o2/token HTTP/l.l
+        Host: api.amazon.com
+        Content-Type: application/x-www-form-urlencoded;charset=UTF-8
+        grant_type=client_credentials
+        &scope=sellingpartnerapi::notifications
+        &client_id=foodev
+        &client_secret=Y76SDl2F
+        :return: AccessTokenResponse
+        """
+        cache_key = self._get_cache_key(scope)
+        try:
+            access_token = grantless_cache[cache_key]
+            logger.debug("from_cache. scope: %s", scope)
+        except KeyError:
+            async with self._lock:
+                try:
+                    access_token = grantless_cache[cache_key]
+                except KeyError:
+                    request_url = self.scheme + self.host + self.path
+                    access_token = await self._request(
+                        request_url,
+                        data=self.grantless_data(scope),
+                        headers=self.headers,
+                    )
+                    logger.debug("token_refreshed")
+                    grantless_cache.clear()
+                    grantless_cache[cache_key] = access_token
+
+        return AccessTokenResponse(**access_token)
+
+    async def authorize_auth_code(self, auth_code):
+        request_url = self.scheme + self.host + self.path
+        return await self._request(
+            request_url,
+            data=self._auth_code_request_body(auth_code),
+            headers=self.headers,
+        )
+
+    def _auth_code_request_body(self, auth_code):
+        return build_auth_code_request_body(self.cred, auth_code)
+
+    def grantless_data(self, scope_value: str):
+        return build_grantless_data(self.cred, scope_value)
+
+    @property
+    def data(self):
+        return build_refresh_token_data(self.cred, self.grant_type)
+
+    @property
+    def headers(self):
+        return build_headers(self.user_agent, self.content_type)
+
+    def _get_cache_key(self, token_flavor=""):
+        return build_cache_key(self.cred.refresh_token, token_flavor)
+
+    async def aclose(self):
+        await self._transport.aclose()

sp_api/asyncio/auth/exceptions.py

@@ -0,0 +1,5 @@
+from sp_api.auth.exceptions import AuthorizationError
+
+__all__ = [
+    "AuthorizationError",
+]

sp_api/asyncio/base/__init__.py

@@ -0,0 +1,53 @@
+from .base_client import BaseClient
+from .client import Client
+
+AsyncBaseClient = Client
+
+from sp_api.base import (
+    Marketplaces,
+    ReportType,
+    FeedType,
+    ProcessingStatus,
+    Schedules,
+    ReportStatus,
+    FirstDayOfWeek,
+    Granularity,
+    BuyerType,
+    FulfillmentChannel,
+    NotificationType,
+    IncludedData,
+    ListingItemsIncludedData,
+    CatalogItemsIncludedData,
+    IneligibilityReasonList,
+    AwsEnv,
+)
+from sp_api.base.credential_provider import (
+    FromCodeCredentialProvider,
+    FromSecretsCredentialProvider,
+    FromCachedSecretsCredentialProvider,
+)
+
+__all__ = [
+    "Marketplaces",
+    "ReportType",
+    "FeedType",
+    "ProcessingStatus",
+    "Schedules",
+    "ReportStatus",
+    "FirstDayOfWeek",
+    "Granularity",
+    "BuyerType",
+    "FulfillmentChannel",
+    "NotificationType",
+    "IncludedData",
+    "ListingItemsIncludedData",
+    "CatalogItemsIncludedData",
+    "IneligibilityReasonList",
+    "AwsEnv",
+    "FromCodeCredentialProvider",
+    "FromSecretsCredentialProvider",
+    "FromCachedSecretsCredentialProvider",
+    "BaseClient",
+    "Client",
+    "AsyncBaseClient",
+]

sp_api/asyncio/base/_transport_httpx.py

@@ -0,0 +1,50 @@
+import httpx
+
+
+class AsyncHttpxTransport:
+    def __init__(
+        self, *, timeout=None, proxies=None, proxy=None, verify=True, client=None
+    ):
+        proxy_config = proxy if proxy is not None else proxies
+        self._client = client or httpx.AsyncClient(
+            timeout=timeout,
+            proxy=proxy_config,
+            verify=verify,
+        )
+
+    async def request(
+        self,
+        method,
+        url,
+        *,
+        params=None,
+        data=None,
+        content=None,
+        headers=None,
+        timeout=None,
+    ):
+        return await self._client.request(
+            method,
+            url,
+            params=params,
+            data=data,
+            content=content,
+            headers=headers,
+            timeout=timeout,
+        )
+
+    def stream(
+        self, method, url, *, params=None, data=None, content=None, headers=None, timeout=None
+    ):
+        return self._client.stream(
+            method,
+            url,
+            params=params,
+            data=data,
+            content=content,
+            headers=headers,
+            timeout=timeout,
+        )
+
+    async def aclose(self):
+        await self._client.aclose()

sp_api/asyncio/base/base_client.py

@@ -0,0 +1,8 @@
+from sp_api.__version__ import __version__
+
+
+class BaseClient:
+    scheme = "https://"
+    method = "GET"
+    content_type = "application/x-www-form-urlencoded;charset=UTF-8"
+    user_agent = f"python-sp-api-{__version__}"

sp_api/asyncio/base/client.py

@@ -0,0 +1,169 @@
+from datetime import datetime
+import logging
+import os
+
+from sp_api.auth import AccessTokenResponse
+from sp_api.base.ApiResponse import ApiResponse
+from sp_api.base.credential_provider import CredentialProvider
+from sp_api.base.marketplaces import Marketplaces
+from sp_api.base._core import parse_response, prepare_request, resolve_method
+
+from ._transport_httpx import AsyncHttpxTransport
+from .base_client import BaseClient
+from ..auth import AccessTokenClient
+from sp_api.base.exceptions import MissingScopeException
+
+log = logging.getLogger(__name__)
+log.setLevel(logging.INFO)  # Set default to DEBUG; users can override externally
+
+
+class Client(BaseClient):
+    grantless_scope: str = ""
+    keep_restricted_data_token: bool = False
+    version = None
+
+    def __init__(
+        self,
+        marketplace: Marketplaces = Marketplaces[
+            os.environ.get("SP_API_DEFAULT_MARKETPLACE", Marketplaces.US.name)
+        ],
+        *,
+        refresh_token=None,
+        account="default",
+        credentials=None,
+        restricted_data_token=None,
+        proxies=None,
+        verify=True,
+        timeout=None,
+        version=None,
+        credential_providers=None,
+        auth_token_client_class=AccessTokenClient,
+    ):
+        if os.environ.get("SP_API_DEFAULT_MARKETPLACE", None):
+            marketplace = Marketplaces[os.environ.get("SP_API_DEFAULT_MARKETPLACE")]
+        self.credentials = CredentialProvider(
+            account,
+            credentials,
+            credential_providers=credential_providers,
+        ).credentials
+
+        self.endpoint = marketplace.endpoint
+        self.marketplace_id = marketplace.marketplace_id
+        self.region = marketplace.region
+        self.restricted_data_token = restricted_data_token
+        self._auth = auth_token_client_class(
+            refresh_token=refresh_token,
+            credentials=self.credentials,
+            proxies=proxies,
+            verify=verify,
+        )
+        self.proxies = proxies
+        self.timeout = timeout
+        self.version = version
+        self.verify = verify
+        self._transport = AsyncHttpxTransport(
+            timeout=timeout,
+            proxies=proxies,
+            verify=verify,
+        )
+
+    async def _get_headers(self, access_token=None):
+        token = access_token or self.restricted_data_token
+        if token is None:
+            token = (await self.auth).access_token
+        return {
+            "host": self.endpoint[8:],
+            "user-agent": self.user_agent,
+            "x-amz-access-token": token,
+            "x-amz-date": datetime.utcnow().strftime("%Y%m%dT%H%M%SZ"),
+            "content-type": "application/json",
+        }
+
+    @property
+    async def auth(self) -> AccessTokenResponse:
+        return await self._auth.get_auth()
+
+    @property
+    async def grantless_auth(self) -> AccessTokenResponse:
+        if not self.grantless_scope:
+            raise MissingScopeException("Grantless operations require scope")
+        return await self._auth.get_grantless_auth(self.grantless_scope)
+
+    async def _request(
+        self,
+        path: str,
+        *,
+        data: dict = None,
+        params: dict = None,
+        headers=None,
+        add_marketplace=True,
+        res_no_data: bool = False,
+        bulk: bool = False,
+        wrap_list: bool = False,
+    ) -> ApiResponse:
+        method, params, data = resolve_method(params, data)
+        self.method = method
+
+        request_headers = headers or await self._get_headers()
+
+        log.debug("HTTP Method: %s", method)
+        log.debug("Making request to URL: %s", self.endpoint + self._check_version(path))
+        log.debug("Request Params: %s", params)
+        log.debug(
+            "Request Data: %s",
+            data if method in ("POST", "PUT", "PATCH") else None,
+        )
+        log.debug("Request Headers: %s", request_headers)
+
+        prepared = prepare_request(
+            method=method,
+            endpoint=self.endpoint,
+            path=path,
+            params=params,
+            data=data,
+            headers=request_headers,
+            add_marketplace=add_marketplace,
+            marketplace_id=self.marketplace_id,
+            version=self.version,
+        )
+        res = await self._transport.request(**prepared)
+        return parse_response(
+            res,
+            method=self.method,
+            res_no_data=res_no_data,
+            bulk=bulk,
+            wrap_list=wrap_list,
+        )
+
+    async def _request_grantless_operation(
+        self, path: str, *, data: dict = None, params: dict = None
+    ):
+        headers = await self._get_headers(
+            access_token=(await self.grantless_auth).access_token
+        )
+        log.debug("HTTP Method: %s", self.method)
+        log.debug("Making request to URL: %s", self.endpoint + self._check_version(path))
+        log.debug("Request Params: %s", params)
+        log.debug(
+            "Request Data: %s",
+            data if self.method in ("POST", "PUT", "PATCH") else None,
+        )
+        log.debug("Request Headers: %s", headers)
+        return await self._request(path, data=data, params=params, headers=headers)
+
+    def _check_version(self, path):
+        if "<version>" not in path:
+            return path
+        return path.replace("<version>", self.version)
+
+    async def __aenter__(self):
+        self.keep_restricted_data_token = True
+        return self
+
+    async def __aexit__(self, *args, **kwargs):
+        self.restricted_data_token = None
+        self.keep_restricted_data_token = False
+        await self.aclose()
+
+    async def aclose(self):
+        await self._transport.aclose()

sp_api/asyncio/util/__init__.py

@@ -0,0 +1,29 @@
+from .retry import retry, sp_retry, throttle_retry
+from .load_all_pages import load_all_pages
+from .key_maker import KeyMaker
+from .load_date_bound import load_date_bound
+from sp_api.util import (
+    normalize_csv_param,
+    normalize_included_data,
+    normalize_marketplace_ids,
+    normalize_datetime_kwargs,
+    encode_kwarg,
+    should_add_marketplace,
+    ensure_csv,
+)
+
+__all__ = [
+    "retry",
+    "sp_retry",
+    "throttle_retry",
+    "load_all_pages",
+    "KeyMaker",
+    "load_date_bound",
+    "normalize_csv_param",
+    "normalize_included_data",
+    "normalize_marketplace_ids",
+    "normalize_datetime_kwargs",
+    "encode_kwarg",
+    "should_add_marketplace",
+    "ensure_csv",
+]

sp_api/asyncio/util/key_maker.py

@@ -0,0 +1,5 @@
+from sp_api.util.key_maker import KeyMaker
+
+__all__ = [
+    "KeyMaker",
+]

sp_api/asyncio/util/load_all_pages.py

@@ -0,0 +1,55 @@
+import asyncio
+
+
+def make_sleep_time(rate_limit, use_rate_limit_header, throttle_by_seconds):
+    if use_rate_limit_header and rate_limit:
+        return 1 / float(rate_limit)
+    return throttle_by_seconds
+
+
+def load_all_pages(
+    throttle_by_seconds: float = 2,
+    next_token_param="NextToken",
+    use_rate_limit_header: bool = False,
+    extras: dict = None,
+    next_token_only: bool = False,
+):
+    """
+    Load all pages if a next token is returned
+
+    Args:
+        throttle_by_seconds: float
+        next_token_param: str | The param amazon expects to hold the next token
+        use_rate_limit_header: if the function should try to use amazon's rate limit header
+        extras: additional data to be sent with NextToken, e.g `dict(QueryType='NEXT_TOKEN')` for `FulfillmentInbound`
+        next_token_only: remove all other params from kwargs, required for reports API
+    Returns:
+        Transforms the function in an async generator, returning all pages
+    """
+    if not extras:
+        extras = {}
+
+    def decorator(function):
+        async def wrapper(*args, **kwargs):
+            done = False
+            while not done:
+                res = await function(*args, **kwargs)
+
+                yield res
+                if res.next_token:
+                    sleep_time = make_sleep_time(
+                        res.rate_limit, use_rate_limit_header, throttle_by_seconds
+                    )
+                    if sleep_time > 0:
+                        await asyncio.sleep(sleep_time)
+                    if next_token_only:
+                        kwargs = {next_token_param: res.next_token}
+                    else:
+                        kwargs.update({next_token_param: res.next_token, **extras})
+                else:
+                    done = True
+
+        wrapper.__doc__ = function.__doc__
+        return wrapper
+
+    return decorator

sp_api/asyncio/util/load_date_bound.py

@@ -0,0 +1,53 @@
+import datetime
+
+
+def load_date_bound(interval_days: int = 30):
+    def make_end_date(s: datetime, e: datetime, i: int):
+        end_date = s + datetime.timedelta(days=i)
+        if end_date > e:
+            return e
+        return end_date
+
+    def parse_if_needed(dt: datetime or str):
+        if isinstance(dt, datetime.datetime):
+            return dt
+        return datetime.datetime.fromisoformat(dt)
+
+    date_range = {}
+
+    def decorator(function):
+        async def wrapper(*args, **kwargs):
+            date_range.update(
+                {
+                    "dataStartTime": parse_if_needed(kwargs["dataStartTime"]),
+                    "dataEndTime": parse_if_needed(
+                        kwargs.get("dataEndTime", datetime.datetime.utcnow())
+                    ),
+                }
+            )
+            kwargs.update(
+                {
+                    "dataEndTime": make_end_date(
+                        date_range["dataStartTime"],
+                        date_range["dataEndTime"],
+                        interval_days,
+                    )
+                }
+            )
+            while kwargs["dataStartTime"] < kwargs["dataEndTime"]:
+                yield await function(*args, **kwargs)
+                kwargs.update(
+                    {
+                        "dataStartTime": parse_if_needed(kwargs["dataEndTime"]),
+                        "dataEndTime": make_end_date(
+                            parse_if_needed(kwargs["dataEndTime"]),
+                            date_range["dataEndTime"],
+                            interval_days,
+                        ),
+                    }
+                )
+
+        wrapper.__doc__ = function.__doc__
+        return wrapper
+
+    return decorator