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

package/package.json

@@ -1,28 +1,29 @@
 {
   "displayName": "CoreML",
   "name": "@camera.ui/camera-ui-coreml",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "description": "camera.ui coreml plugin",
   "author": "seydx (https://github.com/seydx/camera.ui)",
-  "main": "./src/main.py",
-  "type": "module",
+  "main": "./dist/main.py",
+  "type": "commonjs",
   "scripts": {
+    "bundle": "npm run format && npm run lint && cui bundle",
     "format": "ruff format",
     "install-updates": "npm i --save",
-    "lint": "ruff check --fix",
-    "update": "updates --update ./",
-    "prepublishOnly": "npm i --package-lock-only && npm run format && npm run lint"
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "updates": "^16.4.0"
+    "lint": "ruff check",
+    "lint:fix": "ruff check --fix",
+    "prepublishOnly": "node -e \"if(!process.env.SAFE_PUBLISH){console.error('Error: Please use @camera.ui/cli to publish the plugin:\\n  npm run publish:alpha\\n  npm run publish:beta\\n  npm run publish:latest\\n');process.exit(1)}\"",
+    "publish:alpha": "cui publish --alpha",
+    "publish:beta": "cui publish --beta",
+    "publish:latest": "cui publish --latest",
+    "update": "updates --update ./"
   },
   "bugs": {
     "url": "https://github.com/seydx/camera.ui/issues"
   },
   "engines": {
     "camera.ui": ">=0.0.34-alpha.2",
-    "node": ">=20.17.0"
+    "node": ">=20.18.0"
   },
   "homepage": "https://github.com/seydx/camera.ui#readme",
   "keywords": [
@@ -40,6 +41,7 @@
   "camera.ui": {
     "pythonVersion": "3.11",
     "extension": "objectDetection",
-    "dependencies": []
+    "dependencies": [],
+    "bundled": true
   }
-}
+}

package/CHANGELOG.md

@@ -1,8 +0,0 @@
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [X.X.X] - ???
-
-- Initial Release

package/CONTRIBUTING.md

@@ -1 +0,0 @@
-# Contributing

package/LICENSE.md

@@ -1,22 +0,0 @@
-MIT License
-
-Copyright (c) 2023-2024 seydx <dev@seydx.com>
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1 +0,0 @@
-# @camera.ui/camera-ui-coreml

package/config.schema.json

@@ -1,99 +0,0 @@
-{
-  "schema": {
-    "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"
-        }
-      ]
-    }
-  }
-}

package/requirements.txt

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

package/src/camera_detector.py

