python-amazon-sp-api 1.9.60__py3-none-any.whl → 2.0.3__py3-none-any.whl

sp_api/asyncio/util/retry.py

@@ -0,0 +1,88 @@
+import asyncio
+
+
+def retry(exception_classes=None, tries=10, delay=5, rate=1.3):
+    """
+    retry(exception_classes=None, tries=10, delay=5, rate=1.3)
+
+    Retry a call against an endpoint <tries> time
+
+    Args:
+        exception_classes: tuple | The Exceptions to be caught
+        tries: int | How often the call should be retried
+        delay: float | The delay after an error was caught
+        rate: float | The rate to increment delay by
+
+    Returns:
+
+    """
+    if exception_classes is None:
+        exception_classes = (Exception,)
+
+    tries_counter = {"count": 1, "last_delay": delay}
+
+    def decorator(function):
+        async def wrapper(*args, **kwargs):
+            try:
+                return await function(*args, **kwargs)
+            except exception_classes as e:
+                if tries_counter.get("count") + 1 > tries:
+                    raise e
+
+                delay_now = (
+                    delay
+                    if tries_counter.get("count") == 1
+                    else tries_counter.get("last_delay") * rate
+                )
+                tries_counter.update(
+                    {"count": tries_counter.get("count") + 1, "last_delay": delay_now}
+                )
+                await asyncio.sleep(delay_now)
+                return await wrapper(*args, **kwargs)
+            finally:
+                tries_counter.update({"count": 1, "last_delay": delay})
+
+        wrapper.__doc__ = function.__doc__
+        return wrapper
+
+    return decorator
+
+
+def sp_retry(exception_classes=(), tries=10, delay=5, rate=1.3):
+    """
+    This is a shorthand for retry that catches all exceptions thrown by this library
+
+    Retry a call against an endpoint <tries> time
+    Args:
+        exception_classes:
+        tries:
+        delay:
+        rate:
+
+    Returns:
+
+    """
+    from sp_api.base import SellingApiException
+
+    return retry((SellingApiException,) + exception_classes, tries, delay, rate)
+
+
+def throttle_retry(exception_classes=(), tries=10, delay=5, rate=1.3):
+    """
+    This is a shorthand for retry that catches SellingApiRequestThrottledException
+
+    Retry a call against an endpoint <tries> time
+    Args:
+        exception_classes:
+        tries:
+        delay:
+        rate:
+
+    Returns:
+
+    """
+    from sp_api.base import SellingApiRequestThrottledException
+
+    return retry(
+        (SellingApiRequestThrottledException,) + exception_classes, tries, delay, rate
+    )

sp_api/auth/_core.py

@@ -0,0 +1,39 @@
+import hashlib
+
+
+def build_cache_key(refresh_token, token_flavor=""):
+    return "access_token_" + hashlib.md5(
+        (token_flavor + (refresh_token or "__grantless__")).encode("utf-8"),
+        usedforsecurity=False,
+    ).hexdigest()
+
+
+def build_refresh_token_data(credentials, grant_type):
+    return {
+        "grant_type": grant_type,
+        "client_id": credentials.client_id,
+        "refresh_token": credentials.refresh_token,
+        "client_secret": credentials.client_secret,
+    }
+
+
+def build_grantless_data(credentials, scope_value):
+    return {
+        "grant_type": "client_credentials",
+        "client_id": credentials.client_id,
+        "scope": scope_value,
+        "client_secret": credentials.client_secret,
+    }
+
+
+def build_auth_code_request_body(credentials, auth_code):
+    return {
+        "grant_type": "authorization_code",
+        "code": auth_code,
+        "client_id": credentials.client_id,
+        "client_secret": credentials.client_secret,
+    }
+
+
+def build_headers(user_agent, content_type):
+    return {"User-Agent": user_agent, "content-type": content_type}

sp_api/auth/access_token_client.py

@@ -1,14 +1,20 @@
 import os
 
-import requests
-import hashlib
 import logging
 from cachetools import TTLCache
 from sp_api.base import BaseClient
+from sp_api.base._transport_httpx import HttpxTransport
 
 from .credentials import Credentials
 from .access_token_response import AccessTokenResponse
 from .exceptions import AuthorizationError
