✨ add a basic logger

Author: ianardee

mindee/client.py

@@ -1,4 +1,5 @@
 import json
+from typing import Dict
 
 from mindee.inputs import (
     InputDocument,
@@ -7,13 +8,21 @@
     FileDocument,
     PathDocument,
 )
+from mindee.logger import logger
 from mindee.response import format_response, DocumentResponse
-from mindee.http import HTTPException
+from mindee.http import (
+    HTTPException,
+    Endpoint,
+    InvoiceEndpoint,
+    ReceiptEndpoint,
+    PassportEndpoint,
+)
 from mindee.document_config import DocumentConfig, DocumentConfigDict
 from mindee.documents.receipt import Receipt
 from mindee.documents.financial_document import FinancialDocument
 from mindee.documents.invoice import Invoice
 from mindee.documents.passport import Passport
+from mindee.documents.custom_document import CustomDocument
 
 
 class DocumentClient:
@@ -39,6 +48,8 @@ def parse(
         :param username:
         :param include_words: Bool, extract all words into http_response
         """
+        logger.debug("Parsing document as '%s'", document_type)
+
         found = []
         for k in self.doc_configs.keys():
             if k[1] == document_type:
@@ -107,12 +118,7 @@ def __init__(self, raise_on_error: bool = True):
         """
         :param raise_on_error: Raise an Exception on HTTP errors
         """
-        self._doc_configs = {
-            ("mindee", "receipt"): Receipt.get_document_config(),
-            ("mindee", "invoice"): Invoice.get_document_config(),
-            ("mindee", "financial_doc"): FinancialDocument.get_document_config(),
-            ("mindee", "passport"): Passport.get_document_config(),
-        }
+        self._doc_configs: Dict[tuple, DocumentConfig] = {}
         self.raise_on_error = raise_on_error
 
     def config_custom_doc(
@@ -138,14 +144,18 @@ def config_custom_doc(
                         If not set, use the latest version of the model.
         """
         self._doc_configs[(account_name, document_type)] = DocumentConfig(
-            {
-                "document_type": document_type,
-                "singular_name": singular_name,
-                "plural_name": plural_name,
-                "account_name": account_name,
-                "api_key": api_key,
-                "interface_version": version,
-            }
+            document_type=document_type,
+            singular_name=singular_name,
+            plural_name=plural_name,
+            constructor=CustomDocument,
+            endpoints=[
+                Endpoint(
+                    owner=account_name,
+                    url_name=document_type,
+                    version=version,
+                    api_key=api_key,
+                ),
+            ],
         )
         return self
 
@@ -157,8 +167,14 @@ def config_invoice(self, api_key: str = None):
 
         :param api_key: Invoice API key
         """
-        if api_key:
-            self._doc_configs[("mindee", "invoice")].endpoints[0].api_key = api_key
+        config = DocumentConfig(
+            document_type="invoice",
+            singular_name="invoice",
+            plural_name="invoices",
+            constructor=Invoice,
+            endpoints=[InvoiceEndpoint(api_key=api_key)],
+        )
+        self._doc_configs[("mindee", "invoice")] = config
         return self
 
     def config_receipt(self, api_key: str = None):
@@ -169,8 +185,14 @@ def config_receipt(self, api_key: str = None):
 
         :param api_key: Expense Receipt API key
         """
-        if api_key:
-            self._doc_configs[("mindee", "receipt")].endpoints[0].api_key = api_key
+        config = DocumentConfig(
+            document_type="receipt",
+            singular_name="receipt",
+            plural_name="receipts",
+            constructor=Receipt,
+            endpoints=[ReceiptEndpoint(api_key=api_key)],
+        )
+        self._doc_configs[("mindee", "receipt")] = config
         return self
 
     def config_financial_doc(
@@ -184,14 +206,17 @@ def config_financial_doc(
         :param receipt_api_key: Expense Receipt API key
         :param invoice_api_key: Invoice API key
         """
-        if invoice_api_key:
-            self._doc_configs[("mindee", "financial_doc")].endpoints[
-                0
-            ].api_key = invoice_api_key
-        if receipt_api_key:
-            self._doc_configs[("mindee", "financial_doc")].endpoints[
-                1
-            ].api_key = receipt_api_key
+        config = DocumentConfig(
+            document_type="financial_doc",
+            singular_name="financial_doc",
+            plural_name="financial_docs",
+            constructor=FinancialDocument,
+            endpoints=[
+                InvoiceEndpoint(api_key=invoice_api_key),
+                ReceiptEndpoint(api_key=receipt_api_key),
+            ],
+        )
+        self._doc_configs[("mindee", "financial_doc")] = config
         return self
 
     def config_passport(self, api_key: str = None):
@@ -202,8 +227,14 @@ def config_passport(self, api_key: str = None):
 
         :param api_key: Passport API key
         """
-        if api_key:
-            self._doc_configs[("mindee", "passport")].endpoints[0].api_key = api_key
+        config = DocumentConfig(
+            document_type="passport",
+            singular_name="passport",
+            plural_name="passports",
+            constructor=Passport,
+            endpoints=[PassportEndpoint(api_key=api_key)],
+        )
+        self._doc_configs[("mindee", "passport")] = config
         return self
 
     def doc_from_path(

mindee/document_config.py

@@ -1,60 +1,29 @@
-from typing import Dict, List, Any, Type
+from typing import Dict, List
 
-from mindee.http import Endpoint, API_TYPE_OFF_THE_SHELF, API_TYPE_CUSTOM
-from mindee.documents.base import Document
-from mindee.documents.custom_document import CustomDocument
+from mindee.http import Endpoint
+from mindee.documents.base import TypeDocument
 
 
 class DocumentConfig:
     document_type: str
-    api_type: str
     endpoints: List[Endpoint]
     singular_name: str
     plural_name: str
-
-    constructor: Type[Document]
-
-    def __init__(self, config: Dict[str, Any], api_type: str = API_TYPE_CUSTOM):
-        """
-        :param config: Object containing config
-        :param api_type: API_TYPE_OFF_THE_SHELF or API_TYPE_CUSTOM
-        """
-        self.api_type = api_type
-        self._load_config(config)
-
-    def _load_config(self, config):
-        # Check for document_type, singular_name and plural_name in config
-        for mandatory_field in ("document_type", "singular_name", "plural_name"):
-            if mandatory_field not in config.keys():
-                raise AssertionError(
-                    "%s key is required in custom_document configuration"
-                    % mandatory_field
-                )
-        self.document_type = config["document_type"]
-        self.singular_name = config["singular_name"]
-        self.plural_name = config["plural_name"]
-
-        if self.api_type == API_TYPE_CUSTOM:
-            self.constructor = CustomDocument
-            endpoint = Endpoint(
-                owner=config["account_name"],
-                url_name=config["document_type"],
-                version=config["interface_version"],
-            )
-            if config["api_key"]:
-                endpoint.api_key = config["api_key"]
-            else:
-                endpoint.set_api_key_from_env()
-            self.endpoints = [endpoint]
-
-        elif self.api_type == API_TYPE_OFF_THE_SHELF:
-            self.constructor = config["constructor"]
-            self.endpoints = config["endpoints"]
-            for endpoint in self.endpoints:
-                endpoint.set_api_key_from_env()
-
-        else:
-            raise RuntimeError("Unknown API type")
+    constructor: TypeDocument
+
+    def __init__(
+        self,
+        document_type: str,
+        singular_name: str,
+        plural_name: str,
+        constructor: TypeDocument,
+        endpoints: List[Endpoint],
+    ):
+        self.document_type = document_type
+        self.singular_name = singular_name
+        self.plural_name = plural_name
+        self.constructor = constructor
+        self.endpoints = endpoints
 
 
 DocumentConfigDict = Dict[tuple, DocumentConfig]

mindee/documents/base.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Type
 
 # from mindee.inputs import InputDocument
 from mindee.http import Endpoint
@@ -36,3 +36,6 @@ def _reconstruct(self, *args):
     def all_checks(self):
         """Return all checks"""
         return all(self.checklist)
+
+
+TypeDocument = Type[Document]

mindee/documents/financial_document.py

@@ -6,11 +6,10 @@
 from mindee.fields.orientation import Orientation
 from mindee.fields.tax import Tax
 from mindee.fields import Field
-from mindee.http import make_api_request, API_TYPE_OFF_THE_SHELF, Endpoint
+from mindee.http import make_api_request, Endpoint
 from mindee.documents.base import Document
 from mindee.documents.invoice import Invoice
 from mindee.documents.receipt import Receipt
-from mindee.document_config import DocumentConfig
 
 
 class FinancialDocument(Document):
@@ -128,33 +127,6 @@ def __init__(
         # Reconstruct extra fields
         self._reconstruct()
 
-    @staticmethod
-    def get_document_config():
-        """:return: the configuration for financial document"""
-        return DocumentConfig(
-            {
-                "constructor": FinancialDocument,
-                "endpoints": [
-                    Endpoint(
-                        owner="mindee",
-                        url_name="invoices",
-                        version="2",
-                        key_name="invoice",
-                    ),
-                    Endpoint(
-                        owner="mindee",
-                        url_name="expense_receipts",
-                        version="3",
-                        key_name="receipt",
-                    ),
-                ],
-                "document_type": "financial_doc",
-                "singular_name": "financial_doc",
-                "plural_name": "financial_docs",
-            },
-            api_type=API_TYPE_OFF_THE_SHELF,
-        )
-
     def build_from_api_prediction(self, api_prediction, input_file, page_n=0):
         """
         :param api_prediction: Raw prediction from HTTP response

mindee/documents/invoice.py

@@ -8,8 +8,7 @@
 from mindee.fields.orientation import Orientation
 from mindee.fields.payment_details import PaymentDetails
 from mindee.fields.tax import Tax
-from mindee.http import make_api_request, API_TYPE_OFF_THE_SHELF, Endpoint
-from mindee.document_config import DocumentConfig
+from mindee.http import make_api_request, Endpoint
 
 
 class Invoice(Document):
@@ -120,27 +119,6 @@ def __init__(
         # Reconstruct extra fields
         self._reconstruct()
 
-    @staticmethod
-    def get_document_config() -> DocumentConfig:
-        """:return: the configuration for invoice"""
-        return DocumentConfig(
-            {
-                "constructor": Invoice,
-                "endpoints": [
-                    Endpoint(
-                        owner="mindee",
-                        url_name="invoices",
-                        version="2",
-                        key_name="invoice",
-                    )
-                ],
-                "document_type": "invoice",
-                "singular_name": "invoice",
-                "plural_name": "invoices",
-            },
-            api_type=API_TYPE_OFF_THE_SHELF,
-        )
-
     def build_from_api_prediction(self, api_prediction: dict, page_n=0):
         """
         :param api_prediction: Raw prediction from HTTP response

mindee/documents/passport.py

@@ -4,8 +4,7 @@
 from mindee.documents.base import Document
 from mindee.fields import Field
 from mindee.fields.date import Date
-from mindee.http import make_api_request, API_TYPE_OFF_THE_SHELF, Endpoint
-from mindee.document_config import DocumentConfig
+from mindee.http import make_api_request, Endpoint
 
 
 class Passport(Document):
@@ -108,22 +107,6 @@ def __init__(
         # Reconstruct extra fields
         self._reconstruct()
 
-    @staticmethod
-    def get_document_config() -> DocumentConfig:
-        """:return: the configuration for passport"""
-        return DocumentConfig(
-            {
-                "constructor": Passport,
-                "endpoints": [
-                    Endpoint(owner="mindee", url_name="passport", version="1")
-                ],
-                "document_type": "passport",
-                "singular_name": "passport",
-                "plural_name": "passports",
-            },
-            api_type=API_TYPE_OFF_THE_SHELF,
-        )
-
     def build_from_api_prediction(self, api_prediction, page_n=0):
         """
         :param api_prediction: Raw prediction from HTTP response
@@ -159,17 +142,17 @@ def __str__(self) -> str:
         return (
             "-----Passport data-----\n"
             f"Filename: {self.filename}\n"
-            f"Full name: {self.full_name.value}\n"
+            f"Full name: {self.full_name}\n"
             f"Given names: {given_names}\n"
-            f"Surname: {self.surname.value}\n"
-            f"Country: {self.country.value}\n"
-            f"ID Number: {self.id_number.value}\n"
-            f"Issuance date: {self.issuance_date.value}\n"
-            f"Birth date: {self.birth_date.value}\n"
-            f"Expiry date: {self.expiry_date.value}\n"
-            f"MRZ 1: {self.mrz1.value}\n"
-            f"MRZ 2: {self.mrz2.value}\n"
-            f"MRZ: {self.mrz.value}\n"
+            f"Surname: {self.surname}\n"
+            f"Country: {self.country}\n"
+            f"ID Number: {self.id_number}\n"
+            f"Issuance date: {self.issuance_date}\n"
+            f"Birth date: {self.birth_date}\n"
+            f"Expiry date: {self.expiry_date}\n"
+            f"MRZ 1: {self.mrz1}\n"
+            f"MRZ 2: {self.mrz2}\n"
+            f"MRZ: {self.mrz}\n"
             "----------------------"
         )