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

uiprotect/data/devices.py

@@ -7,12 +7,14 @@ import logging
 import warnings
 from collections.abc import Callable
 from datetime import datetime, timedelta
-from functools import cache
-from ipaddress import IPv4Address
+from functools import cache, lru_cache
+from ipaddress import IPv4Address, IPv6Address
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, cast
 
-from pydantic.v1.fields import PrivateAttr
+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
 from ..stream import TalkbackStream
@@ -22,8 +24,10 @@ from ..utils import (
     convert_smart_types,
     convert_to_datetime,
     convert_video_modes,
+    format_host_for_url,
     from_js_time,
     serialize_point,
+    timedelta_total_seconds,
     to_js_time,
     utc_now,
 )
@@ -78,21 +82,11 @@ 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"
-LUX_MAPPING_VALUES = [
-    30,
-    25,
-    20,
-    15,
-    12,
-    10,
-    7,
-    5,
-    3,
-    1,
-]
+LUX_MAPPING_VALUES = [30, 25, 20, 15, 12, 10, 7, 5, 3, 1, 0]
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -102,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
@@ -132,7 +127,7 @@ class Light(ProtectMotionDeviceModel):
     light_device_settings: LightDeviceSettings
     light_on_settings: LightOnSettings
     light_mode_settings: LightModeSettings
-    camera_id: str | None
+    camera_id: str | None = None
     is_camera_paired: bool
 
     @classmethod