+from ._core import (
+    build_auth_code_request_body,
+    build_cache_key,
+    build_grantless_data,
+    build_headers,
+    build_refresh_token_data,
+)
 
 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)))
@@ -25,9 +31,13 @@ class AccessTokenClient(BaseClient):
         self.cred = Credentials(refresh_token, credentials)
         self.proxies = proxies
         self.verify = verify
+        self._transport = HttpxTransport(
+            proxies=proxies,
+            verify=verify,
+        )
 
     def _request(self, url, data, headers):
-        response = requests.post(url, data=data, headers=headers, proxies=self.proxies, verify=self.verify)
+        response = 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')
@@ -93,40 +103,18 @@ class AccessTokenClient(BaseClient):
         return res
 
     def _auth_code_request_body(self, auth_code):
-        return {
-            'grant_type': 'authorization_code',
-            'code': auth_code,
-            'client_id': self.cred.client_id,
-            'client_secret': self.cred.client_secret
-        }
+        return build_auth_code_request_body(self.cred, auth_code)
 
     def grantless_data(self, scope_value: str):
-        return {
-            'grant_type': 'client_credentials',
-            'client_id': self.cred.client_id,
-            'scope': scope_value,
-            'client_secret': self.cred.client_secret
-        }
+        return build_grantless_data(self.cred, scope_value)
 
     @property
     def data(self):
-        return {
-            'grant_type': self.grant_type,
-            'client_id': self.cred.client_id,
-            'refresh_token': self.cred.refresh_token,
-            'client_secret': self.cred.client_secret
-        }
+        return build_refresh_token_data(self.cred, self.grant_type)
 
     @property
     def headers(self):
-        return {
-            'User-Agent': self.user_agent,
-            'content-type': self.content_type
-        }
+        return build_headers(self.user_agent, self.content_type)
 
     def _get_cache_key(self, token_flavor=''):
-        return 'access_token_' + hashlib.md5(
-            (token_flavor + (self.cred.refresh_token or '__grantless__')).encode('utf-8'),
-            usedforsecurity=False
-        ).hexdigest()
-
+        return build_cache_key(self.cred.refresh_token, token_flavor)

sp_api/base/_core.py

@@ -0,0 +1,110 @@
+import json
+from datetime import datetime
+from json import JSONDecodeError
+
+from .ApiResponse import ApiResponse
+from .exceptions import get_exception_for_code
+
+
+def resolve_method(params, data):
+    if params is None:
+        params = {}
+    if data is None:
+        data = {}
+    method = params.pop(
+        "method", data.pop("method", "GET") if isinstance(data, dict) else "GET"
+    )
+    return method, params, data
+
+
+def check_version(path, version):
+    if "<version>" not in path:
+        return path
+    return path.replace("<version>", version)
+
+
+def add_marketplaces(method, marketplace_id, data):
+    post_keys = ["marketplaceIds", "MarketplaceIds"]
+    get_keys = ["MarketplaceId", "MarketplaceIds", "marketplace_ids", "marketplaceIds"]
+
+    if method == "POST":
+        if any(key in data.keys() for key in post_keys):
+            return
+        data.update(
+            {
+                key: marketplace_id if not key.endswith("s") else [marketplace_id]
+                for key in post_keys
+            }
+        )
+        return
+    if any(key in data.keys() for key in get_keys):
+        return
+    data.update(
+        {
+            key: marketplace_id if not key.endswith("s") else [marketplace_id]
+            for key in get_keys
+        }
+    )
+
+
+def build_headers(endpoint, user_agent, access_token, content_type="application/json"):
+    return {
+        "host": endpoint[8:],
+        "user-agent": user_agent,
+        "x-amz-access-token": access_token,
+        "x-amz-date": datetime.utcnow().strftime("%Y%m%dT%H%M%SZ"),
+        "content-type": content_type,
+    }
+
+
+def prepare_request(
+    *,
+    method,
+    endpoint,
+    path,
+    params,
+    data,
+    headers,
+    add_marketplace,
+    marketplace_id,
+    version,
+):
+    if add_marketplace:
+        add_marketplaces(method, marketplace_id, data if method in ("POST", "PUT") else params)
+    url = endpoint + check_version(path, version)
+    content = (
+        json.dumps(data) if data and method in ("POST", "PUT", "PATCH") else None
+    )
+    return {
+        "method": method,
+        "url": url,
+        "params": params,
+        "content": content,
+        "headers": headers,
+    }
+
+
+def parse_response(res, *, method, res_no_data=False, bulk=False, wrap_list=False):
+    if (method == "DELETE" or res_no_data) and 200 <= res.status_code < 300:
+        try:
+            js = res.json() or {}
+        except JSONDecodeError:
+            js = {"status_code": res.status_code}
+    else:
+        try:
+            js = res.json() or {}
+        except JSONDecodeError:
+            js = {}
+
+    if isinstance(js, list):
+        if wrap_list:
+            js = dict(payload=js)
+        else:
+            js = js[0]
+
+    error = js.get("errors", None)
+    if error:
+        exception = get_exception_for_code(res.status_code)
+        raise exception(error, headers=res.headers)
+
+    return ApiResponse(**js, headers=res.headers)

