mindee 1.3.2 → 2.0.0

package/mindee/documents/receipt.js

@@ -1,287 +0,0 @@
-const Document = require("./document");
-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;
-const fs = require("fs").promises;
-
-class Receipt 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 Receipt object from scratch
-   *  @param {Object} totalIncl - total tax Included value for creating Receipt object from scratch
-   *  @param {Object} date - date value for creating Receipt object from scratch
-   *  @param {Object} category - category value for creating Receipt object from scratch
-   *  @param {Object} merchantName - merchant name value for creating Receipt object from scratch
-   *  @param {Object} time - time value for creating Receipt object from scratch
-   *  @param {Object} taxes - taxes value for creating Receipt object from scratch
-   *  @param {Object} orientation - orientation value for creating Receipt object from scratch
-   *  @param {Object} totalTax - total taxes value for creating Receipt object from scratch
-   *  @param {Object} totalExcl - total taxes excluded value for creating Receipt object from scratch
-   *  @param {String} level - specify whether object is built from "page" level or "document" level prediction
-   */
-  constructor({
-    apiPrediction = undefined,
-    inputFile = undefined,
-    locale = undefined,
-    totalIncl = undefined,
-    date = undefined,
-    category = undefined,
-    merchantName = undefined,
-    time = undefined,
-    taxes = undefined,
-    orientation = undefined,
-    totalTax = undefined,
-    totalExcl = undefined,
-    words = undefined,
-    pageNumber = 0,
-    level = "page",
-  }) {
-    super(inputFile);
-    this.level = level;
-    this.constructPrediction = function (item) {
-      return { prediction: { value: item }, valueKey: "value", pageNumber };
-    };
-    if (apiPrediction === undefined) {
-      this.#initFromScratch({
-        locale,
-        totalExcl,
-        totalIncl,
-        date,
-        category,
-        merchantName,
-        time,
-        taxes,
-        orientation,
-        totalTax,
-        pageNumber,
-      });
-    } else {
-      this.#initFromApiPrediction(apiPrediction, pageNumber, words);
-    }
-    this.#checklist();
-    this.#reconstruct();
-  }
-
-  #initFromScratch({
-    locale,
-    totalExcl,
-    totalIncl,
-    date,
-    category,
-    merchantName,
-    time,
-    taxes,
-    orientation,
-    totalTax,
-    pageNumber,
-  }) {
-    this.locale = new Locale(this.constructPrediction(locale));
-    this.totalIncl = new Amount(this.constructPrediction(totalIncl));
-    this.date = new Date(this.constructPrediction(date));
-    this.category = new Field(this.constructPrediction(category));
-    this.merchantName = new Field(this.constructPrediction(merchantName));
-    this.time = new Field(this.constructPrediction(time));
-    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",
-          })
-        );
-      }
-    }
-    this.orientation = new Orientation(this.constructPrediction(orientation));
-    this.totalTax = new Amount(this.constructPrediction(totalTax));
-    this.totalExcl = new Amount(this.constructPrediction(totalExcl));
-  }
-
-  /**
-    Set the object attributes with api prediction values
-    @param apiPrediction: Raw prediction from HTTP response
-    @param pageNumber: Page number for multi pages pdf input
-   */
-  #initFromApiPrediction(apiPrediction, pageNumber, words) {
-    this.locale = new Locale({ prediction: apiPrediction.locale, pageNumber });
-    this.totalIncl = new Amount({
-      prediction: apiPrediction.total_incl,
-      valueKey: "value",
-      pageNumber,
-    });
-    this.date = new Date({
-      prediction: apiPrediction.date,
-      valueKey: "value",
-      pageNumber,
-    });
-    this.category = new Field({
-      prediction: apiPrediction.category,
-      pageNumber,
-    });
-    this.merchantName = new Field({
-      prediction: apiPrediction.supplier,
-      valueKey: "value",
-      pageNumber,
-    });
-    this.time = new Field({
-      prediction: apiPrediction.time,
-      valueKey: "value",
-      pageNumber,
-    });
-    this.taxes = apiPrediction.taxes.map(
-      (taxPrediction) =>
-        new Tax({
-          prediction: taxPrediction,
-          pageNumber,
-          valueKey: "value",
-          rateKey: "rate",
-          codeKey: "code",
-        })
-    );
-    this.totalTax = new Amount({
-      prediction: { value: undefined, confidence: 0 },
-      valueKey: "value",
-      pageNumber,
-    });
-    this.totalExcl = new Amount({
-      prediction: { value: undefined, confidence: 0 },
-      valueKey: "value",
-      pageNumber,
-    });
-    if (this.level === "page") {
-      this.orientation = new Orientation({
-        prediction: apiPrediction.orientation,
-        pageNumber,
-      });
-    } else {
-      this.orientation = new Orientation(
-        this.constructPrediction({
-          prediction: {
-            value: undefined,
-            confidence: 0.0,
-            degrees: undefined,
-          },
-        })
-      );
-    }
-    if (words && words.length > 0) this.words = words;
-  }
-
-  toString() {
-    return `
-    -----Receipt data-----
-    Filename: ${this.filename}
-    Total amount: ${this.totalIncl.value}
-    Date: ${this.date.value}
-    Category: ${this.category.value}
-    Time: ${this.time.value}
-    Merchant name: ${this.merchantName.value}
-    Taxes: ${this.taxes.map((tax) => tax.toString()).join(" - ")}
-    Total taxes: ${this.totalTax.value}
-    `;
-  }
-
-  static async load(path) {
-    const file = fs.readFile(path);
-    const args = JSON.parse(file);
-    return new Receipt({ reconsctruted: true, ...args });
-  }
-
-  /**
-   * Call all check methods
-   */
-  #checklist() {
-    this.checklist = { taxesMatchTotalIncl: this.#taxesMatchTotal() };
-  }
-
-  #taxesMatchTotal() {
-    // Check taxes and total amount exist
-
-    if (this.taxes.length === 0 || this.totalIncl.value == null) return false;
-
-    // Reconstruct total_incl from taxes
-    let totalVat = 0;
-    let reconstructedTotal = 0;
-    this.taxes.forEach((tax) => {
-      if (tax.value == null || !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;
-  }
-
-  /**
-   * Call all fields that need to be reconstructed
-   */
-  #reconstruct() {
-    this.#reconstructTotalExclFromTCCAndTaxes();
-    this.#reconstructTotalTax();
-  }
-
-  /**
-   * Set this.totalExcl with Amount object
-   * The totalExcl Amount value is the difference between totalIncl and sum of taxes
-   * The totalExcl Amount probability is the product of this.taxes probabilities multiplied by totalIncl probability
-   */
-  #reconstructTotalExclFromTCCAndTaxes() {
-    if (this.taxes.length && this.totalIncl.value != null) {
-      const totalExcl = {
-        value: this.totalIncl.value - Field.arraySum(this.taxes),
-        confidence:
-          Field.arrayProbability(this.taxes) * this.totalIncl.probability,
-      };
-      this.totalExcl = new Amount({
-        prediction: totalExcl,
-        valueKey: "value",
-        reconstructed: true,
-      });
-    }
-  }
-
-  /**
-   * Set this.totalTax with Amount object
-   * The totalTax Amount value is the sum of all this.taxes value
-   * The totalTax Amount probability is the product of this.taxes probabilities
-   */
-  #reconstructTotalTax() {
-    if (this.taxes.length && this.totalTax.value == null) {
-      const totalTax = {
-        value: this.taxes
-          .map((tax) => tax.value || 0)
-          .reduce((a, b) => a + b, 0),
-        confidence: Field.arrayProbability(this.taxes),
-      };
-      if (totalTax.value > 0)
-        this.totalTax = new Amount({
-          prediction: totalTax,
-          valueKey: "value",
-          reconstructed: true,
-        });
-    }
-  }
-}
-
-module.exports = Receipt;

