pumpwood_communication.exceptions

  1"""
  2Define PumpWood exceptions to be treated as API errors.
  3
  4Define especific errors for PumpWood plataform. These errors will be treated
  5and will not result in default 500 errors
  6"""
  7
  8
  9class PumpWoodException(Exception): # NOQA
 10    """Special exception used in Pumpowod Systems.
 11
 12    It permits treatment of raises on applications serializing response
 13    using to_dict function and return status code as `status_code`
 14    attribute value.
 15    """
 16
 17    status_code: int = 400
 18    """PumpWoodException will return status 400 on Pumpwood backend."""
 19
 20    message: str
 21    """Message associated with raise."""
 22
 23    payload: dict
 24    """
 25    Dictionary payload that will be returned by to_dict funcion and format
 26    message string.
 27    """
 28
 29    def __repr__(self):
 30        """@private."""
 31        message_fmt = self.format_message()
 32        template = "{class_name}[status_code={status_code}]: " + \
 33            "{message_fmt}\nerror payload={payload}"
 34        return template.format(
 35            class_name=self.__class__.__name__,
 36            status_code=self.status_code,
 37            message_fmt=message_fmt,
 38            payload=self.payload)
 39
 40    def __str__(self):
 41        """@private."""
 42        message_fmt = self.format_message()
 43        template = "{class_name}[status_code={status_code}]: " + \
 44            "{message_fmt}\nerror payload={payload}"
 45        return template.format(
 46            class_name=self.__class__.__name__,
 47            status_code=self.status_code,
 48            message_fmt=message_fmt,
 49            payload=self.payload)
 50
 51    def __init__(self, message: str, payload: dict = {}, status_code=None):
 52        """__init__.
 53
 54        Args:
 55            message:
 56                Message that will be formated using payload
 57                information using `{key}` to replace information.
 58            payload:
 59                Payload data passed as a dictionary, it will be returned
 60                in payload at `to_dict` funcion and used to format message.
 61            status_code:
 62                Change the default status code of the exception.
 63        """
 64        Exception.__init__(self)
 65        self.message = message
 66        if status_code is not None:
 67            self.status_code = status_code
 68        self.payload = payload
 69
 70    def format_message(self) -> str:
 71        """Format exception message using payload data.
 72
 73        Substitute placeholders at exception message with payload.
 74
 75        Returns:
 76            Return a string of message with placeholders substituted with
 77            payload data.
 78        """
 79        try:
 80            return self.message.format(**self.payload)
 81        except Exception:
 82            return self.message + "\n** format error **"
 83
 84    def to_dict(self) -> dict:
 85        """Serialize Exception object to return as reponse.
 86
 87        Returns:
 88            Return a dictionary with keys:
 89            - **payload [dict]:** Payload associated with raise.
 90            - **type [str]:** Return name of the class of the Exception.
 91            - **message_not_fmt [str]:** Return msg without replacemnt of the
 92                msg with payload information.
 93            - **message [str]:** Return msg formated with payload information.
 94        """
 95        message_fmt = self.format_message()
 96        rv = {
 97            "payload": self.payload,
 98            "type": self.__class__.__name__,
 99            "message_not_fmt": self.message,
100            "message": message_fmt}
101        return rv
102
103
104class PumpWoodDataLoadingException(PumpWoodException):
105    """Problem when loading data at dataloaders and to_load models."""
106
107    pass
108
109
110class PumpWoodDatabaseError(PumpWoodException):
111    """Errors raised by Postgres and not treated by other handlers."""
112
113    pass
114
115
116class PumpWoodDataTransformationException(PumpWoodException):
117    """Problem when transforming model data."""
118
119    pass
120
121
122class PumpWoodWrongParameters(PumpWoodException):
123    """Raise for errors in object deserialization."""
124
125    pass
126
127
128class PumpWoodObjectSavingException(PumpWoodException):
129    """Raise for errors in object deserialization."""
130
131    pass
132
133
134class PumpWoodObjectDeleteException(PumpWoodException):
135    """Raise for errors in object deserialization."""
136
137    pass
138
139
140class PumpWoodActionArgsException(PumpWoodException):
141    """Missing arguments to perform action."""
142
143    pass
144
145
146class PumpWoodUnauthorized(PumpWoodException):
147    """User Unauthorized to perform action."""
148
149    status_code = 401
150
151
152class PumpWoodForbidden(PumpWoodException):
153    """Action not permited."""
154
155    status_code = 403
156
157
158class PumpWoodObjectDoesNotExist(PumpWoodException):
159    """Object not found in database."""
160
161    status_code = 404
162
163
164class PumpWoodQueryException(PumpWoodException):
165    """Problem when querying data, like wrong fields or operators."""
166
167    pass
168
169
170class PumpWoodIntegrityError(PumpWoodException):
171    """Problem when saving data due to IntegrityError."""
172
173    pass
174
175
176class PumpWoodNotImplementedError(PumpWoodException):
177    """Problem when saving data due to NotImplementedError."""
178
179    pass
180
181
182class PumpWoodMicroserviceUnavailableError(PumpWoodException):
183    """Problem when trying to use a microservice that was not deployied."""
184
185    pass
186
187
188class PumpWoodMFAError(PumpWoodException):
189    """Problem when using MFA."""
190
191    pass
192
193
194class PumpWoodOtherException(PumpWoodException):
195    """Other untreated error on server."""
196
197    status_code = 500
198
199    def __repr__(self):
200        """__repr__."""
201        template = "{class_name}[status_code={status_code}]: " + \
202            "{message}\nerror payload={payload}"
203        return template.format(
204            class_name=self.__class__.__name__,
205            status_code=self.status_code, message=self.message,
206            payload=self.payload,)
207
208    def __str__(self):
209        """__str__."""
210        template = "{class_name}[status_code={status_code}]: " + \
211            "{message}\nerror payload={payload}"
212        return template.format(
213            class_name=self.__class__.__name__,
214            status_code=self.status_code, message=self.message,
215            payload=self.payload,)
216
217    def __init__(self, message: str, payload: dict = {}, status_code=None):
218        """__init__."""
219        Exception.__init__(self)
220        # Limit size of the error
221        self.message = message[:1000]
222        if status_code is not None:
223            self.status_code = status_code
224        self.payload = payload
225
226    def to_dict(self):
227        """Serialize exception to dictionary."""
228        rv = {
229            "payload": self.payload,
230            "type": self.__class__.__name__,
231            "message": self.message}
232        return rv
233
234
235class AirflowMicroServiceException(PumpWoodException):
236    """Raises from AirflowMicroService."""
237
238    pass
239
240
241exceptions_dict = {
242    "PumpWoodException": PumpWoodException,
243    "PumpWoodDataLoadingException": PumpWoodDataLoadingException,
244    "PumpWoodDatabaseError": PumpWoodDatabaseError,
245    "PumpWoodDataTransformationException": PumpWoodDataTransformationException,
246    "PumpWoodWrongParameters": PumpWoodWrongParameters,
247    "PumpWoodObjectSavingException": PumpWoodObjectSavingException,
248    "PumpWoodObjectDeleteException": PumpWoodObjectDeleteException,
249    "PumpWoodActionArgsException": PumpWoodActionArgsException,
250    "PumpWoodUnauthorized": PumpWoodUnauthorized,
251    "PumpWoodForbidden": PumpWoodForbidden,
252    "PumpWoodObjectDoesNotExist": PumpWoodObjectDoesNotExist,
253    "PumpWoodQueryException": PumpWoodQueryException,
254    "PumpWoodIntegrityError": PumpWoodIntegrityError,
255    "PumpWoodNotImplementedError": PumpWoodNotImplementedError,
256    "PumpWoodMicroserviceUnavailableError":
257        PumpWoodMicroserviceUnavailableError,
258    "PumpWoodMFAError": PumpWoodMFAError,
259    "PumpWoodOtherException": PumpWoodOtherException,
260    "AirflowMicroServiceException": AirflowMicroServiceException,
261}
262"""
263Dictionary used by backends/microservice to treat Pumpwood exceptions and
264re-raise them exception.
265"""