python-amazon-sp-api 1.7.5__py3-none-any.whl → 2.0.10__py3-none-any.whl

sp_api/base/sales_enum.py

@@ -2,22 +2,20 @@ from enum import Enum
 
 
 class Granularity(str, Enum):
-    HOUR = 'Hour'
-    DAY = 'Day'
-    WEEK = 'Week'
-    MONTH = 'Month'
-    YEAR = 'Year'
-    TOTAL = 'Total'
+    HOUR = "Hour"
+    DAY = "Day"
+    WEEK = "Week"
+    MONTH = "Month"
+    YEAR = "Year"
+    TOTAL = "Total"
 
 
 class BuyerType(str, Enum):
-    B2B = 'B2B' # doc: Business to business.
-    B2C = 'B2C' # doc: Business to customer.
-    ALL = 'All' # doc: Both of above
+    B2B = "B2B"  # doc: Business to business.
+    B2C = "B2C"  # doc: Business to customer.
+    ALL = "All"  # doc: Both of above
 
 
 class FirstDayOfWeek(str, Enum):
-    MO = 'Monday'
-    SU = 'Sunday'
-
-
+    MO = "Monday"
+    SU = "Sunday"

sp_api/util/__init__.py

@@ -2,12 +2,48 @@ 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,
+)
+from .products_definitions import (
+    CompetitiveSummaryIncludedData,
+    ItemOffersRequest,
+    GetItemOffersBatchRequest,
+    ListingOffersRequest,
+    GetListingOffersBatchRequest,
+    FeaturedOfferExpectedPriceRequest,
+    GetFeaturedOfferExpectedPriceBatch,
+    CompetitiveSummaryRequest,
+    GetCompetitiveSummaryBatch,
+)
 
 __all__ = [
-    'retry',
-    'sp_retry',
-    'throttle_retry',
-    'load_all_pages',
-    'KeyMaker',
-    'load_date_bound'
+    "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",
+    "CompetitiveSummaryIncludedData",
+    "ItemOffersRequest",
+    "GetItemOffersBatchRequest",
+    "ListingOffersRequest",
+    "GetListingOffersBatchRequest",
+    "FeaturedOfferExpectedPriceRequest",
+    "GetFeaturedOfferExpectedPriceBatch",
+    "CompetitiveSummaryRequest",
+    "GetCompetitiveSummaryBatch",
 ]

sp_api/util/key_maker.py

@@ -72,5 +72,7 @@ class KeyMaker:
 
     @staticmethod
     def _replace_dash(key):
-        return key[0].lower() + ''.join(
-            word.title() if i > 0 else word for i, word in enumerate(re.sub(r'[-\s]', '_', key[1:]).split('_')))
+        return key[0].lower() + "".join(
+            word.title() if i > 0 else word
+            for i, word in enumerate(re.sub(r"[-\s]", "_", key[1:]).split("_"))
+        )

sp_api/util/load_all_pages.py

@@ -7,9 +7,13 @@ def make_sleep_time(rate_limit, use_rate_limit_header, throttle_by_seconds):
     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):
+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
 
