paddle-python-sdk 0.1.1__tar.gz → 0.1.3__tar.gz

{paddle_python_sdk-0.1.1/paddle_python_sdk.egg-info → paddle_python_sdk-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: paddle-python-sdk
-Version: 0.1.1
+Version: 0.1.3
 Summary: Paddle's Python SDK for Paddle Billing
 Home-page: https://developer.paddle.com/api-reference/overview
 Author: Paddle and contributors

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/paddle_billing/Client.py

@@ -9,6 +9,7 @@ from uuid               import uuid4
 from paddle_billing.FiltersUndefined import FiltersUndefined
 from paddle_billing.HasParameters    import HasParameters
 from paddle_billing.Options          import Options
+from paddle_billing.ResponseParser   import ResponseParser
 
 from paddle_billing.Logger.NullHandler import NullHandler
 
@@ -133,8 +134,17 @@ class Client:
         except RequestException as e:
             self.status_code = e.response.status_code
 
+            api_error = None
+            if e.response is not None:
+                response_parser = ResponseParser(e.response)
+                api_error = response_parser.get_error()
+
             if self.log:
-                self.log.error(f"Request failed: {e}")
+                self.log.error(f"Request failed: {e}.{' ' + api_error.detail if api_error is not None else ''}")
+
+            if api_error is not None:
+                raise api_error
+
             raise
 
 
@@ -187,7 +197,7 @@ class Client:
             'Authorization':  f"Bearer {self.__api_key}",
             'Content-Type':   'application/json',
             'Paddle-Version': str(self.use_api_version),
-            'User-Agent':     'PaddleSDK/python 0.1.1',
+            'User-Agent':     'PaddleSDK/python 0.1.3',
         })
 
         # Configure retries

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/paddle_billing/Entities/Collections/NotificationSettingCollection.py

@@ -7,9 +7,9 @@ from paddle_billing.Entities.Collections.Paginator  import Paginator
 class NotificationSettingCollection(Collection):
     @classmethod
     def from_list(cls, items_data: list, paginator: Paginator | None = None) -> NotificationSettingCollection:
-        from paddle_billing.Entities.Notification import Notification
+        from paddle_billing.Entities.NotificationSetting import NotificationSetting
 
-        items: list[Notification] = [Notification.from_dict(item) for item in items_data]
+        items: list[NotificationSetting] = [NotificationSetting.from_dict(item) for item in items_data]
 
         return NotificationSettingCollection(items, paginator)
 

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/paddle_billing/Exceptions/ApiError.py

@@ -1,25 +1,27 @@
 from paddle_billing.Exceptions.FieldError import FieldError
 
+from requests import HTTPError
 
-class ApiError(Exception):
-    def __init__(self, error_type, error_code, detail, docs_url, *field_errors):
+class ApiError(HTTPError):
+    def __init__(self, response, error_type, error_code, detail, docs_url, *field_errors):
+        super().__init__(detail, response=response)
         self.error_type   = error_type
         self.error_code   = error_code
         self.detail       = detail
         self.docs_url     = docs_url
         self.field_errors = field_errors
-        super().__init__(self.detail)
 
 
     def __repr__(self):
