mindee 1.0.4 → 1.0.9

package/mindee/documents/document.js

@@ -0,0 +1,69 @@
+const fs = require("fs").promises;
+
+class Document {
+  /**
+   * Takes a list of Documents and return one Document where
+   * each field is set with the maximum probability field
+   * @param {Input} inputFile - input file given to parse the document
+   */
+  constructor(inputFile = undefined) {
+    this.filepath = undefined;
+    this.filename = undefined;
+    this.fileExtension = undefined;
+
+    if (inputFile != undefined) {
+      this.filepath = inputFile.filepath;
+      this.filename = inputFile.filename;
+      this.fileExtension = inputFile.fileExtension;
+    }
+    this.checklist = {};
+  }
+
+  clone() {
+    return JSON.parse(JSON.stringify(this));
+  }
+
+  /** return true if all checklist of the document if true */
+  checkAll() {
+    return this.checklist.every((item) => item == true);
+  }
+
+  /** Export document into a JSON file */
+  async dump(path) {
+    return await fs.writeFile(path, JSON.stringify(Object.entries(this)));
+  }
+
+  /** Create a Document from a JSON file */
+  static async load(path) {
+    const file = fs.readFile(path);
+    const args = JSON.parse(file);
+    return new Document({ reconsctruted: true, ...args });
+  }
+
+  /**
+   * Takes a list of Documents and return one Document where
+   * each field is set with the maximum probability field
+   * @param {Array<Document>} documents - A list of Documents
+   */
+  static mergePages(documents) {
+    const finalDocument = documents[0].clone();
+    const attributes = Object.getOwnPropertyNames(finalDocument);
+    for (const document of documents) {
+      for (const attribute of attributes) {
+        if (Array.isArray(document?.[attribute])) {
+          finalDocument[attribute] = finalDocument[attribute]?.length
+            ? finalDocument[attribute]
+            : document?.[attribute];
+        } else if (
+          document?.[attribute]?.probability >
+          finalDocument[attribute].probability
+        ) {
+          finalDocument[attribute] = document?.[attribute];
+        }
+      }
+    }
+    return finalDocument;
+  }
+}
+
+module.exports = Document;

package/mindee/documents/fields/amount.js

@@ -0,0 +1,25 @@
+const Field = require("./field");
+
+class Amount extends Field {
+  /**
+   * @param {Object} prediction - Prediction object from HTTP response
+   * @param {String} valueKey - Key to use in the prediction dict
+   * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+   * @param {Integer} pageNumber - Page number for multi pages pdf
+   */
+  constructor({
+    prediction,
+    valueKey = "amount",
+    reconstructed = false,
+    pageNumber = 0,
+  }) {
+    super({ prediction, valueKey, reconstructed, pageNumber });
+    this.value = +parseFloat(prediction[valueKey]).toFixed(3);
+    if (isNaN(this.value)) {
+      this.value = undefined;
+      this.probability = 0;
+    }
+  }
+}
+
+module.exports = Amount;

package/mindee/documents/fields/date.js

@@ -0,0 +1,29 @@
+const Field = require("./field");
+
+class DateField extends Field {
+  /**
+   * @param {Object} prediction - Prediction object from HTTP response
+   * @param {String} valueKey - Key to use in the prediction dict
+   * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+   * @param {Integer} pageNumber - Page number for multi pages pdf
+   */
+  constructor({
+    prediction,
+    valueKey = "iso",
+    reconstructed = false,
+    pageNumber = 0,
+  }) {
+    super({ prediction, valueKey, reconstructed, pageNumber });
+    this.dateObject = new Date(this.value);
+    if (
+      !(this.dateObject instanceof Date) ||
+      isNaN(this.dateObject.valueOf())
+    ) {
+      this.dateObject = undefined;
+      this.probability = 0.0;
+      this.value = undefined;
+    }
+  }
+}
+
+module.exports = DateField;

package/mindee/documents/fields/field.js

