python-amazon-sp-api 1.7.5__py3-none-any.whl → 2.0.10__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/__init__.py

@@ -3,7 +3,7 @@ from .access_token_response import AccessTokenResponse
 from .credentials import Credentials
 
 __all__ = [
-    'AccessTokenResponse',
-    'AccessTokenClient',
-    'Credentials',
+    "AccessTokenResponse",
+    "AccessTokenClient",
+    "Credentials",
 ]

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,17 +1,23 @@
 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=3200)
-grantless_cache = TTLCache(maxsize=int(os.environ.get('SP_API_AUTH_CACHE_SIZE', 10)), ttl=3200)
+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__)
 
@@ -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,39 +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')
-        ).hexdigest()
-
+        return build_cache_key(self.cred.refresh_token, token_flavor)

sp_api/auth/access_token_response.py

@@ -1,6 +1,6 @@
 class AccessTokenResponse:
     def __init__(self, **kwargs):
-        self.access_token = kwargs.get('access_token')
-        self.refresh_token = kwargs.get('refresh_token')
-        self.expires_in = kwargs.get('expires_in')
-        self.token_type = kwargs.get('token_type')
+        self.access_token = kwargs.get("access_token")
+        self.refresh_token = kwargs.get("refresh_token")
+        self.expires_in = kwargs.get("expires_in")
+        self.token_type = kwargs.get("token_type")

sp_api/base/ApiResponse.py

@@ -44,14 +44,15 @@ class ApiResponse:
         self.errors = errors
         self.pagination = pagination
         self.headers = headers
-        self.rate_limit = headers.get("x-amzn-RateLimit-Limit")
+        self.rate_limit = (headers or {}).get("x-amzn-RateLimit-Limit")
         try:
             self.next_token = (
                 nextToken
-                or self.payload.get('pagination', {}).get("nextToken", None)
+                or self.payload.get("pagination", {}).get("nextToken", None)
                 or self.payload.get("NextToken", None)
-                or self.pagination.get("nextToken", None)
-                or self.payload.get('nextPageToken', None)
+                or (self.pagination or {}).get("nextToken", None)
+                or self.payload.get("nextPageToken", None)
+                or self.payload.get("nextToken", None)
             )
 
         except AttributeError:

sp_api/base/__init__.py

@@ -1,6 +1,13 @@
 from .base_client import BaseClient
 from .client import Client
-from .helpers import fill_query_params, sp_endpoint, create_md5, nest_dict, _nest_dict_rec, deprecated
+from .helpers import (
+    fill_query_params,
+    sp_endpoint,
+    create_md5,
+    nest_dict,
+    _nest_dict_rec,
+    deprecated,
+)
 from .marketplaces import Marketplaces
 from .exceptions import SellingApiException
 from .exceptions import SellingApiBadRequestException
@@ -16,7 +23,11 @@ from .schedules import Schedules
 from .report_status import ReportStatus
 from .sales_enum import FirstDayOfWeek, Granularity, BuyerType
 from .fulfillment_channel import FulfillmentChannel
-from .included_data import IncludedData, ListingItemsIncludedData, CatalogItemsIncludedData
+from .included_data import (
+    IncludedData,
+    ListingItemsIncludedData,
+    CatalogItemsIncludedData,
+)
 from .notifications import NotificationType
 from .credential_provider import CredentialProvider, MissingCredentials
 from .ApiResponse import ApiResponse
@@ -30,44 +41,44 @@ from .marketplaces import AwsEnv
 
 
 __all__ = [
-    'Credentials',
-    'AuthorizationError',
-    'AccessTokenClient',
-    'ReportType',
-    'FeedType',
-    'ProcessingStatus',
-    'ApiResponse',
-    'Client',
-    'BaseClient',
-    'Marketplaces',
-    'fill_query_params',
-    'sp_endpoint',
-    'SellingApiException',
-    'SellingApiBadRequestException',
-    'SellingApiNotFoundException',
-    'SellingApiServerException',
-    'SellingApiForbiddenException',
-    'SellingApiBadRequestException',
-    'SellingApiRequestThrottledException',
-    'SellingApiTemporarilyUnavailableException',
-    'SellingApiTooLargeException',
-    'SellingApiStateConflictException',
-    'SellingApiUnsupportedFormatException',
-    'Schedules',
-    'ReportStatus',
-    'FirstDayOfWeek',
-    'Granularity',
-    'BuyerType',
-    'FulfillmentChannel',
-    'deprecated',
-    'NotificationType',
-    'CredentialProvider',
-    'MissingCredentials',
-    'nest_dict',
-    '_nest_dict_rec',
-    'IneligibilityReasonList',
-    'IncludedData',
-    'ListingItemsIncludedData',
-    'CatalogItemsIncludedData',
-    'AwsEnv'
+    "Credentials",
+    "AuthorizationError",
+    "AccessTokenClient",
+    "ReportType",
+    "FeedType",
+    "ProcessingStatus",
+    "ApiResponse",
+    "Client",
+    "BaseClient",
+    "Marketplaces",
+    "fill_query_params",
+    "sp_endpoint",
+    "SellingApiException",
+    "SellingApiBadRequestException",
+    "SellingApiNotFoundException",
+    "SellingApiServerException",
+    "SellingApiForbiddenException",
+    "SellingApiBadRequestException",
+    "SellingApiRequestThrottledException",
+    "SellingApiTemporarilyUnavailableException",
+    "SellingApiTooLargeException",
+    "SellingApiStateConflictException",
+    "SellingApiUnsupportedFormatException",
+    "Schedules",
+    "ReportStatus",
+    "FirstDayOfWeek",
+    "Granularity",
+    "BuyerType",
+    "FulfillmentChannel",
+    "deprecated",
+    "NotificationType",
+    "CredentialProvider",
+    "MissingCredentials",
+    "nest_dict",
+    "_nest_dict_rec",
+    "IneligibilityReasonList",
+    "IncludedData",
+    "ListingItemsIncludedData",
+    "CatalogItemsIncludedData",
+    "AwsEnv",
 ]

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/base_client.py

@@ -2,7 +2,7 @@ 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__}'
+    scheme = "https://"
+    method = "GET"
+    content_type = "application/x-www-form-urlencoded;charset=UTF-8"
+    user_agent = f"python-sp-api-{__version__}"