mindee 1.0.3 → 1.0.8

package/mindee/api/request.js

@@ -0,0 +1,67 @@
+const https = require("https");
+const { version: sdkVersion } = require("../../package.json");
+const { URL } = require("url");
+const FormData = require("form-data");
+
+const request = (url, method, headers, input, includeWords = false) => {
+  return new Promise(function (resolve, reject) {
+    const form = new FormData();
+    let body;
+    headers["User-Agent"] = `mindee-node/${sdkVersion} node/${process.version}`;
+
+    if (["path", "stream"].includes(input.inputType)) {
+      const fileParams = { filename: input.filename };
+      form.append("file", input.fileObject, fileParams);
+      if (includeWords) form.append("include_mvision", "true");
+      headers = { ...headers, ...form.getHeaders() };
+    } else if (input.inputType === "base64") {
+      let body_obj = { file: input.fileObject };
+      if (includeWords) body_obj["include_mvision"] = "true";
+      body = JSON.stringify(body_obj);
+      headers["Content-Type"] = "application/json";
+      headers["Content-Length"] = body.length;
+    }
+
+    const uri = new URL(url);
+    const options = {
+      method: method,
+      headers: headers,
+      hostname: uri.hostname,
+      path: `${uri.pathname}${uri.search}`,
+    };
+
+    const req = https.request(options, function (res) {
+      let responseBody = [];
+
+      res.on("data", function (chunk) {
+        responseBody += chunk;
+      });
+
+      res.on("end", function () {
+        try {
+          resolve({
+            ...res,
+            data: JSON.parse(responseBody),
+          });
+        } catch (error) {
+          console.log(responseBody);
+        }
+      });
+    });
+
+    req.on("error", (err) => {
+      reject(err);
+    });
+
+    if (["path", "stream"].includes(input.inputType)) {
+      form.pipe(req);
+    }
+
+    if (input.inputType === "base64") {
+      req.write(body);
+      req.end();
+    }
+  });
+};
+
+module.exports = request;

package/mindee/api/response.js

@@ -0,0 +1,62 @@
+const Document = require("../documents").document;
+const Receipt = require("../documents").receipt;
+const Invoice = require("../documents").invoice;
+const FinancialDocument = require("../documents").financialDocument;
+const fs = require("fs").promises;
+
+class Response {
+  constructor({
+    httpResponse,
+    documentType,
+    input,
+    error,
+    reconsctruted = false,
+    ...args
+  }) {
+    this.httpResponse = httpResponse;
+    this.documentType = documentType;
+    this.input = input;
+    if (!error && !reconsctruted) this.formatResponse();
+    if (reconsctruted === true) {
+      Object.assign(this, args);
+    }
+  }
+
+  async dump(path) {
+    return await fs.writeFile(path, JSON.stringify(Object.entries(this)));
+  }
+
+  static async load(path) {
+    const file = fs.readFile(path);
+    const args = JSON.parse(file);
+    return new Response({ reconsctruted: true, ...args });
+  }
+
+  formatResponse() {
+    const constructors = {
+      receipt: (params) => new Receipt(params),
+      invoice: (params) => new Invoice(params),
+      financialDocument: (params) => new FinancialDocument(params),
+    };
+    const predictions = this.httpResponse.data.predictions.entries();
+    this[`${this.documentType}s`] = [];
+
+    // Create a list of Document (Receipt, Invoice...) for each page of the input document
+    for (const [pageNumber, prediction] of predictions) {
+      this[`${this.documentType}s`].push(
+        constructors[this.documentType]({
+          apiPrediction: prediction,
+          inputFile: this.input,
+          pageNumber: pageNumber,
+        })
+      );
+    }
+
+    // Merge the list of Document into a unique Document
+    this[this.documentType] = Document.mergePages(
+      this[`${this.documentType}s`]
+    );
+  }
+}
+
+module.exports = Response;

package/mindee/documents/document.js

@@ -0,0 +1,65 @@
+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 (
+          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;