update AI initializing

rework AIAvailabilityStatus events to mediatr

Azaion.Inference/inference.pyx

@@ -5,6 +5,8 @@ from pathlib import Path
 import cv2
 import numpy as np
 cimport constants_inf
+
+from ai_availability_status cimport AIAvailabilityEnum, AIAvailabilityStatus
 from remote_command_inf cimport RemoteCommand
 from annotation cimport Detection, Annotation
 from ai_config cimport AIRecognitionConfig
@@ -60,67 +62,59 @@ cdef class Inference:
         self.tile_height = 0
         self.engine = None
         self.is_building_engine = False
+        self.ai_availability_status = AIAvailabilityStatus()
+        self.init_ai()
 
-    cdef build_tensor_engine(self, object updater_callback):
-        if tensor_gpu_index == -1:
-            return
-
-        try:
-            engine_filename = TensorRTEngine.get_engine_filename(0)
-            models_dir = constants_inf.MODELS_FOLDER
-
-            self.is_building_engine = True
-            updater_callback('downloading')
-
-            res = self.loader_client.load_big_small_resource(engine_filename, models_dir)
-            if res.err is None:
-                constants_inf.log('tensor rt engine is here, no need to build')
-                self.is_building_engine = False
-                updater_callback('enabled')
-                return
-
-            constants_inf.logerror(res.err)
-            # time.sleep(8) # prevent simultaneously loading dll and models
-            updater_callback('converting')
-            constants_inf.log('try to load onnx')
-            res = self.loader_client.load_big_small_resource(constants_inf.AI_ONNX_MODEL_FILE, models_dir)
-            if res.err is not None:
-                updater_callback(f'Error. {res.err}')
-            model_bytes = TensorRTEngine.convert_from_onnx(res.data)
-            updater_callback('uploading')
-            res = self.loader_client.upload_big_small_resource(model_bytes, <str> engine_filename, models_dir)
-            if res.err is not None:
-                updater_callback(f'Error. {res.err}')
-            constants_inf.log(f'uploaded {engine_filename} to CDN and API')
-            self.is_building_engine = False
-            updater_callback('enabled')
-        except Exception as e:
-            updater_callback(f'Error. {str(e)}')
+    cdef bytes get_onnx_engine_bytes(self):
+        models_dir = constants_inf.MODELS_FOLDER
+        self.ai_availability_status.set_status(AIAvailabilityEnum.DOWNLOADING)
+        res = self.loader_client.load_big_small_resource(constants_inf.AI_ONNX_MODEL_FILE, models_dir)
+        if res.err is not None:
+            raise Exception(res.err)
+        return res.data
 
     cdef init_ai(self):
-        if self.engine is not None:
-            return
-
-        models_dir = constants_inf.MODELS_FOLDER
-        if tensor_gpu_index > -1:
+        constants_inf.log(<str> 'init AI...')
+        try:
             while self.is_building_engine:
                 time.sleep(1)
-            engine_filename = TensorRTEngine.get_engine_filename(0)
+            if self.engine is not None:
+                return
+
+            self.is_building_engine = True
+            models_dir = constants_inf.MODELS_FOLDER
+            if tensor_gpu_index > -1:
+                try:
+                    engine_filename = TensorRTEngine.get_engine_filename(0)
+                    self.ai_availability_status.set_status(AIAvailabilityEnum.DOWNLOADING)
+                    res = self.loader_client.load_big_small_resource(engine_filename, models_dir)
+                    if res.err is not None:
+                        raise Exception(res.err)
+                    self.engine = TensorRTEngine(res.data)
+                    self.ai_availability_status.set_status(AIAvailabilityEnum.ENABLED)
+                except Exception as e:
+                    self.ai_availability_status.set_status(AIAvailabilityEnum.ERROR, <str>str(e))
+                    onnx_engine_bytes = self.get_onnx_engine_bytes()
+                    self.ai_availability_status.set_status(AIAvailabilityEnum.CONVERTING)
+                    model_bytes = TensorRTEngine.convert_from_onnx(res.data)
+                    self.ai_availability_status.set_status(AIAvailabilityEnum.UPLOADING)
+                    res = self.loader_client.upload_big_small_resource(model_bytes, <str> engine_filename, models_dir)
+                    if res.err is not None:
+                        self.ai_availability_status.set_status(AIAvailabilityEnum.ERROR, res.err)
+                    self.ai_availability_status.set_status(AIAvailabilityEnum.ENABLED)
+            else:
+                self.engine = OnnxEngine(<bytes>self.get_onnx_engine_bytes())
+            self.is_building_engine = False
+
+            self.model_height, self.model_width = self.engine.get_input_shape()
+            #todo: temporarily, send it from the client
+            self.tile_width = 550
+            self.tile_height = 550
+        except Exception as e:
+            self.ai_availability_status.set_status(AIAvailabilityEnum.ERROR, <str>str(e))
+            self.is_building_engine = False
 
-            res = self.loader_client.load_big_small_resource(engine_filename, models_dir)
-            if res.err is not None:
-                raise Exception(res.err)
-            self.engine = TensorRTEngine(res.data)
-        else:
-            res = self.loader_client.load_big_small_resource(constants_inf.AI_ONNX_MODEL_FILE, models_dir)
-            if res.err is not None:
-                raise Exception(res.err)
-            self.engine = OnnxEngine(res.data)
 
-        self.model_height, self.model_width = self.engine.get_input_shape()
-        #todo: temporarily, send it from the client
-        self.tile_width = 550
-        self.tile_height = 550
 
     cdef preprocess(self, frames):
         blobs = [cv2.dnn.blobFromImage(frame,