Requests page

changelog.d/20240515_100610_kirill.9992_data_processing.md

@@ -0,0 +1,4 @@
+### Added
+
+- Page with status information for different data processing jobs. Currently import/export and task creation jobs are supported
+  (<https://github.com/cvat-ai/cvat/pull/7537>)

cvat-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvat-core",
-  "version": "15.0.5",
+  "version": "15.1.0",
   "type": "module",
   "description": "Part of Computer Vision Tool which presents an interface for client-side integration",
   "main": "src/api.ts",

cvat-core/src/annotations.ts

@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -161,20 +161,20 @@ export function importDataset(
     file: File | string,
     options: {
         convMaskToPoly?: boolean,
-        updateStatusCallback?: (s: string, n: number) => void,
+        uploadStatusCallback?: (s: string, n: number) => void,
     } = {},
-): Promise<void> {
-    const updateStatusCallback = options.updateStatusCallback || (() => {});
+): Promise<string> {
+    const uploadStatusCallback = options.uploadStatusCallback || (() => {});
     const convMaskToPoly = 'convMaskToPoly' in options ? options.convMaskToPoly : true;
     const adjustedOptions = {
-        updateStatusCallback,
+        uploadStatusCallback,
         convMaskToPoly,
     };
 
     if (!(instance instanceof Project || instance instanceof Task || instance instanceof Job)) {
         throw new ArgumentError('Instance must be a Project || Task || Job instance');
     }
-    if (!(typeof updateStatusCallback === 'function')) {
+    if (!(typeof uploadStatusCallback === 'function')) {
         throw new ArgumentError('Callback must be a function');
     }
     if (!(typeof convMaskToPoly === 'boolean')) {

cvat-core/src/api-implementation.ts

@@ -9,6 +9,7 @@ import config from './config';
 import PluginRegistry from './plugins';
 import serverProxy from './server-proxy';
 import lambdaManager from './lambda-manager';
+import requestsManager from './requests-manager';
 import {
     isBoolean,
     isInteger,
@@ -61,6 +62,10 @@ export default function implementAPI(cvat: CVATCore): CVATCore {
     implementationMixin(cvat.lambda.listen, lambdaManager.listen.bind(lambdaManager));
     implementationMixin(cvat.lambda.requests, lambdaManager.requests.bind(lambdaManager));
 
+    implementationMixin(cvat.requests.list, requestsManager.list.bind(requestsManager));
+    implementationMixin(cvat.requests.listen, requestsManager.listen.bind(requestsManager));
+    implementationMixin(cvat.requests.cancel, requestsManager.cancel.bind(requestsManager));
+
     implementationMixin(cvat.server.about, async () => {
         const result = await serverProxy.server.about();
         return result;

cvat-core/src/api.ts

@@ -22,6 +22,7 @@ import Organization from './organization';
 import Webhook from './webhook';
 import AnnotationGuide from './guide';
 import BaseSingleFrameAction from './annotations-actions';
+import { Request } from './requests-manager';
 
 import * as enums from './enums';
 
@@ -374,6 +375,27 @@ function build(): CVATCore {
                 },
             },
         },
+        requests: {
+            async list(): Promise<{
+                requests: Request[];
+                count: number;
+            }> {
+                const result = await PluginRegistry.apiWrapper(cvat.requests.list);
+                return result;
+            },
+            async delete(rqID: string): Promise<void> {
+                const result = await PluginRegistry.apiWrapper(cvat.requests.delete, rqID);
+                return result;
+            },
+            async cancel(rqID: string): Promise<void> {
+                const result = await PluginRegistry.apiWrapper(cvat.requests.cancel, rqID);
+                return result;
+            },
+            async listen(rqID: string, callback: (request: Request) => void): Promise<Request> {
+                const result = await PluginRegistry.apiWrapper(cvat.requests.listen, rqID, callback);
+                return result;
+            },
+        },
         classes: {
             User,
             Project: implementProject(Project),

cvat-core/src/enums.ts

@@ -50,6 +50,7 @@ export enum RQStatus {
     FINISHED = 'finished',
     FAILED = 'failed',
     UNKNOWN = 'unknown',
+    DEFERRED = 'deferred',
 }
 
 export enum TaskMode {

cvat-core/src/exceptions.ts

@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -99,6 +99,8 @@ export class DataError extends Exception {}
 
 export class ScriptingError extends Exception {}
 
+export class RequestError extends Exception {}
+
 export class ServerError extends Exception {
     public code: number;
     constructor(message, code) {

cvat-core/src/index.ts

@@ -4,6 +4,7 @@
 
 import {
     AnalyticsReportFilter, QualityConflictsFilter, QualityReportsFilter, QualitySettingsFilter,
+    RequestsFilter,
 } from './server-response-types';
 import PluginRegistry from './plugins';
 import serverProxy from './server-proxy';
@@ -32,6 +33,7 @@ import QualityConflict from './quality-conflict';
 import QualitySettings from './quality-settings';
 import AnalyticsReport from './analytics-report';
 import AnnotationGuide from './guide';
+import { Request } from './requests-manager';
 import BaseSingleFrameAction, { listActions, registerAction, runActions } from './annotations-actions';
 import {
     ArgumentError, DataError, Exception, ScriptingError, ServerError,
@@ -150,6 +152,19 @@ export default interface CVATCore {
     frames: {
         getMeta: any;
     };
+    requests: {
+        list: () => Promise<{ requests: Request[], count: number }>;
+        listen: (
+            rqID: string | null,
+            options?: {
+                callback?: (request: Request) => void,
+                filter?: RequestsFilter,
+                initialRequest?: Request,
+            }
+        ) => Promise<Request>;
+        cancel: (rqID: string) => Promise<void>;
+        delete: (rqID: string) => Promise<void>;
+    };
     actions: {
         list: typeof listActions;
         register: typeof registerAction;

cvat-core/src/project-implementation.ts

@@ -1,8 +1,9 @@
 // Copyright (C) 2021-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
+import requestsManager, { Request } from './requests-manager';
 import { Storage } from './storage';
 import serverProxy from './server-proxy';
 import { decodePreview } from './frames';
@@ -11,8 +12,9 @@
 import { SerializedLabel } from './server-response-types';
 import { Label } from './labels';
 import AnnotationGuide from './guide';
+import { RQStatus } from './enums';
 
 export default function implementProject(projectClass) {
     projectClass.prototype.save.implementation = async function () {
         if (typeof this.id !== 'undefined') {
             const projectData = this._updateTrigger.getUpdated(this, {
@@ -97,8 +99,8 @@
         targetStorage: Storage,
         customName?: string,
     ) {
-        const result = exportDataset(this, format, saveImages, useDefaultSettings, targetStorage, customName);
-        return result;
+        const rqID = await exportDataset(this, format, saveImages, useDefaultSettings, targetStorage, customName);
+        return rqID;
     };
     projectClass.prototype.annotations.importDataset.implementation = async function (
         format: string,
@@ -107,24 +109,37 @@
         file: File | string,
         options?: {
             convMaskToPoly?: boolean,
-            updateStatusCallback?: (s: string, n: number) => void,
+            uploadStatusCallback?: (s: string, n: number) => void,
+            requestStatusCallback?: (request: Request) => void,
         },
     ) {
-        return importDataset(this, format, useDefaultSettings, sourceStorage, file, options);
+        const { requestStatusCallback } = options || {};
+        const rqID = await importDataset(this, format, useDefaultSettings, sourceStorage, file, options);
+        return requestsManager.listen(rqID, { callback: requestStatusCallback });
     };
 
     projectClass.prototype.backup.implementation = async function (
         targetStorage: Storage,
         useDefaultSettings: boolean,
         fileName?: string,
+        options?: { requestStatusCallback?: (request: Request) => void },
     ) {
-        const result = await serverProxy.projects.backup(this.id, targetStorage, useDefaultSettings, fileName);
-        return result;
+        const { requestStatusCallback } = options || {};
+        const rqID = await serverProxy.projects.backup(this.id, targetStorage, useDefaultSettings, fileName);
+        if (rqID) {
+            return requestsManager.listen(rqID, { callback: requestStatusCallback });
+        }
+        return new Request({ status: RQStatus.FINISHED, message: '' });
     };
 
-    projectClass.restore.implementation = async function (storage: Storage, file: File | string) {
-        const result = await serverProxy.projects.restore(storage, file);
-        return result;
+    projectClass.restore.implementation = async function (
+        storage: Storage,
+        file: File | string,
+        options?: { requestStatusCallback?: (request: Request) => void },
+    ) {
+        const { requestStatusCallback } = options || {};
+        const rqID = await serverProxy.projects.restore(storage, file);
+        return requestsManager.listen(rqID, { callback: requestStatusCallback });
     };
 
     projectClass.prototype.guide.implementation = async function guide() {

cvat-core/src/project.ts

@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -13,6 +13,7 @@
 import User from './user';
 import { FieldUpdateTrigger } from './common';
 import AnnotationGuide from './guide';
+import { Request } from './requests-manager';
 
 export default class Project {
     public readonly id: number;
@@ -206,22 +207,26 @@
         };
     }
 
     async preview() {
         const result = await PluginRegistry.apiWrapper.call(this, Project.prototype.preview);
         return result;
     }
 
     async save() {
         const result = await PluginRegistry.apiWrapper.call(this, Project.prototype.save);
         return result;
     }
 
     async delete() {
         const result = await PluginRegistry.apiWrapper.call(this, Project.prototype.delete);
         return result;
     }
 
-    async backup(targetStorage: Storage, useDefaultSettings: boolean, fileName?: string) {
+    async backup(
+        targetStorage: Storage,
+        useDefaultSettings: boolean,
+        fileName?: string,
+    ) {
         const result = await PluginRegistry.apiWrapper.call(
             this,
             Project.prototype.backup,
@@ -232,8 +237,12 @@
         return result;
     }
 
-    static async restore(storage: Storage, file: File | string) {
-        const result = await PluginRegistry.apiWrapper.call(this, Project.restore, storage, file);
+    static async restore(
+        storage: Storage,
+        file: File | string,
+        options?: { requestStatusCallback?: (request: Request) => void },
+    ) {
+        const result = await PluginRegistry.apiWrapper.call(this, Project.restore, storage, file, options);
         return result;
     }
 
@@ -273,7 +282,7 @@
                     file: File | string,
                     options?: {
                         convMaskToPoly?: boolean,
-                        updateStatusCallback?: (s: string, n: number) => void,
+                        uploadStatusCallback?: (s: string, n: number) => void,
                     },
                 ) {
                     const result = await PluginRegistry.apiWrapper.call(