@@ -18,6 +22,7 @@ def load_all_pages(throttle_by_seconds: float = 2, next_token_param='NextToken',
         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 a generator, returning all pages
     """
@@ -29,12 +34,18 @@ def load_all_pages(throttle_by_seconds: float = 2, next_token_param='NextToken',
             done = False
             while not done:
                 res = function(*args, **kwargs)
+
                 yield res
                 if res.next_token:
-                    sleep_time = make_sleep_time(res.rate_limit, use_rate_limit_header, throttle_by_seconds)
+                    sleep_time = make_sleep_time(
+                        res.rate_limit, use_rate_limit_header, throttle_by_seconds
+                    )
                     if sleep_time > 0:
                         time.sleep(sleep_time)
-                    kwargs.update({next_token_param: res.next_token, **extras})
+                    if next_token_only:
+                        kwargs = {next_token_param: res.next_token}
+                    else:
+                        kwargs.update({next_token_param: res.next_token, **extras})
                 else:
                     done = True
 

sp_api/util/load_date_bound.py

@@ -17,20 +17,35 @@ def load_date_bound(interval_days: int = 30):
 
     def decorator(function):
         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']:
+            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 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)
-                })
+                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

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)

sp_api/util/product_fees.py

@@ -0,0 +1,40 @@
+def create_fees_body(
+    *,
+    price,
+    shipping_price=None,
+    currency="USD",
+    is_fba=False,
+    identifier=None,
+    points=None,
+    marketplace_id=None,
+    optional_fulfillment_program=None,
+    id_type=None,
+    id_value=None,
+):
+    body = {
+        "FeesEstimateRequest": {
+            "Identifier": identifier or str(price),
+            "PriceToEstimateFees": {
+                "ListingPrice": {"Amount": price, "CurrencyCode": currency},
+                "Shipping": (
+                    {"Amount": shipping_price, "CurrencyCode": currency}
+                    if shipping_price
+                    else None
+                ),
+                "Points": points or None,
+            },
+            "IsAmazonFulfilled": is_fba,
+            "OptionalFulfillmentProgram": (
+                optional_fulfillment_program
+                if is_fba is True and optional_fulfillment_program
+                else None
+            ),
+            "MarketplaceId": marketplace_id,
+        }
+    }
+
+    if id_type and id_value:
+        body["IdType"] = id_type
+        body["IdValue"] = id_value
+
+    return body

sp_api/util/products_definitions.py

@@ -0,0 +1,169 @@
+from enum import Enum
+from typing import Optional, List, Dict, Union
+from dataclasses import dataclass, asdict
+
+
+class CompetitiveSummaryIncludedData(Enum):
+    FEATURED_BUYING_OPTIONS = "featuredBuyingOptions"
+    LOWEST_PRICED_OFFERS = "lowestPricedOffers"
+    REFERENCE_PRICES = "referencePrices"
+
+
+@dataclass
+class ItemOffersRequest:
+    """Implements definition: https://developer-docs.amazon.com/sp-api/docs/product-pricing-api-v0-reference
+    #itemoffersrequest"""
+
+    uri: str
+    method: str
+    MarketplaceId: str
+    ItemCondition: str = None
+    CustomerType: str = None
+    headers: Dict = None
+
+
+@dataclass
+class GetItemOffersBatchRequest:
+    """Implements definition: https://developer-docs.amazon.com/sp-api/docs/product-pricing-api-v0-reference
+    #getitemoffersbatchrequest"""
+
+    requests: Optional[List[Union[ItemOffersRequest, Dict]]] = None
+
+    def __post_init__(self):
+        self.requests = self.parse_requests(self.requests)
+
+    def to_dict(self):
+        return asdict(self)
+
+    @staticmethod
+    def parse_requests(requests) -> List[ItemOffersRequest]:
+        parsed_requestes = []
+
+        for request in requests:
+            if isinstance(request, Dict):
+                request = ItemOffersRequest(**request)
+
+            if not isinstance(request, ItemOffersRequest):
+                raise TypeError
+
+            parsed_requestes.append(request)
+
+        return parsed_requestes
+
+
+@dataclass
+class ListingOffersRequest:
+    """Implements definition: https://developer-docs.amazon.com/sp-api/docs/product-pricing-api-v0-reference
+    #listingoffersrequest"""
+
+    uri: str
+    MarketplaceId: str
+    ItemCondition: str
+    method: str = "GET"
+    CustomerType: str = "Consumer"
+
+
+@dataclass
+class GetListingOffersBatchRequest:
+    """Implements definition: https://developer-docs.amazon.com/sp-api/docs/product-pricing-api-v0-reference
+    #getlistingoffersbatchrequest"""
+
+    requests: Optional[List[Union[ListingOffersRequest, Dict]]] = None
+
+    def __post_init__(self):
+        self.requests = self.parse_requests(self.requests)
+
+    def to_dict(self):
+        return asdict(self)
+
+    @staticmethod
+    def parse_requests(requests) -> List[ListingOffersRequest]:
+        parsed_requestes = []
+
+        for request in requests:
+            if isinstance(request, Dict):
+                request = ListingOffersRequest(**request)
+
+            if not isinstance(request, ListingOffersRequest):
+                raise TypeError
+
+            parsed_requestes.append(request)
+
+        return parsed_requestes
+
+
+@dataclass
+class FeaturedOfferExpectedPriceRequest:
+    """ Implements definition: https://developer-docs.amazon.com/sp-api/docs/product-pricing-api-v2022-05-01-reference
+        #FeaturedOfferExpectedPriceRequest """
+    marketplaceId: str
+    sku: str
+    uri: str = "/products/pricing/2022-05-01/offer/featuredOfferExpectedPrice"
+    method: str = "GET"
+
+
+@dataclass
+class GetFeaturedOfferExpectedPriceBatch:
+    """ Implements definition: https://developer-docs.amazon.com/sp-api/docs/product-pricing-api-v2022-05-01-reference
+        #getFeaturedOfferExpectedPriceBatch """
+    requests: Optional[List[Union[FeaturedOfferExpectedPriceRequest, Dict]]] = None
+
+    def __post_init__(self):
+        self.requests = self.parse_requests(self.requests)
+
+    def to_dict(self):
+        return asdict(self)
+
+    @staticmethod
+    def parse_requests(requests) -> List[FeaturedOfferExpectedPriceRequest]:
+        parsed_requests = []
+
+        for request in requests:
+            if isinstance(request, Dict):
+                request = FeaturedOfferExpectedPriceRequest(**request)
+
+            if not isinstance(request, FeaturedOfferExpectedPriceRequest):
+                raise TypeError
+
+            parsed_requests.append(request)
+
+        return parsed_requests
+
+
+@dataclass
+class CompetitiveSummaryRequest:
+    """ Implements definition: https://developer-docs.amazon.com/sp-api/docs/product-pricing-api-v2022-05-01-reference
+        #FeaturedOfferExpectedPriceRequest """
+    marketplaceId: str
+    asin: str
+    includedData: List[CompetitiveSummaryIncludedData]
+    uri: str = "/products/pricing/2022-05-01/items/competitiveSummary"
+    method: str = "GET"
+
+
+@dataclass
+class GetCompetitiveSummaryBatch:
+    """ Implements definition: https://developer-docs.amazon.com/sp-api/docs/product-pricing-api-v2022-05-01-reference
+        #getCompetitiveSummary """
+    requests: Optional[List[Union[CompetitiveSummaryRequest, Dict]]] = None
+
+    def __post_init__(self):
+        self.requests = self.parse_requests(self.requests)
+
+    def to_dict(self):
+        return asdict(self)
+
+    @staticmethod
+    def parse_requests(requests) -> List[CompetitiveSummaryRequest]:
+        parsed_requests = []
+
+        for request in requests:
+            if isinstance(request, Dict):
+                request = CompetitiveSummaryRequest(**request)
+
+            if not isinstance(request, CompetitiveSummaryRequest):
+                raise TypeError
+
+            parsed_requests.append(request)
+
+        return parsed_requests

sp_api/util/report_document.py

@@ -0,0 +1,154 @@
+import codecs
+import zlib
+from io import BytesIO, StringIO
+
+
+def resolve_character_code(response_encoding, fallback="iso-8859-1"):
+    character_code = response_encoding or fallback
+    if character_code and character_code.lower() == "windows-31j":
+        character_code = "cp932"
+    return character_code
+
+
+def decompress_bytes(document, compression_algorithm):
+    if compression_algorithm:
+        return zlib.decompress(bytearray(document), 15 + 32)
+    return document
+
+
+def decode_document(document, character_code):
+    if character_code:
+        try:
+            return document.decode(character_code)
+        except Exception:
+            return document
+    return document
+
+
+def handle_file(file, document, encoding):
+    if isinstance(file, str):
+        with open(file, "w+", encoding=encoding) as text_file:
+            text_file.write(document)
+    elif isinstance(file, BytesIO):
+        file.write(document.encode(encoding))
+        file.seek(0)
+    elif isinstance(file, StringIO):
+        file.write(document)
+        file.seek(0)
+    else:
+        file.write(document)
+
+
+def _open_stream_target(file, encoding):
+    if isinstance(file, str):
+        return open(file, "w+", encoding=encoding), True, True
+    if isinstance(file, StringIO):
+        return file, True, False
+    if isinstance(file, BytesIO):
+        return file, False, False
+    if hasattr(file, "mode") and "b" in file.mode:
+        return file, False, False
+    return file, True, False
+
+
+def _stream_bytes_to_target_sync(
+    chunk_iter, file, encoding, compression_algorithm, close_after
+):
+    decompressor = zlib.decompressobj(15 + 32) if compression_algorithm else None
+    target, is_text, should_close = file
+    decoder = (
+        codecs.getincrementaldecoder(encoding)(errors="replace") if is_text else None
+    )
+    try:
+        for chunk in chunk_iter:
+            if decompressor:
+                chunk = decompressor.decompress(chunk)
+            if decoder:
+                text = decoder.decode(chunk)
+                if text:
+                    target.write(text)
+            else:
+                target.write(chunk)
+        if decompressor:
+            remainder = decompressor.flush()
+            if remainder:
+                if decoder:
+                    text = decoder.decode(remainder)
+                    if text:
+                        target.write(text)
+                else:
+                    target.write(remainder)
+        if decoder:
+            tail = decoder.decode(b"", final=True)
+            if tail:
+                target.write(tail)
+    finally:
+        if close_after and should_close:
+            target.close()
+
+
+async def _stream_bytes_to_target_async(
+    chunk_iter, file, encoding, compression_algorithm, close_after
+):
+    decompressor = zlib.decompressobj(15 + 32) if compression_algorithm else None
+    target, is_text, should_close = file
+    decoder = (
+        codecs.getincrementaldecoder(encoding)(errors="replace") if is_text else None
+    )
+    try:
+        async for chunk in chunk_iter:
+            if decompressor:
+                chunk = decompressor.decompress(chunk)
+            if decoder:
+                text = decoder.decode(chunk)
+                if text:
+                    target.write(text)
+            else:
+                target.write(chunk)
+        if decompressor:
+            remainder = decompressor.flush()
+            if remainder:
+                if decoder:
+                    text = decoder.decode(remainder)
+                    if text:
+                        target.write(text)
+                else:
+                    target.write(remainder)
+        if decoder:
+            tail = decoder.decode(b"", final=True)
+            if tail:
+                target.write(tail)
+    finally:
+        if close_after and should_close:
+            target.close()
+
+
+def _iter_response_bytes_sync(response):
+    if hasattr(response, "iter_content"):
+        return response.iter_content(chunk_size=8192)
+    if hasattr(response, "iter_bytes"):
+        return response.iter_bytes()
+    return response.iter_content(chunk_size=8192)
+
+
+def stream_to_file_sync(response, file, encoding, compression_algorithm):
+    target = _open_stream_target(file, encoding)
+    _stream_bytes_to_target_sync(
+        _iter_response_bytes_sync(response),
+        target,
+        encoding,
+        compression_algorithm,
+        True,
+    )
+
+
+async def stream_to_file_async(response, file, encoding, compression_algorithm):
+    target = _open_stream_target(file, encoding)
+
+    await _stream_bytes_to_target_async(
+        response.aiter_bytes(),
+        target,
+        encoding,
+        compression_algorithm,
+        True,
+    )

sp_api/util/retry.py

@@ -20,31 +20,28 @@ def retry(exception_classes=None, tries=10, delay=5, rate=1.3):
     if exception_classes is None:
         exception_classes = (Exception,)
 
-    tries_counter = {
-        'count': 1,
-        'last_delay': delay
-    }
+    tries_counter = {"count": 1, "last_delay": delay}
 
     def decorator(function):
         def wrapper(*args, **kwargs):
             try:
                 return function(*args, **kwargs)
             except exception_classes as e:
-                if tries_counter.get('count') + 1 > tries:
+                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
-                })
+                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}
+                )
                 time.sleep(delay_now)
                 return wrapper(*args, **kwargs)
             finally:
-                tries_counter.update({
-                    'count': 1,
-                    'last_delay': delay
-                })
+                tries_counter.update({"count": 1, "last_delay": delay})
 
         wrapper.__doc__ = function.__doc__
         return wrapper
@@ -67,6 +64,7 @@ def sp_retry(exception_classes=(), tries=10, delay=5, rate=1.3):
 
     """
     from sp_api.base import SellingApiException
+
     return retry((SellingApiException,) + exception_classes, tries, delay, rate)
 
 
@@ -85,4 +83,7 @@ def throttle_retry(exception_classes=(), tries=10, delay=5, rate=1.3):
 
     """
     from sp_api.base import SellingApiRequestThrottledException
-    return retry((SellingApiRequestThrottledException,) + exception_classes, tries, delay, rate)
+
+    return retry(
+        (SellingApiRequestThrottledException,) + exception_classes, tries, delay, rate
+    )