hass-core/homeassistant/actors.py

"""
homeassistant.actors
~~~~~~~~~~~~~~~~~~~~

This module provides actors that will react to events happening within homeassistant.

"""

import os
import logging
from datetime import datetime, timedelta
import re

import dateutil.parser
from phue import Bridge
import requests

from . import track_state_change
from .util import sanitize_filename
from .observers import (STATE_CATEGORY_SUN, SUN_STATE_BELOW_HORIZON, SUN_STATE_ABOVE_HORIZON,
                        STATE_CATEGORY_ALL_DEVICES, DEVICE_STATE_HOME, DEVICE_STATE_NOT_HOME,
                        STATE_CATEGORY_NEXT_SUN_SETTING, track_time_change)

LIGHT_TRANSITION_TIME = timedelta(minutes=15)

HUE_MAX_TRANSITION_TIME = 9000

EVENT_DOWNLOAD_FILE = "download_file"

EVENT_TURN_LIGHT_ON = "turn_light_on"
EVENT_TURN_LIGHT_OFF = "turn_light_off"

def _hue_process_transition_time(transition_seconds):
    """ Transition time is in 1/10th seconds and cannot exceed MAX_TRANSITION_TIME. """
    return min(HUE_MAX_TRANSITION_TIME, transition_seconds * 10)


class LightTrigger(object):
    """ Class to turn on lights based on available devices and state of the sun. """

    def __init__(self, eventbus, statemachine, device_tracker, light_control):
        self.eventbus = eventbus
        self.statemachine = statemachine
        self.light_control = light_control

        self.logger = logging.getLogger(__name__)

        # Track home coming of each seperate device
        for category in device_tracker.device_state_categories():
            track_state_change(eventbus, category, DEVICE_STATE_NOT_HOME, DEVICE_STATE_HOME, self._handle_device_state_change)

        # Track when all devices are gone to shut down lights
        track_state_change(eventbus, STATE_CATEGORY_ALL_DEVICES, DEVICE_STATE_HOME, DEVICE_STATE_NOT_HOME, self._handle_device_state_change)

        # Track every time sun rises so we can schedule a time-based pre-sun set event
        track_state_change(eventbus, STATE_CATEGORY_SUN, SUN_STATE_BELOW_HORIZON, SUN_STATE_ABOVE_HORIZON, self._handle_sun_rising)

        # If the sun is already above horizon schedule the time-based pre-sun set event
        if statemachine.is_state(STATE_CATEGORY_SUN, SUN_STATE_ABOVE_HORIZON):
            self._handle_sun_rising(None, None, None)

        # Listen for light on and light off events
        eventbus.listen(EVENT_TURN_LIGHT_ON, lambda event: self.light_control.turn_light_on(event.data.get("light_id", None),
                                                                                            event.data.get("transition_seconds", None)))

        eventbus.listen(EVENT_TURN_LIGHT_OFF, lambda event: self.light_control.turn_light_off(event.data.get("light_id", None),
                                                                                              event.data.get("transition_seconds", None)))


    def _handle_sun_rising(self, category, old_state, new_state):
        """The moment sun sets we want to have all the lights on.
           We will schedule to have each light start after one another
           and slowly transition in."""

        start_point = self._start_point_turn_light_before_sun_set()

        def turn_on(light_id):
            """ Lambda can keep track of function parameters, not from local parameters
                If we put the lambda directly in the below statement only the last light
                would be turned on.. """
            return lambda now: self._turn_light_on_before_sunset(light_id)

        for index, light_id in enumerate(self.light_control.light_ids):
            track_time_change(self.eventbus, turn_on(light_id),
                              point_in_time=start_point + index * LIGHT_TRANSITION_TIME)


    def _turn_light_on_before_sunset(self, light_id=None):
        """ Helper function to turn on lights slowly if there are devices home and the light is not on yet. """
        if self.statemachine.is_state(STATE_CATEGORY_ALL_DEVICES, DEVICE_STATE_HOME) and not self.light_control.is_light_on(light_id):
            self.light_control.turn_light_on(light_id, LIGHT_TRANSITION_TIME.seconds)


    def _handle_device_state_change(self, category, old_state, new_state):
        """ Function to handle tracked device state changes. """
        lights_are_on = self.light_control.is_light_on()

        light_needed = not lights_are_on and self.statemachine.is_state(STATE_CATEGORY_SUN, SUN_STATE_BELOW_HORIZON)

        # Specific device came home ?
        if category != STATE_CATEGORY_ALL_DEVICES and new_state.state == DEVICE_STATE_HOME:
            # These variables are needed for the elif check
            now = datetime.now()
            start_point = self._start_point_turn_light_before_sun_set()

            # Do we need lights?
            if light_needed:
                self.logger.info("Home coming event for {}. Turning lights on".format(category))
                self.light_control.turn_light_on()

            # Are we in the time span were we would turn on the lights if someone would be home?
            # Check this by seeing if current time is later then the start point
            elif now > start_point and now < self._next_sun_setting():

                # If this is the case check for every light if it would be on
                # if someone was home when the fading in started and turn it on
                for index, light_id in enumerate(self.light_control.light_ids):

                    if now > start_point + index * LIGHT_TRANSITION_TIME:
                        self.light_control.turn_light_on(light_id)

                    else:
                        # If this one was not the case then the following IFs are not True
                        # as their points are even further in time, break
                        break


        # Did all devices leave the house?
        elif category == STATE_CATEGORY_ALL_DEVICES and new_state.state == DEVICE_STATE_NOT_HOME and lights_are_on:
            self.logger.info("Everyone has left but lights are on. Turning lights off")
            self.light_control.turn_light_off()

    def _next_sun_setting(self):
        """ Returns the datetime object representing the next sun setting. """
        return dateutil.parser.parse(self.statemachine.get_state(STATE_CATEGORY_NEXT_SUN_SETTING).state)

    def _start_point_turn_light_before_sun_set(self):
        """ Helper method to calculate the point in time we have to start fading in lights
            so that all the lights are on the moment the sun sets. """
        return self._next_sun_setting() - LIGHT_TRANSITION_TIME * len(self.light_control.light_ids)


