cvat-ai · nmanovic · Dec 17, 2021 · Aug 28, 2021 · Sep 3, 2021 · Sep 7, 2021
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Data sorting option (<https://github.com/openvinotoolkit/cvat/pull/3937>)
 - Options to change font size & position of text labels on the canvas (<https://github.com/openvinotoolkit/cvat/pull/3972>)
 - Add "tag" return type for automatic annotation in Nuclio (<https://github.com/openvinotoolkit/cvat/pull/3896>)
+- Dataset importing to a project (<https://github.com/openvinotoolkit/cvat/pull/3790>)
 
 ### Changed
 - TDB

@@ -1,6 +1,6 @@
 {
   "name": "cvat-core",
-  "version": "3.21.1",
+  "version": "3.22.0",
   "description": "Part of Computer Vision Tool which presents an interface for client-side integration",
   "main": "babel.config.js",
   "scripts": {

@@ -284,6 +284,22 @@
         return result;
     }
 
+    function importDataset(instance, format, file, updateStatusCallback = () => {}) {
+        if (!(typeof format === 'string')) {
+            throw new ArgumentError('Format must be a string');
+        }
+        if (!(instance instanceof Project)) {
+            throw new ArgumentError('Instance should be a Project instance');
+        }
+        if (!(typeof updateStatusCallback === 'function')) {
+            throw new ArgumentError('Callback should be a function');
+        }
+        if (!(['application/zip', 'application/x-zip-compressed'].includes(file.type))) {
+            throw new ArgumentError('File should be file instance with ZIP extension');
+        }
+        return serverProxy.projects.importDataset(instance.id, format, file, updateStatusCallback);
+    }
+
     function undoActions(session, count) {
         const sessionType = session instanceof Task ? 'task' : 'job';
         const cache = getCache(sessionType);
@@ -366,6 +382,7 @@
         importAnnotations,
         exportAnnotations,
         exportDataset,
+        importDataset,
         undoActions,
         redoActions,
         freezeHistory,

@@ -7,7 +7,7 @@
     const { getPreview } = require('./frames');
 
     const { Project } = require('./project');
-    const { exportDataset } = require('./annotations');
+    const { exportDataset, importDataset } = require('./annotations');
 
     function implementProject(projectClass) {
         projectClass.prototype.save.implementation = async function () {
@@ -61,11 +61,20 @@
         };
 
         projectClass.prototype.annotations.exportDataset.implementation = async function (
-            format, saveImages, customName,
+            format,
+            saveImages,
+            customName,
         ) {
             const result = exportDataset(this, format, customName, saveImages);
             return result;
         };
+        projectClass.prototype.annotations.importDataset.implementation = async function (
+            format,
+            file,
+            updateStatusCallback,
+        ) {
+            return importDataset(this, format, file, updateStatusCallback);
+        };
 
         return projectClass;
     }

@@ -244,6 +244,7 @@
             // So, we need return it
             this.annotations = {
                 exportDataset: Object.getPrototypeOf(this).annotations.exportDataset.bind(this),
+                importDataset: Object.getPrototypeOf(this).annotations.importDataset.bind(this),
             };
         }
 
@@ -310,6 +311,16 @@
                         );
                         return result;
                     },
+                    async importDataset(format, file, updateStatusCallback = null) {
+                        const result = await PluginRegistry.apiWrapper.call(
+                            this,
+                            Project.prototype.annotations.importDataset,
+                            format,
+                            file,
+                            updateStatusCallback,
+                        );
+                        return result;
+                    },
                 },
                 writable: true,
             }),

@@ -514,6 +514,44 @@
                 };
             }
 