@@ -1,272 +0,0 @@
-# camera_detector.py
-import asyncio
-from typing import Optional, cast
-from uuid import uuid4
-
-from camera_ui_python_types import (
-    CameraDevice,
-    CameraPropertyObservableObject,
-    CameraStorage,
-    Detection,
-    LoggerService,
-    ObjectClass,
-    PluginAPI,
-)
-
-from detector_defaults import available_models, default_model
-from object_detector import ObjectDetector
-from plugin_typings import CameraStorageValues
-
-
-class CameraDetector:
-    def __init__(
-        self,
-        camera: CameraDevice,
-        api: PluginAPI,
-        logger: LoggerService,
-    ) -> None:
-        super().__init__()
-
-        self.camera = camera
-        self.api = api
-        self.camera_logger = camera.logger
-
-        self.object_detector = ObjectDetector(self.api, self.camera_logger)
-
-        self.started = False
-        self.closed = False
-        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()
-
-    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
-
-            if self.extended_motion_detector:
-                self.camera_logger.log("Starting Object Detection with Motion Frames")
-            else:
-                self.camera_logger.log("Starting Object Detection")
-
-            self.detection_task = asyncio.create_task(self.__start_detection())
-
-    def close(self):
-        if not self.closed:
-            self.started = False
-            self.closed = True
-
-            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
-
-            self.object_detector.close()
-
-    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()
-
-    async def __restart(self) -> None:
-        if self.restarting or self.closed:
-            return
-
-        self.restarting = True
-
-        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):
-        # 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
-
-            # 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
-
-            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})
-
-    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,86 +0,0 @@
-available_models = [
-    # 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,166 +0,0 @@
-# main.py
-import asyncio
-import os
-from typing import Any, Union
-
-from camera_ui_python_types import (
-    CameraDevice,
-    CameraExtension,
-    FormSubmitResponse,
-    ImageMetadata,
-    LoggerService,
-    ObjectDetectionPlugin,
-    ObjectDetectionPluginResponse,
-    PluginAPI,
-    RootSchema,
-)
-
-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):
-    def __init__(self, logger: LoggerService, api: PluginAPI):
-        self.api = api
-        self.logger = logger
-        self.camera_devices: dict[str, CameraDevice] = {}
-        self.detectors: dict[str, CameraDetector] = {}
-
-        self.api.on("finishLaunching", self.start)
-        self.api.on("shutdown", self.stop)
-
-        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"Camera added: {camera.name}")
-        self.camera_devices[camera.id] = camera
-        await self.create_detector(camera)
-
-    async def camera_deselected(self, id: str, extension: CameraExtension) -> None:
-        camera = self.camera_devices.get(id)
-
-        if camera:
-            self.logger.log(f"Camera removed: {camera.name}")
-            self.remove_detector(camera)
-            del self.camera_devices[id]
-
-    async def start(self) -> None:
-        self.logger.log("Plugin started")
-        await asyncio.gather(*[self.create_detector(camera) for camera in self.camera_devices.values()])
-
-    async def stop(self) -> None:
-        self.logger.log("Plugin stopped")
-
-        detectors_copy = list(self.detectors.values())
-
-        for detector in detectors_copy:
-            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")
-
-                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
-
-    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]
-
-        if detector:
-            detector.close()
-            del self.detectors[camera.id]
-
-    def interfaceSchema(self) -> RootSchema | None:
-        return {
-            "schema": {
-                "models": {
-                    "type": "string",
-                    "title": "Model",
-                    "description": "Model for object detection",
-                    "required": True,
-                    "defaultValue": default_model,
-                    "enum": available_models,
-                }
-            }
-        }
-
-    async def detectObjects(
-        self, image_path: str, metadata: ImageMetadata, config: dict[str, Any]
-    ) -> ObjectDetectionPluginResponse:
-        model_name: str = config.get("models", default_model)
-
-        object_detector = self.object_detectors.get(model_name)
-
-        if not object_detector:
-            object_detector = ObjectDetector(self.api, self.logger)
-            self.object_detectors[model_name] = object_detector
-
-        await object_detector.initialize(model_name)
-
-        detections = await object_detector.detect_single(image_path, metadata)
-
-        print("Detections: ", len(detections))
-
-        return {
-            "detections": detections,
-        }
-
-
-def __main__():
-    return CoreML

package/src/object_detector.py