@@ -169,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"""
 
@@ -254,23 +257,31 @@ class CameraChannel(ProtectBaseObject):
     name: str  # read only
     enabled: bool  # read only
     is_rtsp_enabled: bool
-    rtsp_alias: str | None  # read only
+    rtsp_alias: str | None = None  # read only
     width: int
     height: int
-    fps: int
+    fps: int | None = None  # read only
     bitrate: int
-    min_bitrate: int  # read only
-    max_bitrate: int  # read only
-    min_client_adaptive_bit_rate: int | None  # read only
-    min_motion_adaptive_bit_rate: int | None  # read only
+    min_bitrate: int | None = None  # read only
+    max_bitrate: int | None = None  # read only
+    min_client_adaptive_bit_rate: int | None = None  # read only
+    min_motion_adaptive_bit_rate: int | None = None  # read only
     fps_values: list[int]  # read only
     idr_interval: int
     # 3.0.22+
     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:
@@ -279,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
@@ -289,12 +304,28 @@ 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
+    def rtsps_no_srtp_url(self) -> str | None:
+        if not self.is_rtsp_enabled or self.rtsp_alias is None:
+            return None
+
+        if self._rtsps_no_srtp_url is not None:
+            return self._rtsps_no_srtp_url
+
+        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
     def is_package(self) -> bool:
-        return self.fps <= 2
+        return self.fps is not None and self.fps <= 2
 
 
 class ISPSettings(ProtectBaseObject):
@@ -323,8 +354,8 @@ class ISPSettings(ProtectBaseObject):
     d_zoom_stream_id: int
     focus_mode: FocusMode | None = None
     focus_position: int
-    touch_focus_x: int | None
-    touch_focus_y: int | None
+    touch_focus_x: int | None = None
+    touch_focus_y: int | None = None
     zoom_position: PercentInt
     mount_position: MountPosition | None = None
     # requires 2.8.14+
@@ -341,10 +372,7 @@ class ISPSettings(ProtectBaseObject):
         exclude: set[str] | None = None,
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
-
-        if "focusMode" in data and data["focusMode"] is None:
-            del data["focusMode"]
-
+        pop_dict_set_if_none(data, {"focusMode"})
         return data
 
 
@@ -359,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):
@@ -367,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):
@@ -391,6 +450,8 @@ class RecordingSettings(ProtectBaseObject):
     retention_duration: datetime | None = None
     smart_detect_post_padding: timedelta | None = None
     smart_detect_pre_padding: timedelta | None = None
+    # requires 5.2.39+
+    create_access_event: bool | None = None
 
     @classmethod
     @cache
@@ -473,6 +534,20 @@ class SmartDetectSettings(ProtectBaseObject):
             "autoTrackingObjectTypes": convert_smart_types,
         } | super().unifi_dict_conversions()
 
+    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)
+        if audio_types := data.get("audioTypes"):
+            # SMOKE_CMONX is not supported for audio types
+            # and should not be sent to the camera
+            data["audioTypes"] = [
+                t for t in audio_types if t != SmartDetectAudioType.SMOKE_CMONX.value
+            ]
+        return data
+
 
 class LCDMessage(ProtectBaseObject):
     type: DoorbellMessageType
@@ -530,10 +605,10 @@ class LCDMessage(ProtectBaseObject):
 class TalkbackSettings(ProtectBaseObject):
     type_fmt: AudioCodecs
     type_in: str
-    bind_addr: IPv4Address
+    bind_addr: IPv4Address | None = None
     bind_port: int
-    filter_addr: str | None  # can be used to restrict sender address
-    filter_port: int | None  # can be used to restrict sender port
+    filter_addr: str | None = None  # can be used to restrict sender address
+    filter_port: int | None = None  # can be used to restrict sender port
     channels: int  # 1 or 2
     sampling_rate: int  # 8000, 11025, 22050, 44100, 48000
     bits_per_sample: int
@@ -541,22 +616,22 @@ class TalkbackSettings(ProtectBaseObject):
 
 
 class WifiStats(ProtectBaseObject):
-    channel: int | None
-    frequency: int | None
-    link_speed_mbps: str | None
+    channel: int | None = None
+    frequency: int | None = None
+    link_speed_mbps: str | None = None
     signal_quality: PercentInt
     signal_strength: int
 
 
 class VideoStats(ProtectBaseObject):
-    recording_start: datetime | None
-    recording_end: datetime | None
-    recording_start_lq: datetime | None
-    recording_end_lq: datetime | None
-    timelapse_start: datetime | None
-    timelapse_end: datetime | None
-    timelapse_start_lq: datetime | None
-    timelapse_end_lq: datetime | None
+    recording_start: datetime | None = None
+    recording_end: datetime | None = None
+    recording_start_lq: datetime | None = None
+    recording_end_lq: datetime | None = None
+    timelapse_start: datetime | None = None
+    timelapse_end: datetime | None = None
+    timelapse_start_lq: datetime | None = None
+    timelapse_end_lq: datetime | None = None
 
     @classmethod
     @cache
@@ -572,24 +647,27 @@ class VideoStats(ProtectBaseObject):
     @classmethod
     @cache
     def unifi_dict_conversions(cls) -> dict[str, object | Callable[[Any], Any]]:
-        return {
-            key: convert_to_datetime
-            for key in (
-                "recordingStart",
-                "recordingEnd",
-                "recordingStartLQ",
-                "recordingEndLQ",
-                "timelapseStart",
-                "timelapseEnd",
-                "timelapseStartLQ",
-                "timelapseEndLQ",
+        return (
+            dict.fromkeys(
+                (
+                    "recordingStart",
+                    "recordingEnd",
+                    "recordingStartLQ",
+                    "recordingEndLQ",
+                    "timelapseStart",
+                    "timelapseEnd",
+                    "timelapseStartLQ",
+                    "timelapseEndLQ",
+                ),
+                convert_to_datetime,
             )
-        } | super().unifi_dict_conversions()
+            | super().unifi_dict_conversions()
+        )
 
 
 class StorageStats(ProtectBaseObject):
-    used: int | None  # bytes
-    rate: float | None  # bytes / millisecond
+    used: int | None = None  # bytes
+    rate: float | None = None  # bytes / millisecond
 
     @property
     def rate_per_second(self) -> float | None:
@@ -611,10 +689,7 @@ class StorageStats(ProtectBaseObject):
         exclude: set[str] | None = None,
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
-
-        if "rate" in data and data["rate"] is None:
-            del data["rate"]
-
+        pop_dict_set_if_none(data, {"rate"})
         return data
 
 
@@ -623,7 +698,7 @@ class CameraStats(ProtectBaseObject):
     tx_bytes: int
     wifi: WifiStats
     video: VideoStats
-    storage: StorageStats | None
+    storage: StorageStats | None = None
     wifi_quality: PercentInt
     wifi_strength: int
 
@@ -670,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
@@ -698,7 +777,7 @@ class SmartMotionZone(MotionZone):
 
 
 class PrivacyMaskCapability(ProtectBaseObject):
-    max_masks: int | None
+    max_masks: int | None = None
     rectangle_only: bool
 
 
@@ -725,9 +804,9 @@ class Hotplug(ProtectBaseObject):
 
 
 class PTZRangeSingle(ProtectBaseObject):
-    max: float | None
-    min: float | None
-    step: float | None
+    max: float | None = None
+    min: float | None = None
+    step: float | None = None
 
 
 class PTZRange(ProtectBaseObject):
@@ -761,7 +840,7 @@ class PTZRange(ProtectBaseObject):
 
 
 class PTZZoomRange(PTZRange):
-    ratio: float
+    ratio: int
 
     def to_native_value(self, zoom_value: float, is_relative: bool = False) -> float:
         """Convert zoom values to step values."""
@@ -838,6 +917,11 @@ class CameraFeatureFlags(ProtectBaseObject):
     has_vertical_flip: bool | None = None
     # 3.0.22+
     flash_range: Any | None = None
+    # 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
@@ -891,6 +975,15 @@ class CameraAudioSettings(ProtectBaseObject):
     style: list[AudioStyle]
 
 
+@lru_cache
+def _chime_type_from_total_seconds(total_seconds: float) -> ChimeType:
+    if total_seconds == 0.3:
+        return ChimeType.MECHANICAL
+    if total_seconds > 0.3:
+        return ChimeType.DIGITAL
+    return ChimeType.NONE
+
+
 class Camera(ProtectMotionDeviceModel):
     is_deleting: bool
     # Microphone Sensitivity
@@ -899,13 +992,13 @@ class Camera(ProtectMotionDeviceModel):
     is_recording: bool
     is_motion_detected: bool
     is_smart_detected: bool
-    phy_rate: float | None
+    phy_rate: float | None = None
     hdr_mode: bool
     # Recording Quality -> High Frame
     video_mode: VideoMode
     is_probing_for_wifi: bool
     chime_duration: timedelta
-    last_ring: datetime | None
+    last_ring: datetime | None = None
     is_live_heatmap_enabled: bool
     video_reconfiguration_in_progress: bool
     channels: list[CameraChannel]
@@ -921,18 +1014,18 @@ class Camera(ProtectMotionDeviceModel):
     smart_detect_zones: list[SmartMotionZone]
     stats: CameraStats
     feature_flags: CameraFeatureFlags
-    lcd_message: LCDMessage | None
+    lcd_message: LCDMessage | None = None
     lenses: list[CameraLenses]
-    platform: str
+    platform: str | None = None
     has_speaker: bool
     has_wifi: bool
     audio_bitrate: int
     can_manage: bool
     is_managed: bool
-    voltage: float | None
+    voltage: float | None = None
     # requires 1.21+
-    is_poor_network: bool | None
-    is_wireless_uplink_enabled: bool | None
+    is_poor_network: bool | None = None
+    is_wireless_uplink_enabled: bool | None = None
     # requires 2.6.13+
     homekit_settings: CameraHomekitSettings | None = None
     # requires 2.6.17+
@@ -952,7 +1045,12 @@ class Camera(ProtectMotionDeviceModel):
     is_ptz: bool | None = None
     # requires 2.11.13+
     audio_settings: CameraAudioSettings | None = None
-
+    # requires 5.0.33+
+    is_third_party_camera: bool | None = None
+    # requires 5.1.78+
+    is_paired_with_ai_port: bool | None = None
+    # requires 5.2.39+
+    is_adopted_by_access_app: bool | None = None
     # TODO: used for adopting
     # apMac read only
     # apRssi read only
@@ -968,6 +1066,10 @@ class Camera(ProtectMotionDeviceModel):
 
     # not directly from UniFi
     last_ring_event_id: str | None = None
+    last_nfc_card_scanned_event_id: str | None = None
+    last_nfc_card_scanned: datetime | None = None
+    last_fingerprint_identified_event_id: str | None = None
+    last_fingerprint_identified: datetime | None = None
     last_smart_detect: datetime | None = None
     last_smart_audio_detect: datetime | None = None
     last_smart_detect_event_id: str | None = None
@@ -977,7 +1079,6 @@ class Camera(ProtectMotionDeviceModel):
     last_smart_detect_event_ids: dict[SmartDetectObjectType, str] = {}
     last_smart_audio_detect_event_ids: dict[SmartDetectAudioType, str] = {}
     talkback_stream: TalkbackStream | None = None
-    _last_ring_timeout: datetime | None = PrivateAttr(None)
 
     @classmethod
     @cache
@@ -989,6 +1090,10 @@ class Camera(ProtectMotionDeviceModel):
     def _get_excluded_changed_fields(cls) -> set[str]:
         return super()._get_excluded_changed_fields() | {
             "last_ring_event_id",
+            "last_nfc_card_scanned",
+            "last_nfc_card_scanned_event_id",
+            "last_fingerprint_identified",
+            "last_fingerprint_identified_event_id",
             "last_smart_detect",
             "last_smart_audio_detect",
             "last_smart_detect_event_id",
@@ -1026,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 {}
@@ -1054,21 +1166,25 @@ class Camera(ProtectMotionDeviceModel):
                 ]
 
         data = super().unifi_dict(data=data, exclude=exclude)
-        for key in (
-            "lastRingEventId",
-            "lastSmartDetect",
-            "lastSmartAudioDetect",
-            "lastSmartDetectEventId",
-            "lastSmartAudioDetectEventId",
-            "lastSmartDetects",
-            "lastSmartAudioDetects",
-            "lastSmartDetectEventIds",
-            "lastSmartAudioDetectEventIds",
-            "talkbackStream",
-        ):
-            if key in data:
-                del data[key]
-
+        pop_dict_tuple(
+            data,
+            (
+                "lastFingerprintIdentified",
+                "lastFingerprintIdentifiedEventId",
+                "lastNfcCardScanned",
+                "lastNfcCardScannedEventId",
+                "lastRingEventId",
+                "lastSmartDetect",
+                "lastSmartAudioDetect",
+                "lastSmartDetectEventId",
+                "lastSmartAudioDetectEventId",
+                "lastSmartDetects",
+                "lastSmartAudioDetects",
+                "lastSmartDetectEventIds",
+                "lastSmartAudioDetectEventIds",
+                "talkbackStream",
+            ),
+        )
         if "lcdMessage" in data and data["lcdMessage"] is None:
             data["lcdMessage"] = {}
 
@@ -1084,7 +1200,7 @@ class Camera(ProtectMotionDeviceModel):
                 updated["lcd_message"] = {"reset_at": utc_now() - timedelta(seconds=10)}
             # otherwise, pass full LCD message to prevent issues
             elif self.lcd_message is not None:
-                updated["lcd_message"] = self.lcd_message.dict()
+                updated["lcd_message"] = self.lcd_message.model_dump()
 
             # if reset_at is not passed in, it will default to reset in 1 minute
             if lcd_message is not None and "reset_at" not in lcd_message:
@@ -1096,12 +1212,14 @@ class Camera(ProtectMotionDeviceModel):
         return updated
 
     def update_from_dict(self, data: dict[str, Any]) -> Camera:
-        # a message in the past is actually a singal to wipe the message
-        reset_at = data.get("lcd_message", {}).get("reset_at")
-        if reset_at is not None:
-            reset_at = from_js_time(reset_at)
-            if utc_now() > reset_at:
-                data["lcd_message"] = None
+        # 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 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)
 
@@ -1118,6 +1236,23 @@ class Camera(ProtectMotionDeviceModel):
             return None
         return self._api.bootstrap.events.get(last_smart_detect_event_id)
 
+    @property
+    def last_nfc_card_scanned_event(self) -> Event | None:
+        if (
+            last_nfc_card_scanned_event_id := self.last_nfc_card_scanned_event_id
+        ) is None:
+            return None
+        return self._api.bootstrap.events.get(last_nfc_card_scanned_event_id)
+
+    @property
+    def last_fingerprint_identified_event(self) -> Event | None:
+        if (
+            last_fingerprint_identified_event_id
+            := self.last_fingerprint_identified_event_id
+        ) is None:
+            return None
+        return self._api.bootstrap.events.get(last_fingerprint_identified_event_id)
+
     @property
     def hdr_mode_display(self) -> Literal["auto", "off", "always"]:
         """Get HDR mode similar to how Protect interface works."""
@@ -1140,11 +1275,9 @@ class Camera(ProtectMotionDeviceModel):
         smart_type: SmartDetectObjectType,
     ) -> Event | None:
         """Get the last smart detect event for given type."""
-        event_id = self.last_smart_detect_event_ids.get(smart_type)
-        if event_id is None:
-            return None
-
-        return self._api.bootstrap.events.get(event_id)
+        if event_id := self.last_smart_detect_event_ids.get(smart_type):
+            return self._api.bootstrap.events.get(event_id)
+        return None
 
     @property
     def last_smart_audio_detect_event(self) -> Event | None:
@@ -1228,19 +1361,20 @@ class Camera(ProtectMotionDeviceModel):
         """Get active smart detection types."""
         if self.use_global:
             return set(self.smart_detect_settings.object_types).intersection(
-                self.feature_flags.smart_detect_types,
+                self.feature_flags.smart_detect_types
             )
         return set(self.smart_detect_settings.object_types)
 
     @property
     def active_audio_detect_types(self) -> set[SmartDetectAudioType]:
         """Get active audio detection types."""
+        if not (enabled_audio_types := self.smart_detect_settings.audio_types):
+            return set()
         if self.use_global:
-            return set(self.smart_detect_settings.audio_types or []).intersection(
-                self.feature_flags.smart_detect_audio_types or [],
-            )
-
-        return set(self.smart_detect_settings.audio_types or [])
+            if not (feature_audio_types := self.feature_flags.smart_detect_audio_types):
+                return set()
+            return set(feature_audio_types).intersection(enabled_audio_types)
+        return set(enabled_audio_types)
 
     @property
     def is_motion_detection_on(self) -> bool:
@@ -1382,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
 
@@ -1846,18 +2014,14 @@ class Camera(ProtectMotionDeviceModel):
     # endregion
 
     @property
-    def is_ringing(self) -> bool:
-        if self._last_ring_timeout is None:
-            return False
-        return utc_now() < self._last_ring_timeout
+    def chime_type(self) -> ChimeType:
+        return _chime_type_from_total_seconds(
+            timedelta_total_seconds(self.chime_duration)
+        )
 
     @property
-    def chime_type(self) -> ChimeType:
-        if self.chime_duration.total_seconds() == 0.3:
-            return ChimeType.MECHANICAL
-        if self.chime_duration.total_seconds() > 0.3:
-            return ChimeType.DIGITAL
-        return ChimeType.NONE
+    def chime_duration_seconds(self) -> float:
+        return timedelta_total_seconds(self.chime_duration)
 
     @property
     def is_digital_chime(self) -> bool:
@@ -1935,10 +2099,6 @@ class Camera(ProtectMotionDeviceModel):
 
         return False
 
-    def set_ring_timeout(self) -> None:
-        self._last_ring_timeout = utc_now() + EVENT_PING_INTERVAL
-        self._event_callback_ping()
-
     def get_privacy_zone(self) -> tuple[int | None, CameraZone | None]:
         for index, zone in enumerate(self.privacy_zones):
             if zone.name == PRIVACY_ZONE_NAME:
@@ -1971,13 +2131,19 @@ class Camera(ProtectMotionDeviceModel):
 
         Datetime of screenshot is approximate. It may be +/- a few seconds.
         """
