mindee 3.10.2 → 4.0.1

package/src/api/documentResponse.d.ts

@@ -1,25 +0,0 @@
-import { Document, DocumentSig } from "../documents";
-import { FullText } from "../fields";
-import { InputSource } from "../inputs";
-export interface ResponseProps {
-    httpResponse: any;
-    documentType?: string;
-    input?: InputSource;
-    error: boolean;
-}
-export type ResponseSig<DocType extends Document> = {
-    new (documentClass: DocumentSig<DocType>, params: ResponseProps): Response<DocType>;
-};
-/**
- * Base class for all responses.
- */
-export declare class Response<DocType extends Document> {
-    httpResponse: any;
-    inputFile?: InputSource;
-    document?: DocType;
-    pages: Array<DocType>;
-    readonly documentClass: DocumentSig<DocType>;
-    constructor(documentClass: DocumentSig<DocType>, params: ResponseProps);
-    protected formatResponse(documentType?: string): void;
-    protected getPageText(httpDataDocument: any, pageId: number): FullText;
-}

package/src/api/documentResponse.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Response = void 0;
-const fields_1 = require("../fields");
-/**
- * Base class for all responses.
- */
-class Response {
-    constructor(documentClass, params) {
-        this.pages = [];
-        this.documentClass = documentClass;
-        this.httpResponse = params.httpResponse;
-        this.inputFile = params.input;
-        if (!params.error) {
-            this.formatResponse(params.documentType);
-        }
-    }
-    formatResponse(documentType) {
-        const httpDataDocument = this.httpResponse.data.document;
-        httpDataDocument.inference.pages.forEach((apiPage) => {
-            const pageText = this.getPageText(httpDataDocument, apiPage.id);
-            this.pages.push(new this.documentClass({
-                documentType: documentType,
-                prediction: apiPage.prediction,
-                inputSource: this.inputFile,
-                pageId: apiPage.id,
-                orientation: apiPage.orientation,
-                extras: apiPage.extras,
-                fullText: pageText,
-            }));
-        });
-        this.document = new this.documentClass({
-            documentType: documentType,
-            prediction: httpDataDocument.inference.prediction,
-            inputSource: this.inputFile,
-            orientation: {},
-            extras: {},
-        });
-    }
-    getPageText(httpDataDocument, pageId) {
-        const pageText = new fields_1.FullText();
-        if ("ocr" in httpDataDocument &&
-            Object.keys(httpDataDocument.ocr).length > 0) {
-            pageText.words =
-                httpDataDocument.ocr["mvision-v1"].pages[pageId].all_words;
-        }
-        return pageText;
-    }
-}
-exports.Response = Response;

package/src/api/endpoint.d.ts

@@ -1,63 +0,0 @@
-/// <reference types="node" />
-import { InputSource } from "../inputs";
-import { IncomingMessage, RequestOptions, ClientRequest } from "http";
-export declare const STANDARD_API_OWNER = "mindee";
-export declare const API_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
-export declare const API_HOST_ENVVAR_NAME = "MINDEE_API_HOST";
-export interface EndpointResponse {
-    messageObj: IncomingMessage;
-    data: {
-        [key: string]: any;
-    };
-}
-export declare class Endpoint {
-    apiKey: string;
-    urlName: string;
-    owner: string;
-    version: string;
-    hostname: string;
-    urlRoot: string;
-    private readonly baseHeaders;
-    constructor(owner: string, urlName: string, version: string, apiKey: string);
-    /**
-     * Make a request to POST a document for prediction.
-     * @param input
-     * @param includeWords
-     * @param cropper
-     */
-    predictReqPost(input: InputSource, includeWords?: boolean, cropper?: boolean): Promise<EndpointResponse>;
-    /**
-     * Make a request to POST a document for async prediction.
-     * @param input
-     * @param includeWords
-     * @param cropper
-     */
-    predictAsyncReqPost(input: InputSource, includeWords?: boolean, cropper?: boolean): Promise<EndpointResponse>;
-    /**
-     * Make a request to GET the status of a document in the queue.
-     * @param queueId
-     */
-    documentQueueReqGet(queueId: string): Promise<EndpointResponse>;
-    /**
-     * Make a request to GET a document.
-     * @param documentId
-     */
-    documentGetReq(documentId: string): Promise<EndpointResponse>;
-    /**
-     * Send a file to a prediction API.
-     * @param input
-     * @param predictUrl
-     * @param includeWords
-     * @param cropper
-     */
-    protected sendFileForPrediction(input: InputSource, predictUrl: string, includeWords?: boolean, cropper?: boolean): Promise<EndpointResponse>;
-    protected readResponse(options: RequestOptions, resolve: (value: EndpointResponse | PromiseLike<EndpointResponse>) => void, reject: (reason?: any) => void): ClientRequest;
-    protected apiKeyFromEnv(): string;
-    protected hostnameFromEnv(): string;
-}
-export declare class StandardEndpoint extends Endpoint {
-    constructor(endpointName: string, version: string, apiKey: string);
-}
-export declare class CustomEndpoint extends Endpoint {
-    constructor(endpointName: string, accountName: string, version: string, apiKey: string);
-}

