fix most syntaxes, add tests (integration testing not fully working)

Author: sebastianMindee

mindee/__init__.py

@@ -1,5 +1,6 @@
 from mindee import product
 from mindee.client import Client
+from mindee.client_v2 import ClientV2
 from mindee.input.inference_predict_options import InferencePredictOptions
 from mindee.input.local_response import LocalResponse
 from mindee.input.page_options import PageOptions

mindee/client_v2.py

@@ -19,19 +19,6 @@
 from mindee.parsing.v2.polling_response import PollingResponse
 
 
-def load_prediction(local_response: LocalResponse) -> InferenceResponse:
-    """
-    Load a prediction.
-
-    :param local_response: Local response to load.
-    :return: A valid prediction.
-    """
-    try:
-        return InferenceResponse(local_response.as_dict)
-    except KeyError as exc:
-        raise MindeeError("No prediction found in local response.") from exc
-
-
 class ClientV2(ClientMixin):
     """
     Mindee API Client.
@@ -182,3 +169,16 @@ def enqueue_and_parse(
             )
 
         return poll_results
+
+    @staticmethod
+    def load_inference(local_response: LocalResponse) -> InferenceResponse:
+        """
+        Load a prediction from the V2 API.
+
+        :param local_response: Local response to load.
+        :return: A valid prediction.
+        """
+        try:
+            return InferenceResponse(local_response.as_dict)
+        except KeyError as exc:
+            raise MindeeError("No prediction found in local response.") from exc

mindee/error/__init__.py

@@ -1,6 +1,12 @@
 from mindee.error.geometry_error import GeometryError
 from mindee.error.mimetype_error import MimeTypeError
-from mindee.error.mindee_error import MindeeClientError, MindeeError, MindeeProductError
+from mindee.error.mindee_error import (
+    MindeeApiError,
+    MindeeApiV2Error,
+    MindeeClientError,
+    MindeeError,
+    MindeeProductError,
+)
 from mindee.error.mindee_http_error import (
     MindeeHTTPClientError,
     MindeeHTTPError,

mindee/error/mindee_error.py

@@ -14,7 +14,7 @@ class MindeeApiError(MindeeError):
     """An exception relating to settings of the MindeeClient."""
 
 
-class MindeeAPIV2Error(MindeeError):
+class MindeeApiV2Error(MindeeError):
     """An exception relating to settings of the MindeeClient V2."""
 
 

mindee/error/mindee_http_error_v2.py

@@ -25,21 +25,20 @@ def __init__(self, status: int, detail: Optional[str]) -> None:
 class MindeeHTTPUnknownErrorV2(MindeeHTTPErrorV2):
     """HTTP error with unknown status code."""
 
-    def __init__(self, status: int, detail: Optional[str]) -> None:
+    def __init__(self, detail: Optional[str]) -> None:
         super().__init__(-1, f"Couldn't deserialize server error. Found: {detail}")
 
 
-def handle_error_v2(json_response: StringDict) -> None:
+def handle_error_v2(raw_response: StringDict) -> None:
     """
     Handles HTTP errors by raising MindeeHTTPErrorV2 exceptions with proper details.
 
     :raises MindeeHTTPErrorV2: If the response has been caught.
     :raises MindeeHTTPUnknownErrorV2: If the json return format is unreadable.
     """
-    try:
-        raise MindeeHTTPErrorV2(
-            json_response["job"]["error"]["status"],
-            json_response["job"]["error"]["detail"],
-        )
-    except Exception as exc:
-        raise MindeeHTTPUnknownErrorV2(-1, json.dumps(json_response, indent=2)) from exc
+    if "status" not in raw_response or "detail" not in raw_response:
+        raise MindeeHTTPUnknownErrorV2(json.dumps(raw_response, indent=2))
+    raise MindeeHTTPErrorV2(
+        raw_response["status"],
+        raw_response["detail"],
+    )

mindee/mindee_http/mindee_api_v2.py

@@ -1,18 +1,20 @@
+import os
 from typing import Dict, Optional
 
 import requests
 
-from mindee import InferencePredictOptions
-from mindee.error.mindee_error import MindeeApiError
+from mindee.error.mindee_error import MindeeApiV2Error
 from mindee.input import LocalInputSource
+from mindee.input.inference_predict_options import InferencePredictOptions
+from mindee.logger import logger
 from mindee.mindee_http.base_settings import USER_AGENT
 from mindee.mindee_http.settings_mixin import SettingsMixin
 
 API_KEY_V2_ENV_NAME = "MINDEE_V2_API_KEY"
 API_KEY_V2_DEFAULT = ""
 
 BASE_URL_ENV_NAME = "MINDEE_V2_BASE_URL"
-BASE_URL_DEFAULT = "https://api-v2.mindee.com/v2"
+BASE_URL_DEFAULT = "https://api-v2.mindee.net/v2"
 
 REQUEST_TIMEOUT_ENV_NAME = "MINDEE_REQUEST_TIMEOUT"
 TIMEOUT_DEFAULT = 120
@@ -32,24 +34,39 @@ def __init__(
     ):
         self.api_key = api_key
         if not self.api_key or len(self.api_key) == 0:
-            raise MindeeApiError(
+            raise MindeeApiV2Error(
                 (
                     f"Missing API key,"
                     " check your Client configuration.\n"
                     "You can set this using the "
                     f"'{API_KEY_V2_ENV_NAME}' environment variable."
                 )
             )
+        self.request_timeout = TIMEOUT_DEFAULT
+        self.set_base_url(BASE_URL_DEFAULT)
+        self.set_from_env()
         self.url_root = f"{self.base_url.rstrip('/')}"
 
     @property
     def base_headers(self) -> Dict[str, str]:
         """Base headers to send with all API requests."""
         return {
-            "Authorization": f"Token {self.api_key}",
+            "Authorization": self.api_key or "",
             "User-Agent": USER_AGENT,
         }
 
+    def set_from_env(self) -> None:
+        """Set various parameters from environment variables, if present."""
+        env_vars = {
+            BASE_URL_ENV_NAME: self.set_base_url,
+            REQUEST_TIMEOUT_ENV_NAME: self.set_timeout,
+        }
+        for name, func in env_vars.items():
+            env_val = os.getenv(name, "")
+            if env_val:
+                func(env_val)
+                logger.debug("Value was set from env: %s", name)
+
     def predict_async_req_post(
         self,
         input_source: LocalInputSource,
@@ -64,7 +81,7 @@ def predict_async_req_post(
         :param close_file: Whether to `close()` the file after parsing it.
         :return: requests response.
         """
