♻️ update error handling (#222)

Author: sebastianMindee

mindee/client.py

@@ -14,6 +14,11 @@
     UrlInputSource,
 )
 from mindee.logger import logger
+from mindee.mindee_http import (
+    clean_request_json,
+    is_valid_async_response,
+    is_valid_sync_response,
+)
 from mindee.mindee_http.endpoint import CustomEndpoint, Endpoint
 from mindee.mindee_http.mindee_api import MindeeApi
 from mindee.parsing.common.async_predict_response import AsyncPredictResponse
@@ -312,11 +317,11 @@ def send_feedback(
             endpoint = self._initialize_ots_endpoint(product_class)
 
         feedback_response = endpoint.document_feedback_req_put(document_id, feedback)
-        if not feedback_response.ok:
+        if not is_valid_sync_response(feedback_response):
+            feedback_clean_response = clean_request_json(feedback_response)
             raise handle_error(
                 str(product_class.endpoint_name),
-                feedback_response.json(),
-                feedback_response.status_code,
+                feedback_clean_response,
             )
 
         return FeedbackResponse(feedback_response.json())
@@ -336,11 +341,11 @@ def _make_request(
 
         dict_response = response.json()
 
-        if not response.ok:
+        if not is_valid_sync_response(response):
+            clean_response = clean_request_json(response)
             raise handle_error(
                 str(product_class.endpoint_name),
-                dict_response,
-                response.status_code,
+                clean_response,
             )
 
         return PredictResponse(product_class, dict_response)
@@ -365,11 +370,11 @@ def _predict_async(
 
         dict_response = response.json()
 
-        if not response.ok:
+        if not is_valid_async_response(response):
+            clean_response = clean_request_json(response)
             raise handle_error(
                 str(product_class.endpoint_name),
-                dict_response,
-                response.status_code,
+                clean_response,
             )
 
         return AsyncPredictResponse(product_class, dict_response)
@@ -387,16 +392,11 @@ def _get_queued_document(
         """
         queue_response = endpoint.document_queue_req_get(queue_id=queue_id)
 
-        if (
-            not queue_response.status_code
-            or queue_response.status_code < 200
-            or queue_response.status_code > 302
-        ):
-            dict_response = queue_response.json()
+        if not is_valid_async_response(queue_response):
+            clean_queue_response = clean_request_json(queue_response)
             raise handle_error(
                 str(product_class.endpoint_name),
-                dict_response,
-                queue_response.status_code,
+                clean_queue_response,
             )
 
         return AsyncPredictResponse(product_class, queue_response.json())

mindee/error/mindee_http_error.py

@@ -88,14 +88,24 @@ class MindeeHTTPServerError(MindeeHTTPError):
     """API Server HTTP exception."""
 
 
-def handle_error(url: str, response: StringDict, code: int) -> MindeeHTTPError:
+def handle_error(url: str, response: StringDict) -> MindeeHTTPError:
     """
     Creates an appropriate HTTP error exception, based on retrieved HTTP error code.
 
     :param url: url of the product
     :param response: StringDict
     """
     error_obj = create_error_obj(response)
+    if not isinstance(response, str) and (  # type: ignore
+        "status_code" in response
+        and (
+            isinstance(response["status_code"], int)
+            or response["status_code"].isdigit()
+        )
+    ):
+        code = int(response["status_code"])
+    else:
+        code = 500
     if 400 <= code <= 499:
         return MindeeHTTPClientError(error_obj, url, code)
     if 500 <= code <= 599:

mindee/mindee_http/__init__.py

@@ -1,3 +1,8 @@
 from mindee.mindee_http.base_endpoint import BaseEndpoint
 from mindee.mindee_http.endpoint import CustomEndpoint, Endpoint
 from mindee.mindee_http.mindee_api import MindeeApi
+from mindee.mindee_http.response_validation import (
+    clean_request_json,
+    is_valid_async_response,
+    is_valid_sync_response,
+)

mindee/mindee_http/response_validation.py

@@ -0,0 +1,78 @@
+import json
+
+import requests
+
+from mindee.parsing.common import StringDict
+
+
+def is_valid_sync_response(response: requests.Response) -> bool:
+    """
+    Checks if the synchronous response is valid. Returns True if the response is valid.
+
+    :param response: a requests response object.
+    :return: bool
+    """
+    if not response or not response.ok:
+        return False
+    response_json = json.loads(response.content)
+    # VERY rare edge case where raw html is sent instead of json.
+    if not isinstance(response_json, dict):
+        return False
+    return True
+
+
+def is_valid_async_response(response: requests.Response) -> bool:
+    """
+    Checks if the asynchronous response is valid. Also checks if it is a valid synchronous response.
+
+    Returns True if the response is valid.
+
+    :param response: a requests response object.
+    :return: bool
+    """
+    if not is_valid_sync_response(response):
+        return False
+    response_json = json.loads(response.content)
+    # Checks invalid status codes within the bounds of ok responses.
+    if response.status_code and (
+        response.status_code < 200 or response.status_code > 302
+    ):
+        return False
+    # Async errors.
+    if "job" not in response_json:
+        return False
+    if (
+        "job" in response_json
+        and "error" in response_json["job"]
+        and response_json["job"]["error"]
+    ):
+        return False
+    return True
+
+
+def clean_request_json(response: requests.Response) -> StringDict:
+    """
+    Checks and correct the response error format depending on the two possible kind of returns.
+
+    :param response: Raw request response.
+    :return: Returns the job error if the error is due to parsing, returns the http error otherwise.
+    """
+    response_json = response.json()
+    if response.status_code < 200 or response.status_code > 302:
+        response_json["status_code"] = response.status_code
+        return response_json
+    corrected_json = response_json
+    if (
+        "status_code" in response_json["api_request"]
+        and response_json["api_request"]["status_code"].isdigit()
+        and int(response_json["api_request"]["status_code"]) >= 400
+    ):
+        corrected_json["status_code"] = int(response_json["api_request"]["status_code"])
+    if (
+        "job" in response_json
+        and "error" in response_json["job"]
+        and response_json["job"]["error"]
+    ):
+        corrected_json["error"] = response_json["job"]["error"]
+        corrected_json["status_code"] = 500
+    return corrected_json

mindee/parsing/common/async_predict_response.py

@@ -26,8 +26,8 @@ def __init__(
         Inherits and instantiates a normal PredictResponse if the parsing of
         the current queue is both requested and done.
 
-        :param input_source: Input object
-        :param raw_response: json response from HTTP call
+        :param inference_type: Type of the inference.
+        :param raw_response: json response from HTTP call.
         """
         super().__init__(raw_response)
         self.job = Job(raw_response["job"])

mindee/parsing/common/job.py

@@ -2,6 +2,8 @@
 from datetime import datetime
 from typing import Optional
 
+from mindee.parsing.common.string_dict import StringDict
+
 
 class Job:
     """
@@ -12,6 +14,8 @@ class Job:
 
     id: str
     """ID of the job sent by the API in response to an enqueue request."""
+    error: Optional[StringDict]
+    """Information about an error that occurred during the job processing."""
     issued_at: datetime
     """Timestamp of the request reception by the API."""
     available_at: Optional[datetime]
@@ -33,6 +37,10 @@ def __init__(self, json_response: dict) -> None:
         else:
             self.available_at = None
         self.id = json_response["id"]
+        if json_response.get("status_code"):
+            self.status_code = json_response["status_code"]
+        if json_response.get("error"):
+            self.error = json_response.get("error")
         self.status = json_response["status"]
         if self.available_at:
             self.millisecs_taken = int(

mindee/parsing/common/predict_response.py

@@ -21,8 +21,8 @@ def __init__(
         """
         Container for the raw API response and the parsed document.
 
-        :param input_source: Input object
-        :param http_response: json response from HTTP call
+        :param inference_type: Type of the inference.
+        :param raw_response: json response from HTTP call.
         """
         super().__init__(raw_response)
         self.document = Document(inference_type, raw_response["document"])

tests/api/test_async_response.py

@@ -1,18 +1,41 @@
 import json
 
 import pytest
+import requests
 
 from mindee.client import Client
 from mindee.input.sources import PathInput
+from mindee.mindee_http.response_validation import is_valid_async_response
+from mindee.parsing.common.api_request import RequestStatus
 from mindee.parsing.common.async_predict_response import AsyncPredictResponse
 from mindee.product.invoice_splitter import InvoiceSplitterV1
 
 ASYNC_DIR = "./tests/data/async"
 
-FILE_PATH_POST_SUCCESS = f"{ ASYNC_DIR }/post_success.json"
-FILE_PATH_POST_FAIL = f"{ ASYNC_DIR }/post_fail_forbidden.json"
-FILE_PATH_GET_PROCESSING = f"{ ASYNC_DIR }/get_processing.json"
-FILE_PATH_GET_COMPLETED = f"{ ASYNC_DIR }/get_completed.json"
+FILE_PATH_POST_SUCCESS = f"{ASYNC_DIR}/post_success.json"
+FILE_PATH_POST_FAIL = f"{ASYNC_DIR}/post_fail_forbidden.json"
+FILE_PATH_GET_PROCESSING = f"{ASYNC_DIR}/get_processing.json"
+FILE_PATH_GET_COMPLETED = f"{ASYNC_DIR}/get_completed.json"
+FILE_PATH_GET_FAILED_JOB = f"{ASYNC_DIR}/get_failed_job_error.json"
+
+
+class FakeResponse(requests.Response):
+    def __init__(self, json_data, _status_code=200):
+        super().__init__()
+        self._json_data = json_data
+        self.status_code = _status_code
+        self._ok = True
+
+    def set_ok_status(self, ok_status):
+        self._ok = ok_status
+
+    @property
+    def ok(self):
+        return self._ok
+
+    @property
+    def content(self) -> str:
+        return json.dumps(self._json_data)
 
 
 @pytest.fixture
@@ -29,6 +52,9 @@ def dummy_client() -> Client:
 def test_async_response_post_success():
     response = json.load(open(FILE_PATH_POST_SUCCESS))
     parsed_response = AsyncPredictResponse(InvoiceSplitterV1, response)
+    fake_response = FakeResponse(response)
+    fake_response.set_ok_status(True)
+    assert is_valid_async_response(fake_response) is True
     assert parsed_response.job is not None
     assert (
         parsed_response.job.issued_at.isoformat() == "2023-02-16T12:33:49.602947+00:00"
@@ -41,18 +67,17 @@ def test_async_response_post_success():
 
 def test_async_response_post_fail():
     response = json.load(open(FILE_PATH_POST_FAIL))
-    parsed_response = AsyncPredictResponse(InvoiceSplitterV1, response)
-    assert parsed_response.job is not None
-    assert parsed_response.job.issued_at.isoformat() == "2023-01-01T00:00:00+00:00"
-    assert parsed_response.job.available_at is None
-    assert parsed_response.job.status is None
-    assert parsed_response.job.id is None
-    assert parsed_response.api_request.error["code"] == "Forbidden"
+    fake_response = FakeResponse(response)
+    fake_response.set_ok_status(False)
+    assert is_valid_async_response(fake_response) is False
 
 
 def test_async_get_processing():
     response = json.load(open(FILE_PATH_GET_PROCESSING))
     parsed_response = AsyncPredictResponse(InvoiceSplitterV1, response)
+    fake_response = FakeResponse(response)
+    fake_response.set_ok_status(True)
+    assert is_valid_async_response(fake_response) is True
     assert parsed_response.job is not None
     assert parsed_response.job.issued_at.isoformat() == "2023-03-16T12:33:49.602947"
     assert parsed_response.job.available_at is None
@@ -64,8 +89,25 @@ def test_async_get_processing():
 def test_async_response_get_completed():
     response = json.load(open(FILE_PATH_GET_COMPLETED))
     parsed_response = AsyncPredictResponse(InvoiceSplitterV1, response)
+    fake_response = FakeResponse(response)
+    fake_response.set_ok_status(True)
+    assert is_valid_async_response(fake_response) is True
     assert parsed_response.job is not None
     assert parsed_response.job.issued_at.isoformat() == "2023-03-21T13:52:56.326107"
     assert parsed_response.job.available_at.isoformat() == "2023-03-21T13:53:00.990339"
     assert parsed_response.job.status == "completed"
     assert parsed_response.api_request.error == {}
+
+
+def test_async_get_failed_job():
+    response = json.load(open(FILE_PATH_GET_FAILED_JOB))
+    parsed_response = AsyncPredictResponse(InvoiceSplitterV1, response)
+    fake_response = FakeResponse(response)
+    fake_response.set_ok_status(False)
+    assert is_valid_async_response(fake_response) is False
+    assert parsed_response.api_request.status == RequestStatus.SUCCESS
+    assert parsed_response.api_request.status_code == 200
+    assert parsed_response.job.issued_at.isoformat() == "2024-02-20T10:31:06.878599"
+    assert parsed_response.job.available_at.isoformat() == "2024-02-20T10:31:06.878599"
+    assert parsed_response.job.status == "failed"
+    assert parsed_response.job.error["code"] == "ServerError"