package/src/api/endpoint.js

@@ -1,216 +0,0 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomEndpoint = exports.StandardEndpoint = exports.Endpoint = exports.API_HOST_ENVVAR_NAME = exports.API_KEY_ENVVAR_NAME = exports.STANDARD_API_OWNER = void 0;
-const https = __importStar(require("https"));
-const os = __importStar(require("os"));
-const package_json_1 = require("../../package.json");
-const url_1 = require("url");
-const form_data_1 = __importDefault(require("form-data"));
-const logger_1 = require("../logger");
-const DEFAULT_MINDEE_API_HOST = "api.mindee.net";
-const USER_AGENT = `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${os.type().toLowerCase()}`;
-exports.STANDARD_API_OWNER = "mindee";
-exports.API_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
-exports.API_HOST_ENVVAR_NAME = "MINDEE_API_HOST";
-class Endpoint {
-    constructor(owner, urlName, version, apiKey) {
-        this.owner = owner;
-        this.urlName = urlName;
-        this.version = version;
-        this.apiKey = apiKey || this.apiKeyFromEnv();
-        this.hostname = this.hostnameFromEnv();
-        this.urlRoot = `/v1/products/${owner}/${urlName}/v${version}`;
-        this.baseHeaders = {
-            "User-Agent": USER_AGENT,
-            Authorization: `Token ${this.apiKey}`,
-        };
-    }
-    /**
-     * Make a request to POST a document for prediction.
-     * @param input
-     * @param includeWords
-     * @param cropper
-     */
-    predictReqPost(input, includeWords = false, cropper = false) {
-        return this.sendFileForPrediction(input, "predict", includeWords, cropper);
-    }
-    /**
-     * Make a request to POST a document for async prediction.
-     * @param input
-     * @param includeWords
-     * @param cropper
-     */
-    predictAsyncReqPost(input, includeWords = false, cropper = false) {
-        return this.sendFileForPrediction(input, "predict_async", includeWords, cropper);
-    }
-    /**
-     * Make a request to GET the status of a document in the queue.
-     * @param queueId
-     */
-    documentQueueReqGet(queueId) {
-        return new Promise((resolve, reject) => {
-            const options = {
-                method: "GET",
-                headers: this.baseHeaders,
-                hostname: this.hostname,
-                path: `${this.urlRoot}/documents/queue/${queueId}`,
-            };
-            const req = this.readResponse(options, resolve, reject);
-            // potential ECONNRESET if we don't end the request.
-            req.end();
-        });
-    }
-    /**
-     * Make a request to GET a document.
-     * @param documentId
-     */
-    documentGetReq(documentId) {
-        return new Promise((resolve, reject) => {
-            const options = {
-                method: "GET",
-                headers: this.baseHeaders,
-                hostname: this.hostname,
-                path: `${this.urlRoot}/documents/${documentId}`,
-            };
-            const req = this.readResponse(options, resolve, reject);
-            // potential ECONNRESET if we don't end the request.
-            req.end();
-        });
-    }
-    /**
-     * Send a file to a prediction API.
-     * @param input
-     * @param predictUrl
-     * @param includeWords
-     * @param cropper
-     */
-    sendFileForPrediction(input, predictUrl, includeWords = false, cropper = false) {
-        return new Promise((resolve, reject) => {
-            const searchParams = new url_1.URLSearchParams();
-            if (cropper) {
-                searchParams.append("cropper", "true");
-            }
-            const form = new form_data_1.default();
-            if (input.fileObject instanceof Buffer) {
-                form.append("document", input.fileObject, { filename: input.filename });
-            }
-            else {
-                form.append("document", input.fileObject);
-            }
-            if (includeWords) {
-                form.append("include_mvision", "true");
-            }
-            const headers = { ...this.baseHeaders, ...form.getHeaders() };
-            let path = `${this.urlRoot}/${predictUrl}`;
-            if (searchParams.keys.length > 0) {
-                path += `?${searchParams}`;
-            }
-            const options = {
-                method: "POST",
-                headers: headers,
-                hostname: this.hostname,
-                path: path,
-            };
-            const req = this.readResponse(options, resolve, reject);
-            form.pipe(req);
-            // potential ECONNRESET if we don't end the request.
-            req.end();
-        });
-    }
-    readResponse(options, resolve, reject) {
-        logger_1.logger.debug(`${options.method}: https://${options.hostname}${options.path}`);
-        const req = https.request(options, function (res) {
-            // when the encoding is set, data chunks will be strings
-            res.setEncoding("utf-8");
-            let responseBody = "";
-            res.on("data", function (chunk) {
-                logger_1.logger.debug("Receiving data ...");
-                responseBody += chunk;
-            });
-            res.on("end", function () {
-                logger_1.logger.debug("Parsing the response ...");
-                // handle empty responses from server, for example in the case of redirects
-                if (!responseBody) {
-                    responseBody = "{}";
-                }
-                try {
-                    const parsedResponse = JSON.parse(responseBody);
-                    try {
-                        resolve({
-                            messageObj: res,
-                            data: parsedResponse,
-                        });
-                    }
-                    catch (error) {
-                        logger_1.logger.error("Could not construct the return object.");
-                        reject(error);
-                    }
-                }
-                catch (error) {
-                    logger_1.logger.error("Could not parse the return as JSON.");
-                    logger_1.logger.debug(responseBody);
-                    reject(error);
-                }
-            });
-        });
-        req.on("error", (err) => {
-            reject(err);
-        });
-        return req;
-    }
-    apiKeyFromEnv() {
-        const envVarValue = process.env[exports.API_KEY_ENVVAR_NAME];
-        if (envVarValue) {
-            logger_1.logger.debug(`Set ${this.urlName} v${this.version} API key from environment: ${exports.API_KEY_ENVVAR_NAME}`);
-            return envVarValue;
-        }
-        return "";
-    }
-    hostnameFromEnv() {
-        const envVarValue = process.env[exports.API_HOST_ENVVAR_NAME];
-        if (envVarValue) {
-            logger_1.logger.debug(`Set the API hostname to ${envVarValue}`);
-            return envVarValue;
-        }
-        return DEFAULT_MINDEE_API_HOST;
-    }
-}
-exports.Endpoint = Endpoint;
-class StandardEndpoint extends Endpoint {
-    constructor(endpointName, version, apiKey) {
-        super(exports.STANDARD_API_OWNER, endpointName, version, apiKey);
-    }
-}
-exports.StandardEndpoint = StandardEndpoint;
-class CustomEndpoint extends Endpoint {
-    constructor(endpointName, accountName, version, apiKey) {
-        super(accountName, endpointName, version, apiKey);
-    }
-}
-exports.CustomEndpoint = CustomEndpoint;

