backend rename

frigate/api/app.py

@@ -619,37 +619,39 @@ def get_sub_labels(split_joined: Optional[int] = None):
     return JSONResponse(content=sub_labels)
 
 
-@router.get("/identifiers")
+@router.get("/recognized_license_plates")
-def get_identifiers(split_joined: Optional[int] = None):
+def get_recognized_license_plates(split_joined: Optional[int] = None):
     try:
         events = Event.select(Event.data).distinct()
     except Exception:
         return JSONResponse(
-            content=({"success": False, "message": "Failed to get identifiers"}),
+            content=(
+                {"success": False, "message": "Failed to get recognized license plates"}
+            ),
             status_code=404,
         )
 
-    identifiers = []
+    recognized_license_plates = []
     for e in events:
-        if e.data is not None and "identifier" in e.data:
+        if e.data is not None and "recognized_license_plate" in e.data:
-            identifiers.append(e.data["identifier"])
+            recognized_license_plates.append(e.data["recognized_license_plate"])
 
-    while None in identifiers:
+    while None in recognized_license_plates:
-        identifiers.remove(None)
+        recognized_license_plates.remove(None)
 
     if split_joined:
-        original_identifiers = identifiers.copy()
+        original_recognized_license_plates = recognized_license_plates.copy()
-        for identifier in original_identifiers:
+        for recognized_license_plate in original_recognized_license_plates:
-            if identifier and "," in identifier:
+            if recognized_license_plate and "," in recognized_license_plate:
-                identifiers.remove(identifier)
+                recognized_license_plates.remove(recognized_license_plate)
-                parts = identifier.split(",")
+                parts = recognized_license_plate.split(",")
                 for part in parts:
-                    if part.strip() not in identifiers:
+                    if part.strip() not in recognized_license_plates:
-                        identifiers.append(part.strip())
+                        recognized_license_plates.append(part.strip())
 
-    identifiers = list(set(identifiers))
+    recognized_license_plates = list(set(recognized_license_plates))
-    identifiers.sort()
+    recognized_license_plates.sort()
-    return JSONResponse(content=identifiers)
+    return JSONResponse(content=recognized_license_plates)
 
 
 @router.get("/timeline")

frigate/api/defs/query/events_query_parameters.py

@@ -27,7 +27,7 @@ class EventsQueryParams(BaseModel):
     max_score: Optional[float] = None
     min_speed: Optional[float] = None
     max_speed: Optional[float] = None
-    identifier: Optional[str] = "all"
+    recognized_license_plate: Optional[str] = "all"
     is_submitted: Optional[int] = None
     min_length: Optional[float] = None
     max_length: Optional[float] = None
@@ -56,7 +56,7 @@ class EventsSearchQueryParams(BaseModel):
     max_score: Optional[float] = None
     min_speed: Optional[float] = None
     max_speed: Optional[float] = None
-    identifier: Optional[str] = "all"
+    recognized_license_plate: Optional[str] = "all"
     sort: Optional[str] = None
 
 

frigate/api/event.py

@@ -101,7 +101,7 @@ def events(params: EventsQueryParams = Depends()):
     min_length = params.min_length
     max_length = params.max_length
     event_id = params.event_id
-    identifier = params.identifier
+    recognized_license_plate = params.recognized_license_plate
 
     sort = params.sort
 
@@ -159,31 +159,44 @@ def events(params: EventsQueryParams = Depends()):
         sub_label_clause = reduce(operator.or_, sub_label_clauses)
         clauses.append((sub_label_clause))
 
-    if identifier != "all":
+    if recognized_license_plate != "all":
-        # use matching so joined identifiers are included
+        # use matching so joined recognized_license_plates are included
-        # for example an identifier 'ABC123' would get events
+        # for example a recognized license plate 'ABC123' would get events
-        # with identifiers 'ABC123' and 'ABC123, XYZ789'
+        # with recognized license plates 'ABC123' and 'ABC123, XYZ789'
-        identifier_clauses = []
+        recognized_license_plate_clauses = []
-        filtered_identifiers = identifier.split(",")
+        filtered_recognized_license_plates = recognized_license_plate.split(",")
 
-        if "None" in filtered_identifiers:
+        if "None" in filtered_recognized_license_plates:
-            filtered_identifiers.remove("None")
+            filtered_recognized_license_plates.remove("None")
-            identifier_clauses.append((Event.data["identifier"].is_null()))
+            recognized_license_plate_clauses.append(
+                (Event.data["recognized_license_plate"].is_null())
+            )
 
-        for identifier in filtered_identifiers:
+        for recognized_license_plate in filtered_recognized_license_plates:
             # Exact matching plus list inclusion
