mindee 1.0.6 → 1.0.7

package/CHANGELOG.md

@@ -1,39 +1,42 @@
 # CHANGELOG
 
-## v1.0.6 (2021-06-14)
+## v1.0.7 (2021-11-25)
 
 ### New
+- ✨ Added pdf page number parameter for multi-pages pdfs with file
 
-- ✨ Invoices return API document type
+### Changes
+- :arrow_up: upgrade path-parse dependency
+- :arrow_up: upgrade browserslist dependency
+- :arrow_up: upgrade lodash dependency
+- :arrow_up: upgrade y18n dependency
 
 ## v1.0.4 (2021-02-18)
 
 ### New
-
-- :sparkles: :zap: Add a parameter `filename` and a default filename for streams
+* :sparkles: :zap: Add a parameter `filename` and a default filename for streams
 
 ### Changes
+* :zap: Change parse function to use an object instead of multiples parameters
 
-- :zap: Change parse function to use an object instead of multiples parameters
 
 ## v1.0.3 (2021-02-01)
 
 ### Fixes
+* :bug: _request parameters
+* :bug: `pageNumber` default value
+* :bug: reconstruction method set fields to probability
 
-- :bug: \_request parameters
-- :bug: `pageNumber` default value
-- :bug: reconstruction method set fields to probability
 
 ## v1.0.2 (2021-02-01)
 
 ### Changes
-
-- :zap: Better coverage for total tax
+* :zap: Better coverage for total tax
 
 ### Fixes
+* :bug: `includeWords` is now working
 
-- :bug: `includeWords` is now working
 
 ## v1.0.1 (2021-01-11)
 
-- 🎉 First release
+* 🎉 First release

package/README.md

