unFlask'ify external_event_processor

frigate/app.py

@@ -252,7 +252,9 @@ class FrigateApp:
 
     def init_external_event_processor(self) -> None:
         self.external_event_processor = ExternalEventProcessor(
-            self.config, self.event_queue
+            self.config,
+            self.event_queue,
+            self.detected_frames_processor,
         )
 
     def init_web_server(self) -> None:

frigate/events/external.py

@@ -10,21 +10,27 @@ from multiprocessing.queues import Queue
 from typing import Optional
 
 import cv2
-from flask import Response, current_app, jsonify
 
 from frigate.config import CameraConfig, FrigateConfig
 from frigate.const import CLIPS_DIR
 from frigate.events.maintainer import EventTypeEnum
+from frigate.object_processing import TrackedObjectProcessor
 from frigate.util import draw_box_with_label
 
 logger = logging.getLogger(__name__)
 
 
 class ExternalEventProcessor:
-    def __init__(self, config: FrigateConfig, queue: Queue) -> None:
+    def __init__(
+        self,
+        config: FrigateConfig,
+        queue: Queue,
+        detected_frames_processor: TrackedObjectProcessor,
+    ) -> None:
         self.config = config
         self.queue = queue
         self.default_thumbnail = None
+        self.detected_frames_processor = detected_frames_processor
 
     def create_manual_event(
         self,
@@ -130,20 +136,25 @@ class ExternalEventProcessor:
         ret, jpg = cv2.imencode(".jpg", thumb)
         return base64.b64encode(jpg.tobytes()).decode("utf-8")
 
-
+    def create_event(self, camera_name: str, label: str, body: dict[str, any] = {}):
-def create_event(camera_name: str, label: str, body: dict[str, any] = {}) -> Response:
+        if not camera_name or not self.config.cameras.get(camera_name):
-    if not camera_name or not current_app.frigate_config.cameras.get(camera_name):
+            return {
-        return jsonify(
+                "success": False,
-            {"success": False, "message": f"{camera_name} is not a valid camera."}, 404
+                "error": 404,
-        )
+                "message": f"{camera_name} is not a valid camera.",
+            }
 
         if not label:
-        return jsonify({"success": False, "message": f"{label} must be set."}, 404)
+            return {
+                "success": False,
+                "error": 404,
+                "message": f"{label} must be set.",
+            }
 
         try:
-        frame = current_app.detected_frames_processor.get_current_frame(camera_name)
+            frame = self.detected_frames_processor.get_current_frame(camera_name)
 
-        event_id = current_app.external_processor.create_manual_event(
+            event_id = self.external_processor.create_manual_event(
                 camera_name,
                 label,
                 body.get("sub_label", None),
@@ -154,27 +165,27 @@ def create_event(camera_name: str, label: str, body: dict[str, any] = {}) -> Res
             )
         except Exception as e:
             logger.error(f"The error is {e}")
-        return jsonify(
+            return {
-            {"success": False, "message": f"An unknown error occurred: {e}"}, 404
+                "success": False,
-        )
+                "error": 404,
+                "message": f"An unknown error occurred: {e}",
+            }
 
-    return jsonify(
+        return {
-        {
             "success": True,
             "message": "Successfully created event.",
             "event_id": event_id,
-        },
+        }
-        200,
-    )
 
-
+    def end_event(self, event_id: str, body: dict[str, any] = {}):
-def end_event(event_id: str, body: dict[str, any] = {}) -> Response:
         try:
             end_time = body.get("end_time", datetime.now().timestamp())
-        current_app.external_processor.finish_manual_event(event_id, end_time)
+            self.finish_manual_event(event_id, end_time)
         except Exception:
-        return jsonify(
+            return {
-            {"success": False, "message": f"{event_id} must be set and valid."}, 404
+                "success": False,
-        )
+                "error": 404,
+                "message": f"{event_id} must be set and valid.",
+            }
 
-    return jsonify({"success": True, "message": "Event successfully ended."}, 200)
+        return {"success": True, "message": "Event successfully ended."}

frigate/http.py

@@ -30,7 +30,7 @@ from tzlocal import get_localzone_name
 
 from frigate.config import FrigateConfig
 from frigate.const import CLIPS_DIR, MAX_SEGMENT_DURATION, RECORD_DIR
-from frigate.events.external import ExternalEventProcessor, create_event, end_event
+from frigate.events.external import ExternalEventProcessor
 from frigate.models import Event, Recordings, Timeline
 from frigate.object_processing import TrackedObject
 from frigate.plus import PlusApi
@@ -851,13 +851,13 @@ def events():
 @bp.route("/events/<camera_name>/<label>/create", methods=["POST"])
 def create_event_handler(camera_name, label):
     json: dict[str, any] = request.get_json(silent=True) or {}
-    return create_event(camera_name, label, json)
+    return current_app.external_processor.create_event(camera_name, label, json)
 
 
 @bp.route("/events/<event_id>/end", methods=["PUT"])
 def end_event_handler(event_id):
     json: dict[str, any] = request.get_json(silent=True) or {}
-    return end_event(event_id, json)
+    return current_app.external_processor.end_event(event_id, json)
 
 
 @bp.route("/config")