From 27f01d1dcac143623fbacbf175a9b57d3ab2a87f Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 07:29:12 -0600
Subject: [PATCH 01/27] Move to events package

---
 docs/docs/integrations/api.md               |   9 +
 frigate/app.py                              |   3 +-
 frigate/events/cleanup.py                   | 175 ++++++++++++++++++++
 frigate/{events.py => events/maintainer.py} | 159 ------------------
 frigate/events_manual.py                    | 144 ++++++++++++++++
 frigate/http.py                             |  69 ++++++--
 frigate/object_processing.py                |   2 +-
 frigate/timeline.py                         |   2 +-
 8 files changed, 383 insertions(+), 180 deletions(-)
 create mode 100644 frigate/events/cleanup.py
 rename frigate/{events.py => events/maintainer.py} (51%)
 create mode 100644 frigate/events_manual.py

diff --git a/docs/docs/integrations/api.md b/docs/docs/integrations/api.md
index b5b80f3ea1..434980b243 100644
--- a/docs/docs/integrations/api.md
+++ b/docs/docs/integrations/api.md
@@ -295,3 +295,12 @@ Get ffprobe output for camera feed paths.
 ### `GET /api/<camera_name>/ptz/info`
 
 Get PTZ info for the camera.
+
+### `POST /api/events/manual/<camera_name>/<label>/create`
+
+Create a manual API with a given `label` (ex: doorbell press) to capture a specific event besides an object being detected.
+NOTE: This call will return the unique ID for the event which will be required to `end` the event.
+
+### `POST /api/events/manual/<event_id>/end`
+
+End a specific manual event.
diff --git a/frigate/app.py b/frigate/app.py
index d23073d775..b9c279d429 100644
--- a/frigate/app.py
+++ b/frigate/app.py
@@ -28,7 +28,8 @@
     RECORD_DIR,
 )
 from frigate.object_detection import ObjectDetectProcess
-from frigate.events import EventCleanup, EventProcessor
+from frigate.events.cleanup import EventCleanup
+from frigate.events.maintainer import EventProcessor
 from frigate.http import create_app
 from frigate.log import log_process, root_configurer
 from frigate.models import Event, Recordings, Timeline
diff --git a/frigate/events/cleanup.py b/frigate/events/cleanup.py
new file mode 100644
index 0000000000..28a84ca0b9
--- /dev/null
+++ b/frigate/events/cleanup.py
@@ -0,0 +1,175 @@
+"""Cleanup events based on configured retention."""
+
+import datetime
+import logging
+import os
+import threading
+
+from pathlib import Path
+
+from peewee import fn
+
+from frigate.config import  FrigateConfig
+from frigate.const import CLIPS_DIR
+from frigate.models import Event
+
+from multiprocessing.synchronize import Event as MpEvent
+
+logger = logging.getLogger(__name__)
+
+class EventCleanup(threading.Thread):
+    def __init__(self, config: FrigateConfig, stop_event: MpEvent):
+        threading.Thread.__init__(self)
+        self.name = "event_cleanup"
+        self.config = config
+        self.stop_event = stop_event
+        self.camera_keys = list(self.config.cameras.keys())
+
+    def expire(self, media_type: str) -> None:
+        # TODO: Refactor media_type to enum
+        ## Expire events from unlisted cameras based on the global config
+        if media_type == "clips":
+            retain_config = self.config.record.events.retain
+            file_extension = "mp4"
+            update_params = {"has_clip": False}
+        else:
+            retain_config = self.config.snapshots.retain
+            file_extension = "jpg"
+            update_params = {"has_snapshot": False}
+
+        distinct_labels = (
+            Event.select(Event.label)
+            .where(Event.camera.not_in(self.camera_keys))
+            .distinct()
+        )
+
+        # loop over object types in db
+        for l in distinct_labels:
+            # get expiration time for this label
+            expire_days = retain_config.objects.get(l.label, retain_config.default)
+            expire_after = (
+                datetime.datetime.now() - datetime.timedelta(days=expire_days)
+            ).timestamp()
+            # grab all events after specific time
+            expired_events = Event.select().where(
+                Event.camera.not_in(self.camera_keys),
+                Event.start_time < expire_after,
+                Event.label == l.label,
+                Event.retain_indefinitely == False,
+            )
+            # delete the media from disk
+            for event in expired_events:
+                media_name = f"{event.camera}-{event.id}"
+                media_path = Path(
+                    f"{os.path.join(CLIPS_DIR, media_name)}.{file_extension}"
+                )
+                media_path.unlink(missing_ok=True)
+                if file_extension == "jpg":
+                    media_path = Path(
+                        f"{os.path.join(CLIPS_DIR, media_name)}-clean.png"
+                    )
+                    media_path.unlink(missing_ok=True)
+
+            # update the clips attribute for the db entry
+            update_query = Event.update(update_params).where(
+                Event.camera.not_in(self.camera_keys),
+                Event.start_time < expire_after,
+                Event.label == l.label,
+                Event.retain_indefinitely == False,
+            )
+            update_query.execute()
+
+        ## Expire events from cameras based on the camera config
+        for name, camera in self.config.cameras.items():
+            if media_type == "clips":
+                retain_config = camera.record.events.retain
+            else:
+                retain_config = camera.snapshots.retain
+            # get distinct objects in database for this camera
+            distinct_labels = (
+                Event.select(Event.label).where(Event.camera == name).distinct()
+            )
+
+            # loop over object types in db
+            for l in distinct_labels:
+                # get expiration time for this label
+                expire_days = retain_config.objects.get(l.label, retain_config.default)
+                expire_after = (
+                    datetime.datetime.now() - datetime.timedelta(days=expire_days)
+                ).timestamp()
+                # grab all events after specific time
+                expired_events = Event.select().where(
+                    Event.camera == name,
+                    Event.start_time < expire_after,
+                    Event.label == l.label,
+                    Event.retain_indefinitely == False,
+                )
+                # delete the grabbed clips from disk
+                for event in expired_events:
+                    media_name = f"{event.camera}-{event.id}"
+                    media_path = Path(
+                        f"{os.path.join(CLIPS_DIR, media_name)}.{file_extension}"
+                    )
+                    media_path.unlink(missing_ok=True)
+                    if file_extension == "jpg":
+                        media_path = Path(
+                            f"{os.path.join(CLIPS_DIR, media_name)}-clean.png"
+                        )
+                        media_path.unlink(missing_ok=True)
+                # update the clips attribute for the db entry
+                update_query = Event.update(update_params).where(
+                    Event.camera == name,
+                    Event.start_time < expire_after,
+                    Event.label == l.label,
+                    Event.retain_indefinitely == False,
+                )
+                update_query.execute()
+
+    def purge_duplicates(self) -> None:
+        duplicate_query = """with grouped_events as (
+          select id,
+            label,
+            camera,
+          	has_snapshot,
+          	has_clip,
+          	row_number() over (
+              partition by label, camera, round(start_time/5,0)*5
+              order by end_time-start_time desc
+            ) as copy_number
+          from event
+        )
+
+        select distinct id, camera, has_snapshot, has_clip from grouped_events
+        where copy_number > 1;"""
+
+        duplicate_events = Event.raw(duplicate_query)
+        for event in duplicate_events:
+            logger.debug(f"Removing duplicate: {event.id}")
+            media_name = f"{event.camera}-{event.id}"
+            media_path = Path(f"{os.path.join(CLIPS_DIR, media_name)}.jpg")
+            media_path.unlink(missing_ok=True)
+            media_path = Path(f"{os.path.join(CLIPS_DIR, media_name)}-clean.png")
+            media_path.unlink(missing_ok=True)
+            media_path = Path(f"{os.path.join(CLIPS_DIR, media_name)}.mp4")
+            media_path.unlink(missing_ok=True)
+
+        (
+            Event.delete()
+            .where(Event.id << [event.id for event in duplicate_events])
+            .execute()
+        )
+
+    def run(self) -> None:
+        # only expire events every 5 minutes
+        while not self.stop_event.wait(300):
+            self.expire("clips")
+            self.expire("snapshots")
+            self.purge_duplicates()
+
+            # drop events from db where has_clip and has_snapshot are false
+            delete_query = Event.delete().where(
+                Event.has_clip == False, Event.has_snapshot == False
+            )
+            delete_query.execute()
+
+        logger.info(f"Exiting event cleanup...")
\ No newline at end of file
diff --git a/frigate/events.py b/frigate/events/maintainer.py
similarity index 51%
rename from frigate/events.py
rename to frigate/events/maintainer.py
index 965651edb5..ba76ebb562 100644
--- a/frigate/events.py
+++ b/frigate/events/maintainer.py
@@ -10,7 +10,6 @@
 from peewee import fn
 
 from frigate.config import EventsConfig, FrigateConfig
-from frigate.const import CLIPS_DIR
 from frigate.models import Event
 from frigate.types import CameraMetricsTypes
 from frigate.util import to_relative_box