package/mindee/errors/handler.js

@@ -1,16 +0,0 @@
-const logger = require("../logger");
-
-class ErrorHandler {
-  constructor(throwOnError = true) {
-    this.throwOnError = throwOnError;
-  }
-
-  throw(error, force = true) {
-    if (this.throwOnError || force) throw error;
-    else logger.error(error.message);
-  }
-}
-
-const errorHandler = new ErrorHandler();
-
-module.exports = errorHandler;

package/mindee/index.js

@@ -1,36 +0,0 @@
-const errorHandler = require("./errors/handler");
-const logger = require("./logger");
-const APIReceipt = require("./api/receipt");
-const APIInvoice = require("./api/invoice");
-const APIFinancialDocument = require("./api/financialDocument");
-
-class Client {
-  /**
-   * @param {string} receiptToken - Receipt Expense Token from Mindee dashboard
-   * @param {string} invoiceToken - Invoice Token from Mindee dashboard
-   * @param {boolean} throwOnError - Throw if an error is send from the API / SDK (true by default)
-   * @param {boolean} debug - Enable debug logging (disable by default)
-   */
-  constructor({
-    receiptToken = undefined,
-    invoiceToken = undefined,
-    throwOnError = true,
-    debug = undefined,
-  } = {}) {
-    this.receiptToken = receiptToken || process.env.MINDEE_RECEIPT_TOKEN;
-    this.invoiceToken = invoiceToken || process.env.MINDEE_INVOICE_TOKEN;
-    errorHandler.throwOnError = throwOnError;
-    logger.level = debug ?? process.env.MINDEE_DEBUG ? "debug" : "warn";
-    this.receipt = new APIReceipt(this.receiptToken);
-    this.invoice = new APIInvoice(this.invoiceToken);
-    this.financialDocument = new APIFinancialDocument(
-      this.invoiceToken,
-      this.receiptToken
-    );
-  }
-}
-
-exports.Client = Client;
-exports.documents = require("./documents");
-exports.api = require("./api");
-exports.inputs = require("./inputs");

