@camera.ui/server 0.0.16 → 0.0.17

package/dist/server/src/polyglot/python/camera_ui_types/__init__.py

@@ -23,6 +23,7 @@ JsonSchemaType = Literal["string", "number", "boolean", "object", "array", "butt
 
 
 class JsonBaseSchema(TypedDict):
+    type: JsonSchemaType
     key: NotRequired[Optional[str]]
     title: NotRequired[Optional[str]]
     description: NotRequired[Optional[str]]
@@ -42,7 +43,7 @@ class JsonBaseSchema(TypedDict):
 
 
 class JsonSchemaString(JsonBaseSchema):
-    type: Literal["string"]
+    type: Literal["string"]  # type: ignore
     format: NotRequired[
         Literal["date-time", "date", "time", "email", "uuid", "ipv4", "ipv6", "password", "qrCode", "image"]
     ]
@@ -51,34 +52,34 @@ class JsonSchemaString(JsonBaseSchema):
 
 
 class JsonSchemaNumber(JsonBaseSchema):
-    type: Literal["number"]
+    type: Literal["number"]  # type: ignore
     minimum: NotRequired[int]
     maximum: NotRequired[int]
     step: NotRequired[float]
 
 
 class JsonSchemaBoolean(JsonBaseSchema):
-    type: Literal["boolean"]
+    type: Literal["boolean"]  # type: ignore
 
 
 class JsonSchemaEnum(JsonBaseSchema):
-    type: Literal["string"]
+    type: Literal["string"]  # type: ignore
     enum: list[str]
     multiple: NotRequired[bool]
 
 
 class JsonSchemaButton(JsonBaseSchema):
-    type: Literal["button"]
+    type: Literal["button"]  # type: ignore
 
 
 class JsonSchemaObject(JsonBaseSchema):
-    type: Literal["object"]
+    type: Literal["object"]  # type: ignore
     opened: NotRequired[bool]
     properties: NotRequired["JsonSchemaForm"]
 
 
 class JsonSchemaArray(JsonBaseSchema):
-    type: Literal["array"]
+    type: Literal["array"]  # type: ignore
     opened: NotRequired[bool]
     items: NotRequired["JsonSchema"]
 
@@ -117,9 +118,14 @@ class SchemaConfig(TypedDict):
 
 
 # camera object
+class Go2RtcSource(TypedDict):
+    name: str
+    src: str
+
+
 class Go2RtcFFMPEGSource(TypedDict):
-    aac: str
-    opus: str
+    aac: Go2RtcSource
+    opus: Go2RtcSource
 
 
 class Go2RtcWSSource(TypedDict):

package/dist/server/src/polyglot/python/decoder/child.py

@@ -87,11 +87,6 @@ class FrameWorkerChild:
         self.image_subscriber: Optional[ProxySubscription] = None
         self.signal_subscriber: Optional[ProxySubscription] = None
 
-        self.max_diff_frame = 3
-        self.restart_delay = 5
-        self.stopped = False
-        self.closed = False
-        self.restarting = False
         self.clients: dict[str, FrameWorkerClient] = {}
         self.tasks: TaskSet = TaskSet(f"{self.config['cameraName']} FrameWorkerChild")
 
@@ -110,8 +105,15 @@ class FrameWorkerChild:
         self.stdout_task: Optional[asyncio.Task[None]] = None
         self.close_task: Optional[asyncio.Task[None]] = None
 
+        self.stopped = False
+        self.closed = False
+        self.restarting = False
+
+        self.max_diff_frame = 3
+        self.restart_delay = 5
+
         self.restart_timeout: Optional[asyncio.TimerHandle] = None
-        self.restart_delay = 10
+        self.restart_watchdog_delay = 5
 
         self.close_timeout: Optional[asyncio.TimerHandle] = None
         self.close_delay = 5
@@ -236,6 +238,7 @@ class FrameWorkerChild:
             self.ffmpeg_process = None
 
     async def start_video_session(self) -> None:
+        self.reset_prebuffer()
         await self.reset_video_session()
 
         # await self.reset()
@@ -390,7 +393,8 @@ class FrameWorkerChild:
             def restart_watchdog():
                 reset_restart_watchdog()
                 self.restart_timeout = asyncio.get_event_loop().call_later(
-                    self.restart_delay, lambda: asyncio.create_task(restart_ffmpeg())
+                    self.restart_watchdog_delay,
+                    lambda: asyncio.create_task(restart_ffmpeg(), name="FrameWorker Restart FFmpeg"),
                 )
 
             async def restart_ffmpeg():
@@ -555,9 +559,13 @@ class FrameWorkerChild:
 
         self.logger.trace(f"{self.log_prefix} New client {self.client_identifier(plugin_id, request_id)}")
 
+        if self.close_timeout:
+            self.close_timeout.cancel()
+            self.close_timeout = None
+
         await self.send("updateClient", {"pluginId": client.plugin_id, "requestIds": client.request_ids})
 
-        if len(self.clients) == 1:
+        if len(self.clients) > 0 and self.ffmpeg_process is None and not self.restarting:
             await self.start()
 
     async def remove_client(self, plugin_id: str, request_id: str) -> None:
@@ -584,7 +592,7 @@ class FrameWorkerChild:
                 self.close_timeout.cancel()
 
             self.close_timeout = asyncio.get_event_loop().call_later(
-                self.close_delay, lambda: asyncio.create_task(self.stop())
+                self.close_delay, lambda: asyncio.create_task(self.stop(), name="FrameWorker Stop")
             )
 
     async def recover_clients(self, clients: list[RecoveredClient]) -> None:
@@ -647,7 +655,7 @@ class FrameWorkerChild:
             try:
                 message: PingMessage = {"type": "ping", "requestId": request_id}
 
-                # self.logger.trace(f"{self.log_prefix} Sending ping to {camera_id}:{plugin_id}")
+                # self.logger.trace(f"{self.log_prefix} Sending ping to {self.client_identifier(plugin_id, request_id)}")
 
                 response: PongMessage = await self.signaling_publisher.request(
                     ping_target_subject,
@@ -661,13 +669,13 @@ class FrameWorkerChild:
                 if response["type"] != "pong":
                     raise Exception("Invalid response to ping")
 
-                # self.logger.trace(f"{self.log_prefix} Received pong from {camera_id}:{plugin_id}")
+                # self.logger.trace(f"{self.log_prefix} Received pong from {self.client_identifier(plugin_id, request_id)}")
 
                 await asyncio.sleep(ping_interval)
             except (Exception, NoRespondersError, TimeoutError) as e:
                 if request_id_exists():
                     if isinstance(e, (NoRespondersError, TimeoutError)):
-                        self.logger.trace(f"{self.log_prefix} Ping/Pong timeout for {camera_id}:{plugin_id}")
+                        # self.logger.trace(f"{self.log_prefix} Ping/Pong timeout for {self.client_identifier(plugin_id, request_id)}")
                         await self.remove_client(plugin_id, request_id)
                     else:
                         self.logger.error(f"{self.log_prefix} Error during ping/pong:", e)

package/dist/server/src/polyglot/python/plugins/camera_storage.py

@@ -45,7 +45,6 @@ class CameraStorage:
         self.schema: JsonSchemaForm = schema or {}
         self.values: dict[str, Any] = {}
 
-        self.__api.device_manager.once("cameraDeselected", self.__deselected)
         self.__api.once("shutdown", self.__close)
 
     def initializeStorage(self) -> None:
@@ -54,17 +53,10 @@ class CameraStorage:
         This will load the configuration from the database.
         """
 
-        camera_config: dict[str, Any] = {}
-
-        try:
-            config: Any = self.__plugin_db.get("config") or {}
-            camera_config = config.get(self.__camera_id, {})
-        except:  # noqa: E722
-            pass
-
+        config: Any = self.__plugin_db.get("config") or {}
+        camera_config = config.get(self.__camera_id, {})
         schema_config = generate_json_from_root_schema({"schema": self.schema})
-
-        self.values = merge_with(schema_config, camera_config, merge, [])
+        self.values = merge_with(schema_config, camera_config, merge)
 
         self.__save_db()
 
@@ -198,7 +190,7 @@ class CameraStorage:
         elif isinstance(schema_or_path, dict) and schema is None:
             new_schema = schema_or_path
 
-            self.schema = merge_with(self.schema, new_schema, merge, [])
+            self.schema = merge_with(self.schema, new_schema, merge)
 
             await self.__resolve_on_get_functions(new_schema)
 
@@ -228,7 +220,7 @@ class CameraStorage:
             ObjectPath.delete(self.values, path)
 
             if self.__contains_storable_schema(schema):
-                self.__remove_db()
+                self.__save_db()
 
     async def changeSchema(self, path: str, new_schema: dict[str, Any]) -> None:
         """
@@ -244,7 +236,7 @@ class CameraStorage:
         schema: Optional[JsonSchema] = ObjectPath.get(self.schema, schema_path) or None
 
         if schema:
-            merge_with(schema, new_schema, merge, [])
+            merge_with(schema, new_schema, merge)
             ObjectPath.set(self.schema, schema_path, schema)
 
             await self.__resolve_on_get_functions(schema, schema_path)
@@ -332,7 +324,7 @@ class CameraStorage:
                 schema_path = config_path_to_schema_path(new_path)
                 schema_item: Optional[JsonBaseSchema] = get_value_by_path(self.schema, schema_path)
 
-                if schema_item:
+                if schema_item and schema_item["type"] != "button":
                     on_set_function = schema_item.get("onSet", None)
                     if on_set_function:
                         if inspect.iscoroutinefunction(on_set_function):
@@ -394,18 +386,6 @@ class CameraStorage:
 
         self.__plugin_db.update({"config": config})
 
-    def __remove_db(self) -> None:
-        config: Any = self.__plugin_db.get("config") or {}
-
-        if self.__camera_id in config:
-            del config[self.__camera_id]
-            self.__plugin_db.update(config)
-
-    def __deselected(self, id: str) -> None:
-        if id == self.__camera_id:
-            self.__remove_db()
-
     def __close(self) -> None:
         with suppress(Exception):
             self.__save_db()
-            self.__plugin_db.close()

package/dist/server/src/polyglot/python/plugins/child.py

@@ -108,6 +108,7 @@ class PluginChild:
         self.plugin: Optional[BasePlugin] = None
 
         self.stopped = False
+        self.closed = False
 
     async def run(self):
         self.shutdown_event = asyncio.Event()
@@ -194,6 +195,9 @@ class PluginChild:
 
         self.stopped = True
 
+        if self.api:
+            self.api.emit("shutdown")
+
         if self.message_queue:
             self.message_queue.abort_queue()
 
@@ -201,12 +205,10 @@ class PluginChild:
             with suppress(Exception):
                 await self.publisher.close()
 
-        if self.api:
-            self.api.emit("shutdown")
-
         if self.plugin_db:
-            await asyncio.sleep(1)
-            self.plugin_db.close()
+            await asyncio.sleep(0.5)
+            with suppress(Exception):
+                self.plugin_db.close()
 
         self.shutdown_event.set()
 
@@ -291,9 +293,27 @@ class PluginChild:
 
         if "type" in message:
             if message["type"] == PLUGIN_COMMAND.START.value and "data" in message:
-                self.tasks.add(self.start(message["data"]))
+                await self.start(message["data"])
             elif message["type"] == PLUGIN_COMMAND.STOP.value:
-                self.tasks.add(self.stop())
+                await self.stop()
+
+    async def gracefully_close(self, signame: str, reason: Any = "unknown"):
+        if self.stopped or self.closed:
+            return
+
+        self.closed = True
+
+        self.logger.log(
+            f"{self.display_name} is gracefully closing from signal='{signame}' reason='{reason}'..."
+        )
+
+        try:
+            stop_task = asyncio.create_task(self.stop(), name=f"{self.display_name} Stop")
+            await asyncio.wait_for(stop_task, timeout=2)
+            os.kill(os.getpid(), signal.SIGKILL)
+        except asyncio.TimeoutError:
+            self.logger.warn("Failed to gracefully close before timeout, force quit!")
+            os.kill(os.getpid(), signal.SIGKILL)
 
     def setup_signal_handlers(self):
         loop = asyncio.get_running_loop()
@@ -302,20 +322,12 @@ class PluginChild:
         for signame in ("SIGINT", "SIGTERM"):
             loop.add_signal_handler(
                 getattr(signal, signame),
-                lambda signame=signame: self.gracefully_close(signame, getattr(signal, signame)),
+                lambda signame=signame: asyncio.create_task(
+                    self.gracefully_close(signame, getattr(signal, signame)),
+                    name=f"{self.display_name} Signal",
+                ),
             )
 
-    def gracefully_close(self, signame: str, reason: Any = "unknown"):
-        if self.stopped:
-            return
-
-        self.logger.log(
-            f"{self.display_name} is gracefully closing from signal='{signame}' reason='{reason}'..."
-        )
-
-        self.tasks.add(self.stop())
-        self.shutdown_event.set()
-
     def handle_exception(self, loop: AbstractEventLoop, context: Any):
         print("Exception context:", context)
         traceback.print_exc()
@@ -331,7 +343,7 @@ class PluginChild:
             self.logger.error(f"Caught exception: {msg}")
 
         if loop.is_running():
-            self.gracefully_close("uncaughtException", msg)
+            asyncio.create_task(self.gracefully_close("uncaughtException", msg))
 
 
 if __name__ == "__main__":

package/dist/server/src/polyglot/python/plugins/config_service.py

@@ -163,7 +163,14 @@ class PluginConfigService:
         self.set(path_segments[0], self.__config[path_segments[0]], write)
 
     def __init(self) -> None:
-        os.makedirs(os.path.dirname(self.__config_file), exist_ok=True)
+        directory = os.path.dirname(self.__config_file)
+
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+
+        if not os.path.exists(self.__config_file):
+            open(self.__config_file, "a").close()
+
         self.__read()
 
     def __read(self) -> None:

package/dist/server/src/polyglot/python/plugins/proxy/camera_device.py

@@ -10,6 +10,7 @@ from uuid import uuid4
 
 import aiohttp
 from cachetools import LRUCache, cached
+from camera.iou import merge_detections
 from camera.polygon import are_motion_detections_valid, are_object_detections_valid
 from camera.video_frame import MotionFrame, VideoFrame
 from camera_ui_types import (
@@ -68,6 +69,7 @@ from typings import (
     ClientType,
     Delegates,
     DeserializedError,
+    FrameSubscribtion,
     PluginInfo,
     ProxyMessageStructure,
 )
@@ -190,13 +192,13 @@ class CameraDeviceProxy:
         self.camera_subscriber: Optional[ProxySubscription] = None
         self.camera_plugin_subscriber: Optional[ProxySubscription] = None
         self.signaling_subscriber: Optional[ProxySubscription] = None
-        self.frame_subscriber: Optional[ProxySubscription] = None
-        self.motion_frame_subscriber: Optional[ProxySubscription] = None
+        self.frame_subscribers: list[FrameSubscribtion] = []
+        self.motion_frame_subscribers: list[FrameSubscribtion] = []
 
         self.tasks: TaskSet = TaskSet(f"{self.plugin['name']} - {self.name} - CameraDeviceProxy")
         self.message_queue: Optional[MessageQueue] = None
         self.active_requests: set[str] = set()
-        self.active_motion_requests = 0
+        self.active_motion_requests: set[str] = set()
 
         # print(("INIT camera device with clientSubject", self.subject))
 
@@ -425,24 +427,24 @@ class CameraDeviceProxy:
 
         if prebuffer_duration > 0:
             request_type = "prebuffer"
-            prebuffer_duration = 5 if prebuffer_duration > 5 else prebuffer_duration
+            prebuffer_duration = min(prebuffer_duration, 5)
 
         request_id = f"{str(uuid4())}-{request_type}"
 
         try:
             metadata = await self.__connect_to_decoder(request_id)
+            frame_subscriber = await self.frame_publisher.subscribe(self.frame_subject)
 
-            if not self.frame_subscriber:
-                self.frame_subscriber = await self.frame_publisher.subscribe(self.frame_subject)
+            self.frame_subscribers.append({"request_id": request_id, "subscriber": frame_subscriber})
 
-            async for msg in self.frame_subscriber.subscriber.messages:
-                try:
+            try:
+                async for msg in frame_subscriber.subscriber.messages:
                     if (
                         not self.initialized
                         or len(self.active_requests) == 0
                         or request_id not in self.active_requests
                     ):
-                        break
+                        return
 
                     if len(msg.data) == 0:
                         continue
@@ -450,35 +452,39 @@ class CameraDeviceProxy:
                     frame_data: FrameData = unpack(msg.data)
 
                     yield VideoFrame(self.id, self.frame_publisher, frame_data, metadata, prebuffer_duration)
-                except Exception as e:
-                    if self.initialized:
-                        self.logger.error("Error while processing frame:", e)
-                    else:
-                        break
+
+            except GeneratorExit:
+                return
 
         except asyncio.CancelledError:
-            pass
+            return
         except Exception as e:
             if self.initialized:
                 self.logger.error("Error while generating frames:", e)
+            raise
         finally:
-            self.tasks.add(self.__disconnect_from_decoder(request_id))
+            await self.__disconnect_from_decoder(request_id)
 
     async def get_motion_frames(self) -> AsyncGenerator[MotionFrame, None]:
         if not self.motion_frame_publisher:
             raise Exception("Motion Frame Publisher is not initialized")
 
-        self.active_motion_requests += 1
+        request_id = f"{str(uuid4())}-motion"
 
         try:
-            if not self.motion_frame_subscriber:
-                self.motion_frame_subscriber = await self.motion_frame_publisher.subscribe(
-                    self.motion_frame_subject
-                )
+            motion_frame_subscriber = await self.motion_frame_publisher.subscribe(self.motion_frame_subject)
 
-            async for msg in self.motion_frame_subscriber.subscriber.messages:
-                try:
-                    if not self.initialized or self.active_motion_requests <= 0:
+            self.motion_frame_subscribers.append(
+                {"request_id": request_id, "subscriber": motion_frame_subscriber}
+            )
+
+            try:
+                async for msg in motion_frame_subscriber.subscriber.messages:
+                    if (
+                        not self.initialized
+                        or len(self.active_motion_requests) == 0
+                        or request_id not in self.active_motion_requests
+                    ):
                         break
 
                     if not msg or not msg.data or len(msg.data) == 0:
@@ -499,22 +505,30 @@ class CameraDeviceProxy:
                         motion_state,
                         motion_frame["metadata"],
                     )
-                except Exception as e:
-                    if self.initialized:
-                        self.logger.error("Error while processing motion frame:", e)
-                    else:
-                        break
+
+            except GeneratorExit:
+                return
 
         except asyncio.CancelledError:
             pass
         except Exception as e:
             if self.initialized:
                 self.logger.error("Error while generating motion frames:", e)
+            raise
         finally:
-            self.active_motion_requests -= 1
+            if request_id in self.active_motion_requests:
+                self.active_motion_requests.remove(request_id)
+
+            motion_frame_subscribtion = next(
+                (sub for sub in self.motion_frame_subscribers if sub["request_id"] == request_id), None
+            )
+
+            if motion_frame_subscribtion:
+                self.motion_frame_subscribers.remove(motion_frame_subscribtion)
+                await motion_frame_subscribtion["subscriber"].close()
 
-            if self.active_motion_requests <= 0:
-                self.tasks.add(self.__close_motion_frame_subscriber())
+            if len(self.motion_frame_subscribers) == 0:
+                await self.__close_motion_frame_subscribers()
 
     @overload
     def get_value(self, state_name: Literal["light"]) -> LightState: ...
@@ -913,6 +927,8 @@ class CameraDeviceProxy:
                 det["boundingBox"] = cast(tuple[int, int, int, int], tuple(det["boundingBox"]))
                 det["confidence"] = float(det["confidence"])
 
+            motion_event["detections"] = merge_detections(motion_event["detections"])
+
             motion_event["detections"] = are_motion_detections_valid(
                 motion_event["detections"], self.activity_zones, self.activity_settings
             )
@@ -1433,37 +1449,48 @@ class CameraDeviceProxy:
             metadata = metadata_response.get("metadata")
 
             return metadata
-        except:  # noqa: E722
-            self.logger.error("Failed to get metadata! Frame Worker FFmpeg process might not be running")
+        except Exception as e:
+            self.logger.error("Failed to get metadata! Frame Worker FFmpeg process might not be running", e)
 
     async def __disconnect_from_decoder(self, request_id: str) -> None:
         if request_id in self.active_requests:
             self.active_requests.remove(request_id)
 
-        if not self.signaling_publisher:
-            raise Exception("Signaling Publisher not initialized")
+        frame_subscription = next(
+            (sub for sub in self.frame_subscribers if sub["request_id"] == request_id), None
+        )
 
-        message: SignalingRequest = {
-            "type": "disconnect",
-            "requestId": request_id,
-            "cameraId": self.id,
-            "pluginId": self.plugin["id"],
-        }
+        if frame_subscription:
+            self.frame_subscribers.remove(frame_subscription)
+            await frame_subscription["subscriber"].close()
 
-        await self.signaling_publisher.publish(self.signaling_target_subject, message)
+        if self.signaling_publisher:
+            message: SignalingRequest = {
+                "type": "disconnect",
+                "requestId": request_id,
+                "cameraId": self.id,
+                "pluginId": self.plugin["id"],
+            }
 
-    async def __close_frame_subscriber(self) -> None:
-        with suppress(Exception):
-            if self.frame_subscriber:
-                await self.frame_subscriber.close()
-                self.frame_subscriber = None
+            await self.signaling_publisher.publish(self.signaling_target_subject, message)
+
+    async def __close_frame_subscribers(self) -> None:
+        self.active_requests.clear()
+
+        for sub in self.frame_subscribers:
+            with suppress(Exception):
+                await sub["subscriber"].close()
 
-    async def __close_motion_frame_subscriber(self) -> None:
-        if self.motion_frame_subscriber:
+        self.frame_subscribers.clear()
+
+    async def __close_motion_frame_subscribers(self) -> None:
+        self.active_motion_requests.clear()
+
+        for sub in self.motion_frame_subscribers:
             with suppress(Exception):
-                await self.motion_frame_subscriber.close()
+                await sub["subscriber"].close()
 
-            self.motion_frame_subscriber = None
+        self.motion_frame_subscribers.clear()
 
     async def __request_handler(self, message: ProxyMessageStructure) -> None:
         if not self.message_queue:
@@ -1565,8 +1592,16 @@ class CameraDeviceProxy:
             if message["requestId"] in self.active_requests:
                 self.active_requests.remove(message["requestId"])
 
+            frame_subscribtion = next(
+                (sub for sub in self.frame_subscribers if sub["request_id"] == message["requestId"]), None
+            )
+
+            if frame_subscribtion:
+                self.frame_subscribers.remove(frame_subscribtion)
+                await frame_subscribtion["subscriber"].close()
+
             if len(self.active_requests) == 0:
-                self.tasks.add(self.__close_frame_subscriber())
+                self.tasks.add(self.__close_frame_subscribers())
 
     async def __respond_to_signaling_message(self, msg: Msg, message: PingMessage) -> None:
         try:

package/dist/server/src/polyglot/python/plugins/typings.py

@@ -25,6 +25,7 @@ from camera_ui_types import (
     StateValues,
 )
 from typing_extensions import Literal, NotRequired, TypedDict
+from utilities.subscriptions import ProxySubscription
 
 
 class PLUGIN_STATUS(Enum):
@@ -245,3 +246,8 @@ Delegates = Literal[
     "prebufferDelegate",
     "ptzDelegate",
 ]
+
+
+class FrameSubscribtion(TypedDict):
+    request_id: str
+    subscriber: ProxySubscription

package/dist/server/src/polyglot/python/utilities/subscriptions.py

@@ -1,19 +1,21 @@
+import asyncio
+
 from nats.aio.subscription import Subscription as NatsSubscription
 from pyeecui.asyncio import AsyncIOEventEmitter
 
 
 class ProxySubscription(AsyncIOEventEmitter):
-    def __init__(self, subscriber: NatsSubscription) -> None:
+    def __init__(self, subscriber: NatsSubscription, max_concurrent: int = 25) -> None:
         super().__init__()
-
         self.subscriber = subscriber
+        self.semaphore = asyncio.Semaphore(max_concurrent)
 
     async def listen(self):
         async for msg in self.subscriber.messages:
             if len(msg.data) == 0:
                 continue
-
-            self.emit("message", msg)
+            async with self.semaphore:
+                self.emit("message", msg)
 
     async def close(self):
         self.remove_all_listeners()