sp_api/base/_transport_httpx.py

@@ -0,0 +1,39 @@
+import httpx
+
+
+class HttpxTransport:
+    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.Client(
+            timeout=timeout,
+            proxy=proxy_config,
+            verify=verify,
+        )
+
+    def request(self, method, url, *, params=None, data=None, content=None, headers=None):
+        return self._client.request(
+            method,
+            url,
+            params=params,
+            data=data,
+            content=content,
+            headers=headers,
+        )
+
+    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,
+        )
+
+    def close(self):
+        self._client.close()

sp_api/base/client.py

@@ -1,18 +1,15 @@
-import hashlib
-import json
 from datetime import datetime
 import logging
 import os
 
-from requests import request
-from requests.exceptions import JSONDecodeError
-
 from sp_api.auth import AccessTokenClient, AccessTokenResponse
 from .ApiResponse import ApiResponse
 from .base_client import BaseClient
-from .exceptions import get_exception_for_code, MissingScopeException
+from .exceptions import MissingScopeException
 from .marketplaces import Marketplaces
 from sp_api.base.credential_provider import CredentialProvider
+from ._core import prepare_request, parse_response, resolve_method
+from ._transport_httpx import HttpxTransport
 
 log = logging.getLogger(__name__)
 log.setLevel(logging.INFO)  # Set default to DEBUG; users can override externally
@@ -63,6 +60,11 @@ class Client(BaseClient):
         self.timeout = timeout
         self.version = version
         self.verify = verify
+        self._transport = HttpxTransport(
+            timeout=timeout,
+            proxies=proxies,
+            verify=verify,
+        )
 
     @property
     def headers(self):
@@ -96,40 +98,32 @@ class Client(BaseClient):
         bulk: bool = False,
         wrap_list: bool = False,
     ) -> ApiResponse:
-        if params is None:
-            params = {}
-        if data is None:
-            data = {}
-
-        # Note: The use of isinstance here is to support request schemas that are an array at the
-        # top level, eg get_product_fees_estimate
-        self.method = params.pop(
-            "method", data.pop("method", "GET") if isinstance(data, dict) else "GET"
-        )
+        method, params, data = resolve_method(params, data)
+        self.method = method
 
-        if add_marketplace:
-            self._add_marketplaces(data if self.method in ("POST", "PUT") else params)
+        request_headers = headers or self.headers
 
-        log.debug("HTTP Method: %s", self.method)
+        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 self.method in ("POST", "PUT", "PATCH") else None)
-        log.debug("Request Headers: %s", headers or self.headers)
+        log.debug(
+            "Request Data: %s",
+            data if method in ("POST", "PUT", "PATCH") else None,
+        )
+        log.debug("Request Headers: %s", request_headers)
 
