mindee 4.36.3 → 5.0.0-alpha1

package/src/http/endpoint.js

@@ -1,243 +0,0 @@
-"use strict";
-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 _Endpoint_instances, _Endpoint_predictReqPost, _Endpoint_predictAsyncReqPost, _Endpoint_documentQueueReqGet, _Endpoint_documentGetReq, _Endpoint_documentFeedbackPutReq;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Endpoint = void 0;
-const url_1 = require("url");
-const form_data_1 = __importDefault(require("form-data"));
-const input_1 = require("../input");
-const error_1 = require("./error");
-const baseEndpoint_1 = require("./baseEndpoint");
-const responseValidation_1 = require("./responseValidation");
-/**
- * Endpoint for a product (OTS or Custom).
- */
-class Endpoint extends baseEndpoint_1.BaseEndpoint {
-    constructor(urlName, owner, version, settings) {
-        super(settings, `/v1/products/${owner}/${urlName}/v${version}`);
-        _Endpoint_instances.add(this);
-        this.owner = owner;
-        this.urlName = urlName;
-        this.version = version;
-    }
-    /**
-     * Changes the url to a workflow ID.
-     * @param workflowId
-     */
-    useWorkflowId(workflowId) {
-        this.urlRoot = `/v1/workflows/${workflowId}`;
-    }
-    /**
-     * Sends a document to the API and parses out the result.
-     * Throws an error if the server's response contains one.
-     * @param {PredictParams} params parameters relating to prediction options.
-     * @category Synchronous
-     * @returns a `Promise` containing parsing results.
-     */
-    async predict(params) {
-        await params.inputDoc.init();
-        if (params.pageOptions !== undefined) {
-            await baseEndpoint_1.BaseEndpoint.cutDocPages(params.inputDoc, params.pageOptions);
-        }
-        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictReqPost).call(this, params.inputDoc, params.includeWords, params.fullText, params.cropper);
-        if (!(0, responseValidation_1.isValidSyncResponse)(response)) {
-            (0, error_1.handleError)(this.urlName, response, this.extractStatusMessage(response));
-        }
-        return response;
-    }
-    /**
-     * Enqueues a prediction to the API.
-     * Throws an error if the server's response contains one.
-     * @param {PredictParams} params parameters relating to prediction options.
-     * @category Asynchronous
-     * @returns a `Promise` containing queue data.
-     */
-    async predictAsync(params) {
-        await params.inputDoc.init();
-        if (params.pageOptions !== undefined) {
-            await baseEndpoint_1.BaseEndpoint.cutDocPages(params.inputDoc, params.pageOptions);
-        }
-        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictAsyncReqPost).call(this, params.inputDoc, params.includeWords, params.fullText, params.cropper, params.rag, params.workflowId);
-        if (!(0, responseValidation_1.isValidAsyncResponse)(response)) {
-            (0, error_1.handleError)(this.urlName, response, this.extractStatusMessage(response));
-        }
-        return response;
-    }
-    extractStatusMessage(response) {
-        if (response.messageObj?.statusMessage !== undefined && response.messageObj?.statusMessage !== null) {
-            return response.messageObj?.statusMessage;
-        }
-        const errorDetail = response.data?.api_request?.error?.detail;
-        if (errorDetail) {
-            return JSON.stringify(errorDetail);
-        }
-        const errorMessage = response.data?.api_request?.error?.message;
-        if (errorMessage) {
-            return JSON.stringify(errorMessage);
-        }
-        return undefined;
-    }
-    /**
-     * Requests the results of a queued document from the API.
-     * Throws an error if the server's response contains one.
-     * @param queueId The document's ID in the queue.
-     * @category Asynchronous
-     * @returns a `Promise` containing the parsed result.
-     */
-    async getQueuedDocument(queueId) {
-        const queueResponse = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentQueueReqGet).call(this, queueId);
-        const queueStatusCode = queueResponse.messageObj.statusCode;
-        if (!(0, responseValidation_1.isValidAsyncResponse)(queueResponse)) {
-            (0, error_1.handleError)(this.urlName, queueResponse, this.extractStatusMessage(queueResponse));
-        }
-        if (queueStatusCode === 302 &&
-            queueResponse.messageObj.headers.location !== undefined) {
-            const docId = queueResponse.messageObj.headers.location.split("/").pop();
-            if (docId !== undefined) {
-                return await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentGetReq).call(this, docId);
-            }
-        }
-        return queueResponse;
-    }
-    /**
-     * Send a feedback
-     * @param {string} documentId
-     */
-    async getDocument(documentId) {
-        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentGetReq).call(this, documentId);
-        if (!(0, responseValidation_1.isValidAsyncResponse)(response)) {
-            (0, error_1.handleError)("document", response, this.extractStatusMessage(response));
-        }
-        return response;
-    }
-    /**
-     * Send a feedback
-     * @param {string} documentId - ID of the document to send feedback to.
-     * @param {StringDict} feedback - Feedback object to send.
-     */
-    async sendFeedback(documentId, feedback) {
-        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentFeedbackPutReq).call(this, documentId, feedback);
-        if (!(0, responseValidation_1.isValidSyncResponse)(response)) {
-            (0, error_1.handleError)("feedback", response, this.extractStatusMessage(response));
-        }
-        return response;
-    }
-    /**
-     * Send a file to a prediction API.
-     * @param input
-     * @param predictUrl
-     * @param includeWords
-     * @param fullText
-     * @param cropper
-     * @param rag
-     * @param workflowId
-     */
-    sendFileForPrediction(input, predictUrl, includeWords = false, fullText = false, cropper = false, rag = false, workflowId = undefined) {
-        return new Promise((resolve, reject) => {
-            const searchParams = new url_1.URLSearchParams();
-            if (cropper) {
-                searchParams.append("cropper", "true");
-            }
-            if (rag) {
-                searchParams.append("rag", "true");
-            }
-            if (fullText) {
-                searchParams.append("full_text_ocr", "true");
-            }
-            const form = new form_data_1.default();
-            if (input instanceof input_1.LocalInputSource && 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.settings.baseHeaders, ...form.getHeaders() };
-            let path;
-            if (workflowId === undefined) {
-                path = `${this.urlRoot}/${predictUrl}`;
-            }
-            else {
-                path = `/v1/workflows/${workflowId}/predict_async`;
-            }
-            if (searchParams.toString().length > 0) {
-                path += `?${searchParams}`;
-            }
-            const options = {
-                method: "POST",
-                headers: headers,
-                hostname: this.settings.hostname,
-                path: path,
-                timeout: this.settings.timeout,
-            };
-            const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
-            form.pipe(req);
-            // potential ECONNRESET if we don't end the request.
-            req.end();
-        });
-    }
-}
-exports.Endpoint = Endpoint;
-_Endpoint_instances = new WeakSet(), _Endpoint_predictReqPost = function _Endpoint_predictReqPost(input, includeWords = false, fullText = false, cropper = false) {
-    return this.sendFileForPrediction(input, "predict", includeWords, fullText, cropper);
-}, _Endpoint_predictAsyncReqPost = function _Endpoint_predictAsyncReqPost(
-/**
- * Make a request to POST a document for async prediction.
- * @param input
- * @param includeWords
- * @param fullText
- * @param cropper
- * @param rag
- * @param workflowId
- */
-input, includeWords = false, fullText = false, cropper = false, rag = false, workflowId = undefined) {
-    return this.sendFileForPrediction(input, "predict_async", includeWords, fullText, cropper, rag, workflowId);
-}, _Endpoint_documentQueueReqGet = function _Endpoint_documentQueueReqGet(queueId) {
-    return new Promise((resolve, reject) => {
-        const options = {
-            method: "GET",
-            headers: this.settings.baseHeaders,
-            hostname: this.settings.hostname,
-            path: `${this.urlRoot}/documents/queue/${queueId}`,
-        };
-        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
-        // potential ECONNRESET if we don't end the request.
-        req.end();
-    });
-}, _Endpoint_documentGetReq = function _Endpoint_documentGetReq(documentId) {
-    return new Promise((resolve, reject) => {
-        const options = {
-            method: "GET",
-            headers: this.settings.baseHeaders,
-            hostname: this.settings.hostname,
-            path: `${this.urlRoot}/documents/${documentId}`,
-        };
-        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
-        // potential ECONNRESET if we don't end the request.
-        req.end();
-    });
-}, _Endpoint_documentFeedbackPutReq = function _Endpoint_documentFeedbackPutReq(documentId, feedback) {
-    return new Promise((resolve, reject) => {
-        const options = {
-            method: "PUT",
-            headers: this.settings.baseHeaders,
-            hostname: this.settings.hostname,
-            path: `/v1/documents/${documentId}/feedback`,
-        };
-        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
-        req.write(JSON.stringify(feedback));
-        // potential ECONNRESET if we don't end the request.
-        req.end();
-    });
-};

