clean up

frigate/api/event.py

@@ -947,31 +947,30 @@ def set_description(id):
 
 @EventBp.route("/events/<id>/description/regenerate", methods=["PUT"])
 def regenerate_description(id):
-    # try:
+    try:
-    #     event: Event = Event.get(Event.id == id)
+        event: Event = Event.get(Event.id == id)
-    # except DoesNotExist:
+    except DoesNotExist:
-    #     return make_response(
+        return make_response(
-    #         jsonify({"success": False, "message": "Event " + id + " not found"}), 404
+            jsonify({"success": False, "message": "Event " + id + " not found"}), 404
-    #     )
+        )
 
-    # if (
+    if (
-    #     current_app.frigate_config.semantic_search.enabled
+        current_app.frigate_config.semantic_search.enabled
-    #     and current_app.frigate_config.genai.enabled
+        and current_app.frigate_config.genai.enabled
-    # ):
+    ):
-    logger.info(id)
+        current_app.event_metadata_updater.publish(event.id)
-    current_app.event_metadata_updater.publish(id)
 
-    return make_response(
+        return make_response(
-        jsonify(
+            jsonify(
-            {
+                {
-                "success": True,
+                    "success": True,
-                "message": "Event "
+                    "message": "Event "
-                + id
+                    + id
-                + " description regeneration has been requested.",
+                    + " description regeneration has been requested.",
-            }
+                }
-        ),
+            ),
-        200,
+            200,
-    )
+        )
 
     return make_response(
         jsonify(

frigate/app.py

@@ -376,7 +376,9 @@ class FrigateApp:
     def init_inter_process_communicator(self) -> None:
         self.inter_process_communicator = InterProcessCommunicator()
         self.inter_config_updater = ConfigPublisher()
-        self.event_metadata_updater = EventMetadataPublisher(EventMetadataTypeEnum.all)
+        self.event_metadata_updater = EventMetadataPublisher(
+            EventMetadataTypeEnum.regenerate_description
+        )
         self.inter_zmq_proxy = ZmqProxy()
 
     def init_web_server(self) -> None:

frigate/comms/event_metadata_updater.py

@@ -37,9 +37,11 @@ class EventMetadataSubscriber(Subscriber):
     def check_for_update(
         self, timeout: float = None
     ) -> Optional[tuple[EventMetadataTypeEnum, any]]:
+        print(f"checking for update, timeout {timeout}")
         return super().check_for_update(timeout)
 
     def _return_object(self, topic: str, payload: any) -> any:
+        print(topic, payload)
         if payload is None:
             return (None, None)
         return (EventMetadataTypeEnum[topic[len(self.topic_base) :]], payload)

frigate/embeddings/maintainer.py

@@ -70,14 +70,11 @@ class EmbeddingMaintainer(threading.Thread):
 
     def _process_updates(self) -> None:
         """Process event updates"""
-        logger.info("processing event updates")
+        update = self.event_subscriber.check_for_update()
-        update = self.event_subscriber.check_for_update(timeout=1)
 
         if update is None:
             return
 
-        logger.info("not returning from _process_updates")
-
         source_type, _, camera, data = update
 
         if not camera or source_type != EventTypeEnum.tracked_object:
@@ -101,71 +98,67 @@ class EmbeddingMaintainer(threading.Thread):
 
     def _process_finalized(self) -> None:
         """Process the end of an event."""
+        while True:
+            ended = self.event_end_subscriber.check_for_update()
 
-        logger.info("processing finalized")
+            if ended == None:
-        ended = self.event_end_subscriber.check_for_update(timeout=1)
+                break
 
-        if ended is None:
+            event_id, camera, updated_db = ended
-            return
+            camera_config = self.config.cameras[camera]
 
-        logger.info("not returning from _process_finalized")
+            if updated_db:
-        event_id, camera, updated_db = ended
+                try:
-        camera_config = self.config.cameras[camera]
+                    event: Event = Event.get(Event.id == event_id)
+                except DoesNotExist:
+                    continue
 
-        if updated_db:
+                # Skip the event if not an object
-            try:
+                if event.data.get("type") != "object":
-                event: Event = Event.get(Event.id == event_id)
+                    continue
-            except DoesNotExist:
-                return
 
-            # Skip the event if not an object
+                # Extract valid event metadata
-            if event.data.get("type") != "object":
+                metadata = get_metadata(event)
-                return
+                thumbnail = base64.b64decode(event.thumbnail)
 
-            # Extract valid event metadata
+                # Embed the thumbnail
-            metadata = get_metadata(event)
+                self._embed_thumbnail(event_id, thumbnail, metadata)
-            thumbnail = base64.b64decode(event.thumbnail)
 
-            # Embed the thumbnail
+                if (
-            self._embed_thumbnail(event_id, thumbnail, metadata)
+                    camera_config.genai.enabled
+                    and self.genai_client is not None
+                    and event.data.get("description") is None
+                ):
+                    # Generate the description. Call happens in a thread since it is network bound.
+                    threading.Thread(
+                        target=self._embed_description,
+                        name=f"_embed_description_{event.id}",
+                        daemon=True,
+                        args=(
+                            event,
+                            [
+                                data["thumbnail"]
+                                for data in self.tracked_events[event_id]
+                            ]
+                            if len(self.tracked_events.get(event_id, [])) > 0
+                            else [thumbnail],
+                            metadata,
+                        ),
+                    ).start()
 
-            if (
+            # Delete tracked events based on the event_id
-                camera_config.genai.enabled
+            if event_id in self.tracked_events:
-                and self.genai_client is not None
+                del self.tracked_events[event_id]
-                and event.data.get("description") is None
-            ):
-                # Generate the description. Call happens in a thread since it is network bound.
-                threading.Thread(
-                    target=self._embed_description,
-                    name=f"_embed_description_{event.id}",
-                    daemon=True,
-                    args=(
-                        event,
-                        [data["thumbnail"] for data in self.tracked_events[event_id]]
-                        if len(self.tracked_events.get(event_id, [])) > 0
-                        else [thumbnail],
-                        metadata,
-                    ),
-                ).start()
-
-        # Delete tracked events based on the event_id
-        if event_id in self.tracked_events:
-            del self.tracked_events[event_id]
 
     def _process_event_metadata(self):
         # Check for regenerate description requests
-        logger.info("processing event metadata")
+        (topic, event_id) = self.event_metadata_subscriber.check_for_update()
-        (topic, event_id) = self.event_metadata_subscriber.check_for_update(timeout=1)
-        logger.info(f"in init in maintainer, {topic} {event_id}")
 
         if topic is None:
             return
 
-        logger.info("not returning from _process_event_metadata")
-
         if event_id:
-            logger.info(f"in maintainer: {event_id}")
+            self.handle_regenerate_description(event_id)
-            # self.handle_regenerate_description(event_id)
 
     def _create_thumbnail(self, yuv_frame, box, height=500) -> Optional[bytes]:
         """Return jpg thumbnail of a region of the frame."""