♻️ refactor Endpoints and document building

Author: ianardee

mindee/client.py

@@ -12,7 +12,7 @@
 from mindee.response import format_response, DocumentResponse
 from mindee.http import (
     HTTPException,
-    Endpoint,
+    CustomEndpoint,
     InvoiceEndpoint,
     ReceiptEndpoint,
     PassportEndpoint,
@@ -149,7 +149,7 @@ def config_custom_doc(
             plural_name=plural_name,
             constructor=CustomDocument,
             endpoints=[
-                Endpoint(
+                CustomEndpoint(
                     owner=account_name,
                     url_name=document_type,
                     version=version,

mindee/documents/base.py

@@ -1,32 +1,43 @@
-from typing import List, Type
+from typing import List, Type, Optional
 
 # from mindee.inputs import InputDocument
 from mindee.http import Endpoint
 
 
 class Document:
     type: str
+    checklist: dict = {}
+    filepath: Optional[str] = None
+    filename: Optional[str] = None
+    file_extension: Optional[str] = None
 
     def __init__(
-        self, input_file, document_type: str, api_prediction, page_n=0
-    ):  # pylint: disable=unused-argument
-        self.filepath = None
-        self.filename = None
-        self.file_extension = None
-
-        if input_file is not None:
+        self,
+        input_file,
+        document_type: str,
+        api_prediction,
+        page_n: Optional[int] = None,
+    ):
+        if input_file:
             self.filepath = input_file.filepath
             self.filename = input_file.filename
             self.file_extension = input_file.file_extension
 
         self.type = document_type
-        self.checklist: dict = {}
+
+        self.build_from_api_prediction(api_prediction, page_n=page_n)
+        self._checklist()
+        self._reconstruct()
 
     @staticmethod
     def request(endpoints: List[Endpoint], input_file, include_words: bool = False):
         """Make request to the product endpoint"""
         raise NotImplementedError()
 
+    def build_from_api_prediction(self, api_prediction: dict, page_n):
+        """Build the document from an API response JSON"""
+        raise NotImplementedError()
+
     def _checklist(self, *args):
         raise NotImplementedError()
 

mindee/documents/custom_document.py

@@ -1,15 +1,15 @@
 from typing import Dict, List
 
 from mindee.documents.base import Document
-from mindee.http import make_api_request, Endpoint
+from mindee.http import Endpoint
 
 
 class CustomDocument(Document):
     fields: Dict[str, dict] = {}
 
     def __init__(
         self,
-        document_type: str = "",
+        document_type: str,
         api_prediction=None,
         input_file=None,
         page_n: int = 0,
@@ -20,14 +20,12 @@ def __init__(
         :param input_file: Input object
         :param page_n: Page number for multi pages pdf input
         """
-        # Invoke Document constructor
         super().__init__(
             input_file=input_file,
             document_type=document_type,
             api_prediction=api_prediction,
             page_n=page_n,
         )
-        self.build_from_api_prediction(api_prediction, page_n=page_n)
 
     def build_from_api_prediction(self, api_prediction, page_n: int = 0):
         """
@@ -62,9 +60,7 @@ def request(endpoints: List[Endpoint], input_file, include_words: bool = False):
         :param input_file: Input object
         :param endpoints: Endpoints config
         """
-        return make_api_request(
-            endpoints[0].predict_url, input_file, endpoints[0].api_key
-        )
+        return endpoints[0].predict_request(input_file, include_words)
 
     def _checklist(self):
         return {}

mindee/documents/financial_document.py

@@ -1,12 +1,7 @@
 from typing import List
 
-from mindee.fields.amount import Amount
-from mindee.fields.date import Date
-from mindee.fields.locale import Locale
-from mindee.fields.orientation import Orientation
-from mindee.fields.tax import Tax
 from mindee.fields import Field
-from mindee.http import make_api_request, Endpoint
+from mindee.http import Endpoint
 from mindee.documents.base import Document
 from mindee.documents.invoice import Invoice
 from mindee.documents.receipt import Receipt
@@ -17,50 +12,14 @@ def __init__(
         self,
         api_prediction=None,
         input_file=None,
-        locale=None,
-        total_incl=None,
-        total_excl=None,
-        date=None,
-        invoice_number=None,
-        due_date=None,
-        taxes=None,
-        merchant_name=None,
-        payment_details=None,
-        company_number=None,
-        vat_number=None,
-        orientation=None,
-        total_tax=None,
-        time=None,
         page_n=0,
         document_type="financial_doc",
     ):
         """
         :param api_prediction: Raw prediction from HTTP response
         :param input_file: Input object
-        :param locale: locale value for creating FinancialDocument object from scratch
-        :param total_incl: total_incl value for creating FinancialDocument object from scratch
-        :param total_excl: total_excl value for creating FinancialDocument object from scratch
-        :param date: date value for creating FinancialDocument object from scratch
-        :param invoice_number: invoice_number value for creating FinancialDocument object from scratch
-        :param due_date: due_date value for creating FinancialDocument object from scratch
-        :param taxes: taxes value for creating FinancialDocument object from scratch
-        :param merchant_name: merchant_name value for creating FinancialDocument object from scratch
-        :param payment_details: payment_details value for creating FinancialDocument object from scratch
-        :param company_number: company_number value for creating FinancialDocument object from scratch
-        :param vat_number: vat_number value for creating FinancialDocument object from scratch
-        :param orientation: orientation value for creating FinancialDocument object from scratch
-        :param total_tax: total_tax value for creating FinancialDocument object from scratch
-        :param time: time value for creating FinancialDocument object from scratch
         :param page_n: Page number for multi pages pdf input
         """
-        # Invoke Document constructor
-        super().__init__(
-            input_file=input_file,
-            document_type=document_type,
-            api_prediction=api_prediction,
-            page_n=page_n,
-        )
-
         self.locale = None
         self.total_incl = None
         self.total_excl = None
@@ -76,66 +35,24 @@ def __init__(
         self.total_tax = None
         self.time = None
 
-        if api_prediction is not None:
-            self.build_from_api_prediction(api_prediction, input_file, page_n=page_n)
-        else:
-            self.orientation = Orientation(
-                {"value": orientation}, value_key="value", page_n=page_n
-            )
-            self.locale = Locale({"value": locale}, value_key="value", page_n=page_n)
-            self.date = Date({"value": date}, value_key="value", page_n=page_n)
-            self.due_date = Date({"value": due_date}, value_key="value", page_n=page_n)
-            if taxes is not None:
-                self.taxes = [
-                    Tax(
-                        {"value": t[0], "rate": t[1]},
-                        page_n=page_n,
-                        value_key="value",
-                        rate_key="rate",
-                    )
-                    for t in taxes
-                ]
-            self.total_incl = Amount(
-                {"value": total_incl}, value_key="value", page_n=page_n
-            )
-            self.total_excl = Amount(
-                {"value": total_excl}, value_key="value", page_n=page_n
-            )
-            self.merchant_name = Field(
-                {"value": merchant_name}, value_key="value", page_n=page_n
-            )
-            self.time = Field({"value": time}, value_key="value", page_n=page_n)
-            self.total_tax = Amount(
-                {"value": total_tax}, value_key="value", page_n=page_n
-            )
-            self.vat_number = Field(
-                {"value": vat_number}, value_key="value", page_n=page_n
-            )
-            self.invoice_number = Field(
-                {"value": invoice_number}, value_key="value", page_n=page_n
-            )
-            self.payment_details = Field(
-                {"value": payment_details}, value_key="value", page_n=page_n
-            )
-            self.company_number = Field(
-                {"value": company_number}, value_key="value", page_n=page_n
-            )
-
-        # Run checks
-        self._checklist()
+        # need this for building from prediction
+        self.input_file = input_file
 
-        # Reconstruct extra fields
-        self._reconstruct()
+        super().__init__(
+            input_file=input_file,
+            document_type=document_type,
+            api_prediction=api_prediction,
+            page_n=page_n,
+        )
 
-    def build_from_api_prediction(self, api_prediction, input_file, page_n=0):
+    def build_from_api_prediction(self, api_prediction, page_n=0):
         """
         :param api_prediction: Raw prediction from HTTP response
-        :param input_file: Input object
         :param page_n: Page number for multi pages pdf input
         :return: (void) set the object attributes with api prediction values
         """
         if "invoice_number" in api_prediction.keys():
-            invoice = Invoice(api_prediction, input_file, page_n=page_n)
+            invoice = Invoice(api_prediction, self.input_file, page_n=page_n)
             self.locale = invoice.locale
             self.total_incl = invoice.total_incl
             self.total_excl = invoice.total_excl
@@ -150,7 +67,7 @@ def build_from_api_prediction(self, api_prediction, input_file, page_n=0):
             self.total_tax = invoice.total_tax
             self.time = Field({"value": None, "confidence": 0.0})
         else:
-            receipt = Receipt(api_prediction, input_file, page_n=page_n)
+            receipt = Receipt(api_prediction, self.input_file, page_n=page_n)
             self.orientation = receipt.orientation
             self.date = receipt.date
             self.due_date = receipt.date
@@ -204,12 +121,7 @@ def request(endpoints: List[Endpoint], input_file, include_words=False):
             index = 0
         else:
             index = 1
-        return make_api_request(
-            endpoints[index].predict_url,
-            input_file,
-            endpoints[index].api_key,
-            include_words,
-        )
+        return endpoints[index].predict_request(input_file, include_words)
 
     def _checklist(self):
         """