-            identifier_clauses.append(
+            recognized_license_plate_clauses.append(
-                (Event.data["identifier"].cast("text") == identifier)
+                (
+                    Event.data["recognized_license_plate"].cast("text")
+                    == recognized_license_plate
+                )
             )
-            identifier_clauses.append(
+            recognized_license_plate_clauses.append(
-                (Event.data["identifier"].cast("text") % f"*{identifier},*")
+                (
+                    Event.data["recognized_license_plate"].cast("text")
+                    % f"*{recognized_license_plate},*"
+                )
             )
-            identifier_clauses.append(
+            recognized_license_plate_clauses.append(
-                (Event.data["identifier"].cast("text") % f"*, {identifier}*")
+                (
+                    Event.data["recognized_license_plate"].cast("text")
+                    % f"*, {recognized_license_plate}*"
+                )
             )
 
-        identifier_clause = reduce(operator.or_, identifier_clauses)
+        recognized_license_plate_clause = reduce(
-        clauses.append((identifier_clause))
+            operator.or_, recognized_license_plate_clauses
+        )
+        clauses.append((recognized_license_plate_clause))
 
     if zones != "all":
         # use matching so events with multiple zones
@@ -367,8 +380,8 @@ def events_explore(limit: int = 10):
                         "average_estimated_speed",
                         "velocity_angle",
                         "path_data",
-                        "identifier",
+                        "recognized_license_plate",
-                        "identifier_score",
+                        "recognized_license_plate_score",
                     ]
                 },
                 "event_count": label_counts[event.label],
@@ -426,7 +439,7 @@ def events_search(request: Request, params: EventsSearchQueryParams = Depends())
     has_clip = params.has_clip
     has_snapshot = params.has_snapshot
     is_submitted = params.is_submitted
-    identifier = params.identifier
+    recognized_license_plate = params.recognized_license_plate
 
     # for similarity search
     event_id = params.event_id
@@ -496,31 +509,44 @@ def events_search(request: Request, params: EventsSearchQueryParams = Depends())
 
         event_filters.append((reduce(operator.or_, zone_clauses)))
 
-    if identifier != "all":
+    if recognized_license_plate != "all":
-        # use matching so joined identifiers are included
+        # use matching so joined recognized_license_plates are included
-        # for example an identifier 'ABC123' would get events
+        # for example an recognized_license_plate 'ABC123' would get events
-        # with identifiers 'ABC123' and 'ABC123, XYZ789'
+        # with recognized_license_plates 'ABC123' and 'ABC123, XYZ789'
-        identifier_clauses = []
+        recognized_license_plate_clauses = []
-        filtered_identifiers = identifier.split(",")
+        filtered_recognized_license_plates = recognized_license_plate.split(",")
 
-        if "None" in filtered_identifiers:
+        if "None" in filtered_recognized_license_plates:
-            filtered_identifiers.remove("None")
+            filtered_recognized_license_plates.remove("None")
-            identifier_clauses.append((Event.data["identifier"].is_null()))
+            recognized_license_plate_clauses.append(
+                (Event.data["recognized_license_plate"].is_null())
+            )
 
-        for identifier in filtered_identifiers:
+        for recognized_license_plate in filtered_recognized_license_plates:
             # Exact matching plus list inclusion
-            identifier_clauses.append(
+            recognized_license_plate_clauses.append(
-                (Event.data["identifier"].cast("text") == identifier)
+                (
+                    Event.data["recognized_license_plate"].cast("text")
+                    == recognized_license_plate
+                )
             )
-            identifier_clauses.append(
+            recognized_license_plate_clauses.append(
-                (Event.data["identifier"].cast("text") % f"*{identifier},*")
+                (
+                    Event.data["recognized_license_plate"].cast("text")
+                    % f"*{recognized_license_plate},*"
+                )
             )
-            identifier_clauses.append(
+            recognized_license_plate_clauses.append(
-                (Event.data["identifier"].cast("text") % f"*, {identifier}*")
+                (
+                    Event.data["recognized_license_plate"].cast("text")
+                    % f"*, {recognized_license_plate}*"
+                )
             )
 
-        identifier_clause = reduce(operator.or_, identifier_clauses)
+        recognized_license_plate_clause = reduce(
-        event_filters.append((identifier_clause))
+            operator.or_, recognized_license_plate_clauses
+        )
+        event_filters.append((recognized_license_plate_clause))
 
     if after:
         event_filters.append((Event.start_time > after))
@@ -683,8 +709,8 @@ def events_search(request: Request, params: EventsSearchQueryParams = Depends())
                 "average_estimated_speed",
                 "velocity_angle",
                 "path_data",
-                "identifier",
+                "recognized_license_plate",
-                "identifier_score",
+                "recognized_license_plate_score",
             ]
         }
 

frigate/camera/state.py

@@ -141,8 +141,11 @@ class CameraState:
                     if (
                         obj.get("sub_label") and is_label_printable(obj["sub_label"][0])
                     )
-                    else obj.get("identifier", [None])[0]
+                    else obj.get("recognized_license_plate", [None])[0]
-                    if (obj.get("identifier") and obj["identifier"][0])
+                    if (
+                        obj.get("recognized_license_plate")
+                        and obj["recognized_license_plate"][0]
+                    )
                     else obj["label"]
                 )
                 draw_box_with_label(

frigate/comms/event_metadata_updater.py

@@ -14,7 +14,7 @@ class EventMetadataTypeEnum(str, Enum):
     manual_event_end = "manual_event_end"
     regenerate_description = "regenerate_description"
     sub_label = "sub_label"
-    identifier = "identifier"
+    recognized_license_plate = "recognized_license_plate"
 
 
 class EventMetadataPublisher(Publisher):

frigate/data_processing/common/license_plate/mixin.py

@@ -1064,7 +1064,8 @@ class LicensePlateProcessingMixin:
             )
 
         self.sub_label_publisher.publish(
-            EventMetadataTypeEnum.identifier, (id, top_plate, avg_confidence)
+            EventMetadataTypeEnum.recognized_license_plate,
+            (id, top_plate, avg_confidence),
         )
 
         self.detected_license_plates[id] = {

frigate/events/maintainer.py

@@ -27,7 +27,8 @@ def should_update_db(prev_event: Event, current_event: Event) -> bool:
             or prev_event["average_estimated_speed"]
             != current_event["average_estimated_speed"]
             or prev_event["velocity_angle"] != current_event["velocity_angle"]
-            or prev_event["identifier"] != current_event["identifier"]
+            or prev_event["recognized_license_plate"]
+            != current_event["recognized_license_plate"]
             or prev_event["path_data"] != current_event["path_data"]
         ):
             return True
@@ -227,10 +228,14 @@ class EventProcessor(threading.Thread):
                 event[Event.sub_label] = event_data["sub_label"][0]
                 event[Event.data]["sub_label_score"] = event_data["sub_label"][1]
 
-            # only overwrite the identifier in the database if it's set
+            # only overwrite the recognized_license_plate in the database if it's set
-            if event_data.get("identifier") is not None:
+            if event_data.get("recognized_license_plate") is not None:
-                event[Event.data]["identifier"] = event_data["identifier"][0]
+                event[Event.data]["recognized_license_plate"] = event_data[
-                event[Event.data]["identifier_score"] = event_data["identifier"][1]
+                    "recognized_license_plate"
+                ][0]
+                event[Event.data]["recognized_license_plate_score"] = event_data[
+                    "recognized_license_plate"
+                ][1]
 
             (
                 Event.insert(event)

frigate/track/object_processing.py

@@ -346,10 +346,10 @@ class TrackedObjectProcessor(threading.Thread):
 
         return True
 
-    def set_identifier(
+    def set_recognized_license_plate(
-        self, event_id: str, identifier: str | None, score: float | None
+        self, event_id: str, recognized_license_plate: str | None, score: float | None
     ) -> None:
-        """Update identifier for given event id."""
+        """Update recognized license plate for given event id."""
         tracked_obj: TrackedObject = None
 
         for state in self.camera_states.values():
@@ -367,15 +367,18 @@ class TrackedObjectProcessor(threading.Thread):
             return
 
         if tracked_obj:
-            tracked_obj.obj_data["identifier"] = (identifier, score)
+            tracked_obj.obj_data["recognized_license_plate"] = (
+                recognized_license_plate,
+                score,
+            )
 
         if event:
             data = event.data
-            data["identifier"] = identifier
+            data["recognized_license_plate"] = recognized_license_plate
-            if identifier is None:
+            if recognized_license_plate is None:
-                data["identifier_score"] = None
+                data["recognized_license_plate_score"] = None
             elif score is not None:
-                data["identifier_score"] = score
+                data["recognized_license_plate_score"] = score
             event.data = data
             event.save()
 
@@ -542,9 +545,11 @@ class TrackedObjectProcessor(threading.Thread):
                 if topic.endswith(EventMetadataTypeEnum.sub_label.value):
                     (event_id, sub_label, score) = payload
                     self.set_sub_label(event_id, sub_label, score)
-                if topic.endswith(EventMetadataTypeEnum.identifier.value):
+                if topic.endswith(EventMetadataTypeEnum.recognized_license_plate.value):
-                    (event_id, identifier, score) = payload
+                    (event_id, recognized_license_plate, score) = payload
-                    self.set_identifier(event_id, identifier, score)
+                    self.set_recognized_license_plate(
+                        event_id, recognized_license_plate, score
+                    )
                 elif topic.endswith(EventMetadataTypeEnum.manual_event_create.value):
                     self.create_manual_event(payload)
                 elif topic.endswith(EventMetadataTypeEnum.manual_event_end.value):

frigate/track/tracked_object.py

@@ -153,8 +153,12 @@ class TrackedObject:
                     "current_estimated_speed": self.current_estimated_speed,
                     "velocity_angle": self.velocity_angle,
                     "path_data": self.path_data,
-                    "identifier": obj_data.get("identifier"),
+                    "recognized_license_plate": obj_data.get(
-                    "identifier_score": obj_data.get("identifier_score"),
+                        "recognized_license_plate"
+                    ),
+                    "recognized_license_plate_score": obj_data.get(
+                        "recognized_license_plate_score"
+                    ),
                 }
                 thumb_update = True
 
@@ -367,7 +371,7 @@ class TrackedObject:
             "average_estimated_speed": self.average_estimated_speed,
             "velocity_angle": self.velocity_angle,
             "path_data": self.path_data,
-            "identifier": self.obj_data.get("identifier"),
+            "recognized_license_plate": self.obj_data.get("recognized_license_plate"),
         }
 
         return event