-        if not self._api.bootstrap.auth_user.can(
-            ModelType.CAMERA,
-            PermissionNode.READ_MEDIA,
-            self,
-        ):
+        # Use READ_LIVE if dt is None, otherwise READ_MEDIA
+        auth_user = self._api.bootstrap.auth_user
+        if dt is None:
+            if not (
+                auth_user.can(ModelType.CAMERA, PermissionNode.READ_LIVE, self)
+                or auth_user.can(ModelType.CAMERA, PermissionNode.READ_MEDIA, self)
+            ):
+                raise NotAuthorized(
+                    f"Do not have permission to read live or media for camera: {self.id}"
+                )
+        elif not auth_user.can(ModelType.CAMERA, PermissionNode.READ_MEDIA, self):
             raise NotAuthorized(
-                f"Do not have permission to read media for camera: {self.id}",
+                f"Do not have permission to read media for camera: {self.id}"
             )
 
         if height is None and width is None and self.high_camera_channel is not None:
@@ -1985,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,
@@ -1999,13 +2202,19 @@ class Camera(ProtectMotionDeviceModel):
         if not self.feature_flags.has_package_camera:
             raise BadRequest("Device does not have package camera")
 
-        if not self._api.bootstrap.auth_user.can(
-            ModelType.CAMERA,
-            PermissionNode.READ_MEDIA,
-            self,
-        ):
+        auth_user = self._api.bootstrap.auth_user
+        # Use READ_LIVE if dt is None, otherwise READ_MEDIA
+        if dt is None:
+            if not (
+                auth_user.can(ModelType.CAMERA, PermissionNode.READ_LIVE, self)
+                or auth_user.can(ModelType.CAMERA, PermissionNode.READ_MEDIA, self)
+            ):
+                raise NotAuthorized(
+                    f"Do not have permission to read live or media for camera: {self.id}"
+                )
+        elif not auth_user.can(ModelType.CAMERA, PermissionNode.READ_MEDIA, self):
             raise NotAuthorized(
-                f"Do not have permission to read media for camera: {self.id}",
+                f"Do not have permission to read media for camera: {self.id}"
             )
 
         if height is None and width is None and self.package_camera_channel is not None:
@@ -2111,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)
 
@@ -2201,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")
 
@@ -2210,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))
@@ -2716,8 +2947,8 @@ class SensorThresholdSettings(SensorSettingsBase):
     margin: float  # read only
     # "safe" thresholds for alerting
     # anything below/above will trigger alert
-    low_threshold: float | None
-    high_threshold: float | None
+    low_threshold: float | None = None
+    high_threshold: float | None = None
 
 
 class SensorSensitivitySettings(SensorSettingsBase):
@@ -2725,12 +2956,12 @@ class SensorSensitivitySettings(SensorSettingsBase):
 
 
 class SensorBatteryStatus(ProtectBaseObject):
-    percentage: PercentInt | None
+    percentage: PercentInt | None = None
     is_low: bool
 
 
 class SensorStat(ProtectBaseObject):
-    value: float | None
+    value: float | None = None
     status: SensorStatusType
 
 
@@ -2742,20 +2973,20 @@ class SensorStats(ProtectBaseObject):
 
 class Sensor(ProtectAdoptableDeviceModel):
     alarm_settings: SensorSettingsBase
-    alarm_triggered_at: datetime | None
+    alarm_triggered_at: datetime | None = None
     battery_status: SensorBatteryStatus
-    camera_id: str | None
+    camera_id: str | None = None
     humidity_settings: SensorThresholdSettings
     is_motion_detected: bool
     is_opened: bool
-    leak_detected_at: datetime | None
-    led_settings: SensorSettingsBase
+    leak_detected_at: datetime | None = None
+    led_settings: LEDSettings
     light_settings: SensorThresholdSettings
-    motion_detected_at: datetime | None
+    motion_detected_at: datetime | None = None
     motion_settings: SensorSensitivitySettings
-    open_status_changed_at: datetime | None
+    open_status_changed_at: datetime | None = None
     stats: SensorStats
-    tampering_detected_at: datetime | None
+    tampering_detected_at: datetime | None = None
     temperature_settings: SensorThresholdSettings
     mount_type: MountType
 
@@ -2794,15 +3025,16 @@ class Sensor(ProtectAdoptableDeviceModel):
         exclude: set[str] | None = None,
     ) -> dict[str, Any]:
         data = super().unifi_dict(data=data, exclude=exclude)
-        for key in (
-            "lastMotionEventId",
-            "lastContactEventId",
-            "lastValueEventId",
-            "lastAlarmEventId",
-            "extremeValueDetectedAt",
-        ):
-            if key in data:
-                del data[key]
+        pop_dict_tuple(
+            data,
+            (
+                "lastMotionEventId",
+                "lastContactEventId",
+                "lastValueEventId",
+                "lastAlarmEventId",
+                "extremeValueDetectedAt",
+            ),
+        )
         return data
 
     @property
@@ -3048,13 +3280,13 @@ class Sensor(ProtectAdoptableDeviceModel):
 
 
 class Doorlock(ProtectAdoptableDeviceModel):
-    credentials: str | None
+    credentials: str | None = None
     lock_status: LockStatusType
     enable_homekit: bool
     auto_close_time: timedelta
     led_settings: SensorSettingsBase
     battery_status: SensorBatteryStatus
-    camera_id: str | None
+    camera_id: str | None = None
     has_homekit: bool
     private_token: str
 
@@ -3191,7 +3423,7 @@ class ChimeTrack(ProtectBaseObject):
 class Chime(ProtectAdoptableDeviceModel):
     volume: PercentInt
     is_probing_for_wifi: bool
-    last_ring: datetime | None
+    last_ring: datetime | None = None
     is_wireless_uplink_enabled: bool
     camera_ids: list[str]
     # requires 2.6.17+
@@ -3326,3 +3558,16 @@ class Chime(ProtectAdoptableDeviceModel):
                 raise BadRequest("Camera %s is not paired with chime", camera.id)
 
         await self.queue_update(callback)
+
+
+class AiPort(Camera):
+    paired_cameras: list[str]
+
+
+class Ringtone(ProtectBaseObject):
+    id: str
+    name: str
+    size: int
+    is_default: bool
+    nvr_mac: str
+    model_key: str