@camera.ui/camera-ui-coreml 0.0.20 → 0.0.22

package/config.schema.json

@@ -1,43 +1,99 @@
 {
   "schema": {
-    "model": {
-      "type": "string",
-      "title": "Model",
-      "description": "Model to use for object detection",
-      "required": true,
-      "store": true,
-      "defaultValue": "yolov9m_320",
-      "enum": [
-        "yolo3-tinyu",
-        "yolo3-tinyu_320",
-        "yolov5nu",
-        "yolov5nu_320",
-        "yolov5mu",
-        "yolov5mu_320",
-        "yolov8n",
-        "yolov8n_320",
-        "yolov8s",
-        "yolov8s_320",
-        "yolov8m",
-        "yolov8m_320",
-        "yolov9t",
-        "yolov9t_320",
-        "yolov9s",
-        "yolov9s_320",
-        "yolov9m",
-        "yolov9m_320",
-        "yolov9c",
-        "yolov9c_320"
+    "items": {
+      "type": "object",
+      "title": "Remove Models",
+      "opened": true,
+      "properties": {
+        "model": {
+          "type": "string",
+          "title": "Model",
+          "description": "Model to use for object detection",
+          "required": true,
+          "store": false,
+          "defaultValue": "yolov9m_320 - FP16",
+          "enum": [
+            "yolo3-tinyu - INT8",
+            "yolo3-tinyu_320 - INT8",
+            "yolo3-tinyu - FP16",
+            "yolo3-tinyu_320 - FP16",
+            "yolov5nu - INT8",
+            "yolov5nu_320 - INT8",
+            "yolov5mu - INT8",
+            "yolov5mu_320 - INT8",
+            "yolov5nu - FP16",
+            "yolov5nu_320 - FP16",
+            "yolov5mu - FP16",
+            "yolov5mu_320 - FP16",
+            "yolov8n - INT8",
+            "yolov8n_320 - INT8",
+            "yolov8s - INT8",
+            "yolov8s_320 - INT8",
+            "yolov8m - INT8",
+            "yolov8m_320 - INT8",
+            "yolov8n - FP16",
+            "yolov8n_320 - FP16",
+            "yolov8s - FP16",
+            "yolov8s_320 - FP16",
+            "yolov8m - FP16",
+            "yolov8m_320 - FP16",
+            "yolov9t - INT8",
+            "yolov9t_320 - INT8",
+            "yolov9s - INT8",
+            "yolov9s_320 - INT8",
+            "yolov9m - INT8",
+            "yolov9m_320 - INT8",
+            "yolov9c - INT8",
+            "yolov9c_320 - INT8",
+            "yolov9t - FP16",
+            "yolov9t_320 - FP16",
+            "yolov9s - FP16",
+            "yolov9s_320 - FP16",
+            "yolov9m - FP16",
+            "yolov9m_320 - FP16",
+            "yolov9c - FP16",
+            "yolov9c_320 - FP16",
+            "yolov10n - INT8",
+            "yolov10n_320 - INT8",
+            "yolov10s - INT8",
+            "yolov10s_320 - INT8",
+            "yolov10m - INT8",
+            "yolov10m_320 - INT8",
+            "yolov10l - INT8",
+            "yolov10l_320 - INT8",
+            "yolov10n - FP16",
+            "yolov10n_320 - FP16",
+            "yolov10s - FP16",
+            "yolov10s_320 - FP16",
+            "yolov10m - FP16",
+            "yolov10m_320 - FP16",
+            "yolov10l - FP16",
+            "yolov10l_320 - FP16",
+            "yolov11n - INT8",
+            "yolov11n_320 - INT8",
+            "yolov11s - INT8",
+            "yolov11s_320 - INT8",
+            "yolov11m - INT8",
+            "yolov11m_320 - INT8",
+            "yolov11l - INT8",
+            "yolov11l_320 - INT8",
+            "yolov11n - FP16",
+            "yolov11n_320 - FP16",
+            "yolov11s - FP16",
+            "yolov11s_320 - FP16",
+            "yolov11m - FP16",
+            "yolov11m_320 - FP16",
+            "yolov11l - FP16",
+            "yolov11l_320 - FP16"
+          ]
+        }
+      },
+      "buttons": [
+        {
+          "label": "Remove",
+          "onSubmit": "onRemove"
+        }
       ]
-    },
-    "precision": {
-      "type": "string",
-      "title": "Precision",
-      "description": "Precision of the model",
-      "required": true,
-      "store": true,
-      "defaultValue": "FP16",
-      "enum": ["INT8", "FP16"]
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "displayName": "CoreML",
   "name": "@camera.ui/camera-ui-coreml",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "camera.ui coreml plugin",
   "author": "seydx (https://github.com/seydx/camera.ui)",
   "main": "./src/main.py",
@@ -21,7 +21,7 @@
     "url": "https://github.com/seydx/camera.ui/issues"
   },
   "engines": {
-    "camera.ui": ">=0.0.31-alpha.1",
+    "camera.ui": ">=0.0.34-alpha.2",
     "node": ">=20.17.0"
   },
   "homepage": "https://github.com/seydx/camera.ui#readme",

package/requirements.txt

@@ -1,4 +1,5 @@
-coremltools==7.2
-camera-ui-python-types==0.1.90
+coremltools==8.0
+camera-ui-python-types==0.1.96
 requests==2.32.3
-Pillow==10.4.0
+Pillow==11.0.0
+aiohttp==3.10.10

package/src/camera_detector.py

@@ -1,162 +1,272 @@
+# camera_detector.py
 import asyncio
-from typing import Any, Optional, cast
+from typing import Optional, cast
 from uuid import uuid4
 
 from camera_ui_python_types import (
     CameraDevice,
+    CameraPropertyObservableObject,
     CameraStorage,
     Detection,
     LoggerService,
-    MotionState,
     ObjectClass,
     PluginAPI,
 )
+
+from detector_defaults import available_models, default_model
 from object_detector import ObjectDetector
 from plugin_typings import CameraStorageValues
 
-background_tasks = set[asyncio.Task[Any]]()
-
 
 class CameraDetector:
     def __init__(
         self,
         camera: CameraDevice,
-        object_detector: ObjectDetector,
         api: PluginAPI,
         logger: LoggerService,
-        has_motion: list[str],
     ) -> None:
         super().__init__()
 
         self.camera = camera
         self.api = api
-        self.logger = logger
-        self.object_detector = object_detector
+        self.camera_logger = camera.logger
+
+        self.object_detector = ObjectDetector(self.api, self.camera_logger)
 
-        self.has_motion = has_motion
         self.started = False
         self.closed = False
-        self.frame_generation_task: Optional[asyncio.Task[Any]] = None
+        self.restarting = False
+
+        self.initialized = False
+
+        self.current_generator_type: Optional[bool] = None  # True for extended, False for normal
+        self.detection_task: Optional[asyncio.Task[None]] = None
+
+        # Keep track of camera properties
+        self.connected = False
+        self.has_motion_detector = False
+        self.extended_motion_detector = False
+
+        # Debounce task
+        self.debounce_task: Optional[asyncio.Task[None]] = None
 
         self.camera_storage: CameraStorage[CameraStorageValues] = self.__create_camera_storage()
-        self.camera.on_connected.subscribe(lambda connected: self.start() if connected else self.close())
-        self.camera.on_motion_detected.subscribe(self.__on_motion_detected)
 
-    def start(self):
+    async def initialize(self) -> None:
+        if self.initialized:
+            return
+
+        self.initialized = True
+
+        # Initialize object detector
+        try:
+            model_name = self.camera_storage.values["model"]
+            self.camera_logger.log(f"Initialising Object Detection with model: {model_name}")
+            await self.object_detector.initialize(model_name)
+        except Exception as error:
+            self.camera_logger.error("Error initializing Object Detection", error)
+            return
+
+        if self.closed:
+            return
+
+        # Initialize property values
+        self.connected = self.camera.connected
+        self.has_motion_detector = self.camera.has_motion_detector
+        self.extended_motion_detector = self.camera.extended_motion_detector
+
+        # Subscribe to changes
+        self.camera.on_connected.subscribe(self.on_camera_connected)
+        self.camera.on_property_change("hasMotionDetector").subscribe(self.on_has_motion_detector_changed)
+        self.camera.on_property_change("extendedMotionDetector").subscribe(
+            self.on_extended_motion_detector_changed
+        )
+
+        # Start detection if initial conditions are met
+        await self.check_and_start_or_stop_detection()
+
+    def schedule_check(self):
+        if self.debounce_task and not self.debounce_task.done():
+            return  # Debounce task already scheduled
+
+        self.debounce_task = asyncio.create_task(self.debounce_check())
+
+    async def debounce_check(self):
+        await asyncio.sleep(0.1)  # Debounce delay
+        await self.check_and_start_or_stop_detection()
+
+    def on_camera_connected(self, connected: bool) -> None:
+        self.connected = connected
+        self.schedule_check()
+
+    def on_has_motion_detector_changed(self, state: CameraPropertyObservableObject) -> None:
+        self.has_motion_detector: bool = state["new_state"]
+        self.schedule_check()
+
+    def on_extended_motion_detector_changed(self, state: CameraPropertyObservableObject) -> None:
+        self.extended_motion_detector: bool = state["new_state"]
+        self.schedule_check()
+
+    async def check_and_start_or_stop_detection(self):
+        if self.connected and self.has_motion_detector:
+            if not self.started:
+                await self.start()
+            else:
+                # Restart detection if the generator type has changed
+                if self.current_generator_type != self.extended_motion_detector:
+                    self.close()
+                    await self.start()
+        else:
+            if self.started:
+                self.close()
+
+    async def start(self):
         if not self.started:
             self.started = True
             self.closed = False
 
-            self.logger.log(f"Starting object detection for camera {self.camera.name}...")
-
-            self.frame_generation_task = asyncio.create_task(
-                self.__detect(), name=f"ObjectDetection-{self.camera.name}"
-            )
+            if self.extended_motion_detector:
+                self.camera_logger.log("Starting Object Detection with Motion Frames")
+            else:
+                self.camera_logger.log("Starting Object Detection")
 
-            background_tasks.add(self.frame_generation_task)
-            self.frame_generation_task.add_done_callback(
-                lambda _: background_tasks.remove(self.frame_generation_task)
-                if self.frame_generation_task in background_tasks
-                else None
-            )
+            self.detection_task = asyncio.create_task(self.__start_detection())
 
     def close(self):
-        if self.started and not self.closed:
+        if not self.closed:
             self.started = False
             self.closed = True
 
-            self.logger.log(f"Stopping object detection for camera {self.camera.name}...")
+            self.camera_logger.log("Stopping Object Detection")
+
+            if self.detection_task:
+                self.detection_task.cancel()
+                self.detection_task = None
+
+            if self.debounce_task:
+                self.debounce_task.cancel()
+                self.debounce_task = None
 
-            if self.frame_generation_task is not None:
-                self.frame_generation_task.cancel()
-                self.frame_generation_task = None
+            self.object_detector.close()
 
-        if self.camera.name in self.has_motion:
-            self.has_motion.remove(self.camera.name)
+    async def __start_detection(self) -> None:
+        try:
+            await self.__detect()
+        except asyncio.CancelledError:
+            pass
+        except Exception as error:
+            self.camera_logger.error("Error generating frames", error)
+            await self.__restart()
 
-    def restart(self):
-        self.logger.log(f"Restarting object detection for camera {self.camera.name}...")
+    async def __restart(self) -> None:
+        if self.restarting or self.closed:
+            return
 
-        self.close()
+        self.restarting = True
 
-        if self.camera.connected:
-            self.start()
+        self.camera_logger.log("Restarting Object Detection in 2s...")
+        await asyncio.sleep(2)
+
+        self.restarting = False
+
+        if self.connected and not self.closed and self.has_motion_detector:
+            await self.__start_detection()
 
     async def __detect(self):
-        while not self.closed:
-            try:
-                async for frame in self.camera.get_motion_frames():
-                    if self.closed:
-                        break
-
-                    frame_image = await frame.to_image(
-                        {
-                            "format": {"to": "rgb"},
-                            "resize": {
-                                "width": self.object_detector.input_width,
-                                "height": self.object_detector.input_height,
-                            },
-                        }
-                    )
-
-                    detections: list[Detection] = []
-
-                    class_ids, scores, boxes = await self.object_detector.detect(frame_image["image"])
-
-                    for class_id, score, box in zip(class_ids, scores, boxes):
-                        x1, y1, x2, y2 = box
-
-                        detection: Detection = {
-                            "id": str(uuid4()),
-                            "label": cast(ObjectClass, self.object_detector.labels[class_id]),
-                            "confidence": score,
-                            "boundingBox": (float(x1), float(y1), float(x2), float(y2)),
-                            "inputWidth": self.object_detector.input_width,
-                            "inputHeight": self.object_detector.input_height,
-                            "origWidth": frame.metadata["origWidth"],
-                            "origHeight": frame.metadata["origHeight"],
-                        }
-
-                        detections.append(detection)
-
-                    await self.camera.update_state("object", {"detections": detections})
-            except asyncio.CancelledError:
+        # Choose the generator based on extendedMotionDetector
+        if self.extended_motion_detector:
+            generator = self.camera.get_motion_frames()
+        else:
+            generator = self.camera.get_frames()
+
+        self.current_generator_type = self.extended_motion_detector
+
+        async for frame in generator:
+            if self.closed:
                 break
-            except Exception as error:
-                self.logger.error(self.camera.name, "Error generating motion frames", error)
-                self.logger.log(self.camera.name, "Restarting object detection in 5 seconds...")
-                await asyncio.sleep(5)
-                continue
 
-    def __on_motion_detected(self, state: MotionState) -> None:
-        motion_detected = bool(state.get("state", False) or len(state["detections"]) > 0)
+            # Check if properties have changed
+            if (
+                self.connected != self.camera.connected
+                or self.has_motion_detector != self.camera.has_motion_detector
+                or self.extended_motion_detector != self.camera.extended_motion_detector
+            ):
+                await self.__restart()
+                break
 
-        if motion_detected:
-            if self.camera.name not in self.has_motion:
-                self.has_motion.append(self.camera.name)
-        elif self.camera.name in self.has_motion:
-            self.has_motion.remove(self.camera.name)
+            frame_image = await frame.to_image(
+                {
+                    "format": {"to": "rgb"},
+                    "resize": {
+                        "width": self.object_detector.input_width,
+                        "height": self.object_detector.input_height,
+                    },
+                }
+            )
 
-    def __create_camera_storage(self) -> CameraStorage[CameraStorageValues]:
-        camera_storage: Optional[CameraStorage[CameraStorageValues]] = (
-            self.api.storage_controller.get_camera_storage(self.camera.id)
-        )
+            detections: list[Detection] = []
 
-        if camera_storage is not None:
-            return camera_storage
-
-        return self.api.storage_controller.create_camera_storage(
-            self,
-            self.camera.id,
-            {
-                "active_object_detections": {
-                    "type": "string",
-                    "key": "active_object_detections",
-                    "title": "Active Object Detections",
-                    "description": "Active object detections",
-                    "readonly": True,
-                    "enum": [],
-                    "onGet": lambda: self.has_motion,
+            class_ids, scores, boxes = await self.object_detector.detect(frame_image["image"])
+
+            for class_id, score, box in zip(class_ids, scores, boxes):
+                x1, y1, x2, y2 = box
+
+                detection: Detection = {
+                    "id": str(uuid4()),
+                    "label": cast(ObjectClass, self.object_detector.labels[class_id]),
+                    "confidence": score,
+                    "boundingBox": (float(x1), float(y1), float(x2), float(y2)),
+                    "inputWidth": self.object_detector.input_width,
+                    "inputHeight": self.object_detector.input_height,
+                    "origWidth": frame.metadata["origWidth"],
+                    "origHeight": frame.metadata["origHeight"],
                 }
-            },
+
+                detections.append(detection)
+
+            await self.camera.update_state("object", {"detections": detections})
+
+    async def __default_settings(self) -> None:
+        if self.camera_storage.values["model"] != default_model:
+            await self.camera_storage.setValue("model", default_model)
+
+    async def __change_model(self, new_model: str, old_model: str) -> None:
+        if self.object_detector.downloading:
+            self.camera_logger.log("Model is currently downloading, please wait")
+            await self.camera_storage.setValue("model", old_model)
+            return
+
+        self.camera_logger.log(f"Model changed from {old_model} to {new_model}")
+
+        await self.object_detector.reset()
+        await self.object_detector.initialize(new_model)
+
+    def __create_camera_storage(self) -> CameraStorage[CameraStorageValues]:
+        camera_storage: CameraStorage[CameraStorageValues] = (
+            self.api.storage_controller.create_camera_storage(
+                self,
+                self.camera.id,
+                {
+                    "model": {
+                        "type": "string",
+                        "key": "model",
+                        "title": "Model",
+                        "description": "Model for object detection",
+                        "store": True,
+                        "defaultValue": default_model,
+                        "enum": available_models,
+                        "required": True,
+                        "onSet": lambda new, old: self.__change_model(new, old),
+                    },
+                    "reset": {
+                        "type": "button",
+                        "title": "Default Settings",
+                        "key": "default",
+                        "description": "Reset settings to default",
+                        "onSet": lambda new, old: self.__default_settings(),
+                    },
+                },
+            )
         )
+
+        return camera_storage

package/src/detector_defaults.py

@@ -1,32 +1,86 @@
 available_models = [
-    "yolo3-tinyu",
-    "yolo3-tinyu_320",
-    "yolov5nu",
-    "yolov5nu_320",
-    "yolov5mu",
-    "yolov5mu_320",
-    "yolov8n",
-    "yolov8n_320",
-    "yolov8s",
-    "yolov8s_320",
-    "yolov8m",
-    "yolov8m_320",
-    "yolov9t",
-    "yolov9t_320",
-    "yolov9s",
-    "yolov9s_320",
-    "yolov9m",
-    "yolov9m_320",
-    "yolov9c",
-    "yolov9c_320",
-    "yolov10n",
-    "yolov10n_320",
-    "yolov10s",
-    "yolov10s_320",
-    "yolov10m",
-    "yolov10m_320",
-    "yolov10l",
-    "yolov10l_320",
+    # YOLOv3
+    "yolo3-tinyu - INT8",
+    "yolo3-tinyu_320 - INT8",
+    "yolo3-tinyu - FP16",
+    "yolo3-tinyu_320 - FP16",
+    # YOLOv5
+    "yolov5nu - INT8",
+    "yolov5nu_320 - INT8",
+    "yolov5mu - INT8",
+    "yolov5mu_320 - INT8",
+    "yolov5nu - FP16",
+    "yolov5nu_320 - FP16",
+    "yolov5mu - FP16",
+    "yolov5mu_320 - FP16",
+    # YOLOv8
+    "yolov8n - INT8",
+    "yolov8n_320 - INT8",
+    "yolov8s - INT8",
+    "yolov8s_320 - INT8",
+    "yolov8m - INT8",
+    "yolov8m_320 - INT8",
+    "yolov8n - FP16",
+    "yolov8n_320 - FP16",
+    "yolov8s - FP16",
+    "yolov8s_320 - FP16",
+    "yolov8m - FP16",
+    "yolov8m_320 - FP16",
+    # YOLOv9
+    "yolov9t - INT8",
+    "yolov9t_320 - INT8",
+    "yolov9s - INT8",
+    "yolov9s_320 - INT8",
+    "yolov9m - INT8",
+    "yolov9m_320 - INT8",
+    "yolov9c - INT8",
+    "yolov9c_320 - INT8",
+    "yolov9t - FP16",
+    "yolov9t_320 - FP16",
+    "yolov9s - FP16",
+    "yolov9s_320 - FP16",
+    "yolov9m - FP16",
+    "yolov9m_320 - FP16",
+    "yolov9c - FP16",
+    "yolov9c_320 - FP16",
+    # YOLOv10
+    "yolov10n - INT8",
+    "yolov10n_320 - INT8",
+    "yolov10s - INT8",
+    "yolov10s_320 - INT8",
+    "yolov10m - INT8",
+    "yolov10m_320 - INT8",
+    "yolov10l - INT8",
+    "yolov10l_320 - INT8",
+    "yolov10n - FP16",
+    "yolov10n_320 - FP16",
+    "yolov10s - FP16",
+    "yolov10s_320 - FP16",
+    "yolov10m - FP16",
+    "yolov10m_320 - FP16",
+    "yolov10l - FP16",
+    "yolov10l_320 - FP16",
+    # YOLOv11
+    "yolov11n - INT8",
+    "yolov11n_320 - INT8",
+    "yolov11s - INT8",
+    "yolov11s_320 - INT8",
+    "yolov11m - INT8",
+    "yolov11m_320 - INT8",
+    "yolov11l - INT8",
+    "yolov11l_320 - INT8",
+    "yolov11n - FP16",
+    "yolov11n_320 - FP16",
+    "yolov11s - FP16",
+    "yolov11s_320 - FP16",
+    "yolov11m - FP16",
+    "yolov11m_320 - FP16",
+    "yolov11l - FP16",
+    "yolov11l_320 - FP16",
 ]
 
 available_precision = ["INT8", "FP16"]
+
+default_model = "yolov9m_320 - FP16"
+
+model_version = "v1"

package/src/main.py

@@ -1,6 +1,8 @@
+# main.py
+import asyncio
+import os
 from typing import Any, Union
 
-from camera_detector import CameraDetector
 from camera_ui_python_types import (
     CameraDevice,
     CameraExtension,
@@ -12,8 +14,11 @@ from camera_ui_python_types import (
     PluginAPI,
     RootSchema,
 )
-from detector_defaults import available_models, available_precision
+
+from camera_detector import CameraDetector
+from detector_defaults import available_models, default_model, model_version
 from object_detector import ObjectDetector
+from plugin_typings import FormPayload
 
 
 class CoreML(ObjectDetectionPlugin):
@@ -22,10 +27,6 @@ class CoreML(ObjectDetectionPlugin):
         self.logger = logger
         self.camera_devices: dict[str, CameraDevice] = {}
         self.detectors: dict[str, CameraDetector] = {}
-        self.object_detector = ObjectDetector(self.api, self.logger)
-        self.single_image_detectors: dict[str, ObjectDetector] = {}
-
-        self.has_motion: list[str] = []
 
         self.api.on("finishLaunching", self.start)
         self.api.on("shutdown", self.stop)
@@ -33,45 +34,90 @@ class CoreML(ObjectDetectionPlugin):
         self.api.device_manager.on("cameraSelected", self.camera_selected)
         self.api.device_manager.on("cameraDeselected", self.camera_deselected)
 
+        self.object_detectors: dict[str, ObjectDetector] = {}
+
     async def camera_selected(self, camera: CameraDevice, extension: CameraExtension) -> None:
-        self.logger.log(f"New camera added ({extension}): {camera.name}")
+        self.logger.log(f"Camera added: {camera.name}")
         self.camera_devices[camera.id] = camera
-        self.create_detector(camera)
+        await self.create_detector(camera)
 
-    def camera_deselected(self, id: str, extension: CameraExtension) -> None:
+    async def camera_deselected(self, id: str, extension: CameraExtension) -> None:
         camera = self.camera_devices.get(id)
 
         if camera:
-            self.logger.log(f"Camera removed ({extension}): {camera.name}")
-            self.remove_detector(self.camera_devices[id])
+            self.logger.log(f"Camera removed: {camera.name}")
+            self.remove_detector(camera)
             del self.camera_devices[id]
 
-    def start(self) -> None:
-        self.logger.log("Plugin Started")
-
-        self.object_detector.initialize()
+    async def start(self) -> None:
+        self.logger.log("Plugin started")
+        await asyncio.gather(*[self.create_detector(camera) for camera in self.camera_devices.values()])
 
-        for camera_device in self.camera_devices.values():
-            self.create_detector(camera_device)
-
-    def stop(self) -> None:
-        self.logger.log("Plugin Stopped")
+    async def stop(self) -> None:
+        self.logger.log("Plugin stopped")
 
         detectors_copy = list(self.detectors.values())
 
         for detector in detectors_copy:
-            self.remove_detector(detector.camera)
+            detector.close()
+            del self.detectors[detector.camera.id]
+
+    async def onFormSubmit(self, action_id: str, payload: FormPayload) -> Union[FormSubmitResponse, None]:
+        if action_id == "onRemove":
+            response: FormSubmitResponse = {
+                "schema": {
+                    "config": {
+                        "type": "object",
+                        "title": "Confirm",
+                        "required": True,
+                        "opened": True,
+                        "properties": {
+                            "confirm": {
+                                "type": "string",
+                                "description": "Please type 'REMOVE' to confirm",
+                                "required": True,
+                            }
+                        },
+                        "buttons": [
+                            {
+                                "label": "Remove",
+                                "onSubmit": "onConfirm",
+                            },
+                        ],
+                    }
+                }
+            }
+
+            return response
+        elif action_id == "onConfirm":
+            if payload.get("confirm") == "REMOVE":
+                model, precision = payload["model"].split(" - ")
+                filename = f"coreml_{model}/{precision}"
+
+                model_storage = os.path.join(f"{self.api.storage_path}/models/{model_version}")
+                dir = os.path.join(model_storage, filename)
+
+                if os.path.exists(dir):
+                    self.logger.attention(f"Removing model: {model} - {precision}")
+                    os.rmdir(dir)
+                else:
+                    self.logger.debug(f"Model not found: {model} - {precision}, skipping removal")
 
-    async def onFormSubmit(self, action_id: str, payload: Any) -> Union[FormSubmitResponse, None]:
-        print("Form submitted", action_id, payload)
+                return {
+                    "toast": {
+                        "message": "All models removed!",
+                        "type": "success",
+                    }
+                }
 
     def configureCameras(self, cameras: list[CameraDevice]) -> None:
         for camera in cameras:
             self.camera_devices[camera.id] = camera
 
-    def create_detector(self, camera: CameraDevice) -> None:
-        detector = CameraDetector(camera, self.object_detector, self.api, self.logger, self.has_motion)
+    async def create_detector(self, camera: CameraDevice) -> None:
+        detector = CameraDetector(camera, self.api, self.logger)
         self.detectors[camera.id] = detector
+        await detector.initialize()
 
     def remove_detector(self, camera: CameraDevice) -> None:
         detector = self.detectors[camera.id]
@@ -86,38 +132,30 @@ class CoreML(ObjectDetectionPlugin):
                 "models": {
                     "type": "string",
                     "title": "Model",
-                    "description": "Model to use for object detection",
+                    "description": "Model for object detection",
                     "required": True,
-                    "defaultValue": "yolov9m_320",
+                    "defaultValue": default_model,
                     "enum": available_models,
-                },
-                "precision": {
-                    "type": "string",
-                    "title": "Precision",
-                    "description": "Precision of the model",
-                    "required": True,
-                    "defaultValue": "FP16",
-                    "enum": available_precision,
-                },
+                }
             }
         }
 
     async def detectObjects(
         self, image_path: str, metadata: ImageMetadata, config: dict[str, Any]
     ) -> ObjectDetectionPluginResponse:
-        model = config.get("models")
-        precision = config.get("precision")
+        model_name: str = config.get("models", default_model)
+
+        object_detector = self.object_detectors.get(model_name)
 
-        identifier = f"{model}_{precision}"
-        single_image_detector = self.single_image_detectors.get(identifier)
+        if not object_detector:
+            object_detector = ObjectDetector(self.api, self.logger)
+            self.object_detectors[model_name] = object_detector
 
-        if not single_image_detector:
-            single_image_detector = ObjectDetector(self.api, self.logger)
-            self.single_image_detectors[identifier] = single_image_detector
+        await object_detector.initialize(model_name)
 
-        single_image_detector.initialize(model, precision)
+        detections = await object_detector.detect_single(image_path, metadata)
 
-        detections = await single_image_detector.detect_single(image_path, metadata)
+        print("Detections: ", len(detections))
 
         return {
             "detections": detections,

package/src/object_detector.py

@@ -1,15 +1,25 @@
+# object_detector.py
 import asyncio
 import os
+from asyncio import Lock
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Optional, cast
 from uuid import uuid4
 
+import aiohttp
 import coremltools as ct
 import numpy as np
-import requests
-from camera_ui_python_types import Detection, ImageMetadata, LoggerService, ObjectClass, PluginAPI
-from detector_defaults import available_models, available_precision
+from camera_ui_python_types import (
+    CameraDevice,
+    Detection,
+    ImageMetadata,
+    LoggerService,
+    ObjectClass,
+    PluginAPI,
+)
 from PIL import Image
+
+from detector_defaults import available_models, available_precision, default_model, model_version
 from utils import parse_labels
 
 
@@ -18,12 +28,11 @@ class ObjectDetector:
         self,
         api: PluginAPI,
         logger: LoggerService,
+        camera: Optional[CameraDevice] = None,
     ):
         self.api = api
         self.logger = logger
-        self.config = self.api.config_service.all()
 
-        model_version = "v1"
         self.model_path = os.path.join(f"{self.api.storage_path}/models/{model_version}")
 
         self.initialized = False
@@ -33,6 +42,15 @@ class ObjectDetector:
         self.selected_model = None
         self.selected_precision = None
 
+        self.closed = False
+        self.__downloading = False
+
+        self.lock = Lock()
+
+    @property
+    def downloading(self) -> bool:
+        return self.__downloading
+
     @property
     def input_width(self) -> int:
         return self.input_size[0]
@@ -41,52 +59,82 @@ class ObjectDetector:
     def input_height(self) -> int:
         return self.input_size[1]
 
-    def initialize(self, model: Optional[str] = None, precision: Optional[str] = None) -> None:
-        if not self.initialized:
-            self.initialized = True
-
-            self.logger.log("Initializing CoreML Object Detector...")
+    async def initialize(self, model_name: str) -> None:
+        async with self.lock:
+            if self.__downloading:
+                raise Exception("Already downloading a model")
 
-            self.selected_model = model if model else self.config.get("model", "yolov9m_320")
-            self.selected_precision = precision if precision else self.config.get("precision", "FP16")
+            if not self.initialized:
+                self.initialized = True
+                self.__downloading = True
 
-            if self.selected_model not in available_models:
-                self.selected_model = "yolov9m_320"
+                self.selected_model, self.selected_precision = model_name.split(" - ")
 
-            if self.selected_precision not in available_precision:
-                self.selected_precision = "FP16"
+                if self.selected_model not in available_models:
+                    self.selected_model = default_model.split(" - ")[0]
 
-            yolo_model_name = self.selected_model.split("_")[0]
-            model_file = None
+                if self.selected_precision not in available_precision:
+                    self.selected_precision = default_model.split(" - ")[1]
 
-            files = [
-                f"coreml_{self.selected_model}/{self.selected_precision}/{yolo_model_name}.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
-                f"coreml_{self.selected_model}/{self.selected_precision}/{yolo_model_name}.mlpackage/Data/com.apple.CoreML/model.mlmodel",
-                f"coreml_{self.selected_model}/{self.selected_precision}/{yolo_model_name}.mlpackage/Manifest.json",
-            ]
+                yolo_model_name = self.selected_model.split("_")[0]
+                ml_package = (
+                    f"coreml_{self.selected_model}/{self.selected_precision}/{yolo_model_name}.mlpackage"
+                )
 
-            for f in files:
-                p = self.__downloadFile(
-                    f"https://raw.githubusercontent.com/seydx/models/main/models/coreml/{f}", f
+                files = [
+                    f"{ml_package}/Data/com.apple.CoreML/weights/weight.bin",
+                    f"{ml_package}/Data/com.apple.CoreML/model.mlmodel",
+                    f"{ml_package}/Manifest.json",
+                ]
+
+                for f in files:
+                    url = f"https://raw.githubusercontent.com/seydx/models/main/models/coreml/{f}"
+                    await self.__downloadFile(url, f)
+                    if self.closed:
+                        return
+
+                # Proceed with model loading and initialization
+                loop = asyncio.get_event_loop()
+                self.model = await loop.run_in_executor(
+                    None, ct.models.MLModel, os.path.join(self.model_path, ml_package)
                 )
-                model_file = os.path.dirname(p)
+                self.input_name: str = self.model.get_spec().description.input[0].name  # type: ignore
 
-            self.model = ct.models.MLModel(model=model_file, compute_units=ct.ComputeUnit.ALL)
-            self.input_name: str = self.model.get_spec().description.input[0].name  # type: ignore
+                modelspec: Any = self.model.get_spec()
+                inputdesc = modelspec.description.input[0]  # type: ignore
+                inputheight: Any = inputdesc.type.imageType.height
+                inputwidth: Any = inputdesc.type.imageType.width
 
-            modelspec: Any = self.model.get_spec()
-            inputdesc = modelspec.description.input[0]  # type: ignore
-            inputheight: Any = inputdesc.type.imageType.height
-            inputwidth: Any = inputdesc.type.imageType.width
+                self.input_size: tuple[int, int] = (inputwidth, inputheight)
+                self.labels = parse_labels(modelspec.description.metadata.userDefined)  # type: ignore
 
-            self.input_size: tuple[int, int] = (inputwidth, inputheight)
-            self.labels = parse_labels(modelspec.description.metadata.userDefined)  # type: ignore
+                self.__downloading = False
 
-            self.logger.log("CoreML Object Detector initialized")
+    async def reset(self) -> None:
+        async with self.lock:
+            self.initialized = False
+            if self.executor:
+                self.executor.shutdown(wait=False)
+                self.executor = ThreadPoolExecutor(max_workers=8)
+
+    def close(self) -> None:
+        self.closed = True
+        asyncio.create_task(self.reset())
+        if self.executor:
+            self.executor.shutdown(wait=False)
+            self.executor = None
+
+    def cleanup_model(self, model_name: str) -> None:
+        model, precision = model_name.split(" - ")
+        filename = f"coreml_{model}/{precision}"
+        dir = os.path.join(self.model_path, filename)
+
+        if os.path.exists(dir):
+            os.rmdir(dir)
 
     async def detect(self, image: Image.Image) -> tuple[list[int], list[float], np.ndarray[Any, Any]]:
         if not self.initialized:
-            raise Exception("CoreML Object Detector not initialized")
+            return [], [], np.array([])
 
         out_dict = await asyncio.get_event_loop().run_in_executor(self.executor, self.__model_predict, image)
 
@@ -115,7 +163,6 @@ class ObjectDetector:
         ymax = np.minimum(self.input_height, y_center + height / 2)
 
         boxes = np.vstack([xmin, ymin, xmax, ymax]).T
-        # dets = np.hstack([boxes, scores.reshape(-1, 1), class_ids.reshape(-1, 1)])
 
         return class_ids.tolist(), scores.tolist(), boxes
 
@@ -153,38 +200,29 @@ class ObjectDetector:
     def __model_predict(self, image: Image.Image) -> Any:
         return self.model.predict({self.input_name: image})  # type: ignore
 
-    def __downloadFile(self, url: str, filename: str) -> str:
-        try:
-            fullpath = os.path.join(self.model_path, filename)
+    async def __downloadFile(self, url: str, filename: str) -> None:
+        fullpath = os.path.join(self.model_path, filename)
 
-            if os.path.isfile(fullpath):
-                return fullpath
+        if os.path.isfile(fullpath):
+            return
 
-            tmp = fullpath + ".tmp"
+        tmp = fullpath + ".tmp"
 
-            self.logger.debug("Creating directory for", tmp)
+        os.makedirs(os.path.dirname(fullpath), exist_ok=True)
 
-            os.makedirs(os.path.dirname(fullpath), exist_ok=True)
+        self.logger.debug("Downloading", url)
 
-            self.logger.debug("Downloading", url)
-
-            response = requests.get(url, stream=True)
-
-            if response.status_code < 200 or response.status_code >= 300:
-                raise Exception(f"Error downloading {url}: {response.status_code}")
+        async with aiohttp.ClientSession() as session, session.get(url) as response:
+            if response.status < 200 or response.status >= 300:
+                raise Exception(f"Error downloading {url}: {response.status}")
 
             read = 0
 
             with open(tmp, "wb") as f:
-                for chunk in response.iter_content(chunk_size=1024 * 1024):
+                async for chunk in response.content.iter_chunked(1024 * 1024):
                     if chunk:
                         read += len(chunk)
-                        self.logger.debug("Downloaded", read, "bytes")
+                        self.logger.debug("Downloaded", read, "Bytes")
                         f.write(chunk)
 
-            os.rename(tmp, fullpath)
-
-            return fullpath
-        except Exception as e:
-            self.logger.error("Error downloading", url, e)
-            raise
+        os.rename(tmp, fullpath)

package/src/plugin_typings.py

@@ -1,5 +1,10 @@
-from typing import TypedDict
+from typing import Optional, TypedDict
 
 
 class CameraStorageValues(TypedDict):
-    active_object_detections: list[str]
+    model: str
+
+
+class FormPayload(TypedDict):
+    model: str
+    confirm: Optional[str]