+            async function importDataset(id, format, file, onUpdate) {
+                const { backendAPI } = config;
+                const url = `${backendAPI}/projects/${id}/dataset`;
+
+                const formData = new FormData();
+                formData.append('dataset_file', file);
+
+                return new Promise((resolve, reject) => {
+                    async function requestStatus() {
+                        try {
+                            const response = await Axios.get(`${url}?action=import_status`, {
+                                proxy: config.proxy,
+                            });
+                            if (response.status === 202) {
+                                if (onUpdate && response.data.message !== '') {
+                                    onUpdate(response.data.message, response.data.progress || 0);
+                                }
+                                setTimeout(requestStatus, 3000);
+                            } else if (response.status === 201) {
+                                resolve();
+                            } else {
+                                reject(generateError(response));
+                            }
+                        } catch (error) {
+                            reject(generateError(error));
+                        }
+                    }
+
+                    Axios.post(`${url}?format=${format}`, formData, {
+                        proxy: config.proxy,
+                    }).then(() => {
+                        setTimeout(requestStatus, 2000);
+                    }).catch((error) => {
+                        reject(generateError(error));
+                    });
+                });
+            }
+
             async function exportTask(id) {
                 const { backendAPI } = config;
                 const url = `${backendAPI}/tasks/${id}`;
@@ -577,7 +615,7 @@
                                 const response = await Axios.get(`${backendAPI}/tasks/${id}/status`);
                                 if (['Queued', 'Started'].includes(response.data.state)) {
                                     if (response.data.message !== '') {
-                                        onUpdate(response.data.message);
+                                        onUpdate(response.data.message, response.data.progress || 0);
                                     }
                                     setTimeout(checkStatus, 1000);
                                 } else if (response.data.state === 'Finished') {
@@ -637,7 +675,7 @@
 
                 let response = null;
 
-                onUpdate('The task is being created on the server..');
+                onUpdate('The task is being created on the server..', null);
                 try {
                     response = await Axios.post(`${backendAPI}/tasks`, JSON.stringify(taskSpec), {
                         proxy: config.proxy,
@@ -649,7 +687,7 @@
                     throw generateError(errorData);
                 }
 
-                onUpdate('The data are being uploaded to the server 0%');
+                onUpdate('The data are being uploaded to the server..', null);
 
                 async function chunkUpload(taskId, file) {
                     return new Promise((resolve, reject) => {
@@ -1438,6 +1476,7 @@
                             create: createProject,
                             delete: deleteProject,
                             exportDataset: exportDataset('projects'),
+                            importDataset,
                         }),
                         writable: false,
                     },

@@ -0,0 +1,59 @@
+// Copyright (C) 2021 Intel Corporation
+//
+// SPDX-License-Identifier: MIT
+
+import { createAction, ActionUnion, ThunkAction } from 'utils/redux';
+import { CombinedState } from 'reducers/interfaces';
+import { getProjectsAsync } from './projects-actions';
+
+export enum ImportActionTypes {
+    OPEN_IMPORT_MODAL = 'OPEN_IMPORT_MODAL',
+    CLOSE_IMPORT_MODAL = 'CLOSE_IMPORT_MODAL',
+    IMPORT_DATASET = 'IMPORT_DATASET',
+    IMPORT_DATASET_SUCCESS = 'IMPORT_DATASET_SUCCESS',
+    IMPORT_DATASET_FAILED = 'IMPORT_DATASET_FAILED',
+    IMPORT_DATASET_UPDATE_STATUS = 'IMPORT_DATASET_UPDATE_STATUS',
+}
+
+export const importActions = {
+    openImportModal: (instance: any) => createAction(ImportActionTypes.OPEN_IMPORT_MODAL, { instance }),
+    closeImportModal: () => createAction(ImportActionTypes.CLOSE_IMPORT_MODAL),
+    importDataset: (projectId: number) => (
+        createAction(ImportActionTypes.IMPORT_DATASET, { id: projectId })
+    ),
+    importDatasetSuccess: () => (
+        createAction(ImportActionTypes.IMPORT_DATASET_SUCCESS)
+    ),
+    importDatasetFailed: (instance: any, error: any) => (
+        createAction(ImportActionTypes.IMPORT_DATASET_FAILED, {
+            instance,
+            error,
+        })
+    ),
+    importDatasetUpdateStatus: (progress: number, status: string) => (
+        createAction(ImportActionTypes.IMPORT_DATASET_UPDATE_STATUS, { progress, status })
+    ),
+};
+
+export const importDatasetAsync = (instance: any, format: string, file: File): ThunkAction => (
+    async (dispatch, getState) => {
+        try {
+            const state: CombinedState = getState();
+            if (state.import.importingId !== null) {
+                throw Error('Only one importing of dataset allowed at the same time');
+            }
+            dispatch(importActions.importDataset(instance.id));
+            await instance.annotations.importDataset(format, file, (message: string, progress: number) => (
+                dispatch(importActions.importDatasetUpdateStatus(progress * 100, message))
+            ));
+        } catch (error) {
+            dispatch(importActions.importDatasetFailed(instance, error));
+            return;
+        }
+
+        dispatch(importActions.importDatasetSuccess());
+        dispatch(getProjectsAsync({ id: instance.id }));
+    }
+);
+
+export type ImportActions = ActionUnion<typeof importActions>;
@@ -414,8 +414,8 @@ export function createTaskAsync(data: any): ThunkAction<Promise<void>, {}, {}, A
 
         dispatch(createTask());
         try {
-            const savedTask = await taskInstance.save((status: string): void => {
-                dispatch(createTaskUpdateStatus(status));
+            const savedTask = await taskInstance.save((status: string, progress: number): void => {
+                dispatch(createTaskUpdateStatus(status + (progress !== null ? ` ${Math.floor(progress * 100)}%` : '')));
             });
             dispatch(createTaskSuccess(savedTask.id));
         } catch (error) {

@@ -55,7 +55,7 @@ function ExportDatasetModal(): JSX.Element {
 
     useEffect(() => {
         initActivities();
-    }, [instance?.id, instance instanceof core.classes.Project]);
+    }, [instance?.id, instance instanceof core.classes.Project, taskExportActivities, projectExportActivities]);
 
     const closeModal = (): void => {
         form.resetFields();