mindee 4.36.3 → 5.0.0-alpha2

package/src/pdf/pdfOperation.js

@@ -1,31 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractPages = extractPages;
-exports.countPages = countPages;
-const handler_1 = require("../errors/handler");
-const pdf_lib_1 = require("@cantoo/pdf-lib");
-const input_1 = require("../input");
-const errors_1 = require("../errors");
-const logger_1 = require("../logger");
+import { errorHandler } from "../errors/handler.js";
+import { PageOptionsOperation } from "../input/pageOptions.js";
+import { MindeeError } from "../errors/index.js";
+import { logger } from "../logger.js";
+import { loadOptionalDependency } from "../dependency/index.js";
+let pdfLib = null;
+async function getPdfLib() {
+    if (!pdfLib) {
+        const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Text Embedding");
+        pdfLib = pdfLibImport.default || pdfLibImport;
+    }
+    return pdfLib;
+}
 /**
- * Cut pages from a pdf file. If pages index are out of bound, it will throw an error.
+ * Cut pages from a PDF file. If pages indexes are out of bounds, it will throw an error.
  * @param file
  * @param pageOptions
- * @returns the new cut pdf file.
+ * @returns the new cut PDF file.
  */
-async function extractPages(file, pageOptions) {
-    const currentPdf = await pdf_lib_1.PDFDocument.load(file, {
+export async function extractPages(file, pageOptions) {
+    const pdfLib = await getPdfLib();
+    const currentPdf = await pdfLib.PDFDocument.load(file, {
         ignoreEncryption: true,
         password: ""
     });
-    const newPdf = await pdf_lib_1.PDFDocument.create();
+    const newPdf = await pdfLib.PDFDocument.create();
     const pageCount = currentPdf.getPageCount();
     if (pageCount < pageOptions.onMinPages) {
-        logger_1.logger.debug(`File skipped because it had less than ${pageOptions} pages (${pageCount}).`);
+        logger.debug(`File skipped because it had less than ${pageOptions} pages (${pageCount}).`);
         return { file: file, totalPagesRemoved: 0 };
     }
     if (pageOptions.pageIndexes.length > pageCount) {
-        handler_1.errorHandler.throw(new errors_1.MindeeError("The total indexes of pages to cut is superior to the total page count of the file (" +
+        errorHandler.throw(new MindeeError("The total indexes of pages to cut is superior to the total page count of the file (" +
             pageCount +
             ")."));
     }
@@ -39,18 +44,18 @@ async function extractPages(file, pageOptions) {
         }
     });
     if (!pageIndexes.every((v) => currentPdf.getPageIndices().includes(v))) {
-        handler_1.errorHandler.throw(new errors_1.MindeeError(`Some indexes pages
+        errorHandler.throw(new MindeeError(`Some indexes pages
         (${pageIndexes.join(",")})
         don't exist in the file
         (${currentPdf.getPageIndices().join(", ")})`));
     }
-    if (pageOptions.operation === input_1.PageOptionsOperation.KeepOnly) {
+    if (pageOptions.operation === PageOptionsOperation.KeepOnly) {
         const keptPages = await newPdf.copyPages(currentPdf, pageIndexes);
         keptPages.forEach((keptPage) => {
             newPdf.addPage(keptPage);
         });
     }
-    else if (pageOptions.operation === input_1.PageOptionsOperation.Remove) {
+    else if (pageOptions.operation === PageOptionsOperation.Remove) {
         const pagesToKeep = currentPdf
             .getPageIndices()
             .filter((v) => !pageIndexes.includes(v));
@@ -67,12 +72,13 @@ async function extractPages(file, pageOptions) {
     return { file: fileBuffer, totalPagesRemoved: sumRemovedPages };
 }
 /**
- * Count the number of pages in a pdf file.
+ * Count the number of pages in a PDF file.
  * @param file
  * @returns the number of pages in the file.
  */
-async function countPages(file) {
-    const currentPdf = await pdf_lib_1.PDFDocument.load(file, {
+export async function countPages(file) {
+    const pdfLib = await getPdfLib();
+    const currentPdf = await pdfLib.PDFDocument.load(file, {
         ignoreEncryption: true,
         password: ""
     });

package/src/pdf/pdfUtils.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractTextFromPdf = extractTextFromPdf;
-exports.hasSourceText = hasSourceText;
-const pdf_js_extract_1 = require("pdf.js-extract");
-const mindeeError_1 = require("../errors/mindeeError");
+import { MindeePdfError } from "../errors/index.js";
+import { loadOptionalDependency } from "../dependency/index.js";
 function getConcatenatedText(pages) {
     return pages.flatMap(page => page.content.map(item => item.str)).join(" ");
 }
@@ -13,22 +9,24 @@ function getConcatenatedText(pages) {
  * @returns A Promise containing the extracted text as a string.
  * @param pdfBuffer PDF handle, as a buffer.
  */
-async function extractTextFromPdf(pdfBuffer) {
-    const pdfExtract = new pdf_js_extract_1.PDFExtract();
+export async function extractTextFromPdf(pdfBuffer) {
+    const pdfJsExtract = await loadOptionalDependency("pdf.js-extract", "PDF text extraction");
+    const pdfJs = pdfJsExtract.pdfjs || pdfJsExtract;
+    const pdfExtract = new pdfJs.PDFExtract();
     const options = {};
     const pdf = await new Promise((resolve, reject) => {
         pdfExtract.extractBuffer(pdfBuffer, options, (err, result) => {
             if (err)
                 reject(err);
             if (result === undefined)
-                reject(new mindeeError_1.MindeePdfError("Couldn't process result."));
+                reject(new MindeePdfError("Couldn't process result."));
             else
                 resolve(result);
         });
     });
     const pages = pdf.pages.map((page, index) => ({
         pageNumber: index + 1,
-        content: page.content.map(item => ({
+        content: page.content.map((item) => ({
             str: item.str,
             x: item.x,
             y: item.y,
@@ -49,7 +47,7 @@ async function extractTextFromPdf(pdfBuffer) {
  *
  * @returns A Promise containing a boolean indicating if the PDF has source text.
  */
-async function hasSourceText(pdfData) {
+export async function hasSourceText(pdfData) {
     const text = await extractTextFromPdf(pdfData);
     return text.getConcatenatedText().trim().length > 0;
 }

package/src/v1/cli.js

@@ -0,0 +1,201 @@
+import { Command, Option, } from "commander";
+import { Client, } from "./client.js";
+import { PageOptionsOperation, PathInput, } from "../input/index.js";
+import * as console from "console";
+import { CLI_COMMAND_CONFIG, COMMAND_GENERATED, } from "./product/cliProducts.js";
+const program = new Command();
+//
+// EXECUTE THE COMMANDS
+//
+function initClient(options) {
+    return new Client({
+        apiKey: options.apiKey,
+        debug: options.debug,
+    });
+}
+function getConfig(command) {
+    const conf = CLI_COMMAND_CONFIG.get(command);
+    if (conf === undefined) {
+        throw new Error(`Invalid document type ${command}`);
+    }
+    return conf;
+}
+function getPageOptions(options) {
+    let pageOptions = undefined;
+    if (options.cutPages) {
+        pageOptions = {
+            operation: PageOptionsOperation.KeepOnly,
+            pageIndexes: [0, 1, 2, 3, 4],
+            onMinPages: 5,
+        };
+    }
+    return pageOptions;
+}
+function getPredictParams(options) {
+    return {
+        allWords: options.allWords,
+        cropper: options.cropper,
+    };
+}
+async function callParse(productClass, command, inputPath, options) {
+    const mindeeClient = initClient(options);
+    const predictParams = getPredictParams(options);
+    const pageOptions = getPageOptions(options);
+    const inputSource = new PathInput({ inputPath: inputPath });
+    let response;
+    if (command === COMMAND_GENERATED) {
+        const customEndpoint = mindeeClient.createEndpoint(options.endpoint, options.account, options.version);
+        response = await mindeeClient.parse(productClass, inputSource, {
+            endpoint: customEndpoint,
+            pageOptions: pageOptions,
+            allWords: predictParams.allWords,
+            cropper: predictParams.cropper,
+        });
+    }
+    else {
+        response = await mindeeClient.parse(productClass, inputSource, {
+            pageOptions: pageOptions,
+            allWords: predictParams.allWords,
+            cropper: predictParams.cropper,
+        });
+    }
+    printResponse(response.document, options);
+}
+async function callEnqueueAndParse(productClass, command, inputPath, options) {
+    const mindeeClient = initClient(options);
+    const predictParams = getPredictParams(options);
+    const pageOptions = getPageOptions(options);
+    const inputSource = new PathInput({ inputPath: inputPath });
+    let customEndpoint = undefined;
+    if (command === COMMAND_GENERATED) {
+        customEndpoint = mindeeClient.createEndpoint(options.endpoint, options.account, options.version);
+    }
+    const response = await mindeeClient.enqueueAndParse(productClass, inputSource, {
+        endpoint: customEndpoint,
+        pageOptions: pageOptions,
+        allWords: predictParams.allWords,
+        cropper: predictParams.cropper,
+        initialDelaySec: 2,
+        delaySec: 1.5,
+        maxRetries: 80,
+    });
+    if (!response.document) {
+        throw Error("Document could not be retrieved");
+    }
+    printResponse(response.document, options);
+}
+async function callGetDocument(productClass, documentId, options) {
+    const mindeeClient = initClient(options);
+    const response = await mindeeClient.getDocument(productClass, documentId);
+    printResponse(response.document, options);
+}
+function printResponse(document, options) {
+    if (options.allWords) {
+        document.ocr?.mVisionV1.pages.forEach((page) => {
+            console.log(page.allWords.toString());
+        });
+    }
+    if (options.pages) {
+        document.inference.pages.forEach((page) => {
+            console.log(`\n${page}`);
+        });
+    }
+    if (document) {
+        console.log(`\n${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.allWords) {
+        prog.option("-w, --all-words", "to get all the words in the current document. False by default.");
+    }
+    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) {
+    if (command.parent === null || command.parent === undefined) {
+        throw new Error(`Improperly configured command: ${command.name()}`);
+    }
+    const docClass = getConfig(command.parent.name()).docClass;
+    if ("async" in command.opts() && command.opts()["async"]) {
+        return callEnqueueAndParse(docClass, command.name(), inputPath, allOptions);
+    }
+    return callParse(docClass, command.name(), inputPath, allOptions);
+}
+function addPredictAction(prog) {
+    if (prog.name() === COMMAND_GENERATED) {
+        prog.action(function (inputPath, options, command) {
+            const allOptions = {
+                ...prog.parent?.parent?.opts(),
+                ...prog.parent?.opts(),
+                ...prog.opts(),
+                ...options,
+            };
+            return routeSwitchboard(command, inputPath, allOptions);
+        });
+    }
+    else {
+        prog.action(function (inputPath, options, command) {
+            const allOptions = {
+                ...prog.parent?.parent?.opts(),
+                ...prog.parent?.opts(),
+                ...prog.opts(),
+                ...options,
+            };
+            return routeSwitchboard(command, inputPath, allOptions);
+        });
+    }
+}
+export function cli() {
+    program.name("mindee")
+        .description("Command line interface for Mindee products.")
+        .option("-d, --debug", "high verbosity mode");
+    CLI_COMMAND_CONFIG.forEach((info, name) => {
+        const productCmd = program.command(name)
+            .description(info.displayName);
+        if (info.async) {
+            const getDocProductCmd = productCmd.command("fetch")
+                .description("Fetch previously parsed results.")
+                .argument("<documentId>", "Unique ID of the document.")
+                .action(async (documentId, options) => {
+                const docClass = getConfig(name).docClass;
+                await callGetDocument(docClass, documentId, { ...options, ...productCmd.opts(), ...program.opts() });
+            });
+            addMainOptions(getDocProductCmd);
+        }
+        const predictProductCmd = productCmd.command("parse")
+            .description("Send a file for parsing.");
+        if (info.async) {
+            const asyncOpt = new Option("-A, --async", "Call asynchronously");
+            if (info.sync) {
+                asyncOpt.default(false);
+            }
+            else {
+                asyncOpt.default(true);
+                asyncOpt.hideHelp();
+            }
+            predictProductCmd.addOption(asyncOpt);
+        }
+        if (name === COMMAND_GENERATED) {
+            addCustomPostOptions(predictProductCmd);
+        }
+        addMainOptions(predictProductCmd);
+        addDisplayOptions(predictProductCmd);
+        addPostOptions(predictProductCmd, info);
+        addPredictAction(predictProductCmd);
+    });
+    program.parse(process.argv);
+}

package/src/v1/client.d.ts

@@ -0,0 +1,215 @@
+import { Dispatcher } from "undici";
+import { InputSource, PageOptions } from "../input/index.js";
+import { ApiSettingsV1, Endpoint } from "./http/index.js";
+import { AsyncPredictResponse, ExecutionPriority, FeedbackResponse, Inference, PredictResponse, StringDict, WorkflowResponse } from "./parsing/common/index.js";
+import { GeneratedV1 } from "./product/index.js";
+/**
+ * Common options for workflows and predictions.
+ */
+interface BaseOptions {
+    /**
+     * Whether to include the full ocr text. Only available on compatible APIs.
+     */
+    fullText?: boolean;
+    /**
+     * If set, remove pages from the document as specified.
+     * This is done before sending the file to the server and is useful to avoid page limitations.
+     */
+    pageOptions?: PageOptions;
+    /**
+     * If set, will enable Retrieval-Augmented Generation (only works if a valid workflowId is set).
+     */
+    rag?: boolean;
+}
+/**
+ * Options relating to predictions.
+ */
+export interface PredictOptions extends BaseOptions {
+    /** A custom endpoint. */
+    endpoint?: Endpoint;
+    /**
+     * Whether to include the full text for each page.
+     *
+     * This performs a full OCR operation on the server and will increase response time.
+     */
+    allWords?: boolean;
+    /**
+     * Whether to include cropper results for each page.
+     */
+    cropper?: boolean;
+    /**
+     * The ID of the workflow.
+     */
+    workflowId?: string;
+}
+/**
+ * Options relating to workflows.
+ * @category Workflow
+ */
+export interface WorkflowOptions extends BaseOptions {
+    /**
+     * Alias to give to the document.
+     */
+    alias?: string;
+    /**
+     * Priority to give to the document.
+     */
+    priority?: ExecutionPriority;
+    /**
+     * A unique, encrypted URL for accessing the document validation interface without requiring authentication.
+     */
+    publicUrl?: string;
+}
+/**
+ * Asynchronous polling parameters.
+ */
+export interface OptionalAsyncOptions extends PredictOptions {
+    initialDelaySec?: number;
+    delaySec?: number;
+    maxRetries?: number;
+    initialTimerOptions?: {
+        ref?: boolean;
+        signal?: AbortSignal;
+    };
+    recurringTimerOptions?: {
+        ref?: boolean;
+        signal?: AbortSignal;
+    };
+}
+export interface AsyncOptions extends PredictOptions {
+    initialDelaySec: number;
+    delaySec: number;
+    maxRetries: number;
+    initialTimerOptions?: {
+        ref?: boolean;
+        signal?: AbortSignal;
+    };
+    recurringTimerOptions?: {
+        ref?: boolean;
+        signal?: AbortSignal;
+    };
+}
+export interface ClientOptions {
+    /** Your API key for all endpoints. */
+    apiKey?: string;
+    /** Raise an `Error` on errors. */
+    throwOnError?: boolean;
+    /** Log debug messages. */
+    debug?: boolean;
+    /** Custom dispatcher for HTTP requests. */
+    dispatcher?: Dispatcher;
+}
+/**
+ * Mindee Client class that centralizes most basic operations.
+ *
+ * @category Client
+ */
+export declare class Client {
+    #private;
+    /** Mindee V1 API settings. */
+    protected apiSettings: ApiSettingsV1;
+    /**
+     * @param {ClientOptions} options options for the initialization of a client.
+     */
+    constructor({ apiKey, throwOnError, debug, dispatcher }?: ClientOptions);
+    /**
+     * Send a document to a synchronous endpoint and parse the predictions.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param inputSource file to parse.
+     * @param params parameters relating to prediction options.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    parse<T extends Inference>(productClass: new (httpResponse: StringDict) => T, inputSource: InputSource, params?: PredictOptions): Promise<PredictResponse<T>>;
+    /**
+     * Send the document to an asynchronous endpoint and return its ID in the queue.
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param inputSource file to parse.
+     * @param params parameters relating to prediction options.
+     * @category Asynchronous
+     * @returns a `Promise` containing the job (queue) corresponding to a document.
+     */
+    enqueue<T extends Inference>(productClass: new (httpResponse: StringDict) => T, inputSource: InputSource, params?: PredictOptions): Promise<AsyncPredictResponse<T>>;
+    /**
+     * Polls a queue and returns its status as well as the prediction results if the parsing is done.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param queueId id of the queue to poll.
+     * @param params parameters relating to prediction options.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Asynchronous
+     * @returns a `Promise` containing a `Job`, which also contains a `Document` if the
+     * parsing is complete.
+     */
+    parseQueued<T extends Inference>(productClass: new (httpResponse: StringDict) => T, queueId: string, params?: PredictOptions): Promise<AsyncPredictResponse<T>>;
+    /**
+     * Send the document to an asynchronous endpoint and return its ID in the queue.
+     * @param inputSource file to send to the API.
+     * @param workflowId ID of the workflow.
+     * @param params parameters relating to prediction options.
+     * @category Workflow
+     * @returns a `Promise` containing the job (queue) corresponding to a document.
+     */
+    executeWorkflow(inputSource: InputSource, workflowId: string, params?: WorkflowOptions): Promise<WorkflowResponse<GeneratedV1>>;
+    /**
+     * Fetch prediction results from a document already processed.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param documentId id of the document to fetch.
+     * @param params optional parameters.
+     * @param params.endpoint Endpoint, only specify if using a custom product.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    getDocument<T extends Inference>(productClass: new (httpResponse: StringDict) => T, documentId: string, params?: {
+        endpoint?: Endpoint;
+    }): Promise<PredictResponse<T>>;
+    /**
+     * Send feedback for a document.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param documentId id of the document to send feedback for.
+     * @param feedback the feedback to send.
+     * @param params optional parameters.
+     * @param params.endpoint Endpoint, only specify if using a custom product.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing feedback results.
+     */
+    sendFeedback<T extends Inference>(productClass: new (httpResponse: StringDict) => T, documentId: string, feedback: StringDict, params?: {
+        endpoint?: Endpoint;
+    }): Promise<FeedbackResponse>;
+    /**
+     * Send a document to an asynchronous endpoint and poll the server until the result is sent or
+     * until the maximum number of tries is reached.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param inputSource document to parse.
+     * @param asyncParams parameters relating to prediction options.
+     *
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    enqueueAndParse<T extends Inference>(productClass: new (httpResponse: StringDict) => T, inputSource: InputSource, asyncParams?: OptionalAsyncOptions): Promise<AsyncPredictResponse<T>>;
+    /**
+     * Forces boolean coercion on truthy/falsy parameters.
+     * @param param input parameter to check.
+     * @returns a strict boolean value.
+     */
+    protected getBooleanParam(param?: boolean): boolean;
+    /**
+     * Creates a custom endpoint with the given values. Raises an error if the endpoint is invalid.
+     * @param endpointName Name of the custom Endpoint.
+     * @param accountName Name of the account tied to the Endpoint.
+     * @param endpointVersion Version of the custom Endpoint.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     *
+     * @returns Endpoint a new product endpoint
+     */
+    createEndpoint(endpointName: string, accountName: string, endpointVersion?: string): Endpoint;
+}
+export {};