package/src/http/error.d.ts

@@ -1,67 +0,0 @@
-import { MindeeError } from "../errors";
-import { StringDict } from "../parsing/common";
-import { EndpointResponse } from "./baseEndpoint";
-export declare function handleError(urlName: string, response: EndpointResponse, serverError?: string): void;
-/**
- * `Error` wrapper for server (HTTP) errors.
- * Is used when an error is lacking a handled error code.
- */
-export declare class MindeeHttpError extends MindeeError {
-    /** Description of the error. */
-    message: string;
-    /** Additional details on the error. */
-    details: string | StringDict;
-    /** Standard HTTP error code. */
-    code?: number;
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}
-/**
- * Generic client errors.
- * Can include errors like InvalidQuery.
- */
-export declare class MindeeHttp400Error extends MindeeHttpError {
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}
-/**
- * Can include errors like NoTokenSet or InvalidToken.
- */
-export declare class MindeeHttp401Error extends MindeeHttpError {
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}
-/**
- * Regular AccessForbidden error.
- * Can also include errors like PlanLimitReached, AsyncRequestDisallowed or SyncRequestDisallowed.
- */
-export declare class MindeeHttp403Error extends MindeeHttpError {
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}
-export declare class MindeeHttp404Error extends MindeeHttpError {
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}
-/**
- * Rare error.
- * Can occasionally happen when unusually large documents are passed.
- */
-export declare class MindeeHttp413Error extends MindeeHttpError {
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}
-/**
- * Usually corresponds to TooManyRequests errors.
- * Arises whenever too many calls to the API are made in quick succession.
- */
-export declare class MindeeHttp429Error extends MindeeHttpError {
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}
-/**
- * Generic server errors.
- */
-export declare class MindeeHttp500Error extends MindeeHttpError {
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}
-/**
- * Miscellaneous server errors.
- * Can include errors like RequestTimeout or GatewayTimeout.
- */
-export declare class MindeeHttp504Error extends MindeeHttpError {
-    constructor(httpError: StringDict, urlName: string, code?: number);
-}