@@ -17,7 +17,7 @@ You can use the SDK easily by creating a Client like this :
 ```js
 const { Client } = require("mindee");
 
-const mindeeClient = Client({
+const mindeeClient = new Client({
   invoiceToken: "invoiceApiToken",
   receiptToken: "receiptExpenseApiToken",
 });

package/lib/inputs.js

@@ -16,6 +16,16 @@ var {
   PDFDocument
 } = require("pdf-lib");
 
+var magic = require("stream-mmmagic");
+
+var concat = require("concat-stream");
+
+var {
+  Base64Encode
+} = require("base64-stream");
+
+var ReadableStreamClone = require("readable-stream-clone");
+
 class Input {
   /**
    * @param {(String | Buffer)} file - the file that will be read. Either path or base64 string, or a steam
@@ -99,7 +109,15 @@ class Input {
     return _asyncToGenerator(function* () {
       _this3.fileObject = _this3.file;
       _this3.filename = _this3.filename || "stream";
-      _this3.filepath = undefined;
+      _this3.filepath = undefined; //Copy the ReadableStream
+
+      var stream = new ReadableStreamClone(_this3.fileObject);
+      _this3.fileObject = new ReadableStreamClone(_this3.fileObject);
+      var [mime, output] = yield magic.promise(stream);
+
+      if (mime.type === "application/pdf" && _this3.allowCutPdf == true) {
+        yield _this3.cutPdf();
+      }
     })();
   }
 
@@ -109,6 +127,29 @@ class Input {
     this.filepath = "";
     this.fileExtension = "";
   }
+  /**
+   * Convert ReadableStream to Base64 encoded String
+   *
+   * @param {*} stream ReadableStream to encode
+   * @returns Base64 encoded String
+   */
+
+
+  streamToBase64(stream) {
+    return _asyncToGenerator(function* () {
+      return yield new Promise((resolve, reject) => {
+        var base64 = new Base64Encode();
+
+        var cbConcat = base64 => {
+          resolve(base64);
+        };
+
+        stream.pipe(base64).pipe(concat(cbConcat)).on("error", error => {
+          reject(error);
+        });
+      });
+    })();
+  }
   /** Cut PDF if pages > 5 */
 
 
@@ -117,7 +158,14 @@ class Input {
 
     return _asyncToGenerator(function* () {
       // convert document to PDFDocument & cut CUT_PDF_SIZE - 1 first pages and last page
-      var pdfDocument = yield PDFDocument.load(_this4.fileObject);
+      var pdfDocument;
+
+      if (_this4.filename == "stream") {
+        pdfDocument = yield PDFDocument.load(yield _this4.streamToBase64(_this4.fileObject));
+      } else {
+        pdfDocument = yield PDFDocument.load(_this4.fileObject);
+      }
+
       var splitedPdfDocument = yield PDFDocument.create();
       var pdfLength = pdfDocument.getPageCount();
       if (pdfLength <= _this4.CUT_PDF_SIZE) return;

package/mindee/api/financialDocument.js

@@ -0,0 +1,40 @@
+const APIObject = require("./object");
+const Input = require("../inputs");
+
+class APIFinancialDocument extends APIObject {
+  constructor(invoiceToken, receiptToken) {
+    super(undefined, "financialDocument");
+    this.invoiceToken = invoiceToken;
+    this.receiptToken = receiptToken;
+  }
+
+  /**
+   * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
+   * @param {String} inputType: String in {'path', 'stream', 'base64'}
+   * @param {Boolean} includeWords: extract all words into http_response
+   * @param {String} version: expense_receipt api version
+   * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
+   * @returns {Response} Wrapped response with Receipts objects parsed
+   */
+  async parse({
+    input,
+    inputType = "path",
+    filename = undefined,
+    version = "3",
+    cutPdf = true,
+    includeWords = false,
+  }) {
+    const inputFile = new Input({ file: input, inputType, filename, cutPdf });
+    this.apiToken =
+      inputFile.fileExtension === "pdf" ? this.invoiceToken : this.receiptToken;
+    await inputFile.init();
+    const url =
+      inputFile.fileExtension === "pdf"
+        ? "/invoices/v1/predict"
+        : "/expense_receipts/v3/predict";
+    super.parse();
+    return await super._request(url, inputFile, version, includeWords);
+  }
+}
+
+module.exports = APIFinancialDocument;

package/mindee/api/index.js

@@ -0,0 +1,5 @@
+exports.APIObject = require("./object");
+exports.APIReceipt = require("./receipt");
+exports.Response = require("./response");
+exports.Request = require("./response");
+exports.Invoice = require("./invoice");

package/mindee/api/invoice.js

@@ -0,0 +1,48 @@
+const APIObject = require("./object");
+const Input = require("../inputs");
+
+class APIInvoice extends APIObject {
+  constructor(apiToken = undefined) {
+    super(apiToken, "invoice");
+    this.baseUrl = `${this.baseUrl}/invoices/`;
+  }
+
+  /**
+   * @param {Boolean} includeWords: , extract all words into http_response
+   * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
+   * @param {String} inputType: String in {'path', 'stream', 'base64'}
+   * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
+   * @param {String} version: expense_receipt api version
+   * @returns {Response} Wrapped response with Receipts objects parsed
+   */
+  async parse({
+    input,
+    inputType = "path",
+    filename = undefined,
+    version = "2",
+    cutPdf = true,
+    includeWords = false,
+  }) {
+    super.parse();
+    const inputFile = new Input({ file: input, inputType, filename, cutPdf });
+    await inputFile.init();
+    const url = `v${version}/predict`;
+    return await super._request(url, inputFile, includeWords);
+  }
+
+  /** 
+    @param {String} inputFile - Input object
+    @param {} response - HTTP response
+    @param {Document} documentType - Document class in {"Receipt", "Invoice", "Financial_document"}
+    @returns {Response}
+  */
+  wrapResponse(inputFile, response, documentType) {
+    let result = super.wrapResponse(inputFile, response, documentType);
+    result.documentType =
+      result.httpResponse.data?.predictions?.[0]?.document_type?.value?.toLowerCase() ||
+      result.documentType;
+    return result;
+  }
+}
+
+module.exports = APIInvoice;

package/mindee/api/object.js

@@ -0,0 +1,82 @@
+const Response = require("./response");
+const errorHandler = require("../errors/handler");
+const request = require("./request");
+
+/**
+ * Base class for APIs (APIReceipt & APIInvoice)
+ *  @param {String} apiToken - Token of the API used for parsing document
+ *  @param {String} apiName - Name of the API used for parsing document
+ */
+class APIObject {
+  constructor(apiToken = undefined, apiName = "") {
+    this.apiToken = apiToken;
+    this.baseUrl = "https://api.mindee.net/products";
+    this.apiName = apiName;
+  }
+
+  /**
+   */
+  parse() {
+    if (!this.apiToken) {
+      errorHandler.throw({
+        error: new Error(
+          `Missing API token for ${this.apiName}. \
+          Have you create a mindee Client with a ${this.apiName}Token in parameters ?`
+        ),
+      });
+    }
+  }
+
+  /** 
+    @param {String} url - API url for request
+    @param {Input} inputFile - input file for API
+    @param {Boolean} includeWords - Include Mindee vision words in Response
+    @returns {Response}
+  */
+  async _request(url, inputFile, includeWords = false) {
+    const headers = {
+      "X-Inferuser-Token": this.apiToken,
+    };
+    const response = await request(
+      `${this.baseUrl}${url}`,
+      "POST",
+      headers,
+      inputFile,
+      includeWords
+    );
+    return this.wrapResponse(inputFile, response, this.apiName);
+  }
+
+  /** 
+    @param {String} inputFile - Input object
+    @param {} response - HTTP response
+    @param {Document} documentType - Document class in {"Receipt", "Invoice", "Financial_document"}
+    @returns {Response}
+  */
+  wrapResponse(inputFile, response, documentType) {
+    if (response.statusCode != 200) {
+      const errorMessage = JSON.stringify(response.data, null, 4);
+      errorHandler.throw(
+        new Error(
+          `${this.apiName} API ${response.statusCode} HTTP error: ${errorMessage}`
+        ),
+        false
+      );
+      return new Response({
+        httpResponse: response,
+        documentType: documentType,
+        document: undefined,
+        input: inputFile,
+        error: true,
+      });
+    }
+    return new Response({
+      httpResponse: response,
+      documentType: documentType,
+      document: inputFile,
+      input: inputFile,
+    });
+  }
+}
+
+module.exports = APIObject;

package/mindee/api/receipt.js

@@ -0,0 +1,34 @@
+const APIObject = require("./object");
+const Input = require("../inputs");
+
+class APIReceipt extends APIObject {
+  constructor(apiToken = undefined) {
+    super(apiToken, "receipt");
+    this.baseUrl = `${this.baseUrl}/expense_receipts/`;
+  }
+
+  /**
+   * @param {String} file: Receipt filepath (allowed jpg, png, tiff, pdf)
+   * @param {String} inputType: String in {'path', 'stream', 'base64'}
+   * @param {Boolean} includeWords: extract all words into http_response
+   * @param {String} version: expense_receipt api version
+   * @param {Boolean} cutPdf: Automatically reconstruct pdf with more than 4 pages
+   * @returns {Response} Wrapped response with Receipts objects parsed
+   */
+  async parse({
+    input,
+    inputType = "path",
+    filename = undefined,
+    version = "3",
+    cutPdf = true,
+    includeWords = false,
+  }) {
+    super.parse();
+    const inputFile = new Input({ file: input, inputType, filename, cutPdf });
+    await inputFile.init();
+    const url = `v${version}/predict`;
+    return await super._request(url, inputFile, includeWords);
+  }
+}
+
+module.exports = APIReceipt;

package/mindee/api/request.js

@@ -0,0 +1,63 @@
+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 () {
+        resolve({
+          ...res,
+          data: JSON.parse(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;