class HueLightControl(object):
    """ Class to interface with the Hue light system. """

    def __init__(self, host=None):
        self.bridge = Bridge(host)
        self.lights = self.bridge.get_light_objects()
        self.light_ids = [light.light_id for light in self.lights]


    def is_light_on(self, light_id=None):
        """ Returns if specified or all light are on. """
        if light_id is None:
            return sum([1 for light in self.lights if light.on]) > 0

        else:
            return self.bridge.get_light(light_id, 'on')


    def turn_light_on(self, light_id=None, transition_seconds=None):
        """ Turn the specified or all lights on. """
        if light_id is None:
            light_id = self.light_ids

        command = {'on': True, 'xy': [0.5119, 0.4147], 'bri':164}

        if transition_seconds is not None:
            command['transitiontime'] = _hue_process_transition_time(transition_seconds)

        self.bridge.set_light(light_id, command)


    def turn_light_off(self, light_id=None, transition_seconds=None):
        """ Turn the specified or all lights off. """
        if light_id is None:
            light_id = self.light_ids

        command = {'on': False}

        if transition_seconds is not None:
            command['transitiontime'] = _hue_process_transition_time(transition_seconds)

        self.bridge.set_light(light_id, command)


def setup_file_downloader(eventbus, download_path):
    """ Listens for download events to download files. """

    logger = logging.getLogger(__name__)

    if not os.path.isdir(download_path):
        logger.error("Download path {} does not exist. File Downloader not active.".format(download_path))
        return

    def download_file(event):
        """ Downloads file specified in the url. """
        try:
            req = requests.get(event.data['url'], stream=True)
            if req.status_code == 200:
                filename = None

                if 'content-disposition' in req.headers:
                    match = re.findall(r"filename=(\S+)", req.headers['content-disposition'])

                    if len(match) > 0:
                        filename = match[0].strip("'\" ")

                if not filename:
                    filename = os.path.basename(event.data['url']).strip()

                if not filename:
                    filename = "ha_download"

                # Remove stuff to ruin paths
                filename = sanitize_filename(filename)

                path, ext = os.path.splitext(os.path.join(download_path, filename))

                # If file exist append a number. We test filename, filename_2, filename_3 etc..
                tries = 0
                while True:
                    tries += 1

                    final_path = path + ("" if tries == 1 else "_{}".format(tries)) + ext

                    if not os.path.isfile(final_path):
                        break

                logger.info("FileDownloader:{} -> {}".format(event.data['url'], final_path))

                with open(final_path, 'wb') as fil:
                    for chunk in req.iter_content(1024):
                        fil.write(chunk)

        except requests.exceptions.ConnectionError:
            logger.exception("FileDownloader:ConnectionError occured for {}".format(event.data['url']))


    eventbus.listen(EVENT_DOWNLOAD_FILE, download_file)