mindee 3.6.0 → 3.7.0

package/src/cli.js

@@ -1,4 +1,27 @@
 "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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cli = void 0;
 const commander_1 = require("commander");
@@ -6,121 +29,150 @@ const documents_1 = require("./documents");
 const api_1 = require("./api");
 const client_1 = require("./client");
 const inputs_1 = require("./inputs");
+const console = __importStar(require("console"));
 const program = new commander_1.Command();
 const COMMAND_CUSTOM = "custom";
+//
+// PRODUCT CONFIGURATION
+//
 // The Map's key is the command name as it will appear on the console.
 //
 const CLI_COMMAND_CONFIG = new Map([
     [
         COMMAND_CUSTOM,
         {
-            description: "A custom document",
+            displayName: "Custom Document",
             docClass: documents_1.CustomV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
     [
         "invoice",
         {
-            description: "Invoice",
+            displayName: "Invoice",
             docClass: documents_1.InvoiceV4,
             fullText: true,
+            async: false,
+            sync: true,
         },
     ],
     [
         "invoice-splitter",
         {
-            description: "Invoice Splitter",
+            displayName: "Invoice Splitter",
             docClass: documents_1.InvoiceSplitterV1,
             fullText: false,
+            async: true,
+            sync: false,
         },
     ],
     [
         "receipt",
         {
-            description: "Expense Receipt",
+            displayName: "Expense Receipt",
             docClass: documents_1.ReceiptV4,
             fullText: true,
+            async: false,
+            sync: true,
         },
     ],
     [
         "passport",
         {
-            description: "Passport",
+            displayName: "Passport",
             docClass: documents_1.PassportV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
     [
         "financial",
         {
-            description: "Financial Document",
+            displayName: "Financial Document",
             docClass: documents_1.FinancialDocumentV1,
             fullText: true,
+            async: false,
+            sync: true,
         },
     ],
     [
         "fr-id-card",
         {
-            description: "FR ID Card",
+            displayName: "FR ID Card",
             docClass: documents_1.fr.IdCardV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
     [
         "fr-bank-account-details",
         {
-            description: "FR Bank Account Details",
+            displayName: "FR Bank Account Details",
             docClass: documents_1.fr.BankAccountDetailsV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
     [
         "fr-carte-vitale",
         {
-            description: "FR Carte Vitale",
+            displayName: "FR Carte Vitale",
             docClass: documents_1.fr.CarteVitaleV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
     [
         "eu-license-plate",
         {
-            description: "EU License Plate",
+            displayName: "EU License Plate",
             docClass: documents_1.eu.LicensePlateV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
     [
         "us-bank-check",
         {
-            description: "US Bank Check",
+            displayName: "US Bank Check",
             docClass: documents_1.us.BankCheckV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
     [
         "shipping-container",
         {
-            description: "Shipping Container",
+            displayName: "Shipping Container",
             docClass: documents_1.ShippingContainerV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
     [
         "mvision",
         {
-            description: "Mindee Vision",
+            displayName: "Mindee Vision",
             docClass: documents_1.MindeeVisionV1,
             fullText: false,
+            async: false,
+            sync: true,
         },
     ],
 ]);
-async function predictCall(command, inputPath, options) {
-    const conf = CLI_COMMAND_CONFIG.get(command);
-    if (conf === undefined) {
-        throw new Error(`Invalid document type ${command}`);
-    }
+//
+// EXECUTE THE COMMANDS
+//
+function initClient(command, options) {
     const mindeeClient = new client_1.Client({
         apiKey: options.apiKey,
         debug: options.debug,
@@ -131,7 +183,16 @@ async function predictCall(command, inputPath, options) {
             endpointName: options.documentType,
         });
     }
-    const doc = mindeeClient.docFromPath(inputPath);
+    return mindeeClient;
+}
+function getConfig(command) {
+    const conf = CLI_COMMAND_CONFIG.get(command);
+    if (conf === undefined) {
+        throw new Error(`Invalid document type ${command}`);
+    }
+    return conf;
+}
+function getPredictParams(command, options, conf) {
     let pageOptions = undefined;
     if (options.cutPages) {
         pageOptions = {
@@ -146,7 +207,38 @@ async function predictCall(command, inputPath, options) {
         fullText: options.fullText,
         pageOptions: pageOptions,
     };
+    return predictParams;
+}
+async function callParse(command, inputPath, options) {
+    const conf = getConfig(command);
+    const mindeeClient = initClient(command, options);
+    const predictParams = getPredictParams(command, options, conf);
+    const doc = mindeeClient.docFromPath(inputPath);
     const response = await doc.parse(conf.docClass, predictParams);
+    printResponse(response, options);
+}
+async function callEnqueue(command, inputPath, options) {
+    const conf = getConfig(command);
+    const mindeeClient = initClient(command, options);
+    const predictParams = getPredictParams(command, options, conf);
+    const doc = mindeeClient.docFromPath(inputPath);
+    const response = await doc.enqueue(conf.docClass, predictParams);
+    console.log(response.job);
+}
+async function callParseQueued(command, inputPath, options) {
+    const conf = getConfig(command);
+    const mindeeClient = initClient(command, options);
+    const predictParams = getPredictParams(command, options, conf);
+    const doc = mindeeClient.docForAsync();
+    const response = await doc.parseQueued(conf.docClass, predictParams, inputPath);
+    if (response.document !== undefined) {
+        printResponse(response.document, options);
+    }
+    else {
+        console.log(response);
+    }
+}
+function printResponse(response, options) {
     if (options.fullText) {
         response.pages.forEach((page) => {
             console.log(page.fullText?.toString());
@@ -161,43 +253,103 @@ async function predictCall(command, inputPath, options) {
         console.log(`\n${response.document}`);
     }
 }
+//
+// BUILD THE COMMANDS
+//
+function addMainOptions(prog) {
+    prog.option("-k, --api-key <api_key>", "API key for document endpoint");
+}
+function addPostOptions(prog, info) {
+    prog.option("-c, --cut-pages", "keep only the first 5 pages of the document");
+    if (info.fullText) {
+        prog.option("-t, --full-text", "include full document text in response");
+    }
+    prog.argument("<input_path>", "full path to the file");
+}
+function addCustomPostOptions(prog) {
+    prog.requiredOption("-e, --endpoint <endpoint_name>", "API endpoint name (required)");
+    prog.requiredOption("-a, --account <account_name>", "API account name for the endpoint (required)");
+    prog.option("-v, --version <version>", "version for the endpoint, use the latest version if not specified");
+}
+function addDisplayOptions(prog) {
+    prog.option("-p, --pages", "show content of individual pages");
+}
+function routeSwitchboard(command, inputPath, allOptions) {
+    switch (command.parent?.name()) {
+        case "parse": {
+            return callParse(command.name(), inputPath, allOptions);
+        }
+        case "enqueue": {
+            return callEnqueue(command.name(), inputPath, allOptions);
+        }
+        case "parse-queued": {
+            return callParseQueued(command.name(), inputPath, allOptions);
+        }
+        default: {
+            throw new Error("Unhandled parent command.");
+        }
+    }
+}
+function addAction(prog) {
+    if (prog.name() === COMMAND_CUSTOM) {
+        prog.action(function (inputPath, options, command) {
+            const allOptions = {
+                ...program.opts(),
+                ...options,
+            };
+            return routeSwitchboard(command, inputPath, allOptions);
+        });
+    }
+    else {
+        prog.action(function (inputPath, options, command) {
+            const allOptions = {
+                ...program.opts(),
+                ...options,
+            };
+            return routeSwitchboard(command, inputPath, allOptions);
+        });
+    }
+}
 function cli() {
     program.name("mindee");
     program.option("-d, --debug", "high verbosity mode");
+    const predict = program.command("parse").description("Parse synchronously.");
+    addMainOptions(predict);
+    const enqueue = program
+        .command("enqueue")
+        .description("Add to async parse queue.");
+    addMainOptions(enqueue);
+    const parseQueued = program
+        .command("parse-queued")
+        .description("Parse from async queue.");
+    addMainOptions(parseQueued);
     CLI_COMMAND_CONFIG.forEach((info, name) => {
-        const prog = program.command(name);
-        prog.description(info.description);
-        prog.option("-k, --api-key <api_key>", "API key for document endpoint");
-        prog.option("-c, --cut-pages", "Keep only the first 5 pages of the document.");
-        prog.option("-p, --pages", "Show pages content");
-        if (info.fullText) {
-            prog.option("-t, --full-text", "Include full document text in response");
-        }
-        if (name === COMMAND_CUSTOM) {
-            prog.requiredOption("-u, --user <username>", "API account name for the endpoint");
-            prog.option("-v, --version <version>", "Version for the endpoint, use the latest version if not specified.");
-            prog.argument("<endpoint_name>", "API endpoint name");
-        }
-        prog.argument("<input_path>", "Full path to the file");
-        if (name === COMMAND_CUSTOM) {
-            prog.action((endpointName, inputPath, options, command) => {
-                const allOptions = {
-                    ...program.opts(),
-                    ...options,
-                    documentType: endpointName,
-                };
-                predictCall(command.name(), inputPath, allOptions);
-            });
+        if (info.sync) {
+            const prog = predict
+                .command(name)
+                .description(`Parse an ${info.displayName}.`);
+            if (name === COMMAND_CUSTOM) {
+                addCustomPostOptions(prog);
+            }
+            addDisplayOptions(prog);
+            addPostOptions(prog, info);
+            addAction(prog);
         }
-        else {
-            prog.action((inputPath, options, command) => {
-                const allOptions = {
-                    ...program.opts(),
-                    ...options,
-                    endpointName: undefined,
-                };
-                predictCall(command.name(), inputPath, allOptions);
-            });
+        if (info.async) {
+            const progEnqueue = enqueue
+                .command(name)
+                .description(`Add an ${info.displayName} to the queue.`);
+            if (name === COMMAND_CUSTOM) {
+                addCustomPostOptions(progEnqueue);
+            }
+            addPostOptions(progEnqueue, info);
+            addAction(progEnqueue);
+            const progParse = parseQueued
+                .command(name)
+                .description(`Parse an ${info.displayName} from the queue.`)
+                .argument("<doc_id>", "ID of the document");
+            addDisplayOptions(progParse);
+            addAction(progParse);
         }
     });
     program.parse(process.argv);

package/src/client.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 import { Readable } from "stream";
 import { InputSource, PageOptions } from "./inputs";
-import { Response } from "./api";
+import { Response, AsyncPredictResponse } from "./api";
 import { Document, DocumentSig } from "./documents";
 import { DocumentConfig } from "./documents/documentConfig";
 type DocConfigs = Map<string[], DocumentConfig<any>>;
@@ -41,15 +41,27 @@ export interface PredictOptions {
     pageOptions?: PageOptions;
 }
 declare class DocumentClient {
-    inputSource: InputSource;
     docConfigs: DocConfigs;
-    constructor(inputSource: InputSource, docConfigs: DocConfigs);
+    inputSource?: InputSource;
+    constructor(docConfigs: DocConfigs, inputSource?: InputSource);
     /**
-     * Send a document to an endpoint and parse the predictions.
+     * Send a document to a synchronous endpoint and parse the predictions.
      * @param documentClass
      * @param params
      */
     parse<DocType extends Document>(documentClass: DocumentSig<DocType>, params?: PredictOptions): Promise<Response<DocType>>;
+    /**
+     * Send the document to an asynchronous endpoint and return its ID in the queue.
+     * @param documentClass
+     * @param params
+     */
+    enqueue<DocType extends Document>(documentClass: DocumentSig<DocType>, params?: PredictOptions): Promise<AsyncPredictResponse<DocType>>;
+    parseQueued<DocType extends Document>(documentClass: DocumentSig<DocType>, params: {
+        endpointName?: string | undefined;
+        accountName?: string | undefined;
+    } | undefined, queueId: string): Promise<AsyncPredictResponse<DocType>>;
+    protected getBooleanParam(param?: boolean): boolean;
+    protected getDocConfig<DocType extends Document>(documentClass: DocumentSig<DocType>, endpointName?: string, accountName?: string): DocumentConfig<DocType>;
 }
 export interface CustomConfigParams {
     /** Your organization's username on the API Builder. */
@@ -122,5 +134,9 @@ export declare class Client {
      * @param filename
      */
     docFromBuffer(buffer: Buffer, filename: string): DocumentClient;
+    /**
+     * Load an empty input document from an asynchronous call.
+     */
+    docForAsync(): DocumentClient;
 }
 export {};

package/src/client.js

@@ -8,12 +8,12 @@ const documentConfig_1 = require("./documents/documentConfig");
 const handler_1 = require("./errors/handler");
 const logger_1 = require("./logger");
 class DocumentClient {
-    constructor(inputSource, docConfigs) {
+    constructor(docConfigs, inputSource) {
         this.inputSource = inputSource;
         this.docConfigs = docConfigs;
     }
     /**
-     * Send a document to an endpoint and parse the predictions.
+     * Send a document to a synchronous endpoint and parse the predictions.
      * @param documentClass
      * @param params
      */
@@ -24,12 +24,54 @@ class DocumentClient {
         cropper: false,
         pageOptions: undefined,
     }) {
-        // seems like there should be a better way of doing this
-        const fullText = params?.fullText !== undefined ? params.fullText : false;
-        const cropper = params?.cropper !== undefined ? params.cropper : false;
-        const docType = params.endpointName === undefined || params.endpointName === ""
+        const docConfig = this.getDocConfig(documentClass, params.endpointName, params.accountName);
+        if (this.inputSource === undefined) {
+            throw new Error("The 'parse' function requires an input document.");
+        }
+        return await docConfig.predict({
+            inputDoc: this.inputSource,
+            includeWords: this.getBooleanParam(params.fullText),
+            pageOptions: params.pageOptions,
+            cropper: this.getBooleanParam(params.cropper),
+        });
+    }
+    /**
+     * Send the document to an asynchronous endpoint and return its ID in the queue.
+     * @param documentClass
+     * @param params
+     */
+    async enqueue(documentClass, params = {
+        endpointName: "",
+        accountName: "",
+        fullText: false,
+        cropper: false,
+        pageOptions: undefined,
+    }) {
+        const docConfig = this.getDocConfig(documentClass, params.endpointName, params.accountName);
+        if (this.inputSource === undefined) {
+            throw new Error("The 'enqueue' function requires an input document.");
+        }
+        return await docConfig.asyncPredict({
+            inputDoc: this.inputSource,
+            includeWords: this.getBooleanParam(params.fullText),
+            pageOptions: params.pageOptions,
+            cropper: this.getBooleanParam(params.cropper),
+        });
+    }
+    async parseQueued(documentClass, params = {
+        endpointName: "",
+        accountName: "",
+    }, queueId) {
+        const docConfig = this.getDocConfig(documentClass, params.endpointName, params.accountName);
+        return await docConfig.getQueuedDocument(queueId);
+    }
+    getBooleanParam(param) {
+        return param !== undefined ? param : false;
+    }
+    getDocConfig(documentClass, endpointName, accountName) {
+        const docType = endpointName === undefined || endpointName === ""
             ? documentClass.name
-            : params.endpointName;
+            : endpointName;
         const found = [];
         this.docConfigs.forEach((config, configKey) => {
             if (configKey[1] === docType) {
@@ -43,20 +85,15 @@ class DocumentClient {
         if (found.length === 1) {
             configKey = found[0];
         }
-        else if (params.accountName) {
-            configKey = [params.accountName, docType];
+        else if (accountName) {
+            configKey = [accountName, docType];
         }
         const docConfig = this.docConfigs.get(configKey);
         if (docConfig === undefined) {
             // TODO: raise error printing all usernames
             throw `Couldn't find the config '${configKey}'`;
         }
-        return await docConfig.predict({
-            inputDoc: this.inputSource,
-            includeWords: fullText,
-            pageOptions: params.pageOptions,
-            cropper: cropper,
-        });
+        return docConfig;
     }
 }
 /**
@@ -90,7 +127,7 @@ class Client {
             new api_1.StandardEndpoint("invoices", "4", this.apiKey),
         ]));
         this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.InvoiceSplitterV1.name], new documentConfig_1.DocumentConfig(documents_1.InvoiceSplitterV1, [
-            new api_1.StandardEndpoint("invoice_splitter_beta", "1", this.apiKey),
+            new api_1.StandardEndpoint("invoice_splitter_async_beta", "1", this.apiKey),
         ]));
         this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.ReceiptV3.name], new documentConfig_1.DocumentConfig(documents_1.ReceiptV3, [
             new api_1.StandardEndpoint("expense_receipts", "3", this.apiKey),
@@ -152,7 +189,7 @@ class Client {
         const doc = new inputs_1.PathInput({
             inputPath: inputPath,
         });
-        return new DocumentClient(doc, this.docConfigs);
+        return new DocumentClient(this.docConfigs, doc);
     }
     /**
      * Load an input document from a base64 encoded string.
@@ -164,7 +201,7 @@ class Client {
             inputString: inputString,
             filename: filename,
         });
-        return new DocumentClient(doc, this.docConfigs);
+        return new DocumentClient(this.docConfigs, doc);
     }
     /**
      * Load an input document from a `stream.Readable` object.
@@ -176,7 +213,7 @@ class Client {
             inputStream: inputStream,
             filename: filename,
         });
-        return new DocumentClient(doc, this.docConfigs);
+        return new DocumentClient(this.docConfigs, doc);
     }
     /**
      * Load an input document from a bytes string.
@@ -188,7 +225,7 @@ class Client {
             inputBytes: inputBytes,
             filename: filename,
         });
-        return new DocumentClient(doc, this.docConfigs);
+        return new DocumentClient(this.docConfigs, doc);
     }
     /**
      * Load an input document from a URL.
@@ -198,7 +235,7 @@ class Client {
         const doc = new inputs_1.UrlInput({
             url: url,
         });
-        return new DocumentClient(doc, this.docConfigs);
+        return new DocumentClient(this.docConfigs, doc);
     }
     /**
      * Load an input document from a Buffer.
@@ -210,7 +247,13 @@ class Client {
             buffer: buffer,
             filename: filename,
         });
-        return new DocumentClient(doc, this.docConfigs);
+        return new DocumentClient(this.docConfigs, doc);
+    }
+    /**
+     * Load an empty input document from an asynchronous call.
+     */
+    docForAsync() {
+        return new DocumentClient(this.docConfigs);
     }
 }
 exports.Client = Client;

package/src/documents/custom/fields.js

@@ -28,7 +28,7 @@ class ListFieldValue {
         this.confidence = prediction["confidence"];
         if (prediction["polygon"]) {
             this.polygon = prediction["polygon"];
-            this.bbox = (0, geometry_1.getBboxAsPolygon)(prediction.polygon);
+            this.bbox = (0, geometry_1.getBoundingBox)(prediction.polygon);
         }
     }
     toString() {

package/src/documents/custom/lineitems.d.ts

@@ -0,0 +1,41 @@
+import { BBox, Polygon } from "../../geometry";
+import { ListField, ListFieldValue } from "./fields";
+export declare class Line {
+    /**
+     * Number of the current line.
+     * Starts to 1.
+     */
+    rowNumber: number;
+    /**
+     * List of the fields associated to the current line, identified by their column name.
+     */
+    fields: Map<string, ListFieldValue>;
+    /**
+     * The BBox of the current line.
+     */
+    bbox: BBox;
+    /**
+     * The height tolerance used to build the line.
+     * It helps when the higth of an expected line can vary.
+     */
+    heightTolerance: number;
+    constructor(rowNumber: number, heightTolerance: number);
+    /**
+     * Extends the current bbox of the line with the bbox.
+     */
+    extendWithBbox(bbox: BBox): void;
+    /**
+     * Extends the current bbox of the line with the polygon.
+     */
+    extendWith(polygon: Polygon): void;
+    /**
+     * Check if the bbox fits the current line.
+     */
+    contains(bbox: BBox): boolean;
+    updateField(name: string, fieldValue: ListFieldValue): void;
+}
+export declare class LineItems {
+    rows: Line[];
+    constructor(lines: Line[]);
+}
+export declare function getLineItems(anchorNames: string[], heigthLineTolerance: number, fieldNamesTargeted: string[], fields: Map<string, ListField>): LineItems;