Formatted code using black

Author: sergioteula

amazon_paapi/__init__.py

@@ -1,6 +1,6 @@
 """Amazon Product Advertising API wrapper for Python"""
 
-__author__ = 'Sergio Abad'
+__author__ = "Sergio Abad"
 
 from .api import AmazonApi
 from .tools import get_asin

amazon_paapi/api.py

@@ -64,7 +64,6 @@ def get_items(
         include_unavailable: bool = False,
         **kwargs
     ) -> List[models.Item]:
-
         """Get items information from Amazon.
 
         Args:

amazon_paapi/errors/exceptions.py

@@ -3,43 +3,58 @@
 
 class AmazonException(Exception):
     """Common base class for all Amazon API exceptions."""
+
     def __init__(self, reason: str):
         super().__init__()
         self.reason = reason
 
     def __str__(self) -> str:
-        return '%s' % self.reason
+        return "%s" % self.reason
 
 
 class InvalidArgumentException(AmazonException):
     """Raised when arguments are not correct."""
+
     pass
 
 
 class AsinNotFoundException(AmazonException):
     """Raised if the ASIN for an item is not found."""
+
     pass
 
+
 class ApiRequestException(AmazonException):
     """Raised if the request to Amazon API fails"""
+
     pass
 
+
 class MalformedRequestException(AmazonException):
     """Raised if the request for Amazon API is not correctly formed"""
+
     pass
 
+
 class ItemsNotFoundException(AmazonException):
     """Raised if no items are found"""
+
     pass
 
+
 class TooManyRequestsException(AmazonException):
     """Raised when requests limit is reached"""
+
     pass
 
+
 class InvalidPartnerTagException(AmazonException):
     """Raised if the partner tag is not present or invalid"""
+
     pass
 
+
 class AssociateValidationException(AmazonException):
     """Raised when credentials are not valid for the selected country"""
+
     pass

amazon_paapi/helpers/arguments.py

@@ -9,10 +9,12 @@
 
 def get_items_ids(items: Union[str, List[str]]) -> List[str]:
     if not isinstance(items, str) and not isinstance(items, List):
-        raise InvalidArgumentException('Invalid items argument, it should be a string or List of strings')
+        raise InvalidArgumentException(
+            "Invalid items argument, it should be a string or List of strings"
+        )
 
     if isinstance(items, str):
-        items_ids = items.split(',')
+        items_ids = items.split(",")
         items_ids = [get_asin(x.strip()) for x in items_ids]
 
     else:
@@ -21,7 +23,7 @@ def get_items_ids(items: Union[str, List[str]]) -> List[str]:
     if items_ids:
         return items_ids
 
-    raise AsinNotFoundException('No ASIN codes have been found.')
+    raise AsinNotFoundException("No ASIN codes have been found.")
 
 
 def check_search_args(**kwargs):
@@ -30,18 +32,27 @@ def check_search_args(**kwargs):
 
 
 def _check_search_mandatory_args(**kwargs):
-    mandatory_args = [kwargs['keywords'], kwargs['actor'], kwargs['artist'],
-                      kwargs['author'], kwargs['brand'], kwargs['title'],
-                      kwargs['browse_node_id'], kwargs['search_index']]
+    mandatory_args = [
+        kwargs["keywords"],
+        kwargs["actor"],
+        kwargs["artist"],
+        kwargs["author"],
+        kwargs["brand"],
+        kwargs["title"],
+        kwargs["browse_node_id"],
+        kwargs["search_index"],
+    ]
     if all(arg is None for arg in mandatory_args):
-        error_message = ('At least one of the following args should be provided: '
-                         'keywords, actor, artist, author, brand, title, browse_node_id or search_index.')
+        error_message = (
+            "At least one of the following args should be provided: keywords, actor,"
+            " artist, author, brand, title, browse_node_id or search_index."
+        )
         raise InvalidArgumentException(error_message)
 
 
 def _check_search_pagination_args(**kwargs):
-    error_message = ('Args item_count and item_page should be integers between 1 and 10.')
-    pagination_args = [kwargs['item_count'], kwargs['item_page']]
+    error_message = "Args item_count and item_page should be integers between 1 and 10."
+    pagination_args = [kwargs["item_count"], kwargs["item_page"]]
     pagination_args = [arg for arg in pagination_args if arg]
 
     if not all(isinstance(arg, int) for arg in pagination_args):
@@ -52,8 +63,10 @@ def _check_search_pagination_args(**kwargs):
 
 
 def check_variations_args(**kwargs):
-    error_message = ('Args variation_count and variation_page should be integers between 1 and 10.')
-    variation_args = [kwargs['variation_count'], kwargs['variation_page']]
+    error_message = (
+        "Args variation_count and variation_page should be integers between 1 and 10."
+    )
+    variation_args = [kwargs["variation_count"], kwargs["variation_page"]]
     variation_args = [arg for arg in variation_args if arg]
 
     if not all(isinstance(arg, int) for arg in variation_args):
@@ -64,6 +77,6 @@ def check_variations_args(**kwargs):
 
 
 def check_browse_nodes_args(**kwargs):
-    if not isinstance(kwargs['browse_node_ids'], List):
-        error_message = 'Argument browse_node_ids should be a List of strings.'
+    if not isinstance(kwargs["browse_node_ids"], List):
+        error_message = "Argument browse_node_ids should be a List of strings."
         raise InvalidArgumentException(error_message)

amazon_paapi/helpers/generators.py

@@ -4,7 +4,9 @@
 from typing import Generator, List
 
 
-def get_list_chunks(full_list: List[str], chunk_size: int) -> Generator[List[str], None, None]:
+def get_list_chunks(
+    full_list: List[str], chunk_size: int
+) -> Generator[List[str], None, None]:
     """Yield successive chunks from List."""
     for i in range(0, len(full_list), chunk_size):
-        yield full_list[i:i + chunk_size]
+        yield full_list[i : i + chunk_size]

amazon_paapi/helpers/items.py

@@ -5,7 +5,9 @@
 from .. import models
 
 
-def sort_items(items: List[models.Item], items_ids: List[str], include_unavailable: bool) -> List[models.Item]:
+def sort_items(
+    items: List[models.Item], items_ids: List[str], include_unavailable: bool
+) -> List[models.Item]:
     sorted_items = []
 
     for asin in items_ids:

amazon_paapi/helpers/requests.py

@@ -30,14 +30,18 @@
 
 def get_items_request(amazon_api, asin_chunk: List[str], **kwargs) -> GetItemsRequest:
     try:
-        return GetItemsRequest(resources=_get_request_resources(GetItemsResource),
-                               partner_type=PartnerType.ASSOCIATES,
-                               marketplace=amazon_api._marketplace,
-                               partner_tag=amazon_api._tag,
-                               item_ids=asin_chunk,
-                               **kwargs)
+        return GetItemsRequest(
+            resources=_get_request_resources(GetItemsResource),
+            partner_type=PartnerType.ASSOCIATES,
+            marketplace=amazon_api._marketplace,
+            partner_tag=amazon_api._tag,
+            item_ids=asin_chunk,
+            **kwargs
+        )
     except TypeError as e:
-        raise MalformedRequestException('Parameters for get_items request are not correct: ' + str(e))
+        raise MalformedRequestException(
+            "Parameters for get_items request are not correct: " + str(e)
+        )
 
 
 def get_items_response(amazon_api, request: GetItemsRequest) -> List[Item]:
@@ -47,20 +51,24 @@ def get_items_response(amazon_api, request: GetItemsRequest) -> List[Item]:
         _manage_response_exceptions(e)
 
     if response.items_result == None:
-        raise ItemsNotFoundException('No items have been found')
+        raise ItemsNotFoundException("No items have been found")
 
     return response.items_result.items
 
 
 def get_search_items_request(amazon_api, **kwargs) -> SearchItemsRequest:
     try:
-        return SearchItemsRequest(resources=_get_request_resources(SearchItemsResource),
-                                  partner_type=PartnerType.ASSOCIATES,
-                                  marketplace=amazon_api._marketplace,
-                                  partner_tag=amazon_api._tag,
-                                  **kwargs)
+        return SearchItemsRequest(
+            resources=_get_request_resources(SearchItemsResource),
+            partner_type=PartnerType.ASSOCIATES,
+            marketplace=amazon_api._marketplace,
+            partner_tag=amazon_api._tag,
+            **kwargs
+        )
     except TypeError as e:
-        raise MalformedRequestException('Parameters for search_items request are not correct: ' + str(e))
+        raise MalformedRequestException(
+            "Parameters for search_items request are not correct: " + str(e)
+        )
 
 
 def get_search_items_response(amazon_api, request: SearchItemsRequest) -> SearchResult:
@@ -70,74 +78,97 @@ def get_search_items_response(amazon_api, request: SearchItemsRequest) -> Search
         _manage_response_exceptions(e)
 
     if response.search_result == None:
-        raise ItemsNotFoundException('No items have been found')
+        raise ItemsNotFoundException("No items have been found")
 
     return response.search_result
 
 
 def get_variations_request(amazon_api, **kwargs) -> GetVariationsRequest:
     try:
-        return GetVariationsRequest(resources=_get_request_resources(GetVariationsResource),
-                                    partner_type=PartnerType.ASSOCIATES,
-                                    marketplace=amazon_api._marketplace,
-                                    partner_tag=amazon_api._tag,
-                                    **kwargs)
+        return GetVariationsRequest(
+            resources=_get_request_resources(GetVariationsResource),
+            partner_type=PartnerType.ASSOCIATES,
+            marketplace=amazon_api._marketplace,
+            partner_tag=amazon_api._tag,
+            **kwargs
+        )
     except TypeError as e:
-        raise MalformedRequestException('Parameters for get_variations request are not correct: ' + str(e))
+        raise MalformedRequestException(
+            "Parameters for get_variations request are not correct: " + str(e)
+        )
 
 
-def get_variations_response(amazon_api, request: GetVariationsRequest) -> VariationsResult:
+def get_variations_response(
+    amazon_api, request: GetVariationsRequest
+) -> VariationsResult:
     try:
         response = amazon_api._api.get_variations(request)
     except ApiException as e:
         _manage_response_exceptions(e)
 
     if response.variations_result == None:
-        raise ItemsNotFoundException('No variation items have been found')
+        raise ItemsNotFoundException("No variation items have been found")
 
     return response.variations_result
 
 
 def get_browse_nodes_request(amazon_api, **kwargs) -> GetBrowseNodesRequest:
     try:
-        return GetBrowseNodesRequest(resources=_get_request_resources(GetBrowseNodesResource),
-                                    partner_type=PartnerType.ASSOCIATES,
-                                    marketplace=amazon_api._marketplace,
-                                    partner_tag=amazon_api._tag,
-                                    **kwargs)
+        return GetBrowseNodesRequest(
+            resources=_get_request_resources(GetBrowseNodesResource),
+            partner_type=PartnerType.ASSOCIATES,
+            marketplace=amazon_api._marketplace,
+            partner_tag=amazon_api._tag,
+            **kwargs
+        )
     except TypeError as e:
-        raise MalformedRequestException('Parameters for get_browse_nodes request are not correct: ' + str(e))
+        raise MalformedRequestException(
+            "Parameters for get_browse_nodes request are not correct: " + str(e)
+        )
 
 
-def get_browse_nodes_response(amazon_api, request: GetBrowseNodesRequest) -> List[BrowseNode]:
+def get_browse_nodes_response(
+    amazon_api, request: GetBrowseNodesRequest
+) -> List[BrowseNode]:
     try:
         response = amazon_api._api.get_browse_nodes(request)
     except ApiException as e:
         _manage_response_exceptions(e)
 
     if response.browse_nodes_result == None:
-        raise ItemsNotFoundException('No browse nodes have been found')
+        raise ItemsNotFoundException("No browse nodes have been found")
 
     return response.browse_nodes_result.browse_nodes
 
 
 def _get_request_resources(resources) -> List[str]:
-    resources = inspect.getmembers(resources, lambda a:not(inspect.isroutine(a)))
-    resources = [x[-1] for x in resources if isinstance(x[-1], str) and x[0][0:2] != '__']
+    resources = inspect.getmembers(resources, lambda a: not (inspect.isroutine(a)))
+    resources = [
+        x[-1] for x in resources if isinstance(x[-1], str) and x[0][0:2] != "__"
+    ]
     return resources
 
+
 def _manage_response_exceptions(error) -> None:
     if isinstance(error, ApiException):
         if error.status == 429:
-            raise TooManyRequestsException('Requests limit reached, try increasing throttling or wait before trying again')
-
-        elif 'InvalidParameterValue' in error.body:
-            raise InvalidArgumentException('The value provided in the request for atleast one parameter is invalid.')
-
-        elif 'InvalidPartnerTag' in error.body:
-            raise InvalidArgumentException('The partner tag is invalid or not present.')
-
-        elif 'InvalidAssociate' in error.body:
-            raise AssociateValidationException('Used credentials are not valid for the selected country.')
-
-    raise ApiRequestException('Request failed: ' + str(error.reason))
+            raise TooManyRequestsException(
+                "Requests limit reached, try increasing throttling or wait before"
+                " trying again"
+            )
+
+        elif "InvalidParameterValue" in error.body:
+            raise InvalidArgumentException(
+                "The value provided in the request for atleast one parameter is"
+                " invalid."
+            )
+
+        elif "InvalidPartnerTag" in error.body:
+            raise InvalidArgumentException("The partner tag is invalid or not present.")
+
+        elif "InvalidAssociate" in error.body:
+            raise AssociateValidationException(
+                "Used credentials are not valid for the selected country."
+            )
+
+    raise ApiRequestException("Request failed: " + str(error.reason))