package/src/http/error.js

@@ -1,211 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MindeeHttp504Error = exports.MindeeHttp500Error = exports.MindeeHttp429Error = exports.MindeeHttp413Error = exports.MindeeHttp404Error = exports.MindeeHttp403Error = exports.MindeeHttp401Error = exports.MindeeHttp400Error = exports.MindeeHttpError = void 0;
-exports.handleError = handleError;
-const errors_1 = require("../errors");
-const handler_1 = require("../errors/handler");
-function handleError(urlName, response, serverError) {
-    let code;
-    try {
-        if (response.data.api_request["status_code"] === 200 && response.data?.job?.error?.code) {
-            code = 500;
-            response.data.api_request.error = response.data.job.error;
-        }
-        else if (response.data) {
-            code = response.data.api_request["status_code"];
-        }
-    }
-    catch {
-        code = 500;
-    }
-    let errorObj;
-    try {
-        //Regular instances where the returned error is in JSON format.
-        errorObj = response.data.api_request.error;
-    }
-    catch {
-        //Rare instances where errors are returned as HTML instead of JSON.
-        if (!("reconstructedResponse" in response.data)) {
-            response.data.reconstructedResponse = "";
-        }
-        if (response.data.reconstructedResponse.includes("Maximum pdf pages")) {
-            errorObj = {
-                message: "TooManyPages",
-                details: "Maximum amount of pdf pages reached.",
-            };
-        }
-        else if (response.data.reconstructedResponse.includes("Max file size is")) {
-            errorObj = {
-                message: "FileTooLarge",
-                details: "Maximum file size reached.",
-            };
-        }
-        else if (response.data.reconstructedResponse.includes("Invalid file type")) {
-            errorObj = {
-                message: "InvalidFiletype",
-                details: "Invalid file type.",
-            };
-        }
-        else if (response.data.reconstructedResponse.includes("Gateway timeout")) {
-            errorObj = {
-                message: "RequestTimeout",
-                details: "Request timed out.",
-            };
-        }
-        else if (response.data.reconstructedResponse.includes("Bad gateway")) {
-            errorObj = {
-                message: "BadRequest",
-                details: "Bad Gateway",
-            };
-        }
-        else if (response.data.reconstructedResponse.includes("Too Many Requests")) {
-            errorObj = {
-                message: "TooManyRequests",
-                details: "Too Many Requests.",
-            };
-        }
-        else {
-            errorObj = {
-                message: "Unknown Server Error.",
-                details: response.data.reconstructedResponse,
-            };
-        }
-    }
-    if (serverError !== undefined &&
-        (!("message" in errorObj) ||
-            !errorObj.message ||
-            errorObj.message.length === 0)) {
-        errorObj.message = serverError;
-    }
-    let errorToThrow;
-    switch (code) {
-        case 400:
-            errorToThrow = new MindeeHttp400Error(errorObj, urlName, code);
-            break;
-        case 401:
-            errorToThrow = new MindeeHttp401Error(errorObj, urlName, code);
-            break;
-        case 403:
-            errorToThrow = new MindeeHttp403Error(errorObj, urlName, code);
-            break;
-        case 404:
-            errorToThrow = new MindeeHttp404Error(errorObj, urlName, code);
-            break;
-        case 413:
-            errorToThrow = new MindeeHttp413Error(errorObj, urlName, code);
-            break;
-        case 429:
-            errorToThrow = new MindeeHttp429Error(errorObj, urlName, code);
-            break;
-        case 500:
-            errorToThrow = new MindeeHttp500Error(errorObj, urlName, code);
-            break;
-        case 504:
-            errorToThrow = new MindeeHttp504Error(errorObj, urlName, code);
-            break;
-        default:
-            errorToThrow = new MindeeHttpError(errorObj, urlName, code);
-            break;
-    }
-    handler_1.errorHandler.throw(errorToThrow);
-}
-/**
- * `Error` wrapper for server (HTTP) errors.
- * Is used when an error is lacking a handled error code.
- */
-class MindeeHttpError extends errors_1.MindeeError {
-    constructor(httpError, urlName, code) {
-        super(`${urlName} API ${code} HTTP error: ${httpError.message}`);
-        /** Description of the error. */
-        this.message = "";
-        /** Additional details on the error. */
-        this.details = "";
-        this.details = httpError.details;
-        this.message = httpError.message;
-        this.code = code;
-        this.name = "MindeeHttpError";
-    }
-}
-exports.MindeeHttpError = MindeeHttpError;
-/**
- * Generic client errors.
- * Can include errors like InvalidQuery.
- */
-class MindeeHttp400Error extends MindeeHttpError {
-    constructor(httpError, urlName, code) {
-        super(httpError, urlName, code);
-        this.name = "MindeeHttp400Error";
-    }
-}
-exports.MindeeHttp400Error = MindeeHttp400Error;
-/**
- * Can include errors like NoTokenSet or InvalidToken.
- */
-class MindeeHttp401Error extends MindeeHttpError {
-    constructor(httpError, urlName, code) {
-        super(httpError, urlName, code);
-        this.name = "MindeeHttp401Error";
-    }
-}
-exports.MindeeHttp401Error = MindeeHttp401Error;
-/**
- * Regular AccessForbidden error.
- * Can also include errors like PlanLimitReached, AsyncRequestDisallowed or SyncRequestDisallowed.
- */
-class MindeeHttp403Error extends MindeeHttpError {
-    constructor(httpError, urlName, code) {
-        super(httpError, urlName, code);
-        this.name = "MindeeHttp403Error";
-    }
-}
-exports.MindeeHttp403Error = MindeeHttp403Error;
-class MindeeHttp404Error extends MindeeHttpError {
-    constructor(httpError, urlName, code) {
-        super(httpError, urlName, code);
-        this.name = "MindeeHttp404Error";
-    }
-}
-exports.MindeeHttp404Error = MindeeHttp404Error;
-/**
- * Rare error.
- * Can occasionally happen when unusually large documents are passed.
- */
-class MindeeHttp413Error extends MindeeHttpError {
-    constructor(httpError, urlName, code) {
-        super(httpError, urlName, code);
-        this.name = "MindeeHttp413Error";
-    }
-}
-exports.MindeeHttp413Error = MindeeHttp413Error;
-/**
- * Usually corresponds to TooManyRequests errors.
- * Arises whenever too many calls to the API are made in quick succession.
- */
-class MindeeHttp429Error extends MindeeHttpError {
-    constructor(httpError, urlName, code) {
-        super(httpError, urlName, code);
-        this.name = "MindeeHttp429Error";
-    }
-}
-exports.MindeeHttp429Error = MindeeHttp429Error;
-/**
- * Generic server errors.
- */
-class MindeeHttp500Error extends MindeeHttpError {
-    constructor(httpError, urlName, code) {
-        super(httpError, urlName, code);
-        this.name = "MindeeHttp500Error";
-    }
-}
-exports.MindeeHttp500Error = MindeeHttp500Error;
-/**
- * Miscellaneous server errors.
- * Can include errors like RequestTimeout or GatewayTimeout.
- */
-class MindeeHttp504Error extends MindeeHttpError {
-    constructor(httpError, urlName, code) {
-        super(httpError, urlName, code);
-        this.name = "MindeeHttp504Error";
-    }
-}
-exports.MindeeHttp504Error = MindeeHttp504Error;

