hackerhouse/.venv/Lib/site-packages/blinkpy/sync_module.py

"""Defines a sync module for Blink."""

import logging
import string
import datetime
import traceback
import asyncio
import aiofiles
from sortedcontainers import SortedSet
from requests.structures import CaseInsensitiveDict
from blinkpy import api
from blinkpy.camera import BlinkCamera, BlinkCameraMini, BlinkDoorbell
from blinkpy.helpers.util import (
    time_to_seconds,
    backoff_seconds,
    to_alphanumeric,
    json_dumps,
)
from blinkpy.helpers.constants import ONLINE

_LOGGER = logging.getLogger(__name__)


class BlinkSyncModule:
    """Class to initialize sync module."""

    def __init__(self, blink, network_name, network_id, camera_list):
        """
        Initialize Blink sync module.

        :param blink: Blink class instantiation
        """
        self.blink = blink
        self.network_id = network_id
        self.region_id = blink.auth.region_id
        self.name = network_name
        self.serial = None
        self._version = None
        self.status = "offline"
        self.sync_id = None
        self.host = None
        self.summary = None
        self.network_info = None
        self.events = []
        self.cameras = CaseInsensitiveDict({})
        self.motion_interval = blink.motion_interval
        self.motion = {}
        # A dictionary where keys are the camera names, and
        # values are lists of recent clips.
        self.last_records = {}
        self.camera_list = camera_list
        self.available = False
        # type_key_map is only for the mini's and the doorbells.
        # Outdoor cameras have their own URL API which must be queried.
        self.type_key_map = {
            "mini": "owls",
            "doorbell": "doorbells",
        }
        self._names_table = {}
        self._local_storage = {
            "enabled": False,
            "compatible": False,
            "status": False,
            "last_manifest_id": None,
            "manifest": SortedSet(),
            "manifest_stale": True,
            "last_manifest_read": datetime.datetime(1970, 1, 1, 0, 0, 0).isoformat(),
        }

    @property
    def attributes(self):
        """Return sync attributes."""
        attr = {
            "name": self.name,
            "id": self.sync_id,
            "network_id": self.network_id,
            "serial": self.serial,
            "version": self._version,
            "status": self.status,
            "region_id": self.region_id,
            "local_storage": self.local_storage,
        }
        return attr

    @property
    def urls(self):
        """Return device urls."""
        return self.blink.urls

    @property
    def online(self):
        """Return boolean system online status."""
        try:
            return ONLINE[self.status]
        except KeyError:
            _LOGGER.error("Unknown sync module status %s", self.status)
            self.available = False
            return False

    @property
    def version(self):
        """Return the Syncmodule Firmware version."""
        return self._version

    @property
    def arm(self):
        """Return status of sync module: armed/disarmed."""
        try:
            return self.network_info["network"]["armed"]
        except (KeyError, TypeError):
            self.available = False
            return None

    @property
    def local_storage(self):
        """Indicate if local storage is activated or not (True/False)."""
        return self._local_storage["status"]

    @property
    def local_storage_manifest_ready(self):
        """Indicate if the manifest is up-to-date."""
        return not self._local_storage["manifest_stale"]

    async def async_arm(self, value):
        """Arm or disarm camera."""
        if value:
            return await api.request_system_arm(self.blink, self.network_id)
        return await api.request_system_disarm(self.blink, self.network_id)

    async def start(self):
        """Initialize the system."""
        _LOGGER.debug("Initializing the sync module")
        response = await self.sync_initialize()
        if not response:
            return False

        try:
            self.sync_id = self.summary["id"]
            self.serial = self.summary["serial"]
            self.status = self.summary["status"]
        except KeyError:
            _LOGGER.error("Could not extract some sync module info: %s", response)

        is_ok = await self.get_network_info()

        if not is_ok or not await self.update_cameras():
            self.available = False
            return False
        self.available = True
        return True

    async def sync_initialize(self):
        """Initialize a sync module."""
        # Doesn't include local store info for some reason.
        response = await api.request_syncmodule(self.blink, self.network_id)
        try:
            self.summary = response["syncmodule"]
            self.network_id = self.summary["network_id"]
            await self._init_local_storage(self.summary["id"])
        except (TypeError, KeyError):
            _LOGGER.error(
                "Could not retrieve sync module information with response: %s", response
            )
            return False
        self._version = self.summary.get("fw_version")
        return response

    async def _init_local_storage(self, sync_id):
        """Initialize local storage from homescreen dictionary."""
        home_screen = self.blink.homescreen
        sync_module = None
        try:
            sync_modules = home_screen["sync_modules"]
            for mod in sync_modules:
                if mod["id"] == sync_id:
                    self._local_storage["enabled"] = mod["local_storage_enabled"]
                    self._local_storage["compatible"] = mod["local_storage_compatible"]
                    self._local_storage["status"] = (
                        mod["local_storage_status"] == "active"
                    )
                    self._local_storage["last_manifest_read"] = (
                        datetime.datetime.utcnow() - datetime.timedelta(seconds=10)
                    ).isoformat()
                    sync_module = mod
        except (TypeError, KeyError):
            _LOGGER.error(
                "Could not retrieve sync module information from home screen: %s",
                home_screen,
            )
            return False
        return sync_module

    async def update_cameras(self, camera_type=BlinkCamera):
        """Update cameras from server."""
        type_map = {
            "mini": BlinkCameraMini,
            "doorbell": BlinkDoorbell,
            "default": BlinkCamera,
        }
        try:
            _LOGGER.debug("Updating cameras")
            for camera_config in self.camera_list:
                _LOGGER.debug("Updating camera_config %s", json_dumps(camera_config))
                if "name" not in camera_config:
                    break
                blink_camera_type = camera_config.get("type", "")
                name = camera_config["name"]
                self.motion[name] = False
                unique_info = self.get_unique_info(name)
                if blink_camera_type in type_map:
                    camera_type = type_map[blink_camera_type]
                self.cameras[name] = camera_type(self)
                camera_info = await self.get_camera_info(
                    camera_config["id"], unique_info=unique_info
                )
                self._names_table[to_alphanumeric(name)] = name
                await self.cameras[name].update(
                    camera_info, force_cache=True, force=True
                )
        except KeyError:
            _LOGGER.error("Could not create camera instances for %s", self.name)
            return False
        return True

    def get_unique_info(self, name):
        """Extract unique information for Minis and Doorbells."""
        try:
            for type_key in self.type_key_map.values():
                for device in self.blink.homescreen[type_key]:
                    _LOGGER.debug("checking device %s", device)
                    if device["name"] == name:
                        _LOGGER.debug("Found unique_info %s", device)
                        return device
        except (TypeError, KeyError):
            pass
        return None

    async def get_events(self, **kwargs):
        """Retrieve events from server."""
        force = kwargs.pop("force", False)
        response = await api.request_sync_events(
            self.blink, self.network_id, force=force
        )
        try:
            return response["event"]
        except (TypeError, KeyError):
            _LOGGER.error("Could not extract events: %s", response)
            return False

    async def get_camera_info(self, camera_id, **kwargs):
        """Retrieve camera information."""
        unique = kwargs.get("unique_info", None)
        if unique is not None:
            return unique
        response = await api.request_camera_info(self.blink, self.network_id, camera_id)
        try:
            return response["camera"][0]
        except (TypeError, KeyError):
            _LOGGER.error(
                "Could not extract camera info for %s: %s", camera_id, response
            )
            return {}

    async def get_network_info(self):
        """Retrieve network status."""
        self.network_info = await api.request_network_update(
            self.blink, self.network_id
        )
        try:
            if self.network_info["network"]["sync_module_error"]:
                raise KeyError
        except (TypeError, KeyError):
            self.available = False
            return False
        return True

    async def refresh(self, force_cache=False):
        """Get all blink cameras and pulls their most recent status."""
        if not await self.get_network_info():
            return
        await self.update_local_storage_manifest()
        await self.check_new_videos()
        for camera_name in self.cameras:
            camera_id = self.cameras[camera_name].camera_id
            camera_info = await self.get_camera_info(
                camera_id,
                unique_info=self.get_unique_info(camera_name),
            )
            await self.cameras[camera_name].update(camera_info, force_cache=force_cache)
        self.available = True

    async def check_new_videos(self):
        """Check if new videos since last refresh."""
        _LOGGER.debug("Checking for new videos")
        try:
            interval = self.blink.last_refresh - self.motion_interval * 60
            last_refresh = datetime.datetime.fromtimestamp(self.blink.last_refresh)
            _LOGGER.debug("last_refresh = %s", last_refresh)
            _LOGGER.debug("interval = %s", interval)
        except TypeError:
            # This is the first start, so refresh hasn't happened yet.
            # No need to check for motion.
            ex = traceback.format_exc()
            _LOGGER.error(
                "Error calculating interval (last_refresh = %s): %s",
                self.blink.last_refresh,
                ex,
            )
            trace = "".join(traceback.format_stack())
            _LOGGER.debug("\n%s", trace)
            _LOGGER.info("No new videos since last refresh.")
            return False

        resp = await api.request_videos(self.blink, time=interval, page=1)

        last_record = {}
        for camera in self.cameras:
            # Initialize the list if doesn't exist yet.
            if camera not in self.last_records:
                self.last_records[camera] = []
            # Hang on to the last record if there is one.
            if len(self.last_records[camera]) > 0:
                last_record[camera] = self.last_records[camera][-1]
            # Reset in preparation for processing new entries.
            self.last_records[camera] = []
            self.motion[camera] = False

        try:
            info = resp["media"]
        except (KeyError, TypeError):
            _LOGGER.warning("Could not check for motion. Response: %s", resp)
            return False

        for entry in info:
            try:
                name = entry["device_name"]
                clip_url = entry["media"]
                timestamp = entry["created_at"]
                if self.check_new_video_time(timestamp):
                    self.motion[name] = True and self.arm
                    record = {"clip": clip_url, "time": timestamp}
                    self.last_records[name].append(record)
            except KeyError:
                last_refresh = datetime.datetime.fromtimestamp(self.blink.last_refresh)
                _LOGGER.debug(
                    "No new videos for %s since last refresh at %s.",
                    entry,
                    last_refresh,
                )

        # Process local storage if active and if the manifest is ready.
        last_manifest_read = datetime.datetime.fromisoformat(
            self._local_storage["last_manifest_read"]
        )
        _LOGGER.debug("last_manifest_read = %s", last_manifest_read)
        _LOGGER.debug("Manifest ready? %s", self.local_storage_manifest_ready)
        if self.local_storage and self.local_storage_manifest_ready:
            _LOGGER.debug("Processing updated manifest")
            manifest = self._local_storage["manifest"]
            last_manifest_id = self._local_storage["last_manifest_id"]
            last_manifest_read = self._local_storage["last_manifest_read"]
            last_read_local = (
                datetime.datetime.fromisoformat(last_manifest_read)
                .replace(tzinfo=datetime.timezone.utc)
                .astimezone(tz=None)
            )
            last_clip_time = None
            num_new = 0
            for item in reversed(manifest):
                iso_timestamp = item.created_at.isoformat()

                _LOGGER.debug(
                    "Checking '%s': clip_time = %s, manifest_read = %s",
                    item.name,
                    iso_timestamp,
                    last_manifest_read,
                )
                # Exit the loop once there are no new videos in the list.
                if not self.check_new_video_time(iso_timestamp, last_manifest_read):
                    _LOGGER.info(
                        "No new local storage videos since last manifest "
                        "read at %s.",
                        last_read_local,
                    )
                    break
                _LOGGER.debug("Found new item in local storage manifest: %s", item)
                name = item.name
                clip_url = item.url(last_manifest_id)
                await item.prepare_download(self.blink)
                self.motion[name] = True
                record = {"clip": clip_url, "time": iso_timestamp}
                self.last_records[name].append(record)
                last_clip_time = item.created_at
                num_new += 1

            # The manifest became ready, and we read recent clips from it.
            if num_new > 0:
                last_manifest_read = (
                    datetime.datetime.utcnow() - datetime.timedelta(seconds=10)
                ).isoformat()
                self._local_storage["last_manifest_read"] = last_manifest_read
                _LOGGER.debug("Updated last_manifest_read to %s", last_manifest_read)
                _LOGGER.debug("Last clip time was %s", last_clip_time)
        # We want to keep the last record when no new motion was detected.
        for camera in self.cameras:
            # Check if there are no new records, indicating motion.
            if len(self.last_records[camera]) == 0:
                # If no new records, check if we had a previous last record.
                if camera in last_record:
                    # Put the last record back into the empty list.
                    self.last_records[camera].append(last_record[camera])

        return True

    def check_new_video_time(self, timestamp, reference=None):
        """Check if video has timestamp since last refresh.

        :param timestamp ISO-formatted timestamp string
        :param reference ISO-formatted reference timestamp string
        """
        if not reference:
            return time_to_seconds(timestamp) > self.blink.last_refresh
        return time_to_seconds(timestamp) > time_to_seconds(reference)

    async def update_local_storage_manifest(self):
        """Update local storage manifest, which lists all stored clips."""
        if not self.local_storage:
            self._local_storage["manifest_stale"] = True
            return None
        _LOGGER.debug("Updating local storage manifest")

        response = await self.poll_local_storage_manifest()
        try:
            manifest_request_id = response["id"]
        except (TypeError, KeyError):
            _LOGGER.error(
                "Could not extract manifest request ID from response: %s", response
            )
            self._local_storage["manifest_stale"] = True
            return None

        response = await self.poll_local_storage_manifest(manifest_request_id)
        try:
            manifest_id = response["manifest_id"]
        except (TypeError, KeyError):
            _LOGGER.error("Could not extract manifest ID from response: %s", response)
            self._local_storage["manifest_stale"] = True
            return None

        self._local_storage["last_manifest_id"] = manifest_id
        template = string.Template(api.local_storage_clip_url_template()).substitute(
            account_id=self.blink.account_id,
            network_id=self.network_id,
            sync_id=self.sync_id,
            manifest_id="$manifest_id",
            clip_id="$clip_id",
        )
        num_stored = len(self._local_storage["manifest"])
        try:
            for item in response["clips"]:
                alphanumeric_name = item["camera_name"]
                if alphanumeric_name in self._names_table:
                    camera_name = self._names_table[alphanumeric_name]
                    self._local_storage["manifest"].add(
                        LocalStorageMediaItem(
                            item["id"],
                            camera_name,
                            item["created_at"],
                            item["size"],
                            manifest_id,
                            template,
                        )
                    )
            num_added = len(self._local_storage["manifest"]) - num_stored
            if num_added > 0:
                _LOGGER.info(
                    "Found %s new clip(s) in local storage manifest id = %s",
                    num_added,
                    manifest_id,
                )
        except (TypeError, KeyError):
            ex = traceback.format_exc()
            _LOGGER.error("Could not extract clips list from response: %s", ex)
            trace = "".join(traceback.format_stack())
            _LOGGER.debug("\n%s", trace)
            self._local_storage["manifest_stale"] = True
            return None

        self._local_storage["manifest_stale"] = False
        return True

    async def poll_local_storage_manifest(
        self, manifest_request_id=None, max_retries=4
    ):
        """Poll for local storage manifest."""
        # The sync module may be busy processing another request
        # (like saving a new clip).
        # Poll the endpoint until it is ready, backing off each retry.
        response = None
        for retry in range(max_retries):
            # Request building the manifest.
            if not manifest_request_id:
                response = await api.request_local_storage_manifest(
                    self.blink, self.network_id, self.sync_id
                )
                if response and "id" in response:
                    break
            # Get the manifest.
            else:
                response = await api.get_local_storage_manifest(
                    self.blink, self.network_id, self.sync_id, manifest_request_id
                )
                if response and "clips" in response:
                    break
            seconds = backoff_seconds(retry=retry, default_time=3)
            _LOGGER.debug("[retry=%d] Retrying in %d seconds", retry + 1, seconds)
            await asyncio.sleep(seconds)
        return response