@@ -196,161 +195,3 @@ def handle_object_detection(
         if event_type == "end":
             del self.events_in_process[event_data["id"]]
             self.event_processed_queue.put((event_data["id"], camera))
-
-
-class EventCleanup(threading.Thread):
-    def __init__(self, config: FrigateConfig, stop_event: MpEvent):
-        threading.Thread.__init__(self)
-        self.name = "event_cleanup"
-        self.config = config
-        self.stop_event = stop_event
-        self.camera_keys = list(self.config.cameras.keys())
-
-    def expire(self, media_type: str) -> None:
-        # TODO: Refactor media_type to enum
-        ## Expire events from unlisted cameras based on the global config
-        if media_type == "clips":
-            retain_config = self.config.record.events.retain
-            file_extension = "mp4"
-            update_params = {"has_clip": False}
-        else:
-            retain_config = self.config.snapshots.retain
-            file_extension = "jpg"
-            update_params = {"has_snapshot": False}
-
-        distinct_labels = (
-            Event.select(Event.label)
-            .where(Event.camera.not_in(self.camera_keys))
-            .distinct()
-        )
-
-        # loop over object types in db
-        for l in distinct_labels:
-            # get expiration time for this label
-            expire_days = retain_config.objects.get(l.label, retain_config.default)
-            expire_after = (
-                datetime.datetime.now() - datetime.timedelta(days=expire_days)
-            ).timestamp()
-            # grab all events after specific time
-            expired_events = Event.select().where(
-                Event.camera.not_in(self.camera_keys),
-                Event.start_time < expire_after,
-                Event.label == l.label,
-                Event.retain_indefinitely == False,
-            )
-            # delete the media from disk
-            for event in expired_events:
-                media_name = f"{event.camera}-{event.id}"
-                media_path = Path(
-                    f"{os.path.join(CLIPS_DIR, media_name)}.{file_extension}"
-                )
-                media_path.unlink(missing_ok=True)
-                if file_extension == "jpg":
-                    media_path = Path(
-                        f"{os.path.join(CLIPS_DIR, media_name)}-clean.png"
-                    )
-                    media_path.unlink(missing_ok=True)
-
-            # update the clips attribute for the db entry
-            update_query = Event.update(update_params).where(
-                Event.camera.not_in(self.camera_keys),
-                Event.start_time < expire_after,
-                Event.label == l.label,
-                Event.retain_indefinitely == False,
-            )
-            update_query.execute()
-
-        ## Expire events from cameras based on the camera config
-        for name, camera in self.config.cameras.items():
-            if media_type == "clips":
-                retain_config = camera.record.events.retain
-            else:
-                retain_config = camera.snapshots.retain
-            # get distinct objects in database for this camera
-            distinct_labels = (
-                Event.select(Event.label).where(Event.camera == name).distinct()
-            )
-
-            # loop over object types in db
-            for l in distinct_labels:
-                # get expiration time for this label
-                expire_days = retain_config.objects.get(l.label, retain_config.default)
-                expire_after = (
-                    datetime.datetime.now() - datetime.timedelta(days=expire_days)
-                ).timestamp()
-                # grab all events after specific time
-                expired_events = Event.select().where(
-                    Event.camera == name,
-                    Event.start_time < expire_after,
-                    Event.label == l.label,
-                    Event.retain_indefinitely == False,
-                )
-                # delete the grabbed clips from disk
-                for event in expired_events:
-                    media_name = f"{event.camera}-{event.id}"
-                    media_path = Path(
-                        f"{os.path.join(CLIPS_DIR, media_name)}.{file_extension}"
-                    )
-                    media_path.unlink(missing_ok=True)
-                    if file_extension == "jpg":
-                        media_path = Path(
-                            f"{os.path.join(CLIPS_DIR, media_name)}-clean.png"
-                        )
-                        media_path.unlink(missing_ok=True)
-                # update the clips attribute for the db entry
-                update_query = Event.update(update_params).where(
-                    Event.camera == name,
-                    Event.start_time < expire_after,
-                    Event.label == l.label,
-                    Event.retain_indefinitely == False,
-                )
-                update_query.execute()
-
-    def purge_duplicates(self) -> None:
-        duplicate_query = """with grouped_events as (
-          select id,
-            label,
-            camera,
-          	has_snapshot,
-          	has_clip,
-          	row_number() over (
-              partition by label, camera, round(start_time/5,0)*5
-              order by end_time-start_time desc
-            ) as copy_number
-          from event
-        )
-
-        select distinct id, camera, has_snapshot, has_clip from grouped_events
-        where copy_number > 1;"""
-
-        duplicate_events = Event.raw(duplicate_query)
-        for event in duplicate_events:
-            logger.debug(f"Removing duplicate: {event.id}")
-            media_name = f"{event.camera}-{event.id}"
-            media_path = Path(f"{os.path.join(CLIPS_DIR, media_name)}.jpg")
-            media_path.unlink(missing_ok=True)
-            media_path = Path(f"{os.path.join(CLIPS_DIR, media_name)}-clean.png")
-            media_path.unlink(missing_ok=True)
-            media_path = Path(f"{os.path.join(CLIPS_DIR, media_name)}.mp4")
-            media_path.unlink(missing_ok=True)
-
-        (
-            Event.delete()
-            .where(Event.id << [event.id for event in duplicate_events])
-            .execute()
-        )
-
-    def run(self) -> None:
-        # only expire events every 5 minutes
-        while not self.stop_event.wait(300):
-            self.expire("clips")
-            self.expire("snapshots")
-            self.purge_duplicates()
-
-            # drop events from db where has_clip and has_snapshot are false
-            delete_query = Event.delete().where(
-                Event.has_clip == False, Event.has_snapshot == False
-            )
-            delete_query.execute()
-
-        logger.info(f"Exiting event cleanup...")
diff --git a/frigate/events_manual.py b/frigate/events_manual.py
new file mode 100644
index 0000000000..a1e4c3e18f
--- /dev/null
+++ b/frigate/events_manual.py
@@ -0,0 +1,144 @@
+import base64
+import logging
+import os
+import random
+import string
+
+import cv2
+from frigate.config import CameraConfig
+
+from frigate.const import CLIPS_DIR
+from frigate.models import Event
+from frigate.object_processing import TrackedObjectProcessor
+
+logger = logging.getLogger(__name__)
+
+
+def create_manual_event(
+    tracked_object_processor: TrackedObjectProcessor,
+    camera_config: CameraConfig,
+    camera_name: str,
+    label: str,
+) -> str:
+    # get a valid frame time for camera
+    frame_time = tracked_object_processor.get_current_frame_time(camera_name)
+
+    # create event id and start frame time
+    rand_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+    event_id = f"{frame_time}-{rand_id}"
+
+    # fabricate obj_data
+    obj_data = {
+        "id": event_id,
+        "camera": camera_name,
+        "frame_time": frame_time,
+        "snapshot_time": 0.0,
+        "label": label,
+        "top_score": 1,
+        "false_positive": False,
+        "start_time": frame_time,
+        "end_time": None,
+        "score": 1,
+        "box": [],
+        "area": 0,
+        "ratio": 0,
+        "region": [],
+        "stationary": False,
+        "motionless_count": 0,
+        "position_changes": [],
+        "current_zones": "",
+        "entered_zones": "",
+        "has_clip": False,
+        "has_snapshot": False,
+        "thumbnail": None,
+    }
+
+    # insert object into the queue
+    current_obj_data = obj_data.copy()
+    tracked_object_processor.event_queue.put(("start", camera_name, current_obj_data))
+
+    # update object data an send another event
+    obj_data["has_clip"] = camera_config.record.enabled
+    obj_data["has_snapshot"] = True
+
+    # Get current frame for thumb & snapshot
+    (
+        current_frame,
+        updated_frame_time,
+    ) = tracked_object_processor.get_current_frame_and_time(camera_name)
+
+    # write jpg snapshot
+    height = int(current_frame.shape[0])
+    width = int(height * current_frame.shape[1] / current_frame.shape[0])
+
+    current_frame = cv2.resize(
+        current_frame, dsize=(width, height), interpolation=cv2.INTER_AREA
+    )
+
+    ret, jpg = cv2.imencode(".jpg", current_frame, [int(cv2.IMWRITE_JPEG_QUALITY), 70])
+
+    with open(
+        os.path.join(CLIPS_DIR, f"{camera_name}-{event_id}.jpg"),
+        "wb",
+    ) as j:
+        j.write(jpg.tobytes())
+
+    # write clean snapshot if enabled
+    if camera_config.snapshots.clean_copy:
+        ret, png = cv2.imencode(".png", current_frame)
+        png_bytes = png.tobytes()
+
+        if png_bytes is None:
+            logger.warning(f"Unable to save clean snapshot for {event_id}.")
+        else:
+            with open(
+                os.path.join(
+                    CLIPS_DIR,
+                    f"{camera_name}-{event_id}-clean.png",
+                ),
+                "wb",
+            ) as p:
+                p.write(png_bytes)
+
+    # get thumbnail
+    height = 175
+    width = int(height * current_frame.shape[1] / current_frame.shape[0])
+
+    current_frame = cv2.resize(
+        current_frame, dsize=(width, height), interpolation=cv2.INTER_AREA
+    )
+
+    ret, thumb = cv2.imencode(
+        ".jpg", current_frame, [int(cv2.IMWRITE_JPEG_QUALITY), 30]
+    )
+
+    obj_data["thumbnail"] = base64.b64encode(thumb).decode("utf-8")
+    obj_data["snapshot_time"] = updated_frame_time
+
+    # update event in queue
+    tracked_object_processor.event_queue.put(("update", camera_name, obj_data))
+
+    return event_id
+
+
+def finish_manual_event(
+    tracked_object_processor: TrackedObjectProcessor,
+    event_id: str,
+):
+    # get associated event and data
+    manual_event: Event = Event.get(Event.id == event_id)
+    camera_name = manual_event.camera
+
+    # get frame time
+    frame_time = tracked_object_processor.get_current_frame_time(camera_name)
+
+    # create obj_data
+    obj_data = {
+        "id": event_id,
+        "end_time": frame_time,
+        "has_snapshot": False,
+        "has_clip": False,
+    }
+
+    # end event in queue
+    tracked_object_processor.event_queue.put(("end", camera_name, obj_data))
diff --git a/frigate/http.py b/frigate/http.py
index 94aa5c129e..a7755ee544 100644
--- a/frigate/http.py
+++ b/frigate/http.py
@@ -1,8 +1,8 @@
 import base64
 from datetime import datetime, timedelta, timezone
 import copy
-import glob
 import logging
+import glob
 import json
 import os
 import subprocess as sp
@@ -34,6 +34,7 @@
 from frigate.config import FrigateConfig
 from frigate.const import CLIPS_DIR, MAX_SEGMENT_DURATION, RECORD_DIR
 from frigate.models import Event, Recordings, Timeline
+from frigate.events_manual import create_manual_event, finish_manual_event
 from frigate.object_processing import TrackedObject
 from frigate.plus import PlusApi
 from frigate.ptz import OnvifController
@@ -44,6 +45,7 @@
     restart_frigate,
     vainfo_hwaccel,
     get_tz_modifiers,
+    to_relative_box,
 )
 from frigate.storage import StorageMaintainer
 from frigate.version import VERSION
@@ -195,7 +197,7 @@ def send_to_plus(id):
         return make_response(jsonify({"success": False, "message": message}), 404)
 
     # events from before the conversion to relative dimensions cant include annotations
-    if any(d > 1 for d in event.data["box"]):
+    if any(d > 1 for d in event.box):
         include_annotation = None
 
     if event.end_time is None:
@@ -251,8 +253,8 @@ def send_to_plus(id):
     event.save()
 
     if not include_annotation is None:
