Per Camera Snooze

blinkpy/api.py

@@ -568,14 +568,14 @@ async def request_get_config(blink, network, camera_id, product_type="owl"):
     :param blink: Blink instance.
     :param network: Sync module network id.
     :param camera_id: ID of camera
-    :param product_type: Camera product type "owl" or "catalina"
+    :param product_type: Camera product type "owl", "catalina", or "sedona"
     """
     if product_type == "owl":
         url = (
             f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}"
             f"/networks/{network}/owls/{camera_id}/config"
         )
-    elif product_type == "catalina":
+    elif product_type in ["catalina", "sedona"]:
         url = f"{blink.urls.base_url}/network/{network}/camera/{camera_id}/config"
     else:
         _LOGGER.info(
@@ -596,15 +596,15 @@ async def request_update_config(
     :param blink: Blink instance.
     :param network: Sync module network id.
     :param camera_id: ID of camera
-    :param product_type: Camera product type "owl" or "catalina"
+    :param product_type: Camera product type "owl", "catalina", or "sedona"
     :param data: string w/JSON dict of parameters/values to update
     """
     if product_type == "owl":
         url = (
             f"{blink.urls.base_url}/api/v1/accounts/"
             f"{blink.account_id}/networks/{network}/owls/{camera_id}/config"
         )
-    elif product_type == "catalina":
+    elif product_type in ["catalina", "sedona"]:
         url = f"{blink.urls.base_url}/network/{network}/camera/{camera_id}/update"
     else:
         _LOGGER.info(
@@ -1063,3 +1063,41 @@ async def oauth_refresh_token(auth, refresh_token, hardware_id):
 
     _LOGGER.error("OAuth token refresh failed with status %s", response.status)
     return None
+
+
+async def request_camera_snooze(
+    blink, network, camera_id, product_type="owl", data=None
+):
+    """
+    Update camera snooze configuration.
+
+    :param blink: Blink instance.
+    :param network: Sync module network id.
+    :param camera_id: ID of camera
+    :param product_type: Camera product type "owl", "catalina",
+        "doorbell", "hawk", "lotus", or "sedona"
+    :param data: string w/JSON dict of parameters/values to update
+    """
+    product_lookup = {
+        "catalina": "cameras",
+        "sedona": "cameras",
+        "owl": "owls",
+        "hawk": "owls",
+        "doorbell": "doorbells",
+        "lotus": "doorbells",
+    }
+
+    if product_type not in product_lookup:
+        _LOGGER.info(
+            "Camera %s with product type %s snooze update not implemented.",
+            camera_id,
+            product_type,
+        )
+        return None
+
+    url_root = (
+        f"{blink.urls.base_url}/api/v1/accounts/{blink.account_id}"
+        f"/networks/{network}"
+    )
+    url = f"{url_root}/{product_lookup[product_type]}/{camera_id}/snooze"
+    return await http_post(blink, url, json=True, data=data)

blinkpy/camera.py

@@ -177,6 +177,61 @@ async def async_set_night_vision(self, value):
             return await res.json()
         return None
 
+    @property
+    async def snoozed(self):
+        """Return snooze status as boolean."""
+        response_data = None
+        try:
+            if self.product_type in ["catalina", "sedona"]:
+                res = await api.request_get_config(
+                    self.sync.blink,
+                    self.network_id,
+                    self.camera_id,
+                    product_type=self.product_type,
+                )
+                response_data = res
+                snooze_value = res["camera"][0].get("snooze_till")
+                return bool(snooze_value)
+            else:
+                response_data = self.sync.blink.homescreen
+                if self.product_type in ["doorbell", "lotus"]:
+                    collection_key = "doorbells"
+                else:
+                    collection_key = "owls"
+                for device in self.sync.blink.homescreen.get(collection_key, []):
+                    if str(device.get("id")) == str(self.camera_id):
+                        snooze_value = device.get("snooze")
+                        return bool(snooze_value)
+                return False
+        except TypeError:
+            return False
+        except (IndexError, KeyError, ValueError) as e:
+            _LOGGER.warning(
+                "Exception %s: Encountered a likely malformed response "
+                "from the snooze API endpoint. Response: %s",
+                e,
+                response_data,
+            )
+            return False
+
+    async def async_snooze(self, snooze_time=3600):
+        """
+        Set camera snooze status.
+
+        :param snooze_time: Time in seconds to snooze camera. Default is 3600 (1 hour).
+        """
+        data = dumps({"snooze_time": snooze_time})
+        res = await api.request_camera_snooze(
+            self.sync.blink,
+            self.network_id,
+            self.camera_id,
+            product_type=self.product_type,
+            data=data,
+        )
+        if res and self.product_type not in ["catalina", "sedona"]:
+            await self.sync.blink.get_homescreen()
+        return res
+
     @property
     def floodlight_enabled(self):
         """Return last-known floodlight state if tracked, else None."""

tests/test_api.py

@@ -189,6 +189,46 @@ async def test_request_update_config(self, mock_resp):
             )
         )
 
+    async def test_request_camera_snooze(self, mock_resp):
+        """Test camera snooze request."""
+        mock_resp.return_value = {"message": "Camera snoozed"}
+        # Test catalina camera
+        response = await api.request_camera_snooze(
+            self.blink, "network", "camera_id", "catalina", '{"snooze_time": 300}'
+        )
+        self.assertEqual(response, {"message": "Camera snoozed"})
+        # Test sedona camera
+        response = await api.request_camera_snooze(
+            self.blink, "network", "camera_id", "sedona", '{"snooze_time": 300}'
+        )
+        self.assertEqual(response, {"message": "Camera snoozed"})
+        # Test owl camera
+        response = await api.request_camera_snooze(
+            self.blink, "network", "camera_id", "owl", '{"snooze_time": 300}'
+        )
+        self.assertEqual(response, {"message": "Camera snoozed"})
+        # Test hawk camera
+        response = await api.request_camera_snooze(
+            self.blink, "network", "camera_id", "hawk", '{"snooze_time": 300}'
+        )
+        self.assertEqual(response, {"message": "Camera snoozed"})
+        # Test doorbell camera
+        response = await api.request_camera_snooze(
+            self.blink, "network", "camera_id", "doorbell", '{"snooze_time": 300}'
+        )
+        self.assertEqual(response, {"message": "Camera snoozed"})
+        # Test lotus camera
+        response = await api.request_camera_snooze(
+            self.blink, "network", "camera_id", "lotus", '{"snooze_time": 300}'
+        )
+        self.assertEqual(response, {"message": "Camera snoozed"})
+        # Test unsupported camera type
+        self.assertIsNone(
+            await api.request_camera_snooze(
+                self.blink, "network", "camera_id", "unsupported_type"
+            )
+        )
+
     async def test_wait_for_command(self, mock_resp):
         """Test Motion detect enable."""
         mock_resp.side_effect = (COMMAND_NOT_COMPLETE, COMMAND_COMPLETE)