@@ -1,228 +0,0 @@
-# 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
-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
-
-
-class ObjectDetector:
-    def __init__(
-        self,
-        api: PluginAPI,
-        logger: LoggerService,
-        camera: Optional[CameraDevice] = None,
-    ):
-        self.api = api
-        self.logger = logger
-
-        self.model_path = os.path.join(f"{self.api.storage_path}/models/{model_version}")
-
-        self.initialized = False
-        self.minThreshold = 0.2
-        self.executor = ThreadPoolExecutor(max_workers=8)
-
-        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]
-
-    @property
-    def input_height(self) -> int:
-        return self.input_size[1]
-
-    async def initialize(self, model_name: str) -> None:
-        async with self.lock:
-            if self.__downloading:
-                raise Exception("Already downloading a model")
-
-            if not self.initialized:
-                self.initialized = True
-                self.__downloading = True
-
-                self.selected_model, self.selected_precision = model_name.split(" - ")
-
-                if self.selected_model not in available_models:
-                    self.selected_model = default_model.split(" - ")[0]
-
-                if self.selected_precision not in available_precision:
-                    self.selected_precision = default_model.split(" - ")[1]
-
-                yolo_model_name = self.selected_model.split("_")[0]
-                ml_package = (
-                    f"coreml_{self.selected_model}/{self.selected_precision}/{yolo_model_name}.mlpackage"
-                )
-
-                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)
-                )
-                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
-
-                self.input_size: tuple[int, int] = (inputwidth, inputheight)
-                self.labels = parse_labels(modelspec.description.metadata.userDefined)  # type: ignore
-
-                self.__downloading = False
-
-    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:
-            return [], [], np.array([])
-
-        out_dict = await asyncio.get_event_loop().run_in_executor(self.executor, self.__model_predict, image)
-
-        coordinatesList = out_dict["coordinates"]
-        confidenceList = out_dict["confidence"]
-
-        indices = np.argmax(confidenceList, axis=1)
-        maxConfidences = confidenceList[np.arange(len(confidenceList)), indices]
-        valid = maxConfidences >= self.minThreshold
-
-        if not np.any(valid):
-            return [], [], np.array([])
-
-        coordinates = coordinatesList[valid]
-        class_ids = indices[valid]
-        scores = maxConfidences[valid]
-
-        x_center = self.__torelative(coordinates[:, 0], self.input_width)
-        y_center = self.__torelative(coordinates[:, 1], self.input_height)
-        width = self.__torelative(coordinates[:, 2], self.input_width)
-        height = self.__torelative(coordinates[:, 3], self.input_height)
-
-        xmin = np.maximum(0, x_center - width / 2)
-        ymin = np.maximum(0, y_center - height / 2)
-        xmax = np.minimum(self.input_width, x_center + width / 2)
-        ymax = np.minimum(self.input_height, y_center + height / 2)
-
-        boxes = np.vstack([xmin, ymin, xmax, ymax]).T
-
-        return class_ids.tolist(), scores.tolist(), boxes
-
-    async def detect_single(self, image_path: str, metadata: ImageMetadata) -> list[Detection]:
-        image = Image.open(image_path)
-        image = image.convert("RGB").resize((self.input_width, self.input_height))
-
-        detections: list[Detection] = []
-
-        class_ids, scores, boxes = await self.detect(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.labels[class_id]),
-                "confidence": score,
-                "boundingBox": (float(x1), float(y1), float(x2), float(y2)),
-                "inputWidth": self.input_width,
-                "inputHeight": self.input_height,
-                "origWidth": metadata["width"],
-                "origHeight": metadata["height"],
-            }
-
-            detections.append(detection)
-
-        image.close()
-
-        return detections
-
-    def __torelative(self, values: int, size: int) -> int:
-        return values * size
-
-    def __model_predict(self, image: Image.Image) -> Any:
-        return self.model.predict({self.input_name: image})  # type: ignore
-
-    async def __downloadFile(self, url: str, filename: str) -> None:
-        fullpath = os.path.join(self.model_path, filename)
-
-        if os.path.isfile(fullpath):
-            return
-
-        tmp = fullpath + ".tmp"
-
-        os.makedirs(os.path.dirname(fullpath), exist_ok=True)
-
-        self.logger.debug("Downloading", url)
-
-        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:
-                async for chunk in response.content.iter_chunked(1024 * 1024):
-                    if chunk:
-                        read += len(chunk)
-                        self.logger.debug("Downloaded", read, "Bytes")
-                        f.write(chunk)
-
-        os.rename(tmp, fullpath)

package/src/plugin_typings.py

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

package/src/utils.py

@@ -1,44 +0,0 @@
-import ast
-import re
-from typing import Any
-
-
-def parse_label_contents(contents: str) -> dict[int, Any]:
-    lines = contents.split(",")
-    ret: dict[int, Any] = {}
-
-    for row_number, content in enumerate(lines):
-        pair = re.split(r"[:\s]+", content.strip(), maxsplit=1)
-        if len(pair) == 2 and pair[0].strip().isdigit():
-            ret[int(pair[0])] = pair[1].strip()
-        else:
-            ret[row_number] = content.strip()
-
-    return ret
-
-
-def parse_labels(userDefined: dict[str, Any]) -> list[str]:
-    yolo = userDefined.get("names") or userDefined.get("yolo.names")
-
-    if yolo:
-        j = ast.literal_eval(yolo)
-        ret = []
-        for _, v in j.items():
-            ret.append(v)
-
-        return ret
-
-    classes = userDefined.get("classes")
-
-    # print("classes", classes)
-
-    if not classes:
-        raise Exception("no classes found in model metadata")
-
-    cont = parse_label_contents(classes)
-    ret: list[str] = []
-
-    for _, v in cont.items():
-        ret.append(v)
-
-    return ret