New models UI

CHANGELOG.md

@@ -37,6 +37,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Windows Installation Instructions adjusted to work around <https://github.com/nuclio/nuclio/issues/1821>
 - The contour detection function for semantic segmentation (<https://github.com/opencv/cvat/pull/4665>)
 - Delete newline character when generating a webhook signature (<https://github.com/opencv/cvat/pull/5622>)
+- DL models UI (<https://github.com/opencv/cvat/pull/5635>)
 
 ### Deprecated
 - TDB

cvat-core/package.json

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

cvat-core/src/api-implementation.ts

@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022 CVAT.ai Corporation
+// Copyright (C) 2022-2023 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
@@ -37,6 +37,7 @@ export default function implementAPI(cvat) {
     cvat.lambda.cancel.implementation = lambdaManager.cancel.bind(lambdaManager);
     cvat.lambda.listen.implementation = lambdaManager.listen.bind(lambdaManager);
     cvat.lambda.requests.implementation = lambdaManager.requests.bind(lambdaManager);
+    cvat.lambda.providers.implementation = lambdaManager.providers.bind(lambdaManager);
 
     cvat.server.about.implementation = async () => {
         const result = await serverProxy.server.about();

cvat-core/src/api.ts

@@ -190,18 +190,22 @@ function build() {
                 const result = await PluginRegistry.apiWrapper(cvat.lambda.call, task, model, args);
                 return result;
             },
-            async cancel(requestID) {
-                const result = await PluginRegistry.apiWrapper(cvat.lambda.cancel, requestID);
+            async cancel(requestID, functionID) {
+                const result = await PluginRegistry.apiWrapper(cvat.lambda.cancel, requestID, functionID);
                 return result;
             },
-            async listen(requestID, onChange) {
-                const result = await PluginRegistry.apiWrapper(cvat.lambda.listen, requestID, onChange);
+            async listen(requestID, functionID, onChange) {
+                const result = await PluginRegistry.apiWrapper(cvat.lambda.listen, requestID, functionID, onChange);
                 return result;
             },
             async requests() {
                 const result = await PluginRegistry.apiWrapper(cvat.lambda.requests);
                 return result;
             },
+            async providers() {
+                const result = await PluginRegistry.apiWrapper(cvat.lambda.providers);
+                return result;
+            },
         },
         logger: loggerStorage,
         config: {

cvat-core/src/enums.ts

@@ -1,5 +1,5 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022 CVAT.ai Corporation
+// Copyright (C) 2022-2023 CVAT.ai Corporation
 //
 // SPDX-License-Identifier = MIT
 
@@ -136,6 +136,12 @@ export enum ModelType {
     DETECTOR = 'detector',
     INTERACTOR = 'interactor',
     TRACKER = 'tracker',
+    CLASSIFIER = 'classifier',
+    REID = 'reid',
+}
+
+export enum ModelProviders {
+    CVAT = 'cvat',
 }
 
 export const colors = [

cvat-core/src/lambda-manager.ts

@@ -1,12 +1,18 @@
 // Copyright (C) 2019-2022 Intel Corporation
-// Copyright (C) 2022 CVAT.ai Corporation
+// Copyright (C) 2022-2023 CVAT.ai Corporation
 //
 // SPDX-License-Identifier: MIT
 
 import serverProxy from './server-proxy';
 import { ArgumentError } from './exceptions';
 import MLModel from './ml-model';
-import { RQStatus } from './enums';
+import { ModelProviders, RQStatus } from './enums';
+
+export interface ModelProvider {
+    name: string;
+    icon: string;
+    attributes: Record<string, string>;
+}
 
 class LambdaManager {
     private listening: any;
@@ -18,18 +24,26 @@ class LambdaManager {
     }
 
     async list(): Promise<MLModel[]> {
-        if (Array.isArray(this.cachedList)) {
-            return [...this.cachedList];
-        }
-
-        const result = await serverProxy.lambda.list();
+        let lambdaFunctions = [];
+        let functions = [];
+        try {
+            // lambda.list returns error if list is empty, but we should work with models anyway
+            lambdaFunctions = await serverProxy.lambda.list();
+        // eslint-disable-next-line no-empty
+        } catch (error) {}
+
+        try {
+            functions = await serverProxy.functions.list();
+        // eslint-disable-next-line no-empty
+        } catch (error) {}
+
+        const result = [...lambdaFunctions, ...functions];
         const models = [];
 
         for (const model of result) {
             models.push(
                 new MLModel({
                     ...model,
-                    type: model.kind,
                 }),
             );
         }
@@ -59,7 +73,12 @@ class LambdaManager {
             function: model.id,
         };
 
-        const result = await serverProxy.lambda.run(body);
+        let result;
+        if (model.provider === ModelProviders.CVAT) {
+            result = await serverProxy.lambda.run(body);
+        } else {
+            result = await serverProxy.functions.run(body);
+        }
         return result.id;
     }
 
@@ -73,32 +92,59 @@ class LambdaManager {
             task: taskID,
         };
 
-        const result = await serverProxy.lambda.call(model.id, body);
+        let result;
+        if (model.provider === ModelProviders.CVAT) {
+            result = await serverProxy.lambda.call(model.id, body);
+        } else {
+            result = await serverProxy.functions.call(model.id, body);
+        }
         return result;
     }
 
     async requests() {
-        const result = await serverProxy.lambda.requests();
+        const lambdaRequests = await serverProxy.lambda.requests();
+        const functionsRequests = await serverProxy.functions.requests();
+        const result = [...lambdaRequests, ...functionsRequests];
         return result.filter((request) => ['queued', 'started'].includes(request.status));
     }
 
-    async cancel(requestID): Promise<void> {
+    async cancel(requestID, functionID): Promise<void> {
         if (typeof requestID !== 'string') {
             throw new ArgumentError(`Request id argument is required to be a string. But got ${requestID}`);
         }
+        const model = this.cachedList.find((_model) => _model.id === functionID);
+        if (!model) {
+            throw new ArgumentError('Incorrect Function Id provided');
+        }
 
         if (this.listening[requestID]) {
             clearTimeout(this.listening[requestID].timeout);
             delete this.listening[requestID];
         }
-        await serverProxy.lambda.cancel(requestID);
+
+        const { provider } = model;
+        if (provider === ModelProviders.CVAT) {
+            await serverProxy.lambda.cancel(requestID);
+        } else {
+            await serverProxy.functions.cancel(requestID);
+        }
     }
 
-    async listen(requestID, onUpdate): Promise<void> {
+    async listen(requestID, functionID, onUpdate): Promise<void> {
+        const model = this.cachedList.find((_model) => _model.id === functionID);
+        if (!model) {
+            throw new ArgumentError('Incorrect Function Id provided');
+        }
+        const { provider } = model;
         const timeoutCallback = async (): Promise<void> => {
             try {
                 this.listening[requestID].timeout = null;
-                const response = await serverProxy.lambda.status(requestID);
+                let response = null;
+                if (provider === ModelProviders.CVAT) {
+                    response = await serverProxy.lambda.status(requestID);
+                } else {
+                    response = await serverProxy.functions.status(requestID);
+                }
 
                 if (response.status === RQStatus.QUEUED || response.status === RQStatus.STARTED) {
                     onUpdate(response.status, response.progress || 0);
@@ -123,9 +169,24 @@ class LambdaManager {
 
         this.listening[requestID] = {
             onUpdate,
+            functionID,
             timeout: setTimeout(timeoutCallback, 2000),
         };
     }
+
+    async providers(): Promise<ModelProvider[]> {
+        const providersData: Record<string, Record<string, string>> = await serverProxy.functions.providers();
+        const providers = Object.entries(providersData).map(([provider, attributes]) => {
+            const { icon } = attributes;
+            delete attributes.icon;
+            return {
+                name: provider,
+                icon,
+                attributes,
+            };
+        });
+        return providers;
+    }
 }
 
 export default new LambdaManager();