package/src/api/index.d.ts

@@ -1,3 +0,0 @@
-export { Response, ResponseSig } from "./documentResponse";
-export { Endpoint, CustomEndpoint, StandardEndpoint, EndpointResponse, STANDARD_API_OWNER, API_KEY_ENVVAR_NAME, } from "./endpoint";
-export { AsyncPredictResponse } from "./predictResponse";

package/src/api/index.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncPredictResponse = exports.API_KEY_ENVVAR_NAME = exports.STANDARD_API_OWNER = exports.StandardEndpoint = exports.CustomEndpoint = exports.Endpoint = exports.Response = void 0;
-var documentResponse_1 = require("./documentResponse");
-Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return documentResponse_1.Response; } });
-var endpoint_1 = require("./endpoint");
-Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return endpoint_1.Endpoint; } });
-Object.defineProperty(exports, "CustomEndpoint", { enumerable: true, get: function () { return endpoint_1.CustomEndpoint; } });
-Object.defineProperty(exports, "StandardEndpoint", { enumerable: true, get: function () { return endpoint_1.StandardEndpoint; } });
-Object.defineProperty(exports, "STANDARD_API_OWNER", { enumerable: true, get: function () { return endpoint_1.STANDARD_API_OWNER; } });
-Object.defineProperty(exports, "API_KEY_ENVVAR_NAME", { enumerable: true, get: function () { return endpoint_1.API_KEY_ENVVAR_NAME; } });
-var predictResponse_1 = require("./predictResponse");
-Object.defineProperty(exports, "AsyncPredictResponse", { enumerable: true, get: function () { return predictResponse_1.AsyncPredictResponse; } });