@@ -0,0 +1,89 @@
+class Field {
+  /**
+   * @param {Object} prediction - Prediction object from HTTP response
+   * @param {String} valueKey - Key to use in the prediction dict
+   * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+   * @param {Integer} pageNumber - Page number for multi pages pdf
+   * @param {Array<String>} extraFields - Extra fields to get from the prediction and to set as attribute of the Field
+   */
+  constructor({
+    prediction,
+    valueKey = "value",
+    reconstructed = false,
+    extraFields,
+    pageNumber,
+  }) {
+    this.pageNumber = pageNumber;
+    this.reconstructed = reconstructed;
+    this.value = undefined;
+    this.probability = 0.0;
+    this.bbox = [];
+    if (valueKey in prediction && prediction[valueKey] !== "N/A") {
+      this.value = prediction[valueKey];
+      if (prediction.probability) this.probability = prediction.probability;
+      if (prediction.segmentation)
+        this.bbox = prediction.segmentation.bounding_box || [];
+      if (extraFields) {
+        for (const fieldName of extraFields) {
+          this[fieldName] = prediction[fieldName];
+        }
+      }
+    }
+  }
+
+  compare(other) {
+    if (this.value == null && other.value == null) return true;
+    else if (this.value == null || other.value == null) return false;
+    else {
+      if (typeof this.value == "string") {
+        return this.value.toLowerCase() === other.value.toLowerCase();
+      } else {
+        return this.value === other.value;
+      }
+    }
+  }
+
+  /**
+  @param {Array<Field>} array1 - first Array of Fields
+  @param {Array<Field>} array2 - second Array of Fields
+  @param {String} attr - Attribute to compare
+  @returns {Boolean} - true if all elements in array1 exist in array2 and vice-versa, false otherwise
+   */
+  static compareArrays(array1, array2, attr = "value") {
+    const list1 = array1.map((item) => item[attr]);
+    const list2 = array2.map((item) => item[attr]);
+    if (list1.length !== list2.length) return false;
+    for (const item1 of list1) {
+      if (!list2.includes(item1)) return false;
+    }
+    return true;
+  }
+
+  /**
+   * @param {Array<Field>} array - Array of Fields
+   * @returns {Number} product of all the fields probaility
+   */
+  static arrayProbability(array) {
+    let total = 1.0;
+    for (const field of array) {
+      total *= field.probability;
+      if (isNaN(total)) return 0.0;
+    }
+    return total;
+  }
+
+  /**
+   * @param {Array<Field>} array - Array of Fields
+   * @returns {Number} Sum of all the Fields values in the array
+   */
+  static arraySum(array) {
+    let total = 0;
+    for (const field of array) {
+      total += field.value;
+      if (isNaN(total)) return 0.0;
+    }
+    return total;
+  }
+}
+
+module.exports = Field;

package/mindee/documents/fields/index.js

@@ -0,0 +1,7 @@
+exports.field = require("./field");
+exports.date = require("./date");
+exports.amount = require("./amount");
+exports.locale = require("./locale");
+exports.orientation = require("./orientation");
+exports.paymentDetails = require("./paymentDetails");
+exports.tax = require("./tax.js");

package/mindee/documents/fields/locale.js

@@ -0,0 +1,30 @@
+const Field = require("./field");
+
+class Locale extends Field {
+  /**
+   * @param {Object} prediction - Prediction object from HTTP response
+   * @param {String} valueKey - Key to use in the prediction dict
+   * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+   * @param {Integer} pageNumber - Page number for multi pages pdf
+   */
+  constructor({
+    prediction,
+    valueKey = "value",
+    reconstructed = false,
+    pageNumber = 0,
+  }) {
+    super({ prediction, valueKey, reconstructed, pageNumber });
+
+    this.language = undefined;
+    this.country = undefined;
+    this.currency = undefined;
+    if ("language" in prediction && prediction.language !== "N/A")
+      this.language = prediction.language;
+    if ("country" in prediction && prediction.country !== "N/A")
+      this.country = prediction.country;
+    if ("currency" in prediction && prediction.currency !== "N/A")
+      this.currency = prediction.currency;
+  }
+}
+
+module.exports = Locale;

package/mindee/documents/fields/orientation.js

