Fixed duplicated notifications for automatic annotation

changelog.d/20240312_155103_klakhov_fix_auto_annotation_notifications.md

@@ -0,0 +1,4 @@
+### Fixed
+
+- Duplicated notifications for automatic annotation
+  (<https://github.com/opencv/cvat/pull/7595>)

cvat-core/src/lambda-manager.ts

@@ -43,7 +43,7 @@
         return { models, count: lambdaFunctions.length };
     }
 
     async run(taskID: number, model: MLModel, args: any) {
         if (!Number.isInteger(taskID) || taskID < 0) {
             throw new ArgumentError(`Argument taskID must be a positive integer. Got "${taskID}"`);
         }
@@ -106,7 +106,7 @@
 
     async listen(
         requestID: string,
-        functionID: string,
+        functionID: string | number,
         callback: (status: RQStatus, progress: number, message?: string) => void,
     ): Promise<void> {
         const model = this.cachedList.find((_model) => _model.id === functionID);

cvat-ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvat-ui",
-  "version": "1.63.3",
+  "version": "1.63.4",
   "description": "CVAT single-page application",
   "main": "src/index.tsx",
   "scripts": {

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

@@ -1,5 +1,5 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -20,6 +20,7 @@ export enum ModelsActionTypes {
     DELETE_MODEL = 'DELETE_MODEL',
     DELETE_MODEL_SUCCESS = 'DELETE_MODEL_SUCCESS',
     DELETE_MODEL_FAILED = 'DELETE_MODEL_FAILED',
+    GET_INFERENCES_SUCCESS = 'GET_INFERENCES_SUCCESS',
     START_INFERENCE_FAILED = 'START_INFERENCE_FAILED',
     GET_INFERENCE_STATUS_SUCCESS = 'GET_INFERENCE_STATUS_SUCCESS',
     GET_INFERENCE_STATUS_FAILED = 'GET_INFERENCE_STATUS_FAILED',
@@ -45,6 +46,9 @@ export const modelsActions = {
         error,
     }),
     fetchMetaFailed: (error: any) => createAction(ModelsActionTypes.FETCH_META_FAILED, { error }),
+    getInferencesSuccess: (requestedInferenceIDs: Record<string, boolean>) => (
+        createAction(ModelsActionTypes.GET_INFERENCES_SUCCESS, { requestedInferenceIDs })
+    ),
     getInferenceStatusSuccess: (taskID: number, activeInference: ActiveInference) => (
         createAction(ModelsActionTypes.GET_INFERENCE_STATUS_SUCCESS, {
             taskID,
@@ -64,9 +68,10 @@ export const modelsActions = {
             error,
         })
     ),
-    cancelInferenceSuccess: (taskID: number) => (
+    cancelInferenceSuccess: (taskID: number, activeInference: ActiveInference) => (
         createAction(ModelsActionTypes.CANCEL_INFERENCE_SUCCESS, {
             taskID,
+            activeInference,
         })
     ),
     cancelInferenceFailed: (taskID: number, error: any) => (
@@ -119,8 +124,9 @@ interface InferenceMeta {
 
 function listen(inferenceMeta: InferenceMeta, dispatch: (action: ModelsActions) => void): void {
     const { taskID, requestID, functionID } = inferenceMeta;
+
     core.lambda
-        .listen(requestID, functionID, (status: RQStatus, progress: number, message: string) => {
+        .listen(requestID, functionID, (status: RQStatus, progress: number, message?: string) => {
             if (status === RQStatus.FAILED || status === RQStatus.UNKNOWN) {
                 dispatch(
                     modelsActions.getInferenceStatusFailed(
@@ -129,7 +135,7 @@ function listen(inferenceMeta: InferenceMeta, dispatch: (action: ModelsActions)
                             status,
                             progress,
                             functionID,
-                            error: message,
+                            error: message as string,
                             id: requestID,
                         },
                         new Error(`Inference status for the task ${taskID} is ${status}. ${message}`),
@@ -144,7 +150,7 @@ function listen(inferenceMeta: InferenceMeta, dispatch: (action: ModelsActions)
                     status,
                     progress,
                     functionID,
-                    error: message,
+                    error: message as string,
                     id: requestID,
                 }),
             );
@@ -163,22 +169,29 @@ function listen(inferenceMeta: InferenceMeta, dispatch: (action: ModelsActions)
 }
 
 export function getInferenceStatusAsync(): ThunkAction {
-    return async (dispatch): Promise<void> => {
+    return async (dispatch, getState): Promise<void> => {
         const dispatchCallback = (action: ModelsActions): void => {
             dispatch(action);
         };
 
+        const { requestedInferenceIDs } = getState().models;
+
         try {
             const requests = await core.lambda.requests();
+            const newListenedIDs: Record<string, boolean> = {};
             requests
                 .map((request: any): object => ({
                     taskID: +request.function.task,
                     requestID: request.id,
                     functionID: request.function.id,
                 }))
                 .forEach((inferenceMeta: InferenceMeta): void => {
-                    listen(inferenceMeta, dispatchCallback);
+                    if (!(inferenceMeta.requestID in requestedInferenceIDs)) {
+                        listen(inferenceMeta, dispatchCallback);
+                        newListenedIDs[inferenceMeta.requestID] = true;
+                    }
                 });
+            dispatch(modelsActions.getInferencesSuccess(newListenedIDs));
         } catch (error) {
             dispatch(modelsActions.fetchMetaFailed(error));
         }
@@ -201,6 +214,7 @@ export function startInferenceAsync(taskId: number, model: MLModel, body: object
                 },
                 dispatchCallback,
             );
+            dispatch(modelsActions.getInferencesSuccess({ [requestID]: true }));
         } catch (error) {
             dispatch(modelsActions.startInferenceFailed(taskId, error));
         }
@@ -212,7 +226,7 @@ export function cancelInferenceAsync(taskID: number): ThunkAction {
         try {
             const inference = getState().models.inferences[taskID];
             await core.lambda.cancel(inference.id, inference.functionID);
-            dispatch(modelsActions.cancelInferenceSuccess(taskID));
+            dispatch(modelsActions.cancelInferenceSuccess(taskID, inference));
         } catch (error) {
             dispatch(modelsActions.cancelInferenceFailed(taskID, error));
         }

cvat-ui/src/reducers/index.ts

@@ -414,6 +414,9 @@ export interface ModelsState {
     reid: MLModel[];
     classifiers: MLModel[];
     totalCount: number;
+    requestedInferenceIDs: {
+        [index: string]: boolean;
+    };
     inferences: {
         [index: number]: ActiveInference;
     };

cvat-ui/src/reducers/models-reducer.ts

@@ -1,8 +1,9 @@
 // Copyright (C) 2020-2022 Intel Corporation
-// Copyright (C) 2022-2023 CVAT.ai Corporation
+// Copyright (C) 2022-2024 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
+import { omit } from 'lodash';
 import { BoundariesActions, BoundariesActionTypes } from 'actions/boundaries-actions';
 import { ModelsActionTypes, ModelsActions } from 'actions/models-actions';
 import { AuthActionTypes, AuthActions } from 'actions/auth-actions';
@@ -20,6 +21,7 @@ const defaultState: ModelsState = {
     classifiers: [],
     modelRunnerIsVisible: false,
     modelRunnerTask: null,
+    requestedInferenceIDs: {},
     inferences: {},
     totalCount: 0,
     query: {
@@ -88,15 +90,28 @@ export default function (state = defaultState, action: ModelsActions | AuthActio
                 modelRunnerTask: null,
             };
         }
+        case ModelsActionTypes.GET_INFERENCES_SUCCESS: {
+            const { requestedInferenceIDs } = state;
+
+            return {
+                ...state,
+                requestedInferenceIDs: {
+                    ...requestedInferenceIDs,
+                    ...action.payload.requestedInferenceIDs,
+                },
+            };
+        }
         case ModelsActionTypes.GET_INFERENCE_STATUS_SUCCESS: {
-            const { inferences } = state;
+            const { inferences, requestedInferenceIDs } = state;
 
             if (action.payload.activeInference.status === 'finished') {
+                const { taskID, activeInference } = action.payload;
+                const { id: inferenceID } = activeInference;
+
                 return {
                     ...state,
-                    inferences: Object.fromEntries(
-                        Object.entries(inferences).filter(([key]): boolean => +key !== action.payload.taskID),
-                    ),
+                    inferences: omit(inferences, taskID),
+                    requestedInferenceIDs: omit(requestedInferenceIDs, inferenceID),
                 };
             }
 
@@ -123,12 +138,14 @@ export default function (state = defaultState, action: ModelsActions | AuthActio
             };
         }
         case ModelsActionTypes.CANCEL_INFERENCE_SUCCESS: {
-            const { inferences } = state;
-            delete inferences[action.payload.taskID];
+            const { inferences, requestedInferenceIDs } = state;
+            const { taskID, activeInference } = action.payload;
+            const { id: inferenceID } = activeInference;
 
             return {
                 ...state,
-                inferences: { ...inferences },
+                inferences: omit(inferences, taskID),
+                requestedInferenceIDs: omit(requestedInferenceIDs, inferenceID),
             };
         }
         case ModelsActionTypes.GET_MODEL_PREVIEW: {