package/src/api/predictResponse.d.ts

@@ -1,33 +0,0 @@
-import { StringDict } from "../fields";
-import { Document } from "../documents";
-import { Response } from "./documentResponse";
-export declare class Job {
-    issuedAt: Date;
-    availableAt?: Date;
-    id?: string;
-    status?: "waiting" | "processing" | "completed";
-    /**
-     * The time taken to process the job, in milliseconds.
-     */
-    milliSecsTaken?: number;
-    constructor(jsonResponse: StringDict);
-    protected datetimeWithTimezone(date: string): Date;
-}
-export declare class ApiRequest {
-    error: StringDict;
-    resources: string[];
-    status: "failure" | "success";
-    /** HTTP status code */
-    statusCode: number;
-    url: string;
-    constructor(serverResponse: StringDict);
-}
-export declare class BasePredictResponse {
-    apiRequest: ApiRequest;
-    constructor(serverResponse: StringDict);
-}
-export declare class AsyncPredictResponse<DocType extends Document> extends BasePredictResponse {
-    job: Job;
-    document?: Response<DocType>;
-    constructor(serverResponse: StringDict, document?: Response<DocType>);
-}

package/src/api/predictResponse.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncPredictResponse = exports.BasePredictResponse = exports.ApiRequest = exports.Job = void 0;
-class Job {
-    constructor(jsonResponse) {
-        this.issuedAt = this.datetimeWithTimezone(jsonResponse["issued_at"]);
-        if (jsonResponse["available_at"] !== undefined &&
-            jsonResponse["available_at"] !== null) {
-            this.availableAt = this.datetimeWithTimezone(jsonResponse["available_at"]);
-        }
-        this.id = jsonResponse["id"];
-        this.status = jsonResponse["status"];
-        if (this.availableAt !== undefined) {
-            this.milliSecsTaken =
-                this.availableAt.getTime() - this.issuedAt.getTime();
-        }
-    }
-    // Hideous thing to make sure dates sent back by the server are parsed correctly in UTC.
-    datetimeWithTimezone(date) {
-        if (date.search(/\+[0-9]{2}:[0-9]{2}$/) === -1) {
-            date += "+00:00";
-        }
-        return new Date(date);
-    }
-}
-exports.Job = Job;
-class ApiRequest {
-    constructor(serverResponse) {
-        this.error = serverResponse["error"];
-        this.resources = serverResponse["resources"];
-        this.status = serverResponse["status"];
-        this.statusCode = serverResponse["status_code"];
-        this.url = serverResponse["url"];
-    }
-}
-exports.ApiRequest = ApiRequest;
-// For upcoming v4, use this as the base for all responses.
-// To not break compatibility, in v3.x, we will only use it as the base for async responses.
-class BasePredictResponse {
-    constructor(serverResponse) {
-        this.apiRequest = new ApiRequest(serverResponse["api_request"]);
-    }
-}
-exports.BasePredictResponse = BasePredictResponse;
-class AsyncPredictResponse extends BasePredictResponse {
-    constructor(serverResponse, document) {
-        super(serverResponse);
-        this.job = new Job(serverResponse["job"]);
-        this.document = document;
-    }
-}
-exports.AsyncPredictResponse = AsyncPredictResponse;

package/src/documents/cropper/cropperV1.d.ts

@@ -1,7 +0,0 @@
-import { Document, DocumentConstructorProps } from "../document";
-import { PositionField } from "../../fields";
-export declare class CropperV1 extends Document {
-    cropping: PositionField[];
-    constructor({ prediction, orientation, inputSource, pageId, }: DocumentConstructorProps);
-    toString(): string;
-}

package/src/documents/cropper/cropperV1.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CropperV1 = void 0;
-const document_1 = require("../document");
-const fields_1 = require("../../fields");
-class CropperV1 extends document_1.Document {
-    constructor({ prediction, orientation = undefined, inputSource = undefined, pageId = undefined, }) {
-        super({
-            inputSource: inputSource,
-            pageId: pageId,
-            orientation: orientation,
-        });
-        this.cropping = [];
-        if (pageId !== undefined) {
-            prediction.cropping.forEach((crop) => {
-                this.cropping.push(new fields_1.PositionField({
-                    prediction: crop,
-                    pageId: pageId,
-                }));
-            });
-        }
-    }
-    toString() {
-        const cropping = this.cropping
-            .map((crop) => crop.toString())
-            .join("\n          ");
-        const outStr = `----- Cropper Data -----
-Filename: ${this.filename}
-Cropping: ${cropping}
-------------------------
-`;
-        return CropperV1.cleanOutString(outStr);
-    }
-}
-exports.CropperV1 = CropperV1;

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