package/mindee/inputs.js

@@ -1,158 +0,0 @@
-const fs = require("fs").promises;
-const errorHandler = require("./errors/handler");
-const path = require("path");
-const { PDFDocument } = require("pdf-lib");
-const concat = require("concat-stream");
-const { Base64Encode } = require("base64-stream");
-const fileType = require("file-type");
-const ArrayBufferEncode = require("base64-arraybuffer");
-
-class Input {
-  MIMETYPES = {
-    png: "image/png",
-    jpg: "image/jpg",
-    jpeg: "image/jpeg",
-    webp: "image/webp",
-    pdf: "application/pdf",
-  };
-  ALLOWED_INPUT_TYPE = ["base64", "path", "stream", "dummy"];
-  CUT_PDF_SIZE = 5;
-
-  /**
-   * @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: 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
-   * NB: Because of async calls, init() should be called after creating the object
-   */
-  constructor({ file, filename = undefined, inputType, allowCutPdf = true }) {
-    // Check if inputType is valid
-    if (!this.ALLOWED_INPUT_TYPE.includes(inputType)) {
-      errorHandler.throw(
-        new Error(
-          `The input type is invalid. It should be \
-            ${this.ALLOWED_INPUT_TYPE.toString()}`
-        )
-      );
-    }
-    this.file = file;
-    this.filename = filename;
-    this.inputType = inputType;
-    this.allowCutPdf = allowCutPdf;
-  }
-
-  async init() {
-    if (this.inputType === "base64") await this.initBase64();
-    else if (this.inputType === "path") await this.initFile();
-    else if (this.inputType === "stream") await this.initStream();
-    else this.initDummy();
-  }
-
-  async initBase64() {
-    this.fileObject = this.file;
-    this.filepath = undefined;
-
-    if (this.filename === undefined) {
-      const mimeType = await fileType.fromBuffer(
-        Buffer.from(this.fileObject, "base64")
-      );
-      if (mimeType !== undefined) {
-        this.fileExtension = mimeType.mime;
-        this.filename = `from_${this.inputType}.${mimeType.ext}`;
-      } else {
-        throw "Could not determine the MIME type. Please specify the 'filename' option.";
-      }
-    } else {
-      const filetype = this.filename.split(".").pop();
-      this.fileExtension = this.MIMETYPES[filetype];
-    }
-
-    if (this.fileExtension === "application/pdf" && this.allowCutPdf == true) {
-      await this.cutPdf();
-    }
-  }
-
-  async initFile() {
-    this.fileObject = await fs.readFile(this.file);
-    this.filepath = this.file;
-    this.filename = this.filename || path.basename(this.file);
-
-    // Check if file type is valid
-    const filetype = this.filename.split(".").pop();
-    if (!(filetype in this.MIMETYPES)) {
-      errorHandler.throw(
-        new Error(
-          `File type is not allowed. It must be ${Object.keys(
-            this.MIMETYPES
-          ).toString()}`
-        )
-      );
-    }
-    this.fileExtension = this.MIMETYPES[filetype];
-
-    if (this.fileExtension === "application/pdf" && this.allowCutPdf == true) {
-      await this.cutPdf();
-    }
-  }
-
-  async initStream() {
-    const file = await this.streamToBase64(this.file);
-
-    this.file = file;
-    this.inputType = "base64";
-    await this.initBase64();
-  }
-
-  initDummy() {
-    this.fileObject = "";
-    this.filename = "";
-    this.filepath = "";
-    this.fileExtension = "";
-  }
-
-  /**
-   * Convert ReadableStream to Base64 encoded String
-   *
-   * @param {*} stream ReadableStream to encode
-   * @returns Base64 encoded String
-   */
-  async streamToBase64(stream) {
-    return new Promise((resolve, reject) => {
-      const base64 = new Base64Encode();
-
-      const cbConcat = (base64) => {
-        resolve(base64);
-      };
-
-      stream
-        .pipe(base64)
-        .pipe(concat(cbConcat))
-        .on("error", (error) => {
-          reject(error);
-        });
-    });
-  }
-
-  /** Cut PDF if pages > 5 */
-  async cutPdf() {
-    // convert document to PDFDocument & cut CUT_PDF_SIZE - 1 first pages and last page
-    let pdfDocument = await PDFDocument.load(this.fileObject, {
-      ignoreEncryption: true,
-    });
-    const splitedPdfDocument = await PDFDocument.create();
-    const pdfLength = pdfDocument.getPageCount();
-    if (pdfLength <= this.CUT_PDF_SIZE) return;
-    const pagesNumbers = [...Array(pdfLength - 1).keys(), pdfLength - 1];
-    const pages = await splitedPdfDocument.copyPages(pdfDocument, pagesNumbers);
-    pages.forEach((page) => splitedPdfDocument.addPage(page));
-    const data = await splitedPdfDocument.save();
-    if (this.inputType === "path") {
-      this.fileObject = Buffer.from(data);
-    } else if (this.inputType === "base64") {
-      this.fileObject = ArrayBufferEncode.encode(data);
-    }
-  }
-}
-
-module.exports = Input;

package/mindee/logger.js

@@ -1,33 +0,0 @@
-const LOGGER_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-};
-
-class Logger {
-  constructor(level = "debug") {
-    if (!(level in LOGGER_LEVELS)) level = "debug";
-    this.level = LOGGER_LEVELS[level];
-  }
-
-  debug(...args) {
-    if (this.level <= LOGGER_LEVELS["debug"]) console.debug(args);
-  }
-
-  info(...args) {
-    if (this.level <= LOGGER_LEVELS["info"]) console.info(args);
-  }
-
-  warn(...args) {
-    if (this.level <= LOGGER_LEVELS["warn"]) console.warn(args);
-  }
-
-  error(...args) {
-    if (this.level <= LOGGER_LEVELS["error"]) console.error(args);
-  }
-}
-
-const logger = new Logger();
-
-module.exports = logger;