applied comments

cvat-core/package.json

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

cvat-core/src/api.ts

@@ -237,14 +237,8 @@ function build(): CVATCore {
                 const result = await PluginRegistry.apiWrapper(cvat.lambda.cancel, requestID, functionID);
                 return result;
             },
-            async listen(requestID, functionID, onChange, options) {
-                const result = await PluginRegistry.apiWrapper(
-                    cvat.lambda.listen,
-                    requestID,
-                    functionID,
-                    onChange,
-                    options,
-                );
+            async listen(requestID, functionID, onChange) {
+                const result = await PluginRegistry.apiWrapper(cvat.lambda.listen, requestID, functionID, onChange);
                 return result;
             },
             async requests() {

cvat-core/src/lambda-manager.ts

@@ -108,19 +108,15 @@ class LambdaManager {
         requestID: string,
         functionID: string | number,
         callback: (status: RQStatus, progress: number, message?: string) => void,
-        options: { includeListening: boolean } = { includeListening: true },
     ): Promise<void> {
         const model = this.cachedList.find((_model) => _model.id === functionID);
         if (!model) {
             throw new ArgumentError('Incorrect function Id provided');
         }
 
-        // already listening, avoid sending extra requests
         if (requestID in this.listening) {
-            const { includeListening } = options;
-            if (includeListening) {
-                this.listening[requestID].onUpdate.push(callback);
-            }
+            this.listening[requestID].onUpdate.push(callback);
+            // already listening, avoid sending extra requests
             return;
         }
         const timeoutCallback = (): void => {

cvat-ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvat-ui",
-  "version": "1.63.1",
+  "version": "1.63.3",
   "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) => (
@@ -149,7 +154,7 @@ function listen(inferenceMeta: InferenceMeta, dispatch: (action: ModelsActions)
                     id: requestID,
                 }),
             );
-        }, { includeListening: false })
+        })
         .catch((error: Error) => {
             dispatch(
                 modelsActions.getInferenceStatusFailed(taskID, {
@@ -164,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));
         }
@@ -202,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));
         }
@@ -213,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,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 @@ const defaultState: ModelsState = {
     classifiers: [],
     modelRunnerIsVisible: false,
     modelRunnerTask: null,
+    requestedInferenceIDs: {},
     inferences: {},
     totalCount: 0,
     query: {
@@ -88,6 +89,17 @@ 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;
 
@@ -123,12 +135,14 @@ export default function (state = defaultState, action: ModelsActions | AuthActio
             };
         }
         case ModelsActionTypes.CANCEL_INFERENCE_SUCCESS: {
-            const { inferences } = state;
+            const { inferences, requestedInferenceIDs } = state;
             delete inferences[action.payload.taskID];
+            delete requestedInferenceIDs[action.payload.activeInference.id];
 
             return {
                 ...state,
                 inferences: { ...inferences },
+                requestedInferenceIDs: { ...requestedInferenceIDs },
             };
         }
         case ModelsActionTypes.GET_MODEL_PREVIEW: {