@@ -1,10 +0,0 @@
-import { Document, DocumentConstructorProps } from "../document";
-import { ClassificationField, ListField } from "./fields";
-import { StringDict } from "../../fields";
-export declare class CustomV1 extends Document {
-    fields: Map<string, ListField>;
-    classifications: Map<string, ClassificationField>;
-    constructor({ inputSource, prediction, extras, orientation, pageId, documentType, }: DocumentConstructorProps);
-    protected setField(fieldName: string, apiPrediction: StringDict, pageId: number | undefined): void;
-    toString(): string;
-}

package/src/documents/custom/customV1.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomV1 = void 0;
-const document_1 = require("../document");
-const fields_1 = require("./fields");
-class CustomV1 extends document_1.Document {
-    constructor({ inputSource, prediction, extras = undefined, orientation = undefined, pageId, documentType, }) {
-        super({
-            inputSource: inputSource,
-            pageId: pageId,
-            orientation: orientation,
-            extras: extras,
-            documentType: documentType,
-        });
-        this.fields = new Map();
-        this.classifications = new Map();
-        Object.keys(prediction).forEach((fieldName) => {
-            this.setField(fieldName, prediction, pageId);
-        });
-    }
-    setField(fieldName, apiPrediction, pageId) {
-        // Currently, two types of fields possible in a custom API response:
-        // fields having a list of values, and classification fields.
-        const fieldPrediction = apiPrediction[fieldName];
-        if (fieldPrediction["values"] !== undefined) {
-            // Only value lists have the 'values' attribute.
-            this.fields.set(fieldName, new fields_1.ListField({
-                prediction: fieldPrediction,
-                pageId: pageId,
-            }));
-        }
-        else if (fieldPrediction["value"] !== undefined) {
-            // Only classifications have the 'value' attribute.
-            this.classifications.set(fieldName, new fields_1.ClassificationField({ prediction: fieldPrediction }));
-        }
-        else {
-            throw "Unknown API field type";
-        }
-    }
-    toString() {
-        let outStr = `----- ${this.docType} -----`;
-        outStr += `\nFilename: ${this.filename}`.trimEnd();
-        this.classifications.forEach((fieldData, name) => {
-            outStr += `\n${name}: ${fieldData}`.trimEnd();
-        });
-        this.fields.forEach((fieldData, name) => {
-            outStr += `\n${name}: ${fieldData}`.trimEnd();
-        });
-        outStr += "\n----------------------\n";
-        return outStr;
-    }
-}
-exports.CustomV1 = CustomV1;

package/src/documents/document.d.ts

@@ -1,47 +0,0 @@
-import { InputSource } from "../inputs";
-import { PositionField, FullText, OrientationField, StringDict } from "../fields";
-export type DocumentSig<DocType extends Document> = {
-    new ({ prediction, orientation, extras, pageId, fullText, documentType, inputSource, }: DocumentConstructorProps): DocType;
-};
-export interface DocumentConstructorProps extends BaseDocumentConstructorProps {
-    /** JSON parsed prediction from HTTP response */
-    prediction: StringDict;
-}
-interface BaseDocumentConstructorProps {
-    /** Orientation JSON for page-level document */
-    orientation?: StringDict;
-    /** Extras JSON */
-    extras?: StringDict;
-    /** input file given to parse the document */
-    inputSource?: InputSource;
-    /** Page ID for page-level document */
-    pageId?: number;
-    /** full OCR extracted text */
-    fullText?: FullText;
-    documentType?: string;
-}
-export declare class Document {
-    checklist: {
-        [index: string]: boolean;
-    };
-    mimeType?: string;
-    filename: string;
-    filepath?: string;
-    fullText?: FullText;
-    pageId?: number | undefined;
-    orientation?: OrientationField;
-    cropper: PositionField[];
-    readonly docType: string;
-    constructor({ orientation, extras, inputSource, fullText, pageId, documentType, }: BaseDocumentConstructorProps);
-    clone(): any;
-    /** return true if all checklist of the document if true */
-    checkAll(): boolean;
-    /**
-     * 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: any): any;
-    static cleanOutString(outStr: string): string;
-}
-export {};