-        region = event.data["region"]
-        box = event.data["box"]
+        region = event.region
+        box = event.box
 
         try:
             current_app.plus_api.add_annotation(
@@ -293,7 +295,7 @@ def false_positive(id):
         return make_response(jsonify({"success": False, "message": message}), 404)
 
     # events from before the conversion to relative dimensions cant include annotations
-    if any(d > 1 for d in event.data["box"]):
+    if any(d > 1 for d in event.box):
         message = f"Events prior to 0.13 cannot be submitted as false positives"
         logger.error(message)
         return make_response(jsonify({"success": False, "message": message}), 400)
@@ -310,15 +312,11 @@ def false_positive(id):
         # need to refetch the event now that it has a plus_id
         event = Event.get(Event.id == id)
 
-    region = event.data["region"]
-    box = event.data["box"]
+    region = event.region
+    box = event.box
 
     # provide top score if score is unavailable
-    score = (
-        (event.data["top_score"] if event.data["top_score"] else event.top_score)
-        if event.data["score"] is None
-        else event.data["score"]
-    )
+    score = event.top_score if event.score is None else event.score
 
     try:
         current_app.plus_api.add_false_positive(
@@ -759,7 +757,6 @@ def events():
         Event.top_score,
         Event.false_positive,
         Event.box,
-        Event.data,
     ]
 
     if camera != "all":
@@ -848,6 +845,47 @@ def events():
     return jsonify([model_to_dict(e, exclude=excluded_fields) for e in events])
 
 
+@bp.route("/events/manual/<camera_name>/<label>/create", methods=("POST",))
+def create_event(camera_name, label):
+    if not camera_name or not current_app.frigate_config.cameras.get(camera_name):
+        return jsonify(
+            {"success": False, "message": f"{camera_name} is not a valid camera."}, 404
+        )
+
+    camera_config = current_app.frigate_config.cameras.get(camera_name)
+
+    if not label:
+        return jsonify({"success": False, "message": f"{label} must be set."}, 404)
+
+    event_id = create_manual_event(
+        current_app.detected_frames_processor,
+        camera_config,
+        camera_name,
+        label,
+    )
+
+    return jsonify(
+        {
+            "success": True,
+            "message": f"Event successfully created.",
+            "event_id": event_id,
+        },
+        200,
+    )
+
+
+@bp.route("/events/manual/<event_id>/end", methods=("POST",))
+def end_event(event_id):
+    try:
+        finish_manual_event(current_app.detected_frames_processor, event_id)
+    except:
+        return jsonify(
+            {"success": False, "message": f"{event_id} must be set and valid."}, 404
+        )
+
+    return jsonify({"success": True, "message": f"Event successfully ended."}, 200)
+
+
 @bp.route("/config")
 def config():
     config = current_app.frigate_config.dict()
@@ -866,11 +904,6 @@ def config():
 
     config["plus"] = {"enabled": current_app.plus_api.is_active()}
 
-    for detector, detector_config in config["detectors"].items():
-        detector_config["model"][
-            "labelmap"
-        ] = current_app.frigate_config.model.merged_labelmap
-
     return jsonify(config)
 
 
diff --git a/frigate/object_processing.py b/frigate/object_processing.py
index cc1667ffba..3088857fa5 100644
--- a/frigate/object_processing.py
+++ b/frigate/object_processing.py
@@ -21,7 +21,7 @@
     FrigateConfig,
 )
 from frigate.const import CLIPS_DIR
