From 8dd68f4f398a2f256cd0dc06e9d70495988d93ec Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Fri, 2 Apr 2021 09:00:38 +0300
Subject: [PATCH 01/19] initial version of task export/import feature

---
 cvat-core/src/server-proxy.js                 |  59 +++
 cvat-core/src/session.js                      |  40 ++
 cvat-ui/src/actions/tasks-actions.ts          | 106 ++++++
 .../components/actions-menu/actions-menu.tsx  |   8 +
 .../src/components/tasks-page/tasks-page.tsx  |  11 +-
 cvat-ui/src/components/tasks-page/top-bar.tsx |  29 +-
 .../containers/actions-menu/actions-menu.tsx  |  14 +-
 .../src/containers/tasks-page/tasks-page.tsx  |   8 +-
 cvat-ui/src/reducers/interfaces.ts            |   4 +
 cvat-ui/src/reducers/tasks-reducer.ts         |  48 +++
 cvat/apps/dataset_manager/views.py            |  42 ++-
 cvat/apps/engine/backup.py                    | 354 ++++++++++++++++++
 cvat/apps/engine/serializers.py               |   6 +-
 cvat/apps/engine/task.py                      |  56 +--
 cvat/apps/engine/views.py                     | 175 +++++++--
 15 files changed, 898 insertions(+), 62 deletions(-)
 create mode 100644 cvat/apps/engine/backup.py

diff --git a/cvat-core/src/server-proxy.js b/cvat-core/src/server-proxy.js
index 1e7018c53bc..90cfee08696 100644
--- a/cvat-core/src/server-proxy.js
+++ b/cvat-core/src/server-proxy.js
@@ -465,6 +465,63 @@
                 });
             }
 
+            async function backupTask(id) {
+                const { backendAPI } = config;
+                let url = `${backendAPI}/tasks/${id}`;
+
+                return new Promise((resolve, reject) => {
+                    async function request() {
+                        try {
+                            const response = await Axios.get(`${url}?action=export`, {
+                                proxy: config.proxy,
+                            });
+                            if (response.status === 202) {
+                                setTimeout(request, 3000);
+                            } else {
+                                resolve(`${url}?action=download`);
+                            }
+                        } catch (errorData) {
+                            reject(generateError(errorData));
+                        }
+                    }
+
+                    setTimeout(request);
+                });
+            }
+
+            async function importTask(file) {
+                const { backendAPI } = config;
+
+                let annotationData = new FormData();
+                annotationData.append('task_file', file);
+
+                return new Promise((resolve, reject) => {
+                    async function request() {
+                        try {
+                            const response = await Axios.post(
+                                `${backendAPI}/tasks?action=import`,
+                                annotationData,
+                                {
+                                    proxy: config.proxy,
+                                },
+                            );
+                            if (response.status === 202) {
+                                annotationData = new FormData();
+                                annotationData.append('rq_id', response.data.rq_id);
+                                setTimeout(request, 3000);
+                            } else {
+                                const importedTask = await getTasks(`?id=${response.data.id}`);
+                                resolve(importedTask[0]);
+                            }
+                        } catch (errorData) {
+                            reject(generateError(errorData));
+                        }
+                    }
+
+                    setTimeout(request);
+                });
+            }
+
             async function createTask(taskSpec, taskDataSpec, onUpdate) {
                 const { backendAPI } = config;
 
@@ -1046,6 +1103,8 @@
                             createTask,
                             deleteTask,
                             exportDataset,
+                            backupTask,
+                            importTask,
                         }),
                         writable: false,
                     },
diff --git a/cvat-core/src/session.js b/cvat-core/src/session.js
index 105dfc9b5b8..458c49a955b 100644
--- a/cvat-core/src/session.js
+++ b/cvat-core/src/session.js
@@ -1604,6 +1604,36 @@
             const result = await PluginRegistry.apiWrapper.call(this, Task.prototype.delete);
             return result;
         }
+
+        /**
+         * Method makes a backup of a task
+         * @method backup
+         * @memberof module:API.cvat.classes.Task
+         * @readonly
+         * @instance
+         * @async
+         * @throws {module:API.cvat.exceptions.ServerError}
+         * @throws {module:API.cvat.exceptions.PluginError}
+         */
+        async backup() {
+            const result = await PluginRegistry.apiWrapper.call(this, Task.prototype.backup);
+            return result;
+        }
+
+        /**
+         * Method imports a task from a backup
+         * @method import
+         * @memberof module:API.cvat.classes.Task
+         * @readonly
+         * @instance
+         * @async
+         * @throws {module:API.cvat.exceptions.ServerError}
+         * @throws {module:API.cvat.exceptions.PluginError}
+         */
+         async import(file) {
+            const result = await PluginRegistry.apiWrapper.call(this, Task.prototype.import, file);
+            return result;
+        }
     }
 
     module.exports = {
@@ -2005,6 +2035,16 @@
         return result;
     };
 