-        res = request(
-            self.method,
-            self.endpoint + self._check_version(path),
+        prepared = prepare_request(
+            method=method,
+            endpoint=self.endpoint,
+            path=path,
             params=params,
-            data=(
-                json.dumps(data)
-                if data and self.method in ("POST", "PUT", "PATCH")
-                else None
-            ),
-            headers=headers or self.headers,
-            timeout=self.timeout,
-            proxies=self.proxies,
-            verify=self.verify,
+            data=data,
+            headers=request_headers,
+            add_marketplace=add_marketplace,
+            marketplace_id=self.marketplace_id,
+            version=self.version,
         )
+        res = self._transport.request(**prepared)
         return self._check_response(res, res_no_data, bulk, wrap_list)
 
     def _check_response(
@@ -139,36 +133,15 @@ class Client(BaseClient):
         bulk: bool = False,
         wrap_list: bool = False,
     ) -> ApiResponse:
-        if (self.method == "DELETE" or res_no_data) and 200 <= res.status_code < 300:
-            try:
-                js = res.json() or {}
-            except JSONDecodeError:
-                js = {"status_code": res.status_code}
-        else:
-            try:
-                js = res.json() or {}
-            except JSONDecodeError:
-                js = {}
-
-        log.debug("Response before list handling: %s", js)
-
-
-        if isinstance(js, list):
-            if wrap_list:
-                # Support responses that are an array at the top level, eg get_product_fees_estimate
-                js = dict(payload=js)
-            else:
-                js = js[0]
-
-        error = js.get("errors", None)
-
-        if error:
-            log.error("Error Response: %s", error)
-            exception = get_exception_for_code(res.status_code)
-            raise exception(error, headers=res.headers)
-
-        log.debug("Response: %s", js)
-        return ApiResponse(**js, headers=res.headers)
+        response = parse_response(
+            res,
+            method=self.method,
+            res_no_data=res_no_data,
+            bulk=bulk,
+            wrap_list=wrap_list,
+        )
+        log.debug("Response: %s", response)
+        return response
 
     def _add_marketplaces(self, data):
         POST = ["marketplaceIds", "MarketplaceIds"]
@@ -196,6 +169,9 @@ class Client(BaseClient):
             }
         )
 
+    def close(self):
+        self._transport.close()
+
     def _request_grantless_operation(
         self, path: str, *, data: dict = None, params: dict = None
     ):
@@ -225,3 +201,4 @@ class Client(BaseClient):
     def __exit__(self, *args, **kwargs):
         self.restricted_data_token = None
         self.keep_restricted_data_token = False
+        self.close()

sp_api/util/__init__.py

@@ -2,6 +2,15 @@ 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 .params import (
+    normalize_csv_param,
+    normalize_included_data,
+    normalize_marketplace_ids,
+    normalize_datetime_kwargs,
+    encode_kwarg,
+    should_add_marketplace,
+    ensure_csv,
+)
 
 __all__ = [
     "retry",
@@ -10,4 +19,11 @@ __all__ = [
     "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/util/params.py

@@ -0,0 +1,57 @@
+from collections import abc
+from datetime import datetime
+
+
+def to_csv(value, mapper=None):
+    if value and isinstance(value, abc.Iterable) and not isinstance(value, str):
+        if mapper:
+            value = [mapper(item) for item in value]
+        return ",".join(value)
+    return value
+
+
+def normalize_csv_param(kwargs, key, mapper=None):
+    if key in kwargs:
+        value = to_csv(kwargs.get(key), mapper)
+        if value is not None:
+            kwargs[key] = value
+    return kwargs
+
+
+def normalize_included_data(kwargs, enum_cls=None, key="includedData"):
+    def mapper(value):
+        if enum_cls and isinstance(value, enum_cls):
+            return value.value
+        return value
+
+    return normalize_csv_param(kwargs, key, mapper)
+
+
+def normalize_marketplace_ids(kwargs, marketplace_cls=None, key="marketplaceIds"):
+    def mapper(value):
+        if marketplace_cls and isinstance(value, marketplace_cls):
+            return value.marketplace_id
+        return value
+
+    return normalize_csv_param(kwargs, key, mapper)
+
+
+def normalize_datetime_kwargs(kwargs, keys):
+    for key in keys:
+        if isinstance(kwargs.get(key), datetime):
+            kwargs[key] = kwargs.get(key).isoformat()
+    return kwargs
+
+
+def encode_kwarg(kwargs, key, encoder):
+    if key in kwargs:
+        kwargs[key] = encoder(kwargs.pop(key))
+    return kwargs
+
+
+def should_add_marketplace(kwargs, token_key="nextToken"):
+    return token_key not in kwargs
+
+
+def ensure_csv(value, mapper=None):
+    return to_csv(value, mapper)