@@ -0,0 +1,24 @@
+const Field = require("./field");
+
+class Orientation extends Field {
+  /**
+   * @param {Object} prediction - Prediction object from HTTP response
+   * @param {String} valueKey - Key to use in the prediction dict
+   * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+   * @param {Integer} pageNumber - Page number for multi pages pdf
+   */
+  constructor({
+    prediction,
+    valueKey = "degrees",
+    reconstructed = false,
+    pageNumber = 0,
+  }) {
+    const orientations = [0, 90, 180, 270];
+    super({ prediction, valueKey, reconstructed, pageNumber });
+    this.value = parseInt(prediction[valueKey]);
+    if (isNaN(this.value)) this.probability = 0.0;
+    if (!orientations.includes(this.value)) this.value = 0;
+  }
+}
+
+module.exports = Orientation;

package/mindee/documents/fields/paymentDetails.js

@@ -0,0 +1,52 @@
+const Field = require("./field");
+
+class PaymentDetails extends Field {
+  /**
+   * @param {Object} prediction - Prediction object from HTTP response
+   * @param {String} valueKey - Key to use in the prediction dict to get the iban
+   * @param {String} accountNumberKey - Key to use to get the account number in the prediction dict
+   * @param {String} ibanKey - Key to use to get the IBAN in the prediction dict
+   * @param {String} routingNumberKey - Key to use to get the routing number in the prediction dict
+   * @param {String} swiftKey - Key to use to get the SWIFT in the prediction dict
+   * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+   * @param {Integer} pageNumber - Page number for multi pages pdf
+   */
+  constructor({
+    prediction,
+    valueKey = "iban",
+    accountNumberKey = "account_number",
+    ibanKey = "iban",
+    routingNumberKey = "routing_number",
+    swiftKey = "swift",
+    reconstructed = false,
+    pageNumber = 0,
+  }) {
+    super({ prediction, valueKey, reconstructed, pageNumber });
+
+    this.accountNumber = undefined;
+    this.iban = undefined;
+    this.routingNumber = undefined;
+    this.swift = undefined;
+
+    this.#setKey(prediction[accountNumberKey], "accountNumber");
+    this.#setKey(prediction[ibanKey], "iban");
+    this.#setKey(prediction[routingNumberKey], "routingNumber");
+    this.#setKey(prediction[swiftKey], "swift");
+  }
+
+  #setKey(value, key) {
+    if (typeof value === "string" && value !== "N/A") this[key] = value;
+    else this[key] = undefined;
+  }
+
+  toString() {
+    let str = "";
+    const keys = ["accountNumber", "iban", "routingNumber", "swift"];
+    for (const key of keys) {
+      if (this[key]) str += `${this[key]}; `;
+    }
+    return str;
+  }
+}
+
+module.exports = PaymentDetails;

package/mindee/documents/fields/tax.js

@@ -0,0 +1,47 @@
+const Field = require("./field");
+
+class Tax extends Field {
+  /**
+   * @param {Object} prediction - Prediction object from HTTP response
+   * @param {String} valueKey - Key to use in the prediction dict to get the tax value
+   * @param {String} rateKey - Key to use to get the tax rate in the prediction dict
+   * @param {String} codeKey - Key to use to get the tax code in the prediction dict
+   * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+   * @param {Integer} pageNumber - Page number for multi pages pdf
+   */
+  constructor({
+    prediction,
+    valueKey = "value",
+    rateKey = "rate",
+    codeKey = "code",
+    reconstructed = false,
+    pageNumber = 0,
+  }) {
+    super({ prediction, valueKey, reconstructed, pageNumber });
+
+    this.rate = parseFloat(prediction[rateKey]);
+    if (isNaN(this.rate)) this.rate = undefined;
+
+    this.code = prediction[codeKey]?.toString();
+    if (this.code === "N/A") this.code = undefined;
+
+    this.value = parseFloat(prediction[valueKey]);
+    if (isNaN(this.value)) {
+      this.value = undefined;
+      this.probability = 0.0;
+    }
+  }
+
+  toString() {
+    let str = "";
+    const keys = ["value", "rate", "code"];
+    for (const [i, key] of keys.entries()) {
+      const value = this[key] === undefined ? "_" : this[key].toString();
+      if (i < keys.length - 1) str += `${value}${key === "rate" ? "%" : ""}; `;
+      else str += value;
+    }
+    return str;
+  }
+}
+
+module.exports = Tax;

