mindee 1.0.6 → 1.1.0

package/lib/inputs.js

@@ -16,11 +16,20 @@ var {
   PDFDocument
 } = require("pdf-lib");
 
+var concat = require("concat-stream");
+
+var {
+  Base64Encode
+} = require("base64-stream");
+
+var fileType = require("file-type");
+
+var ArrayBufferEncode = require("base64-arraybuffer");
+
 class Input {
   /**
    * @param {(String | Buffer)} file - the file that will be read. Either path or base64 string, or a steam
    * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
-   *                             NB: in case of base64 file, only jpeg file is supported
    *                             NB: dummy is only used for tests purposes
    * @param {String} filename - File name of the input
    * @param {Boolean} cut_pdf: Automatically reconstruct pdf with more than 4 pages
@@ -61,45 +70,60 @@ class Input {
     var _this = this;
 
     return _asyncToGenerator(function* () {
-      if (_this.inputType === "base64") _this.initBase64();else if (_this.inputType === "path") yield _this.initFile();else if (_this.inputType === "stream") yield _this.initStream();else _this.initDummy();
+      if (_this.inputType === "base64") yield _this.initBase64();else if (_this.inputType === "path") yield _this.initFile();else if (_this.inputType === "stream") yield _this.initStream();else _this.initDummy();
     })();
   }
 
   initBase64() {
-    this.fileObject = this.file;
-    this.filepath = undefined;
-    this.fileExtension = undefined;
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      _this2.fileObject = _this2.file;
+      _this2.filepath = undefined;
+      _this2.fileExtension = undefined;
+
+      if (_this2.allowCutPdf == true) {
+        var typeOfFile = yield fileType.fromBuffer(Buffer.from(_this2.fileObject, "base64"));
+
+        if (typeOfFile === undefined) {
+          console.error("Cannot detect mime type of: ".concat(_this2.fileObject));
+        } else if (typeOfFile.mime === "application/pdf") {
+          yield _this2.cutPdf();
+        }
+      }
+    })();
   }
 
   initFile() {
-    var _this2 = this;
+    var _this3 = this;
 
     return _asyncToGenerator(function* () {
-      _this2.fileObject = yield fs.readFile(_this2.file);
-      _this2.filepath = _this2.file;
-      _this2.filename = _this2.filename || path.basename(_this2.file); // Check if file type is valid
+      _this3.fileObject = yield fs.readFile(_this3.file);
+      _this3.filepath = _this3.file;
+      _this3.filename = _this3.filename || path.basename(_this3.file); // Check if file type is valid
 
-      var filetype = _this2.filename.split(".").pop();
+      var filetype = _this3.filename.split(".").pop();
 
-      if (!(filetype in _this2.MIMETYPES)) {
-        errorHandler.throw(new Error("File type is not allowed. It must be ".concat(Object.keys(_this2.MIMETYPES).toString())));
+      if (!(filetype in _this3.MIMETYPES)) {
+        errorHandler.throw(new Error("File type is not allowed. It must be ".concat(Object.keys(_this3.MIMETYPES).toString())));
       }
 
-      _this2.fileExtension = _this2.MIMETYPES[filetype];
+      _this3.fileExtension = _this3.MIMETYPES[filetype];
 
-      if (_this2.fileExtension === "application/pdf" && _this2.allowCutPdf == true) {
-        yield _this2.cutPdf();
+      if (_this3.fileExtension === "application/pdf" && _this3.allowCutPdf == true) {
+        yield _this3.cutPdf();
       }
     })();
   }
 
   initStream() {
-    var _this3 = this;
+    var _this4 = this;
 
     return _asyncToGenerator(function* () {
-      _this3.fileObject = _this3.file;
-      _this3.filename = _this3.filename || "stream";
-      _this3.filepath = undefined;
+      var file = yield _this4.streamToBase64(_this4.file);
+      _this4.file = file;
+      _this4.inputType = "base64";
+      yield _this4.initBase64();
     })();
   }
 
@@ -109,23 +133,53 @@ 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 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 */
 
 
   cutPdf() {
-    var _this4 = this;
+    var _this5 = this;
 
     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 = yield PDFDocument.load(_this5.fileObject, {
+        ignoreEncryption: true
+      });
       var splitedPdfDocument = yield PDFDocument.create();
       var pdfLength = pdfDocument.getPageCount();
-      if (pdfLength <= _this4.CUT_PDF_SIZE) return;
-      var pagesNumbers = [...Array(_this4.CUT_PDF_SIZE - 1).keys(), pdfLength - 1];
+      if (pdfLength <= _this5.CUT_PDF_SIZE) return;
+      var pagesNumbers = [...Array(_this5.CUT_PDF_SIZE - 1).keys(), pdfLength - 1];
       var pages = yield splitedPdfDocument.copyPages(pdfDocument, pagesNumbers);
       pages.forEach(page => splitedPdfDocument.addPage(page));
       var data = yield splitedPdfDocument.save();
-      _this4.fileObject = Buffer.from(data);
+
+      if (_this5.inputType === "path") {
+        _this5.fileObject = Buffer.from(data);
+      } else if (_this5.inputType === "base64") {
+        _this5.fileObject = ArrayBufferEncode.encode(data);
+      }
     })();
   }
 

package/mindee/api/financialDocument.js

@@ -0,0 +1,47 @@
+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: inputType,
+      filename: filename,
+      allowCutPdf: cutPdf,
+    });
+    await inputFile.init();
+    this.apiToken =
+      inputFile.fileExtension === "application/pdf"
+        ? this.invoiceToken
+        : this.receiptToken;
+    const url =
+      inputFile.fileExtension === "application/pdf"
+        ? "/invoices/v2/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,53 @@
+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: inputType,
+      filename: filename,
+      allowCutPdf: 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/v1/products/mindee/";
+    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 > 201) {
+      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,39 @@
+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: inputType,
+      filename: filename,
+      allowCutPdf: 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,70 @@
+const https = require("https");
+const { version: sdkVersion } = require("../../package.json");
+const { URL } = require("url");
+const FormData = require("form-data");
+const os = require("os");
+
+const request = (url, method, headers, input, includeWords = false) => {
+  return new Promise(function (resolve, reject) {
+    const form = new FormData();
+    let body;
+
+    headers["User-Agent"] = `mindee-api-nodejs@v${sdkVersion} nodejs-${
+      process.version
+    } ${os.type().toLowerCase()}`;
+    if (["path", "stream"].includes(input.inputType)) {
+      const fileParams = { filename: input.filename };
+      form.append("document", input.fileObject, fileParams);
+      if (includeWords) form.append("include_mvision", "true");
+      headers = { ...headers, ...form.getHeaders() };
+    } else if (input.inputType === "base64") {
+      let body_obj = { document: 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, error);
+        }
+      });
+    });
+
+    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,65 @@
+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.document.inference.pages.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.prediction,
+          inputFile: this.input,
+          pageNumber: pageNumber,
+        })
+      );
+    }
+
+    // Merge the list of Document into a unique Document
+    this[this.documentType] = constructors[this.documentType]({
+      apiPrediction: this.httpResponse.data.document.inference.prediction,
+      inputFile: this.input,
+      pageNumber: -1,
+      level: "document",
+    });
+  }
+}
+
+module.exports = Response;

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;