def compare_devices(data):
obj = create_from_unifi_dict(deepcopy(data))
obj_dict = obj.unifi_dict()
compare_objs(obj.model.value, data, obj_dict)
set_no_debug()
obj_construct = create_from_unifi_dict(deepcopy(data))
assert obj == obj_construct
set_debug()
async def test_get_device_not_adopted_enabled(protect_client: ProtectApiClient, camera):
camera["isAdopted"] = False
protect_client.ignore_unadopted = False
protect_client.api_request_obj = AsyncMock(return_value=camera) # type: ignore
obj = create_from_unifi_dict(camera)
assert obj == await protect_client.get_camera("test_id")
async def get_events(
self,
start: Optional[datetime] = None,
end: Optional[datetime] = None,
limit: Optional[int] = None,
types: Optional[List[EventType]] = None,
) -> List[Event]:
"""
Same as `get_events_raw`, except
* returns actual `Event` objects instead of raw Python dictionaries
* filers out non-device events
* filters out events with too low of a score
Args:
* `start`: start time for events
* `end`: end time for events
* `limit`: max number of events to return
* `types`: list of EventTypes to get events for
If `limit`, `start` and `end` are not provided, it will default to all events in the last 24 hours.
If `start` is provided, then `end` or `limit` must be provided. If `end` is provided, then `start` or
`limit` must be provided. Otherwise, you will get a 400 error from Unifi Protect
"""
response = await self.get_events_raw(start=start,
end=end,
limit=limit,
types=types)
events = []
for event_dict in response:
# ignore unknown events
if "type" not in event_dict or event_dict[
"type"] not in EventType.values():
_LOGGER.debug("Unknown event type: %s", event_dict)
continue
event = create_from_unifi_dict(event_dict, api=self)
# should never happen
if not isinstance(event, Event):
continue
if event.type.value in EventType.device_events(
) and event.score >= self._minimum_score:
events.append(event)
return events
async def get_device(
self,
model_type: ModelType,
device_id: str,
expected_type: Optional[Type[ProtectModel]] = None
) -> ProtectModel:
"""Gets a device give the device model_type and id, converted into Python object"""
obj = create_from_unifi_dict(await self.get_device_raw(
model_type, device_id),
api=self)
if expected_type is not None and not isinstance(obj, expected_type):
raise NvrError(f"Unexpected model returned: {obj.model}")
return obj
async def get_devices(
self,
model_type: ModelType,
expected_type: Optional[Type[ProtectModel]] = None
) -> List[ProtectModel]:
"""Gets a device list given a model_type, converted into Python objects"""
objs: List[ProtectModel] = []
for obj_dict in await self.get_devices_raw(model_type):
obj = create_from_unifi_dict(obj_dict)
if expected_type is not None and not isinstance(
obj, expected_type):
raise NvrError(f"Unexpected model returned: {obj.model}")
objs.append(obj)
return objs
async def get_events(
self,
start: Optional[datetime] = None,
end: Optional[datetime] = None,
limit: Optional[int] = None,
camera_ids: Optional[List[str]] = None,
) -> List[Event]:
"""
Same as `get_events_raw`, except
* returns actual `Event` objects instead of raw Python dictionaries
* filers out non-device events
* filters out events with too low of a score
"""
response = await self.get_events_raw(start=start,
end=end,
limit=limit,
camera_ids=camera_ids)
events = []
for event_dict in response:
# ignore unknown events
if "type" not in event_dict or event_dict[
"type"] not in EventType.values():
_LOGGER.debug("Unknown event type: %s", event_dict)
continue
event = create_from_unifi_dict(event_dict, api=self)
# should never happen
if not isinstance(event, Event):
continue
if event.type.value in EventType.device_events(
) and event.score >= self._minimum_score:
events.append(event)
return events
async def test_get_liveviews(protect_client: ProtectApiClient, liveviews):
objs = [create_from_unifi_dict(d) for d in liveviews]
assert objs == await protect_client.get_liveviews()
async def test_get_bridges(protect_client: ProtectApiClient, bridges):
objs = [create_from_unifi_dict(d) for d in bridges]
assert objs == await protect_client.get_bridges()
async def test_get_viewers(protect_client: ProtectApiClient, viewports):
objs = [create_from_unifi_dict(d) for d in viewports]
assert objs == await protect_client.get_viewers()
async def test_get_sensors(protect_client: ProtectApiClient, sensors):
objs = [create_from_unifi_dict(d) for d in sensors]
assert objs == await protect_client.get_sensors()
async def test_get_cameras(protect_client: ProtectApiClient, cameras):
objs = [create_from_unifi_dict(d) for d in cameras]
assert objs == await protect_client.get_cameras()
async def test_get_liveview(protect_client: ProtectApiClient, liveview):
obj = create_from_unifi_dict(liveview)
assert obj == await protect_client.get_liveview("test_id")
async def test_get_bridge(protect_client: ProtectApiClient, bridge):
obj = create_from_unifi_dict(bridge)
assert obj == await protect_client.get_bridge("test_id")
async def test_get_viewer(protect_client: ProtectApiClient, viewport):
obj = create_from_unifi_dict(viewport)
assert obj == await protect_client.get_viewer("test_id")
async def test_get_sensor(protect_client: ProtectApiClient, sensor):
obj = create_from_unifi_dict(sensor)
assert obj == await protect_client.get_sensor("test_id")
async def test_get_camera(protect_client: ProtectApiClient, camera):
obj = create_from_unifi_dict(camera)
assert obj == await protect_client.get_camera("test_id")