package/mindee/documents/financialDocument.js

@@ -0,0 +1,204 @@
+const Document = require("./document");
+const Invoice = require("./invoice");
+const Receipt = require("./receipt");
+const Field = require("./fields").field;
+const Date = require("./fields").date;
+const Amount = require("./fields").amount;
+const Locale = require("./fields").locale;
+const Orientation = require("./fields").orientation;
+const Tax = require("./fields").tax;
+
+class FinancialDocument extends Document {
+  /**
+   *  @param {Object} apiPrediction - Json parsed prediction from HTTP response
+   *  @param {Input} input - Input object
+   *  @param {Integer} pageNumber - Page number for multi pages pdf input
+   *  @param {Object} locale - locale value for creating FinancialDocument object from scratch
+   *  @param {Object} totalIncl - total tax included value for creating FinancialDocument object from scratch
+   *  @param {Object} totalExcl - total tax excluded value for creating FinancialDocument object from scratch
+   *  @param {Object} Date - date value for creating FinancialDocument object from scratch
+   *  @param {Object} InvoiceNumber - Invoice number value for creating FinancialDocument object from scratch
+   *  @param {Object} taxes - taxes value for creating FinancialDocument object from scratch
+   *  @param {Object} merchantName - merchant name value for creating FinancialDocument object from scratch
+   *  @param {Object} paymentDetails - payment details value for creating FinancialDocument object from scratch
+   *  @param {Object} companyNumber - company number value for creating FinancialDocument object from scratch
+   *  @param {Object} vatNumber - vat number value for creating FinancialDocument object from scratch
+   *  @param {Object} orientation - orientation value for creating FinancialDocument object from scratch
+   *  @param {Object} totalTax - total tax value for creating FinancialDocument object from scratch
+   *  @param {Object} time - time value for creating FinancialDocument object from scratch
+   *  @param {Object} pageNumber - pageNumber for multi pages pdf input
+   */
+  constructor({
+    apiPrediction = undefined,
+    inputFile = undefined,
+    locale = undefined,
+    totalIncl = undefined,
+    totalExcl = undefined,
+    date = undefined,
+    invoiceNumber = undefined,
+    dueDate = undefined,
+    taxes = undefined,
+    merchantName = undefined,
+    paymentDetails = undefined,
+    companyNumber = undefined,
+    vatNumber = undefined,
+    orientation = undefined,
+    totalTax = undefined,
+    time = undefined,
+    pageNumber = 0,
+  }) {
+    super(inputFile);
+    if (apiPrediction === undefined) {
+      this.#initFromScratch({
+        locale,
+        totalIncl,
+        totalExcl,
+        date,
+        invoiceNumber,
+        dueDate,
+        taxes,
+        merchantName,
+        paymentDetails,
+        companyNumber,
+        vatNumber,
+        orientation,
+        pageNumber,
+        totalTax,
+        time,
+      });
+    } else {
+      this.#initFromApiPrediction(apiPrediction, inputFile, pageNumber);
+    }
+    this.#checklist();
+  }
+
+  #initFromScratch({
+    locale,
+    totalIncl,
+    totalExcl,
+    totalTax,
+    date,
+    invoiceNumber,
+    dueDate,
+    taxes,
+    paymentDetails,
+    companyNumber,
+    vatNumber,
+    orientation,
+    pageNumber,
+    merchantName,
+    time,
+  }) {
+    const constructPrediction = function (item) {
+      return { prediction: { value: item }, valueKey: "value", pageNumber };
+    };
+    this.locale = new Locale(constructPrediction(locale));
+    this.totalIncl = new Amount(constructPrediction(totalIncl));
+    this.totalExcl = new Amount(constructPrediction(totalExcl));
+    this.totalTax = new Amount(constructPrediction(totalTax));
+    this.date = new Date(constructPrediction(date));
+    this.dueDate = new Date(constructPrediction(dueDate));
+    this.merchantName = new Field(constructPrediction(merchantName));
+    this.time = new Field(constructPrediction(time));
+    this.orientation = new Orientation(constructPrediction(orientation));
+    this.invoiceNumber = new Field(constructPrediction(invoiceNumber));
+    this.paymentDetails = new Field(constructPrediction(paymentDetails));
+    this.companyNumber = new Field(constructPrediction(companyNumber));
+    this.vatNumber = new Field(constructPrediction(vatNumber));
+    if (taxes !== undefined) {
+      this.taxes = [];
+      for (const t of taxes) {
+        this.taxes.push(
+          new Tax({
+            prediction: { value: t[0], rate: t[1] },
+            pageNumber,
+            valueKey: "value",
+            rateKey: "rate",
+          })
+        );
+      }
+    }
+  }
+
+  #initFromApiPrediction(apiPrediction, inputFile, pageNumber) {
+    if (Object.keys(apiPrediction).includes("invoice_number")) {
+      const invoice = new Invoice({ apiPrediction, inputFile, pageNumber });
+      Object.assign(this, invoice);
+      this.time = new Field({
+        prediction: { value: undefined, probability: 0.0 },
+      });
+      this.merchantName = new Field({
+        prediction: { value: undefined, probability: 0.0 },
+      });
+    } else {
+      const receipt = new Receipt({ apiPrediction, inputFile, pageNumber });
+      Object.assign(this, receipt);
+      this.invoiceDate = new Field({
+        prediction: { value: undefined, probability: 0.0 },
+      });
+      this.invoiceNumber = new Field({
+        prediction: { value: undefined, probability: 0.0 },
+      });
+      this.dueDate = new Field({
+        prediction: { value: undefined, probability: 0.0 },
+      });
+      this.paymentDetails = new Field({
+        prediction: { value: undefined, probability: 0.0 },
+      });
+      this.companyNumber = new Field({
+        prediction: { value: undefined, probability: 0.0 },
+      });
+    }
+  }
+
+  toString() {
+    return `
+    -----Financial document-----
+    Filename: ${this.filename}
+    Total amount: ${this.totalIncl.value}
+    Date: ${this.date.value}
+    Merchant name: ${this.merchantName.value}
+    Total taxes: ${this.totalTax.value}
+    `;
+  }
+
+  #checklist() {
+    this.checklist = {
+      taxesMatchTotalIncl: this.#taxesMatchTotalIncl(),
+    };
+  }
+
+  #taxesMatchTotalIncl() {
+    // Check taxes and total include exist
+    if (this.taxes.length === 0 || this.totalIncl.value === undefined)
+      return false;
+
+    // Reconstruct totalIncl from taxes
+    let totalVat = 0;
+    let reconstructedTotal = 0;
+    this.taxes.forEach((tax) => {
+      if (tax.value === undefined || !tax.rate) return false;
+      totalVat += tax.value;
+      reconstructedTotal += tax.value + (100 * tax.value) / tax.rate;
+    });
+
+    // Sanity check
+    if (totalVat <= 0) return false;
+
+    // Crate epsilon
+    const eps = 1 / (100 * totalVat);
+
+    if (
+      this.totalIncl.value * (1 - eps) - 0.02 <= reconstructedTotal &&
+      reconstructedTotal <= this.totalIncl.value * (1 + eps) + 0.02
+    ) {
+      this.taxes = this.taxes.map((tax) => ({ ...tax, probability: 1.0 }));
+      this.totalTax.probability = 1.0;
+      this.totalIncl.probability = 1.0;
+      return true;
+    }
+    return false;
+  }
+}
+
+module.exports = FinancialDocument;

package/mindee/documents/index.js

@@ -0,0 +1,5 @@
+exports.fields = require("./fields");
+exports.document = require("./document");
+exports.receipt = require("./receipt");
+exports.invoice = require("./invoice");
+exports.financialDocument = require("./financialDocument");