uiprotect 7.5.2__py3-none-any.whl → 7.32.0__py3-none-any.whl

uiprotect/data/devices.py

@@ -8,11 +8,12 @@ import warnings
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from functools import cache, lru_cache
-from ipaddress import IPv4Address
+from ipaddress import IPv4Address, IPv6Address
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, cast
 
 from convertertools import pop_dict_set_if_none, pop_dict_tuple
+from pydantic import model_validator
 from pydantic.fields import PrivateAttr
 
 from ..exceptions import BadRequest, NotAuthorized, StreamError
@@ -23,6 +24,7 @@ from ..utils import (
     convert_smart_types,
     convert_to_datetime,
     convert_video_modes,
+    format_host_for_url,
     from_js_time,
     serialize_point,
     timedelta_total_seconds,
@@ -80,6 +82,7 @@ from .types import (
 from .user import User
 
 if TYPE_CHECKING:
+    from ..api import RTSPSStreams
     from .nvr import Event, Liveview
 
 PRIVACY_ZONE_NAME = "pyufp_privacy_zone"
@@ -93,9 +96,10 @@ class LightDeviceSettings(ProtectBaseObject):
     is_indicator_enabled: bool
     # Brightness
     led_level: LEDLevel
-    lux_sensitivity: LowMedHigh
     pir_duration: timedelta
     pir_sensitivity: PercentInt
+    # lux_sensitivity exists in Private API but not in Public API - filtered when sending updates
+    lux_sensitivity: LowMedHigh | None = None
 
     @classmethod
     @cache
@@ -160,6 +164,14 @@ class Light(ProtectMotionDeviceModel):
                 self.camera_id = camera.id
             await self.save_device(data_before_changes, force_emit=True)
 
+    async def set_flood_light(self, enabled: bool) -> None:
+        """Sets the flood light (force on) for the light"""
+
+        def callback() -> None:
+            self.light_on_settings.is_led_force_on = enabled
+
+        await self.queue_update(callback)
+
     async def set_status_light(self, enabled: bool) -> None:
         """Sets the status indicator light for the light"""
 
@@ -260,10 +272,17 @@ class CameraChannel(ProtectBaseObject):
     auto_bitrate: bool | None = None
     auto_fps: bool | None = None
 
+    _parent: Camera | None = PrivateAttr(None)
     _rtsp_url: str | None = PrivateAttr(None)
     _rtsps_url: str | None = PrivateAttr(None)
     _rtsps_no_srtp_url: str | None = PrivateAttr(None)
 
+    def _get_connection_host(self) -> IPv4Address | IPv6Address | str:
+        """Get connection host (camera's for stacked NVR, otherwise NVR's)."""
+        if self._parent is not None and self._parent.connection_host is not None:
+            return self._parent.connection_host
+        return self._api.connection_host
+
     @property
     def rtsp_url(self) -> str | None:
         if not self.is_rtsp_enabled or self.rtsp_alias is None:
@@ -271,7 +290,11 @@ class CameraChannel(ProtectBaseObject):
 
         if self._rtsp_url is not None:
             return self._rtsp_url
-        self._rtsp_url = f"rtsp://{self._api.connection_host}:{self._api.bootstrap.nvr.ports.rtsp}/{self.rtsp_alias}"
+
+        host = format_host_for_url(self._get_connection_host())
+        self._rtsp_url = (
+            f"rtsp://{host}:{self._api.bootstrap.nvr.ports.rtsp}/{self.rtsp_alias}"
+        )
         return self._rtsp_url
 
     @property
@@ -281,7 +304,9 @@ class CameraChannel(ProtectBaseObject):
 
         if self._rtsps_url is not None:
             return self._rtsps_url
-        self._rtsps_url = f"rtsps://{self._api.connection_host}:{self._api.bootstrap.nvr.ports.rtsps}/{self.rtsp_alias}?enableSrtp"
+
+        host = format_host_for_url(self._get_connection_host())
+        self._rtsps_url = f"rtsps://{host}:{self._api.bootstrap.nvr.ports.rtsps}/{self.rtsp_alias}?enableSrtp"
         return self._rtsps_url
 
     @property
@@ -291,7 +316,11 @@ class CameraChannel(ProtectBaseObject):
 
         if self._rtsps_no_srtp_url is not None:
             return self._rtsps_no_srtp_url
-        self._rtsps_no_srtp_url = f"rtsps://{self._api.connection_host}:{self._api.bootstrap.nvr.ports.rtsps}/{self.rtsp_alias}"
+
+        host = format_host_for_url(self._get_connection_host())
+        self._rtsps_no_srtp_url = (
+            f"rtsps://{host}:{self._api.bootstrap.nvr.ports.rtsps}/{self.rtsp_alias}"
+        )
         return self._rtsps_no_srtp_url
 
     @property
@@ -358,7 +387,21 @@ class OSDSettings(ProtectBaseObject):
 class LEDSettings(ProtectBaseObject):
     # Status Light
     is_enabled: bool
-    blink_rate: int  # in milliseconds betweeen blinks, 0 = solid
+    blink_rate: int | None = (
+        None  # in milliseconds between blinks, 0 = solid (removed in Protect 6.x)
+    )
+    # 6.2+
+    welcome_led: bool | None = None
+    flood_led: bool | None = None
+
+    def unifi_dict(
+        self,
+        data: dict[str, Any] | None = None,
+        exclude: set[str] | None = None,
+    ) -> dict[str, Any]:
+        data = super().unifi_dict(data=data, exclude=exclude)
+        pop_dict_set_if_none(data, {"blinkRate", "welcomeLed", "floodLed"})
+        return data
 
 
 class SpeakerSettings(ProtectBaseObject):
@@ -366,6 +409,23 @@ class SpeakerSettings(ProtectBaseObject):
     # Status Sounds
     are_system_sounds_enabled: bool
     volume: PercentInt
+    # Doorbell ring volume (for doorbells)
+    ring_volume: PercentInt | None = None
+    ringtone_id: str | None = None
+    repeat_times: int | None = None
+    # Actual speaker output volume (for cameras with speakers)
+    speaker_volume: PercentInt | None = None
+
+    def unifi_dict(
+        self,
+        data: dict[str, Any] | None = None,
+        exclude: set[str] | None = None,
+    ) -> dict[str, Any]:
+        data = super().unifi_dict(data=data, exclude=exclude)
+        pop_dict_set_if_none(
+            data, {"ringVolume", "ringtoneId", "repeatTimes", "speakerVolume"}
+        )
+        return data
 
 
 class RecordingSettings(ProtectBaseObject):
@@ -685,6 +745,10 @@ class CameraZone(ProtectBaseObject):
         if "points" in data:
             data["points"] = [serialize_point(p) for p in data["points"]]
 
+        if "color" in data and isinstance(data["color"], dict):
+            # Serialize Color object to hex string to avoid Pydantic serialization warnings
+            data["color"] = self.color.as_hex().upper()
+
         return data
 
     @staticmethod
@@ -856,6 +920,8 @@ class CameraFeatureFlags(ProtectBaseObject):
     # 4.73.71+
     support_nfc: bool | None = None
     has_fingerprint_sensor: bool | None = None
+    # 6.0.0+
+    support_full_hd_snapshot: bool | None = None
 
     focus: PTZRange
     pan: PTZRange
@@ -926,7 +992,7 @@ class Camera(ProtectMotionDeviceModel):
     is_recording: bool
     is_motion_detected: bool
     is_smart_detected: bool
-    phy_rate: int | None = None
+    phy_rate: float | None = None
     hdr_mode: bool
     # Recording Quality -> High Frame
     video_mode: VideoMode
@@ -1065,6 +1131,13 @@ class Camera(ProtectMotionDeviceModel):
             "chimeDuration": lambda x: timedelta(milliseconds=x),
         } | super().unifi_dict_conversions()
 
+    @model_validator(mode="after")
+    def _set_channel_parents(self) -> Camera:
+        """Set parent camera reference in channels after initialization."""
+        for channel in self.channels:
+            channel._parent = self
+        return self
+
     @classmethod
     def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
         # LCD messages comes back as empty dict {}
@@ -1140,12 +1213,13 @@ class Camera(ProtectMotionDeviceModel):
 
     def update_from_dict(self, data: dict[str, Any]) -> Camera:
         # a message in the past is actually a signal to wipe the message
-        if (reset_at := data.get("lcd_message", {}).get("reset_at")) is not None:
-            if utc_now() > from_js_time(reset_at):
-                # Important: Make a copy of the data before modifying it
-                # since unifi_dict_to_dict will otherwise report incorrect changes
-                data = data.copy()
-                data["lcd_message"] = None
+        if (
+            reset_at := data.get("lcd_message", {}).get("reset_at")
+        ) is not None and utc_now() > from_js_time(reset_at):
+            # Important: Make a copy of the data before modifying it
+            # since unifi_dict_to_dict will otherwise report incorrect changes
+            data = data.copy()
+            data["lcd_message"] = None
 
         return super().update_from_dict(data)
 
@@ -1442,6 +1516,40 @@ class Camera(ProtectMotionDeviceModel):
         """Toggles vehicle smart detection. Requires camera to have smart detection"""
         return await self._set_object_detect(SmartDetectObjectType.VEHICLE, enabled)
 
+    # endregion
+    # region Face
+
+    @property
+    def can_detect_face(self) -> bool:
+        return SmartDetectObjectType.FACE in self.feature_flags.smart_detect_types
+
+    @property
+    def is_face_detection_on(self) -> bool:
+        """Is Face Detection available and enabled?"""
+        return self._is_smart_enabled(SmartDetectObjectType.FACE)
+
+    @property
+    def last_face_detect_event(self) -> Event | None:
+        """Get the last face smart detection event."""
+        return self.get_last_smart_detect_event(SmartDetectObjectType.FACE)
+
+    @property
+    def last_face_detect(self) -> datetime | None:
+        """Get the last face smart detection event."""
+        return self.last_smart_detects.get(SmartDetectObjectType.FACE)
+
+    @property
+    def is_face_currently_detected(self) -> bool:
+        """Is face currently being detected"""
+        return self._is_smart_detected(SmartDetectObjectType.FACE)
+
+    async def set_face_detection(self, enabled: bool) -> None:
+        """Toggles face smart detection. Requires camera to have smart detection"""
+        return await self._set_object_detect(
+            SmartDetectObjectType.FACE,
+            enabled,
+        )
+
     # endregion
     # region License Plate
 
@@ -2043,6 +2151,43 @@ class Camera(ProtectMotionDeviceModel):
 
         return await self._api.get_camera_snapshot(self.id, width, height, dt=dt)
 
+    async def get_public_api_snapshot(
+        self, high_quality: bool | None = None
+    ) -> bytes | None:
+        """Gets snapshot for camera using public API."""
+        if self._api._api_key is None:
+            raise NotAuthorized("Cannot get public API snapshot without an API key.")
+
+        if high_quality is None:
+            high_quality = self.feature_flags.support_full_hd_snapshot or False
+
+        return await self._api.get_public_api_camera_snapshot(
+            camera_id=self.id, high_quality=high_quality
+        )
+
+    async def create_rtsps_streams(
+        self, qualities: list[str] | str
+    ) -> RTSPSStreams | None:
+        """Creates RTSPS streams for camera using public API."""
+        if self._api._api_key is None:
+            raise NotAuthorized("Cannot create RTSPS streams without an API key.")
+
+        return await self._api.create_camera_rtsps_streams(self.id, qualities)
+
+    async def get_rtsps_streams(self) -> RTSPSStreams | None:
+        """Gets existing RTSPS streams for camera using public API."""
+        if self._api._api_key is None:
+            raise NotAuthorized("Cannot get RTSPS streams without an API key.")
+
+        return await self._api.get_camera_rtsps_streams(self.id)
+
+    async def delete_rtsps_streams(self, qualities: list[str] | str) -> bool:
+        """Deletes RTSPS streams for camera using public API."""
+        if self._api._api_key is None:
+            raise NotAuthorized("Cannot delete RTSPS streams without an API key.")
+
+        return await self._api.delete_camera_rtsps_streams(self.id, qualities)
+
     async def get_package_snapshot(
         self,
         width: int | None = None,
@@ -2175,7 +2320,9 @@ class Camera(ProtectMotionDeviceModel):
 
         def callback() -> None:
             self.led_settings.is_enabled = enabled
-            self.led_settings.blink_rate = 0
+            # blink_rate was removed in Protect 6.x
+            if self.led_settings.blink_rate is not None:
+                self.led_settings.blink_rate = 0
 
         await self.queue_update(callback)
 
@@ -2265,7 +2412,17 @@ class Camera(ProtectMotionDeviceModel):
         await self.queue_update(callback)
 
     async def set_speaker_volume(self, level: int) -> None:
-        """Sets the speaker sensitivity level on camera. Requires camera to have speakers"""
+        """Sets the speaker output volume on camera. Requires camera to have speakers"""
+        if not self.feature_flags.has_speaker:
+            raise BadRequest("Camera does not have speaker")
+
+        def callback() -> None:
+            self.speaker_settings.speaker_volume = PercentInt(level)
+
+        await self.queue_update(callback)
+
+    async def set_volume(self, level: int) -> None:
+        """Sets the general volume level on camera. Requires camera to have speakers"""
         if not self.feature_flags.has_speaker:
             raise BadRequest("Camera does not have speaker")
 
@@ -2274,6 +2431,16 @@ class Camera(ProtectMotionDeviceModel):
 
         await self.queue_update(callback)
 
+    async def set_ring_volume(self, level: int) -> None:
+        """Sets the doorbell ring volume. Requires camera to be a doorbell"""
+        if not self.feature_flags.is_doorbell:
+            raise BadRequest("Camera is not a doorbell")
+
+        def callback() -> None:
+            self.speaker_settings.ring_volume = PercentInt(level)
+
+        await self.queue_update(callback)
+
     async def set_chime_type(self, chime_type: ChimeType) -> None:
         """Sets chime type for doorbell. Requires camera to be a doorbell"""
         await self.set_chime_duration(timedelta(milliseconds=chime_type.value))
@@ -2813,7 +2980,7 @@ class Sensor(ProtectAdoptableDeviceModel):
     is_motion_detected: bool
     is_opened: bool
     leak_detected_at: datetime | None = None
-    led_settings: SensorSettingsBase
+    led_settings: LEDSettings
     light_settings: SensorThresholdSettings
     motion_detected_at: datetime | None = None
     motion_settings: SensorSensitivitySettings

uiprotect/data/nvr.py

@@ -15,12 +15,12 @@ from uuid import UUID
 
 import aiofiles
 import orjson
-from aiofiles import os as aos
 from convertertools import pop_dict_set_if_none, pop_dict_tuple
+from pydantic import ConfigDict
 from pydantic.fields import PrivateAttr
 
 from ..exceptions import BadRequest, NotAuthorized
-from ..utils import RELEASE_CACHE, convert_to_datetime
+from ..utils import convert_to_datetime
 from .base import (
     ProtectBaseObject,
     ProtectDeviceModel,
@@ -46,7 +46,6 @@ from .types import (
     ModelType,
     MountType,
     PercentFloat,
-    PercentInt,
     PermissionNode,
     ProgressCallback,
     RecordingMode,
@@ -71,27 +70,46 @@ DELETE_KEYS_THUMB = {"color", "vehicleType"}
 DELETE_KEYS_EVENT = {"deletedAt", "category", "subCategory"}
 
 
+class MetaInfo(ProtectBaseObject):
+    applicationVersion: str
+
+
 class NVRLocation(UserLocation):
     is_geofencing_enabled: bool
     radius: int
     model: ModelType | None = None
 
 
+class SmartDetectItemAttribute(ProtectBaseObject):
+    """Attribute value with confidence for smart detect items (e.g., color, vehicle type)."""
+
+    val: str
+    confidence: int
+
+
 class SmartDetectItem(ProtectBaseObject):
     id: str
     timestamp: datetime
-    level: PercentInt
     coord: tuple[int, int, int, int]
     object_type: SmartDetectObjectType
     zone_ids: list[int]
     duration: timedelta
+    confidence: int
+    first_shown_time_ms: int
+    idle_since_time_ms: int
+    stationary: bool
+    license_plate: str | None = None  # only populated for vehicle object_type
+    depth: float | None = None
+    speed: float | None = None
+    attributes: dict[str, SmartDetectItemAttribute] | None = None
+    lines: list[int] | None = None
 
     @classmethod
     @cache
     def _get_unifi_remaps(cls) -> dict[str, str]:
         return {
             **super()._get_unifi_remaps(),
-            "zones": "zoneIds",
+            "zones": "zone_ids",
         }
 
     @classmethod
@@ -126,9 +144,22 @@ class SmartDetectTrack(ProtectBaseObject):
         return self._api.bootstrap.events.get(self.event_id)
 
 
-class LicensePlateMetadata(ProtectBaseObject):
-    name: str
-    confidence_level: int
+class EventThumbnailGroup(ProtectBaseObject):
+    """Group information for detected thumbnails (e.g., license plate recognition)."""
+
+    id: str
+    name: str | None = None
+    matched_name: str | None = None
+    confidence: int
+
+    def unifi_dict(
+        self,
+        data: dict[str, Any] | None = None,
+        exclude: set[str] | None = None,
+    ) -> dict[str, Any]:
+        data = super().unifi_dict(data=data, exclude=exclude)
+        pop_dict_set_if_none(data, {"matchedName", "name"})
+        return data
 
 
 class EventThumbnailAttribute(ProtectBaseObject):
@@ -163,8 +194,48 @@ class FingerprintMetadata(ProtectBaseObject):
 
 
 class EventThumbnailAttributes(ProtectBaseObject):
-    color: EventThumbnailAttribute | None = None
-    vehicle_type: EventThumbnailAttribute | None = None
+    """
+    Dynamic attributes for detected thumbnails.
+
+    All attributes are stored as extra fields for full flexibility.
+
+    Common attribute types:
+    - color, vehicleType, faceMask: EventThumbnailAttribute (with val and confidence)
+    - zone: list[int] - Zone IDs where detection occurred
+    - trackerId: int - Unique tracker ID for this detection
+
+    Allows any attributes for forward compatibility with new UFP features.
+
+    Example usage:
+        >>> attrs = thumbnail.attributes
+        >>> if attrs:
+        ...     # Access EventThumbnailAttribute objects
+        ...     color = attrs.color  # EventThumbnailAttribute
+        ...     if color:
+        ...         print(f"Color: {color.val} (confidence: {color.confidence})")
+        ...     # Access primitive types
+        ...     zones = attrs.zone  # list[int] | None
+        ...     tracker = attrs.trackerId  # int | None
+    """
+
+    model_config = ConfigDict(extra="allow")
+
+    def get_value(self, key: str) -> str | None:
+        """Get the string value from an EventThumbnailAttribute field, if it exists."""
+        attr = getattr(self, key, None)
+        if isinstance(attr, EventThumbnailAttribute):
+            return attr.val
+        return None
+
+    @classmethod
+    def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
+        # Convert nested attribute objects to EventThumbnailAttribute instances
+        return {
+            key: EventThumbnailAttribute.from_unifi_dict(**value)
+            if isinstance(value, dict) and "val" in value and "confidence" in value
+            else value
+            for key, value in data.items()
+        }
 
     def unifi_dict(
         self,
@@ -172,8 +243,9 @@ class EventThumbnailAttributes(ProtectBaseObject):
         exclude: set[str] | None = None,
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
-        pop_dict_set_if_none(data, DELETE_KEYS_THUMB)
-        return data
+
+        # Remove None values from extra fields
+        return {k: v for k, v in data.items() if v is not None}
 
 
 class EventDetectedThumbnail(ProtectBaseObject):
@@ -182,6 +254,11 @@ class EventDetectedThumbnail(ProtectBaseObject):
     cropped_id: str
     attributes: EventThumbnailAttributes | None = None
     name: str | None = None
+    coord: list[int] | None = None
+    confidence: int | None = None
+    # requires 6.0.0+
+    group: EventThumbnailGroup | None = None
+    object_id: str | None = None
 
     @classmethod
     @cache
@@ -194,7 +271,7 @@ class EventDetectedThumbnail(ProtectBaseObject):
         exclude: set[str] | None = None,
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
-        pop_dict_set_if_none(data, {"name"})
+        pop_dict_set_if_none(data, {"name", "group", "objectId", "coord", "confidence"})
         return data
 
 
@@ -217,8 +294,6 @@ class EventMetadata(ProtectBaseObject):
     alarm_type: str | None = None
     device_id: str | None = None
     mac: str | None = None
-    # require 2.7.5+
-    license_plate: LicensePlateMetadata | None = None
     # requires 2.11.13+
     detected_thumbnails: list[EventDetectedThumbnail] | None = None
     # requires 5.1.34+
@@ -297,6 +372,9 @@ class Event(ProtectModelWithId):
     # only appears if `get_events` is called with category
     category: EventCategories | None = None
     sub_category: str | None = None
+    # requires 6.0.0+
+    is_favorite: bool | None = None
+    favorite_object_ids: list[str] | None = None
 
     # TODO:
     # partition
@@ -377,6 +455,45 @@ class Event(ProtectModelWithId):
         ]
         return self._smart_detect_events
 
+    def get_detected_thumbnail(self) -> EventDetectedThumbnail | None:
+        """
+        Gets best detected thumbnail for event (UFP 6.x+).
+
+        Returns the thumbnail marked with clockBestWall, which indicates
+        the optimal frame for this detection (highest confidence, best angle, etc.).
+
+        Returns:
+            EventDetectedThumbnail with the best detection frame, or None if:
+            - Event has no metadata
+            - No detected thumbnails available
+            - No thumbnail has clockBestWall set
+
+        Example usage:
+            >>> # License Plate Recognition
+            >>> thumbnail = event.get_detected_thumbnail()
+            >>> if thumbnail and thumbnail.group:
+            ...     plate = thumbnail.group.matched_name  # "ABC123"
+            ...     confidence = thumbnail.group.confidence  # 95
+            ...     if thumbnail.attributes:
+            ...         color = thumbnail.attributes.get_value("color")  # "white"
+            ...         vehicle = thumbnail.attributes.get_value("vehicleType")  # "sedan"
+
+            >>> # Face Detection
+            >>> thumbnail = event.get_detected_thumbnail()
+            >>> if thumbnail and thumbnail.group:
+            ...     face_name = thumbnail.group.matched_name  # "John Doe"
+            ...     confidence = thumbnail.group.confidence  # 87
+
+        """
+        if not self.metadata or not self.metadata.detected_thumbnails:
+            return None
+
+        for thumbnail in self.metadata.detected_thumbnails:
+            if thumbnail.clock_best_wall:
+                return thumbnail
+
+        return None
+
     async def get_thumbnail(
         self,
         width: int | None = None,
@@ -1213,29 +1330,8 @@ class NVR(ProtectDeviceModel):
         return versions
 
     async def get_is_prerelease(self) -> bool:
-        """Get if current version of Protect is a prerelease version."""
-        # only EA versions have `-beta` in versions
-        if self.version.is_prerelease:
-            return True
-
-        # 2.6.14 is an EA version that looks like a release version
-        cache_file_path = self._api.cache_dir / "release_cache.json"
-        versions = await self._read_cache_file(
-            cache_file_path,
-        ) or await self._read_cache_file(RELEASE_CACHE)
-        if versions is None or self.version not in versions:
-            versions = await self._api.get_release_versions()
-            try:
-                _LOGGER.debug("Fetching releases from APT repos...")
-                tmp = self._api.cache_dir / "release_cache.tmp.json"
-                await aos.makedirs(self._api.cache_dir, exist_ok=True)
-                async with aiofiles.open(tmp, "wb") as cache_file:
-                    await cache_file.write(orjson.dumps([str(v) for v in versions]))
-                await aos.rename(tmp, cache_file_path)
-            except Exception:
-                _LOGGER.warning("Failed write cache file.")
-
-        return self.version not in versions
+        """[DEPRECATED] Always returns False. Will be removed after HA 2025.8.0."""
+        return False
 
     async def set_smart_detections(self, value: bool) -> None:
         """Set if smart detections are enabled."""
@@ -1361,6 +1457,11 @@ class NVR(ProtectDeviceModel):
         """
         return self._is_smart_enabled(SmartDetectObjectType.VEHICLE)
 
+    @property
+    def is_global_face_detection_on(self) -> bool:
+        """Is Face Detection available and enabled?"""
+        return self._is_smart_enabled(SmartDetectObjectType.FACE)
+
     @property
     def is_global_license_plate_detection_on(self) -> bool:
         """