class BlinkOwl(BlinkSyncModule):
    """Representation of a sync-less device."""

    def __init__(self, blink, name, network_id, response):
        """Initialize a sync-less object."""
        cameras = [{"name": name, "id": response["id"]}]
        super().__init__(blink, name, network_id, cameras)
        self.sync_id = response["id"]
        self.serial = response["serial"]
        self.status = response["enabled"]
        if not self.serial:
            self.serial = f"{network_id}-{self.sync_id}"

    async def sync_initialize(self):
        """Initialize a sync-less module."""
        self.summary = {
            "id": self.sync_id,
            "name": self.name,
            "serial": self.serial,
            "status": self.status,
            "onboarded": True,
            "account_id": self.blink.account_id,
            "network_id": self.network_id,
        }
        return self.summary

    async def update_cameras(self, camera_type=BlinkCameraMini):
        """Update sync-less cameras."""
        return await super().update_cameras(camera_type=BlinkCameraMini)

    async def get_camera_info(self, camera_id, **kwargs):
        """Retrieve camera information."""
        try:
            for owl in self.blink.homescreen["owls"]:
                if owl["name"] == self.name:
                    self.status = owl["enabled"]
                    return owl
        except (TypeError, KeyError):
            pass
        return None

    async def get_network_info(self):
        """Get network info for sync-less module."""
        return True

    @property
    def network_info(self):
        """Format owl response to resemble sync module."""
        return {
            "network": {
                "id": self.network_id,
                "name": self.name,
                "armed": self.status,
                "sync_module_error": False,
                "account_id": self.blink.account_id,
            }
        }

    @network_info.setter
    def network_info(self, value):
        """Set network_info property."""