-        return (f"ApiError(type='{self.error_type}', error_code='{self.error_code}', detail='{self.detail}', "
+        return (f"ApiError(error_type='{self.error_type}', error_code='{self.error_code}', detail='{self.detail}', "
                 f"docs_url='{self.docs_url}', field_errors={self.field_errors})")
 
 
     @classmethod
-    def from_error_data(cls, error):
+    def from_error_data(cls, response, error):
         field_errors = [FieldError(fe['field'], fe['message']) for fe in error.get('errors', [])]
         return cls(
+            response,
             error['type'],
             error['code'],
             error['detail'],

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/paddle_billing/ResponseParser.py

@@ -9,6 +9,8 @@ from paddle_billing.Exceptions.ApiError import ApiError
 class ResponseParser:
     def __init__(self, response: Response):
         self.body = None
+        self.error = None
+        self.response = response
 
         if not hasattr(response, 'text'):
             return
@@ -19,13 +21,17 @@ class ResponseParser:
             self.body = None
 
         if self.body and 'error' in self.body:
-            self.parse_errors()
+            self.error = self.parse_errors()
 
 
     def get_data(self) -> list | dict:
         return self.body.get('data', []) if self.body else []
 
 
+    def get_error(self) -> ApiError | None:
+        return self.error
+
+
     def get_pagination(self) -> Pagination:
         meta       = self.body.get('meta',  {}) if self.body  else {}
         pagination = meta.get('pagination', {}) if meta       else {}
@@ -38,15 +44,15 @@ class ResponseParser:
         )
 
 
-    def parse_errors(self):
+    def parse_errors(self) -> ApiError | None:
         if not self.body or 'error' not in self.body:
-            return
+            return None
 
         error           = self.body['error']
         code            = error.get('code', 'shared_error')
         exception_class = self.find_exception_class_from_code(code)
 
-        raise exception_class(error)
+        return exception_class.from_error_data(self.response, error)
 
 
     @staticmethod
@@ -57,7 +63,7 @@ class ResponseParser:
         if not resource:
             return ApiError
 
-        class_name = f"api_error.{resource}ApiError"
+        class_name = f"paddle_billing.Exceptions.ApiErrors.{resource}ApiError"
         try:
             module = __import__(class_name, fromlist=[''])
             return getattr(module, f'{resource}ApiError')

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3/paddle_python_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: paddle-python-sdk
-Version: 0.1.1
+Version: 0.1.3
 Summary: Paddle's Python SDK for Paddle Billing
 Home-page: https://developer.paddle.com/api-reference/overview
 Author: Paddle and contributors

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/paddle_python_sdk.egg-info/SOURCES.txt

@@ -473,7 +473,10 @@ paddle_python_sdk.egg-info/dependency_links.txt
 paddle_python_sdk.egg-info/requires.txt
 paddle_python_sdk.egg-info/top_level.txt
 tests/__init__.py
+tests/conftest.py
 tests/Functional/__init__.py
+tests/Functional/Client/__init__.py
+tests/Functional/Client/test_Client.py
 tests/Functional/Resources/__init__.py
 tests/Functional/Resources/Addresses/__init__.py
 tests/Functional/Resources/Addresses/test_AddressesClient.py
@@ -517,4 +520,5 @@ tests/Unit/PaddleStrEnum/test_PaddleStrEnum.py
 tests/Utils/FakeResponse.py
 tests/Utils/ReadsFixture.py
 tests/Utils/TestClient.py
+tests/Utils/TestLogger.py
 tests/Utils/__init__.py

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 
 setup(
-    version         = '0.1.1',
+    version         = '0.1.3',
 
     author          = 'Paddle and contributors',
     author_email    = 'team-dx@paddle.com',

paddle_python_sdk-0.1.3/tests/Functional/Client/test_Client.py

@@ -0,0 +1,138 @@
+from json         import loads, dumps
+from pytest       import mark, raises
+from urllib.parse import unquote
+
+from paddle_billing.Exceptions.ApiError                  import ApiError
+from paddle_billing.Exceptions.ApiErrors.AddressApiError import AddressApiError
+
+from requests.exceptions import RequestException, HTTPError
+
+from tests.Utils.TestLogger import test_log_handler, LogHandler
+
+
+class TestClient:
+    @mark.parametrize(
+        [
+            'expected_response_status',
+            'expected_reason',
+            'expected_response_body',
+            'expected_exception',
+        ],
+        [
+            (
+                400,
+                'Bad Request',
+                {
+                    "error": {
+                        "type": "request_error",
+                        "code": "bad_request",
+                        "detail": "Invalid request",
+                        "documentation_url": "https://developer.paddle.com/v1/errors/shared/bad_request",
+                        "errors": [
+                            {
+                                "field": "some_field",
+                                "message": "Some error message"
+                            }
+                        ]
+                    },
+                    "meta": {
+                        "request_id": "f00bb3ca-399d-4686-889c-50b028f4c912"
+                    }
+                },
+                ApiError
+            ),
+            (
+                404,
+                'Not Found',
+                {
+                    "error": {
+                        "type": "request_error",
+                        "code": "not_found",
+                        "detail": "Entity not found",
+                        "documentation_url": "https://developer.paddle.com/v1/errors/shared/not_found"
+                    },
+                    "meta": {
+                        "request_id": "f00bb3ca-399d-4686-889c-50b028f4c912"
+                    }
+                },
+                ApiError
+            ),
+            (
+                400,
+                'Bad Request',
+                {
+                    "error": {
+                        "type": "request_error",
+                        "code": "address_location_not_allowed",
+                        "detail": "Cannot create address with an unsupported location",
+                        "documentation_url": "https://developer.paddle.com/errors/addresses/address_location_not_allowed"
+                    },
+                    "meta": {
+                        "request_id": "f00bb3ca-399d-4686-889c-50b028f4c912"
+                    }
+                },
+                AddressApiError
+            ),
+        ],
+        ids=[
+            "Returns bad_request response",
+            "Returns not_found response",
+            "Returns address_location_not_allowed response",
+        ],
+    )
+    def test_post_raw_returns_error_response(
+        self,
+        test_client,
+        test_log_handler: LogHandler,
+        mock_requests,
+        expected_response_status,
+        expected_reason,
+        expected_response_body,
+        expected_exception
+    ):
+        expected_request_url = f"{test_client.base_url}/some/url"
+        expected_request_body = { "some_property": "some value" }
+        mock_requests.post(expected_request_url, status_code=expected_response_status, text=dumps(expected_response_body), reason=expected_reason)
+
+        with raises(expected_exception) as exception_info:
+            test_client.client.post_raw(expected_request_url, expected_request_body)
+
+        request_json = test_client.client.payload
+        last_request = mock_requests.last_request
+        api_error    = exception_info.value
+
+        assert unquote(last_request.url) == expected_request_url, \
+            "The URL does not match the expected URL, verify the query string is correct"
+
+        assert loads(request_json) == expected_request_body, \
+            "The request JSON doesn't match the expected fixture JSON"
+
+        assert isinstance(api_error, ApiError)
+        assert isinstance(api_error, HTTPError)
+        assert isinstance(api_error, RequestException)
+        assert api_error.response.status_code == expected_response_status, 'Unexpected status code'
+        assert api_error.error_type == expected_response_body['error']['type']
+        assert api_error.error_code == expected_response_body['error']['code']
+        assert api_error.detail == expected_response_body['error']['detail']
+        assert api_error.docs_url == expected_response_body['error']['documentation_url']
+
+        if 'errors' in expected_response_body['error']:
+            assert len(api_error.field_errors) == len(expected_response_body['error']['errors'])
+
+            for i, expected_field_error in enumerate(expected_response_body['error']['errors']):
+                assert api_error.field_errors[i].field == expected_field_error['field']
+                assert api_error.field_errors[i].error == expected_field_error['message']
+        else:
+            assert len(api_error.field_errors) == 0
+
+        assert str(api_error) == expected_response_body['error']['detail']
+        assert repr(api_error) == ("ApiError("
+            f"error_type='{api_error.error_type}', "
+            f"error_code='{api_error.error_code}', "
+            f"detail='{api_error.detail}', "
+            f"docs_url='{api_error.docs_url}', "
+            f"field_errors={api_error.field_errors}"
+            ")")
+
+        assert test_log_handler.get_logs()[0].message == \
+            f"Request failed: {expected_response_status} Client Error: {expected_reason} for url: {expected_request_url}. {api_error.detail}"

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/tests/Functional/Resources/Addresses/test_AddressesClient.py

@@ -1,14 +1,17 @@
-from json         import loads
-from pytest       import mark
+from json         import loads, dumps
+from pytest       import mark, raises
 from urllib.parse import unquote
 
 from paddle_billing.Entities.Address     import Address
 from paddle_billing.Entities.Collections import AddressCollection
 from paddle_billing.Entities.Shared      import CountryCode, CustomData, Status
+from paddle_billing.Exceptions.ApiError  import ApiError
 
 from paddle_billing.Resources.Addresses.Operations import CreateAddress, ListAddresses, UpdateAddress
 from paddle_billing.Resources.Shared.Operations    import Pager
 
+from requests.exceptions import RequestException, HTTPError
+
 from tests.Utils.TestClient   import mock_requests, test_client
 from tests.Utils.ReadsFixture import ReadsFixtures
 
@@ -78,6 +81,100 @@ class TestAddressesClient:
             "The response JSON doesn't match the expected fixture JSON"
 
 
+    @mark.parametrize(
+        [
+            'customer_id',
+            'operation',
+            'expected_request_body',
+            'expected_response_status',
+            'expected_reason',
+            'expected_response_body',
+            'expected_url_path',
+        ],
+        [
+            (
+                'ctm_01h844p3h41s12zs5mn4axja51',
+                CreateAddress(CountryCode.AG),
+                ReadsFixtures.read_raw_json_fixture('request/create_basic'),
+                400,
+                'Bad Request',
+                {
+                    "error": {
+                        "type": "request_error",
+                        "code": "bad_request",
+                        "detail": "Invalid request",
+                        "documentation_url": "https://developer.paddle.com/v1/errors/shared/bad_request",
+                        "errors": [
+                        {
+                            "field": "postal_code",
+                            "message": "US postal_code must be 5 digits only"
+                        }
+                        ]
+                    },
+                    "meta": {
+                        "request_id": "f00bb3ca-399d-4686-889c-50b028f4c911"
+                    }
+                },
+                '/customers/ctm_01h844p3h41s12zs5mn4axja51/addresses'
+            ),
+        ],
+        ids=[
+            "Returns 400 response for postal code",
+        ],
+    )
+    def test_create_address_returns_error_response(
+        self,
+        test_client,
+        mock_requests,
+        customer_id,
+        operation,
+        expected_request_body,
+        expected_response_status,
+        expected_reason,
+        expected_response_body,
+        expected_url_path,
+    ):
+        expected_url = f"{test_client.base_url}{expected_url_path}"
+        mock_requests.post(expected_url, status_code=expected_response_status, text=dumps(expected_response_body), reason=expected_reason)
+
+        with raises(ApiError) as exception_info:
+            test_client.client.addresses.create(customer_id, operation)
+
+        request_json = test_client.client.payload
+        last_request = mock_requests.last_request
+        api_error    = exception_info.value
+
+        assert unquote(last_request.url) == expected_url, \
+            "The URL does not match the expected URL, verify the query string is correct"
+
+        assert loads(request_json) == loads(expected_request_body), \
+            "The request JSON doesn't match the expected fixture JSON"
+
+        assert isinstance(api_error, ApiError)
+        assert isinstance(api_error, HTTPError)
+        assert isinstance(api_error, RequestException)
+        assert api_error.response.status_code == expected_response_status, 'Unexpected status code'
+        assert api_error.error_type == expected_response_body['error']['type']
+        assert api_error.error_code == expected_response_body['error']['code']
+        assert api_error.detail == expected_response_body['error']['detail']
+        assert api_error.docs_url == expected_response_body['error']['documentation_url']
+
+        assert len(api_error.field_errors) == len(expected_response_body['error']['errors'])
+
+        for i, expected_field_error in enumerate(expected_response_body['error']['errors']):
+            assert api_error.field_errors[i].field == expected_field_error['field']
+            assert api_error.field_errors[i].error == expected_field_error['message']
+
+        assert str(api_error) == api_error.detail
+        assert repr(api_error) == ("ApiError("
+            f"error_type='{api_error.error_type}', "
+            f"error_code='{api_error.error_code}', "
+            f"detail='{api_error.detail}', "
+            f"docs_url='{api_error.docs_url}', "
+            f"field_errors={api_error.field_errors}"
+            ")")
+
+
     @mark.parametrize(
         'customer_id, address_id, operation, expected_request_body, expected_response_status, expected_response_body, expected_url',
         [

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/tests/Functional/Resources/NotificationSettings/test_NotificationSettingsClient.py

@@ -200,13 +200,17 @@ class TestNotificationSettingsClient:
         expected_url,
     ):
         expected_url = f"{test_client.base_url}{expected_url}"
-        mock_requests.get(expected_url, status_code=expected_response_status)
+        mock_requests.get(expected_url, status_code=expected_response_status, text=expected_response_body)
 
         response     = test_client.client.notification_settings.list()
         last_request = mock_requests.last_request
 
         assert isinstance(response, NotificationSettingCollection)
+        assert all(
+            isinstance(item, NotificationSetting) for item in response.items
+        ), "Not all items are NotificationSetting"
         assert last_request is not None
+
         assert last_request.method            == 'GET'
         assert test_client.client.status_code == expected_response_status
         assert unquote(last_request.url)      == expected_url, \

{paddle_python_sdk-0.1.1 → paddle_python_sdk-0.1.3}/tests/Utils/TestClient.py

@@ -1,20 +1,24 @@
 from os            import getenv
 from pytest        import fixture
 from requests_mock import Mocker
+from logging       import Logger
 
 from paddle_billing import Client, Environment, Options
 
+from tests.Utils.TestLogger import test_logger
+
 
 class TestClient:
     def __init__(
         self,
         client:         Client | None = None,
         api_secret_key: str    | None = None,
-        environment:    Environment   = Environment.SANDBOX
+        environment:    Environment   = Environment.SANDBOX,
+        logger:         Logger | None = None,
      ):
         self._environment = environment
         self._base_url    = self._environment.base_url
-        self._client      = client or self.create_client(api_secret_key)
+        self._client      = client or self.create_client(api_secret_key, logger)
 
 
     @property
@@ -30,16 +34,17 @@ class TestClient:
         return self._environment
 
 
-    def create_client(self, api_secret_key: str | None = None):
+    def create_client(self, api_secret_key: str | None = None, logger: Logger | None = None):
         return Client(
             getenv('PADDLE_API_SECRET_KEY') if api_secret_key is None else api_secret_key,
             options = Options(self._environment),
+            logger=logger
         )
 
 
 @fixture(autouse=True)
-def test_client():
-    return TestClient(environment=Environment.SANDBOX)
+def test_client(test_logger):
+    return TestClient(environment=Environment.SANDBOX, logger=test_logger)
 
 
 @fixture

paddle_python_sdk-0.1.3/tests/Utils/TestLogger.py

@@ -0,0 +1,28 @@
+from pytest  import fixture
+from logging import getLogger, Logger, Handler, LogRecord
+
+
+class LogHandler(Handler):
+    def __init__(self):
+        super().__init__()
+        self._logs = []
+
+
+    def emit(self, record):
+        self._logs.append(record)
+
+
+    def get_logs(self) -> list[LogRecord]:
+        return self._logs
+
+
+@fixture
+def test_log_handler() -> LogHandler:
+    return LogHandler()
+
+
+@fixture
+def test_logger(test_log_handler) -> Logger:
+    logger = getLogger('paddle_test_logger')
+    logger.addHandler(test_log_handler)
+    return logger

paddle_python_sdk-0.1.3/tests/conftest.py

@@ -0,0 +1,2 @@
+from tests.Utils.TestClient import mock_requests, test_client
+from tests.Utils.TestLogger import test_log_handler, test_logger