Fix error object

Author: 0xRy4n

intercom_python_sdk/core/errors.py

@@ -1,42 +1,23 @@
-"""
-# Intercom Error Objects
-
-`core/errors.py`
-
-This module contains the IntercomErrorObject and IntercomErrorList classes, which
-are custom exceptions for Intercom error objects. These models/schemas are implemented
-as defined by the Intercom API Reference [1].
-
----
-- [1] https://developers.intercom.com/intercom-api-reference/reference/error-objects
-"""
 # Built-ins
 from pprint import pformat
-from typing import Any
+from typing import Any, List
 
 # External
-from marshmallow import (
-    fields,
-    post_load,
-)
+from marshmallow import fields, Schema, post_load, ValidationError
 
 # From Current Package
+# Assuming that the SchemaBase import is valid and it extends from marshmallow.Schema
 from .schema_base import SchemaBase
 
 
 class IntercomErrorObjectSchema(SchemaBase):
     """
     Schema for an Intercom error object.
-
-    Attributes:
-        code (str): The code of the error.
-        message (str): The message of the error.
-        field (str): The field of the error (optional).
     """
-    code = fields.Str()
-    message = fields.Str()
-    field = fields.Str()
-    request_id = fields.Str()
+    code = fields.Str(required=True)
+    message = fields.Str(required=True)
+    field = fields.Str(missing=None)
+    request_id = fields.Str(missing=None)
 
     @post_load
     def make_intercom_error_object(self, data, **kwargs):
@@ -46,58 +27,51 @@ def make_intercom_error_object(self, data, **kwargs):
 class IntercomErrorListSchema(SchemaBase):
     """
     Schema for a list of Intercom error objects.
-
-    Attributes:
-        type (str): The type of the error.
-        errors (List[IntercomErrorObjectSchema]): The list of errors.
     """
-    type = fields.Str()
-    errors = fields.List(fields.Nested(IntercomErrorObjectSchema))
-    request_id = fields.Str()
+    type = fields.Str(required=True)
+    errors = fields.List(fields.Nested(IntercomErrorObjectSchema), required=True)
+    request_id = fields.Str(missing=None)
 
     @post_load
     def make_intercom_error_list(self, data, **kwargs):
         return IntercomErrorList(**data)
 
 
-class IntercomErrorObject:
+class IntercomErrorObject(Exception):
     """ Custom exception for an Intercom error object. """
-
-    def __init__(self, **kwargs: Any):
-        self.code = kwargs.get("code", "")
-        self.message = kwargs.get("message", "")
-
-        if kwargs.get("field"):
-            self.field = kwargs.get("field")
-
-        if kwargs.get("request_id"):
-            self.request_id = kwargs.get("request_id")
+    def __init__(self, code: str, message: str, field: str = None, request_id: str = None):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.field = field
+        self.request_id = request_id
 
     def __str__(self):
-        return f"\n{pformat(self.__dict__)}\n"
-
-    def __repr__(self):
-        return self.__str__()
+        return f"IntercomErrorObject(code={self.code}, message={self.message}, field={self.field}, request_id={self.request_id})"
 
 
 class IntercomErrorList(Exception):
     """ Custom exception for a list of Intercom error objects. """
-    def __init__(self, **kwargs):
-        self.type = kwargs.get("type", "")
-        self.errors = kwargs.get("errors", [])
-        self.request_id = kwargs.get("request_id", None)
+    def __init__(self, type: str, errors: List[IntercomErrorObject], request_id: str = None):
+        message = f"Intercom API returned multiple errors: {pformat(errors)}"
+        super().__init__(message)
+        self.type = type
+        self.errors = errors
+        self.request_id = request_id
 
-        super().__init__(f"Error Response from Intercom API. Request ID: {self.request_id}\n {pformat(self.__dict__)}")
 
-
-def catch_api_error(response):  # type: ignore
-    """ Catches API errors and raises them as as custom exceptions. """
+def catch_api_error(response):
+    """ Catches API errors and raises them as custom exceptions. """
     if 200 <= response.status_code < 300:
         return response
 
-    data = response.json()
-    error = IntercomErrorListSchema().load(data)
-
-    print(response.content)
+    try:
+        data = response.json()
+    except ValueError:
+        response.raise_for_status()
 
-    raise error  # type: ignore
+    try:
+        error_list = IntercomErrorListSchema().load(data)
+        raise error_list
+    except ValidationError as e:
+        raise ValueError(f"Error parsing error response: {e.messages}")