class BlinkLotus(BlinkSyncModule):
    """Representation of a sync-less device."""

    def __init__(self, blink, name, network_id, response):
        """Initialize a sync-less object."""
        cameras = [{"name": name, "id": response["id"]}]
        super().__init__(blink, name, network_id, cameras)
        self.sync_id = response["id"]
        self.serial = response["serial"]
        self.status = response["enabled"]
        if not self.serial:
            self.serial = f"{network_id}-{self.sync_id}"

    async def sync_initialize(self):
        """Initialize a sync-less module."""
        self.summary = {
            "id": self.sync_id,
            "name": self.name,
            "serial": self.serial,
            "status": self.status,
            "onboarded": True,
            "account_id": self.blink.account_id,
            "network_id": self.network_id,
        }
        return self.summary

    async def update_cameras(self, camera_type=BlinkDoorbell):
        """Update sync-less cameras."""
        return await super().update_cameras(camera_type=BlinkDoorbell)

    async def get_camera_info(self, camera_id, **kwargs):
        """Retrieve camera information."""
        try:
            for doorbell in self.blink.homescreen["doorbells"]:
                if doorbell["name"] == self.name:
                    self.status = doorbell["enabled"]
                    return doorbell
        except (TypeError, KeyError):
            pass
        return None

    async def get_network_info(self):
        """Get network info for sync-less module."""
        return True

    @property
    def network_info(self):
        """Format lotus response to resemble sync module."""
        return {
            "network": {
                "id": self.network_id,
                "name": self.name,
                "armed": self.status,
                "sync_module_error": False,
                "account_id": self.blink.account_id,
            }
        }

    @network_info.setter
    def network_info(self, value):
        """Set network_info property."""


