mindee 1.1.2 → 1.3.1

package/dist/documents/receipt.js

@@ -0,0 +1,231 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Receipt_instances, _Receipt_initFromScratch, _Receipt_initFromApiPrediction, _Receipt_checklist, _Receipt_taxesMatchTotal, _Receipt_reconstruct, _Receipt_reconstructTotalExclFromTCCAndTaxes, _Receipt_reconstructTotalTax;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Receipt = void 0;
+const document_1 = require("@documents/document");
+const fields_1 = require("@documents/fields");
+const promises_1 = __importDefault(require("fs/promises"));
+class Receipt extends document_1.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);
+        _Receipt_instances.add(this);
+        this.level = level;
+        this.constructPrediction = function (item) {
+            return { prediction: { value: item }, valueKey: "value", pageNumber };
+        };
+        if (apiPrediction === undefined) {
+            __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_initFromScratch).call(this, {
+                locale,
+                totalExcl,
+                totalIncl,
+                date,
+                category,
+                merchantName,
+                time,
+                taxes,
+                orientation,
+                totalTax,
+                pageNumber,
+            });
+        }
+        else {
+            __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_initFromApiPrediction).call(this, apiPrediction, pageNumber, words);
+        }
+        __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_checklist).call(this);
+        __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_reconstruct).call(this);
+    }
+    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 load(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = promises_1.default.readFile(path);
+            const args = JSON.parse(file);
+            return new Receipt(Object.assign({ reconsctruted: true }, args));
+        });
+    }
+}
+exports.Receipt = Receipt;
+_Receipt_instances = new WeakSet(), _Receipt_initFromScratch = function _Receipt_initFromScratch({ locale, totalExcl, totalIncl, date, category, merchantName, time, taxes, orientation, totalTax, pageNumber, }) {
+    this.locale = new fields_1.Locale(this.constructPrediction(locale));
+    this.totalIncl = new fields_1.Amount(this.constructPrediction(totalIncl));
+    this.date = new fields_1.DateField(this.constructPrediction(date));
+    this.category = new fields_1.Field(this.constructPrediction(category));
+    this.merchantName = new fields_1.Field(this.constructPrediction(merchantName));
+    this.time = new fields_1.Field(this.constructPrediction(time));
+    if (taxes !== undefined) {
+        this.taxes = [];
+        for (const t of taxes) {
+            this.taxes.push(new fields_1.Tax({
+                prediction: { value: t[0], rate: t[1] },
+                pageNumber,
+                valueKey: "value",
+                rateKey: "rate",
+            }));
+        }
+    }
+    this.orientation = new fields_1.Orientation(this.constructPrediction(orientation));
+    this.totalTax = new fields_1.Amount(this.constructPrediction(totalTax));
+    this.totalExcl = new fields_1.Amount(this.constructPrediction(totalExcl));
+}, _Receipt_initFromApiPrediction = function _Receipt_initFromApiPrediction(apiPrediction, pageNumber, words) {
+    this.locale = new fields_1.Locale({ prediction: apiPrediction.locale, pageNumber });
+    this.totalIncl = new fields_1.Amount({
+        prediction: apiPrediction.total_incl,
+        valueKey: "value",
+        pageNumber,
+    });
+    this.date = new fields_1.DateField({
+        prediction: apiPrediction.date,
+        valueKey: "value",
+        pageNumber,
+    });
+    this.category = new fields_1.Field({
+        prediction: apiPrediction.category,
+        pageNumber,
+    });
+    this.merchantName = new fields_1.Field({
+        prediction: apiPrediction.supplier,
+        valueKey: "value",
+        pageNumber,
+    });
+    this.time = new fields_1.Field({
+        prediction: apiPrediction.time,
+        valueKey: "value",
+        pageNumber,
+    });
+    this.taxes = apiPrediction.taxes.map((taxPrediction) => new fields_1.Tax({
+        prediction: taxPrediction,
+        pageNumber,
+        valueKey: "value",
+        rateKey: "rate",
+        codeKey: "code",
+    }));
+    this.totalTax = new fields_1.Amount({
+        prediction: { value: undefined, confidence: 0 },
+        valueKey: "value",
+        pageNumber,
+    });
+    this.totalExcl = new fields_1.Amount({
+        prediction: { value: undefined, confidence: 0 },
+        valueKey: "value",
+        pageNumber,
+    });
+    if (this.level === "page") {
+        this.orientation = new fields_1.Orientation({
+            prediction: apiPrediction.orientation,
+            pageNumber,
+        });
+    }
+    else {
+        this.orientation = new fields_1.Orientation(this.constructPrediction({
+            prediction: {
+                value: undefined,
+                confidence: 0.0,
+                degrees: undefined,
+            },
+        }));
+    }
+    if (words && words.length > 0)
+        this.words = words;
+}, _Receipt_checklist = function _Receipt_checklist() {
+    this.checklist = { taxesMatchTotalIncl: __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_taxesMatchTotal).call(this) };
+}, _Receipt_taxesMatchTotal = function _Receipt_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) => (Object.assign(Object.assign({}, tax), { probability: 1.0 })));
+        this.totalTax.probability = 1.0;
+        this.totalIncl.probability = 1.0;
+        return true;
+    }
+    return false;
+}, _Receipt_reconstruct = function _Receipt_reconstruct() {
+    __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_reconstructTotalExclFromTCCAndTaxes).call(this);
+    __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_reconstructTotalTax).call(this);
+}, _Receipt_reconstructTotalExclFromTCCAndTaxes = function _Receipt_reconstructTotalExclFromTCCAndTaxes() {
+    if (this.taxes.length && this.totalIncl.value != null) {
+        const totalExcl = {
+            value: this.totalIncl.value - fields_1.Field.arraySum(this.taxes),
+            confidence: fields_1.Field.arrayProbability(this.taxes) * this.totalIncl.probability,
+        };
+        this.totalExcl = new fields_1.Amount({
+            prediction: totalExcl,
+            valueKey: "value",
+            reconstructed: true,
+        });
+    }
+}, _Receipt_reconstructTotalTax = function _Receipt_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: fields_1.Field.arrayProbability(this.taxes),
+        };
+        if (totalTax.value > 0)
+            this.totalTax = new fields_1.Amount({
+                prediction: totalTax,
+                valueKey: "value",
+                reconstructed: true,
+            });
+    }
+};

