mindee 1.3.2 → 2.0.0

package/mindee/api/invoice.js

@@ -1,53 +0,0 @@
-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 = "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);
-  }
-
-  /** 
-    @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

@@ -1,82 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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) {
-    let form = new FormData();
-
-    headers["User-Agent"] = `mindee-api-nodejs@v${sdkVersion} nodejs-${
-      process.version
-    } ${os.type().toLowerCase()}`;
-
-    const fileParams = { filename: input.filename };
-
-    if (input.inputType === "base64") {
-      form.append(
-        "document",
-        Buffer.from(input.fileObject, "base64"),
-        fileParams
-      );
-    } else {
-      form.append("document", input.fileObject, fileParams);
-    }
-    if (includeWords) {
-      form.append("include_mvision", "true");
-    }
-    headers = { ...headers, ...form.getHeaders() };
-
-    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.error(responseBody, error);
-        }
-      });
-    });
-
-    req.on("error", (err) => {
-      reject(err);
-    });
-
-    if (["path", "stream"].includes(input.inputType)) {
-      form.pipe(req);
-    }
-
-    if (input.inputType === "base64") {
-      form.pipe(req);
-    }
-  });
-};
-
-module.exports = request;

package/mindee/api/response.js

@@ -1,80 +0,0 @@
-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() {
-    let http_data_document = this.httpResponse.data.document;
-    const constructors = {
-      receipt: (params) => new Receipt(params),
-      invoice: (params) => new Invoice(params),
-      financialDocument: (params) => new FinancialDocument(params),
-    };
-
-    const predictions = http_data_document.inference.pages.entries();
-    this[`${this.documentType}s`] = [];
-    let document_words_content = [];
-
-    // Create a list of Document (Receipt, Invoice...) for each page of the input document
-    for (const [pageNumber, prediction] of predictions) {
-      let page_words_content = [];
-      if (
-        "ocr" in http_data_document &&
-        Object.keys(http_data_document.ocr).length > 0
-      ) {
-        page_words_content =
-          http_data_document.ocr["mvision-v1"].pages[pageNumber].all_words;
-        document_words_content.push(
-          ...http_data_document.ocr["mvision-v1"].pages[pageNumber].all_words
-        );
-      }
-      this[`${this.documentType}s`].push(
-        constructors[this.documentType]({
-          apiPrediction: prediction.prediction,
-          inputFile: this.input,
-          pageNumber: pageNumber,
-          words: page_words_content,
-        })
-      );
-    }
-
-    // Merge the list of Document into a unique Document
-    this[this.documentType] = constructors[this.documentType]({
-      apiPrediction: http_data_document.inference.prediction,
-      inputFile: this.input,
-      pageNumber: http_data_document.n_pages,
-      level: "document",
-      words: document_words_content,
-    });
-  }
-}
-
-module.exports = Response;

package/mindee/documents/document.js

@@ -1,69 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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 = prediction.confidence ? prediction.confidence : 0.0;
-    this.bbox = prediction.polygon ? prediction.polygon : [];
-    if (valueKey in prediction && prediction[valueKey] !== null) {
-      this.value = prediction[valueKey];
-      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

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

@@ -1,30 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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