class LocalStorageMediaItem:
    """Metadata of media item in the local storage manifest."""

    def __init__(
        self, item_id, camera_name, created_at, size, manifest_id, url_template
    ):
        """Initialize media item.

        :param item_id: ID of the manifest item.
        :param camera_name: Name of camera that took the video.
        :param created_at: ISO-formatted time stamp for creation time.
        :param size: Size of the video file.
        """
        self._id = int(item_id)
        self._camera_name = camera_name
        self._created_at = datetime.datetime.fromisoformat(created_at)
        self._size = size
        self._url_template = url_template
        self._manifest_id = manifest_id

    def _build_url(self, manifest_id, clip_id):
        return string.Template(self._url_template).substitute(
            manifest_id=manifest_id, clip_id=clip_id
        )

    @property
    def id(self):
        """Return media item ID."""
        return self._id

    @property
    def name(self):
        """Return name of camera that captured this media item."""
        return self._camera_name

    @property
    def created_at(self):
        """Return the ISO-formatted creation time stamp of this media item."""
        return self._created_at

    @property
    def size(self):
        """Return the reported size of this media item."""
        return self._size

    def url(self, manifest_id=None):
        """Build the URL.

        Builds the url new each time since the media item is cached,
        and the manifest is possibly rebuilt each refresh.

        :param manifest_id: ID of new manifest (if it changed)
        :return: URL for clip retrieval
        """
        if manifest_id:
            self._manifest_id = manifest_id
        return self._build_url(self._manifest_id, self._id)

    async def prepare_download(self, blink, max_retries=4):
        """Initiate upload of media item from the sync module to Blink cloud servers."""
        if max_retries == 0:
            return None
        url = blink.urls.base_url + self.url()
        response = await api.http_post(blink, url)
        await api.wait_for_command(blink, response)
        return response

    async def delete_video(self, blink, max_retries=4) -> bool:
        """Delete video from sync module."""
        delete_url = blink.urls.base_url + self.url()
        delete_url = delete_url.replace("request", "delete")

        for retry in range(max_retries):
            delete = await api.http_post(
                blink, delete_url, json=False
            )  # Delete the video
            if delete.status == 200:
                return True
            seconds = backoff_seconds(retry=retry, default_time=3)
            _LOGGER.debug("[retry=%d] Retrying in %d seconds", retry + 1, seconds)
            await asyncio.sleep(seconds)
        return False

    async def download_video(self, blink, file_name, max_retries=4) -> bool:
        """Download a previously prepared video from sync module."""
        for retry in range(max_retries):
            url = blink.urls.base_url + self.url()
            video = await api.http_get(blink, url, json=False)
            if video.status == 200:
                async with aiofiles.open(file_name, "wb") as vidfile:
                    await vidfile.write(await video.read())  # download the video
                    return True
            seconds = backoff_seconds(retry=retry, default_time=3)
            _LOGGER.debug(
                "[retry=%d] Retrying in %d seconds: %s", retry + 1, seconds, url
            )
            await asyncio.sleep(seconds)
        return False

    async def download_video_delete(self, blink, file_name, max_retries=4) -> bool:
        """Delete local videos.

        Initiate upload of media item from the sync module to
        Blink cloud servers then download to local filesystem and delete from sync.
        """
        if await self.prepare_download(blink):
            if await self.download_video(blink, file_name):
                if await self.delete_video(blink):
                    return True
        return False

    def __repr__(self):
        """Create string representation."""
        return (
            f"LocalStorageMediaItem(id={self._id}, camera_name={self._camera_name}, "
            f"created_at={self._created_at}"
            + f", size={self._size}, manifest_id={self._manifest_id}, "
            f"url_template={self._url_template})"
        )

    def __str__(self):
        """Create string representation."""
        return self.__repr__()

    def cmp_key(self):
        """Return key to use for comparison."""
        return self._created_at

    def __eq__(self, other):
        """Check equality."""
        return self.cmp_key() == other.cmp_key()

    def __lt__(self, other):
        """Check less than."""
        return self.cmp_key() < other.cmp_key()

    def __hash__(self):
        """Return unique hash value."""
        return self._id