-from frigate.events import EventTypeEnum
+from frigate.events.maintainer import EventTypeEnum
 from frigate.util import (
     SharedMemoryFrameManager,
     calculate_region,
diff --git a/frigate/timeline.py b/frigate/timeline.py
index 6b969bc0e2..e40549d08e 100644
--- a/frigate/timeline.py
+++ b/frigate/timeline.py
@@ -5,7 +5,7 @@
 import queue
 
 from frigate.config import FrigateConfig
-from frigate.events import EventTypeEnum
+from frigate.events.maintainer import EventTypeEnum
 from frigate.models import Timeline
 
 from multiprocessing.queues import Queue

From 5456902a76b21038009fcbbfb5797e78b8616e10 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 08:09:31 -0600
Subject: [PATCH 02/27] Improve handling of external events

---
 frigate/events/external.py   |  63 +++++++++++++++
 frigate/events/maintainer.py |   2 +-
 frigate/events_manual.py     | 144 -----------------------------------
 3 files changed, 64 insertions(+), 145 deletions(-)
 create mode 100644 frigate/events/external.py
 delete mode 100644 frigate/events_manual.py

diff --git a/frigate/events/external.py b/frigate/events/external.py
new file mode 100644
index 0000000000..6d22eed5ce
--- /dev/null
+++ b/frigate/events/external.py
@@ -0,0 +1,63 @@
+"""Handle external events created by the user."""
+
+import datetime
+import logging
+import random
+import string
+
+from typing import Optional
+
+from multiprocessing.queues import Queue
+
+from frigate.config import FrigateConfig
+from frigate.events.maintainer import EventTypeEnum
+from frigate.models import Event
+
+logger = logging.getLogger(__name__)
+
+
+class ExternalEventProcessor:
+    def __init__(self, config: FrigateConfig, queue: Queue) -> None:
+        self.config = config
+        self.queue = queue
+
+    def create_manual_event(
+        self,
+        camera: str,
+        label: str,
+        sub_label: str,
+        duration: Optional[int],
+        include_recording: bool,
+    ) -> str:
+        now = datetime.datetime.now().timestamp()
+        camera_config = self.config.cameras.get(camera)
+
+        # create event id and start frame time
+        rand_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+        event_id = f"{now}-{rand_id}"
+
+        self.queue.put(
+            (
+                EventTypeEnum.api,
+                "new",
+                camera_config,
+                {
+                    "id": event_id,
+                    "label": label,
+                    "sub_label": sub_label,
+                    "camera": camera,
+                    "start_time": now,
+                    "end_time": now + duration if duration is not None else None,
+                    "thumbnail": "",  # TODO create thumbnail icon
+                    "has_clip": camera_config.record.enabled and include_recording,
+                    "has_snapshot": False,  # TODO get snapshot frame passed in
+                },
+            )
+        )
+
+        return event_id
+
+    def finish_manual_event(self, event_id: str):
+        """Finish external event with indeterminate duration."""
+        now = datetime.datetime.now().timestamp()
+        self.queue.put((EventTypeEnum.api, "end", None, {"end_time": now}))
diff --git a/frigate/events/maintainer.py b/frigate/events/maintainer.py
index ba76ebb562..22c27c132c 100644
--- a/frigate/events/maintainer.py
+++ b/frigate/events/maintainer.py
@@ -22,7 +22,7 @@
 
 
 class EventTypeEnum(str, Enum):
-    # api = "api"
+    api = "api"
     # audio = "audio"
     tracked_object = "tracked_object"
 
diff --git a/frigate/events_manual.py b/frigate/events_manual.py
deleted file mode 100644
index a1e4c3e18f..0000000000
--- a/frigate/events_manual.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import base64
-import logging
-import os
-import random
-import string
-
-import cv2
-from frigate.config import CameraConfig
-
-from frigate.const import CLIPS_DIR
-from frigate.models import Event
-from frigate.object_processing import TrackedObjectProcessor
-
-logger = logging.getLogger(__name__)
-
-
-def create_manual_event(
-    tracked_object_processor: TrackedObjectProcessor,
-    camera_config: CameraConfig,
-    camera_name: str,
-    label: str,
-) -> str:
-    # get a valid frame time for camera
-    frame_time = tracked_object_processor.get_current_frame_time(camera_name)
-
-    # create event id and start frame time
-    rand_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
-    event_id = f"{frame_time}-{rand_id}"
-
-    # fabricate obj_data
-    obj_data = {
-        "id": event_id,
-        "camera": camera_name,
-        "frame_time": frame_time,
-        "snapshot_time": 0.0,
-        "label": label,
-        "top_score": 1,
-        "false_positive": False,
-        "start_time": frame_time,
-        "end_time": None,
-        "score": 1,
-        "box": [],
-        "area": 0,
-        "ratio": 0,
-        "region": [],
-        "stationary": False,
-        "motionless_count": 0,
-        "position_changes": [],
-        "current_zones": "",
-        "entered_zones": "",
-        "has_clip": False,
-        "has_snapshot": False,
-        "thumbnail": None,
-    }
-
-    # insert object into the queue
-    current_obj_data = obj_data.copy()
-    tracked_object_processor.event_queue.put(("start", camera_name, current_obj_data))
-
-    # update object data an send another event
-    obj_data["has_clip"] = camera_config.record.enabled
-    obj_data["has_snapshot"] = True
-
-    # Get current frame for thumb & snapshot
-    (
-        current_frame,
-        updated_frame_time,
-    ) = tracked_object_processor.get_current_frame_and_time(camera_name)
-
-    # write jpg snapshot
-    height = int(current_frame.shape[0])
-    width = int(height * current_frame.shape[1] / current_frame.shape[0])
-
-    current_frame = cv2.resize(
-        current_frame, dsize=(width, height), interpolation=cv2.INTER_AREA
-    )
-
-    ret, jpg = cv2.imencode(".jpg", current_frame, [int(cv2.IMWRITE_JPEG_QUALITY), 70])
-
-    with open(
-        os.path.join(CLIPS_DIR, f"{camera_name}-{event_id}.jpg"),
-        "wb",
-    ) as j:
-        j.write(jpg.tobytes())
-
-    # write clean snapshot if enabled
-    if camera_config.snapshots.clean_copy:
-        ret, png = cv2.imencode(".png", current_frame)
-        png_bytes = png.tobytes()
-
-        if png_bytes is None:
-            logger.warning(f"Unable to save clean snapshot for {event_id}.")
-        else:
-            with open(
-                os.path.join(
-                    CLIPS_DIR,
-                    f"{camera_name}-{event_id}-clean.png",
-                ),
-                "wb",
-            ) as p:
-                p.write(png_bytes)
-
-    # get thumbnail
-    height = 175
-    width = int(height * current_frame.shape[1] / current_frame.shape[0])
-
-    current_frame = cv2.resize(
-        current_frame, dsize=(width, height), interpolation=cv2.INTER_AREA
-    )
-
-    ret, thumb = cv2.imencode(
-        ".jpg", current_frame, [int(cv2.IMWRITE_JPEG_QUALITY), 30]
-    )
-
-    obj_data["thumbnail"] = base64.b64encode(thumb).decode("utf-8")
-    obj_data["snapshot_time"] = updated_frame_time
-
-    # update event in queue
-    tracked_object_processor.event_queue.put(("update", camera_name, obj_data))
-
-    return event_id
-
-
-def finish_manual_event(
-    tracked_object_processor: TrackedObjectProcessor,
-    event_id: str,
-):
-    # get associated event and data
-    manual_event: Event = Event.get(Event.id == event_id)
-    camera_name = manual_event.camera
-
-    # get frame time
-    frame_time = tracked_object_processor.get_current_frame_time(camera_name)
-
-    # create obj_data
-    obj_data = {
-        "id": event_id,
-        "end_time": frame_time,
-        "has_snapshot": False,
-        "has_clip": False,
-    }
-
-    # end event in queue
-    tracked_object_processor.event_queue.put(("end", camera_name, obj_data))

From 4d35b92e8ae96076bf8ec93bb8d38c32ba18cf96 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 08:17:10 -0600
Subject: [PATCH 03/27] Handle external events in the event queue

---
 frigate/events/external.py   |  4 +++-
 frigate/events/maintainer.py | 32 ++++++++++++++++++++++++++++++--
 2 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/frigate/events/external.py b/frigate/events/external.py
index 6d22eed5ce..da78f93780 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -60,4 +60,6 @@ def create_manual_event(
     def finish_manual_event(self, event_id: str):
         """Finish external event with indeterminate duration."""
         now = datetime.datetime.now().timestamp()
-        self.queue.put((EventTypeEnum.api, "end", None, {"end_time": now}))
+        self.queue.put(
+            (EventTypeEnum.api, "end", None, {"id": event_id, "end_time": now})
+        )
diff --git a/frigate/events/maintainer.py b/frigate/events/maintainer.py
index 22c27c132c..73e456255b 100644
--- a/frigate/events/maintainer.py
+++ b/frigate/events/maintainer.py
@@ -1,11 +1,9 @@
 import datetime
 import logging
-import os
 import queue
 import threading
 
 from enum import Enum
-from pathlib import Path
 
 from peewee import fn
 
@@ -96,6 +94,8 @@ def run(self) -> None:
                     continue
 
                 self.handle_object_detection(event_type, camera, event_data)
+            elif source_type == EventTypeEnum.api:
+                self.handle_external_detection(event_type, event_data)
 
         # set an end_time on events without an end_time before exiting
         Event.update(end_time=datetime.datetime.now().timestamp()).where(
@@ -195,3 +195,31 @@ def handle_object_detection(
         if event_type == "end":
             del self.events_in_process[event_data["id"]]
             self.event_processed_queue.put((event_data["id"], camera))
+
+    def handle_external_detection(self, type: str, event_data: Event):
+        if type == "new":
+            event = {
+                Event.id: event_data["id"],
+                Event.label: event_data["label"],
+                Event.sub_label: event_data["sub_label"],
+                Event.camera: event_data["camera"],
+                Event.start_time: event_data["start_time"],
+                Event.end_time: event_data["end_time"],
+                Event.thumbnail: event_data["thumbnail"],
+                Event.has_clip: event_data["has_clip"],
+                Event.has_snapshot: event_data["has_snapshot"],
+            }
+        elif type == "end":
+            event = {
+                Event.id: event_data["id"],
+                Event.end_time: event_data["end_time"],
+            }
+
+        (
+            Event.insert(event)
+            .on_conflict(
+                conflict_target=[Event.id],
+                update=event,
+            )
+            .execute()
+        )

From 73a1b970f64be608d64f789d96bc45a586103f83 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 08:23:47 -0600
Subject: [PATCH 04/27] Pass in event processor

---
 frigate/app.py  | 6 ++++++
 frigate/http.py | 3 ++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/frigate/app.py b/frigate/app.py
index b9c279d429..146db30d57 100644
--- a/frigate/app.py
+++ b/frigate/app.py
@@ -29,6 +29,7 @@
 )
 from frigate.object_detection import ObjectDetectProcess
 from frigate.events.cleanup import EventCleanup
+from frigate.events.external import ExternalEventProcessor
 from frigate.events.maintainer import EventProcessor
 from frigate.http import create_app
 from frigate.log import log_process, root_configurer
@@ -205,6 +206,9 @@ def init_stats(self) -> None:
             self.config, self.camera_metrics, self.detectors, self.processes
         )
 
+    def init_external_event_processor(self) -> None:
+        self.event_processor = ExternalEventProcessor(self.config, self.event_queue)
+
     def init_web_server(self) -> None:
         self.flask_app = create_app(
             self.config,
@@ -213,6 +217,7 @@ def init_web_server(self) -> None:
             self.detected_frames_processor,
             self.storage_maintainer,
             self.onvif_controller,
+            self.event_processor,
             self.plus_api,
         )
 
@@ -437,6 +442,7 @@ def start(self) -> None:
         self.start_camera_capture_processes()
         self.start_storage_maintainer()
         self.init_stats()
+        self.init_external_event_processor()
         self.init_web_server()
         self.start_timeline_processor()
         self.start_event_processor()
diff --git a/frigate/http.py b/frigate/http.py
index a7755ee544..ff67feb645 100644
--- a/frigate/http.py
+++ b/frigate/http.py
@@ -34,7 +34,7 @@
 from frigate.config import FrigateConfig
 from frigate.const import CLIPS_DIR, MAX_SEGMENT_DURATION, RECORD_DIR
 from frigate.models import Event, Recordings, Timeline
-from frigate.events_manual import create_manual_event, finish_manual_event
+from frigate.events.external import ExternalEventProcessor
 from frigate.object_processing import TrackedObject
 from frigate.plus import PlusApi
 from frigate.ptz import OnvifController
@@ -62,6 +62,7 @@ def create_app(
     detected_frames_processor,
     storage_maintainer: StorageMaintainer,
     onvif: OnvifController,
+    external_processor: ExternalEventProcessor,
     plus_api: PlusApi,
 ):
     app = Flask(__name__)

From 0a1b0ed92ae821fada11d610cf204af8353e24f5 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 09:28:33 -0600
Subject: [PATCH 05/27] Check event json

---
 frigate/events/external.py |  2 +-
 frigate/http.py            | 15 ++++++++-------
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/frigate/events/external.py b/frigate/events/external.py
index da78f93780..38f78778eb 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -25,7 +25,7 @@ def create_manual_event(
         self,
         camera: str,
         label: str,
-        sub_label: str,
+        sub_label: Optional[str],
         duration: Optional[int],
         include_recording: bool,
     ) -> str:
diff --git a/frigate/http.py b/frigate/http.py
index ff67feb645..e513d58dd7 100644
--- a/frigate/http.py
+++ b/frigate/http.py
@@ -82,6 +82,7 @@ def _db_close(exc):
     app.detected_frames_processor = detected_frames_processor
     app.storage_maintainer = storage_maintainer
     app.onvif = onvif
+    app.external_processor = external_processor
     app.plus_api = plus_api
     app.camera_error_image = None
     app.hwaccel_errors = []
@@ -853,22 +854,21 @@ def create_event(camera_name, label):
             {"success": False, "message": f"{camera_name} is not a valid camera."}, 404
         )
 
-    camera_config = current_app.frigate_config.cameras.get(camera_name)
-
     if not label:
         return jsonify({"success": False, "message": f"{label} must be set."}, 404)
 
-    event_id = create_manual_event(
-        current_app.detected_frames_processor,
-        camera_config,
+    event_id = current_app.external_processor.create_manual_event(
         camera_name,
         label,
+        request.json.get("sub_label"),
+        request.json.get("duration"),
+        request.json.get("include_recording") or True,
     )
 
     return jsonify(
         {
             "success": True,
-            "message": f"Event successfully created.",
+            "message": "Successfully created event.",
             "event_id": event_id,
         },
         200,
@@ -878,7 +878,8 @@ def create_event(camera_name, label):
 @bp.route("/events/manual/<event_id>/end", methods=("POST",))
 def end_event(event_id):
     try:
-        finish_manual_event(current_app.detected_frames_processor, event_id)
+        current_app.external_processor.finish_manual_event(event_id)
+        # TODO we need some way to verify that the event id is valid, just check in the db?
     except:
         return jsonify(
             {"success": False, "message": f"{event_id} must be set and valid."}, 404

From c4aea4d1ca766cc474d5dd0444851fd87cd7980e Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 12:07:05 -0600
Subject: [PATCH 06/27] Fix json parsing and change defaults

---
 frigate/events/maintainer.py |  2 ++
 frigate/http.py              | 25 +++++++++++++++----------
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/frigate/events/maintainer.py b/frigate/events/maintainer.py
index 73e456255b..8ae3e5e859 100644
--- a/frigate/events/maintainer.py
+++ b/frigate/events/maintainer.py
@@ -208,6 +208,8 @@ def handle_external_detection(self, type: str, event_data: Event):
                 Event.thumbnail: event_data["thumbnail"],
                 Event.has_clip: event_data["has_clip"],
                 Event.has_snapshot: event_data["has_snapshot"],
+                Event.zones: [],
+                Event.data: {},
             }
         elif type == "end":
             event = {
diff --git a/frigate/http.py b/frigate/http.py
index e513d58dd7..e99d361e60 100644
--- a/frigate/http.py
+++ b/frigate/http.py
@@ -45,7 +45,6 @@
     restart_frigate,
     vainfo_hwaccel,
     get_tz_modifiers,
-    to_relative_box,
 )
 from frigate.storage import StorageMaintainer
 from frigate.version import VERSION
@@ -847,7 +846,7 @@ def events():
     return jsonify([model_to_dict(e, exclude=excluded_fields) for e in events])
 
 
-@bp.route("/events/manual/<camera_name>/<label>/create", methods=("POST",))
+@bp.route("/events/<camera_name>/<label>/create", methods=["POST"])
 def create_event(camera_name, label):
     if not camera_name or not current_app.frigate_config.cameras.get(camera_name):
         return jsonify(
@@ -857,13 +856,19 @@ def create_event(camera_name, label):
     if not label:
         return jsonify({"success": False, "message": f"{label} must be set."}, 404)
 
-    event_id = current_app.external_processor.create_manual_event(
-        camera_name,
-        label,
-        request.json.get("sub_label"),
-        request.json.get("duration"),
-        request.json.get("include_recording") or True,
-    )
+    json: dict[str, any] = request.get_json(silent=True) or {}
+
+    try:
+        event_id = current_app.external_processor.create_manual_event(
+            camera_name,
+            label,
+            json.get("sub_label", None),
+            json.get("duration", 30),
+            json.get("include_recording", True),
+        )
+    except Exception as e:
+        logger.error(f"The error is {e}")
+        return jsonify({"success": False, "message": f"An unknown error occurred: {e}"}, 404)
 
     return jsonify(
         {
@@ -875,7 +880,7 @@ def create_event(camera_name, label):
     )
 
 
-@bp.route("/events/manual/<event_id>/end", methods=("POST",))
+@bp.route("/events/<event_id>/end", methods=["POST"])
 def end_event(event_id):
     try:
         current_app.external_processor.finish_manual_event(event_id)

From b64b0ac48701329c7be97fb4d7c30c9ad47674c5 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 12:26:59 -0600
Subject: [PATCH 07/27] Fix snapshot saving

---
 frigate/events/external.py | 37 +++++++++++++++++++++++++++++++++----
 frigate/http.py            |  7 ++++++-
 2 files changed, 39 insertions(+), 5 deletions(-)

diff --git a/frigate/events/external.py b/frigate/events/external.py
index 38f78778eb..b414c93713 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -1,7 +1,9 @@
 """Handle external events created by the user."""
 
+import cv2
 import datetime
 import logging
+import os
 import random
 import string
 
@@ -9,9 +11,9 @@
 
 from multiprocessing.queues import Queue
 
-from frigate.config import FrigateConfig
+from frigate.config import CameraConfig, FrigateConfig
+from frigate.const import CLIPS_DIR
 from frigate.events.maintainer import EventTypeEnum
-from frigate.models import Event
 
 logger = logging.getLogger(__name__)
 
@@ -28,6 +30,7 @@ def create_manual_event(
         sub_label: Optional[str],
         duration: Optional[int],
         include_recording: bool,
+        snapshot_frame: any,
     ) -> str:
         now = datetime.datetime.now().timestamp()
         camera_config = self.config.cameras.get(camera)
@@ -36,6 +39,7 @@ def create_manual_event(
         rand_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
         event_id = f"{now}-{rand_id}"
 
+        self._write_snapshots(camera_config, event_id, snapshot_frame)
         self.queue.put(
             (
                 EventTypeEnum.api,
@@ -50,16 +54,41 @@ def create_manual_event(
                     "end_time": now + duration if duration is not None else None,
                     "thumbnail": "",  # TODO create thumbnail icon
                     "has_clip": camera_config.record.enabled and include_recording,
-                    "has_snapshot": False,  # TODO get snapshot frame passed in
+                    "has_snapshot": True,
                 },
             )
         )
 
         return event_id
 
-    def finish_manual_event(self, event_id: str):
+    def finish_manual_event(self, event_id: str) -> None:
         """Finish external event with indeterminate duration."""
         now = datetime.datetime.now().timestamp()
         self.queue.put(
             (EventTypeEnum.api, "end", None, {"id": event_id, "end_time": now})
         )
+
+    def _write_snapshots(
+        self, camera_config: CameraConfig, event_id: str, img_bytes: any
+    ) -> None:
+        # write jpg snapshot
+        ret, jpg = cv2.imencode(".jpg", img_bytes)
+        with open(
+            os.path.join(CLIPS_DIR, f"{camera_config.name}-{event_id}.jpg"),
+            "wb",
+        ) as j:
+            j.write(jpg.tobytes())
+
+        # write clean snapshot if enabled
+        if camera_config.snapshots.clean_copy:
+            ret, png = cv2.imencode(".png", img_bytes)
+
+            if ret:
+                with open(
+                    os.path.join(
+                        CLIPS_DIR,
+                        f"{camera_config.name}-{event_id}-clean.png",
+                    ),
+                    "wb",
+                ) as p:
+                    p.write(png.tobytes())
diff --git a/frigate/http.py b/frigate/http.py
index e99d361e60..9de68f398e 100644
--- a/frigate/http.py
+++ b/frigate/http.py
@@ -859,16 +859,21 @@ def create_event(camera_name, label):
     json: dict[str, any] = request.get_json(silent=True) or {}
 
     try:
+        frame = current_app.detected_frames_processor.get_current_frame(camera_name)
+
         event_id = current_app.external_processor.create_manual_event(
             camera_name,
             label,
             json.get("sub_label", None),
             json.get("duration", 30),
             json.get("include_recording", True),
+            frame,
         )
     except Exception as e:
         logger.error(f"The error is {e}")
-        return jsonify({"success": False, "message": f"An unknown error occurred: {e}"}, 404)
+        return jsonify(
+            {"success": False, "message": f"An unknown error occurred: {e}"}, 404
+        )
 
     return jsonify(
         {

From 28f909baaa5ece54ddc966623d33c30c27d61ef4 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 12:37:52 -0600
Subject: [PATCH 08/27] Hide % score when not available

---
 web/src/routes/Events.jsx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/web/src/routes/Events.jsx b/web/src/routes/Events.jsx
index 9c479f8b8c..2502c4cb1c 100644
--- a/web/src/routes/Events.jsx
+++ b/web/src/routes/Events.jsx
@@ -599,7 +599,9 @@ export default function Events({ path, ...props }) {
                           {event.sub_label
                             ? `${event.label.replaceAll('_', ' ')}: ${event.sub_label.replaceAll('_', ' ')}`
                             : event.label.replaceAll('_', ' ')}
-                          ({((event?.data?.top_score || event.top_score) * 100).toFixed(0)}%)
+                          {(event?.data?.top_score || event.top_score || 0) == 0
+                            ? null
+                            : ` (${((event?.data?.top_score || event.top_score) * 100).toFixed(0)}%)`}
                         </div>
                         <div className="text-sm flex">
                           <Clock className="h-5 w-5 mr-2 inline" />

From ccf3b72467bfd30c9a9d08d49812d2114211f55c Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 12:44:58 -0600
Subject: [PATCH 09/27] Correct docs and add json example

---
 docs/docs/integrations/api.md | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/docs/docs/integrations/api.md b/docs/docs/integrations/api.md
index 434980b243..6e44149270 100644
--- a/docs/docs/integrations/api.md
+++ b/docs/docs/integrations/api.md
@@ -296,11 +296,18 @@ Get ffprobe output for camera feed paths.
 
 Get PTZ info for the camera.
 
-### `POST /api/events/manual/<camera_name>/<label>/create`
+### `POST /api/events/<camera_name>/<label>/create`
 
 Create a manual API with a given `label` (ex: doorbell press) to capture a specific event besides an object being detected.
-NOTE: This call will return the unique ID for the event which will be required to `end` the event.
 
-### `POST /api/events/manual/<event_id>/end`
+```json
+{
+  "subLabel": "some_string", // add sub label to event
+  "duration": 30, // predetermined length of event (default: 30 seconds) or can be to null for indeterminate length event
+  "include_recording": true // whether the event should save recordings along with the snapshot that is taken
+}
+```
+
+### `POST /api/events/<event_id>/end`
 
-End a specific manual event.
+End a specific manual event without a predetermined length.

From 83a0a518a93f28f6a791239082a9866a2c2c0ec0 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 13:48:53 -0600
Subject: [PATCH 10/27] Save event png db

---
 frigate/events/external.py        |  17 ++++++++++++++++-
 frigate/images/external-event.png | Bin 0 -> 939 bytes
 2 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 frigate/images/external-event.png

diff --git a/frigate/events/external.py b/frigate/events/external.py
index b414c93713..5c800a8872 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -1,7 +1,9 @@
 """Handle external events created by the user."""
 
+import base64
 import cv2
 import datetime
+import glob
 import logging
 import os
 import random
@@ -22,6 +24,7 @@ class ExternalEventProcessor:
     def __init__(self, config: FrigateConfig, queue: Queue) -> None:
         self.config = config
         self.queue = queue
+        self.default_thumbnail = None
 
     def create_manual_event(
         self,
@@ -40,6 +43,10 @@ def create_manual_event(
         event_id = f"{now}-{rand_id}"
 
         self._write_snapshots(camera_config, event_id, snapshot_frame)
+
+        if not self.default_thumbnail:
+            self._calculate_thumbnail_bytes()
+
         self.queue.put(
             (
                 EventTypeEnum.api,
@@ -52,7 +59,7 @@ def create_manual_event(
                     "camera": camera,
                     "start_time": now,
                     "end_time": now + duration if duration is not None else None,
-                    "thumbnail": "",  # TODO create thumbnail icon
+                    "thumbnail": self.default_thumbnail,
                     "has_clip": camera_config.record.enabled and include_recording,
                     "has_snapshot": True,
                 },
@@ -68,6 +75,14 @@ def finish_manual_event(self, event_id: str) -> None:
             (EventTypeEnum.api, "end", None, {"id": event_id, "end_time": now})
         )
 
+    def _calculate_thumbnail_bytes(self) -> None:
+        error_image = glob.glob("/opt/frigate/frigate/images/external-event.png")
+
+        if len(error_image) > 0:
+            with open("/opt/frigate/frigate/images/external-event.png", 'rb') as img:
+                img_bytes = img.read()
+                self.default_thumbnail = base64.b64encode(img_bytes).decode("utf-8")
+
     def _write_snapshots(
         self, camera_config: CameraConfig, event_id: str, img_bytes: any
     ) -> None:
diff --git a/frigate/images/external-event.png b/frigate/images/external-event.png
new file mode 100644
index 0000000000000000000000000000000000000000..5b396206ba18c10cc1f7f7253880098d4158d483
GIT binary patch
literal 939
zcmeAS@N?(olHy`uVBq!ia0vp^1|ZDA3?vioaBgK_VDt^}32_B-8UFtdUG?91=6~&m
z|DKcnJ2d>a?E7!r0Ag5o{<mrW;Lz~Nq2Y^d>sQN`Z{`i(>{`CrG<>&e`EJ+z-KzPA
zb@LC4=AX8$Uo4xx0@c_weYI`@lHY)eZJWMXH+{Em{%X_w)w&tT{$|zm&8F$QRnvEn
zGN5=9NXiOmAW#;FT7U)u)qe*vKw7|Rtbin#0n`pO*183x(gv&y=mro2qzfbnAwlMV
z6u?Bl4ggvK5l1Ew>Ooc@DZr)}Y$nJr$R;4O|NsBbJpU3X#B)o6{DK)6nOWJ`IXJm^
zcm+iyB&B6!<>VEW)iw1Djf_pqt*mXme1gIvqGHn0v$FH@3#+PY>lzxHnp@ktCr+L+
zZN|)5vllI1wqoU~)oV9z+r4N1p(CeGpE-N};??Un?%cco@X^y(uiw1=@bUB4Z$Ezh
z`PVYrjTLAyW0JSKOP&&cpg52{+0(@_#N+teso}wg90VHl7b!G}3aXZc2#5wc=xA)b
zek18%Q>^B$|NpO^6^trke{5l7w}Jm=*?pDmH}@(p(W}?gO^kflC9_HD+I<IC&ljB>
zArmL?O<)ZA<L||I!pea$;D>ZdN;X@Cs#aW3-e*S5aG}mAw@V+Cr~YkUdr)xt4f_)}
zOXi%a_&V`ggT>k>>)xh2G`O`~iwhKq&9DsEecLxCA?~Z}M)zNv9%bL(=3-W$vtZuI
zjLq>Z4EvJQ*d~-Niqer0Tgq_2v03oOvF9^p`RM(uwVTg=H}T5kiQ1+Trqizac35_<
ze5w{3$?{*_VcG1jk8O6;wFjPz?9t!QQ0lY7TG4T(!m8UpcnZ!j^)b9#Sr}-expF`M
zhgJ4k${F*SVvHMo8%pFjvOAr(d^fmvhDnbx?{kCcMDG>%g&b^;-uNPL%$#eU>6G08
zZ(2%H8SU73UR%EtkVq_h#FcjG;=D^`!dA=Y8&n<2i|sy?*(<KT{O0X*GY&Y*m)o2<
ySk62lc5C=7jngk;c-l=@oP8TraVTu@??2K%5~V`V{S2@N<vLGSKbLh*2~7YL^}~z+

literal 0
HcmV?d00001


From 18ce20ab58b226c5d7b22360e922a3dad7eaee3f Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 13:51:01 -0600
Subject: [PATCH 11/27] Adjust image

---
 frigate/images/external-event.png | Bin 939 -> 2167 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/frigate/images/external-event.png b/frigate/images/external-event.png
index 5b396206ba18c10cc1f7f7253880098d4158d483..f2006d3773d8c597b1448aa5657fd6985014a646 100644
GIT binary patch
literal 2167
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

literal 939
zcmeAS@N?(olHy`uVBq!ia0vp^1|ZDA3?vioaBgK_VDt^}32_B-8UFtdUG?91=6~&m
z|DKcnJ2d>a?E7!r0Ag5o{<mrW;Lz~Nq2Y^d>sQN`Z{`i(>{`CrG<>&e`EJ+z-KzPA
zb@LC4=AX8$Uo4xx0@c_weYI`@lHY)eZJWMXH+{Em{%X_w)w&tT{$|zm&8F$QRnvEn
zGN5=9NXiOmAW#;FT7U)u)qe*vKw7|Rtbin#0n`pO*183x(gv&y=mro2qzfbnAwlMV
z6u?Bl4ggvK5l1Ew>Ooc@DZr)}Y$nJr$R;4O|NsBbJpU3X#B)o6{DK)6nOWJ`IXJm^
zcm+iyB&B6!<>VEW)iw1Djf_pqt*mXme1gIvqGHn0v$FH@3#+PY>lzxHnp@ktCr+L+
zZN|)5vllI1wqoU~)oV9z+r4N1p(CeGpE-N};??Un?%cco@X^y(uiw1=@bUB4Z$Ezh
z`PVYrjTLAyW0JSKOP&&cpg52{+0(@_#N+teso}wg90VHl7b!G}3aXZc2#5wc=xA)b
zek18%Q>^B$|NpO^6^trke{5l7w}Jm=*?pDmH}@(p(W}?gO^kflC9_HD+I<IC&ljB>
zArmL?O<)ZA<L||I!pea$;D>ZdN;X@Cs#aW3-e*S5aG}mAw@V+Cr~YkUdr)xt4f_)}
zOXi%a_&V`ggT>k>>)xh2G`O`~iwhKq&9DsEecLxCA?~Z}M)zNv9%bL(=3-W$vtZuI
zjLq>Z4EvJQ*d~-Niqer0Tgq_2v03oOvF9^p`RM(uwVTg=H}T5kiQ1+Trqizac35_<
ze5w{3$?{*_VcG1jk8O6;wFjPz?9t!QQ0lY7TG4T(!m8UpcnZ!j^)b9#Sr}-expF`M
zhgJ4k${F*SVvHMo8%pFjvOAr(d^fmvhDnbx?{kCcMDG>%g&b^;-uNPL%$#eU>6G08
zZ(2%H8SU73UR%EtkVq_h#FcjG;=D^`!dA=Y8&n<2i|sy?*(<KT{O0X*GY&Y*m)o2<
ySk62lc5C=7jngk;c-l=@oP8TraVTu@??2K%5~V`V{S2@N<vLGSKbLh*2~7YL^}~z+


From d39b02e587911ec5be200a7df723b657312645ff Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 15:24:20 -0600
Subject: [PATCH 12/27] Formatting

---
 frigate/events/cleanup.py  | 5 +++--
 frigate/events/external.py | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/frigate/events/cleanup.py b/frigate/events/cleanup.py
index 28a84ca0b9..09b1964fd7 100644
--- a/frigate/events/cleanup.py
+++ b/frigate/events/cleanup.py
@@ -9,7 +9,7 @@
 
 from peewee import fn
 
-from frigate.config import  FrigateConfig
+from frigate.config import FrigateConfig
 from frigate.const import CLIPS_DIR
 from frigate.models import Event
 
@@ -17,6 +17,7 @@
 
 logger = logging.getLogger(__name__)
 
+
 class EventCleanup(threading.Thread):
     def __init__(self, config: FrigateConfig, stop_event: MpEvent):
         threading.Thread.__init__(self)
@@ -172,4 +173,4 @@ def run(self) -> None:
             )
             delete_query.execute()
 
-        logger.info(f"Exiting event cleanup...")
\ No newline at end of file
+        logger.info(f"Exiting event cleanup...")
diff --git a/frigate/events/external.py b/frigate/events/external.py
index 5c800a8872..05af01ffec 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -79,7 +79,7 @@ def _calculate_thumbnail_bytes(self) -> None:
         error_image = glob.glob("/opt/frigate/frigate/images/external-event.png")
 
         if len(error_image) > 0:
-            with open("/opt/frigate/frigate/images/external-event.png", 'rb') as img:
+            with open("/opt/frigate/frigate/images/external-event.png", "rb") as img:
                 img_bytes = img.read()
                 self.default_thumbnail = base64.b64encode(img_bytes).decode("utf-8")
 

From c2af257821ff0fc6977fa91a1c8fb992c43ee99a Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 15:29:13 -0600
Subject: [PATCH 13/27] Add catch for failure ending event

---
 frigate/events/maintainer.py | 17 ++++++++++-------
 frigate/http.py              |  1 -
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/frigate/events/maintainer.py b/frigate/events/maintainer.py
index 8ae3e5e859..898218ef04 100644
--- a/frigate/events/maintainer.py
+++ b/frigate/events/maintainer.py
@@ -217,11 +217,14 @@ def handle_external_detection(self, type: str, event_data: Event):
                 Event.end_time: event_data["end_time"],
             }
 
-        (
-            Event.insert(event)
-            .on_conflict(
-                conflict_target=[Event.id],
-                update=event,
+        try:
+            (
+                Event.insert(event)
+                .on_conflict(
+                    conflict_target=[Event.id],
+                    update=event,
+                )
+                .execute()
             )
-            .execute()
-        )
+        except Exception:
+            logger.warning(f"Failed to update manual event: {event_data['id']}")
diff --git a/frigate/http.py b/frigate/http.py
index 9de68f398e..b9f273d326 100644
--- a/frigate/http.py
+++ b/frigate/http.py
@@ -889,7 +889,6 @@ def create_event(camera_name, label):
 def end_event(event_id):
     try:
         current_app.external_processor.finish_manual_event(event_id)
-        # TODO we need some way to verify that the event id is valid, just check in the db?
     except:
         return jsonify(
             {"success": False, "message": f"{event_id} must be set and valid."}, 404

From dcd44132a4bf8d562f5ec62c038db72cc568b25a Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 15:33:38 -0600
Subject: [PATCH 14/27] Add init to modules

---
 frigate/events/__init__.py | 0
 frigate/record/__init__.py | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 frigate/events/__init__.py
 create mode 100644 frigate/record/__init__.py

diff --git a/frigate/events/__init__.py b/frigate/events/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/frigate/record/__init__.py b/frigate/record/__init__.py
new file mode 100644
index 0000000000..e69de29bb2

From dfb1707d9c98d2138ed28e4cd2143936e2d9cd4a Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 15:35:21 -0600
Subject: [PATCH 15/27] Fix naming

---
 frigate/app.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/frigate/app.py b/frigate/app.py
index 146db30d57..360d17ea88 100644
--- a/frigate/app.py
+++ b/frigate/app.py
@@ -207,7 +207,7 @@ def init_stats(self) -> None:
         )
 
     def init_external_event_processor(self) -> None:
-        self.event_processor = ExternalEventProcessor(self.config, self.event_queue)
+        self.external_event_processor = ExternalEventProcessor(self.config, self.event_queue)
 
     def init_web_server(self) -> None:
         self.flask_app = create_app(
@@ -217,7 +217,7 @@ def init_web_server(self) -> None:
             self.detected_frames_processor,
             self.storage_maintainer,
             self.onvif_controller,
-            self.event_processor,
+            self.external_event_processor,
             self.plus_api,
         )
 

From 1fcef0b1d8e5dd0ffe714f1291242b4656800fff Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 15:44:06 -0600
Subject: [PATCH 16/27] Formatting

---
 frigate/app.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/frigate/app.py b/frigate/app.py
index 360d17ea88..5e934cc4b0 100644
--- a/frigate/app.py
+++ b/frigate/app.py
@@ -207,7 +207,9 @@ def init_stats(self) -> None:
         )
 
     def init_external_event_processor(self) -> None:
-        self.external_event_processor = ExternalEventProcessor(self.config, self.event_queue)
+        self.external_event_processor = ExternalEventProcessor(
+            self.config, self.event_queue
+        )
 
     def init_web_server(self) -> None:
         self.flask_app = create_app(

From 39d39fe84cfec48b034e1970caa66deafe7b1c98 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 15:45:38 -0600
Subject: [PATCH 17/27] Fix http creation

---
 frigate/test/test_http.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/frigate/test/test_http.py b/frigate/test/test_http.py
index 2c0e58df29..c7447b906b 100644
--- a/frigate/test/test_http.py
+++ b/frigate/test/test_http.py
@@ -155,6 +155,7 @@ def test_get_good_event(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         id = "123456.random"
@@ -175,6 +176,7 @@ def test_get_bad_event(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         id = "123456.random"
@@ -194,6 +196,7 @@ def test_delete_event(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         id = "123456.random"
@@ -215,6 +218,7 @@ def test_event_retention(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         id = "123456.random"
@@ -240,6 +244,7 @@ def test_set_delete_sub_label(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         id = "123456.random"
@@ -274,6 +279,7 @@ def test_sub_label_list(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         id = "123456.random"
@@ -298,6 +304,7 @@ def test_config(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
 
@@ -314,6 +321,7 @@ def test_recordings(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         id = "123456.random"
@@ -333,6 +341,7 @@ def test_stats(self, mock_stats):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         mock_stats.return_value = self.test_stats

From 062983bee912eb683fda198f8cd75060017dba5a Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Mon, 1 May 2023 16:08:09 -0600
Subject: [PATCH 18/27] fix test

---
 frigate/test/test_http.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/frigate/test/test_http.py b/frigate/test/test_http.py
index c7447b906b..ecb5003836 100644
--- a/frigate/test/test_http.py
+++ b/frigate/test/test_http.py
@@ -120,6 +120,7 @@ def test_get_event_list(self):
             None,
             None,
             None,
+            None,
             PlusApi(),
         )
         id = "123456.random"

From c65b149483e4bd66cd243e11046276f3e32baac5 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Tue, 2 May 2023 06:19:01 -0600
Subject: [PATCH 19/27] Change to PUT and include response in docs

---
 docs/docs/integrations/api.md | 17 ++++++++++++++++-
 frigate/http.py               |  2 +-
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/docs/docs/integrations/api.md b/docs/docs/integrations/api.md
index 6e44149270..bf1a79384a 100644
--- a/docs/docs/integrations/api.md
+++ b/docs/docs/integrations/api.md
@@ -300,6 +300,8 @@ Get PTZ info for the camera.
 
 Create a manual API with a given `label` (ex: doorbell press) to capture a specific event besides an object being detected.
 
+**Optional Body:**
+
 ```json
 {
   "subLabel": "some_string", // add sub label to event
@@ -308,6 +310,19 @@ Create a manual API with a given `label` (ex: doorbell press) to capture a speci
 }
 ```
 
-### `POST /api/events/<event_id>/end`
+**Success Response:**
+
+```json
+[
+  {
+    "event_id": "1682970645.13116-1ug7ns",
+    "message": "Successfully created event.",
+    "success": true
+  },
+  200
+]
+```
+
+### `PUT /api/events/<event_id>/end`
 
 End a specific manual event without a predetermined length.
diff --git a/frigate/http.py b/frigate/http.py
index b9f273d326..7605c9bec4 100644
--- a/frigate/http.py
+++ b/frigate/http.py
@@ -885,7 +885,7 @@ def create_event(camera_name, label):
     )
 
 
-@bp.route("/events/<event_id>/end", methods=["POST"])
+@bp.route("/events/<event_id>/end", methods=["PUT"])
 def end_event(event_id):
     try:
         current_app.external_processor.finish_manual_event(event_id)

From 9ba7f5c2ae35190dfa8089d1c035489b99b5d89e Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Tue, 2 May 2023 14:05:41 -0600
Subject: [PATCH 20/27] Add ability to set bounding box locations in snapshot

---
 docs/docs/integrations/api.md |  7 ++++-
 frigate/events/external.py    | 48 ++++++++++++++++++++++++++---------
 frigate/http.py               |  1 +
 3 files changed, 43 insertions(+), 13 deletions(-)

diff --git a/docs/docs/integrations/api.md b/docs/docs/integrations/api.md
index bf1a79384a..fbdb5a25da 100644
--- a/docs/docs/integrations/api.md
+++ b/docs/docs/integrations/api.md
@@ -306,7 +306,12 @@ Create a manual API with a given `label` (ex: doorbell press) to capture a speci
 {
   "subLabel": "some_string", // add sub label to event
   "duration": 30, // predetermined length of event (default: 30 seconds) or can be to null for indeterminate length event
-  "include_recording": true // whether the event should save recordings along with the snapshot that is taken
+  "include_recording": true, // whether the event should save recordings along with the snapshot that is taken
+  "draw": { // optional bounding box that will be drawn on the snapshot
+    "box": [0.5, 0.5, 0.25, 0.25], // box consists of x, 1, width, height which are on a scale between 0 - 1
+    "color": [255, 0, 0], // color of the box, default is red
+    "score": 100, // optional score of the object
+  },
 }
 ```
 
diff --git a/frigate/events/external.py b/frigate/events/external.py
index 05af01ffec..9dd8d98c9f 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -16,6 +16,7 @@
 from frigate.config import CameraConfig, FrigateConfig
 from frigate.const import CLIPS_DIR
 from frigate.events.maintainer import EventTypeEnum
+from frigate.util import draw_box_with_label
 
 logger = logging.getLogger(__name__)
 
@@ -42,7 +43,7 @@ def create_manual_event(
         rand_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
         event_id = f"{now}-{rand_id}"
 
-        self._write_snapshots(camera_config, event_id, snapshot_frame)
+        self._write_snapshots(camera_config, label, event_id, snapshot_frame)
 
         if not self.default_thumbnail:
             self._calculate_thumbnail_bytes()
@@ -76,24 +77,21 @@ def finish_manual_event(self, event_id: str) -> None:
         )
 
     def _calculate_thumbnail_bytes(self) -> None:
-        error_image = glob.glob("/opt/frigate/frigate/images/external-event.png")
+        thumbnail = glob.glob("/opt/frigate/frigate/images/external-event.png")
 
-        if len(error_image) > 0:
+        if len(thumbnail) > 0:
             with open("/opt/frigate/frigate/images/external-event.png", "rb") as img:
                 img_bytes = img.read()
                 self.default_thumbnail = base64.b64encode(img_bytes).decode("utf-8")
 
     def _write_snapshots(
-        self, camera_config: CameraConfig, event_id: str, img_bytes: any
+        self,
+        camera_config: CameraConfig,
+        label: str,
+        event_id: str,
+        draw: dict[str, any],
+        img_bytes: any,
     ) -> None:
-        # write jpg snapshot
-        ret, jpg = cv2.imencode(".jpg", img_bytes)
-        with open(
-            os.path.join(CLIPS_DIR, f"{camera_config.name}-{event_id}.jpg"),
-            "wb",
-        ) as j:
-            j.write(jpg.tobytes())
-
         # write clean snapshot if enabled
         if camera_config.snapshots.clean_copy:
             ret, png = cv2.imencode(".png", img_bytes)
@@ -107,3 +105,29 @@ def _write_snapshots(
                     "wb",
                 ) as p:
                     p.write(png.tobytes())
+
+        # write jpg snapshot with optional annotations
+        if draw.get("box"):
+            x = draw["box"][0] * camera_config.detect.width
+            y = draw["box"][1] * camera_config.detect.height
+            width = draw["box"][2] * camera_config.detect.width
+            height = draw["box"][3] * camera_config.detect.height
+
+            draw_box_with_label(
+                img_bytes,
+                x,
+                y,
+                x + width,
+                y + height,
+                label,
+                f"{draw.get('score', '-')}% {int(width * height)}",
+                thickness=2,
+                color=draw.get("color", (255, 0, 0)),
+            )
+
+        ret, jpg = cv2.imencode(".jpg", img_bytes)
+        with open(
+            os.path.join(CLIPS_DIR, f"{camera_config.name}-{event_id}.jpg"),
+            "wb",
+        ) as j:
+            j.write(jpg.tobytes())
diff --git a/frigate/http.py b/frigate/http.py
index 7605c9bec4..1fd4bef8e7 100644
--- a/frigate/http.py
+++ b/frigate/http.py
@@ -867,6 +867,7 @@ def create_event(camera_name, label):
             json.get("sub_label", None),
             json.get("duration", 30),
             json.get("include_recording", True),
+            json.get("draw", {}),
             frame,
         )
     except Exception as e:

From 1eb9403dc16ed611c4cb45e8d93d2c7877f0f608 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Tue, 2 May 2023 20:38:22 -0600
Subject: [PATCH 21/27] Support multiple box annotations

---
 docs/docs/integrations/api.md | 15 ++++++++++-----
 frigate/events/external.py    | 35 ++++++++++++++++++-----------------
 2 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/docs/docs/integrations/api.md b/docs/docs/integrations/api.md
index fbdb5a25da..e7d85574d3 100644
--- a/docs/docs/integrations/api.md
+++ b/docs/docs/integrations/api.md
@@ -307,11 +307,16 @@ Create a manual API with a given `label` (ex: doorbell press) to capture a speci
   "subLabel": "some_string", // add sub label to event
   "duration": 30, // predetermined length of event (default: 30 seconds) or can be to null for indeterminate length event
   "include_recording": true, // whether the event should save recordings along with the snapshot that is taken
-  "draw": { // optional bounding box that will be drawn on the snapshot
-    "box": [0.5, 0.5, 0.25, 0.25], // box consists of x, 1, width, height which are on a scale between 0 - 1
-    "color": [255, 0, 0], // color of the box, default is red
-    "score": 100, // optional score of the object
-  },
+  "draw": {
+    // optional annotations that will be drawn on the snapshot
+    "boxes": [
+      {
+        "box": [0.5, 0.5, 0.25, 0.25], // box consists of x, 1, width, height which are on a scale between 0 - 1
+        "color": [255, 0, 0], // color of the box, default is red
+        "score": 100 // optional score of the object
+      }
+    ]
+  }
 }
 ```
 
diff --git a/frigate/events/external.py b/frigate/events/external.py
index 9dd8d98c9f..87befe5595 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -107,23 +107,24 @@ def _write_snapshots(
                     p.write(png.tobytes())
 
         # write jpg snapshot with optional annotations
-        if draw.get("box"):
-            x = draw["box"][0] * camera_config.detect.width
-            y = draw["box"][1] * camera_config.detect.height
-            width = draw["box"][2] * camera_config.detect.width
-            height = draw["box"][3] * camera_config.detect.height
-
-            draw_box_with_label(
-                img_bytes,
-                x,
-                y,
-                x + width,
-                y + height,
-                label,
-                f"{draw.get('score', '-')}% {int(width * height)}",
-                thickness=2,
-                color=draw.get("color", (255, 0, 0)),
-            )
+        if draw.get("boxes") and isinstance(draw.get("boxes"), list):
+            for box in draw.get("boxes"):
+                x = box["box"][0] * camera_config.detect.width
+                y = box["box"][1] * camera_config.detect.height
+                width = box["box"][2] * camera_config.detect.width
+                height = box["box"][3] * camera_config.detect.height
+
+                draw_box_with_label(
+                    img_bytes,
+                    x,
+                    y,
+                    x + width,
+                    y + height,
+                    label,
+                    f"{box.get('score', '-')}% {int(width * height)}",
+                    thickness=2,
+                    color=box.get("color", (255, 0, 0)),
+                )
 
         ret, jpg = cv2.imencode(".jpg", img_bytes)
         with open(

From 9046713971ab6ef64073418800aa4b5921db90d4 Mon Sep 17 00:00:00 2001
From: Nicolas Mowen <nickmowen213@gmail.com>
Date: Wed, 17 May 2023 20:23:18 -0600
Subject: [PATCH 22/27] Cleanup docs example response

Co-authored-by: Blake Blackshear <blake@frigate.video>
---
 docs/docs/integrations/api.md | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/docs/docs/integrations/api.md b/docs/docs/integrations/api.md
index e7d85574d3..28492c646d 100644
--- a/docs/docs/integrations/api.md
+++ b/docs/docs/integrations/api.md
@@ -323,14 +323,11 @@ Create a manual API with a given `label` (ex: doorbell press) to capture a speci
 **Success Response:**
 
 ```json
-[
-  {
-    "event_id": "1682970645.13116-1ug7ns",
-    "message": "Successfully created event.",
-    "success": true
-  },
-  200
-]
+{
+  "event_id": "1682970645.13116-1ug7ns",
+  "message": "Successfully created event.",
+  "success": true
+}
 ```
 
 ### `PUT /api/events/<event_id>/end`

From 82a173b920fae5e70fac8f69ef458a9862b90c45 Mon Sep 17 00:00:00 2001
From: Nicolas Mowen <nickmowen213@gmail.com>
Date: Wed, 17 May 2023 20:24:25 -0600
Subject: [PATCH 23/27] Cleanup docs wording

Co-authored-by: Blake Blackshear <blake@frigate.video>
---
 docs/docs/integrations/api.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/docs/integrations/api.md b/docs/docs/integrations/api.md
index 28492c646d..3e5fdfe3ee 100644
--- a/docs/docs/integrations/api.md
+++ b/docs/docs/integrations/api.md
@@ -311,9 +311,9 @@ Create a manual API with a given `label` (ex: doorbell press) to capture a speci
     // optional annotations that will be drawn on the snapshot
     "boxes": [
       {
-        "box": [0.5, 0.5, 0.25, 0.25], // box consists of x, 1, width, height which are on a scale between 0 - 1
+        "box": [0.5, 0.5, 0.25, 0.25], // box consists of x, y, width, height which are on a scale between 0 - 1
         "color": [255, 0, 0], // color of the box, default is red
-        "score": 100 // optional score of the object
+        "score": 100 // optional score associated with the box
       }
     ]
   }

From 48f13a5f366853d4d995a38f7f59777d1ea970d2 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Thu, 18 May 2023 11:20:14 -0600
Subject: [PATCH 24/27] Store full frame for thumbnail

---
 frigate/events/external.py        |  22 +++++++---------------
 frigate/images/external-event.png | Bin 2167 -> 0 bytes
 2 files changed, 7 insertions(+), 15 deletions(-)
 delete mode 100644 frigate/images/external-event.png

diff --git a/frigate/events/external.py b/frigate/events/external.py
index 87befe5595..c3177185f3 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -34,6 +34,7 @@ def create_manual_event(
         sub_label: Optional[str],
         duration: Optional[int],
         include_recording: bool,
+        draw: dict[str, any],
         snapshot_frame: any,
     ) -> str:
         now = datetime.datetime.now().timestamp()
@@ -43,10 +44,7 @@ def create_manual_event(
         rand_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
         event_id = f"{now}-{rand_id}"
 
-        self._write_snapshots(camera_config, label, event_id, snapshot_frame)
-
-        if not self.default_thumbnail:
-            self._calculate_thumbnail_bytes()
+        thumbnail = self._write_images(camera_config, label, event_id, draw, snapshot_frame)
 
         self.queue.put(
             (
@@ -60,7 +58,7 @@ def create_manual_event(
                     "camera": camera,
                     "start_time": now,
                     "end_time": now + duration if duration is not None else None,
-                    "thumbnail": self.default_thumbnail,
+                    "thumbnail": thumbnail,
                     "has_clip": camera_config.record.enabled and include_recording,
                     "has_snapshot": True,
                 },
@@ -76,22 +74,14 @@ def finish_manual_event(self, event_id: str) -> None:
             (EventTypeEnum.api, "end", None, {"id": event_id, "end_time": now})
         )
 
-    def _calculate_thumbnail_bytes(self) -> None:
-        thumbnail = glob.glob("/opt/frigate/frigate/images/external-event.png")
-
-        if len(thumbnail) > 0:
-            with open("/opt/frigate/frigate/images/external-event.png", "rb") as img:
-                img_bytes = img.read()
-                self.default_thumbnail = base64.b64encode(img_bytes).decode("utf-8")
-
-    def _write_snapshots(
+    def _write_images(
         self,
         camera_config: CameraConfig,
         label: str,
         event_id: str,
         draw: dict[str, any],
         img_bytes: any,
-    ) -> None:
+    ) -> str:
         # write clean snapshot if enabled
         if camera_config.snapshots.clean_copy:
             ret, png = cv2.imencode(".png", img_bytes)
@@ -132,3 +122,5 @@ def _write_snapshots(
             "wb",
         ) as j:
             j.write(jpg.tobytes())
+
+        return base64.b64encode(jpg.tobytes()).decode("utf-8")
diff --git a/frigate/images/external-event.png b/frigate/images/external-event.png
deleted file mode 100644
index f2006d3773d8c597b1448aa5657fd6985014a646..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2167
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


From 028c117cdd32c76f7c1eba90833b00778078933d Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Thu, 18 May 2023 11:21:33 -0600
Subject: [PATCH 25/27] Formatting

---
 frigate/events/external.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/frigate/events/external.py b/frigate/events/external.py
index c3177185f3..5e79ff57fe 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -44,7 +44,9 @@ def create_manual_event(
         rand_id = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
         event_id = f"{now}-{rand_id}"
 
-        thumbnail = self._write_images(camera_config, label, event_id, draw, snapshot_frame)
+        thumbnail = self._write_images(
+            camera_config, label, event_id, draw, snapshot_frame
+        )
 
         self.queue.put(
             (

From 9e2f9a9b6fe1356c0f76787137e68eea6d6c0b2c Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Thu, 18 May 2023 11:43:24 -0600
Subject: [PATCH 26/27] Set thumbnail height to 175

---
 frigate/events/external.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/frigate/events/external.py b/frigate/events/external.py
index 5e79ff57fe..42cc10e210 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -82,11 +82,11 @@ def _write_images(
         label: str,
         event_id: str,
         draw: dict[str, any],
-        img_bytes: any,
+        img_frame: any,
     ) -> str:
         # write clean snapshot if enabled
         if camera_config.snapshots.clean_copy:
-            ret, png = cv2.imencode(".png", img_bytes)
+            ret, png = cv2.imencode(".png", img_frame)
 
             if ret:
                 with open(
@@ -107,7 +107,7 @@ def _write_images(
                 height = box["box"][3] * camera_config.detect.height
 
                 draw_box_with_label(
-                    img_bytes,
+                    img_frame,
                     x,
                     y,
                     x + width,
@@ -118,11 +118,17 @@ def _write_images(
                     color=box.get("color", (255, 0, 0)),
                 )
 
-        ret, jpg = cv2.imencode(".jpg", img_bytes)
+        ret, jpg = cv2.imencode(".jpg", img_frame)
         with open(
             os.path.join(CLIPS_DIR, f"{camera_config.name}-{event_id}.jpg"),
             "wb",
         ) as j:
             j.write(jpg.tobytes())
 
+        # create thumbnail with max height of 175 and save
+        width = int(175 * img_frame.shape[1] / img_frame.shape[0])
+        thumb = cv2.resize(
+            img_frame, dsize=(width, 175), interpolation=cv2.INTER_AREA
+        )
+        ret, jpg = cv2.imencode(".jpg", thumb)
         return base64.b64encode(jpg.tobytes()).decode("utf-8")

From 10a78674588e0f57bdcee0ec7cd0aa91f9919760 Mon Sep 17 00:00:00 2001
From: Nick Mowen <nickmowen213@gmail.com>
Date: Thu, 18 May 2023 11:52:42 -0600
Subject: [PATCH 27/27] Formatting

---
 frigate/events/external.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/frigate/events/external.py b/frigate/events/external.py
index 42cc10e210..ee2906e02c 100644
--- a/frigate/events/external.py
+++ b/frigate/events/external.py
@@ -127,8 +127,6 @@ def _write_images(
 
         # create thumbnail with max height of 175 and save
         width = int(175 * img_frame.shape[1] / img_frame.shape[0])
-        thumb = cv2.resize(
-            img_frame, dsize=(width, 175), interpolation=cv2.INTER_AREA
-        )
+        thumb = cv2.resize(img_frame, dsize=(width, 175), interpolation=cv2.INTER_AREA)
         ret, jpg = cv2.imencode(".jpg", thumb)
         return base64.b64encode(jpg.tobytes()).decode("utf-8")