update AI initializing

rework AIAvailabilityStatus events to mediatr

Azaion.Inference/ai_availability_status.pxd

@@ -0,0 +1,14 @@
+cdef enum AIAvailabilityEnum:
+    NONE = 0
+    DOWNLOADING = 10
+    CONVERTING = 20
+    UPLOADING = 30
+    ENABLED = 200
+    ERROR = 500
+
+cdef class AIAvailabilityStatus:
+    cdef AIAvailabilityEnum status
+    cdef str error_message
+
+    cdef bytes serialize(self)
+    cdef set_status(self, AIAvailabilityEnum status, str error_message=*)

Azaion.Inference/ai_availability_status.pyx

@@ -0,0 +1,36 @@
+cimport constants_inf
+import msgpack
+
+AIStatus2Text = {
+    AIAvailabilityEnum.NONE: "None",
+    AIAvailabilityEnum.DOWNLOADING: "Downloading",
+    AIAvailabilityEnum.CONVERTING: "Converting",
+    AIAvailabilityEnum.UPLOADING: "Uploading",
+    AIAvailabilityEnum.ENABLED: "Enabled",
+    AIAvailabilityEnum.ERROR: "Error",
+}
+
+cdef class AIAvailabilityStatus:
+    def __init__(self):
+        self.status = AIAvailabilityEnum.NONE
+        self.error_message = None
+
+    def __str__(self):
+        status_text = AIStatus2Text.get(self.status, "Unknown")
+        error_text = self.error_message if self.error_message else ""
+        return f"{status_text} {error_text}"
+
+    cdef bytes serialize(self):
+        return msgpack.packb({
+            "s": self.status,
+            "m": self.error_message
+        })
+
+    cdef set_status(self, AIAvailabilityEnum status, str error_message=None):
+        self.status = status
+        self.error_message = error_message
+        if error_message is not None:
+            constants_inf.logerror(<str>error_message)
+        else:
+            constants_inf.log(<str>str(self))
+

Azaion.Inference/build_inference.cmd

@@ -35,6 +35,7 @@ venv\Scripts\pyinstaller --name=azaion-inference ^
 --collect-all jwt ^
 --collect-all loguru ^
 --hidden-import constants_inf ^
+--hidden-import ai_availability_status ^
 --hidden-import file_data ^
 --hidden-import remote_command_inf ^
 --hidden-import remote_command_handler_inf ^
@@ -49,8 +50,9 @@ start.py
 
 robocopy "dist\azaion-inference\_internal" "..\dist-azaion\_internal" "ai_config.cp312-win_amd64.pyd" "annotation.cp312-win_amd64.pyd"
 robocopy "dist\azaion-inference\_internal" "..\dist-azaion\_internal" "constants_inf.cp312-win_amd64.pyd" "file_data.cp312-win_amd64.pyd"
+robocopy "dist\azaion-inference\_internal" "..\dist-azaion\_internal" "ai_availability_status.pyd"
 robocopy "dist\azaion-inference\_internal" "..\dist-azaion\_internal" "remote_command_inf.cp312-win_amd64.pyd" "remote_command_handler_inf.cp312-win_amd64.pyd"
-robocopy "dist\azaion-inference\_internal" "..\dist-azaion\_internal" "inference.cp312-win_amd64.pyd" "inference_engine.cp312-win_amd64.pyd"
+robocopy "dist\azaion-inference\_internal" "..\dist-azaion\_internal" "inference.cp312-win_amd64.py=d" "inference_engine.cp312-win_amd64.pyd"
 robocopy "dist\azaion-inference\_internal" "..\dist-azaion\_internal" "loader_client.cp312-win_amd64.pyd" "tensorrt_engine.cp312-win_amd64.pyd"
 robocopy "dist\azaion-inference\_internal" "..\dist-azaion\_internal" "onnx_engine.cp312-win_amd64.pyd" "main_inference.cp312-win_amd64.pyd"
 

Azaion.Inference/inference.pxd

@@ -1,3 +1,4 @@
+from ai_availability_status cimport AIAvailabilityStatus
 from remote_command_inf cimport RemoteCommand
 from annotation cimport Annotation, Detection
 from ai_config cimport AIRecognitionConfig
@@ -12,6 +13,7 @@ cdef class Inference:
     cdef dict[str, list(Detection)] _tile_detections
     cdef AIRecognitionConfig ai_config
     cdef bint stop_signal
+    cdef AIAvailabilityStatus ai_availability_status
 
     cdef str model_input
     cdef int model_width
@@ -19,7 +21,7 @@ cdef class Inference:
     cdef int tile_width
     cdef int tile_height
 
-    cdef build_tensor_engine(self, object updater_callback)
+    cdef bytes get_onnx_engine_bytes(self)
     cdef init_ai(self)
     cdef bint is_building_engine
     cdef bint is_video(self, str filepath)

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,

Azaion.Inference/main_inference.pyx

@@ -44,8 +44,8 @@ cdef class CommandProcessor:
             if command.command_type == CommandType.INFERENCE:
                 self.inference_queue.put(command)
             elif command.command_type == CommandType.AI_AVAILABILITY_CHECK:
-                self.inference.build_tensor_engine(lambda status: self.remote_handler.send(command.client_id,
-                    RemoteCommand(CommandType.AI_AVAILABILITY_RESULT, None, status).serialize()))
+                status = self.inference.ai_availability_status.serialize()
+                self.remote_handler.send(command.client_id, RemoteCommand(CommandType.AI_AVAILABILITY_RESULT, status).serialize())
             elif command.command_type == CommandType.STOP_INFERENCE:
                 self.inference.stop()
             elif command.command_type == CommandType.EXIT:

Azaion.Inference/setup.py

@@ -14,6 +14,7 @@ trace_line = False
 
 extensions = [
     Extension('constants_inf', ['constants_inf.pyx'], **debug_args),
+    Extension('ai_availability_status', ['ai_availability_status.pyx'], **debug_args),
     Extension('file_data', ['file_data.pyx'], **debug_args),
     Extension('remote_command_inf', ['remote_command_inf.pyx'], **debug_args),
     Extension('remote_command_handler_inf', ['remote_command_handler_inf.pyx'], **debug_args),