package/dist/errors/handler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const logger_1 = require("@mindee/logger");
+class ErrorHandler {
+    constructor(throwOnError = true) {
+        this.throwOnError = throwOnError;
+        this.throwOnError = throwOnError;
+    }
+    throw(error) {
+        if (this.throwOnError || force)
+            throw error;
+        else
+            logger_1.logger.error(error.message);
+    }
+}
+exports.errorHandler = new ErrorHandler();

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const handler_1 = require("@errors/handler");
+const logger_1 = require("@mindee/logger");
+const receipt_1 = require("@mindee/api/receipt");
+const invoice_1 = require("@mindee/api/invoice");
+const financialDocument_1 = require("@mindee/api/financialDocument");
+class Client {
+    constructor({ receiptToken, invoiceToken, throwOnError = true, debug, }) {
+        this.receiptToken = receiptToken || process.env.MINDEE_RECEIPT_TOKEN;
+        this.invoiceToken = invoiceToken || process.env.MINDEE_INVOICE_TOKEN;
+        handler_1.errorHandler.throwOnError = throwOnError;
+        logger_1.logger.level = (debug !== null && debug !== void 0 ? debug : process.env.MINDEE_DEBUG) ? "debug" : "warn";
+        this.receipt = new receipt_1.APIReceipt(this.receiptToken);
+        this.invoice = new invoice_1.APIInvoice(this.invoiceToken);
+        this.financialDocument = new financialDocument_1.APIFinancialDocument(this.invoiceToken, this.receiptToken);
+    }
+}
+exports.Client = Client;
+exports.documents = require("./documents");
+exports.api = require("./api");
+exports.inputs = require("./inputs");

