React & Antd UI: Export dataset, refactoring & fixes

CONTRIBUTING.md

@@ -29,6 +29,7 @@ $ python3 -m venv .env
 $ . .env/bin/activate
 $ pip install -U pip wheel
 $ pip install -r cvat/requirements/development.txt
+$ pip install -r datumaro/requirements.txt
 $ python manage.py migrate
 $ python manage.py collectstatic
 ```

cvat-core/src/server-proxy.js

@@ -147,6 +147,7 @@
                     `${encodeURIComponent('password')}=${encodeURIComponent(password)}`,
                 ]).join('&').replace(/%20/g, '+');
 
+                Axios.defaults.headers.common.Authorization = '';
                 let authenticationResponse = null;
                 try {
                     authenticationResponse = await Axios.post(
@@ -246,7 +247,7 @@
                 try {
                     await Axios.delete(`${backendAPI}/tasks/${id}`);
                 } catch (errorData) {
-                    throw generateError(errorData, 'Could not delete the task from the server');
+                    throw generateError(errorData, `Could not delete the task ${id} from the server`);
                 }
             }
 

cvat-ui/src/actions/formats-actions.ts

@@ -6,38 +6,53 @@ import getCore from '../core';
 const cvat = getCore();
 
 export enum FormatsActionTypes {
-    GETTING_FORMATS_SUCCESS = 'GETTING_FORMATS_SUCCESS',
-    GETTING_FORMATS_FAILED = 'GETTING_FORMATS_FAILED',
+    GET_FORMATS = 'GET_FORMATS',
+    GET_FORMATS_SUCCESS = 'GET_FORMATS_SUCCESS',
+    GET_FORMATS_FAILED = 'GET_FORMATS_FAILED',
 }
 
-export function gettingFormatsSuccess(formats: any): AnyAction {
+function getFormats(): AnyAction {
     return {
-        type: FormatsActionTypes.GETTING_FORMATS_SUCCESS,
+        type: FormatsActionTypes.GET_FORMATS,
+        payload: {},
+    };
+}
+
+function getFormatsSuccess(
+    annotationFormats: any[],
+    datasetFormats: any[],
+): AnyAction {
+    return {
+        type: FormatsActionTypes.GET_FORMATS_SUCCESS,
         payload: {
-            formats,
+            annotationFormats,
+            datasetFormats,
         },
     };
 }
 
-export function gettingFormatsFailed(error: any): AnyAction {
+function getFormatsFailed(error: any): AnyAction {
     return {
-        type: FormatsActionTypes.GETTING_FORMATS_FAILED,
+        type: FormatsActionTypes.GET_FORMATS_FAILED,
         payload: {
             error,
         },
     };
 }
 
-export function gettingFormatsAsync(): ThunkAction<Promise<void>, {}, {}, AnyAction> {
+export function getFormatsAsync(): ThunkAction<Promise<void>, {}, {}, AnyAction> {
     return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
-        let formats = null;
+        dispatch(getFormats());
+        let annotationFormats = null;
+        let datasetFormats = null;
         try {
-            formats = await cvat.server.formats();
+            annotationFormats = await cvat.server.formats();
+            datasetFormats = await cvat.server.datasetFormats();
         } catch (error) {
-            dispatch(gettingFormatsFailed(error));
+            dispatch(getFormatsFailed(error));
             return;
         }
 
-        dispatch(gettingFormatsSuccess(formats));
+        dispatch(getFormatsSuccess(annotationFormats, datasetFormats));
     };
 }

cvat-ui/src/actions/models-actions.ts

@@ -3,7 +3,12 @@ import { ThunkAction } from 'redux-thunk';
 
 import getCore from '../core';
 import { getCVATStore } from '../store';
-import { Model, ModelFiles, CombinedState } from '../reducers/interfaces';
+import {
+    Model,
+    ModelFiles,
+    ActiveInference,
+    CombinedState,
+} from '../reducers/interfaces';
 
 export enum ModelsActionTypes {
     GET_MODELS = 'GET_MODELS',
@@ -324,6 +329,199 @@ ThunkAction<Promise<void>, {}, {}, AnyAction> {
     };
 }
 
+
+function getInferenceStatusSuccess(
+    taskID: number,
+    activeInference: ActiveInference,
+): AnyAction {
+    const action = {
+        type: ModelsActionTypes.GET_INFERENCE_STATUS_SUCCESS,
+        payload: {
+            taskID,
+            activeInference,
+        },
+    };
+
+    return action;
+}
+
+function getInferenceStatusFailed(taskID: number, error: any): AnyAction {
+    const action = {
+        type: ModelsActionTypes.GET_INFERENCE_STATUS_FAILED,
+        payload: {
+            taskID,
+            error,
+        },
+    };
+
+    return action;
+}
+
+interface InferenceMeta {
+    active: boolean;
+    taskID: number;
+    requestID: string;
+}
+
+const timers: any = {};
+
+async function timeoutCallback(
+    url: string,
+    taskID: number,
+    dispatch: ActionCreator<Dispatch>,
+): Promise<void> {
+    try {
+        delete timers[taskID];
+
+        const response = await core.server.request(url, {
+            method: 'GET',
+        });
+
+        const activeInference: ActiveInference = {
+            status: response.status,
+            progress: +response.progress || 0,
+            error: response.error || response.stderr || '',
+        };
+
+
+        if (activeInference.status === 'unknown') {
+            dispatch(getInferenceStatusFailed(
+                taskID,
+                new Error(
+                    `Inference status for the task ${taskID} is unknown.`,
+                ),
+            ));
+
+            return;
+        }
+
+        if (activeInference.status === 'failed') {
+            dispatch(getInferenceStatusFailed(
+                taskID,
+                new Error(
+                    `Inference status for the task ${taskID} is failed. ${activeInference.error}`,
+                ),
+            ));
+
+            return;
+        }
+
+        if (activeInference.status !== 'finished') {
+            timers[taskID] = setTimeout(
+                timeoutCallback.bind(
+                    null,
+                    url,
+                    taskID,
+                    dispatch,
+                ), 3000,
+            );
+        }
+
+        dispatch(getInferenceStatusSuccess(taskID, activeInference));
+    } catch (error) {
+        dispatch(getInferenceStatusFailed(taskID, error));
+    }
+}
+
+function subscribe(
+    urlPath: string,
+    inferenceMeta: InferenceMeta,
+    dispatch: ActionCreator<Dispatch>,
+): void {
+    if (!(inferenceMeta.taskID in timers)) {
+        const requestURL = `${baseURL}/${urlPath}/${inferenceMeta.requestID}`;
+        timers[inferenceMeta.taskID] = setTimeout(
+            timeoutCallback.bind(
+                null,
+                requestURL,
+                inferenceMeta.taskID,
+                dispatch,
+            ),
+        );
+    }
+}
+
+export function getInferenceStatusAsync(tasks: number[]):
+ThunkAction<Promise<void>, {}, {}, AnyAction> {
+    return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
+        function parse(response: any): InferenceMeta[] {
+            return Object.keys(response).map((key: string): InferenceMeta => ({
+                taskID: +key,
+                requestID: response[key].rq_id || key,
+                active: typeof (response[key].active) === 'undefined' ? ['queued', 'started']
+                    .includes(response[key].status.toLowerCase()) : response[key].active,
+            }));
+        }
+
+        const store = getCVATStore();
+        const state: CombinedState = store.getState();
+        const OpenVINO = state.plugins.plugins.AUTO_ANNOTATION;
+        const RCNN = state.plugins.plugins.TF_ANNOTATION;
+        const MaskRCNN = state.plugins.plugins.TF_SEGMENTATION;
+
+        try {
+            if (OpenVINO) {
+                const response = await core.server.request(
+                    `${baseURL}/auto_annotation/meta/get`, {
+                        method: 'POST',
+                        data: JSON.stringify(tasks),
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                    },
+                );
+
+                parse(response.run)
+                    .filter((inferenceMeta: InferenceMeta): boolean => inferenceMeta.active)
+                    .forEach((inferenceMeta: InferenceMeta): void => {
+                        subscribe('auto_annotation/check', inferenceMeta, dispatch);
+                    });
+            }
+
+            if (RCNN) {
+                const response = await core.server.request(
+                    `${baseURL}/tensorflow/annotation/meta/get`, {
+                        method: 'POST',
+                        data: JSON.stringify(tasks),
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                    },
+                );
+
+                parse(response)
+                    .filter((inferenceMeta: InferenceMeta): boolean => inferenceMeta.active)
+                    .forEach((inferenceMeta: InferenceMeta): void => {
+                        subscribe('tensorflow/annotation/check/task', inferenceMeta, dispatch);
+                    });
+            }
+
+            if (MaskRCNN) {
+                const response = await core.server.request(
+                    `${baseURL}/tensorflow/segmentation/meta/get`, {
+                        method: 'POST',
+                        data: JSON.stringify(tasks),
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                    },
+                );
+
+                parse(response)
+                    .filter((inferenceMeta: InferenceMeta): boolean => inferenceMeta.active)
+                    .forEach((inferenceMeta: InferenceMeta): void => {
+                        subscribe('tensorflow/segmentation/check/task', inferenceMeta, dispatch);
+                    });
+            }
+        } catch (error) {
+            tasks.forEach((task: number): void => {
+                dispatch(getInferenceStatusFailed(task, error));
+            });
+        }
+    };
+}
+
+
 function inferModel(): AnyAction {
     const action = {
         type: ModelsActionTypes.INFER_MODEL,
@@ -387,6 +585,8 @@ export function inferModelAsync(
                     },
                 );
             }
+
+            dispatch(getInferenceStatusAsync([taskInstance.id]));
         } catch (error) {
             dispatch(inferModelFailed(error));
             return;

cvat-ui/src/actions/notification-actions.ts

@@ -0,0 +1,24 @@
+import { AnyAction } from 'redux';
+
+export enum NotificationsActionType {
+    RESET_ERRORS = 'RESET_ERRORS',
+    RESET_MESSAGES = 'RESET_MESSAGES',
+}
+
+export function resetErrors(): AnyAction {
+    const action = {
+        type: NotificationsActionType.RESET_ERRORS,
+        payload: {},
+    };
+
+    return action;
+}
+
+export function resetMessages(): AnyAction {
+    const action = {
+        type: NotificationsActionType.RESET_MESSAGES,
+        payload: {},
+    };
+
+    return action;
+}

cvat-ui/src/actions/plugins-actions.ts

@@ -4,13 +4,23 @@ import { SupportedPlugins } from '../reducers/interfaces';
 import PluginChecker from '../utils/plugin-checker';
 
 export enum PluginsActionTypes {
+    CHECK_PLUGINS = 'CHECK_PLUGINS',
     CHECKED_ALL_PLUGINS = 'CHECKED_ALL_PLUGINS'
 }
 
 interface PluginObjects {
     [plugin: string]: boolean;
 }
 
+function checkPlugins(): AnyAction {
+    const action = {
+        type: PluginsActionTypes.CHECK_PLUGINS,
+        payload: {},
+    };
+
+    return action;
+}
+
 function checkedAllPlugins(plugins: PluginObjects): AnyAction {
     const action = {
         type: PluginsActionTypes.CHECKED_ALL_PLUGINS,
@@ -25,6 +35,7 @@ function checkedAllPlugins(plugins: PluginObjects): AnyAction {
 export function checkPluginsAsync():
 ThunkAction<Promise<void>, {}, {}, AnyAction> {
     return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
+        dispatch(checkPlugins());
         const plugins: PluginObjects = {};
 
         const promises: Promise<boolean>[] = [];