-        data = {}
+        data = {"model_id": options.model_id}
         params = {}
         url = f"{self.url_root}/inferences/enqueue"
 
@@ -77,7 +94,10 @@ def predict_async_req_post(
         if options.alias and len(options.alias):
             data["alias"] = options.alias
 
-        files = {"document": input_source.read_contents(close_file)}
+        files = {
+            "file": input_source.read_contents(close_file)
+            + (input_source.file_mimetype,)
+        }
         response = requests.post(
             url=url,
             files=files,

mindee/mindee_http/response_validation_v2.py

@@ -17,7 +17,11 @@ def is_valid_post_response(response: requests.Response) -> bool:
     response_json = json.loads(response.content)
     if not "job" in response_json:
         return False
-    if "job" in response_json and "error" in response_json["job"]:
+    if (
+        "job" in response_json
+        and "error" in response_json["job"]
+        and response_json["job"]["error"] is not None
+    ):
         return False
     return True
 

mindee/parsing/common/api_request.py

@@ -21,9 +21,9 @@ class ApiRequest:
     """HTTP status code."""
     url: str
 
-    def __init__(self, json_response: dict) -> None:
-        self.url = json_response["url"]
-        self.error = json_response["error"]
-        self.resources = json_response["resources"]
-        self.status = RequestStatus(json_response["status"])
-        self.status_code = json_response["status_code"]
+    def __init__(self, raw_response: StringDict) -> None:
+        self.url = raw_response["url"]
+        self.error = raw_response["error"]
+        self.resources = raw_response["resources"]
+        self.status = RequestStatus(raw_response["status"])
+        self.status_code = raw_response["status_code"]

mindee/parsing/common/execution_file.py

@@ -12,6 +12,6 @@ class ExecutionFile:
     alias: Optional[str]
     """File name."""
 
-    def __init__(self, json_response: StringDict):
-        self.name = json_response["name"]
-        self.alias = json_response["alias"]
+    def __init__(self, raw_response: StringDict):
+        self.name = raw_response["name"]
+        self.alias = raw_response["alias"]

mindee/parsing/v2/base_field.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Union
 
-from mindee.error.mindee_error import MindeeAPIV2Error
+from mindee.error.mindee_error import MindeeApiV2Error
 from mindee.parsing.common.string_dict import StringDict
 
 
@@ -14,7 +14,9 @@ def __init__(self, indent_level=0) -> None:
         self._indent_level = indent_level
 
     @staticmethod
-    def create_field(raw_response: StringDict, indent_level: int = 0) -> "BaseField":
+    def create_field(
+        raw_response: StringDict, indent_level: int = 0
+    ) -> Union["ListField", "ObjectField", "SimpleField"]:
         """Factory function to create appropriate field instances."""
         if isinstance(raw_response, dict):
             if "items" in raw_response:
@@ -23,14 +25,14 @@ def create_field(raw_response: StringDict, indent_level: int = 0) -> "BaseField"
                 return ObjectField(raw_response, indent_level)
             if "value" in raw_response:
                 return SimpleField(raw_response, indent_level)
-            raise MindeeAPIV2Error("Unrecognized field format.")
-        raise MindeeAPIV2Error("Unrecognized field format.")
+            raise MindeeApiV2Error(f"Unrecognized field format in {raw_response}.")
+        raise MindeeApiV2Error(f"Unrecognized field format {raw_response}.")
 
 
 class ListField(BaseField):
     """List field containing multiple fields."""
 
-    items: List[BaseField]
+    items: List[Union["ListField", "ObjectField", "SimpleField"]]
     """Items contained in the list."""
 
     def __init__(self, raw_response: StringDict, indent_level: int = 0):
@@ -40,23 +42,26 @@ def __init__(self, raw_response: StringDict, indent_level: int = 0):
         for item in raw_response["items"]:
             if isinstance(item, dict):
                 self.items.append(BaseField.create_field(item, 1))
-            raise MindeeAPIV2Error("Unrecognized field format.")
+            else:
+                raise MindeeApiV2Error(f"Unrecognized field format '{item}'.")
 
 
 class ObjectField(BaseField):
     """Object field containing multiple fields."""
 
-    fields: Dict[str, BaseField]
+    fields: Dict[str, Union[ListField, "ObjectField", "SimpleField"]]
     """Fields contained in the object."""
 
     def __init__(self, raw_response: StringDict, indent_level: int = 0):
         super().__init__(indent_level)
-        fields: Dict[str, BaseField] = {}
-        for field_key, field_value in raw_response.items():
+        inner_fields = raw_response.get("fields", raw_response)
+
+        self.fields: Dict[str, Union["ListField", "ObjectField", "SimpleField"]] = {}
+        for field_key, field_value in inner_fields.items():
             if isinstance(field_value, dict):
-                fields[field_key] = BaseField.create_field(field_value, 1)
+                self.fields[field_key] = BaseField.create_field(field_value, 1)
             else:
-                raise MindeeAPIV2Error("Unrecognized field format.")
+                raise MindeeApiV2Error(f"Unrecognized field format '{field_value}'.")
 
     def __str__(self) -> str:
         out_str = ""
@@ -72,7 +77,7 @@ class SimpleField(BaseField):
 
     def __init__(self, raw_response: StringDict, indent_level: int = 0):
         super().__init__(indent_level)
-        self.value = raw_response["value"] if "value" in raw_response else None
+        self.value = raw_response["value"] = raw_response.get("value", None)
 
     def __str__(self) -> str:
         return f"{' ' * self._indent_level}{self.value}\n"

mindee/parsing/v2/inference_fields.py

@@ -1,7 +1,20 @@
 from typing import Union
 
-from mindee.parsing.v2.base_field import ListField, ObjectField, SimpleField
+from mindee.parsing.common.string_dict import StringDict
+from mindee.parsing.v2.base_field import BaseField, ListField, ObjectField, SimpleField
 
 
-class InferenceFields(dict[str, Union[ObjectField, ListField, SimpleField]]):
+class InferenceFields(dict[str, Union[SimpleField, ObjectField, ListField]]):
     """Inference fields dict."""
+
+    def __init__(self, raw_response: StringDict) -> None:
+        super().__init__()
+        for key, value in raw_response.items():
+            field_obj = BaseField.create_field(value, 0)
+            self[key] = field_obj
+
+    def __getattr__(self, item):
+        try:
+            return self[item]
+        except KeyError:
+            raise AttributeError(item) from None

mindee/parsing/v2/inference_file.py

@@ -1,3 +1,6 @@
+from mindee.parsing.common.string_dict import StringDict
+
+
 class InferenceFile:
     """Inference File info."""
 
@@ -6,6 +9,6 @@ class InferenceFile:
     alais: str
     """Alias of the file."""
 
-    def __init__(self, json_response: dict) -> None:
-        self.name = json_response["name"]
-        self.alias = json_response["alias"]
+    def __init__(self, raw_response: StringDict) -> None:
+        self.name = raw_response["name"]
+        self.alias = raw_response["alias"]

mindee/parsing/v2/inference_options.py

@@ -1,12 +1,12 @@
-from typing import List
+from typing import List, Optional
 
 from mindee.parsing.common.string_dict import StringDict
 
 
 class InferenceOptions:
     """Optional information about the document."""
 
-    raw_text: List[str]
+    raw_text: Optional[List[str]]
 
     def __init__(self, raw_response: StringDict):
-        self.raw_text = raw_response["raw_text"]
+        self.raw_text = raw_response["raw_text"] if "raw_text" in raw_response else None

mindee/parsing/v2/inference_result.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from mindee.parsing.common.string_dict import StringDict
 from mindee.parsing.v2.inference_fields import InferenceFields
 from mindee.parsing.v2.inference_options import InferenceOptions
@@ -8,12 +10,16 @@ class InferenceResult:
 
     fields: InferenceFields
     """Fields contained in the inference."""
-    options: InferenceOptions
+    options: Optional[InferenceOptions]
     """Potential options retrieved alongside the inference."""
 
-    def __init__(self, json_response: StringDict) -> None:
-        self.fields = InferenceFields(json_response["fields"])
-        self.options = InferenceOptions(json_response["options"])
+    def __init__(self, raw_response: StringDict) -> None:
+        self.fields = InferenceFields(raw_response["fields"])
+        self.options = (
+            InferenceOptions(raw_response["options"])
+            if raw_response.get("options")
+            else None
+        )
 
     def __str__(self) -> str:
         str_fields = ""