package/src/http/httpParams.d.ts

@@ -1,19 +0,0 @@
-import { InputSource, PageOptions } from "../input";
-import { ExecutionPriority } from "../parsing/common";
-interface HTTPParams {
-    inputDoc: InputSource;
-    fullText: boolean;
-    pageOptions?: PageOptions;
-    rag?: boolean;
-}
-export interface PredictParams extends HTTPParams {
-    includeWords: boolean;
-    cropper: boolean;
-    workflowId?: string;
-}
-export interface WorkflowParams extends HTTPParams {
-    alias?: string;
-    priority?: ExecutionPriority;
-    publicUrl?: string;
-}
-export {};

package/src/http/httpParams.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/src/http/mindeeApiV2.d.ts

@@ -1,34 +0,0 @@
-import { ApiSettingsV2 } from "./apiSettingsV2";
-import { InferenceParameters } from "../clientV2";
-import { InferenceResponse, JobResponse } from "../parsing/v2";
-import { InputSource } from "../input";
-export declare class MindeeApiV2 {
-    #private;
-    settings: ApiSettingsV2;
-    constructor(apiKey?: string);
-    /**
-     * Sends a file to the inference queue.
-     * @param inputSource Local file loaded as an input.
-     * @param params {InferenceParameters} parameters relating to the enqueueing options.
-     * @category V2
-     * @throws Error if the server's response contains one.
-     * @returns a `Promise` containing a job response.
-     */
-    reqPostInferenceEnqueue(inputSource: InputSource, params: InferenceParameters): Promise<JobResponse>;
-    /**
-     * Requests the job of a queued document from the API.
-     * Throws an error if the server's response contains one.
-     * @param inferenceId The document's ID in the queue.
-     * @category Asynchronous
-     * @returns a `Promise` containing either the parsed result, or information on the queue.
-     */
-    reqGetInference(inferenceId: string): Promise<InferenceResponse>;
-    /**
-     * Requests the results of a queued document from the API.
-     * Throws an error if the server's response contains one.
-     * @param jobId The document's ID in the queue.
-     * @category Asynchronous
-     * @returns a `Promise` containing information on the queue.
-     */
-    reqGetJob(jobId: string): Promise<JobResponse>;
-}