package/dist/inputs.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Input = void 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");
+const promises_1 = __importDefault(require("fs/promises"));
+const path = __importStar(require("path"));
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const concat = __importStar(require("concat-stream"));
+const base64_stream_1 = require("base64-stream");
+const fileType = __importStar(require("file-type"));
+const ArrayBufferEncode = __importStar(require("base64-arraybuffer"));
+const handler_1 = require("@errors/handler");
+const pdf_lib_1 = require("pdf-lib");
+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: dummy is only used for tests purposes
+     * @param {String} filename - File name of the input
+     * @param allowCutPdf
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor(file, inputType, allowCutPdf = true, filename) {
+        this.file = file;
+        this.inputType = inputType;
+        this.allowCutPdf = allowCutPdf;
+        this.filename = filename;
+        this.MIMETYPES = {
+            png: "image/png",
+            jpg: "image/jpg",
+            jpeg: "image/jpeg",
+            webp: "image/webp",
+            pdf: "application/pdf",
+        };
+        this.ALLOWED_INPUT_TYPE = ["base64", "path", "stream", "dummy"];
+        this.CUT_PDF_SIZE = 5;
+        // Check if inputType is valid
+        if (!this.ALLOWED_INPUT_TYPE.includes(inputType)) {
+            handler_1.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;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fileObject = this.file;
+            this.filepath = undefined;
+            if (this.filename === undefined) {
+                const mimeType = yield 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) {
+                yield this.cutPdf();
+            }
+        });
+    }
+    initFile() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.fileObject = yield promises_1.default.readFile(this.file);
+            this.filepath = this.file;
+            if (typeof this.file === "string") {
+                this.filename = this.filename || path.basename(this.file);
+            }
+            // Check if file type is valid
+            const filetype = (_a = this.filename) === null || _a === void 0 ? void 0 : _a.split(".").pop();
+            if (!filetype || !(filetype in this.MIMETYPES)) {
+                handler_1.errorHandler.throw(new Error(`File type is not allowed. It must be ${Object.keys(this.MIMETYPES).toString()}`));
+            }
+            this.fileExtension = filetype ? this.MIMETYPES[filetype] : "";
+            if (this.fileExtension === "application/pdf" && this.allowCutPdf) {
+                yield this.cutPdf();
+            }
+        });
+    }
+    initStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.file = (yield this.streamToBase64(this.file));
+            this.inputType = "base64";
+            yield 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
+     */
+    streamToBase64(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const base64 = new base64_stream_1.Base64Encode();
+                const cbConcat = (base64) => {
+                    resolve(base64);
+                };
+                stream
+                    .pipe(base64)
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore TO DO : FIX
+                    .pipe(concat(cbConcat))
+                    .on("error", (error) => {
+                    reject(error);
+                });
+            });
+        });
+    }
+    /** Cut PDF if pages > 5 */
+    cutPdf() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // convert document to PDFDocument & cut CUT_PDF_SIZE - 1 first pages and last page
+            const pdfDocument = yield pdf_lib_1.PDFDocument.load(this.fileObject, {
+                ignoreEncryption: true,
+            });
+            const splitedPdfDocument = yield pdf_lib_1.PDFDocument.create();
+            const pdfLength = pdfDocument.getPageCount();
+            if (pdfLength <= this.CUT_PDF_SIZE)
+                return;
+            const pagesNumbers = [
+                ...Array(this.CUT_PDF_SIZE - 1).keys(),
+                pdfLength - 1,
+            ];
+            const pages = yield splitedPdfDocument.copyPages(pdfDocument, pagesNumbers);
+            pages.forEach((page) => splitedPdfDocument.addPage(page));
+            const data = yield splitedPdfDocument.save();
+            if (this.inputType === "path") {
+                this.fileObject = Buffer.from(data);
+            }
+            else if (this.inputType === "base64") {
+                this.fileObject = ArrayBufferEncode.encode(data);
+            }
+        });
+    }
+}
+exports.Input = Input;

package/dist/logger.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const LOGGER_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+class Logger {
+    constructor(level = "debug") {
+        this.level = level;
+        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);
+    }
+}
+exports.logger = new Logger();

package/lib/api/financialDocument.js

@@ -46,7 +46,7 @@ class APIFinancialDocument extends APIObject {
       });
       yield inputFile.init();
       _this.apiToken = inputFile.fileExtension === "application/pdf" ? _this.invoiceToken : _this.receiptToken;
-      var url = inputFile.fileExtension === "application/pdf" ? "/invoices/v3/predict" : "/expense_receipts/v3/predict";
+      var url = inputFile.fileExtension === "application/pdf" ? "/invoices/v2/predict" : "/expense_receipts/v3/predict";
 
       _superprop_getParse().call(_this);
 

package/lib/api/invoice.js

@@ -34,7 +34,7 @@ class APIInvoice extends APIObject {
         input,
         inputType = "path",
         filename = undefined,
-        version = "3",
+        version = "2",
         cutPdf = true,
         includeWords = false
       } = _ref;

package/lib/api/response.js

@@ -82,7 +82,7 @@ class Response {
     this[this.documentType] = constructors[this.documentType]({
       apiPrediction: this.httpResponse.data.document.inference.prediction,
       inputFile: this.input,
-      pageNumber: this.httpResponse.data.document.n_pages,
+      pageNumber: -1,
       level: "document"
     });
   }

package/lib/documents/fields/field.js

@@ -19,11 +19,13 @@ class Field {
     this.pageNumber = pageNumber;
     this.reconstructed = reconstructed;
     this.value = undefined;
-    this.probability = prediction.confidence ? prediction.confidence : 0.0;
-    this.bbox = prediction.polygon ? prediction.polygon : [];
+    this.probability = 0.0;
+    this.bbox = [];
 
     if (valueKey in prediction && prediction[valueKey] !== null) {
       this.value = prediction[valueKey];
+      if (prediction.probability) this.probability = prediction.probability;
+      if (prediction.segmentation) this.bbox = prediction.segmentation.bounding_box || [];
 
       if (extraFields) {
         for (var fieldName of extraFields) {