+    Task.prototype.backup.implementation = async function () {
+        const result = await serverProxy.tasks.backupTask(this.id);
+        return result;
+    };
+
+    Task.prototype.import.implementation = async function (file) {
+        const result = await serverProxy.tasks.importTask(file);
+        return result;
+    };
+
     Task.prototype.frames.get.implementation = async function (frame, isPlaying, step) {
         if (!Number.isInteger(frame) || frame < 0) {
             throw new ArgumentError(`Frame must be a positive integer. Got: "${frame}"`);
diff --git a/cvat-ui/src/actions/tasks-actions.ts b/cvat-ui/src/actions/tasks-actions.ts
index 3dcf75bcfbc..1d2dee09250 100644
--- a/cvat-ui/src/actions/tasks-actions.ts
+++ b/cvat-ui/src/actions/tasks-actions.ts
@@ -35,6 +35,12 @@ export enum TasksActionTypes {
     UPDATE_TASK_SUCCESS = 'UPDATE_TASK_SUCCESS',
     UPDATE_TASK_FAILED = 'UPDATE_TASK_FAILED',
     HIDE_EMPTY_TASKS = 'HIDE_EMPTY_TASKS',
+    BACKUP_TASK = 'BACKUP_TASK',
+    BACKUP_TASK_SUCCESS = 'BACKUP_TASK_SUCCESS',
+    BACKUP_TASK_FAILED = 'BACKUP_TASK_FAILED',
+    IMPORT_TASK = 'IMPORT_TASK',
+    IMPORT_TASK_SUCCESS = 'IMPORT_TASK_SUCCESS',
+    IMPORT_TASK_FAILED = 'IMPORT_TASK_FAILED',
 }
 
 function getTasks(): AnyAction {
@@ -213,6 +219,55 @@ export function loadAnnotationsAsync(
     };
 }
 
+function importTask(): AnyAction {
+    const action = {
+        type: TasksActionTypes.IMPORT_TASK,
+        payload: {},
+        importing: true,
+    };
+
+    return action;
+}
+
+function importTaskSuccess(taskId: number): AnyAction {
+    const action = {
+        type: TasksActionTypes.IMPORT_TASK_SUCCESS,
+        payload: {
+            taskId,
+            importing: false,
+        },
+    };
+
+    return action;
+}
+
+function importTaskFailed(error: any): AnyAction {
+    const action = {
+        type: TasksActionTypes.IMPORT_TASK_FAILED,
+        payload: {
+            error,
+            importing: false,
+        },
+    };
+
+    return action;
+}
+
+export function importTaskAsync(
+    file: File,
+): ThunkAction<Promise<void>, {}, {}, AnyAction> {
+    return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
+        try {
+            dispatch(importTask());
+            let taskInstance = new cvat.classes.Task({});
+            taskInstance = await taskInstance.import(file);
+            dispatch(importTaskSuccess(taskInstance));
+        } catch (error) {
+            dispatch(importTaskFailed(error));
+        }
+    };
+}
+
 function exportDataset(task: any, exporter: any): AnyAction {
     const action = {
         type: TasksActionTypes.EXPORT_DATASET,
@@ -267,6 +322,57 @@ export function exportDatasetAsync(task: any, exporter: any): ThunkAction<Promis
     };
 }
 
+function backupTask(taskID: number): AnyAction {
+    const action = {
+        type: TasksActionTypes.BACKUP_TASK,
+        payload: {
+            taskID,
+        },
+    };
+
+    return action;
+}
+
+function backupTaskSuccess(taskID: any): AnyAction {
+    const action = {
+        type: TasksActionTypes.BACKUP_TASK_SUCCESS,
+        payload: {
+            taskID,
+        },
+    };
+
+    return action;
+}
+
+function backupTaskFailed(taskID: any, error: any): AnyAction {
+    const action = {
+        type: TasksActionTypes.BACKUP_TASK_FAILED,
+        payload: {
+            taskID,
+            error,
+        },
+    };
+
+    return action;
+}
+
+export function backupTaskAsync(taskInstance: any): ThunkAction<Promise<void>, {}, {}, AnyAction> {
+    return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
+        dispatch(backupTask(taskInstance.id));
+
+        try {
+            const url = await taskInstance.backup();
+            const downloadAnchor = window.document.getElementById('downloadAnchor') as HTMLAnchorElement;
+            downloadAnchor.href = url;
+            downloadAnchor.click();
+        } catch (error) {
+            dispatch(backupTaskFailed(taskInstance.id, error));
+        }
+
+        dispatch(backupTaskSuccess(taskInstance.id));
+    };
+}
+
 function deleteTask(taskID: number): AnyAction {
     const action = {
         type: TasksActionTypes.DELETE_TASK,
diff --git a/cvat-ui/src/components/actions-menu/actions-menu.tsx b/cvat-ui/src/components/actions-menu/actions-menu.tsx
index 52e0f05bcb1..c56fd84e3dd 100644
--- a/cvat-ui/src/components/actions-menu/actions-menu.tsx
+++ b/cvat-ui/src/components/actions-menu/actions-menu.tsx
@@ -6,6 +6,7 @@ import './styles.scss';
 import React from 'react';
 import Menu from 'antd/lib/menu';
 import Modal from 'antd/lib/modal';
+import { LoadingOutlined } from '@ant-design/icons';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { MenuInfo } from 'rc-menu/lib/interface';
 import DumpSubmenu from './dump-submenu';
@@ -25,6 +26,7 @@ interface Props {
     inferenceIsActive: boolean;
     taskDimension: DimensionType;
     onClickMenu: (params: MenuInfo, file?: File) => void;
+    backupIsActive: boolean;
 }
 
 export enum Actions {
@@ -34,6 +36,7 @@ export enum Actions {
     DELETE_TASK = 'delete_task',
     RUN_AUTO_ANNOTATION = 'run_auto_annotation',
     OPEN_BUG_TRACKER = 'open_bug_tracker',
+    BACKUP_TASK = 'backup_task',
 }
 
 export default function ActionsMenuComponent(props: Props): JSX.Element {
@@ -49,6 +52,7 @@ export default function ActionsMenuComponent(props: Props): JSX.Element {
         exportActivities,
         loadActivity,
         taskDimension,
+        backupIsActive,
     } = props;
 
     let latestParams: MenuInfo | null = null;
@@ -127,6 +131,10 @@ export default function ActionsMenuComponent(props: Props): JSX.Element {
             <Menu.Item disabled={inferenceIsActive} key={Actions.RUN_AUTO_ANNOTATION}>
                 Automatic annotation
             </Menu.Item>
+            <Menu.Item key={Actions.BACKUP_TASK}>
+                {backupIsActive && <LoadingOutlined style={{ marginLeft: 10 }} />}
+                Backup Task
+            </Menu.Item>
             <hr />
             <Menu.Item key={Actions.DELETE_TASK}>Delete</Menu.Item>
         </Menu>
diff --git a/cvat-ui/src/components/tasks-page/tasks-page.tsx b/cvat-ui/src/components/tasks-page/tasks-page.tsx
index daafb44d976..fd1bd3df092 100644
--- a/cvat-ui/src/components/tasks-page/tasks-page.tsx
+++ b/cvat-ui/src/components/tasks-page/tasks-page.tsx
@@ -25,6 +25,8 @@ interface TasksPageProps {
     numberOfHiddenTasks: number;
     onGetTasks: (gettingQuery: TasksQuery) => void;
     hideEmptyTasks: (hideEmpty: boolean) => void;
+    onImportTask: (file: File) => void;
+    taskImporting: boolean;
 }
 
 function getSearchField(gettingQuery: TasksQuery): string {
@@ -186,7 +188,7 @@ class TasksPageComponent extends React.PureComponent<TasksPageProps & RouteCompo
     }
 
     public render(): JSX.Element {
-        const { tasksFetching, gettingQuery, numberOfVisibleTasks } = this.props;
+        const { tasksFetching, gettingQuery, numberOfVisibleTasks, onImportTask, taskImporting } = this.props;
 
         if (tasksFetching) {
             return <Spin size='large' className='cvat-spinner' />;
@@ -194,7 +196,12 @@ class TasksPageComponent extends React.PureComponent<TasksPageProps & RouteCompo
 
         return (
             <div className='cvat-tasks-page'>
-                <TopBar onSearch={this.handleSearch} searchValue={getSearchField(gettingQuery)} />
+                <TopBar
+                    onSearch={this.handleSearch}
+                    searchValue={getSearchField(gettingQuery)}
+                    onFileUpload={onImportTask}
+                    taskImporting={taskImporting}
+                 />
                 {numberOfVisibleTasks ? (
                     <TaskListContainer onSwitchPage={this.handlePagination} />
                 ) : (
diff --git a/cvat-ui/src/components/tasks-page/top-bar.tsx b/cvat-ui/src/components/tasks-page/top-bar.tsx
index b3c64d3209e..58611805856 100644
--- a/cvat-ui/src/components/tasks-page/top-bar.tsx
+++ b/cvat-ui/src/components/tasks-page/top-bar.tsx
@@ -9,14 +9,18 @@ import { PlusOutlined } from '@ant-design/icons';
 import Button from 'antd/lib/button';
 import Input from 'antd/lib/input';
 import Text from 'antd/lib/typography/Text';
+import Upload from 'antd/lib/upload';
+import { UploadOutlined, LoadingOutlined } from '@ant-design/icons';
 
 interface VisibleTopBarProps {
     onSearch: (value: string) => void;
+    onFileUpload(file: File): void;
     searchValue: string;
+    taskImporting: boolean;
 }
 
 export default function TopBarComponent(props: VisibleTopBarProps): JSX.Element {
-    const { searchValue, onSearch } = props;
+    const { searchValue, onSearch, onFileUpload, taskImporting } = props;
 
     const history = useHistory();
 
@@ -33,6 +37,29 @@ export default function TopBarComponent(props: VisibleTopBarProps): JSX.Element
                         placeholder='Search'
                     />
                 </Col>
+                <Col md={{ span: 11 }} lg={{ span: 9 }} xl={{ span: 8 }} xxl={{ span: 7 }}>
+                    <Upload
+                        accept='.zip'
+                        multiple={false}
+                        showUploadList={false}
+                        beforeUpload={(file: File): boolean => {
+                            onFileUpload(file);
+                            return false;
+                        }}
+                    >
+                        <Button
+                            size='large'
+                            id='cvat-import-task-button'
+                            type='primary'
+                            disabled={taskImporting}
+                            icon={<UploadOutlined />}
+                        >
+
+                            Import Task
+                            {taskImporting && <LoadingOutlined style={{ marginLeft: 10 }} />}
+                        </Button>
+                    </Upload>
+                </Col>
                 <Col md={{ span: 11 }} lg={{ span: 9 }} xl={{ span: 8 }} xxl={{ span: 7 }}>
                     <Button
                         size='large'
diff --git a/cvat-ui/src/containers/actions-menu/actions-menu.tsx b/cvat-ui/src/containers/actions-menu/actions-menu.tsx
index acc6a45156e..86d91f1c952 100644
--- a/cvat-ui/src/containers/actions-menu/actions-menu.tsx
+++ b/cvat-ui/src/containers/actions-menu/actions-menu.tsx
@@ -11,6 +11,7 @@ import { CombinedState } from 'reducers/interfaces';
 import { modelsActions } from 'actions/models-actions';
 import {
     dumpAnnotationsAsync, loadAnnotationsAsync, exportDatasetAsync, deleteTaskAsync,
+    backupTaskAsync,
 } from 'actions/tasks-actions';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { MenuInfo } from 'rc-menu/lib/interface';
@@ -25,6 +26,7 @@ interface StateToProps {
     dumpActivities: string[] | null;
     exportActivities: string[] | null;
     inferenceIsActive: boolean;
+    backupIsActive: boolean;
 }
 
 interface DispatchToProps {
@@ -33,6 +35,7 @@ interface DispatchToProps {
     exportDataset: (taskInstance: any, exporter: any) => void;
     deleteTask: (taskInstance: any) => void;
     openRunModelWindow: (taskInstance: any) => void;
+    backupTask: (taskInstance: any) => void;
 }
 
 function mapStateToProps(state: CombinedState, own: OwnProps): StateToProps {
@@ -43,7 +46,7 @@ function mapStateToProps(state: CombinedState, own: OwnProps): StateToProps {
     const {
         formats: { annotationFormats },
         tasks: {
-            activities: { dumps, loads, exports: activeExports },
+            activities: { dumps, loads, exports: activeExports, backups },
         },
     } = state;
 
@@ -53,6 +56,7 @@ function mapStateToProps(state: CombinedState, own: OwnProps): StateToProps {
         loadActivity: tid in loads ? loads[tid] : null,
         annotationFormats,
         inferenceIsActive: tid in state.models.inferences,
+        backupIsActive: tid in backups,
     };
 }
 
@@ -73,6 +77,9 @@ function mapDispatchToProps(dispatch: any): DispatchToProps {
         openRunModelWindow: (taskInstance: any): void => {
             dispatch(modelsActions.showRunModelDialog(taskInstance));
         },
+        backupTask: (taskInstance: any): void => {
+            dispatch(backupTaskAsync(taskInstance));
+        },
     };
 }
 
@@ -84,12 +91,14 @@ function ActionsMenuContainer(props: OwnProps & StateToProps & DispatchToProps):
         dumpActivities,
         exportActivities,
         inferenceIsActive,
+        backupIsActive,
 
         loadAnnotations,
         dumpAnnotations,
         exportDataset,
         deleteTask,
         openRunModelWindow,
+        backupTask,
     } = props;
 
     function onClickMenu(params: MenuInfo, file?: File): void {
@@ -123,6 +132,8 @@ function ActionsMenuContainer(props: OwnProps & StateToProps & DispatchToProps):
                 window.open(`${taskInstance.bugTracker}`, '_blank');
             } else if (action === Actions.RUN_AUTO_ANNOTATION) {
                 openRunModelWindow(taskInstance);
+            } else if (action === Actions.BACKUP_TASK) {
+                backupTask(taskInstance);
             }
         }
     }
@@ -140,6 +151,7 @@ function ActionsMenuContainer(props: OwnProps & StateToProps & DispatchToProps):
             inferenceIsActive={inferenceIsActive}
             onClickMenu={onClickMenu}
             taskDimension={taskInstance.dimension}
+            backupIsActive={backupIsActive}
         />
     );
 }
diff --git a/cvat-ui/src/containers/tasks-page/tasks-page.tsx b/cvat-ui/src/containers/tasks-page/tasks-page.tsx
index ac5514267e2..d38a81cdc9a 100644
--- a/cvat-ui/src/containers/tasks-page/tasks-page.tsx
+++ b/cvat-ui/src/containers/tasks-page/tasks-page.tsx
@@ -8,7 +8,7 @@ import { Task, TasksQuery, CombinedState } from 'reducers/interfaces';
 
 import TasksPageComponent from 'components/tasks-page/tasks-page';
 
-import { getTasksAsync, hideEmptyTasks } from 'actions/tasks-actions';
+import { getTasksAsync, hideEmptyTasks, importTaskAsync } from 'actions/tasks-actions';
 
 interface StateToProps {
     tasksFetching: boolean;
@@ -16,11 +16,13 @@ interface StateToProps {
     numberOfTasks: number;
     numberOfVisibleTasks: number;
     numberOfHiddenTasks: number;
+    taskImporting: boolean;
 }
 
 interface DispatchToProps {
     onGetTasks: (gettingQuery: TasksQuery) => void;
     hideEmptyTasks: (hideEmpty: boolean) => void;
+    onImportTask: (file: File) => void;
 }
 
 function mapStateToProps(state: CombinedState): StateToProps {
@@ -34,6 +36,7 @@ function mapStateToProps(state: CombinedState): StateToProps {
         numberOfHiddenTasks: tasks.hideEmpty
             ? tasks.current.filter((task: Task): boolean => !task.instance.jobs.length).length
             : 0,
+        taskImporting: state.tasks.importing,
     };
 }
 
@@ -45,6 +48,9 @@ function mapDispatchToProps(dispatch: any): DispatchToProps {
         hideEmptyTasks: (hideEmpty: boolean): void => {
             dispatch(hideEmptyTasks(hideEmpty));
         },
+        onImportTask: (file: File): void => {
+            dispatch(importTaskAsync(file));
+        },
     };
 }
 
diff --git a/cvat-ui/src/reducers/interfaces.ts b/cvat-ui/src/reducers/interfaces.ts
index 5c3f48c6302..0ae5a48b014 100644
--- a/cvat-ui/src/reducers/interfaces.ts
+++ b/cvat-ui/src/reducers/interfaces.ts
@@ -70,6 +70,7 @@ export interface Task {
 }
 
 export interface TasksState {
+    importing: boolean;
     initialized: boolean;
     fetching: boolean;
     updating: boolean;
@@ -98,6 +99,9 @@ export interface TasksState {
             status: string;
             error: string;
         };
+        backups: {
+            [tid: number]: boolean;
+        }
     };
 }
 
diff --git a/cvat-ui/src/reducers/tasks-reducer.ts b/cvat-ui/src/reducers/tasks-reducer.ts
index 2cc8db82e97..44e6a2ee1ad 100644
--- a/cvat-ui/src/reducers/tasks-reducer.ts
+++ b/cvat-ui/src/reducers/tasks-reducer.ts
@@ -36,7 +36,9 @@ const defaultState: TasksState = {
             status: '',
             error: '',
         },
+        backups: {},
     },
+    importing: false,
 };
 
 export default (state: TasksState = defaultState, action: AnyAction): TasksState => {
@@ -238,6 +240,52 @@ export default (state: TasksState = defaultState, action: AnyAction): TasksState
                 },
             };
         }
+        case TasksActionTypes.BACKUP_TASK: {
+            const { taskID } = action.payload;
+            const { backups } = state.activities;
+
+            backups[taskID] = true;
+
+            return {
+                ...state,
+                activities: {
+                    ...state.activities,
+                    backups: {
+                        ...backups,
+                    },
+                },
+            };
+        }
+        case TasksActionTypes.BACKUP_TASK_FAILED:
+        case TasksActionTypes.BACKUP_TASK_SUCCESS: {
+            const { taskID } = action.payload;
+            const { backups } = state.activities;
+
+            delete backups[taskID];
+
+            return {
+                ...state,
+                activities: {
+                    ...state.activities,
+                    backups: {
+                        ...backups,
+                    },
+                },
+            };
+        }
+        case TasksActionTypes.IMPORT_TASK: {
+            return {
+                ...state,
+                importing: true,
+            };
+        }
+        case TasksActionTypes.IMPORT_TASK_FAILED:
+        case TasksActionTypes.IMPORT_TASK_SUCCESS: {
+            return {
+                ...state,
+                importing: false,
+            };
+        }
         case TasksActionTypes.CREATE_TASK: {
             return {
                 ...state,
diff --git a/cvat/apps/dataset_manager/views.py b/cvat/apps/dataset_manager/views.py
index b622eaa65af..36fcea63fd3 100644
--- a/cvat/apps/dataset_manager/views.py
+++ b/cvat/apps/dataset_manager/views.py
@@ -8,18 +8,18 @@
 from datetime import timedelta
 
 import django_rq
+from datumaro.cli.util import make_file_name
+from datumaro.util import to_snake_case
 from django.utils import timezone
 
 import cvat.apps.dataset_manager.task as task
+from cvat.apps.engine.backup import TaskExporter
 from cvat.apps.engine.log import slogger
 from cvat.apps.engine.models import Task
-from datumaro.cli.util import make_file_name
-from datumaro.util import to_snake_case
 
 from .formats.registry import EXPORT_FORMATS, IMPORT_FORMATS
 from .util import current_function_name
 
-
 _MODULE_NAME = __package__ + '.' + osp.splitext(osp.basename(__file__))[0]
 def log_exception(logger=None, exc_info=True):
     if logger is None:
@@ -97,6 +97,40 @@ def clear_export_cache(task_id, file_path, file_ctime):
         log_exception(slogger.task[task_id])
         raise
 
+def backup_task(task_id, output_path):
+    try:
+        db_task = Task.objects.get(pk=task_id)
+
+        cache_dir = get_export_cache_dir(db_task)
+        output_path = osp.join(cache_dir, output_path)
+
+        task_time = timezone.localtime(db_task.updated_date).timestamp()
+        if not (osp.exists(output_path) and \
+                task_time <= osp.getmtime(output_path)):
+            os.makedirs(cache_dir, exist_ok=True)
+            with tempfile.TemporaryDirectory(dir=cache_dir) as temp_dir:
+                temp_file = osp.join(temp_dir, 'dump')
+                task_exporter = TaskExporter(task_id)
+                task_exporter.export_to(temp_file)
+                os.replace(temp_file, output_path)
+
+            archive_ctime = osp.getctime(output_path)
+            scheduler = django_rq.get_scheduler()
+            cleaning_job = scheduler.enqueue_in(time_delta=CACHE_TTL,
+                func=clear_export_cache,
+                task_id=task_id,
+                file_path=output_path, file_ctime=archive_ctime)
+            slogger.task[task_id].info(
+                "The task '{}' is backuped at '{}' "
+                "and available for downloading for the next {}. "
+                "Export cache cleaning job is enqueued, id '{}'".format(
+                db_task.name, output_path, CACHE_TTL,
+                cleaning_job.id))
+
+        return output_path
+    except Exception:
+        log_exception(slogger.task[task_id])
+        raise
 
 def get_export_formats():
     return list(EXPORT_FORMATS.values())
@@ -108,4 +142,4 @@ def get_all_formats():
     return {
         'importers': get_import_formats(),
         'exporters': get_export_formats(),
-    }
\ No newline at end of file
+    }
diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
new file mode 100644
index 00000000000..09f3426035b
--- /dev/null
+++ b/cvat/apps/engine/backup.py
@@ -0,0 +1,354 @@
+import io
+import os
+from enum import Enum
+from zipfile import ZipFile
+
+from rest_framework.parsers import JSONParser
+from rest_framework.renderers import JSONRenderer
+
+import cvat.apps.dataset_manager as dm
+from cvat.apps.engine import models
+from cvat.apps.engine.serializers import (AttributeSerializer, DataSerializer,
+                                          FrameMetaSerializer,
+                                          LabeledDataSerializer,
+                                          SegmentSerializer,
+                                          SimpleJobSerializer, TaskSerializer)
+from cvat.apps.engine.utils import av_scan_paths
+
+
+class TaskExporter():
+    class Version(Enum):
+        V1 = 'v1'
+
+    MANIFEST_FILENAME = 'manifest.json'
+    DATA_DIRNAME = 'data'
+    TASK_DIRNAME = 'task'
+
+    def __init__(self, pk, version=Version.V1):
+        self._db_task = models.Task.objects.prefetch_related('data__images').select_related('data__video').get(pk=pk)
+        self._db_task.segment_set.all().prefetch_related('job_set')
+        self._db_data = self._db_task.data
+        self._version = version
+
+    def _write_directory(self, source_dir, zip_object, target_dir, exclude=None):
+        exclude = [] if exclude is None else exclude
+        for root, dirs, files in os.walk(source_dir, topdown=True):
+            dirs[:] = [d for d in dirs if d not in exclude]
+            for filename in files:
+                file_path = os.path.join(root, filename)
+                arcname = os.path.normpath(os.path.join(target_dir, os.path.relpath(root, source_dir), filename))
+                zip_object.write(filename=file_path, arcname=arcname)
+
+    def _write_data(self, zip_object):
+        data_dir = self._db_data.get_data_dirname()
+        self._write_directory(source_dir=data_dir, zip_object=zip_object, target_dir=self.DATA_DIRNAME)
+
+    def _write_task(self, zip_object):
+        task_dir = self._db_task.get_task_dirname()
+        self._write_directory(source_dir=task_dir, zip_object=zip_object, target_dir=self.TASK_DIRNAME, exclude=('artifacts', 'export_cache', 'logs'))
+
+    def _write_manifest(self, zip_object):
+        task_serializer = TaskSerializer(self._db_task)
+        task_serializer.fields.pop('url')
+        task_serializer.fields['owner'].fields.pop('url')
+        task_serializer.fields.pop('segments')
+        segments = []
+        for db_segment in self._db_task.segment_set.all():
+            jobs = []
+            for db_job in db_segment.job_set.all():
+                job_serializer = SimpleJobSerializer(db_job)
+                job_serializer.fields.pop('url')
+                jobs.append(job_serializer.data)
+            segment_serailizer = SegmentSerializer(db_segment)
+            segment_serailizer.fields.pop('jobs')
+            segment = segment_serailizer.data
+            segment['jobs'] = jobs
+            segments.append(segment)
+
+        data_serializer = DataSerializer(self._db_data)
+        if hasattr(self._db_task.data, 'video'):
+            media = [self._db_task.data.video]
+        else:
+            media = list(self._db_task.data.images.order_by('frame'))
+
+        frame_meta = [{
+            'width': item.width,
+            'height': item.height,
+            'name': item.path,
+        } for item in media]
+        frame_meta_serializer = FrameMetaSerializer(data=frame_meta, many=True)
+
+        job_annotations = {}
+        for db_segment in self._db_task.segment_set.all():
+            for db_job in db_segment.job_set.all():
+                annotations = dm.task.get_job_data(db_job.id)
+                annotations_serializer = LabeledDataSerializer(data=annotations)
+                annotations_serializer.is_valid(raise_exception=True)
+                job_annotations[db_job.id] = annotations_serializer.data
+
+        manifest = task_serializer.data
+        manifest['version'] = self._version.value
+        manifest['data'] = data_serializer.data
+        frame_meta_serializer.is_valid(raise_exception=True)
+        manifest['data']['frames'] = frame_meta_serializer.data
+        for segment in segments:
+            for job in segment['jobs']:
+                job['annotations'] = job_annotations[job['id']]
+        manifest['segments'] = segments
+
+        zip_object.writestr(self.MANIFEST_FILENAME, data=JSONRenderer().render(manifest))
+
+    def export_to(self, filename):
+        with ZipFile(filename, 'x') as output_file:
+            self._write_data(output_file)
+            self._write_task(output_file)
+            self._write_manifest(output_file)
+
+class TaskImporter():
+    class Version(Enum):
+        V1 = 'v1'
+
+    MANIFEST_FILENAME = 'manifest.json'
+    DATA_DIRNAME = 'data'
+    TASK_DIRNAME = 'task'
+
+    def __init__(self, filename):
+        self._filename = filename
+        self._manifest = self._read_manifest()
+        self._version = self._read_version()
+
+    def _read_manifest(self):
+        with ZipFile(self._filename, 'r') as input_file:
+            return JSONParser().parse(io.BytesIO(input_file.read(self.MANIFEST_FILENAME)))
+
+    def _read_version(self):
+        version = self._manifest.pop('version')
+        try:
+            return self.Version(version)
+        except ValueError:
+            raise ValueError('{} version is not supported'.format(version))
+
+    def _prepare_meta(self, allowed_keys, meta):
+        for key in list(meta.keys()):
+            if key not in allowed_keys:
+                del meta[key]
+
+    def _prepare_task_meta(self, task):
+        allowed_fields = (
+            'name',
+            'mode',
+            'bug_tracker',
+            'overlap',
+            'segment_size',
+            'status',
+            'dimension',
+            'subset',
+        )
+
+        self._prepare_meta(allowed_fields, task)
+
+    def _prepare_data_meta(self, data):
+        allowed_fields = (
+            'chunk_size',
+            'size',
+            'image_quality',
+            'start_frame',
+            'stop_frame',
+            'frame_filter',
+            'compressed_chunk_type',
+            'original_chunk_type',
+            'storage_method',
+            'storage',
+        )
+        self._prepare_meta(allowed_fields, data)
+        if not data['frame_filter']:
+            data.pop('frame_filter')
+
+    def _prepare_segment_meta(self, segments):
+        allowed_fields = (
+            'start_frame',
+            'stop_frame',
+        )
+        self._prepare_meta(allowed_fields, segments)
+
+    def _prepare_job_meta(self, jobs):
+        allowed_fields = (
+            'status',
+        )
+        self._prepare_meta(allowed_fields, jobs)
+
+    def _prepare_annotations(self, annotations):
+        allowed_fields = (
+            'label_id',
+            'type',
+            'occluded',
+            'z_order',
+            'points',
+            'frame',
+            'group',
+            'source',
+            'attributes',
+            'shapes',
+        )
+
+        for tag in annotations['tags']:
+            self._prepare_meta(allowed_fields, tag)
+        for shape in annotations['shapes']:
+            self._prepare_meta(allowed_fields, shape)
+        for track in annotations['tracks']:
+            self._prepare_meta(allowed_fields, track)
+
+    def _create_labels(self, db_task, labels):
+        label_mapping = {}
+        attribute_mapping = {}
+
+        for label in labels:
+            label_id = label.pop('id')
+            attributes = label.pop('attributes', [])
+            db_label = models.Label.objects.create(task=db_task, **label)
+            label_mapping[label_id] = db_label.id
+
+            for attribute in attributes:
+                attribute_id = attribute.pop('id')
+                # attribute['label_id'] = db_label.id
+                attribute_serializer = AttributeSerializer(data=attribute)
+                attribute_serializer.is_valid(raise_exception=True)
+                db_attribute = attribute_serializer.save(label=db_label)
+                attribute_mapping[attribute_id] = db_attribute.id
+
+        return label_mapping, attribute_mapping
+
+    def _create_job(self, db_segment, job):
+        self._prepare_job_meta(job)
+        db_job = models.Job.objects.create(segment=db_segment, **job)
+        return db_job
+
+    def _update_annotations(self, labels_mapping, attributes_mapping, annotations):
+        def update_ids(objects):
+            for obj in objects:
+                obj['label_id'] = labels_mapping[obj['label_id']]
+                for attribute in obj['attributes']:
+                    attribute['spec_id'] = attributes_mapping[attribute['spec_id']]
+
+        update_ids(annotations['tags'])
+        update_ids(annotations['shapes'])
+        update_ids(annotations['tracks'])
+        for track in annotations['tracks']:
+            for track_shape in track['shapes']:
+                track_shape.pop('id')
+                for attribute in track_shape['attributes']:
+                    attribute['spec_id'] = attributes_mapping[attribute['spec_id']]
+                    attribute.pop('id')
+
+    def _create_annotations(self, db_job, labels_mapping, attributes_mapping, annotations):
+        self._update_annotations(labels_mapping, attributes_mapping, annotations)
+        self._prepare_annotations(annotations)
+
+        serializer = LabeledDataSerializer(data=annotations)
+        serializer.is_valid(raise_exception=True)
+        dm.task.put_job_data(db_job.id, serializer.data)
+
+    def _create_segments(self, db_task, labels_mapping, attributes_mapping, segments):
+        for segment in segments:
+            jobs = segment.pop('jobs')
+            self._prepare_segment_meta(segment)
+            db_segment = models.Segment.objects.create(task=db_task, **segment)
+            for job in jobs:
+                annotations = job.pop('annotations')
+                db_job = self._create_job(db_segment, job)
+                self._create_annotations(db_job, labels_mapping, attributes_mapping, annotations)
+
+    def _create_data(self, data):
+        self._prepare_data_meta(data)
+        data_serializer = DataSerializer(data=data)
+        data_serializer.is_valid(raise_exception=True)
+        db_data = data_serializer.save()
+        return db_data
+
+    def _create_frames(self, db_data, frames):
+        for frame in frames:
+            frame['data'] = db_data
+            frame['path'] = frame.pop('name')
+
+        if self._db_task.mode == 'annotation':
+            if self._db_task.dimension == models.DimensionType.DIM_2D:
+                models.Image.objects.bulk_create(frames)
+            # else: TODO
+        else:
+            models.Video.objects.create(**frames[0])
+
+    def _create_task(self):
+        data = self._manifest.pop('data')
+        frames = data.pop('frames')
+        labels = self._manifest.pop('labels')
+        segments = self._manifest.pop('segments')
+
+        db_data = self._create_data(data)
+
+        self._prepare_task_meta(self._manifest)
+        self._manifest['data_id'] = db_data.id
+
+        self._db_task = models.Task.objects.create(data=db_data, **self._manifest)
+
+        self._create_frames(db_data, frames)
+
+        labels_mapping, attributes_mapping = self._create_labels(self._db_task, labels)
+
+        self._create_segments(self._db_task, labels_mapping, attributes_mapping, segments)
+
+    def _import_task(self):
+        data = self._manifest.pop('data')
+        frames = data.pop('frames')
+        labels = self._manifest.pop('labels')
+        self._segments = self._manifest.pop('segments')
+
+        db_data = self._create_data(data)
+
+        self._prepare_task_meta(self._manifest)
+        self._manifest['data_id'] = db_data.id
+
+        self._db_task = models.Task.objects.create(data=db_data, **self._manifest)
+
+        self._create_frames(db_data, frames)
+
+        self._labels_mapping, self._attributes_mapping = self._create_labels(self._db_task, labels)
+
+        return self._db_task.id
+
+    def _import_annotations(self):
+        if not hasattr(self, '_labels_mapping') or not hasattr(self, '_attributes_mapping') or not hasattr(self, '_segments'):
+            raise Exception('Call import_task() first')
+
+        self._create_segments(self._db_task, self._labels_mapping, self._attributes_mapping, self._segments)
+
+    def _import_media(self):
+        task_path = self._db_task.get_task_dirname()
+        if os.path.isdir(task_path):
+            shutil.rmtree(task_path)
+
+        os.makedirs(self._db_task.get_task_logs_dirname())
+        os.makedirs(self._db_task.get_task_artifacts_dirname())
+
+        data_path = self._db_task.data.get_data_dirname()
+
+        with ZipFile(self._filename, 'r') as input_file:
+            for f in input_file.namelist():
+                if f.startswith(self.DATA_DIRNAME + os.path.sep):
+                    with open(os.path.join(data_path, os.path.relpath(f, self.DATA_DIRNAME)), "wb") as target_file:
+                        target_file.write(input_file.read(f))
+                elif f.startswith(self.TASK_DIRNAME + os.path.sep):
+                    with open(os.path.join(task_path, os.path.relpath(f, self.TASK_DIRNAME)), "wb") as target_file:
+                        target_file.write(input_file.read(f))
+
+    def import_task(self):
+        self._import_task()
+        self._import_annotations()
+        self._import_media()
+        return self._db_task
+
+
+def import_task(filename):
+    av_scan_paths(filename)
+    task_importer = TaskImporter(filename)
+    db_task = task_importer.import_task()
+    return db_task.id
diff --git a/cvat/apps/engine/serializers.py b/cvat/apps/engine/serializers.py
index 4aab32f4f4b..ae05cce4812 100644
--- a/cvat/apps/engine/serializers.py
+++ b/cvat/apps/engine/serializers.py
@@ -276,7 +276,7 @@ class Meta:
         model = models.Data
         fields = ('chunk_size', 'size', 'image_quality', 'start_frame', 'stop_frame', 'frame_filter',
             'compressed_chunk_type', 'original_chunk_type', 'client_files', 'server_files', 'remote_files', 'use_zip_chunks',
-            'use_cache', 'copy_data')
+            'use_cache', 'copy_data', 'storage_method', 'storage')
 
     # pylint: disable=no-self-use
     def validate_frame_filter(self, value):
@@ -525,6 +525,7 @@ class FrameMetaSerializer(serializers.Serializer):
     width = serializers.IntegerField()
     height = serializers.IntegerField()
     name = serializers.CharField(max_length=1024)
+    path = serializers.CharField(max_length=1024, default='')
 
 class PluginsSerializer(serializers.Serializer):
     GIT_INTEGRATION = serializers.BooleanField()
@@ -626,6 +627,9 @@ class LogEventSerializer(serializers.Serializer):
 class AnnotationFileSerializer(serializers.Serializer):
     annotation_file = serializers.FileField()
 
+class TaskFileSerializer(serializers.Serializer):
+    task_file = serializers.FileField()
+
 class ReviewSerializer(serializers.ModelSerializer):
     assignee = BasicUserSerializer(allow_null=True, required=False)
     assignee_id = serializers.IntegerField(write_only=True, allow_null=True, required=False)
diff --git a/cvat/apps/engine/task.py b/cvat/apps/engine/task.py
index b54b3af9558..7d0e48c4897 100644
--- a/cvat/apps/engine/task.py
+++ b/cvat/apps/engine/task.py
@@ -5,28 +5,30 @@
 
 import itertools
 import os
+import shutil
 import sys
+from distutils.dir_util import copy_tree
 from re import findall
-import rq
-import shutil
 from traceback import print_exception
 from urllib import parse as urlparse
 from urllib import request as urlrequest
-import requests
-
-from cvat.apps.engine.media_extractors import get_mime, MEDIA_TYPES, Mpeg4ChunkWriter, ZipChunkWriter, Mpeg4CompressedChunkWriter, ZipCompressedChunkWriter, ValidateDimension
-from cvat.apps.engine.models import DataChoice, StorageMethodChoice, StorageChoice, RelatedFile
-from cvat.apps.engine.utils import av_scan_paths
-from cvat.apps.engine.prepare import prepare_meta
-from cvat.apps.engine.models import DimensionType
 
 import django_rq
+import requests
+import rq
 from django.conf import settings
 from django.db import transaction
-from distutils.dir_util import copy_tree
 
-from . import models
-from .log import slogger
+from cvat.apps.engine import models
+from cvat.apps.engine.log import slogger
+from cvat.apps.engine.media_extractors import (MEDIA_TYPES, Mpeg4ChunkWriter,
+                                               Mpeg4CompressedChunkWriter,
+                                               ValidateDimension,
+                                               ZipChunkWriter,
+                                               ZipCompressedChunkWriter,
+                                               get_mime)
+from cvat.apps.engine.prepare import prepare_meta
+from cvat.apps.engine.utils import av_scan_paths
 
 ############################# Low Level server API
 
@@ -225,11 +227,11 @@ def _create_thread(tid, data):
     media = _count_files(data, meta_info_file)
     media, task_mode = _validate_data(media, meta_info_file)
     if meta_info_file:
-        assert settings.USE_CACHE and db_data.storage_method == StorageMethodChoice.CACHE, \
+        assert settings.USE_CACHE and db_data.storage_method == models.StorageMethodChoice.CACHE, \
             "File with meta information can be uploaded if 'Use cache' option is also selected"
 
     if data['server_files']:
-        if db_data.storage == StorageChoice.LOCAL:
+        if db_data.storage == models.StorageChoice.LOCAL:
             _copy_data_from_share(data['server_files'], upload_dir)
         else:
             upload_dir = settings.SHARE_ROOT
@@ -248,7 +250,7 @@ def _create_thread(tid, data):
             if extractor is not None:
                 raise Exception('Combined data types are not supported')
             source_paths=[os.path.join(upload_dir, f) for f in media_files]
-            if media_type in  ('archive', 'zip') and db_data.storage == StorageChoice.SHARE:
+            if media_type in  ('archive', 'zip') and db_data.storage == models.StorageChoice.SHARE:
                 source_paths.append(db_data.get_upload_dirname())
             extractor = MEDIA_TYPES[media_type]['extractor'](
                 source_path=source_paths,
@@ -262,15 +264,15 @@ def _create_thread(tid, data):
         extractor.extract()
         validate_dimension.set_path(os.path.split(extractor.get_zip_filename())[0])
         validate_dimension.validate()
-        if validate_dimension.dimension == DimensionType.DIM_3D:
-            db_task.dimension = DimensionType.DIM_3D
+        if validate_dimension.dimension == models.DimensionType.DIM_3D:
+            db_task.dimension = models.DimensionType.DIM_3D
 
             extractor.reconcile(
                 source_files=list(validate_dimension.related_files.keys()),
                 step=db_data.get_frame_step(),
                 start=db_data.start_frame,
                 stop=data['stop_frame'],
-                dimension=DimensionType.DIM_3D,
+                dimension=models.DimensionType.DIM_3D,
 
             )
             extractor.add_files(validate_dimension.converted_files)
@@ -293,8 +295,8 @@ def update_progress(progress):
         job.save_meta()
         update_progress.call_counter = (update_progress.call_counter + 1) % len(progress_animation)
 
-    compressed_chunk_writer_class = Mpeg4CompressedChunkWriter if db_data.compressed_chunk_type == DataChoice.VIDEO else ZipCompressedChunkWriter
-    if db_data.original_chunk_type == DataChoice.VIDEO:
+    compressed_chunk_writer_class = Mpeg4CompressedChunkWriter if db_data.compressed_chunk_type == models.DataChoice.VIDEO else ZipCompressedChunkWriter
+    if db_data.original_chunk_type == models.DataChoice.VIDEO:
         original_chunk_writer_class = Mpeg4ChunkWriter
         # Let's use QP=17 (that is 67 for 0-100 range) for the original chunks, which should be visually lossless or nearly so.
         # A lower value will significantly increase the chunk size with a slight increase of quality.
@@ -304,7 +306,7 @@ def update_progress(progress):
         original_quality = 100
 
     kwargs = {}
-    if validate_dimension.dimension == DimensionType.DIM_3D:
+    if validate_dimension.dimension == models.DimensionType.DIM_3D:
         kwargs["dimension"] = validate_dimension.dimension
     compressed_chunk_writer = compressed_chunk_writer_class(db_data.image_quality, **kwargs)
     original_chunk_writer = original_chunk_writer_class(original_quality)
@@ -322,7 +324,7 @@ def update_progress(progress):
     video_path = ""
     video_size = (0, 0)
 
-    if settings.USE_CACHE and db_data.storage_method == StorageMethodChoice.CACHE:
+    if settings.USE_CACHE and db_data.storage_method == models.StorageMethodChoice.CACHE:
        for media_type, media_files in media.items():
 
             if not media_files:
@@ -367,7 +369,7 @@ def update_progress(progress):
                     db_data.size = len(range(db_data.start_frame, min(data['stop_frame'] + 1 if data['stop_frame'] else all_frames, all_frames), db_data.get_frame_step()))
                     video_path = os.path.join(upload_dir, media_files[0])
                 except Exception as ex:
-                    db_data.storage_method = StorageMethodChoice.FILE_SYSTEM
+                    db_data.storage_method = models.StorageMethodChoice.FILE_SYSTEM
                     if os.path.exists(db_data.get_meta_path()):
                         os.remove(db_data.get_meta_path())
                     base_msg = str(ex) if isinstance(ex, AssertionError) else "Uploaded video does not support a quick way of task creating."
@@ -392,7 +394,7 @@ def update_progress(progress):
                         for (path, frame), (w, h) in zip(chunk_paths, img_sizes)
                     ])
 
-    if db_data.storage_method == StorageMethodChoice.FILE_SYSTEM or not settings.USE_CACHE:
+    if db_data.storage_method == models.StorageMethodChoice.FILE_SYSTEM or not settings.USE_CACHE:
         counter = itertools.count()
         generator = itertools.groupby(extractor, lambda x: next(counter) // db_data.chunk_size)
         for chunk_idx, chunk_data in generator:
@@ -423,7 +425,7 @@ def update_progress(progress):
             update_progress(progress)
 
     if db_task.mode == 'annotation':
-        if validate_dimension.dimension == DimensionType.DIM_2D:
+        if validate_dimension.dimension == models.DimensionType.DIM_2D:
             models.Image.objects.bulk_create(db_images)
         else:
             related_file = []
@@ -442,8 +444,8 @@ def update_progress(progress):
                 if validate_dimension.related_files.get(image_data.path, None):
                     for related_image_file in validate_dimension.related_files[image_data.path]:
                         related_file.append(
-                            RelatedFile(data=db_data, primary_image_id=image_data.id, path=related_image_file))
-            RelatedFile.objects.bulk_create(related_file)
+                            models.RelatedFile(data=db_data, primary_image_id=image_data.id, path=related_image_file))
+            models.RelatedFile.objects.bulk_create(related_file)
         db_images = []
     else:
         models.Video.objects.create(
diff --git a/cvat/apps/engine/views.py b/cvat/apps/engine/views.py
index 5ab76673b72..cf7208a7df2 100644
--- a/cvat/apps/engine/views.py
+++ b/cvat/apps/engine/views.py
@@ -2,23 +2,24 @@
 #
 # SPDX-License-Identifier: MIT
 
+import io
 import os
 import os.path as osp
-import io
 import shutil
 import traceback
+import uuid
 from datetime import datetime
 from distutils.util import strtobool
 from tempfile import mkstemp
-import cv2
 
+import cv2
 import django_rq
-from django.shortcuts import get_object_or_404
 from django.apps import apps
 from django.conf import settings
 from django.contrib.auth.models import User
 from django.db import IntegrityError
 from django.http import HttpResponse
+from django.shortcuts import get_object_or_404
 from django.utils import timezone
 from django.utils.decorators import method_decorator
 from django_filters import rest_framework as filters
@@ -35,23 +36,34 @@
 from sendfile import sendfile
 
 import cvat.apps.dataset_manager as dm
-import cvat.apps.dataset_manager.views # pylint: disable=unused-import
+import cvat.apps.dataset_manager.views  # pylint: disable=unused-import
 from cvat.apps.authentication import auth
 from cvat.apps.dataset_manager.bindings import CvatImportError
 from cvat.apps.dataset_manager.serializers import DatasetFormatsSerializer
 from cvat.apps.engine.frame_provider import FrameProvider
-from cvat.apps.engine.models import (
-    Job, StatusChoice, Task, Project, Review, Issue,
-    Comment, StorageMethodChoice, ReviewStatus, StorageChoice, DimensionType, Image
-)
-from cvat.apps.engine.serializers import (
-    AboutSerializer, AnnotationFileSerializer, BasicUserSerializer,
-    DataMetaSerializer, DataSerializer, ExceptionSerializer,
-    FileInfoSerializer, JobSerializer, LabeledDataSerializer,
-    LogEventSerializer, ProjectSerializer, ProjectSearchSerializer, ProjectWithoutTaskSerializer,
-    RqStatusSerializer, TaskSerializer, UserSerializer, PluginsSerializer, ReviewSerializer,
-    CombinedReviewSerializer, IssueSerializer, CombinedIssueSerializer, CommentSerializer
-)
+from cvat.apps.engine.models import (Comment, DimensionType, Image, Issue, Job,
+                                     Project, Review, ReviewStatus,
+                                     StatusChoice, StorageChoice,
+                                     StorageMethodChoice, Task)
+from cvat.apps.engine.serializers import (AboutSerializer,
+                                          AnnotationFileSerializer,
+                                          BasicUserSerializer,
+                                          CombinedIssueSerializer,
+                                          CombinedReviewSerializer,
+                                          CommentSerializer,
+                                          DataMetaSerializer, DataSerializer,
+                                          ExceptionSerializer,
+                                          FileInfoSerializer, IssueSerializer,
+                                          JobSerializer, LabeledDataSerializer,
+                                          LogEventSerializer,
+                                          PluginsSerializer,
+                                          ProjectSearchSerializer,
+                                          ProjectSerializer,
+                                          ProjectWithoutTaskSerializer,
+                                          ReviewSerializer, RqStatusSerializer,
+                                          TaskFileSerializer, TaskSerializer,
+                                          UserSerializer)
+from cvat.apps.engine.backup import import_task
 from cvat.apps.engine.utils import av_scan_paths
 
 from . import models, task
@@ -355,20 +367,133 @@ def get_permissions(self):
 
         return [perm() for perm in permissions]
 
-    def perform_create(self, serializer):
-        def validate_task_limit(owner):
-            admin_perm = auth.AdminRolePermission()
-            is_admin = admin_perm.has_permission(self.request, self)
-            if not is_admin and settings.RESTRICTIONS['task_limit'] is not None and \
-                Task.objects.filter(owner=owner).count() >= settings.RESTRICTIONS['task_limit']:
-                raise serializers.ValidationError('The user has the maximum number of tasks')
+    def _validate_task_limit(self, owner):
+        admin_perm = auth.AdminRolePermission()
+        is_admin = admin_perm.has_permission(self.request, self)
+        if not is_admin and settings.RESTRICTIONS['task_limit'] is not None and \
+            Task.objects.filter(owner=owner).count() >= settings.RESTRICTIONS['task_limit']:
+            raise serializers.ValidationError('The user has the maximum number of tasks')
+
+    def create(self, request):
+        action = self.request.query_params.get('action', None)
+        if action is None:
+            return super().create(request)
+        elif action == 'import':
+            self._validate_task_limit(owner=self.request.user)
+            if 'rq_id' in request.data:
+                rq_id = request.data['rq_id']
+            else:
+                rq_id = "{}@/api/v1/tasks/{}?action_import".format(request.user, uuid.uuid4())
+
+            queue = django_rq.get_queue("default")
+            rq_job = queue.fetch_job(rq_id)
+
+            if not rq_job:
+                serializer = TaskFileSerializer(data=request.data)
+                serializer.is_valid(raise_exception=True)
+                task_file = serializer.validated_data['task_file']
+                fd, filename = mkstemp(prefix='cvat_')
+                with open(filename, 'wb+') as f:
+                    for chunk in task_file.chunks():
+                        f.write(chunk)
+                rq_job = queue.enqueue_call(
+                    func=import_task,
+                    args=(filename,),
+                    job_id=rq_id,
+                )
+                rq_job.meta['tmp_file'] = filename
+                rq_job.meta['tmp_file_descriptor'] = fd
+                rq_job.save_meta()
+            else:
+                if rq_job.is_finished:
+                    task_id = rq_job.return_value
+                    os.close(rq_job.meta['tmp_file_descriptor'])
+                    os.remove(rq_job.meta['tmp_file'])
+                    rq_job.delete()
+                    return Response({'id': task_id}, status=status.HTTP_201_CREATED)
+                elif rq_job.is_failed:
+                    os.close(rq_job.meta['tmp_file_descriptor'])
+                    os.remove(rq_job.meta['tmp_file'])
+                    exc_info = str(rq_job.exc_info)
+                    rq_job.delete()
 
+                    # RQ adds a prefix with exception class name
+                    import_error_prefix = '{}.{}'.format(
+                        CvatImportError.__module__, CvatImportError.__name__)
+                    if exc_info.startswith(import_error_prefix):
+                        exc_info = exc_info.replace(import_error_prefix + ': ', '')
+                        return Response(data=exc_info,
+                            status=status.HTTP_400_BAD_REQUEST)
+                    else:
+                        return Response(data=exc_info,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+            return Response({'rq_id': rq_id}, status=status.HTTP_202_ACCEPTED)
+        else:
+            raise serializers.ValidationError(
+                "Unexpected action specified for the request")
+
+    def retrieve(self, request, pk=None):
+        db_task = self.get_object() # force to call check_object_permissions
+        action = self.request.query_params.get('action', None)
+        if action is None:
+            return super().retrieve(request, pk)
+        elif action in ('export', 'download'):
+            queue = django_rq.get_queue("default")
+            rq_id = "/api/v1/tasks/{}?action_export".format(pk)
+
+            rq_job = queue.fetch_job(rq_id)
+            if rq_job:
+                last_task_update_time = timezone.localtime(db_task.updated_date)
+                request_time = rq_job.meta.get('request_time', None)
+                if request_time is None or request_time < last_task_update_time:
+                    rq_job.cancel()
+                    rq_job.delete()
+                else:
+                    if rq_job.is_finished:
+                        file_path = rq_job.return_value
+                        if action == "download" and osp.exists(file_path):
+                            rq_job.delete()
+
+                            timestamp = datetime.strftime(last_task_update_time,
+                                "%Y_%m_%d_%H_%M_%S")
+                            filename = "task_{}_backup_{}{}".format(
+                                db_task.name, timestamp,
+                                osp.splitext(file_path)[1])
+                            return sendfile(request, file_path, attachment=True,
+                                attachment_filename=filename.lower())
+                        else:
+                            if osp.exists(file_path):
+                                return Response(status=status.HTTP_201_CREATED)
+                    elif rq_job.is_failed:
+                        exc_info = str(rq_job.exc_info)
+                        rq_job.delete()
+                        return Response(exc_info,
+                            status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+                    else:
+                        return Response(status=status.HTTP_202_ACCEPTED)
+
+            ttl = dm.views.CACHE_TTL.total_seconds()
+            queue.enqueue_call(
+                func=dm.views.backup_task,
+                args=(pk, 'task_dump.zip'),
+                job_id=rq_id,
+                meta={ 'request_time': timezone.localtime() },
+                result_ttl=ttl, failure_ttl=ttl)
+            return Response(status=status.HTTP_202_ACCEPTED)
+
+        else:
+            raise serializers.ValidationError(
+                "Unexpected action specified for the request")
+
+
+    def perform_create(self, serializer):
         owner = self.request.data.get('owner', None)
         if owner:
-            validate_task_limit(owner)
+            self._validate_task_limit(owner)
             serializer.save()
         else:
-            validate_task_limit(self.request.user)
+            self._validate_task_limit(self.request.user)
             serializer.save(owner=self.request.user)
 
     def perform_destroy(self, instance):

From 24cb227938e79401e38205aa369e558d4b905e4b Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Fri, 2 Apr 2021 10:24:25 +0300
Subject: [PATCH 02/19] fixed tests

---
 cvat/apps/engine/task.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cvat/apps/engine/task.py b/cvat/apps/engine/task.py
index fb776bbcd2e..1616ab6af23 100644
--- a/cvat/apps/engine/task.py
+++ b/cvat/apps/engine/task.py
@@ -253,7 +253,7 @@ def _create_thread(tid, data):
             if media_type in {'archive', 'zip'} and db_data.storage == models.StorageChoice.SHARE:
                 source_paths.append(db_data.get_upload_dirname())
                 upload_dir = db_data.get_upload_dirname()
-                db_data.storage = StorageChoice.LOCAL
+                db_data.storage = models.StorageChoice.LOCAL
             extractor = MEDIA_TYPES[media_type]['extractor'](
                 source_path=source_paths,
                 step=db_data.get_frame_step(),

From cdf2e1242bd8b306f5d59b28cfcbe87a3e5c564f Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Mon, 5 Apr 2021 13:17:15 +0300
Subject: [PATCH 03/19] CLI

---
 cvat/apps/engine/backup.py   | 29 ++++++---------------
 utils/cli/cli.py             | 16 +++++++-----
 utils/cli/core/core.py       | 48 +++++++++++++++++++++++++++++++++++
 utils/cli/core/definition.py | 49 +++++++++++++++++++++++++++++++++++-
 4 files changed, 113 insertions(+), 29 deletions(-)

diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index 09f3426035b..e3f67a5a1ce 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -266,36 +266,18 @@ def _create_data(self, data):
         return db_data
 
     def _create_frames(self, db_data, frames):
-        for frame in frames:
+        for idx, frame in enumerate(frames):
             frame['data'] = db_data
             frame['path'] = frame.pop('name')
+            frame['frame'] = idx
 
         if self._db_task.mode == 'annotation':
             if self._db_task.dimension == models.DimensionType.DIM_2D:
-                models.Image.objects.bulk_create(frames)
+                models.Image.objects.bulk_create(models.Image(**frame) for frame in frames)
             # else: TODO
         else:
             models.Video.objects.create(**frames[0])
 
-    def _create_task(self):
-        data = self._manifest.pop('data')
-        frames = data.pop('frames')
-        labels = self._manifest.pop('labels')
-        segments = self._manifest.pop('segments')
-
-        db_data = self._create_data(data)
-
-        self._prepare_task_meta(self._manifest)
-        self._manifest['data_id'] = db_data.id
-
-        self._db_task = models.Task.objects.create(data=db_data, **self._manifest)
-
-        self._create_frames(db_data, frames)
-
-        labels_mapping, attributes_mapping = self._create_labels(self._db_task, labels)
-
-        self._create_segments(self._db_task, labels_mapping, attributes_mapping, segments)
-
     def _import_task(self):
         data = self._manifest.pop('data')
         frames = data.pop('frames')
@@ -309,7 +291,10 @@ def _import_task(self):
 
         self._db_task = models.Task.objects.create(data=db_data, **self._manifest)
 
-        self._create_frames(db_data, frames)
+        try:
+            self._create_frames(db_data, frames)
+        except Exception as e:
+            print(e)
 
         self._labels_mapping, self._attributes_mapping = self._create_labels(self._db_task, labels)
 
diff --git a/utils/cli/cli.py b/utils/cli/cli.py
index ae08ad1a327..52f60ee1e4b 100755
--- a/utils/cli/cli.py
+++ b/utils/cli/cli.py
@@ -19,12 +19,16 @@ def config_log(level):
 
 
 def main():
-    actions = {'create': CLI.tasks_create,
-               'delete': CLI.tasks_delete,
-               'ls': CLI.tasks_list,
-               'frames': CLI.tasks_frame,
-               'dump': CLI.tasks_dump,
-               'upload': CLI.tasks_upload}
+    actions = {
+        'create': CLI.tasks_create,
+        'delete': CLI.tasks_delete,
+        'ls': CLI.tasks_list,
+        'frames': CLI.tasks_frame,
+        'dump': CLI.tasks_dump,
+        'upload': CLI.tasks_upload,
+        'export': CLI.tasks_export,
+        'import': CLI.tasks_import,
+    }
     args = parser.parse_args()
     config_log(args.loglevel)
     with requests.Session() as session:
diff --git a/utils/cli/core/core.py b/utils/cli/core/core.py
index 57b39d1f860..314fd1cbf63 100644
--- a/utils/cli/core/core.py
+++ b/utils/cli/core/core.py
@@ -198,6 +198,54 @@ def tasks_upload(self, task_id, fileformat, filename, **kwargs):
             "with annotation file {} finished".format(filename)
         log.info(logger_string)
 
+    def tasks_export(self, task_id, filename, export_verification_period=3, **kwargs):
+        """ Export and download a whole task """
+        url = self.api.tasks_id(task_id)
+        export_url = url + '?action=export'
+        response = self.session.get(export_url)
+        response.raise_for_status()
+
+        while True:
+            sleep(export_verification_period)
+            response = self.session.get(export_url)
+            response.raise_for_status()
+            log.info('STATUS {}'.format(response.status_code))
+            if response.status_code == 201:
+                break
+
+        response = self.session.get(url + '?action=download')
+        response.raise_for_status()
+
+        with open(filename, 'wb') as fp:
+            fp.write(response.content)
+        logger_string = "Task {} has been exported sucessfully. ".format(task_id) +\
+            "to {}".format(os.path.abspath(filename))
+        log.info(logger_string)
+
+    def tasks_import(self, filename, import_verification_period=3, **kwargs):
+        """ Import a task"""
+        url = self.api.tasks + '?action=import'
+        response = self.session.post(
+                url,
+                files={'task_file': open(filename, 'rb')}
+            )
+        response.raise_for_status()
+        response_json = response.json()
+        rq_id = response_json['rq_id']
+        while True:
+            sleep(import_verification_period)
+            response = self.session.post(
+                url,
+                data={'rq_id': rq_id}
+            )
+            response.raise_for_status()
+            if response.status_code == 201:
+                break
+
+        task_id = response.json()['id']
+        logger_string = "Task has been imported sucessfully. Task ID: {}".format(task_id)
+        log.info(logger_string)
+
     def login(self, credentials):
         url = self.api.login
         auth = {'username': credentials[0], 'password': credentials[1]}
diff --git a/utils/cli/core/definition.py b/utils/cli/core/definition.py
index c15dbafee43..c4603f0bbb6 100644
--- a/utils/cli/core/definition.py
+++ b/utils/cli/core/definition.py
@@ -289,4 +289,51 @@ def argparse(s):
     type=str,
     default='CVAT 1.1',
     help='annotation format (default: %(default)s)'
-)
\ No newline at end of file
+)
+
+#######################################################################
+# Export task
+#######################################################################
+
+export_task_parser = task_subparser.add_parser(
+    'export',
+    description='Export a CVAT task.'
+)
+export_task_parser.add_argument(
+    'task_id',
+    type=int,
+    help='task ID'
+)
+export_task_parser.add_argument(
+    'filename',
+    type=str,
+    help='output file'
+)
+export_task_parser.add_argument(
+    '--export_verification_period',
+    default=3,
+    type=int,
+    help='''number of seconds to wait until checking
+            if the export of the task is completed'''
+)
+
+#######################################################################
+# Import task
+#######################################################################
+
+import_task_parser = task_subparser.add_parser(
+    'import',
+    description='import a CVAT task.'
+)
+import_task_parser.add_argument(
+    'filename',
+    type=str,
+    help='upload file'
+)
+import_task_parser.add_argument(
+    '--import_verification_period',
+    default=3,
+    type=int,
+    help='''number of seconds to wait until checking
+            if the import of the task is completed'''
+)

From c44faec65f0ddaf45a0c9be75ff3f9cc08216472 Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Fri, 9 Apr 2021 14:27:47 +0300
Subject: [PATCH 04/19] fix comments

---
 cvat-core/package-lock.json                   |   2 +-
 cvat-core/package.json                        |   2 +-
 cvat-core/src/server-proxy.js                 |  16 +-
 cvat-core/src/session.js                      |  20 +-
 cvat-ui/package-lock.json                     |  26 +-
 cvat-ui/package.json                          |   5 +-
 cvat-ui/src/actions/tasks-actions.ts          |  42 ++-
 .../components/actions-menu/actions-menu.tsx  |  12 +-
 .../src/components/actions-menu/styles.scss   |   4 +
 cvat-ui/src/components/tasks-page/styles.scss |   8 +
 cvat-ui/src/components/tasks-page/top-bar.tsx |  18 +-
 .../containers/actions-menu/actions-menu.tsx  |  33 ++-
 .../src/containers/tasks-page/tasks-page.tsx  |   8 +-
 cvat-ui/src/reducers/interfaces.ts            |   7 +-
 cvat-ui/src/reducers/notifications-reducer.ts |  50 +++-
 cvat-ui/src/reducers/tasks-reducer.ts         |  16 +-
 cvat/apps/engine/backup.py                    | 280 ++++++++++++------
 cvat/apps/engine/serializers.py               |   7 +
 18 files changed, 358 insertions(+), 198 deletions(-)

diff --git a/cvat-core/package-lock.json b/cvat-core/package-lock.json
index 644895f51d0..6b439227066 100644
--- a/cvat-core/package-lock.json
+++ b/cvat-core/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "cvat-core",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
diff --git a/cvat-core/package.json b/cvat-core/package.json
index e0453e8ed45..f8c1dc697e6 100644
--- a/cvat-core/package.json
+++ b/cvat-core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cvat-core",
-  "version": "3.12.0",
+  "version": "3.13.0",
   "description": "Part of Computer Vision Tool which presents an interface for client-side integration",
   "main": "babel.config.js",
   "scripts": {
diff --git a/cvat-core/src/server-proxy.js b/cvat-core/src/server-proxy.js
index 90cfee08696..5505f5cc2b9 100644
--- a/cvat-core/src/server-proxy.js
+++ b/cvat-core/src/server-proxy.js
@@ -465,9 +465,9 @@
                 });
             }
 
-            async function backupTask(id) {
+            async function exportTask(id) {
                 const { backendAPI } = config;
-                let url = `${backendAPI}/tasks/${id}`;
+                const url = `${backendAPI}/tasks/${id}`;
 
                 return new Promise((resolve, reject) => {
                     async function request() {
@@ -498,13 +498,9 @@
                 return new Promise((resolve, reject) => {
                     async function request() {
                         try {
-                            const response = await Axios.post(
-                                `${backendAPI}/tasks?action=import`,
-                                annotationData,
-                                {
-                                    proxy: config.proxy,
-                                },
-                            );
+                            const response = await Axios.post(`${backendAPI}/tasks?action=import`, annotationData, {
+                                proxy: config.proxy,
+                            });
                             if (response.status === 202) {
                                 annotationData = new FormData();
                                 annotationData.append('rq_id', response.data.rq_id);
@@ -1103,7 +1099,7 @@
                             createTask,
                             deleteTask,
                             exportDataset,
-                            backupTask,
+                            exportTask,
                             importTask,
                         }),
                         writable: false,
diff --git a/cvat-core/src/session.js b/cvat-core/src/session.js
index 458c49a955b..7615d566aeb 100644
--- a/cvat-core/src/session.js
+++ b/cvat-core/src/session.js
@@ -1607,7 +1607,7 @@
 
         /**
          * Method makes a backup of a task
-         * @method backup
+         * @method export
          * @memberof module:API.cvat.classes.Task
          * @readonly
          * @instance
@@ -1615,8 +1615,8 @@
          * @throws {module:API.cvat.exceptions.ServerError}
          * @throws {module:API.cvat.exceptions.PluginError}
          */
-        async backup() {
-            const result = await PluginRegistry.apiWrapper.call(this, Task.prototype.backup);
+        async export() {
+            const result = await PluginRegistry.apiWrapper.call(this, Task.prototype.export);
             return result;
         }
 
@@ -1630,8 +1630,8 @@
          * @throws {module:API.cvat.exceptions.ServerError}
          * @throws {module:API.cvat.exceptions.PluginError}
          */
-         async import(file) {
-            const result = await PluginRegistry.apiWrapper.call(this, Task.prototype.import, file);
+        static async import(file) {
+            const result = await PluginRegistry.apiWrapper.call(this, Task.import, file);
             return result;
         }
     }
@@ -1877,12 +1877,12 @@
         return result;
     };
 
-    Job.prototype.annotations.import.implementation = function (data) {
+    Job.prototype.annotations.import.implementation = async function (data) {
         const result = importAnnotations(this, data);
         return result;
     };
 
-    Job.prototype.annotations.export.implementation = function () {
+    Job.prototype.annotations.export.implementation = async function () {
         const result = exportAnnotations(this);
         return result;
     };
@@ -2035,12 +2035,12 @@
         return result;
     };
 
-    Task.prototype.backup.implementation = async function () {
-        const result = await serverProxy.tasks.backupTask(this.id);
+    Task.prototype.export.implementation = async function () {
+        const result = await serverProxy.tasks.exportTask(this.id);
         return result;
     };
 
-    Task.prototype.import.implementation = async function (file) {
+    Task.import.implementation = async function (file) {
         const result = await serverProxy.tasks.importTask(file);
         return result;
     };
diff --git a/cvat-ui/package-lock.json b/cvat-ui/package-lock.json
index c23090f3cb8..f92d3ea6df7 100644
--- a/cvat-ui/package-lock.json
+++ b/cvat-ui/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "cvat-ui",
-  "version": "1.18.1",
+  "version": "1.19.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -14969,7 +14969,8 @@
             "promise-inflight": "^1.0.1",
             "rimraf": "^2.6.3",
             "ssri": "^6.0.1",
-            "unique-filename": "^1.1.1"
+            "unique-filename": "^1.1.1",
+            "y18n": "^4.0.0"
           }
         },
         "cache-base": {
@@ -21132,7 +21133,8 @@
                 "require-directory": "^2.1.1",
                 "require-main-filename": "^2.0.0",
                 "set-blocking": "^2.0.0",
-                "which-module": "^2.0.0"
+                "which-module": "^2.0.0",
+                "y18n": "^4.0.0"
               }
             }
           }
@@ -21311,6 +21313,11 @@
           "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
           "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="
         },
+        "y18n": {
+          "version": "4.0.3",
+          "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
+          "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="
+        },
         "yallist": {
           "version": "3.1.1",
           "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
@@ -21330,6 +21337,7 @@
             "set-blocking": "^2.0.0",
             "string-width": "^4.2.0",
             "which-module": "^2.0.0",
+            "y18n": "^4.0.0",
             "yargs-parser": "^18.1.2"
           }
         },
@@ -28255,9 +28263,9 @@
       }
     },
     "rc-menu": {
-      "version": "8.10.6",
-      "resolved": "https://registry.npmjs.org/rc-menu/-/rc-menu-8.10.6.tgz",
-      "integrity": "sha512-RVkd8XChwSmVOdNULbqLNnABthRZWnhqct1Q74onEXTClsXvsLADMhlIJtw/umglVSECM+14TJdIli9rl2Bzlw==",
+      "version": "8.10.7",
+      "resolved": "https://registry.npmjs.org/rc-menu/-/rc-menu-8.10.7.tgz",
+      "integrity": "sha512-m/ypV7OjkkUsMdutzMUxEI8tWyi0Y1TQ5YkSDk7k2uv2aCKkHYEoDKsDAfcPeejo3HMo2z5unWE+jD+dCphraw==",
       "requires": {
         "@babel/runtime": "^7.10.1",
         "classnames": "2.x",
@@ -28278,9 +28286,9 @@
           }
         },
         "rc-util": {
-          "version": "5.9.4",
-          "resolved": "https://registry.npmjs.org/rc-util/-/rc-util-5.9.4.tgz",
-          "integrity": "sha512-pzFmYZsKLJ1p+Uv4NqA4aNBaFh8/hOQxOOxA5G4TiyPboa0o/PjminxUCKvoSwVJVW5YgleSM2XPCTpTV6DCsQ==",
+          "version": "5.9.8",
+          "resolved": "https://registry.npmjs.org/rc-util/-/rc-util-5.9.8.tgz",
+          "integrity": "sha512-typLSHYGf5irvGLYQshs0Ra3aze086h0FhzsAkyirMunYZ7b3Te8gKa5PVaanoHaZa9sS6qx98BxgysoRP+6Tw==",
           "requires": {
             "@babel/runtime": "^7.12.5",
             "react-is": "^16.12.0",
diff --git a/cvat-ui/package.json b/cvat-ui/package.json
index d6bbde46e5c..3f80e9293ce 100644
--- a/cvat-ui/package.json
+++ b/cvat-ui/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cvat-ui",
-  "version": "1.18.1",
+  "version": "1.19.0",
   "description": "CVAT single-page application",
   "main": "src/index.tsx",
   "scripts": {
@@ -55,6 +55,7 @@
     "@types/react-color": "^3.0.4",
     "@types/react-dom": "^16.9.11",
     "@types/react-redux": "^7.1.16",
+    "@types/react-resizable": "^1.7.2",
     "@types/react-router": "^5.1.12",
     "@types/react-router-dom": "^5.1.7",
     "@types/react-share": "^3.0.3",
@@ -72,6 +73,7 @@
     "mousetrap": "^1.6.5",
     "platform": "^1.3.6",
     "prop-types": "^15.7.2",
+    "rc-menu": "^8.10.7",
     "react": "^16.14.0",
     "react-awesome-query-builder": "^3.0.0",
     "react-color": "^2.19.3",
@@ -79,7 +81,6 @@
     "react-dom": "^16.14.0",
     "react-redux": "^7.2.2",
     "react-resizable": "^1.11.1",
-    "@types/react-resizable": "^1.7.2",
     "react-router": "^5.1.0",
     "react-router-dom": "^5.1.0",
     "react-share": "^3.0.1",
diff --git a/cvat-ui/src/actions/tasks-actions.ts b/cvat-ui/src/actions/tasks-actions.ts
index 1d2dee09250..f0ad77ac368 100644
--- a/cvat-ui/src/actions/tasks-actions.ts
+++ b/cvat-ui/src/actions/tasks-actions.ts
@@ -35,9 +35,9 @@ export enum TasksActionTypes {
     UPDATE_TASK_SUCCESS = 'UPDATE_TASK_SUCCESS',
     UPDATE_TASK_FAILED = 'UPDATE_TASK_FAILED',
     HIDE_EMPTY_TASKS = 'HIDE_EMPTY_TASKS',
-    BACKUP_TASK = 'BACKUP_TASK',
-    BACKUP_TASK_SUCCESS = 'BACKUP_TASK_SUCCESS',
-    BACKUP_TASK_FAILED = 'BACKUP_TASK_FAILED',
+    EXPORT_TASK = 'EXPORT_TASK',
+    EXPORT_TASK_SUCCESS = 'EXPORT_TASK_SUCCESS',
+    EXPORT_TASK_FAILED = 'EXPORT_TASK_FAILED',
     IMPORT_TASK = 'IMPORT_TASK',
     IMPORT_TASK_SUCCESS = 'IMPORT_TASK_SUCCESS',
     IMPORT_TASK_FAILED = 'IMPORT_TASK_FAILED',
@@ -223,18 +223,16 @@ function importTask(): AnyAction {
     const action = {
         type: TasksActionTypes.IMPORT_TASK,
         payload: {},
-        importing: true,
     };
 
     return action;
 }
 
-function importTaskSuccess(taskId: number): AnyAction {
+function importTaskSuccess(task: any): AnyAction {
     const action = {
         type: TasksActionTypes.IMPORT_TASK_SUCCESS,
         payload: {
-            taskId,
-            importing: false,
+            task,
         },
     };
 
@@ -246,21 +244,17 @@ function importTaskFailed(error: any): AnyAction {
         type: TasksActionTypes.IMPORT_TASK_FAILED,
         payload: {
             error,
-            importing: false,
         },
     };
 
     return action;
 }
 
-export function importTaskAsync(
-    file: File,
-): ThunkAction<Promise<void>, {}, {}, AnyAction> {
+export function importTaskAsync(file: File): ThunkAction<Promise<void>, {}, {}, AnyAction> {
     return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
         try {
             dispatch(importTask());
-            let taskInstance = new cvat.classes.Task({});
-            taskInstance = await taskInstance.import(file);
+            const taskInstance = await cvat.classes.Task.import(file);
             dispatch(importTaskSuccess(taskInstance));
         } catch (error) {
             dispatch(importTaskFailed(error));
@@ -322,9 +316,9 @@ export function exportDatasetAsync(task: any, exporter: any): ThunkAction<Promis
     };
 }
 
-function backupTask(taskID: number): AnyAction {
+function exportTask(taskID: number): AnyAction {
     const action = {
-        type: TasksActionTypes.BACKUP_TASK,
+        type: TasksActionTypes.EXPORT_TASK,
         payload: {
             taskID,
         },
@@ -333,9 +327,9 @@ function backupTask(taskID: number): AnyAction {
     return action;
 }
 
-function backupTaskSuccess(taskID: any): AnyAction {
+function exportTaskSuccess(taskID: number): AnyAction {
     const action = {
-        type: TasksActionTypes.BACKUP_TASK_SUCCESS,
+        type: TasksActionTypes.EXPORT_TASK_SUCCESS,
         payload: {
             taskID,
         },
@@ -344,9 +338,9 @@ function backupTaskSuccess(taskID: any): AnyAction {
     return action;
 }
 
-function backupTaskFailed(taskID: any, error: any): AnyAction {
+function exportTaskFailed(taskID: number, error: Error): AnyAction {
     const action = {
-        type: TasksActionTypes.BACKUP_TASK_FAILED,
+        type: TasksActionTypes.EXPORT_TASK_FAILED,
         payload: {
             taskID,
             error,
@@ -356,20 +350,20 @@ function backupTaskFailed(taskID: any, error: any): AnyAction {
     return action;
 }
 
-export function backupTaskAsync(taskInstance: any): ThunkAction<Promise<void>, {}, {}, AnyAction> {
+export function exportTaskAsync(taskInstance: any): ThunkAction<Promise<void>, {}, {}, AnyAction> {
     return async (dispatch: ActionCreator<Dispatch>): Promise<void> => {
-        dispatch(backupTask(taskInstance.id));
+        dispatch(exportTask(taskInstance.id));
 
         try {
-            const url = await taskInstance.backup();
+            const url = await taskInstance.export();
             const downloadAnchor = window.document.getElementById('downloadAnchor') as HTMLAnchorElement;
             downloadAnchor.href = url;
             downloadAnchor.click();
         } catch (error) {
-            dispatch(backupTaskFailed(taskInstance.id, error));
+            dispatch(exportTaskFailed(taskInstance.id, error));
         }
 
-        dispatch(backupTaskSuccess(taskInstance.id));
+        dispatch(exportTaskSuccess(taskInstance.id));
     };
 }
 
diff --git a/cvat-ui/src/components/actions-menu/actions-menu.tsx b/cvat-ui/src/components/actions-menu/actions-menu.tsx
index c56fd84e3dd..47a13b727f8 100644
--- a/cvat-ui/src/components/actions-menu/actions-menu.tsx
+++ b/cvat-ui/src/components/actions-menu/actions-menu.tsx
@@ -26,7 +26,7 @@ interface Props {
     inferenceIsActive: boolean;
     taskDimension: DimensionType;
     onClickMenu: (params: MenuInfo, file?: File) => void;
-    backupIsActive: boolean;
+    exportIsActive: boolean;
 }
 
 export enum Actions {
@@ -36,7 +36,7 @@ export enum Actions {
     DELETE_TASK = 'delete_task',
     RUN_AUTO_ANNOTATION = 'run_auto_annotation',
     OPEN_BUG_TRACKER = 'open_bug_tracker',
-    BACKUP_TASK = 'backup_task',
+    EXPORT_TASK = 'export_task',
 }
 
 export default function ActionsMenuComponent(props: Props): JSX.Element {
@@ -52,7 +52,7 @@ export default function ActionsMenuComponent(props: Props): JSX.Element {
         exportActivities,
         loadActivity,
         taskDimension,
-        backupIsActive,
+        exportIsActive,
     } = props;
 
     let latestParams: MenuInfo | null = null;
@@ -131,9 +131,9 @@ export default function ActionsMenuComponent(props: Props): JSX.Element {
             <Menu.Item disabled={inferenceIsActive} key={Actions.RUN_AUTO_ANNOTATION}>
                 Automatic annotation
             </Menu.Item>
-            <Menu.Item key={Actions.BACKUP_TASK}>
-                {backupIsActive && <LoadingOutlined style={{ marginLeft: 10 }} />}
-                Backup Task
+            <Menu.Item key={Actions.EXPORT_TASK}>
+                {exportIsActive && <LoadingOutlined id='cvat-export-task-loading' />}
+                Export Task
             </Menu.Item>
             <hr />
             <Menu.Item key={Actions.DELETE_TASK}>Delete</Menu.Item>
diff --git a/cvat-ui/src/components/actions-menu/styles.scss b/cvat-ui/src/components/actions-menu/styles.scss
index ccb00306475..1b69092249a 100644
--- a/cvat-ui/src/components/actions-menu/styles.scss
+++ b/cvat-ui/src/components/actions-menu/styles.scss
@@ -48,3 +48,7 @@
 .cvat-menu-icon {
     transform: scale(0.5);
 }
+
+#cvat-export-task-loading {
+    margin-left: 10;
+}
diff --git a/cvat-ui/src/components/tasks-page/styles.scss b/cvat-ui/src/components/tasks-page/styles.scss
index 73ad1e575b4..7d934b34b38 100644
--- a/cvat-ui/src/components/tasks-page/styles.scss
+++ b/cvat-ui/src/components/tasks-page/styles.scss
@@ -157,3 +157,11 @@
 #cvat-create-task-button {
     padding: 0 30px;
 }
+
+#cvat-import-task-button {
+    padding: 0 30px;
+}
+
+#cvat-import-task-button-loading {
+    margin-left: 10;
+}
diff --git a/cvat-ui/src/components/tasks-page/top-bar.tsx b/cvat-ui/src/components/tasks-page/top-bar.tsx
index bba352ecd18..5b7a0291a32 100644
--- a/cvat-ui/src/components/tasks-page/top-bar.tsx
+++ b/cvat-ui/src/components/tasks-page/top-bar.tsx
@@ -5,12 +5,11 @@
 import React from 'react';
 import { useHistory } from 'react-router';
 import { Row, Col } from 'antd/lib/grid';
-import { PlusOutlined } from '@ant-design/icons';
+import { PlusOutlined, UploadOutlined, LoadingOutlined } from '@ant-design/icons';
 import Button from 'antd/lib/button';
 import Input from 'antd/lib/input';
 import Text from 'antd/lib/typography/Text';
 import Upload from 'antd/lib/upload';
-import { UploadOutlined, LoadingOutlined } from '@ant-design/icons';
 
 import SearchTooltip from 'components/search-tooltip/search-tooltip';
 
@@ -22,14 +21,16 @@ interface VisibleTopBarProps {
 }
 
 export default function TopBarComponent(props: VisibleTopBarProps): JSX.Element {
-    const { searchValue, onSearch, onFileUpload, taskImporting } = props;
+    const {
+        searchValue, onSearch, onFileUpload, taskImporting,
+    } = props;
 
     const history = useHistory();
 
     return (
         <>
-            <Row justify='center' align='middle'>
-                <Col md={11} lg={9} xl={8} xxl={7}>
+            <Row justify='center' align='middle' gutter={8}>
+                <Col md={8} lg={7} xl={6} xxl={5}>
                     <Text className='cvat-title'>Tasks</Text>
                     <SearchTooltip instance='task'>
                         <Input.Search
@@ -41,7 +42,7 @@ export default function TopBarComponent(props: VisibleTopBarProps): JSX.Element
                         />
                     </SearchTooltip>
                 </Col>
-                <Col md={{ span: 11 }} lg={{ span: 9 }} xl={{ span: 8 }} xxl={{ span: 7 }}>
+                <Col md={{ span: 8 }} lg={{ span: 7 }} xl={{ span: 6 }} xxl={{ span: 6 }}>
                     <Upload
                         accept='.zip'
                         multiple={false}
@@ -58,13 +59,12 @@ export default function TopBarComponent(props: VisibleTopBarProps): JSX.Element
                             disabled={taskImporting}
                             icon={<UploadOutlined />}
                         >
-
                             Import Task
-                            {taskImporting && <LoadingOutlined style={{ marginLeft: 10 }} />}
+                            {taskImporting && <LoadingOutlined id='cvat-import-task-button-loading' />}
                         </Button>
                     </Upload>
                 </Col>
-                <Col md={{ span: 11 }} lg={{ span: 9 }} xl={{ span: 8 }} xxl={{ span: 7 }}>
+                <Col md={{ span: 6 }} lg={{ span: 4 }} xl={{ span: 3 }} xxl={{ span: 3 }}>
                     <Button
                         size='large'
                         id='cvat-create-task-button'
diff --git a/cvat-ui/src/containers/actions-menu/actions-menu.tsx b/cvat-ui/src/containers/actions-menu/actions-menu.tsx
index 86d91f1c952..dae00261731 100644
--- a/cvat-ui/src/containers/actions-menu/actions-menu.tsx
+++ b/cvat-ui/src/containers/actions-menu/actions-menu.tsx
@@ -5,16 +5,19 @@
 import React from 'react';
 import { connect } from 'react-redux';
 
+import { MenuInfo } from 'rc-menu/lib/interface';
 import ActionsMenuComponent, { Actions } from 'components/actions-menu/actions-menu';
 import { CombinedState } from 'reducers/interfaces';
 
 import { modelsActions } from 'actions/models-actions';
 import {
-    dumpAnnotationsAsync, loadAnnotationsAsync, exportDatasetAsync, deleteTaskAsync,
-    backupTaskAsync,
+    dumpAnnotationsAsync,
+    loadAnnotationsAsync,
+    exportDatasetAsync,
+    deleteTaskAsync,
+    exportTaskAsync,
 } from 'actions/tasks-actions';
 // eslint-disable-next-line import/no-extraneous-dependencies
-import { MenuInfo } from 'rc-menu/lib/interface';
 
 interface OwnProps {
     taskInstance: any;
@@ -26,7 +29,7 @@ interface StateToProps {
     dumpActivities: string[] | null;
     exportActivities: string[] | null;
     inferenceIsActive: boolean;
-    backupIsActive: boolean;
+    exportIsActive: boolean;
 }
 
 interface DispatchToProps {
@@ -35,7 +38,7 @@ interface DispatchToProps {
     exportDataset: (taskInstance: any, exporter: any) => void;
     deleteTask: (taskInstance: any) => void;
     openRunModelWindow: (taskInstance: any) => void;
-    backupTask: (taskInstance: any) => void;
+    exportTask: (taskInstance: any) => void;
 }
 
 function mapStateToProps(state: CombinedState, own: OwnProps): StateToProps {
@@ -46,7 +49,9 @@ function mapStateToProps(state: CombinedState, own: OwnProps): StateToProps {
     const {
         formats: { annotationFormats },
         tasks: {
-            activities: { dumps, loads, exports: activeExports, backups },
+            activities: {
+                dumps, loads, exports: activeExports, backups,
+            },
         },
     } = state;
 
@@ -56,7 +61,7 @@ function mapStateToProps(state: CombinedState, own: OwnProps): StateToProps {
         loadActivity: tid in loads ? loads[tid] : null,
         annotationFormats,
         inferenceIsActive: tid in state.models.inferences,
-        backupIsActive: tid in backups,
+        exportIsActive: tid in backups,
     };
 }
 
@@ -77,8 +82,8 @@ function mapDispatchToProps(dispatch: any): DispatchToProps {
         openRunModelWindow: (taskInstance: any): void => {
             dispatch(modelsActions.showRunModelDialog(taskInstance));
         },
-        backupTask: (taskInstance: any): void => {
-            dispatch(backupTaskAsync(taskInstance));
+        exportTask: (taskInstance: any): void => {
+            dispatch(exportTaskAsync(taskInstance));
         },
     };
 }
@@ -91,14 +96,14 @@ function ActionsMenuContainer(props: OwnProps & StateToProps & DispatchToProps):
         dumpActivities,
         exportActivities,
         inferenceIsActive,
-        backupIsActive,
+        exportIsActive,
 
         loadAnnotations,
         dumpAnnotations,
         exportDataset,
         deleteTask,
         openRunModelWindow,
-        backupTask,
+        exportTask,
     } = props;
 
     function onClickMenu(params: MenuInfo, file?: File): void {
@@ -132,8 +137,8 @@ function ActionsMenuContainer(props: OwnProps & StateToProps & DispatchToProps):
                 window.open(`${taskInstance.bugTracker}`, '_blank');
             } else if (action === Actions.RUN_AUTO_ANNOTATION) {
                 openRunModelWindow(taskInstance);
-            } else if (action === Actions.BACKUP_TASK) {
-                backupTask(taskInstance);
+            } else if (action === Actions.EXPORT_TASK) {
+                exportTask(taskInstance);
             }
         }
     }
@@ -151,7 +156,7 @@ function ActionsMenuContainer(props: OwnProps & StateToProps & DispatchToProps):
             inferenceIsActive={inferenceIsActive}
             onClickMenu={onClickMenu}
             taskDimension={taskInstance.dimension}
-            backupIsActive={backupIsActive}
+            exportIsActive={exportIsActive}
         />
     );
 }
diff --git a/cvat-ui/src/containers/tasks-page/tasks-page.tsx b/cvat-ui/src/containers/tasks-page/tasks-page.tsx
index d38a81cdc9a..ba5780b6595 100644
--- a/cvat-ui/src/containers/tasks-page/tasks-page.tsx
+++ b/cvat-ui/src/containers/tasks-page/tasks-page.tsx
@@ -1,4 +1,4 @@
-// Copyright (C) 2020 Intel Corporation
+// Copyright (C) 2021 Intel Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -33,9 +33,9 @@ function mapStateToProps(state: CombinedState): StateToProps {
         gettingQuery: tasks.gettingQuery,
         numberOfTasks: state.tasks.count,
         numberOfVisibleTasks: state.tasks.current.length,
-        numberOfHiddenTasks: tasks.hideEmpty
-            ? tasks.current.filter((task: Task): boolean => !task.instance.jobs.length).length
-            : 0,
+        numberOfHiddenTasks: tasks.hideEmpty ?
+            tasks.current.filter((task: Task): boolean => !task.instance.jobs.length).length :
+            0,
         taskImporting: state.tasks.importing,
     };
 }
diff --git a/cvat-ui/src/reducers/interfaces.ts b/cvat-ui/src/reducers/interfaces.ts
index acfa2e2ebd7..cd466b04f61 100644
--- a/cvat-ui/src/reducers/interfaces.ts
+++ b/cvat-ui/src/reducers/interfaces.ts
@@ -101,7 +101,7 @@ export interface TasksState {
         };
         backups: {
             [tid: number]: boolean;
-        }
+        };
     };
 }
 
@@ -245,9 +245,11 @@ export interface NotificationsState {
             updating: null | ErrorState;
             dumping: null | ErrorState;
             loading: null | ErrorState;
-            exporting: null | ErrorState;
+            exportingAsDataset: null | ErrorState;
             deleting: null | ErrorState;
             creating: null | ErrorState;
+            exporting: null | ErrorState;
+            importing: null | ErrorState;
         };
         formats: {
             fetching: null | ErrorState;
@@ -309,6 +311,7 @@ export interface NotificationsState {
     messages: {
         tasks: {
             loadingDone: string;
+            importingDone: string;
         };
         models: {
             inferenceDone: string;
diff --git a/cvat-ui/src/reducers/notifications-reducer.ts b/cvat-ui/src/reducers/notifications-reducer.ts
index 4df4f446185..f9e7d7d3f28 100644
--- a/cvat-ui/src/reducers/notifications-reducer.ts
+++ b/cvat-ui/src/reducers/notifications-reducer.ts
@@ -42,9 +42,11 @@ const defaultState: NotificationsState = {
             updating: null,
             dumping: null,
             loading: null,
-            exporting: null,
+            exportingAsDataset: null,
             deleting: null,
             creating: null,
+            exporting: null,
+            importing: null,
         },
         formats: {
             fetching: null,
@@ -106,6 +108,7 @@ const defaultState: NotificationsState = {
     messages: {
         tasks: {
             loadingDone: '',
+            importingDone: '',
         },
         models: {
             inferenceDone: '',
@@ -307,7 +310,7 @@ export default function (state = defaultState, action: AnyAction): Notifications
                     ...state.errors,
                     tasks: {
                         ...state.errors.tasks,
-                        exporting: {
+                        exportingAsDataset: {
                             message:
                                 'Could not export dataset for the ' +
                                 `<a href="/tasks/${taskID}" target="_blank">task ${taskID}</a>`,
@@ -436,6 +439,49 @@ export default function (state = defaultState, action: AnyAction): Notifications
                 },
             };
         }
+        case TasksActionTypes.EXPORT_TASK_FAILED: {
+            return {
+                ...state,
+                errors: {
+                    ...state.errors,
+                    tasks: {
+                        ...state.errors.tasks,
+                        exporting: {
+                            message: 'Could not export the task',
+                            reason: action.payload.error.toString(),
+                        },
+                    },
+                },
+            };
+        }
+        case TasksActionTypes.IMPORT_TASK_FAILED: {
+            return {
+                ...state,
+                errors: {
+                    ...state.errors,
+                    tasks: {
+                        ...state.errors.tasks,
+                        importing: {
+                            message: 'Could not import the task',
+                            reason: action.payload.error.toString(),
+                        },
+                    },
+                },
+            };
+        }
+        case TasksActionTypes.IMPORT_TASK_SUCCESS: {
+            const taskID = action.payload.task.id;
+            return {
+                ...state,
+                messages: {
+                    ...state.messages,
+                    tasks: {
+                        ...state.messages.tasks,
+                        importingDone: `Task has been imported succesfully <a href="/tasks/${taskID}">Open task</a>`,
+                    },
+                },
+            };
+        }
         case ProjectsActionTypes.GET_PROJECTS_FAILED: {
             return {
                 ...state,
diff --git a/cvat-ui/src/reducers/tasks-reducer.ts b/cvat-ui/src/reducers/tasks-reducer.ts
index 44e6a2ee1ad..df9f9a1de50 100644
--- a/cvat-ui/src/reducers/tasks-reducer.ts
+++ b/cvat-ui/src/reducers/tasks-reducer.ts
@@ -1,8 +1,9 @@
-// Copyright (C) 2020 Intel Corporation
+// Copyright (C) 2021 Intel Corporation
 //
 // SPDX-License-Identifier: MIT
 
 import { AnyAction } from 'redux';
+import { omit } from 'lodash';
 import { BoundariesActionTypes } from 'actions/boundaries-actions';
 import { TasksActionTypes } from 'actions/tasks-actions';
 import { AuthActionTypes } from 'actions/auth-actions';
@@ -240,24 +241,23 @@ export default (state: TasksState = defaultState, action: AnyAction): TasksState
                 },
             };
         }
-        case TasksActionTypes.BACKUP_TASK: {
+        case TasksActionTypes.EXPORT_TASK: {
             const { taskID } = action.payload;
             const { backups } = state.activities;
 
-            backups[taskID] = true;
-
             return {
                 ...state,
                 activities: {
                     ...state.activities,
                     backups: {
                         ...backups,
+                        ...Object.fromEntries([[taskID, true]]),
                     },
                 },
             };
         }
-        case TasksActionTypes.BACKUP_TASK_FAILED:
-        case TasksActionTypes.BACKUP_TASK_SUCCESS: {
+        case TasksActionTypes.EXPORT_TASK_FAILED:
+        case TasksActionTypes.EXPORT_TASK_SUCCESS: {
             const { taskID } = action.payload;
             const { backups } = state.activities;
 
@@ -267,9 +267,7 @@ export default (state: TasksState = defaultState, action: AnyAction): TasksState
                 ...state,
                 activities: {
                     ...state.activities,
-                    backups: {
-                        ...backups,
-                    },
+                    backups: omit(backups, [taskID]),
                 },
             };
         }
diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index e3f67a5a1ce..c30536d8eda 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -8,9 +8,11 @@
 
 import cvat.apps.dataset_manager as dm
 from cvat.apps.engine import models
+from cvat.apps.engine.log import slogger
 from cvat.apps.engine.serializers import (AttributeSerializer, DataSerializer,
                                           FrameMetaSerializer,
                                           LabeledDataSerializer,
+                                          RelatedFileSerializer,
                                           SegmentSerializer,
                                           SimpleJobSerializer, TaskSerializer)
 from cvat.apps.engine.utils import av_scan_paths
@@ -30,10 +32,10 @@ def __init__(self, pk, version=Version.V1):
         self._db_data = self._db_task.data
         self._version = version
 
-    def _write_directory(self, source_dir, zip_object, target_dir, exclude=None):
-        exclude = [] if exclude is None else exclude
+    def _write_directory(self, source_dir, zip_object, target_dir, recursive=True):
         for root, dirs, files in os.walk(source_dir, topdown=True):
-            dirs[:] = [d for d in dirs if d not in exclude]
+            if not recursive:
+                dirs.clear()
             for filename in files:
                 file_path = os.path.join(root, filename)
                 arcname = os.path.normpath(os.path.join(target_dir, os.path.relpath(root, source_dir), filename))
@@ -41,65 +43,111 @@ def _write_directory(self, source_dir, zip_object, target_dir, exclude=None):
 
     def _write_data(self, zip_object):
         data_dir = self._db_data.get_data_dirname()
-        self._write_directory(source_dir=data_dir, zip_object=zip_object, target_dir=self.DATA_DIRNAME)
+        self._write_directory(
+            source_dir=data_dir,
+            zip_object=zip_object,
+            target_dir=self.DATA_DIRNAME,
+        )
 
     def _write_task(self, zip_object):
         task_dir = self._db_task.get_task_dirname()
-        self._write_directory(source_dir=task_dir, zip_object=zip_object, target_dir=self.TASK_DIRNAME, exclude=('artifacts', 'export_cache', 'logs'))
+        self._write_directory(
+            source_dir=task_dir,
+            zip_object=zip_object,
+            target_dir=self.TASK_DIRNAME,
+            recursive=False,
+        )
 
     def _write_manifest(self, zip_object):
-        task_serializer = TaskSerializer(self._db_task)
-        task_serializer.fields.pop('url')
-        task_serializer.fields['owner'].fields.pop('url')
-        task_serializer.fields.pop('segments')
-        segments = []
-        for db_segment in self._db_task.segment_set.all():
-            jobs = []
-            for db_job in db_segment.job_set.all():
-                job_serializer = SimpleJobSerializer(db_job)
-                job_serializer.fields.pop('url')
-                jobs.append(job_serializer.data)
-            segment_serailizer = SegmentSerializer(db_segment)
-            segment_serailizer.fields.pop('jobs')
-            segment = segment_serailizer.data
-            segment['jobs'] = jobs
-            segments.append(segment)
-
-        data_serializer = DataSerializer(self._db_data)
-        if hasattr(self._db_task.data, 'video'):
-            media = [self._db_task.data.video]
-        else:
-            media = list(self._db_task.data.images.order_by('frame'))
-
-        frame_meta = [{
-            'width': item.width,
-            'height': item.height,
-            'name': item.path,
-        } for item in media]
-        frame_meta_serializer = FrameMetaSerializer(data=frame_meta, many=True)
-
-        job_annotations = {}
-        for db_segment in self._db_task.segment_set.all():
-            for db_job in db_segment.job_set.all():
-                annotations = dm.task.get_job_data(db_job.id)
-                annotations_serializer = LabeledDataSerializer(data=annotations)
-                annotations_serializer.is_valid(raise_exception=True)
-                job_annotations[db_job.id] = annotations_serializer.data
-
-        manifest = task_serializer.data
+        def serialize_task():
+            task_serializer = TaskSerializer(self._db_task)
+            task_serializer.fields.pop('url')
+            task_serializer.fields['owner'].fields.pop('url')
+            task_serializer.fields.pop('segments')
+
+            return task_serializer.data
+
+        def serialize_segmetnts():
+            def serialize_annotations(segments):
+                job_annotations = {}
+                for db_segment in self._db_task.segment_set.all():
+                    for db_job in db_segment.job_set.all():
+                        annotations = dm.task.get_job_data(db_job.id)
+                        annotations_serializer = LabeledDataSerializer(data=annotations)
+                        annotations_serializer.is_valid(raise_exception=True)
+                        job_annotations[db_job.id] = annotations_serializer.data
+
+                for segment in segments:
+                    for job in segment['jobs']:
+                        job['annotations'] = job_annotations[job['id']]
+
+                return segments
+
+            segments = []
+            for db_segment in self._db_task.segment_set.all():
+                jobs = []
+                for db_job in db_segment.job_set.all():
+                    job_serializer = SimpleJobSerializer(db_job)
+                    job_serializer.fields.pop('url')
+                    jobs.append(job_serializer.data)
+                segment_serailizer = SegmentSerializer(db_segment)
+                segment_serailizer.fields.pop('jobs')
+                segment = segment_serailizer.data
+                segment['jobs'] = jobs
+                segments.append(segment)
+
+            return serialize_annotations(segments)
+
+        def serialize_data():
+            def serialize_related_files(image):
+                related_files_serializer = RelatedFileSerializer(image.related_files.all(), many=True)
+                related_files = related_files_serializer.data
+                for f in related_files:
+                    f['path'] = os.path.relpath(f['path'], image.data.get_upload_dirname())
+
+                return related_files
+
+            def serialize_frames():
+                if hasattr(self._db_task.data, 'video'):
+                    media = [self._db_task.data.video]
+                else:
+                    media = list(self._db_task.data.images.order_by('frame'))
+
+                frame_meta = []
+                for item in media:
+                    frame = {
+                        'width': item.width,
+                        'height': item.height,
+                        'name': item.path,
+                    }
+
+                    frame_meta_serializer = FrameMetaSerializer(data=frame)
+                    frame_meta_serializer.is_valid(raise_exception=True)
+                    frame = frame_meta_serializer.data
+
+                    if self._db_task.dimension == models.DimensionType.DIM_3D:
+                        frame['related_files'] = serialize_related_files(item)
+
+                    frame_meta.append(frame)
+
+                return frame_meta
+
+            data_serializer = DataSerializer(self._db_data)
+
+            data = data_serializer.data
+            data['frames'] = serialize_frames()
+
+            return data
+
+        manifest = serialize_task()
         manifest['version'] = self._version.value
-        manifest['data'] = data_serializer.data
-        frame_meta_serializer.is_valid(raise_exception=True)
-        manifest['data']['frames'] = frame_meta_serializer.data
-        for segment in segments:
-            for job in segment['jobs']:
-                job['annotations'] = job_annotations[job['id']]
-        manifest['segments'] = segments
+        manifest['data'] = serialize_data()
+        manifest['segments'] = serialize_segmetnts()
 
         zip_object.writestr(self.MANIFEST_FILENAME, data=JSONRenderer().render(manifest))
 
     def export_to(self, filename):
-        with ZipFile(filename, 'x') as output_file:
+        with ZipFile(filename, 'w') as output_file:
             self._write_data(output_file)
             self._write_task(output_file)
             self._write_manifest(output_file)
@@ -129,12 +177,14 @@ def _read_version(self):
             raise ValueError('{} version is not supported'.format(version))
 
     def _prepare_meta(self, allowed_keys, meta):
-        for key in list(meta.keys()):
-            if key not in allowed_keys:
-                del meta[key]
+        keys_to_drop = set(meta.keys()) - allowed_keys
+        logger = slogger.task[self._db_task.id] if hasattr(self, '_db_task') else slogger.glob
+        logger.warning('the following keys are dropped {}'.format(keys_to_drop))
+        for key in keys_to_drop:
+            del meta[key]
 
     def _prepare_task_meta(self, task):
-        allowed_fields = (
+        allowed_fields = {
             'name',
             'mode',
             'bug_tracker',
@@ -143,12 +193,12 @@ def _prepare_task_meta(self, task):
             'status',
             'dimension',
             'subset',
-        )
+        }
 
         self._prepare_meta(allowed_fields, task)
 
     def _prepare_data_meta(self, data):
-        allowed_fields = (
+        allowed_fields = {
             'chunk_size',
             'size',
             'image_quality',
@@ -159,26 +209,26 @@ def _prepare_data_meta(self, data):
             'original_chunk_type',
             'storage_method',
             'storage',
-        )
+        }
         self._prepare_meta(allowed_fields, data)
         if not data['frame_filter']:
             data.pop('frame_filter')
 
     def _prepare_segment_meta(self, segments):
-        allowed_fields = (
+        allowed_fields = {
             'start_frame',
             'stop_frame',
-        )
+        }
         self._prepare_meta(allowed_fields, segments)
 
     def _prepare_job_meta(self, jobs):
-        allowed_fields = (
+        allowed_fields = {
             'status',
-        )
+        }
         self._prepare_meta(allowed_fields, jobs)
 
     def _prepare_annotations(self, annotations):
-        allowed_fields = (
+        allowed_fields = {
             'label_id',
             'type',
             'occluded',
@@ -189,7 +239,7 @@ def _prepare_annotations(self, annotations):
             'source',
             'attributes',
             'shapes',
-        )
+        }
 
         for tag in annotations['tags']:
             self._prepare_meta(allowed_fields, tag)
@@ -198,6 +248,12 @@ def _prepare_annotations(self, annotations):
         for track in annotations['tracks']:
             self._prepare_meta(allowed_fields, track)
 
+    @staticmethod
+    def _prepare_dirs(filepath):
+        target_dir = os.path.dirname(filepath)
+        if not os.path.exists(target_dir):
+            os.makedirs(target_dir)
+
     def _create_labels(self, db_task, labels):
         label_mapping = {}
         attribute_mapping = {}
@@ -210,7 +266,6 @@ def _create_labels(self, db_task, labels):
 
             for attribute in attributes:
                 attribute_id = attribute.pop('id')
-                # attribute['label_id'] = db_label.id
                 attribute_serializer = AttributeSerializer(data=attribute)
                 attribute_serializer.is_valid(raise_exception=True)
                 db_attribute = attribute_serializer.save(label=db_label)
@@ -238,7 +293,6 @@ def update_ids(objects):
                 track_shape.pop('id')
                 for attribute in track_shape['attributes']:
                     attribute['spec_id'] = attributes_mapping[attribute['spec_id']]
-                    attribute.pop('id')
 
     def _create_annotations(self, db_job, labels_mapping, attributes_mapping, annotations):
         self._update_annotations(labels_mapping, attributes_mapping, annotations)
@@ -266,17 +320,55 @@ def _create_data(self, data):
         return db_data
 
     def _create_frames(self, db_data, frames):
-        for idx, frame in enumerate(frames):
+        def _prepare_frame(frame, frame_number=None):
             frame['data'] = db_data
             frame['path'] = frame.pop('name')
-            frame['frame'] = idx
+            if frame_number is not None:
+                frame['frame'] = frame_number
+
+            return frame
+
+        def _prepare_related_file(related_file, rf_id):
+            related_file['data'] = db_data
+            related_file.pop('primary_image')
+            related_file.pop('id')
+            related_file['primary_image_id'] = rf_id
+            related_file['path'] = os.path.join(db_data.get_upload_dirname(), related_file['path'])
+
+            return related_file
 
         if self._db_task.mode == 'annotation':
-            if self._db_task.dimension == models.DimensionType.DIM_2D:
-                models.Image.objects.bulk_create(models.Image(**frame) for frame in frames)
-            # else: TODO
+            db_frames = []
+            db_related_files = []
+            for idx, frame in enumerate(frames):
+                related_files = frame.pop('related_files', [])
+                frame = _prepare_frame(frame, idx)
+
+                for related_file in related_files:
+                    related_file = _prepare_related_file(related_file, len(db_frames))
+                    db_related_file = models.RelatedFile(**related_file)
+                    db_related_files.append(db_related_file)
+
+                db_frames.append(models.Image(**frame))
+
+            db_frames = dm.task.bulk_create(
+                db_model=models.Image,
+                objects=db_frames,
+                flt_param={'data_id': db_data.id},
+            )
+
+            for db_related_file in db_related_files:
+                db_related_file.primary_image = db_frames[db_related_file.primary_image_id]
+
+            dm.task.bulk_create(
+                db_model=models.RelatedFile,
+                objects=db_related_files,
+                flt_param={}
+            )
+
         else:
-            models.Video.objects.create(**frames[0])
+            frame = _prepare_frame(frames[0])
+            models.Video.objects.create(**frame)
 
     def _import_task(self):
         data = self._manifest.pop('data')
@@ -284,46 +376,43 @@ def _import_task(self):
         labels = self._manifest.pop('labels')
         self._segments = self._manifest.pop('segments')
 
-        db_data = self._create_data(data)
-
         self._prepare_task_meta(self._manifest)
-        self._manifest['data_id'] = db_data.id
+        self._db_task = models.Task.objects.create(**self._manifest)
+        task_path = self._db_task.get_task_dirname()
+        if os.path.isdir(task_path):
+            shutil.rmtree(task_path)
+
+        os.makedirs(self._db_task.get_task_logs_dirname())
+        os.makedirs(self._db_task.get_task_artifacts_dirname())
 
-        self._db_task = models.Task.objects.create(data=db_data, **self._manifest)
+        db_data = self._create_data(data)
+        self._db_task.data = db_data
+        self._db_task.save()
 
-        try:
-            self._create_frames(db_data, frames)
-        except Exception as e:
-            print(e)
+        self._create_frames(db_data, frames)
 
         self._labels_mapping, self._attributes_mapping = self._create_labels(self._db_task, labels)
 
         return self._db_task.id
 
     def _import_annotations(self):
-        if not hasattr(self, '_labels_mapping') or not hasattr(self, '_attributes_mapping') or not hasattr(self, '_segments'):
-            raise Exception('Call import_task() first')
-
         self._create_segments(self._db_task, self._labels_mapping, self._attributes_mapping, self._segments)
 
     def _import_media(self):
-        task_path = self._db_task.get_task_dirname()
-        if os.path.isdir(task_path):
-            shutil.rmtree(task_path)
-
-        os.makedirs(self._db_task.get_task_logs_dirname())
-        os.makedirs(self._db_task.get_task_artifacts_dirname())
-
         data_path = self._db_task.data.get_data_dirname()
 
         with ZipFile(self._filename, 'r') as input_file:
             for f in input_file.namelist():
                 if f.startswith(self.DATA_DIRNAME + os.path.sep):
-                    with open(os.path.join(data_path, os.path.relpath(f, self.DATA_DIRNAME)), "wb") as target_file:
-                        target_file.write(input_file.read(f))
+                    target_file = os.path.join(data_path, os.path.relpath(f, self.DATA_DIRNAME))
+                    self._prepare_dirs(target_file)
+                    with open(target_file, "wb") as out:
+                        out.write(input_file.read(f))
                 elif f.startswith(self.TASK_DIRNAME + os.path.sep):
-                    with open(os.path.join(task_path, os.path.relpath(f, self.TASK_DIRNAME)), "wb") as target_file:
-                        target_file.write(input_file.read(f))
+                    target_file = os.path.join(task_path, os.path.relpath(f, self.TASK_DIRNAME))
+                    self._prepare_dirs(target_file)
+                    with open(target_file, "wb") as out:
+                        out.write(input_file.read(f))
 
     def import_task(self):
         self._import_task()
@@ -332,6 +421,7 @@ def import_task(self):
         return self._db_task
 
 
+
 def import_task(filename):
     av_scan_paths(filename)
     task_importer = TaskImporter(filename)
diff --git a/cvat/apps/engine/serializers.py b/cvat/apps/engine/serializers.py
index bfe52a6964e..6bab6dd99d3 100644
--- a/cvat/apps/engine/serializers.py
+++ b/cvat/apps/engine/serializers.py
@@ -690,3 +690,10 @@ def create(self, validated_data):
                 models.Comment.objects.create(**comment)
 
         return db_review
+
+class RelatedFileSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = models.RelatedFile
+        fields = '__all__'
+        read_only_fields = ('path',)
\ No newline at end of file

From c2801bfd57aa8ff19e5c0fa4d8495bd1cd8fcb03 Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Fri, 9 Apr 2021 15:07:27 +0300
Subject: [PATCH 05/19] updated license headers

---
 cvat-core/src/session.js              | 4 ++--
 cvat-ui/src/reducers/tasks-reducer.ts | 2 +-
 cvat/apps/engine/backup.py            | 4 ++++
 cvat/apps/engine/serializers.py       | 2 +-
 cvat/apps/engine/views.py             | 2 +-
 5 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/cvat-core/src/session.js b/cvat-core/src/session.js
index 7c788805119..dd412a34243 100644
--- a/cvat-core/src/session.js
+++ b/cvat-core/src/session.js
@@ -1939,12 +1939,12 @@
         return result;
     };
 
-    Job.prototype.annotations.import.implementation = async function (data) {
+    Job.prototype.annotations.import.implementation = function (data) {
         const result = importAnnotations(this, data);
         return result;
     };
 
-    Job.prototype.annotations.export.implementation = async function () {
+    Job.prototype.annotations.export.implementation = function () {
         const result = exportAnnotations(this);
         return result;
     };
diff --git a/cvat-ui/src/reducers/tasks-reducer.ts b/cvat-ui/src/reducers/tasks-reducer.ts
index df9f9a1de50..c1666545571 100644
--- a/cvat-ui/src/reducers/tasks-reducer.ts
+++ b/cvat-ui/src/reducers/tasks-reducer.ts
@@ -1,4 +1,4 @@
-// Copyright (C) 2021 Intel Corporation
+// Copyright (C) 2020-2021 Intel Corporation
 //
 // SPDX-License-Identifier: MIT
 
diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index c30536d8eda..ea36b321fc9 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -1,3 +1,7 @@
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+
 import io
 import os
 from enum import Enum
diff --git a/cvat/apps/engine/serializers.py b/cvat/apps/engine/serializers.py
index df8e4819e5f..1a13d801689 100644
--- a/cvat/apps/engine/serializers.py
+++ b/cvat/apps/engine/serializers.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2019 Intel Corporation
+# Copyright (C) 2019-2021 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 
diff --git a/cvat/apps/engine/views.py b/cvat/apps/engine/views.py
index ebf34b3ad1f..3a3e2aff103 100644
--- a/cvat/apps/engine/views.py
+++ b/cvat/apps/engine/views.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2020 Intel Corporation
+# Copyright (C) 2018-2021 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 

From b11ed87f8143b185ee5095cf3fc4efde5a3f1a1b Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Fri, 9 Apr 2021 15:11:53 +0300
Subject: [PATCH 06/19] fix eslint issues

---
 cvat-ui/src/components/tasks-page/tasks-page.tsx | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/cvat-ui/src/components/tasks-page/tasks-page.tsx b/cvat-ui/src/components/tasks-page/tasks-page.tsx
index fd1bd3df092..9c429d8bf53 100644
--- a/cvat-ui/src/components/tasks-page/tasks-page.tsx
+++ b/cvat-ui/src/components/tasks-page/tasks-page.tsx
@@ -1,4 +1,4 @@
-// Copyright (C) 2020 Intel Corporation
+// Copyright (C) 2020-2021 Intel Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -83,7 +83,9 @@ class TasksPageComponent extends React.PureComponent<TasksPageProps & RouteCompo
     }
 
     public componentDidUpdate(prevProps: TasksPageProps & RouteComponentProps): void {
-        const { location, gettingQuery, tasksFetching, numberOfHiddenTasks, onGetTasks, hideEmptyTasks } = this.props;
+        const {
+            location, gettingQuery, tasksFetching, numberOfHiddenTasks, onGetTasks, hideEmptyTasks,
+        } = this.props;
 
         if (prevProps.location.search !== location.search) {
             // get new tasks if any query changes
@@ -188,7 +190,9 @@ class TasksPageComponent extends React.PureComponent<TasksPageProps & RouteCompo
     }
 
     public render(): JSX.Element {
-        const { tasksFetching, gettingQuery, numberOfVisibleTasks, onImportTask, taskImporting } = this.props;
+        const {
+            tasksFetching, gettingQuery, numberOfVisibleTasks, onImportTask, taskImporting,
+        } = this.props;
 
         if (tasksFetching) {
             return <Spin size='large' className='cvat-spinner' />;
@@ -201,7 +205,7 @@ class TasksPageComponent extends React.PureComponent<TasksPageProps & RouteCompo
                     searchValue={getSearchField(gettingQuery)}
                     onFileUpload={onImportTask}
                     taskImporting={taskImporting}
-                 />
+                />
                 {numberOfVisibleTasks ? (
                     <TaskListContainer onSwitchPage={this.handlePagination} />
                 ) : (

From e1cabf8ccfafa95d00bfa084f085ab05131b3747 Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Mon, 19 Apr 2021 13:18:01 +0300
Subject: [PATCH 07/19] fix comments

---
 cvat-core/src/server-proxy.js        | 10 +++++-----
 cvat-ui/src/actions/tasks-actions.ts |  3 +--
 cvat/apps/engine/task.py             |  8 ++------
 cvat/apps/engine/views.py            | 29 ++++++++--------------------
 utils/cli/core/core.py               |  4 +---
 utils/cli/core/definition.py         | 14 --------------
 6 files changed, 17 insertions(+), 51 deletions(-)

diff --git a/cvat-core/src/server-proxy.js b/cvat-core/src/server-proxy.js
index 30b9e4edbc6..628ea6cebe3 100644
--- a/cvat-core/src/server-proxy.js
+++ b/cvat-core/src/server-proxy.js
@@ -517,18 +517,18 @@
             async function importTask(file) {
                 const { backendAPI } = config;
 
-                let annotationData = new FormData();
-                annotationData.append('task_file', file);
+                let taskData = new FormData();
+                taskData.append('task_file', file);
 
                 return new Promise((resolve, reject) => {
                     async function request() {
                         try {
-                            const response = await Axios.post(`${backendAPI}/tasks?action=import`, annotationData, {
+                            const response = await Axios.post(`${backendAPI}/tasks?action=import`, taskData, {
                                 proxy: config.proxy,
                             });
                             if (response.status === 202) {
-                                annotationData = new FormData();
-                                annotationData.append('rq_id', response.data.rq_id);
+                                taskData = new FormData();
+                                taskData.append('rq_id', response.data.rq_id);
                                 setTimeout(request, 3000);
                             } else {
                                 const importedTask = await getTasks(`?id=${response.data.id}`);
diff --git a/cvat-ui/src/actions/tasks-actions.ts b/cvat-ui/src/actions/tasks-actions.ts
index f0ad77ac368..29a0eccc8dc 100644
--- a/cvat-ui/src/actions/tasks-actions.ts
+++ b/cvat-ui/src/actions/tasks-actions.ts
@@ -359,11 +359,10 @@ export function exportTaskAsync(taskInstance: any): ThunkAction<Promise<void>, {
             const downloadAnchor = window.document.getElementById('downloadAnchor') as HTMLAnchorElement;
             downloadAnchor.href = url;
             downloadAnchor.click();
+            dispatch(exportTaskSuccess(taskInstance.id));
         } catch (error) {
             dispatch(exportTaskFailed(taskInstance.id, error));
         }
-
-        dispatch(exportTaskSuccess(taskInstance.id));
     };
 }
 
diff --git a/cvat/apps/engine/task.py b/cvat/apps/engine/task.py
index 1616ab6af23..7d9032380e3 100644
--- a/cvat/apps/engine/task.py
+++ b/cvat/apps/engine/task.py
@@ -20,12 +20,8 @@
 
 from cvat.apps.engine import models
 from cvat.apps.engine.log import slogger
-from cvat.apps.engine.media_extractors import (MEDIA_TYPES, Mpeg4ChunkWriter,
-                                               Mpeg4CompressedChunkWriter,
-                                               ValidateDimension,
-                                               ZipChunkWriter,
-                                               ZipCompressedChunkWriter,
-                                               get_mime)
+from cvat.apps.engine.media_extractors import (MEDIA_TYPES, Mpeg4ChunkWriter, Mpeg4CompressedChunkWriter,
+    ValidateDimension, ZipChunkWriter, ZipCompressedChunkWriter, get_mime)
 from cvat.apps.engine.utils import av_scan_paths
 from utils.dataset_manifest import ImageManifestManager, VideoManifestManager
 from utils.dataset_manifest.core import VideoManifestValidator
diff --git a/cvat/apps/engine/views.py b/cvat/apps/engine/views.py
index 3a3e2aff103..86b5d47b6ab 100644
--- a/cvat/apps/engine/views.py
+++ b/cvat/apps/engine/views.py
@@ -42,27 +42,14 @@
 from cvat.apps.dataset_manager.serializers import DatasetFormatsSerializer
 from cvat.apps.engine.frame_provider import FrameProvider
 from cvat.apps.engine.models import (Comment, DimensionType, Image, Issue, Job,
-                                     Project, Review, ReviewStatus,
-                                     StatusChoice, StorageChoice,
-                                     StorageMethodChoice, Task)
-from cvat.apps.engine.serializers import (AboutSerializer,
-                                          AnnotationFileSerializer,
-                                          BasicUserSerializer,
-                                          CombinedIssueSerializer,
-                                          CombinedReviewSerializer,
-                                          CommentSerializer,
-                                          DataMetaSerializer, DataSerializer,
-                                          ExceptionSerializer,
-                                          FileInfoSerializer, IssueSerializer,
-                                          JobSerializer, LabeledDataSerializer,
-                                          LogEventSerializer,
-                                          PluginsSerializer,
-                                          ProjectSearchSerializer,
-                                          ProjectSerializer,
-                                          ProjectWithoutTaskSerializer,
-                                          ReviewSerializer, RqStatusSerializer,
-                                          TaskFileSerializer, TaskSerializer,
-                                          UserSerializer)
+    Project, Review, ReviewStatus, StatusChoice, StorageChoice,
+    StorageMethodChoice, Task)
+from cvat.apps.engine.serializers import (AboutSerializer, AnnotationFileSerializer, BasicUserSerializer,
+    CombinedIssueSerializer, CombinedReviewSerializer, CommentSerializer, DataMetaSerializer, DataSerializer,
+    ExceptionSerializer, FileInfoSerializer, IssueSerializer, JobSerializer, LabeledDataSerializer,
+    LogEventSerializer, PluginsSerializer, ProjectSearchSerializer, ProjectSerializer,
+    ProjectWithoutTaskSerializer, ReviewSerializer, RqStatusSerializer, TaskFileSerializer, TaskSerializer,
+    UserSerializer)
 from cvat.apps.engine.backup import import_task
 from cvat.apps.engine.utils import av_scan_paths
 from . import models, task
diff --git a/utils/cli/core/core.py b/utils/cli/core/core.py
index 314fd1cbf63..6f966ce732a 100644
--- a/utils/cli/core/core.py
+++ b/utils/cli/core/core.py
@@ -202,16 +202,14 @@ def tasks_export(self, task_id, filename, export_verification_period=3, **kwargs
         """ Export and download a whole task """
         url = self.api.tasks_id(task_id)
         export_url = url + '?action=export'
-        response = self.session.get(export_url)
-        response.raise_for_status()
 
         while True:
-            sleep(export_verification_period)
             response = self.session.get(export_url)
             response.raise_for_status()
             log.info('STATUS {}'.format(response.status_code))
             if response.status_code == 201:
                 break
+            sleep(export_verification_period)
 
         response = self.session.get(url + '?action=download')
         response.raise_for_status()
diff --git a/utils/cli/core/definition.py b/utils/cli/core/definition.py
index c4603f0bbb6..76ecfa1d2fe 100644
--- a/utils/cli/core/definition.py
+++ b/utils/cli/core/definition.py
@@ -309,13 +309,6 @@ def argparse(s):
     type=str,
     help='output file'
 )
-export_task_parser.add_argument(
-    '--export_verification_period',
-    default=3,
-    type=int,
-    help='''number of seconds to wait until checking
-            if the export of the task is completed'''
-)
 
 #######################################################################
 # Import task
@@ -330,10 +323,3 @@ def argparse(s):
     type=str,
     help='upload file'
 )
-import_task_parser.add_argument(
-    '--import_verification_period',
-    default=3,
-    type=int,
-    help='''number of seconds to wait until checking
-            if the import of the task is completed'''
-)

From 859271bec70ab5ea7f70ebc86f78c6f41957d695 Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Tue, 20 Apr 2021 06:39:48 +0300
Subject: [PATCH 08/19] fixed comments

---
 .../components/actions-menu/actions-menu.tsx  |   2 +-
 cvat/apps/documentation/backup_hld.md         |  57 ++++
 cvat/apps/engine/backup.py                    | 249 +++++++++---------
 cvat/apps/engine/frame_provider.py            |  10 +-
 cvat/apps/engine/tests/test_rest_api.py       | 131 ++++++++-
 5 files changed, 325 insertions(+), 124 deletions(-)
 create mode 100644 cvat/apps/documentation/backup_hld.md

diff --git a/cvat-ui/src/components/actions-menu/actions-menu.tsx b/cvat-ui/src/components/actions-menu/actions-menu.tsx
index 47a13b727f8..d43f20c9700 100644
--- a/cvat-ui/src/components/actions-menu/actions-menu.tsx
+++ b/cvat-ui/src/components/actions-menu/actions-menu.tsx
@@ -131,7 +131,7 @@ export default function ActionsMenuComponent(props: Props): JSX.Element {
             <Menu.Item disabled={inferenceIsActive} key={Actions.RUN_AUTO_ANNOTATION}>
                 Automatic annotation
             </Menu.Item>
-            <Menu.Item key={Actions.EXPORT_TASK}>
+            <Menu.Item key={Actions.EXPORT_TASK} disabled={exportIsActive}>
                 {exportIsActive && <LoadingOutlined id='cvat-export-task-loading' />}
                 Export Task
             </Menu.Item>
diff --git a/cvat/apps/documentation/backup_hld.md b/cvat/apps/documentation/backup_hld.md
new file mode 100644
index 00000000000..faf0c5829b9
--- /dev/null
+++ b/cvat/apps/documentation/backup_hld.md
@@ -0,0 +1,57 @@
+## Task and Project Import/Export functionality
+
+This document describes the high-level design for implementing import / export implementation for tasks and projects.
+
+API endpoints:
+
+- Import task
+
+  - endpoint: `/api/v1/tasks?action=import​`
+  - method: `POST`
+  - Content-Type: `multipart/form-data​`
+  - returns: json
+
+- Export task
+
+  - endpoint: `/api/v1/tasks/{id}?action=export​`
+  - method: `GET`
+  - returns: zip archive
+
+  The zip archive has the following structure:
+
+  ```
+   .
+   ├── data
+   │   ├── compressed
+   │   ├── original
+   │   ├── raw
+   │   │   ├── {user uploaded data}
+   │   │   ├── manifest.jsonl
+   ├── task.json
+   └── annotations.json
+  ```
+
+- Import project
+
+  - endpoint: `/api/v1/projects?action=import​`
+  - method: `POST`
+  - Content-Type: `multipart/form-data​`
+  - returns: json
+
+- Export project
+
+  - endpoint: `/api/v1/projects/<id>?action=export​`
+  - method: `GET`
+  - returns: zip archive
+
+  The zip archive has the following structure:
+
+  ```
+   .
+   ├── tasks
+   │   ├── task_1
+   │   ├── task_2
+   │   ├── ...
+   │   └── task_N
+   └── project.json
+  ```
diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index ea36b321fc9..938d5f25350 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -5,6 +5,7 @@
 import io
 import os
 from enum import Enum
+import shutil
 from zipfile import ZipFile
 
 from rest_framework.parsers import JSONParser
@@ -14,34 +15,113 @@
 from cvat.apps.engine import models
 from cvat.apps.engine.log import slogger
 from cvat.apps.engine.serializers import (AttributeSerializer, DataSerializer,
-                                          FrameMetaSerializer,
-                                          LabeledDataSerializer,
-                                          RelatedFileSerializer,
-                                          SegmentSerializer,
-                                          SimpleJobSerializer, TaskSerializer)
+    FrameMetaSerializer, LabeledDataSerializer, RelatedFileSerializer, SegmentSerializer,
+    SimpleJobSerializer, TaskSerializer)
 from cvat.apps.engine.utils import av_scan_paths
 
-
-class TaskExporter():
-    class Version(Enum):
+class Version(Enum):
         V1 = 'v1'
 
-    MANIFEST_FILENAME = 'manifest.json'
+class _TaskBackupBase():
+    MANIFEST_FILENAME = 'task.json'
+    ANNOTATIONS_FILENAME = 'annotations.json'
     DATA_DIRNAME = 'data'
     TASK_DIRNAME = 'task'
 
+    def _prepare_meta(self, allowed_keys, meta):
+        keys_to_drop = set(meta.keys()) - allowed_keys
+        logger = slogger.task[self._db_task.id] if hasattr(self, '_db_task') else slogger.glob
+        logger.warning('the following keys are dropped {}'.format(keys_to_drop))
+        for key in keys_to_drop:
+            del meta[key]
+
+        return meta
+
+    def _prepare_task_meta(self, task):
+        allowed_fields = {
+            'name',
+            'mode',
+            'bug_tracker',
+            'overlap',
+            'segment_size',
+            'status',
+            'dimension',
+            'subset',
+            'labels',
+        }
+
+        return self._prepare_meta(allowed_fields, task)
+
+    def _prepare_data_meta(self, data):
+        allowed_fields = {
+            'chunk_size',
+            'size',
+            'image_quality',
+            'start_frame',
+            'stop_frame',
+            'frame_filter',
+            'compressed_chunk_type',
+            'original_chunk_type',
+            'storage_method',
+            'storage',
+        }
+        self._prepare_meta(allowed_fields, data)
+        if not data['frame_filter']:
+            data.pop('frame_filter')
+        return data
+
+    def _prepare_segment_meta(self, segments):
+        allowed_fields = {
+            'start_frame',
+            'stop_frame',
+        }
+        return self._prepare_meta(allowed_fields, segments)
+
+    def _prepare_job_meta(self, jobs):
+        allowed_fields = {
+            'id',
+            'status',
+        }
+        return self._prepare_meta(allowed_fields, jobs)
+
+    def _prepare_annotations(self, annotations):
+        allowed_fields = {
+            'label_id',
+            'type',
+            'occluded',
+            'z_order',
+            'points',
+            'frame',
+            'group',
+            'source',
+            'attributes',
+            'shapes',
+        }
+
+        for tag in annotations['tags']:
+            self._prepare_meta(allowed_fields, tag)
+        for shape in annotations['shapes']:
+            self._prepare_meta(allowed_fields, shape)
+        for track in annotations['tracks']:
+            self._prepare_meta(allowed_fields, track)
+
+        return annotations
+
+class TaskExporter(_TaskBackupBase):
     def __init__(self, pk, version=Version.V1):
         self._db_task = models.Task.objects.prefetch_related('data__images').select_related('data__video').get(pk=pk)
         self._db_task.segment_set.all().prefetch_related('job_set')
         self._db_data = self._db_task.data
         self._version = version
 
-    def _write_directory(self, source_dir, zip_object, target_dir, recursive=True):
+    def _write_directory(self, source_dir, zip_object, target_dir, recursive=True, exclude_files=None):
         for root, dirs, files in os.walk(source_dir, topdown=True):
             if not recursive:
                 dirs.clear()
             for filename in files:
                 file_path = os.path.join(root, filename)
+                if exclude_files and file_path in exclude_files:
+                    continue
                 arcname = os.path.normpath(os.path.join(target_dir, os.path.relpath(root, source_dir), filename))
                 zip_object.write(filename=file_path, arcname=arcname)
 
@@ -51,6 +131,8 @@ def _write_data(self, zip_object):
             source_dir=data_dir,
             zip_object=zip_object,
             target_dir=self.DATA_DIRNAME,
+            exclude_files=tuple(os.path.join(data_dir, f) for f in \
+                ('preview.jpeg', os.path.join('raw', 'index.json'))),
         )
 
     def _write_task(self, zip_object):
@@ -66,41 +148,27 @@ def _write_manifest(self, zip_object):
         def serialize_task():
             task_serializer = TaskSerializer(self._db_task)
             task_serializer.fields.pop('url')
-            task_serializer.fields['owner'].fields.pop('url')
+            task_serializer.fields.pop('owner')
+            task_serializer.fields.pop('assignee')
             task_serializer.fields.pop('segments')
 
-            return task_serializer.data
+            return self._prepare_task_meta(task_serializer.data)
 
         def serialize_segmetnts():
-            def serialize_annotations(segments):
-                job_annotations = {}
-                for db_segment in self._db_task.segment_set.all():
-                    for db_job in db_segment.job_set.all():
-                        annotations = dm.task.get_job_data(db_job.id)
-                        annotations_serializer = LabeledDataSerializer(data=annotations)
-                        annotations_serializer.is_valid(raise_exception=True)
-                        job_annotations[db_job.id] = annotations_serializer.data
-
-                for segment in segments:
-                    for job in segment['jobs']:
-                        job['annotations'] = job_annotations[job['id']]
-
-                return segments
-
             segments = []
             for db_segment in self._db_task.segment_set.all():
                 jobs = []
                 for db_job in db_segment.job_set.all():
                     job_serializer = SimpleJobSerializer(db_job)
                     job_serializer.fields.pop('url')
-                    jobs.append(job_serializer.data)
+                    jobs.append(self._prepare_job_meta(job_serializer.data))
                 segment_serailizer = SegmentSerializer(db_segment)
                 segment_serailizer.fields.pop('jobs')
                 segment = segment_serailizer.data
                 segment['jobs'] = jobs
                 segments.append(segment)
 
-            return serialize_annotations(segments)
+            return segments
 
         def serialize_data():
             def serialize_related_files(image):
@@ -143,115 +211,56 @@ def serialize_frames():
 
             return data
 
-        manifest = serialize_task()
-        manifest['version'] = self._version.value
-        manifest['data'] = serialize_data()
-        manifest['segments'] = serialize_segmetnts()
+        task = serialize_task()
+        task['version'] = self._version.value
+        task['data'] = serialize_data()
+        task['segments'] = serialize_segmetnts()
+
+        zip_object.writestr(self.MANIFEST_FILENAME, data=JSONRenderer().render(task))
 
-        zip_object.writestr(self.MANIFEST_FILENAME, data=JSONRenderer().render(manifest))
+    def _write_annotations(self, zip_object):
+        def serialize_annotations():
+            job_annotations = {}
+            for db_segment in self._db_task.segment_set.all():
+                for db_job in db_segment.job_set.all():
+                    annotations = dm.task.get_job_data(db_job.id)
+                    annotations_serializer = LabeledDataSerializer(data=annotations)
+                    annotations_serializer.is_valid(raise_exception=True)
+                    job_annotations[db_job.id] = self._prepare_annotations(annotations_serializer.data)
+
+            return job_annotations
+
+        annotations = serialize_annotations()
+        zip_object.writestr(self.ANNOTATIONS_FILENAME, data=JSONRenderer().render(annotations))
 
     def export_to(self, filename):
         with ZipFile(filename, 'w') as output_file:
             self._write_data(output_file)
             self._write_task(output_file)
             self._write_manifest(output_file)
+            self._write_annotations(output_file)
 
-class TaskImporter():
-    class Version(Enum):
-        V1 = 'v1'
-
-    MANIFEST_FILENAME = 'manifest.json'
-    DATA_DIRNAME = 'data'
-    TASK_DIRNAME = 'task'
-
+class TaskImporter(_TaskBackupBase):
     def __init__(self, filename):
         self._filename = filename
-        self._manifest = self._read_manifest()
+        self._manifest, self._annotations = self._read_meta()
         self._version = self._read_version()
 
-    def _read_manifest(self):
+    def _read_meta(self):
         with ZipFile(self._filename, 'r') as input_file:
-            return JSONParser().parse(io.BytesIO(input_file.read(self.MANIFEST_FILENAME)))
+            manifest = JSONParser().parse(io.BytesIO(input_file.read(self.MANIFEST_FILENAME)))
+            annotations = JSONParser().parse(io.BytesIO(input_file.read(self.ANNOTATIONS_FILENAME)))
+            annotations = {int(job_id): job_annotations for job_id, job_annotations in annotations.items()}
+
+            return manifest, annotations
 
     def _read_version(self):
         version = self._manifest.pop('version')
         try:
-            return self.Version(version)
+            return Version(version)
         except ValueError:
             raise ValueError('{} version is not supported'.format(version))
 
-    def _prepare_meta(self, allowed_keys, meta):
-        keys_to_drop = set(meta.keys()) - allowed_keys
-        logger = slogger.task[self._db_task.id] if hasattr(self, '_db_task') else slogger.glob
-        logger.warning('the following keys are dropped {}'.format(keys_to_drop))
-        for key in keys_to_drop:
-            del meta[key]
-
-    def _prepare_task_meta(self, task):
-        allowed_fields = {
-            'name',
-            'mode',
-            'bug_tracker',
-            'overlap',
-            'segment_size',
-            'status',
-            'dimension',
-            'subset',
-        }
-
-        self._prepare_meta(allowed_fields, task)
-
-    def _prepare_data_meta(self, data):
-        allowed_fields = {
-            'chunk_size',
-            'size',
-            'image_quality',
-            'start_frame',
-            'stop_frame',
-            'frame_filter',
-            'compressed_chunk_type',
-            'original_chunk_type',
-            'storage_method',
-            'storage',
-        }
-        self._prepare_meta(allowed_fields, data)
-        if not data['frame_filter']:
-            data.pop('frame_filter')
-
-    def _prepare_segment_meta(self, segments):
-        allowed_fields = {
-            'start_frame',
-            'stop_frame',
-        }
-        self._prepare_meta(allowed_fields, segments)
-
-    def _prepare_job_meta(self, jobs):
-        allowed_fields = {
-            'status',
-        }
-        self._prepare_meta(allowed_fields, jobs)
-
-    def _prepare_annotations(self, annotations):
-        allowed_fields = {
-            'label_id',
-            'type',
-            'occluded',
-            'z_order',
-            'points',
-            'frame',
-            'group',
-            'source',
-            'attributes',
-            'shapes',
-        }
-
-        for tag in annotations['tags']:
-            self._prepare_meta(allowed_fields, tag)
-        for shape in annotations['shapes']:
-            self._prepare_meta(allowed_fields, shape)
-        for track in annotations['tracks']:
-            self._prepare_meta(allowed_fields, track)
-
     @staticmethod
     def _prepare_dirs(filepath):
         target_dir = os.path.dirname(filepath)
@@ -312,9 +321,9 @@ def _create_segments(self, db_task, labels_mapping, attributes_mapping, segments
             self._prepare_segment_meta(segment)
             db_segment = models.Segment.objects.create(task=db_task, **segment)
             for job in jobs:
-                annotations = job.pop('annotations')
+                job_id = job.pop('id')
                 db_job = self._create_job(db_segment, job)
-                self._create_annotations(db_job, labels_mapping, attributes_mapping, annotations)
+                self._create_annotations(db_job, labels_mapping, attributes_mapping, self._annotations[job_id])
 
     def _create_data(self, data):
         self._prepare_data_meta(data)
diff --git a/cvat/apps/engine/frame_provider.py b/cvat/apps/engine/frame_provider.py
index ea8e19fcb7a..cd9b64c1335 100644
--- a/cvat/apps/engine/frame_provider.py
+++ b/cvat/apps/engine/frame_provider.py
@@ -5,13 +5,14 @@
 import math
 from enum import Enum
 from io import BytesIO
+import os
 
 import cv2
 import numpy as np
 from PIL import Image
 
 from cvat.apps.engine.cache import CacheInteraction
-from cvat.apps.engine.media_extractors import VideoReader, ZipReader
+from cvat.apps.engine.media_extractors import VideoReader, ZipReader, IMediaReader
 from cvat.apps.engine.mime_types import mimetypes
 from cvat.apps.engine.models import DataChoice, StorageMethodChoice, DimensionType
 
@@ -159,7 +160,12 @@ def _convert_frame(self, frame, reader_class, out_type):
             raise Exception('unsupported output type')
 
     def get_preview(self):
-        return self._db_data.get_preview_path()
+        preview_path = self._db_data.get_preview_path()
+        if not os.path.exists(preview_path):
+            preview, _ = self.get_frame(frame_number=0)
+            preview = IMediaReader._get_preview(preview)
+            preview.save(preview_path)
+        return preview_path
 
     def get_chunk(self, chunk_number, quality=Quality.ORIGINAL):
         chunk_number = self._validate_chunk_number(chunk_number)
diff --git a/cvat/apps/engine/tests/test_rest_api.py b/cvat/apps/engine/tests/test_rest_api.py
index 01b85641ecb..b82947d9c4d 100644
--- a/cvat/apps/engine/tests/test_rest_api.py
+++ b/cvat/apps/engine/tests/test_rest_api.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2020 Intel Corporation
+# Copyright (C) 2020-2021 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 
@@ -1887,6 +1887,135 @@ def test_api_v1_tasks_no_auth(self):
         }
         self._check_api_v1_tasks(None, data)
 
+
+
+class TaskImportExportAPITestCase(APITestCase):
+
+    def setUp(self):
+        self.client = APIClient()
+
+    @classmethod
+    def setUpTestData(cls):
+        create_db_users(cls)
+
+    def _create_tasks(self):
+        self.tasks = []
+        data = {
+            "name": "my task #1",
+            "owner_id": self.owner.id,
+            "assignee_id": self.assignee.id,
+            "overlap": 0,
+            "segment_size": 100,
+            "image_quality": 75,
+            "size": 100,
+            "labels": [{
+                "name": "car",
+                "color": "#ff00ff",
+                "attributes": [{
+                    "name": "bool_attribute",
+                    "mutable": True,
+                    "input_type": AttributeType.CHECKBOX,
+                    "default_value": "true"
+                }],
+            }, {
+                "name": "person",
+            }]
+        }
+
+        with ForceLogin(self.owner, self.client):
+            response = self.client.post('/api/v1/tasks', data=data, format="json")
+            assert response.status_code == status.HTTP_201_CREATED
+            tid = response.data["id"]
+
+            images = {
+                "client_files[0]": generate_image_file("test_1.jpg")[1],
+                "client_files[1]": generate_image_file("test_2.jpg")[1],
+                "client_files[2]": generate_image_file("test_3.jpg")[1],
+                "image_quality": 75,
+            }
+            response = self.client.post("/api/v1/tasks/{}/data".format(tid), data=images)
+            assert response.status_code == status.HTTP_202_ACCEPTED
+            self.tasks.append(tid)
+
+            response = self.client.post('/api/v1/tasks', data=data, format="json")
+            assert response.status_code == status.HTTP_201_CREATED
+            tid = response.data["id"]
+            video = {
+                "client_files[0]": generate_video_file("test_video.mp4")[1],
+                "image_quality": 75,
+            }
+            response = self.client.post("/api/v1/tasks/{}/data".format(tid), data=video)
+            assert response.status_code == status.HTTP_202_ACCEPTED
+            self.tasks.append(tid)
+
+    def _run_api_v1_tasks_id_export(self, tid, user, query_params=""):
+        with ForceLogin(user, self.client):
+            response = self.client.get('/api/v1/tasks/{}?{}'.format(tid, query_params), format="json")
+
+        return response
+
+    def _run_api_v1_tasks_id_import(self, user, data):
+        with ForceLogin(user, self.client):
+            response = self.client.post('/api/v1/tasks?action=import', data=data, format="multipart")
+
+        return response
+
+    def _run_api_v1_tasks_id_export_import(self, user):
+        if user:
+            if user is self.user or user is self.annotator:
+                HTTP_200_OK = status.HTTP_403_FORBIDDEN
+                HTTP_202_ACCEPTED = status.HTTP_403_FORBIDDEN
+                HTTP_201_CREATED = status.HTTP_403_FORBIDDEN
+            else:
+                HTTP_200_OK = status.HTTP_200_OK
+                HTTP_202_ACCEPTED = status.HTTP_202_ACCEPTED
+                HTTP_201_CREATED = status.HTTP_201_CREATED
+        else:
+            HTTP_200_OK = status.HTTP_401_UNAUTHORIZED
+            HTTP_202_ACCEPTED = status.HTTP_401_UNAUTHORIZED
+            HTTP_201_CREATED = status.HTTP_401_UNAUTHORIZED
+
+        self._create_tasks()
+        for tid in self.tasks:
+            response = self._run_api_v1_tasks_id_export(tid, user, "action=export")
+            self.assertEqual(response.status_code, HTTP_202_ACCEPTED)
+
+            response = self._run_api_v1_tasks_id_export(tid, user, "action=export")
+            self.assertEqual(response.status_code, HTTP_201_CREATED)
+
+            response = self._run_api_v1_tasks_id_export(tid, user, "action=download")
+            self.assertEqual(response.status_code, HTTP_200_OK)
+
+            if user and user is not self.observer and user is not self.user and user is not self.annotator:
+                self.assertTrue(response.streaming)
+                content = io.BytesIO(b"".join(response.streaming_content))
+                content.seek(0)
+
+                uploaded_data = {
+                    "task_file": content,
+                }
+                response = self._run_api_v1_tasks_id_import(user, uploaded_data)
+                self.assertEqual(response.status_code, HTTP_202_ACCEPTED)
+                if user is not self.observer and user is not self.user and user is not self.annotator:
+                    rq_id = response.data["rq_id"]
+                    response = self._run_api_v1_tasks_id_import(user, {"rq_id": rq_id})
+                    self.assertEqual(response.status_code, HTTP_201_CREATED)
+
+    def test_api_v1_tasks_id_export_admin(self):
+        self._run_api_v1_tasks_id_export_import(self.admin)
+
+    def test_api_v1_tasks_id_export_user(self):
+        self._run_api_v1_tasks_id_export_import(self.user)
+
+    def test_api_v1_tasks_id_export_annotator(self):
+        self._run_api_v1_tasks_id_export_import(self.annotator)
+
+    def test_api_v1_tasks_id_export_observer(self):
+        self._run_api_v1_tasks_id_export_import(self.observer)
+
+    def test_api_v1_tasks_id_export_no_auth(self):
+        self._run_api_v1_tasks_id_export_import(None)
+
 def generate_image_file(filename):
     f = BytesIO()
     gen = random.SystemRandom()

From b4b0564df66cd7b4b6fd02ed2c303a0b2495c74b Mon Sep 17 00:00:00 2001
From: Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Tue, 20 Apr 2021 09:14:14 +0300
Subject: [PATCH 09/19] reverted changes in *.md files

---
 cvat/apps/dataset_manager/formats/README.md | 25 +++++++++------------
 cvat/apps/documentation/user_guide.md       | 22 ++++++++----------
 2 files changed, 20 insertions(+), 27 deletions(-)

diff --git a/cvat/apps/dataset_manager/formats/README.md b/cvat/apps/dataset_manager/formats/README.md
index b67dc734391..3af8cbfda4b 100644
--- a/cvat/apps/dataset_manager/formats/README.md
+++ b/cvat/apps/dataset_manager/formats/README.md
@@ -536,13 +536,14 @@ archive.zip/
   - `score` (number) - the annotation `score` field
   - arbitrary attributes - will be stored in the `attributes` annotation section
 
-_Note_: there is also a [support for COCO keypoints over Datumaro](https://github.com/openvinotoolkit/cvat/issues/2910#issuecomment-726077582)
+
+*Note*: there is also a [support for COCO keypoints over Datumaro](https://github.com/openvinotoolkit/cvat/issues/2910#issuecomment-726077582)
 
 1. Install [Datumaro](https://github.com/openvinotoolkit/datumaro)
-   `pip install datumaro`
+  `pip install datumaro`
 1. Export the task in the `Datumaro` format, unzip
 1. Export the Datumaro project in `coco` / `coco_person_keypoints` formats
-   `datum export -f coco -p path/to/project [-- --save-images]`
+  `datum export -f coco -p path/to/project [-- --save-images]`
 
 This way, one can export CVAT points as single keypoints or
 keypoint lists (without the `visibility` COCO flag).
@@ -625,20 +626,16 @@ item {
 - supported annotations: Rectangles, Polygons (as masks, manually over [Datumaro](https://github.com/openvinotoolkit/datumaro/blob/develop/docs/user_manual.md))
 
 How to export masks:
-
 1. Export annotations in `Datumaro` format
 1. Apply `polygons_to_masks` and `boxes_to_masks` transforms
-
-```bash
-datum transform -t polygons_to_masks -p path/to/proj -o ptm
-datum transform -t boxes_to_masks -p ptm -o btm
-```
-
+  ```bash
+  datum transform -t polygons_to_masks -p path/to/proj -o ptm
+  datum transform -t boxes_to_masks -p ptm -o btm
+  ```
 1. Export in the `TF Detection API` format
-
-```bash
-datum export -f tf_detection_api -p btm [-- --save-images]
-```
+  ```bash
+  datum export -f tf_detection_api -p btm [-- --save-images]
+  ```
 
 #### TFRecord import
 
diff --git a/cvat/apps/documentation/user_guide.md b/cvat/apps/documentation/user_guide.md
index ced7ed93fc3..9406756d2f6 100644
--- a/cvat/apps/documentation/user_guide.md
+++ b/cvat/apps/documentation/user_guide.md
@@ -284,7 +284,6 @@ Go to the [Django administration panel](http://localhost:8080/admin). There you
       1. Assigned to — is used to assign a task to a person. Start typing an assignee’s name and/or
          choose the right person out of the dropdown list.
     - `Jobs` — is a list of all jobs for a particular task. Here you can find the next data:
-
       - Jobs name with a hyperlink to it.
       - Frames — the frame interval.
       - A status of the job. The status is specified by the user in the menu inside the job.
@@ -687,8 +686,8 @@ In addition the workspace also has the following functions:
     ![](static/documentation/images/image068_mapillary_vistas.jpg)
 
   - Adjust `Brightness`/`Contrast`/`Saturation` of too exposed or too
-    dark images using `F3` — color settings (changes displaying settings and not the
-    image itself).
+  dark images using `F3` — color settings (changes displaying settings and not the
+  image itself).
 
   Shortcuts:
 
@@ -740,7 +739,7 @@ In tab `Workspace` you can:
 
 - `Attribute annotation mode (AAM) zoom margin` input box — defines margins (in px)
   for shape in the attribute annotation mode.
-- Click `Save` to save settings (settings will be saved on the server and will not change after the page is refreshed). Click `Cancel` or press `F2` to return to the annotation.
+- Click `Save` to save settings (settings will be saved on the server and will not change after the page is refreshed). Click `Cancel`  or press `F2` to return to the annotation.
 
 ---
 
@@ -1286,7 +1285,6 @@ To edit a polygon you have to click on it while holding `Shift`, it will open th
 
 - In the editor you can create new points or delete part of a polygon by closing the line on another point.
 - When `Intelligent polygon cropping` option is activated in the settings, СVAT considers two criteria to decide which part of a polygon should be cut off during automatic editing.
-
   - The first criteria is a number of cut points.
   - The second criteria is a length of a cut curve.
 
@@ -1307,12 +1305,12 @@ To do this, one needs to define a background class in the task and draw holes
 with it as additional shapes above the shapes needed to have holes:
 
 The editor window:
-![The editor](static/documentation/images/mask_export_example1_editor.png)
+  ![The editor](static/documentation/images/mask_export_example1_editor.png)
 
 Remember to use z-axis ordering for shapes by \[\-\] and \[\+\, \=\] keys.
 
 Exported masks:
-![A class mask](static/documentation/images/mask_export_example1_cls_mask.png) ![An instance mask](static/documentation/images/mask_export_example1_inst_mask.png)
+  ![A class mask](static/documentation/images/mask_export_example1_cls_mask.png)  ![An instance mask](static/documentation/images/mask_export_example1_inst_mask.png)
 
 Notice that it is currently impossible to have a single instance number for
 internal shapes (they will be merged into the largest one and then covered by
@@ -1321,7 +1319,6 @@ internal shapes (they will be merged into the largest one and then covered by
 ### Creating masks
 
 There are several formats in CVAT that can be used to export masks:
-
 - `Segmentation Mask` (PASCAL VOC masks)
 - `CamVid`
 - `MOTS`
@@ -1332,10 +1329,9 @@ There are several formats in CVAT that can be used to export masks:
 
 An example of exported masks (in the `Segmentation Mask` format):
 
-![A class mask](static/documentation/images/exported_cls_masks_example.png) ![An instance mask](static/documentation/images/exported_inst_masks_example.png)
+  ![A class mask](static/documentation/images/exported_cls_masks_example.png) ![An instance mask](static/documentation/images/exported_inst_masks_example.png)
 
 Important notices:
-
 - Both boxes and polygons are converted into masks
 - Grouped objects are considered as a single instance and exported as a single
   mask (label and attributes are taken from the largest object in the group)
@@ -1345,16 +1341,15 @@ Important notices:
 All the labels have associated colors, which are used in the generated masks.
 These colors can be changed in the task label properties:
 
-![](static/documentation/images/label_color_picker.jpg)
+  ![](static/documentation/images/label_color_picker.jpg)
 
 Label colors are also displayed in the annotation window on the right panel,
 where you can show or hide specific labels
 (only the presented labels are displayed):
 
-![](static/documentation/images/label_panel_anno_window.jpg)
+  ![](static/documentation/images/label_panel_anno_window.jpg)
 
 A background class can be:
-
 - A default class, which is implicitly-added, of black color (RGB 0, 0, 0)
 - `background` class with any color (has a priority, name is case-insensitive)
 - Any class of black color (RGB 0, 0, 0)
@@ -1362,6 +1357,7 @@ A background class can be:
 To change backgound color in generated masks (default is black),
 change `background` class color to the desired one.
 
+
 ## Annotation with polylines
 
 It is used for road markup annotation etc.

From b57c93934e9f2ca985011d3fed53ebdec38491d9 Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Thu, 29 Apr 2021 18:01:37 +0300
Subject: [PATCH 10/19] fixed comments

---
 cvat/apps/documentation/backup_hld.md |   7 +-
 cvat/apps/engine/backup.py            | 264 ++++++++++----------------
 cvat/apps/engine/frame_provider.py    |   7 +-
 cvat/apps/engine/media_extractors.py  |  53 ++++--
 cvat/apps/engine/task.py              |  23 ++-
 5 files changed, 152 insertions(+), 202 deletions(-)

diff --git a/cvat/apps/documentation/backup_hld.md b/cvat/apps/documentation/backup_hld.md
index faf0c5829b9..ee6309cd10a 100644
--- a/cvat/apps/documentation/backup_hld.md
+++ b/cvat/apps/documentation/backup_hld.md
@@ -22,11 +22,8 @@ API endpoints:
   ```
    .
    ├── data
-   │   ├── compressed
-   │   ├── original
-   │   ├── raw
-   │   │   ├── {user uploaded data}
-   │   │   ├── manifest.jsonl
+   │   ├── {user uploaded data}
+   │   ├── manifest.jsonl
    ├── task.json
    └── annotations.json
   ```
diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index 938d5f25350..979f34cfa58 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -8,6 +8,7 @@
 import shutil
 from zipfile import ZipFile
 
+from django.conf import settings
 from rest_framework.parsers import JSONParser
 from rest_framework.renderers import JSONRenderer
 
@@ -15,12 +16,14 @@
 from cvat.apps.engine import models
 from cvat.apps.engine.log import slogger
 from cvat.apps.engine.serializers import (AttributeSerializer, DataSerializer,
-    FrameMetaSerializer, LabeledDataSerializer, RelatedFileSerializer, SegmentSerializer,
-    SimpleJobSerializer, TaskSerializer)
+    LabeledDataSerializer, SegmentSerializer, SimpleJobSerializer, TaskSerializer)
 from cvat.apps.engine.utils import av_scan_paths
+from cvat.apps.engine.models import StorageChoice, StorageMethodChoice, DataChoice, Job
+from cvat.apps.engine.task import _create_thread
+
 
 class Version(Enum):
-        V1 = 'v1'
+        V1 = '1.0'
 
 class _TaskBackupBase():
     MANIFEST_FILENAME = 'task.json'
@@ -30,22 +33,20 @@ class _TaskBackupBase():
 
     def _prepare_meta(self, allowed_keys, meta):
         keys_to_drop = set(meta.keys()) - allowed_keys
-        logger = slogger.task[self._db_task.id] if hasattr(self, '_db_task') else slogger.glob
-        logger.warning('the following keys are dropped {}'.format(keys_to_drop))
-        for key in keys_to_drop:
-            del meta[key]
+        if keys_to_drop:
+            logger = slogger.task[self._db_task.id] if hasattr(self, '_db_task') else slogger.glob
+
+            logger.warning('the following keys are dropped {}'.format(keys_to_drop))
+            for key in keys_to_drop:
+                del meta[key]
 
         return meta
 
     def _prepare_task_meta(self, task):
         allowed_fields = {
             'name',
-            'mode',
             'bug_tracker',
-            'overlap',
-            'segment_size',
             'status',
-            'dimension',
             'subset',
             'labels',
         }
@@ -55,19 +56,19 @@ def _prepare_task_meta(self, task):
     def _prepare_data_meta(self, data):
         allowed_fields = {
             'chunk_size',
-            'size',
             'image_quality',
             'start_frame',
             'stop_frame',
             'frame_filter',
-            'compressed_chunk_type',
-            'original_chunk_type',
+            'chunk_type',
             'storage_method',
             'storage',
         }
+
         self._prepare_meta(allowed_fields, data)
-        if not data['frame_filter']:
+        if 'frame_filter' in data and not data['frame_filter']:
             data.pop('frame_filter')
+
         return data
 
     def _prepare_segment_meta(self, segments):
@@ -114,26 +115,49 @@ def __init__(self, pk, version=Version.V1):
         self._db_data = self._db_task.data
         self._version = version
 
+    def _write_files(self, source_dir, zip_object, files, target_dir):
+        for filename in files:
+            arcname = os.path.normpath(
+                os.path.join(
+                    target_dir,
+                    os.path.relpath(filename, source_dir),
+                )
+            )
+            zip_object.write(filename=filename, arcname=arcname)
+
     def _write_directory(self, source_dir, zip_object, target_dir, recursive=True, exclude_files=None):
         for root, dirs, files in os.walk(source_dir, topdown=True):
             if not recursive:
                 dirs.clear()
-            for filename in files:
-                file_path = os.path.join(root, filename)
-                if exclude_files and file_path in exclude_files:
-                    continue
-                arcname = os.path.normpath(os.path.join(target_dir, os.path.relpath(root, source_dir), filename))
-                zip_object.write(filename=file_path, arcname=arcname)
+
+            if files:
+                self._write_files(
+                    source_dir=source_dir,
+                    zip_object=zip_object,
+                    files=(os.path.join(root, f) for f in files if not exclude_files or f not in exclude_files),
+                    target_dir=target_dir,
+                )
 
     def _write_data(self, zip_object):
-        data_dir = self._db_data.get_data_dirname()
-        self._write_directory(
-            source_dir=data_dir,
-            zip_object=zip_object,
-            target_dir=self.DATA_DIRNAME,
-            exclude_files=tuple(os.path.join(data_dir, f) for f in \
-                ('preview.jpeg', os.path.join('raw', 'index.json'))),
-        )
+        if self._db_data.storage == StorageChoice.LOCAL:
+            self._write_directory(
+                source_dir=self._db_data.get_upload_dirname(),
+                zip_object=zip_object,
+                target_dir=self.DATA_DIRNAME,
+            )
+        else:
+            data_dir = settings.SHARE_ROOT
+            if hasattr(self._db_data, 'video'):
+                media_files = (os.path.join(data_dir, self._db_data.video.path), )
+            else:
+                media_files = (os.path.join(data_dir, im.path) for im in self._db_data.images.all().order_by('frame'))
+
+            self._write_files(
+                source_dir=data_dir,
+                zip_object=zip_object,
+                files=media_files,
+                target_dir=self.DATA_DIRNAME
+            )
 
     def _write_task(self, zip_object):
         task_dir = self._db_task.get_task_dirname()
@@ -154,67 +178,32 @@ def serialize_task():
 
             return self._prepare_task_meta(task_serializer.data)
 
-        def serialize_segmetnts():
-            segments = []
+        def serialize_jobs():
+            task_jobs = []
             for db_segment in self._db_task.segment_set.all():
-                jobs = []
-                for db_job in db_segment.job_set.all():
-                    job_serializer = SimpleJobSerializer(db_job)
-                    job_serializer.fields.pop('url')
-                    jobs.append(self._prepare_job_meta(job_serializer.data))
+                db_job = db_segment.job_set.first()
+                job_serializer = SimpleJobSerializer(db_job)
+                job_serializer.fields.pop('url')
+                job_data = self._prepare_job_meta(job_serializer.data)
                 segment_serailizer = SegmentSerializer(db_segment)
                 segment_serailizer.fields.pop('jobs')
                 segment = segment_serailizer.data
-                segment['jobs'] = jobs
-                segments.append(segment)
+                segment.update(job_data)
+                task_jobs.append(segment)
 
-            return segments
+            return task_jobs
 
         def serialize_data():
-            def serialize_related_files(image):
-                related_files_serializer = RelatedFileSerializer(image.related_files.all(), many=True)
-                related_files = related_files_serializer.data
-                for f in related_files:
-                    f['path'] = os.path.relpath(f['path'], image.data.get_upload_dirname())
-
-                return related_files
-
-            def serialize_frames():
-                if hasattr(self._db_task.data, 'video'):
-                    media = [self._db_task.data.video]
-                else:
-                    media = list(self._db_task.data.images.order_by('frame'))
-
-                frame_meta = []
-                for item in media:
-                    frame = {
-                        'width': item.width,
-                        'height': item.height,
-                        'name': item.path,
-                    }
-
-                    frame_meta_serializer = FrameMetaSerializer(data=frame)
-                    frame_meta_serializer.is_valid(raise_exception=True)
-                    frame = frame_meta_serializer.data
-
-                    if self._db_task.dimension == models.DimensionType.DIM_3D:
-                        frame['related_files'] = serialize_related_files(item)
-
-                    frame_meta.append(frame)
-
-                return frame_meta
-
             data_serializer = DataSerializer(self._db_data)
-
             data = data_serializer.data
-            data['frames'] = serialize_frames()
-
-            return data
+            data['chunk_type'] = data.pop('compressed_chunk_type')
+            data['storage'] = StorageChoice.LOCAL
+            return self._prepare_data_meta(data)
 
         task = serialize_task()
         task['version'] = self._version.value
         task['data'] = serialize_data()
-        task['segments'] = serialize_segmetnts()
+        task['jobs'] = serialize_jobs()
 
         zip_object.writestr(self.MANIFEST_FILENAME, data=JSONRenderer().render(task))
 
@@ -234,6 +223,9 @@ def serialize_annotations():
         zip_object.writestr(self.ANNOTATIONS_FILENAME, data=JSONRenderer().render(annotations))
 
     def export_to(self, filename):
+        if self._db_task.data.storage_method == StorageMethodChoice.FILE_SYSTEM and \
+           self._db_task.data.storage == StorageChoice.SHARE:
+           raise Exception('The task cannot be exported because it does not contain any raw data')
         with ZipFile(filename, 'w') as output_file:
             self._write_data(output_file)
             self._write_task(output_file)
@@ -286,11 +278,6 @@ def _create_labels(self, db_task, labels):
 
         return label_mapping, attribute_mapping
 
-    def _create_job(self, db_segment, job):
-        self._prepare_job_meta(job)
-        db_job = models.Job.objects.create(segment=db_segment, **job)
-        return db_job
-
     def _update_annotations(self, labels_mapping, attributes_mapping, annotations):
         def update_ids(objects):
             for obj in objects:
@@ -315,81 +302,27 @@ def _create_annotations(self, db_job, labels_mapping, attributes_mapping, annota
         serializer.is_valid(raise_exception=True)
         dm.task.put_job_data(db_job.id, serializer.data)
 
-    def _create_segments(self, db_task, labels_mapping, attributes_mapping, segments):
-        for segment in segments:
-            jobs = segment.pop('jobs')
-            self._prepare_segment_meta(segment)
-            db_segment = models.Segment.objects.create(task=db_task, **segment)
-            for job in jobs:
-                job_id = job.pop('id')
-                db_job = self._create_job(db_segment, job)
-                self._create_annotations(db_job, labels_mapping, attributes_mapping, self._annotations[job_id])
-
     def _create_data(self, data):
-        self._prepare_data_meta(data)
         data_serializer = DataSerializer(data=data)
         data_serializer.is_valid(raise_exception=True)
         db_data = data_serializer.save()
         return db_data
 
-    def _create_frames(self, db_data, frames):
-        def _prepare_frame(frame, frame_number=None):
-            frame['data'] = db_data
-            frame['path'] = frame.pop('name')
-            if frame_number is not None:
-                frame['frame'] = frame_number
-
-            return frame
-
-        def _prepare_related_file(related_file, rf_id):
-            related_file['data'] = db_data
-            related_file.pop('primary_image')
-            related_file.pop('id')
-            related_file['primary_image_id'] = rf_id
-            related_file['path'] = os.path.join(db_data.get_upload_dirname(), related_file['path'])
-
-            return related_file
-
-        if self._db_task.mode == 'annotation':
-            db_frames = []
-            db_related_files = []
-            for idx, frame in enumerate(frames):
-                related_files = frame.pop('related_files', [])
-                frame = _prepare_frame(frame, idx)
-
-                for related_file in related_files:
-                    related_file = _prepare_related_file(related_file, len(db_frames))
-                    db_related_file = models.RelatedFile(**related_file)
-                    db_related_files.append(db_related_file)
-
-                db_frames.append(models.Image(**frame))
-
-            db_frames = dm.task.bulk_create(
-                db_model=models.Image,
-                objects=db_frames,
-                flt_param={'data_id': db_data.id},
-            )
-
-            for db_related_file in db_related_files:
-                db_related_file.primary_image = db_frames[db_related_file.primary_image_id]
-
-            dm.task.bulk_create(
-                db_model=models.RelatedFile,
-                objects=db_related_files,
-                flt_param={}
-            )
+    @staticmethod
+    def _calculate_segment_size(jobs):
+        segment_size = jobs[0]['stop_frame'] - jobs[0]['start_frame'] + 1
+        overlap = 0 if len(jobs) == 1 else jobs[0]['stop_frame'] - jobs[1]['start_frame'] + 1
 
-        else:
-            frame = _prepare_frame(frames[0])
-            models.Video.objects.create(**frame)
+        return segment_size, overlap
 
     def _import_task(self):
         data = self._manifest.pop('data')
-        frames = data.pop('frames')
         labels = self._manifest.pop('labels')
-        self._segments = self._manifest.pop('segments')
+        self._jobs = self._manifest.pop('jobs')
 
         self._prepare_task_meta(self._manifest)
+        self._manifest['segment_size'], self._manifest['overlap'] = self._calculate_segment_size(self._jobs)
+
         self._db_task = models.Task.objects.create(**self._manifest)
         task_path = self._db_task.get_task_dirname()
         if os.path.isdir(task_path):
@@ -398,22 +331,17 @@ def _import_task(self):
         os.makedirs(self._db_task.get_task_logs_dirname())
         os.makedirs(self._db_task.get_task_artifacts_dirname())
 
-        db_data = self._create_data(data)
-        self._db_task.data = db_data
-        self._db_task.save()
-
-        self._create_frames(db_data, frames)
-
         self._labels_mapping, self._attributes_mapping = self._create_labels(self._db_task, labels)
 
-        return self._db_task.id
-
-    def _import_annotations(self):
-        self._create_segments(self._db_task, self._labels_mapping, self._attributes_mapping, self._segments)
-
-    def _import_media(self):
-        data_path = self._db_task.data.get_data_dirname()
+        self._prepare_data_meta(data)
+        data_serializer = DataSerializer(data=data)
+        data_serializer.is_valid(raise_exception=True)
+        db_data = data_serializer.save()
+        self._db_task.data = db_data
+        self._db_task.save()
 
+        data_path = self._db_task.data.get_upload_dirname()
+        uploaded_files = []
         with ZipFile(self._filename, 'r') as input_file:
             for f in input_file.namelist():
                 if f.startswith(self.DATA_DIRNAME + os.path.sep):
@@ -421,20 +349,36 @@ def _import_media(self):
                     self._prepare_dirs(target_file)
                     with open(target_file, "wb") as out:
                         out.write(input_file.read(f))
+                    uploaded_files.append(os.path.relpath(f, self.DATA_DIRNAME))
                 elif f.startswith(self.TASK_DIRNAME + os.path.sep):
                     target_file = os.path.join(task_path, os.path.relpath(f, self.TASK_DIRNAME))
                     self._prepare_dirs(target_file)
                     with open(target_file, "wb") as out:
                         out.write(input_file.read(f))
 
+        data['use_zip_chunks'] = data.pop('chunk_type') == DataChoice.IMAGESET
+        data = data_serializer.data
+        data['client_files'] = uploaded_files
+        _create_thread(self._db_task.pk, data)
+
+    def _import_annotations(self):
+        job_mapping = {}
+        for db_segment in self._db_task.segment_set.all():
+            for db_job in db_segment.job_set.all():
+                for job in self._jobs:
+                    if db_segment.start_frame == job['start_frame']:
+                        job_mapping[job['id']] = db_job.id
+
+        for job in self._jobs:
+            db_job = Job.objects.get(pk=job_mapping[job['id']])
+            self._create_annotations(db_job, self._labels_mapping, self._attributes_mapping, self._annotations[job['id']])
+
+
     def import_task(self):
         self._import_task()
         self._import_annotations()
-        self._import_media()
         return self._db_task
 
-
-
 def import_task(filename):
     av_scan_paths(filename)
     task_importer = TaskImporter(filename)
diff --git a/cvat/apps/engine/frame_provider.py b/cvat/apps/engine/frame_provider.py
index cd9b64c1335..8c562a2c894 100644
--- a/cvat/apps/engine/frame_provider.py
+++ b/cvat/apps/engine/frame_provider.py
@@ -160,12 +160,7 @@ def _convert_frame(self, frame, reader_class, out_type):
             raise Exception('unsupported output type')
 
     def get_preview(self):
-        preview_path = self._db_data.get_preview_path()
-        if not os.path.exists(preview_path):
-            preview, _ = self.get_frame(frame_number=0)
-            preview = IMediaReader._get_preview(preview)
-            preview.save(preview_path)
-        return preview_path
+        return self._db_data.get_preview_path()
 
     def get_chunk(self, chunk_number, quality=Quality.ORIGINAL):
         chunk_number = self._validate_chunk_number(chunk_number)
diff --git a/cvat/apps/engine/media_extractors.py b/cvat/apps/engine/media_extractors.py
index dda3956e5b7..71b887556db 100644
--- a/cvat/apps/engine/media_extractors.py
+++ b/cvat/apps/engine/media_extractors.py
@@ -107,6 +107,7 @@ def __init__(self, source_path, step=1, start=0, stop=None):
             start=start,
             stop=stop,
         )
+        self._dimension = DimensionType.DIM_2D
 
     def __iter__(self):
         for i in range(self._start, self._stop, self._step):
@@ -122,13 +123,30 @@ def get_progress(self, pos):
         return (pos - self._start + 1) / (self._stop - self._start)
 
     def get_preview(self):
-        fp = open(self._source_path[0], "rb")
+        if self._dimension == DimensionType.DIM_3D:
+            fp = open(os.path.join(os.path.dirname(__file__), 'assets/3d_preview.jpeg'), "rb")
+        else:
+            fp = open(self._source_path[0], "rb")
         return self._get_preview(fp)
 
     def get_image_size(self, i):
+        if self._dimension == DimensionType.DIM_3D:
+            with open(self.get_path(i), 'rb') as f:
+                properties = ValidateDimension.get_pcd_properties(f)
+                return int(properties["WIDTH"]),  int(properties["HEIGHT"])
         img = Image.open(self._source_path[i])
         return img.width, img.height
 
+    def reconcile(self, source_files, step=1, start=0, stop=None, dimension=DimensionType.DIM_2D):
+        # FIXME
+        ImageListReader.__init__(self,
+            source_path=source_files,
+            step=step,
+            start=start,
+            stop=stop
+        )
+        self._dimension = dimension
+
     @property
     def absolute_source_paths(self):
         return [self.get_path(idx) for idx, _ in enumerate(self._source_path)]
@@ -195,8 +213,7 @@ def _make_name():
 
 class ZipReader(ImageListReader):
     def __init__(self, source_path, step=1, start=0, stop=None):
-        self._dimension = DimensionType.DIM_2D
-        self._zip_source = zipfile.ZipFile(source_path[0], mode='a')
+        self._zip_source = zipfile.ZipFile(source_path[0], mode='r')
         self.extract_dir = source_path[1] if len(source_path) > 1 else None
         file_list = [f for f in self._zip_source.namelist() if files_to_ignore(f) and get_mime(f) == 'image']
         super().__init__(file_list, step, start, stop)
@@ -206,6 +223,7 @@ def __del__(self):
 
     def get_preview(self):
         if self._dimension == DimensionType.DIM_3D:
+            # TODO
             fp = open(os.path.join(os.path.dirname(__file__), 'assets/3d_preview.jpeg'), "rb")
             return self._get_preview(fp)
         io_image = io.BytesIO(self._zip_source.read(self._source_path[0]))
@@ -213,32 +231,20 @@ def get_preview(self):
 
     def get_image_size(self, i):
         if self._dimension == DimensionType.DIM_3D:
-            with self._zip_source.open(self._source_path[i], "r") as file:
-                properties = ValidateDimension.get_pcd_properties(file)
+            with open(self.get_path(i), 'rb') as f:
+                properties = ValidateDimension.get_pcd_properties(f)
                 return int(properties["WIDTH"]),  int(properties["HEIGHT"])
         img = Image.open(io.BytesIO(self._zip_source.read(self._source_path[i])))
         return img.width, img.height
 
     def get_image(self, i):
+        if self._dimension == DimensionType.DIM_3D:
+            return self.get_path(i)
         return io.BytesIO(self._zip_source.read(self._source_path[i]))
 
-    def add_files(self, source_path):
-        root_path = os.path.split(self._zip_source.filename)[0]
-        for path in source_path:
-            self._zip_source.write(path, path.replace(root_path, ""))
-
     def get_zip_filename(self):
         return self._zip_source.filename
 
-    def reconcile(self, source_files, step=1, start=0, stop=None, dimension=DimensionType.DIM_2D):
-        self._dimension = dimension
-        super().__init__(
-            source_path=source_files,
-            step=step,
-            start=start,
-            stop=stop
-        )
-
     def get_path(self, i):
         if self._zip_source.filename:
             return os.path.join(os.path.dirname(self._zip_source.filename), self._source_path[i]) \
@@ -246,6 +252,15 @@ def get_path(self, i):
         else: # necessary for mime_type definition
             return self._source_path[i]
 
+    def reconcile(self, source_files, step=1, start=0, stop=None, dimension=DimensionType.DIM_2D):
+        super().reconcile(
+            source_files=source_files,
+            step=step,
+            start=start,
+            stop=stop,
+            dimension=dimension,
+        )
+
     def extract(self):
         self._zip_source.extractall(self.extract_dir if self.extract_dir else os.path.dirname(self._zip_source.filename))
         if not self.extract_dir:
diff --git a/cvat/apps/engine/task.py b/cvat/apps/engine/task.py
index 7d9032380e3..5ea57ae3324 100644
--- a/cvat/apps/engine/task.py
+++ b/cvat/apps/engine/task.py
@@ -260,20 +260,19 @@ def _create_thread(tid, data):
     validate_dimension = ValidateDimension()
     if extractor.__class__ == MEDIA_TYPES['zip']['extractor']:
         extractor.extract()
-        validate_dimension.set_path(os.path.split(extractor.get_zip_filename())[0])
-        validate_dimension.validate()
-        if validate_dimension.dimension == models.DimensionType.DIM_3D:
-            db_task.dimension = models.DimensionType.DIM_3D
+    validate_dimension.set_path(upload_dir)
+    validate_dimension.validate()
+    if validate_dimension.dimension == models.DimensionType.DIM_3D:
+        db_task.dimension = models.DimensionType.DIM_3D
 
-            extractor.reconcile(
-                source_files=list(validate_dimension.related_files.keys()),
-                step=db_data.get_frame_step(),
-                start=db_data.start_frame,
-                stop=data['stop_frame'],
-                dimension=models.DimensionType.DIM_3D,
+        extractor.reconcile(
+            source_files=[os.path.join(upload_dir, f) for f in validate_dimension.related_files.keys()],
+            step=db_data.get_frame_step(),
+            start=db_data.start_frame,
+            stop=data['stop_frame'],
+            dimension=models.DimensionType.DIM_3D,
 
-            )
-            extractor.add_files(validate_dimension.converted_files)
+        )
 
     db_task.mode = task_mode
     db_data.compressed_chunk_type = models.DataChoice.VIDEO if task_mode == 'interpolation' and not data['use_zip_chunks'] else models.DataChoice.IMAGESET

From 32266f7bb62b16b9467e2541b3622aa3ab2fd50b Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Thu, 29 Apr 2021 18:13:45 +0300
Subject: [PATCH 11/19] fix pylint issues

---
 cvat/apps/engine/frame_provider.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/cvat/apps/engine/frame_provider.py b/cvat/apps/engine/frame_provider.py
index 8c562a2c894..ea8e19fcb7a 100644
--- a/cvat/apps/engine/frame_provider.py
+++ b/cvat/apps/engine/frame_provider.py
@@ -5,14 +5,13 @@
 import math
 from enum import Enum
 from io import BytesIO
-import os
 
 import cv2
 import numpy as np
 from PIL import Image
 
 from cvat.apps.engine.cache import CacheInteraction
-from cvat.apps.engine.media_extractors import VideoReader, ZipReader, IMediaReader
+from cvat.apps.engine.media_extractors import VideoReader, ZipReader
 from cvat.apps.engine.mime_types import mimetypes
 from cvat.apps.engine.models import DataChoice, StorageMethodChoice, DimensionType
 

From ff80d8a39380c84d3137d31ff3457d8fcecd93af Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Tue, 4 May 2021 15:34:44 +0300
Subject: [PATCH 12/19] fix import for share case

---
 cvat/apps/engine/backup.py | 16 ++++++++++++++--
 cvat/apps/engine/task.py   | 10 ++++++----
 cvat/apps/engine/views.py  |  3 +++
 3 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index 979f34cfa58..bb9970df239 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -159,6 +159,14 @@ def _write_data(self, zip_object):
                 target_dir=self.DATA_DIRNAME
             )
 
+            upload_dir = self._db_data.get_upload_dirname()
+            self._write_files(
+                source_dir=upload_dir,
+                zip_object=zip_object,
+                files=(os.path.join(upload_dir, f) for f in ('manifest.jsonl', 'index.json')),
+                target_dir=self.DATA_DIRNAME
+            )
+
     def _write_task(self, zip_object):
         task_dir = self._db_task.get_task_dirname()
         self._write_directory(
@@ -197,7 +205,6 @@ def serialize_data():
             data_serializer = DataSerializer(self._db_data)
             data = data_serializer.data
             data['chunk_type'] = data.pop('compressed_chunk_type')
-            data['storage'] = StorageChoice.LOCAL
             return self._prepare_data_meta(data)
 
         task = serialize_task()
@@ -359,7 +366,12 @@ def _import_task(self):
         data['use_zip_chunks'] = data.pop('chunk_type') == DataChoice.IMAGESET
         data = data_serializer.data
         data['client_files'] = uploaded_files
-        _create_thread(self._db_task.pk, data)
+        _create_thread(self._db_task.pk, data.copy(), True)
+        db_data.start_frame = data['start_frame']
+        db_data.stop_frame = data['stop_frame']
+        db_data.frame_filter = data['frame_filter']
+        db_data.storage = StorageChoice.LOCAL
+        db_data.save(update_fields=['start_frame', 'stop_frame', 'frame_filter', 'storage'])
 
     def _import_annotations(self):
         job_mapping = {}
diff --git a/cvat/apps/engine/task.py b/cvat/apps/engine/task.py
index 5ea57ae3324..a2ee1a6aa1d 100644
--- a/cvat/apps/engine/task.py
+++ b/cvat/apps/engine/task.py
@@ -206,14 +206,11 @@ def _download_data(urls, upload_dir):
     return list(local_files.keys())
 
 @transaction.atomic
-def _create_thread(tid, data):
+def _create_thread(tid, data, isImport=False):
     slogger.glob.info("create task #{}".format(tid))
 
     db_task = models.Task.objects.select_for_update().get(pk=tid)
     db_data = db_task.data
-    if db_task.data.size != 0:
-        raise NotImplementedError("Adding more data is not implemented")
-
     upload_dir = db_data.get_upload_dirname()
 
     if data['remote_files']:
@@ -250,6 +247,11 @@ def _create_thread(tid, data):
                 source_paths.append(db_data.get_upload_dirname())
                 upload_dir = db_data.get_upload_dirname()
                 db_data.storage = models.StorageChoice.LOCAL
+            if isImport and media_type == 'image' and db_data.storage == models.StorageChoice.SHARE:
+                db_data.start_frame = 0
+                data['stop_frame'] = None
+                db_data.frame_filter = ''
+
             extractor = MEDIA_TYPES[media_type]['extractor'](
                 source_path=source_paths,
                 step=db_data.get_frame_step(),
diff --git a/cvat/apps/engine/views.py b/cvat/apps/engine/views.py
index 86b5d47b6ab..d81e3c2db49 100644
--- a/cvat/apps/engine/views.py
+++ b/cvat/apps/engine/views.py
@@ -526,6 +526,9 @@ def jobs(self, request, pk):
     def data(self, request, pk):
         if request.method == 'POST':
             db_task = self.get_object() # call check_object_permissions as well
+            if db_task.data:
+                return Response(data='Adding more data is not supported',
+                    status=status.HTTP_400_BAD_REQUEST)
             serializer = DataSerializer(data=request.data)
             serializer.is_valid(raise_exception=True)
             db_data = serializer.save()

From 60df6a965341d711bb373d4dad98db26475fafaa Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Thu, 6 May 2021 17:10:47 +0300
Subject: [PATCH 13/19] improved unit tests

---
 cvat/apps/engine/backup.py              |   8 +-
 cvat/apps/engine/task.py                |  11 +-
 cvat/apps/engine/tests/test_rest_api.py | 296 ++++++++++++++++++++----
 cvat/apps/engine/views.py               |   2 +-
 4 files changed, 269 insertions(+), 48 deletions(-)

diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index bb9970df239..7e1e520950c 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -240,8 +240,9 @@ def export_to(self, filename):
             self._write_annotations(output_file)
 
 class TaskImporter(_TaskBackupBase):
-    def __init__(self, filename):
+    def __init__(self, filename, user_id):
         self._filename = filename
+        self._user_id = user_id
         self._manifest, self._annotations = self._read_meta()
         self._version = self._read_version()
 
@@ -329,6 +330,7 @@ def _import_task(self):
 
         self._prepare_task_meta(self._manifest)
         self._manifest['segment_size'], self._manifest['overlap'] = self._calculate_segment_size(self._jobs)
+        self._manifest["owner_id"] = self._user_id
 
         self._db_task = models.Task.objects.create(**self._manifest)
         task_path = self._db_task.get_task_dirname()
@@ -391,8 +393,8 @@ def import_task(self):
         self._import_annotations()
         return self._db_task
 
-def import_task(filename):
+def import_task(filename, user):
     av_scan_paths(filename)
-    task_importer = TaskImporter(filename)
+    task_importer = TaskImporter(filename, user)
     db_task = task_importer.import_task()
     return db_task.id
diff --git a/cvat/apps/engine/task.py b/cvat/apps/engine/task.py
index a2ee1a6aa1d..54354e7509e 100644
--- a/cvat/apps/engine/task.py
+++ b/cvat/apps/engine/task.py
@@ -72,8 +72,9 @@ def _save_task_to_db(db_task):
 
     segment_size = db_task.segment_size
     segment_step = segment_size
-    if segment_size == 0:
+    if segment_size == 0 or segment_size > db_task.data.size:
         segment_size = db_task.data.size
+        db_task.segment_size = segment_size
 
         # Segment step must be more than segment_size + overlap in single-segment tasks
         # Otherwise a task contains an extra segment
@@ -205,6 +206,9 @@ def _download_data(urls, upload_dir):
 
     return list(local_files.keys())
 
+def _get_manifest_frame_indexer(start_frame=0, frame_step=1):
+    return lambda frame_id: start_frame + frame_id * frame_step
+
 @transaction.atomic
 def _create_thread(tid, data, isImport=False):
     slogger.glob.info("create task #{}".format(tid))
@@ -237,6 +241,7 @@ def _create_thread(tid, data, isImport=False):
 
     db_images = []
     extractor = None
+    manifest_index = _get_manifest_frame_indexer()
 
     for media_type, media_files in media.items():
         if media_files:
@@ -248,6 +253,7 @@ def _create_thread(tid, data, isImport=False):
                 upload_dir = db_data.get_upload_dirname()
                 db_data.storage = models.StorageChoice.LOCAL
             if isImport and media_type == 'image' and db_data.storage == models.StorageChoice.SHARE:
+                manifest_index = _get_manifest_frame_indexer(db_data.start_frame, db_data.get_frame_step())
                 db_data.start_frame = 0
                 data['stop_frame'] = None
                 db_data.frame_filter = ''
@@ -273,7 +279,6 @@ def _create_thread(tid, data, isImport=False):
             start=db_data.start_frame,
             stop=data['stop_frame'],
             dimension=models.DimensionType.DIM_3D,
-
         )
 
     db_task.mode = task_mode
@@ -419,7 +424,7 @@ def _update_status(msg):
                     img_sizes = []
 
                     for _, frame_id in chunk_paths:
-                        properties = manifest[frame_id]
+                        properties = manifest[manifest_index(frame_id)]
                         if db_task.dimension == models.DimensionType.DIM_2D:
                             resolution = (properties['width'], properties['height'])
                         else:
diff --git a/cvat/apps/engine/tests/test_rest_api.py b/cvat/apps/engine/tests/test_rest_api.py
index b82947d9c4d..0c6d3b3434e 100644
--- a/cvat/apps/engine/tests/test_rest_api.py
+++ b/cvat/apps/engine/tests/test_rest_api.py
@@ -1893,60 +1893,249 @@ class TaskImportExportAPITestCase(APITestCase):
 
     def setUp(self):
         self.client = APIClient()
+        self.tasks = []
 
     @classmethod
     def setUpTestData(cls):
         create_db_users(cls)
 
-    def _create_tasks(self):
-        self.tasks = []
-        data = {
-            "name": "my task #1",
-            "owner_id": self.owner.id,
-            "assignee_id": self.assignee.id,
-            "overlap": 0,
-            "segment_size": 100,
-            "image_quality": 75,
-            "size": 100,
-            "labels": [{
-                "name": "car",
-                "color": "#ff00ff",
-                "attributes": [{
-                    "name": "bool_attribute",
-                    "mutable": True,
-                    "input_type": AttributeType.CHECKBOX,
-                    "default_value": "true"
-                }],
-            }, {
-                "name": "person",
-            }]
-        }
+        cls.media_data = []
+
+        image_count = 10
+        imagename_pattern = "test_{}.jpg"
+        for i in range(image_count):
+            filename = imagename_pattern.format(i)
+            path = os.path.join(settings.SHARE_ROOT, filename)
+            _, data = generate_image_file(filename)
+            with open(path, "wb") as image:
+                image.write(data.read())
+
+        cls.media_data.append(
+            {
+                **{"image_quality": 75,
+                   "copy_data": True,
+                   "start_frame": 2,
+                   "stop_frame": 9,
+                   "frame_filter": "step=2",
+                },
+                **{"server_files[{}]".format(i): imagename_pattern.format(i) for i in range(image_count)},
+            }
+        )
 
-        with ForceLogin(self.owner, self.client):
-            response = self.client.post('/api/v1/tasks', data=data, format="json")
-            assert response.status_code == status.HTTP_201_CREATED
-            tid = response.data["id"]
+        filename = "test_video_1.mp4"
+        path = os.path.join(settings.SHARE_ROOT, filename)
+        _, data = generate_video_file(filename, width=1280, height=720)
+        with open(path, "wb") as video:
+            video.write(data.read())
+        cls.media_data.append(
+            {
+                "image_quality": 75,
+                "copy_data": True,
+                "start_frame": 2,
+                "stop_frame": 24,
+                "frame_filter": "step=2",
+                "server_files[0]": filename,
+            }
+        )
 
-            images = {
+        filename = os.path.join("test_archive_1.zip")
+        path = os.path.join(settings.SHARE_ROOT, filename)
+        _, data = generate_zip_archive_file(filename, count=5)
+        with open(path, "wb") as zip_archive:
+            zip_archive.write(data.read())
+        cls.media_data.append(
+            {
+                "image_quality": 75,
+                "server_files[0]": filename,
+            }
+        )
+
+        filename = "test_pointcloud_pcd.zip"
+        source_path = os.path.join(os.path.dirname(__file__), 'assets', filename)
+        path = os.path.join(settings.SHARE_ROOT, filename)
+        shutil.copyfile(source_path, path)
+        cls.media_data.append(
+            {
+                "image_quality": 75,
+                "server_files[0]": filename,
+            }
+        )
+
+        filename = "test_velodyne_points.zip"
+        source_path = os.path.join(os.path.dirname(__file__), 'assets', filename)
+        path = os.path.join(settings.SHARE_ROOT, filename)
+        shutil.copyfile(source_path, path)
+        cls.media_data.append(
+            {
+                "image_quality": 75,
+                "server_files[0]": filename,
+            }
+        )
+
+        filename = os.path.join("videos", "test_video_1.mp4")
+        path = os.path.join(settings.SHARE_ROOT, filename)
+        os.makedirs(os.path.dirname(path))
+        _, data = generate_video_file(filename, width=1280, height=720)
+        with open(path, "wb") as video:
+            video.write(data.read())
+
+        generate_manifest_file(data_type='video', manifest_path=os.path.join(settings.SHARE_ROOT, 'videos', 'manifest.jsonl'),
+            sources=[path])
+
+        cls.media_data.append(
+            {
+                "image_quality": 70,
+                "copy_data": True,
+                "server_files[0]": filename,
+                "server_files[1]": os.path.join("videos", "manifest.jsonl"),
+                "use_cache": True,
+            }
+        )
+
+        generate_manifest_file(data_type='images', manifest_path=os.path.join(settings.SHARE_ROOT, 'manifest.jsonl'),
+            sources=[os.path.join(settings.SHARE_ROOT, imagename_pattern.format(i)) for i in range(1, 8)])
+        cls.media_data.append(
+            {
+                **{"image_quality": 70,
+                    "copy_data": True,
+                    "use_cache": True,
+                    "frame_filter": "step=2",
+                    "server_files[0]": "manifest.jsonl",
+                },
+                **{
+                    **{"server_files[{}]".format(i): imagename_pattern.format(i) for i in range(1, 8)},
+                }
+            }
+        )
+
+        cls.media_data.extend([
+            # image list local
+            {
                 "client_files[0]": generate_image_file("test_1.jpg")[1],
                 "client_files[1]": generate_image_file("test_2.jpg")[1],
                 "client_files[2]": generate_image_file("test_3.jpg")[1],
                 "image_quality": 75,
-            }
-            response = self.client.post("/api/v1/tasks/{}/data".format(tid), data=images)
-            assert response.status_code == status.HTTP_202_ACCEPTED
-            self.tasks.append(tid)
+            },
+            # video local
+            {
+                "client_files[0]": generate_video_file("test_video.mp4")[1],
+                "image_quality": 75,
+            },
+            # zip archive local
+            {
+                "client_files[0]": generate_zip_archive_file("test_archive_1.zip", 10)[1],
+                "image_quality": 50,
+            },
+            # pdf local
+            {
+                "client_files[0]": generate_pdf_file("test_pdf_1.pdf", 7)[1],
+                "image_quality": 54,
+            },
+        ])
+
+    def tearDown(self):
+        for task in self.tasks:
+            shutil.rmtree(os.path.join(settings.TASKS_ROOT, str(task["id"])))
+            shutil.rmtree(os.path.join(settings.MEDIA_DATA_ROOT, str(task["data_id"])))
 
-            response = self.client.post('/api/v1/tasks', data=data, format="json")
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        path = os.path.join(settings.SHARE_ROOT, "test_1.jpg")
+        os.remove(path)
+
+        path = os.path.join(settings.SHARE_ROOT, "test_2.jpg")
+        os.remove(path)
+
+        path = os.path.join(settings.SHARE_ROOT, "test_3.jpg")
+        os.remove(path)
+
+        path = os.path.join(settings.SHARE_ROOT, "test_video_1.mp4")
+        os.remove(path)
+
+        path = os.path.join(settings.SHARE_ROOT, "videos", "test_video_1.mp4")
+        os.remove(path)
+
+        path = os.path.join(settings.SHARE_ROOT, "videos", "manifest.jsonl")
+        os.remove(path)
+        os.rmdir(os.path.dirname(path))
+
+        path = os.path.join(settings.SHARE_ROOT, "test_pointcloud_pcd.zip")
+        os.remove(path)
+
+        path = os.path.join(settings.SHARE_ROOT, "test_velodyne_points.zip")
+        os.remove(path)
+
+        path = os.path.join(settings.SHARE_ROOT, "manifest.jsonl")
+        os.remove(path)
+
+    def _create_tasks(self):
+        self.tasks = []
+
+        def _create_task(task_data, media_data):
+            response = self.client.post('/api/v1/tasks', data=task_data, format="json")
             assert response.status_code == status.HTTP_201_CREATED
             tid = response.data["id"]
-            video = {
-                "client_files[0]": generate_video_file("test_video.mp4")[1],
-                "image_quality": 75,
-            }
-            response = self.client.post("/api/v1/tasks/{}/data".format(tid), data=video)
+
+            for media in media_data.values():
+                if isinstance(media, io.BytesIO):
+                    media.seek(0)
+            response = self.client.post("/api/v1/tasks/{}/data".format(tid), data=media_data)
             assert response.status_code == status.HTTP_202_ACCEPTED
-            self.tasks.append(tid)
+            response = self.client.get("/api/v1/tasks/{}".format(tid))
+            data_id = response.data["data"]
+            self.tasks.append({
+                "id": tid,
+                "data_id": data_id,
+            })
+
+        task_data = [
+            {
+                "name": "my task #1",
+                "owner_id": self.owner.id,
+                "assignee_id": self.assignee.id,
+                "overlap": 0,
+                "segment_size": 100,
+                "labels": [{
+                    "name": "car",
+                    "color": "#ff00ff",
+                    "attributes": [{
+                        "name": "bool_attribute",
+                        "mutable": True,
+                        "input_type": AttributeType.CHECKBOX,
+                        "default_value": "true"
+                    }],
+                    }, {
+                        "name": "person",
+                    },
+                ]
+            },
+            {
+                "name": "my task #2",
+                "owner_id": self.owner.id,
+                "assignee_id": self.assignee.id,
+                "overlap": 1,
+                "segment_size": 3,
+                "labels": [{
+                    "name": "car",
+                    "color": "#ff00ff",
+                    "attributes": [{
+                        "name": "bool_attribute",
+                        "mutable": True,
+                        "input_type": AttributeType.CHECKBOX,
+                        "default_value": "true"
+                    }],
+                    }, {
+                        "name": "person",
+                    },
+                ]
+            },
+        ]
+
+        with ForceLogin(self.owner, self.client):
+            for data in task_data:
+                for media in self.media_data:
+                    _create_task(data, media)
 
     def _run_api_v1_tasks_id_export(self, tid, user, query_params=""):
         with ForceLogin(user, self.client):
@@ -1960,6 +2149,12 @@ def _run_api_v1_tasks_id_import(self, user, data):
 
         return response
 
+    def _run_api_v1_tasks_id(self, tid, user):
+        with ForceLogin(user, self.client):
+            response = self.client.get('/api/v1/tasks/{}'.format(tid), format="json")
+
+        return response.data
+
     def _run_api_v1_tasks_id_export_import(self, user):
         if user:
             if user is self.user or user is self.annotator:
@@ -1976,7 +2171,8 @@ def _run_api_v1_tasks_id_export_import(self, user):
             HTTP_201_CREATED = status.HTTP_401_UNAUTHORIZED
 
         self._create_tasks()
-        for tid in self.tasks:
+        for task in self.tasks:
+            tid = task["id"]
             response = self._run_api_v1_tasks_id_export(tid, user, "action=export")
             self.assertEqual(response.status_code, HTTP_202_ACCEPTED)
 
@@ -2000,6 +2196,23 @@ def _run_api_v1_tasks_id_export_import(self, user):
                     rq_id = response.data["rq_id"]
                     response = self._run_api_v1_tasks_id_import(user, {"rq_id": rq_id})
                     self.assertEqual(response.status_code, HTTP_201_CREATED)
+                    original_task = self._run_api_v1_tasks_id(tid, user)
+                    imported_task = self._run_api_v1_tasks_id(response.data["id"], user)
+                    compare_objects(
+                        self=self,
+                        obj1=original_task,
+                        obj2=imported_task,
+                        ignore_keys=(
+                            "id",
+                            "url",
+                            "owner",
+                            "project_id",
+                            "assignee",
+                            "created_date",
+                            "updated_date",
+                            "data",
+                        ),
+                    )
 
     def test_api_v1_tasks_id_export_admin(self):
         self._run_api_v1_tasks_id_export_import(self.admin)
@@ -2271,6 +2484,7 @@ def tearDownClass(cls):
 
         path = os.path.join(settings.SHARE_ROOT, "videos", "manifest.jsonl")
         os.remove(path)
+        os.rmdir(os.path.dirname(path))
 
         path = os.path.join(settings.SHARE_ROOT, "manifest.jsonl")
         os.remove(path)
@@ -2940,7 +3154,7 @@ def compare_objects(self, obj1, obj2, ignore_keys, fp_tolerance=.001):
                 continue
             v2 = obj2[k]
             if k == 'attributes':
-                key = lambda a: a['spec_id']
+                key = lambda a: a['spec_id'] if 'spec_id' in a else a['id']
                 v1.sort(key=key)
                 v2.sort(key=key)
             compare_objects(self, v1, v2, ignore_keys)
diff --git a/cvat/apps/engine/views.py b/cvat/apps/engine/views.py
index d81e3c2db49..dcb1656d0b1 100644
--- a/cvat/apps/engine/views.py
+++ b/cvat/apps/engine/views.py
@@ -390,7 +390,7 @@ def create(self, request):
                         f.write(chunk)
                 rq_job = queue.enqueue_call(
                     func=import_task,
-                    args=(filename,),
+                    args=(filename, request.user.id),
                     job_id=rq_id,
                 )
                 rq_job.meta['tmp_file'] = filename

From c956914fc461a07a38af12d96f0c911c014c2ef8 Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Tue, 11 May 2021 11:10:13 +0300
Subject: [PATCH 14/19] updated changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bfeb7189d19..45afdc8798a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Hotkeys to switch a label of existing object or to change default label (for objects created with N) (<https://github.com/openvinotoolkit/cvat/pull/3070>)
 - A script to convert some kinds of DICOM files to regular images (<https://github.com/openvinotoolkit/cvat/pull/3095>)
 - Helm chart prototype (<https://github.com/openvinotoolkit/cvat/pull/3102>)
+- Ability to export/import tasks (<https://github.com/openvinotoolkit/cvat/pull/3056>)
 
 ### Changed
 

From e7438e3fa8a0a17dfc8d29bf4327e46008901b03 Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Thu, 13 May 2021 13:06:49 +0300
Subject: [PATCH 15/19] fixed Maria's comments

---
 cvat/apps/engine/backup.py           |  4 +++-
 cvat/apps/engine/media_extractors.py |  9 +++++----
 cvat/apps/engine/task.py             | 13 +++++++++----
 utils/cli/core/core.py               |  9 +++++----
 4 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index 7e1e520950c..5b48222b9a0 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -145,7 +145,7 @@ def _write_data(self, zip_object):
                 zip_object=zip_object,
                 target_dir=self.DATA_DIRNAME,
             )
-        else:
+        elif self._db_data.storage == StorageChoice.SHARE:
             data_dir = settings.SHARE_ROOT
             if hasattr(self._db_data, 'video'):
                 media_files = (os.path.join(data_dir, self._db_data.video.path), )
@@ -166,6 +166,8 @@ def _write_data(self, zip_object):
                 files=(os.path.join(upload_dir, f) for f in ('manifest.jsonl', 'index.json')),
                 target_dir=self.DATA_DIRNAME
             )
+        else:
+            raise NotImplementedError()
 
     def _write_task(self, zip_object):
         task_dir = self._db_task.get_task_dirname()
diff --git a/cvat/apps/engine/media_extractors.py b/cvat/apps/engine/media_extractors.py
index 71b887556db..bd851179946 100644
--- a/cvat/apps/engine/media_extractors.py
+++ b/cvat/apps/engine/media_extractors.py
@@ -755,15 +755,15 @@ def process_files(self, root, actual_path, files):
         pcd_files = {}
 
         for file in files:
-            file_name, file_extension = file.rsplit('.', maxsplit=1)
+            file_name, file_extension = os.path.splitext(file)
             file_path = os.path.abspath(os.path.join(root, file))
 
-            if file_extension == "bin":
+            if file_extension == ".bin":
                 path = self.bin_operation(file_path, actual_path)
                 pcd_files[file_name] = path
                 self.related_files[path] = []
 
-            elif file_extension == "pcd":
+            elif file_extension == ".pcd":
                 path = ValidateDimension.pcd_operation(file_path, actual_path)
                 if path == file_path:
                     self.image_files[file_name] = file_path
@@ -771,7 +771,8 @@ def process_files(self, root, actual_path, files):
                     pcd_files[file_name] = path
                     self.related_files[path] = []
             else:
-                self.image_files[file_name] = file_path
+                if _is_image(file_path):
+                    self.image_files[file_name] = file_path
         return pcd_files
 
     def validate_velodyne_points(self, *args):
diff --git a/cvat/apps/engine/task.py b/cvat/apps/engine/task.py
index 54354e7509e..2b393526e68 100644
--- a/cvat/apps/engine/task.py
+++ b/cvat/apps/engine/task.py
@@ -265,11 +265,17 @@ def _create_thread(tid, data, isImport=False):
                 stop=data['stop_frame'],
             )
 
+
     validate_dimension = ValidateDimension()
-    if extractor.__class__ == MEDIA_TYPES['zip']['extractor']:
+    if isinstance(extractor, MEDIA_TYPES['zip']['extractor']):
         extractor.extract()
-    validate_dimension.set_path(upload_dir)
-    validate_dimension.validate()
+
+    if db_data.storage == models.StorageChoice.LOCAL or \
+        (db_data.storage == models.StorageChoice.SHARE and \
+        isinstance(extractor, MEDIA_TYPES['zip']['extractor'])):
+        validate_dimension.set_path(upload_dir)
+        validate_dimension.validate()
+
     if validate_dimension.dimension == models.DimensionType.DIM_3D:
         db_task.dimension = models.DimensionType.DIM_3D
 
@@ -324,7 +330,6 @@ def update_progress(progress):
         else:
             db_data.chunk_size = 36
 
-
     video_path = ""
     video_size = (0, 0)
 
diff --git a/utils/cli/core/core.py b/utils/cli/core/core.py
index 5e7cbd7826c..df262c8f9e6 100644
--- a/utils/cli/core/core.py
+++ b/utils/cli/core/core.py
@@ -227,10 +227,11 @@ def tasks_export(self, task_id, filename, export_verification_period=3, **kwargs
     def tasks_import(self, filename, import_verification_period=3, **kwargs):
         """ Import a task"""
         url = self.api.tasks + '?action=import'
-        response = self.session.post(
-                url,
-                files={'task_file': open(filename, 'rb')}
-            )
+        with open(filename, 'rb') as input_file:
+            response = self.session.post(
+                    url,
+                    files={'task_file': input_file}
+                )
         response.raise_for_status()
         response_json = response.json()
         rq_id = response_json['rq_id']

From 1aae8f942d5940b6879cdb60c562fb7fe1dfc64f Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Fri, 28 May 2021 11:01:07 +0300
Subject: [PATCH 16/19] fixed comments

---
 .../src/components/tasks-page/tasks-page.tsx  |  13 +-
 cvat/apps/engine/backup.py                    | 185 ++++++++++++------
 cvat/apps/engine/views.py                     |   8 +-
 3 files changed, 137 insertions(+), 69 deletions(-)

diff --git a/cvat-ui/src/components/tasks-page/tasks-page.tsx b/cvat-ui/src/components/tasks-page/tasks-page.tsx
index 9c429d8bf53..6e0df457716 100644
--- a/cvat-ui/src/components/tasks-page/tasks-page.tsx
+++ b/cvat-ui/src/components/tasks-page/tasks-page.tsx
@@ -84,10 +84,19 @@ class TasksPageComponent extends React.PureComponent<TasksPageProps & RouteCompo
 
     public componentDidUpdate(prevProps: TasksPageProps & RouteComponentProps): void {
         const {
-            location, gettingQuery, tasksFetching, numberOfHiddenTasks, onGetTasks, hideEmptyTasks,
+            location,
+            gettingQuery,
+            tasksFetching,
+            numberOfHiddenTasks,
+            onGetTasks,
+            hideEmptyTasks,
+            taskImporting,
         } = this.props;
 
-        if (prevProps.location.search !== location.search) {
+        if (
+            prevProps.location.search !== location.search ||
+            (prevProps.taskImporting === true && taskImporting === false)
+        ) {
             // get new tasks if any query changes
             const query = updateQuery(gettingQuery, location.search);
             message.destroy();
diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index 5b48222b9a0..69a958e7206 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -18,7 +18,7 @@
 from cvat.apps.engine.serializers import (AttributeSerializer, DataSerializer,
     LabeledDataSerializer, SegmentSerializer, SimpleJobSerializer, TaskSerializer)
 from cvat.apps.engine.utils import av_scan_paths
-from cvat.apps.engine.models import StorageChoice, StorageMethodChoice, DataChoice, Job
+from cvat.apps.engine.models import StorageChoice, StorageMethodChoice, DataChoice
 from cvat.apps.engine.task import _create_thread
 
 
@@ -78,18 +78,37 @@ def _prepare_segment_meta(self, segments):
         }
         return self._prepare_meta(allowed_fields, segments)
 
-    def _prepare_job_meta(self, jobs):
+    def _prepare_job_meta(self, job):
         allowed_fields = {
-            'id',
             'status',
         }
-        return self._prepare_meta(allowed_fields, jobs)
+        return self._prepare_meta(allowed_fields, job)
 
-    def _prepare_annotations(self, annotations):
+    def _prepare_attribute_meta(self, attribute):
         allowed_fields = {
+            'name',
+            'mutable',
+            'input_type',
+            'default_value',
+            'values',
+        }
+        return self._prepare_meta(allowed_fields, attribute)
+
+    def _prepare_label_meta(self, labels):
+        allowed_fields = {
+            'name',
+            'color',
+            'attributes',
+        }
+        return self._prepare_meta(allowed_fields, labels)
+
+    def _prepare_annotations(self, annotations, label_mapping):
+        allowed_fields = {
+            'label',
             'label_id',
             'type',
             'occluded',
+            'outside',
             'z_order',
             'points',
             'frame',
@@ -99,11 +118,43 @@ def _prepare_annotations(self, annotations):
             'shapes',
         }
 
+        def _update_attribute(attribute, label):
+            if 'name' in attribute:
+                source, dest = attribute.pop('name'), 'spec_id'
+            else:
+                source, dest = attribute.pop('spec_id'), 'name'
+            attribute[dest] = label_mapping[label]['attributes'][source]
+
+        def _update_label(shape):
+            if 'label_id' in shape:
+                source, dest = shape.pop('label_id'), 'label'
+            elif 'label' in shape:
+                source, dest = shape.pop('label'), 'label_id'
+            shape[dest] = label_mapping[source]['value']
+
+            return source
+
         for tag in annotations['tags']:
+            label = _update_label(tag)
+            for attr in tag['attributes']:
+                _update_attribute(attr, label)
             self._prepare_meta(allowed_fields, tag)
+
         for shape in annotations['shapes']:
+            label = _update_label(shape)
+            for attr in shape['attributes']:
+                _update_attribute(attr, label)
             self._prepare_meta(allowed_fields, shape)
+
         for track in annotations['tracks']:
+            label = _update_label(track)
+            for shape in track['shapes']:
+                for attr in shape['attributes']:
+                    _update_attribute(attr, label)
+                self._prepare_meta(allowed_fields, shape)
+
+            for attr in track['attributes']:
+                _update_attribute(attr, label)
             self._prepare_meta(allowed_fields, track)
 
         return annotations
@@ -115,6 +166,20 @@ def __init__(self, pk, version=Version.V1):
         self._db_data = self._db_task.data
         self._version = version
 
+        db_labels = (self._db_task.project if self._db_task.project_id else self._db_task).label_set.all().prefetch_related(
+            'attributespec_set')
+
+        self._label_mapping = {}
+        self._label_mapping = {db_label.id: db_label.name for db_label in db_labels}
+        self._attribute_mapping = {}
+        for db_label in db_labels:
+            self._label_mapping[db_label.id] = {
+                'value': db_label.name,
+                'attributes': {},
+            }
+            for db_attribute in db_label.attributespec_set.all():
+                self._label_mapping[db_label.id]['attributes'][db_attribute.id] = db_attribute.name
+
     def _write_files(self, source_dir, zip_object, files, target_dir):
         for filename in files:
             arcname = os.path.normpath(
@@ -163,7 +228,7 @@ def _write_data(self, zip_object):
             self._write_files(
                 source_dir=upload_dir,
                 zip_object=zip_object,
-                files=(os.path.join(upload_dir, f) for f in ('manifest.jsonl', 'index.json')),
+                files=(os.path.join(upload_dir, f) for f in ('manifest.jsonl',)),
                 target_dir=self.DATA_DIRNAME
             )
         else:
@@ -186,22 +251,32 @@ def serialize_task():
             task_serializer.fields.pop('assignee')
             task_serializer.fields.pop('segments')
 
-            return self._prepare_task_meta(task_serializer.data)
+            task = self._prepare_task_meta(task_serializer.data)
+            task['labels'] = [self._prepare_label_meta(l) for l in task['labels']]
+            for label in task['labels']:
+                label['attributes'] = [self._prepare_attribute_meta(a) for a in label['attributes']]
+
+            return task
+
+        def serialize_segment(db_segment):
+            db_job = db_segment.job_set.first()
+            job_serializer = SimpleJobSerializer(db_job)
+            job_serializer.fields.pop('url')
+            job_serializer.fields.pop('assignee')
+            job_serializer.fields.pop('reviewer')
+            job_data = self._prepare_job_meta(job_serializer.data)
+
+            segment_serailizer = SegmentSerializer(db_segment)
+            segment_serailizer.fields.pop('jobs')
+            segment = segment_serailizer.data
+            segment.update(job_data)
+
+            return segment
 
         def serialize_jobs():
-            task_jobs = []
-            for db_segment in self._db_task.segment_set.all():
-                db_job = db_segment.job_set.first()
-                job_serializer = SimpleJobSerializer(db_job)
-                job_serializer.fields.pop('url')
-                job_data = self._prepare_job_meta(job_serializer.data)
-                segment_serailizer = SegmentSerializer(db_segment)
-                segment_serailizer.fields.pop('jobs')
-                segment = segment_serailizer.data
-                segment.update(job_data)
-                task_jobs.append(segment)
-
-            return task_jobs
+            db_segments = list(self._db_task.segment_set.all())
+            db_segments.sort(key=lambda i: i.job_set.first().id)
+            return (serialize_segment(s) for s in db_segments)
 
         def serialize_data():
             data_serializer = DataSerializer(self._db_data)
@@ -218,13 +293,15 @@ def serialize_data():
 
     def _write_annotations(self, zip_object):
         def serialize_annotations():
-            job_annotations = {}
-            for db_segment in self._db_task.segment_set.all():
-                for db_job in db_segment.job_set.all():
-                    annotations = dm.task.get_job_data(db_job.id)
-                    annotations_serializer = LabeledDataSerializer(data=annotations)
-                    annotations_serializer.is_valid(raise_exception=True)
-                    job_annotations[db_job.id] = self._prepare_annotations(annotations_serializer.data)
+            job_annotations = []
+            db_segments = list(self._db_task.segment_set.all())
+            db_segments.sort(key=lambda i: i.job_set.first().id)
+            db_job_ids = (s.job_set.first().id for s in db_segments)
+            for db_job_id in db_job_ids:
+                annotations = dm.task.get_job_data(db_job_id)
+                annotations_serializer = LabeledDataSerializer(data=annotations)
+                annotations_serializer.is_valid(raise_exception=True)
+                job_annotations.append(self._prepare_annotations(annotations_serializer.data, self._label_mapping))
 
             return job_annotations
 
@@ -247,12 +324,12 @@ def __init__(self, filename, user_id):
         self._user_id = user_id
         self._manifest, self._annotations = self._read_meta()
         self._version = self._read_version()
+        self._labels_mapping = {}
 
     def _read_meta(self):
         with ZipFile(self._filename, 'r') as input_file:
             manifest = JSONParser().parse(io.BytesIO(input_file.read(self.MANIFEST_FILENAME)))
             annotations = JSONParser().parse(io.BytesIO(input_file.read(self.ANNOTATIONS_FILENAME)))
-            annotations = {int(job_id): job_annotations for job_id, job_annotations in annotations.items()}
 
             return manifest, annotations
 
@@ -271,42 +348,27 @@ def _prepare_dirs(filepath):
 
     def _create_labels(self, db_task, labels):
         label_mapping = {}
-        attribute_mapping = {}
 
         for label in labels:
-            label_id = label.pop('id')
+            label_name = label['name']
             attributes = label.pop('attributes', [])
             db_label = models.Label.objects.create(task=db_task, **label)
-            label_mapping[label_id] = db_label.id
+            label_mapping[label_name] = {
+                'value': db_label.id,
+                'attributes': {},
+            }
 
             for attribute in attributes:
-                attribute_id = attribute.pop('id')
+                attribute_name = attribute['name']
                 attribute_serializer = AttributeSerializer(data=attribute)
                 attribute_serializer.is_valid(raise_exception=True)
                 db_attribute = attribute_serializer.save(label=db_label)
-                attribute_mapping[attribute_id] = db_attribute.id
-
-        return label_mapping, attribute_mapping
+                label_mapping[label_name]['attributes'][attribute_name] = db_attribute.id
 
-    def _update_annotations(self, labels_mapping, attributes_mapping, annotations):
-        def update_ids(objects):
-            for obj in objects:
-                obj['label_id'] = labels_mapping[obj['label_id']]
-                for attribute in obj['attributes']:
-                    attribute['spec_id'] = attributes_mapping[attribute['spec_id']]
+        return label_mapping
 
-        update_ids(annotations['tags'])
-        update_ids(annotations['shapes'])
-        update_ids(annotations['tracks'])
-        for track in annotations['tracks']:
-            for track_shape in track['shapes']:
-                track_shape.pop('id')
-                for attribute in track_shape['attributes']:
-                    attribute['spec_id'] = attributes_mapping[attribute['spec_id']]
-
-    def _create_annotations(self, db_job, labels_mapping, attributes_mapping, annotations):
-        self._update_annotations(labels_mapping, attributes_mapping, annotations)
-        self._prepare_annotations(annotations)
+    def _create_annotations(self, db_job, annotations):
+        self._prepare_annotations(annotations, self._labels_mapping)
 
         serializer = LabeledDataSerializer(data=annotations)
         serializer.is_valid(raise_exception=True)
@@ -342,7 +404,7 @@ def _import_task(self):
         os.makedirs(self._db_task.get_task_logs_dirname())
         os.makedirs(self._db_task.get_task_artifacts_dirname())
 
-        self._labels_mapping, self._attributes_mapping = self._create_labels(self._db_task, labels)
+        self._labels_mapping = self._create_labels(self._db_task, labels)
 
         self._prepare_data_meta(data)
         data_serializer = DataSerializer(data=data)
@@ -378,17 +440,12 @@ def _import_task(self):
         db_data.save(update_fields=['start_frame', 'stop_frame', 'frame_filter', 'storage'])
 
     def _import_annotations(self):
-        job_mapping = {}
-        for db_segment in self._db_task.segment_set.all():
-            for db_job in db_segment.job_set.all():
-                for job in self._jobs:
-                    if db_segment.start_frame == job['start_frame']:
-                        job_mapping[job['id']] = db_job.id
-
-        for job in self._jobs:
-            db_job = Job.objects.get(pk=job_mapping[job['id']])
-            self._create_annotations(db_job, self._labels_mapping, self._attributes_mapping, self._annotations[job['id']])
+        db_segments = list(self._db_task.segment_set.all())
+        db_segments.sort(key=lambda i: i.job_set.first().id)
+        db_jobs = (s.job_set.first() for s in db_segments)
 
+        for db_job, annotations in zip(db_jobs, self._annotations):
+            self._create_annotations(db_job, annotations)
 
     def import_task(self):
         self._import_task()
diff --git a/cvat/apps/engine/views.py b/cvat/apps/engine/views.py
index dcb1656d0b1..37233d81ee3 100644
--- a/cvat/apps/engine/views.py
+++ b/cvat/apps/engine/views.py
@@ -392,10 +392,12 @@ def create(self, request):
                     func=import_task,
                     args=(filename, request.user.id),
                     job_id=rq_id,
+                    meta={
+                        'tmp_file': filename,
+                        'tmp_file_descriptor': fd,
+                    },
                 )
-                rq_job.meta['tmp_file'] = filename
-                rq_job.meta['tmp_file_descriptor'] = fd
-                rq_job.save_meta()
+
             else:
                 if rq_job.is_finished:
                     task_id = rq_job.return_value

From 3a1bd568c7627ffecbb8c51be7d9590502db894d Mon Sep 17 00:00:00 2001
From: Boris Sekachev <boris.sekachev@intel.com>
Date: Thu, 3 Jun 2021 22:02:57 +0300
Subject: [PATCH 17/19] Fixed position of create new task button

---
 cvat-ui/src/components/tasks-page/styles.scss |   8 ++
 cvat-ui/src/components/tasks-page/top-bar.tsx | 104 +++++++++---------
 2 files changed, 63 insertions(+), 49 deletions(-)

diff --git a/cvat-ui/src/components/tasks-page/styles.scss b/cvat-ui/src/components/tasks-page/styles.scss
index 7d934b34b38..0516d4753a4 100644
--- a/cvat-ui/src/components/tasks-page/styles.scss
+++ b/cvat-ui/src/components/tasks-page/styles.scss
@@ -11,6 +11,14 @@
     height: 100%;
     width: 100%;
 
+    .cvat-tasks-page-top-bar {
+        > div:nth-child(1) {
+            > div:nth-child(1) {
+                width: 100%;
+            }
+        }
+    }
+
     > div:nth-child(2) {
         height: 83%;
         padding-top: 10px;
diff --git a/cvat-ui/src/components/tasks-page/top-bar.tsx b/cvat-ui/src/components/tasks-page/top-bar.tsx
index 5b7a0291a32..af8aa1ba319 100644
--- a/cvat-ui/src/components/tasks-page/top-bar.tsx
+++ b/cvat-ui/src/components/tasks-page/top-bar.tsx
@@ -28,54 +28,60 @@ export default function TopBarComponent(props: VisibleTopBarProps): JSX.Element
     const history = useHistory();
 
     return (
-        <>
-            <Row justify='center' align='middle' gutter={8}>
-                <Col md={8} lg={7} xl={6} xxl={5}>
-                    <Text className='cvat-title'>Tasks</Text>
-                    <SearchTooltip instance='task'>
-                        <Input.Search
-                            className='cvat-task-page-search-task'
-                            defaultValue={searchValue}
-                            onSearch={onSearch}
-                            size='large'
-                            placeholder='Search'
-                        />
-                    </SearchTooltip>
-                </Col>
-                <Col md={{ span: 8 }} lg={{ span: 7 }} xl={{ span: 6 }} xxl={{ span: 6 }}>
-                    <Upload
-                        accept='.zip'
-                        multiple={false}
-                        showUploadList={false}
-                        beforeUpload={(file: File): boolean => {
-                            onFileUpload(file);
-                            return false;
-                        }}
-                    >
-                        <Button
-                            size='large'
-                            id='cvat-import-task-button'
-                            type='primary'
-                            disabled={taskImporting}
-                            icon={<UploadOutlined />}
-                        >
-                            Import Task
-                            {taskImporting && <LoadingOutlined id='cvat-import-task-button-loading' />}
-                        </Button>
-                    </Upload>
-                </Col>
-                <Col md={{ span: 6 }} lg={{ span: 4 }} xl={{ span: 3 }} xxl={{ span: 3 }}>
-                    <Button
-                        size='large'
-                        id='cvat-create-task-button'
-                        type='primary'
-                        onClick={(): void => history.push('/tasks/create')}
-                        icon={<PlusOutlined />}
-                    >
-                        Create new task
-                    </Button>
-                </Col>
-            </Row>
-        </>
+        <Row className='cvat-tasks-page-top-bar' justify='center' align='middle'>
+            <Col md={22} lg={18} xl={16} xxl={14}>
+                <Row justify='space-between' align='bottom'>
+                    <Col>
+                        <Text className='cvat-title'>Tasks</Text>
+                        <SearchTooltip instance='task'>
+                            <Input.Search
+                                className='cvat-task-page-search-task'
+                                defaultValue={searchValue}
+                                onSearch={onSearch}
+                                size='large'
+                                placeholder='Search'
+                            />
+                        </SearchTooltip>
+                    </Col>
+                    <Col>
+                        <Row gutter={8}>
+                            <Col>
+                                <Upload
+                                    accept='.zip'
+                                    multiple={false}
+                                    showUploadList={false}
+                                    beforeUpload={(file: File): boolean => {
+                                        onFileUpload(file);
+                                        return false;
+                                    }}
+                                >
+                                    <Button
+                                        size='large'
+                                        id='cvat-import-task-button'
+                                        type='primary'
+                                        disabled={taskImporting}
+                                        icon={<UploadOutlined />}
+                                    >
+                                        Import Task
+                                        {taskImporting && <LoadingOutlined id='cvat-import-task-button-loading' />}
+                                    </Button>
+                                </Upload>
+                            </Col>
+                            <Col>
+                                <Button
+                                    size='large'
+                                    id='cvat-create-task-button'
+                                    type='primary'
+                                    onClick={(): void => history.push('/tasks/create')}
+                                    icon={<PlusOutlined />}
+                                >
+                                    Create new task
+                                </Button>
+                            </Col>
+                        </Row>
+                    </Col>
+                </Row>
+            </Col>
+        </Row>
     );
 }

From 78eef6647ba2acc6e1e0c15ab962473cdef566c3 Mon Sep 17 00:00:00 2001
From: Boris Sekachev <boris.sekachev@intel.com>
Date: Fri, 4 Jun 2021 10:01:42 +0300
Subject: [PATCH 18/19] Fixed span position

---
 cvat-ui/src/components/tasks-page/styles.scss | 25 +++++++------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/cvat-ui/src/components/tasks-page/styles.scss b/cvat-ui/src/components/tasks-page/styles.scss
index 0516d4753a4..2c6dce8ce44 100644
--- a/cvat-ui/src/components/tasks-page/styles.scss
+++ b/cvat-ui/src/components/tasks-page/styles.scss
@@ -15,6 +15,15 @@
         > div:nth-child(1) {
             > div:nth-child(1) {
                 width: 100%;
+
+                > div:nth-child(1) {
+                    display: flex;
+
+                    > span:nth-child(2) {
+                        width: 200px;
+                        margin-left: 10px;
+                    }
+                }
             }
         }
     }
@@ -27,22 +36,6 @@
     > div:nth-child(3) {
         padding-top: 10px;
     }
-
-    > div:nth-child(1) {
-        > div:nth-child(1) {
-            display: flex;
-
-            > span:nth-child(2) {
-                width: 200px;
-                margin-left: 10px;
-            }
-        }
-
-        > div:nth-child(2) {
-            display: flex;
-            justify-content: flex-end;
-        }
-    }
 }
 
 /* empty-tasks icon */

From 32aacc4655c2a9f58107f93a90c667a3ebb46000 Mon Sep 17 00:00:00 2001
From: Andrey Zhavoronkov <andrey.zhavoronkov@intel.com>
Date: Mon, 7 Jun 2021 10:26:16 +0300
Subject: [PATCH 19/19] fixed comments

---
 cvat/apps/engine/backup.py | 139 ++++++++++++++++++++++++++++++-------
 cvat/apps/engine/task.py   |   5 +-
 cvat/apps/engine/views.py  |   5 +-
 3 files changed, 120 insertions(+), 29 deletions(-)

diff --git a/cvat/apps/engine/backup.py b/cvat/apps/engine/backup.py
index 69a958e7206..da42cab6b30 100644
--- a/cvat/apps/engine/backup.py
+++ b/cvat/apps/engine/backup.py
@@ -9,6 +9,7 @@
 from zipfile import ZipFile
 
 from django.conf import settings
+from django.db import transaction
 from rest_framework.parsers import JSONParser
 from rest_framework.renderers import JSONRenderer
 
@@ -16,7 +17,8 @@
 from cvat.apps.engine import models
 from cvat.apps.engine.log import slogger
 from cvat.apps.engine.serializers import (AttributeSerializer, DataSerializer,
-    LabeledDataSerializer, SegmentSerializer, SimpleJobSerializer, TaskSerializer)
+    LabeledDataSerializer, SegmentSerializer, SimpleJobSerializer, TaskSerializer,
+    ReviewSerializer, IssueSerializer, CommentSerializer)
 from cvat.apps.engine.utils import av_scan_paths
 from cvat.apps.engine.models import StorageChoice, StorageMethodChoice, DataChoice
 from cvat.apps.engine.task import _create_thread
@@ -71,13 +73,6 @@ def _prepare_data_meta(self, data):
 
         return data
 
-    def _prepare_segment_meta(self, segments):
-        allowed_fields = {
-            'start_frame',
-            'stop_frame',
-        }
-        return self._prepare_meta(allowed_fields, segments)
-
     def _prepare_job_meta(self, job):
         allowed_fields = {
             'status',
@@ -159,10 +154,43 @@ def _update_label(shape):
 
         return annotations
 
+    def _prepare_review_meta(self, review):
+        allowed_fields = {
+            'estimated_quality',
+            'status',
+            'issues',
+        }
+        return self._prepare_meta(allowed_fields, review)
+
+    def _prepare_issue_meta(self, issue):
+        allowed_fields = {
+            'frame',
+            'position',
+            'created_date',
+            'resolved_date',
+            'comments',
+        }
+        return self._prepare_meta(allowed_fields, issue)
+
+    def _prepare_comment_meta(self, comment):
+        allowed_fields = {
+            'message',
+            'created_date',
+            'updated_date',
+        }
+        return self._prepare_meta(allowed_fields, comment)
+
+    def _get_db_jobs(self):
+        if self._db_task:
+            db_segments = list(self._db_task.segment_set.all().prefetch_related('job_set'))
+            db_segments.sort(key=lambda i: i.job_set.first().id)
+            db_jobs = (s.job_set.first() for s in db_segments)
+            return db_jobs
+        return ()
+
 class TaskExporter(_TaskBackupBase):
     def __init__(self, pk, version=Version.V1):
         self._db_task = models.Task.objects.prefetch_related('data__images').select_related('data__video').get(pk=pk)
-        self._db_task.segment_set.all().prefetch_related('job_set')
         self._db_data = self._db_task.data
         self._version = version
 
@@ -258,6 +286,32 @@ def serialize_task():
 
             return task
 
+        def serialize_comment(db_comment):
+            comment_serializer = CommentSerializer(db_comment)
+            comment_serializer.fields.pop('author')
+
+            return self._prepare_comment_meta(comment_serializer.data)
+
+        def serialize_issue(db_issue):
+            issue_serializer = IssueSerializer(db_issue)
+            issue_serializer.fields.pop('owner')
+            issue_serializer.fields.pop('resolver')
+
+            issue = issue_serializer.data
+            issue['comments'] = (serialize_comment(c) for c in db_issue.comment_set.order_by('id'))
+
+            return self._prepare_issue_meta(issue)
+
+        def serialize_review(db_review):
+            review_serializer = ReviewSerializer(db_review)
+            review_serializer.fields.pop('reviewer')
+            review_serializer.fields.pop('assignee')
+
+            review = review_serializer.data
+            review['issues'] = (serialize_issue(i) for i in db_review.issue_set.order_by('id'))
+
+            return self._prepare_review_meta(review)
+
         def serialize_segment(db_segment):
             db_job = db_segment.job_set.first()
             job_serializer = SimpleJobSerializer(db_job)
@@ -271,6 +325,9 @@ def serialize_segment(db_segment):
             segment = segment_serailizer.data
             segment.update(job_data)
 
+            db_reviews = db_job.review_set.order_by('id')
+            segment['reviews'] = (serialize_review(r) for r in db_reviews)
+
             return segment
 
         def serialize_jobs():
@@ -294,9 +351,8 @@ def serialize_data():
     def _write_annotations(self, zip_object):
         def serialize_annotations():
             job_annotations = []
-            db_segments = list(self._db_task.segment_set.all())
-            db_segments.sort(key=lambda i: i.job_set.first().id)
-            db_job_ids = (s.job_set.first().id for s in db_segments)
+            db_jobs = self._get_db_jobs()
+            db_job_ids = (j.id for j in db_jobs)
             for db_job_id in db_job_ids:
                 annotations = dm.task.get_job_data(db_job_id)
                 annotations_serializer = LabeledDataSerializer(data=annotations)
@@ -325,6 +381,7 @@ def __init__(self, filename, user_id):
         self._manifest, self._annotations = self._read_meta()
         self._version = self._read_version()
         self._labels_mapping = {}
+        self._db_task = None
 
     def _read_meta(self):
         with ZipFile(self._filename, 'r') as input_file:
@@ -374,12 +431,6 @@ def _create_annotations(self, db_job, annotations):
         serializer.is_valid(raise_exception=True)
         dm.task.put_job_data(db_job.id, serializer.data)
 
-    def _create_data(self, data):
-        data_serializer = DataSerializer(data=data)
-        data_serializer.is_valid(raise_exception=True)
-        db_data = data_serializer.save()
-        return db_data
-
     @staticmethod
     def _calculate_segment_size(jobs):
         segment_size = jobs[0]['stop_frame'] - jobs[0]['start_frame'] + 1
@@ -388,12 +439,47 @@ def _calculate_segment_size(jobs):
         return segment_size, overlap
 
     def _import_task(self):
+
+        def _create_comment(comment, db_issue):
+            comment['issue'] = db_issue.id
+            comment_serializer = CommentSerializer(data=comment)
+            comment_serializer.is_valid(raise_exception=True)
+            db_comment = comment_serializer.save()
+            return db_comment
+
+        def _create_issue(issue, db_review, db_job):
+            issue['review'] = db_review.id
+            issue['job'] = db_job.id
+            comments = issue.pop('comments')
+
+            issue_serializer = IssueSerializer(data=issue)
+            issue_serializer.is_valid( raise_exception=True)
+            db_issue = issue_serializer.save()
+
+            for comment in comments:
+                _create_comment(comment, db_issue)
+
+            return db_issue
+
+        def _create_review(review, db_job):
+            review['job'] = db_job.id
+            issues = review.pop('issues')
+
+            review_serializer = ReviewSerializer(data=review)
+            review_serializer.is_valid(raise_exception=True)
+            db_review = review_serializer.save()
+
+            for issue in issues:
+                _create_issue(issue, db_review, db_job)
+
+            return db_review
+
         data = self._manifest.pop('data')
         labels = self._manifest.pop('labels')
-        self._jobs = self._manifest.pop('jobs')
+        jobs = self._manifest.pop('jobs')
 
         self._prepare_task_meta(self._manifest)
-        self._manifest['segment_size'], self._manifest['overlap'] = self._calculate_segment_size(self._jobs)
+        self._manifest['segment_size'], self._manifest['overlap'] = self._calculate_segment_size(jobs)
         self._manifest["owner_id"] = self._user_id
 
         self._db_task = models.Task.objects.create(**self._manifest)
@@ -439,11 +525,15 @@ def _import_task(self):
         db_data.storage = StorageChoice.LOCAL
         db_data.save(update_fields=['start_frame', 'stop_frame', 'frame_filter', 'storage'])
 
-    def _import_annotations(self):
-        db_segments = list(self._db_task.segment_set.all())
-        db_segments.sort(key=lambda i: i.job_set.first().id)
-        db_jobs = (s.job_set.first() for s in db_segments)
+        for db_job, job in zip(self._get_db_jobs(), jobs):
+            db_job.status = job['status']
+            db_job.save()
 
+            for review in job['reviews']:
+                _create_review(review, db_job)
+
+    def _import_annotations(self):
+        db_jobs = self._get_db_jobs()
         for db_job, annotations in zip(db_jobs, self._annotations):
             self._create_annotations(db_job, annotations)
 
@@ -452,6 +542,7 @@ def import_task(self):
         self._import_annotations()
         return self._db_task
 
+@transaction.atomic
 def import_task(filename, user):
     av_scan_paths(filename)
     task_importer = TaskImporter(filename, user)
diff --git a/cvat/apps/engine/task.py b/cvat/apps/engine/task.py
index ad0c385ce83..a026c3b9e93 100644
--- a/cvat/apps/engine/task.py
+++ b/cvat/apps/engine/task.py
@@ -39,12 +39,13 @@ def create(tid, data):
 @transaction.atomic
 def rq_handler(job, exc_type, exc_value, traceback):
     splitted = job.id.split('/')
-    tid = int(splitted[splitted.index('tasks') + 1])
+    tid = splitted[splitted.index('tasks') + 1]
     try:
+        tid = int(tid)
         db_task = models.Task.objects.select_for_update().get(pk=tid)
         with open(db_task.get_log_path(), "wt") as log_file:
             print_exception(exc_type, exc_value, traceback, file=log_file)
-    except models.Task.DoesNotExist:
+    except (models.Task.DoesNotExist, ValueError):
         pass # skip exceptions in the code
 
     return False
diff --git a/cvat/apps/engine/views.py b/cvat/apps/engine/views.py
index e0f8907f055..2085a37c66a 100644
--- a/cvat/apps/engine/views.py
+++ b/cvat/apps/engine/views.py
@@ -379,7 +379,7 @@ def create(self, request):
             if 'rq_id' in request.data:
                 rq_id = request.data['rq_id']
             else:
-                rq_id = "{}@/api/v1/tasks/{}?action_import".format(request.user, uuid.uuid4())
+                rq_id = "{}@/api/v1/tasks/{}/import".format(request.user, uuid.uuid4())
 
             queue = django_rq.get_queue("default")
             rq_job = queue.fetch_job(rq_id)
@@ -438,7 +438,7 @@ def retrieve(self, request, pk=None):
             return super().retrieve(request, pk)
         elif action in ('export', 'download'):
             queue = django_rq.get_queue("default")
-            rq_id = "/api/v1/tasks/{}?action_export".format(pk)
+            rq_id = "/api/v1/tasks/{}/export".format(pk)
 
             rq_job = queue.fetch_job(rq_id)
             if rq_job:
@@ -484,7 +484,6 @@ def retrieve(self, request, pk=None):
             raise serializers.ValidationError(
                 "Unexpected action specified for the request")
 
-
     def perform_create(self, serializer):
         owner = self.request.data.get('owner', None)
         if owner: