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

uiprotect/data/types.py

@@ -1,19 +1,52 @@
 from __future__ import annotations
 
 import enum
-from collections.abc import Callable, Coroutine
-from functools import cache, cached_property
-from typing import Any, Literal, Optional, TypeVar, Union
+import types
+from collections.abc import Callable, Coroutine, Sequence
+from functools import cache, lru_cache
+from typing import Annotated, Any, Literal, TypeVar, Union, get_args, get_origin
 
 from packaging.version import Version as BaseVersion
-from pydantic.v1 import BaseModel, ConstrainedInt
-from pydantic.v1.color import Color as BaseColor
-from pydantic.v1.types import ConstrainedFloat, ConstrainedStr
+from pydantic import BaseModel, Field
+from pydantic.types import StringConstraints
+from pydantic_extra_types.color import Color  # noqa: F401
+
+from .._compat import cached_property
 
 KT = TypeVar("KT")
 VT = TypeVar("VT")
 
 
+@lru_cache(maxsize=512)
+def get_field_type(annotation: type[Any] | None) -> tuple[type | None, Any]:
+    """Extract the origin and type from an annotation."""
+    if annotation is None:
+        raise ValueError("Type annotation cannot be None")
+    origin = get_origin(annotation)
+    args: Sequence[Any]
+    if origin in (list, set):
+        if not (args := get_args(annotation)):
+            raise ValueError(f"Unable to determine args of type: {annotation}")
+        return origin, args[0]
+    if origin is dict:
+        if not (args := get_args(annotation)):
+            raise ValueError(f"Unable to determine args of type: {annotation}")
+        return origin, args[1]
+    if origin is Annotated:
+        if not (args := get_args(annotation)):
+            raise ValueError(f"Unable to determine args of type: {annotation}")
+        return None, args[0]
+    if origin is Union or origin is types.UnionType:
+        if not (args := get_args(annotation)):
+            raise ValueError(f"Unable to determine args of type: {annotation}")
+        args = [get_field_type(arg) for arg in args]
+        if len(args) == 2 and type(None) in list(zip(*args, strict=False))[1]:
+            # Strip '| None' type from Union
+            return next(arg for arg in args if arg[1] is not type(None))
+        return None, annotation
+    return origin, annotation
+
+
 DEFAULT = "DEFAULT_VALUE"
 DEFAULT_TYPE = Literal["DEFAULT_VALUE"]
 EventCategories = Literal[
@@ -27,7 +60,7 @@ EventCategories = Literal[
 ]
 
 ProgressCallback = Callable[[int, int, int], Coroutine[Any, Any, None]]
-IteratorCallback = Callable[[int, Optional[bytes]], Coroutine[Any, Any, None]]
+IteratorCallback = Callable[[int, bytes | None], Coroutine[Any, Any, None]]
 
 
 class FixSizeOrderedDict(dict[KT, VT]):
@@ -49,6 +82,11 @@ class ValuesEnumMixin:
     _values: list[str] | None = None
     _values_normalized: dict[str, str] | None = None
 
+    @classmethod
+    @cache
+    def from_string(cls, value: str) -> Any:
+        return cls(value)  # type: ignore[call-arg]
+
     @classmethod
     @cache
     def values(cls) -> list[str]:
@@ -96,8 +134,12 @@ class ModelType(str, UnknownValuesEnumMixin, enum.Enum):
     DOORLOCK = "doorlock"
     SCHEDULE = "schedule"
     CHIME = "chime"
+    AIPORT = "aiport"
     DEVICE_GROUP = "deviceGroup"
     RECORDING_SCHEDULE = "recordingSchedule"
+    ULP_USER = "ulpUser"
+    RINGTONE = "ringtone"
+    KEYRING = "keyring"
     UNKNOWN = "unknown"
 
     bootstrap_model_types: tuple[ModelType, ...]
@@ -111,6 +153,16 @@ class ModelType(str, UnknownValuesEnumMixin, enum.Enum):
         """Return the devices key."""
         return f"{self.value}s"
 
+    @cached_property
+    def name(self) -> str:
+        """Return the name."""
+        return self._name_
+
+    @cached_property
+    def value(self) -> str:
+        """Return the value."""
+        return self._value_
+
     @classmethod
     @cache
     def from_string(cls, value: str) -> ModelType:
@@ -133,6 +185,7 @@ class ModelType(str, UnknownValuesEnumMixin, enum.Enum):
             ModelType.SENSOR,
             ModelType.DOORLOCK,
             ModelType.CHIME,
+            ModelType.AIPORT,
         )
 
     @classmethod
@@ -184,6 +237,8 @@ class EventType(str, ValuesEnumMixin, enum.Enum):
     POOR_CONNECTION = "poorConnection"
     STREAM_RECOVERY = "streamRecovery"
     MOTION = "motion"
+    NFC_CARD_SCANNED = "nfcCardScanned"
+    FINGERPRINT_IDENTIFIED = "fingerprintIdentified"
     RECORDING_DELETED = "recordingDeleted"
     SMART_AUDIO_DETECT = "smartAudioDetect"
     SMART_DETECT = "smartDetectZone"
@@ -257,8 +312,12 @@ class EventType(str, ValuesEnumMixin, enum.Enum):
     def device_events() -> list[str]:
         return [
             EventType.MOTION.value,
+            EventType.NFC_CARD_SCANNED.value,
+            EventType.FINGERPRINT_IDENTIFIED.value,
             EventType.RING.value,
             EventType.SMART_DETECT.value,
+            EventType.SMART_AUDIO_DETECT.value,
+            EventType.SMART_DETECT_LINE.value,
         ]
 
     @staticmethod
@@ -386,6 +445,8 @@ class VideoMode(str, ValuesEnumMixin, enum.Enum):
     HOMEKIT = "homekit"
     SPORT = "sport"
     SLOW_SHUTTER = "slowShutter"
+    LPR_NONE_REFLEX = "lprNoneReflex"
+    LPR_REFLEX = "lprReflex"
     # should only be for unadopted devices
     UNKNOWN = "unknown"
 
@@ -398,6 +459,7 @@ class AudioStyle(str, UnknownValuesEnumMixin, enum.Enum):
 
 @enum.unique
 class RecordingMode(str, ValuesEnumMixin, enum.Enum):
+    ADAPTIVE = "adaptive"
     ALWAYS = "always"
     NEVER = "never"
     SCHEDULE = "schedule"
@@ -475,6 +537,7 @@ class SleepStateType(str, ValuesEnumMixin, enum.Enum):
 class AutoExposureMode(str, ValuesEnumMixin, enum.Enum):
     MANUAL = "manual"
     AUTO = "auto"
+    NONE = "none"
     SHUTTER = "shutter"
     FLICK50 = "flick50"
     FLICK60 = "flick60"
@@ -484,6 +547,7 @@ class AutoExposureMode(str, ValuesEnumMixin, enum.Enum):
 class FocusMode(str, ValuesEnumMixin, enum.Enum):
     MANUAL = "manual"
     AUTO = "auto"
+    NONE = "none"
     ZTRIG = "ztrig"
     TOUCH = "touch"
 
@@ -575,9 +639,20 @@ class PermissionNode(str, UnknownValuesEnumMixin, enum.Enum):
     READ_LIVE = "readlive"
     UNKNOWN = "unknown"
 
+    @cached_property
+    def name(self) -> str:
+        """Return the name."""
+        return self._name_
+
+    @cached_property
+    def value(self) -> str:
+        """Return the value."""
+        return self._value_
+
 
 @enum.unique
 class HDRMode(str, UnknownValuesEnumMixin, enum.Enum):
+    NONE = "none"
     NORMAL = "normal"
     ALWAYS_ON = "superHdr"
 
@@ -591,64 +666,33 @@ class LensType(str, enum.Enum):
     DLSR_17 = "m43"
 
 
-class DoorbellText(ConstrainedStr):
-    max_length = 30
-
-
-class ICRCustomValue(ConstrainedInt):
-    ge = 0
-    le = 10
-
-
-class ICRLuxValue(ConstrainedInt):
-    ge = 1
-    le = 30
-
-
-class LEDLevel(ConstrainedInt):
-    ge = 0
-    le = 6
-
+DoorbellText = Annotated[str, StringConstraints(max_length=30)]
 
-class PercentInt(ConstrainedInt):
-    ge = 0
-    le = 100
+ICRCustomValue = Annotated[int, Field(ge=0, le=11)]
 
+ICRLuxValue = Annotated[int, Field(ge=1, le=30)]
 
-class TwoByteInt(ConstrainedInt):
-    ge = 1
-    le = 255
+LEDLevel = Annotated[int, Field(ge=0, le=6)]
 
+PercentInt = Annotated[int, Field(ge=0, le=101)]
 
-class PercentFloat(ConstrainedFloat):
-    ge = 0
-    le = 100
+TwoByteInt = Annotated[int, Field(ge=1, le=256)]
 
+PercentFloat = Annotated[float, Field(ge=0, le=100)]
 
-class WDRLevel(ConstrainedInt):
-    ge = 0
-    le = 3
+WDRLevel = Annotated[int, Field(ge=0, le=4)]
 
+ICRSensitivity = Annotated[int, Field(ge=0, le=4)]
 
-class ICRSensitivity(ConstrainedInt):
-    ge = 0
-    le = 3
+Percent = Annotated[float, Field(ge=0, le=1)]
 
-
-class Percent(ConstrainedFloat):
-    ge = 0
-    le = 1
-
-
-class RepeatTimes(ConstrainedInt):
-    ge = 1
-    le = 6
+RepeatTimes = Annotated[int, Field(ge=1, le=6)]
 
 
 class PTZPositionDegree(BaseModel):
     pan: float
     tilt: float
-    zoom: int
+    zoom: float
 
 
 class PTZPositionSteps(BaseModel):
@@ -679,15 +723,6 @@ class PTZPreset(BaseModel):
 CoordType = Union[Percent, int, float]
 
 
-# TODO: fix when upgrading to pydantic v2
-class Color(BaseColor):
-    def __eq__(self, o: object) -> bool:
-        if isinstance(o, Color):
-            return self.as_hex() == o.as_hex()
-
-        return super().__eq__(o)
-
-
 class Version(BaseVersion):
     def __str__(self) -> str:
         super_str = super().__str__()

uiprotect/data/user.py

@@ -2,21 +2,28 @@
 
 from __future__ import annotations
 
+import sys
+from abc import abstractmethod
 from datetime import datetime
 from functools import cache
-from typing import Any
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
-from pydantic.v1.fields import PrivateAttr
+from pydantic.fields import PrivateAttr
 
 from .base import ProtectBaseObject, ProtectModel, ProtectModelWithId
 from .types import ModelType, PermissionNode
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 
 class Permission(ProtectBaseObject):
     raw_permission: str
     model: ModelType
     nodes: set[PermissionNode]
-    obj_ids: set[str] | None
+    obj_ids: set[str] | None = None
 
     @classmethod
     def unifi_dict_to_dict(cls, data: dict[str, Any]) -> dict[str, Any]:
@@ -72,8 +79,8 @@ class Group(ProtectModelWithId):
 
 class UserLocation(ProtectModel):
     is_away: bool
-    latitude: float | None
-    longitude: float | None
+    latitude: float | None = None
+    longitude: float | None = None
 
 
 class CloudAccount(ProtectModelWithId):
@@ -82,7 +89,7 @@ class CloudAccount(ProtectModelWithId):
     email: str
     user_id: str
     name: str
-    location: UserLocation | None
+    location: UserLocation | None = None
     profile_img: str | None = None
 
     @classmethod
@@ -116,21 +123,21 @@ class UserFeatureFlags(ProtectBaseObject):
 
 class User(ProtectModelWithId):
     permissions: list[Permission]
-    last_login_ip: str | None
-    last_login_time: datetime | None
+    last_login_ip: str | None = None
+    last_login_time: datetime | None = None
     is_owner: bool
     enable_notifications: bool
     has_accepted_invite: bool
     all_permissions: list[Permission]
     scopes: list[str] | None = None
-    location: UserLocation | None
+    location: UserLocation | None = None
     name: str
     first_name: str
     last_name: str
-    email: str | None
+    email: str | None = None
     local_username: str
     group_ids: list[str]
-    cloud_account: CloudAccount | None
+    cloud_account: CloudAccount | None = None
     feature_flags: UserFeatureFlags
 
     # TODO:
@@ -210,7 +217,7 @@ class User(ProtectModelWithId):
     ) -> bool:
         """Checks if a user can do a specific action"""
         check_self = False
-        if model == self.model and obj is not None and obj.id == self.id:
+        if model is self.model and obj is not None and obj.id == self.id:
             perm_str = f"{model.value}:{node.value}:$"
             check_self = True
         else:
@@ -221,7 +228,7 @@ class User(ProtectModelWithId):
             return self._perm_cache[perm_str]
 
         for perm in self.all_permissions:
-            if model != perm.model or node not in perm.nodes:
+            if model is not perm.model or node not in perm.nodes:
                 continue
             if perm.obj_ids is None:
                 self._perm_cache[perm_str] = True
@@ -234,3 +241,115 @@ class User(ProtectModelWithId):
                 return True
         self._perm_cache[perm_str] = False
         return False
+
+
+T = TypeVar("T", bound="ProtectModelWithId")
+
+
+class UlpUserKeyringBase(Generic[T]):
+    """Base class for collections of ULP users and keyrings."""
+
+    def __init__(self) -> None:
+        self._id_to_item: dict[str, T] = {}
+
+    def __len__(self) -> int:
+        return len(self._id_to_item)
+
+    @classmethod
+    def from_list(cls, items: list[T]) -> Self:
+        instance = cls()
+        for item in items:
+            instance.add(item)
+        return instance
+
+    def add(self, item: T) -> None:
+        """Add an item to the collection."""
+        self._id_to_item[item.id] = item
+
+    def remove(self, item: T) -> None:
+        """Remove an item from the collection."""
+        self._id_to_item.pop(item.id, None)
+
+    def by_id(self, item_id: str) -> T | None:
+        """Retrieve an item by its ID."""
+        return self._id_to_item.get(item_id)
+
+    @abstractmethod
+    def by_ulp_id(self, item_id: str) -> T | None:
+        """Retrieve an item by its ULP ID."""
+
+    def as_list(self) -> list[T]:
+        return list(self._id_to_item.values())
+
+    def __eq__(self, other: Any) -> bool:
+        if TYPE_CHECKING:
+            assert isinstance(other, UlpUserKeyringBase)
+        return self._id_to_item == other._id_to_item
+
+
+class Keyring(ProtectModelWithId):
+    device_type: str
+    device_id: str
+    registry_type: str
+    registry_id: str
+    last_activity: datetime | None = None
+    ulp_user: str
+
+
+class Keyrings(UlpUserKeyringBase[Keyring]):
+    def __init__(self) -> None:
+        super().__init__()
+        self._keyrings_by_registry_id: dict[str, Keyring] = {}
+        self._keyrings_by_ulp_user: dict[str, Keyring] = {}
+
+    def add(self, keyring: Keyring) -> None:
+        super().add(keyring)
+        self._keyrings_by_registry_id[keyring.registry_id] = keyring
+        self._keyrings_by_ulp_user[keyring.ulp_user] = keyring
+
+    def remove(self, keyring: Keyring) -> None:
+        super().remove(keyring)
+        self._keyrings_by_registry_id.pop(keyring.registry_id, None)
+        self._keyrings_by_ulp_user.pop(keyring.ulp_user, None)
+
+    def by_ulp_id(self, ulp_id: str) -> Keyring | None:
+        return self._keyrings_by_ulp_user.get(ulp_id)
+
+    def by_registry_id(self, registry_id: str) -> Keyring | None:
+        return self._keyrings_by_registry_id.get(registry_id)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Keyrings):
+            return NotImplemented
+        return super().__eq__(other)
+
+
+class UlpUser(ProtectModelWithId):
+    ulp_id: str
+    first_name: str
+    last_name: str
+    full_name: str
+    avatar: str
+    status: str
+
+
+class UlpUsers(UlpUserKeyringBase[UlpUser]):
+    def __init__(self) -> None:
+        super().__init__()
+        self._users_by_ulp_id: dict[str, UlpUser] = {}
+
+    def add(self, user: UlpUser) -> None:
+        super().add(user)
+        self._users_by_ulp_id[user.ulp_id] = user
+
+    def remove(self, user: UlpUser) -> None:
+        super().remove(user)
+        self._users_by_ulp_id.pop(user.ulp_id, None)
+
+    def by_ulp_id(self, ulp_id: str) -> UlpUser | None:
+        return self._users_by_ulp_id.get(ulp_id)
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, UlpUsers):
+            return NotImplemented
+        return super().__eq__(other)

uiprotect/data/websocket.py

@@ -7,11 +7,12 @@ import enum
 import struct
 import zlib
 from dataclasses import dataclass
-from functools import cache, cached_property
+from functools import cache
 from typing import TYPE_CHECKING, Any
 
 import orjson
 
+from .._compat import cached_property
 from ..exceptions import WSDecodeError, WSEncodeError
 from .types import ProtectWSPayloadFormat
 

uiprotect/stream.py

@@ -18,6 +18,12 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+CODEC_TO_ENCODER = {
+    "aac": {"encoder": "aac", "format": "adts"},
+    "opus": {"encoder": "libopus", "format": "rtp"},
+    "vorbis": {"encoder": "libvorbis", "format": "ogg"},
+}
+
 
 class FfmpegCommand:
     ffmpeg_path: Path | None
@@ -130,9 +136,10 @@ class TalkbackStream(FfmpegCommand):
         if len(input_args) > 0:
             input_args += " "
 
-        bitrate = camera.talkback_settings.bits_per_sample * 1000
-        # 8000 seems to result in best quality without overloading the camera
-        udp_bitrate = bitrate + 8000
+        codec = camera.talkback_settings.type_fmt.value
+        encoder = CODEC_TO_ENCODER.get(codec)
+        if encoder is None:
+            raise ValueError(f"Unsupported codec: {codec}")
 
         # vn = no video
         # acodec = audio codec to encode output in (aac)
@@ -142,9 +149,9 @@ class TalkbackStream(FfmpegCommand):
         cmd = (
             "-loglevel info -hide_banner "
             f'{input_args}-i "{content_url}" -vn '
-            f"-acodec {camera.talkback_settings.type_fmt.value} -ac {camera.talkback_settings.channels} "
-            f"-ar {camera.talkback_settings.sampling_rate} -b:a {bitrate} -map 0:a "
-            f'-f adts "udp://{camera.host}:{camera.talkback_settings.bind_port}?bitrate={udp_bitrate}"'
+            f"-acodec {encoder['encoder']} -ac {camera.talkback_settings.channels} "
+            f"-ar {camera.talkback_settings.sampling_rate} -b:a {camera.talkback_settings.sampling_rate} -map 0:a "
+            f'-f {encoder["format"]} "udp://{camera.host}:{camera.talkback_settings.bind_port}?bitrate={camera.talkback_settings.sampling_rate}"'
         )
 
         super().__init__(cmd, ffmpeg_path)

uiprotect/test_util/__init__.py

@@ -126,11 +126,12 @@ class SampleDataGenerator:
             "group": len(bootstrap["groups"]),
             "liveview": len(bootstrap["liveviews"]),
             "viewer": len(bootstrap["viewers"]),
-            "light": len(bootstrap["lights"]),
-            "bridge": len(bootstrap["bridges"]),
-            "sensor": len(bootstrap["sensors"]),
-            "doorlock": len(bootstrap["doorlocks"]),
-            "chime": len(bootstrap["chimes"]),
+            "light": len(bootstrap.get("lights", [])),
+            "bridge": len(bootstrap.get("bridges", [])),
+            "sensor": len(bootstrap.get("sensors", [])),
+            "doorlock": len(bootstrap.get("doorlocks", [])),
+            "chime": len(bootstrap.get("chimes", [])),
+            "aiport": len(bootstrap.get("aiports", [])),
         }
 
         self.log("Generating event data...")
@@ -141,6 +142,7 @@ class SampleDataGenerator:
 
         if close_session:
             await self.client.close_session()
+            await self.client.close_public_api_session()
 
         await self.write_json_file("sample_constants", self.constants, anonymize=False)
 
@@ -283,6 +285,7 @@ class SampleDataGenerator:
             self.generate_sensor_data(),
             self.generate_lock_data(),
             self.generate_chime_data(),
+            self.generate_aiport_data(),
             self.generate_bridge_data(),
             self.generate_liveview_data(),
         )
@@ -306,10 +309,18 @@ class SampleDataGenerator:
         await self.write_json_file("sample_camera", deepcopy(obj))
         self.constants["camera_online"] = camera_is_online
 
+        # Check if camera has channels
+        if not obj.get("channels") or len(obj["channels"]) == 0:
+            self.log(
+                "Camera has no channels, skipping snapshot, thumbnail and heatmap generation",
+            )
+            return
+
         if not camera_is_online:
             self.log(
                 "Camera is not online, skipping snapshot, thumbnail and heatmap generation",
             )
+            return
 
         # snapshot
         width = obj["channels"][0]["width"]
@@ -322,6 +333,15 @@ class SampleDataGenerator:
             snapshot = await self.client.get_camera_snapshot(obj["id"], width, height)
             await self.write_image_file(filename, snapshot)
 
+        # public api snapshot
+        pub_filename = "sample_camera_public_api_snapshot"
+        if self.anonymize:
+            self.log(f"Writing {pub_filename}...")
+            placeholder_image(self.output_folder / f"{pub_filename}.png", width, height)
+        else:
+            pub_snapshot = await self.client.get_public_api_camera_snapshot(obj["id"])
+            await self.write_image_file(pub_filename, pub_snapshot)
+
     async def generate_motion_data(
         self,
         motion_event: dict[str, Any] | None,
@@ -359,7 +379,7 @@ class SampleDataGenerator:
         length = int((motion_event["end"] - motion_event["start"]) / 1000)
         if self.anonymize:
             run(
-                split(  # noqa: S603
+                split(
                     BLANK_VIDEO_CMD.format(
                         length=length,
                         filename=self.output_folder / f"{filename}.mp4",
@@ -440,7 +460,12 @@ class SampleDataGenerator:
         await self.write_json_file("sample_sensor", obj)
 
     async def generate_lock_data(self) -> None:
-        objs = await self.client.api_request_list("doorlocks")
+        try:
+            objs = await self.client.api_request_list("doorlocks")
+        except BadRequest:
+            self.log("No doorlock endpoint available. Skipping doorlock endpoints...")
+            return
+
         device_id: str | None = None
         for obj_dict in objs:
             device_id = obj_dict["id"]
@@ -469,6 +494,21 @@ class SampleDataGenerator:
         obj = await self.client.api_request_obj(f"chimes/{device_id}")
         await self.write_json_file("sample_chime", obj)
 
+    async def generate_aiport_data(self) -> None:
+        objs = await self.client.api_request_list("aiports")
+        device_id: str | None = None
+        for obj_dict in objs:
+            device_id = obj_dict["id"]
+            if is_online(obj_dict):
+                break
+
+        if device_id is None:
+            self.log("No aiport found. Skipping aiport endpoints...")
+            return
+
+        obj = await self.client.api_request_obj(f"aiports/{device_id}")
+        await self.write_json_file("sample_aiport", obj)
+
     async def generate_bridge_data(self) -> None:
         objs = await self.client.api_request_list("bridges")
         device_id: str | None = None

uiprotect/test_util/anonymize.py

@@ -3,11 +3,10 @@ from __future__ import annotations
 import secrets
 import string
 import uuid
+import warnings
 from typing import Any
 from urllib.parse import urlparse
 
-import typer
-
 from ..data import ModelType
 
 object_id_mapping: dict[str, str] = {}
@@ -72,7 +71,7 @@ def anonymize_user(user_dict: dict[str, Any]) -> dict[str, Any]:
     return user_dict
 
 
-def anonymize_value(value: Any, name: str | None = None) -> Any:
+def anonymize_value(value: Any, name: str | None = None) -> Any:  # noqa: PLR0912
     if isinstance(value, str):
         if name == "accessKey":
             value = f"{random_number(13)}:{random_hex(24)}:{random_hex(128)}"
@@ -105,13 +104,13 @@ def anonymize_value(value: Any, name: str | None = None) -> Any:
     return value
 
 
-def anonymize_dict(obj: dict[str, Any], name: str | None = None) -> dict[str, Any]:
+def anonymize_dict(obj: dict[str, Any], name: str | None = None) -> dict[str, Any]:  # noqa: PLR0912
     obj_type = None
     if "modelKey" in obj:
         if obj["modelKey"] in [m.value for m in ModelType]:
             obj_type = ModelType(obj["modelKey"])
         else:
-            typer.secho(f"Unknown modelKey: {obj['modelKey']}", fg="yellow")
+            warnings.warn(f"Unknown modelKey: {obj['modelKey']}", stacklevel=2)
 
     if obj_type == ModelType.USER:
         return anonymize_user(obj)