Renamed exceptions

Author: sergioteula

amazon_paapi/api.py

@@ -7,7 +7,7 @@
 from typing import List, Union
 
 from . import models
-from .errors import InvalidArgumentException
+from .errors import InvalidArgument
 from .helpers import arguments, requests
 from .helpers.generators import get_list_chunks
 from .helpers.items import sort_items
@@ -50,7 +50,7 @@ def __init__(
             self.region = models.regions.REGIONS[country]
             self.marketplace = "www.amazon." + models.regions.DOMAINS[country]
         except KeyError as error:
-            raise InvalidArgumentException("Country code is not correct") from error
+            raise InvalidArgument("Country code is not correct") from error
 
         self.api = DefaultApi(key, secret, self._host, self.region)
 

amazon_paapi/errors/__init__.py

@@ -1,23 +1,23 @@
 from .exceptions import (
-    AmazonException,
-    ApiRequestException,
-    AsinNotFoundException,
-    AssociateValidationException,
-    InvalidArgumentException,
-    InvalidPartnerTagException,
-    ItemsNotFoundException,
-    MalformedRequestException,
-    TooManyRequestsException,
+    AmazonError,
+    AsinNotFound,
+    AssociateValidationError,
+    InvalidArgument,
+    InvalidPartnerTag,
+    ItemsNotFound,
+    MalformedRequest,
+    RequestError,
+    TooManyRequests,
 )
 
 __all__ = [
-    "AmazonException",
-    "ApiRequestException",
-    "AsinNotFoundException",
-    "AssociateValidationException",
-    "InvalidArgumentException",
-    "InvalidPartnerTagException",
-    "ItemsNotFoundException",
-    "MalformedRequestException",
-    "TooManyRequestsException",
+    "AmazonError",
+    "AsinNotFound",
+    "AssociateValidationError",
+    "InvalidArgument",
+    "InvalidPartnerTag",
+    "ItemsNotFound",
+    "MalformedRequest",
+    "RequestError",
+    "TooManyRequests",
 ]

amazon_paapi/errors/exceptions.py

@@ -1,7 +1,7 @@
 """Custom exceptions module"""
 
 
-class AmazonException(Exception):
+class AmazonError(Exception):
     """Common base class for all Amazon API exceptions."""
 
     def __init__(self, reason: str):
@@ -12,33 +12,33 @@ def __str__(self) -> str:
         return self.reason
 
 
-class InvalidArgumentException(AmazonException):
-    """Raised when arguments are not correct."""
+class AsinNotFound(AmazonError):
+    """Raised if the ASIN for an item is not found."""
 
 
-class AsinNotFoundException(AmazonException):
-    """Raised if the ASIN for an item is not found."""
+class AssociateValidationError(AmazonError):
+    """Raised when credentials are not valid for the selected country."""
 
 
-class ApiRequestException(AmazonException):
-    """Raised if the request to Amazon API fails"""
+class InvalidArgument(AmazonError):
+    """Raised when arguments are not correct."""
 
 
-class MalformedRequestException(AmazonException):
-    """Raised if the request for Amazon API is not correctly formed"""
+class InvalidPartnerTag(AmazonError):
+    """Raised if the partner tag is not present or invalid."""
 
 
-class ItemsNotFoundException(AmazonException):
-    """Raised if no items are found"""
+class ItemsNotFound(AmazonError):
+    """Raised if no items are found."""
 
 
-class TooManyRequestsException(AmazonException):
-    """Raised when requests limit is reached"""
+class MalformedRequest(AmazonError):
+    """Raised if the request for Amazon API is not correctly formed."""
 
 
-class InvalidPartnerTagException(AmazonException):
-    """Raised if the partner tag is not present or invalid"""
+class RequestError(AmazonError):
+    """Raised if the request to Amazon API fails."""
 
 
-class AssociateValidationException(AmazonException):
-    """Raised when credentials are not valid for the selected country"""
+class TooManyRequests(AmazonError):
+    """Raised when requests limit is reached."""

amazon_paapi/helpers/arguments.py

@@ -3,13 +3,13 @@
 
 from typing import List, Union
 
-from ..errors import AsinNotFoundException, InvalidArgumentException
+from ..errors import AsinNotFound, InvalidArgument
 from ..tools import get_asin
 
 
 def get_items_ids(items: Union[str, List[str]]) -> List[str]:
     if not isinstance(items, str) and not isinstance(items, List):
-        raise InvalidArgumentException(
+        raise InvalidArgument(
             "Invalid items argument, it should be a string or List of strings"
         )
 
@@ -23,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 AsinNotFound("No ASIN codes have been found.")
 
 
 def check_search_args(**kwargs):
@@ -47,7 +47,7 @@ def _check_search_mandatory_args(**kwargs):
             "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)
+        raise InvalidArgument(error_message)
 
 
 def _check_search_pagination_args(**kwargs):
@@ -56,10 +56,10 @@ def _check_search_pagination_args(**kwargs):
     pagination_args = [arg for arg in pagination_args if arg]
 
     if not all(isinstance(arg, int) for arg in pagination_args):
-        raise InvalidArgumentException(error_message)
+        raise InvalidArgument(error_message)
 
     if not all(1 <= arg <= 10 for arg in pagination_args):
-        raise InvalidArgumentException(error_message)
+        raise InvalidArgument(error_message)
 
 
 def check_variations_args(**kwargs):
@@ -70,13 +70,13 @@ def check_variations_args(**kwargs):
     variation_args = [arg for arg in variation_args if arg]
 
     if not all(isinstance(arg, int) for arg in variation_args):
-        raise InvalidArgumentException(error_message)
+        raise InvalidArgument(error_message)
 
     if not all(1 <= arg <= 10 for arg in variation_args):
-        raise InvalidArgumentException(error_message)
+        raise InvalidArgument(error_message)
 
 
 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."
-        raise InvalidArgumentException(error_message)
+        raise InvalidArgument(error_message)

amazon_paapi/helpers/requests.py

@@ -5,12 +5,12 @@
 from typing import List
 
 from ..errors import (
-    ApiRequestException,
-    AssociateValidationException,
-    InvalidArgumentException,
-    ItemsNotFoundException,
-    MalformedRequestException,
-    TooManyRequestsException,
+    AssociateValidationError,
+    InvalidArgument,
+    ItemsNotFound,
+    MalformedRequest,
+    RequestError,
+    TooManyRequests,
 )
 from ..models.browse_nodes_result import BrowseNode
 from ..models.item_result import Item
@@ -39,7 +39,7 @@ def get_items_request(amazon_api, asin_chunk: List[str], **kwargs) -> GetItemsRe
             **kwargs,
         )
     except TypeError as exc:
-        raise MalformedRequestException(
+        raise MalformedRequest(
             f"Parameters for get_items request are not correct: {exc}"
         ) from exc
 
@@ -51,7 +51,7 @@ def get_items_response(amazon_api, request: GetItemsRequest) -> List[Item]:
         _manage_response_exceptions(exc)
 
     if response.items_result is None:
-        raise ItemsNotFoundException("No items have been found")
+        raise ItemsNotFound("No items have been found")
 
     return response.items_result.items
 
@@ -66,7 +66,7 @@ def get_search_items_request(amazon_api, **kwargs) -> SearchItemsRequest:
             **kwargs,
         )
     except TypeError as exc:
-        raise MalformedRequestException(
+        raise MalformedRequest(
             f"Parameters for search_items request are not correct: {exc}"
         ) from exc
 
@@ -78,7 +78,7 @@ def get_search_items_response(amazon_api, request: SearchItemsRequest) -> Search
         _manage_response_exceptions(exc)
 
     if response.search_result is None:
-        raise ItemsNotFoundException("No items have been found")
+        raise ItemsNotFound("No items have been found")
 
     return response.search_result
 
@@ -93,7 +93,7 @@ def get_variations_request(amazon_api, **kwargs) -> GetVariationsRequest:
             **kwargs,
         )
     except TypeError as exc:
-        raise MalformedRequestException(
+        raise MalformedRequest(
             f"Parameters for get_variations request are not correct: {exc}"
         ) from exc
 
@@ -107,7 +107,7 @@ def get_variations_response(
         _manage_response_exceptions(exc)
 
     if response.variations_result is None:
-        raise ItemsNotFoundException("No variation items have been found")
+        raise ItemsNotFound("No variation items have been found")
 
     return response.variations_result
 
@@ -122,7 +122,7 @@ def get_browse_nodes_request(amazon_api, **kwargs) -> GetBrowseNodesRequest:
             **kwargs,
         )
     except TypeError as exc:
-        raise MalformedRequestException(
+        raise MalformedRequest(
             f"Parameters for get_browse_nodes request are not correct: {exc}"
         ) from exc
 
@@ -136,7 +136,7 @@ def get_browse_nodes_response(
         _manage_response_exceptions(exc)
 
     if response.browse_nodes_result is None:
-        raise ItemsNotFoundException("No browse nodes have been found")
+        raise ItemsNotFound("No browse nodes have been found")
 
     return response.browse_nodes_result.browse_nodes
 
@@ -152,23 +152,23 @@ def _get_request_resources(resources) -> List[str]:
 def _manage_response_exceptions(error) -> None:
     if isinstance(error, ApiException):
         if error.status == 429:
-            raise TooManyRequestsException(
+            raise TooManyRequests(
                 "Requests limit reached, try increasing throttling or wait before"
                 " trying again"
             )
 
         if "InvalidParameterValue" in error.body:
-            raise InvalidArgumentException(
+            raise InvalidArgument(
                 "The value provided in the request for atleast one parameter is"
                 " invalid."
             )
 
         if "InvalidPartnerTag" in error.body:
-            raise InvalidArgumentException("The partner tag is invalid or not present.")
+            raise InvalidArgument("The partner tag is invalid or not present.")
 
         if "InvalidAssociate" in error.body:
-            raise AssociateValidationException(
+            raise AssociateValidationError(
                 "Used credentials are not valid for the selected country."
             )
 
-    raise ApiRequestException("Request failed: " + str(error.reason))
+    raise RequestError("Request failed: " + str(error.reason))

amazon_paapi/tools/asin.py

@@ -2,7 +2,7 @@
 
 import re
 
-from ..errors import AsinNotFoundException
+from ..errors import AsinNotFound
 
 
 def get_asin(text: str) -> str:
@@ -16,4 +16,4 @@ def get_asin(text: str) -> str:
     if asin:
         return asin.group(2).upper()
 
-    raise AsinNotFoundException("Asin not found: " + text)
+    raise AsinNotFound("Asin not found: " + text)

tests/test_helpers_arguments.py

@@ -1,6 +1,6 @@
 import unittest
 
-from amazon_paapi.errors import AsinNotFoundException, InvalidArgumentException
+from amazon_paapi.errors import AsinNotFound, InvalidArgument
 from amazon_paapi.helpers.arguments import get_items_ids
 
 
@@ -22,9 +22,9 @@ def test_get_items_ids(self):
         )
 
     def test_get_items_ids_asin_not_found(self):
-        with self.assertRaises(AsinNotFoundException):
+        with self.assertRaises(AsinNotFound):
             get_items_ids("https://www.amazon.es/gp/")
 
     def test_get_items_ids_invalid_argument(self):
-        with self.assertRaises(InvalidArgumentException):
+        with self.assertRaises(InvalidArgument):
             get_items_ids(34)

tests/test_tools.py

@@ -1,6 +1,6 @@
 import unittest
 
-from amazon_paapi.errors import AsinNotFoundException
+from amazon_paapi.errors import AsinNotFound
 from amazon_paapi.tools import get_asin
 
 
@@ -28,8 +28,8 @@ def test_get_asin(self):
         )
 
     def test_asin_not_found(self):
-        with self.assertRaises(AsinNotFoundException):
+        with self.assertRaises(AsinNotFound):
             get_asin("https://www.amazon.es/gp/")
 
-        with self.assertRaises(AsinNotFoundException):
+        with self.assertRaises(AsinNotFound):
             get_asin("this is not even a URL")